it,
} from "./dev-deps.js";
import {
+ arrayBufferSlice,
base16Binary,
base16String,
base32Binary,
base64String,
filenameSafeBase64Binary,
filenameSafeBase64String,
+ get16BitSignedIntegralItem,
+ get16BitUnsignedIntegralItem,
+ get32BitFloatingPointItem,
+ get32BitSignedIntegralItem,
+ get32BitUnsignedIntegralItem,
+ get64BitFloatingPointItem,
+ get64BitSignedIntegralItem,
+ get64BitUnsignedIntegralItem,
+ get8BitSignedIntegralItem,
+ get8BitUnsignedIntegralItem,
isArrayBuffer,
isArrayBufferView,
isBase16,
isBase32,
isBase64,
- isDataView,
isFilenameSafeBase64,
+ isSharedArrayBuffer,
isTypedArray,
isWRMGBase32,
+ set16BitIntegralItem,
+ set32BitFloatingPointItem,
+ set32BitIntegralItem,
+ set64BitFloatingPointItem,
+ set64BitIntegralItem,
+ set8BitIntegralItem,
toArrayBuffer,
wrmgBase32Binary,
wrmgBase32String,
}],
]);
+describe("arrayBufferSlice", () => {
+ it("[[Call]] slices an `ArrayBuffer`", () => {
+ const baseBuffer = Uint8Array.from([2, 3, 1, 9, 8, 5]).buffer;
+ assertEquals(
+ new Uint8Array(arrayBufferSlice(baseBuffer, 1, 4)),
+ Uint8Array.from([3, 1, 9]),
+ );
+ });
+
+ it("[[Call]] slices an `SharedArrayBuffer`", () => {
+ const baseBuffer = new SharedArrayBuffer(6);
+ new Uint8Array(baseBuffer).set([2, 3, 1, 9, 8, 5], 0);
+ assertEquals(
+ new Uint8Array(arrayBufferSlice(baseBuffer, 1, 4)),
+ Uint8Array.from([3, 1, 9]),
+ );
+ });
+
+ it("[[Call]] throws for others", () => {
+ [
+ undefined,
+ null,
+ true,
+ Symbol(),
+ 27,
+ 98n,
+ {},
+ [],
+ () => {},
+ new Proxy({}, {}),
+ "string",
+ new DataView(new ArrayBuffer()),
+ new Uint8Array(),
+ ].forEach((value) =>
+ assertThrows(() => arrayBufferSlice(value, 0, 0))
+ );
+ });
+});
+
describe("base16Binary", () => {
it("[[Call]] returns the correct data", () => {
assertEquals(
});
});
+describe("get8BitSignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from([0, -1, 0]).buffer;
+ assertStrictEquals(get8BitSignedIntegralItem(buffer, 1), -1n);
+ assertStrictEquals(
+ get8BitSignedIntegralItem(new DataView(buffer), 1),
+ -1n,
+ );
+ assertStrictEquals(
+ get8BitSignedIntegralItem(new Uint8Array(buffer), 1),
+ -1n,
+ );
+ });
+});
+
+describe("get8BitUnsignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from([0, -1, 0]).buffer;
+ assertStrictEquals(get8BitUnsignedIntegralItem(buffer, 1), 255n);
+ assertStrictEquals(
+ get8BitUnsignedIntegralItem(new DataView(buffer), 1),
+ 255n,
+ );
+ assertStrictEquals(
+ get8BitUnsignedIntegralItem(new Int8Array(buffer), 1),
+ 255n,
+ );
+ });
+});
+
+describe("get16BitSignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from([0, 0, -1, -1, 0, 0]).buffer;
+ assertStrictEquals(get16BitSignedIntegralItem(buffer, 2), -1n);
+ assertStrictEquals(
+ get16BitSignedIntegralItem(new DataView(buffer), 2),
+ -1n,
+ );
+ assertStrictEquals(
+ get16BitSignedIntegralItem(new Uint16Array(buffer), 2),
+ -1n,
+ );
+ });
+});
+
+describe("get16BitUnsignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from([0, 0, -1, -1, 0, 0]).buffer;
+ assertStrictEquals(
+ get16BitUnsignedIntegralItem(buffer, 2),
+ (1n << 16n) - 1n,
+ );
+ assertStrictEquals(
+ get16BitUnsignedIntegralItem(new DataView(buffer), 2),
+ (1n << 16n) - 1n,
+ );
+ assertStrictEquals(
+ get16BitUnsignedIntegralItem(new Int16Array(buffer), 2),
+ (1n << 16n) - 1n,
+ );
+ });
+});
+
+describe("get32BitFloatingPointItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = new ArrayBuffer(12);
+ const view = new DataView(buffer);
+ view.setFloat32(0, NaN);
+ view.setFloat32(4, -Infinity);
+ view.setFloat32(8, -0);
+ assertStrictEquals(get32BitFloatingPointItem(buffer, 0), NaN);
+ assertStrictEquals(
+ get32BitFloatingPointItem(buffer, 4),
+ -Infinity,
+ );
+ assertStrictEquals(get32BitFloatingPointItem(buffer, 8), -0);
+ assertStrictEquals(
+ get32BitFloatingPointItem(new DataView(buffer), 4),
+ -Infinity,
+ );
+ assertStrictEquals(
+ get32BitFloatingPointItem(new Uint32Array(buffer), 4),
+ -Infinity,
+ );
+ });
+});
+
+describe("get32BitSignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from(
+ [0, 0, 0, 0, -1, -1, -1, -1, 0, 0, 0, 0],
+ ).buffer;
+ assertStrictEquals(get32BitSignedIntegralItem(buffer, 4), -1n);
+ assertStrictEquals(
+ get32BitSignedIntegralItem(new DataView(buffer), 4),
+ -1n,
+ );
+ assertStrictEquals(
+ get32BitSignedIntegralItem(new Uint32Array(buffer), 4),
+ -1n,
+ );
+ });
+});
+
+describe("get32BitUnsignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from(
+ [0, 0, 0, 0, -1, -1, -1, -1, 0, 0, 0, 0],
+ ).buffer;
+ assertStrictEquals(
+ get32BitUnsignedIntegralItem(buffer, 4),
+ (1n << 32n) - 1n,
+ );
+ assertStrictEquals(
+ get32BitUnsignedIntegralItem(new DataView(buffer), 4),
+ (1n << 32n) - 1n,
+ );
+ assertStrictEquals(
+ get32BitUnsignedIntegralItem(new Int32Array(buffer), 4),
+ (1n << 32n) - 1n,
+ );
+ });
+});
+
+describe("get64BitFloatingPointItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = new ArrayBuffer(24);
+ const view = new DataView(buffer);
+ view.setFloat64(0, NaN);
+ view.setFloat64(8, -Infinity);
+ view.setFloat64(16, -0);
+ assertStrictEquals(get64BitFloatingPointItem(buffer, 0), NaN);
+ assertStrictEquals(
+ get64BitFloatingPointItem(buffer, 8),
+ -Infinity,
+ );
+ assertStrictEquals(get64BitFloatingPointItem(buffer, 16), -0);
+ assertStrictEquals(
+ get64BitFloatingPointItem(new DataView(buffer), 8),
+ -Infinity,
+ );
+ assertStrictEquals(
+ get64BitFloatingPointItem(new BigUint64Array(buffer), 8),
+ -Infinity,
+ );
+ });
+});
+
+describe("get64BitSignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from(
+ [0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1],
+ ).buffer;
+ assertStrictEquals(get64BitSignedIntegralItem(buffer, 8), -1n);
+ assertStrictEquals(
+ get64BitSignedIntegralItem(new DataView(buffer), 8),
+ -1n,
+ );
+ assertStrictEquals(
+ get64BitSignedIntegralItem(new BigUint64Array(buffer), 8),
+ -1n,
+ );
+ });
+});
+
+describe("get64BitUnsignedIntegralItem", () => {
+ it("[[Call]] gets the item", () => {
+ const buffer = Int8Array.from(
+ [0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1],
+ ).buffer;
+ assertStrictEquals(
+ get64BitUnsignedIntegralItem(buffer, 8),
+ (1n << 64n) - 1n,
+ );
+ assertStrictEquals(
+ get64BitUnsignedIntegralItem(new DataView(buffer), 8),
+ (1n << 64n) - 1n,
+ );
+ assertStrictEquals(
+ get64BitUnsignedIntegralItem(new BigInt64Array(buffer), 8),
+ (1n << 64n) - 1n,
+ );
+ });
+});
+
describe("isArrayBuffer", () => {
it("[[Call]] returns true for array buffers", () => {
assertStrictEquals(
isArrayBuffer(new ArrayBuffer()),
true,
);
+ assertStrictEquals(
+ isArrayBuffer(new SharedArrayBuffer()),
+ true,
+ );
});
it("[[Call]] returns false for others", () => {
() => {},
new Proxy({}, {}),
"string",
- new SharedArrayBuffer(),
new DataView(new ArrayBuffer()),
new Uint8Array(),
].forEach((value) =>
});
});
-describe("isDataView", () => {
- it("[[Call]] returns true for data views", () => {
- assertStrictEquals(
- isDataView(new DataView(new ArrayBuffer())),
- true,
- );
+describe("isFilenameSafeBase64", () => {
+ it("[[Call]] returns true for filename‐safe base64 strings", () => {
+ for (const { base64 } of data.values()) {
+ assertStrictEquals(
+ isFilenameSafeBase64(
+ base64.replace("+", "-").replace("/", "_"),
+ ),
+ true,
+ );
+ }
});
it("[[Call]] returns false for others", () => {
[],
() => {},
new Proxy({}, {}),
- "string",
- new ArrayBuffer(),
- new SharedArrayBuffer(),
- new Uint8Array(),
- ].forEach((value) => assertStrictEquals(isDataView(value), false));
+ "abc/",
+ "a",
+ "abc==",
+ ].forEach((value) =>
+ assertStrictEquals(isFilenameSafeBase64(value), false)
+ );
});
});
-describe("isFilenameSafeBase64", () => {
- it("[[Call]] returns true for filename‐safe base64 strings", () => {
- for (const { base64 } of data.values()) {
- assertStrictEquals(
- isFilenameSafeBase64(
- base64.replace("+", "-").replace("/", "_"),
- ),
- true,
- );
- }
+describe("isSharedArrayBuffer", () => {
+ it("[[Call]] returns true for shared array buffers", () => {
+ assertStrictEquals(
+ isSharedArrayBuffer(new SharedArrayBuffer()),
+ true,
+ );
});
it("[[Call]] returns false for others", () => {
[],
() => {},
new Proxy({}, {}),
- "abc/",
- "a",
- "abc==",
+ "string",
+ new ArrayBuffer(),
+ new DataView(new ArrayBuffer()),
+ new Uint8Array(),
].forEach((value) =>
- assertStrictEquals(isFilenameSafeBase64(value), false)
+ assertStrictEquals(isSharedArrayBuffer(value), false)
);
});
});
});
});
+describe("set8BitIntegralItem", () => {
+ it("[[Call]] sets the item", () => {
+ const buffer = new ArrayBuffer(3);
+ set8BitIntegralItem(buffer, 1, -1n);
+ set8BitIntegralItem(buffer, 2, (1 << 8) - 1);
+ assertEquals(
+ new Int8Array(buffer),
+ Int8Array.from([0, -1, -1]),
+ );
+ });
+});
+
+describe("set16BitIntegralItem", () => {
+ it("[[Call]] sets the item", () => {
+ const buffer = new ArrayBuffer(6);
+ set16BitIntegralItem(buffer, 2, -1n);
+ set16BitIntegralItem(buffer, 4, (1 << 16) - 1);
+ assertEquals(
+ new Int8Array(buffer),
+ Int8Array.from([0, 0, -1, -1, -1, -1]),
+ );
+ });
+});
+
+describe("set32BitFloatingPointItem", () => {
+ it("[[Call]] sets the item", () => {
+ const buffer = new ArrayBuffer(12);
+ const expected = new ArrayBuffer(12);
+ const view = new DataView(expected);
+ view.setFloat32(0, NaN);
+ set32BitFloatingPointItem(buffer, 0, NaN);
+ view.setFloat32(4, -Infinity);
+ set32BitFloatingPointItem(buffer, 4, -Infinity);
+ view.setFloat32(8, -0);
+ set32BitFloatingPointItem(buffer, 8, -0);
+ assertEquals(
+ new Uint8Array(buffer),
+ new Uint8Array(expected),
+ );
+ });
+});
+
+describe("set32BitIntegralItem", () => {
+ it("[[Call]] sets the item", () => {
+ const buffer = new ArrayBuffer(12);
+ set32BitIntegralItem(buffer, 4, -1n);
+ set32BitIntegralItem(buffer, 8, -1 >>> 0);
+ assertEquals(
+ new Int8Array(buffer),
+ Int8Array.from([0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1]),
+ );
+ });
+});
+
+describe("set64BitFloatingPointItem", () => {
+ it("[[Call]] sets the item", () => {
+ const buffer = new ArrayBuffer(24);
+ const expected = new ArrayBuffer(24);
+ const view = new DataView(expected);
+ view.setFloat64(0, NaN);
+ set64BitFloatingPointItem(buffer, 0, NaN);
+ view.setFloat64(4, -Infinity);
+ set64BitFloatingPointItem(buffer, 4, -Infinity);
+ view.setFloat64(8, -0);
+ set64BitFloatingPointItem(buffer, 8, -0);
+ assertEquals(
+ new Uint8Array(buffer),
+ new Uint8Array(expected),
+ );
+ });
+});
+
+describe("set64BitIntegralItem", () => {
+ it("[[Call]] sets the item", () => {
+ const buffer = new ArrayBuffer(12);
+ set64BitIntegralItem(buffer, 4, -1n);
+ assertEquals(
+ new Int8Array(buffer),
+ Int8Array.from([0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1]),
+ );
+ });
+});
+
describe("toArrayBuffer", () => {
it("[[Call]] returns the argument for array buffers", () => {
const buffer = new ArrayBuffer();
Lady’s Gitweb / Pisces / blobdiff