bufferutils.js

/* global describe, it */

var assert = require('assert')
var bufferutils = require('../src/bufferutils')

var fixtures = require('./fixtures/bufferutils.json')

describe('bufferutils', function () {
  describe('pushDataSize', function () {
    fixtures.valid.forEach(function (f) {
      it('determines the pushDataSize of ' + f.dec + ' correctly', function () {
        if (!f.hexPD) return

        var size = bufferutils.pushDataSize(f.dec)

        assert.strictEqual(size, f.hexPD.length / 2)
      })
    })
  })

  describe('readPushDataInt', function () {
    fixtures.valid.forEach(function (f) {
      if (!f.hexPD) return

      it('decodes ' + f.hexPD + ' correctly', function () {
        var buffer = Buffer.from(f.hexPD, 'hex')
        var d = bufferutils.readPushDataInt(buffer, 0)
        var fopcode = parseInt(f.hexPD.substr(0, 2), 16)

        assert.strictEqual(d.opcode, fopcode)
        assert.strictEqual(d.number, f.dec)
        assert.strictEqual(d.size, buffer.length)
      })
    })

    fixtures.invalid.readPushDataInt.forEach(function (f) {
      if (!f.hexPD) return

      it('decodes ' + f.hexPD + ' as null', function () {
        var buffer = Buffer.from(f.hexPD, 'hex')

        var n = bufferutils.readPushDataInt(buffer, 0)
        assert.strictEqual(n, null)
      })
    })
  })

  describe('readUInt64LE', function () {
    fixtures.valid.forEach(function (f) {
      it('decodes ' + f.hex64 + ' correctly', function () {
        var buffer = Buffer.from(f.hex64, 'hex')
        var number = bufferutils.readUInt64LE(buffer, 0)

        assert.strictEqual(number, f.dec)
      })
    })

    fixtures.invalid.readUInt64LE.forEach(function (f) {
      it('throws on ' + f.description, function () {
        var buffer = Buffer.from(f.hex64, 'hex')

        assert.throws(function () {
          bufferutils.readUInt64LE(buffer, 0)
        }, new RegExp(f.exception))
      })
    })
  })

  describe('readVarInt', function () {
    fixtures.valid.forEach(function (f) {
      it('decodes ' + f.hexVI + ' correctly', function () {
        var buffer = Buffer.from(f.hexVI, 'hex')
        var d = bufferutils.readVarInt(buffer, 0)

        assert.strictEqual(d.number, f.dec)
        assert.strictEqual(d.size, buffer.length)
      })
    })

    fixtures.invalid.readUInt64LE.forEach(function (f) {
      it('throws on ' + f.description, function () {
        var buffer = Buffer.from(f.hexVI, 'hex')

        assert.throws(function () {
          bufferutils.readVarInt(buffer, 0)
        }, new RegExp(f.exception))
      })
    })
  })

  describe('varIntBuffer', function () {
    fixtures.valid.forEach(function (f) {
      it('encodes ' + f.dec + ' correctly', function () {
        var buffer = bufferutils.varIntBuffer(f.dec)

        assert.strictEqual(buffer.toString('hex'), f.hexVI)
      })
    })
  })

  describe('varIntSize', function () {
    fixtures.valid.forEach(function (f) {
      it('determines the varIntSize of ' + f.dec + ' correctly', function () {
        var size = bufferutils.varIntSize(f.dec)

        assert.strictEqual(size, f.hexVI.length / 2)
      })
    })
  })

  describe('writePushDataInt', function () {
    fixtures.valid.forEach(function (f) {
      if (!f.hexPD) return

      it('encodes ' + f.dec + ' correctly', function () {
        var buffer = Buffer.alloc(5, 0)

        var n = bufferutils.writePushDataInt(buffer, f.dec, 0)
        assert.strictEqual(buffer.slice(0, n).toString('hex'), f.hexPD)
      })
    })
  })

  describe('writeUInt64LE', function () {
    fixtures.valid.forEach(function (f) {
      it('encodes ' + f.dec + ' correctly', function () {
        var buffer = Buffer.alloc(8, 0)

        bufferutils.writeUInt64LE(buffer, f.dec, 0)
        assert.strictEqual(buffer.toString('hex'), f.hex64)
      })
    })

    fixtures.invalid.readUInt64LE.forEach(function (f) {
      it('throws on ' + f.description, function () {
        var buffer = Buffer.alloc(8, 0)

        assert.throws(function () {
          bufferutils.writeUInt64LE(buffer, f.dec, 0)
        }, new RegExp(f.exception))
      })
    })
  })

  describe('writeVarInt', function () {
    fixtures.valid.forEach(function (f) {
      it('encodes ' + f.dec + ' correctly', function () {
        var buffer = Buffer.alloc(9, 0)

        var n = bufferutils.writeVarInt(buffer, f.dec, 0)
        assert.strictEqual(buffer.slice(0, n).toString('hex'), f.hexVI)
      })
    })

    fixtures.invalid.readUInt64LE.forEach(function (f) {
      it('throws on ' + f.description, function () {
        var buffer = Buffer.alloc(9, 0)

        assert.throws(function () {
          bufferutils.writeVarInt(buffer, f.dec, 0)
        }, new RegExp(f.exception))
      })
    })
  })
})