text: 'use strict';
  /* jshint unused: false */
  
  var should = require('chai').should();
  var expect = require('chai').expect;
  
  var auroracoin = require('../..');
  var errors = auroracoin.errors;
  var BufferUtil = auroracoin.util.buffer;
  
  describe('buffer utils', function() {
  
    describe('equals', function() {
      it('recognizes these two equal buffers', function() {
        var bufferA = new Buffer([1, 2, 3]);
        var bufferB = new Buffer('010203', 'hex');
        BufferUtil.equal(bufferA, bufferB).should.equal(true);
      });
      it('no false positive: returns false with two different buffers', function() {
        var bufferA = new Buffer([1, 2, 3]);
        var bufferB = new Buffer('010204', 'hex');
        BufferUtil.equal(bufferA, bufferB).should.equal(false);
      });
      it('coverage: quickly realizes a difference in size and returns false', function() {
        var bufferA = new Buffer([1, 2, 3]);
        var bufferB = new Buffer([]);
        BufferUtil.equal(bufferA, bufferB).should.equal(false);
      });
      it('"equals" is an an alias for "equal"', function() {
        var bufferA = new Buffer([1, 2, 3]);
        var bufferB = new Buffer([1, 2, 3]);
        BufferUtil.equal(bufferA, bufferB).should.equal(true);
        BufferUtil.equals(bufferA, bufferB).should.equal(true);
      });
    });
  
    describe('fill', function() {
      it('checks arguments', function() {
        expect(function() {
          BufferUtil.fill('something');
        }).to.throw(errors.InvalidArgumentType);
        expect(function() {
          BufferUtil.fill(new Buffer([0, 0, 0]), 'invalid');
        }).to.throw(errors.InvalidArgumentType);
      });
      it('works correctly for a small buffer', function() {
        var buffer = BufferUtil.fill(new Buffer(10), 6);
        for (var i = 0; i < 10; i++) {
          buffer[i].should.equal(6);
        }
      });
    });
  
    describe('isBuffer', function() {
      it('has no false positive', function() {
        expect(BufferUtil.isBuffer(1)).to.equal(false);
      });
      it('has no false negative', function() {
        expect(BufferUtil.isBuffer(new Buffer(0))).to.equal(true);
      });
    });
  
    describe('emptyBuffer', function() {
      it('creates a buffer filled with zeros', function() {
        var buffer = BufferUtil.emptyBuffer(10);
        expect(buffer.length).to.equal(10);
        for (var i = 0; i < 10; i++) {
          expect(buffer[i]).to.equal(0);
        }
      });
      it('checks arguments', function() {
        expect(function() {
          BufferUtil.emptyBuffer('invalid');
        }).to.throw(errors.InvalidArgumentType);
      });
    });
  
    describe('single byte buffer <=> integer', function() {
      it('integerAsSingleByteBuffer should return a buffer of length 1', function() {
        expect(BufferUtil.integerAsSingleByteBuffer(100)[0]).to.equal(100);
      });
      it('should check the type', function() {
        expect(function() {
          BufferUtil.integerAsSingleByteBuffer('invalid');
        }).to.throw(errors.InvalidArgumentType);
        expect(function() {
          BufferUtil.integerFromSingleByteBuffer('invalid');
        }).to.throw(errors.InvalidArgumentType);
      });
      it('works correctly for edge cases', function() {
        expect(BufferUtil.integerAsSingleByteBuffer(255)[0]).to.equal(255);
        expect(BufferUtil.integerAsSingleByteBuffer(-1)[0]).to.equal(255);
      });
      it('does a round trip', function() {
        expect(BufferUtil.integerAsSingleByteBuffer(
          BufferUtil.integerFromSingleByteBuffer(new Buffer([255]))
        )[0]).to.equal(255);
      });
    });
  
    describe('4byte buffer integer <=> integer', function() {
      it('integerAsBuffer should return a buffer of length 4', function() {
        expect(BufferUtil.integerAsBuffer(100).length).to.equal(4);
      });
      it('is little endian', function() {
        expect(BufferUtil.integerAsBuffer(100)[3]).to.equal(100);
      });
      it('should check the type', function() {
        expect(function() {
          BufferUtil.integerAsBuffer('invalid');
        }).to.throw(errors.InvalidArgumentType);
        expect(function() {
          BufferUtil.integerFromBuffer('invalid');
        }).to.throw(errors.InvalidArgumentType);
      });
      it('works correctly for edge cases', function() {
        expect(BufferUtil.integerAsBuffer(4294967295)[0]).to.equal(255);
        expect(BufferUtil.integerAsBuffer(4294967295)[3]).to.equal(255);
        expect(BufferUtil.integerAsBuffer(-1)[0]).to.equal(255);
        expect(BufferUtil.integerAsBuffer(-1)[3]).to.equal(255);
      });
      it('does a round trip', function() {
        expect(BufferUtil.integerFromBuffer(
          BufferUtil.integerAsBuffer(10000)
        )).to.equal(10000);
      });
    });
  
    describe('buffer to hex', function() {
      it('returns an expected value in hexa', function() {
        expect(BufferUtil.bufferToHex(new Buffer([255, 0, 128]))).to.equal('ff0080');
      });
      it('checks the argument type', function() {
        expect(function() {
          BufferUtil.bufferToHex('invalid');
        }).to.throw(errors.InvalidArgumentType);
      });
      it('round trips', function() {
        var original = new Buffer([255, 0, 128]);
        var hexa = BufferUtil.bufferToHex(original);
        var back = BufferUtil.hexToBuffer(hexa);
        expect(BufferUtil.equal(original, back)).to.equal(true);
      });
    });
  
    describe('reverse', function() {
      it('reverses a buffer', function() {
        // http://bit.ly/1J2Ai4x
        var original = new Buffer([255, 0, 128]);
        var reversed = BufferUtil.reverse(original);
        original[0].should.equal(reversed[2]);
        original[1].should.equal(reversed[1]);
        original[2].should.equal(reversed[0]);
      });
    });
  });
  