Software: Apache/2.2.16 (Debian). PHP/5.3.3-7+squeeze19 uname -a: Linux mail.tri-specialutilitydistrict.com 2.6.32-5-amd64 #1 SMP Tue May 13 16:34:35 UTC uid=33(www-data) gid=33(www-data) groups=33(www-data) Safe-mode: OFF (not secure) /usr/share/pyshared/nevow/js/Divmod/Test/ drwxr-xr-x | |
| Viewing file: Select action/file-type: // -*- test-case-name: nevow.test.test_javascript -*-
/**
* Tests for Divmod.UnitTest, the Javascript unit-testing framework.
* Uses mock test cases provided by Divmod.Test.Mock.
*/
// import Divmod.UnitTest
// import Divmod.Test.Mock
/* DON'T load Divmod.MockBrowser; it should be imported implicitly. */
/**
* A mock L{TestResult} object that we use to test that L{startTest} and L{stopTest}
* are called appropriately.
*/
Divmod.Test.TestUnitTest.MockResult = Divmod.Class.subclass('Divmod.Test.TestUnitTest.MockResult');
Divmod.Test.TestUnitTest.MockResult.methods(
function __init__(self) {
self.log = '';
},
function startTest(self, test) {
self.log += 'startTest ' + test.id();
},
function addSuccess(self, test) {
self.log += ' addSuccess ' + test.id();
},
function stopTest(self, test) {
self.log += ' stopTest ' + test.id();
});
/**
* Tests for assertions in L{Divmod.UnitTest.TestCase}.
*/
Divmod.Test.TestUnitTest.AssertionTests = Divmod.UnitTest.TestCase.subclass('Divmod.Test.TestUnitTest.AssertionTests');
Divmod.Test.TestUnitTest.AssertionTests.methods(
/**
* Test that L{assert} raises an exception if its expression is false.
*/
function test_assert(self) {
self.assertThrows(Divmod.UnitTest.AssertionError,
function () { self.assert(false, "message"); })
},
/**
* Verify that isTestCaseClass returns a positive result for TestCase
* subclasses and a negative result for other types of object.
*/
function test_isTestCaseClass(self) {
self.assertIdentical(
true, Divmod.UnitTest.isTestCaseClass(
Divmod.Test.TestUnitTest.AssertionTests));
self.assertIdentical(
false, Divmod.UnitTest.isTestCaseClass(
Divmod.Test.TestUnitTest.AssertionTests()));
self.assertIdentical(
false, Divmod.UnitTest.isTestCaseClass(1));
},
/**
* Test that L{assertThrows} doesn't raise an exception if its callable
* raises the excepted error.
*/
function test_assertThrowsPositive(self) {
try {
self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
throw Divmod.UnitTest.AssertionError();
});
} catch (e) {
self.fail("assertThrows should have passed: " + e.message);
}
},
/**
* Test that L{assertThrows} raises an exception if its callable does
* I{not} raise an exception.
*/
function test_assertThrowsNoException(self) {
var raised = true;
try {
self.assertThrows(Divmod.UnitTest.AssertionError,
function () { });
raised = false;
} catch (e) {
if (!(e instanceof Divmod.UnitTest.AssertionError)) {
self.fail("assertThrows should have thrown AssertionError");
}
}
if (!raised) {
self.fail("assertThrows did not raise an error");
}
},
/**
* Test that L{assertThrows} raises an exception if its callable raises
* the wrong kind of exception.
*/
function test_assertThrowsWrongException(self) {
var raised = true;
try {
self.assertThrows(Divmod.UnitTest.AssertionError,
function () { throw Divmod.IndexError(); });
raised = false;
} catch (e) {
if (!(e instanceof Divmod.UnitTest.AssertionError)) {
self.fail("assertThrows should have thrown AssertionError");
}
}
if (!raised) {
self.fail("assertThrows did not raise an error");
}
},
/**
* Test that L{compare} does not raise an exception if its callable
* returns C{true}.
*/
function test_comparePositive(self) {
self.compare(function () { return true; });
},
/**
* Test that L{compare} raises an error if its callable returns C{false}.
*/
function test_compareNegative(self) {
self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.compare(
function (a, b) { return a === b; },
"!==", "a", "b");
});
},
/**
* Test that the message of L{compare}'s AssertionError describes the
* failed the comparison based on its parameters.
*/
function test_compareDefaultMessage(self) {
try {
self.compare(function () {return false;}, "<->", "a", "b");
} catch (e) {
self.assertIdentical(e.message, '"a" <-> "b"');
}
},
/**
* Test that the L{compare}'s AssertionError includes the optional
* message if it is provided.
*/
function test_compareWithMessage(self) {
try {
self.compare(function () {return false;}, "<->", "a", "b",
"Hello");
} catch (e) {
self.assertIdentical(e.message, '"a" <-> "b": Hello');
}
},
/**
* Test that L{assertIdentical} raises an exception if its arguments are
* unequal, and that the message of the raised exception contains the
* arguments.
*/
function test_assertIdenticalNegative(self) {
var e = self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.assertIdentical('apple', 'orange');
});
self.assert(e.message === '"apple" !== "orange"', e.message);
},
/**
* If L{assertIdentical} is given a message as an optional third argument,
* that message should appear in the raised exception's message. Test this.
*/
function test_assertIdenticalNegativeWithMessage(self) {
try {
self.assertIdentical('apple', 'orange', 'some message');
} catch (e) {
self.assert(e.message === '"apple" !== "orange": some message');
}
},
/**
* Test that L{assertIdentical} doesn't raise an exception if its
* arguments are equal.
*/
function test_assertIdenticalPositive(self) {
self.assertIdentical('apple', 'apple');
},
/**
* Test that L{assertIdentical} thinks that 1 and '1' are unequal.
*/
function test_assertIdenticalDifferentTypes(self) {
var raised = true;
var e = self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.assertIdentical(1, '1');
});
self.assert(e.message === '1 !== "1"');
},
/**
* Test that L{assertArraysEqual} doesn't raise an exception if it is
* passed that two 'equal' arrays.
*/
function test_assertArraysEqualPositive(self) {
self.assertArraysEqual([], []);
self.assertArraysEqual([1, 2], [1, 2]);
},
/**
* Test that L{assertArraysEqual} raises exceptions if it is passed two unequal
* arrays.
*/
function test_assertArraysEqualNegative(self) {
self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.assertArraysEqual([1, 2], [1, 2, 3]);
});
self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.assertArraysEqual({'foo': 2}, [2]);
});
self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.assertArraysEqual(1, [1]);
});
self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.assertArraysEqual(function () { return 1; },
function () { return 2; });
});
self.assertThrows(Divmod.UnitTest.AssertionError,
function () {
self.assertArraysEqual(function () { },
function () { });
});
},
/**
* Test that two equal arrays are not identical, and that an object is
* identical to itself.
*/
function test_assertIdentical(self) {
var foo = [1, 2];
self.assertIdentical(foo, foo);
self.assertThrows(Divmod.UnitTest.AssertionError,
function () { self.assertIdentical(foo, [1, 2]); });
});
/**
* Tests for L{TestCase}.
*/
Divmod.Test.TestUnitTest.TestCaseTest = Divmod.UnitTest.TestCase.subclass('Divmod.Test.TestUnitTest.TestCaseTest');
Divmod.Test.TestUnitTest.TestCaseTest.methods(
function setUp(self) {
self.result = Divmod.UnitTest.TestResult();
},
/**
* Test that when a test is run, C{setUp} is called first, then the test
* method, then L{tearDown}.
*/
function test_wasRun(self) {
var test = Divmod.Test.Mock._WasRun("test_good");
self.assertIdentical(test.log, '');
test.run(self.result);
self.assertIdentical(test.log, 'setUp test tearDown');
},
/**
* Test that C{tearDown} still gets called, even when the test fails.
*/
function test_tearDownCalled(self) {
var test = Divmod.Test.Mock._WasRun("test_bad");
test.run(self.result);
self.assertIdentical(test.log, 'setUp tearDown');
},
/**
* Test that C{run} takes a L{TestResult} that we can use to see whether
* the test passed.
*/
function test_goodResult(self) {
var test = Divmod.Test.Mock._WasRun('test_good');
test.run(self.result);
self.assertArraysEqual(self.result.getSummary(), [1, 0, 0]);
self.assert(self.result.wasSuccessful());
},
/**
* Test that C{run} takes a L{TestResult} that we can use to see whether
* test test failed.
*/
function test_badResult(self) {
var test = Divmod.Test.Mock._WasRun('test_bad');
test.run(self.result);
self.assertArraysEqual(self.result.getSummary(), [1, 1, 0]);
self.assert(!self.result.wasSuccessful());
},
/**
* Test that the L{TestResult} distinguishes between failed assertions
* and general errors.
*/
function test_errorResult(self) {
var test = Divmod.Test.Mock._WasRun('test_error');
test.run(self.result);
self.assertArraysEqual(self.result.getSummary(), [1, 0, 1]);
self.assert(!self.result.wasSuccessful());
},
/**
* Test that we can find out which tests had which errors and which tests
* succeeded.
*/
function test_resultAccumulation(self) {
var suite = Divmod.UnitTest.TestSuite();
var bad = Divmod.Test.Mock._WasRun('test_bad');
var good = Divmod.Test.Mock._WasRun('test_good');
var error = Divmod.Test.Mock._WasRun('test_error');
suite.addTests([bad, good, error]);
suite.run(self.result);
self.assertArraysEqual(self.result.getSummary(), [3, 1, 1]);
// check the failure
self.assertIdentical(self.result.failures[0].length, 2);
self.assertIdentical(self.result.failures[0][0], bad);
self.assert(self.result.failures[0][1]
instanceof Divmod.UnitTest.AssertionError);
self.assertIdentical(self.result.failures[0][1].message,
"fail this test deliberately");
// check the error
self.assertIdentical(self.result.errors[0].length, 2);
self.assertIdentical(self.result.errors[0][0], error);
self.assert(self.result.errors[0][1] instanceof Divmod.Error);
self.assertIdentical(self.result.errors[0][1].message, "error");
self.assertArraysEqual(self.result.successes, [good]);
},
/**
* Test that neither L{tearDown} nor the test method is called when
* L{setUp} fails.
*/
function test_failureInSetUp(self) {
var test = Divmod.Test.Mock._BadSetUp('test_method');
self.assertIdentical(test.log, '');
test.run(self.result);
self.assertIdentical(test.log, '');
},
/**
* Test that failures in L{setUp} are reported to the L{TestResult}
* object.
*/
function test_failureInSetUpReported(self) {
var test = Divmod.Test.Mock._BadSetUp('test_method');
test.run(self.result);
self.assertArraysEqual(self.result.getSummary(), [1, 0, 1]);
},
/**
* Test that failures in L{tearDown} are reported to the L{TestResult}
* object.
*/
function test_failureInTearDownReported(self) {
var test = Divmod.Test.Mock._BadTearDown('test_method');
test.run(self.result);
self.assertArraysEqual(self.result.getSummary(), [1, 0, 1]);
},
/**
* Test that a test which fails in L{tearDown} does *not* get added as
* a success.
*/
function test_badTearDownNotSuccess(self) {
var test = Divmod.Test.Mock._BadTearDown('test_method');
test.run(self.result);
self.assertIdentical(self.result.successes.length, 0);
},
/**
* Test that L{TestCase.run} calls L{TestResult.startTest} and
* L{TestResult.stopTest}.
*/
function test_startAndStopTest(self) {
var test = Divmod.Test.Mock._WasRun('test_good');
var id = test.id();
var result = Divmod.Test.TestUnitTest.MockResult();
test.run(result);
self.assertIdentical(
result.log,
'startTest ' + id + ' addSuccess ' + id + ' stopTest ' + id);
},
/**
* Test that we can create a L{TestSuite}, add tests to it, run it and
* get the results of all of the tests.
*/
function test_testSuite(self) {
var suite = Divmod.UnitTest.TestSuite();
suite.addTest(Divmod.Test.Mock._WasRun('test_good'));
suite.addTest(Divmod.Test.Mock._WasRun('test_bad'));
suite.run(self.result);
self.assertArraysEqual(self.result.getSummary(), [2, 1, 0]);
self.assert(!self.result.wasSuccessful());
},
/**
* Check that C{countTestCases} returns 0 for an empty suite, 1 for a test,
* and n for a suite with n tests.
*/
function test_countTestCases(self) {
self.assertIdentical(self.countTestCases(), 1);
var suite = Divmod.UnitTest.TestSuite();
self.assertIdentical(suite.countTestCases(), 0);
suite.addTest(self);
self.assertIdentical(suite.countTestCases(), 1);
suite.addTest(Divmod.Test.Mock._WasRun('good'));
self.assertIdentical(suite.countTestCases(), 2);
},
/**
* Test that C{id} returns the fully-qualified name of the test.
*/
function test_id(self) {
var test = Divmod.Test.Mock._WasRun('test_good');
self.assertIdentical(test.id(), 'Divmod.Test.Mock._WasRun.test_good');
},
/**
* Test that C{visit} calls the visitor with the test case.
*/
function test_visitCase(self) {
var log = [];
function visitor(test) {
log.push(test);
}
self.visit(visitor);
self.assertArraysEqual(log, [self]);
},
/**
* Test that C{visit} calls the visitor for each test case in a suite.
*/
function test_visitSuite(self) {
var log = [];
function visitor(test) {
log.push(test);
}
Divmod.UnitTest.TestSuite().visit(visitor);
self.assertArraysEqual(log, []);
var tests = [self, Divmod.Test.Mock._WasRun('test_good')];
var suite = Divmod.UnitTest.TestSuite(tests);
suite.visit(visitor);
self.assertArraysEqual(log, tests);
},
/**
* Check that issubclass returns true when the first parameter is a subclass
* of the second, and false otherwise.
*/
function test_issubclass(self) {
self.assert(self.__class__.subclassOf(self.__class__),
"Thing should subclass itself");
self.assert(self.__class__.subclassOf(Divmod.UnitTest.TestCase));
self.assert(!Divmod.UnitTest.TestCase.subclassOf(self.__class__));
});
Divmod.Test.TestUnitTest.LoaderTests = Divmod.UnitTest.TestCase.subclass("Divmod.Test.TestUnitTest.LoaderTests");
Divmod.Test.TestUnitTest.LoaderTests.methods(
/**
* Return a list containing the id() of each test in a suite.
*/
function getTestIDs(self, suite) {
var ids = [];
suite.visit(function (test) { ids.push(test.id()); });
return ids;
},
/**
* Test that C{loadFromClass} returns an empty suite when given a
* C{TestCase} subclass that contains no tests.
*/
function test_loadFromClassEmpty(self) {
var suite = Divmod.UnitTest.loadFromClass(Divmod.UnitTest.TestCase);
self.assertArraysEqual(self.getTestIDs(suite), []);
},
/**
* Test that C{loadFromClass} returns a suite which contains all the
* test methods in a given C{TestCase} subclass.
*/
function test_loadFromClass(self) {
var suite = Divmod.UnitTest.loadFromClass(Divmod.Test.Mock._WasRun);
self.assertArraysEqual(self.getTestIDs(suite),
['Divmod.Test.Mock._WasRun.test_bad',
'Divmod.Test.Mock._WasRun.test_error',
'Divmod.Test.Mock._WasRun.test_good']);
},
/**
* Test that C{loadFromModule} returns an empty suite when given a module
* with no unit tests.
*/
function test_loadFromModuleEmpty(self) {
var module = {};
var suite = Divmod.UnitTest.loadFromModule(module);
self.assertIdentical(suite.countTestCases(), 0);
},
/**
* Test that C{loadFromModule} returns a suite which contains all the
* test methods in a given module.
*/
function test_loadFromModule(self) {
var Mock = {};
Mock.SomeTestCase = Divmod.UnitTest.TestCase.subclass('Mock.SomeTestCase');
Mock.SomeTestCase.methods(function test_method(self) {});
suite = Divmod.UnitTest.loadFromModule(Mock);
self.assertArraysEqual(self.getTestIDs(suite),
['Mock.SomeTestCase.test_method']);
});
Divmod.Test.TestUnitTest.RunnerTest = Divmod.UnitTest.TestCase.subclass('Divmod.Test.TestUnitTest.RunnerTest');
Divmod.Test.TestUnitTest.RunnerTest.methods(
function setUp(self) {
self.result = Divmod.UnitTest.TestResult();
},
/**
* Test that the summary of an empty result object indicates the 'test run'
* passed, and that no tests were run.
*/
function test_formatSummaryEmpty(self) {
self.assertIdentical(Divmod.UnitTest.formatSummary(self.result),
"PASSED (tests=0)");
},
/**
* Test that the summary of a result object from a successful test run
* indicates that the run was successful along with the number of tests in
* the run.
*/
function test_formatSummaryOK(self) {
var test = Divmod.Test.Mock._WasRun('test_good');
test.run(self.result);
self.assertIdentical(Divmod.UnitTest.formatSummary(self.result),
"PASSED (tests=1)");
},
/**
* Test that the summary of a result object from a test run with failures
* indicates an overall failure as well as the number of test failures.
*/
function test_formatSummaryFailed(self) {
var test = Divmod.Test.Mock._WasRun('test_bad');
test.run(self.result);
self.assertIdentical(Divmod.UnitTest.formatSummary(self.result),
"FAILED (tests=1, failures=1)");
},
/**
* As L{test_formatSummaryFailed}, but for errors instead of failures.
*/
function test_formatSummaryError(self) {
var test = Divmod.Test.Mock._WasRun('test_error');
test.run(self.result);
self.assertIdentical(Divmod.UnitTest.formatSummary(self.result),
"FAILED (tests=1, errors=1)");
},
/**
* Sanity test added to make sure the summary makes sense when a suite
* has both failed and errored tests.
*/
function test_formatSummaryMultiple(self) {
var test = Divmod.UnitTest.loadFromClass(Divmod.Test.Mock._WasRun);
test.run(self.result);
self.assertIdentical(Divmod.UnitTest.formatSummary(self.result),
"FAILED (tests=3, errors=1, failures=1)");
},
/**
* Check that L{formatErrors} returns an empty string for an empty result.
*/
function test_formatErrorsEmpty(self) {
self.assertIdentical(Divmod.UnitTest.formatErrors(self.result), '');
},
/**
* Check that L{formatErrors} returns an empty string for a successful result.
*/
function test_formatErrorsOK(self) {
var test = Divmod.Test.Mock._WasRun('test_good');
test.run(self.result);
self.assertIdentical(Divmod.UnitTest.formatErrors(self.result), '');
},
/**
* Check that the L{formatError} returns a nicely formatted representation
* of a failed/errored test.
*/
function test_formatError(self) {
var test = Divmod.Test.Mock._WasRun('test_bad');
var error, failure;
try {
throw Divmod.Error("error-message");
} catch (e) {
error = e;
failure = Divmod.Defer.Failure(error);
}
self.assertIdentical(
Divmod.UnitTest.formatError('FAILURE', test, error),
'[FAILURE] Divmod.Test.Mock._WasRun.test_bad: error-message\n'
+ failure.toPrettyText(failure.filteredParseStack()) + '\n');
},
/**
* Check that L{formatErrors} returns a string that contains all of the
* errors and failures from the result, formatted using L{formatError}.
*/
function test_formatErrors(self) {
var test = Divmod.UnitTest.loadFromClass(Divmod.Test.Mock._WasRun);
test.run(self.result);
var expected = '';
for (var i = 0; i < self.result.errors.length; ++i) {
expected += Divmod.UnitTest.formatError('ERROR',
self.result.errors[i][0],
self.result.errors[i][1]);
}
for (var i = 0; i < self.result.failures.length; ++i) {
expected += Divmod.UnitTest.formatError('FAILURE',
self.result.failures[i][0],
self.result.failures[i][1]);
}
var observed = Divmod.UnitTest.formatErrors(self.result);
self.assertIdentical(observed, expected);
});
Divmod.Test.TestUnitTest.MockDocumentTest = Divmod.UnitTest.TestCase.subclass(
'Divmod.Test.TestUnitTest.MockDocumentTest');
Divmod.Test.TestUnitTest.MockDocumentTest.methods(
/**
* Verify that the document is implicitly imported by the test set up.
* NB: If we ever have a way to run these tests in a real browser, there
* should be a way to skip this one.
*/
function test_documentExists(self) {
self.assert(document instanceof Divmod.MockBrowser.Document);
},
/**
* Verify that the document has a "body" attribute which is an element.
*/
function test_documentHasBody(self) {
self.assert(document.body instanceof Divmod.MockBrowser.Element);
},
/**
* Verify that the elements created by the document have their tag name
* set based on input.
*/
function test_createElement(self) {
var aDocument = Divmod.MockBrowser.Document();
self.assertIdentical(aDocument.createElement('something').tagName,
'SOMETHING');
},
/**
* Elements created with L{Document.createElement} should have a
* C{ownerDocument} property which refers to the document which created
* them.
*/
function test_createdElementHasDocument(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement('a');
self.assertIdentical(anElement.ownerDocument, aDocument);
},
/**
* Verify that text nodes are created with appropriate 'length',
* 'nodeValue', and (empty) 'childNodes' attributes.
*/
function test_createTextNode(self) {
var aDocument = Divmod.MockBrowser.Document();
var aNode = aDocument.createTextNode("hello, world!");
self.assertIdentical(aNode.length, 13);
self.assertIdentical(aNode.nodeValue, "hello, world!");
self.assertIdentical(aNode.childNodes.length, 0);
},
/**
* Text Nodes created with L{Document.createElement} should have a
* C{ownerDocument} property which refers to the document which created
* them.
*/
function test_createdTextNodeHasDocument(self) {
var aDocument = Divmod.MockBrowser.Document();
var aNode = aDocument.createTextNode("hello, world!");
self.assertIdentical(aNode.ownerDocument, aDocument);
},
/**
* Verify that setting an attribute on an element results in that
* attribute being returned from getAttribute.
*/
function test_setGetAttribute(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement('test');
anElement.setAttribute("abc", "123");
self.assertIdentical(anElement.getAttribute("abc"), "123");
},
/**
* Verify that setting an attribute and then removing it results in
* getAttribute subsequently returning C{undefined}.
*/
function test_getRemoveAttribute(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement('test');
anElement.setAttribute("abc", "123");
anElement.removeAttribute("abc");
self.assertIdentical(anElement.getAttribute("abc"), undefined);
},
/**
* Verify that an Element will have a "style" attribute that can be
* manipulated.
*/
function test_elementHasStyle(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement('test');
anElement.style.border = 'thin solid blue';
self.assertIdentical(anElement.style.border, 'thin solid blue');
},
/**
* Verify that an Element given a certain class via setAttribute will be
* given a 'className' attribute that matches the class.
*/
function test_firefoxStyleClassAttribute(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement('test');
anElement.setAttribute("class", "something");
self.assertIdentical(anElement.className, "something");
},
/**
* Verify that a mock element's appendChild() puts that element into the
* childNodes array.
*/
function test_appendChild(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("test");
var anotherElement = aDocument.createElement('test2');
anElement.appendChild(anotherElement);
self.assertIdentical(anElement.childNodes[0], anotherElement);
self.assertIdentical(anotherElement.parentNode, anElement);
},
/**
* Verify that a mock element's removeChild() removes that element (and
* only that element) from the childNodes array.
*/
function test_removeChild(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("test");
var anotherElement = aDocument.createElement("test2");
var ignoreMe = aDocument.createElement("testX");
var ignoreMe2 = aDocument.createElement("testY");
anElement.appendChild(ignoreMe);
anElement.appendChild(anotherElement);
anElement.appendChild(ignoreMe2);
anElement.removeChild(anotherElement);
self.assertIdentical(anElement.childNodes.length, 2);
for (var i = 0; i < anElement.childNodes.length; i++) {
self.assert(anElement.childNodes[i] !== anotherElement);
}
},
/**
* Verify that an exception will be raised if a mock element is asked to
* remove a child which it does not contain.
*/
function test_removeChildInvalid(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("test");
var anotherElement = aDocument.createElement("test2");
self.assertThrows(
Divmod.MockBrowser.DOMError,
function () {
anElement.removeChild(anotherElement);
});
},
/**
* Verify that elements can be retrieved by their ID.
*/
function test_getElementById(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("a");
var anotherElement = aDocument.createElement("b");
aDocument.body.appendChild(anElement);
aDocument.body.appendChild(anotherElement);
anotherElement.id = 'test1';
self.assertIdentical(aDocument.getElementById('test1'), anotherElement);
var thirdElement = aDocument.createElement('c');
aDocument.body.appendChild(thirdElement);
thirdElement.id = 'test2';
self.assertIdentical(aDocument.getElementById('test2'), thirdElement);
},
/**
* Verify that orphaned elements (those not in any document) will not be
* returned by getElementById even if they have an ID that matches.
*/
function test_getElementByIdNoOrphans(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("a");
anElement.id = 'test1';
self.assertIdentical(aDocument.getElementById('test1'), null);
aDocument.body.appendChild(anElement);
self.assertIdentical(aDocument.getElementById('test1'), anElement);
},
/**
* Verify that conflicting IDs are resolved in the reverse order they are
* created; i.e. that the most recently added created node in the document
* with a given ID is found.
*
* This behavior is inconsistent with actual browser DOM, but providing
* proper DOM semantics is difficult due to the fact that tests are
* sharing lots of global state but should not be.
*
* Although these tests here each create their own document object for
* better isolation, third-party code designed to run in an actual browser
* (c.f. MochiKit.DOM) will generally assume that there is only one global
* document and may hold their own references to it.
*
* Browsers appear to treat the first element to be added to the document
* with a given ID as the definitive one, whereas we always want to take
* the most recent, because a previous test may have stomped on that ID.
*
* Eventually it might be a better idea to have the test framework
* interact with the global document a bit, re-setting it to a pristine
* state between tests to that they do not interact with each other, and
* correcting this implementation to be completely consistent with the
* browser's getElementById.
*
* However, for the time being, this point is mostly moot; I can't find a
* description of the behavior of ID conflicts in either the DOM
* specifications or browser documentation (except by the vague
* implication that they should never, ever happen) so this behavior is
* correct inasmuch as it prevents tests from having inter-test
* interactions which they should not have. -glyph
*/
function test_conflictResolutionOrder(self) {
var aDocument = Divmod.MockBrowser.Document();
var c = aDocument.createElement("c");
var b = aDocument.createElement("b");
var a = aDocument.createElement("a");
c.id = 'test1';
aDocument.body.appendChild(a);
aDocument.body.appendChild(b);
aDocument.body.appendChild(c);
self.assertIdentical(aDocument.getElementById('test1'), c);
b.id = 'test1';
a.id = 'test1';
// a was created later.
self.assertIdentical(aDocument.getElementById("test1"), a);
},
/**
* Verify that getElementById with an id that does not exist will mimic
* Firefox's behavior and return 'null'.
*/
function test_getNoElementById(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("div");
anElement.id = "some-id";
self.assertIdentical(aDocument.getElementById("some-other-id"), null);
},
/**
* Make a L{Document} containing some C{<span>} and C{<div>} nodes at
* various depths.
*/
function _makeNestedDocument(self) {
var aDocument = Divmod.MockBrowser.Document();
var outerNode = aDocument.createElement("div");
var innerNode = aDocument.createElement("div");
var spanOne = aDocument.createElement("span");
spanOne.appendChild(aDocument.createTextNode("LULZ"));
innerNode.appendChild(spanOne);
outerNode.appendChild(innerNode);
var spanTwo = aDocument.createElement("span");
spanTwo.appendChild(aDocument.createTextNode("OK"));
outerNode.appendChild(spanTwo);
aDocument.body.appendChild(outerNode);
return aDocument;
},
/**
* getElementsByTagName, when called on L{Document}, should return all
* nodes with the specified tag name, at any depth inside the document's
* body.
*/
function test_getElementsByTagNameDocument(self) {
var aDocument = self._makeNestedDocument();
var outerNode = aDocument.body.childNodes[0];
var deepSpan = outerNode.childNodes[0].childNodes[0];
var shallowSpan = outerNode.childNodes[1];
var result = aDocument.getElementsByTagName('span');
self.assertIdentical(result.length, 2);
self.assertIdentical(result[0], deepSpan);
self.assertIdentical(result[1], shallowSpan);
},
/**
* getElementsByTagName, when called on L{Document.body}, should exclude
* its body node from the result.
*/
function test_getElementsByTagNameBodyNoBody(self) {
var aDocument = Divmod.MockBrowser.Document();
self.assertIdentical(
aDocument.body.getElementsByTagName('body').length, 0);
},
/**
* getElementsByTagName, when called on L{Document}, should include its
* body node from the result.
*/
function test_getElementsByTagNameDocumentIncludesBody(self) {
var aDocument = Divmod.MockBrowser.Document();
var nodes = aDocument.getElementsByTagName('body');
self.assertIdentical(nodes.length, 1);
self.assertIdentical(nodes[0], aDocument.body);
},
/**
* getElementsByTagName should also work on L{Element}.
*/
function test_getElementsByTagNameElement(self) {
var aDocument = self._makeNestedDocument();
var outerNode = aDocument.body.childNodes[0];
var deepSpan = outerNode.childNodes[0].childNodes[0];
var shallowSpan = outerNode.childNodes[1];
var result = outerNode.getElementsByTagName('span');
self.assertIdentical(result.length, 2);
self.assertIdentical(result[0], deepSpan);
self.assertIdentical(result[1], shallowSpan);
},
/**
* getElementsByTagName, when called on L{Element}, should exclude the
* node it's called on from the result.
*/
function test_getElementsByTagNameElementNoTop(self) {
var aDocument = self._makeNestedDocument();
var shallowDiv = aDocument.body.childNodes[0];
var deepDiv = shallowDiv.childNodes[0];
var result = shallowDiv.getElementsByTagName('div');
self.assertIdentical(result.length, 1);
self.assertIdentical(result[0], deepDiv);
},
/**
* getElementsByTagName should return all elements (no text nodes) when
* passed C{*}.
*/
function test_getElementsByTagNameWildcard(self) {
var aDocument = self._makeNestedDocument();
var result = aDocument.getElementsByTagName('*');
self.assertIdentical(result.length, 5);
self.assertIdentical(result[0], aDocument.body);
var outerNode = aDocument.body.childNodes[0];
self.assertIdentical(result[1], outerNode);
var innerNode = outerNode.childNodes[0];
self.assertIdentical(result[2], innerNode);
var spanOne = innerNode.childNodes[0];
self.assertIdentical(result[3], spanOne);
var spanTwo = outerNode.childNodes[1];
self.assertIdentical(result[4], spanTwo);
result = outerNode.getElementsByTagName('*');
self.assertIdentical(result.length, 3);
self.assertIdentical(result[0], innerNode);
self.assertIdentical(result[1], spanOne);
self.assertIdentical(result[2], spanTwo);
},
/**
* Verify that the string representation of a mock element captures all of
* its interesting features to provide something to introspect while
* debugging.
*/
function test_elementToString(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("stuff");
// Tag name.
self.assertIdentical(
anElement.toString(), "<{MOCK}STUFF />");
anElement.setAttribute("hello", "world");
// Attributes.
self.assertIdentical(
anElement.toString(), '<{MOCK}STUFF hello="world" />');
anElement.style.border = "thick solid blue";
// Special "style" attribute.
self.assertIdentical(
anElement.toString(),
'<{MOCK}STUFF hello="world" {style}="border: thick solid blue; " />');
anotherElement = aDocument.createElement("other");
anElement.appendChild(anotherElement);
// Child nodes.
self.assertIdentical(
anElement.toString(),
'<{MOCK}STUFF hello="world" {style}="border: thick solid blue; ">...</STUFF>');
},
/**
* Verify that the default size of an Element will initially be (0, 0)
* until that element is added to the document.
*/
function test_defaultElementSize(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("stuff");
self.assertIdentical(0, anElement.clientHeight);
self.assertIdentical(0, anElement.clientWidth);
aDocument.body.appendChild(anElement);
self.assertIdentical(aDocument.DEFAULT_HEIGHT,
anElement.clientHeight);
self.assertIdentical(aDocument.DEFAULT_WIDTH,
anElement.clientWidth);
},
/**
* Verify that the platform will respect the sizes set for mock elements
* in tests.
*/
function test_getMockElementSize(self) {
var aDocument = Divmod.MockBrowser.Document();
var anElement = aDocument.createElement("stuff");
anElement.setMockElementSize(1234, 5678);
var size = Divmod.Runtime.theRuntime.getElementSize(anElement);
self.assertIdentical(size.w, 1234);
self.assertIdentical(size.h, 5678);
});
/**
* Tests for L{Divmod.Runtime.Platform.repr}.
*/
Divmod.Test.TestUnitTest.ReprTests =
Divmod.UnitTest.TestCase.subclass('Divmod.Test.TestUnitTest.ReprTests');
Divmod.Test.TestUnitTest.ReprTests.methods(
/**
* Test that repr(undefined) and repr(null) work.
*/
function test_undefinedAndNull(self) {
var repr = Divmod.UnitTest.repr;
self.assertIdentical(repr(null), 'null');
self.assertIdentical(repr(undefined), 'undefined');
},
/**
* Test that some simple values have a reasonable repr().
*/
function test_simpleValues(self) {
var repr = Divmod.UnitTest.repr;
self.assertIdentical(repr(5), '5');
self.assertIdentical(repr('foo'), '"foo"');
self.assert(repr(['foo']).search('foo') >= 0);
});
|
:: Command execute :: | |
--[ c99shell v. 2.0 [PHP 7 Update] [25.02.2019] maintained by KaizenLouie | C99Shell Github | Generation time: 0.0171 ]-- |