mirror of
https://github.com/overte-org/overte.git
synced 2025-04-26 08:36:26 +02:00
384 lines
14 KiB
JavaScript
384 lines
14 KiB
JavaScript
//
|
|
// typedArraysunitTest.js
|
|
// examples
|
|
//
|
|
// Created by Clément Brisset on 7/7/14
|
|
// Copyright 2014 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
Script.include("Test.js");
|
|
|
|
test('ArrayBuffer', function(finished) {
|
|
this.assertEquals(new ArrayBuffer(0).byteLength, 0, 'no length');
|
|
|
|
this.assertEquals(typeof(new ArrayBuffer(0)), 'object', 'creation');
|
|
this.assertEquals(typeof(new ArrayBuffer(1)), 'object', 'creation');
|
|
this.assertEquals(typeof(new ArrayBuffer(123)), 'object', 'creation');
|
|
|
|
this.assertEquals(new ArrayBuffer(123).byteLength, 123, 'length');
|
|
|
|
// raises(function () { return new ArrayBuffer(-1); }, RangeError, 'negative length');
|
|
// raises(function () { return new ArrayBuffer(0x80000000); }, RangeError, 'absurd length');
|
|
});
|
|
|
|
test('DataView constructors', function (finished) {
|
|
var d = new DataView(new ArrayBuffer(8));
|
|
|
|
d.setUint32(0, 0x12345678);
|
|
this.assertEquals(d.getUint32(0), 0x12345678, 'big endian/big endian');
|
|
|
|
d.setUint32(0, 0x12345678, true);
|
|
this.assertEquals(d.getUint32(0, true), 0x12345678, 'little endian/little endian');
|
|
|
|
d.setUint32(0, 0x12345678, true);
|
|
this.assertEquals(d.getUint32(0), 0x78563412, 'little endian/big endian');
|
|
|
|
d.setUint32(0, 0x12345678);
|
|
this.assertEquals(d.getUint32(0, true), 0x78563412, 'big endian/little endian');
|
|
|
|
// raises(function () { return new DataView({}); }, 'non-ArrayBuffer argument');
|
|
// raises(function () { return new DataView("bogus"); }, TypeError, 'non-ArrayBuffer argument');
|
|
});
|
|
|
|
|
|
test('ArrayBufferView', function () {
|
|
var ab = new ArrayBuffer(48);
|
|
var i32 = new Int32Array(ab, 16);
|
|
i32.set([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
|
|
this.assertEquals(i32.buffer, ab, 'ArrayBuffers equal');
|
|
this.assertEquals(i32.byteOffset, 16, 'byteOffset');
|
|
this.assertEquals(i32.byteLength, 32, 'byteLength');
|
|
|
|
var da = new DataView(i32.buffer, 8);
|
|
this.assertEquals(da.buffer, ab, 'DataView: ArrayBuffers equal');
|
|
this.assertEquals(da.byteOffset, 8, 'DataView: byteOffset');
|
|
this.assertEquals(da.byteLength, 40, 'DataView: byteLength');
|
|
});
|
|
|
|
test('TypedArrays', function () {
|
|
var a;
|
|
|
|
this.assertEquals(Int8Array.BYTES_PER_ELEMENT, 1, 'Int8Array.BYTES_PER_ELEMENT');
|
|
a = new Int8Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 1, 'int8Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'int8Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 8, 'int8Array.byteLength');
|
|
|
|
this.assertEquals(Uint8Array.BYTES_PER_ELEMENT, 1, 'Uint8Array.BYTES_PER_ELEMENT');
|
|
a = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 1, 'uint8Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'uint8Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 8, 'uint8Array.byteLength');
|
|
|
|
this.assertEquals(Int16Array.BYTES_PER_ELEMENT, 2, 'Int16Array.BYTES_PER_ELEMENT');
|
|
a = new Int16Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 2, 'int16Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'int16Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 16, 'int16Array.byteLength');
|
|
|
|
this.assertEquals(Uint16Array.BYTES_PER_ELEMENT, 2, 'Uint16Array.BYTES_PER_ELEMENT');
|
|
a = new Uint16Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 2, 'uint16Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'uint16Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 16, 'uint16Array.byteLength');
|
|
|
|
this.assertEquals(Int32Array.BYTES_PER_ELEMENT, 4, 'Int32Array.BYTES_PER_ELEMENT');
|
|
a = new Int32Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 4, 'int32Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'int32Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 32, 'int32Array.byteLength');
|
|
|
|
this.assertEquals(Uint32Array.BYTES_PER_ELEMENT, 4, 'Uint32Array.BYTES_PER_ELEMENT');
|
|
a = new Uint32Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 4, 'uint32Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'uint32Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 32, 'uint32Array.byteLength');
|
|
|
|
this.assertEquals(Float32Array.BYTES_PER_ELEMENT, 4, 'Float32Array.BYTES_PER_ELEMENT');
|
|
a = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 4, 'float32Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'float32Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 32, 'float32Array.byteLength');
|
|
|
|
this.assertEquals(Float64Array.BYTES_PER_ELEMENT, 8, 'Float64Array.BYTES_PER_ELEMENT');
|
|
a = new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
this.assertEquals(a.BYTES_PER_ELEMENT, 8, 'float64Array.BYTES_PER_ELEMENT');
|
|
this.assertEquals(a.byteOffset, 0, 'float64Array.byteOffset');
|
|
this.assertEquals(a.byteLength, 64, 'float64Array.byteLength');
|
|
});
|
|
|
|
|
|
test('typed array constructors', function () {
|
|
this.arrayEqual(new Int8Array({ length: 3 }), [0, 0, 0], 'array equal -1');
|
|
var rawbuf = (new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7])).buffer;
|
|
|
|
var int8 = new Int8Array();
|
|
this.assertEquals(int8.length, 0, 'no args 0');
|
|
// raises(function () { return new Int8Array(-1); }, /*Range*/Error, 'bogus length');
|
|
// raises(function () { return new Int8Array(0x80000000); }, /*Range*/Error, 'bogus length');
|
|
|
|
int8 = new Int8Array(4);
|
|
this.assertEquals(int8.BYTES_PER_ELEMENT, 1);
|
|
this.assertEquals(int8.length, 4, 'length 1');
|
|
this.assertEquals(int8.byteLength, 4, 'length 2');
|
|
this.assertEquals(int8.byteOffset, 0, 'length 3');
|
|
this.assertEquals(int8.get(-1), undefined, 'length, out of bounds 4');
|
|
this.assertEquals(int8.get(4), undefined, 'length, out of bounds 5');
|
|
|
|
int8 = new Int8Array([1, 2, 3, 4, 5, 6]);
|
|
this.assertEquals(int8.length, 6, 'array 6');
|
|
this.assertEquals(int8.byteLength, 6, 'array 7');
|
|
this.assertEquals(int8.byteOffset, 0, 'array 8');
|
|
this.assertEquals(int8.get(3), 4, 'array 9');
|
|
this.assertEquals(int8.get(-1), undefined, 'array, out of bounds 10');
|
|
this.assertEquals(int8.get(6), undefined, 'array, out of bounds 11');
|
|
|
|
int8 = new Int8Array(rawbuf);
|
|
this.assertEquals(int8.length, 8, 'buffer 12');
|
|
this.assertEquals(int8.byteLength, 8, 'buffer 13');
|
|
this.assertEquals(int8.byteOffset, 0, 'buffer 14');
|
|
this.assertEquals(int8.get(7), 7, 'buffer 15');
|
|
int8.set([111]);
|
|
this.assertEquals(int8.get(0), 111, 'buffer 16');
|
|
this.assertEquals(int8.get(-1), undefined, 'buffer, out of bounds 17');
|
|
this.assertEquals(int8.get(8), undefined, 'buffer, out of bounds 18');
|
|
|
|
int8 = new Int8Array(rawbuf, 2);
|
|
this.assertEquals(int8.length, 6, 'buffer, byteOffset 19');
|
|
this.assertEquals(int8.byteLength, 6, 'buffer, byteOffset 20');
|
|
this.assertEquals(int8.byteOffset, 2, 'buffer, byteOffset 21');
|
|
this.assertEquals(int8.get(5), 7, 'buffer, byteOffset 22');
|
|
int8.set([112]);
|
|
this.assertEquals(int8.get(0), 112, 'buffer 23');
|
|
this.assertEquals(int8.get(-1), undefined, 'buffer, byteOffset, out of bounds 24');
|
|
this.assertEquals(int8.get(6), undefined, 'buffer, byteOffset, out of bounds 25');
|
|
|
|
int8 = new Int8Array(rawbuf, 8);
|
|
this.assertEquals(int8.length, 0, 'buffer, byteOffset 26');
|
|
|
|
// raises(function () { return new Int8Array(rawbuf, -1); }, 'invalid byteOffset 27');
|
|
// raises(function () { return new Int8Array(rawbuf, 9); }, 'invalid byteOffset 28');
|
|
// raises(function () { return new Int8Array(rawbuf, -1); }, 'invalid byteOffset 29');
|
|
// raises(function () { return new Int32Array(rawbuf, 5); }, 'invalid byteOffset 30');
|
|
|
|
int8 = new Int8Array(rawbuf, 2, 4);
|
|
this.assertEquals(int8.length, 4, 'buffer, byteOffset, length 31');
|
|
this.assertEquals(int8.byteLength, 4, 'buffer, byteOffset, length 32');
|
|
this.assertEquals(int8.byteOffset, 2, 'buffer, byteOffset, length 33');
|
|
this.assertEquals(int8.get(3), 5, 'buffer, byteOffset, length 34');
|
|
int8.set([113]);
|
|
this.assertEquals(int8.get(0), 113, 'buffer, byteOffset, length 35');
|
|
this.assertEquals(int8.get(-1), undefined, 'buffer, byteOffset, length, out of bounds 36');
|
|
this.assertEquals(int8.get(4), undefined, 'buffer, byteOffset, length, out of bounds 37');
|
|
|
|
// raises(function () { return new Int8Array(rawbuf, 0, 9); }, 'invalid byteOffset+length');
|
|
// raises(function () { return new Int8Array(rawbuf, 8, 1); }, 'invalid byteOffset+length');
|
|
// raises(function () { return new Int8Array(rawbuf, 9, -1); }, 'invalid byteOffset+length');
|
|
});
|
|
|
|
test('TypedArray clone constructor', function () {
|
|
var src = new Int32Array([1, 2, 3, 4, 5, 6, 7, 8]);
|
|
var dst = new Int32Array(src);
|
|
this.arrayEqual(dst, [1, 2, 3, 4, 5, 6, 7, 8], '1');
|
|
src.set([99]);
|
|
this.arrayEqual(src, [99, 2, 3, 4, 5, 6, 7, 8], '2');
|
|
this.arrayEqual(dst, [1, 2, 3, 4, 5, 6, 7, 8], '3');
|
|
});
|
|
|
|
|
|
test('conversions', function () {
|
|
var uint8 = new Uint8Array([1, 2, 3, 4]),
|
|
uint16 = new Uint16Array(uint8.buffer),
|
|
uint32 = new Uint32Array(uint8.buffer);
|
|
|
|
// Note: can't probe individual bytes without endianness awareness
|
|
this.arrayEqual(uint8, [1, 2, 3, 4]);
|
|
uint16.set([0xffff]);
|
|
this.arrayEqual(uint8, [0xff, 0xff, 3, 4]);
|
|
uint16.set([0xeeee], 1);
|
|
this.arrayEqual(uint8, [0xff, 0xff, 0xee, 0xee]);
|
|
uint32.set([0x11111111]);
|
|
this.assertEquals(uint16.get(0), 0x1111);
|
|
this.assertEquals(uint16.get(1), 0x1111);
|
|
this.arrayEqual(uint8, [0x11, 0x11, 0x11, 0x11]);
|
|
});
|
|
|
|
|
|
test('signed/unsigned conversions', function () {
|
|
|
|
var int8 = new Int8Array(1), uint8 = new Uint8Array(int8.buffer);
|
|
uint8.set([123]);
|
|
this.assertEquals(int8.get(0), 123, 'int8/uint8');
|
|
uint8.set([161]);
|
|
this.assertEquals(int8.get(0), -95, 'int8/uint8');
|
|
int8.set([-120]);
|
|
this.assertEquals(uint8.get(0), 136, 'uint8/int8');
|
|
int8.set([-1]);
|
|
this.assertEquals(uint8.get(0), 0xff, 'uint8/int8');
|
|
|
|
var int16 = new Int16Array(1), uint16 = new Uint16Array(int16.buffer);
|
|
uint16.set([3210]);
|
|
this.assertEquals(int16.get(0), 3210, 'int16/uint16');
|
|
uint16.set([49232]);
|
|
this.assertEquals(int16.get(0), -16304, 'int16/uint16');
|
|
int16.set([-16384]);
|
|
this.assertEquals(uint16.get(0), 49152, 'uint16/int16');
|
|
int16.set([-1]);
|
|
this.assertEquals(uint16.get(0), 0xffff, 'uint16/int16');
|
|
|
|
var int32 = new Int32Array(1), uint32 = new Uint32Array(int32.buffer);
|
|
uint32.set([0x80706050]);
|
|
this.assertEquals(int32.get(0), -2140118960, 'int32/uint32');
|
|
int32.set([-2023406815]);
|
|
this.assertEquals(uint32.get(0), 0x87654321, 'uint32/int32');
|
|
int32.set([-1]);
|
|
this.assertEquals(uint32.get(0), 0xffffffff, 'uint32/int32');
|
|
});
|
|
|
|
|
|
test('Int32Array round trips', function () {
|
|
var i32 = new Int32Array([0]);
|
|
var data = [
|
|
0,
|
|
1,
|
|
-1,
|
|
123,
|
|
-456,
|
|
0x80000000 >> 0,
|
|
0x7fffffff >> 0,
|
|
0x12345678 >> 0,
|
|
0x87654321 >> 0
|
|
];
|
|
|
|
for (var i = 0; i < data.length; i += 1) {
|
|
var datum = data[i];
|
|
i32.set([datum]);
|
|
this.assertEquals(datum, i32.get(0), String(datum));
|
|
}
|
|
});
|
|
|
|
|
|
test('Int16Array round trips', function () {
|
|
var i16 = new Int16Array([0]);
|
|
var data = [
|
|
0,
|
|
1,
|
|
-1,
|
|
123,
|
|
-456,
|
|
0xffff8000 >> 0,
|
|
0x00007fff >> 0,
|
|
0x00001234 >> 0,
|
|
0xffff8765 >> 0
|
|
];
|
|
|
|
for (var i = 0; i < data.length; i += 1) {
|
|
var datum = data[i];
|
|
i16.set([datum]);
|
|
this.assertEquals(datum, i16.get(0), String(datum));
|
|
}
|
|
});
|
|
|
|
|
|
test('Int8Array round trips', function () {
|
|
var i8 = new Int8Array([0]);
|
|
var data = [
|
|
0,
|
|
1,
|
|
-1,
|
|
123,
|
|
-45,
|
|
0xffffff80 >> 0,
|
|
0x0000007f >> 0,
|
|
0x00000012 >> 0,
|
|
0xffffff87 >> 0
|
|
];
|
|
|
|
for (var i = 0; i < data.length; i += 1) {
|
|
var datum = data[i];
|
|
i8.set([datum]);
|
|
this.assertEquals(datum, i8.get(0), String(datum));
|
|
}
|
|
});
|
|
|
|
test('TypedArray setting', function () {
|
|
|
|
var a = new Int32Array([1, 2, 3, 4, 5]);
|
|
var b = new Int32Array(5);
|
|
b.set(a);
|
|
this.arrayEqual(b, [1, 2, 3, 4, 5], '1');
|
|
// raises(function () { b.set(a, 1); });
|
|
|
|
b.set(new Int32Array([99, 98]), 2);
|
|
this.arrayEqual(b, [1, 2, 99, 98, 5], '2');
|
|
|
|
b.set(new Int32Array([99, 98, 97]), 2);
|
|
this.arrayEqual(b, [1, 2, 99, 98, 97], '3');
|
|
|
|
// raises(function () { b.set(new Int32Array([99, 98, 97, 96]), 2); });
|
|
// raises(function () { b.set([101, 102, 103, 104], 4); });
|
|
|
|
// ab = [ 0, 1, 2, 3, 4, 5, 6, 7 ]
|
|
// a1 = [ ^, ^, ^, ^, ^, ^, ^, ^ ]
|
|
// a2 = [ ^, ^, ^, ^ ]
|
|
var ab = new ArrayBuffer(8);
|
|
var a1 = new Uint8Array(ab);
|
|
for (var i = 0; i < a1.length; i += 1) { a1.set([i], i); }
|
|
var a2 = new Uint8Array(ab, 4);
|
|
a1.set(a2, 2);
|
|
this.arrayEqual(a1, [0, 1, 4, 5, 6, 7, 6, 7]);
|
|
this.arrayEqual(a2, [6, 7, 6, 7]);
|
|
});
|
|
|
|
|
|
test('TypedArray.subarray', function () {
|
|
|
|
var a = new Int32Array([1, 2, 3, 4, 5]);
|
|
this.arrayEqual(a.subarray(3), [4, 5]);
|
|
this.arrayEqual(a.subarray(1, 3), [2, 3]);
|
|
this.arrayEqual(a.subarray(-3), [3, 4, 5]);
|
|
this.arrayEqual(a.subarray(-3, -1), [3, 4]);
|
|
this.arrayEqual(a.subarray(3, 2), []);
|
|
this.arrayEqual(a.subarray(-2, -3), []);
|
|
this.arrayEqual(a.subarray(4, 1), []);
|
|
this.arrayEqual(a.subarray(-1, -4), []);
|
|
this.arrayEqual(a.subarray(1).subarray(1), [3, 4, 5]);
|
|
this.arrayEqual(a.subarray(1, 4).subarray(1, 2), [3]);
|
|
});
|
|
|
|
|
|
test('DataView constructors', function () {
|
|
|
|
var d = new DataView(new ArrayBuffer(8));
|
|
|
|
d.setUint32(0, 0x12345678);
|
|
this.assertEquals(d.getUint32(0), 0x12345678, 'big endian/big endian');
|
|
|
|
d.setUint32(0, 0x12345678, true);
|
|
this.assertEquals(d.getUint32(0, true), 0x12345678, 'little endian/little endian');
|
|
|
|
d.setUint32(0, 0x12345678, true);
|
|
this.assertEquals(d.getUint32(0), 0x78563412, 'little endian/big endian');
|
|
|
|
d.setUint32(0, 0x12345678);
|
|
this.assertEquals(d.getUint32(0, true), 0x78563412, 'big endian/little endian');
|
|
|
|
// Chrome allows no arguments, throws if non-ArrayBuffer
|
|
//stricterEqual(new DataView().buffer.byteLength, 0, 'no arguments');
|
|
|
|
// Safari (iOS 5) does not
|
|
//raises(function () { return new DataView(); }, TypeError, 'no arguments');
|
|
|
|
// Chrome raises TypeError, Safari iOS5 raises isDOMException(INDEX_SIZE_ERR)
|
|
// raises(function () { return new DataView({}); }, 'non-ArrayBuffer argument');
|
|
|
|
// raises(function () { return new DataView("bogus"); }, TypeError, 'non-ArrayBuffer argument');
|
|
});
|
|
|
|
|
|
|
|
|