| // |reftest| skip-if(!this.hasOwnProperty("TypedObject")) |
| var BUGNUMBER = 939715; |
| var summary = 'method type.from'; |
| |
| /* |
| * Any copyright is dedicated to the Public Domain. |
| * http://creativecommons.org/licenses/publicdomain/ |
| */ |
| |
| var ArrayType = TypedObject.ArrayType; |
| var StructType = TypedObject.StructType; |
| var uint8 = TypedObject.uint8; |
| var uint16 = TypedObject.uint16; |
| var uint32 = TypedObject.uint32; |
| var uint8Clamped = TypedObject.uint8Clamped; |
| var int8 = TypedObject.int8; |
| var int16 = TypedObject.int16; |
| var int32 = TypedObject.int32; |
| var float32 = TypedObject.float32; |
| var float64 = TypedObject.float64; |
| |
| // Test name format: |
| |
| // from<N>DimArrayOf<G1>sTo<G2>s where <N> is a positive integer (or its |
| // equivalent word in English) and <G1> and <G2> are both grain types |
| // (potentially an array themselves.) |
| |
| function fromOneDimArrayOfUint8ToUint32s() { |
| var intype = uint8.array(4); |
| var type = uint32.array(4); |
| var i1 = intype.build(i => i); |
| var r1 = type.from(i1, j => j*2); |
| var r2 = type.from(i1, 1, j => j*2); |
| assertTypedEqual(type, r1, new type([0, 2, 4, 6])); |
| assertTypedEqual(type, r1, r2); |
| } |
| |
| function fromOneDimArrayOfUint32ToUint8s() { |
| var intype = uint32.array(4); |
| var type = uint8.array(4); |
| var i1 = intype.build(i => i); |
| var r1 = type.from(i1, j => j*200); |
| var r2 = type.from(i1, 1, j => j*200); |
| assertTypedEqual(type, r1, new type([0, 200, 400 % 256, 600 % 256])); |
| assertTypedEqual(type, r1, r2); |
| } |
| |
| function fromTwoDimArrayOfUint8ToUint32s() { |
| var intype = uint8.array(4).array(4); |
| var rowtype = uint32.array(4); |
| var type = rowtype.array(4); |
| var i1 = new type([[10, 11, 12, 13], |
| [20, 21, 22, 23], |
| [30, 31, 32, 33], |
| [40, 41, 42, 43]]); |
| |
| var r1 = type.from(i1, 2, x => x*2); |
| var r2 = type.from(i1, 1, a => rowtype.from(a, 1, x => x*2)); |
| var r3 = type.from(i1, 1, (a, j, c, out) => { out[0] = a[0]*2; |
| out[1] = a[1]*2; |
| out[2] = a[2]*2; |
| out[3] = a[3]*2; }); |
| assertTypedEqual(type, r1, new type([[20, 22, 24, 26], |
| [40, 42, 44, 46], |
| [60, 62, 64, 66], |
| [80, 82, 84, 86]])); |
| assertTypedEqual(type, r1, r2); |
| assertTypedEqual(type, r1, r3); |
| } |
| |
| function fromTwoDimArrayOfUint32ToUint8s() { |
| var intype = uint32.array(4).array(4); |
| var rowtype = uint8.array(4); |
| var type = rowtype.array(4); |
| var i1 = new type([[10, 11, 12, 13], |
| [20, 21, 22, 23], |
| [30, 31, 32, 33], |
| [40, 41, 42, 43]]); |
| |
| var r1 = type.from(i1, 2, x => x*2); |
| var r2 = type.from(i1, 1, a => rowtype.from(a, 1, x => x*2)); |
| var r3 = type.from(i1, 1, (a, j, c, out) => { out[0] = a[0]*2; |
| out[1] = a[1]*2; |
| out[2] = a[2]*2; |
| out[3] = a[3]*2; }); |
| assertTypedEqual(type, r1, new type([[20, 22, 24, 26], |
| [40, 42, 44, 46], |
| [60, 62, 64, 66], |
| [80, 82, 84, 86]])); |
| assertTypedEqual(type, r1, r2); |
| assertTypedEqual(type, r1, r3); |
| } |
| |
| function fromOneDimArrayOfArrayOfUint8ToUint32s() { |
| var intype = uint8.array(4).array(4); |
| var type = uint32.array(4); |
| var i1 = new intype([[0xdd, 0xcc, 0xbb, 0xaa], |
| [0x09, 0x08, 0x07, 0x06], |
| [0x15, 0x14, 0x13, 0x12], |
| [0x23, 0x32, 0x41, 0x50]]); |
| |
| function combine(a,b,c,d) { return a << 24 | b << 16 | c << 8 | d; } |
| |
| var r1 = type.from(i1, x => combine(x[0], x[1], x[2], x[3])); |
| assertTypedEqual(type, r1, new type([0xddccbbaa, |
| 0x09080706, |
| 0x15141312, |
| 0x23324150])); |
| } |
| |
| function fromOneDimArrayOfUint32ToArrayOfUint8s() { |
| var intype = uint32.array(4); |
| var type = uint8.array(4).array(4); |
| var i1 = new intype([0xddccbbaa, |
| 0x09080706, |
| 0x15141312, |
| 0x23324150]); |
| |
| function divide(a) { return [a >> 24 & 0xFF, a >> 16 & 0xFF, a >> 8 & 0xFF, a & 0xFF]; } |
| |
| var r1 = type.from(i1, x => divide(x)); |
| var r2 = type.from(i1, 1, (x, i, c, out) => { |
| var [a,b,c,d] = divide(x); |
| out[0] = a; out[1] = b; out[2] = c; out[3] = d; |
| }); |
| assertTypedEqual(type, r1, new type([[0xdd, 0xcc, 0xbb, 0xaa], |
| [0x09, 0x08, 0x07, 0x06], |
| [0x15, 0x14, 0x13, 0x12], |
| [0x23, 0x32, 0x41, 0x50]])); |
| assertTypedEqual(type, r1, r2); |
| } |
| |
| var Grain = new StructType({f: uint32}); |
| function wrapG(v) { return new Grain({f: v}); } |
| function doubleG(g) { return new Grain({f: g.f * 2}); } |
| function tenG(x, y) { return new Grain({f: x * 10 + y}); } |
| |
| function fromOneDimArrayOfStructsToStructs() { |
| var type = Grain.array(4); |
| var i1 = type.build(wrapG); |
| var r1 = type.from(i1, doubleG); |
| var r2 = type.from(i1, 1, doubleG); |
| var r3 = type.from(i1, 1, (g, j, c, out) => { out.f = g.f * 2; }); |
| assertTypedEqual(type, r1, new type([{f:0}, {f:2}, |
| {f:4}, {f:6}])); |
| assertTypedEqual(type, r1, r2); |
| assertTypedEqual(type, r1, r3); |
| } |
| |
| function fromTwoDimArrayOfStructsToStructs() { |
| var rowtype = Grain.array(2); |
| var type = rowtype.array(2); |
| var i1 = type.build(2, tenG); |
| var r1 = type.from(i1, 2, doubleG); |
| var r2 = type.from(i1, 1, (m) => rowtype.from(m, 1, doubleG)); |
| var r3 = type.from(i1, 1, |
| (m, j, c, out) => { out[0].f = m[0].f * 2; out[1].f = m[1].f * 2; }); |
| assertTypedEqual(type, r1, new type([[{f:00}, {f:02}], |
| [{f:20}, {f:22}]])); |
| assertTypedEqual(type, r1, r2); |
| assertTypedEqual(type, r1, r3); |
| } |
| |
| function fromOneDimArrayOfStructsToArrayOfStructs() { |
| var Line = Grain.array(2); |
| var Box = Line.array(2); |
| var i1 = Line.build(wrapG); |
| var r1 = Box.from(i1, (g) => Line.build((y) => tenG(g.f, y))); |
| var r2 = Box.from(i1, (g) => Line.from(i1, (y) => tenG(g.f, y.f))); |
| var r3 = Box.from(i1, |
| (g, j, c, out) => { out[0] = tenG(g.f, 0); out[1] = tenG(g.f, 1); }); |
| assertTypedEqual(Box, r1, new Box([[{f:00}, {f:01}], |
| [{f:10}, {f:11}]])); |
| assertTypedEqual(Box, r1, r2); |
| assertTypedEqual(Box, r1, r3); |
| } |
| |
| function Array_build(n, f) { |
| var a = new Array(n); |
| for ( var i=0 ; i < n ; i++ ) |
| a[i] = f(i); |
| return a; |
| } |
| |
| function fromUntypedArrayToUint32s() { |
| var type = uint32.array(4); |
| var i1 = Array_build(4, i => i); |
| var r1 = type.from(i1, j => j*2); |
| var r2 = type.from(i1, 1, j => j*2); |
| assertTypedEqual(type, r1, new type([0, 2, 4, 6])); |
| assertTypedEqual(type, r1, r2); |
| } |
| |
| function fromUntypedArrayToUint8s() { |
| var type = uint8.array(4); |
| var i1 = Array_build(4, i => i); |
| var r1 = type.from(i1, j => j*200); |
| var r2 = type.from(i1, 1, j => j*200); |
| assertTypedEqual(type, r1, new type([0, 200, 400 % 256, 600 % 256])); |
| assertTypedEqual(type, r1, r2); |
| } |
| |
| function runTests() { |
| print(BUGNUMBER + ": " + summary); |
| |
| fromOneDimArrayOfUint8ToUint32s(); |
| fromOneDimArrayOfUint32ToUint8s(); |
| |
| fromTwoDimArrayOfUint8ToUint32s(); |
| fromTwoDimArrayOfUint32ToUint8s(); |
| |
| fromOneDimArrayOfArrayOfUint8ToUint32s(); |
| fromOneDimArrayOfUint32ToArrayOfUint8s(); |
| |
| fromOneDimArrayOfStructsToStructs(); |
| fromTwoDimArrayOfStructsToStructs(); |
| |
| fromOneDimArrayOfStructsToArrayOfStructs(); |
| |
| fromUntypedArrayToUint32s(); |
| fromUntypedArrayToUint8s(); |
| |
| if (typeof reportCompare === "function") |
| reportCompare(true, true); |
| print("Tests complete"); |
| } |
| |
| runTests(); |
