From 9cfd9fd0c470d8942ca764d1d0e3d0f9b35bc80f Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Sat, 6 Aug 2016 22:32:17 +0300 Subject: [PATCH] lib: add swap64 (was introduced in node 6.3.0) news: https://nodejs.org/en/blog/release/v6.3.0/ PR: https://github.com/nodejs/node/pull/7157 --- index.js | 14 ++++ test/node/test-buffer-swap.js | 136 ++++++++++++++++++++++++++-------- 2 files changed, 121 insertions(+), 29 deletions(-) diff --git a/index.js b/index.js index f04a7dd..e36a5a7 100644 --- a/index.js +++ b/index.js @@ -542,6 +542,20 @@ Buffer.prototype.swap32 = function swap32 () { return this } +Buffer.prototype.swap64 = function swap64 () { + var len = this.length + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits') + } + for (var i = 0; i < len; i += 8) { + swap(this, i, i + 7) + swap(this, i + 1, i + 6) + swap(this, i + 2, i + 5) + swap(this, i + 3, i + 4) + } + return this +} + Buffer.prototype.toString = function toString () { var length = this.length | 0 if (length === 0) return '' diff --git a/test/node/test-buffer-swap.js b/test/node/test-buffer-swap.js index ebb044b..e2e6ec1 100644 --- a/test/node/test-buffer-swap.js +++ b/test/node/test-buffer-swap.js @@ -5,31 +5,28 @@ if (Buffer.TYPED_ARRAY_SUPPORT) return; var assert = require('assert'); -var buf = Buffer.from([0x1, 0x2, 0x3, 0x4]); +// Test buffers small enough to use the JS implementation +const buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]); assert.strictEqual(buf, buf.swap16()); -assert.deepStrictEqual(buf, Buffer.from([0x2, 0x1, 0x4, 0x3])); +assert.deepStrictEqual(buf, Buffer.from([0x02, 0x01, 0x04, 0x03, 0x06, 0x05, + 0x08, 0x07, 0x0a, 0x09, 0x0c, 0x0b, + 0x0e, 0x0d, 0x10, 0x0f])); +buf.swap16(); // restore assert.strictEqual(buf, buf.swap32()); -assert.deepStrictEqual(buf, Buffer.from([0x3, 0x4, 0x1, 0x2])); - -var buf_array = []; -for (var i = 1; i < 33; i++) - buf_array.push(i); -var buf2 = Buffer.from(buf_array); -buf2.swap32(); -assert.deepStrictEqual(buf2, - Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07, 0x06, 0x05, 0x0c, - 0x0b, 0x0a, 0x09, 0x10, 0x0f, 0x0e, 0x0d, 0x14, 0x13, - 0x12, 0x11, 0x18, 0x17, 0x16, 0x15, 0x1c, 0x1b, 0x1a, - 0x19, 0x20, 0x1f, 0x1e, 0x1d])); -buf2.swap16(); -assert.deepStrictEqual(buf2, - Buffer.from([0x03, 0x04, 0x01, 0x02, 0x07, 0x08, 0x05, 0x06, 0x0b, - 0x0c, 0x09, 0x0a, 0x0f, 0x10, 0x0d, 0x0e, 0x13, 0x14, - 0x11, 0x12, 0x17, 0x18, 0x15, 0x16, 0x1b, 0x1c, 0x19, - 0x1a, 0x1f, 0x20, 0x1d, 0x1e])); +assert.deepStrictEqual(buf, Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07, + 0x06, 0x05, 0x0c, 0x0b, 0x0a, 0x09, + 0x10, 0x0f, 0x0e, 0x0d])); +buf.swap32(); // restore +assert.strictEqual(buf, buf.swap64()); +assert.deepStrictEqual(buf, Buffer.from([0x08, 0x07, 0x06, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x10, 0x0f, 0x0e, 0x0d, + 0x0c, 0x0b, 0x0a, 0x09])); + +// Operates in-place var buf3 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]); buf3.slice(1, 5).swap32(); assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x5, 0x4, 0x3, 0x2, 0x6, 0x7])); @@ -37,27 +34,108 @@ assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x5, 0x4, 0x3, 0x2, 0x6, 0x7])); buf3.slice(1, 5).swap16(); assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x4, 0x5, 0x2, 0x3, 0x6, 0x7])); +const buf3_64 = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]); +buf3_64.slice(2, 18).swap64(); +assert.deepStrictEqual(buf3_64, Buffer.from([0x01, 0x02, 0x0a, 0x09, 0x08, 0x07, + 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, + 0x0f, 0x10])); + // Force use of native code (Buffer size above threshold limit for js impl) -var buf4 = Buffer.allocUnsafe(1024).fill([0x1, 0x2, 0x3, 0x4]); -var buf5 = Buffer.allocUnsafe(1024).fill([0x2, 0x1, 0x4, 0x3]); -var buf6 = Buffer.allocUnsafe(1024) - .fill([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]); -var buf7 = Buffer.allocUnsafe(1024) - .fill([0x4, 0x3, 0x2, 0x1, 0x8, 0x7, 0x6, 0x5]); +var buf4A = new Uint32Array(256).fill(0x04030201); +var buf4 = Buffer.from(buf4A.buffer, buf4A.byteOffset); +var buf5A = new Uint32Array(256).fill(0x03040102); +var buf5 = Buffer.from(buf5A.buffer, buf5A.byteOffset); buf4.swap16(); assert.deepStrictEqual(buf4, buf5); +var buf6A = new Uint32Array(256).fill(0x04030201); +var buf6 = Buffer.from(buf6A.buffer); +var bu7A = new Uint32Array(256).fill(0x01020304); +var buf7 = Buffer.from(bu7A.buffer, bu7A.byteOffset); + buf6.swap32(); assert.deepStrictEqual(buf6, buf7); -var re16 = /Buffer size must be a multiple of 16-bits/; -var re32 = /Buffer size must be a multiple of 32-bits/; +var buf8A = new Uint8Array(256 * 8); +var buf9A = new Uint8Array(256 * 8); +for (let i = 0; i < buf8A.length; i++) { + buf8A[i] = i % 8; + buf9A[buf9A.length - i - 1] = i % 8; +} +var buf8 = Buffer.from(buf8A.buffer, buf8A.byteOffset); +var buf9 = Buffer.from(buf9A.buffer, buf9A.byteOffset); + +buf8.swap64(); +assert.deepStrictEqual(buf8, buf9); + +// Test native code with buffers that are not memory-aligned +var buf10A = new Uint8Array(256 * 8); +var buf11A = new Uint8Array(256 * 8 - 2); +for (let i = 0; i < buf10A.length; i++) { + buf10A[i] = i % 2; +} +for (let i = 1; i < buf11A.length; i++) { + buf11A[buf11A.length - i] = (i + 1) % 2; +} +var buf10 = Buffer.from(buf10A.buffer, buf10A.byteOffset); +// 0|1 0|1 0|1... +var buf11 = Buffer.from(buf11A.buffer, buf11A.byteOffset); +// 0|0 1|0 1|0... + +buf10.slice(1, buf10.length - 1).swap16(); +assert.deepStrictEqual(buf10.slice(0, buf11.length), buf11); + + +var buf12A = new Uint8Array(256 * 8); +var buf13A = new Uint8Array(256 * 8 - 4); +for (let i = 0; i < buf12A.length; i++) { + buf12A[i] = i % 4; +} +for (let i = 1; i < buf13A.length; i++) { + buf13A[buf13A.length - i] = (i + 1) % 4; +} +var buf12 = Buffer.from(buf12A.buffer, buf12A.byteOffset); +// 0|1 2 3 0|1 2 3... +var buf13 = Buffer.from(buf13A.buffer, buf13A.byteOffset); +// 0|0 3 2 1|0 3 2... + +buf12.slice(1, buf12.length - 3).swap32(); +assert.deepStrictEqual(buf12.slice(0, buf13.length), buf13); + + +var buf14A = new Uint8Array(256 * 8); +var buf15A = new Uint8Array(256 * 8 - 8); +for (let i = 0; i < buf14A.length; i++) { + buf14A[i] = i % 8; +} +for (let i = 1; i < buf15A.length; i++) { + buf15A[buf15A.length - i] = (i + 1) % 8; +} +var buf14 = Buffer.from(buf14A.buffer, buf14A.byteOffset); +// 0|1 2 3 4 5 6 7 0|1 2 3 4... +var buf15 = Buffer.from(buf15A.buffer, buf15A.byteOffset); +// 0|0 7 6 5 4 3 2 1|0 7 6 5... + +buf14.slice(1, buf14.length - 7).swap64(); +assert.deepStrictEqual(buf14.slice(0, buf15.length), buf15); + +// Length assertions +const re16 = /Buffer size must be a multiple of 16-bits/; +const re32 = /Buffer size must be a multiple of 32-bits/; +const re64 = /Buffer size must be a multiple of 64-bits/; assert.throws(() => Buffer.from(buf3).swap16(), re16); assert.throws(() => Buffer.alloc(1025).swap16(), re16); assert.throws(() => Buffer.from(buf3).swap32(), re32); assert.throws(() => buf3.slice(1, 3).swap32(), re32); assert.throws(() => Buffer.alloc(1025).swap32(), re32); - +assert.throws(() => buf3.slice(1, 3).swap64(), re64); +assert.throws(() => Buffer.alloc(1025).swap64(), re64); -- 2.34.1