?HAMA

Navigation

Breadcrumbs

/ / home / byroehnu / .trash / node_modules11 / restructure / test

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 9.48 KB

/home/byroehnu/.trash/node_modules11/restructure/test/Pointer.js

Text Base64

import assert from 'assert';
import {Pointer, VoidPointer, uint8, DecodeStream, EncodeStream, Struct} from 'restructure';

describe('Pointer', function() {
  describe('decode', function() {
    it('should handle null pointers', function() {
      const stream = new DecodeStream(new Uint8Array([0]));
      const pointer = new Pointer(uint8, uint8);
      return assert.equal(pointer.decode(stream, {_startOffset: 50}), null);
    });

it('should use local offsets from start of parent by default', function() {
      const stream = new DecodeStream(new Uint8Array([1, 53]));
      const pointer = new Pointer(uint8, uint8);
      assert.equal(pointer.decode(stream, {_startOffset: 0}), 53);
    });

it('should support immediate offsets', function() {
      const stream = new DecodeStream(new Uint8Array([1, 53]));
      const pointer = new Pointer(uint8, uint8, {type: 'immediate'});
      assert.equal(pointer.decode(stream), 53);
    });

it('should support offsets relative to the parent', function() {
      const stream = new DecodeStream(new Uint8Array([0, 0, 1, 53]));
      stream.pos = 2;
      const pointer = new Pointer(uint8, uint8, {type: 'parent'});
      assert.equal(pointer.decode(stream, {parent: {_startOffset: 2}}), 53);
    });

it('should support global offsets', function() {
      const stream = new DecodeStream(new Uint8Array([1, 2, 4, 0, 0, 0, 53]));
      const pointer = new Pointer(uint8, uint8, {type: 'global'});
      stream.pos = 2;
      assert.equal(pointer.decode(stream, {parent: {parent: {_startOffset: 2}}}), 53);
    });

it('should support offsets relative to a property on the parent', function() {
      const stream = new DecodeStream(new Uint8Array([1, 0, 0, 0, 0, 53]));
      const pointer = new Pointer(uint8, uint8, {relativeTo: ctx => ctx.parent.ptr});
      assert.equal(pointer.decode(stream, {_startOffset: 0, parent: {ptr: 4}}), 53);
    });

it('should throw when passing a non function relativeTo option', function() {
      return assert.throws(() => new Pointer(uint8, uint8, {relativeTo: 'parent.ptr'}));
    });

it('should support returning pointer if there is no decode type', function() {
      const stream = new DecodeStream(new Uint8Array([4]));
      const pointer = new Pointer(uint8, 'void');
      assert.equal(pointer.decode(stream, {_startOffset: 0}), 4);
    });

it('should support decoding pointers lazily', function() {
      const stream = new DecodeStream(new Uint8Array([1, 53]));
      const struct = new Struct({
        ptr: new Pointer(uint8, uint8, {lazy: true})});

const res = struct.decode(stream);
      assert.equal(typeof Object.getOwnPropertyDescriptor(res, 'ptr').get, 'function');
      assert.equal(Object.getOwnPropertyDescriptor(res, 'ptr').enumerable, true);
      assert.equal(res.ptr, 53);
    });
  });

describe('size', function() {
    it('should add to local pointerSize', function() {
      const pointer = new Pointer(uint8, uint8);
      const ctx = {pointerSize: 0};
      assert.equal(pointer.size(10, ctx), 1);
      assert.equal(ctx.pointerSize, 1);
    });

it('should add to immediate pointerSize', function() {
      const pointer = new Pointer(uint8, uint8, {type: 'immediate'});
      const ctx = {pointerSize: 0};
      assert.equal(pointer.size(10, ctx), 1);
      assert.equal(ctx.pointerSize, 1);
    });

it('should add to parent pointerSize', function() {
      const pointer = new Pointer(uint8, uint8, {type: 'parent'});
      const ctx = {parent: {pointerSize: 0}};
      assert.equal(pointer.size(10, ctx), 1);
      assert.equal(ctx.parent.pointerSize, 1);
    });

it('should add to global pointerSize', function() {
      const pointer = new Pointer(uint8, uint8, {type: 'global'});
      const ctx = {parent: {parent: {parent: {pointerSize: 0}}}};
      assert.equal(pointer.size(10, ctx), 1);
      assert.equal(ctx.parent.parent.parent.pointerSize, 1);
    });

it('should handle void pointers', function() {
      const pointer = new Pointer(uint8, 'void');
      const ctx = {pointerSize: 0};
      assert.equal(pointer.size(new VoidPointer(uint8, 50), ctx), 1);
      assert.equal(ctx.pointerSize, 1);
    });

it('should throw if no type and not a void pointer', function() {
      const pointer = new Pointer(uint8, 'void');
      const ctx = {pointerSize: 0};
      assert.throws(() => pointer.size(30, ctx));
    });

it('should return a fixed size without a value', function() {
      const pointer = new Pointer(uint8, uint8);
      assert.equal(pointer.size(), 1);
    });
  });

describe('encode', function() {
    it('should handle null pointers', function() {
      const ptr = new Pointer(uint8, uint8);
      const ctx = {
        pointerSize: 0,
        startOffset: 0,
        pointerOffset: 0,
        pointers: []
      };

const stream = new EncodeStream(new Uint8Array(ptr.size(null)));
      ptr.encode(stream, null, ctx);
      assert.equal(ctx.pointerSize, 0);

assert.deepEqual(stream.buffer, new Uint8Array([0]));
    });

it('should handle local offsets', function() {
      const ptr = new Pointer(uint8, uint8);
      const ctx = {
        pointerSize: 0,
        startOffset: 0,
        pointerOffset: 1,
        pointers: []
      };

const stream = new EncodeStream(new Uint8Array(ptr.size(10)));
      ptr.encode(stream, 10, ctx);
      assert.equal(ctx.pointerOffset, 2);
      assert.deepEqual(ctx.pointers, [
        { type: uint8, val: 10, parent: ctx }
      ]);

assert.deepEqual(stream.buffer, new Uint8Array([1]));
    });

it('should handle immediate offsets', function() {
      const ptr = new Pointer(uint8, uint8, {type: 'immediate'});
      const ctx = {
        pointerSize: 0,
        startOffset: 0,
        pointerOffset: 1,
        pointers: []
      };

assert.deepEqual(stream.buffer, new Uint8Array([0]));
    });

it('should handle offsets relative to parent', function() {
      const ptr = new Pointer(uint8, uint8, {type: 'parent'});
      const ctx = {
        parent: {
          pointerSize: 0,
          startOffset: 3,
          pointerOffset: 5,
          pointers: []
        }
      };

assert.deepEqual(stream.buffer, new Uint8Array([2]));
    });

it('should handle global offsets', function() {
      const ptr = new Pointer(uint8, uint8, {type: 'global'});
      const ctx = {
        parent: {
          parent: {
            parent: {
              pointerSize: 0,
              startOffset: 3,
              pointerOffset: 5,
              pointers: []
            }
          }
        }
      };

const stream = new EncodeStream(new Uint8Array(ptr.size(10, JSON.parse(JSON.stringify(ctx)))));
      ptr.encode(stream, 10, ctx);
      assert.equal(ctx.parent.parent.parent.pointerOffset, 6);
      assert.deepEqual(ctx.parent.parent.parent.pointers, [
        { type: uint8, val: 10, parent: ctx }
      ]);

assert.deepEqual(stream.buffer, new Uint8Array([5]));
    });

it('should support offsets relative to a property on the parent', function() {
      const ptr = new Pointer(uint8, uint8, {relativeTo: ctx => ctx.ptr});
      const ctx = {
        pointerSize: 0,
        startOffset: 0,
        pointerOffset: 10,
        pointers: [],
        val: {
          ptr: 4
        }
      };

const stream = new EncodeStream(new Uint8Array(ptr.size(10, {...ctx})));
      ptr.encode(stream, 10, ctx);
      assert.equal(ctx.pointerOffset, 11);
      assert.deepEqual(ctx.pointers, [
        { type: uint8, val: 10, parent: ctx }
      ]);

assert.deepEqual(stream.buffer, new Uint8Array([6]));
    });

it('should support void pointers', function() {
      const ptr = new Pointer(uint8, 'void');
      const ctx = {
        pointerSize: 0,
        startOffset: 0,
        pointerOffset: 1,
        pointers: []
      };

const val = new VoidPointer(uint8, 55);
      const stream = new EncodeStream(new Uint8Array(ptr.size(val, {...ctx})));
      ptr.encode(stream, val, ctx);
      assert.equal(ctx.pointerOffset, 2);
      assert.deepEqual(ctx.pointers, [
        { type: uint8, val: 55, parent: ctx }
      ]);

assert.deepEqual(stream.buffer, new Uint8Array([1]));
    });

it('should throw if not a void pointer instance', function() {
      const ptr = new Pointer(uint8, 'void');
      const ctx = {
        pointerSize: 0,
        startOffset: 0,
        pointerOffset: 1,
        pointers: []
      };

const stream = new EncodeStream(new Uint8Array(0));
      assert.throws(() => ptr.encode(stream, 44, ctx));
    });
  });
});

