App-MFILE-WWW
view release on metacpan or search on metacpan
share/js/core/qunit.js view on Meta::CPAN
attrs = _node.attributes;
if (attrs) {
for (i = 0, len = attrs.length; i < len; i++) {
val = attrs[i].nodeValue;
// IE6 includes all attributes in .attributes, even ones not explicitly
// set. Those have values like undefined, null, 0, false, "" or
// "inherit".
if (val && val !== "inherit") {
ret += " " + attrs[i].nodeName + "=" + dump.parse(val, "attribute");
}
}
}
ret += close;
// Show content of TextNode or CDATASection
if (_node.nodeType === 3 || _node.nodeType === 4) {
ret += _node.nodeValue;
}
return ret + open + "/" + tag + close;
},
// Function calls it internally, it's the arguments part of the function
functionArgs: function functionArgs(fn) {
var args,
l = fn.length;
if (!l) {
return "";
}
args = new Array(l);
while (l--) {
// 97 is 'a'
args[l] = String.fromCharCode(97 + l);
}
return " " + args.join(", ") + " ";
},
// Object calls it internally, the key part of an item in a map
key: quote,
// Function calls it internally, it's the content of the function
functionCode: "[code]",
// Node calls it internally, it's a html attribute value
attribute: quote,
string: quote,
date: quote,
regexp: literal,
number: literal,
"boolean": literal,
symbol: function symbol(sym) {
return sym.toString();
}
},
// If true, entities are escaped ( <, >, \t, space and \n )
HTML: false,
// Indentation unit
indentChar: " ",
// If true, items in a collection, are separated by a \n, else just a space.
multiline: true
};
return dump;
})();
var LISTENERS = Object.create(null);
var SUPPORTED_EVENTS = ["runStart", "suiteStart", "testStart", "assertion", "testEnd", "suiteEnd", "runEnd"];
/**
* Emits an event with the specified data to all currently registered listeners.
* Callbacks will fire in the order in which they are registered (FIFO). This
* function is not exposed publicly; it is used by QUnit internals to emit
* logging events.
*
* @private
* @method emit
* @param {String} eventName
* @param {Object} data
* @return {Void}
*/
function emit(eventName, data) {
if (objectType(eventName) !== "string") {
throw new TypeError("eventName must be a string when emitting an event");
}
// Clone the callbacks in case one of them registers a new callback
var originalCallbacks = LISTENERS[eventName];
var callbacks = originalCallbacks ? [].concat(toConsumableArray(originalCallbacks)) : [];
for (var i = 0; i < callbacks.length; i++) {
callbacks[i](data);
}
}
/**
* Registers a callback as a listener to the specified event.
*
* @public
* @method on
* @param {String} eventName
* @param {Function} callback
* @return {Void}
*/
function on(eventName, callback) {
if (objectType(eventName) !== "string") {
throw new TypeError("eventName must be a string when registering a listener");
} else if (!inArray(eventName, SUPPORTED_EVENTS)) {
var events = SUPPORTED_EVENTS.join(", ");
throw new Error("\"" + eventName + "\" is not a valid event; must be one of: " + events + ".");
} else if (objectType(callback) !== "function") {
throw new TypeError("callback must be a function when registering a listener");
}
share/js/core/qunit.js view on Meta::CPAN
label: "No try-catch",
tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging " + "exceptions in IE reasonable. Stored as query-strings."
});
QUnit.begin(function () {
var i,
option,
urlConfig = QUnit.config.urlConfig;
for (i = 0; i < urlConfig.length; i++) {
// Options can be either strings or objects with nonempty "id" properties
option = QUnit.config.urlConfig[i];
if (typeof option !== "string") {
option = option.id;
}
if (QUnit.config[option] === undefined) {
QUnit.config[option] = urlParams[option];
}
}
});
function getUrlParams() {
var i, param, name, value;
var urlParams = Object.create(null);
var params = location.search.slice(1).split("&");
var length = params.length;
for (i = 0; i < length; i++) {
if (params[i]) {
param = params[i].split("=");
name = decodeQueryParam(param[0]);
// Allow just a key to turn on a flag, e.g., test.html?noglobals
value = param.length === 1 || decodeQueryParam(param.slice(1).join("="));
if (name in urlParams) {
urlParams[name] = [].concat(urlParams[name], value);
} else {
urlParams[name] = value;
}
}
}
return urlParams;
}
function decodeQueryParam(param) {
return decodeURIComponent(param.replace(/\+/g, "%20"));
}
})();
var stats = {
passedTests: 0,
failedTests: 0,
skippedTests: 0,
todoTests: 0
};
// Escape text for attribute or text content.
function escapeText(s) {
if (!s) {
return "";
}
s = s + "";
// Both single quotes and double quotes (for attributes)
return s.replace(/['"<>&]/g, function (s) {
switch (s) {
case "'":
return "'";
case "\"":
return """;
case "<":
return "<";
case ">":
return ">";
case "&":
return "&";
}
});
}
(function () {
// Don't load the HTML Reporter on non-browser environments
if (typeof window === "undefined" || !window.document) {
return;
}
var config = QUnit.config,
document$$1 = window.document,
collapseNext = false,
hasOwn = Object.prototype.hasOwnProperty,
unfilteredUrl = setUrl({ filter: undefined, module: undefined,
moduleId: undefined, testId: undefined }),
modulesList = [];
function addEvent(elem, type, fn) {
elem.addEventListener(type, fn, false);
}
function removeEvent(elem, type, fn) {
elem.removeEventListener(type, fn, false);
}
function addEvents(elems, type, fn) {
var i = elems.length;
while (i--) {
addEvent(elems[i], type, fn);
}
}
function hasClass(elem, name) {
return (" " + elem.className + " ").indexOf(" " + name + " ") >= 0;
}
function addClass(elem, name) {
if (!hasClass(elem, name)) {
elem.className += (elem.className ? " " : "") + name;
}
}
function toggleClass(elem, name, force) {
if (force || typeof force === "undefined" && !hasClass(elem, name)) {
addClass(elem, name);
} else {
removeClass(elem, name);
}
}
function removeClass(elem, name) {
var set = " " + elem.className + " ";
// Class name may appear multiple times
while (set.indexOf(" " + name + " ") >= 0) {
set = set.replace(" " + name + " ", " ");
}
// Trim for prettiness
elem.className = typeof set.trim === "function" ? set.trim() : set.replace(/^\s+|\s+$/g, "");
}
function id(name) {
return document$$1.getElementById && document$$1.getElementById(name);
}
function abortTests() {
var abortButton = id("qunit-abort-tests-button");
if (abortButton) {
abortButton.disabled = true;
abortButton.innerHTML = "Aborting...";
}
QUnit.config.queue.length = 0;
return false;
}
function interceptNavigation(ev) {
applyUrlParams();
if (ev && ev.preventDefault) {
ev.preventDefault();
}
return false;
}
function getUrlConfigHtml() {
var i,
j,
val,
escaped,
escapedTooltip,
selection = false,
urlConfig = config.urlConfig,
urlConfigHtml = "";
for (i = 0; i < urlConfig.length; i++) {
// Options can be either strings or objects with nonempty "id" properties
val = config.urlConfig[i];
if (typeof val === "string") {
val = {
id: val,
label: val
};
}
escaped = escapeText(val.id);
escapedTooltip = escapeText(val.tooltip);
if (!val.value || typeof val.value === "string") {
urlConfigHtml += "<label for='qunit-urlconfig-" + escaped + "' title='" + escapedTooltip + "'><input id='qunit-urlconfig-" + escaped + "' name='" + escaped + "' type='checkbox'" + (val.value ? " value='" + escapeText(val.value) + "'" : "") + (c...
} else {
urlConfigHtml += "<label for='qunit-urlconfig-" + escaped + "' title='" + escapedTooltip + "'>" + val.label + ": </label><select id='qunit-urlconfig-" + escaped + "' name='" + escaped + "' title='" + escapedTooltip + "'><option></option>";
if (QUnit.is("array", val.value)) {
for (j = 0; j < val.value.length; j++) {
escaped = escapeText(val.value[j]);
urlConfigHtml += "<option value='" + escaped + "'" + (config[val.id] === val.value[j] ? (selection = true) && " selected='selected'" : "") + ">" + escaped + "</option>";
}
} else {
for (j in val.value) {
if (hasOwn.call(val.value, j)) {
urlConfigHtml += "<option value='" + escapeText(j) + "'" + (config[val.id] === j ? (selection = true) && " selected='selected'" : "") + ">" + escapeText(val.value[j]) + "</option>";
}
}
}
if (config[val.id] && !selection) {
escaped = escapeText(config[val.id]);
urlConfigHtml += "<option value='" + escaped + "' selected='selected' disabled='disabled'>" + escaped + "</option>";
}
urlConfigHtml += "</select>";
}
}
return urlConfigHtml;
}
// Handle "click" events on toolbar checkboxes and "change" for select menus.
// Updates the URL with the new state of `config.urlConfig` values.
function toolbarChanged() {
var updatedUrl,
value,
tests,
field = this,
params = {};
// Detect if field is a select menu or a checkbox
if ("selectedIndex" in field) {
value = field.options[field.selectedIndex].value || undefined;
} else {
value = field.checked ? field.defaultValue || true : undefined;
}
params[field.name] = value;
updatedUrl = setUrl(params);
// Check if we can apply the change without a page refresh
if ("hidepassed" === field.name && "replaceState" in window.history) {
QUnit.urlParams[field.name] = value;
config[field.name] = value || false;
tests = id("qunit-tests");
if (tests) {
toggleClass(tests, "hidepass", value || false);
}
window.history.replaceState(null, "", updatedUrl);
} else {
window.location = updatedUrl;
}
}
function setUrl(params) {
var key,
arrValue,
i,
querystring = "?",
location = window.location;
params = QUnit.extend(QUnit.extend({}, QUnit.urlParams), params);
for (key in params) {
// Skip inherited or undefined properties
if (hasOwn.call(params, key) && params[key] !== undefined) {
// Output a parameter for each value of this key (but usually just one)
arrValue = [].concat(params[key]);
for (i = 0; i < arrValue.length; i++) {
querystring += encodeURIComponent(key);
if (arrValue[i] !== true) {
share/js/core/qunit.js view on Meta::CPAN
module: undefined,
testId: undefined
});
}
function toolbarUrlConfigContainer() {
var urlConfigContainer = document$$1.createElement("span");
urlConfigContainer.innerHTML = getUrlConfigHtml();
addClass(urlConfigContainer, "qunit-url-config");
addEvents(urlConfigContainer.getElementsByTagName("input"), "change", toolbarChanged);
addEvents(urlConfigContainer.getElementsByTagName("select"), "change", toolbarChanged);
return urlConfigContainer;
}
function abortTestsButton() {
var button = document$$1.createElement("button");
button.id = "qunit-abort-tests-button";
button.innerHTML = "Abort";
addEvent(button, "click", abortTests);
return button;
}
function toolbarLooseFilter() {
var filter = document$$1.createElement("form"),
label = document$$1.createElement("label"),
input = document$$1.createElement("input"),
button = document$$1.createElement("button");
addClass(filter, "qunit-filter");
label.innerHTML = "Filter: ";
input.type = "text";
input.value = config.filter || "";
input.name = "filter";
input.id = "qunit-filter-input";
button.innerHTML = "Go";
label.appendChild(input);
filter.appendChild(label);
filter.appendChild(document$$1.createTextNode(" "));
filter.appendChild(button);
addEvent(filter, "submit", interceptNavigation);
return filter;
}
function moduleListHtml() {
var i,
checked,
html = "";
for (i = 0; i < config.modules.length; i++) {
if (config.modules[i].name !== "") {
checked = config.moduleId.indexOf(config.modules[i].moduleId) > -1;
html += "<li><label class='clickable" + (checked ? " checked" : "") + "'><input type='checkbox' " + "value='" + config.modules[i].moduleId + "'" + (checked ? " checked='checked'" : "") + " />" + escapeText(config.modules[i].name) + "</label></l...
}
}
return html;
}
function toolbarModuleFilter() {
var allCheckbox,
commit,
reset,
moduleFilter = document$$1.createElement("form"),
label = document$$1.createElement("label"),
moduleSearch = document$$1.createElement("input"),
dropDown = document$$1.createElement("div"),
actions = document$$1.createElement("span"),
dropDownList = document$$1.createElement("ul"),
dirty = false;
moduleSearch.id = "qunit-modulefilter-search";
addEvent(moduleSearch, "input", searchInput);
addEvent(moduleSearch, "input", searchFocus);
addEvent(moduleSearch, "focus", searchFocus);
addEvent(moduleSearch, "click", searchFocus);
label.id = "qunit-modulefilter-search-container";
label.innerHTML = "Module: ";
label.appendChild(moduleSearch);
actions.id = "qunit-modulefilter-actions";
actions.innerHTML = "<button style='display:none'>Apply</button>" + "<button type='reset' style='display:none'>Reset</button>" + "<label class='clickable" + (config.moduleId.length ? "" : " checked") + "'><input type='checkbox'" + (config.moduleI...
allCheckbox = actions.lastChild.firstChild;
commit = actions.firstChild;
reset = commit.nextSibling;
addEvent(commit, "click", applyUrlParams);
dropDownList.id = "qunit-modulefilter-dropdown-list";
dropDownList.innerHTML = moduleListHtml();
dropDown.id = "qunit-modulefilter-dropdown";
dropDown.style.display = "none";
dropDown.appendChild(actions);
dropDown.appendChild(dropDownList);
addEvent(dropDown, "change", selectionChange);
selectionChange();
moduleFilter.id = "qunit-modulefilter";
moduleFilter.appendChild(label);
moduleFilter.appendChild(dropDown);
addEvent(moduleFilter, "submit", interceptNavigation);
addEvent(moduleFilter, "reset", function () {
// Let the reset happen, then update styles
window.setTimeout(selectionChange);
});
// Enables show/hide for the dropdown
function searchFocus() {
if (dropDown.style.display !== "none") {
return;
}
share/js/core/qunit.js view on Meta::CPAN
if (!searchText || item.textContent.toLowerCase().indexOf(searchText) > -1) {
item.style.display = "";
} else {
item.style.display = "none";
}
}
}
// Processes selection changes
function selectionChange(evt) {
var i,
item,
checkbox = evt && evt.target || allCheckbox,
modulesList = dropDownList.getElementsByTagName("input"),
selectedNames = [];
toggleClass(checkbox.parentNode, "checked", checkbox.checked);
dirty = false;
if (checkbox.checked && checkbox !== allCheckbox) {
allCheckbox.checked = false;
removeClass(allCheckbox.parentNode, "checked");
}
for (i = 0; i < modulesList.length; i++) {
item = modulesList[i];
if (!evt) {
toggleClass(item.parentNode, "checked", item.checked);
} else if (checkbox === allCheckbox && checkbox.checked) {
item.checked = false;
removeClass(item.parentNode, "checked");
}
dirty = dirty || item.checked !== item.defaultChecked;
if (item.checked) {
selectedNames.push(item.parentNode.textContent);
}
}
commit.style.display = reset.style.display = dirty ? "" : "none";
moduleSearch.placeholder = selectedNames.join(", ") || allCheckbox.parentNode.textContent;
moduleSearch.title = "Type to filter list. Current selection:\n" + (selectedNames.join("\n") || allCheckbox.parentNode.textContent);
}
return moduleFilter;
}
function appendToolbar() {
var toolbar = id("qunit-testrunner-toolbar");
if (toolbar) {
toolbar.appendChild(toolbarUrlConfigContainer());
toolbar.appendChild(toolbarModuleFilter());
toolbar.appendChild(toolbarLooseFilter());
toolbar.appendChild(document$$1.createElement("div")).className = "clearfix";
}
}
function appendHeader() {
var header = id("qunit-header");
if (header) {
header.innerHTML = "<a href='" + escapeText(unfilteredUrl) + "'>" + header.innerHTML + "</a> ";
}
}
function appendBanner() {
var banner = id("qunit-banner");
if (banner) {
banner.className = "";
}
}
function appendTestResults() {
var tests = id("qunit-tests"),
result = id("qunit-testresult"),
controls;
if (result) {
result.parentNode.removeChild(result);
}
if (tests) {
tests.innerHTML = "";
result = document$$1.createElement("p");
result.id = "qunit-testresult";
result.className = "result";
tests.parentNode.insertBefore(result, tests);
result.innerHTML = "<div id=\"qunit-testresult-display\">Running...<br /> </div>" + "<div id=\"qunit-testresult-controls\"></div>" + "<div class=\"clearfix\"></div>";
controls = id("qunit-testresult-controls");
}
if (controls) {
controls.appendChild(abortTestsButton());
}
}
function appendFilteredTest() {
var testId = QUnit.config.testId;
if (!testId || testId.length <= 0) {
return "";
}
return "<div id='qunit-filteredTest'>Rerunning selected tests: " + escapeText(testId.join(", ")) + " <a id='qunit-clearFilter' href='" + escapeText(unfilteredUrl) + "'>Run all tests</a></div>";
}
function appendUserAgent() {
var userAgent = id("qunit-userAgent");
if (userAgent) {
userAgent.innerHTML = "";
userAgent.appendChild(document$$1.createTextNode("QUnit " + QUnit.version + "; " + navigator.userAgent));
}
}
function appendInterface() {
var qunit = id("qunit");
if (qunit) {
qunit.innerHTML = "<h1 id='qunit-header'>" + escapeText(document$$1.title) + "</h1>" + "<h2 id='qunit-banner'></h2>" + "<div id='qunit-testrunner-toolbar'></div>" + appendFilteredTest() + "<h2 id='qunit-userAgent'></h2>" + "<ol id='qunit-tests'>...
}
appendHeader();
appendBanner();
appendTestResults();
appendUserAgent();
appendToolbar();
}
function appendTestsList(modules) {
var i, l, x, z, test, moduleObj;
for (i = 0, l = modules.length; i < l; i++) {
moduleObj = modules[i];
for (x = 0, z = moduleObj.tests.length; x < z; x++) {
test = moduleObj.tests[x];
appendTest(test.name, test.testId, moduleObj.name);
}
}
}
function appendTest(name, testId, moduleName) {
var title,
rerunTrigger,
testBlock,
assertList,
tests = id("qunit-tests");
if (!tests) {
return;
}
title = document$$1.createElement("strong");
title.innerHTML = getNameHtml(name, moduleName);
rerunTrigger = document$$1.createElement("a");
rerunTrigger.innerHTML = "Rerun";
rerunTrigger.href = setUrl({ testId: testId });
testBlock = document$$1.createElement("li");
testBlock.appendChild(title);
testBlock.appendChild(rerunTrigger);
testBlock.id = "qunit-test-output-" + testId;
assertList = document$$1.createElement("ol");
assertList.className = "qunit-assert-list";
testBlock.appendChild(assertList);
tests.appendChild(testBlock);
}
// HTML Reporter initialization and load
QUnit.begin(function (details) {
var i, moduleObj, tests;
// Sort modules by name for the picker
for (i = 0; i < details.modules.length; i++) {
moduleObj = details.modules[i];
if (moduleObj.name) {
modulesList.push(moduleObj.name);
}
}
modulesList.sort(function (a, b) {
return a.localeCompare(b);
});
// Initialize QUnit elements
appendInterface();
appendTestsList(details.modules);
tests = id("qunit-tests");
if (tests && config.hidepassed) {
addClass(tests, "hidepass");
}
});
QUnit.done(function (details) {
var banner = id("qunit-banner"),
tests = id("qunit-tests"),
abortButton = id("qunit-abort-tests-button"),
totalTests = stats.passedTests + stats.skippedTests + stats.todoTests + stats.failedTests,
html = [totalTests, " tests completed in ", details.runtime, " milliseconds, with ", stats.failedTests, " failed, ", stats.skippedTests, " skipped, and ", stats.todoTests, " todo.<br />", "<span class='passed'>", details.passed, "</span> asse...
test,
assertLi,
assertList;
// Update remaing tests to aborted
if (abortButton && abortButton.disabled) {
html = "Tests aborted after " + details.runtime + " milliseconds.";
for (var i = 0; i < tests.children.length; i++) {
test = tests.children[i];
if (test.className === "" || test.className === "running") {
test.className = "aborted";
assertList = test.getElementsByTagName("ol")[0];
assertLi = document$$1.createElement("li");
assertLi.className = "fail";
assertLi.innerHTML = "Test aborted.";
assertList.appendChild(assertLi);
}
}
}
if (banner && (!abortButton || abortButton.disabled === false)) {
banner.className = stats.failedTests ? "qunit-fail" : "qunit-pass";
}
if (abortButton) {
abortButton.parentNode.removeChild(abortButton);
}
if (tests) {
id("qunit-testresult-display").innerHTML = html;
}
if (config.altertitle && document$$1.title) {
// Show ✖ for good, ✔ for bad suite result in title
// use escape sequences in case file gets loaded with non-utf-8-charset
document$$1.title = [stats.failedTests ? "\u2716" : "\u2714", document$$1.title.replace(/^[\u2714\u2716] /i, "")].join(" ");
}
// Scroll back to top to show results
if (config.scrolltop && window.scrollTo) {
window.scrollTo(0, 0);
}
});
function getNameHtml(name, module) {
var nameHtml = "";
if (module) {
nameHtml = "<span class='module-name'>" + escapeText(module) + "</span>: ";
}
nameHtml += "<span class='test-name'>" + escapeText(name) + "</span>";
return nameHtml;
}
QUnit.testStart(function (details) {
var running, testBlock, bad;
testBlock = id("qunit-test-output-" + details.testId);
if (testBlock) {
testBlock.className = "running";
} else {
// Report later registered tests
appendTest(details.name, details.testId, details.module);
}
running = id("qunit-testresult-display");
if (running) {
bad = QUnit.config.reorder && details.previousFailure;
running.innerHTML = (bad ? "Rerunning previously failed test: <br />" : "Running: <br />") + getNameHtml(details.name, details.module);
}
});
function stripHtml(string) {
// Strip tags, html entity and whitespaces
return string.replace(/<\/?[^>]+(>|$)/g, "").replace(/\"/g, "").replace(/\s+/g, "");
}
QUnit.log(function (details) {
var assertList,
assertLi,
message,
expected,
actual,
diff,
showDiff = false,
testItem = id("qunit-test-output-" + details.testId);
if (!testItem) {
return;
}
message = escapeText(details.message) || (details.result ? "okay" : "failed");
message = "<span class='test-message'>" + message + "</span>";
message += "<span class='runtime'>@ " + details.runtime + " ms</span>";
// The pushFailure doesn't provide details.expected
// when it calls, it's implicit to also not show expected and diff stuff
// Also, we need to check details.expected existence, as it can exist and be undefined
if (!details.result && hasOwn.call(details, "expected")) {
if (details.negative) {
expected = "NOT " + QUnit.dump.parse(details.expected);
} else {
expected = QUnit.dump.parse(details.expected);
}
actual = QUnit.dump.parse(details.actual);
message += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + escapeText(expected) + "</pre></td></tr>";
if (actual !== expected) {
message += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText(actual) + "</pre></td></tr>";
if (typeof details.actual === "number" && typeof details.expected === "number") {
if (!isNaN(details.actual) && !isNaN(details.expected)) {
showDiff = true;
diff = details.actual - details.expected;
diff = (diff > 0 ? "+" : "") + diff;
}
} else if (typeof details.actual !== "boolean" && typeof details.expected !== "boolean") {
diff = QUnit.diff(expected, actual);
// don't show diff if there is zero overlap
showDiff = stripHtml(diff).length !== stripHtml(expected).length + stripHtml(actual).length;
}
if (showDiff) {
message += "<tr class='test-diff'><th>Diff: </th><td><pre>" + diff + "</pre></td></tr>";
}
} else if (expected.indexOf("[object Array]") !== -1 || expected.indexOf("[object Object]") !== -1) {
message += "<tr class='test-message'><th>Message: </th><td>" + "Diff suppressed as the depth of object is more than current max depth (" + QUnit.config.maxDepth + ").<p>Hint: Use <code>QUnit.dump.maxDepth</code> to " + " run with a higher max d...
} else {
message += "<tr class='test-message'><th>Message: </th><td>" + "Diff suppressed as the expected and actual results have an equivalent" + " serialization</td></tr>";
}
if (details.source) {
message += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText(details.source) + "</pre></td></tr>";
}
message += "</table>";
// This occurs when pushFailure is set and we have an extracted stack trace
} else if (!details.result && details.source) {
message += "<table>" + "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText(details.source) + "</pre></td></tr>" + "</table>";
}
assertList = testItem.getElementsByTagName("ol")[0];
assertLi = document$$1.createElement("li");
assertLi.className = details.result ? "pass" : "fail";
assertLi.innerHTML = message;
assertList.appendChild(assertLi);
});
QUnit.testDone(function (details) {
var testTitle,
time,
testItem,
assertList,
good,
bad,
testCounts,
skipped,
sourceName,
tests = id("qunit-tests");
if (!tests) {
return;
}
testItem = id("qunit-test-output-" + details.testId);
assertList = testItem.getElementsByTagName("ol")[0];
good = details.passed;
bad = details.failed;
// This test passed if it has no unexpected failed assertions
var testPassed = details.failed > 0 ? details.todo : !details.todo;
if (testPassed) {
// Collapse the passing tests
addClass(assertList, "qunit-collapsed");
} else if (config.collapse) {
if (!collapseNext) {
// Skip collapsing the first failing test
collapseNext = true;
} else {
// Collapse remaining tests
addClass(assertList, "qunit-collapsed");
}
}
// The testItem.firstChild is the test name
testTitle = testItem.firstChild;
testCounts = bad ? "<b class='failed'>" + bad + "</b>, " + "<b class='passed'>" + good + "</b>, " : "";
testTitle.innerHTML += " <b class='counts'>(" + testCounts + details.assertions.length + ")</b>";
if (details.skipped) {
share/js/core/qunit.js view on Meta::CPAN
if (diffs[pointer][0] === DIFF_DELETE) {
postDel = true;
} else {
postIns = true;
}
/*
* Five types to be split:
* <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
* <ins>A</ins>X<ins>C</ins><del>D</del>
* <ins>A</ins><del>B</del>X<ins>C</ins>
* <ins>A</del>X<ins>C</ins><del>D</del>
* <ins>A</ins><del>B</del>X<del>C</del>
*/
if (lastequality && (preIns && preDel && postIns && postDel || lastequality.length < 2 && preIns + preDel + postIns + postDel === 3)) {
// Duplicate record.
diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastequality]);
// Change second copy to insert.
diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
equalitiesLength--; // Throw away the equality we just deleted;
lastequality = null;
if (preIns && preDel) {
// No changes made which could affect previous entry, keep going.
postIns = postDel = true;
equalitiesLength = 0;
} else {
equalitiesLength--; // Throw away the previous equality.
pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
postIns = postDel = false;
}
changes = true;
}
}
pointer++;
}
if (changes) {
this.diffCleanupMerge(diffs);
}
};
/**
* Convert a diff array into a pretty HTML report.
* @param {!Array.<!DiffMatchPatch.Diff>} diffs Array of diff tuples.
* @param {integer} string to be beautified.
* @return {string} HTML representation.
*/
DiffMatchPatch.prototype.diffPrettyHtml = function (diffs) {
var op,
data,
x,
html = [];
for (x = 0; x < diffs.length; x++) {
op = diffs[x][0]; // Operation (insert, delete, equal)
data = diffs[x][1]; // Text of change.
switch (op) {
case DIFF_INSERT:
html[x] = "<ins>" + escapeText(data) + "</ins>";
break;
case DIFF_DELETE:
html[x] = "<del>" + escapeText(data) + "</del>";
break;
case DIFF_EQUAL:
html[x] = "<span>" + escapeText(data) + "</span>";
break;
}
}
return html.join("");
};
/**
* Determine the common prefix of two strings.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {number} The number of characters common to the start of each
* string.
*/
DiffMatchPatch.prototype.diffCommonPrefix = function (text1, text2) {
var pointermid, pointermax, pointermin, pointerstart;
// Quick check for common null cases.
if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {
return 0;
}
// Binary search.
// Performance analysis: https://neil.fraser.name/news/2007/10/09/
pointermin = 0;
pointermax = Math.min(text1.length, text2.length);
pointermid = pointermax;
pointerstart = 0;
while (pointermin < pointermid) {
if (text1.substring(pointerstart, pointermid) === text2.substring(pointerstart, pointermid)) {
pointermin = pointermid;
pointerstart = pointermin;
} else {
pointermax = pointermid;
}
pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
}
return pointermid;
};
/**
* Determine the common suffix of two strings.
* @param {string} text1 First string.
* @param {string} text2 Second string.
* @return {number} The number of characters common to the end of each string.
*/
DiffMatchPatch.prototype.diffCommonSuffix = function (text1, text2) {
var pointermid, pointermax, pointermin, pointerend;
// Quick check for common null cases.
if (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1)) {
return 0;
}
// Binary search.
// Performance analysis: https://neil.fraser.name/news/2007/10/09/
pointermin = 0;
pointermax = Math.min(text1.length, text2.length);
pointermid = pointermax;
pointerend = 0;
while (pointermin < pointermid) {
( run in 2.287 seconds using v1.01-cache-2.11-cpan-39bf76dae61 )