ya-struct 0.0.5 → 0.0.6

package/test/abi.js

@@ -1,203 +0,0 @@
-/* global describe */
-/* global it */
-
-import struct from "../lib/index.js";
-import assert from "assert";
-
-describe("abi", () => {
-  const testEndiannessFor = ({ endianness }) => {
-    it("should support structure definition", () => {
-      const def = struct
-        .define(({ field }) => {
-          field.UInt32("myfield1");
-          field.UInt32("myfield2");
-        })
-        .abi({ endianness });
-
-      assert.strictEqual(def.size, 8);
-      assert.strictEqual(def.fields.myfield1.offset, 0);
-      assert.strictEqual(def.fields.myfield1.size, 4);
-      assert.strictEqual(def.fields.myfield2.offset, 4);
-      assert.strictEqual(def.fields.myfield2.size, 4);
-    });
-
-    it("should parse data correctly", () => {
-      const def = struct
-        .define(({ field }) => {
-          field.UInt32("myfield1");
-          field.UInt32("myfield2");
-        })
-        .abi({ endianness });
-
-      const buf = def.format({});
-
-      buf[`writeUInt32${endianness}`](20, 0);
-      buf[`writeUInt32${endianness}`](30, 4);
-
-      const data = def.parse(buf);
-      assert.strictEqual(data.myfield1, 20n);
-      assert.strictEqual(data.myfield2, 30n);
-    });
-
-    it("should format data correctly", () => {
-      const def = struct
-        .define(({ field }) => {
-          field.UInt32("myfield1");
-          field.UInt32("myfield2");
-        })
-        .abi({ endianness });
-
-      const buf = def.format({
-        myfield1: 20n,
-        myfield2: 30n,
-      });
-
-      const myfield1 = buf[`readUInt32${endianness}`](0);
-      const myfield2 = buf[`readUInt32${endianness}`](4);
-
-      assert.strictEqual(myfield1, 20);
-      assert.strictEqual(myfield2, 30);
-    });
-  };
-
-  describe("little endian", () => {
-    testEndiannessFor({ endianness: "LE" });
-  });
-
-  describe("big endian", () => {
-    testEndiannessFor({ endianness: "BE" });
-  });
-
-  describe("data models", () => {
-    describe("LP64", () => {
-      const endianness = "LE";
-      const dataModel = "LP64";
-
-      it("should support structure definition", () => {
-        const def = struct
-          .define(({ field }) => {
-            field.Pointer("myfield1");
-            field.Pointer("myfield2");
-          })
-          .abi({ endianness, dataModel });
-
-        assert.strictEqual(def.size, 16);
-        assert.strictEqual(def.fields.myfield1.offset, 0);
-        assert.strictEqual(def.fields.myfield1.size, 8);
-        assert.strictEqual(def.fields.myfield2.offset, 8);
-        assert.strictEqual(def.fields.myfield2.size, 8);
-      });
-
-      it("should parse data correctly", () => {
-        const def = struct
-          .define(({ field }) => {
-            field.Pointer("myfield1");
-            field.Pointer("myfield2");
-          })
-          .abi({ endianness, dataModel });
-
-        const buf = def.format({});
-
-        buf.writeBigUInt64LE(20n, 0);
-        buf.writeBigUInt64LE(30n, 8);
-
-        const data = def.parse(buf);
-        assert.strictEqual(data.myfield1, 20n);
-        assert.strictEqual(data.myfield2, 30n);
-      });
-
-      it("should format data correctly", () => {
-        const def = struct
-          .define(({ field }) => {
-            field.Pointer("myfield1");
-            field.Pointer("myfield2");
-          })
-          .abi({ endianness, dataModel });
-
-        const buf = def.format({
-          myfield1: 20n,
-          myfield2: 30n,
-        });
-
-        const myfield1 = buf.readBigUInt64LE(0);
-        const myfield2 = buf.readBigUInt64LE(8);
-
-        assert.strictEqual(myfield1, 20n);
-        assert.strictEqual(myfield2, 30n);
-      });
-    });
-  });
-
-  describe("alignment models", () => {
-    describe("LP64 - gcc", () => {
-      const endianness = "LE";
-      const dataModel = "LP64";
-      const compiler = "gcc";
-
-      it("should align Int8 correctly", () => {
-        const def = struct
-          .define(({ field }) => {
-            field.Int8("myfield1");
-            field.Int8("myfield2");
-          })
-          .abi({ endianness, dataModel, compiler });
-
-        assert.strictEqual(def.fields.myfield1.offset, 0);
-        assert.strictEqual(def.fields.myfield2.offset, 1);
-      });
-
-      it("should align Int16 correctly", () => {
-        const def = struct
-          .define(({ field }) => {
-            field.Int8("myfield1");
-            field.Int16LE("myfield2");
-          })
-          .abi({ endianness, dataModel, compiler });
-
-        assert.strictEqual(def.fields.myfield1.offset, 0);
-        assert.strictEqual(def.fields.myfield2.offset, 2);
-      });
-
-      it("should align Int32 correctly", () => {
-        const def = struct
-          .define(({ field }) => {
-            field.Int8("myfield1");
-            field.Int32LE("myfield2");
-          })
-          .abi({ endianness, dataModel, compiler });
-
-        assert.strictEqual(def.fields.myfield1.offset, 0);
-        assert.strictEqual(def.fields.myfield2.offset, 4);
-      });
-
-      it("should align Int64 correctly", () => {
-        const def = struct
-          .define(({ field }) => {
-            field.Int8("myfield1");
-            field.Int64LE("myfield2");
-          })
-          .abi({ endianness, dataModel, compiler });
-
-        assert.strictEqual(def.fields.myfield1.offset, 0);
-        assert.strictEqual(def.fields.myfield2.offset, 8);
-      });
-    });
-  });
-
-  const supportedAbiPlatforms = [
-    {
-      arch: "x64",
-      platform: "linux",
-    },
-  ];
-
-  const isHostSupported = supportedAbiPlatforms.some(({ arch, platform }) => {
-    return process.arch === arch && process.platform === platform;
-  });
-
-  describe("host detection", () => {
-    (isHostSupported ? it : it.skip)("should detect host without error", () => {
-      struct.define(() => {}).forHost();
-    });
-  });
-});

