From b319fa7f4965af3d3d576ea528248a31c96a4053 Mon Sep 17 00:00:00 2001 From: Felipe Baltor Date: Thu, 22 Jun 2023 06:55:48 -0300 Subject: [PATCH] test(ext/node): port buffer_test.ts from deno_std (#19556) --- cli/tests/unit_node/buffer_test.ts | 645 ++++++++++++++++++++++++++++- 1 file changed, 643 insertions(+), 2 deletions(-) diff --git a/cli/tests/unit_node/buffer_test.ts b/cli/tests/unit_node/buffer_test.ts index 1d7571f6a5..74415d0d56 100644 --- a/cli/tests/unit_node/buffer_test.ts +++ b/cli/tests/unit_node/buffer_test.ts @@ -1,7 +1,589 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. - import { Buffer } from "node:buffer"; -import { assertEquals } from "../../../test_util/std/testing/asserts.ts"; +import { + assertEquals, + assertThrows, +} from "../../../test_util/std/testing/asserts.ts"; + +Deno.test({ + name: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] alloc filled correctly with integer", + fn() { + const buffer: Buffer = Buffer.alloc(3, 5); + assertEquals(buffer, Buffer.from([5, 5, 5])); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with single character", + fn() { + assertEquals(Buffer.alloc(5, "a"), Buffer.from([97, 97, 97, 97, 97])); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with base64 string", + fn() { + assertEquals( + Buffer.alloc(11, "aGVsbG8gd29ybGQ=", "base64"), + Buffer.from([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]), + ); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with hex string", + fn() { + assertEquals( + Buffer.alloc(4, "64656e6f", "hex"), + Buffer.from([100, 101, 110, 111]), + ); + }, +}); + +Deno.test({ + name: + "[node/buffer] alloc filled correctly with hex string smaller than alloc size", + fn() { + assertEquals( + Buffer.alloc(13, "64656e6f", "hex").toString(), + "denodenodenod", + ); + }, +}); + +Deno.test({ + name: + "[node/buffer] alloc filled correctly with Uint8Array smaller than alloc size", + fn() { + // todo(fbaltor): remove this 'any' when @types/node fixes https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/65831 + // deno-lint-ignore no-explicit-any + const arr: any = new Uint8Array([100, 101]); + assertEquals( + Buffer.alloc(7, arr), + Buffer.from([100, 101, 100, 101, 100, 101, 100]), + ); + assertEquals( + Buffer.alloc(6, arr), + Buffer.from([100, 101, 100, 101, 100, 101]), + ); + }, +}); + +Deno.test({ + name: + "[node/buffer] alloc filled correctly with Uint8Array bigger than alloc size", + fn() { + assertEquals( + // todo(fbaltor): remove this 'any' when @types/node fixes https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/65831 + // deno-lint-ignore no-explicit-any + Buffer.alloc(1, new Uint8Array([100, 101]) as any), + Buffer.from([100]), + ); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with Buffer", + fn() { + assertEquals( + Buffer.alloc(6, Buffer.from([100, 101])), + Buffer.from([100, 101, 100, 101, 100, 101]), + ); + assertEquals( + Buffer.alloc(7, Buffer.from([100, 101])), + Buffer.from([100, 101, 100, 101, 100, 101, 100]), + ); + }, +}); + +// tests from: +// https://github.com/nodejs/node/blob/56dbe466fdbc598baea3bfce289bf52b97b8b8f7/test/parallel/test-buffer-bytelength.js#L70 +Deno.test({ + name: "[node/buffer] Byte length is the expected for strings", + fn() { + // Special case: zero length string + assertEquals(Buffer.byteLength("", "ascii"), 0); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("", "HeX" as any), 0); + + // utf8 + assertEquals(Buffer.byteLength("∑éllö wørl∂!", "utf-8"), 19); + assertEquals(Buffer.byteLength("κλμνξο", "utf8"), 12); + assertEquals(Buffer.byteLength("挵挶挷挸挹", "utf-8"), 15); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("𠝹𠱓𠱸", "UTF8" as any), 12); + // Without an encoding, utf8 should be assumed + assertEquals(Buffer.byteLength("hey there"), 9); + assertEquals(Buffer.byteLength("𠱸挶νξ#xx :)"), 17); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("hello world", "" as any), 11); + // It should also be assumed with unrecognized encoding + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("hello world", "abc" as any), 11); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("ßœ∑≈", "unkn0wn enc0ding" as any), 10); + + // base64 + assertEquals(Buffer.byteLength("aGVsbG8gd29ybGQ=", "base64"), 11); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("aGVsbG8gd29ybGQ=", "BASE64" as any), 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) => { + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("Il était tué", encoding as any), 12); + }); + + ["ucs2", "ucs-2", "utf16le", "utf-16le"] + .reduce((es: string[], e: string) => es.concat(e, e.toUpperCase()), []) + .forEach((encoding: string) => { + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("Il était tué", encoding as any), 24); + }); + }, +}); + +Deno.test({ + name: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] No buffers concat returns an empty buffer", + fn() { + const resultBuffer = Buffer.concat([]); + assertEquals(resultBuffer.length, 0, "Buffer length should be 0"); + }, +}); + +Deno.test({ + name: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] 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( + Buffer.from(data1), + buffer1, + ); + }, +}); + +Deno.test({ + name: "[node/buffer] 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: + "[node/buffer] 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: "[node/buffer] 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: "[node/buffer] Buffer from string hex", + fn() { + for (const encoding of ["hex", "HEX"]) { + const buffer: Buffer = Buffer.from( + "7468697320697320612074c3a97374", + // deno-lint-ignore no-explicit-any + encoding as any, + ); + 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: "[node/buffer] Buffer from string base64", + fn() { + for (const encoding of ["base64", "BASE64"]) { + const buffer: Buffer = Buffer.from( + "dGhpcyBpcyBhIHTDqXN0", + // deno-lint-ignore no-explicit-any + encoding as any, + ); + 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: "[node/buffer] Buffer to string base64", + fn() { + for (const encoding of ["base64", "BASE64"]) { + const buffer: Buffer = Buffer.from("deno land"); + assertEquals( + // deno-lint-ignore no-explicit-any + buffer.toString(encoding as any), + "ZGVubyBsYW5k", + "Buffer to string should recover the string in base64", + ); + } + const b64 = "dGhpcyBpcyBhIHTDqXN0"; + assertEquals(Buffer.from(b64, "base64").toString("base64"), b64); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer to string hex", + fn() { + for (const encoding of ["hex", "HEX"]) { + const buffer: Buffer = Buffer.from("deno land"); + assertEquals( + // deno-lint-ignore no-explicit-any + buffer.toString(encoding as any), + "64656e6f206c616e64", + "Buffer to string should recover the string", + ); + } + const hex = "64656e6f206c616e64"; + assertEquals(Buffer.from(hex, "hex").toString("hex"), hex); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer from string invalid encoding", + fn() { + const defaultToUtf8Encodings = [null, 5, {}, true, false, ""]; + const invalidEncodings = ["deno", "base645"]; + + for (const encoding of defaultToUtf8Encodings) { + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.from("yes", encoding as any).toString(), "yes"); + } + + for (const encoding of invalidEncodings) { + assertThrows( + () => { + // deno-lint-ignore no-explicit-any + Buffer.from("yes", encoding as any); + }, + TypeError, + `Unknown encoding: ${encoding}`, + ); + } + }, +}); + +Deno.test({ + name: "[node/buffer] 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: "[node/buffer] isBuffer returns true if the object is a buffer", + fn() { + assertEquals(Buffer.isBuffer(Buffer.from("test")), true); + }, +}); + +Deno.test({ + name: "[node/buffer] 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: "[node/buffer] Buffer toJSON", + fn() { + assertEquals( + JSON.stringify(Buffer.from("deno")), + '{"type":"Buffer","data":[100,101,110,111]}', + ); + }, +}); + +Deno.test({ + name: "[node/buffer] 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: "[node/buffer] slice with infinity returns empty buffer", @@ -10,3 +592,62 @@ Deno.test({ assertEquals(buf.slice(Infinity).length, 0); }, }); + +Deno.test({ + name: "[node/buffer] 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: "[node/buffer] 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); + }); + }, +}); + +Deno.test({ + name: + "[node/buffer] utf8Write handle missing optional length argument (https://github.com/denoland/deno_std/issues/2046)", + fn() { + const buf = Buffer.alloc(8); + // @ts-expect-error Buffer.prototype.utf8Write is an undocumented API + assertEquals(buf.utf8Write("abc", 0), 3); + assertEquals([...buf], [0x61, 0x62, 0x63, 0, 0, 0, 0, 0]); + }, +});