Initial commit

[Habu] / mod.test.js

// 🎐📦 ハブ ∷ mod.test.js
// ====================================================================
//
// Copyright © 2022 Lady [@ Lady’s Computer].
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at <https://mozilla.org/MPL/2.0/>.

import { assertStrictEquals } from "./dev-deps.js";
import ハブ from "./mod.js";

Deno.test({
  name: "ハブ instances can store and retrieve data",
  fn: () => {
    for (let bitWidth = 1; bitWidth <= 64; ++bitWidth) {
      const data = Array.from(function* () {
        for (let i = 0; i < 69; i++) {
          yield BigInt(
            Math.random() * Number(1n << BigInt(bitWidth)) >>> 0,
          );
        }
      }());
      const instance = new ハブ(bitWidth, 69);
      assertStrictEquals(instance.length, 69);
      assertStrictEquals(
        instance.byteLength,
        Math.ceil(69 / instance.wordScale) * instance.wordSize,
      );
      for (const [index, value] of data.entries()) {
        instance[index] = value;
      }
      for (const [index, value] of data.entries()) {
        const actual = instance[index];
        assertStrictEquals(
          actual,
          value,
          `Actual value for index ${index} of bitWidth ${bitWidth} was ${actual}, but ${value} was expected.`,
        );
      }
    }
  },
});

Deno.test({
  name: "ハブ instances can share buffers",
  fn: () => {
    const bitWidth = 7;
    const data = Array.from(function* () {
      for (let i = 0; i < 69; i++) {
        yield BigInt(
          Math.random() * Number(1n << BigInt(bitWidth)) >>> 0,
        );
      }
    }());
    const instance = new ハブ(bitWidth, data);
    const otherInstance = new ハブ(bitWidth, instance.buffer, 0, 69);
    assertStrictEquals(otherInstance.length, 69);
    for (const [index, value] of otherInstance.entries()) {
      const actual = instance[index];
      assertStrictEquals(
        actual,
        value,
        `Value mismatch for index ${index}.`,
      );
    }
  },
});

Deno.test({
  name: "ハブ instances can subset other instances using array buffers",
  fn: () => {
    const bitWidth = 7;
    const data = Array.from(function* () {
      for (let i = 0; i < 69; i++) {
        yield BigInt(
          Math.random() * Number(1n << BigInt(bitWidth)) >>> 0,
        );
      }
    }());
    const instance = new ハブ(bitWidth, data);
    const otherInstance = new ハブ(bitWidth, instance.buffer, 8, 42);
    assertStrictEquals(otherInstance.length, 42);
    assertStrictEquals(otherInstance.byteLength, 40);
    for (const [index, value] of otherInstance.entries()) {
      const actual = instance[index + 9]; // 9 elements per 8 bytes
      assertStrictEquals(
        actual,
        value,
        `Value mismatch for index ${index}.`,
      );
    }
  },
});

Deno.test({
  name: "ハブ.from",
  fn: () => {
    const bitWidth = 7;
    const data = Array.from(function* () {
      for (let i = 0; i < 69; i++) {
        yield BigInt(
          Math.random() * Number(1n << BigInt(bitWidth)) >>> 0,
        );
      }
    }());
    const instance = ハブ.from(bitWidth, data);
    for (const [index, value] of data.entries()) {
      const actual = instance[index];
      assertStrictEquals(
        actual,
        value,
        `Value mismatch for index ${index}.`,
      );
    }
  },
});

Deno.test({
  name: "ハブ.of",
  fn: () => {
    const bitWidth = 7;
    const data = Array.from(function* () {
      for (let i = 0; i < 69; i++) {
        yield BigInt(
          Math.random() * Number(1n << BigInt(bitWidth)) >>> 0,
        );
      }
    }());
    const instance = ハブ.of(bitWidth, ...data);
    for (const [index, value] of data.entries()) {
      const actual = instance[index];
      assertStrictEquals(
        actual,
        value,
        `Value mismatch for index ${index}.`,
      );
    }
  },
});

Deno.test({
  name: "ハブ#concat",
  fn: () => {
    const bitWidth = 7;
    const data = Array.from(function* () {
      for (let i = 0; i < 69; i++) {
        yield BigInt(
          Math.random() * Number(1n << BigInt(bitWidth)) >>> 0,
        );
      }
    }());
    const instance = new ハブ(7);
    const concatted = instance.concat(data);
    assertStrictEquals(concatted.length, 69);
    for (const [index, value] of data.entries()) {
      const actual = concatted[index];
      assertStrictEquals(actual, value);
    }
  },
});

Deno.test({
  name: "ハブ#constructor",
  fn: () => {
    const instance = new ハブ(7);
    const { constructor } = instance;
    assertStrictEquals(new constructor(5).bitWidth, 7);
    assertStrictEquals(new constructor(5).length, 5);
    assertStrictEquals(constructor[Symbol.species], constructor);
  },
});

Deno.test({
  name: "ハブ#filter",
  fn: () => {
    const data = Array.from(function* () {
      for (let i = 0; i < 69; i++) {
        yield i % 2 ? 0n : 1n;
      }
    }());
    const instance = new ハブ(7, data);
    const filtered = instance.filter(($) => !!$);
    assertStrictEquals(filtered.length, 35);
    for (const value of filtered) {
      assertStrictEquals(value, 1n);
    }
  },
});