package/test/basic.js

@@ -1,92 +0,0 @@
-/* global describe */
-/* global it */
-
-import struct from "../lib/index.js";
-import assert from "assert";
-
-describe("basic", () => {
-  it("should support structure definition", () => {
-    const def = struct
-      .define(({ field }) => {
-        field.UInt32LE("myfield1");
-        field.UInt32LE("myfield2");
-      })
-      .abi({});
-
-    assert.strictEqual(def.size, 8);
-    assert.strictEqual(def.fields.myfield1.offset, 0);
-    assert.strictEqual(def.fields.myfield1.size, 4);
-    assert.strictEqual(def.fields.myfield2.offset, 4);
-    assert.strictEqual(def.fields.myfield2.size, 4);
-  });
-
-  it("should allow empty instantiation", () => {
-    const def = struct
-      .define(({ field }) => {
-        field.UInt32LE("myfield1");
-        field.UInt32LE("myfield2");
-      })
-      .abi({});
-
-    const buf = def.format({});
-
-    assert.strictEqual(buf.length, 8);
-    assert.strictEqual(buf.readUInt32LE(0), 0);
-    assert.strictEqual(buf.readUInt32LE(4), 0);
-  });
-
-  it("should format data correctly", () => {
-    const def = struct
-      .define(({ field }) => {
-        field.UInt32LE("myfield1");
-        field.UInt32LE("myfield2");
-      })
-      .abi({});
-
-    const buf = def.format({
-      myfield1: 10n,
-      myfield2: 20n,
-    });
-
-    assert.strictEqual(buf.length, 8);
-    assert.strictEqual(buf.readUInt32LE(0), 10);
-    assert.strictEqual(buf.readUInt32LE(4), 20);
-  });
-
-  it("should partial-format data correctly", () => {
-    const def = struct
-      .define(({ field }) => {
-        field.UInt32LE("myfield1");
-        field.UInt32LE("myfield2");
-      })
-      .abi({});
-
-    const buf = def.format({
-      myfield2: 20n,
-    });
-
-    assert.strictEqual(buf.length, 8);
-    assert.strictEqual(buf.readUInt32LE(0), 0);
-    assert.strictEqual(buf.readUInt32LE(4), 20);
-  });
-
-  it("should parse data correctly", () => {
-    const def = struct
-      .define(({ field }) => {
-        field.UInt32LE("myfield1");
-        field.UInt32LE("myfield2");
-      })
-      .abi({});
-
-    const buf = def.format({});
-
-    assert.strictEqual(buf.length, 8);
-
-    buf.writeUInt32LE(30, 0);
-
-    const data = def.parse(buf);
-
-    assert.strictEqual(data.myfield1, 30n);
-    assert.strictEqual(data.myfield2, 0n);
-  });
-});

package/test/ctypes.js

