diff options
Diffstat (limited to 'js/src/tests/ecma_7/TypedObject/method_build.js')
-rw-r--r-- | js/src/tests/ecma_7/TypedObject/method_build.js | 141 |
1 files changed, 141 insertions, 0 deletions
diff --git a/js/src/tests/ecma_7/TypedObject/method_build.js b/js/src/tests/ecma_7/TypedObject/method_build.js new file mode 100644 index 000000000..c23f629c1 --- /dev/null +++ b/js/src/tests/ecma_7/TypedObject/method_build.js @@ -0,0 +1,141 @@ +// |reftest| skip-if(!this.hasOwnProperty("TypedObject")) +var BUGNUMBER = 939715; +var summary = 'method type.build'; + +/* + * 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; + +function oneDimensionalArrayOfUints() { + var grain = uint32; + var type = grain.array(4); + var r1 = type.build(x => x * 2); + assertTypedEqual(type, r1, new type([0, 2, 4, 6])); +} + +function oneDimensionalArrayOfStructs() { + var grain = new StructType({f: uint32}); + var type = grain.array(4); + var r1 = type.build(x => new grain({f: x * 2})); + var r2 = type.build((x, out) => { out.f = x * 2; }); + assertTypedEqual(type, r1, new type([{f:0}, {f:2}, + {f:4}, {f:6}])); + assertTypedEqual(type, r1, r2); +} + +// At an attempt at readability, the tests below all try to build up +// numbers where there is a one-to-one mapping between input dimension +// and base-10 digit in the output. +// +// (Note that leading zeros must be elided in the expected-values to +// avoid inadvertantly interpreting the numbers as octal constants.) + +function twoDimensionalArrayOfStructsWithDepth2() { + var grain = new StructType({f: uint32}); + var type = grain.array(2, 2); + + var r1 = type.build(2, (x, y) => { + return new grain({f: x * 10 + y}); + }); + + var r2 = type.build(2, (x, y, out) => { + out.f = x * 10 + y; + }); + + assertTypedEqual(type, r1, new type([[{f: 0}, {f: 1}], + [{f:10}, {f:11}]])); + assertTypedEqual(type, r1, r2); +} + +function twoDimensionalArrayOfStructsWithDepth1() { + var grain = new StructType({f: uint32}).array(2); + var type = grain.array(2); + + var r1 = type.build((x) => { + return new grain([{f: x * 10}, + {f: x * 10 + 1}]); + }); + + var r2 = type.build(1, (x, out) => { + out[0].f = x * 10 + 0; + out[1].f = x * 10 + 1; + }); + + assertTypedEqual(type, r1, new type([[{f: 0}, {f: 1}], + [{f:10}, {f:11}]])); + assertTypedEqual(type, r1, r2); +} + +function threeDimensionalArrayOfUintsWithDepth3() { + var grain = uint32; + var type = grain.array(2).array(2).array(2); + var r1 = type.build(3, (x,y,z) => x * 100 + y * 10 + z); + assertTypedEqual(type, r1, new type([[[ 0, 1], [ 10, 11]], + [[100, 101], [110, 111]]])); +} + +function threeDimensionalArrayOfUintsWithDepth2() { + var grain = uint32.array(2); + var type = grain.array(2).array(2); + var r1 = type.build(2, (x,y) => [x * 100 + y * 10 + 0, x * 100 + y * 10 + 1]); + var r1b = type.build(2, (x,y) => grain.build(z => x * 100 + y * 10 + z)); + var r1c = type.build(2, (x,y) => grain.build(1, z => x * 100 + y * 10 + z)); + + var r2 = type.build(2, (x,y, out) => { out[0] = x * 100 + y * 10 + 0; + out[1] = x * 100 + y * 10 + 1; + }); + assertTypedEqual(type, r1, new type([[[ 0, 1], [ 10, 11]], + [[100, 101], [110, 111]]])); + assertTypedEqual(type, r1, r1b); + assertTypedEqual(type, r1, r1c); + assertTypedEqual(type, r1, r2); +} + +function threeDimensionalArrayOfUintsWithDepth1() { + var grain = uint32.array(2).array(2); + var type = grain.array(2); + var r1 = type.build(1, (x) => grain.build(y => [x * 100 + y * 10 + 0, x * 100 + y * 10 + 1])); + var r1b = type.build(1, (x) => grain.build(1, y => [x * 100 + y * 10 + 0, x * 100 + y * 10 + 1])); + var r1c = type.build(1, (x) => grain.build(2, (y,z) => x * 100 + y * 10 + z)); + var r2 = type.build(1, (x, out) => { out[0][0] = x * 100 + 0 * 10 + 0; + out[0][1] = x * 100 + 0 * 10 + 1; + out[1][0] = x * 100 + 1 * 10 + 0; + out[1][1] = x * 100 + 1 * 10 + 1; + }); + assertTypedEqual(type, r1, new type([[[ 0, 1], [ 10, 11]], + [[100, 101], [110, 111]]])); + assertTypedEqual(type, r1, r1b); + assertTypedEqual(type, r1, r1c); + assertTypedEqual(type, r1, r2); +} + +function runTests() { + print(BUGNUMBER + ": " + summary); + + oneDimensionalArrayOfUints(); + oneDimensionalArrayOfStructs(); + twoDimensionalArrayOfStructsWithDepth2(); + twoDimensionalArrayOfStructsWithDepth1(); + threeDimensionalArrayOfUintsWithDepth3(); + threeDimensionalArrayOfUintsWithDepth2(); + threeDimensionalArrayOfUintsWithDepth1(); + + if (typeof reportCompare === "function") + reportCompare(true, true); + print("Tests complete"); +} + +runTests(); |