Array.reduce: Changed size of test to reduce running time on slower machines.

test/mjsunit/array-reduce.js

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 157 matching lines @@
            simpleSparseArray, accumulate, []);
 
 
 testReduce("reduce", "EmptySparseReduceSumNoInit", 0, [], [,,0,,], sum);
 testReduce("reduce", "EmptySparseReduceProdNoInit", 1, [], [,,1,,], prod);
 testReduce("reduce", "EmptySparseReduceDecNoInit", 0, [], [,,0,,], dec);
 testReduce("reduce", "EmptySparseReduceAccumulateNoInit",
            [], [], [,,[],,], accumulate);
 
 
-var verySparseArray = new Array(500000);
-verySparseArray[100000] = 2;
-verySparseArray[250000] = 4;
-verySparseArray[450000] = 6;
-var verySparseSlice2 = verySparseArray.slice(0, 100001);
-var verySparseSlice4 = verySparseArray.slice(0, 250001);
-var verySparseSlice6 = verySparseArray.slice(0, 450001);
+var verySparseArray = [];
+verySparseArray.length = 10000;
+verySparseArray[2000] = 2;
+verySparseArray[5000] = 4;
+verySparseArray[9000] = 6;
+var verySparseSlice2 = verySparseArray.slice(0, 2001);
+var verySparseSlice4 = verySparseArray.slice(0, 5001);
+var verySparseSlice6 = verySparseArray.slice(0, 9001);
 
 testReduce("reduce", "VerySparseReduceSum", 12,
-           [[0, 2, 100000, verySparseArray, 2],
-            [2, 4, 250000, verySparseArray, 6],
-            [6, 6, 450000, verySparseArray, 12]],
+           [[0, 2, 2000, verySparseArray, 2],
+            [2, 4, 5000, verySparseArray, 6],
+            [6, 6, 9000, verySparseArray, 12]],
            verySparseArray, sum, 0);
 
 testReduce("reduce", "VerySparseReduceProd", 48,
-           [[1, 2, 100000, verySparseArray, 2],
-            [2, 4, 250000, verySparseArray, 8],
-            [8, 6, 450000, verySparseArray, 48]],
+           [[1, 2, 2000, verySparseArray, 2],
+            [2, 4, 5000, verySparseArray, 8],
+            [8, 6, 9000, verySparseArray, 48]],
            verySparseArray, prod, 1);
 
 testReduce("reduce", "VerySparseReduceDec", Infinity,
-           [[0, 2, 100000, verySparseArray, Infinity],
-            [Infinity, 4, 250000, verySparseArray, Infinity],
-            [Infinity, 6, 450000, verySparseArray, Infinity]],
+           [[0, 2, 2000, verySparseArray, Infinity],
+            [Infinity, 4, 5000, verySparseArray, Infinity],
+            [Infinity, 6, 9000, verySparseArray, Infinity]],
            verySparseArray, dec, 0);
 
