Change Numeric sourceInfos into sample diagnostics

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..15458bf3b0238c1f5fdc1921178d641bac6fcc02 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">
 
@@ -55,16 +56,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 +78,66 @@ 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'));
 
     assert.equal(n.numNans, 2);
-    assert.deepEqual(n.nanSourceInfos, ['b', 'c']);
+    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 +200,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);