How to use buffer - 10 common examples

To help you get started, we’ve selected a few buffer examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

nrkno / tv-automation-atem-connection / src / lib / __tests__ / atemSocket.spec.ts View on Github

socket.on('error', error)
		socket.on('commandReceived', change)

		const parser = (socket as any)._commandParser as CommandParser
		expect(parser).toBeTruthy()
		const parserSpy = jest.spyOn(parser, 'commandFromRawName')
		expect(parser.version).toEqual(ProtocolVersion.V7_2) // Default

		const expectedCmd1 = new ProgramInputUpdateCommand(0, { source: 0x0123 })
		const expectedCmd2 = new PreviewInputUpdateCommand(1, { source: 0x0444 })

		const testCmd1 = Buffer.from([0, 12, 0, 0, ...Buffer.from(ProgramInputUpdateCommand.rawName, 'ascii'), 0x00, 0x00, 0x01, 0x23])
		const testCmd2 = Buffer.from([0, 12, 0, 0, ...Buffer.from(PreviewInputUpdateCommand.rawName, 'ascii'), 0x01, 0x00, 0x04, 0x44])
		const pktId = 822
		expect(AtemSocketChildSingleton.onCommandReceived).toBeDefined()
		await AtemSocketChildSingleton.onCommandReceived!(Buffer.concat([testCmd1, testCmd2]), pktId)
		await clock.tickAsync(0)

		expect(connect).toHaveBeenCalledTimes(0)
		expect(error).toHaveBeenCalledTimes(0)
		expect(change).toHaveBeenCalledTimes(2)

		expect(parserSpy).toHaveBeenCalledTimes(2)
		expect(parserSpy).toHaveBeenCalledWith(ProgramInputUpdateCommand.rawName)
		expect(parserSpy).toHaveBeenCalledWith(PreviewInputUpdateCommand.rawName)

		// A change with the command
		expect(change).toHaveBeenCalledWith(expectedCmd1)
		expect(change).toHaveBeenCalledWith(expectedCmd2)
	})
	test('receive - empty buffer', async () => {

graalvm / graaljs / test / simple / test-buffer.js View on Github

expected.slice(240, 300) + '\x03' +
                      expected.slice(300, 360);
b = new Buffer(expectedIllegal, 'base64');
assert.equal(quote.length, b.length);
assert.equal(quote, b.toString('ascii', 0, quote.length));


assert.equal(new Buffer('', 'base64').toString(), '');
assert.equal(new Buffer('K', 'base64').toString(), '');

// multiple-of-4 with padding
assert.equal(new Buffer('Kg==', 'base64').toString(), '*');
assert.equal(new Buffer('Kio=', 'base64').toString(), '**');
assert.equal(new Buffer('Kioq', 'base64').toString(), '***');
assert.equal(new Buffer('KioqKg==', 'base64').toString(), '****');
assert.equal(new Buffer('KioqKio=', 'base64').toString(), '*****');
assert.equal(new Buffer('KioqKioq', 'base64').toString(), '******');
assert.equal(new Buffer('KioqKioqKg==', 'base64').toString(), '*******');
assert.equal(new Buffer('KioqKioqKio=', 'base64').toString(), '********');
assert.equal(new Buffer('KioqKioqKioq', 'base64').toString(), '*********');
assert.equal(new Buffer('KioqKioqKioqKg==', 'base64').toString(),
             '**********');
assert.equal(new Buffer('KioqKioqKioqKio=', 'base64').toString(),
             '***********');
assert.equal(new Buffer('KioqKioqKioqKioq', 'base64').toString(),
             '************');
assert.equal(new Buffer('KioqKioqKioqKioqKg==', 'base64').toString(),
             '*************');
assert.equal(new Buffer('KioqKioqKioqKioqKio=', 'base64').toString(),
             '**************');
assert.equal(new Buffer('KioqKioqKioqKioqKioq', 'base64').toString(),
             '***************');

DefinitelyTyped / DefinitelyTyped / types / uws / uws-tests.ts View on Github

}).on('end', () => {
            res.end('You posted me this: ' + Buffer.concat(body).toString());
        });
        // handle some GET url