@@ -1,166 +0,0 @@
-/* global describe */
-/* global it */
-
-import struct from "../lib/index.js";
-import tmp from "tmp-promise";
-import path from "path";
-import fs from "fs";
-import child_process from "child_process";
-import assert from "assert";
-
-const cTypeNameMap = {
-  signedChar: "signed char",
-  signedShort: "signed short",
-  signedInt: "signed int",
-  signedLong: "signed long",
-  signedLongLong: "signed long long",
-
-  unsignedChar: "unsigned char",
-  unsignedShort: "unsigned short",
-  unsignedInt: "unsigned int",
-  unsignedLong: "unsigned long",
-  unsignedLongLong: "unsigned long long",
-
-  //   float: "float",
-  //   double: "double",
-  //   longDouble: "long double",
-};
-
-const typesToTest = Object.keys(cTypeNameMap);
-
-const exec = (command) => {
-  return new Promise((resolve, reject) => {
-    child_process.exec(command, (err, stdout, stderr) => {
-      if (err) {
-        reject(stderr || err);
-      } else {
-        resolve(stdout);
-      }
-    });
-  });
-};
-
-const compileAndRun = async ({ code }) => {
-  return await tmp.withDir(async (dir) => {
-    const sourceFile = path.resolve(dir.path, "main.c");
-    const binaryFile = path.resolve(dir.path, "main.out");
-
-    await fs.promises.writeFile(sourceFile, code);
-    try {
-      await exec(`gcc "${sourceFile}" -o "${binaryFile}"`);
-      try {
-        return await exec(`"${binaryFile}"`);
-      } finally {
-        await fs.promises.unlink(binaryFile);
-      }
-    } finally {
-      await fs.promises.unlink(sourceFile);
-    }
-  });
-};
-
-const testNativeStructOffsetAndSize = async ({ fields }) => {
-  const code = `
-  #include <stdio.h>
-
-  struct test_struct {
-      ${fields.map((field) => `${field.type} ${field.name};`).join("\n")}
-  };
-
-  int main(int argc, char* argv[]) {
-  ${fields
-    .map((field) => {
-      return `printf("${field.name} %i %i\\n",
-           __builtin_offsetof(struct test_struct, ${field.name}),
-           sizeof(((struct test_struct*) 0)->${field.name}));`;
-    })
-    .join("\n")}
-
-    return 0;
-  }
-    `;
-
-  const output = await compileAndRun({
-    code,
-  });
-
-  let result = {};
-
-  const lines = output
-    .trim()
-    .split("\n")
-    .map((line) => line.trim());
-  lines.forEach((line) => {
-    const parts = line.split(/\s+/);
-    const fieldName = parts[0];
-    const offset = parseInt(parts[1], 10);
-    const size = parseInt(parts[2], 10);
-
-    result = {
-      ...result,
-      [fieldName]: {
-        offset,
-        size,
-      },
-    };
-  });
-
-  return result;
-};
-
-const genTestStructures = ({ numFields }) => {
-  if (numFields === 0) {
-    return [[]];
-  }
-
-  const other = genTestStructures({ numFields: numFields - 1 });
-
-  let result = [];
-  other.forEach((entry) => {
-    typesToTest.forEach((type) => {
-      result = [...result, [type, ...entry]];
-    });
-  });
-
-  return result;
-};
-
-describe("ctypes", () => {
-  const testStructures = genTestStructures({ numFields: 2 });
-
-  testStructures.forEach((testStructure, idx) => {
-    describe(`c test structure #${idx + 1}`, () => {
-      it("should have correct offsets and sizes", async () => {
-        const fields = testStructure.map((typeName, fieldIdx) => {
-          return {
-            name: `field${fieldIdx}`,
-            type: `${cTypeNameMap[typeName]}`,
-          };
-        });
-
-        const result = await testNativeStructOffsetAndSize({ fields });
-
-        const def = struct
-          .define(({ field }) => {
-            testStructure.forEach((typeName, fieldIdx) => {
-              field.CTypes[typeName](`field${fieldIdx}`);
-            });
-          })
-          .forHost();
-
-        let jsFields = {};
-        Object.keys(def.fields).forEach((fieldName) => {
-          jsFields = {
-            ...jsFields,
-            [fieldName]: {
-              offset: def.fields[fieldName].offset,
-              size: def.fields[fieldName].size,
-            },
-          };
-        });
-
-        assert.deepEqual(jsFields, result);
-      });
-    });
-  });
-});

package/test/ref.js

@@ -1,35 +0,0 @@
-/* global describe */
-/* global it */
-
-import struct from "../lib/index.js";
-import assert from "assert";
-
-describe("referencing", () => {
-  it("should allow buffer referencing", () => {
-    const def1 = struct
-      .define(({ field }) => {
-        field.UInt32LE("myfield1");
-        field.UInt32LE("myfield2");
-      })
-      .abi({});
-
-    const def2 = struct
-      .define(({ field }) => {
-        field.UInt64LE("pointerToDef1");
-      })
-      .abi({});
-
-    const buf1 = def1.format({});
-    const buf2 = def2.format({
-      pointerToDef1: buf1,
-    });
-
-    const addr = buf2.readBigUInt64LE(0);
-
-    assert.strictEqual(typeof addr, "bigint");
-    assert(addr !== 0n);
-    assert(Array.isArray(buf2.referencedBuffers));
-    assert.strictEqual(buf2.referencedBuffers.length, 1);
-    assert.strictEqual(buf2.referencedBuffers[0], buf1);
-  });
-});