test/mjsunit/harmony/simd.js - v8/v8 - Git at Google

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // Flags: --harmony-simd --harmony-tostring  --harmony-reflect
 // Flags: --allow-natives-syntax --expose-natives-as natives --noalways-opt

 function lanesForType(typeName) {
   // The lane count follows the first 'x' in the type name, which begins with
   // 'float', 'int', or 'bool'.
   return Number.parseInt(typeName[typeName.indexOf('x') + 1]);
 }


 function isValidSimdString(string, value, type, lanes) {
   var simdFn = SIMD[type],
       parseFn =
           type.indexOf('float') === 0 ? Number.parseFloat : Number.parseInt,
       indexOfOpenParen = string.indexOf('(');
   // Check prefix for correct type name.
   if (string.substr(0, indexOfOpenParen).toUpperCase() !== type.toUpperCase())
     return false;
   // Remove type name and open parenthesis.
   string = string.substr(indexOfOpenParen + 1);
   var laneStrings = string.split(',');
   if (laneStrings.length !== lanes)
     return false;
   for (var i = 0; i < lanes; i++) {
     var fromString = parseFn(laneStrings[i]),
         fromValue = simdFn.extractLane(value, i);
     if (Math.abs(fromString - fromValue) > Number.EPSILON)
       return false;
   }
   return true;
 }


 // Test for structural equivalence.
 function areEquivalent(type, lanes, a, b) {
   var simdFn = SIMD[type];
   for (var i = 0; i < lanes; i++) {
     if (simdFn.extractLane(a, i) !== simdFn.extractLane(b, i))
       return false;
   }
   return true;
 }


 var sameValue = natives.$sameValue;
 var sameValueZero = natives.$sameValueZero;

 // Calls SameValue and SameValueZero and checks that their results match. Also
 // checks the internal SameValue checks using Object freeze and defineProperty.
 function sameValueBoth(a, b) {
   var result = sameValue(a, b);
   assertTrue(result === sameValueZero(a, b));
   return result;
 }


 // Calls SameValue and SameValueZero and checks that their results don't match.
 function sameValueZeroOnly(a, b) {
   var result = sameValueZero(a, b);
   assertTrue(result && !sameValue(a, b));
   return result;
 }


 // Tests for the global SIMD object.
 function TestSIMDObject() {
   assertSame(typeof SIMD, 'object');
   assertSame(SIMD.constructor, Object);
   assertSame(Object.getPrototypeOf(SIMD), Object.prototype);
   assertSame(SIMD + "", "[object SIMD]");
 }
 TestSIMDObject()

 // TestConstructor populates this with interesting values for the other tests.
 var values;

 // Test different forms of constructor calls. This test populates 'values' with
 // a variety of SIMD values as a side effect, which are used by other tests.
 function TestConstructor(type, lanes) {
   var simdFn = SIMD[type];
   assertFalse(Object === simdFn.prototype.constructor)
   assertFalse(simdFn === Object.prototype.constructor)
   assertSame(simdFn, simdFn.prototype.constructor)

   values = []

   // The constructor expects values for all lanes.
   switch (type) {
     case 'float32x4':
       // The constructor expects values for all lanes.
       assertThrows(function () { simdFn() }, TypeError)
       assertThrows(function () { simdFn(0) }, TypeError)
       assertThrows(function () { simdFn(0, 1) }, TypeError)
       assertThrows(function () { simdFn(0, 1, 2) }, TypeError)

       values.push(simdFn(1, 2, 3, 4))
       values.push(simdFn(1, 2, 3, 4))       // test structural equivalence
       values.push(simdFn(-0, NaN, 0, 0.5))
       values.push(simdFn(-0, NaN, 0, 0.5))  // test structural equivalence
       values.push(simdFn(3, 2, 1, 0))
       values.push(simdFn(0, 0, 0, 0))
       break
   }
   for (var i in values) {
     assertSame(simdFn, values[i].__proto__.constructor)
     assertSame(simdFn, Object(values[i]).__proto__.constructor)
     assertSame(simdFn.prototype, values[i].__proto__)
     assertSame(simdFn.prototype, Object(values[i]).__proto__)
   }
 }


 function TestType(type, lanes) {
   for (var i in values) {
     assertEquals(type, typeof values[i])
     assertTrue(typeof values[i] === type)
     assertTrue(typeof Object(values[i]) === 'object')
     assertEquals(null, %_ClassOf(values[i]))
     assertEquals("Float32x4", %_ClassOf(Object(values[i])))
   }
 }


 function TestPrototype(type, lanes) {
   var simdFn = SIMD[type];
   assertSame(Object.prototype, simdFn.prototype.__proto__)
   for (var i in values) {
     assertSame(simdFn.prototype, values[i].__proto__)
     assertSame(simdFn.prototype, Object(values[i]).__proto__)
   }
 }


 function TestValueOf(type, lanes) {
   var simdFn = SIMD[type];
   for (var i in values) {
     assertTrue(values[i] === Object(values[i]).valueOf())
     assertTrue(values[i] === values[i].valueOf())
     assertTrue(simdFn.prototype.valueOf.call(Object(values[i])) === values[i])
     assertTrue(simdFn.prototype.valueOf.call(values[i]) === values[i])
   }
 }


 function TestGet(type, lanes) {
   var simdFn = SIMD[type];
   for (var i in values) {
     assertEquals(undefined, values[i].a)
     assertEquals(undefined, values[i]["a" + "b"])
     assertEquals(undefined, values[i]["" + "1"])
     assertEquals(undefined, values[i][42])
   }
 }


 function TestToBoolean(type, lanes) {
   for (var i in values) {
     assertTrue(Boolean(Object(values[i])))
     assertFalse(!Object(values[i]))
     assertTrue(Boolean(values[i]).valueOf())
     assertFalse(!values[i])
     assertTrue(!!values[i])
     assertTrue(values[i] && true)
     assertFalse(!values[i] && false)
     assertTrue(!values[i] || true)
     assertEquals(1, values[i] ? 1 : 2)
     assertEquals(2, !values[i] ? 1 : 2)
     if (!values[i]) assertUnreachable();
     if (values[i]) {} else assertUnreachable();
   }
 }


 function TestToString(type, lanes) {
   var simdFn = SIMD[type];
   for (var i in values) {
     assertEquals(values[i].toString(), String(values[i]))
     assertTrue(isValidSimdString(values[i].toString(), values[i], type, lanes))
     assertTrue(
         isValidSimdString(Object(values[i]).toString(), values[i], type, lanes))
     assertTrue(isValidSimdString(
         simdFn.prototype.toString.call(values[i]), values[i], type, lanes))
   }
 }


 function TestToNumber(type, lanes) {
   for (var i in values) {
     assertThrows(function() { Number(Object(values[i])) }, TypeError)
     assertThrows(function() { +Object(values[i]) }, TypeError)
     assertThrows(function() { Number(values[i]) }, TypeError)
     assertThrows(function() { values[i] + 0 }, TypeError)
   }
 }


 function TestEquality(type, lanes) {
   // Every SIMD value should equal itself, and non-strictly equal its wrapper.
   for (var i in values) {
     assertSame(values[i], values[i])
     assertEquals(values[i], values[i])
     assertTrue(Object.is(values[i], values[i]))
     assertTrue(values[i] === values[i])
     assertTrue(values[i] == values[i])
     assertFalse(values[i] === Object(values[i]))
     assertFalse(Object(values[i]) === values[i])
     assertFalse(values[i] == Object(values[i]))
     assertFalse(Object(values[i]) == values[i])
     assertTrue(values[i] === values[i].valueOf())
     assertTrue(values[i].valueOf() === values[i])
     assertTrue(values[i] == values[i].valueOf())
     assertTrue(values[i].valueOf() == values[i])
     assertFalse(Object(values[i]) === Object(values[i]))
     assertEquals(Object(values[i]).valueOf(), Object(values[i]).valueOf())
   }

   // Test structural equivalence.
   for (var i = 0; i < values.length; i++) {
     for (var j = i + 1; j < values.length; j++) {
       var a = values[i], b = values[j],
           equivalent = areEquivalent(type, lanes, a, b);
       assertSame(equivalent, a == b);
       assertSame(equivalent, a === b);
     }
   }

   // SIMD values should not be equal to any other kind of object.
   var others = [347, 1.275, NaN, "string", null, undefined, {}, function() {}]
   for (var i in values) {
     for (var j in others) {
       assertFalse(values[i] === others[j])
       assertFalse(others[j] === values[i])
       assertFalse(values[i] == others[j])
       assertFalse(others[j] == values[i])
     }
   }
 }


 function TestSameValue(type, lanes) {
   // SIMD value types.
   // All lanes checked.
   // TODO(bbudge): use loops to test lanes when replaceLane is defined.
   assertTrue(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
                            SIMD.float32x4(1, 2, 3, 4)));
   assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
                             SIMD.float32x4(NaN, 2, 3, 4)));
   assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
                             SIMD.float32x4(1, NaN, 3, 4)));
   assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
                             SIMD.float32x4(1, 2, NaN, 4)));
   assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
                             SIMD.float32x4(1, 2, 3, NaN)));
   // Special values.
   // TODO(bbudge): use loops to test lanes when replaceLane is defined.
   assertTrue(sameValueBoth(SIMD.float32x4(NaN, 2, 3, 4),
                            SIMD.float32x4(NaN, 2, 3, 4)));
   assertTrue(sameValueBoth(SIMD.float32x4(+0, 2, 3, 4),
                            SIMD.float32x4(+0, 2, 3, 4)));
   assertTrue(sameValueBoth(SIMD.float32x4(-0, 2, 3, 4),
                            SIMD.float32x4(-0, 2, 3, 4)));
   assertTrue(sameValueZeroOnly(SIMD.float32x4(+0, 2, 3, 4),
                                SIMD.float32x4(-0, 2, 3, 4)));
   assertTrue(sameValueZeroOnly(SIMD.float32x4(-0, 2, 3, 4),
                                SIMD.float32x4(+0, 2, 3, 4)));
 }


 function TestComparison(type, lanes) {
   var a = values[0], b = values[1];

   function lt() { a < b; }
   function gt() { a > b; }
   function le() { a <= b; }
   function ge() { a >= b; }
   function lt_same() { a < a; }
   function gt_same() { a > a; }
   function le_same() { a <= a; }
   function ge_same() { a >= a; }

   var throwFuncs = [lt, gt, le, ge, lt_same, gt_same, le_same, ge_same];

   for (var f of throwFuncs) {
     assertThrows(f, TypeError);
     %OptimizeFunctionOnNextCall(f);
     assertThrows(f, TypeError);
     assertThrows(f, TypeError);
   }
 }


 // Test SIMD value wrapping/boxing over non-builtins.
 function TestCall(type, lanes) {
   var simdFn = SIMD[type];
   simdFn.prototype.getThisProto = function () {
     return Object.getPrototypeOf(this);
   }
   for (var i in values) {
     assertTrue(values[i].getThisProto() === simdFn.prototype)
   }
 }


 function TestAsSetKey(type, lanes, set) {
   function test(set, key) {
     assertFalse(set.has(key));
     assertFalse(set.delete(key));
     if (!(set instanceof WeakSet)) {
       assertSame(set, set.add(key));
       assertTrue(set.has(key));
       assertTrue(set.delete(key));
     } else {
       // SIMD values can't be used as keys in WeakSets.
       assertThrows(function() { set.add(key) });
     }
     assertFalse(set.has(key));
     assertFalse(set.delete(key));
     assertFalse(set.has(key));
   }

   for (var i in values) {
     test(set, values[i]);
   }
 }


 function TestAsMapKey(type, lanes, map) {
   function test(map, key, value) {
     assertFalse(map.has(key));
     assertSame(undefined, map.get(key));
     assertFalse(map.delete(key));
     if (!(map instanceof WeakMap)) {
       assertSame(map, map.set(key, value));
       assertSame(value, map.get(key));
       assertTrue(map.has(key));
       assertTrue(map.delete(key));
     } else {
       // SIMD values can't be used as keys in WeakMaps.
       assertThrows(function() { map.set(key, value) });
     }
     assertFalse(map.has(key));
     assertSame(undefined, map.get(key));
     assertFalse(map.delete(key));
     assertFalse(map.has(key));
     assertSame(undefined, map.get(key));
   }

   for (var i in values) {
     test(map, values[i], {});
   }
 }


 // Test SIMD type with Harmony reflect-apply.
 function TestReflectApply(type) {
   function returnThis() { return this; }
   function returnThisStrict() { 'use strict'; return this; }
   function noop() {}
   function noopStrict() { 'use strict'; }
   var R = void 0;

   for (var i in values) {
     assertSame(SIMD[type].prototype,
                Object.getPrototypeOf(
                   Reflect.apply(returnThis, values[i], [])));
     assertSame(values[i], Reflect.apply(returnThisStrict, values[i], []));

     assertThrows(
         function() { 'use strict'; Reflect.apply(values[i]); }, TypeError);
     assertThrows(
         function() { Reflect.apply(values[i]); }, TypeError);
     assertThrows(
         function() { Reflect.apply(noopStrict, R, values[i]); }, TypeError);
     assertThrows(
         function() { Reflect.apply(noop, R, values[i]); }, TypeError);
   }
 }


 function TestSIMDTypes() {
   var types = [ 'float32x4' ];
   for (var i = 0; i < types.length; ++i) {
     var type = types[i],
         lanes = lanesForType(type);
     TestConstructor(type, lanes);
     TestType(type, lanes);
     TestPrototype(type, lanes);
     TestValueOf(type, lanes);
     TestGet(type, lanes);
     TestToBoolean(type, lanes);
     TestToString(type, lanes);
     TestToNumber(type, lanes);
     TestEquality(type, lanes);
     TestSameValue(type, lanes);
     TestComparison(type, lanes);
     TestCall(type, lanes);
     TestAsSetKey(type, lanes, new Set);
     TestAsSetKey(type, lanes, new WeakSet);
     TestAsMapKey(type, lanes, new Map);
     TestAsMapKey(type, lanes, new WeakMap);
     TestReflectApply(type);
   }
 }
 TestSIMDTypes();
	// Copyright 2015 the V8 project authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// Flags: --harmony-simd --harmony-tostring --harmony-reflect
	// Flags: --allow-natives-syntax --expose-natives-as natives --noalways-opt

	function lanesForType(typeName) {
	// The lane count follows the first 'x' in the type name, which begins with
	// 'float', 'int', or 'bool'.
	return Number.parseInt(typeName[typeName.indexOf('x') + 1]);
	}


	function isValidSimdString(string, value, type, lanes) {
	var simdFn = SIMD[type],
	parseFn =
	type.indexOf('float') === 0 ? Number.parseFloat : Number.parseInt,
	indexOfOpenParen = string.indexOf('(');
	// Check prefix for correct type name.
	if (string.substr(0, indexOfOpenParen).toUpperCase() !== type.toUpperCase())
	return false;
	// Remove type name and open parenthesis.
	string = string.substr(indexOfOpenParen + 1);
	var laneStrings = string.split(',');
	if (laneStrings.length !== lanes)
	return false;
	for (var i = 0; i < lanes; i++) {
	var fromString = parseFn(laneStrings[i]),
	fromValue = simdFn.extractLane(value, i);
	if (Math.abs(fromString - fromValue) > Number.EPSILON)
	return false;
	}
	return true;
	}


	// Test for structural equivalence.
	function areEquivalent(type, lanes, a, b) {
	var simdFn = SIMD[type];
	for (var i = 0; i < lanes; i++) {
	if (simdFn.extractLane(a, i) !== simdFn.extractLane(b, i))
	return false;
	}
	return true;
	}


	var sameValue = natives.$sameValue;
	var sameValueZero = natives.$sameValueZero;

	// Calls SameValue and SameValueZero and checks that their results match. Also
	// checks the internal SameValue checks using Object freeze and defineProperty.
	function sameValueBoth(a, b) {
	var result = sameValue(a, b);
	assertTrue(result === sameValueZero(a, b));
	return result;
	}


	// Calls SameValue and SameValueZero and checks that their results don't match.
	function sameValueZeroOnly(a, b) {
	var result = sameValueZero(a, b);
	assertTrue(result && !sameValue(a, b));
	return result;
	}


	// Tests for the global SIMD object.
	function TestSIMDObject() {
	assertSame(typeof SIMD, 'object');
	assertSame(SIMD.constructor, Object);
	assertSame(Object.getPrototypeOf(SIMD), Object.prototype);
	assertSame(SIMD + "", "[object SIMD]");
	}
	TestSIMDObject()

	// TestConstructor populates this with interesting values for the other tests.
	var values;

	// Test different forms of constructor calls. This test populates 'values' with
	// a variety of SIMD values as a side effect, which are used by other tests.
	function TestConstructor(type, lanes) {
	var simdFn = SIMD[type];
	assertFalse(Object === simdFn.prototype.constructor)
	assertFalse(simdFn === Object.prototype.constructor)
	assertSame(simdFn, simdFn.prototype.constructor)

	values = []

	// The constructor expects values for all lanes.
	switch (type) {
	case 'float32x4':
	// The constructor expects values for all lanes.
	assertThrows(function () { simdFn() }, TypeError)
	assertThrows(function () { simdFn(0) }, TypeError)
	assertThrows(function () { simdFn(0, 1) }, TypeError)
	assertThrows(function () { simdFn(0, 1, 2) }, TypeError)

	values.push(simdFn(1, 2, 3, 4))
	values.push(simdFn(1, 2, 3, 4)) // test structural equivalence
	values.push(simdFn(-0, NaN, 0, 0.5))
	values.push(simdFn(-0, NaN, 0, 0.5)) // test structural equivalence
	values.push(simdFn(3, 2, 1, 0))
	values.push(simdFn(0, 0, 0, 0))
	break
	}
	for (var i in values) {
	assertSame(simdFn, values[i].__proto__.constructor)
	assertSame(simdFn, Object(values[i]).__proto__.constructor)
	assertSame(simdFn.prototype, values[i].__proto__)
	assertSame(simdFn.prototype, Object(values[i]).__proto__)
	}
	}


	function TestType(type, lanes) {
	for (var i in values) {
	assertEquals(type, typeof values[i])
	assertTrue(typeof values[i] === type)
	assertTrue(typeof Object(values[i]) === 'object')
	assertEquals(null, %_ClassOf(values[i]))
	assertEquals("Float32x4", %_ClassOf(Object(values[i])))
	}
	}


	function TestPrototype(type, lanes) {
	var simdFn = SIMD[type];
	assertSame(Object.prototype, simdFn.prototype.__proto__)
	for (var i in values) {
	assertSame(simdFn.prototype, values[i].__proto__)
	assertSame(simdFn.prototype, Object(values[i]).__proto__)
	}
	}


	function TestValueOf(type, lanes) {
	var simdFn = SIMD[type];
	for (var i in values) {
	assertTrue(values[i] === Object(values[i]).valueOf())
	assertTrue(values[i] === values[i].valueOf())
	assertTrue(simdFn.prototype.valueOf.call(Object(values[i])) === values[i])
	assertTrue(simdFn.prototype.valueOf.call(values[i]) === values[i])
	}
	}


	function TestGet(type, lanes) {
	var simdFn = SIMD[type];
	for (var i in values) {
	assertEquals(undefined, values[i].a)
	assertEquals(undefined, values[i]["a" + "b"])
	assertEquals(undefined, values[i]["" + "1"])
	assertEquals(undefined, values[i][42])
	}
	}


	function TestToBoolean(type, lanes) {
	for (var i in values) {
	assertTrue(Boolean(Object(values[i])))
	assertFalse(!Object(values[i]))
	assertTrue(Boolean(values[i]).valueOf())
	assertFalse(!values[i])
	assertTrue(!!values[i])
	assertTrue(values[i] && true)
	assertFalse(!values[i] && false)
	assertTrue(!values[i] \|\| true)
	assertEquals(1, values[i] ? 1 : 2)
	assertEquals(2, !values[i] ? 1 : 2)
	if (!values[i]) assertUnreachable();
	if (values[i]) {} else assertUnreachable();
	}
	}


	function TestToString(type, lanes) {
	var simdFn = SIMD[type];
	for (var i in values) {
	assertEquals(values[i].toString(), String(values[i]))
	assertTrue(isValidSimdString(values[i].toString(), values[i], type, lanes))
	assertTrue(
	isValidSimdString(Object(values[i]).toString(), values[i], type, lanes))
	assertTrue(isValidSimdString(
	simdFn.prototype.toString.call(values[i]), values[i], type, lanes))
	}
	}


	function TestToNumber(type, lanes) {
	for (var i in values) {
	assertThrows(function() { Number(Object(values[i])) }, TypeError)
	assertThrows(function() { +Object(values[i]) }, TypeError)
	assertThrows(function() { Number(values[i]) }, TypeError)
	assertThrows(function() { values[i] + 0 }, TypeError)
	}
	}


	function TestEquality(type, lanes) {
	// Every SIMD value should equal itself, and non-strictly equal its wrapper.
	for (var i in values) {
	assertSame(values[i], values[i])
	assertEquals(values[i], values[i])
	assertTrue(Object.is(values[i], values[i]))
	assertTrue(values[i] === values[i])
	assertTrue(values[i] == values[i])
	assertFalse(values[i] === Object(values[i]))
	assertFalse(Object(values[i]) === values[i])
	assertFalse(values[i] == Object(values[i]))
	assertFalse(Object(values[i]) == values[i])
	assertTrue(values[i] === values[i].valueOf())
	assertTrue(values[i].valueOf() === values[i])
	assertTrue(values[i] == values[i].valueOf())
	assertTrue(values[i].valueOf() == values[i])
	assertFalse(Object(values[i]) === Object(values[i]))
	assertEquals(Object(values[i]).valueOf(), Object(values[i]).valueOf())
	}

	// Test structural equivalence.
	for (var i = 0; i < values.length; i++) {
	for (var j = i + 1; j < values.length; j++) {
	var a = values[i], b = values[j],
	equivalent = areEquivalent(type, lanes, a, b);
	assertSame(equivalent, a == b);
	assertSame(equivalent, a === b);
	}
	}

	// SIMD values should not be equal to any other kind of object.
	var others = [347, 1.275, NaN, "string", null, undefined, {}, function() {}]
	for (var i in values) {
	for (var j in others) {
	assertFalse(values[i] === others[j])
	assertFalse(others[j] === values[i])
	assertFalse(values[i] == others[j])
	assertFalse(others[j] == values[i])
	}
	}
	}


	function TestSameValue(type, lanes) {
	// SIMD value types.
	// All lanes checked.
	// TODO(bbudge): use loops to test lanes when replaceLane is defined.
	assertTrue(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
	SIMD.float32x4(1, 2, 3, 4)));
	assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
	SIMD.float32x4(NaN, 2, 3, 4)));
	assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
	SIMD.float32x4(1, NaN, 3, 4)));
	assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
	SIMD.float32x4(1, 2, NaN, 4)));
	assertFalse(sameValueBoth(SIMD.float32x4(1, 2, 3, 4),
	SIMD.float32x4(1, 2, 3, NaN)));
	// Special values.
	// TODO(bbudge): use loops to test lanes when replaceLane is defined.
	assertTrue(sameValueBoth(SIMD.float32x4(NaN, 2, 3, 4),
	SIMD.float32x4(NaN, 2, 3, 4)));
	assertTrue(sameValueBoth(SIMD.float32x4(+0, 2, 3, 4),
	SIMD.float32x4(+0, 2, 3, 4)));
	assertTrue(sameValueBoth(SIMD.float32x4(-0, 2, 3, 4),
	SIMD.float32x4(-0, 2, 3, 4)));
	assertTrue(sameValueZeroOnly(SIMD.float32x4(+0, 2, 3, 4),
	SIMD.float32x4(-0, 2, 3, 4)));
	assertTrue(sameValueZeroOnly(SIMD.float32x4(-0, 2, 3, 4),
	SIMD.float32x4(+0, 2, 3, 4)));
	}


	function TestComparison(type, lanes) {
	var a = values[0], b = values[1];

	function lt() { a < b; }
	function gt() { a > b; }
	function le() { a <= b; }
	function ge() { a >= b; }
	function lt_same() { a < a; }
	function gt_same() { a > a; }
	function le_same() { a <= a; }
	function ge_same() { a >= a; }

	var throwFuncs = [lt, gt, le, ge, lt_same, gt_same, le_same, ge_same];

	for (var f of throwFuncs) {
	assertThrows(f, TypeError);
	%OptimizeFunctionOnNextCall(f);
	assertThrows(f, TypeError);
	assertThrows(f, TypeError);
	}
	}


	// Test SIMD value wrapping/boxing over non-builtins.
	function TestCall(type, lanes) {
	var simdFn = SIMD[type];
	simdFn.prototype.getThisProto = function () {
	return Object.getPrototypeOf(this);
	}
	for (var i in values) {
	assertTrue(values[i].getThisProto() === simdFn.prototype)
	}
	}


	function TestAsSetKey(type, lanes, set) {
	function test(set, key) {
	assertFalse(set.has(key));
	assertFalse(set.delete(key));
	if (!(set instanceof WeakSet)) {
	assertSame(set, set.add(key));
	assertTrue(set.has(key));
	assertTrue(set.delete(key));
	} else {
	// SIMD values can't be used as keys in WeakSets.
	assertThrows(function() { set.add(key) });
	}
	assertFalse(set.has(key));
	assertFalse(set.delete(key));
	assertFalse(set.has(key));
	}

	for (var i in values) {
	test(set, values[i]);
	}
	}


	function TestAsMapKey(type, lanes, map) {
	function test(map, key, value) {
	assertFalse(map.has(key));
	assertSame(undefined, map.get(key));
	assertFalse(map.delete(key));
	if (!(map instanceof WeakMap)) {
	assertSame(map, map.set(key, value));
	assertSame(value, map.get(key));
	assertTrue(map.has(key));
	assertTrue(map.delete(key));
	} else {
	// SIMD values can't be used as keys in WeakMaps.
	assertThrows(function() { map.set(key, value) });
	}
	assertFalse(map.has(key));
	assertSame(undefined, map.get(key));
	assertFalse(map.delete(key));
	assertFalse(map.has(key));
	assertSame(undefined, map.get(key));
	}

	for (var i in values) {
	test(map, values[i], {});
	}
	}


	// Test SIMD type with Harmony reflect-apply.
	function TestReflectApply(type) {
	function returnThis() { return this; }
	function returnThisStrict() { 'use strict'; return this; }
	function noop() {}
	function noopStrict() { 'use strict'; }
	var R = void 0;

	for (var i in values) {
	assertSame(SIMD[type].prototype,
	Object.getPrototypeOf(
	Reflect.apply(returnThis, values[i], [])));
	assertSame(values[i], Reflect.apply(returnThisStrict, values[i], []));

	assertThrows(
	function() { 'use strict'; Reflect.apply(values[i]); }, TypeError);
	assertThrows(
	function() { Reflect.apply(values[i]); }, TypeError);
	assertThrows(
	function() { Reflect.apply(noopStrict, R, values[i]); }, TypeError);
	assertThrows(
	function() { Reflect.apply(noop, R, values[i]); }, TypeError);
	}
	}


	function TestSIMDTypes() {
	var types = [ 'float32x4' ];
	for (var i = 0; i < types.length; ++i) {
	var type = types[i],
	lanes = lanesForType(type);
	TestConstructor(type, lanes);
	TestType(type, lanes);
	TestPrototype(type, lanes);
	TestValueOf(type, lanes);
	TestGet(type, lanes);
	TestToBoolean(type, lanes);
	TestToString(type, lanes);
	TestToNumber(type, lanes);
	TestEquality(type, lanes);
	TestSameValue(type, lanes);
	TestComparison(type, lanes);
	TestCall(type, lanes);
	TestAsSetKey(type, lanes, new Set);
	TestAsSetKey(type, lanes, new WeakSet);
	TestAsMapKey(type, lanes, new Map);
	TestAsMapKey(type, lanes, new WeakMap);
	TestReflectApply(type);
	}
	}
	TestSIMDTypes();