| // Copyright (C) 2012 Google Inc. 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 with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| // @fileoverview Base JS file for pages that want to parse the results JSON |
| // from the testing bots. This deals with generic utility functions, visible |
| // history, popups and appending the script elements for the JSON files. |
| // |
| // The calling page is expected to implement the following "abstract" |
| // functions/objects: |
| var g_pageLoadStartTime = Date.now(); |
| var g_resourceLoader; |
| |
| // Generates the contents of the dashboard. The page should override this with |
| // a function that generates the page assuming all resources have loaded. |
| function generatePage() {} |
| |
| // Takes a key and a value and sets the g_currentState[key] = value iff key is |
| // a valid hash parameter and the value is a valid value for that key. |
| // |
| // @return {boolean} Whether the key what inserted into the g_currentState. |
| function handleValidHashParameter(key, value) |
| { |
| return false; |
| } |
| |
| // Default hash parameters for the page. The page should override this to create |
| // default states. |
| var g_defaultDashboardSpecificStateValues = {}; |
| |
| |
| // The page should override this to modify page state due to |
| // changing query parameters. |
| // @param {Object} params New or modified query params as key: value. |
| // @return {boolean} Whether changing this parameter should cause generatePage to be called. |
| function handleQueryParameterChange(params) |
| { |
| return true; |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // CONSTANTS |
| ////////////////////////////////////////////////////////////////////////////// |
| var GTEST_EXPECTATIONS_MAP_ = { |
| 'P': 'PASS', |
| 'F': 'FAIL', |
| 'N': 'NO DATA', |
| 'X': 'SKIPPED' |
| }; |
| |
| var LAYOUT_TEST_EXPECTATIONS_MAP_ = { |
| 'P': 'PASS', |
| 'N': 'NO DATA', |
| 'X': 'SKIP', |
| 'T': 'TIMEOUT', |
| 'F': 'TEXT', |
| 'C': 'CRASH', |
| 'I': 'IMAGE', |
| 'Z': 'IMAGE+TEXT', |
| // We used to glob a bunch of expectations into "O" as OTHER. Expectations |
| // are more precise now though and it just means MISSING. |
| 'O': 'MISSING' |
| }; |
| |
| var FAILURE_EXPECTATIONS_ = { |
| 'T': 1, |
| 'F': 1, |
| 'C': 1, |
| 'I': 1, |
| 'Z': 1 |
| }; |
| |
| // Keys in the JSON files. |
| var WONTFIX_COUNTS_KEY = 'wontfixCounts'; |
| var FIXABLE_COUNTS_KEY = 'fixableCounts'; |
| var DEFERRED_COUNTS_KEY = 'deferredCounts'; |
| var WONTFIX_DESCRIPTION = 'Tests never to be fixed (WONTFIX)'; |
| var FIXABLE_DESCRIPTION = 'All tests for this release'; |
| var DEFERRED_DESCRIPTION = 'All deferred tests (DEFER)'; |
| var FIXABLE_COUNT_KEY = 'fixableCount'; |
| var ALL_FIXABLE_COUNT_KEY = 'allFixableCount'; |
| var CHROME_REVISIONS_KEY = 'chromeRevision'; |
| var WEBKIT_REVISIONS_KEY = 'webkitRevision'; |
| var TIMESTAMPS_KEY = 'secondsSinceEpoch'; |
| var BUILD_NUMBERS_KEY = 'buildNumbers'; |
| var TESTS_KEY = 'tests'; |
| var ONE_DAY_SECONDS = 60 * 60 * 24; |
| var ONE_WEEK_SECONDS = ONE_DAY_SECONDS * 7; |
| |
| // These should match the testtype uploaded to test-results.appspot.com. |
| // See http://test-results.appspot.com/testfile. |
| var TEST_TYPES = [ |
| 'base_unittests', |
| 'browser_tests', |
| 'cacheinvalidation_unittests', |
| 'compositor_unittests', |
| 'content_browsertests', |
| 'content_unittests', |
| 'courgette_unittests', |
| 'crypto_unittests', |
| 'googleurl_unittests', |
| 'gfx_unittests', |
| 'gl_tests', |
| 'gpu_tests', |
| 'gpu_unittests', |
| 'installer_util_unittests', |
| 'interactive_ui_tests', |
| 'ipc_tests', |
| 'jingle_unittests', |
| 'layout-tests', |
| 'media_unittests', |
| 'mini_installer_test', |
| 'net_unittests', |
| 'printing_unittests', |
| 'remoting_unittests', |
| 'safe_browsing_tests', |
| 'sql_unittests', |
| 'sync_unit_tests', |
| 'sync_integration_tests', |
| 'test_shell_tests', |
| 'ui_tests', |
| 'unit_tests', |
| 'views_unittests', |
| 'webkit_unit_tests', |
| ]; |
| |
| var RELOAD_REQUIRING_PARAMETERS = ['showAllRuns', 'group', 'testType']; |
| |
| // Enum for indexing into the run-length encoded results in the JSON files. |
| // 0 is where the count is length is stored. 1 is the value. |
| var RLE = { |
| LENGTH: 0, |
| VALUE: 1 |
| } |
| |
| function isFailingResult(value) |
| { |
| return 'FSTOCIZ'.indexOf(value) != -1; |
| } |
| |
| // Takes a key and a value and sets the g_currentState[key] = value iff key is |
| // a valid hash parameter and the value is a valid value for that key. Handles |
| // cross-dashboard parameters then falls back to calling |
| // handleValidHashParameter for dashboard-specific parameters. |
| // |
| // @return {boolean} Whether the key what inserted into the g_currentState. |
| function handleValidHashParameterWrapper(key, value) |
| { |
| switch(key) { |
| case 'testType': |
| validateParameter(g_crossDashboardState, key, value, |
| function() { return TEST_TYPES.indexOf(value) != -1; }); |
| return true; |
| |
| case 'group': |
| validateParameter(g_crossDashboardState, key, value, |
| function() { |
| return value in LAYOUT_TESTS_BUILDER_GROUPS || |
| value in CHROMIUM_GPU_TESTS_BUILDER_GROUPS || |
| value in CHROMIUM_GTESTS_BUILDER_GROUPS; |
| }); |
| return true; |
| |
| // FIXME: This should probably be stored on g_crossDashboardState like everything else in this function. |
| case 'builder': |
| validateParameter(g_currentState, key, value, |
| function() { return value in g_builders; }); |
| return true; |
| |
| case 'useTestData': |
| case 'showAllRuns': |
| g_crossDashboardState[key] = value == 'true'; |
| return true; |
| |
| case 'buildDir': |
| if (value === 'Debug' || value == 'Release') { |
| g_crossDashboardState['testType'] = 'layout-tests'; |
| g_crossDashboardState[key] = value; |
| return true; |
| } else |
| return false; |
| |
| default: |
| return handleValidHashParameter(key, value); |
| } |
| } |
| |
| var g_defaultCrossDashboardStateValues = { |
| group: '@ToT - chromium.org', |
| showAllRuns: false, |
| testType: 'layout-tests', |
| buildDir: '', |
| useTestData: false, |
| } |
| |
| // Generic utility functions. |
| function $(id) |
| { |
| return document.getElementById(id); |
| } |
| |
| function stringContains(a, b) |
| { |
| return a.indexOf(b) != -1; |
| } |
| |
| function caseInsensitiveContains(a, b) |
| { |
| return a.match(new RegExp(b, 'i')); |
| } |
| |
| function startsWith(a, b) |
| { |
| return a.indexOf(b) == 0; |
| } |
| |
| function endsWith(a, b) |
| { |
| return a.lastIndexOf(b) == a.length - b.length; |
| } |
| |
| function isValidName(str) |
| { |
| return str.match(/[A-Za-z0-9\-\_,]/); |
| } |
| |
| function trimString(str) |
| { |
| return str.replace(/^\s+|\s+$/g, ''); |
| } |
| |
| function collapseWhitespace(str) |
| { |
| return str.replace(/\s+/g, ' '); |
| } |
| |
| function validateParameter(state, key, value, validateFn) |
| { |
| if (validateFn()) |
| state[key] = value; |
| else |
| console.log(key + ' value is not valid: ' + value); |
| } |
| |
| function queryHashAsMap() |
| { |
| var hash = window.location.hash; |
| var paramsList = hash ? hash.substring(1).split('&') : []; |
| var paramsMap = {}; |
| var invalidKeys = []; |
| for (var i = 0; i < paramsList.length; i++) { |
| var thisParam = paramsList[i].split('='); |
| if (thisParam.length != 2) { |
| console.log('Invalid query parameter: ' + paramsList[i]); |
| continue; |
| } |
| |
| paramsMap[thisParam[0]] = decodeURIComponent(thisParam[1]); |
| } |
| |
| // FIXME: remove support for mapping from the master parameter to the group |
| // one once the waterfall starts to pass in the builder name instead. |
| if (paramsMap.master) { |
| paramsMap.group = LEGACY_BUILDER_MASTERS_TO_GROUPS[paramsMap.master]; |
| if (!paramsMap.group) |
| console.log('ERROR: Unknown master name: ' + paramsMap.master); |
| window.location.hash = window.location.hash.replace('master=' + paramsMap.master, 'group=' + paramsMap.group); |
| delete paramsMap.master; |
| } |
| |
| return paramsMap; |
| } |
| |
| function parseParameter(parameters, key) |
| { |
| if (!(key in parameters)) |
| return; |
| var value = parameters[key]; |
| if (!handleValidHashParameterWrapper(key, value)) |
| console.log("Invalid query parameter: " + key + '=' + value); |
| } |
| |
| function parseCrossDashboardParameters() |
| { |
| g_crossDashboardState = {}; |
| var parameters = queryHashAsMap(); |
| for (parameterName in g_defaultCrossDashboardStateValues) |
| parseParameter(parameters, parameterName); |
| |
| fillMissingValues(g_crossDashboardState, g_defaultCrossDashboardStateValues); |
| if (currentBuilderGroup() === undefined) |
| g_crossDashboardState.group = g_defaultCrossDashboardStateValues.group; |
| } |
| |
| function parseDashboardSpecificParameters() |
| { |
| g_currentState = {}; |
| var parameters = queryHashAsMap(); |
| for (parameterName in g_defaultDashboardSpecificStateValues) |
| parseParameter(parameters, parameterName); |
| } |
| |
| function parseParameters() |
| { |
| var oldCrossDashboardState = g_crossDashboardState; |
| var oldDashboardSpecificState = g_currentState; |
| |
| parseCrossDashboardParameters(); |
| parseDashboardSpecificParameters(); |
| parseParameter(queryHashAsMap(), 'builder'); |
| |
| var crossDashboardDiffState = diffStates(oldCrossDashboardState, g_crossDashboardState); |
| var dashboardSpecificDiffState = diffStates(oldDashboardSpecificState, g_currentState); |
| |
| fillMissingValues(g_currentState, g_defaultDashboardSpecificStateValues); |
| if (!g_crossDashboardState.useTestData) |
| fillMissingValues(g_currentState, {'builder': g_defaultBuilderName}); |
| |
| // FIXME: dashboard_base shouldn't know anything about specific dashboard specific keys. |
| if (dashboardSpecificDiffState.builder) |
| delete g_currentState.tests; |
| if (g_currentState.tests) |
| delete g_currentState.builder; |
| |
| // Some parameters require loading different JSON files when the value changes. Do a reload. |
| if (Object.keys(oldCrossDashboardState).length) { |
| for (var key in g_crossDashboardState) { |
| if (oldCrossDashboardState[key] != g_crossDashboardState[key] && RELOAD_REQUIRING_PARAMETERS.indexOf(key) != -1) |
| window.location.reload(); |
| } |
| } |
| |
| return dashboardSpecificDiffState; |
| } |
| |
| function diffStates(oldState, newState) |
| { |
| // If there is no old state, everything in the current state is new. |
| if (!oldState) |
| return newState; |
| |
| var changedParams = {}; |
| for (curKey in newState) { |
| var oldVal = oldState[curKey]; |
| var newVal = newState[curKey]; |
| // Add new keys or changed values. |
| if (!oldVal || oldVal != newVal) |
| changedParams[curKey] = newVal; |
| } |
| return changedParams; |
| } |
| |
| function defaultValue(key) |
| { |
| if (key in g_defaultDashboardSpecificStateValues) |
| return g_defaultDashboardSpecificStateValues[key]; |
| return g_defaultCrossDashboardStateValues[key]; |
| } |
| |
| function fillMissingValues(to, from) |
| { |
| for (var state in from) { |
| if (!(state in to)) |
| to[state] = from[state]; |
| } |
| } |
| |
| // FIXME: Rename this to g_dashboardSpecificState; |
| var g_currentState = {}; |
| var g_crossDashboardState = {}; |
| parseCrossDashboardParameters(); |
| |
| function isLayoutTestResults() |
| { |
| return g_crossDashboardState.testType == 'layout-tests'; |
| } |
| |
| function isGPUTestResults() |
| { |
| return g_crossDashboardState.testType == 'gpu_tests'; |
| } |
| |
| function currentBuilderGroupCategory() |
| { |
| switch (g_crossDashboardState.testType) { |
| case 'gl_tests': |
| case 'gpu_tests': |
| return CHROMIUM_GPU_TESTS_BUILDER_GROUPS; |
| case 'layout-tests': |
| return LAYOUT_TESTS_BUILDER_GROUPS; |
| case 'test_shell_tests': |
| case 'webkit_unit_tests': |
| return TEST_SHELL_TESTS_BUILDER_GROUPS; |
| default: |
| return CHROMIUM_GTESTS_BUILDER_GROUPS; |
| } |
| } |
| |
| function currentBuilderGroup() |
| { |
| return currentBuilderGroupCategory()[g_crossDashboardState.group] |
| } |
| |
| function builderMaster(builderName) |
| { |
| return BUILDER_TO_MASTER[builderName]; |
| } |
| |
| function isTipOfTreeWebKitBuilder() |
| { |
| return currentBuilderGroup().isToTWebKit; |
| } |
| |
| var g_defaultBuilderName, g_builders; |
| function initBuilders() |
| { |
| if (g_crossDashboardState.buildDir) { |
| // If buildDir is set, point to the results.json in the local tree. Useful for debugging changes to the python JSON generator. |
| g_defaultBuilderName = 'DUMMY_BUILDER_NAME'; |
| g_builders = {'DUMMY_BUILDER_NAME': ''}; |
| var loc = document.location.toString(); |
| var offset = loc.indexOf('webkit/'); |
| } else |
| currentBuilderGroup().setup(); |
| } |
| |
| var g_resultsByBuilder = {}; |
| var g_expectationsByPlatform = {}; |
| var g_staleBuilders = []; |
| var g_buildersThatFailedToLoad = []; |
| |
| // TODO(aboxhall): figure out whether this is a performance bottleneck and |
| // change calling code to understand the trie structure instead if necessary. |
| function flattenTrie(trie, prefix) |
| { |
| var result = {}; |
| for (var name in trie) { |
| var fullName = prefix ? prefix + "/" + name : name; |
| var data = trie[name]; |
| if ("results" in data) |
| result[fullName] = data; |
| else { |
| var partialResult = flattenTrie(data, fullName); |
| for (var key in partialResult) { |
| result[key] = partialResult[key]; |
| } |
| } |
| } |
| return result; |
| } |
| |
| function isTreeMap() |
| { |
| return endsWith(window.location.pathname, 'treemap.html'); |
| } |
| |
| function isFlakinessDashboard() |
| { |
| return endsWith(window.location.pathname, 'flakiness_dashboard.html'); |
| } |
| |
| var g_hasDoneInitialPageGeneration = false; |
| // String of error messages to display to the user. |
| var g_errorMessages = ''; |
| |
| // Record a new error message. |
| // @param {string} errorMsg The message to show to the user. |
| function addError(errorMsg) |
| { |
| g_errorMessages += errorMsg + '<br>'; |
| } |
| |
| // Clear out error and warning messages. |
| function clearErrors() |
| { |
| g_errorMessages = ''; |
| } |
| |
| // If there are errors, show big and red UI for errors so as to be noticed. |
| function showErrors() |
| { |
| var errors = $('errors'); |
| |
| if (!g_errorMessages) { |
| if (errors) |
| errors.parentNode.removeChild(errors); |
| return; |
| } |
| |
| if (!errors) { |
| errors = document.createElement('H2'); |
| errors.style.color = 'red'; |
| errors.id = 'errors'; |
| document.body.appendChild(errors); |
| } |
| |
| errors.innerHTML = g_errorMessages; |
| } |
| |
| function addBuilderLoadErrors() |
| { |
| if (g_hasDoneInitialPageGeneration) |
| return; |
| |
| if (g_buildersThatFailedToLoad.length) |
| addError('ERROR: Failed to get data from ' + g_buildersThatFailedToLoad.toString() + '.'); |
| |
| if (g_staleBuilders.length) |
| addError('ERROR: Data from ' + g_staleBuilders.toString() + ' is more than 1 day stale.'); |
| } |
| |
| function resourceLoadingComplete() |
| { |
| g_resourceLoader = null; |
| handleLocationChange(); |
| } |
| |
| function handleLocationChange() |
| { |
| if (g_resourceLoader) |
| return; |
| |
| addBuilderLoadErrors(); |
| g_hasDoneInitialPageGeneration = true; |
| |
| var params = parseParameters(); |
| var shouldGeneratePage = true; |
| if (Object.keys(params).length) |
| shouldGeneratePage = handleQueryParameterChange(params); |
| |
| var newHash = permaLinkURLHash(); |
| var winHash = window.location.hash || "#"; |
| // Make sure the location is the same as the state we are using internally. |
| // These get out of sync if processQueryParamChange changed state. |
| if (newHash != winHash) { |
| // This will cause another hashchange, and when we loop |
| // back through here next time, we'll go through generatePage. |
| window.location.hash = newHash; |
| } else if (shouldGeneratePage) |
| generatePage(); |
| } |
| |
| window.onhashchange = handleLocationChange; |
| |
| function combinedDashboardState() |
| { |
| var combinedState = Object.create(g_currentState); |
| for (var key in g_crossDashboardState) |
| combinedState[key] = g_crossDashboardState[key]; |
| return combinedState; |
| } |
| |
| // Sets the page state. Takes varargs of key, value pairs. |
| function setQueryParameter(var_args) |
| { |
| var state = combinedDashboardState(); |
| for (var i = 0; i < arguments.length; i += 2) { |
| var key = arguments[i]; |
| state[key] = arguments[i + 1]; |
| } |
| // Note: We use window.location.hash rather that window.location.replace |
| // because of bugs in Chrome where extra entries were getting created |
| // when back button was pressed and full page navigation was occuring. |
| // FIXME: file those bugs. |
| window.location.hash = permaLinkURLHash(state); |
| } |
| |
| function permaLinkURLHash(opt_state) |
| { |
| var state = opt_state || combinedDashboardState(); |
| return '#' + joinParameters(state); |
| } |
| |
| function joinParameters(stateObject) |
| { |
| var state = []; |
| for (var key in stateObject) { |
| var value = stateObject[key]; |
| if (value != defaultValue(key)) |
| state.push(key + '=' + encodeURIComponent(value)); |
| } |
| return state.join('&'); |
| } |
| |
| function logTime(msg, startTime) |
| { |
| console.log(msg + ': ' + (Date.now() - startTime)); |
| } |
| |
| function hidePopup() |
| { |
| var popup = $('popup'); |
| if (popup) |
| popup.parentNode.removeChild(popup); |
| } |
| |
| function showPopup(target, html) |
| { |
| var popup = $('popup'); |
| if (!popup) { |
| popup = document.createElement('div'); |
| popup.id = 'popup'; |
| document.body.appendChild(popup); |
| } |
| |
| // Set html first so that we can get accurate size metrics on the popup. |
| popup.innerHTML = html; |
| |
| var targetRect = target.getBoundingClientRect(); |
| |
| var x = Math.min(targetRect.left - 10, document.documentElement.clientWidth - popup.offsetWidth); |
| x = Math.max(0, x); |
| popup.style.left = x + document.body.scrollLeft + 'px'; |
| |
| var y = targetRect.top + targetRect.height; |
| if (y + popup.offsetHeight > document.documentElement.clientHeight) |
| y = targetRect.top - popup.offsetHeight; |
| y = Math.max(0, y); |
| popup.style.top = y + document.body.scrollTop + 'px'; |
| } |
| |
| // Create a new function with some of its arguements |
| // pre-filled. |
| // Taken from goog.partial in the Closure library. |
| // @param {Function} fn A function to partially apply. |
| // @param {...*} var_args Additional arguments that are partially |
| // applied to fn. |
| // @return {!Function} A partially-applied form of the function bind() was |
| // invoked as a method of. |
| function partial(fn, var_args) |
| { |
| var args = Array.prototype.slice.call(arguments, 1); |
| return function() { |
| // Prepend the bound arguments to the current arguments. |
| var newArgs = Array.prototype.slice.call(arguments); |
| newArgs.unshift.apply(newArgs, args); |
| return fn.apply(this, newArgs); |
| }; |
| }; |
| |
| // Returns the appropriate expectatiosn map for the current testType. |
| function expectationsMap() |
| { |
| return isLayoutTestResults() ? LAYOUT_TEST_EXPECTATIONS_MAP_ : GTEST_EXPECTATIONS_MAP_; |
| } |
| |
| function toggleQueryParameter(param) |
| { |
| setQueryParameter(param, !queryParameterValue(param)); |
| } |
| |
| function queryParameterValue(parameter) |
| { |
| return g_currentState[parameter] || g_crossDashboardState[parameter]; |
| } |
| |
| function checkboxHTML(queryParameter, label, isChecked, opt_extraJavaScript) |
| { |
| var js = opt_extraJavaScript || ''; |
| return '<label style="padding-left: 2em">' + |
| '<input type="checkbox" onchange="toggleQueryParameter(\'' + queryParameter + '\');' + js + '" ' + |
| (isChecked ? 'checked' : '') + '>' + label + |
| '</label> '; |
| } |
| |
| function selectHTML(label, queryParameter, options) |
| { |
| var html = '<label style="padding-left: 2em">' + label + ': ' + |
| '<select onchange="setQueryParameter(\'' + queryParameter + '\', this[this.selectedIndex].value)">'; |
| |
| for (var i = 0; i < options.length; i++) { |
| var value = options[i]; |
| html += '<option value="' + value + '" ' + |
| (queryParameterValue(queryParameter) == value ? 'selected' : '') + |
| '>' + value + '</option>' |
| } |
| html += '</select></label> '; |
| return html; |
| } |
| |
| // Returns the HTML for the select element to switch to different testTypes. |
| function htmlForTestTypeSwitcher(opt_noBuilderMenu, opt_extraHtml, opt_includeNoneBuilder) |
| { |
| var html = '<div style="border-bottom:1px dashed">'; |
| html += '' + |
| htmlForDashboardLink('Stats', 'aggregate_results.html') + |
| htmlForDashboardLink('Timeline', 'timeline_explorer.html') + |
| htmlForDashboardLink('Results', 'flakiness_dashboard.html') + |
| htmlForDashboardLink('Treemap', 'treemap.html'); |
| |
| html += selectHTML('Test type', 'testType', TEST_TYPES); |
| |
| if (!opt_noBuilderMenu) { |
| var buildersForMenu = Object.keys(g_builders); |
| if (opt_includeNoneBuilder) |
| buildersForMenu.unshift('--------------'); |
| html += selectHTML('Builder', 'builder', buildersForMenu); |
| } |
| |
| html += selectHTML('Group', 'group', |
| Object.keys(currentBuilderGroupCategory())); |
| |
| if (!isTreeMap()) |
| html += checkboxHTML('showAllRuns', 'Show all runs', g_crossDashboardState.showAllRuns); |
| |
| if (opt_extraHtml) |
| html += opt_extraHtml; |
| return html + '</div>'; |
| } |
| |
| function selectBuilder(builder) |
| { |
| setQueryParameter('builder', builder); |
| } |
| |
| function loadDashboard(fileName) |
| { |
| var pathName = window.location.pathname; |
| pathName = pathName.substring(0, pathName.lastIndexOf('/') + 1); |
| window.location = pathName + fileName + window.location.hash; |
| } |
| |
| function htmlForTopLink(html, onClick, isSelected) |
| { |
| var cssText = isSelected ? 'font-weight: bold;' : 'color:blue;text-decoration:underline;cursor:pointer;'; |
| cssText += 'margin: 0 5px;'; |
| return '<span style="' + cssText + '" onclick="' + onClick + '">' + html + '</span>'; |
| } |
| |
| function htmlForDashboardLink(html, fileName) |
| { |
| var pathName = window.location.pathname; |
| var currentFileName = pathName.substring(pathName.lastIndexOf('/') + 1); |
| var isSelected = currentFileName == fileName; |
| var onClick = 'loadDashboard(\'' + fileName + '\')'; |
| return htmlForTopLink(html, onClick, isSelected); |
| } |
| |
| function revisionLink(results, index, key, singleUrlTemplate, rangeUrlTemplate) |
| { |
| var currentRevision = parseInt(results[key][index], 10); |
| var previousRevision = parseInt(results[key][index + 1], 10); |
| |
| function singleUrl() |
| { |
| return singleUrlTemplate.replace('<rev>', currentRevision); |
| } |
| |
| function rangeUrl() |
| { |
| return rangeUrlTemplate.replace('<rev1>', currentRevision).replace('<rev2>', previousRevision + 1); |
| } |
| |
| if (currentRevision == previousRevision) |
| return 'At <a href="' + singleUrl() + '">r' + currentRevision + '</a>'; |
| else if (currentRevision - previousRevision == 1) |
| return '<a href="' + singleUrl() + '">r' + currentRevision + '</a>'; |
| else |
| return '<a href="' + rangeUrl() + '">r' + (previousRevision + 1) + ' to r' + currentRevision + '</a>'; |
| } |
| |
| function chromiumRevisionLink(results, index) |
| { |
| return revisionLink( |
| results, |
| index, |
| CHROME_REVISIONS_KEY, |
| 'http://src.chromium.org/viewvc/chrome?view=rev&revision=<rev>', |
| 'http://build.chromium.org/f/chromium/perf/dashboard/ui/changelog.html?url=/trunk/src&range=<rev2>:<rev1>&mode=html'); |
| } |
| |
| function webKitRevisionLink(results, index) |
| { |
| return revisionLink( |
| results, |
| index, |
| WEBKIT_REVISIONS_KEY, |
| 'http://trac.webkit.org/changeset/<rev>', |
| 'http://trac.webkit.org/log/trunk/?rev=<rev1>&stop_rev=<rev2>&limit=100&verbose=on'); |
| } |
| |
| // "Decompresses" the RLE-encoding of test results so that we can query it |
| // by build index and test name. |
| // |
| // @param {Object} results results for the current builder |
| // @return Object with these properties: |
| // - testNames: array mapping test index to test names. |
| // - resultsByBuild: array of builds, for each build a (sparse) array of test results by test index. |
| // - flakyTests: array with the boolean value true at test indices that are considered flaky (more than one single-build failure). |
| // - flakyDeltasByBuild: array of builds, for each build a count of flaky test results by expectation, as well as a total. |
| function decompressResults(builderResults) |
| { |
| var builderTestResults = builderResults[TESTS_KEY]; |
| var buildCount = builderResults[FIXABLE_COUNTS_KEY].length; |
| var resultsByBuild = new Array(buildCount); |
| var flakyDeltasByBuild = new Array(buildCount); |
| |
| // Pre-sizing the test result arrays for each build saves us ~250ms |
| var testCount = 0; |
| for (var testName in builderTestResults) |
| testCount++; |
| for (var i = 0; i < buildCount; i++) { |
| resultsByBuild[i] = new Array(testCount); |
| resultsByBuild[i][testCount - 1] = undefined; |
| flakyDeltasByBuild[i] = {}; |
| } |
| |
| // Using indices instead of the full test names for each build saves us |
| // ~1500ms |
| var testIndex = 0; |
| var testNames = new Array(testCount); |
| var flakyTests = new Array(testCount); |
| |
| // Decompress and "invert" test results (by build instead of by test) and |
| // determine which are flaky. |
| for (var testName in builderTestResults) { |
| var oneBuildFailureCount = 0; |
| |
| testNames[testIndex] = testName; |
| var testResults = builderTestResults[testName].results; |
| for (var i = 0, rleResult, currentBuildIndex = 0; (rleResult = testResults[i]) && currentBuildIndex < buildCount; i++) { |
| var count = rleResult[RLE.LENGTH]; |
| var value = rleResult[RLE.VALUE]; |
| |
| if (count == 1 && value in FAILURE_EXPECTATIONS_) |
| oneBuildFailureCount++; |
| |
| for (var j = 0; j < count; j++) { |
| resultsByBuild[currentBuildIndex++][testIndex] = value; |
| if (currentBuildIndex == buildCount) |
| break; |
| } |
| } |
| |
| if (oneBuildFailureCount > 2) |
| flakyTests[testIndex] = true; |
| |
| testIndex++; |
| } |
| |
| // Now that we know which tests are flaky, count the test results that are |
| // from flaky tests for each build. |
| testIndex = 0; |
| for (var testName in builderTestResults) { |
| if (!flakyTests[testIndex++]) |
| continue; |
| |
| var testResults = builderTestResults[testName].results; |
| for (var i = 0, rleResult, currentBuildIndex = 0; (rleResult = testResults[i]) && currentBuildIndex < buildCount; i++) { |
| var count = rleResult[RLE.LENGTH]; |
| var value = rleResult[RLE.VALUE]; |
| |
| for (var j = 0; j < count; j++) { |
| var buildTestResults = flakyDeltasByBuild[currentBuildIndex++]; |
| function addFlakyDelta(key) |
| { |
| if (!(key in buildTestResults)) |
| buildTestResults[key] = 0; |
| buildTestResults[key]++; |
| } |
| addFlakyDelta(value); |
| if (value != 'P' && value != 'N') |
| addFlakyDelta('total'); |
| if (currentBuildIndex == buildCount) |
| break; |
| } |
| } |
| } |
| |
| return { |
| testNames: testNames, |
| resultsByBuild: resultsByBuild, |
| flakyTests: flakyTests, |
| flakyDeltasByBuild: flakyDeltasByBuild |
| }; |
| } |
| |
| document.addEventListener('mousedown', function(e) { |
| // Clear the open popup, unless the click was inside the popup. |
| var popup = $('popup'); |
| if (popup && e.target != popup && !(popup.compareDocumentPosition(e.target) & 16)) |
| hidePopup(); |
| }, false); |
| |
| window.addEventListener('load', function() { |
| // This doesn't seem totally accurate as there is a race between |
| // onload firing and the last script tag being executed. |
| logTime('Time to load JS', g_pageLoadStartTime); |
| g_resourceLoader = new loader.Loader(); |
| g_resourceLoader.load(); |
| }, false); |