Exit & Reset Text mode: syntax highlighting auto-detects file type.

Directory Contents

Dirs: 0 × Files: 15

Sort:

Enable drag-to-move

Name	Size	Perms	Modified	Actions
Array.js	3.97 KB	lrw-r--r--	2026-02-14 19:19:14	Edit Download recursive recursive
Bitfield.js	1.04 KB	lrw-r--r--	2026-02-14 19:19:14	Edit Download recursive recursive
Boolean.js	1.15 KB	lrw-r--r--	2026-02-14 19:19:16	Edit Download recursive recursive
Buffer.js	1.53 KB	lrw-r--r--	2026-02-14 19:19:16	Edit Download recursive recursive
DecodeStream.js	3.53 KB	lrw-r--r--	2026-02-14 19:19:16	Edit Download recursive recursive
EncodeStream.js	3.74 KB	lrw-r--r--	2026-02-14 19:19:16	Edit Download recursive recursive
Enum.js	831 B	lrw-r--r--	2026-02-14 19:19:16	Edit Download recursive recursive
LazyArray.js	1.87 KB	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive
Number.js	11.03 KB	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive
Optional.js	3.83 KB	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive
Pointer.js	9.48 KB	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive
Reserved.js	820 B	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive
String.js	5.61 KB	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive
Struct.js	3.45 KB	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive
VersionedStruct.js	11.37 KB	lrw-r--r--	2026-02-14 19:19:18	Edit Download recursive recursive