-testReduce("reduce", "SimpleSparseReduceAccumulate",
+testReduce("reduce", "VerySparseReduceAccumulate",
            verySparseSlice6,
-           [[[], 2, 100000, verySparseArray, verySparseSlice2],
-            [verySparseSlice2, 4, 250000, verySparseArray, verySparseSlice4],
-            [verySparseSlice4, 6, 450000, verySparseArray, verySparseSlice6]],
+           [[[], 2, 2000, verySparseArray, verySparseSlice2],
+            [verySparseSlice2, 4, 5000, verySparseArray, verySparseSlice4],
+            [verySparseSlice4, 6, 9000, verySparseArray, verySparseSlice6]],
            verySparseArray, accumulate, []);
 
 
 testReduce("reduce", "VerySparseReduceSumNoInit", 12,
-           [[2, 4, 250000, verySparseArray, 6],
-            [6, 6, 450000, verySparseArray, 12]],
+           [[2, 4, 5000, verySparseArray, 6],
+            [6, 6, 9000, verySparseArray, 12]],
            verySparseArray, sum);
 
 testReduce("reduce", "VerySparseReduceProdNoInit", 48,
-           [[2, 4, 250000, verySparseArray, 8],
-            [8, 6, 450000, verySparseArray, 48]],
+           [[2, 4, 5000, verySparseArray, 8],
+            [8, 6, 9000, verySparseArray, 48]],
            verySparseArray, prod);
 
 testReduce("reduce", "VerySparseReduceDecNoInit", Infinity,
-           [[2, 4, 250000, verySparseArray, Infinity],
-            [Infinity, 6, 450000, verySparseArray, Infinity]],
+           [[2, 4, 5000, verySparseArray, Infinity],
+            [Infinity, 6, 9000, verySparseArray, Infinity]],
            verySparseArray, dec);
 
 testReduce("reduce", "SimpleSparseReduceAccumulateNoInit",
            2,
-           [[2, 4, 250000, verySparseArray, 2],
-            [2, 6, 450000, verySparseArray, 2]],
+           [[2, 4, 5000, verySparseArray, 2],
+            [2, 6, 9000, verySparseArray, 2]],
            verySparseArray, accumulate);
 
 
 // ---- Test ReduceRight
 
 testReduce("reduceRight", "SimpleReduceRightSum", 12,
            [[0, 6, 2, simpleArray, 6],
             [6, 4, 1, simpleArray, 10],
             [10, 2, 0, simpleArray, 12]],
            simpleArray, sum, 0);
@@ skipping 58 matching lines @@
 testReduce("reduceRight", "EmptySparseReduceRightSumNoInit",
            0, [], [,,0,,], sum);
 testReduce("reduceRight", "EmptySparseReduceRightProdNoInit",
            1, [], [,,1,,], prod);
 testReduce("reduceRight", "EmptySparseReduceRightDecNoInit",
            0, [], [,,0,,], dec);
 testReduce("reduceRight", "EmptySparseReduceRightAccumulateNoInit",
            [], [], [,,[],,], accumulate);
 
 
-var verySparseSuffix6 = new Array(450001);
-verySparseSuffix6[450000] = 6;
-var verySparseSuffix4 = new Array(450001);
-verySparseSuffix4[250000] = 4;
-verySparseSuffix4[450000] = 6;
+var verySparseSuffix6 = [];
+verySparseSuffix6[9000] = 6;
+var verySparseSuffix4 = [];
+verySparseSuffix4[5000] = 4;
+verySparseSuffix4[9000] = 6;
 var verySparseSuffix2 = verySparseSlice6;
 
 
 testReduce("reduceRight", "VerySparseReduceRightSum", 12,
-           [[0, 6, 450000, verySparseArray, 6],
-            [6, 4, 250000, verySparseArray, 10],
-            [10, 2, 100000, verySparseArray, 12]],
+           [[0, 6, 9000, verySparseArray, 6],
+            [6, 4, 5000, verySparseArray, 10],
+            [10, 2, 2000, verySparseArray, 12]],
            verySparseArray, sum, 0);
 
 testReduce("reduceRight", "VerySparseReduceRightProd", 48,
-           [[1, 6, 450000, verySparseArray, 6],
-            [6, 4, 250000, verySparseArray, 24],
-            [24, 2, 100000, verySparseArray, 48]],
+           [[1, 6, 9000, verySparseArray, 6],
+            [6, 4, 5000, verySparseArray, 24],
+            [24, 2, 2000, verySparseArray, 48]],
            verySparseArray, prod, 1);
 
 testReduce("reduceRight", "VerySparseReduceRightDec", Infinity,
-           [[0, 6, 450000, verySparseArray, Infinity],
-            [Infinity, 4, 250000, verySparseArray, Infinity],
-            [Infinity, 2, 100000, verySparseArray, Infinity]],
+           [[0, 6, 9000, verySparseArray, Infinity],
+            [Infinity, 4, 5000, verySparseArray, Infinity],
+            [Infinity, 2, 2000, verySparseArray, Infinity]],
            verySparseArray, dec, 0);
 
-testReduce("reduceRight", "SimpleSparseReduceRightAccumulate",
+testReduce("reduceRight", "VerySparseReduceRightAccumulate",
            verySparseSuffix2,
-           [[[], 6, 450000, verySparseArray, verySparseSuffix6],
-            [verySparseSuffix6, 4, 250000, verySparseArray, verySparseSuffix4],
-            [verySparseSuffix4, 2, 100000, verySparseArray, verySparseSuffix2]],
+           [[[], 6, 9000, verySparseArray, verySparseSuffix6],
+            [verySparseSuffix6, 4, 5000, verySparseArray, verySparseSuffix4],
+            [verySparseSuffix4, 2, 2000, verySparseArray, verySparseSuffix2]],
            verySparseArray, accumulate, []);
 
 
 testReduce("reduceRight", "VerySparseReduceRightSumNoInit", 12,
-           [[6, 4, 250000, verySparseArray, 10],
-            [10, 2, 100000, verySparseArray, 12]],
+           [[6, 4, 5000, verySparseArray, 10],
+            [10, 2, 2000, verySparseArray, 12]],
            verySparseArray, sum);
 
 testReduce("reduceRight", "VerySparseReduceRightProdNoInit", 48,
-           [[6, 4, 250000, verySparseArray, 24],
-            [24, 2, 100000, verySparseArray, 48]],
+           [[6, 4, 5000, verySparseArray, 24],
+            [24, 2, 2000, verySparseArray, 48]],
            verySparseArray, prod);
 
 testReduce("reduceRight", "VerySparseReduceRightDecNoInit", Infinity,
-           [[6, 4, 250000, verySparseArray, Infinity],
-            [Infinity, 2, 100000, verySparseArray, Infinity]],
+           [[6, 4, 5000, verySparseArray, Infinity],
+            [Infinity, 2, 2000, verySparseArray, Infinity]],
            verySparseArray, dec);
 
 testReduce("reduceRight", "SimpleSparseReduceRightAccumulateNoInit",
            6,
-           [[6, 4, 250000, verySparseArray, 6],
-            [6, 2, 100000, verySparseArray, 6]],
+           [[6, 4, 5000, verySparseArray, 6],
+            [6, 2, 2000, verySparseArray, 6]],
            verySparseArray, accumulate);
 
 
 // undefined is an element
 var undefArray = [,,undefined,,undefined,,];
 
 testReduce("reduce", "SparseUndefinedReduceAdd", NaN,
            [[0, undefined, 2, undefArray, NaN],
             [NaN, undefined, 4, undefArray, NaN],
            ],
            undefArray, sum, 0);
 
 testReduce("reduceRight", "SparseUndefinedReduceRightAdd", NaN,
            [[0, undefined, 4, undefArray, NaN],
             [NaN, undefined, 2, undefArray, NaN],
            ], undefArray, sum, 0);
 
 testReduce("reduce", "SparseUndefinedReduceAddNoInit", NaN,
            [[undefined, undefined, 4, undefArray, NaN],
            ], undefArray, sum);
 
 testReduce("reduceRight", "SparseUndefinedReduceRightAddNoInit", NaN,
            [[undefined, undefined, 2, undefArray, NaN],
            ], undefArray, sum);
 
 
+// Ignore non-array properties:
+
+var arrayPlus = [1,2,,3];
+arrayPlus[-1] = NaN;
+arrayPlus[Math.pow(2,32)] = NaN;
+arrayPlus[NaN] = NaN;
+arrayPlus["00"] = NaN;
+arrayPlus["02"] = NaN;
+arrayPlus["-0"] = NaN;
+
+testReduce("reduce", "ArrayWithNonElementPropertiesReduce", 6,
+           [[0, 1, 0, arrayPlus, 1],
+            [1, 2, 1, arrayPlus, 3],
+            [3, 3, 3, arrayPlus, 6],
+           ], arrayPlus, sum, 0);
+
 // Test error conditions
 
 try {
   [1].reduce("not a function");
   fail("Reduce callback not a function not throwing");
 } catch (e) {
   assertTrue(e instanceof TypeError,
              "reduce callback not a function not throwing TypeError");
   assertEquals("called_non_callable", e.type,
                "reduce non function TypeError type");
@@ skipping 83 matching lines @@
 }
 
 var arr = [1, 2, 3, 4];
 testReduce("reduce", "ArrayManipulationExtender", 10,
            [[0, 1, 0, [1, 2, 3, 4], 1],
             [1, 2, 1, [1, 2, 3, 4, 4], 3],
             [3, 3, 2, [1, 2, 3, 4, 4, 5], 6],
             [6, 4, 3, [1, 2, 3, 4, 4, 5, 6], 10],
            ], arr, extender, 0);