bnoguchi / redis-node / test / string_commands.vows.js View on Github

'should return the entire image': function (err, value) {
                var paths = [ "sample.png", "test/sample.png" ],
                    path = paths.shift();
                while (true) {
                  try {
                    var fileContents = fs.readFileSync(path, 'binary');
                    break;
                  } catch (e) {
                    path = paths.shift();
                  }
                }
                var imageBuffer = new Buffer(Buffer.byteLength(fileContents, 'binary'));
                imageBuffer.write(fileContents, 0, "binary");

                // TODO Make value binary a Buffer vs the current binary string?
                assert.equal(value, imageBuffer.toString("binary"));
            }
        }

node-app / Nodelike / Nodelike Tests / package / test-buffer.js View on Github

(function() {
  var buf = new Buffer('0123456789');
  assert.equal(buf.slice(-10, 10), '0123456789');
  assert.equal(buf.slice(-20, 10), '0123456789');
  assert.equal(buf.slice(-20, -10), '');
  assert.equal(buf.slice(0, -1), '012345678');
  assert.equal(buf.slice(2, -2), '234567');
  assert.equal(buf.slice(0, 65536), '0123456789');
  assert.equal(buf.slice(65536, 0), '');
  for (var i = 0, s = buf.toString(); i &lt; buf.length; ++i) {
    assert.equal(buf.slice(-i), s.slice(-i));
    assert.equal(buf.slice(0, -i), s.slice(0, -i));
  }
  // try to slice a zero length Buffer
  // see https://github.com/joyent/node/issues/5881
  SlowBuffer(0).slice(0, 1);
  // make sure a zero length slice doesn't set the .parent attribute
  assert.equal(Buffer(5).slice(0,0).parent, undefined);
  // and make sure a proper slice does have a parent
  assert.ok(typeof Buffer(5).slice(0, 5).parent === 'object');
})();

nodejs / abi-stable-node / test / parallel / test-buffer-slow.js View on Github

assert.strictEqual(sb.buffer.byteLength, 4);

// should work without new
sb = SlowBuffer(4);
assert(sb instanceof Buffer);
assert.strictEqual(sb.length, 4);
sb.fill(1);
for (const [key, value] of sb.entries()) {
  assert.deepStrictEqual(value, ones[key]);
}

// should work with edge cases
assert.strictEqual(SlowBuffer(0).length, 0);
try {
  assert.strictEqual(
    SlowBuffer(buffer.kMaxLength).length, buffer.kMaxLength);
} catch (e) {
  assert.equal(e.message, common.engineSpecificMessage({
    v8: 'Array buffer allocation failed',
    chakracore: 'Invalid offset/length when creating typed array'
  }));
}

// should work with number-coercible values
assert.strictEqual(SlowBuffer('6').length, 6);
assert.strictEqual(SlowBuffer(true).length, 1);

// should create zero-length buffer if parameter is not a number
assert.strictEqual(SlowBuffer().length, 0);
assert.strictEqual(SlowBuffer(NaN).length, 0);
assert.strictEqual(SlowBuffer({}).length, 0);
assert.strictEqual(SlowBuffer('string').length, 0);

mceSystems / node-jsc / test / parallel / test-buffer-over-max-length.js View on Github

'use strict';
const common = require('../common');
const assert = require('assert');

const buffer = require('buffer');
const SlowBuffer = buffer.SlowBuffer;

const kMaxLength = buffer.kMaxLength;
const bufferMaxSizeMsg = common.bufferMaxSizeMsg;

assert.throws(() => Buffer((-1 >>> 0) + 1), bufferMaxSizeMsg);
assert.throws(() => SlowBuffer((-1 >>> 0) + 1), bufferMaxSizeMsg);
assert.throws(() => Buffer.alloc((-1 >>> 0) + 1), bufferMaxSizeMsg);
assert.throws(() => Buffer.allocUnsafe((-1 >>> 0) + 1), bufferMaxSizeMsg);
assert.throws(() => Buffer.allocUnsafeSlow((-1 >>> 0) + 1), bufferMaxSizeMsg);

