asn1-ber - npm Package Compare versions
Comparing version 1.1.2 to 1.1.3
@@ -100,4 +100,5 @@ | ||
| if (lenB > 4) | ||
| throw InvalidAsn1Error('encoding too long'); | ||
| // Caused problems for node-net-snmp issue #172 | ||
| // if (lenB > 4) | ||
| // throw InvalidAsn1Error('encoding too long'); | ||
@@ -108,4 +109,6 @@ if (this._size - offset < lenB) | ||
| this._len = 0; | ||
| for (var i = 0; i < lenB; i++) | ||
| this._len = (this._len << 8) + (this._buf[offset++] & 0xff); | ||
| for (var i = 0; i < lenB; i++) { | ||
| this._len *= 256; | ||
| this._len += (this._buf[offset++] & 0xff); | ||
| } | ||
@@ -246,4 +249,6 @@ } else { | ||
| if (this.length > 4) | ||
| throw InvalidAsn1Error('Integer too long: ' + this.length); | ||
| // Is it better to modulo 2**32 a large integer, throw an error, or just return it? | ||
| // Went with the modulo 2**32 | ||
| // if (this.length > 5) | ||
| // throw InvalidAsn1Error('Integer too long: ' + this.length); | ||
@@ -258,10 +263,10 @@ if (this.length > this._size - o) | ||
| for (var i = 0; i < this.length; i++) { | ||
| value <<= 8; | ||
| value |= (this._buf[this._offset++] & 0xff); | ||
| value *= 256; | ||
| value += (this._buf[this._offset++] & 0xff); | ||
| } | ||
| if ((fb & 0x80) == 0x80 && i !== 4) | ||
| value -= (1 << (i * 8)); | ||
| if ((fb & 0x80) == 0x80) | ||
| value -= 2**(i * 8); | ||
| return value >> 0; | ||
| return value % (2**32); | ||
| }; | ||
@@ -268,0 +273,0 @@ |
@@ -71,27 +71,51 @@ | ||
| Writer.prototype.writeInt = function(i, tag) { | ||
| if (typeof(i) !== 'number') | ||
| if (typeof(i) !== 'number') { | ||
| throw new TypeError('argument must be a Number'); | ||
| if (typeof(tag) !== 'number') | ||
| } | ||
| if (typeof(tag) !== 'number') { | ||
| tag = ASN1.Integer; | ||
| } | ||
| var sz = 4; | ||
| while ((((i & 0xff800000) === 0) || ((i & 0xff800000) === 0xff800000 >> 0)) && | ||
| (sz > 1)) { | ||
| sz--; | ||
| i <<= 8; | ||
| let bitString; | ||
| let byteLength; | ||
| if ( i < 0 ) { | ||
| let positiveBitString = Number(-i).toString(2); | ||
| byteLength = Math.trunc((positiveBitString.length - 1) / 8) + 1; | ||
| if (positiveBitString.length % 8 == 0 && positiveBitString.includes('1', 1) ) { | ||
| byteLength++; | ||
| } | ||
| let bitLength = byteLength * 8; | ||
| positiveBitString = positiveBitString.padStart(bitLength, '0'); | ||
| let twosComplement = positiveBitString.split(''); | ||
| for ( let charPos = 0 ; charPos < bitLength ; charPos++ ) { | ||
| twosComplement[charPos] = positiveBitString[charPos] == '0' ? '1' : '0'; | ||
| } | ||
| for ( let charPos = bitLength - 1 ; charPos >= 0 ; charPos-- ) { | ||
| if ( twosComplement[charPos] == '1' ) { | ||
| twosComplement[charPos] = '0'; | ||
| } else { | ||
| twosComplement[charPos] = '1'; | ||
| break; | ||
| } | ||
| } | ||
| bitString = twosComplement.join(''); | ||
| } else { | ||
| bitString = Number(i).toString(2); | ||
| byteLength = Math.trunc(bitString.length / 8) + 1; | ||
| let bitLength = byteLength * 8; | ||
| bitString = bitString.padStart(bitLength, '0'); | ||
| if ( bitString.length % 8 == 0 && bitString[0] == '1' ) { | ||
| byteLength++; | ||
| bitString = '00000000' + bitString; | ||
| } | ||
| } | ||
| const byteArray = bitString.match(/.{1,8}/g).map(binaryByte => parseInt(binaryByte, 2)); | ||
| if (sz > 4) | ||
| throw new InvalidAsn1Error('BER ints cannot be > 0xffffffff'); | ||
| this._ensure(2 + sz); | ||
| this._ensure(2 + byteLength); | ||
| this._buf[this._offset++] = tag; | ||
| this._buf[this._offset++] = sz; | ||
| this._buf[this._offset++] = byteLength; | ||
| while (sz-- > 0) { | ||
| this._buf[this._offset++] = ((i & 0xff000000) >>> 24); | ||
| i <<= 8; | ||
| for ( let bytePos = 0 ; bytePos < byteLength ; bytePos++ ) { | ||
| this._buf[this._offset++] = byteArray[bytePos]; | ||
| } | ||
@@ -101,3 +125,2 @@ | ||
| Writer.prototype.writeNull = function() { | ||
@@ -104,0 +127,0 @@ this.writeByte(ASN1.Null); |
| { | ||
| "name": "asn1-ber", | ||
| "version": "1.1.2", | ||
| "version": "1.1.3", | ||
| "description": "Generate and parse ASN1.BER objects", | ||
| "main": "index.js", | ||
| "scripts": { | ||
| "test": "mocha" | ||
| }, | ||
| "directories": {}, | ||
| "dependencies": {}, | ||
| "devDependencies": { | ||
| "tap": "*" | ||
| "mocha": "^10.0.0" | ||
| }, | ||
| "contributors": [ | ||
| "contributors": [ | ||
| { | ||
@@ -13,0 +16,0 @@ "name": "Stephen Vickers", |
@@ -563,2 +563,6 @@ | ||
| ## Version 1.1.3 - 07/06/2022 | ||
| * Fix 5-byte integer encoding and decoding | ||
| # License | ||
@@ -565,0 +569,0 @@ |
@@ -10,3 +10,3 @@ | ||
| it("can read a value", function() { | ||
| var reader = new BerReader(Buffer.alloc([0xde])) | ||
| var reader = new BerReader(Buffer.from([0xde])) | ||
| assert.equal(reader.readByte(), 0xde) | ||
@@ -17,16 +17,58 @@ }) | ||
| describe("readInt()", function() { | ||
| it("can read a 1 byte integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x01, 0x03])) | ||
| assert.equal(reader.readInt(), 0x03) | ||
| assert.equal(reader.length, 0x01) | ||
| it("can read zero", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x01, 0x00])) | ||
| assert.equal(reader.readInt(), 0) | ||
| assert.equal(reader.length, 1) | ||
| }) | ||
| it("can read a 2 byte integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x02, 0x7e, 0xde])) | ||
| it("can read a 1 byte positive integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x01, 0x01])) | ||
| assert.equal(reader.readInt(), 1) | ||
| assert.equal(reader.length, 1) | ||
| }) | ||
| it("can read a 1 byte positive integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x01, 0x34])) | ||
| assert.equal(reader.readInt(), 52) | ||
| assert.equal(reader.length, 1) | ||
| }) | ||
| it("can read a 1 byte positive integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x01, 0x7f])) | ||
| assert.equal(reader.readInt(), 127) | ||
| assert.equal(reader.length, 1) | ||
| }) | ||
| it("can read a 2 byte positive integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x02, 0x00, 0x80])) | ||
| assert.equal(reader.readInt(), 128) | ||
| assert.equal(reader.length, 2) | ||
| }) | ||
| it("can read a 2 byte positive integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x02, 0x7e, 0xde])) | ||
| assert.equal(reader.readInt(), 0x7ede) | ||
| assert.equal(reader.length, 0x02) | ||
| assert.equal(reader.length, 2) | ||
| }) | ||
| it("can read a 3 byte integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x03, 0x7e, 0xde, 0x03])) | ||
| it("can read a 2 byte positive integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x02, 0x7f, 0xff])) | ||
| assert.equal(reader.readInt(), 32767) | ||
| assert.equal(reader.length, 2) | ||
| }) | ||
| it("can read a 3 byte positive integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x03, 0x00, 0x80, 0x00])) | ||
| assert.equal(reader.readInt(), 32768) | ||
| assert.equal(reader.length, 3) | ||
| }) | ||
| it("can read a 3 byte positive integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x03, 0x7e, 0xde, 0x03])) | ||
| assert.equal(reader.readInt(), 8314371) | ||
| assert.equal(reader.length, 3) | ||
| }) | ||
| it("can read a 3 byte positive integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x03, 0x7e, 0xde, 0x03])) | ||
| assert.equal(reader.readInt(), 0x7ede03) | ||
@@ -36,33 +78,109 @@ assert.equal(reader.length, 0x03) | ||
| it("can read a 4 byte integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x04, 0x7e, 0xde, 0x03, 0x01])) | ||
| assert.equal(reader.readInt(), 0x7ede0301) | ||
| assert.equal(reader.length, 0x04) | ||
| it("can read a 4 byte positive integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x04, 0x00, 0x80, 0x00, 0x00])) | ||
| assert.equal(reader.readInt(), 8388608) | ||
| assert.equal(reader.length, 4) | ||
| }) | ||
| it("can read a 1 byte unsigned integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x01, 0xdc])) | ||
| it("can read a 4 byte positive integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x04, 0x7e, 0xde, 0x03, 0x01])) | ||
| assert.equal(reader.readInt(), 2128478977) | ||
| assert.equal(reader.length, 4) | ||
| }) | ||
| it("can read a 4 byte positive integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x04, 0x7f, 0xff, 0xff, 0xff])) | ||
| assert.equal(reader.readInt(), 2147483647) | ||
| assert.equal(reader.length, 4) | ||
| }) | ||
| it("can read a 5 byte positive integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x05, 0x00, 0x80, 0x00, 0x00, 0x00])) | ||
| assert.equal(reader.readInt(), 2147483648) | ||
| assert.equal(reader.length, 5) | ||
| }) | ||
| it("can read a 5 byte positive integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x05, 0x00, 0x8b, 0xde, 0x03, 0x01])) | ||
| assert.equal(reader.readInt(), 2346582785) | ||
| assert.equal(reader.length, 5) | ||
| }) | ||
| it("can read a 5 byte positive integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x05, 0x00, 0xff, 0xff, 0xff, 0xff])) | ||
| assert.equal(reader.readInt(), 4294967295) | ||
| assert.equal(reader.length, 5) | ||
| }) | ||
| it("can read a 1 byte negative integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x01, 0x80])) | ||
| assert.equal(reader.readInt(), -128) | ||
| assert.equal(reader.length, 1) | ||
| }) | ||
| it("can read a 1 byte negative integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x01, 0xdc])) | ||
| assert.equal(reader.readInt(), -36) | ||
| assert.equal(reader.length, 0x01) | ||
| assert.equal(reader.length, 1) | ||
| }) | ||
| it("can read a 2 byte unsigned integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x02, 0xc0, 0x4e])) | ||
| it("can read a 1 byte negative integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x01, 0xff])) | ||
| assert.equal(reader.readInt(), -1) | ||
| assert.equal(reader.length, 1) | ||
| }) | ||
| it("can read a 2 byte negative integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x02, 0x80, 0x00])) | ||
| assert.equal(reader.readInt(), -32768) | ||
| assert.equal(reader.length, 2) | ||
| }) | ||
| it("can read a 2 byte negative integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x02, 0xc0, 0x4e])) | ||
| assert.equal(reader.readInt(), -16306) | ||
| assert.equal(reader.length, 0x02) | ||
| assert.equal(reader.length, 2) | ||
| }) | ||
| it("can read a 2 byte negative integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x02, 0xff, 0x7f])) | ||
| assert.equal(reader.readInt(), -129) | ||
| assert.equal(reader.length, 2) | ||
| }) | ||
| it("can read a 3 byte unsigned integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x03, 0xff, 0x00, 0x19])) | ||
| it("can read a 3 byte negative integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x03, 0x80, 0x00, 0x00])) | ||
| assert.equal(reader.readInt(), -8388608) | ||
| assert.equal(reader.length, 3) | ||
| }) | ||
| it("can read a 3 byte negative integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x03, 0xff, 0x00, 0x19])) | ||
| assert.equal(reader.readInt(), -65511) | ||
| assert.equal(reader.length, 0x03) | ||
| assert.equal(reader.length, 3) | ||
| }) | ||
| it("can read a 3 byte negative integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x03, 0xff, 0x7f, 0xff])) | ||
| assert.equal(reader.readInt(), -32769) | ||
| assert.equal(reader.length, 3) | ||
| }) | ||
| it("can read a 4 byte unsigned integer", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x02, 0x04, 0x91, 0x7c, 0x22, 0x1f])) | ||
| it("can read a 4 byte negative integer - lowest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x04, 0x80, 0x00, 0x00, 0x00])) | ||
| assert.equal(reader.readInt(), -2147483648) | ||
| assert.equal(reader.length, 4) | ||
| }) | ||
| it("can read a 4 byte negative integer - middle", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x04, 0x91, 0x7c, 0x22, 0x1f])) | ||
| assert.equal(reader.readInt(), -1854135777) | ||
| assert.equal(reader.length, 0x04) | ||
| assert.equal(reader.length, 4) | ||
| }) | ||
| it("can read a 4 byte negative integer - highest", function() { | ||
| var reader = new BerReader(Buffer.from([0x02, 0x04, 0xff, 0x7f, 0xff, 0xff])) | ||
| assert.equal(reader.readInt(), -8388609) | ||
| assert.equal(reader.length, 4) | ||
| }) | ||
| }) | ||
@@ -72,3 +190,3 @@ | ||
| it("can read a true value", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x01, 0x01, 0xff])) | ||
| var reader = new BerReader(Buffer.from([0x01, 0x01, 0xff])) | ||
| assert.equal(reader.readBoolean(), true) | ||
@@ -79,3 +197,3 @@ assert.equal(reader.length, 0x01) | ||
| it("can read a false value", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x01, 0x01, 0x00])) | ||
| var reader = new BerReader(Buffer.from([0x01, 0x01, 0x00])) | ||
| assert.equal(reader.readBoolean(), false) | ||
@@ -88,3 +206,3 @@ assert.equal(reader.length, 0x01) | ||
| it("can read a value", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x0a, 0x01, 0x20])) | ||
| var reader = new BerReader(Buffer.from([0x0a, 0x01, 0x20])) | ||
| assert.equal(reader.readEnumeration(), 0x20, 'wrong value') | ||
@@ -98,3 +216,3 @@ assert.equal(reader.length, 0x01, 'wrong length') | ||
| // Make sure 2887117176 is NOT converted to -1407850120 | ||
| var buffer = Buffer.alloc([6, 18, 43, 6, 1, 4, 1, 245, 12, 1, 1, 5, 1, 1, 19, 138, 224, 215, 210, 120]) | ||
| var buffer = Buffer.from([6, 18, 43, 6, 1, 4, 1, 245, 12, 1, 1, 5, 1, 1, 19, 138, 224, 215, 210, 120]) | ||
| var reader = new BerReader(buffer) | ||
@@ -122,3 +240,3 @@ assert.equal(reader.readOID(), "1.3.6.1.4.1.14988.1.1.5.1.1.19.2887117176") | ||
| it("can read a sequence", function() { | ||
| var reader = new BerReader(Buffer.alloc([0x30, 0x03, 0x01, 0x01, 0xff])) | ||
| var reader = new BerReader(Buffer.from([0x30, 0x03, 0x01, 0x01, 0xff])) | ||
| assert.equal(reader.readSequence(), 0x30) | ||
@@ -125,0 +243,0 @@ assert.equal(reader.length, 0x03) |
@@ -16,3 +16,3 @@ | ||
| assert.equal(buffer.length, 1) | ||
| assert.equal(buffer[0], 0xC2) | ||
| assert.equal(buffer[0], 0xc2) | ||
| }) | ||
@@ -22,5 +22,5 @@ }) | ||
| describe("writeInt()", function() { | ||
| it("can write 1 byte integers", function() { | ||
| it("can write zero", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(0x7f) | ||
| writer.writeInt(0) | ||
@@ -32,8 +32,44 @@ var buffer = writer.buffer | ||
| assert.equal(buffer[1], 0x01) | ||
| assert.equal(buffer[2], 0x00) | ||
| }) | ||
| it("can write 1 byte positive integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(1) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 3) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x01) | ||
| assert.equal(buffer[2], 0x01) | ||
| }) | ||
| it("can write 1 byte positive integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(101) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 3) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x01) | ||
| assert.equal(buffer[2], 0x65) | ||
| }) | ||
| it("can write 1 byte positive integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(127) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 3) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x01) | ||
| assert.equal(buffer[2], 0x7f) | ||
| }) | ||
| it("can write 2 byte integers", function() { | ||
| it("can write 2 byte positive integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(0x7ffe) | ||
| writer.writeInt(128) | ||
@@ -45,9 +81,35 @@ var buffer = writer.buffer | ||
| assert.equal(buffer[1], 0x02) | ||
| assert.equal(buffer[2], 0x00) | ||
| assert.equal(buffer[3], 0x80) | ||
| }) | ||
| it("can write 2 byte positive integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(9374) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 4) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x02) | ||
| assert.equal(buffer[2], 0x24) | ||
| assert.equal(buffer[3], 0x9e) | ||
| }) | ||
| it("can write 2 byte positive integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(32767) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 4) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x02) | ||
| assert.equal(buffer[2], 0x7f) | ||
| assert.equal(buffer[3], 0xfe) | ||
| assert.equal(buffer[3], 0xff) | ||
| }) | ||
| it("can write 3 byte integers", function() { | ||
| it("can write 3 byte positive integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(0x7ffffe) | ||
| writer.writeInt(32768) | ||
@@ -59,10 +121,38 @@ var buffer = writer.buffer | ||
| assert.equal(buffer[1], 0x03) | ||
| assert.equal(buffer[2], 0x00) | ||
| assert.equal(buffer[3], 0x80) | ||
| assert.equal(buffer[4], 0x00) | ||
| }) | ||
| it("can write 3 byte positive integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(5938243) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 5) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x03) | ||
| assert.equal(buffer[2], 0x5a) | ||
| assert.equal(buffer[3], 0x9c) | ||
| assert.equal(buffer[4], 0x43) | ||
| }) | ||
| it("can write 3 byte positive integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(8388607) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 5) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x03) | ||
| assert.equal(buffer[2], 0x7f) | ||
| assert.equal(buffer[3], 0xff) | ||
| assert.equal(buffer[4], 0xfe) | ||
| assert.equal(buffer[4], 0xff) | ||
| }) | ||
| it("can write 4 byte integers", function() { | ||
| it("can write 4 byte positive integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(0x7ffffffe) | ||
| writer.writeInt(8388608) | ||
@@ -74,10 +164,88 @@ var buffer = writer.buffer | ||
| assert.equal(buffer[1], 0x04) | ||
| assert.equal(buffer[2], 0x00) | ||
| assert.equal(buffer[3], 0x80) | ||
| assert.equal(buffer[4], 0x00) | ||
| assert.equal(buffer[5], 0x00) | ||
| }) | ||
| it("can write 4 byte positive integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(1483722690) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 6) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x04) | ||
| assert.equal(buffer[2], 0x58) | ||
| assert.equal(buffer[3], 0x6f) | ||
| assert.equal(buffer[4], 0xcf) | ||
| assert.equal(buffer[5], 0xc2) | ||
| }) | ||
| it("can write 4 byte positive integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(2147483647) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 6) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x04) | ||
| assert.equal(buffer[2], 0x7f) | ||
| assert.equal(buffer[3], 0xff) | ||
| assert.equal(buffer[4], 0xff) | ||
| assert.equal(buffer[5], 0xfe) | ||
| assert.equal(buffer[5], 0xff) | ||
| }) | ||
| it("can write 1 byte unsigned integers", function() { | ||
| it("can write 5 byte positive integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(2147483648) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 7) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x05) | ||
| assert.equal(buffer[2], 0x00) | ||
| assert.equal(buffer[3], 0x80) | ||
| assert.equal(buffer[4], 0x00) | ||
| assert.equal(buffer[5], 0x00) | ||
| assert.equal(buffer[6], 0x00) | ||
| }) | ||
| it("can write 5 byte positive integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(3843548325) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 7) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x05) | ||
| assert.equal(buffer[2], 0x00) | ||
| assert.equal(buffer[3], 0xe5) | ||
| assert.equal(buffer[4], 0x17) | ||
| assert.equal(buffer[5], 0xe4) | ||
| assert.equal(buffer[6], 0xa5) | ||
| }) | ||
| it("can write 5 byte positive integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(4294967295) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 7) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x05) | ||
| assert.equal(buffer[2], 0x00) | ||
| assert.equal(buffer[3], 0xff) | ||
| assert.equal(buffer[4], 0xff) | ||
| assert.equal(buffer[5], 0xff) | ||
| assert.equal(buffer[6], 0xff) | ||
| }) | ||
| it("can write 1 byte negative integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-128) | ||
@@ -93,4 +261,41 @@ | ||
| it("can write 2 byte unsigned integers", function() { | ||
| it("can write 1 byte negative integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-73) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 3) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x01) | ||
| assert.equal(buffer[2], 0xb7) | ||
| }) | ||
| it("can write 1 byte negative integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-1) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 3) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x01) | ||
| assert.equal(buffer[2], 0xff) | ||
| }) | ||
| it("can write 2 byte negative integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-32768) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 4) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x02) | ||
| assert.equal(buffer[2], 0x80) | ||
| assert.equal(buffer[3], 0x00) | ||
| }) | ||
| it("can write 2 byte negative integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-22400) | ||
@@ -107,4 +312,31 @@ | ||
| it("can write 3 byte unsigned integers", function() { | ||
| it("can write 2 byte negative integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-129) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 4) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x02) | ||
| assert.equal(buffer[2], 0xff) | ||
| assert.equal(buffer[3], 0x7f) | ||
| }) | ||
| it("can write 3 byte negative integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-8388608) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 5) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x03) | ||
| assert.equal(buffer[2], 0x80) | ||
| assert.equal(buffer[3], 0x00) | ||
| assert.equal(buffer[4], 0x00) | ||
| }) | ||
| it("can write 3 byte negative integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-481653) | ||
@@ -122,4 +354,33 @@ | ||
| it("can write 4 byte unsigned integers", function() { | ||
| it("can write 3 byte negative integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-32769) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 5) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x03) | ||
| assert.equal(buffer[2], 0xff) | ||
| assert.equal(buffer[3], 0x7f) | ||
| assert.equal(buffer[4], 0xff) | ||
| }) | ||
| it("can write 4 byte negative integers - lowest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-2147483648) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 6) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x04) | ||
| assert.equal(buffer[2], 0x80) | ||
| assert.equal(buffer[3], 0x00) | ||
| assert.equal(buffer[4], 0x00) | ||
| assert.equal(buffer[5], 0x00) | ||
| }) | ||
| it("can write 4 byte negative integers - middle", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-1522904131) | ||
@@ -137,2 +398,17 @@ | ||
| }) | ||
| it("can write 4 byte negative integers - highest", function() { | ||
| var writer = new BerWriter() | ||
| writer.writeInt(-8388609) | ||
| var buffer = writer.buffer | ||
| assert.equal(buffer.length, 6) | ||
| assert.equal(buffer[0], 0x02) | ||
| assert.equal(buffer[1], 0x04) | ||
| assert.equal(buffer[2], 0xff) | ||
| assert.equal(buffer[3], 0x7f) | ||
| assert.equal(buffer[4], 0xff) | ||
| assert.equal(buffer[5], 0xff) | ||
| }) | ||
| }) | ||
@@ -177,3 +453,3 @@ | ||
| var expected = Buffer.alloc([ | ||
| var expected = Buffer.from([ | ||
| 0x04, 0x0b, 0x30, 0x09, 0x02, 0x01, 0x0f, 0x01, | ||
@@ -180,0 +456,0 @@ 0x01, 0xff, 0x01, 0x01, 0xff |
No alert changes
Improved metrics
- Total package byte prevSize
62242
29.53%- Number of package files
11
10%- Lines of code
1277
43.32%- Number of lines in readme file
594
0.68%No dependency changes