| <!DOCTYPE HTML> |
| <html> |
| <!-- |
| Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| Use of this source code is governed by a BSD-style license that can be |
| found in the LICENSE file. |
| --> |
| <head i18n-values="dir:textdirection;"> |
| <title>TimelineAnalysis tests</title> |
| <script src="base.js"></script> |
| <style> |
| .timeline-view { |
| border: 1px solid black; |
| margin: 10px; |
| } |
| .timeline-find-dialog { |
| border: 1px solid black; |
| margin: 10px; |
| } |
| </style> |
| </head> |
| <body> |
| <script> |
| base.require('unittest'); |
| base.require('tracing_controller'); |
| base.require('test_utils'); |
| base.require('timeline_model'); |
| base.require('trace_event_importer'); |
| base.require('timeline_analysis'); |
| base.require('timeline_filter'); |
| base.require('tracks.timeline_counter_track'); |
| base.require('tracks.timeline_slice_track'); |
| base.require('tracks.timeline_thread_track'); |
| base.require('timeline'); /* TODO(nduca): reduce dependency */ |
| </script> |
| <script> |
| 'use strict'; |
| |
| var TimelineCounter = tracing.TimelineCounter; |
| var TimelineThread = tracing.TimelineThread; |
| var TimelineAnalysisView = tracing.TimelineAnalysisView; |
| var TimelineModel = tracing.TimelineModel; |
| var TimelineThreadTrack = tracks.TimelineThreadTrack; |
| var TimelineSelection = tracing.TimelineSelection; |
| var TimelineTitleFilter = tracing.TimelineTitleFilter; |
| var TimelineCounterTrack = tracks.TimelineCounterTrack; |
| var TimelineSliceTrack = tracks.TimelineSliceTrack; |
| var newSliceNamed = test_utils.newSliceNamed; |
| var newSliceCategory = test_utils.newSliceCategory; |
| |
| function createSelectionWithSingleSlice(withCategory) { |
| var model = new TimelineModel(); |
| var t53 = model.getOrCreateProcess(52).getOrCreateThread(53); |
| if (withCategory) |
| t53.pushSlice(newSliceCategory('foo', 'b', 0, 0.002)); |
| else |
| t53.pushSlice(newSliceNamed('b', 0, 0.002)); |
| |
| var t53track = new TimelineThreadTrack(); |
| t53track.thread = t53; |
| |
| var selection = new TimelineSelection(); |
| t53track.addAllObjectsMatchingFilterToSelection( |
| new TimelineTitleFilter('b'), selection); |
| assertEquals(1, selection.length); |
| |
| return selection; |
| } |
| |
| function createSelectionWithTwoSlices() { |
| var events = [ |
| {name: 'a', args: {}, pid: 52, ts: 520, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'a', args: {}, pid: 52, ts: 560, cat: 'foo', tid: 53, ph: 'E'}, |
| {name: 'aa', args: {}, pid: 52, ts: 640, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'aa', args: {}, pid: 52, ts: 700, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| var model = new TimelineModel(events); |
| |
| var t53track = new TimelineThreadTrack(); |
| t53track.thread = model.processes[52].threads[53]; |
| |
| var selection = new TimelineSelection(); |
| t53track.addAllObjectsMatchingFilterToSelection( |
| new TimelineTitleFilter('a'), selection); |
| assertEquals(2, selection.length); |
| |
| return selection; |
| } |
| |
| function createSelectionWithTwoSlicesSameTitle() { |
| var events = [ |
| {name: 'c', args: {}, pid: 52, ts: 620, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'c', args: {}, pid: 52, ts: 660, cat: 'foo', tid: 53, ph: 'E'}, |
| {name: 'c', args: {}, pid: 52, ts: 740, cat: 'foo', tid: 53, ph: 'B'}, |
| {name: 'c', args: {}, pid: 52, ts: 800, cat: 'foo', tid: 53, ph: 'E'} |
| ]; |
| var model = new TimelineModel(events); |
| |
| var t53track = new TimelineThreadTrack(); |
| t53track.thread = model.processes[52].threads[53]; |
| |
| var selection = new TimelineSelection(); |
| t53track.addAllObjectsMatchingFilterToSelection( |
| new TimelineTitleFilter('c'), selection); |
| assertEquals(2, selection.length); |
| |
| return selection; |
| } |
| |
| function createSelectionWithCounters(numSamples) { |
| if (numSamples > 2 || numSamples < 1) |
| throw new Error('This function only supports 1 or 2 samples'); |
| var events = [ |
| {name: 'ctr', args: {'value': 0}, pid: 1, ts: 0, cat: 'foo', tid: 1, |
| ph: 'C', id: 0}, |
| {name: 'ctr', args: {'value': 10}, pid: 1, ts: 10, cat: 'foo', tid: 1, |
| ph: 'C', id: 0} |
| ]; |
| var model = new TimelineModel(events); |
| var p = model.processes[1]; |
| var ctr = model.processes[1].counters['foo.ctr[0]']; |
| assertEquals('ctr[0]', ctr.name); |
| assertEquals(2, ctr.numSamples); |
| assertEquals(1, ctr.numSeries); |
| assertArrayEquals([0, 0.01], ctr.timestamps); |
| assertArrayEquals([0, 10], ctr.samples); |
| |
| var selection = new TimelineSelection(); |
| var t1track = new TimelineThreadTrack(); |
| selection.addCounterSample(t1track, ctr, 1); |
| |
| if (numSamples == 1) |
| return selection; |
| |
| selection.addCounterSample(t1track, ctr, 0); |
| return selection; |
| } |
| |
| function createSelectionWithTwoSeriesSingleCounter() { |
| var events = [ |
| {name: 'ctr', args: {'bytesallocated': 0, 'bytesfree': 25}, pid: 1, |
| ts: 0, cat: 'foo', tid: 1, ph: 'C', id: 0}, |
| {name: 'ctr', args: {'bytesallocated': 10, 'bytesfree': 15}, pid: 1, |
| ts: 10, cat: 'foo', tid: 1, ph: 'C', id: 0}, |
| {name: 'ctr', args: {'bytesallocated': 20, 'bytesfree': 5}, pid: 1, |
| ts: 20, cat: 'foo', tid: 1, ph: 'C', id: 0} |
| ]; |
| var model = new TimelineModel(events); |
| var p = model.processes[1]; |
| var ctr = model.processes[1].counters['foo.ctr[0]']; |
| assertEquals('ctr[0]', ctr.name); |
| assertEquals(3, ctr.numSamples); |
| assertEquals(2, ctr.numSeries); |
| |
| var selection = new TimelineSelection(); |
| var t1track = new TimelineThreadTrack(); |
| selection.addCounterSample(t1track, ctr, 1); |
| |
| return selection; |
| } |
| |
| function createSelectionWithTwoSeriesTwoCounters() { |
| var ctr1 = new TimelineCounter(null, 0, '', 'ctr1'); |
| ctr1.seriesNames.push('bytesallocated', 'bytesfree'); |
| ctr1.seriesColors.push(0, 1); |
| ctr1.timestamps.push(0, 10, 20); |
| ctr1.samples.push(0, 25, 10, 15, 20, 5); |
| |
| var ctr2 = new TimelineCounter(null, 0, '', 'ctr2'); |
| ctr2.seriesNames.push('bytesallocated', 'bytesfree'); |
| ctr2.seriesColors.push(0, 1); |
| ctr2.timestamps.push(0, 10, 20); |
| ctr2.samples.push(0, 25, 10, 15, 20, 5); |
| |
| var selection = new TimelineSelection(); |
| var t1track = new TimelineThreadTrack(); |
| selection.addCounterSample(t1track, ctr1, 1); |
| selection.addCounterSample(t1track, ctr2, 2); |
| |
| return selection; |
| } |
| |
| function createSelectionWithTwoCountersDiffSeriesDiffHits() { |
| var ctr1 = new TimelineCounter(null, 0, '', 'a'); |
| ctr1.seriesNames.push('bytesallocated'); |
| ctr1.seriesColors.push(0); |
| ctr1.timestamps.push(0, 10, 20); |
| ctr1.samples.push(0, 25, 10); |
| assertEquals('a', ctr1.name); |
| assertEquals(3, ctr1.numSamples); |
| assertEquals(1, ctr1.numSeries); |
| |
| var ctr2 = new TimelineCounter(null, 0, '', 'b'); |
| ctr2.seriesNames.push('bytesallocated', 'bytesfree'); |
| ctr2.seriesColors.push(0, 1); |
| ctr2.timestamps.push(0, 10, 20, 30); |
| ctr2.samples.push(0, 25, 10, 15, 20, 5, 25, 0); |
| assertEquals('b', ctr2.name); |
| assertEquals(4, ctr2.numSamples); |
| assertEquals(2, ctr2.numSeries); |
| |
| var selection = new TimelineSelection(); |
| var t1track = new TimelineThreadTrack(); |
| selection.addCounterSample(t1track, ctr1, 1); |
| selection.addCounterSample(t1track, ctr2, 2); |
| |
| return selection; |
| } |
| |
| function createSelectionWithSingleSliceSingleCounter() { |
| var model = new TimelineModel(); |
| var thread = model.getOrCreateProcess(1).getOrCreateThread(1); |
| thread.pushSlice(newSliceNamed('b', 1, 5)); |
| |
| var ctr1 = model.getOrCreateProcess(1).getOrCreateCounter('cat', 'ctr1'); |
| ctr1.seriesNames.push('bytesallocated', 'bytesfree'); |
| ctr1.seriesColors.push(0, 1); |
| ctr1.timestamps.push(0, 10, 20); |
| ctr1.samples.push(0, 25, 10, 15, 20, 5); |
| assertEquals('ctr1', ctr1.name); |
| assertEquals(3, ctr1.numSamples); |
| assertEquals(2, ctr1.numSeries); |
| |
| var ctr1track = new TimelineCounterTrack(); |
| ctr1track.counter = ctr1; |
| |
| var threadTrack = new TimelineSliceTrack(); |
| threadTrack.slices = thread.slices; |
| |
| var selection = new TimelineSelection(); |
| selection.addCounterSample(ctr1track, ctr1, 1); |
| threadTrack.addAllObjectsMatchingFilterToSelection( |
| new TimelineTitleFilter('b'), selection); |
| assertEquals(2, selection.length); |
| return selection; |
| } |
| |
| function createSelectionWithNormallyDistributedSamples(numSlices) { |
| // Distance between start times is normally distributed, with mu = 16ms |
| // and sigma = 3ms. |
| var startTimes = [ |
| 0, 18.4362262859, 32.5378088645, 44.8978868054, |
| 63.4772725504, 77.438888345, 92.0102867913, 99.6208686689, |
| 119.150576393, 137.54545468, 153.991587743, 175.456095568, |
| 193.395772651, 205.691644582, 218.740054982, 239.308480724, |
| 250.880949151, 268.528689601, 281.950478133, 296.791635722, |
| 315.862427391, 333.954888221, 342.392899581, 362.364373939, |
| 377.593380892, 392.296896748, 415.779941407, 435.517713864, |
| 454.581222491, 470.329018858, 488.37029095, 502.283017166, |
| 521.15141113, 534.36224697, 554.425018316, 574.89913248, |
| 589.60294439, 604.780562233, 615.481610668, 630.055628965, |
| 645.908449096, 661.776084055, 673.276049017, 689.776401428, |
| 704.440135004, 716.33262401, 732.380086528, 743.970715322, |
| 756.506690025, 772.391485532, 794.636984401, 803.801415494, |
| 819.006502926, 837.610127549, 854.551103283, 875.170613672, |
| 891.508235124, 905.263299017, 929.309555683, 943.417968804, |
| 957.289319239, 972.302910569, 986.669355637, 1002.71558868, |
| 1013.83359637, 1030.16840733, 1040.39503139, 1057.61583325, |
| 1075.64709686, 1086.67671319, 1100.4617455, 1118.4871842, |
| 1129.98143488, 1144.52318588, 1160.36966285, 1179.50049042, |
| 1195.03088169, 1215.98199401, 1226.66591838, 1245.83650314, |
| 1268.18058265, 1285.11047342, 1301.71570575, 1316.40723345, |
| 1329.94342488, 1343.7569577, 1358.28267513, 1371.17560308, |
| 1386.42247119, 1401.51767749, 1417.52489051, 1440.98712348, |
| 1457.80113781, 1475.66079406, 1494.64137536, 1509.52941903, |
| 1524.54762552, 1545.42960714, 1565.19444597, 1580.56308936, |
| 1596.72211651]; |
| |
| var events = []; |
| |
| var model = new TimelineModel(); |
| var thread = model.getOrCreateProcess(52).getOrCreateThread(53); |
| var duration = 1; // 1ms |
| |
| for (var i = 0; i < startTimes.length; ++i) { |
| for (var j = 0; j < numSlices; ++j) { |
| var name = 'slice' + String(numSlices - 1 - j); |
| thread.slices.push(newSliceNamed(name, startTimes[i], duration)); |
| } |
| } |
| |
| var t53track = new TimelineThreadTrack(); |
| t53track.thread = model.processes[52].threads[53]; |
| |
| var selection = new TimelineSelection(); |
| t53track.addAllObjectsMatchingFilterToSelection( |
| new TimelineTitleFilter('slice'), selection); |
| assertEquals(101 * numSlices, selection.length); |
| |
| return selection; |
| } |
| |
| function testAnalysisViewWithSingleSlice() { |
| var selection = createSelectionWithSingleSlice(); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function testAnalysisViewWithSingleSliceCategory() { |
| var selection = createSelectionWithSingleSlice(true); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function testAnalysisViewWithMultipleSlices() { |
| var selection = createSelectionWithTwoSlices(); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function testAnalysisViewWithMultipleSlicesSameTitle() { |
| var selection = createSelectionWithTwoSlicesSameTitle(); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function testAnalysisViewWithSingleCounterWithTwoSeries() { |
| var selection = createSelectionWithTwoSeriesSingleCounter(); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function testAnalysisViewWithTwoCountersWithTwoSeries() { |
| var selection = createSelectionWithTwoSeriesTwoCounters(); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function testAnalysisViewWithSingleSliceSingleCounter() { |
| var selection = createSelectionWithSingleSliceSingleCounter(); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function testSelectionWithNormallyDistributedSamples() { |
| var numSlices = 1; |
| var selection = createSelectionWithNormallyDistributedSamples(numSlices); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| } |
| |
| function StubAnalysisResults() { |
| this.tables = []; |
| } |
| StubAnalysisResults.prototype = { |
| __proto__: Object.protoype, |
| |
| appendTable: function(parent, className) { |
| var table = { |
| className: className, |
| rows: [] |
| }; |
| table.className = className; |
| this.tables.push(table); |
| return table; |
| }, |
| |
| appendTableHeader: function(table, label) { |
| if (table.tableHeader) |
| throw new Error('Only one summary header allowed.'); |
| table.tableHeader = label; |
| }, |
| |
| appendSummaryRow: function(table, label, opt_text) { |
| table.rows.push({label: label, |
| text: opt_text}); |
| }, |
| |
| appendSpacingRow: function(table) { |
| table.rows.push({spacing: true}); |
| }, |
| |
| appendSummaryRowTime: function(table, label, time) { |
| table.rows.push({label: label, |
| time: time}); |
| }, |
| |
| appendDataRow: function(table, label, duration, occurences, details) { |
| table.rows.push({label: label, |
| duration: duration, |
| occurences: occurences, |
| details: details}); |
| } |
| }; |
| |
| function testAnalyzeSelectionWithSingleSlice() { |
| var selection = createSelectionWithSingleSlice(); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| var table = results.tables[0]; |
| assertEquals('Selected slice:', table.tableHeader); |
| assertEquals(3, table.rows.length); |
| |
| assertEquals('b', table.rows[0].text); |
| assertEquals(0, table.rows[1].time); |
| assertAlmostEquals(0.002, table.rows[2].time); |
| } |
| |
| function testAnalyzeSelectionWithFalsyArgs() { |
| var model = new TimelineModel(); |
| var t53 = model.getOrCreateProcess(52).getOrCreateThread(53); |
| var slice = newSliceNamed('b', 0, 0.002); |
| slice.args.bar = 0; |
| slice.args.foo = false; |
| t53.pushSlice(slice); |
| var t53track = new TimelineThreadTrack(); |
| t53track.thread = t53; |
| var selection = new TimelineSelection(); |
| t53track.addAllObjectsMatchingFilterToSelection( |
| new TimelineTitleFilter('b'), selection); |
| assertEquals(1, selection.length); |
| |
| var analysisEl = new TimelineAnalysisView(); |
| analysisEl.selection = selection; |
| this.addHTMLOutput(undefined, analysisEl); |
| var rows = analysisEl.querySelectorAll('tr'); |
| assertEquals(rows.length, 7); |
| assertEquals(' bar', rows[5].children[0].textContent); |
| assertEquals('0', rows[5].children[1].textContent); |
| assertEquals(' foo', rows[6].children[0].textContent); |
| assertEquals('false', rows[6].children[1].textContent); |
| } |
| |
| function testAnalyzeSelectionWithSingleSliceCategory() { |
| var selection = createSelectionWithSingleSlice(true); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| var table = results.tables[0]; |
| assertEquals('Selected slice:', table.tableHeader); |
| assertEquals(4, table.rows.length); |
| |
| assertEquals('b', table.rows[0].text); |
| assertEquals('foo', table.rows[1].text); |
| assertEquals(0, table.rows[2].time); |
| assertAlmostEquals(0.002, table.rows[3].time); |
| } |
| |
| function testAnalyzeSelectionWithTwoSlices() { |
| var selection = createSelectionWithTwoSlices(); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| var table = results.tables[0]; |
| assertEquals('Slices:', table.tableHeader); |
| assertEquals(6, table.rows.length); |
| |
| assertEquals('a', table.rows[0].label); |
| assertEquals(1, table.rows[0].occurences); |
| assertAlmostEquals(0.04, table.rows[0].duration); |
| assertEquals('aa', table.rows[1].label); |
| assertEquals(1, table.rows[1].occurences); |
| assertAlmostEquals(0.06, table.rows[1].duration); |
| assertEquals('*Totals', table.rows[2].label); |
| assertEquals(2, table.rows[2].occurences); |
| assertAlmostEquals(0.1, table.rows[2].duration); |
| |
| assertEquals('Selection start', table.rows[4].label); |
| assertAlmostEquals(0, table.rows[4].time); |
| |
| assertEquals('Selection extent', table.rows[5].label); |
| assertAlmostEquals(0.18, table.rows[5].time); |
| } |
| |
| function testAnalyzeSelectionWithTwoSlicesSameTitle() { |
| var selection = createSelectionWithTwoSlicesSameTitle(); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| var table = results.tables[0]; |
| |
| assertEquals('Slices:', table.tableHeader); |
| assertEquals(5, table.rows.length); |
| |
| assertEquals('c', table.rows[0].label); |
| assertEquals('2', table.rows[0].occurences); |
| assertAlmostEquals(0.04, table.rows[0].details.min); |
| assertAlmostEquals(0.05, table.rows[0].details.avg); |
| assertAlmostEquals(0.06, table.rows[0].details.max); |
| assertAlmostEquals(0.1, table.rows[0].duration); |
| assertEquals('*Totals', table.rows[1].label); |
| assertAlmostEquals(0.1, table.rows[1].duration); |
| assertEquals('Selection start', table.rows[3].label); |
| assertAlmostEquals(0, table.rows[3].time); |
| assertEquals('Selection extent', table.rows[4].label); |
| assertAlmostEquals(0.18, table.rows[4].time); |
| } |
| |
| function testAnalyzeSelectionWithSingleCounter() { |
| var selection = createSelectionWithCounters(1); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| var table = results.tables[0]; |
| assertEquals('Selected counter:', table.tableHeader); |
| assertEquals(3, table.rows.length); |
| |
| assertEquals('Title', table.rows[0].label); |
| assertEquals('Timestamp', table.rows[1].label); |
| assertEquals('value', table.rows[2].label); |
| assertEquals(10, table.rows[2].text); |
| } |
| |
| function testAnalyzeSelectionWithBasicTwoSeriesTwoCounters() { |
| var selection = createSelectionWithTwoSeriesTwoCounters(); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| var table = results.tables[0]; |
| assertEquals('Counters:', table.tableHeader); |
| assertEquals(4, table.rows.length); |
| |
| assertEquals('ctr1: bytesallocated', table.rows[0].label); |
| assertEquals('ctr1: bytesfree', table.rows[1].label); |
| assertEquals('ctr2: bytesallocated', table.rows[2].label); |
| assertEquals('ctr2: bytesfree', table.rows[3].label); |
| } |
| |
| function testAnalyzeSelectionWithComplexSeriesTwoCounters() { |
| var selection = createSelectionWithTwoCountersDiffSeriesDiffHits(); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| var table = results.tables[0]; |
| assertEquals('Counters:', table.tableHeader); |
| assertEquals(3, table.rows.length); |
| |
| assertEquals('a: bytesallocated', table.rows[0].label); |
| assertEquals('b: bytesallocated', table.rows[1].label); |
| assertEquals('b: bytesfree', table.rows[2].label); |
| } |
| |
| function testAnalyzeSelectionWithCounterAndSlices() { |
| var selection = createSelectionWithSingleSliceSingleCounter(); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(2, results.tables.length); |
| var sliceTable = results.tables[0]; |
| var counterTable = results.tables[1]; |
| |
| assertEquals('Selected slice:', sliceTable.tableHeader); |
| assertEquals(3, sliceTable.rows.length); |
| |
| assertEquals('Selected counter:', counterTable.tableHeader); |
| assertEquals(4, counterTable.rows.length); |
| } |
| |
| function testAnalyzeSelectionWithNormallyDistributedSamples() { |
| var numSlices = 2; |
| var selection = createSelectionWithNormallyDistributedSamples(numSlices); |
| |
| var results = new StubAnalysisResults(); |
| tracing.analyzeSelection_(results, selection); |
| assertEquals(1, results.tables.length); |
| |
| assertEquals('slice0', results.tables[0].rows[0].label); |
| assertEquals( |
| 63, Math.round(results.tables[0].rows[0].details.frequency)); |
| assertEquals( |
| 16, Math.round(results.tables[0].rows[0].details.frequency_stddev)); |
| |
| assertEquals('slice1', results.tables[0].rows[1].label); |
| assertEquals( |
| 63, Math.round(results.tables[0].rows[1].details.frequency)); |
| assertEquals( |
| 16, Math.round(results.tables[0].rows[1].details.frequency_stddev)); |
| } |
| </script> |
| </body> |
| </html> |
