lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Incorporate endianness into buffer.read* function names instead of passing in a boolean flag

v0.7.4-release
Brian White 14 years ago
committed by Ben Noordhuis
parent
a002f4f453
commit
b7c23ac3f5
11 changed files with 595 additions and 499 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 256
      doc/api/buffers.markdown
  2. 466
      lib/buffer.js
  3. 14
      lib/buffer_ieee754.js
  4. 61
      test/simple/test-readdouble.js
  5. 37
      test/simple/test-readfloat.js
  6. 68
      test/simple/test-readint.js
  7. 51
      test/simple/test-readuint.js
  8. 21
      test/simple/test-writedouble.js
  9. 21
      test/simple/test-writefloat.js
  10. 44
      test/simple/test-writeint.js
  11. 55
      test/simple/test-writeuint.js

256
doc/api/buffers.markdown
View File

@ -155,8 +155,8 @@ indexes.
**Modifying the new buffer slice will modify memory in the original buffer!** **Modifying the new buffer slice will modify memory in the original buffer!**
Example: build a Buffer with the ASCII alphabet, take a slice, then modify one byte Example: build a Buffer with the ASCII alphabet, take a slice, then modify one
from the original Buffer. byte from the original Buffer.
var buf1 = new Buffer(26); var buf1 = new Buffer(26);
@ -172,11 +172,12 @@ from the original Buffer.
// abc // abc
// !bc // !bc
### buffer.readUInt8(offset, bigEndian) ### buffer.readUInt8(offset, noAssert=false)
Reads an unsigned 8 bit integer from the buffer at the specified offset. If Reads an unsigned 8 bit integer from the buffer at the specified offset.
`bigEndian` is true, reads bytes in a big endian format, otherwise reads them as
little endian. Set `noAssert` to true to skip validation of `offset`. This means that `offset`
may be beyond the end of the buffer.
Example: Example:
@ -188,24 +189,22 @@ Example:
buf[3] = 0x42; buf[3] = 0x42;
for (ii = 0; ii < buf.length; ii++) { for (ii = 0; ii < buf.length; ii++) {
console.log(buf.readUInt8(ii, true)); console.log(buf.readUInt8(ii);
console.log(buf.readUInt8(ii, false));
} }
// 0x3
// 0x3 // 0x3
// 0x4 // 0x4
// 0x4
// 0x23
// 0x23 // 0x23
// 0x42 // 0x42
// 0x42
### buffer.readUInt16(offset, bigEndian) ### buffer.readUInt16LE(offset, noAssert=false)
### buffer.readUInt16BE(offset, noAssert=false)
Reads an unsigned 16 bit integer from the buffer at the specified offset with
specified endian format.
Reads an unsigned 16 bit integer from the buffer at the specified offset. If Set `noAssert` to true to skip validation of `offset`. This means that `offset`
`bigEndian` is true, reads bytes in a big endian format, otherwise reads them as may be beyond the end of the buffer.
little endian.
Example: Example:
@ -216,12 +215,12 @@ Example:
buf[2] = 0x23; buf[2] = 0x23;
buf[3] = 0x42; buf[3] = 0x42;
console.log(buf.readUInt16(0, true)); console.log(buf.readUInt16BE(0));
console.log(buf.readUInt16(0, false)); console.log(buf.readUInt16LE(0));
console.log(buf.readUInt16(1, true)); console.log(buf.readUInt16BE(1));
console.log(buf.readUInt16(1, false)); console.log(buf.readUInt16LE(1));
console.log(buf.readUInt16(2, true)); console.log(buf.readUInt16BE(2));
console.log(buf.readUInt16(2, false)); console.log(buf.readUInt16LE(2));
// 0x0304 // 0x0304
// 0x0403 // 0x0403
@ -230,12 +229,14 @@ Example:
// 0x2342 // 0x2342
// 0x4223 // 0x4223
### buffer.readUInt32(offset, bigEndian) ### buffer.readUInt32LE(offset, noAssert=false)
### buffer.readUInt32BE(offset, noAssert=false)
Reads an unsigned 32 bit integer from the buffer at the specified offset. If Reads an unsigned 32 bit integer from the buffer at the specified offset with
`bigEndian` is true, reads bytes in a big endian format, otherwise reads them as specified endian format.
little endian.
Set `noAssert` to true to skip validation of `offset`. This means that `offset`
may be beyond the end of the buffer.
Example: Example:
@ -246,43 +247,54 @@ Example:
buf[2] = 0x23; buf[2] = 0x23;
buf[3] = 0x42; buf[3] = 0x42;
console.log(buf.readUInt32(0, true)); console.log(buf.readUInt32BE(0));
console.log(buf.readUInt32(0, false)); console.log(buf.readUInt32LE(0));
// 0x03042342 // 0x03042342
// 0x42230403 // 0x42230403
### buffer.readInt8(offset, bigEndian) ### buffer.readInt8(offset, noAssert=false)
Reads a signed 8 bit integer from the buffer at the specified offset. If Reads a signed 8 bit integer from the buffer at the specified offset.
`bigEndian` is true, reads bytes in a big endian format, otherwise reads them as
little endian.
Works as `buffer.readUInt8`, except buffer contents are treated as twos Set `noAssert` to true to skip validation of `offset`. This means that `offset`
may be beyond the end of the buffer.
Works as `buffer.readUInt8`, except buffer contents are treated as two's
complement signed values. complement signed values.
### buffer.readInt16(offset, bigEndian) ### buffer.readInt16LE(offset, noAssert=false)
### buffer.readInt16BE(offset, noAssert=false)
Reads a signed 16 bit integer from the buffer at the specified offset with
specified endian format.
Reads a signed 16 bit integer from the buffer at the specified offset. If Set `noAssert` to true to skip validation of `offset`. This means that `offset`
`bigEndian` is true, reads bytes in a big endian format, otherwise reads them as may be beyond the end of the buffer.
little endian.
Works as `buffer.readUInt16`, except buffer contents are treated as twos Works as `buffer.readUInt16*`, except buffer contents are treated as two's
complement signed values. complement signed values.
### buffer.readInt32(offset, bigEndian) ### buffer.readInt32LE(offset, noAssert=false)
### buffer.readInt32BE(offset, noAssert=false)
Reads a signed 32 bit integer from the buffer at the specified offset. If Reads a signed 32 bit integer from the buffer at the specified offset with
`bigEndian` is true, reads bytes in a big endian format, otherwise reads them as specified endian format.
little endian.
Works as `buffer.readUInt32`, except buffer contents are treated as twos Set `noAssert` to true to skip validation of `offset`. This means that `offset`
may be beyond the end of the buffer.
Works as `buffer.readUInt32*`, except buffer contents are treated as two's
complement signed values. complement signed values.
### buffer.readFloat(offset, bigEndian) ### buffer.readFloatLE(offset, noAssert=false)
### buffer.readFloatBE(offset, noAssert=false)
Reads a 32 bit float from the buffer at the specified offset. Reads a 32 bit float from the buffer at the specified offset with specified
endian format.
Set `noAssert` to true to skip validation of `offset`. This means that `offset`
may be beyond the end of the buffer.
Example: Example:
@ -293,15 +305,18 @@ Example:
buf[2] = 0x80; buf[2] = 0x80;
buf[3] = 0x3f; buf[3] = 0x3f;
console.log(buf.readFloat(0, false)); console.log(buf.readFloatLE(0));
// 0x01 // 0x01
### buffer.readDouble(offset, bigEndian) ### buffer.readDoubleLE(offset, noAssert=false)
### buffer.readDoubleBE(offset, noAssert=false)
Reads a 64 bit double from the buffer at the specified offset with specified
endian format.
Reads a 64 bit double from the buffer at the specified offset. Endian must be Set `noAssert` to true to skip validation of `offset`. This means that `offset`
either true or false and specifies what endian ordering to read the bytes may be beyond the end of the buffer.
from the buffer in.
Example: Example:
@ -316,152 +331,175 @@ Example:
buf[6] = 0xd5; buf[6] = 0xd5;
buf[7] = 0x3f; buf[7] = 0x3f;
console.log(buf.readDouble(0, false)); console.log(buf.readDoubleLE(0));
// 0.3333333333333333 // 0.3333333333333333
### buffer.writeUInt8(value, offset, bigEndian) ### buffer.writeUInt8(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset. Note, `value` must be a
format. Note, `value` must be a valid 8 bit unsigned integer. valid unsigned 8 bit integer.
Set `noAssert` to true to skip validation of `value` and `offset`. This means
that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Example: Example:
var buf = new Buffer(4); var buf = new Buffer(4);
buf.writeUInt8(0x3, 0, true); buf.writeUInt8(0x3, 0);
buf.writeUInt8(0x4, 1, true); buf.writeUInt8(0x4, 1);
buf.writeUInt8(0x23, 2, true); buf.writeUInt8(0x23, 2);
buf.writeUInt8(0x42, 3, true); buf.writeUInt8(0x42, 3);
console.log(buf);
buf.writeUInt8(0x3, 0, false);
buf.writeUInt8(0x4, 1, false);
buf.writeUInt8(0x23, 2, false);
buf.writeUInt8(0x42, 3, false);
console.log(buf); console.log(buf);
// <Buffer 03 04 23 42> // <Buffer 03 04 23 42>
// <Buffer 03 04 23 42>
### buffer.writeUInt16(value, offset, bigEndian) ### buffer.writeUInt16LE(value, offset, noAssert=false)
### buffer.writeUInt16BE(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset with specified endian
format. Note, `value` must be a valid 16 bit unsigned integer. format. Note, `value` must be a valid unsigned 16 bit integer.
Set `noAssert` to true to skip validation of `value` and `offset`. This means
that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Example: Example:
var buf = new Buffer(4); var buf = new Buffer(4);
buf.writeUInt16(0xdead, 0, true); buf.writeUInt16BE(0xdead, 0);
buf.writeUInt16(0xbeef, 2, true); buf.writeUInt16BE(0xbeef, 2);
console.log(buf); console.log(buf);
buf.writeUInt16(0xdead, 0, false); buf.writeUInt16LE(0xdead, 0);
buf.writeUInt16(0xbeef, 2, false); buf.writeUInt16LE(0xbeef, 2);
console.log(buf); console.log(buf);
// <Buffer de ad be ef> // <Buffer de ad be ef>
// <Buffer ad de ef be> // <Buffer ad de ef be>
### buffer.writeUInt32(value, offset, bigEndian) ### buffer.writeUInt32LE(value, offset, noAssert=false)
### buffer.writeUInt32BE(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset with specified endian
format. Note, `value` must be a valid 32 bit unsigned integer. format. Note, `value` must be a valid unsigned 32 bit integer.
Set `noAssert` to true to skip validation of `value` and `offset`. This means
that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Example: Example:
var buf = new Buffer(4); var buf = new Buffer(4);
buf.writeUInt32(0xfeedface, 0, true); buf.writeUInt32BE(0xfeedface, 0);
console.log(buf); console.log(buf);
buf.writeUInt32(0xfeedface, 0, false); buf.writeUInt32LE(0xfeedface, 0);
console.log(buf); console.log(buf);
// <Buffer fe ed fa ce> // <Buffer fe ed fa ce>
// <Buffer ce fa ed fe> // <Buffer ce fa ed fe>
### buffer.writeInt8(value, offset, bigEndian) ### buffer.writeInt8(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset. Note, `value` must be a
format. Note, `value` must be a valid 16 bit signed integer. valid signed 8 bit integer.
Set `noAssert` to true to skip validation of `value` and `offset`. This means
that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Works as `buffer.writeUInt8`, except value is written out as a two's complement Works as `buffer.writeUInt8`, except value is written out as a two's complement
signed integer into `buffer`. signed integer into `buffer`.
### buffer.writeInt16(value, offset, bigEndian) ### buffer.writeInt16LE(value, offset, noAssert=false)
### buffer.writeInt16BE(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset with specified endian
format. Note, `value` must be a valid 16 bit unsigned integer. format. Note, `value` must be a valid signed 16 bit integer.
Works as `buffer.writeUInt16`, except value is written out as a two's complement Set `noAssert` to true to skip validation of `value` and `offset`. This means
signed integer into `buffer`. that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Works as `buffer.writeUInt16*`, except value is written out as a two's
complement signed integer into `buffer`.
### buffer.writeInt32(value, offset, bigEndian) ### buffer.writeInt32LE(value, offset, noAssert=false)
### buffer.writeInt32BE(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset with specified endian
format. Note, `value` must be a valid 32 bit signed integer. format. Note, `value` must be a valid signed 32 bit integer.
Works as `buffer.writeUInt32`, except value is written out as a two's complement Set `noAssert` to true to skip validation of `value` and `offset`. This means
signed integer into `buffer`. that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Works as `buffer.writeUInt32*`, except value is written out as a two's
complement signed integer into `buffer`.
### buffer.writeFloat(value, offset, bigEndian) ### buffer.writeFloatLE(value, offset, noAssert=false)
### buffer.writeFloatBE(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset with specified endian
format. Note, `value` must be a valid 32 bit float. format. Note, `value` must be a valid 32 bit float.
Set `noAssert` to true to skip validation of `value` and `offset`. This means
that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Example: Example:
var buf = new Buffer(4); var buf = new Buffer(4);
buf.writeFloat(0xcafebabe, 0, true); buf.writeFloatBE(0xcafebabe, 0);
console.log(buf); console.log(buf);
buf.writeFloat(0xcafebabe, 0, false); buf.writeFloatLE(0xcafebabe, 0);
console.log(buf); console.log(buf);
// <Buffer 4f 4a fe bb> // <Buffer 4f 4a fe bb>
// <Buffer bb fe 4a 4f> // <Buffer bb fe 4a 4f>
### buffer.writeDouble(value, offset, bigEndian) ### buffer.writeDoubleLE(value, offset, noAssert=false)
### buffer.writeDoubleBE(value, offset, noAssert=false)
Writes `value` to the buffer at the specified offset with specified endian Writes `value` to the buffer at the specified offset with specified endian
format. Note, `value` must be a valid 64 bit double. format. Note, `value` must be a valid 64 bit double.
Set `noAssert` to true to skip validation of `value` and `offset`. This means
that `value` may be too large for the specific function and `offset` may be
beyond the end of the buffer leading to the values being silently dropped. This
should not be used unless you are certain of correctness.
Example: Example:
var buf = new Buffer(8); var buf = new Buffer(8);
buf.writeFloat(0xdeadbeefcafebabe, 0, true); buf.writeDoubleBE(0xdeadbeefcafebabe, 0);
console.log(buf); console.log(buf);
buf.writeFloat(0xdeadbeefcafebabe, 0, false); buf.writeDoubleLE(0xdeadbeefcafebabe, 0);
console.log(buf); console.log(buf);
// <Buffer 43 eb d5 b7 dd f9 5f d7> // <Buffer 43 eb d5 b7 dd f9 5f d7>
// <Buffer d7 5f f9 dd b7 d5 eb 43> // <Buffer d7 5f f9 dd b7 d5 eb 43>
### buffer.readUInt8NoChk(value, offset, bigEndian)
### buffer.readUInt16NoChk(value, offset, bigEndian)
### buffer.readUInt32NoChk(value, offset, bigEndian)
### buffer.writeUInt8NoChk(value, offset, bigEndian)
### buffer.writeUInt16NoChk(value, offset, bigEndian)
### buffer.writeUInt32NoChk(value, offset, bigEndian)
These functions all work as per the versions without the NoChk suffix. These
functions allow you to do use the raw functionality without any kind of
validation for correctness. This means that value may be too large for the
specific function and offset may be beyond the end of the buffer leading to the
values being silently dropped. These should not be used unless you are certain
of correctness.
### buffer.fill(value, offset=0, length=-1) ### buffer.fill(value, offset=0, length=-1)
Fills the buffer with the specified value. If the offset and length are not Fills the buffer with the specified value. If the offset and length are not
@ -472,5 +510,5 @@ given it will fill the entire buffer.
### INSPECT_MAX_BYTES ### INSPECT_MAX_BYTES
How many bytes will be returned when `b.inspect()` is called. This can How many bytes will be returned when `buffer.inspect()` is called. This can
be overriden by user modules. be overriden by user modules.

466
lib/buffer.js
View File

@ -536,28 +536,36 @@ Buffer.prototype.asciiWrite = function(string, offset) {
return this.write(string, offset, 'ascii'); return this.write(string, offset, 'ascii');
}; };
Buffer.prototype.readUInt8NoChk = function(offset, bigEndian) { Buffer.prototype.readUInt8 = function(offset, noAssert) {
var buffer = this; var buffer = this;
if (!noAssert) {
assert.ok(offset !== undefined && offset !== null,
'missing offset');
assert.ok(offset < buffer.length,
'Trying to read beyond buffer length');
}
return buffer[offset]; return buffer[offset];
}; };
Buffer.prototype.readUInt8 = function(offset, bigEndian) { function readUInt16(buffer, offset, isBigEndian, noAssert) {
var buffer = this; var val = 0;
assert.ok(offset !== undefined && offset !== null,
'missing offset');
assert.ok(offset < buffer.length, if (!noAssert) {
'Trying to read beyond buffer length'); assert.ok(typeof (isBigEndian) === 'boolean',
'missing or invalid endian');
return buffer.readUInt8NoChk(offset, bigEndian); assert.ok(offset !== undefined && offset !== null,
}; 'missing offset');
Buffer.prototype.readUInt16NoChk = function(offset, bigEndian) { assert.ok(offset + 1 < buffer.length,
var val = 0; 'Trying to read beyond buffer length');
var buffer = this; }
if (bigEndian) { if (isBigEndian) {
val = buffer[offset] << 8; val = buffer[offset] << 8;
val |= buffer[offset + 1]; val |= buffer[offset + 1];
} else { } else {
@ -566,28 +574,31 @@ Buffer.prototype.readUInt16NoChk = function(offset, bigEndian) {
} }
return val; return val;
}; }
Buffer.prototype.readUInt16 = function(offset, bigEndian) { Buffer.prototype.readUInt16LE = function(offset, noAssert) {
var buffer = this; return readUInt16(this, offset, false, noAssert);
};
assert.ok(typeof (bigEndian) === 'boolean', Buffer.prototype.readUInt16BE = function(offset, noAssert) {
'missing or invalid endian'); return readUInt16(this, offset, true, noAssert);
};
assert.ok(offset !== undefined && offset !== null, function readUInt32(buffer, offset, isBigEndian, noAssert) {
'missing offset'); var val = 0;
assert.ok(offset + 1 < buffer.length, if (!noAssert) {
'Trying to read beyond buffer length'); assert.ok(typeof (isBigEndian) === 'boolean',
'missing or invalid endian');
return buffer.readUInt16NoChk(offset, bigEndian); assert.ok(offset !== undefined && offset !== null,
}; 'missing offset');
Buffer.prototype.readUInt32NoChk = function(offset, bigEndian) { assert.ok(offset + 3 < buffer.length,
var val = 0; 'Trying to read beyond buffer length');
var buffer = this; }
if (bigEndian) { if (isBigEndian) {
val = buffer[offset + 1] << 16; val = buffer[offset + 1] << 16;
val |= buffer[offset + 2] << 8; val |= buffer[offset + 2] << 8;
val |= buffer[offset + 3]; val |= buffer[offset + 3];
@ -600,22 +611,14 @@ Buffer.prototype.readUInt32NoChk = function(offset, bigEndian) {
} }
return val; return val;
}; }
Buffer.prototype.readUInt32 = function(offset, bigEndian) {
var val = 0;
var buffer = this;
assert.ok(typeof (bigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset !== undefined && offset !== null,
'missing offset');
assert.ok(offset + 3 < buffer.length, Buffer.prototype.readUInt32LE = function(offset, noAssert) {
'Trying to read beyond buffer length'); return readUInt32(this, offset, false, noAssert);
};
return buffer.readUInt32NoChk(offset, bigEndian); Buffer.prototype.readUInt32BE = function(offset, noAssert) {
return readUInt32(this, offset, true, noAssert);
}; };
@ -664,15 +667,17 @@ Buffer.prototype.readUInt32 = function(offset, bigEndian) {
* (0x007f + 1) * -1 * (0x007f + 1) * -1
* (0x0080) * -1 * (0x0080) * -1
*/ */
Buffer.prototype.readInt8 = function(offset, bigEndian) { Buffer.prototype.readInt8 = function(offset, noAssert) {
var buffer = this; var buffer = this;
var neg; var neg;
assert.ok(offset !== undefined && offset !== null, if (!noAssert) {
'missing offset'); assert.ok(offset !== undefined && offset !== null,
'missing offset');
assert.ok(offset < buffer.length, assert.ok(offset < buffer.length,
'Trying to read beyond buffer length'); 'Trying to read beyond buffer length');
}
neg = buffer[offset] & 0x80; neg = buffer[offset] & 0x80;
if (!neg) { if (!neg) {
@ -682,77 +687,108 @@ Buffer.prototype.readInt8 = function(offset, bigEndian) {
return ((0xff - buffer[offset] + 1) * -1); return ((0xff - buffer[offset] + 1) * -1);
}; };
function readInt16(buffer, offset, isBigEndian, noAssert) {
Buffer.prototype.readInt16 = function(offset, bigEndian) {
var buffer = this;
var neg; var neg;
assert.ok(typeof (bigEndian) === 'boolean', if (!noAssert) {
'missing or invalid endian'); assert.ok(typeof (isBigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset !== undefined && offset !== null, assert.ok(offset !== undefined && offset !== null,
'missing offset'); 'missing offset');
assert.ok(offset + 1 < buffer.length, assert.ok(offset + 1 < buffer.length,
'Trying to read beyond buffer length'); 'Trying to read beyond buffer length');
}
val = buffer.readUInt16NoChk(offset, bigEndian); val = readUInt16(buffer, offset, isBigEndian, noAssert);
neg = val & 0x8000; neg = val & 0x8000;
if (!neg) { if (!neg) {
return val; return val;
} }
return (0xffff - val + 1) * -1; return (0xffff - val + 1) * -1;
}
Buffer.prototype.readInt16LE = function(offset, noAssert) {
return readInt16(this, offset, false, noAssert);
}; };
Buffer.prototype.readInt16BE = function(offset, noAssert) {
return readInt16(this, offset, true, noAssert);
};
Buffer.prototype.readInt32 = function(offset, bigEndian) { function readInt32(buffer, offset, isBigEndian, noAssert) {
var buffer = this;
var neg; var neg;
assert.ok(typeof (bigEndian) === 'boolean', if (!noAssert) {
'missing or invalid endian'); assert.ok(typeof (isBigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset !== undefined && offset !== null, assert.ok(offset !== undefined && offset !== null,
'missing offset'); 'missing offset');
assert.ok(offset + 3 < buffer.length, assert.ok(offset + 3 < buffer.length,
'Trying to read beyond buffer length'); 'Trying to read beyond buffer length');
}
val = buffer.readUInt32NoChk(offset, bigEndian); val = readUInt32(buffer, offset, isBigEndian, noAssert);
neg = val & 0x80000000; neg = val & 0x80000000;
if (!neg) { if (!neg) {
return (val); return (val);
} }
return (0xffffffff - val + 1) * -1; return (0xffffffff - val + 1) * -1;
}; }
Buffer.prototype.readInt32LE = function(offset, noAssert) {
return readInt32(this, offset, false, noAssert);
};
Buffer.prototype.readFloat = function(offset, bigEndian) { Buffer.prototype.readInt32BE = function(offset, noAssert) {
var buffer = this; return readInt32(this, offset, true, noAssert);
};
assert.ok(typeof (bigEndian) === 'boolean', function readFloat(buffer, offset, isBigEndian, noAssert) {
'missing or invalid endian'); if (!noAssert) {
assert.ok(typeof (isBigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset + 3 < buffer.length, assert.ok(offset + 3 < buffer.length,
'Trying to read beyond buffer length'); 'Trying to read beyond buffer length');
}
return require('buffer_ieee754').readIEEE754(buffer, offset, bigEndian, return require('buffer_ieee754').readIEEE754(buffer, offset, isBigEndian,
23, 4); 23, 4);
}
Buffer.prototype.readFloatLE = function(offset, noAssert) {
return readFloat(this, offset, false, noAssert);
}; };
Buffer.prototype.readDouble = function(offset, bigEndian) { Buffer.prototype.readFloatBE = function(offset, noAssert) {
var buffer = this; return readFloat(this, offset, true, noAssert);
};
assert.ok(typeof (bigEndian) === 'boolean', function readDouble(buffer, offset, isBigEndian, noAssert) {
'missing or invalid endian'); if (!noAssert) {
assert.ok(typeof (isBigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset + 7 < buffer.length, assert.ok(offset + 7 < buffer.length,
'Trying to read beyond buffer length'); 'Trying to read beyond buffer length');
}
return require('buffer_ieee754').readIEEE754(buffer, offset, bigEndian, return require('buffer_ieee754').readIEEE754(buffer, offset, isBigEndian,
52, 8); 52, 8);
}
Buffer.prototype.readDoubleLE = function(offset, noAssert) {
return readDouble(this, offset, false, noAssert);
};
Buffer.prototype.readDoubleBE = function(offset, noAssert) {
return readDouble(this, offset, true, noAssert);
}; };
@ -777,68 +813,77 @@ function verifuint(value, max) {
assert.ok(Math.floor(value) === value, 'value has a fractional component'); assert.ok(Math.floor(value) === value, 'value has a fractional component');
} }
Buffer.prototype.writeUInt8NoChk = function(value, offset, bigEndian) { Buffer.prototype.writeUInt8 = function(value, offset, noAssert) {
var buffer = this; var buffer = this;
buffer[offset] = value;
};
Buffer.prototype.writeUInt8 = function(value, offset, bigEndian) { if (!noAssert) {
var buffer = this; assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(value !== undefined && value !== null, assert.ok(offset !== undefined && offset !== null,
'missing value'); 'missing offset');
assert.ok(typeof (bigEndian) === 'boolean', assert.ok(offset < buffer.length,
'missing or invalid endian'); 'trying to write beyond buffer length');
assert.ok(offset !== undefined && offset !== null, verifuint(value, 0xff);
'missing offset'); }
assert.ok(offset < buffer.length, buffer[offset] = value;
'trying to write beyond buffer length'); };
verifuint(value, 0xff); function writeUInt16(buffer, value, offset, isBigEndian, noAssert) {
if (!noAssert) {
assert.ok(value !== undefined && value !== null,
'missing value');
buffer.writeUInt8NoChk(value, offset, bigEndian); assert.ok(typeof (isBigEndian) === 'boolean',
}; 'missing or invalid endian');
Buffer.prototype.writeUInt16NoChk = function(value, offset, bigEndian) { assert.ok(offset !== undefined && offset !== null,
var buffer = this; 'missing offset');
if (bigEndian) { assert.ok(offset + 1 < buffer.length,
'trying to write beyond buffer length');
verifuint(value, 0xffff);
}
if (isBigEndian) {
buffer[offset] = (value & 0xff00) >>> 8; buffer[offset] = (value & 0xff00) >>> 8;
buffer[offset + 1] = value & 0x00ff; buffer[offset + 1] = value & 0x00ff;
} else { } else {
buffer[offset + 1] = (value & 0xff00) >>> 8; buffer[offset + 1] = (value & 0xff00) >>> 8;
buffer[offset] = value & 0x00ff; buffer[offset] = value & 0x00ff;
} }
}
Buffer.prototype.writeUInt16LE = function(value, offset, noAssert) {
writeUInt16(this, value, offset, false, noAssert);
}; };
Buffer.prototype.writeUInt16 = function(value, offset, bigEndian) { Buffer.prototype.writeUInt16BE = function(value, offset, noAssert) {
var buffer = this; writeUInt16(this, value, offset, true, noAssert);
};
assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(typeof (bigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset !== undefined && offset !== null, function writeUInt32(buffer, value, offset, isBigEndian, noAssert) {
'missing offset'); if (!noAssert) {
assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(offset + 1 < buffer.length, assert.ok(typeof (isBigEndian) === 'boolean',
'trying to write beyond buffer length'); 'missing or invalid endian');
verifuint(value, 0xffff); assert.ok(offset !== undefined && offset !== null,
'missing offset');
buffer.writeUInt16NoChk(value, offset, bigEndian); assert.ok(offset + 3 < buffer.length,
}; 'trying to write beyond buffer length');
Buffer.prototype.writeUInt32NoChk = function(value, offset, bigEndian) { verifuint(value, 0xffffffff);
var buffer = this; }
if (bigEndian) { if (isBigEndian) {
buffer[offset] = (value >>> 24) & 0xff; buffer[offset] = (value >>> 24) & 0xff;
buffer[offset + 1] = (value >>> 16) & 0xff; buffer[offset + 1] = (value >>> 16) & 0xff;
buffer[offset + 2] = (value >>> 8) & 0xff; buffer[offset + 2] = (value >>> 8) & 0xff;
@ -849,26 +894,14 @@ Buffer.prototype.writeUInt32NoChk = function(value, offset, bigEndian) {
buffer[offset + 1] = (value >>> 8) & 0xff; buffer[offset + 1] = (value >>> 8) & 0xff;
buffer[offset] = value & 0xff; buffer[offset] = value & 0xff;
} }
}; }
Buffer.prototype.writeUInt32 = function(value, offset, bigEndian) {
var buffer = this;
assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(typeof (bigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset !== undefined && offset !== null,
'missing offset');
assert.ok(offset + 3 < buffer.length,
'trying to write beyond buffer length');
verifuint(value, 0xffffffff); Buffer.prototype.writeUInt32LE = function(value, offset, noAssert) {
writeUInt32(this, value, offset, false, noAssert);
};
buffer.writeUInt32NoChk(value, offset, bigEndian); Buffer.prototype.writeUInt32BE = function(value, offset, noAssert) {
writeUInt32(this, value, offset, true, noAssert);
}; };
@ -923,7 +956,6 @@ function verifsint(value, max, min) {
assert.ok(Math.floor(value) === value, 'value has a fractional component'); assert.ok(Math.floor(value) === value, 'value has a fractional component');
} }
function verifIEEE754(value, max, min) { function verifIEEE754(value, max, min) {
assert.ok(typeof (value) == 'number', assert.ok(typeof (value) == 'number',
'cannot write a non-number as a number'); 'cannot write a non-number as a number');
@ -933,119 +965,147 @@ function verifIEEE754(value, max, min) {
assert.ok(value >= min, 'value smaller than minimum allowed value'); assert.ok(value >= min, 'value smaller than minimum allowed value');
} }
Buffer.prototype.writeInt8 = function(value, offset, noAssert) {
Buffer.prototype.writeInt8 = function(value, offset, bigEndian) {
var buffer = this; var buffer = this;
assert.ok(value !== undefined && value !== null, if (!noAssert) {
'missing value'); assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(typeof (bigEndian) === 'boolean', assert.ok(offset !== undefined && offset !== null,
'missing or invalid endian'); 'missing offset');
assert.ok(offset !== undefined && offset !== null, assert.ok(offset < buffer.length,
'missing offset'); 'Trying to write beyond buffer length');
assert.ok(offset < buffer.length, verifsint(value, 0x7f, -0xf0);
'Trying to write beyond buffer length'); }
verifsint(value, 0x7f, -0xf0);
if (value >= 0) { if (value >= 0) {
buffer.writeUInt8NoChk(value, offset, bigEndian); buffer.writeUInt8(value, offset, noAssert);
} else { } else {
buffer.writeUInt8NoChk(0xff + value + 1, offset, bigEndian); buffer.writeUInt8(0xff + value + 1, offset, noAssert);
} }
}; };
function writeInt16(buffer, value, offset, isBigEndian, noAssert) {
if (!noAssert) {
assert.ok(value !== undefined && value !== null,
'missing value');
Buffer.prototype.writeInt16 = function(value, offset, bigEndian) { assert.ok(typeof (isBigEndian) === 'boolean',
var buffer = this; 'missing or invalid endian');
assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(typeof (bigEndian) === 'boolean',
'missing or invalid endian');
assert.ok(offset !== undefined && offset !== null, assert.ok(offset !== undefined && offset !== null,
'missing offset'); 'missing offset');
assert.ok(offset + 1 < buffer.length, assert.ok(offset + 1 < buffer.length,
'Trying to write beyond buffer length'); 'Trying to write beyond buffer length');
verifsint(value, 0x7fff, -0xf000); verifsint(value, 0x7fff, -0xf000);
}
if (value >= 0) { if (value >= 0) {
buffer.writeUInt16NoChk(value, offset, bigEndian); writeUInt16(buffer, value, offset, isBigEndian, noAssert);
} else { } else {
buffer.writeUInt16NoChk(0xffff + value + 1, offset, bigEndian); writeUInt16(buffer, 0xffff + value + 1, offset, isBigEndian, noAssert);
} }
}
Buffer.prototype.writeInt16LE = function(value, offset, noAssert) {
writeInt16(this, value, offset, false, noAssert);
}; };
Buffer.prototype.writeInt16BE = function(value, offset, noAssert) {
writeInt16(this, value, offset, true, noAssert);
};
Buffer.prototype.writeInt32 = function(value, offset, bigEndian) { function writeInt32(buffer, value, offset, isBigEndian, noAssert) {
var buffer = this; if (!noAssert) {
assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(value !== undefined && value !== null, assert.ok(typeof (isBigEndian) === 'boolean',
'missing value'); 'missing or invalid endian');
assert.ok(typeof (bigEndian) === 'boolean', assert.ok(offset !== undefined && offset !== null,
'missing or invalid endian'); 'missing offset');
assert.ok(offset !== undefined && offset !== null, assert.ok(offset + 3 < buffer.length,
'missing offset'); 'Trying to write beyond buffer length');
assert.ok(offset + 3 < buffer.length, verifsint(value, 0x7fffffff, -0xf0000000);
'Trying to write beyond buffer length'); }
verifsint(value, 0x7fffffff, -0xf0000000);
if (value >= 0) { if (value >= 0) {
buffer.writeUInt32NoChk(value, offset, bigEndian); writeUInt32(buffer, value, offset, isBigEndian, noAssert);
} else { } else {
buffer.writeUInt32NoChk(0xffffffff + value + 1, offset, bigEndian); writeUInt32(buffer, 0xffffffff + value + 1, offset, isBigEndian, noAssert);
} }
}
Buffer.prototype.writeInt32LE = function(value, offset, noAssert) {
writeInt32(this, value, offset, false, noAssert);
}; };
Buffer.prototype.writeInt32BE = function(value, offset, noAssert) {
writeInt32(this, value, offset, true, noAssert);
};
Buffer.prototype.writeFloat = function(value, offset, bigEndian) { function writeFloat(buffer, value, offset, isBigEndian, noAssert) {
var buffer = this; if (!noAssert) {
assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(value !== undefined && value !== null, assert.ok(typeof (isBigEndian) === 'boolean',
'missing value'); 'missing or invalid endian');
assert.ok(typeof (bigEndian) === 'boolean', assert.ok(offset !== undefined && offset !== null,
'missing or invalid endian'); 'missing offset');
assert.ok(offset !== undefined && offset !== null, assert.ok(offset + 3 < buffer.length,
'missing offset'); 'Trying to write beyond buffer length');
assert.ok(offset + 3 < buffer.length, verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38);
'Trying to write beyond buffer length'); }
verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38); require('buffer_ieee754').writeIEEE754(buffer, value, offset, isBigEndian,
require('buffer_ieee754').writeIEEE754(buffer, value, offset, bigEndian,
23, 4); 23, 4);
}
Buffer.prototype.writeFloatLE = function(value, offset, noAssert) {
writeFloat(this, value, offset, false, noAssert);
}; };
Buffer.prototype.writeFloatBE = function(value, offset, noAssert) {
writeFloat(this, value, offset, true, noAssert);
};
Buffer.prototype.writeDouble = function(value, offset, bigEndian) { function writeDouble(buffer, value, offset, isBigEndian, noAssert) {
var buffer = this; if (!noAssert) {
assert.ok(value !== undefined && value !== null,
'missing value');
assert.ok(value !== undefined && value !== null, assert.ok(typeof (isBigEndian) === 'boolean',
'missing value'); 'missing or invalid endian');
assert.ok(typeof (bigEndian) === 'boolean', assert.ok(offset !== undefined && offset !== null,
'missing or invalid endian'); 'missing offset');
assert.ok(offset !== undefined && offset !== null, assert.ok(offset + 7 < buffer.length,
'missing offset'); 'Trying to write beyond buffer length');
assert.ok(offset + 7 < buffer.length, verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308);
'Trying to write beyond buffer length'); }
verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308); require('buffer_ieee754').writeIEEE754(buffer, value, offset, isBigEndian,
require('buffer_ieee754').writeIEEE754(buffer, value, offset, bigEndian,
52, 8); 52, 8);
}
Buffer.prototype.writeDoubleLE = function(value, offset, noAssert) {
writeDouble(this, value, offset, false, noAssert);
}; };
Buffer.prototype.writeDoubleBE = function(value, offset, noAssert) {
writeDouble(this, value, offset, true, noAssert);
};

14
lib/buffer_ieee754.js
View File

@ -30,15 +30,14 @@
// //
// Modifications to writeIEEE754 to support negative zeroes made by Brian White // Modifications to writeIEEE754 to support negative zeroes made by Brian White
exports.readIEEE754 = function(buffer, offset, endian, mLen, nBytes) { exports.readIEEE754 = function(buffer, offset, isBE, mLen, nBytes) {
var e, m, var e, m,
bBE = endian,
eLen = nBytes * 8 - mLen - 1, eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1, eMax = (1 << eLen) - 1,
eBias = eMax >> 1, eBias = eMax >> 1,
nBits = -7, nBits = -7,
i = bBE ? 0 : (nBytes - 1), i = isBE ? 0 : (nBytes - 1),
d = bBE ? 1 : -1, d = isBE ? 1 : -1,
s = buffer[offset + i]; s = buffer[offset + i];
i += d; i += d;
@ -64,15 +63,14 @@ exports.readIEEE754 = function(buffer, offset, endian, mLen, nBytes) {
return (s ? -1 : 1) * m * Math.pow(2, e - mLen); return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
}; };
exports.writeIEEE754 = function(buffer, value, offset, endian, mLen, nBytes) { exports.writeIEEE754 = function(buffer, value, offset, isBE, mLen, nBytes) {
var e, m, c, var e, m, c,
bBE = endian,
eLen = nBytes * 8 - mLen - 1, eLen = nBytes * 8 - mLen - 1,
eMax = (1 << eLen) - 1, eMax = (1 << eLen) - 1,
eBias = eMax >> 1, eBias = eMax >> 1,
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0), rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
i = bBE ? (nBytes-1) : 0, i = isBE ? (nBytes-1) : 0,
d = bBE ? -1 : 1, d = isBE ? -1 : 1,
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
value = Math.abs(value); value = Math.abs(value);

61
test/simple/test-readdouble.js
View File

@ -8,6 +8,7 @@ var ASSERT = require('assert');
*/ */
function test() { function test() {
var buffer = new Buffer(8); var buffer = new Buffer(8);
buffer[0] = 0x55; buffer[0] = 0x55;
buffer[1] = 0x55; buffer[1] = 0x55;
buffer[2] = 0x55; buffer[2] = 0x55;
@ -16,8 +17,8 @@ function test() {
buffer[5] = 0x55; buffer[5] = 0x55;
buffer[6] = 0xd5; buffer[6] = 0xd5;
buffer[7] = 0x3f; buffer[7] = 0x3f;
ASSERT.equal(1.1945305291680097e+103, buffer.readDouble(0, true)); ASSERT.equal(1.1945305291680097e+103, buffer.readDoubleBE(0));
ASSERT.equal(0.3333333333333333, buffer.readDouble(0, false)); ASSERT.equal(0.3333333333333333, buffer.readDoubleLE(0));
buffer[0] = 1; buffer[0] = 1;
buffer[1] = 0; buffer[1] = 0;
@ -27,18 +28,18 @@ function test() {
buffer[5] = 0; buffer[5] = 0;
buffer[6] = 0xf0; buffer[6] = 0xf0;
buffer[7] = 0x3f; buffer[7] = 0x3f;
ASSERT.equal(7.291122019655968e-304, buffer.readDouble(0, true)); ASSERT.equal(7.291122019655968e-304, buffer.readDoubleBE(0));
ASSERT.equal(1.0000000000000002, buffer.readDouble(0, false)); ASSERT.equal(1.0000000000000002, buffer.readDoubleLE(0));
buffer[0] = 2; buffer[0] = 2;
ASSERT.equal(4.778309726801735e-299, buffer.readDouble(0, true)); ASSERT.equal(4.778309726801735e-299, buffer.readDoubleBE(0));
ASSERT.equal(1.0000000000000004, buffer.readDouble(0, false)); ASSERT.equal(1.0000000000000004, buffer.readDoubleLE(0));
buffer[0] = 1; buffer[0] = 1;
buffer[6] = 0; buffer[6] = 0;
buffer[7] = 0; buffer[7] = 0;
ASSERT.equal(7.291122019556398e-304, buffer.readDouble(0, true)); ASSERT.equal(7.291122019556398e-304, buffer.readDoubleBE(0));
ASSERT.equal(5e-324, buffer.readDouble(0, false)); ASSERT.equal(5e-324, buffer.readDoubleLE(0));
buffer[0] = 0xff; buffer[0] = 0xff;
buffer[1] = 0xff; buffer[1] = 0xff;
@ -48,13 +49,13 @@ function test() {
buffer[5] = 0xff; buffer[5] = 0xff;
buffer[6] = 0x0f; buffer[6] = 0x0f;
buffer[7] = 0x00; buffer[7] = 0x00;
ASSERT.ok(isNaN(buffer.readDouble(0, true))); ASSERT.ok(isNaN(buffer.readDoubleBE(0)));
ASSERT.equal(2.225073858507201e-308, buffer.readDouble(0, false)); ASSERT.equal(2.225073858507201e-308, buffer.readDoubleLE(0));
buffer[6] = 0xef; buffer[6] = 0xef;
buffer[7] = 0x7f; buffer[7] = 0x7f;
ASSERT.ok(isNaN(buffer.readDouble(0, true))); ASSERT.ok(isNaN(buffer.readDoubleBE(0)));
ASSERT.equal(1.7976931348623157e+308, buffer.readDouble(0, false)); ASSERT.equal(1.7976931348623157e+308, buffer.readDoubleLE(0));
buffer[0] = 0; buffer[0] = 0;
buffer[1] = 0; buffer[1] = 0;
@ -64,42 +65,42 @@ function test() {
buffer[5] = 0; buffer[5] = 0;
buffer[6] = 0xf0; buffer[6] = 0xf0;
buffer[7] = 0x3f; buffer[7] = 0x3f;
ASSERT.equal(3.03865e-319, buffer.readDouble(0, true)); ASSERT.equal(3.03865e-319, buffer.readDoubleBE(0));
ASSERT.equal(1, buffer.readDouble(0, false)); ASSERT.equal(1, buffer.readDoubleLE(0));
buffer[6] = 0; buffer[6] = 0;
buffer[7] = 0x40; buffer[7] = 0x40;
ASSERT.equal(3.16e-322, buffer.readDouble(0, true)); ASSERT.equal(3.16e-322, buffer.readDoubleBE(0));
ASSERT.equal(2, buffer.readDouble(0, false)); ASSERT.equal(2, buffer.readDoubleLE(0));
buffer[7] = 0xc0; buffer[7] = 0xc0;
ASSERT.equal(9.5e-322, buffer.readDouble(0, true)); ASSERT.equal(9.5e-322, buffer.readDoubleBE(0));
ASSERT.equal(-2, buffer.readDouble(0, false)); ASSERT.equal(-2, buffer.readDoubleLE(0));
buffer[6] = 0x10; buffer[6] = 0x10;
buffer[7] = 0; buffer[7] = 0;
ASSERT.equal(2.0237e-320, buffer.readDouble(0, true)); ASSERT.equal(2.0237e-320, buffer.readDoubleBE(0));
ASSERT.equal(2.2250738585072014e-308, buffer.readDouble(0, false)); ASSERT.equal(2.2250738585072014e-308, buffer.readDoubleLE(0));
buffer[6] = 0; buffer[6] = 0;
ASSERT.equal(0, buffer.readDouble(0, true)); ASSERT.equal(0, buffer.readDoubleBE(0));
ASSERT.equal(0, buffer.readDouble(0, false)); ASSERT.equal(0, buffer.readDoubleLE(0));
ASSERT.equal(false, 1/buffer.readDouble(0, false)<0); ASSERT.equal(false, 1/buffer.readDoubleLE(0)<0);
buffer[7] = 0x80; buffer[7] = 0x80;
ASSERT.equal(6.3e-322, buffer.readDouble(0, true)); ASSERT.equal(6.3e-322, buffer.readDoubleBE(0));
ASSERT.equal(0, buffer.readDouble(0, false)); ASSERT.equal(0, buffer.readDoubleLE(0));
ASSERT.equal(true, 1/buffer.readDouble(0, false)<0); ASSERT.equal(true, 1/buffer.readDoubleLE(0)<0);
buffer[6] = 0xf0; buffer[6] = 0xf0;
buffer[7] = 0x7f; buffer[7] = 0x7f;
ASSERT.equal(3.0418e-319, buffer.readDouble(0, true)); ASSERT.equal(3.0418e-319, buffer.readDoubleBE(0));
ASSERT.equal(Infinity, buffer.readDouble(0, false)); ASSERT.equal(Infinity, buffer.readDoubleLE(0));
buffer[6] = 0xf0; buffer[6] = 0xf0;
buffer[7] = 0xff; buffer[7] = 0xff;
ASSERT.equal(3.04814e-319, buffer.readDouble(0, true)); ASSERT.equal(3.04814e-319, buffer.readDoubleBE(0));
ASSERT.equal(-Infinity, buffer.readDouble(0, false)); ASSERT.equal(-Infinity, buffer.readDoubleLE(0));
} }

37
test/simple/test-readfloat.js
View File

@ -8,60 +8,61 @@ var ASSERT = require('assert');
*/ */
function test() { function test() {
var buffer = new Buffer(4); var buffer = new Buffer(4);
buffer[0] = 0; buffer[0] = 0;
buffer[1] = 0; buffer[1] = 0;
buffer[2] = 0x80; buffer[2] = 0x80;
buffer[3] = 0x3f; buffer[3] = 0x3f;
ASSERT.equal(4.600602988224807e-41, buffer.readFloat(0, true)); ASSERT.equal(4.600602988224807e-41, buffer.readFloatBE(0));
ASSERT.equal(1, buffer.readFloat(0, false)); ASSERT.equal(1, buffer.readFloatLE(0));
buffer[0] = 0; buffer[0] = 0;
buffer[1] = 0; buffer[1] = 0;
buffer[2] = 0; buffer[2] = 0;
buffer[3] = 0xc0; buffer[3] = 0xc0;
ASSERT.equal(2.6904930515036488e-43, buffer.readFloat(0, true)); ASSERT.equal(2.6904930515036488e-43, buffer.readFloatBE(0));
ASSERT.equal(-2, buffer.readFloat(0, false)); ASSERT.equal(-2, buffer.readFloatLE(0));
buffer[0] = 0xff; buffer[0] = 0xff;
buffer[1] = 0xff; buffer[1] = 0xff;
buffer[2] = 0x7f; buffer[2] = 0x7f;
buffer[3] = 0x7f; buffer[3] = 0x7f;
ASSERT.ok(isNaN(buffer.readFloat(0, true))); ASSERT.ok(isNaN(buffer.readFloatBE(0)));
ASSERT.equal(3.4028234663852886e+38, buffer.readFloat(0, false)); ASSERT.equal(3.4028234663852886e+38, buffer.readFloatLE(0));
buffer[0] = 0xab; buffer[0] = 0xab;
buffer[1] = 0xaa; buffer[1] = 0xaa;
buffer[2] = 0xaa; buffer[2] = 0xaa;
buffer[3] = 0x3e; buffer[3] = 0x3e;
ASSERT.equal(-1.2126478207002966e-12, buffer.readFloat(0, true)); ASSERT.equal(-1.2126478207002966e-12, buffer.readFloatBE(0));
ASSERT.equal(0.3333333432674408, buffer.readFloat(0, false)); ASSERT.equal(0.3333333432674408, buffer.readFloatLE(0));
buffer[0] = 0; buffer[0] = 0;
buffer[1] = 0; buffer[1] = 0;
buffer[2] = 0; buffer[2] = 0;
buffer[3] = 0; buffer[3] = 0;
ASSERT.equal(0, buffer.readFloat(0, true)); ASSERT.equal(0, buffer.readFloatBE(0));
ASSERT.equal(0, buffer.readFloat(0, false)); ASSERT.equal(0, buffer.readFloatLE(0));
ASSERT.equal(false, 1/buffer.readFloat(0, false)<0); ASSERT.equal(false, 1/buffer.readFloatLE(0)<0);
buffer[3] = 0x80; buffer[3] = 0x80;
ASSERT.equal(1.793662034335766e-43, buffer.readFloat(0, true)); ASSERT.equal(1.793662034335766e-43, buffer.readFloatBE(0));
ASSERT.equal(0, buffer.readFloat(0, false)); ASSERT.equal(0, buffer.readFloatLE(0));
ASSERT.equal(true, 1/buffer.readFloat(0, false)<0); ASSERT.equal(true, 1/buffer.readFloatLE(0)<0);
buffer[0] = 0; buffer[0] = 0;
buffer[1] = 0; buffer[1] = 0;
buffer[2] = 0x80; buffer[2] = 0x80;
buffer[3] = 0x7f; buffer[3] = 0x7f;
ASSERT.equal(4.609571298396486e-41, buffer.readFloat(0, true)); ASSERT.equal(4.609571298396486e-41, buffer.readFloatBE(0));
ASSERT.equal(Infinity, buffer.readFloat(0, false)); ASSERT.equal(Infinity, buffer.readFloatLE(0));
buffer[0] = 0; buffer[0] = 0;
buffer[1] = 0; buffer[1] = 0;
buffer[2] = 0x80; buffer[2] = 0x80;
buffer[3] = 0xff; buffer[3] = 0xff;
ASSERT.equal(4.627507918739843e-41, buffer.readFloat(0, true)); ASSERT.equal(4.627507918739843e-41, buffer.readFloatBE(0));
ASSERT.equal(-Infinity, buffer.readFloat(0, false)); ASSERT.equal(-Infinity, buffer.readFloatLE(0));
} }

68
test/simple/test-readint.js
View File

@ -10,39 +10,34 @@ function test8() {
var data = new Buffer(4); var data = new Buffer(4);
data[0] = 0x23; data[0] = 0x23;
ASSERT.equal(0x23, data.readInt8(0, true)); ASSERT.equal(0x23, data.readInt8(0));
ASSERT.equal(0x23, data.readInt8(0, false));
data[0] = 0xff; data[0] = 0xff;
ASSERT.equal(-1, data.readInt8(0, true)); ASSERT.equal(-1, data.readInt8(0));
ASSERT.equal(-1, data.readInt8(0, false));
data[0] = 0x87; data[0] = 0x87;
data[1] = 0xab; data[1] = 0xab;
data[2] = 0x7c; data[2] = 0x7c;
data[3] = 0xef; data[3] = 0xef;
ASSERT.equal(-121, data.readInt8(0, true)); ASSERT.equal(-121, data.readInt8(0));
ASSERT.equal(-85, data.readInt8(1, true)); ASSERT.equal(-85, data.readInt8(1));
ASSERT.equal(124, data.readInt8(2, true)); ASSERT.equal(124, data.readInt8(2));
ASSERT.equal(-17, data.readInt8(3, true)); ASSERT.equal(-17, data.readInt8(3));
ASSERT.equal(-121, data.readInt8(0, false));
ASSERT.equal(-85, data.readInt8(1, false));
ASSERT.equal(124, data.readInt8(2, false));
ASSERT.equal(-17, data.readInt8(3, false));
} }
function test16() { function test16() {
var buffer = new Buffer(6); var buffer = new Buffer(6);
buffer[0] = 0x16; buffer[0] = 0x16;
buffer[1] = 0x79; buffer[1] = 0x79;
ASSERT.equal(0x1679, buffer.readInt16(0, true)); ASSERT.equal(0x1679, buffer.readInt16BE(0));
ASSERT.equal(0x7916, buffer.readInt16(0, false)); ASSERT.equal(0x7916, buffer.readInt16LE(0));
buffer[0] = 0xff; buffer[0] = 0xff;
buffer[1] = 0x80; buffer[1] = 0x80;
ASSERT.equal(-128, buffer.readInt16(0, true)); ASSERT.equal(-128, buffer.readInt16BE(0));
ASSERT.equal(-32513, buffer.readInt16(0, false)); ASSERT.equal(-32513, buffer.readInt16LE(0));
/* test offset with weenix */ /* test offset with weenix */
buffer[0] = 0x77; buffer[0] = 0x77;
@ -51,34 +46,35 @@ function test16() {
buffer[3] = 0x6e; buffer[3] = 0x6e;
buffer[4] = 0x69; buffer[4] = 0x69;
buffer[5] = 0x78; buffer[5] = 0x78;
ASSERT.equal(0x7765, buffer.readInt16(0, true)); ASSERT.equal(0x7765, buffer.readInt16BE(0));
ASSERT.equal(0x6565, buffer.readInt16(1, true)); ASSERT.equal(0x6565, buffer.readInt16BE(1));
ASSERT.equal(0x656e, buffer.readInt16(2, true)); ASSERT.equal(0x656e, buffer.readInt16BE(2));
ASSERT.equal(0x6e69, buffer.readInt16(3, true)); ASSERT.equal(0x6e69, buffer.readInt16BE(3));
ASSERT.equal(0x6978, buffer.readInt16(4, true)); ASSERT.equal(0x6978, buffer.readInt16BE(4));
ASSERT.equal(0x6577, buffer.readInt16(0, false)); ASSERT.equal(0x6577, buffer.readInt16LE(0));
ASSERT.equal(0x6565, buffer.readInt16(1, false)); ASSERT.equal(0x6565, buffer.readInt16LE(1));
ASSERT.equal(0x6e65, buffer.readInt16(2, false)); ASSERT.equal(0x6e65, buffer.readInt16LE(2));
ASSERT.equal(0x696e, buffer.readInt16(3, false)); ASSERT.equal(0x696e, buffer.readInt16LE(3));
ASSERT.equal(0x7869, buffer.readInt16(4, false)); ASSERT.equal(0x7869, buffer.readInt16LE(4));
} }
function test32() { function test32() {
var buffer = new Buffer(6); var buffer = new Buffer(6);
buffer[0] = 0x43; buffer[0] = 0x43;
buffer[1] = 0x53; buffer[1] = 0x53;
buffer[2] = 0x16; buffer[2] = 0x16;
buffer[3] = 0x79; buffer[3] = 0x79;
ASSERT.equal(0x43531679, buffer.readInt32(0, true)); ASSERT.equal(0x43531679, buffer.readInt32BE(0));
ASSERT.equal(0x79165343, buffer.readInt32(0, false)); ASSERT.equal(0x79165343, buffer.readInt32LE(0));
buffer[0] = 0xff; buffer[0] = 0xff;
buffer[1] = 0xfe; buffer[1] = 0xfe;
buffer[2] = 0xef; buffer[2] = 0xef;
buffer[3] = 0xfa; buffer[3] = 0xfa;
ASSERT.equal(-69638, buffer.readInt32(0, true)); ASSERT.equal(-69638, buffer.readInt32BE(0));
ASSERT.equal(-84934913, buffer.readInt32(0, false)); ASSERT.equal(-84934913, buffer.readInt32LE(0));
buffer[0] = 0x42; buffer[0] = 0x42;
buffer[1] = 0xc3; buffer[1] = 0xc3;
@ -86,12 +82,12 @@ function test32() {
buffer[3] = 0xa9; buffer[3] = 0xa9;
buffer[4] = 0x36; buffer[4] = 0x36;
buffer[5] = 0x17; buffer[5] = 0x17;
ASSERT.equal(0x42c395a9, buffer.readInt32(0, true)); ASSERT.equal(0x42c395a9, buffer.readInt32BE(0));
ASSERT.equal(-1013601994, buffer.readInt32(1, true)); ASSERT.equal(-1013601994, buffer.readInt32BE(1));
ASSERT.equal(-1784072681, buffer.readInt32(2, true)); ASSERT.equal(-1784072681, buffer.readInt32BE(2));
ASSERT.equal(-1449802942, buffer.readInt32(0, false)); ASSERT.equal(-1449802942, buffer.readInt32LE(0));
ASSERT.equal(917083587, buffer.readInt32(1, false)); ASSERT.equal(917083587, buffer.readInt32LE(1));
ASSERT.equal(389458325, buffer.readInt32(2, false)); ASSERT.equal(389458325, buffer.readInt32LE(2));
} }

51
test/simple/test-readuint.js
View File

@ -13,21 +13,18 @@ var ASSERT = require('assert');
*/ */
function test8() { function test8() {
var data = new Buffer(4); var data = new Buffer(4);
data[0] = 23; data[0] = 23;
data[1] = 23; data[1] = 23;
data[2] = 23; data[2] = 23;
data[3] = 23; data[3] = 23;
ASSERT.equal(23, data.readUInt8(0, true)); ASSERT.equal(23, data.readUInt8(0));
ASSERT.equal(23, data.readUInt8(0, false)); ASSERT.equal(23, data.readUInt8(1));
ASSERT.equal(23, data.readUInt8(1, true)); ASSERT.equal(23, data.readUInt8(2));
ASSERT.equal(23, data.readUInt8(1, false)); ASSERT.equal(23, data.readUInt8(3));
ASSERT.equal(23, data.readUInt8(2, true));
ASSERT.equal(23, data.readUInt8(2, false));
ASSERT.equal(23, data.readUInt8(3, true));
ASSERT.equal(23, data.readUInt8(3, false));
data[0] = 255; /* If it became a signed int, would be -1 */ data[0] = 255; /* If it became a signed int, would be -1 */
ASSERT.equal(255, data.readUInt8(0, true)); ASSERT.equal(255, data.readUInt8(0));
ASSERT.equal(255, data.readUInt8(0, false));
} }
@ -46,20 +43,17 @@ function test16() {
data[1] = 0x23; data[1] = 0x23;
data[2] = 0x42; data[2] = 0x42;
data[3] = 0x3f; data[3] = 0x3f;
ASSERT.equal(0x23, data.readUInt16BE(0));
ASSERT.equal(0x23, data.readUInt16(0, true)); ASSERT.equal(0x2342, data.readUInt16BE(1));
ASSERT.equal(0x2342, data.readUInt16(1, true)); ASSERT.equal(0x423f, data.readUInt16BE(2));
ASSERT.equal(0x423f, data.readUInt16(2, true)); ASSERT.equal(0x2300, data.readUInt16LE(0));
ASSERT.equal(0x4223, data.readUInt16LE(1));
ASSERT.equal(0x2300, data.readUInt16(0, false)); ASSERT.equal(0x3f42, data.readUInt16LE(2));
ASSERT.equal(0x4223, data.readUInt16(1, false));
ASSERT.equal(0x3f42, data.readUInt16(2, false));
data[0] = 0xfe; data[0] = 0xfe;
data[1] = 0xfe; data[1] = 0xfe;
ASSERT.equal(0xfefe, data.readUInt16BE(0));
ASSERT.equal(0xfefe, data.readUInt16(0, true)); ASSERT.equal(0xfefe, data.readUInt16LE(0));
ASSERT.equal(0xfefe, data.readUInt16(0, false));
} }
@ -72,20 +66,19 @@ function test16() {
*/ */
function test32() { function test32() {
var data = new Buffer(8); var data = new Buffer(8);
data[0] = 0x32; data[0] = 0x32;
data[1] = 0x65; data[1] = 0x65;
data[2] = 0x42; data[2] = 0x42;
data[3] = 0x56; data[3] = 0x56;
data[4] = 0x23; data[4] = 0x23;
data[5] = 0xff; data[5] = 0xff;
ASSERT.equal(0x32654256, data.readUInt32BE(0));
ASSERT.equal(0x32654256, data.readUInt32(0, true)); ASSERT.equal(0x65425623, data.readUInt32BE(1));
ASSERT.equal(0x65425623, data.readUInt32(1, true)); ASSERT.equal(0x425623ff, data.readUInt32BE(2));
ASSERT.equal(0x425623ff, data.readUInt32(2, true)); ASSERT.equal(0x56426532, data.readUInt32LE(0));
ASSERT.equal(0x23564265, data.readUInt32LE(1));
ASSERT.equal(0x56426532, data.readUInt32(0, false)); ASSERT.equal(0xff235642, data.readUInt32LE(2));
ASSERT.equal(0x23564265, data.readUInt32(1, false));
ASSERT.equal(0xff235642, data.readUInt32(2, false));
} }

21
test/simple/test-writedouble.js
View File

@ -5,8 +5,9 @@ var ASSERT = require('assert');
function test() { function test() {
var buffer = new Buffer(16); var buffer = new Buffer(16);
buffer.writeDouble(2.225073858507201e-308, 0, true);
buffer.writeDouble(2.225073858507201e-308, 8, false); buffer.writeDoubleBE(2.225073858507201e-308, 0);
buffer.writeDoubleLE(2.225073858507201e-308, 8);
ASSERT.equal(0x00, buffer[0]); ASSERT.equal(0x00, buffer[0]);
ASSERT.equal(0x0f, buffer[1]); ASSERT.equal(0x0f, buffer[1]);
ASSERT.equal(0xff, buffer[2]); ASSERT.equal(0xff, buffer[2]);
@ -24,8 +25,8 @@ function test() {
ASSERT.equal(0x0f, buffer[14]); ASSERT.equal(0x0f, buffer[14]);
ASSERT.equal(0x00, buffer[15]); ASSERT.equal(0x00, buffer[15]);
buffer.writeDouble(1.0000000000000004, 0, true); buffer.writeDoubleBE(1.0000000000000004, 0);
buffer.writeDouble(1.0000000000000004, 8, false); buffer.writeDoubleLE(1.0000000000000004, 8);
ASSERT.equal(0x3f, buffer[0]); ASSERT.equal(0x3f, buffer[0]);
ASSERT.equal(0xf0, buffer[1]); ASSERT.equal(0xf0, buffer[1]);
ASSERT.equal(0x00, buffer[2]); ASSERT.equal(0x00, buffer[2]);
@ -43,8 +44,8 @@ function test() {
ASSERT.equal(0xf0, buffer[14]); ASSERT.equal(0xf0, buffer[14]);
ASSERT.equal(0x3f, buffer[15]); ASSERT.equal(0x3f, buffer[15]);
buffer.writeDouble(-2, 0, true); buffer.writeDoubleBE(-2, 0);
buffer.writeDouble(-2, 8, false); buffer.writeDoubleLE(-2, 8);
ASSERT.equal(0xc0, buffer[0]); ASSERT.equal(0xc0, buffer[0]);
ASSERT.equal(0x00, buffer[1]); ASSERT.equal(0x00, buffer[1]);
ASSERT.equal(0x00, buffer[2]); ASSERT.equal(0x00, buffer[2]);
@ -62,8 +63,8 @@ function test() {
ASSERT.equal(0x00, buffer[14]); ASSERT.equal(0x00, buffer[14]);
ASSERT.equal(0xc0, buffer[15]); ASSERT.equal(0xc0, buffer[15]);
buffer.writeDouble(1.7976931348623157e+308, 0, true); buffer.writeDoubleBE(1.7976931348623157e+308, 0);
buffer.writeDouble(1.7976931348623157e+308, 8, false); buffer.writeDoubleLE(1.7976931348623157e+308, 8);
ASSERT.equal(0x7f, buffer[0]); ASSERT.equal(0x7f, buffer[0]);
ASSERT.equal(0xef, buffer[1]); ASSERT.equal(0xef, buffer[1]);
ASSERT.equal(0xff, buffer[2]); ASSERT.equal(0xff, buffer[2]);
@ -81,8 +82,8 @@ function test() {
ASSERT.equal(0xef, buffer[14]); ASSERT.equal(0xef, buffer[14]);
ASSERT.equal(0x7f, buffer[15]); ASSERT.equal(0x7f, buffer[15]);
buffer.writeDouble(0*-1, 0, true); buffer.writeDoubleBE(0*-1, 0);
buffer.writeDouble(0*-1, 8, false); buffer.writeDoubleLE(0*-1, 8);
ASSERT.equal(0x80, buffer[0]); ASSERT.equal(0x80, buffer[0]);
ASSERT.equal(0x00, buffer[1]); ASSERT.equal(0x00, buffer[1]);
ASSERT.equal(0x00, buffer[2]); ASSERT.equal(0x00, buffer[2]);

21
test/simple/test-writefloat.js
View File

@ -5,8 +5,9 @@ var ASSERT = require('assert');
function test() { function test() {
var buffer = new Buffer(8); var buffer = new Buffer(8);
buffer.writeFloat(1, 0, true);
buffer.writeFloat(1, 4, false); buffer.writeFloatBE(1, 0);
buffer.writeFloatLE(1, 4);
ASSERT.equal(0x3f, buffer[0]); ASSERT.equal(0x3f, buffer[0]);
ASSERT.equal(0x80, buffer[1]); ASSERT.equal(0x80, buffer[1]);
ASSERT.equal(0x00, buffer[2]); ASSERT.equal(0x00, buffer[2]);
@ -16,8 +17,8 @@ function test() {
ASSERT.equal(0x80, buffer[6]); ASSERT.equal(0x80, buffer[6]);
ASSERT.equal(0x3f, buffer[7]); ASSERT.equal(0x3f, buffer[7]);
buffer.writeFloat(1.793662034335766e-43, 0, true); buffer.writeFloatBE(1.793662034335766e-43, 0);
buffer.writeFloat(1.793662034335766e-43, 4, false); buffer.writeFloatLE(1.793662034335766e-43, 4);
ASSERT.equal(0x00, buffer[0]); ASSERT.equal(0x00, buffer[0]);
ASSERT.equal(0x00, buffer[1]); ASSERT.equal(0x00, buffer[1]);
ASSERT.equal(0x00, buffer[2]); ASSERT.equal(0x00, buffer[2]);
@ -27,8 +28,8 @@ function test() {
ASSERT.equal(0x00, buffer[6]); ASSERT.equal(0x00, buffer[6]);
ASSERT.equal(0x00, buffer[7]); ASSERT.equal(0x00, buffer[7]);
buffer.writeFloat(1/3, 0, true); buffer.writeFloatBE(1/3, 0);
buffer.writeFloat(1/3, 4, false); buffer.writeFloatLE(1/3, 4);
ASSERT.equal(0x3e, buffer[0]); ASSERT.equal(0x3e, buffer[0]);
ASSERT.equal(0xaa, buffer[1]); ASSERT.equal(0xaa, buffer[1]);
ASSERT.equal(0xaa, buffer[2]); ASSERT.equal(0xaa, buffer[2]);
@ -38,8 +39,8 @@ function test() {
ASSERT.equal(0xaa, buffer[6]); ASSERT.equal(0xaa, buffer[6]);
ASSERT.equal(0x3e, buffer[7]); ASSERT.equal(0x3e, buffer[7]);
buffer.writeFloat(3.4028234663852886e+38, 0, true); buffer.writeFloatBE(3.4028234663852886e+38, 0);
buffer.writeFloat(3.4028234663852886e+38, 4, false); buffer.writeFloatLE(3.4028234663852886e+38, 4);
ASSERT.equal(0x7f, buffer[0]); ASSERT.equal(0x7f, buffer[0]);
ASSERT.equal(0x7f, buffer[1]); ASSERT.equal(0x7f, buffer[1]);
ASSERT.equal(0xff, buffer[2]); ASSERT.equal(0xff, buffer[2]);
@ -49,8 +50,8 @@ function test() {
ASSERT.equal(0x7f, buffer[6]); ASSERT.equal(0x7f, buffer[6]);
ASSERT.equal(0x7f, buffer[7]); ASSERT.equal(0x7f, buffer[7]);
buffer.writeFloat(0*-1, 0, true); buffer.writeFloatBE(0*-1, 0);
buffer.writeFloat(0*-1, 4, false); buffer.writeFloatLE(0*-1, 4);
ASSERT.equal(0x80, buffer[0]); ASSERT.equal(0x80, buffer[0]);
ASSERT.equal(0x00, buffer[1]); ASSERT.equal(0x00, buffer[1]);
ASSERT.equal(0x00, buffer[2]); ASSERT.equal(0x00, buffer[2]);

44
test/simple/test-writeint.js
View File

@ -4,44 +4,43 @@
var ASSERT = require('assert'); var ASSERT = require('assert');
function test8() { function test8() {
var buffer = new Buffer(4); var buffer = new Buffer(2);
buffer.writeInt8(0x23, 0, true);
buffer.writeInt8(0x23, 1, false); buffer.writeInt8(0x23, 0);
buffer.writeInt8(-5, 2, true); buffer.writeInt8(-5, 1);
buffer.writeInt8(-5, 3, false);
ASSERT.equal(0x23, buffer[0]); ASSERT.equal(0x23, buffer[0]);
ASSERT.equal(0x23, buffer[1]); ASSERT.equal(0xfb, buffer[1]);
ASSERT.equal(0xfb, buffer[2]);
ASSERT.equal(0xfb, buffer[3]);
/* Make sure we handle truncation correctly */ /* Make sure we handle truncation correctly */
ASSERT.throws(function() { ASSERT.throws(function() {
buffer.writeInt8(0xabc, 0, true); buffer.writeInt8(0xabc, 0);
}); });
ASSERT.throws(function() { ASSERT.throws(function() {
buffer.writeInt8(0xabc, 0, false); buffer.writeInt8(0xabc, 0);
}); });
} }
function test16() { function test16() {
var buffer = new Buffer(6); var buffer = new Buffer(6);
buffer.writeInt16(0x0023, 0, true);
buffer.writeInt16(0x0023, 2, false); buffer.writeInt16BE(0x0023, 0);
buffer.writeInt16LE(0x0023, 2);
ASSERT.equal(0x00, buffer[0]); ASSERT.equal(0x00, buffer[0]);
ASSERT.equal(0x23, buffer[1]); ASSERT.equal(0x23, buffer[1]);
ASSERT.equal(0x23, buffer[2]); ASSERT.equal(0x23, buffer[2]);
ASSERT.equal(0x00, buffer[3]); ASSERT.equal(0x00, buffer[3]);
buffer.writeInt16(-5, 0, true);
buffer.writeInt16(-5, 2, false); buffer.writeInt16BE(-5, 0);
buffer.writeInt16LE(-5, 2);
ASSERT.equal(0xff, buffer[0]); ASSERT.equal(0xff, buffer[0]);
ASSERT.equal(0xfb, buffer[1]); ASSERT.equal(0xfb, buffer[1]);
ASSERT.equal(0xfb, buffer[2]); ASSERT.equal(0xfb, buffer[2]);
ASSERT.equal(0xff, buffer[3]); ASSERT.equal(0xff, buffer[3]);
buffer.writeInt16(-1679, 1, true); buffer.writeInt16BE(-1679, 1);
buffer.writeInt16(-1679, 3, false); buffer.writeInt16LE(-1679, 3);
ASSERT.equal(0xf9, buffer[1]); ASSERT.equal(0xf9, buffer[1]);
ASSERT.equal(0x71, buffer[2]); ASSERT.equal(0x71, buffer[2]);
ASSERT.equal(0x71, buffer[3]); ASSERT.equal(0x71, buffer[3]);
@ -51,8 +50,9 @@ function test16() {
function test32() { function test32() {
var buffer = new Buffer(8); var buffer = new Buffer(8);
buffer.writeInt32(0x23, 0, true);
buffer.writeInt32(0x23, 4, false); buffer.writeInt32BE(0x23, 0);
buffer.writeInt32LE(0x23, 4);
ASSERT.equal(0x00, buffer[0]); ASSERT.equal(0x00, buffer[0]);
ASSERT.equal(0x00, buffer[1]); ASSERT.equal(0x00, buffer[1]);
ASSERT.equal(0x00, buffer[2]); ASSERT.equal(0x00, buffer[2]);
@ -62,8 +62,8 @@ function test32() {
ASSERT.equal(0x00, buffer[6]); ASSERT.equal(0x00, buffer[6]);
ASSERT.equal(0x00, buffer[7]); ASSERT.equal(0x00, buffer[7]);
buffer.writeInt32(-5, 0, true); buffer.writeInt32BE(-5, 0);
buffer.writeInt32(-5, 4, false); buffer.writeInt32LE(-5, 4);
ASSERT.equal(0xff, buffer[0]); ASSERT.equal(0xff, buffer[0]);
ASSERT.equal(0xff, buffer[1]); ASSERT.equal(0xff, buffer[1]);
ASSERT.equal(0xff, buffer[2]); ASSERT.equal(0xff, buffer[2]);
@ -73,8 +73,8 @@ function test32() {
ASSERT.equal(0xff, buffer[6]); ASSERT.equal(0xff, buffer[6]);
ASSERT.equal(0xff, buffer[7]); ASSERT.equal(0xff, buffer[7]);
buffer.writeInt32(-805306713, 0, true); buffer.writeInt32BE(-805306713, 0);
buffer.writeInt32(-805306713, 4, false); buffer.writeInt32LE(-805306713, 4);
ASSERT.equal(0xcf, buffer[0]); ASSERT.equal(0xcf, buffer[0]);
ASSERT.equal(0xff, buffer[1]); ASSERT.equal(0xff, buffer[1]);
ASSERT.equal(0xfe, buffer[2]); ASSERT.equal(0xfe, buffer[2]);

55
test/simple/test-writeuint.js
View File

@ -12,25 +12,29 @@ var ASSERT = require('assert');
*/ */
function test8() { function test8() {
var data = new Buffer(4); var data = new Buffer(4);
data.writeUInt8(23, 0, true);
data.writeUInt8(23, 1, true); data.writeUInt8(23, 0);
data.writeUInt8(23, 2, true); data.writeUInt8(23, 1);
data.writeUInt8(23, 3, true); data.writeUInt8(23, 2);
data.writeUInt8(23, 3);
ASSERT.equal(23, data[0]); ASSERT.equal(23, data[0]);
ASSERT.equal(23, data[1]); ASSERT.equal(23, data[1]);
ASSERT.equal(23, data[2]); ASSERT.equal(23, data[2]);
ASSERT.equal(23, data[3]); ASSERT.equal(23, data[3]);
data.writeUInt8(23, 0, false);
data.writeUInt8(23, 1, false); data.writeUInt8(23, 0);
data.writeUInt8(23, 2, false); data.writeUInt8(23, 1);
data.writeUInt8(23, 3, false); data.writeUInt8(23, 2);
data.writeUInt8(23, 3);
ASSERT.equal(23, data[0]); ASSERT.equal(23, data[0]);
ASSERT.equal(23, data[1]); ASSERT.equal(23, data[1]);
ASSERT.equal(23, data[2]); ASSERT.equal(23, data[2]);
ASSERT.equal(23, data[3]); ASSERT.equal(23, data[3]);
data.writeUInt8(255, 0, true);
data.writeUInt8(255, 0);
ASSERT.equal(255, data[0]); ASSERT.equal(255, data[0]);
data.writeUInt8(255, 0, false);
data.writeUInt8(255, 0);
ASSERT.equal(255, data[0]); ASSERT.equal(255, data[0]);
} }
@ -38,34 +42,37 @@ function test8() {
function test16() { function test16() {
var value = 0x2343; var value = 0x2343;
var data = new Buffer(4); var data = new Buffer(4);
data.writeUInt16(value, 0, true);
data.writeUInt16BE(value, 0);
ASSERT.equal(0x23, data[0]); ASSERT.equal(0x23, data[0]);
ASSERT.equal(0x43, data[1]); ASSERT.equal(0x43, data[1]);
data.writeUInt16(value, 1, true);
data.writeUInt16BE(value, 1);
ASSERT.equal(0x23, data[1]); ASSERT.equal(0x23, data[1]);
ASSERT.equal(0x43, data[2]); ASSERT.equal(0x43, data[2]);
data.writeUInt16(value, 2, true);
data.writeUInt16BE(value, 2);
ASSERT.equal(0x23, data[2]); ASSERT.equal(0x23, data[2]);
ASSERT.equal(0x43, data[3]); ASSERT.equal(0x43, data[3]);
data.writeUInt16(value, 0, false); data.writeUInt16LE(value, 0);
ASSERT.equal(0x23, data[1]); ASSERT.equal(0x23, data[1]);
ASSERT.equal(0x43, data[0]); ASSERT.equal(0x43, data[0]);
data.writeUInt16(value, 1, false); data.writeUInt16LE(value, 1);
ASSERT.equal(0x23, data[2]); ASSERT.equal(0x23, data[2]);
ASSERT.equal(0x43, data[1]); ASSERT.equal(0x43, data[1]);
data.writeUInt16(value, 2, false); data.writeUInt16LE(value, 2);
ASSERT.equal(0x23, data[3]); ASSERT.equal(0x23, data[3]);
ASSERT.equal(0x43, data[2]); ASSERT.equal(0x43, data[2]);
value = 0xff80; value = 0xff80;
data.writeUInt16(value, 0, false); data.writeUInt16LE(value, 0);
ASSERT.equal(0xff, data[1]); ASSERT.equal(0xff, data[1]);
ASSERT.equal(0x80, data[0]); ASSERT.equal(0x80, data[0]);
data.writeUInt16(value, 0, true); data.writeUInt16BE(value, 0);
ASSERT.equal(0xff, data[0]); ASSERT.equal(0xff, data[0]);
ASSERT.equal(0x80, data[1]); ASSERT.equal(0x80, data[1]);
} }
@ -75,37 +82,37 @@ function test32() {
var data = new Buffer(6); var data = new Buffer(6);
var value = 0xe7f90a6d; var value = 0xe7f90a6d;
data.writeUInt32(value, 0, true); data.writeUInt32BE(value, 0);
ASSERT.equal(0xe7, data[0]); ASSERT.equal(0xe7, data[0]);
ASSERT.equal(0xf9, data[1]); ASSERT.equal(0xf9, data[1]);
ASSERT.equal(0x0a, data[2]); ASSERT.equal(0x0a, data[2]);
ASSERT.equal(0x6d, data[3]); ASSERT.equal(0x6d, data[3]);
data.writeUInt32(value, 1, true); data.writeUInt32BE(value, 1);
ASSERT.equal(0xe7, data[1]); ASSERT.equal(0xe7, data[1]);
ASSERT.equal(0xf9, data[2]); ASSERT.equal(0xf9, data[2]);
ASSERT.equal(0x0a, data[3]); ASSERT.equal(0x0a, data[3]);
ASSERT.equal(0x6d, data[4]); ASSERT.equal(0x6d, data[4]);
data.writeUInt32(value, 2, true); data.writeUInt32BE(value, 2);
ASSERT.equal(0xe7, data[2]); ASSERT.equal(0xe7, data[2]);
ASSERT.equal(0xf9, data[3]); ASSERT.equal(0xf9, data[3]);
ASSERT.equal(0x0a, data[4]); ASSERT.equal(0x0a, data[4]);
ASSERT.equal(0x6d, data[5]); ASSERT.equal(0x6d, data[5]);
data.writeUInt32(value, 0, false); data.writeUInt32LE(value, 0);
ASSERT.equal(0xe7, data[3]); ASSERT.equal(0xe7, data[3]);
ASSERT.equal(0xf9, data[2]); ASSERT.equal(0xf9, data[2]);
ASSERT.equal(0x0a, data[1]); ASSERT.equal(0x0a, data[1]);
ASSERT.equal(0x6d, data[0]); ASSERT.equal(0x6d, data[0]);
data.writeUInt32(value, 1, false); data.writeUInt32LE(value, 1);
ASSERT.equal(0xe7, data[4]); ASSERT.equal(0xe7, data[4]);
ASSERT.equal(0xf9, data[3]); ASSERT.equal(0xf9, data[3]);
ASSERT.equal(0x0a, data[2]); ASSERT.equal(0x0a, data[2]);
ASSERT.equal(0x6d, data[1]); ASSERT.equal(0x6d, data[1]);
data.writeUInt32(value, 2, false); data.writeUInt32LE(value, 2);
ASSERT.equal(0xe7, data[5]); ASSERT.equal(0xe7, data[5]);
ASSERT.equal(0xf9, data[4]); ASSERT.equal(0xf9, data[4]);
ASSERT.equal(0x0a, data[3]); ASSERT.equal(0x0a, data[3]);

Write Preview
Loading…
Cancel
Save