diff options
| -rw-r--r-- | src/bun.js/bindings/JSBuffer.cpp | 118 | ||||
| -rw-r--r-- | src/bun.js/bindings/JSBufferEncodingType.cpp | 11 | ||||
| -rw-r--r-- | test/bun.js/buffer.test.js | 143 |
3 files changed, 229 insertions, 43 deletions
diff --git a/src/bun.js/bindings/JSBuffer.cpp b/src/bun.js/bindings/JSBuffer.cpp index aec9e82b1..2e15c419a 100644 --- a/src/bun.js/bindings/JSBuffer.cpp +++ b/src/bun.js/bindings/JSBuffer.cpp @@ -430,6 +430,75 @@ EncodedJSValue constructSlowBuffer(JSGlobalObject* lexicalGlobalObject, CallFram return jsBufferConstructorFunction_allocUnsafeSlowBody(lexicalGlobalObject, callFrame); } +static inline JSC::EncodedJSValue jsBufferFromStringAndEncoding(JSC::JSGlobalObject* lexicalGlobalObject, JSString* str, WebCore::BufferEncodingType encoding) +{ + auto scope = DECLARE_THROW_SCOPE(lexicalGlobalObject->vm()); + if (!str) { + throwTypeError(lexicalGlobalObject, scope, "byteLength() expects a string"_s); + return JSC::JSValue::encode(jsUndefined()); + } + + if (str->length() == 0) + return JSC::JSValue::encode(JSC::jsNumber(0)); + + int64_t written = 0; + + switch (encoding) { + + case WebCore::BufferEncodingType::ucs2: + case WebCore::BufferEncodingType::utf16le: { + // https://github.com/nodejs/node/blob/e676942f814915b2d24fc899bb42dc71ae6c8226/lib/buffer.js#L600 + return JSC::JSValue::encode(JSC::jsNumber(str->length() * 2)); + } + + case WebCore::BufferEncodingType::latin1: + case WebCore::BufferEncodingType::ascii: { + // https: // github.com/nodejs/node/blob/e676942f814915b2d24fc899bb42dc71ae6c8226/lib/buffer.js#L627 + return JSC::JSValue::encode(JSC::jsNumber(str->length())); + } + + case WebCore::BufferEncodingType::base64: + case WebCore::BufferEncodingType::base64url: { + int64_t length = str->length(); + auto view = str->tryGetValue(lexicalGlobalObject); + + if (view.is8Bit()) { + if (view.characters8()[length - 1] == 0x3D) { + length--; + + if (length > 1 && view.characters8()[length - 1] == '=') + length--; + } + } else { + if (view.characters16()[length - 1] == 0x3D) { + length--; + + if (length > 1 && view.characters16()[length - 1] == '=') + length--; + } + } + + // https://github.com/nodejs/node/blob/e676942f814915b2d24fc899bb42dc71ae6c8226/lib/buffer.js#L579 + return JSValue::encode(jsNumber(static_cast<double>((length * 3) >> 2))); + } + + case WebCore::BufferEncodingType::hex: { + return JSValue::encode(jsNumber(str->length() >> 1)); + } + + case WebCore::BufferEncodingType::utf8: { + auto view = str->tryGetValue(lexicalGlobalObject); + if (view.is8Bit()) { + written = Bun__encoding__byteLengthLatin1(view.characters8(), view.length(), static_cast<uint8_t>(encoding)); + } else { + written = Bun__encoding__byteLengthUTF16(view.characters16(), view.length(), static_cast<uint8_t>(encoding)); + } + break; + } + } + + return JSC::JSValue::encode(JSC::jsNumber(written)); +} static inline JSC::EncodedJSValue jsBufferConstructorFunction_byteLengthBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame) { auto& vm = JSC::getVM(lexicalGlobalObject); @@ -446,56 +515,33 @@ static inline JSC::EncodedJSValue jsBufferConstructorFunction_byteLengthBody(JSC EnsureStillAliveScope arg0 = callFrame->argument(0); auto input = arg0.value(); - if (JSC::JSArrayBufferView* view = JSC::jsDynamicCast<JSC::JSArrayBufferView*>(input)) { - RELEASE_AND_RETURN(scope, JSValue::encode(JSC::jsNumber(view->byteLength()))); - } - auto* str = arg0.value().toStringOrNull(lexicalGlobalObject); - - if (!str) { - throwTypeError(lexicalGlobalObject, scope, "byteLength() expects a string"_s); - return JSC::JSValue::encode(jsUndefined()); - } EnsureStillAliveScope arg1 = callFrame->argument(1); - - if (str->length() == 0) - return JSC::JSValue::encode(JSC::jsNumber(0)); - if (callFrame->argumentCount() > 1) { if (arg1.value().isString()) { std::optional<BufferEncodingType> encoded = parseEnumeration<BufferEncodingType>(*lexicalGlobalObject, arg1.value()); - if (!encoded) { - throwTypeError(lexicalGlobalObject, scope, "Invalid encoding"_s); - return JSC::JSValue::encode(jsUndefined()); - } - encoding = encoded.value(); + // this one doesn't fail + if (encoded) { + encoding = encoded.value(); + } } } - auto view = str->tryGetValue(lexicalGlobalObject); - int64_t written = 0; + if (LIKELY(input.isString())) + return jsBufferFromStringAndEncoding(lexicalGlobalObject, asString(input), encoding); - switch (encoding) { - case WebCore::BufferEncodingType::utf8: - case WebCore::BufferEncodingType::latin1: - case WebCore::BufferEncodingType::ascii: - case WebCore::BufferEncodingType::ucs2: - case WebCore::BufferEncodingType::utf16le: - case WebCore::BufferEncodingType::base64: - case WebCore::BufferEncodingType::base64url: - case WebCore::BufferEncodingType::hex: { - if (view.is8Bit()) { - written = Bun__encoding__byteLengthLatin1(view.characters8(), view.length(), static_cast<uint8_t>(encoding)); - } else { - written = Bun__encoding__byteLengthUTF16(view.characters16(), view.length(), static_cast<uint8_t>(encoding)); - } - break; + if (auto* arrayBufferView = jsDynamicCast<JSC::JSArrayBufferView*>(input)) { + return JSValue::encode(jsNumber(arrayBufferView->byteLength())); } + + if (auto* arrayBuffer = jsDynamicCast<JSC::JSArrayBuffer*>(input)) { + return JSValue::encode(jsNumber(arrayBuffer->impl()->byteLength())); } - RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::jsNumber(written))); + throwTypeError(lexicalGlobalObject, scope, "Invalid input, must be a string, Buffer, or ArrayBuffer"_s); + return JSC::JSValue::encode(jsUndefined()); } static inline JSC::EncodedJSValue jsBufferConstructorFunction_compareBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame) diff --git a/src/bun.js/bindings/JSBufferEncodingType.cpp b/src/bun.js/bindings/JSBufferEncodingType.cpp index 4b4442e27..d65e90d2b 100644 --- a/src/bun.js/bindings/JSBufferEncodingType.cpp +++ b/src/bun.js/bindings/JSBufferEncodingType.cpp @@ -61,8 +61,17 @@ template<> std::optional<BufferEncodingType> parseEnumeration<BufferEncodingType return std::nullopt; auto encoding = str->value(&lexicalGlobalObject); - if (encoding.length() < 3) + switch (encoding.length()) { + case 0: { + return BufferEncodingType::utf8; + } + case 1: + case 2: { return std::nullopt; + } + default: { + } + } switch (encoding[0]) { case 'u': diff --git a/test/bun.js/buffer.test.js b/test/bun.js/buffer.test.js index c732b58e3..b02608cc2 100644 --- a/test/bun.js/buffer.test.js +++ b/test/bun.js/buffer.test.js @@ -1,4 +1,4 @@ -import { describe, it, expect, beforeEach, afterEach } from "bun:test"; +import { describe, it, expect, beforeEach, afterEach, test } from "bun:test"; import { gc } from "./gc"; const BufferModule = await import("buffer"); @@ -6,7 +6,14 @@ const BufferModule = await import("buffer"); beforeEach(() => gc()); afterEach(() => gc()); -const assert = { +function assert(a) { + expect(a).toBeTruthy(); +} + +Object.assign(assert, { + ok(a) { + expect(a).toBeTruthy(); + }, deepStrictEqual(a, b) { expect(b).toStrictEqual(a); }, @@ -16,7 +23,7 @@ const assert = { throws(a, b) { expect(a).toThrow(); }, -}; +}); it("Buffer.alloc", () => { // Verify the maximum Uint8Array size. There is no concrete limit by spec. The @@ -1233,9 +1240,9 @@ it("Buffer.alloc", () => { Buffer.from(new ArrayBuffer()); // Test that ArrayBuffer from a different context is detected correctly. - const arrayBuf = vm.runInNewContext("new ArrayBuffer()"); - Buffer.from(arrayBuf); - Buffer.from({ buffer: arrayBuf }); + // const arrayBuf = vm.runInNewContext("new ArrayBuffer()"); + // Buffer.from(arrayBuf); + // Buffer.from({ buffer: arrayBuf }); assert.throws( () => Buffer.alloc({ valueOf: () => 1 }), @@ -2685,3 +2692,127 @@ it("Buffer.fill (Node.js tests)", () => { buf.fill("This is not correctly encoded", "hex"); }).toThrow(); }); + +test("Buffer.byteLength", () => { + "use strict"; + + const SlowBuffer = require("buffer").SlowBuffer; + + // [[32, "latin1"], [NaN, "utf8"], [{}, "latin1"], []].forEach((args) => { + // assert.throws(() => Buffer.byteLength(...args)); + // }); + + // assert.strictEqual(Buffer.byteLength("", undefined, true), -1); + + assert(ArrayBuffer.isView(new Buffer(10))); + assert(ArrayBuffer.isView(new SlowBuffer(10))); + assert(ArrayBuffer.isView(Buffer.alloc(10))); + assert(ArrayBuffer.isView(Buffer.allocUnsafe(10))); + assert(ArrayBuffer.isView(Buffer.allocUnsafeSlow(10))); + assert(ArrayBuffer.isView(Buffer.from(""))); + + // buffer + const incomplete = Buffer.from([0xe4, 0xb8, 0xad, 0xe6, 0x96]); + assert.strictEqual(Buffer.byteLength(incomplete), 5); + const ascii = Buffer.from("abc"); + assert.strictEqual(Buffer.byteLength(ascii), 3); + + // ArrayBuffer + const buffer = new ArrayBuffer(8); + assert.strictEqual(Buffer.byteLength(buffer), 8); + + // TypedArray + const int8 = new Int8Array(8); + assert.strictEqual(Buffer.byteLength(int8), 8); + const uint8 = new Uint8Array(8); + assert.strictEqual(Buffer.byteLength(uint8), 8); + const uintc8 = new Uint8ClampedArray(2); + assert.strictEqual(Buffer.byteLength(uintc8), 2); + const int16 = new Int16Array(8); + assert.strictEqual(Buffer.byteLength(int16), 16); + const uint16 = new Uint16Array(8); + assert.strictEqual(Buffer.byteLength(uint16), 16); + const int32 = new Int32Array(8); + assert.strictEqual(Buffer.byteLength(int32), 32); + const uint32 = new Uint32Array(8); + assert.strictEqual(Buffer.byteLength(uint32), 32); + const float32 = new Float32Array(8); + assert.strictEqual(Buffer.byteLength(float32), 32); + const float64 = new Float64Array(8); + assert.strictEqual(Buffer.byteLength(float64), 64); + + // DataView + const dv = new DataView(new ArrayBuffer(2)); + assert.strictEqual(Buffer.byteLength(dv), 2); + + // Special case: zero length string + assert.strictEqual(Buffer.byteLength("", "ascii"), 0); + assert.strictEqual(Buffer.byteLength("", "HeX"), 0); + + // utf8 + assert.strictEqual(Buffer.byteLength("∑éllö wørl∂!", "utf-8"), 19); + assert.strictEqual(Buffer.byteLength("κλμνξο", "utf8"), 12); + assert.strictEqual(Buffer.byteLength("挵挶挷挸挹", "utf-8"), 15); + assert.strictEqual(Buffer.byteLength("𠝹𠱓𠱸", "UTF8"), 12); + // Without an encoding, utf8 should be assumed + assert.strictEqual(Buffer.byteLength("hey there"), 9); + assert.strictEqual(Buffer.byteLength("𠱸挶νξ#xx :)"), 17); + assert.strictEqual(Buffer.byteLength("hello world", ""), 11); + // It should also be assumed with unrecognized encoding + assert.strictEqual(Buffer.byteLength("hello world", "abc"), 11); + assert.strictEqual(Buffer.byteLength("ßœ∑≈", "unkn0wn enc0ding"), 10); + + // base64 + assert.strictEqual(Buffer.byteLength("aGVsbG8gd29ybGQ=", "base64"), 11); + assert.strictEqual(Buffer.byteLength("aGVsbG8gd29ybGQ=", "BASE64"), 11); + assert.strictEqual(Buffer.byteLength("bm9kZS5qcyByb2NrcyE=", "base64"), 14); + assert.strictEqual(Buffer.byteLength("aGkk", "base64"), 3); + assert.strictEqual( + Buffer.byteLength("bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==", "base64"), + 25, + ); + // base64url + assert.strictEqual(Buffer.byteLength("aGVsbG8gd29ybGQ", "base64url"), 11); + assert.strictEqual(Buffer.byteLength("aGVsbG8gd29ybGQ", "BASE64URL"), 11); + assert.strictEqual(Buffer.byteLength("bm9kZS5qcyByb2NrcyE", "base64url"), 14); + assert.strictEqual(Buffer.byteLength("aGkk", "base64url"), 3); + assert.strictEqual( + Buffer.byteLength("bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw", "base64url"), + 25, + ); + // special padding + assert.strictEqual(Buffer.byteLength("aaa=", "base64"), 2); + assert.strictEqual(Buffer.byteLength("aaaa==", "base64"), 3); + assert.strictEqual(Buffer.byteLength("aaa=", "base64url"), 2); + assert.strictEqual(Buffer.byteLength("aaaa==", "base64url"), 3); + + assert.strictEqual(Buffer.byteLength("Il était tué"), 14); + assert.strictEqual(Buffer.byteLength("Il était tué", "utf8"), 14); + + ["ascii", "latin1", "binary"] + .reduce((es, e) => es.concat(e, e.toUpperCase()), []) + .forEach((encoding) => { + assert.strictEqual(Buffer.byteLength("Il était tué", encoding), 12); + }); + + ["ucs2", "ucs-2", "utf16le", "utf-16le"] + .reduce((es, e) => es.concat(e, e.toUpperCase()), []) + .forEach((encoding) => { + assert.strictEqual(Buffer.byteLength("Il était tué", encoding), 24); + }); + + // Test that ArrayBuffer from a different context is detected correctly + // const arrayBuf = vm.runInNewContext("new ArrayBuffer()"); + // assert.strictEqual(Buffer.byteLength(arrayBuf), 0); + + // Verify that invalid encodings are treated as utf8 + for (let i = 1; i < 10; i++) { + const encoding = String(i).repeat(i); + + assert.ok(!Buffer.isEncoding(encoding)); + assert.strictEqual( + Buffer.byteLength("foo", encoding), + Buffer.byteLength("foo", "utf8"), + ); + } +}); |