• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1'use strict';
2const common = require('../../common');
3const assert = require('assert');
4
5// Testing api calls for arrays
6const test_typedarray = require(`./build/${common.buildType}/test_typedarray`);
7
8const byteArray = new Uint8Array(3);
9byteArray[0] = 0;
10byteArray[1] = 1;
11byteArray[2] = 2;
12assert.strictEqual(byteArray.length, 3);
13
14const doubleArray = new Float64Array(3);
15doubleArray[0] = 0.0;
16doubleArray[1] = 1.1;
17doubleArray[2] = 2.2;
18assert.strictEqual(doubleArray.length, 3);
19
20const byteResult = test_typedarray.Multiply(byteArray, 3);
21assert.ok(byteResult instanceof Uint8Array);
22assert.strictEqual(byteResult.length, 3);
23assert.strictEqual(byteResult[0], 0);
24assert.strictEqual(byteResult[1], 3);
25assert.strictEqual(byteResult[2], 6);
26
27const doubleResult = test_typedarray.Multiply(doubleArray, -3);
28assert.ok(doubleResult instanceof Float64Array);
29assert.strictEqual(doubleResult.length, 3);
30assert.strictEqual(doubleResult[0], -0);
31assert.strictEqual(Math.round(10 * doubleResult[1]) / 10, -3.3);
32assert.strictEqual(Math.round(10 * doubleResult[2]) / 10, -6.6);
33
34const externalResult = test_typedarray.External();
35assert.ok(externalResult instanceof Int8Array);
36assert.strictEqual(externalResult.length, 3);
37assert.strictEqual(externalResult[0], 0);
38assert.strictEqual(externalResult[1], 1);
39assert.strictEqual(externalResult[2], 2);
40
41// Validate creation of all kinds of TypedArrays
42const buffer = new ArrayBuffer(128);
43const arrayTypes = [ Int8Array, Uint8Array, Uint8ClampedArray, Int16Array,
44                     Uint16Array, Int32Array, Uint32Array, Float32Array,
45                     Float64Array, BigInt64Array, BigUint64Array ];
46
47arrayTypes.forEach((currentType) => {
48  const template = Reflect.construct(currentType, buffer);
49  const theArray = test_typedarray.CreateTypedArray(template, buffer);
50
51  assert.ok(theArray instanceof currentType,
52            'Type of new array should match that of the template. ' +
53            `Expected type: ${currentType.name}, ` +
54            `actual type: ${template.constructor.name}`);
55  assert.notStrictEqual(theArray, template);
56  assert.strictEqual(theArray.buffer, buffer);
57});
58
59arrayTypes.forEach((currentType) => {
60  const template = Reflect.construct(currentType, buffer);
61  assert.throws(() => {
62    test_typedarray.CreateTypedArray(template, buffer, 0, 136);
63  }, RangeError);
64});
65
66const nonByteArrayTypes = [ Int16Array, Uint16Array, Int32Array, Uint32Array,
67                            Float32Array, Float64Array,
68                            BigInt64Array, BigUint64Array ];
69nonByteArrayTypes.forEach((currentType) => {
70  const template = Reflect.construct(currentType, buffer);
71  assert.throws(() => {
72    test_typedarray.CreateTypedArray(template, buffer,
73                                     currentType.BYTES_PER_ELEMENT + 1, 1);
74    console.log(`start of offset ${currentType}`);
75  }, RangeError);
76});
77
78// Test detaching
79arrayTypes.forEach((currentType) => {
80  const buffer = Reflect.construct(currentType, [8]);
81  assert.strictEqual(buffer.length, 8);
82  assert.ok(!test_typedarray.IsDetached(buffer.buffer));
83  test_typedarray.Detach(buffer);
84  assert.ok(test_typedarray.IsDetached(buffer.buffer));
85  assert.strictEqual(buffer.length, 0);
86});
87{
88  const buffer = test_typedarray.External();
89  assert.ok(externalResult instanceof Int8Array);
90  assert.strictEqual(externalResult.length, 3);
91  assert.strictEqual(externalResult.byteLength, 3);
92  assert.ok(!test_typedarray.IsDetached(buffer.buffer));
93  test_typedarray.Detach(buffer);
94  assert.ok(test_typedarray.IsDetached(buffer.buffer));
95  assert.ok(externalResult instanceof Int8Array);
96  assert.strictEqual(buffer.length, 0);
97  assert.strictEqual(buffer.byteLength, 0);
98}
99
100{
101  const buffer = new ArrayBuffer(128);
102  assert.ok(!test_typedarray.IsDetached(buffer));
103}
104
105{
106  const buffer = test_typedarray.NullArrayBuffer();
107  assert.ok(buffer instanceof ArrayBuffer);
108  assert.ok(test_typedarray.IsDetached(buffer));
109}
110