[polymer] Merge of master into polymer10-migration

tracing/tracing/value/numeric_test.html

Index: tracing/tracing/value/numeric_test.html
diff --git a/tracing/tracing/value/numeric_test.html b/tracing/tracing/value/numeric_test.html
index ed586ededfb45e6ac2428c17c5117a30e932c4f8..208bb90acd2591c72e0b6995262b45586fe378cc 100644
--- a/tracing/tracing/value/numeric_test.html
+++ b/tracing/tracing/value/numeric_test.html
@@ -7,6 +7,7 @@ found in the LICENSE file.
 
 <link rel="import" href="/tracing/base/range.html">
 <link rel="import" href="/tracing/base/statistics.html">
+<link rel="import" href="/tracing/value/diagnostics/generic.html">
 <link rel="import" href="/tracing/value/numeric.html">
 <link rel="import" href="/tracing/value/unit.html">
 
@@ -14,7 +15,6 @@ found in the LICENSE file.
 'use strict';
 
 tr.b.unittest.testSuite(function() {
-
   var TEST_NUMERIC_BUILDER = tr.v.NumericBuilder.createLinear(
       tr.v.Unit.byName.timeDurationInMs, tr.b.Range.fromExplicitRange(0, 1000),
       10);
@@ -42,6 +42,30 @@ tr.b.unittest.testSuite(function() {
     }
   }
 
+  test('significance', function() {
+    assert.strictEqual(TEST_NUMERIC_BUILDER.build().getDifferenceSignificance(
+        TEST_NUMERIC_BUILDER.build()), tr.v.Significance.DONT_CARE);
+
+    var builder = tr.v.NumericBuilder.createLinear(
+        tr.v.Unit.byName.unitlessNumber_smallerIsBetter,
+        tr.b.Range.fromExplicitRange(0, 100), 10);
+    var numericA = builder.build();
+    var numericB = builder.build();
+    for (var i = 0; i < 100; ++i) {
+      numericA.add(i);
+      numericB.add(i * 0.85);
+    }
+
+    assert.strictEqual(numericA.getDifferenceSignificance(numericB),
+        tr.v.Significance.INSIGNIFICANT);
+    assert.strictEqual(numericB.getDifferenceSignificance(numericA),
+        tr.v.Significance.INSIGNIFICANT);
+    assert.strictEqual(numericA.getDifferenceSignificance(numericB, 0.1),
+        tr.v.Significance.SIGNIFICANT);
+    assert.strictEqual(numericB.getDifferenceSignificance(numericA, 0.1),
+        tr.v.Significance.SIGNIFICANT);
+  });
+
   test('nonUnitThrows', function() {
     assert.throws(function() { new tr.v.NumericBase('foo', -273.15); });
   });
@@ -55,16 +79,16 @@ tr.b.unittest.testSuite(function() {
     var n = TEST_NUMERIC_BUILDER.build();
     assert.equal(n.getBinForValue(250).range.min, 200);
     assert.equal(n.getBinForValue(250).range.max, 300);
-    n.add(-1, 'a');
-    n.add(0, 'b');
-    n.add(0, 'c');
-    n.add(500, 'c');
-    n.add(999, 'd');
-    n.add(1000, 'd');
+    n.add(-1, new tr.v.d.Generic('a'));
+    n.add(0, new tr.v.d.Generic('b'));
+    n.add(0, new tr.v.d.Generic('c'));
+    n.add(500, new tr.v.d.Generic('c'));
+    n.add(999, new tr.v.d.Generic('d'));
+    n.add(1000, new tr.v.d.Generic('d'));
     assert.equal(n.underflowBin.count, 1);
 
     assert.equal(n.getBinForValue(0).count, 2);
-    assert.deepEqual(n.getBinForValue(0).sourceInfos,
+    assert.deepEqual(n.getBinForValue(0).diagnostics.map(d => d.value),
                      ['b', 'c']);
 
     assert.equal(n.getBinForValue(500).count, 1);
@@ -77,56 +101,68 @@ tr.b.unittest.testSuite(function() {
 
   test('numericNans', function() {
     var n = TEST_NUMERIC_BUILDER.build();
-    n.add(undefined, 'b');
-    n.add(NaN, 'c');
+    n.add(undefined, new tr.v.d.Generic('b'));
+    n.add(NaN, new tr.v.d.Generic('c'));
+    n.add(undefined);
+    n.add(NaN);
 
-    assert.equal(n.numNans, 2);
-    assert.deepEqual(n.nanSourceInfos, ['b', 'c']);
+    assert.equal(n.numNans, 4);
+    assert.deepEqual(n.nanDiagnostics.map(d => d.value), ['b', 'c']);
+
+    var n2 = n.clone();
+    assert.instanceOf(n2.nanDiagnostics[0], tr.v.d.Generic);
   });
 
   test('addNumericsValid', function() {
     var n0 = TEST_NUMERIC_BUILDER.build();
     var n1 = TEST_NUMERIC_BUILDER.build();
-    n0.add(-1, 'a0');
-    n0.add(0, 'b0');
-    n0.add(0, 'c0');
-    n0.add(500, 'c0');
-    n0.add(1000, 'd0');
-    n0.add(NaN, 'e0');
-
-    n1.add(-1, 'a1');
-    n1.add(0, 'b1');
-    n1.add(0, 'c1');
-    n1.add(999, 'd1');
-    n1.add(1000, 'd1');
-    n1.add(NaN, 'e1');
+    n0.add(-1, new tr.v.d.Generic('a0'));
+    n0.add(0, new tr.v.d.Generic('b0'));
+    n0.add(0, new tr.v.d.Generic('c0'));
+    n0.add(500, new tr.v.d.Generic('c0'));
+    n0.add(1000, new tr.v.d.Generic('d0'));
+    n0.add(NaN, new tr.v.d.Generic('e0'));
+
+    n1.add(-1, new tr.v.d.Generic('a1'));
+    n1.add(0, new tr.v.d.Generic('b1'));
+    n1.add(0, new tr.v.d.Generic('c1'));
+    n1.add(999, new tr.v.d.Generic('d1'));
+    n1.add(1000, new tr.v.d.Generic('d1'));
+    n1.add(NaN, new tr.v.d.Generic('e1'));
 
     n0.addNumeric(n1);
 
     assert.equal(n0.numNans, 2);
-    assert.deepEqual(n0.nanSourceInfos, ['e0', 'e1']);
+    assert.deepEqual(n0.nanDiagnostics.map(d => d.value), ['e0', 'e1']);
 
     assert.equal(n0.underflowBin.count, 2);
-    assert.deepEqual(n0.underflowBin.sourceInfos, ['a0', 'a1']);
+    assert.deepEqual(n0.underflowBin.diagnostics.map(d => d.value),
+        ['a0', 'a1']);
 
     assert.equal(n0.getBinForValue(0).count, 4);
-    assert.deepEqual(n0.getBinForValue(0).sourceInfos,
+    assert.deepEqual(n0.getBinForValue(0).diagnostics.map(d => d.value),
         ['b0', 'c0', 'b1', 'c1']);
 
     assert.equal(n0.getBinForValue(500).count, 1);
-    assert.deepEqual(n0.getBinForValue(500).sourceInfos, ['c0']);
+    assert.deepEqual(n0.getBinForValue(500).diagnostics.map(d => d.value),
+        ['c0']);
 
     assert.equal(n0.getBinForValue(999).count, 1);
-    assert.deepEqual(n0.getBinForValue(999).sourceInfos, ['d1']);
+    assert.deepEqual(n0.getBinForValue(999).diagnostics.map(d => d.value),
+        ['d1']);
 
     assert.equal(n0.overflowBin.count, 2);
-    assert.deepEqual(n0.overflowBin.sourceInfos, ['d0', 'd1']);
+    assert.deepEqual(n0.overflowBin.diagnostics.map(d => d.value),
+        ['d0', 'd1']);
 
     assert.equal(n0.numValues, 10);
     assert.closeTo(n0.average, 349.7, 0.1);
 
     assert.equal(2, n0.maxCount);
     assert.equal(2, n1.maxCount);
+
+    var n02 = n0.clone();
+    assert.instanceOf(n02.underflowBin.diagnostics[0], tr.v.d.Generic);
   });
 
   test('addNumericsInvalid', function() {
@@ -189,7 +225,7 @@ tr.b.unittest.testSuite(function() {
           tr.v.Unit.byName.timeDurationInMs,
           tr.b.Range.fromExplicitRange(min, max),
           bins).build();
-      array.forEach((x) => n.add(x, 'x'));
+      array.forEach((x) => n.add(x, new tr.v.d.Generic('x')));
       [0.25, 0.5, 0.75, 0.8, 0.95, 0.99].forEach(function(percent) {
         var expected = tr.b.Statistics.percentile(array, percent);
         var actual = n.getApproximatePercentile(percent);
@@ -415,6 +451,120 @@ tr.b.unittest.testSuite(function() {
     assert.strictEqual(values.pct_099_5.value, 0);
     assert.strictEqual(values.pct_100.value, 0);
   });
+
+  test('sampleValues', function() {
+    var n0 = TEST_NUMERIC_BUILDER.build();
+    var n1 = TEST_NUMERIC_BUILDER.build();
+    // maxNumSampleValues defaults to numBins * 10, which, including the
+    // underflowBin and overflowBin plus this builder's 10 central bins,
+    // is 12 * 10.
+    assert.strictEqual(n0.maxNumSampleValues, 120);
+    assert.strictEqual(n1.maxNumSampleValues, 120);
+    var values0 = [];
+    var values1 = [];
+    for (var i = 0; i < 10; ++i) {
+      values0.push(i);
+      n0.add(i);
+    }
+    for (var i = 10; i < 20; ++i) {
+      values1.push(i);
+      n1.add(i);
+    }
+    assert.deepEqual(n0.sampleValues, values0);
+    assert.deepEqual(n1.sampleValues, values1);
+    n0.addNumeric(n1);
+    assert.deepEqual(n0.sampleValues, values0.concat(values1));
+    var n2 = n0.clone();
+    assert.deepEqual(n2.sampleValues, values0.concat(values1));
+
+    for (var i = 0; i < 200; ++i)
+      n0.add(i);
+    assert.strictEqual(n0.sampleValues.length, n0.maxNumSampleValues);
+
+    var n3 = TEST_NUMERIC_BUILDER.build();
+    n3.maxNumSampleValues = 10;
+    for (var i = 0; i < 100; ++i)
+      n3.add(i);
+    assert.strictEqual(n3.sampleValues.length, 10);
+  });
+
+  test('mergeScalarNumerics', function() {
+    var scalarA = new tr.v.ScalarNumeric(tr.v.Unit.byName.timeDurationInMs, 10);
+    var scalarB = new tr.v.ScalarNumeric(tr.v.Unit.byName.timeDurationInMs, 20);
+
+    var numeric = scalarA.merge(scalarB);
+    assert.instanceOf(numeric, tr.v.Numeric);
+    assert.strictEqual(numeric.range.min, 10);
+    assert.strictEqual(numeric.range.max, 20);
+    assert.strictEqual(numeric.maxNumSampleValues, 1000);
+    assert.strictEqual(numeric.numValues, 2);
+    assert.strictEqual(numeric.numNans, 0);
+    assert.lengthOf(numeric.sampleValues, 2);
+    assert.lengthOf(numeric.allBins, 4);
+
+    scalarB.value = scalarA.value;
+    numeric = scalarA.merge(scalarB);
+    assert.instanceOf(numeric, tr.v.Numeric);
+    assert.strictEqual(numeric.maxNumSampleValues, 1000);
+    assert.strictEqual(numeric.numValues, 2);
+    assert.strictEqual(numeric.numNans, 0);
+    assert.lengthOf(numeric.sampleValues, 2);
+    assert.lengthOf(numeric.allBins, 4);
+    assert.strictEqual(numeric.range.min, 9);
+    assert.strictEqual(numeric.range.max, 10);
+
+    scalarA.value = 'i am not a number';
+    scalarB.value = 'i am also not a number';
+    numeric = scalarA.merge(scalarB);
+    assert.instanceOf(numeric, tr.v.Numeric);
+    assert.strictEqual(numeric.maxNumSampleValues, 1000);
+    assert.strictEqual(numeric.numValues, 0);
+    assert.strictEqual(numeric.numNans, 2);
+    assert.lengthOf(numeric.sampleValues, 2);
+    assert.lengthOf(numeric.allBins, 4);
+    assert.strictEqual(numeric.range.min, 0);
+    assert.strictEqual(numeric.range.max, 1);
+  });
+
+  test('mergeNumericWithScalar', function() {
+    var scalar = new tr.v.ScalarNumeric(
+        tr.v.Unit.byName.timeDurationInMs, 1010);
+    var numeric = TEST_NUMERIC_BUILDER.build();
+    for (var i = 0; i < 100; ++i)
+      numeric.add(Math.random() * 1000);
+    numeric.add('i am not a number');
+
+    var mergedA = scalar.merge(numeric);
+    var mergedB = numeric.merge(scalar);
+    assert.instanceOf(mergedA, tr.v.Numeric);
+    assert.instanceOf(mergedB, tr.v.Numeric);
+
+    assert.strictEqual(mergedA.maxNumSampleValues, 1000);
+    // numValues does not include non-number samples.
+    assert.strictEqual(mergedA.numValues, 101);
+    assert.strictEqual(mergedA.numNans, 1);
+    assert.strictEqual(mergedA.range.min, numeric.running.min);
+    assert.strictEqual(mergedA.range.max, 1010);
+
+    assert.strictEqual(mergedB.maxNumSampleValues, 1000);
+    // numValues does not include non-number samples.
+    assert.strictEqual(mergedB.numValues, 101);
+    assert.strictEqual(mergedB.numNans, 1);
+    assert.strictEqual(mergedB.range.min, numeric.running.min);
+    assert.strictEqual(mergedB.range.max, 1010);
+
+    // Normalize away some insignificant differences so that deepEqual can test
+    // the significant fields.
+    var mergedAdict = mergedA.asDict();
+    var mergedBdict = mergedB.asDict();
+    mergedAdict.sampleValues.sort();
+    mergedBdict.sampleValues.sort();
+    for (var stat in mergedAdict.running) {
+      mergedAdict.running[stat] = Math.round(mergedAdict.running[stat]);
+      mergedBdict.running[stat] = Math.round(mergedBdict.running[stat]);
+    }
+    assert.deepEqual(mergedAdict, mergedBdict);
+  });
 });
 
 </script>