?HAMA

Navigation

Breadcrumbs

/ / proc / thread-self / root / home / byroehnu / .trash / node_modules11 / restructure / test

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 11.03 KB

/proc/thread-self/root/home/byroehnu/.trash/node_modules11/restructure/test/Number.js

Text Base64

import {
  uint8,
  uint16, uint16be, uint16le,
  uint24, uint24be, uint24le,
  uint32, uint32be, uint32le,
  int8,
  int16, int16be, int16le,
  int24, int24be, int24le,
  int32, int32be, int32le,
  float, floatbe, floatle,
  double, doublebe, doublele,
  fixed16, fixed16be, fixed16le,
  fixed32, fixed32be, fixed32le,
  DecodeStream, EncodeStream
} from 'restructure';
import assert from 'assert';

describe('Number', function() {
  describe('uint8', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xab, 0xff]));
      assert.equal(uint8.decode(stream), 0xab);
      assert.equal(uint8.decode(stream), 0xff);
    });

it('should have a size', () => assert.equal(uint8.size(), 1));

it('should encode', function() {
      assert.deepEqual(uint8.toBuffer(0xab), new Uint8Array([0xab]));
      assert.deepEqual(uint8.toBuffer(0xff), new Uint8Array([0xff]));
    });
  });

describe('uint16', () =>
    it('is an alias for uint16be', () => assert.deepEqual(uint16, uint16be))
  );

describe('uint16be', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xab, 0xff]));
      assert.equal(uint16be.decode(stream), 0xabff);
    });

it('should have a size', () => assert.equal(uint16be.size(), 2));

it('should encode', function() {
      assert.deepEqual(uint16be.toBuffer(0xabff), new Uint8Array([0xab, 0xff]));
    });
  });

describe('uint16le', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xff, 0xab]));
      assert.equal(uint16le.decode(stream), 0xabff);
    });

it('should have a size', () => assert.equal(uint16le.size(), 2));

it('should encode', function() {
      assert.deepEqual(uint16le.toBuffer(0xabff), new Uint8Array([0xff, 0xab]));
    });
  });

describe('uint24', () =>
    it('is an alias for uint24be', () => assert.deepEqual(uint24, uint24be))
  );

describe('uint24be', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24]));
      assert.equal(uint24be.decode(stream), 0xffab24);
    });

it('should have a size', () => assert.equal(uint24be.size(), 3));

it('should encode', function() {
      assert.deepEqual(uint24be.toBuffer(0xffab24), new Uint8Array([0xff, 0xab, 0x24]));
    });
  });

describe('uint24le', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0x24, 0xab, 0xff]));
      assert.equal(uint24le.decode(stream), 0xffab24);
    });

it('should have a size', () => assert.equal(uint24le.size(), 3));

it('should encode', function() {
      assert.deepEqual(uint24le.toBuffer(0xffab24), new Uint8Array([0x24, 0xab, 0xff]));
    });
  });

describe('uint32', () =>
    it('is an alias for uint32be', () => assert.deepEqual(uint32, uint32be))
  );

describe('uint32be', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
      assert.equal(uint32be.decode(stream), 0xffab24bf);
    });

it('should have a size', () => assert.equal(uint32be.size(), 4));

it('should encode', function() {
      assert.deepEqual(uint32be.toBuffer(0xffab24bf), new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
    });
  });

describe('uint32le', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
      assert.equal(uint32le.decode(stream), 0xffab24bf);
    });

it('should have a size', () => assert.equal(uint32le.size(), 4));

it('should encode', function() {
      assert.deepEqual(uint32le.toBuffer(0xffab24bf), new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
    });
  });

describe('int8', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0x7f, 0xff]));
      assert.equal(int8.decode(stream), 127);
      assert.equal(int8.decode(stream), -1);
    });

it('should have a size', () => assert.equal(int8.size(), 1));

it('should encode', function() {
      assert.deepEqual(uint8.toBuffer(127), new Uint8Array([0x7f]));
      assert.deepEqual(uint8.toBuffer(-1), new Uint8Array([0xff]));
    });
  });

describe('int16', () =>
    it('is an alias for int16be', () => assert.deepEqual(int16, int16be))
  );

describe('int16be', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xff, 0xab]));
      assert.equal(int16be.decode(stream), -85);
    });

it('should have a size', () => assert.equal(int16be.size(), 2));

it('should encode', function() {
      assert.deepEqual(int16be.toBuffer(-85), new Uint8Array([0xff, 0xab]));
    });
  });

describe('int16le', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xab, 0xff]));
      assert.equal(int16le.decode(stream), -85);
    });

it('should have a size', () => assert.equal(int16le.size(), 2));

it('should encode', function() {
      assert.deepEqual(int16le.toBuffer(-85), new Uint8Array([0xab, 0xff]));
    });
  });

describe('int24', () =>
    it('is an alias for int24be', () => assert.deepEqual(int24, int24be))
  );

describe('int24be', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24]));
      assert.equal(int24be.decode(stream), -21724);
    });

it('should have a size', () => assert.equal(int24be.size(), 3));

it('should encode', function() {
      assert.deepEqual(int24be.toBuffer(-21724), new Uint8Array([0xff, 0xab, 0x24]));
    });
  });

describe('int24le', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0x24, 0xab, 0xff]));
      assert.equal(int24le.decode(stream), -21724);
    });

it('should have a size', () => assert.equal(int24le.size(), 3));

it('should encode', function() {
      assert.deepEqual(int24le.toBuffer(-21724), new Uint8Array([0x24, 0xab, 0xff]));
    });
  });

describe('int32', () =>
    it('is an alias for int32be', () => assert.deepEqual(int32, int32be))
  );

