From 8128a6b55879fd154d97829b18bec476b2e243ee Mon Sep 17 00:00:00 2001 From: Alexander O'Mara Date: Fri, 15 Nov 2024 00:26:47 -0500 Subject: [PATCH] Test macros --- member/f32.test.ts | 26 +++++++++++++---- member/f64.test.ts | 26 +++++++++++++---- member/i16.test.ts | 65 ++++++++++++++++++++++++++++++----------- member/i24.test.ts | 65 ++++++++++++++++++++++++++++++----------- member/i32.test.ts | 65 ++++++++++++++++++++++++++++++----------- member/i64.test.ts | 65 ++++++++++++++++++++++++++++++----------- member/i8.test.ts | 67 ++++++++++++++++++++++++++++++++++++++++--- member/struct.test.ts | 27 +++++++++++++---- member/struct.ts | 2 +- 9 files changed, 321 insertions(+), 87 deletions(-) diff --git a/member/f32.test.ts b/member/f32.test.ts index dade2e5..b39cc6c 100644 --- a/member/f32.test.ts +++ b/member/f32.test.ts @@ -2,6 +2,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberF32 } from './f32.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberF32', () => { const v = new DataView(new ArrayBuffer(4)); @@ -45,7 +46,20 @@ Deno.test('memberF32', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + }; + assertEquals(Test.BYTE_LENGTH, 12); + assertEquals(byteLength(Test), 12); + assertEquals(byteLength(Test, 'alpha'), 4); + assertEquals(byteLength(Test, 'beta'), 4); + assertEquals(byteLength(Test, 'gamma'), 4); + assertEquals(littleEndian(Test, 'alpha'), true); + assertEquals(littleEndian(Test, 'beta'), false); + assertEquals(littleEndian(Test, 'gamma'), null); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -58,9 +72,9 @@ Deno.test('memberF32', () => { assertEquals(test.alpha, f32); assertEquals(test.beta, f32); assertEquals(test.gamma, f32); - assertEquals(view.getFloat32(0, true), f32); - assertEquals(view.getFloat32(4, false), f32); - assertEquals(view.getFloat32(8, false), f32); + assertEquals(view.getFloat32(off.alpha, true), f32); + assertEquals(view.getFloat32(off.beta, false), f32); + assertEquals(view.getFloat32(off.gamma, false), f32); } { const test = new Test(data.buffer, 0, true); @@ -71,9 +85,9 @@ Deno.test('memberF32', () => { assertEquals(test.alpha, f32); assertEquals(test.beta, f32); assertEquals(test.gamma, f32); - assertEquals(view.getFloat32(0, true), f32); - assertEquals(view.getFloat32(4, false), f32); - assertEquals(view.getFloat32(8, true), f32); + assertEquals(view.getFloat32(off.alpha, true), f32); + assertEquals(view.getFloat32(off.beta, false), f32); + assertEquals(view.getFloat32(off.gamma, true), f32); } } }); diff --git a/member/f64.test.ts b/member/f64.test.ts index be86d3c..bba74c2 100644 --- a/member/f64.test.ts +++ b/member/f64.test.ts @@ -2,6 +2,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberF64 } from './f64.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberF64', () => { for ( @@ -41,7 +42,20 @@ Deno.test('memberF64', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + }; + assertEquals(Test.BYTE_LENGTH, 24); + assertEquals(byteLength(Test), 24); + assertEquals(byteLength(Test, 'alpha'), 8); + assertEquals(byteLength(Test, 'beta'), 8); + assertEquals(byteLength(Test, 'gamma'), 8); + assertEquals(littleEndian(Test, 'alpha'), true); + assertEquals(littleEndian(Test, 'beta'), false); + assertEquals(littleEndian(Test, 'gamma'), null); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -54,9 +68,9 @@ Deno.test('memberF64', () => { assertEquals(test.alpha, f64); assertEquals(test.beta, f64); assertEquals(test.gamma, f64); - assertEquals(view.getFloat64(0, true), f64); - assertEquals(view.getFloat64(8, false), f64); - assertEquals(view.getFloat64(16, false), f64); + assertEquals(view.getFloat64(off.alpha, true), f64); + assertEquals(view.getFloat64(off.beta, false), f64); + assertEquals(view.getFloat64(off.gamma, false), f64); } { const test = new Test(data.buffer, 0, true); @@ -67,9 +81,9 @@ Deno.test('memberF64', () => { assertEquals(test.alpha, f64); assertEquals(test.beta, f64); assertEquals(test.gamma, f64); - assertEquals(view.getFloat64(0, true), f64); - assertEquals(view.getFloat64(8, false), f64); - assertEquals(view.getFloat64(16, true), f64); + assertEquals(view.getFloat64(off.alpha, true), f64); + assertEquals(view.getFloat64(off.beta, false), f64); + assertEquals(view.getFloat64(off.gamma, true), f64); } } }); diff --git a/member/i16.test.ts b/member/i16.test.ts index 29a7eef..9a034b1 100644 --- a/member/i16.test.ts +++ b/member/i16.test.ts @@ -2,6 +2,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberI16, memberU16 } from './i16.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberI16', () => { class Test extends Struct { @@ -24,7 +25,23 @@ Deno.test('memberI16', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 8); + assertEquals(byteLength(Test), 8); + assertEquals(byteLength(Test, 'alpha'), 2); + assertEquals(byteLength(Test, 'beta'), 2); + assertEquals(byteLength(Test, 'gamma'), 2); + assertEquals(byteLength(Test, 'delta'), 2); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -39,10 +56,10 @@ Deno.test('memberI16', () => { assertEquals(test.beta, -2); assertEquals(test.gamma, -3); assertEquals(test.delta, -4); - assertEquals(view.getInt16(0, false), 0x7fff); - assertEquals(view.getInt16(2, false), -2); - assertEquals(view.getInt16(4, true), -3); - assertEquals(view.getInt16(6, false), -4); + assertEquals(view.getInt16(off.alpha, false), 0x7fff); + assertEquals(view.getInt16(off.beta, false), -2); + assertEquals(view.getInt16(off.gamma, true), -3); + assertEquals(view.getInt16(off.delta, false), -4); } { const test = new Test(data.buffer, 0, true); @@ -55,10 +72,10 @@ Deno.test('memberI16', () => { assertEquals(test.beta, -2); assertEquals(test.gamma, -3); assertEquals(test.delta, -4); - assertEquals(view.getInt16(0, true), 0x7fff); - assertEquals(view.getInt16(2, true), -2); - assertEquals(view.getInt16(4, true), -3); - assertEquals(view.getInt16(6, false), -4); + assertEquals(view.getInt16(off.alpha, true), 0x7fff); + assertEquals(view.getInt16(off.beta, true), -2); + assertEquals(view.getInt16(off.gamma, true), -3); + assertEquals(view.getInt16(off.delta, false), -4); } }); @@ -83,7 +100,23 @@ Deno.test('memberU16', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 8); + assertEquals(byteLength(Test), 8); + assertEquals(byteLength(Test, 'alpha'), 2); + assertEquals(byteLength(Test, 'beta'), 2); + assertEquals(byteLength(Test, 'gamma'), 2); + assertEquals(byteLength(Test, 'delta'), 2); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -98,10 +131,10 @@ Deno.test('memberU16', () => { assertEquals(test.beta, 0xfffe); assertEquals(test.gamma, 0xfffd); assertEquals(test.delta, 0xfffc); - assertEquals(view.getUint16(0, false), 0x7fff); - assertEquals(view.getUint16(2, false), 0xfffe); - assertEquals(view.getUint16(4, true), 0xfffd); - assertEquals(view.getUint16(6, false), 0xfffc); + assertEquals(view.getUint16(off.alpha, false), 0x7fff); + assertEquals(view.getUint16(off.beta, false), 0xfffe); + assertEquals(view.getUint16(off.gamma, true), 0xfffd); + assertEquals(view.getUint16(off.delta, false), 0xfffc); } { const test = new Test(data.buffer, 0, true); @@ -114,9 +147,9 @@ Deno.test('memberU16', () => { assertEquals(test.beta, 0xfffe); assertEquals(test.gamma, 0xfffd); assertEquals(test.delta, 0xfffc); - assertEquals(view.getUint16(0, true), 0x7fff); - assertEquals(view.getUint16(2, true), 0xfffe); - assertEquals(view.getUint16(4, true), 0xfffd); - assertEquals(view.getUint16(6, false), 0xfffc); + assertEquals(view.getUint16(off.alpha, true), 0x7fff); + assertEquals(view.getUint16(off.beta, true), 0xfffe); + assertEquals(view.getUint16(off.gamma, true), 0xfffd); + assertEquals(view.getUint16(off.delta, false), 0xfffc); } }); diff --git a/member/i24.test.ts b/member/i24.test.ts index 03b9051..42aa510 100644 --- a/member/i24.test.ts +++ b/member/i24.test.ts @@ -3,6 +3,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberI24, memberU24 } from './i24.ts'; import { getInt24, getUint24 } from '../dataview.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberI24', () => { class Test extends Struct { @@ -25,7 +26,23 @@ Deno.test('memberI24', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 12); + assertEquals(byteLength(Test), 12); + assertEquals(byteLength(Test, 'alpha'), 3); + assertEquals(byteLength(Test, 'beta'), 3); + assertEquals(byteLength(Test, 'gamma'), 3); + assertEquals(byteLength(Test, 'delta'), 3); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -40,10 +57,10 @@ Deno.test('memberI24', () => { assertEquals(test.beta, -2); assertEquals(test.gamma, -3); assertEquals(test.delta, -4); - assertEquals(getInt24(view, 0, false), 0x7fffff); - assertEquals(getInt24(view, 3, false), -2); - assertEquals(getInt24(view, 6, true), -3); - assertEquals(getInt24(view, 9, false), -4); + assertEquals(getInt24(view, off.alpha, false), 0x7fffff); + assertEquals(getInt24(view, off.beta, false), -2); + assertEquals(getInt24(view, off.gamma, true), -3); + assertEquals(getInt24(view, off.delta, false), -4); } { const test = new Test(data.buffer, 0, true); @@ -56,10 +73,10 @@ Deno.test('memberI24', () => { assertEquals(test.beta, -2); assertEquals(test.gamma, -3); assertEquals(test.delta, -4); - assertEquals(getInt24(view, 0, true), 0x7fffff); - assertEquals(getInt24(view, 3, true), -2); - assertEquals(getInt24(view, 6, true), -3); - assertEquals(getInt24(view, 9, false), -4); + assertEquals(getInt24(view, off.alpha, true), 0x7fffff); + assertEquals(getInt24(view, off.beta, true), -2); + assertEquals(getInt24(view, off.gamma, true), -3); + assertEquals(getInt24(view, off.delta, false), -4); } }); @@ -84,7 +101,23 @@ Deno.test('memberU24', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 12); + assertEquals(byteLength(Test), 12); + assertEquals(byteLength(Test, 'alpha'), 3); + assertEquals(byteLength(Test, 'beta'), 3); + assertEquals(byteLength(Test, 'gamma'), 3); + assertEquals(byteLength(Test, 'delta'), 3); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -99,10 +132,10 @@ Deno.test('memberU24', () => { assertEquals(test.beta, 0xfffffe); assertEquals(test.gamma, 0xfffffd); assertEquals(test.delta, 0xfffffc); - assertEquals(getUint24(view, 0, false), 0x7fffff); - assertEquals(getUint24(view, 3, false), 0xfffffe); - assertEquals(getUint24(view, 6, true), 0xfffffd); - assertEquals(getUint24(view, 9, false), 0xfffffc); + assertEquals(getUint24(view, off.alpha, false), 0x7fffff); + assertEquals(getUint24(view, off.beta, false), 0xfffffe); + assertEquals(getUint24(view, off.gamma, true), 0xfffffd); + assertEquals(getUint24(view, off.delta, false), 0xfffffc); } { const test = new Test(data.buffer, 0, true); @@ -115,9 +148,9 @@ Deno.test('memberU24', () => { assertEquals(test.beta, 0xfffffe); assertEquals(test.gamma, 0xfffffd); assertEquals(test.delta, 0xfffffc); - assertEquals(getUint24(view, 0, true), 0x7fffff); - assertEquals(getUint24(view, 3, true), 0xfffffe); - assertEquals(getUint24(view, 6, true), 0xfffffd); - assertEquals(getUint24(view, 9, false), 0xfffffc); + assertEquals(getUint24(view, off.alpha, true), 0x7fffff); + assertEquals(getUint24(view, off.beta, true), 0xfffffe); + assertEquals(getUint24(view, off.gamma, true), 0xfffffd); + assertEquals(getUint24(view, off.delta, false), 0xfffffc); } }); diff --git a/member/i32.test.ts b/member/i32.test.ts index d59495b..ab5ef08 100644 --- a/member/i32.test.ts +++ b/member/i32.test.ts @@ -2,6 +2,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberI32, memberU32 } from './i32.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberI32', () => { class Test extends Struct { @@ -24,7 +25,23 @@ Deno.test('memberI32', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 16); + assertEquals(byteLength(Test), 16); + assertEquals(byteLength(Test, 'alpha'), 4); + assertEquals(byteLength(Test, 'beta'), 4); + assertEquals(byteLength(Test, 'gamma'), 4); + assertEquals(byteLength(Test, 'delta'), 4); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -39,10 +56,10 @@ Deno.test('memberI32', () => { assertEquals(test.beta, -2); assertEquals(test.gamma, -3); assertEquals(test.delta, -4); - assertEquals(view.getInt32(0, false), 0x7fffffff); - assertEquals(view.getInt32(4, false), -2); - assertEquals(view.getInt32(8, true), -3); - assertEquals(view.getInt32(12, false), -4); + assertEquals(view.getInt32(off.alpha, false), 0x7fffffff); + assertEquals(view.getInt32(off.beta, false), -2); + assertEquals(view.getInt32(off.gamma, true), -3); + assertEquals(view.getInt32(off.delta, false), -4); } { const test = new Test(data.buffer, 0, true); @@ -55,10 +72,10 @@ Deno.test('memberI32', () => { assertEquals(test.beta, -2); assertEquals(test.gamma, -3); assertEquals(test.delta, -4); - assertEquals(view.getInt32(0, true), 0x7fffffff); - assertEquals(view.getInt32(4, true), -2); - assertEquals(view.getInt32(8, true), -3); - assertEquals(view.getInt32(12, false), -4); + assertEquals(view.getInt32(off.alpha, true), 0x7fffffff); + assertEquals(view.getInt32(off.beta, true), -2); + assertEquals(view.getInt32(off.gamma, true), -3); + assertEquals(view.getInt32(off.delta, false), -4); } }); @@ -83,7 +100,23 @@ Deno.test('memberU32', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 16); + assertEquals(byteLength(Test), 16); + assertEquals(byteLength(Test, 'alpha'), 4); + assertEquals(byteLength(Test, 'beta'), 4); + assertEquals(byteLength(Test, 'gamma'), 4); + assertEquals(byteLength(Test, 'delta'), 4); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -98,10 +131,10 @@ Deno.test('memberU32', () => { assertEquals(test.beta, 0xfffffffe); assertEquals(test.gamma, 0xfffffffd); assertEquals(test.delta, 0xfffffffc); - assertEquals(view.getUint32(0, false), 0x7fffffff); - assertEquals(view.getUint32(4, false), 0xfffffffe); - assertEquals(view.getUint32(8, true), 0xfffffffd); - assertEquals(view.getUint32(12, false), 0xfffffffc); + assertEquals(view.getUint32(off.alpha, false), 0x7fffffff); + assertEquals(view.getUint32(off.beta, false), 0xfffffffe); + assertEquals(view.getUint32(off.gamma, true), 0xfffffffd); + assertEquals(view.getUint32(off.delta, false), 0xfffffffc); } { const test = new Test(data.buffer, 0, true); @@ -114,9 +147,9 @@ Deno.test('memberU32', () => { assertEquals(test.beta, 0xfffffffe); assertEquals(test.gamma, 0xfffffffd); assertEquals(test.delta, 0xfffffffc); - assertEquals(view.getUint32(0, true), 0x7fffffff); - assertEquals(view.getUint32(4, true), 0xfffffffe); - assertEquals(view.getUint32(8, true), 0xfffffffd); - assertEquals(view.getUint32(12, false), 0xfffffffc); + assertEquals(view.getUint32(off.alpha, true), 0x7fffffff); + assertEquals(view.getUint32(off.beta, true), 0xfffffffe); + assertEquals(view.getUint32(off.gamma, true), 0xfffffffd); + assertEquals(view.getUint32(off.delta, false), 0xfffffffc); } }); diff --git a/member/i64.test.ts b/member/i64.test.ts index 76b8dc8..ada93ab 100644 --- a/member/i64.test.ts +++ b/member/i64.test.ts @@ -2,6 +2,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberI64, memberU64 } from './i64.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberI64', () => { class Test extends Struct { @@ -24,7 +25,23 @@ Deno.test('memberI64', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 32); + assertEquals(byteLength(Test), 32); + assertEquals(byteLength(Test, 'alpha'), 8); + assertEquals(byteLength(Test, 'beta'), 8); + assertEquals(byteLength(Test, 'gamma'), 8); + assertEquals(byteLength(Test, 'delta'), 8); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -39,10 +56,10 @@ Deno.test('memberI64', () => { assertEquals(test.beta, -2n); assertEquals(test.gamma, -3n); assertEquals(test.delta, -4n); - assertEquals(view.getBigInt64(0, false), 0x7fffffffffffffffn); - assertEquals(view.getBigInt64(8, false), -2n); - assertEquals(view.getBigInt64(16, true), -3n); - assertEquals(view.getBigInt64(24, false), -4n); + assertEquals(view.getBigInt64(off.alpha, false), 0x7fffffffffffffffn); + assertEquals(view.getBigInt64(off.beta, false), -2n); + assertEquals(view.getBigInt64(off.gamma, true), -3n); + assertEquals(view.getBigInt64(off.delta, false), -4n); } { const test = new Test(data.buffer, 0, true); @@ -55,10 +72,10 @@ Deno.test('memberI64', () => { assertEquals(test.beta, -2n); assertEquals(test.gamma, -3n); assertEquals(test.delta, -4n); - assertEquals(view.getBigInt64(0, true), 0x7fffffffffffffffn); - assertEquals(view.getBigInt64(8, true), -2n); - assertEquals(view.getBigInt64(16, true), -3n); - assertEquals(view.getBigInt64(24, false), -4n); + assertEquals(view.getBigInt64(off.alpha, true), 0x7fffffffffffffffn); + assertEquals(view.getBigInt64(off.beta, true), -2n); + assertEquals(view.getBigInt64(off.gamma, true), -3n); + assertEquals(view.getBigInt64(off.delta, false), -4n); } }); @@ -83,7 +100,23 @@ Deno.test('memberU64', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + delta: byteOffset(Test, 'delta'), + }; + assertEquals(Test.BYTE_LENGTH, 32); + assertEquals(byteLength(Test), 32); + assertEquals(byteLength(Test, 'alpha'), 8); + assertEquals(byteLength(Test, 'beta'), 8); + assertEquals(byteLength(Test, 'gamma'), 8); + assertEquals(byteLength(Test, 'delta'), 8); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), true); + assertEquals(littleEndian(Test, 'delta'), false); const data = new Uint8Array(Test.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -98,10 +131,10 @@ Deno.test('memberU64', () => { assertEquals(test.beta, 0xfffffffffffffffen); assertEquals(test.gamma, 0xfffffffffffffffdn); assertEquals(test.delta, 0xfffffffffffffffcn); - assertEquals(view.getBigUint64(0, false), 0x7fffffffffffffffn); - assertEquals(view.getBigUint64(8, false), 0xfffffffffffffffen); - assertEquals(view.getBigUint64(16, true), 0xfffffffffffffffdn); - assertEquals(view.getBigUint64(24, false), 0xfffffffffffffffcn); + assertEquals(view.getBigUint64(off.alpha, false), 0x7fffffffffffffffn); + assertEquals(view.getBigUint64(off.beta, false), 0xfffffffffffffffen); + assertEquals(view.getBigUint64(off.gamma, true), 0xfffffffffffffffdn); + assertEquals(view.getBigUint64(off.delta, false), 0xfffffffffffffffcn); } { const test = new Test(data.buffer, 0, true); @@ -114,9 +147,9 @@ Deno.test('memberU64', () => { assertEquals(test.beta, 0xfffffffffffffffen); assertEquals(test.gamma, 0xfffffffffffffffdn); assertEquals(test.delta, 0xfffffffffffffffcn); - assertEquals(view.getBigUint64(0, true), 0x7fffffffffffffffn); - assertEquals(view.getBigUint64(8, true), 0xfffffffffffffffen); - assertEquals(view.getBigUint64(16, true), 0xfffffffffffffffdn); - assertEquals(view.getBigUint64(24, false), 0xfffffffffffffffcn); + assertEquals(view.getBigUint64(off.alpha, true), 0x7fffffffffffffffn); + assertEquals(view.getBigUint64(off.beta, true), 0xfffffffffffffffen); + assertEquals(view.getBigUint64(off.gamma, true), 0xfffffffffffffffdn); + assertEquals(view.getBigUint64(off.delta, false), 0xfffffffffffffffcn); } }); diff --git a/member/i8.test.ts b/member/i8.test.ts index 6978eee..2e63cd0 100644 --- a/member/i8.test.ts +++ b/member/i8.test.ts @@ -2,6 +2,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberI8, memberI8A, memberU8, memberU8A } from './i8.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberI8', () => { class Test extends Struct { @@ -18,7 +19,17 @@ Deno.test('memberI8', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + }; + assertEquals(Test.BYTE_LENGTH, 2); + assertEquals(byteLength(Test), 2); + assertEquals(byteLength(Test, 'alpha'), 1); + assertEquals(byteLength(Test, 'beta'), 1); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); const data = new Uint8Array(Test.BYTE_LENGTH); const test = new Test(data.buffer); @@ -27,7 +38,8 @@ Deno.test('memberI8', () => { assertEquals(test.alpha, 0x7f); assertEquals(test.beta, -1); - assertEquals(data, new Uint8Array([0x7f, 0xff])); + assertEquals(data[off.alpha], 0x7f); + assertEquals(data[off.beta], 0xff); }); Deno.test('memberU8', () => { @@ -45,7 +57,17 @@ Deno.test('memberU8', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + }; + assertEquals(Test.BYTE_LENGTH, 2); + assertEquals(byteLength(Test), 2); + assertEquals(byteLength(Test, 'alpha'), 1); + assertEquals(byteLength(Test, 'beta'), 1); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); const data = new Uint8Array(Test.BYTE_LENGTH); const test = new Test(data.buffer); @@ -54,7 +76,8 @@ Deno.test('memberU8', () => { assertEquals(test.alpha, 0x7f); assertEquals(test.beta, 0xff); - assertEquals(data, new Uint8Array([0x7f, 0xff])); + assertEquals(data[off.alpha], 0x7f); + assertEquals(data[off.beta], 0xff); }); Deno.test('memberI8A', () => { @@ -75,7 +98,20 @@ Deno.test('memberI8A', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + }; + assertEquals(Test.BYTE_LENGTH, 6); + assertEquals(byteLength(Test), 6); + assertEquals(byteLength(Test, 'alpha'), 2); + assertEquals(byteLength(Test, 'beta'), 4); + assertEquals(byteLength(Test, 'gamma'), 0); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), null); const data = new Uint8Array(Test.BYTE_LENGTH); const test = new Test(data.buffer); @@ -87,7 +123,12 @@ Deno.test('memberI8A', () => { test.beta[3] = -3; assertEquals(test.gamma.length, 0); - assertEquals(data, new Uint8Array([1, 0xff, 2, 0xfe, 3, 0xfd])); + assertEquals(data[off.alpha], 1); + assertEquals(data[off.alpha + 1], 0xff); + assertEquals(data[off.beta], 2); + assertEquals(data[off.beta + 1], 0xfe); + assertEquals(data[off.beta + 2], 3); + assertEquals(data[off.beta + 3], 0xfd); }); Deno.test('memberU8A', () => { @@ -108,7 +149,20 @@ Deno.test('memberU8A', () => { })(super.BYTE_LENGTH); } + const off = { + alpha: byteOffset(Test, 'alpha'), + beta: byteOffset(Test, 'beta'), + gamma: byteOffset(Test, 'gamma'), + }; + assertEquals(Test.BYTE_LENGTH, 6); + assertEquals(byteLength(Test), 6); + assertEquals(byteLength(Test, 'alpha'), 2); + assertEquals(byteLength(Test, 'beta'), 4); + assertEquals(byteLength(Test, 'gamma'), 0); + assertEquals(littleEndian(Test, 'alpha'), null); + assertEquals(littleEndian(Test, 'beta'), null); + assertEquals(littleEndian(Test, 'gamma'), null); const data = new Uint8Array(Test.BYTE_LENGTH); const test = new Test(data.buffer); @@ -120,5 +174,10 @@ Deno.test('memberU8A', () => { test.beta[3] = 0xfd; assertEquals(test.gamma.length, 0); - assertEquals(data, new Uint8Array([1, 0xff, 2, 0xfe, 3, 0xfd])); + assertEquals(data[off.alpha], 1); + assertEquals(data[off.alpha + 1], 0xff); + assertEquals(data[off.beta], 2); + assertEquals(data[off.beta + 1], 0xfe); + assertEquals(data[off.beta + 2], 3); + assertEquals(data[off.beta + 3], 0xfd); }); diff --git a/member/struct.test.ts b/member/struct.test.ts index e2e04f9..08ba873 100644 --- a/member/struct.test.ts +++ b/member/struct.test.ts @@ -3,6 +3,7 @@ import { assertEquals } from '@std/assert'; import { Struct } from '../struct.ts'; import { memberU32 } from './i32.ts'; import { memberStruct } from './struct.ts'; +import { byteLength, byteOffset, littleEndian } from '../macro.ts'; Deno.test('memberStruct', () => { class TestChild extends Struct { @@ -36,7 +37,21 @@ Deno.test('memberStruct', () => { })(super.BYTE_LENGTH); } + const offBeta = byteOffset(TestChild, 'beta'); + const off = { + alpha: byteOffset(TestParent, 'alpha'), + beta: byteOffset(TestParent, 'beta'), + gamma: byteOffset(TestParent, 'gamma'), + }; + assertEquals(TestParent.BYTE_LENGTH, 24); + assertEquals(byteLength(TestParent), 24); + assertEquals(byteLength(TestParent, 'alpha'), 8); + assertEquals(byteLength(TestParent, 'beta'), 8); + assertEquals(byteLength(TestParent, 'gamma'), 8); + assertEquals(littleEndian(TestParent, 'alpha'), true); + assertEquals(littleEndian(TestParent, 'beta'), false); + assertEquals(littleEndian(TestParent, 'gamma'), null); const data = new Uint8Array(TestParent.BYTE_LENGTH); const view = new DataView(data.buffer); @@ -52,9 +67,9 @@ Deno.test('memberStruct', () => { assertEquals(test.alpha.beta, 0x12345678); assertEquals(test.beta.beta, 0x23456789); assertEquals(test.gamma.beta, 0x34567890); - assertEquals(view.getUint32(4, true), 0x12345678); - assertEquals(view.getUint32(12, false), 0x23456789); - assertEquals(view.getUint32(20, true), 0x34567890); + assertEquals(view.getUint32(off.alpha + offBeta, true), 0x12345678); + assertEquals(view.getUint32(off.beta + offBeta, false), 0x23456789); + assertEquals(view.getUint32(off.gamma + offBeta, true), 0x34567890); } { const test = new TestParent(data.buffer, 0, false); @@ -68,8 +83,8 @@ Deno.test('memberStruct', () => { assertEquals(test.alpha.beta, 0x12345678); assertEquals(test.beta.beta, 0x23456789); assertEquals(test.gamma.beta, 0x34567890); - assertEquals(view.getUint32(4, true), 0x12345678); - assertEquals(view.getUint32(12, false), 0x23456789); - assertEquals(view.getUint32(20, false), 0x34567890); + assertEquals(view.getUint32(off.alpha + offBeta, true), 0x12345678); + assertEquals(view.getUint32(off.beta + offBeta, false), 0x23456789); + assertEquals(view.getUint32(off.gamma + offBeta, false), 0x34567890); } }); diff --git a/member/struct.ts b/member/struct.ts index a744747..49c90a8 100644 --- a/member/struct.ts +++ b/member/struct.ts @@ -28,5 +28,5 @@ export function memberStruct( ); }, }); - return member(StructM, name, byteOffset, StructM.BYTE_LENGTH, littleEndian); + return member(StructT, name, byteOffset, StructM.BYTE_LENGTH, littleEndian); }