SIMD.js: Update Float32x4 and tests to current spec.

test/mjsunit/harmony/simd.js

 // 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,
+          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())
+  // Check prefix (e.g. SIMD.Float32x4.)
+  if (string.substr(0, indexOfOpenParen) !== 'SIMD.' + type)
     return false;
-  // Remove type name and open parenthesis.
+  // Remove type name (e.g. SIMD.Float32x4) 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;
   }
@@ skipping 49 matching lines @@
 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':
+    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) {
+  var typeofString = type.charAt(0).toLowerCase() + type.slice(1);
   for (var i in values) {
-    assertEquals(type, typeof values[i])
-    assertTrue(typeof values[i] === type)
+    assertEquals(typeofString, typeof values[i])
+    assertTrue(typeof values[i] === typeofString)
     assertTrue(typeof Object(values[i]) === 'object')
     assertEquals(null, %_ClassOf(values[i]))
-    assertEquals("Float32x4", %_ClassOf(Object(values[i])))
+    assertEquals(type, %_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__)
@@ skipping 104 matching lines @@
       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)));
+  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)));
+  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; }
@@ skipping 95 matching lines @@
         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' ];
+  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();