describe('int32be', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
      assert.equal(int32be.decode(stream), -5561153);
    });

it('should have a size', () => assert.equal(int32be.size(), 4));

it('should encode', function() {
      assert.deepEqual(int32be.toBuffer(-5561153), new Uint8Array([0xff, 0xab, 0x24, 0xbf]));
    });
  });

describe('int32le', function() {
    it('should decode', function() {
      const stream = new DecodeStream(new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
      assert.equal(int32le.decode(stream), -5561153);
    });

it('should have a size', () => assert.equal(int32le.size(), 4));

it('should encode', function() {
      assert.deepEqual(int32le.toBuffer(-5561153), new Uint8Array([0xbf, 0x24, 0xab, 0xff]));
    });
  });

describe('float', () =>
    it('is an alias for floatbe', () => assert.deepEqual(float, floatbe))
  );

describe('floatbe', function() {
    it('should decode', function() {
      const value = floatbe.fromBuffer(new Uint8Array([0x43, 0x7a, 0x8c, 0xcd]));
      assert(value >= 250.55 - 0.005);
      assert(value <= 250.55 + 0.005);
    });

it('should have a size', () => assert.equal(floatbe.size(), 4));

it('should encode', function() {
      assert.deepEqual(floatbe.toBuffer(250.55), new Uint8Array([0x43, 0x7a, 0x8c, 0xcd]));
    });
  });

describe('floatle', function() {
    it('should decode', function() {
      const value = floatle.fromBuffer(new Uint8Array([0xcd, 0x8c, 0x7a, 0x43]));
      assert(value >= 250.55 - 0.005);
      assert(value <= 250.55 + 0.005);
    });

it('should have a size', () => assert.equal(floatle.size(), 4));

it('should encode', function() {
      assert.deepEqual(floatle.toBuffer(250.55), new Uint8Array([0xcd, 0x8c, 0x7a, 0x43]));
    });
  });

describe('double', () =>
    it('is an alias for doublebe', () => assert.deepEqual(double, doublebe))
  );

describe('doublebe', function() {
    it('should decode', function() {
      const value = doublebe.fromBuffer(new Uint8Array([0x40, 0x93, 0x4a, 0x3d, 0x70, 0xa3, 0xd7, 0x0a]));
      assert(value >= 1234.56 - 0.005);
      assert(value <= 1234.56 + 0.005);
    });

it('should have a size', () => assert.equal(doublebe.size(), 8));

it('should encode', function() {
      assert.deepEqual(doublebe.toBuffer(1234.56), new Uint8Array([0x40, 0x93, 0x4a, 0x3d, 0x70, 0xa3, 0xd7, 0x0a]));
    });
  });

describe('doublele', function() {
    it('should decode', function() {
      const value = doublele.fromBuffer(new Uint8Array([0x0a, 0xd7, 0xa3, 0x70, 0x3d, 0x4a, 0x93, 0x40]));
      assert(value >= 1234.56 - 0.005);
      assert(value <= 1234.56 + 0.005);
    });

it('should have a size', () => assert.equal(doublele.size(), 8));

it('should encode', function() {
      assert.deepEqual(doublele.toBuffer(1234.56), new Uint8Array([0x0a, 0xd7, 0xa3, 0x70, 0x3d, 0x4a, 0x93, 0x40]));
    });
  });

describe('fixed16', () =>
    it('is an alias for fixed16be', () => assert.deepEqual(fixed16, fixed16be))
  );

describe('fixed16be', function() {
    it('should decode', function() {
      const value = fixed16be.fromBuffer(new Uint8Array([0x19, 0x57]));
      assert(value >= 25.34 - 0.005);
      assert(value <= 25.34 + 0.005);
    });

it('should have a size', () => assert.equal(fixed16be.size(), 2));

it('should encode', function() {
      assert.deepEqual(fixed16be.toBuffer(25.34), new Uint8Array([0x19, 0x57]));
    });
  });

describe('fixed16le', function() {
    it('should decode', function() {
      const value = fixed16le.fromBuffer(new Uint8Array([0x57, 0x19]));
      assert(value >= 25.34 - 0.005);
      assert(value <= 25.34 + 0.005);
    });

it('should have a size', () => assert.equal(fixed16le.size(), 2));

it('should encode', function() {
      assert.deepEqual(fixed16le.toBuffer(25.34), new Uint8Array([0x57, 0x19]));
    });
  });

describe('fixed32', () =>
    it('is an alias for fixed32be', () => assert.deepEqual(fixed32, fixed32be))
  );

describe('fixed32be', function() {
    it('should decode', function() {
      const value = fixed32be.fromBuffer(new Uint8Array([0x00, 0xfa, 0x8c, 0xcc]));
      assert(value >= 250.55 - 0.005);
      assert(value <= 250.55 + 0.005);
    });

it('should have a size', () => assert.equal(fixed32be.size(), 4));

it('should encode', function() {
      assert.deepEqual(fixed32be.toBuffer(250.55), new Uint8Array([0x00, 0xfa, 0x8c, 0xcc]));
    });
  });

describe('fixed32le', function() {
    it('should decode', function() {
      const value = fixed32le.fromBuffer(new Uint8Array([0xcc, 0x8c, 0xfa, 0x00]));
      assert(value >= 250.55 - 0.005);
      assert(value <= 250.55 + 0.005);
    });

it('should have a size', () => assert.equal(fixed32le.size(), 4));

it('should encode', function() {
      assert.deepEqual(fixed32le.toBuffer(250.55), new Uint8Array([0xcc, 0x8c, 0xfa, 0x00]));
    });
  });
});

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