How to use the coap-packet.parse function in coap-packet

var checkBlock2Option = function(msg, payload_req1, req1_block2_num, payload_len) {
      var res = parse(msg)

      // Have block2 option?
      var block2Buff = getOption(res.options, 'Block2')
      expect(block2Buff instanceof Buffer).to.eql(true)

      var block2 = parseBlock2(block2Buff)
      expect(block2).to.not.eql(null)

      var expectMore = (req1_block2_num + 1) * 16 <= payload_len

      // Have correct num / moreBlock2 fields?
      expect(block2.num).to.eql(req1_block2_num)
      expect(block2.moreBlock2).to.eql(expectMore)
    }

this._sock.on('message', function(msg, rsinfo) {
    var packet
      , message
      , outSocket

    try {
      packet = parse(msg)
    } catch(err) {
      return
    }

    if (packet.code[0] === '0' && packet.code !== '0.00') {
      // ignore this packet since it's not a response.
      return
    }

    outSocket = that._sock.address();
    that._handle(msg, rsinfo, outSocket)
  })

client.on('message', function(msg, rinfo) {
      var result = parse(msg)
      expect(result.code).to.eql('0.00')
      expect(result.reset).to.eql(true)
      expect(result.ack).to.eql(false)
      expect(result.token.length).to.eql(0)
      expect(result.payload.length).to.eql(0)
      done()
    });
    server.on('request', function(req, res) {

client.on('message', function(msg) {
          var res = parse(msg)
          send(generate({
              code: '0.00'
            , messageId: res.messageId
            , ack: true }))
          messages++
        })
      })

client.on('message', function(msg) {
        expect(parse(msg).options[0].value).to.eql(buf1)
        expect(parse(msg).options[1].value).to.eql(buf2)
        done()
      })
    })

server.on('message', function (msg, rsinfo) {
      var packet = parse(msg)
        , toSend = generate({
          messageId: packet.messageId
          , code: '0.00'
          , ack: true
          , payload: 'this payload invalidates empty message'
        })
      expect(packet.code).to.be.eq('0.01');
      messages++
      server.send(toSend, 0, toSend.length, rsinfo.port, rsinfo.address)
    })

server.on('message', function (msg) {
        if (parse(msg).ack)
          done()
      })
    })

Agent.prototype._handle = function handle(msg, rsinfo, outSocket) {
  var packet = parse(msg)
    , buf
    , response
    , that = this
    , req = this._msgIdToReq[packet.messageId]
    , ackSent = function(err) {
        if (err && req)
          req.emit('error', err)

        that._msgInFlight--
        if (that._closing && that._msgInFlight === 0) {
          that._doClose()
        }
      }

  if (!req) {
    if (packet.token.length == 4) {

function parseRequest(request, next) {
  try {
    request.packet = parse(request.raw)
    next(null)
  } catch (err) {
    next(err)
  }
}

CoAPServer.prototype._sendProxied = function(packet, proxyUri, callback) {
  var url = require('url').parse(proxyUri)
    , host = url.hostname
    , port = url.port
    , message = generate(removeProxyOptions(packet))

  this._sock.send(message, 0, message.length, port, host, callback)
}