assert.throws(() => Buffer(kMaxLength + 1), bufferMaxSizeMsg);
assert.throws(() => SlowBuffer(kMaxLength + 1), bufferMaxSizeMsg);
assert.throws(() => Buffer.alloc(kMaxLength + 1), bufferMaxSizeMsg);
assert.throws(() => Buffer.allocUnsafe(kMaxLength + 1), bufferMaxSizeMsg);
assert.throws(() => Buffer.allocUnsafeSlow(kMaxLength + 1), bufferMaxSizeMsg);

// issue GH-4331
assert.throws(() => Buffer.allocUnsafe(0xFFFFFFFF), bufferMaxSizeMsg);

animetosho / ParPar / test / par-compare.js View on Github

in: [tmpDir + 'test64m.bin'],
		blockSize: 1048576,
		blocks: 0,
		singleFile: true
	},
	{
		in: [tmpDir + 'test65k.bin'],
		blockSize: 1048576,
		blocks: 0,
		singleFile: true
	},*/
	
	// 2x large block size test
	{
		in: [tmpDir + 'test64m.bin'],
		blockSize: Math.floor((require('buffer').kMaxLength || (1024*1024*1024-1))/4)*4 - 192, // max allowable buffer size test
		blocks: 1,
		memory: process.arch == 'x64' ? '2.5g' : '1.5g',
		singleFile: true
	},
	{
		in: [tmpDir + 'test64m.bin'],
		blockSize: 4294967296, // 4GB, should exceed node's limit
		blocks: 2,
		memory: '511m',
		singleFile: true
	},
	{ // max number of blocks test
		in: [tmpDir + 'test64m.bin'],
		blockSize: 2048,
		blocks: 32768, // max allowed by par2cmdline; TODO: test w/ 65536
		singleFile: true

graalvm / graaljs / test / parallel / test-icu-transcode.js View on Github

assert.deepStrictEqual(
  buffer.transcode(Buffer.from('hi', 'ascii'), 'ascii', 'utf16le'),
  Buffer.from('hi', 'utf16le'));
assert.deepStrictEqual(
  buffer.transcode(Buffer.from('hi', 'latin1'), 'latin1', 'utf16le'),
  Buffer.from('hi', 'utf16le'));
assert.deepStrictEqual(
  buffer.transcode(Buffer.from('hä', 'latin1'), 'latin1', 'utf16le'),
  Buffer.from('hä', 'utf16le'));

// Test that Uint8Array arguments are okay.
{
  const uint8array = new Uint8Array([...Buffer.from('hä', 'latin1')]);
  assert.deepStrictEqual(
    buffer.transcode(uint8array, 'latin1', 'utf16le'),
    Buffer.from('hä', 'utf16le'));
}

{
  const dest = buffer.transcode(new Uint8Array(), 'utf8', 'latin1');
  assert.strictEqual(dest.length, 0);
}

graalvm / graaljs / test / parallel / test-icu-transcode.js View on Github

buffer.transcode(Buffer.from('hi', 'latin1'), 'latin1', 'utf16le'),
  Buffer.from('hi', 'utf16le'));
assert.deepStrictEqual(
  buffer.transcode(Buffer.from('hä', 'latin1'), 'latin1', 'utf16le'),
  Buffer.from('hä', 'utf16le'));

// Test that Uint8Array arguments are okay.
{
  const uint8array = new Uint8Array([...Buffer.from('hä', 'latin1')]);
  assert.deepStrictEqual(
    buffer.transcode(uint8array, 'latin1', 'utf16le'),
    Buffer.from('hä', 'utf16le'));
}

{
  const dest = buffer.transcode(new Uint8Array(), 'utf8', 'latin1');
  assert.strictEqual(dest.length, 0);
}

How to use buffer - 10 common examples

To help you get started, we’ve selected a few buffer examples, based on popular ways it is used in public projects.

buffer

Package Health Score

Popular buffer functions

Similar packages