clipperz/password-manager-mirror
1
0
Fork 0
mirror of http://git.whoc.org.uk/git/password-manager.git synced 2025-10-24 17:27:35 +02:00
Code Issues Releases Wiki Activity

Interim synchronization with internal repository

Browse Source 
This is an intermir commit to share what is going on with the development of the new /delta version.
This commit is contained in:
Giulio Cesare Solaroli
2014-07-28 18:07:48 +02:00
parent 6dd16d9359
commit f8da092f3d
111 changed files with 34049 additions and 28666 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
frontend/delta/tests/SimpleTest/SimpleTest.Async.js Normal file
View File

@@ -0,0 +1,164 @@
/*
Copyright 2008-2013 Clipperz Srl
This file is part of Clipperz, the online password manager.
For further information about its features and functionalities please
refer to http://www.clipperz.com.
* Clipperz is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
* Clipperz is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public
License along with Clipperz. If not, see http://www.gnu.org/licenses/.
*/
MochiKit.Base.update(Clipperz.Async.Deferred.prototype, {
/*
'_addTest': function(anExpectedValue, aDescription, isDeep, aResult) {
if (isDeep) {
SimpleTest.isDeeply(aResult, anExpectedValue, aDescription);
} else {
SimpleTest.is(aResult, anExpectedValue, aDescription);
}
return aResult;
},
*/
'addTest': function (anExpectedValue, aDescription, isDeep) {
// this.addMethod(this, '_addTest', anExpectedValue, aDescription, isDeep);
// this.addCallback(Clipperz.Async.test, anExpectedValue, aDescription, isDeep);
if (isDeep) {
// SimpleTest.isDeeply(aResult, anExpectedValue, aDescription);
this.addCallback(Clipperz.Async.Test.isDeeply(anExpectedValue, aDescription));
} else {
// SimpleTest.is(aResult, anExpectedValue, aDescription);
this.addCallback(Clipperz.Async.Test.is(anExpectedValue, aDescription));
}
},
//-------------------------------------------------------------------------
'shouldSucceed': function (aDescription) {
this.addCallbackPass(SimpleTest.ok, true, aDescription);
this.addErrbackPass (SimpleTest.ok, false, aDescription);
this.addBoth(MochiKit.Async.succeed, null);
},
'shouldFail': function (aDescription) {
this.addCallbackPass(SimpleTest.ok, false, aDescription);
this.addErrbackPass (SimpleTest.ok, true, aDescription);
this.addBoth(MochiKit.Async.succeed, null);
},
//-------------------------------------------------------------------------
});
Clipperz.Async.Test = {};
MochiKit.Base.update(Clipperz.Async.Test, {
'is': function (anExpectedResult, aDescription) {
return MochiKit.Base.partial(function (anExpectedResult, aDescription, aResult) {
SimpleTest.is(aResult, anExpectedResult, aDescription);
return aResult;
}, anExpectedResult, aDescription);
},
//-------------------------------------------------------------------------
'ok': function (aDescription) {
return MochiKit.Base.partial(function (aDescription, aResult) {
SimpleTest.ok(aResult, aDescription);
return aResult;
}, aDescription);
},
//-------------------------------------------------------------------------
'fail': function(aDescription) {
return MochiKit.Base.partial(function (aDescription, aResult) {
SimpleTest.ok(!aResult, aDescription);
return aResult;
}, aDescription);
},
//-------------------------------------------------------------------------
'isDeeply': function (anExpectedResult, aDescription) {
return MochiKit.Base.partial(function (anExpectedResult, aDescription, aResult) {
SimpleTest.isDeeply(aResult, anExpectedResult, aDescription);
return aResult;
}, anExpectedResult, aDescription);
},
//-------------------------------------------------------------------------
__syntaxFix__: "syntax fix"
});
SimpleTest.runDeferredTests = function (aName, aTestSet, aTestArguments) {
try {
var deferredTests;
var aTestName;
var title;
deferredTests = new Clipperz.Async.Deferred(aName + " <deferred test set>", aTestArguments);
title = aName;
aTestName = window.location.href.match(/#.*/);
if (aTestName && (aTestName != '#')) {
aTestName = aTestName[0].slice(1);
if (aTestName in aTestSet) {
//Clipperz.log("single test execution, via fragment identifier", aTestName);
title += ' [' + aTestName + ']';
deferredTests.addCallback(aTestSet[aTestName], aTestArguments);
deferredTests.addErrback(SimpleTest.ok, false, aTestName);
} else {
title = 'WRONG TEST NAME'
deferredTests.addBoth(is, aTestName, null, "Wrong test name selected to run");
}
} else {
for (aTestName in aTestSet) {
deferredTests.addCallback(aTestSet[aTestName], aTestArguments);
deferredTests.addErrback(SimpleTest.ok, false, aTestName);
deferredTests.addBoth(MochiKit.Async.wait, 0.5);
}
deferredTests.addBoth(is, true, true, "FINISH: completed the full stack of tests");
}
MochiKit.DOM.currentDocument().title = title;
deferredTests.addBoth(SimpleTest.finish);
deferredTests.callback();
SimpleTest.waitForExplicitFinish();
} catch (err) {
var s = "test suite failure!\n";
var o = {};
var k = null;
for (k in err) {
// ensure unique keys?!
if (!o[k]) {
s += k + ": " + err[k] + "\n";
o[k] = err[k];
}
}
ok ( false, s );
}
}

447
frontend/delta/tests/SimpleTest/SimpleTest.js Normal file
View File

@@ -0,0 +1,447 @@
/*
Copyright 2008-2013 Clipperz Srl
This file is part of Clipperz, the online password manager.
For further information about its features and functionalities please
refer to http://www.clipperz.com.
* Clipperz is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
* Clipperz is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public
License along with Clipperz. If not, see http://www.gnu.org/licenses/.
*/
/**
* SimpleTest, a partial Test.Simple/Test.More API compatible test library.
*
* Why?
*
* Test.Simple doesn't work on IE < 6.
* TODO:
* * Support the Test.Simple API used by MochiKit, to be able to test MochiKit
* itself against IE 5.5
*
**/
if (typeof(SimpleTest) == "undefined") {
var SimpleTest = {};
}
// Check to see if the TestRunner is present and has logging
if (typeof(parent) != "undefined" && parent.TestRunner) {
SimpleTest._logEnabled = parent.TestRunner.logEnabled;
}
SimpleTest._tests = [];
SimpleTest._stopOnLoad = true;
SimpleTest._scopeCopy = {};
/**
* Saves a copy of the specified scope variables.
*/
SimpleTest.saveScope = function (scope) {
SimpleTest._scopeCopy = {};
for (var k in scope) {
SimpleTest._scopeCopy[k] = scope[k];
}
}
/**
* Verifies the specified scope against the stored copy and reports
* any differences as test failures.
*/
SimpleTest.verifyScope = function (scope) {
var filter = ['test', '_firebug','_FirebugConsole','XMLHttpRequest','Audio',
'XSLTProcessor','Option','Image','scrollMaxX','scrollMaxY',
'clipboardData'];
for (var k in scope) {
if (MochiKit.Base.findValue(filter, k) < 0) {
var v = scope[k];
var old = SimpleTest._scopeCopy[k];
if (v !== old && typeof(old) === "undefined") {
SimpleTest.ok(false, "scope modified, variable " + k + " was added");
} else if (v !== old) {
SimpleTest.ok(false, "scope modified, variable " + k + " changed from: " + old + ", to: " + v);
}
}
}
for (var k in SimpleTest._scopeCopy) {
if (!(k in scope)) {
SimpleTest.ok(false, "scope modified, variable " + k + " has been removed");
}
}
}
/**
* Something like assert.
*/
SimpleTest.ok = function (condition, name, diag) {
var test = {'result': !!condition, 'name': name, 'diag': diag || ""};
if (SimpleTest._logEnabled) {
var msg = test.result ? "PASS" : "FAIL";
msg += " | " + test.name;
if (test.result) {
parent.TestRunner.logger.log(msg);
} else {
msg += " | " + test.diag;
parent.TestRunner.logger.error(msg);
}
}
SimpleTest._tests.push(test);
};
/**
* Roughly equivalent to ok(a==b, name)
*/
SimpleTest.is = function (a, b, name) {
var repr = MochiKit.Base.repr;
SimpleTest.ok(a == b, name, "got " + repr(a) + ", expected " + repr(b));
};
/**
* Roughly equivalent to ok(compare(a,b)==0, name)
*/
SimpleTest.eq = function (a, b, name) {
var base = MochiKit.Base;
var repr = base.repr;
try {
SimpleTest.ok(base.compare(a, b) == 0, name, "got " + repr(a) + ", expected " + repr(b));
} catch (e) {
SimpleTest.ok(false, name, "exception in compare: " + repr(e));
}
};
/**
* Makes a test report, returns it as a DIV element.
**/
SimpleTest.report = function () {
var DIV = MochiKit.DOM.DIV;
var passed = 0;
var failed = 0;
var results = MochiKit.Base.map(
function (test) {
var cls, msg;
if (test.result) {
passed++;
cls = "test_ok";
msg = "ok - " + test.name;
} else {
failed++;
cls = "test_not_ok";
msg = "not ok - " + test.name;
if (test.diag != null && test.diag != "") {
msg += ": " + test.diag;
}
}
return DIV({"class": cls}, msg);
},
SimpleTest._tests
);
var summary_class = ((failed == 0) ? 'all_pass' : 'some_fail');
return DIV({'class': 'tests_report'},
DIV({'class': 'tests_summary ' + summary_class},
DIV({'class': 'tests_passed'}, "Passed: " + passed),
DIV({'class': 'tests_failed'}, "Failed: " + failed)),
results
);
};
/**
* Toggle element visibility
**/
SimpleTest.toggle = function(el) {
if (MochiKit.Style.getStyle(el, 'display') == 'block') {
el.style.display = 'none';
} else {
el.style.display = 'block';
}
};
/**
* Toggle visibility for divs with a specific class.
**/
SimpleTest.toggleByClass = function (cls) {
var elems = MochiKit.DOM.getElementsByTagAndClassName('div', cls);
MochiKit.Base.map(SimpleTest.toggle, elems);
return false;
};
/**
* Shows the report in the browser
**/
SimpleTest.showReport = function() {
var base = MochiKit.Base;
var dom = MochiKit.DOM;
var togglePassed = dom.A({'href': '#'}, "Toggle passed tests");
var toggleFailed = dom.A({'href': '#'}, "Toggle failed tests");
togglePassed.onclick = base.partial(SimpleTest.toggleByClass, 'test_ok');
toggleFailed.onclick = base.partial(SimpleTest.toggleByClass, 'test_not_ok');
var body = document.getElementsByTagName("body")[0];
var firstChild = body.childNodes[0];
var addNode;
if (firstChild) {
addNode = function (el) {
body.insertBefore(el, firstChild);
};
} else {
addNode = function (el) {
body.appendChild(el)
};
}
addNode(togglePassed);
addNode(dom.SPAN(null, " "));
addNode(toggleFailed);
addNode(SimpleTest.report());
};
/**
* Tells SimpleTest to don't finish the test when the document is loaded,
* useful for asynchronous tests.
*
* When SimpleTest.waitForExplicitFinish is called,
* explicit SimpleTest.finish() is required.
**/
SimpleTest.waitForExplicitFinish = function () {
SimpleTest._stopOnLoad = false;
};
/**
* Talks to the TestRunner if being ran on a iframe and the parent has a
* TestRunner object.
**/
SimpleTest.talkToRunner = function () {
if (typeof(parent) != "undefined" && parent.TestRunner) {
parent.TestRunner.testFinished(document);
}
};
/**
* Finishes the tests. This is automatically called, except when
* SimpleTest.waitForExplicitFinish() has been invoked.
**/
SimpleTest.finish = function () {
SimpleTest.showReport();
SimpleTest.talkToRunner();
};
MochiKit.DOM.addLoadEvent(function() {
if (SimpleTest._stopOnLoad) {
SimpleTest.finish();
}
});
// --------------- Test.Builder/Test.More isDeeply() -----------------
SimpleTest.DNE = {dne: 'Does not exist'};
SimpleTest.LF = "\r\n";
SimpleTest._isRef = function (object) {
var type = typeof(object);
return type == 'object' || type == 'function';
};
SimpleTest._deepCheck = function (e1, e2, stack, seen) {
var ok = false;
// Either they're both references or both not.
var sameRef = !(!SimpleTest._isRef(e1) ^ !SimpleTest._isRef(e2));
if (e1 == null && e2 == null) {
ok = true;
} else if (e1 != null ^ e2 != null) {
ok = false;
} else if (e1 == SimpleTest.DNE ^ e2 == SimpleTest.DNE) {
ok = false;
} else if (sameRef && e1 == e2) {
// Handles primitives and any variables that reference the same
// object, including functions.
ok = true;
} else if (SimpleTest.isa(e1, 'Array') && SimpleTest.isa(e2, 'Array')) {
ok = SimpleTest._eqArray(e1, e2, stack, seen);
} else if (typeof e1 == "object" && typeof e2 == "object") {
ok = SimpleTest._eqAssoc(e1, e2, stack, seen);
} else {
// If we get here, they're not the same (function references must
// always simply rererence the same function).
stack.push({ vals: [e1, e2] });
ok = false;
}
return ok;
};
SimpleTest._eqArray = function (a1, a2, stack, seen) {
// Return if they're the same object.
if (a1 == a2) return true;
// JavaScript objects have no unique identifiers, so we have to store
// references to them all in an array, and then compare the references
// directly. It's slow, but probably won't be much of an issue in
// practice. Start by making a local copy of the array to as to avoid
// confusing a reference seen more than once (such as [a, a]) for a
// circular reference.
for (var j = 0; j < seen.length; j++) {
if (seen[j][0] == a1) {
return seen[j][1] == a2;
}
}
// If we get here, we haven't seen a1 before, so store it with reference
// to a2.
seen.push([ a1, a2 ]);
var ok = true;
// Only examines enumerable attributes. Only works for numeric arrays!
// Associative arrays return 0. So call _eqAssoc() for them, instead.
var max = a1.length > a2.length ? a1.length : a2.length;
if (max == 0) return SimpleTest._eqAssoc(a1, a2, stack, seen);
for (var i = 0; i < max; i++) {
var e1 = i > a1.length - 1 ? SimpleTest.DNE : a1[i];
var e2 = i > a2.length - 1 ? SimpleTest.DNE : a2[i];
stack.push({ type: 'Array', idx: i, vals: [e1, e2] });
if (ok = SimpleTest._deepCheck(e1, e2, stack, seen)) {
stack.pop();
} else {
break;
}
}
return ok;
};
SimpleTest._eqAssoc = function (o1, o2, stack, seen) {
// Return if they're the same object.
if (o1 == o2) return true;
// JavaScript objects have no unique identifiers, so we have to store
// references to them all in an array, and then compare the references
// directly. It's slow, but probably won't be much of an issue in
// practice. Start by making a local copy of the array to as to avoid
// confusing a reference seen more than once (such as [a, a]) for a
// circular reference.
seen = seen.slice(0);
for (var j = 0; j < seen.length; j++) {
if (seen[j][0] == o1) {
return seen[j][1] == o2;
}
}
// If we get here, we haven't seen o1 before, so store it with reference
// to o2.
seen.push([ o1, o2 ]);
// They should be of the same class.
var ok = true;
// Only examines enumerable attributes.
var o1Size = 0; for (var i in o1) o1Size++;
var o2Size = 0; for (var i in o2) o2Size++;
var bigger = o1Size > o2Size ? o1 : o2;
for (var i in bigger) {
var e1 = o1[i] == undefined ? SimpleTest.DNE : o1[i];
var e2 = o2[i] == undefined ? SimpleTest.DNE : o2[i];
stack.push({ type: 'Object', idx: i, vals: [e1, e2] });
if (ok = SimpleTest._deepCheck(e1, e2, stack, seen)) {
stack.pop();
} else {
break;
}
}
return ok;
};
SimpleTest._formatStack = function (stack) {
var variable = '$Foo';
for (var i = 0; i < stack.length; i++) {
var entry = stack[i];
var type = entry['type'];
var idx = entry['idx'];
if (idx != null) {
if (/^\d+$/.test(idx)) {
// Numeric array index.
variable += '[' + idx + ']';
} else {
// Associative array index.
idx = idx.replace("'", "\\'");
variable += "['" + idx + "']";
}
}
}
var vals = stack[stack.length-1]['vals'].slice(0, 2);
var vars = [
variable.replace('$Foo', 'got'),
variable.replace('$Foo', 'expected')
];
var out = "Structures begin differing at:" + SimpleTest.LF;
for (var i = 0; i < vals.length; i++) {
var val = vals[i];
if (val == null) {
val = 'undefined';
} else {
val == SimpleTest.DNE ? "Does not exist" : "'" + val + "'";
}
}
out += vars[0] + ' = ' + vals[0] + SimpleTest.LF;
out += vars[1] + ' = ' + vals[1] + SimpleTest.LF;
return ' ' + out;
};
SimpleTest.isDeeply = function (it, as, name) {
var ok;
// ^ is the XOR operator.
if (SimpleTest._isRef(it) ^ SimpleTest._isRef(as)) {
// One's a reference, one isn't.
ok = false;
} else if (!SimpleTest._isRef(it) && !SimpleTest._isRef(as)) {
// Neither is an object.
ok = SimpleTest.is(it, as, name);
} else {
// We have two objects. Do a deep comparison.
var stack = [], seen = [];
if ( SimpleTest._deepCheck(it, as, stack, seen)) {
ok = SimpleTest.ok(true, name);
} else {
ok = SimpleTest.ok(false, name, SimpleTest._formatStack(stack));
}
}
return ok;
};
SimpleTest.typeOf = function (object) {
var c = Object.prototype.toString.apply(object);
var name = c.substring(8, c.length - 1);
if (name != 'Object') return name;
// It may be a non-core class. Try to extract the class name from
// the constructor function. This may not work in all implementations.
if (/function ([^(\s]+)/.test(Function.toString.call(object.constructor))) {
return RegExp.$1;
}
// No idea. :-(
return name;
};
SimpleTest.isa = function (object, clas) {
return SimpleTest.typeOf(object) == clas;
};
// Global symbols:
var ok = SimpleTest.ok;
var is = SimpleTest.is;
var isDeeply = SimpleTest.isDeeply;

256
frontend/delta/tests/SimpleTest/TestRunner.js Normal file
View File

@@ -0,0 +1,256 @@
/*
Copyright 2008-2013 Clipperz Srl
This file is part of Clipperz, the online password manager.
For further information about its features and functionalities please
refer to http://www.clipperz.com.
* Clipperz is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
* Clipperz is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public
License along with Clipperz. If not, see http://www.gnu.org/licenses/.
*/
/**
* TestRunner: A test runner for SimpleTest
* TODO:
*
* * Avoid moving iframes: That causes reloads on mozilla and opera.
*
*
**/
var TestRunner = {};
TestRunner.logEnabled = false;
TestRunner._iframes = {};
TestRunner._iframeDocuments = {};
TestRunner._iframeRows = {};
TestRunner._currentTest = 0;
TestRunner._urls = [];
TestRunner._testsDiv = DIV();
TestRunner._progressDiv = DIV();
TestRunner._summaryDiv = DIV(null,
H1(null, "Tests Summary"),
TABLE(null,
THEAD(null,
TR(null,
TH(null, "Test"),
TH(null, "Passed"),
TH(null, "Failed")
)
),
TFOOT(/*null, TR(null, TH(null, "-"), TH(null, "--"), TH(null, "---"))*/),
TBODY()
)
);
/**
* This function is called after generating the summary.
**/
TestRunner.onComplete = null;
/**
* If logEnabled is true, this is the logger that will be used.
**/
TestRunner.logger = MochiKit.Logging.logger;
/**
* Toggle element visibility
**/
TestRunner._toggle = function(el) {
if (el.className == "noshow") {
el.className = "";
el.style.cssText = "";
} else {
el.className = "noshow";
el.style.cssText = "width:0px; height:0px; border:0px;";
}
};
/**
* Creates the iframe that contains a test
**/
TestRunner._makeIframe = function (url) {
var iframe = document.createElement('iframe');
iframe.src = url;
iframe.name = url;
iframe.width = "500";
var tbody = TestRunner._summaryDiv.getElementsByTagName("tbody")[0];
var tr = TR(null, TD({'colspan': '3'}, iframe));
iframe._row = tr;
tbody.appendChild(tr);
return iframe;
};
/**
* TestRunner entry point.
*
* The arguments are the URLs of the test to be ran.
*
**/
TestRunner.runTests = function (/*url...*/) {
if (TestRunner.logEnabled)
TestRunner.logger.log("SimpleTest START");
var body = document.getElementsByTagName("body")[0];
appendChildNodes(body,
TestRunner._testsDiv,
TestRunner._progressDiv,
TestRunner._summaryDiv
);
for (var i = 0; i < arguments.length; i++) {
TestRunner._urls.push(arguments[i]);
}
TestRunner.runNextTest();
};
/**
* Run the next test. If no test remains, calls makeSummary
**/
TestRunner.runNextTest = function() {
if (TestRunner._currentTest < TestRunner._urls.length) {
var url = TestRunner._urls[TestRunner._currentTest];
var progress = SPAN(null,
"Running ", A({href:url}, url), "..."
);
if (TestRunner.logEnabled)
TestRunner.logger.log(scrapeText(progress));
TestRunner._progressDiv.appendChild(progress);
TestRunner._iframes[url] = TestRunner._makeIframe(url);
} else {
TestRunner.makeSummary();
if (TestRunner.onComplete) {
TestRunner.onComplete();
}
}
};
/**
* This stub is called by SimpleTest when a test is finished.
**/
TestRunner.testFinished = function (doc) {
appendChildNodes(TestRunner._progressDiv, SPAN(null, "Done"), BR());
var finishedURL = TestRunner._urls[TestRunner._currentTest];
if (TestRunner.logEnabled)
TestRunner.logger.debug("SimpleTest finished " + finishedURL);
TestRunner._iframeDocuments[finishedURL] = doc;
// TestRunner._iframes[finishedURL].style.display = "none";
if (finishedURL != null) {
TestRunner._toggle(TestRunner._iframes[finishedURL]);
TestRunner._currentTest++;
TestRunner.runNextTest();
}
};
/**
* Display the summary in the browser
**/
/*
TestRunner.makeSummary = function() {
if (TestRunner.logEnabled)
TestRunner.logger.log("SimpleTest FINISHED");
var rows = [];
for (var url in TestRunner._iframeDocuments) {
var doc = TestRunner._iframeDocuments[url];
var nOK = withDocument(doc,
partial(getElementsByTagAndClassName, 'div', 'test_ok')
).length;
var nNotOK = withDocument(doc,
partial(getElementsByTagAndClassName, 'div', 'test_not_ok')
).length;
var toggle = partial(TestRunner._toggle, TestRunner._iframes[url]);
var jsurl = "TestRunner._toggle(TestRunner._iframes['" + url + "'])";
var row = TR(
{'style': {'backgroundColor': nNotOK > 0 ? "#f00":"#0f0"}},
TD(null, url),
TD(null, nOK),
TD(null, nNotOK)
);
row.onclick = toggle;
var tbody = TestRunner._summaryDiv.getElementsByTagName("tbody")[0];
tbody.insertBefore(row, TestRunner._iframes[url]._row)
}
};
*/
TestRunner.makeSummary = function() {
var base = MochiKit.Base;
var dom = MochiKit.DOM;
var iter = MochiKit.Iter;
var total_Ok, total_not_Ok;
total_Ok = 0;
total_not_Ok = 0;
if (TestRunner.logEnabled)
TestRunner.logger.log("SimpleTest FINISHED");
var rows = [];
for (var url in TestRunner._iframeDocuments) {
var doc = TestRunner._iframeDocuments[url];
var nOK = withDocument(doc,
partial(getElementsByTagAndClassName, 'div', 'test_ok')
).length;
var nNotOK = withDocument(doc,
partial(getElementsByTagAndClassName, 'div', 'test_not_ok')
).length;
var toggle = partial(TestRunner._toggle, TestRunner._iframes[url]);
var jsurl = "TestRunner._toggle(TestRunner._iframes['" + url + "'])";
var row = TR(
{'style': {'backgroundColor': nNotOK > 0 ? "#f00":"#0f0"}},
TD(null, url),
TD(null, nOK),
TD(null, nNotOK)
);
row.onclick = toggle;
var tbody = TestRunner._summaryDiv.getElementsByTagName("tbody")[0];
tbody.insertBefore(row, TestRunner._iframes[url]._row);
total_Ok += nOK;
total_not_Ok += nNotOK;
}
{
var tfoot = TestRunner._summaryDiv.getElementsByTagName("tfoot")[0];
tfoot.appendChild(TR(null,
TH(null, ""),
TH({'style':"color:green;"}, total_Ok),
TH({'style':"color:" + ((total_not_Ok == 0) ? 'black' : 'red') + ";"}, total_not_Ok)
));
}
var testRunnerResults;
var i, c;
testRunnerResults = dom.DIV({'style': 'display:none; visibility:hidden;'}, null);
c = total_Ok;
for (i=0; i<c; i++) {
dom.appendChildNodes(testRunnerResults, dom.DIV({'class': 'test_ok'}, "ok"));
}
c = total_not_Ok;
for (i=0; i<c; i++) {
dom.appendChildNodes(testRunnerResults, dom.DIV({'class': 'test_not_ok'}, "fail"));
}
document.getElementsByTagName("body")[0].appendChild(testRunnerResults);
if (typeof(parent) != "undefined" && parent.TestRunner) {
parent.TestRunner.testFinished(document);
}
};

51
frontend/delta/tests/SimpleTest/test.css Normal file
View File

@@ -0,0 +1,51 @@
/*
Copyright 2008-2013 Clipperz Srl
This file is part of Clipperz, the online password manager.
For further information about its features and functionalities please
refer to http://www.clipperz.com.
* Clipperz is free software: you can redistribute it and/or modify it
under the terms of the GNU Affero General Public License as published
by the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
* Clipperz is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public
License along with Clipperz. If not, see http://www.gnu.org/licenses/.
*/
.test_ok {
color: green;
display: none;
}
.test_not_ok {
color: red;
display: block;
}
.test_ok, .test_not_ok {
border-bottom-width: 2px;
border-bottom-style: solid;
border-bottom-color: black;
}
.all_pass {
background-color: lime;
}
.some_fail {
background-color: red;
}
.tests_report {
border-width: 2px;
border-style: solid;
width: 20em;
}