Skip to main content
Module

std/node/buffer_test.ts

Deno standard library
Go to Latest
File
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.import { assertEquals, assertThrows } from "../testing/asserts.ts";import "./internal/errors.ts";import { Buffer } from "./buffer.ts";
Deno.test({ name: "alloc fails if size is not a number", fn() { const invalidSizes = [{}, "1", "foo", []];
for (const size of invalidSizes) { assertThrows( () => { // deno-lint-ignore ban-ts-comment // @ts-expect-error Buffer.alloc(size); }, TypeError, '"size" argument must be of type number', "should throw on non-number size", ); } },});
Deno.test({ name: "alloc allocates a buffer with the expected size", fn() { const buffer: Buffer = Buffer.alloc(1); assertEquals(buffer.length, 1, "Buffer size should be 1"); assertEquals(buffer[0], 0, "Content should be filled with 0"); },});
Deno.test({ name: "alloc(0) creates an empty buffer", fn() { const buffer: Buffer = Buffer.alloc(0); assertEquals(buffer.length, 0, "Buffer size should be 0"); },});
Deno.test({ name: "allocUnsafe allocates a buffer with the expected size", fn() { const buffer: Buffer = Buffer.allocUnsafe(1); assertEquals(buffer.length, 1, "Buffer size should be 1"); },});
Deno.test({ name: "allocUnsafe(0) creates an empty buffer", fn() { const buffer: Buffer = Buffer.allocUnsafe(0); assertEquals(buffer.length, 0, "Buffer size should be 0"); },});
Deno.test({ name: "alloc filled correctly with integer", fn() { const buffer: Buffer = Buffer.alloc(3, 5); assertEquals(buffer, new Buffer([5, 5, 5])); },});
Deno.test({ name: "alloc filled correctly with single character", fn() { assertEquals(Buffer.alloc(5, "a"), new Buffer([97, 97, 97, 97, 97])); },});
Deno.test({ name: "alloc filled correctly with base64 string", fn() { assertEquals( Buffer.alloc(11, "aGVsbG8gd29ybGQ=", "base64"), new Buffer([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]), ); },});
Deno.test({ name: "alloc filled correctly with hex string", fn() { assertEquals( Buffer.alloc(4, "64656e6f", "hex"), new Buffer([100, 101, 110, 111]), ); },});
Deno.test({ name: "alloc filled correctly with hex string smaller than alloc size", fn() { assertEquals( Buffer.alloc(13, "64656e6f", "hex").toString(), "denodenodenod", ); },});
Deno.test({ name: "alloc filled correctly with Uint8Array smaller than alloc size", fn() { assertEquals( Buffer.alloc(7, new Uint8Array([100, 101])), new Buffer([100, 101, 100, 101, 100, 101, 100]), ); assertEquals( Buffer.alloc(6, new Uint8Array([100, 101])), new Buffer([100, 101, 100, 101, 100, 101]), ); },});
Deno.test({ name: "alloc filled correctly with Uint8Array bigger than alloc size", fn() { assertEquals( Buffer.alloc(1, new Uint8Array([100, 101])), new Buffer([100]), ); },});
Deno.test({ name: "alloc filled correctly with Buffer", fn() { assertEquals( Buffer.alloc(6, new Buffer([100, 101])), new Buffer([100, 101, 100, 101, 100, 101]), ); assertEquals( Buffer.alloc(7, new Buffer([100, 101])), new Buffer([100, 101, 100, 101, 100, 101, 100]), ); },});
// tests from:// https://github.com/nodejs/node/blob/56dbe466fdbc598baea3bfce289bf52b97b8b8f7/test/parallel/test-buffer-bytelength.js#L70Deno.test({ name: "Byte length is the expected for strings", fn() { // Special case: zero length string assertEquals(Buffer.byteLength("", "ascii"), 0); assertEquals(Buffer.byteLength("", "HeX"), 0);
// utf8 assertEquals(Buffer.byteLength("∑éllö wørl∂!", "utf-8"), 19); assertEquals(Buffer.byteLength("κλμνξο", "utf8"), 12); assertEquals(Buffer.byteLength("挵挶挷挸挹", "utf-8"), 15); assertEquals(Buffer.byteLength("𠝹𠱓𠱸", "UTF8"), 12); // Without an encoding, utf8 should be assumed assertEquals(Buffer.byteLength("hey there"), 9); assertEquals(Buffer.byteLength("𠱸挶νξ#xx :)"), 17); assertEquals(Buffer.byteLength("hello world", ""), 11); // It should also be assumed with unrecognized encoding assertEquals(Buffer.byteLength("hello world", "abc"), 11); assertEquals(Buffer.byteLength("ßœ∑≈", "unkn0wn enc0ding"), 10);
// base64 assertEquals(Buffer.byteLength("aGVsbG8gd29ybGQ=", "base64"), 11); assertEquals(Buffer.byteLength("aGVsbG8gd29ybGQ=", "BASE64"), 11); assertEquals(Buffer.byteLength("bm9kZS5qcyByb2NrcyE=", "base64"), 14); assertEquals(Buffer.byteLength("aGkk", "base64"), 3); assertEquals( Buffer.byteLength("bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==", "base64"), 25, ); // special padding assertEquals(Buffer.byteLength("aaa=", "base64"), 2); assertEquals(Buffer.byteLength("aaaa==", "base64"), 3);
assertEquals(Buffer.byteLength("Il était tué"), 14); assertEquals(Buffer.byteLength("Il était tué", "utf8"), 14);
["ascii", "latin1", "binary"] .reduce((es: string[], e: string) => es.concat(e, e.toUpperCase()), []) .forEach((encoding: string) => { assertEquals(Buffer.byteLength("Il était tué", encoding), 12); });
["ucs2", "ucs-2", "utf16le", "utf-16le"] .reduce((es: string[], e: string) => es.concat(e, e.toUpperCase()), []) .forEach((encoding: string) => { assertEquals(Buffer.byteLength("Il était tué", encoding), 24); }); },});
Deno.test({ name: "Byte length is the expected one for non-strings", fn() { assertEquals( Buffer.byteLength(Buffer.alloc(0)), Buffer.alloc(0).byteLength, "Byte lenght differs on buffers", ); },});
Deno.test({ name: "Two Buffers are concatenated", fn() { const data1 = [1, 2, 3]; const data2 = [4, 5, 6];
const buffer1 = Buffer.from(data1); const buffer2 = Buffer.from(data2);
const resultBuffer = Buffer.concat([buffer1, buffer2]); const expectedBuffer = Buffer.from([...data1, ...data2]); assertEquals(resultBuffer, expectedBuffer); },});
Deno.test({ name: "A single buffer concatenates and return the same buffer", fn() { const buffer1 = Buffer.alloc(1); const resultBuffer = Buffer.concat([buffer1]); assertEquals(resultBuffer.length, 1, "Buffer length should be 1"); },});
Deno.test({ name: "No buffers concat returns an empty buffer", fn() { const resultBuffer = Buffer.concat([]); assertEquals(resultBuffer.length, 0, "Buffer length should be 0"); },});
Deno.test({ name: "Buffer concat respects totalLength parameter", fn() { const maxLength1 = 10; const buffer1 = Buffer.alloc(2); const buffer2 = Buffer.alloc(2); assertEquals( Buffer.concat([buffer1, buffer2], maxLength1).length, maxLength1, );
const maxLength2 = 3; const buffer3 = Buffer.alloc(2); const buffer4 = Buffer.alloc(2); assertEquals( Buffer.concat([buffer3, buffer4], maxLength2).length, maxLength2, ); },});
Deno.test({ name: "Buffer 8 bit unsigned integers", fn() { const buffer = Buffer.from([0xff, 0x2a, 0x2a, 0x2a]); assertEquals(buffer.readUInt8(0), 255); assertEquals(buffer.readUInt8(1), 42); assertEquals(buffer.readUInt8(2), 42); assertEquals(buffer.readUInt8(3), 42); },});
Deno.test({ name: "Buffer 16 bit unsigned integers", fn() { const buffer = Buffer.from([0x00, 0x2a, 0x42, 0x3f]); assertEquals(buffer.readUInt16BE(0), 0x2a); assertEquals(buffer.readUInt16BE(1), 0x2a42); assertEquals(buffer.readUInt16BE(2), 0x423f); assertEquals(buffer.readUInt16LE(0), 0x2a00); assertEquals(buffer.readUInt16LE(1), 0x422a); assertEquals(buffer.readUInt16LE(2), 0x3f42);
buffer[0] = 0xfe; buffer[1] = 0xfe; assertEquals(buffer.readUInt16BE(0), 0xfefe); assertEquals(buffer.readUInt16LE(0), 0xfefe); },});
Deno.test({ name: "Buffer 32 bit unsigned integers", fn() { const buffer = Buffer.from([0x32, 0x65, 0x42, 0x56, 0x23, 0xff]); assertEquals(buffer.readUInt32BE(0), 0x32654256); assertEquals(buffer.readUInt32BE(1), 0x65425623); assertEquals(buffer.readUInt32BE(2), 0x425623ff); assertEquals(buffer.readUInt32LE(0), 0x56426532); assertEquals(buffer.readUInt32LE(1), 0x23564265); assertEquals(buffer.readUInt32LE(2), 0xff235642); },});
Deno.test({ name: "Buffer readUIntBE", fn() { const buffer = Buffer.from([ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, ]); assertEquals(buffer.readUIntBE(0, 1), 0x01); assertEquals(buffer.readUIntBE(0, 2), 0x0102); assertEquals(buffer.readUIntBE(0, 4), 0x01020304); },});
Deno.test({ name: "Buffer readUIntLE", fn() { const buffer = Buffer.from([ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, ]); assertEquals(buffer.readUIntLE(0, 1), 0x01); assertEquals(buffer.readUIntLE(0, 2), 0x0201); assertEquals(buffer.readUIntLE(0, 4), 0x04030201); },});
Deno.test({ name: "Buffer copy works as expected", fn() { const data1 = new Uint8Array([1, 2, 3]); const data2 = new Uint8Array([4, 5, 6]);
const buffer1 = Buffer.from(data1); const buffer2 = Buffer.from(data2);
//Mutates data_1 data1.set(data2); //Mutates buffer_1 buffer2.copy(buffer1);
assertEquals( new Buffer(data1), buffer1, ); },});
Deno.test({ name: "Buffer copy respects the starting point for copy", fn() { const buffer1 = Buffer.from([1, 2, 3]); const buffer2 = Buffer.alloc(8);
buffer1.copy(buffer2, 5);
const expected = Buffer.from([0, 0, 0, 0, 0, 1, 2, 3]);
assertEquals( buffer2, expected, ); },});
Deno.test({ name: "Buffer copy doesn't throw on offset but copies until offset reached", fn() { const buffer1 = Buffer.from([1, 2, 3]); const buffer2 = Buffer.alloc(8);
const writtenBytes1 = buffer1.copy(buffer2, 6);
assertEquals( writtenBytes1, 2, );
assertEquals( buffer2, Buffer.from([0, 0, 0, 0, 0, 0, 1, 2]), );
const buffer3 = Buffer.from([1, 2, 3]); const buffer4 = Buffer.alloc(8);
const writtenBytes2 = buffer3.copy(buffer4, 8);
assertEquals( writtenBytes2, 0, );
assertEquals( buffer4, Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]), ); },});
Deno.test({ name: "Buffer from string creates a Buffer", fn() { const buffer: Buffer = Buffer.from("test"); assertEquals(buffer.length, 4, "Buffer length should be 4"); assertEquals( buffer.toString(), "test", "Buffer to string should recover the string", ); },});
Deno.test({ name: "Buffer from string hex", fn() { for (const encoding of ["hex", "HEX"]) { const buffer: Buffer = Buffer.from( "7468697320697320612074c3a97374", encoding, ); assertEquals(buffer.length, 15, "Buffer length should be 15"); assertEquals( buffer.toString(), "this is a tést", "Buffer to string should recover the string", ); } },});
Deno.test({ name: "Buffer from string base64", fn() { for (const encoding of ["base64", "BASE64"]) { const buffer: Buffer = Buffer.from("dGhpcyBpcyBhIHTDqXN0", encoding); assertEquals(buffer.length, 15, "Buffer length should be 15"); assertEquals( buffer.toString(), "this is a tést", "Buffer to string should recover the string", ); } },});
Deno.test({ name: "Buffer to string base64", fn() { for (const encoding of ["base64", "BASE64"]) { const buffer: Buffer = Buffer.from("deno land"); assertEquals( buffer.toString(encoding), "ZGVubyBsYW5k", "Buffer to string should recover the string in base64", ); } const b64 = "dGhpcyBpcyBhIHTDqXN0"; assertEquals(Buffer.from(b64, "base64").toString("base64"), b64); },});
Deno.test({ name: "Buffer to string hex", fn() { for (const encoding of ["hex", "HEX"]) { const buffer: Buffer = Buffer.from("deno land"); assertEquals( buffer.toString(encoding), "64656e6f206c616e64", "Buffer to string should recover the string", ); } const hex = "64656e6f206c616e64"; assertEquals(Buffer.from(hex, "hex").toString("hex"), hex); },});
Deno.test({ name: "Buffer from string invalid encoding", fn() { const defaultToUtf8Encodings = [null, 5, {}, true, false, ""]; const invalidEncodings = ["deno", "base645"];
for (const encoding of defaultToUtf8Encodings) { assertEquals(Buffer.from("yes", encoding).toString(), "yes"); }
for (const encoding of invalidEncodings) { assertThrows( () => { Buffer.from("yes", encoding); }, TypeError, `Unknown encoding: ${encoding}`, ); } },});
Deno.test({ name: "Buffer from another buffer creates a Buffer", fn() { const buffer: Buffer = Buffer.from(Buffer.from("test")); assertEquals(buffer.length, 4, "Buffer length should be 4"); assertEquals( buffer.toString(), "test", "Buffer to string should recover the string", ); },});
Deno.test({ name: "isBuffer returns true if the object is a buffer", fn() { assertEquals(Buffer.isBuffer(Buffer.from("test")), true); },});
Deno.test({ name: "isBuffer returns false if the object is not a buffer", fn() { assertEquals(Buffer.isBuffer({ test: 3 }), false); assertEquals(Buffer.isBuffer(new Uint8Array()), false); },});
Deno.test({ name: "Buffer toJSON", fn() { assertEquals( JSON.stringify(Buffer.from("deno")), '{"type":"Buffer","data":[100,101,110,111]}', ); },});
Deno.test({ name: "buf.slice does not create a copy", fn() { const buf = Buffer.from("ceno"); // This method is not compatible with the Uint8Array.prototype.slice() const slice = buf.slice(); slice[0]++; assertEquals(slice.toString(), "deno"); },});
Deno.test({ name: "isEncoding returns true for valid encodings", fn() { [ "hex", "HEX", "HeX", "utf8", "utf-8", "ascii", "latin1", "binary", "base64", "BASE64", "BASe64", "ucs2", "ucs-2", "utf16le", "utf-16le", ].forEach((enc) => { assertEquals(Buffer.isEncoding(enc), true); }); },});
Deno.test({ name: "isEncoding returns false for invalid encodings", fn() { [ "utf9", "utf-7", "Unicode-FTW", "new gnu gun", false, NaN, {}, Infinity, [], 1, 0, -1, ].forEach((enc) => { // @ts-expect-error This deliberately ignores the type constraint assertEquals(Buffer.isEncoding(enc), false); }); },});