')).exec('
| ')[0]);
- assertEqual('false', RegExp.escape(false));
- assertEqual('undefined', RegExp.escape());
- assertEqual('null', RegExp.escape(null));
- assertEqual('42', RegExp.escape(42));
+ this.assertEqual('false', RegExp.escape(false));
+ this.assertEqual('undefined', RegExp.escape());
+ this.assertEqual('null', RegExp.escape(null));
+ this.assertEqual('42', RegExp.escape(42));
- assertEqual('\\\\n\\\\r\\\\t', RegExp.escape('\\n\\r\\t'));
- assertEqual('\n\r\t', RegExp.escape('\n\r\t'));
- assertEqual('\\{5,2\\}', RegExp.escape('{5,2}'));
+ this.assertEqual('\\\\n\\\\r\\\\t', RegExp.escape('\\n\\r\\t'));
+ this.assertEqual('\n\r\t', RegExp.escape('\n\r\t'));
+ this.assertEqual('\\{5,2\\}', RegExp.escape('{5,2}'));
- assertEqual(
+ this.assertEqual(
'\\/\\(\\[\\.\\*\\+\\?\\^\\=\\!\\:\\$\\{\\}\\(\\)\\|\\[\\\\\\]\\\\\\\/\\\\\\\\\\]\\)\\/g',
RegExp.escape('/([.*+?^=!:${}()|[\\]\\/\\\\])/g')
);
- }},
+ },
- testBrowserDetection: function() {with(this) {
+ testBrowserDetection: function() {
var results = $H(Prototype.Browser).map(function(engine){
return engine;
}).partition(function(engine){
@@ -482,76 +482,76 @@
});
var trues = results[0], falses = results[1];
- info('User agent string is: ' + navigator.userAgent);
+ this.info('User agent string is: ' + navigator.userAgent);
- assert(trues.size() == 0 || trues.size() == 1,
+ this.assert(trues.size() == 0 || trues.size() == 1,
'There should be only one or no browser detected.');
// we should have definite trues or falses here
- trues.each(function(result){
- assert(result[1] === true);
- });
- falses.each(function(result){
- assert(result[1] === false);
- });
+ trues.each(function(result) {
+ this.assert(result[1] === true);
+ }, this);
+ falses.each(function(result) {
+ this.assert(result[1] === false);
+ }, this);
if(navigator.userAgent.indexOf('AppleWebKit/') > -1) {
- info('Running on WebKit');
- assert(Prototype.Browser.WebKit);
+ this.info('Running on WebKit');
+ this.assert(Prototype.Browser.WebKit);
}
if(!!window.opera) {
- info('Running on Opera');
- assert(Prototype.Browser.Opera);
+ this.info('Running on Opera');
+ this.assert(Prototype.Browser.Opera);
}
if(!!(window.attachEvent && !window.opera)) {
- info('Running on IE');
- assert(Prototype.Browser.IE);
+ this.info('Running on IE');
+ this.assert(Prototype.Browser.IE);
}
if(navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1) {
- info('Running on Gecko');
- assert(Prototype.Browser.Gecko);
+ this.info('Running on Gecko');
+ this.assert(Prototype.Browser.Gecko);
}
- }},
+ },
- testClassCreate: function() { with(this) {
- assert(Object.isFunction(Animal), 'Animal is not a constructor');
- assertEnumEqual([Cat, Mouse, Dog, Ox], Animal.subclasses);
+ testClassCreate: function() {
+ this.assert(Object.isFunction(Animal), 'Animal is not a constructor');
+ this.assertEnumEqual([Cat, Mouse, Dog, Ox], Animal.subclasses);
Animal.subclasses.each(function(subclass) {
- assertEqual(Animal, subclass.superclass);
- });
+ this.assertEqual(Animal, subclass.superclass);
+ }, this);
var Bird = Class.create(Animal);
- assertEqual(Bird, Animal.subclasses.last());
+ this.assertEqual(Bird, Animal.subclasses.last());
// for..in loop (for some reason) doesn't iterate over the constructor property in top-level classes
- assertEnumEqual(Object.keys(new Animal).sort(), Object.keys(new Bird).without('constructor').sort());
- }},
+ this.assertEnumEqual(Object.keys(new Animal).sort(), Object.keys(new Bird).without('constructor').sort());
+ },
- testClassInstantiation: function() { with(this) {
+ testClassInstantiation: function() {
var pet = new Animal("Nibbles");
- assertEqual("Nibbles", pet.name, "property not initialized");
- assertEqual('Nibbles: Hi!', pet.say('Hi!'));
- assertEqual(Animal, pet.constructor, "bad constructor reference");
- assertUndefined(pet.superclass);
+ this.assertEqual("Nibbles", pet.name, "property not initialized");
+ this.assertEqual('Nibbles: Hi!', pet.say('Hi!'));
+ this.assertEqual(Animal, pet.constructor, "bad constructor reference");
+ this.assertUndefined(pet.superclass);
var Empty = Class.create();
- assert('object', typeof new Empty);
- }},
+ this.assert('object', typeof new Empty);
+ },
- testInheritance: function() { with(this) {
+ testInheritance: function() {
var tom = new Cat('Tom');
- assertEqual(Cat, tom.constructor, "bad constructor reference");
- assertEqual(Animal, tom.constructor.superclass, 'bad superclass reference');
- assertEqual('Tom', tom.name);
- assertEqual('Tom: meow', tom.say('meow'));
- assertEqual('Tom: Yuk! I only eat mice.', tom.eat(new Animal));
- }},
+ this.assertEqual(Cat, tom.constructor, "bad constructor reference");
+ this.assertEqual(Animal, tom.constructor.superclass, 'bad superclass reference');
+ this.assertEqual('Tom', tom.name);
+ this.assertEqual('Tom: meow', tom.say('meow'));
+ this.assertEqual('Tom: Yuk! I only eat mice.', tom.eat(new Animal));
+ },
- testSuperclassMethodCall: function() { with(this) {
+ testSuperclassMethodCall: function() {
var tom = new Cat('Tom');
- assertEqual('Tom: Yum!', tom.eat(new Mouse));
+ this.assertEqual('Tom: Yum!', tom.eat(new Mouse));
// augment the constructor and test
var Dodo = Class.create(Animal, {
@@ -566,12 +566,12 @@
});
var gonzo = new Dodo('Gonzo');
- assertEqual('Gonzo', gonzo.name);
- assert(gonzo.extinct, 'Dodo birds should be extinct');
- assertEqual("Gonzo: hello honk honk", gonzo.say("hello"));
- }},
+ this.assertEqual('Gonzo', gonzo.name);
+ this.assert(gonzo.extinct, 'Dodo birds should be extinct');
+ this.assertEqual("Gonzo: hello honk honk", gonzo.say("hello"));
+ },
- testClassAddMethods: function() { with(this) {
+ testClassAddMethods: function() {
var tom = new Cat('Tom');
var jerry = new Mouse('Jerry');
@@ -590,12 +590,12 @@
}
});
- assertEqual('Tom: ZZZ', tom.sleep(), "added instance method not available to subclass");
- assertEqual("Jerry: ZZZ ... no, can't sleep! Gotta steal cheese!", jerry.sleep());
- assertEqual("Jerry: (from a mousehole) Take that, Tom!", jerry.escape(tom));
+ this.assertEqual('Tom: ZZZ', tom.sleep(), "added instance method not available to subclass");
+ this.assertEqual("Jerry: ZZZ ... no, can't sleep! Gotta steal cheese!", jerry.sleep());
+ this.assertEqual("Jerry: (from a mousehole) Take that, Tom!", jerry.escape(tom));
// insure that a method has not propagated *up* the prototype chain:
- assertUndefined(tom.escape);
- assertUndefined(new Animal().escape);
+ this.assertUndefined(tom.escape);
+ this.assertUndefined(new Animal().escape);
Animal.addMethods({
sleep: function() {
@@ -603,42 +603,36 @@
}
});
- assertEqual("Jerry: zZzZ ... no, can't sleep! Gotta steal cheese!", jerry.sleep());
- }},
+ this.assertEqual("Jerry: zZzZ ... no, can't sleep! Gotta steal cheese!", jerry.sleep());
+ },
- testBaseClassWithMixin: function() { with(this) {
+ testBaseClassWithMixin: function() {
var grass = new Plant('grass', 3);
- assertRespondsTo('getValue', grass);
- assertEqual('#
', grass.inspect());
- }},
+ this.assertRespondsTo('getValue', grass);
+ this.assertEqual('#', grass.inspect());
+ },
- testSubclassWithMixin: function() { with(this) {
+ testSubclassWithMixin: function() {
var snoopy = new Dog('Snoopy', 12, 'male');
- assertRespondsTo('reproduce', snoopy);
- }},
+ this.assertRespondsTo('reproduce', snoopy);
+ },
- testSubclassWithMixins: function() { with(this) {
+ testSubclassWithMixins: function() {
var cow = new Ox('cow', 400, 'female');
- assertEqual('#', cow.inspect());
- assertRespondsTo('reproduce', cow);
- assertRespondsTo('getValue', cow);
- }},
+ this.assertEqual('#', cow.inspect());
+ this.assertRespondsTo('reproduce', cow);
+ this.assertRespondsTo('getValue', cow);
+ },
- testClassWithToStringAndValueOfMethods: function() { with(this) {
- var Foo = Class.create({
- toString: function() {
- return "toString";
- },
-
- valueOf: function() {
- return "valueOf";
- }
- });
-
- assertEqual("toString", new Foo().toString());
- assertEqual("valueOf", new Foo().valueOf());
- }}
-
+ testClassWithToStringAndValueOfMethods: function() {
+ var Foo = Class.create({
+ toString: function() { return "toString" },
+ valueOf: function() { return "valueOf" }
+ });
+
+ this.assertEqual("toString", new Foo().toString());
+ this.assertEqual("valueOf", new Foo().valueOf());
+ }
});
// ]]>
diff --git a/test/unit/dom.html b/test/unit/dom.html
index 4a9fb83..969d9c5 100644
--- a/test/unit/dom.html
+++ b/test/unit/dom.html
@@ -447,587 +447,587 @@
var props = [];
this.properties.each(function(prop) {
if (eval(prop)) props[prop] = eval(prop);
- });
+ }, this);
return props;
}
};
new Test.Unit.Runner({
- testDollarFunction: function() { with(this) {
- assertUndefined($());
+ testDollarFunction: function() {
+ this.assertUndefined($());
- assertNull(document.getElementById('noWayThisIDExists'));
- assertNull($('noWayThisIDExists'));
+ this.assertNull(document.getElementById('noWayThisIDExists'));
+ this.assertNull($('noWayThisIDExists'));
- assertIdentical(document.getElementById('testdiv'), $('testdiv'));
- assertEnumEqual([ $('testdiv'), $('container') ], $('testdiv', 'container'));
- assertEnumEqual([ $('testdiv'), undefined, $('container') ],
+ this.assertIdentical(document.getElementById('testdiv'), $('testdiv'));
+ this.assertEnumEqual([ $('testdiv'), $('container') ], $('testdiv', 'container'));
+ this.assertEnumEqual([ $('testdiv'), undefined, $('container') ],
$('testdiv', 'noWayThisIDExists', 'container'));
var elt = $('testdiv');
- assertIdentical(elt, $(elt));
- assertRespondsTo('hide', elt);
- assertRespondsTo('childOf', elt);
- }},
+ this.assertIdentical(elt, $(elt));
+ this.assertRespondsTo('hide', elt);
+ this.assertRespondsTo('childOf', elt);
+ },
- testGetElementsByClassName: function() {with(this) {
+ testGetElementsByClassName: function() {
if (document.getElementsByClassName.toString().include('[native code]')) {
- info("browser uses native getElementsByClassName; skipping tests");
+ this.info("browser uses native getElementsByClassName; skipping tests");
return;
}
var div = $('class_names'), list = $('class_names_ul');
- assertElementsMatch(document.getElementsByClassName('A'), 'p.A', 'ul#class_names_ul.A', 'li.A.C');
+ this.assertElementsMatch(document.getElementsByClassName('A'), 'p.A', 'ul#class_names_ul.A', 'li.A.C');
if (Prototype.Browser.IE)
- assertUndefined(document.getElementById('unextended').show);
+ this.assertUndefined(document.getElementById('unextended').show);
- assertElementsMatch(div.getElementsByClassName('B'), 'ul#class_names_ul.A.B', 'div.B.C.D');
- assertElementsMatch(div.getElementsByClassName('D C B'), 'div.B.C.D');
- assertElementsMatch(div.getElementsByClassName(' D\nC\tB '), 'div.B.C.D');
- assertElementsMatch(div.getElementsByClassName($w('D C B')));
- assertElementsMatch(list.getElementsByClassName('A'), 'li.A.C');
- assertElementsMatch(list.getElementsByClassName(' A '), 'li.A.C');
- assertElementsMatch(list.getElementsByClassName('C A'), 'li.A.C');
- assertElementsMatch(list.getElementsByClassName("C\nA "), 'li.A.C');
- assertElementsMatch(list.getElementsByClassName('B'));
- assertElementsMatch(list.getElementsByClassName('1'), 'li.1');
- assertElementsMatch(list.getElementsByClassName([1]), 'li.1');
- assertElementsMatch(list.getElementsByClassName(['1 junk']));
- assertElementsMatch(list.getElementsByClassName(''));
- assertElementsMatch(list.getElementsByClassName(' '));
- assertElementsMatch(list.getElementsByClassName(['']));
- assertElementsMatch(list.getElementsByClassName([' ', '']));
- assertElementsMatch(list.getElementsByClassName({}));
+ this.assertElementsMatch(div.getElementsByClassName('B'), 'ul#class_names_ul.A.B', 'div.B.C.D');
+ this.assertElementsMatch(div.getElementsByClassName('D C B'), 'div.B.C.D');
+ this.assertElementsMatch(div.getElementsByClassName(' D\nC\tB '), 'div.B.C.D');
+ this.assertElementsMatch(div.getElementsByClassName($w('D C B')));
+ this.assertElementsMatch(list.getElementsByClassName('A'), 'li.A.C');
+ this.assertElementsMatch(list.getElementsByClassName(' A '), 'li.A.C');
+ this.assertElementsMatch(list.getElementsByClassName('C A'), 'li.A.C');
+ this.assertElementsMatch(list.getElementsByClassName("C\nA "), 'li.A.C');
+ this.assertElementsMatch(list.getElementsByClassName('B'));
+ this.assertElementsMatch(list.getElementsByClassName('1'), 'li.1');
+ this.assertElementsMatch(list.getElementsByClassName([1]), 'li.1');
+ this.assertElementsMatch(list.getElementsByClassName(['1 junk']));
+ this.assertElementsMatch(list.getElementsByClassName(''));
+ this.assertElementsMatch(list.getElementsByClassName(' '));
+ this.assertElementsMatch(list.getElementsByClassName(['']));
+ this.assertElementsMatch(list.getElementsByClassName([' ', '']));
+ this.assertElementsMatch(list.getElementsByClassName({}));
// those lookups shouldn't have extended all nodes in document
- if (Prototype.Browser.IE) assertUndefined(document.getElementById('unextended')['show']);
- }},
+ if (Prototype.Browser.IE) this.assertUndefined(document.getElementById('unextended')['show']);
+ },
- testElementInsertWithHTML: function() {with(this) {
+ testElementInsertWithHTML: function() {
Element.insert('insertions-main', {before:'before text
more testing
'});
- assert(getInnerHTML('insertions-container').startsWith('before text
more testing
'));
+ this.assert(getInnerHTML('insertions-container').startsWith('before text
more testing
'));
Element.insert('insertions-main', {after:'after text
more testing
'});
- assert(getInnerHTML('insertions-container').endsWith('after text
more testing
'));
+ this.assert(getInnerHTML('insertions-container').endsWith('after text
more testing
'));
Element.insert('insertions-main', {top:'top text.
more testing
'});
- assert(getInnerHTML('insertions-main').startsWith('top text.
more testing
'));
+ this.assert(getInnerHTML('insertions-main').startsWith('top text.
more testing
'));
Element.insert('insertions-main', {bottom:'bottom text.
more testing
'});
- assert(getInnerHTML('insertions-main').endsWith('bottom text.
more testing
'));
- }},
+ this.assert(getInnerHTML('insertions-main').endsWith('bottom text.
more testing
'));
+ },
- testElementInsertWithDOMNode: function() {with(this) {
+ testElementInsertWithDOMNode: function() {
Element.insert('insertions-node-main', {before: createParagraph('node before')});
- assert(getInnerHTML('insertions-node-container').startsWith('node before
'));
+ this.assert(getInnerHTML('insertions-node-container').startsWith('node before
'));
Element.insert('insertions-node-main', {after: createParagraph('node after')});
- assert(getInnerHTML('insertions-node-container').endsWith('node after
'));
+ this.assert(getInnerHTML('insertions-node-container').endsWith('node after
'));
Element.insert('insertions-node-main', {top:createParagraph('node top')});
- assert(getInnerHTML('insertions-node-main').startsWith('node top
'));
+ this.assert(getInnerHTML('insertions-node-main').startsWith('node top
'));
Element.insert('insertions-node-main', {bottom:createParagraph('node bottom')});
- assert(getInnerHTML('insertions-node-main').endsWith('node bottom
'));
- assertEqual($('insertions-node-main'), $('insertions-node-main').insert(document.createElement('p')));
- }},
+ this.assert(getInnerHTML('insertions-node-main').endsWith('node bottom
'));
+ this.assertEqual($('insertions-node-main'), $('insertions-node-main').insert(document.createElement('p')));
+ },
- testElementInsertWithToElementMethod: function() {with(this) {
+ testElementInsertWithToElementMethod: function() {
Element.insert('insertions-node-main', {toElement: createParagraph.curry('toElement') });
- assert(getInnerHTML('insertions-node-main').endsWith('toelement
'));
+ this.assert(getInnerHTML('insertions-node-main').endsWith('toelement
'));
Element.insert('insertions-node-main', {bottom: {toElement: createParagraph.curry('bottom toElement') }});
- assert(getInnerHTML('insertions-node-main').endsWith('bottom toelement
'));
- }},
+ this.assert(getInnerHTML('insertions-node-main').endsWith('bottom toelement
'));
+ },
- testElementInsertWithToHTMLMethod: function() {with(this) {
+ testElementInsertWithToHTMLMethod: function() {
Element.insert('insertions-node-main', {toHTML: function() { return 'toHTML
'} });
- assert(getInnerHTML('insertions-node-main').endsWith('tohtml
'));
+ this.assert(getInnerHTML('insertions-node-main').endsWith('tohtml
'));
Element.insert('insertions-node-main', {bottom: {toHTML: function() { return 'bottom toHTML
'} }});
- assert(getInnerHTML('insertions-node-main').endsWith('bottom tohtml
'));
- }},
+ this.assert(getInnerHTML('insertions-node-main').endsWith('bottom tohtml
'));
+ },
- testElementInsertWithNonString: function() {with(this) {
+ testElementInsertWithNonString: function() {
Element.insert('insertions-main', {bottom:3});
- assert(getInnerHTML('insertions-main').endsWith('3'));
- }},
+ this.assert(getInnerHTML('insertions-main').endsWith('3'));
+ },
- testElementInsertInTables: function() {with(this) {
+ testElementInsertInTables: function() {
Element.insert('second_row', {after:'| Third Row |
'});
- assert($('second_row').descendantOf('table'));
+ this.assert($('second_row').descendantOf('table'));
$('a_cell').insert({top:'hello world'});
- assert($('a_cell').innerHTML.startsWith('hello world'));
+ this.assert($('a_cell').innerHTML.startsWith('hello world'));
$('a_cell').insert({after:'hi planet | '});
- assertEqual('hi planet', $('a_cell').next().innerHTML);
+ this.assertEqual('hi planet', $('a_cell').next().innerHTML);
$('table_for_insertions').insert('| a cell! |
');
- assert($('table_for_insertions').innerHTML.gsub('\r\n', '').toLowerCase().include('| a cell! |
'));
+ this.assert($('table_for_insertions').innerHTML.gsub('\r\n', '').toLowerCase().include('| a cell! |
'));
$('row_1').insert({after:'|
|
| last |
'});
- assertEqual('last', $A($('table_for_row_insertions').getElementsByTagName('tr')).last().lastChild.innerHTML);
- }},
+ this.assertEqual('last', $A($('table_for_row_insertions').getElementsByTagName('tr')).last().lastChild.innerHTML);
+ },
- testElementInsertInSelect: function() {with(this) {
+ testElementInsertInSelect: function() {
var selectTop = $('select_for_insert_top'), selectBottom = $('select_for_insert_bottom');
selectBottom.insert('');
- assertEqual('option 45', selectBottom.getValue());
+ this.assertEqual('option 45', selectBottom.getValue());
selectTop.insert({top:''});
- assertEqual(4, selectTop.options.length);
- }},
+ this.assertEqual(4, selectTop.options.length);
+ },
- testElementMethodInsert: function() {with(this) {
+ testElementMethodInsert: function() {
$('element-insertions-main').insert({before:'some text before'});
- assert(getInnerHTML('element-insertions-container').startsWith('some text before'));
+ this.assert(getInnerHTML('element-insertions-container').startsWith('some text before'));
$('element-insertions-main').insert({after:'some text after'});
- assert(getInnerHTML('element-insertions-container').endsWith('some text after'));
+ this.assert(getInnerHTML('element-insertions-container').endsWith('some text after'));
$('element-insertions-main').insert({top:'some text top'});
- assert(getInnerHTML('element-insertions-main').startsWith('some text top'));
+ this.assert(getInnerHTML('element-insertions-main').startsWith('some text top'));
$('element-insertions-main').insert({bottom:'some text bottom'});
- assert(getInnerHTML('element-insertions-main').endsWith('some text bottom'));
+ this.assert(getInnerHTML('element-insertions-main').endsWith('some text bottom'));
$('element-insertions-main').insert('some more text at the bottom');
- assert(getInnerHTML('element-insertions-main').endsWith('some more text at the bottom'));
+ this.assert(getInnerHTML('element-insertions-main').endsWith('some more text at the bottom'));
$('element-insertions-main').insert({TOP:'some text uppercase top'});
- assert(getInnerHTML('element-insertions-main').startsWith('some text uppercase top'));
+ this.assert(getInnerHTML('element-insertions-main').startsWith('some text uppercase top'));
$('element-insertions-multiple-main').insert({
top:'1', bottom:2, before: new Element('p').update('3'), after:'4'
});
- assert(getInnerHTML('element-insertions-multiple-main').startsWith('1'));
- assert(getInnerHTML('element-insertions-multiple-main').endsWith('2'));
- assert(getInnerHTML('element-insertions-multiple-container').startsWith('3
'));
- assert(getInnerHTML('element-insertions-multiple-container').endsWith('4'));
+ this.assert(getInnerHTML('element-insertions-multiple-main').startsWith('1'));
+ this.assert(getInnerHTML('element-insertions-multiple-main').endsWith('2'));
+ this.assert(getInnerHTML('element-insertions-multiple-container').startsWith('3
'));
+ this.assert(getInnerHTML('element-insertions-multiple-container').endsWith('4'));
$('element-insertions-main').update('test');
$('element-insertions-main').insert(null);
$('element-insertions-main').insert({bottom:null});
- assertEqual('test', getInnerHTML('element-insertions-main'));
+ this.assertEqual('test', getInnerHTML('element-insertions-main'));
$('element-insertions-main').insert(1337);
- assertEqual('test1337', getInnerHTML('element-insertions-main'));
- }},
+ this.assertEqual('test1337', getInnerHTML('element-insertions-main'));
+ },
- testNewElementInsert: function() {with(this) {
+ testNewElementInsert: function() {
var container = new Element('div');
element = new Element('div');
container.insert(element);
element.insert({ before: 'a paragraph
' });
- assertEqual('a paragraph
', getInnerHTML(container));
+ this.assertEqual('a paragraph
', getInnerHTML(container));
element.insert({ after: 'some text' });
- assertEqual('a paragraph
some text', getInnerHTML(container));
+ this.assertEqual('a paragraph
some text', getInnerHTML(container));
element.insert({ top: 'a paragraph
' });
- assertEqual('a paragraph
', getInnerHTML(element));
+ this.assertEqual('a paragraph
', getInnerHTML(element));
element.insert('some text');
- assertEqual('a paragraph
some text', getInnerHTML(element));
- }},
+ this.assertEqual('a paragraph
some text', getInnerHTML(element));
+ },
- testInsertionBackwardsCompatibility: function() {with(this) {
+ testInsertionBackwardsCompatibility: function() {
new Insertion.Before('element-insertions-main', 'some backward-compatibility testing before');
- assert(getInnerHTML('element-insertions-container').include('some backward-compatibility testing before'));
+ this.assert(getInnerHTML('element-insertions-container').include('some backward-compatibility testing before'));
new Insertion.After('element-insertions-main', 'some backward-compatibility testing after');
- assert(getInnerHTML('element-insertions-container').include('some backward-compatibility testing after'));
+ this.assert(getInnerHTML('element-insertions-container').include('some backward-compatibility testing after'));
new Insertion.Top('element-insertions-main', 'some backward-compatibility testing top');
- assert(getInnerHTML('element-insertions-main').startsWith('some backward-compatibility testing top'));
+ this.assert(getInnerHTML('element-insertions-main').startsWith('some backward-compatibility testing top'));
new Insertion.Bottom('element-insertions-main', 'some backward-compatibility testing bottom');
- assert(getInnerHTML('element-insertions-main').endsWith('some backward-compatibility testing bottom'));
- }},
+ this.assert(getInnerHTML('element-insertions-main').endsWith('some backward-compatibility testing bottom'));
+ },
- testElementWrap: function() {with(this) {
+ testElementWrap: function() {
var element = $('wrap'), parent = document.createElement('div');
element.wrap();
- assert(getInnerHTML('wrap-container').startsWith('\ntestVar="hello!";\n');
- assertEqual('hello from div!',$('testdiv').innerHTML);
- wait(100,function(){
- assertEqual('hello!',testVar);
+ this.assertEqual('hello from div!',$('testdiv').innerHTML);
+ this.wait(100,function(){
+ this.assertEqual('hello!',testVar);
Element.update('testdiv','another hello from div!\n
diff --git a/test/unit/enumerable.html b/test/unit/enumerable.html
index c2e29e4..71e88af 100644
--- a/test/unit/enumerable.html
+++ b/test/unit/enumerable.html
@@ -66,261 +66,261 @@
}
new Test.Unit.Runner({
- testEachBreak: function() {with(this) {
+ testEachBreak: function() {
var result = 0;
Fixtures.Basic.each(function(value) {
if ((result = value) == 2) throw $break;
});
- assertEqual(2, result);
- }},
+ this.assertEqual(2, result);
+ },
- testEachReturnActsAsContinue: function() {with(this) {
+ testEachReturnActsAsContinue: function() {
var results = [];
Fixtures.Basic.each(function(value) {
if (value == 2) return;
results.push(value);
});
- assertEqual('1, 3', results.join(', '));
- }},
+ this.assertEqual('1, 3', results.join(', '));
+ },
- testEachChaining: function() {with(this) {
- assertEqual(Fixtures.Primes, Fixtures.Primes.each(Prototype.emptyFunction));
- assertEqual(3, Fixtures.Basic.each(Prototype.emptyFunction).length);
- }},
+ testEachChaining: function() {
+ this.assertEqual(Fixtures.Primes, Fixtures.Primes.each(Prototype.emptyFunction));
+ this.assertEqual(3, Fixtures.Basic.each(Prototype.emptyFunction).length);
+ },
- testEnumContext: function() {with(this) {
+ testEnumContext: function() {
var results = [];
Fixtures.Basic.each(function(value) {
results.push(value * this.i);
}, { i: 2 });
- assertEqual('2 4 6', results.join(' '));
+ this.assertEqual('2 4 6', results.join(' '));
- assert(Fixtures.Basic.all(function(value){
+ this.assert(Fixtures.Basic.all(function(value){
return value >= this.min && value <= this.max;
}, { min: 1, max: 3 }));
- assert(!Fixtures.Basic.all(function(value){
+ this.assert(!Fixtures.Basic.all(function(value){
return value >= this.min && value <= this.max;
}));
- assert(Fixtures.Basic.any(function(value){
+ this.assert(Fixtures.Basic.any(function(value){
return value == this.target_value;
}, { target_value: 2 }));
- }},
+ },
- testAny: function() {with(this) {
- assert(!([].any()));
+ testAny: function() {
+ this.assert(!([].any()));
- assert([true, true, true].any());
- assert([true, false, false].any());
- assert(![false, false, false].any());
+ this.assert([true, true, true].any());
+ this.assert([true, false, false].any());
+ this.assert(![false, false, false].any());
- assert(Fixtures.Basic.any(function(value) {
+ this.assert(Fixtures.Basic.any(function(value) {
return value > 2;
}));
- assert(!Fixtures.Basic.any(function(value) {
+ this.assert(!Fixtures.Basic.any(function(value) {
return value > 5;
}));
- }},
+ },
- testAll: function() {with(this) {
- assert([].all());
+ testAll: function() {
+ this.assert([].all());
- assert([true, true, true].all());
- assert(![true, false, false].all());
- assert(![false, false, false].all());
+ this.assert([true, true, true].all());
+ this.assert(![true, false, false].all());
+ this.assert(![false, false, false].all());
- assert(Fixtures.Basic.all(function(value) {
+ this.assert(Fixtures.Basic.all(function(value) {
return value > 0;
}));
- assert(!Fixtures.Basic.all(function(value) {
+ this.assert(!Fixtures.Basic.all(function(value) {
return value > 1;
}));
- }},
+ },
- testCollect: function() {with(this) {
- assertEqual(Fixtures.Nicknames.join(', '),
+ testCollect: function() {
+ this.assertEqual(Fixtures.Nicknames.join(', '),
Fixtures.People.collect(function(person) {
return person.nickname;
}).join(", "));
- assertEqual(26, Fixtures.Primes.map().length);
- }},
+ this.assertEqual(26, Fixtures.Primes.map().length);
+ },
- testDetect: function() {with(this) {
- assertEqual('Marcel Molina Jr.',
+ testDetect: function() {
+ this.assertEqual('Marcel Molina Jr.',
Fixtures.People.detect(function(person) {
return person.nickname.match(/no/);
}).name);
- }},
+ },
- testEachSlice: function() {with(this) {
- assertEnumEqual([], [].eachSlice(2));
- assertEqual(1, [1].eachSlice(1).length);
- assertEnumEqual([1], [1].eachSlice(1)[0]);
- assertEqual(2, Fixtures.Basic.eachSlice(2).length);
- assertEnumEqual(
+ testEachSlice: function() {
+ this.assertEnumEqual([], [].eachSlice(2));
+ this.assertEqual(1, [1].eachSlice(1).length);
+ this.assertEnumEqual([1], [1].eachSlice(1)[0]);
+ this.assertEqual(2, Fixtures.Basic.eachSlice(2).length);
+ this.assertEnumEqual(
[3, 2, 1, 11, 7, 5, 19, 17, 13, 31, 29, 23, 43, 41, 37, 59, 53, 47, 71, 67, 61, 83, 79, 73, 97, 89],
Fixtures.Primes.eachSlice( 3, function(slice){ return slice.reverse() }).flatten()
);
- assertEnumEqual(Fixtures.Basic, Fixtures.Basic.eachSlice(-10));
- assertEnumEqual(Fixtures.Basic, Fixtures.Basic.eachSlice(0));
- assertNotIdentical(Fixtures.Basic, Fixtures.Basic.eachSlice(0));
- }},
+ this.assertEnumEqual(Fixtures.Basic, Fixtures.Basic.eachSlice(-10));
+ this.assertEnumEqual(Fixtures.Basic, Fixtures.Basic.eachSlice(0));
+ this.assertNotIdentical(Fixtures.Basic, Fixtures.Basic.eachSlice(0));
+ },
- testEachWithIndex: function() {with(this) {
+ testEachWithIndex: function() {
var nicknames = [], indexes = [];
Fixtures.People.each(function(person, index) {
nicknames.push(person.nickname);
indexes.push(index);
});
- assertEqual(Fixtures.Nicknames.join(', '),
+ this.assertEqual(Fixtures.Nicknames.join(', '),
nicknames.join(', '));
- assertEqual('0, 1, 2, 3', indexes.join(', '));
- }},
+ this.assertEqual('0, 1, 2, 3', indexes.join(', '));
+ },
- testFindAll: function() {with(this) {
- assertEqual(Fixtures.Primes.join(', '),
+ testFindAll: function() {
+ this.assertEqual(Fixtures.Primes.join(', '),
Fixtures.Z.findAll(prime).join(', '));
- }},
+ },
- testGrep: function() {with(this) {
- assertEqual('noradio, htonl',
+ testGrep: function() {
+ this.assertEqual('noradio, htonl',
Fixtures.Nicknames.grep(/o/).join(", "));
- assertEqual('NORADIO, HTONL',
+ this.assertEqual('NORADIO, HTONL',
Fixtures.Nicknames.grep(/o/, function(nickname) {
return nickname.toUpperCase();
}).join(", "))
- assertEnumEqual($('grepHeader', 'grepCell'),
+ this.assertEnumEqual($('grepHeader', 'grepCell'),
$('grepTable', 'grepTBody', 'grepRow', 'grepHeader', 'grepCell').grep(new Selector('.cell')));
- }},
+ },
- testInclude: function() {with(this) {
- assert(Fixtures.Nicknames.include('sam-'));
- assert(Fixtures.Nicknames.include('noradio'));
- assert(!Fixtures.Nicknames.include('gmosx'));
- assert(Fixtures.Basic.include(2));
- assert(Fixtures.Basic.include('2'));
- assert(!Fixtures.Basic.include('4'));
- }},
+ testInclude: function() {
+ this.assert(Fixtures.Nicknames.include('sam-'));
+ this.assert(Fixtures.Nicknames.include('noradio'));
+ this.assert(!Fixtures.Nicknames.include('gmosx'));
+ this.assert(Fixtures.Basic.include(2));
+ this.assert(Fixtures.Basic.include('2'));
+ this.assert(!Fixtures.Basic.include('4'));
+ },
- testInGroupsOf: function() { with(this) {
- assertEnumEqual([], [].inGroupsOf(3));
+ testInGroupsOf: function() {
+ this.assertEnumEqual([], [].inGroupsOf(3));
var arr = [1, 2, 3, 4, 5, 6].inGroupsOf(3);
- assertEqual(2, arr.length);
- assertEnumEqual([1, 2, 3], arr[0]);
- assertEnumEqual([4, 5, 6], arr[1]);
+ this.assertEqual(2, arr.length);
+ this.assertEnumEqual([1, 2, 3], arr[0]);
+ this.assertEnumEqual([4, 5, 6], arr[1]);
arr = [1, 2, 3, 4, 5, 6].inGroupsOf(4);
- assertEqual(2, arr.length);
- assertEnumEqual([1, 2, 3, 4], arr[0]);
- assertEnumEqual([5, 6, null, null], arr[1]);
+ this.assertEqual(2, arr.length);
+ this.assertEnumEqual([1, 2, 3, 4], arr[0]);
+ this.assertEnumEqual([5, 6, null, null], arr[1]);
var basic = Fixtures.Basic
arr = basic.inGroupsOf(4,'x');
- assertEqual(1, arr.length);
- assertEnumEqual([1, 2, 3, 'x'], arr[0]);
+ this.assertEqual(1, arr.length);
+ this.assertEnumEqual([1, 2, 3, 'x'], arr[0]);
- assertEnumEqual([1,2,3,'a'], basic.inGroupsOf(2, 'a').flatten());
+ this.assertEnumEqual([1,2,3,'a'], basic.inGroupsOf(2, 'a').flatten());
arr = basic.inGroupsOf(5, '');
- assertEqual(1, arr.length);
- assertEnumEqual([1, 2, 3, '', ''], arr[0]);
+ this.assertEqual(1, arr.length);
+ this.assertEnumEqual([1, 2, 3, '', ''], arr[0]);
- assertEnumEqual([1,2,3,0], basic.inGroupsOf(2, 0).flatten());
- assertEnumEqual([1,2,3,false], basic.inGroupsOf(2, false).flatten());
- }},
+ this.assertEnumEqual([1,2,3,0], basic.inGroupsOf(2, 0).flatten());
+ this.assertEnumEqual([1,2,3,false], basic.inGroupsOf(2, false).flatten());
+ },
- testInject: function() {with(this) {
- assertEqual(1061,
+ testInject: function() {
+ this.assertEqual(1061,
Fixtures.Primes.inject(0, function(sum, value) {
return sum + value;
}));
- }},
+ },
- testInvoke: function() {with(this) {
+ testInvoke: function() {
var result = [[2, 1, 3], [6, 5, 4]].invoke('sort');
- assertEqual(2, result.length);
- assertEqual('1, 2, 3', result[0].join(', '));
- assertEqual('4, 5, 6', result[1].join(', '));
+ this.assertEqual(2, result.length);
+ this.assertEqual('1, 2, 3', result[0].join(', '));
+ this.assertEqual('4, 5, 6', result[1].join(', '));
result = result.invoke('invoke', 'toString', 2);
- assertEqual('1, 10, 11', result[0].join(', '));
- assertEqual('100, 101, 110', result[1].join(', '));
- }},
+ this.assertEqual('1, 10, 11', result[0].join(', '));
+ this.assertEqual('100, 101, 110', result[1].join(', '));
+ },
- testMax: function() {with(this) {
- assertEqual(100, Fixtures.Z.max());
- assertEqual(97, Fixtures.Primes.max());
- assertEqual(2, [ -9, -8, -7, -6, -4, -3, -2, 0, -1, 2 ].max());
- assertEqual('sam-', Fixtures.Nicknames.max()); // ?s > ?U
- }},
+ testMax: function() {
+ this.assertEqual(100, Fixtures.Z.max());
+ this.assertEqual(97, Fixtures.Primes.max());
+ this.assertEqual(2, [ -9, -8, -7, -6, -4, -3, -2, 0, -1, 2 ].max());
+ this.assertEqual('sam-', Fixtures.Nicknames.max()); // ?s > ?U
+ },
- testMin: function() {with(this) {
- assertEqual(1, Fixtures.Z.min());
- assertEqual(0, [ 1, 2, 3, 4, 5, 6, 7, 8, 0, 9 ].min());
- assertEqual('Ulysses', Fixtures.Nicknames.min()); // ?U < ?h
- }},
+ testMin: function() {
+ this.assertEqual(1, Fixtures.Z.min());
+ this.assertEqual(0, [ 1, 2, 3, 4, 5, 6, 7, 8, 0, 9 ].min());
+ this.assertEqual('Ulysses', Fixtures.Nicknames.min()); // ?U < ?h
+ },
- testPartition: function() {with(this) {
+ testPartition: function() {
var result = Fixtures.People.partition(function(person) {
return person.name.length < 15;
}).invoke('pluck', 'nickname');
- assertEqual(2, result.length);
- assertEqual('sam-, htonl', result[0].join(', '));
- assertEqual('noradio, Ulysses', result[1].join(', '));
- }},
+ this.assertEqual(2, result.length);
+ this.assertEqual('sam-, htonl', result[0].join(', '));
+ this.assertEqual('noradio, Ulysses', result[1].join(', '));
+ },
- testPluck: function() {with(this) {
- assertEqual(Fixtures.Nicknames.join(', '),
+ testPluck: function() {
+ this.assertEqual(Fixtures.Nicknames.join(', '),
Fixtures.People.pluck('nickname').join(', '));
- }},
+ },
- testReject: function() {with(this) {
- assertEqual(0,
+ testReject: function() {
+ this.assertEqual(0,
Fixtures.Nicknames.reject(Prototype.K).length);
- assertEqual('sam-, noradio, htonl',
+ this.assertEqual('sam-, noradio, htonl',
Fixtures.Nicknames.reject(function(nickname) {
return nickname != nickname.toLowerCase();
}).join(', '));
- }},
+ },
- testSortBy: function() {with(this) {
- assertEqual('htonl, noradio, sam-, Ulysses',
+ testSortBy: function() {
+ this.assertEqual('htonl, noradio, sam-, Ulysses',
Fixtures.People.sortBy(function(value) {
return value.nickname.toLowerCase();
}).pluck('nickname').join(', '));
- }},
+ },
- testToArray: function() {with(this) {
+ testToArray: function() {
var result = Fixtures.People.toArray();
- assert(result != Fixtures.People); // they're different objects...
- assertEqual(Fixtures.Nicknames.join(', '),
+ this.assert(result != Fixtures.People); // they're different objects...
+ this.assertEqual(Fixtures.Nicknames.join(', '),
result.pluck('nickname').join(', ')); // but the values are the same
- }},
+ },
- testZip: function() {with(this) {
+ testZip: function() {
var result = [1, 2, 3].zip([4, 5, 6], [7, 8, 9]);
- assertEqual('[[1, 4, 7], [2, 5, 8], [3, 6, 9]]', result.inspect());
+ this.assertEqual('[[1, 4, 7], [2, 5, 8], [3, 6, 9]]', result.inspect());
result = [1, 2, 3].zip([4, 5, 6], [7, 8, 9], function(array) { return array.reverse() });
- assertEqual('[[7, 4, 1], [8, 5, 2], [9, 6, 3]]', result.inspect());
- }},
+ this.assertEqual('[[7, 4, 1], [8, 5, 2], [9, 6, 3]]', result.inspect());
+ },
- testSize: function() {with(this) {
- assertEqual(4, Fixtures.People.size());
- assertEqual(4, Fixtures.Nicknames.size());
- assertEqual(26, Fixtures.Primes.size());
- assertEqual(0, [].size());
- }}
+ testSize: function() {
+ this.assertEqual(4, Fixtures.People.size());
+ this.assertEqual(4, Fixtures.Nicknames.size());
+ this.assertEqual(26, Fixtures.Primes.size());
+ this.assertEqual(0, [].size());
+ }
});
// ]]>
diff --git a/test/unit/event.html b/test/unit/event.html
index 7d4f15a..17552f9 100644
--- a/test/unit/event.html
+++ b/test/unit/event.html
@@ -37,47 +37,47 @@
new Test.Unit.Runner({
// test firing an event and observing it on the element it's fired from
- testCustomEventFiring: function() { with(this) {
+ testCustomEventFiring: function() {
var span = $("span"), fired = false, observer = function(event) {
- assertEqual(span, event.element());
- assertEqual(1, event.memo.index);
+ this.assertEqual(span, event.element());
+ this.assertEqual(1, event.memo.index);
fired = true;
- }
+ }.bind(this);
span.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened", { index: 1 });
- assert(fired);
+ this.assert(fired);
fired = false;
span.fire("test:somethingElseHappened");
- assert(!fired);
+ this.assert(!fired);
span.stopObserving("test:somethingHappened", observer);
span.fire("test:somethingHappened");
- assert(!fired);
- }},
+ this.assert(!fired);
+ },
// test firing an event and observing it on a containing element
- testCustomEventBubbling: function() { with(this) {
+ testCustomEventBubbling: function() {
var span = $("span"), outer = $("outer"), fired = false, observer = function(event) {
- assertEqual(span, event.element());
+ this.assertEqual(span, event.element());
fired = true;
- };
+ }.bind(this);
outer.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened");
- assert(fired);
+ this.assert(fired);
fired = false;
span.fire("test:somethingElseHappened");
- assert(!fired);
+ this.assert(!fired);
outer.stopObserving("test:somethingHappened", observer);
span.fire("test:somethingHappened");
- assert(!fired);
- }},
+ this.assert(!fired);
+ },
- testCustomEventCanceling: function() { with(this) {
+ testCustomEventCanceling: function() {
var span = $("span"), outer = $("outer"), inner = $("inner");
var fired = false, stopped = false;
@@ -93,161 +93,161 @@
inner.observe("test:somethingHappened", innerObserver);
outer.observe("test:somethingHappened", outerObserver);
span.fire("test:somethingHappened");
- assert(stopped);
- assert(!fired);
+ this.assert(stopped);
+ this.assert(!fired);
fired = stopped = false;
inner.stopObserving("test:somethingHappened", innerObserver);
span.fire("test:somethingHappened");
- assert(!stopped);
- assert(fired);
+ this.assert(!stopped);
+ this.assert(fired);
outer.stopObserving("test:somethingHappened", outerObserver);
- }},
+ },
- testEventObjectIsExtended: function() { with(this) {
+ testEventObjectIsExtended: function() {
var span = $("span"), event, observedEvent, observer = function(e) { observedEvent = e };
span.observe("test:somethingHappened", observer);
event = span.fire("test:somethingHappened");
- assertEqual(event, observedEvent);
- assertEqual(Event.Methods.stop.methodize(), event.stop);
+ this.assertEqual(event, observedEvent);
+ this.assertEqual(Event.Methods.stop.methodize(), event.stop);
span.stopObserving("test:somethingHappened", observer);
event = span.fire("test:somethingHappenedButNoOneIsListening");
- assertEqual(Event.Methods.stop.methodize(), event.stop);
- }},
+ this.assertEqual(Event.Methods.stop.methodize(), event.stop);
+ },
- testEventObserversAreBoundToTheObservedElement: function() { with(this) {
+ testEventObserversAreBoundToTheObservedElement: function() {
var span = $("span"), target, observer = function() { target = this };
span.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened");
span.stopObserving("test:somethingHappened", observer);
- assertEqual(span, target);
+ this.assertEqual(span, target);
target = null;
var outer = $("outer");
outer.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened");
outer.stopObserving("test:somethingHappened", observer);
- assertEqual(outer, target);
- }},
+ this.assertEqual(outer, target);
+ },
- testMultipleCustomEventObserversWithTheSameHandler: function() { with(this) {
+ testMultipleCustomEventObserversWithTheSameHandler: function() {
var span = $("span"), count = 0, observer = function() { count++ };
span.observe("test:somethingHappened", observer);
span.observe("test:somethingElseHappened", observer);
span.fire("test:somethingHappened");
- assertEqual(1, count);
+ this.assertEqual(1, count);
span.fire("test:somethingElseHappened");
- assertEqual(2, count);
- }},
+ this.assertEqual(2, count);
+ },
- testStopObservingWithoutArguments: function() { with(this) {
+ testStopObservingWithoutArguments: function() {
var span = $("span"), count = 0, observer = function() { count++ };
span.observe("test:somethingHappened", observer);
span.observe("test:somethingElseHappened", observer);
span.stopObserving();
span.fire("test:somethingHappened");
- assertEqual(0, count);
+ this.assertEqual(0, count);
span.fire("test:somethingElseHappened");
- assertEqual(0, count);
- }},
+ this.assertEqual(0, count);
+ },
- testStopObservingWithoutHandlerArgument: function() { with(this) {
+ testStopObservingWithoutHandlerArgument: function() {
var span = $("span"), count = 0, observer = function() { count++ };
span.observe("test:somethingHappened", observer);
span.observe("test:somethingElseHappened", observer);
span.stopObserving("test:somethingHappened");
span.fire("test:somethingHappened");
- assertEqual(0, count);
+ this.assertEqual(0, count);
span.fire("test:somethingElseHappened");
- assertEqual(1, count);
+ this.assertEqual(1, count);
span.stopObserving("test:somethingElseHappened");
span.fire("test:somethingElseHappened");
- assertEqual(1, count);
- }},
+ this.assertEqual(1, count);
+ },
- testStopObservingRemovesHandlerFromCache: function() { with(this) {
+ testStopObservingRemovesHandlerFromCache: function() {
var span = $("span"), observer = function() { }, eventID;
span.observe("test:somethingHappened", observer);
eventID = span._prototypeEventID;
- assert(Event.cache[eventID]);
- assert(Object.isArray(Event.cache[eventID]["test:somethingHappened"]));
- assertEqual(1, Event.cache[eventID]["test:somethingHappened"].length);
+ this.assert(Event.cache[eventID]);
+ this.assert(Object.isArray(Event.cache[eventID]["test:somethingHappened"]));
+ this.assertEqual(1, Event.cache[eventID]["test:somethingHappened"].length);
span.stopObserving("test:somethingHappened", observer);
- assert(Event.cache[eventID]);
- assert(Object.isArray(Event.cache[eventID]["test:somethingHappened"]));
- assertEqual(0, Event.cache[eventID]["test:somethingHappened"].length);
- }},
+ this.assert(Event.cache[eventID]);
+ this.assert(Object.isArray(Event.cache[eventID]["test:somethingHappened"]));
+ this.assertEqual(0, Event.cache[eventID]["test:somethingHappened"].length);
+ },
- testObserveAndStopObservingAreChainable: function() { with(this) {
+ testObserveAndStopObservingAreChainable: function() {
var span = $("span"), observer = function() { };
- assertEqual(span, span.observe("test:somethingHappened", observer));
- assertEqual(span, span.stopObserving("test:somethingHappened", observer));
+ this.assertEqual(span, span.observe("test:somethingHappened", observer));
+ this.assertEqual(span, span.stopObserving("test:somethingHappened", observer));
span.observe("test:somethingHappened", observer);
- assertEqual(span, span.stopObserving("test:somethingHappened"));
+ this.assertEqual(span, span.stopObserving("test:somethingHappened"));
span.observe("test:somethingHappened", observer);
- assertEqual(span, span.stopObserving());
- assertEqual(span, span.stopObserving()); // assert it again, after there are no observers
+ this.assertEqual(span, span.stopObserving());
+ this.assertEqual(span, span.stopObserving()); // assert it again, after there are no observers
span.observe("test:somethingHappened", observer);
- assertEqual(span, span.observe("test:somethingHappened", observer)); // try to reuse the same observer
+ this.assertEqual(span, span.observe("test:somethingHappened", observer)); // try to reuse the same observer
span.stopObserving();
- }},
+ },
- testDocumentLoaded: function() { with(this) {
- assert(!documentLoaded);
- assert(document.loaded);
- }},
+ testDocumentLoaded: function() {
+ this.assert(!documentLoaded);
+ this.assert(document.loaded);
+ },
- testDocumentContentLoadedEventFiresBeforeWindowLoad: function() { with(this) {
- assert(eventResults.contentLoaded, "contentLoaded");
- assert(eventResults.contentLoaded.endOfDocument, "contentLoaded.endOfDocument");
- assert(!eventResults.contentLoaded.windowLoad, "!contentLoaded.windowLoad");
- assert(eventResults.windowLoad, "windowLoad");
- assert(eventResults.windowLoad.endOfDocument, "windowLoad.endOfDocument");
- assert(eventResults.windowLoad.contentLoaded, "windowLoad.contentLoaded");
- }},
+ testDocumentContentLoadedEventFiresBeforeWindowLoad: function() {
+ this.assert(eventResults.contentLoaded, "contentLoaded");
+ this.assert(eventResults.contentLoaded.endOfDocument, "contentLoaded.endOfDocument");
+ this.assert(!eventResults.contentLoaded.windowLoad, "!contentLoaded.windowLoad");
+ this.assert(eventResults.windowLoad, "windowLoad");
+ this.assert(eventResults.windowLoad.endOfDocument, "windowLoad.endOfDocument");
+ this.assert(eventResults.windowLoad.contentLoaded, "windowLoad.contentLoaded");
+ },
- testEventStopped: function() { with(this) {
+ testEventStopped: function() {
var span = $("span"), event;
span.observe("test:somethingHappened", function() { });
event = span.fire("test:somethingHappened");
- assert(!event.stopped, "event.stopped should be false with an empty observer");
+ this.assert(!event.stopped, "event.stopped should be false with an empty observer");
span.stopObserving("test:somethingHappened");
span.observe("test:somethingHappened", function(e) { e.stop() });
event = span.fire("test:somethingHappened");
- assert(event.stopped, "event.stopped should be true for an observer that calls stop");
+ this.assert(event.stopped, "event.stopped should be true for an observer that calls stop");
span.stopObserving("test:somethingHappened");
- }},
+ },
- testEventFindElement: function() { with(this) {
+ testEventFindElement: function() {
var span = $("span"), event;
event = span.fire("test:somethingHappened");
- assertElementMatches(event.findElement(), 'span#span');
- assertElementMatches(event.findElement('span'), 'span#span');
- assertElementMatches(event.findElement('p'), 'p#inner');
- assertEqual(null, event.findElement('div.does_not_exist'));
- assertElementMatches(event.findElement('.does_not_exist, span'), 'span#span');
- }},
+ this.assertElementMatches(event.findElement(), 'span#span');
+ this.assertElementMatches(event.findElement('span'), 'span#span');
+ this.assertElementMatches(event.findElement('p'), 'p#inner');
+ this.assertEqual(null, event.findElement('div.does_not_exist'));
+ this.assertElementMatches(event.findElement('.does_not_exist, span'), 'span#span');
+ },
- testEventIDDuplication: function() { with(this) {
+ testEventIDDuplication: function() {
$('container').down().observe("test:somethingHappened", Prototype.emptyFunction);
$('container').innerHTML += $('container').innerHTML;
- assertUndefined($('container').down(1)._prototypeEventID);
- }}
+ this.assertUndefined($('container').down(1)._prototypeEventID);
+ }
});
document.observe("dom:loaded", function(event) {
diff --git a/test/unit/form.html b/test/unit/form.html
index 81c1deb..1204775 100644
--- a/test/unit/form.html
+++ b/test/unit/form.html
@@ -149,29 +149,29 @@
// Make sure to set defaults in the test forms, as some browsers override this
// with previously entered values on page reload
- setup: function(){ with(this) {
+ setup: function(){
$$('form').each(function(f){ f.reset() });
// hidden value does not reset (for some reason)
$('bigform')['tf_hidden'].value = '';
- }},
+ },
- testDollarF: function(){ with(this) {
- assertEqual("4", $F("input_enabled"));
- }},
+ testDollarF: function(){
+ this.assertEqual("4", $F("input_enabled"));
+ },
- testFormElementEventObserver: function(){ with(this) {
+ testFormElementEventObserver: function(){
var callbackCounter = 0;
var observer = new Form.Element.EventObserver('input_enabled', function(){
callbackCounter++;
});
- assertEqual(0, callbackCounter);
+ this.assertEqual(0, callbackCounter);
$('input_enabled').value = 'boo!';
observer.onElementEvent(); // can't test the event directly, simulating
- assertEqual(1, callbackCounter);
- }},
+ this.assertEqual(1, callbackCounter);
+ },
- testFormElementObserver: function(){ with(this) {
+ testFormElementObserver: function(){
var timedCounter = 0;
// First part: regular field
var observer = new Form.Element.Observer('input_enabled', 0.5, function() {
@@ -179,18 +179,18 @@
});
// Test it's unchanged yet
- assertEqual(0, timedCounter);
+ this.assertEqual(0, timedCounter);
// Test it doesn't change on first check
- wait(550, function() {
- assertEqual(0, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(0, timedCounter);
// Change, test it doesn't immediately change
$('input_enabled').value = 'yowza!';
- assertEqual(0, timedCounter);
+ this.assertEqual(0, timedCounter);
// Test it changes on next check, but not again on the next
- wait(550, function() {
- assertEqual(1, timedCounter);
- wait(550, function() {
- assertEqual(1, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(1, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(1, timedCounter);
observer.stop();
});
});
@@ -206,27 +206,27 @@
});
// Test it's unchanged yet
- assertEqual(0, timedCounter);
+ this.assertEqual(0, timedCounter);
// Test it doesn't change on first check
- wait(550, function() {
- assertEqual(0, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(0, timedCounter);
// Change, test it doesn't immediately change
// NOTE: it is important that the 3rd be re-selected, for the
// serialize form to obtain the expected value :-)
$('multiSel1_opt3').selected = true;
- assertEqual(0, timedCounter);
+ this.assertEqual(0, timedCounter);
// Test it changes on next check, but not again on the next
- wait(550, function() {
- assertEqual(1, timedCounter);
- wait(550, function() {
- assertEqual(1, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(1, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(1, timedCounter);
observer.stop();
});
});
});
- }},
+ },
- testFormObserver: function(){ with(this) {
+ testFormObserver: function(){
var timedCounter = 0;
// should work the same way was Form.Element.Observer
var observer = new Form.Observer('form', 0.5, function(form, value) {
@@ -234,69 +234,69 @@
});
// Test it's unchanged yet
- assertEqual(0, timedCounter);
+ this.assertEqual(0, timedCounter);
// Test it doesn't change on first check
- wait(550, function() {
- assertEqual(0, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(0, timedCounter);
// Change, test it doesn't immediately change
$('input_enabled').value = 'yowza!';
- assertEqual(0, timedCounter);
+ this.assertEqual(0, timedCounter);
// Test it changes on next check, but not again on the next
- wait(550, function() {
- assertEqual(1, timedCounter);
- wait(550, function() {
- assertEqual(1, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(1, timedCounter);
+ this.wait(550, function() {
+ this.assertEqual(1, timedCounter);
observer.stop();
});
});
});
- }},
+ },
- testFormEnabling: function(){ with(this) {
+ testFormEnabling: function(){
var form = $('bigform')
var input1 = $('dummy_disabled');
var input2 = $('focus_text');
- assertDisabled(input1);
- assertEnabled(input2);
+ this.assertDisabled(input1);
+ this.assertEnabled(input2);
form.disable();
- assertDisabled(input1, input2);
+ this.assertDisabled(input1, input2);
form.enable();
- assertEnabled(input1, input2);
+ this.assertEnabled(input1, input2);
input1.disable();
- assertDisabled(input1);
+ this.assertDisabled(input1);
// non-form elements:
var fieldset = $('selects_fieldset');
var fields = fieldset.immediateDescendants();
- fields.each(function(select) { assertEnabled(select) });
+ fields.each(function(select) { this.assertEnabled(select) }, this);
Form.disable(fieldset)
- fields.each(function(select) { assertDisabled(select) });
+ fields.each(function(select) { this.assertDisabled(select) }, this);
Form.enable(fieldset)
- fields.each(function(select) { assertEnabled(select) });
- }},
+ fields.each(function(select) { this.assertEnabled(select) }, this);
+ },
- testFormElementEnabling: function(){ with(this) {
+ testFormElementEnabling: function(){
var field = $('input_disabled');
field.enable();
- assertEnabled(field);
+ this.assertEnabled(field);
field.disable();
- assertDisabled(field);
+ this.assertDisabled(field);
var field = $('input_enabled');
- assertEnabled(field);
+ this.assertEnabled(field);
field.disable();
- assertDisabled(field);
+ this.assertDisabled(field);
field.enable();
- assertEnabled(field);
- }},
+ this.assertEnabled(field);
+ },
// due to the lack of a DOM hasFocus() API method,
// we're simulating things here a little bit
- testFormActivating: function(){ with(this) {
+ testFormActivating: function(){
// Firefox, IE, and Safari 2+
function getSelection(element){
try {
@@ -311,52 +311,52 @@
// Form.focusFirstElement shouldn't focus disabled elements
var element = Form.findFirstElement('bigform');
- assertEqual('submit', element.id);
+ this.assertEqual('submit', element.id);
// Test IE doesn't select text on buttons
Form.focusFirstElement('bigform');
- if(document.selection) assertEqual('', getSelection(element));
+ if(document.selection) this.assertEqual('', getSelection(element));
// Form.Element.activate shouldn't select text on buttons
element = $('focus_text');
- assertEqual('', getSelection(element));
+ this.assertEqual('', getSelection(element));
// Form.Element.activate should select text on text input elements
element.activate();
- assertEqual('Hello', getSelection(element));
+ this.assertEqual('Hello', getSelection(element));
// Form.Element.activate shouldn't raise an exception when the form or field is hidden
- assertNothingRaised(function() {
+ this.assertNothingRaised(function() {
$('form_focus_hidden').focusFirstElement();
});
- }},
+ },
- testFormGetElements: function() {with(this) {
+ testFormGetElements: function() {
var elements = Form.getElements('various'),
names = $w('tf_selectOne tf_textarea tf_checkbox tf_selectMany tf_text tf_radio tf_hidden tf_password');
- assertEnumEqual(names, elements.pluck('name'))
- }},
+ this.assertEnumEqual(names, elements.pluck('name'))
+ },
- testFormGetInputs: function() {with(this){
+ testFormGetInputs: function() {
var form = $('form');
[form.getInputs(), Form.getInputs(form)].each(function(inputs){
- assertEqual(inputs.length, 5);
- assert(inputs instanceof Array);
- assert(inputs.all(function(input) { return (input.tagName == "INPUT"); }));
- });
- }},
+ this.assertEqual(inputs.length, 5);
+ this.assert(inputs instanceof Array);
+ this.assert(inputs.all(function(input) { return (input.tagName == "INPUT"); }));
+ }, this);
+ },
- testFormFindFirstElement: function() {with(this) {
- assertEqual($('ffe_checkbox'), $('ffe').findFirstElement());
- assertEqual($('ffe_ti_submit'), $('ffe_ti').findFirstElement());
- assertEqual($('ffe_ti2_checkbox'), $('ffe_ti2').findFirstElement());
- }},
+ testFormFindFirstElement: function() {
+ this.assertEqual($('ffe_checkbox'), $('ffe').findFirstElement());
+ this.assertEqual($('ffe_ti_submit'), $('ffe_ti').findFirstElement());
+ this.assertEqual($('ffe_ti2_checkbox'), $('ffe_ti2').findFirstElement());
+ },
- testFormSerialize: function() {with(this){
+ testFormSerialize: function() {
// form is initially empty
var form = $('bigform');
var expected = { tf_selectOne:'', tf_textarea:'', tf_text:'', tf_hidden:'', tf_password:'' };
- assertHashEqual(expected, Form.serialize('various', true));
+ this.assertHashEqual(expected, Form.serialize('various', true));
// set up some stuff
form['tf_selectOne'].selectedIndex = 1;
@@ -370,48 +370,48 @@
tf_hidden:"moo%hoo&test", tf_password:'sekrit code', tf_checkbox:'on', tf_radio:'on' }
// return params
- assertHashEqual(expected, Form.serialize('various', true));
+ this.assertHashEqual(expected, Form.serialize('various', true));
// return string
- assertEnumEqual(Object.toQueryString(expected).split('&').sort(),
+ this.assertEnumEqual(Object.toQueryString(expected).split('&').sort(),
Form.serialize('various').split('&').sort());
- assertEqual('string', typeof $('form').serialize({ hash:false }));
+ this.assertEqual('string', typeof $('form').serialize({ hash:false }));
// Checks that disabled element is not included in serialized form.
$('input_enabled').enable();
- assertHashEqual({ val1:4, action:'blah', first_submit:'Commit it!' },
+ this.assertHashEqual({ val1:4, action:'blah', first_submit:'Commit it!' },
$('form').serialize(true));
// should not eat empty values for duplicate names
$('checkbox_hack').checked = false;
var data = Form.serialize('value_checks', true);
- assertEnumEqual(['', 'siamese'], data['twin']);
- assertEqual('0', data['checky']);
+ this.assertEnumEqual(['', 'siamese'], data['twin']);
+ this.assertEqual('0', data['checky']);
$('checkbox_hack').checked = true;
- assertEnumEqual($w('1 0'), Form.serialize('value_checks', true)['checky']);
+ this.assertEnumEqual($w('1 0'), Form.serialize('value_checks', true)['checky']);
// all kinds of SELECT controls
var params = Form.serialize('selects_fieldset', true);
var expected = { 'nvm[]':['One', 'Three'], evu:'', 'evm[]':['', 'Three'] };
- assertHashEqual(expected, params);
+ this.assertHashEqual(expected, params);
params = Form.serialize('selects_wrapper', true);
- assertHashEqual(Object.extend(expected, { vu:1, 'vm[]':[1, 3], nvu:'One' }), params);
+ this.assertHashEqual(Object.extend(expected, { vu:1, 'vm[]':[1, 3], nvu:'One' }), params);
// explicit submit button
- assertHashEqual({ val1:4, action:'blah', second_submit:'Delete it!' },
+ this.assertHashEqual({ val1:4, action:'blah', second_submit:'Delete it!' },
$('form').serialize({ submit: 'second_submit' }));
- assertHashEqual({ val1:4, action:'blah' },
+ this.assertHashEqual({ val1:4, action:'blah' },
$('form').serialize({ submit: false }));
- assertHashEqual({ val1:4, action:'blah' },
+ this.assertHashEqual({ val1:4, action:'blah' },
$('form').serialize({ submit: 'inexistent' }));
- }},
+ },
- testFormMethodsOnExtendedElements: function() {with(this) {
+ testFormMethodsOnExtendedElements: function() {
var form = $('form');
- assertEqual(Form.serialize('form'), form.serialize());
- assertEqual(Form.Element.serialize('input_enabled'), $('input_enabled').serialize());
- assertNotEqual(form.serialize, $('input_enabled').serialize);
+ this.assertEqual(Form.serialize('form'), form.serialize());
+ this.assertEqual(Form.Element.serialize('input_enabled'), $('input_enabled').serialize());
+ this.assertNotEqual(form.serialize, $('input_enabled').serialize);
Element.addMethods('INPUT', { anInputMethod: function(input) { return 'input' } });
Element.addMethods('SELECT', { aSelectMethod: function(select) { return 'select' } });
@@ -420,74 +420,73 @@
var input = form['tf_text'], select = form['tf_selectOne'];
input._extendedByPrototype = select._extendedByPrototype = false;
- assert($(input).anInputMethod);
- assert(!input.aSelectMethod);
- assertEqual('input', input.anInputMethod());
+ this.assert($(input).anInputMethod);
+ this.assert(!input.aSelectMethod);
+ this.assertEqual('input', input.anInputMethod());
- assert($(select).aSelectMethod);
- assert(!select.anInputMethod);
- assertEqual('select', select.aSelectMethod());
- }},
+ this.assert($(select).aSelectMethod);
+ this.assert(!select.anInputMethod);
+ this.assertEqual('select', select.aSelectMethod());
+ },
- testFormRequest: function() {with(this) {
+ testFormRequest: function() {
request = $("form").request();
- assert($("form").hasAttribute("method"));
- assert(request.url.include("fixtures/empty.js?val1=4"));
- assertEqual("get", request.method);
+ this.assert($("form").hasAttribute("method"));
+ this.assert(request.url.include("fixtures/empty.js?val1=4"));
+ this.assertEqual("get", request.method);
request = $("form").request({ method: "put", parameters: {val2: "hello"} });
- assert(request.url.endsWith("fixtures/empty.js"));
- assertEqual(4, request.options.parameters['val1']);
- assertEqual('hello', request.options.parameters['val2']);
- assertEqual("post", request.method);
- assertEqual("put", request.parameters['_method']);
+ this.assert(request.url.endsWith("fixtures/empty.js"));
+ this.assertEqual(4, request.options.parameters['val1']);
+ this.assertEqual('hello', request.options.parameters['val2']);
+ this.assertEqual("post", request.method);
+ this.assertEqual("put", request.parameters['_method']);
// with empty action attribute
request = $("ffe").request({ method: 'post' });
- assert(request.url.include("unit/form.html"),
+ this.assert(request.url.include("unit/form.html"),
'wrong default action for form element with empty action attribute');
- }},
+ },
- testFormElementMethodsChaining: function(){ with(this) {
+ testFormElementMethodsChaining: function(){
var methods = $w('clear activate disable enable'),
formElements = $('form').getElements();
methods.each(function(method){
formElements.each(function(element){
var returned = element[method]();
- assertIdentical(element, returned);
- });
- });
- }},
+ this.assertIdentical(element, returned);
+ }, this);
+ }, this);
+ },
- testSetValue: function(){ with(this) {
+ testSetValue: function(){
// text input
var input = $('input_enabled'), oldValue = input.getValue();
- assertEqual(input, input.setValue('foo'), 'setValue chaining is broken');
- assertEqual('foo', input.getValue(), 'value improperly set');
+ this.assertEqual(input, input.setValue('foo'), 'setValue chaining is broken');
+ this.assertEqual('foo', input.getValue(), 'value improperly set');
input.setValue(oldValue);
- assertEqual(oldValue, input.getValue(), 'value improperly restored to original');
+ this.assertEqual(oldValue, input.getValue(), 'value improperly restored to original');
// checkbox
input = $('checkbox_hack');
input.setValue(false);
- assertEqual(null, input.getValue(), 'checkbox should be unchecked');
+ this.assertEqual(null, input.getValue(), 'checkbox should be unchecked');
input.setValue(true);
- assertEqual("1", input.getValue(), 'checkbox should be checked');
+ this.assertEqual("1", input.getValue(), 'checkbox should be checked');
// selectbox
input = $('bigform')['vu'];
input.setValue('3');
- assertEqual('3', input.getValue(), 'single select option improperly set');
+ this.assertEqual('3', input.getValue(), 'single select option improperly set');
input.setValue('1');
- assertEqual('1', input.getValue());
+ this.assertEqual('1', input.getValue());
// multiple select
input = $('bigform')['vm[]'];
input.setValue(['2', '3']);
- assertEnumEqual(['2', '3'], input.getValue(),
+ this.assertEnumEqual(['2', '3'], input.getValue(),
'multiple select options improperly set');
input.setValue(['1', '3']);
- assertEnumEqual(['1', '3'], input.getValue());
- }}
-
+ this.assertEnumEqual(['1', '3'], input.getValue());
+ }
});
// ]]>
diff --git a/test/unit/hash.html b/test/unit/hash.html
index 3bcbec4..60c96ba 100644
--- a/test/unit/hash.html
+++ b/test/unit/hash.html
@@ -54,177 +54,177 @@
};
new Test.Unit.Runner({
- testSet: function(){ with(this) {
+ testSet: function() {
var h = $H({a: 'A'})
- assertEqual('B', h.set('b', 'B'));
- assertHashEqual({a: 'A', b: 'B'}, h);
+ this.assertEqual('B', h.set('b', 'B'));
+ this.assertHashEqual({a: 'A', b: 'B'}, h);
- assertUndefined(h.set('c'));
- assertHashEqual({a: 'A', b: 'B', c: undefined}, h);
- }},
+ this.assertUndefined(h.set('c'));
+ this.assertHashEqual({a: 'A', b: 'B', c: undefined}, h);
+ },
- testGet: function(){ with(this) {
+ testGet: function() {
var h = $H({a: 'A'});
- assertEqual('A', h.get('a'));
- assertUndefined(h.a);
- assertUndefined($H({}).get('a'));
- }},
+ this.assertEqual('A', h.get('a'));
+ this.assertUndefined(h.a);
+ this.assertUndefined($H({}).get('a'));
+ },
- testUnset: function(){ with(this) {
+ testUnset: function() {
var hash = $H(Fixtures.many);
- assertEqual('B', hash.unset('b'));
- assertHashEqual({a:'A', c: 'C', d:'D#'}, hash);
- assertUndefined(hash.unset('z'));
- assertHashEqual({a:'A', c: 'C', d:'D#'}, hash);
+ this.assertEqual('B', hash.unset('b'));
+ this.assertHashEqual({a:'A', c: 'C', d:'D#'}, hash);
+ this.assertUndefined(hash.unset('z'));
+ this.assertHashEqual({a:'A', c: 'C', d:'D#'}, hash);
// not equivalent to Hash#remove
- assertEqual('A', hash.unset('a', 'c'));
- assertHashEqual({c: 'C', d:'D#'}, hash);
- }},
+ this.assertEqual('A', hash.unset('a', 'c'));
+ this.assertHashEqual({c: 'C', d:'D#'}, hash);
+ },
- testToObject: function(){ with(this) {
+ testToObject: function() {
var hash = $H(Fixtures.many), object = hash.toObject();
- assertInstanceOf(Object, object);
- assertHashEqual(Fixtures.many, object);
- assertNotIdentical(Fixtures.many, object);
+ this.assertInstanceOf(Object, object);
+ this.assertHashEqual(Fixtures.many, object);
+ this.assertNotIdentical(Fixtures.many, object);
hash.set('foo', 'bar');
- assertHashNotEqual(object, hash.toObject());
- }},
+ this.assertHashNotEqual(object, hash.toObject());
+ },
- testConstruct: function(){ with(this) {
+ testConstruct: function() {
var object = Object.clone(Fixtures.one);
var h = new Hash(object), h2 = $H(object);
- assertInstanceOf(Hash, h);
- assertInstanceOf(Hash, h2);
+ this.assertInstanceOf(Hash, h);
+ this.assertInstanceOf(Hash, h2);
- assertHashEqual({}, new Hash());
- assertHashEqual(object, h);
- assertHashEqual(object, h2);
+ this.assertHashEqual({}, new Hash());
+ this.assertHashEqual(object, h);
+ this.assertHashEqual(object, h2);
h.set('foo', 'bar');
- assertHashNotEqual(object, h);
+ this.assertHashNotEqual(object, h);
var clone = $H(h);
- assertInstanceOf(Hash, clone);
- assertHashEqual(h, clone);
+ this.assertInstanceOf(Hash, clone);
+ this.assertHashEqual(h, clone);
h.set('foo', 'foo');
- assertHashNotEqual(h, clone);
- assertIdentical($H, Hash.from);
- }},
+ this.assertHashNotEqual(h, clone);
+ this.assertIdentical($H, Hash.from);
+ },
- testKeys: function(){ with(this) {
- assertEnumEqual([], $H({}).keys());
- assertEnumEqual(['a'], $H(Fixtures.one).keys());
- assertEnumEqual($w('a b c d'), $H(Fixtures.many).keys().sort());
- assertEnumEqual($w('plus quad'), $H(Fixtures.functions).keys().sort());
- }},
+ testKeys: function() {
+ this.assertEnumEqual([], $H({}).keys());
+ this.assertEnumEqual(['a'], $H(Fixtures.one).keys());
+ this.assertEnumEqual($w('a b c d'), $H(Fixtures.many).keys().sort());
+ this.assertEnumEqual($w('plus quad'), $H(Fixtures.functions).keys().sort());
+ },
- testValues: function(){ with(this) {
- assertEnumEqual([], $H({}).values());
- assertEnumEqual(['A#'], $H(Fixtures.one).values());
- assertEnumEqual($w('A B C D#'), $H(Fixtures.many).values().sort());
- assertEnumEqual($w('function function'),
+ testValues: function() {
+ this.assertEnumEqual([], $H({}).values());
+ this.assertEnumEqual(['A#'], $H(Fixtures.one).values());
+ this.assertEnumEqual($w('A B C D#'), $H(Fixtures.many).values().sort());
+ this.assertEnumEqual($w('function function'),
$H(Fixtures.functions).values().map(function(i){ return typeof i }));
- assertEqual(9, $H(Fixtures.functions).get('quad')(3));
- assertEqual(6, $H(Fixtures.functions).get('plus')(3));
- }},
+ this.assertEqual(9, $H(Fixtures.functions).get('quad')(3));
+ this.assertEqual(6, $H(Fixtures.functions).get('plus')(3));
+ },
- testIndex: function(){ with(this) {
- assertUndefined($H().index('foo'));
+ testIndex: function() {
+ this.assertUndefined($H().index('foo'));
- assert('a', $H(Fixtures.one).index('A#'));
- assert('a', $H(Fixtures.many).index('A'));
- assertUndefined($H(Fixtures.many).index('Z'))
+ this.assert('a', $H(Fixtures.one).index('A#'));
+ this.assert('a', $H(Fixtures.many).index('A'));
+ this.assertUndefined($H(Fixtures.many).index('Z'))
var hash = $H({a:1,b:'2',c:1});
- assert(['a','c'].include(hash.index(1)));
- assertUndefined(hash.index('1'));
- }},
+ this.assert(['a','c'].include(hash.index(1)));
+ this.assertUndefined(hash.index('1'));
+ },
- testMerge: function(){ with(this) {
+ testMerge: function() {
var h = $H(Fixtures.many);
- assertNotIdentical(h, h.merge());
- assertNotIdentical(h, h.merge({}));
- assertInstanceOf(Hash, h.merge());
- assertInstanceOf(Hash, h.merge({}));
- assertHashEqual(h, h.merge());
- assertHashEqual(h, h.merge({}));
- assertHashEqual(h, h.merge($H()));
- assertHashEqual({a:'A', b:'B', c:'C', d:'D#', aaa:'AAA' }, h.merge({aaa: 'AAA'}));
- assertHashEqual({a:'A#', b:'B', c:'C', d:'D#' }, h.merge(Fixtures.one));
- }},
+ this.assertNotIdentical(h, h.merge());
+ this.assertNotIdentical(h, h.merge({}));
+ this.assertInstanceOf(Hash, h.merge());
+ this.assertInstanceOf(Hash, h.merge({}));
+ this.assertHashEqual(h, h.merge());
+ this.assertHashEqual(h, h.merge({}));
+ this.assertHashEqual(h, h.merge($H()));
+ this.assertHashEqual({a:'A', b:'B', c:'C', d:'D#', aaa:'AAA' }, h.merge({aaa: 'AAA'}));
+ this.assertHashEqual({a:'A#', b:'B', c:'C', d:'D#' }, h.merge(Fixtures.one));
+ },
- testUpdate: function(){ with(this) {
+ testUpdate: function() {
var h = $H(Fixtures.many);
- assertIdentical(h, h.update());
- assertIdentical(h, h.update({}));
- assertHashEqual(h, h.update());
- assertHashEqual(h, h.update({}));
- assertHashEqual(h, h.update($H()));
- assertHashEqual({a:'A', b:'B', c:'C', d:'D#', aaa:'AAA' }, h.update({aaa: 'AAA'}));
- assertHashEqual({a:'A#', b:'B', c:'C', d:'D#', aaa:'AAA' }, h.update(Fixtures.one));
- }},
+ this.assertIdentical(h, h.update());
+ this.assertIdentical(h, h.update({}));
+ this.assertHashEqual(h, h.update());
+ this.assertHashEqual(h, h.update({}));
+ this.assertHashEqual(h, h.update($H()));
+ this.assertHashEqual({a:'A', b:'B', c:'C', d:'D#', aaa:'AAA' }, h.update({aaa: 'AAA'}));
+ this.assertHashEqual({a:'A#', b:'B', c:'C', d:'D#', aaa:'AAA' }, h.update(Fixtures.one));
+ },
- testToQueryString: function(){ with(this) {
- assertEqual('', $H({}).toQueryString());
- assertEqual('a%23=A', $H({'a#': 'A'}).toQueryString());
- assertEqual('a=A%23', $H(Fixtures.one).toQueryString());
- assertEqual('a=A&b=B&c=C&d=D%23', $H(Fixtures.many).toQueryString());
- assertEqual("a=b&c", $H(Fixtures.value_undefined).toQueryString());
- assertEqual("a=b&c", $H("a=b&c".toQueryParams()).toQueryString());
- assertEqual("a=b&c=", $H(Fixtures.value_null).toQueryString());
- assertEqual("a=b&c=0", $H(Fixtures.value_zero).toQueryString());
- assertEqual("color=r&color=g&color=b", $H(Fixtures.multiple).toQueryString());
- assertEqual("color=r&color=&color=g&color&color=0", $H(Fixtures.multiple_nil).toQueryString());
- assertEqual("color=&color", $H(Fixtures.multiple_all_nil).toQueryString());
- assertEqual("", $H(Fixtures.multiple_empty).toQueryString());
- assertEqual("stuff%5B%5D=%24&stuff%5B%5D=a&stuff%5B%5D=%3B", $H(Fixtures.multiple_special).toQueryString());
- assertHashEqual(Fixtures.multiple_special, $H(Fixtures.multiple_special).toQueryString().toQueryParams());
- assertIdentical(Object.toQueryString, Hash.toQueryString);
- }},
+ testToQueryString: function() {
+ this.assertEqual('', $H({}).toQueryString());
+ this.assertEqual('a%23=A', $H({'a#': 'A'}).toQueryString());
+ this.assertEqual('a=A%23', $H(Fixtures.one).toQueryString());
+ this.assertEqual('a=A&b=B&c=C&d=D%23', $H(Fixtures.many).toQueryString());
+ this.assertEqual("a=b&c", $H(Fixtures.value_undefined).toQueryString());
+ this.assertEqual("a=b&c", $H("a=b&c".toQueryParams()).toQueryString());
+ this.assertEqual("a=b&c=", $H(Fixtures.value_null).toQueryString());
+ this.assertEqual("a=b&c=0", $H(Fixtures.value_zero).toQueryString());
+ this.assertEqual("color=r&color=g&color=b", $H(Fixtures.multiple).toQueryString());
+ this.assertEqual("color=r&color=&color=g&color&color=0", $H(Fixtures.multiple_nil).toQueryString());
+ this.assertEqual("color=&color", $H(Fixtures.multiple_all_nil).toQueryString());
+ this.assertEqual("", $H(Fixtures.multiple_empty).toQueryString());
+ this.assertEqual("stuff%5B%5D=%24&stuff%5B%5D=a&stuff%5B%5D=%3B", $H(Fixtures.multiple_special).toQueryString());
+ this.assertHashEqual(Fixtures.multiple_special, $H(Fixtures.multiple_special).toQueryString().toQueryParams());
+ this.assertIdentical(Object.toQueryString, Hash.toQueryString);
+ },
- testInspect: function(){ with(this) {
- assertEqual('#', $H({}).inspect());
- assertEqual("#", $H(Fixtures.one).inspect());
- assertEqual("#", $H(Fixtures.many).inspect());
- }},
+ testInspect: function() {
+ this.assertEqual('#', $H({}).inspect());
+ this.assertEqual("#", $H(Fixtures.one).inspect());
+ this.assertEqual("#", $H(Fixtures.many).inspect());
+ },
- testClone: function(){ with(this) {
+ testClone: function() {
var h = $H(Fixtures.many);
- assertHashEqual(h, h.clone());
- assertInstanceOf(Hash, h.clone());
- assertNotIdentical(h, h.clone());
- }},
+ this.assertHashEqual(h, h.clone());
+ this.assertInstanceOf(Hash, h.clone());
+ this.assertNotIdentical(h, h.clone());
+ },
- testToJSON: function(){ with(this) {
- assertEqual('{\"b\": [false, true], \"c\": {\"a\": \"hello!\"}}',
+ testToJSON: function() {
+ this.assertEqual('{\"b\": [false, true], \"c\": {\"a\": \"hello!\"}}',
$H({'b': [undefined, false, true, undefined], c: {a: 'hello!'}}).toJSON());
- }},
+ },
- testAbilityToContainAnyKey: function(){ with(this) {
+ testAbilityToContainAnyKey: function() {
var h = $H({ _each: 'E', map: 'M', keys: 'K', pluck: 'P', unset: 'U' });
- assertEnumEqual($w('_each keys map pluck unset'), h.keys().sort());
- assertEqual('U', h.unset('unset'));
- assertHashEqual({ _each: 'E', map: 'M', keys: 'K', pluck: 'P' }, h);
- }},
+ this.assertEnumEqual($w('_each keys map pluck unset'), h.keys().sort());
+ this.assertEqual('U', h.unset('unset'));
+ this.assertHashEqual({ _each: 'E', map: 'M', keys: 'K', pluck: 'P' }, h);
+ },
- testHashToTemplateReplacements: function() { with(this) {
+ testHashToTemplateReplacements: function() {
var template = new Template("#{a} #{b}"), hash = $H({ a: "hello", b: "world" });
- assertEqual("hello world", template.evaluate(hash.toObject()));
- assertEqual("hello world", template.evaluate(hash));
- assertEqual("hello", "#{a}".interpolate(hash));
- }},
+ this.assertEqual("hello world", template.evaluate(hash.toObject()));
+ this.assertEqual("hello world", template.evaluate(hash));
+ this.assertEqual("hello", "#{a}".interpolate(hash));
+ },
- testPreventIterationOverShadowedProperties: function() { with(this) {
+ testPreventIterationOverShadowedProperties: function() {
// redundant now that object is systematically cloned.
var FooMaker = function(value) {
this.key = value;
};
FooMaker.prototype.key = 'foo';
var foo = new FooMaker('bar');
- assertEqual("key=bar", new Hash(foo).toQueryString());
- assertEqual("key=bar", new Hash(new Hash(foo)).toQueryString());
- }}
+ this.assertEqual("key=bar", new Hash(foo).toQueryString());
+ this.assertEqual("key=bar", new Hash(new Hash(foo)).toQueryString());
+ }
});
// ]]>
diff --git a/test/unit/number.html b/test/unit/number.html
index fbfbf03..ce0405c 100644
--- a/test/unit/number.html
+++ b/test/unit/number.html
@@ -29,37 +29,37 @@
new Test.Unit.Runner({
- testNumberMathMethods: function() {with(this) {
- assertEqual(1, (0.9).round());
- assertEqual(-2, (-1.9).floor());
- assertEqual(-1, (-1.9).ceil());
+ testNumberMathMethods: function() {
+ this.assertEqual(1, (0.9).round());
+ this.assertEqual(-2, (-1.9).floor());
+ this.assertEqual(-1, (-1.9).ceil());
- $w('abs floor round ceil').each( function(method){
- assertEqual(Math[method](Math.PI), Math.PI[method]());
- });
- }},
+ $w('abs floor round ceil').each(function(method) {
+ this.assertEqual(Math[method](Math.PI), Math.PI[method]());
+ }, this);
+ },
- testNumberToColorPart: function() {with(this) {
- assertEqual('00', (0).toColorPart());
- assertEqual('0a', (10).toColorPart());
- assertEqual('ff', (255).toColorPart());
- }},
+ testNumberToColorPart: function() {
+ this.assertEqual('00', (0).toColorPart());
+ this.assertEqual('0a', (10).toColorPart());
+ this.assertEqual('ff', (255).toColorPart());
+ },
- testNumberToPaddedString: function() {with(this) {
- assertEqual('00', (0).toPaddedString(2, 16));
- assertEqual('0a', (10).toPaddedString(2, 16));
- assertEqual('ff', (255).toPaddedString(2, 16));
- assertEqual('000', (0).toPaddedString(3));
- assertEqual('010', (10).toPaddedString(3));
- assertEqual('100', (100).toPaddedString(3));
- assertEqual('1000', (1000).toPaddedString(3));
- }},
+ testNumberToPaddedString: function() {
+ this.assertEqual('00', (0).toPaddedString(2, 16));
+ this.assertEqual('0a', (10).toPaddedString(2, 16));
+ this.assertEqual('ff', (255).toPaddedString(2, 16));
+ this.assertEqual('000', (0).toPaddedString(3));
+ this.assertEqual('010', (10).toPaddedString(3));
+ this.assertEqual('100', (100).toPaddedString(3));
+ this.assertEqual('1000', (1000).toPaddedString(3));
+ },
- testNumberToJSON: function() {with(this) {
- assertEqual('null', Number.NaN.toJSON());
- assertEqual('0', (0).toJSON());
- assertEqual('-293', (-293).toJSON());
- }}
+ testNumberToJSON: function() {
+ this.assertEqual('null', Number.NaN.toJSON());
+ this.assertEqual('0', (0).toJSON());
+ this.assertEqual('-293', (-293).toJSON());
+ }
});
diff --git a/test/unit/position.html b/test/unit/position.html
index 7784a1c..1cc3e5a 100644
--- a/test/unit/position.html
+++ b/test/unit/position.html
@@ -53,34 +53,33 @@
Position.includeScrollOffsets = false;
},
- testPrepare: function() {with(this) {
+ testPrepare: function() {
Position.prepare();
- assertEqual(0, Position.deltaX);
- assertEqual(0, Position.deltaY);
+ this.assertEqual(0, Position.deltaX);
+ this.assertEqual(0, Position.deltaY);
scrollTo(20,30);
Position.prepare();
- assertEqual(20, Position.deltaX);
- assertEqual(30, Position.deltaY);
- }},
+ this.assertEqual(20, Position.deltaX);
+ this.assertEqual(30, Position.deltaY);
+ },
- testWithin: function() {with(this) {
+ testWithin: function() {
[true, false].each(function(withScrollOffsets) {
Position.includeScrollOffsets = withScrollOffsets;
- assert(!Position.within($('body_absolute'), 9, 9), 'outside left/top');
- assert(Position.within($('body_absolute'), 10, 10), 'left/top corner');
- assert(Position.within($('body_absolute'), 10, 19), 'left/bottom corner');
- assert(!Position.within($('body_absolute'), 10, 20), 'outside bottom');
- });
+ this.assert(!Position.within($('body_absolute'), 9, 9), 'outside left/top');
+ this.assert(Position.within($('body_absolute'), 10, 10), 'left/top corner');
+ this.assert(Position.within($('body_absolute'), 10, 19), 'left/bottom corner');
+ this.assert(!Position.within($('body_absolute'), 10, 20), 'outside bottom');
+ }, this);
scrollTo(20,30);
Position.prepare();
Position.includeScrollOffsets = true;
- assert(!Position.within($('body_absolute'), 9, 9), 'outside left/top');
- assert(Position.within($('body_absolute'), 10, 10), 'left/top corner');
- assert(Position.within($('body_absolute'), 10, 19), 'left/bottom corner');
- assert(!Position.within($('body_absolute'), 10, 20), 'outside bottom');
- }}
-
+ this.assert(!Position.within($('body_absolute'), 9, 9), 'outside left/top');
+ this.assert(Position.within($('body_absolute'), 10, 10), 'left/top corner');
+ this.assert(Position.within($('body_absolute'), 10, 19), 'left/bottom corner');
+ this.assert(!Position.within($('body_absolute'), 10, 20), 'outside bottom');
+ }
});
// ]]>
diff --git a/test/unit/range.html b/test/unit/range.html
index 896b13c..b3ffdc8 100644
--- a/test/unit/range.html
+++ b/test/unit/range.html
@@ -28,64 +28,61 @@
//
diff --git a/test/unit/selector.html b/test/unit/selector.html
index 2392fc7..bd02a29 100644
--- a/test/unit/selector.html
+++ b/test/unit/selector.html
@@ -103,337 +103,337 @@
new Test.Unit.Runner({
- testSelectorWithTagName: function() {with(this) {
- assertEnumEqual($A(document.getElementsByTagName('li')), $$('li'));
- assertEnumEqual([$('strong')], $$('strong'));
- assertEnumEqual([], $$('nonexistent'));
+ testSelectorWithTagName: function() {
+ this.assertEnumEqual($A(document.getElementsByTagName('li')), $$('li'));
+ this.assertEnumEqual([$('strong')], $$('strong'));
+ this.assertEnumEqual([], $$('nonexistent'));
var allNodes = $A(document.getElementsByTagName('*')).select( function(node) {
return node.tagName !== '!';
});
- assertEnumEqual(allNodes, $$('*'));
- }},
+ this.assertEnumEqual(allNodes, $$('*'));
+ },
- testSelectorWithId: function() {with(this) {
- assertEnumEqual([$('fixtures')], $$('#fixtures'));
- assertEnumEqual([], $$('#nonexistent'));
- assertEnumEqual([$('troubleForm')], $$('#troubleForm'));
- }},
+ testSelectorWithId: function() {
+ this.assertEnumEqual([$('fixtures')], $$('#fixtures'));
+ this.assertEnumEqual([], $$('#nonexistent'));
+ this.assertEnumEqual([$('troubleForm')], $$('#troubleForm'));
+ },
- testSelectorWithClassName: function() {with(this) {
- assertEnumEqual($('p', 'link_1', 'item_1'), $$('.first'));
- assertEnumEqual([], $$('.second'));
- }},
+ testSelectorWithClassName: function() {
+ this.assertEnumEqual($('p', 'link_1', 'item_1'), $$('.first'));
+ this.assertEnumEqual([], $$('.second'));
+ },
- testSelectorWithTagNameAndId: function() {with(this) {
- assertEnumEqual([$('strong')], $$('strong#strong'));
- assertEnumEqual([], $$('p#strong'));
- }},
+ testSelectorWithTagNameAndId: function() {
+ this.assertEnumEqual([$('strong')], $$('strong#strong'));
+ this.assertEnumEqual([], $$('p#strong'));
+ },
- testSelectorWithTagNameAndClassName: function() {with(this) {
- assertEnumEqual($('link_1', 'link_2'), $$('a.internal'));
- assertEnumEqual([$('link_2')], $$('a.internal.highlight'));
- assertEnumEqual([$('link_2')], $$('a.highlight.internal'));
- assertEnumEqual([], $$('a.highlight.internal.nonexistent'));
- }},
+ testSelectorWithTagNameAndClassName: function() {
+ this.assertEnumEqual($('link_1', 'link_2'), $$('a.internal'));
+ this.assertEnumEqual([$('link_2')], $$('a.internal.highlight'));
+ this.assertEnumEqual([$('link_2')], $$('a.highlight.internal'));
+ this.assertEnumEqual([], $$('a.highlight.internal.nonexistent'));
+ },
- testSelectorWithIdAndClassName: function() {with(this) {
- assertEnumEqual([$('link_2')], $$('#link_2.internal'));
- assertEnumEqual([$('link_2')], $$('.internal#link_2'));
- assertEnumEqual([$('link_2')], $$('#link_2.internal.highlight'));
- assertEnumEqual([], $$('#link_2.internal.nonexistent'));
- }},
+ testSelectorWithIdAndClassName: function() {
+ this.assertEnumEqual([$('link_2')], $$('#link_2.internal'));
+ this.assertEnumEqual([$('link_2')], $$('.internal#link_2'));
+ this.assertEnumEqual([$('link_2')], $$('#link_2.internal.highlight'));
+ this.assertEnumEqual([], $$('#link_2.internal.nonexistent'));
+ },
- testSelectorWithTagNameAndIdAndClassName: function() {with(this) {
- assertEnumEqual([$('link_2')], $$('a#link_2.internal'));
- assertEnumEqual([$('link_2')], $$('a.internal#link_2'));
- assertEnumEqual([$('item_1')], $$('li#item_1.first'));
- assertEnumEqual([], $$('li#item_1.nonexistent'));
- assertEnumEqual([], $$('li#item_1.first.nonexistent'));
- }},
+ testSelectorWithTagNameAndIdAndClassName: function() {
+ this.assertEnumEqual([$('link_2')], $$('a#link_2.internal'));
+ this.assertEnumEqual([$('link_2')], $$('a.internal#link_2'));
+ this.assertEnumEqual([$('item_1')], $$('li#item_1.first'));
+ this.assertEnumEqual([], $$('li#item_1.nonexistent'));
+ this.assertEnumEqual([], $$('li#item_1.first.nonexistent'));
+ },
- test$$MatchesAncestryWithTokensSeparatedByWhitespace: function() {with(this) {
- assertEnumEqual($('em2', 'em', 'span'), $$('#fixtures a *'));
- assertEnumEqual([$('p')], $$('div#fixtures p'));
- }},
+ test$$MatchesAncestryWithTokensSeparatedByWhitespace: function() {
+ this.assertEnumEqual($('em2', 'em', 'span'), $$('#fixtures a *'));
+ this.assertEnumEqual([$('p')], $$('div#fixtures p'));
+ },
- test$$CombinesResultsWhenMultipleExpressionsArePassed: function() {with(this) {
- assertEnumEqual($('link_1', 'link_2', 'item_1', 'item_2', 'item_3'), $$('#p a', ' ul#list li '));
- }},
+ test$$CombinesResultsWhenMultipleExpressionsArePassed: function() {
+ this.assertEnumEqual($('link_1', 'link_2', 'item_1', 'item_2', 'item_3'), $$('#p a', ' ul#list li '));
+ },
- testSelectorWithTagNameAndAttributeExistence: function() {with(this) {
- assertEnumEqual($$('#fixtures h1'), $$('h1[class]'), 'h1[class]');
- assertEnumEqual($$('#fixtures h1'), $$('h1[CLASS]'), 'h1[CLASS]');
- assertEnumEqual([$('item_3')], $$('li#item_3[class]'), 'li#item_3[class]');
- }},
+ testSelectorWithTagNameAndAttributeExistence: function() {
+ this.assertEnumEqual($$('#fixtures h1'), $$('h1[class]'), 'h1[class]');
+ this.assertEnumEqual($$('#fixtures h1'), $$('h1[CLASS]'), 'h1[CLASS]');
+ this.assertEnumEqual([$('item_3')], $$('li#item_3[class]'), 'li#item_3[class]');
+ },
- testSelectorWithTagNameAndSpecificAttributeValue: function() {with(this) {
- assertEnumEqual($('link_1', 'link_2', 'link_3'), $$('a[href="#"]'));
- assertEnumEqual($('link_1', 'link_2', 'link_3'), $$('a[href=#]'));
- }},
+ testSelectorWithTagNameAndSpecificAttributeValue: function() {
+ this.assertEnumEqual($('link_1', 'link_2', 'link_3'), $$('a[href="#"]'));
+ this.assertEnumEqual($('link_1', 'link_2', 'link_3'), $$('a[href=#]'));
+ },
- testSelectorWithTagNameAndWhitespaceTokenizedAttributeValue: function() {with(this) {
- assertEnumEqual($('link_1', 'link_2'), $$('a[class~="internal"]'));
- assertEnumEqual($('link_1', 'link_2'), $$('a[class~=internal]'));
- }},
+ testSelectorWithTagNameAndWhitespaceTokenizedAttributeValue: function() {
+ this.assertEnumEqual($('link_1', 'link_2'), $$('a[class~="internal"]'));
+ this.assertEnumEqual($('link_1', 'link_2'), $$('a[class~=internal]'));
+ },
- testSelectorWithAttributeAndNoTagName: function() {with(this) {
- assertEnumEqual($(document.body).select('a[href]'), $(document.body).select('[href]'));
- assertEnumEqual($$('a[class~="internal"]'), $$('[class~=internal]'));
- assertEnumEqual($$('*[id]'), $$('[id]'));
- assertEnumEqual($('checked_radio', 'unchecked_radio'), $$('[type=radio]'));
- assertEnumEqual($$('*[type=checkbox]'), $$('[type=checkbox]'));
- assertEnumEqual($('with_title', 'commaParent'), $$('[title]'));
- assertEnumEqual($$('#troubleForm *[type=radio]'), $$('#troubleForm [type=radio]'));
- assertEnumEqual($$('#troubleForm *[type]'), $$('#troubleForm [type]'));
- }},
+ testSelectorWithAttributeAndNoTagName: function() {
+ this.assertEnumEqual($(document.body).select('a[href]'), $(document.body).select('[href]'));
+ this.assertEnumEqual($$('a[class~="internal"]'), $$('[class~=internal]'));
+ this.assertEnumEqual($$('*[id]'), $$('[id]'));
+ this.assertEnumEqual($('checked_radio', 'unchecked_radio'), $$('[type=radio]'));
+ this.assertEnumEqual($$('*[type=checkbox]'), $$('[type=checkbox]'));
+ this.assertEnumEqual($('with_title', 'commaParent'), $$('[title]'));
+ this.assertEnumEqual($$('#troubleForm *[type=radio]'), $$('#troubleForm [type=radio]'));
+ this.assertEnumEqual($$('#troubleForm *[type]'), $$('#troubleForm [type]'));
+ },
- testSelectorWithUniversalAndHyphenTokenizedAttributeValue: function() {with(this) {
- assertEnumEqual([$('item_3')], $$('*[xml:lang|="es"]'));
- assertEnumEqual([$('item_3')], $$('*[xml:lang|="ES"]'));
- }},
+ testSelectorWithUniversalAndHyphenTokenizedAttributeValue: function() {
+ this.assertEnumEqual([$('item_3')], $$('*[xml:lang|="es"]'));
+ this.assertEnumEqual([$('item_3')], $$('*[xml:lang|="ES"]'));
+ },
- testSelectorWithTagNameAndNegatedAttributeValue: function() {with(this) {
- assertEnumEqual([], $$('a[href!=#]'));
- }},
+ testSelectorWithTagNameAndNegatedAttributeValue: function() {
+ this.assertEnumEqual([], $$('a[href!=#]'));
+ },
- testSelectorWithBracketAttributeValue: function() {with(this) {
- assertEnumEqual($('chk_1', 'chk_2'), $$('#troubleForm2 input[name="brackets[5][]"]'));
- assertEnumEqual([$('chk_1')], $$('#troubleForm2 input[name="brackets[5][]"]:checked'));
- assertEnumEqual([$('chk_2')], $$('#troubleForm2 input[name="brackets[5][]"][value=2]'));
- assertEnumEqual([], $$('#troubleForm2 input[name=brackets[5][]]'));
- }},
+ testSelectorWithBracketAttributeValue: function() {
+ this.assertEnumEqual($('chk_1', 'chk_2'), $$('#troubleForm2 input[name="brackets[5][]"]'));
+ this.assertEnumEqual([$('chk_1')], $$('#troubleForm2 input[name="brackets[5][]"]:checked'));
+ this.assertEnumEqual([$('chk_2')], $$('#troubleForm2 input[name="brackets[5][]"][value=2]'));
+ this.assertEnumEqual([], $$('#troubleForm2 input[name=brackets[5][]]'));
+ },
- test$$WithNestedAttributeSelectors: function() {with(this) {
- assertEnumEqual([$('strong')], $$('div[style] p[id] strong'));
- }},
+ test$$WithNestedAttributeSelectors: function() {
+ this.assertEnumEqual([$('strong')], $$('div[style] p[id] strong'));
+ },
- testSelectorWithMultipleConditions: function() {with(this) {
- assertEnumEqual([$('link_3')], $$('a[class~=external][href="#"]'));
- assertEnumEqual([], $$('a[class~=external][href!="#"]'));
- }},
+ testSelectorWithMultipleConditions: function() {
+ this.assertEnumEqual([$('link_3')], $$('a[class~=external][href="#"]'));
+ this.assertEnumEqual([], $$('a[class~=external][href!="#"]'));
+ },
- testSelectorMatchElements: function() {with(this) {
- assertElementsMatch(Selector.matchElements($('list').descendants(), 'li'), '#item_1', '#item_2', '#item_3');
- assertElementsMatch(Selector.matchElements($('fixtures').descendants(), 'a.internal'), '#link_1', '#link_2');
- assertEnumEqual([], Selector.matchElements($('fixtures').descendants(), 'p.last'));
- assertElementsMatch(Selector.matchElements($('fixtures').descendants(), '.inexistant, a.internal'), '#link_1', '#link_2');
- }},
+ testSelectorMatchElements: function() {
+ this.assertElementsMatch(Selector.matchElements($('list').descendants(), 'li'), '#item_1', '#item_2', '#item_3');
+ this.assertElementsMatch(Selector.matchElements($('fixtures').descendants(), 'a.internal'), '#link_1', '#link_2');
+ this.assertEnumEqual([], Selector.matchElements($('fixtures').descendants(), 'p.last'));
+ this.assertElementsMatch(Selector.matchElements($('fixtures').descendants(), '.inexistant, a.internal'), '#link_1', '#link_2');
+ },
- testSelectorFindElement: function() {with(this) {
- assertElementMatches(Selector.findElement($('list').descendants(), 'li'), 'li#item_1.first');
- assertElementMatches(Selector.findElement($('list').descendants(), 'li', 1), 'li#item_2');
- assertElementMatches(Selector.findElement($('list').descendants(), 'li#item_3'), 'li');
- assertEqual(undefined, Selector.findElement($('list').descendants(), 'em'));
- }},
+ testSelectorFindElement: function() {
+ this.assertElementMatches(Selector.findElement($('list').descendants(), 'li'), 'li#item_1.first');
+ this.assertElementMatches(Selector.findElement($('list').descendants(), 'li', 1), 'li#item_2');
+ this.assertElementMatches(Selector.findElement($('list').descendants(), 'li#item_3'), 'li');
+ this.assertEqual(undefined, Selector.findElement($('list').descendants(), 'em'));
+ },
- testElementMatch: function() {with(this) {
+ testElementMatch: function() {
var span = $('dupL1');
// tests that should pass
- assert(span.match('span'));
- assert(span.match('span#dupL1'));
- assert(span.match('div > span'), 'child combinator');
- assert(span.match('#dupContainer span'), 'descendant combinator');
- assert(span.match('#dupL1'), 'ID only');
- assert(span.match('span.span_foo'), 'class name 1');
- assert(span.match('span.span_bar'), 'class name 2');
- assert(span.match('span:first-child'), 'first-child pseudoclass');
+ this.assert(span.match('span'));
+ this.assert(span.match('span#dupL1'));
+ this.assert(span.match('div > span'), 'child combinator');
+ this.assert(span.match('#dupContainer span'), 'descendant combinator');
+ this.assert(span.match('#dupL1'), 'ID only');
+ this.assert(span.match('span.span_foo'), 'class name 1');
+ this.assert(span.match('span.span_bar'), 'class name 2');
+ this.assert(span.match('span:first-child'), 'first-child pseudoclass');
- assert(!span.match('span.span_wtf'), 'bogus class name');
- assert(!span.match('#dupL2'), 'different ID');
- assert(!span.match('div'), 'different tag name');
- assert(!span.match('span span'), 'different ancestry');
- assert(!span.match('span > span'), 'different parent');
- assert(!span.match('span:nth-child(5)'), 'different pseudoclass');
+ this.assert(!span.match('span.span_wtf'), 'bogus class name');
+ this.assert(!span.match('#dupL2'), 'different ID');
+ this.assert(!span.match('div'), 'different tag name');
+ this.assert(!span.match('span span'), 'different ancestry');
+ this.assert(!span.match('span > span'), 'different parent');
+ this.assert(!span.match('span:nth-child(5)'), 'different pseudoclass');
- assert(!$('link_2').match('a[rel^=external]'));
- assert($('link_1').match('a[rel^=external]'));
- assert($('link_1').match('a[rel^="external"]'));
- assert($('link_1').match("a[rel^='external']"));
+ this.assert(!$('link_2').match('a[rel^=external]'));
+ this.assert($('link_1').match('a[rel^=external]'));
+ this.assert($('link_1').match('a[rel^="external"]'));
+ this.assert($('link_1').match("a[rel^='external']"));
- assert(span.match({ match: function(element) { return true }}), 'custom selector');
- assert(!span.match({ match: function(element) { return false }}), 'custom selector');
- }},
+ this.assert(span.match({ match: function(element) { return true }}), 'custom selector');
+ this.assert(!span.match({ match: function(element) { return false }}), 'custom selector');
+ },
- testSelectorWithSpaceInAttributeValue: function() {with(this) {
- assertEnumEqual([$('with_title')], $$('cite[title="hello world!"]'));
- }},
+ testSelectorWithSpaceInAttributeValue: function() {
+ this.assertEnumEqual([$('with_title')], $$('cite[title="hello world!"]'));
+ },
// AND NOW COME THOSE NEW TESTS AFTER ANDREW'S REWRITE!
- testSelectorWithNamespacedAttributes: function() { with(this) {
+ testSelectorWithNamespacedAttributes: function() {
if (Prototype.BrowserFeatures.XPath) {
- assertUndefined(new Selector('html[xml:lang]').xpath);
- assertUndefined(new Selector('body p[xml:lang]').xpath);
+ this.assertUndefined(new Selector('html[xml:lang]').xpath);
+ this.assertUndefined(new Selector('body p[xml:lang]').xpath);
} else
- info("Could not test XPath bypass: no XPath to begin with!");
+ this.info("Could not test XPath bypass: no XPath to begin with!");
- assertElementsMatch($$('[xml:lang]'), 'html', '#item_3');
- assertElementsMatch($$('*[xml:lang]'), 'html', '#item_3');
- }},
+ this.assertElementsMatch($$('[xml:lang]'), 'html', '#item_3');
+ this.assertElementsMatch($$('*[xml:lang]'), 'html', '#item_3');
+ },
- testSelectorWithChild: function() { with(this) {
- assertEnumEqual($('link_1', 'link_2'), $$('p.first > a'));
- assertEnumEqual($('father', 'uncle'), $$('div#grandfather > div'));
- assertEnumEqual($('level2_1', 'level2_2'), $$('#level1>span'));
- assertEnumEqual($('level2_1', 'level2_2'), $$('#level1 > span'));
- assertEnumEqual($('level3_1', 'level3_2'), $$('#level2_1 > *'));
- assertEnumEqual([], $$('div > #nonexistent'));
- $RunBenchmarks && wait(500, function() {
- benchmark(function() { $$('#level1 > span') }, 1000);
+ testSelectorWithChild: function() {
+ this.assertEnumEqual($('link_1', 'link_2'), $$('p.first > a'));
+ this.assertEnumEqual($('father', 'uncle'), $$('div#grandfather > div'));
+ this.assertEnumEqual($('level2_1', 'level2_2'), $$('#level1>span'));
+ this.assertEnumEqual($('level2_1', 'level2_2'), $$('#level1 > span'));
+ this.assertEnumEqual($('level3_1', 'level3_2'), $$('#level2_1 > *'));
+ this.assertEnumEqual([], $$('div > #nonexistent'));
+ $RunBenchmarks && this.wait(500, function() {
+ this.benchmark(function() { $$('#level1 > span') }, 1000);
});
- }},
+ },
- testSelectorWithAdjacence: function() { with(this) {
- assertEnumEqual([$('uncle')], $$('div.brothers + div.brothers'));
- assertEnumEqual([$('uncle')], $$('div.brothers + div'));
- assertEqual($('level2_2'), $$('#level2_1+span').reduce());
- assertEqual($('level2_2'), $$('#level2_1 + span').reduce());
- assertEqual($('level2_2'), $$('#level2_1 + *').reduce());
- assertEnumEqual([], $$('#level2_2 + span'));
- assertEqual($('level3_2'), $$('#level3_1 + span').reduce());
- assertEqual($('level3_2'), $$('#level3_1 + *').reduce());
- assertEnumEqual([], $$('#level3_2 + *'));
- assertEnumEqual([], $$('#level3_1 + em'));
- $RunBenchmarks && wait(500, function() {
- benchmark(function() { $$('#level3_1 + span') }, 1000);
+ testSelectorWithAdjacence: function() {
+ this.assertEnumEqual([$('uncle')], $$('div.brothers + div.brothers'));
+ this.assertEnumEqual([$('uncle')], $$('div.brothers + div'));
+ this.assertEqual($('level2_2'), $$('#level2_1+span').reduce());
+ this.assertEqual($('level2_2'), $$('#level2_1 + span').reduce());
+ this.assertEqual($('level2_2'), $$('#level2_1 + *').reduce());
+ this.assertEnumEqual([], $$('#level2_2 + span'));
+ this.assertEqual($('level3_2'), $$('#level3_1 + span').reduce());
+ this.assertEqual($('level3_2'), $$('#level3_1 + *').reduce());
+ this.assertEnumEqual([], $$('#level3_2 + *'));
+ this.assertEnumEqual([], $$('#level3_1 + em'));
+ $RunBenchmarks && this.wait(500, function() {
+ this.benchmark(function() { $$('#level3_1 + span') }, 1000);
});
- }},
+ },
- testSelectorWithLaterSibling: function() { with(this) {
- assertEnumEqual([$('list')], $$('h1 ~ ul'));
- assertEqual($('level2_2'), $$('#level2_1 ~ span').reduce());
- assertEnumEqual($('level2_2', 'level2_3'), $$('#level2_1 ~ *').reduce());
- assertEnumEqual([], $$('#level2_2 ~ span'));
- assertEnumEqual([], $$('#level3_2 ~ *'));
- assertEnumEqual([], $$('#level3_1 ~ em'));
- assertEnumEqual([$('level3_2')], $$('#level3_1 ~ #level3_2'));
- assertEnumEqual([$('level3_2')], $$('span ~ #level3_2'));
- assertEnumEqual([], $$('div ~ #level3_2'));
- assertEnumEqual([], $$('div ~ #level2_3'));
- $RunBenchmarks && wait(500, function() {
- benchmark(function() { $$('#level2_1 ~ span') }, 1000);
+ testSelectorWithLaterSibling: function() {
+ this.assertEnumEqual([$('list')], $$('h1 ~ ul'));
+ this.assertEqual($('level2_2'), $$('#level2_1 ~ span').reduce());
+ this.assertEnumEqual($('level2_2', 'level2_3'), $$('#level2_1 ~ *').reduce());
+ this.assertEnumEqual([], $$('#level2_2 ~ span'));
+ this.assertEnumEqual([], $$('#level3_2 ~ *'));
+ this.assertEnumEqual([], $$('#level3_1 ~ em'));
+ this.assertEnumEqual([$('level3_2')], $$('#level3_1 ~ #level3_2'));
+ this.assertEnumEqual([$('level3_2')], $$('span ~ #level3_2'));
+ this.assertEnumEqual([], $$('div ~ #level3_2'));
+ this.assertEnumEqual([], $$('div ~ #level2_3'));
+ $RunBenchmarks && this.wait(500, function() {
+ this.benchmark(function() { $$('#level2_1 ~ span') }, 1000);
});
- }},
+ },
- testSelectorWithNewAttributeOperators: function() { with(this) {
- assertEnumEqual($('father', 'uncle'), $$('div[class^=bro]'), 'matching beginning of string');
- assertEnumEqual($('father', 'uncle'), $$('div[class$=men]'), 'matching end of string');
- assertEnumEqual($('father', 'uncle'), $$('div[class*="ers m"]'), 'matching substring')
- assertEnumEqual($('level2_1', 'level2_2', 'level2_3'), $$('#level1 *[id^="level2_"]'));
- assertEnumEqual($('level2_1', 'level2_2', 'level2_3'), $$('#level1 *[id^=level2_]'));
- assertEnumEqual($('level2_1', 'level3_1'), $$('#level1 *[id$="_1"]'));
- assertEnumEqual($('level2_1', 'level3_1'), $$('#level1 *[id$=_1]'));
- assertEnumEqual($('level2_1', 'level3_2', 'level2_2', 'level2_3'), $$('#level1 *[id*="2"]'));
- assertEnumEqual($('level2_1', 'level3_2', 'level2_2', 'level2_3'), $$('#level1 *[id*=2]'));
- $RunBenchmarks && wait(500, function() {
- benchmark(function() { $$('#level1 *[id^=level2_]') }, 1000, '[^=]');
- benchmark(function() { $$('#level1 *[id$=_1]') }, 1000, '[$=]');
- benchmark(function() { $$('#level1 *[id*=_2]') }, 1000, '[*=]');
+ testSelectorWithNewAttributeOperators: function() {
+ this.assertEnumEqual($('father', 'uncle'), $$('div[class^=bro]'), 'matching beginning of string');
+ this.assertEnumEqual($('father', 'uncle'), $$('div[class$=men]'), 'matching end of string');
+ this.assertEnumEqual($('father', 'uncle'), $$('div[class*="ers m"]'), 'matching substring')
+ this.assertEnumEqual($('level2_1', 'level2_2', 'level2_3'), $$('#level1 *[id^="level2_"]'));
+ this.assertEnumEqual($('level2_1', 'level2_2', 'level2_3'), $$('#level1 *[id^=level2_]'));
+ this.assertEnumEqual($('level2_1', 'level3_1'), $$('#level1 *[id$="_1"]'));
+ this.assertEnumEqual($('level2_1', 'level3_1'), $$('#level1 *[id$=_1]'));
+ this.assertEnumEqual($('level2_1', 'level3_2', 'level2_2', 'level2_3'), $$('#level1 *[id*="2"]'));
+ this.assertEnumEqual($('level2_1', 'level3_2', 'level2_2', 'level2_3'), $$('#level1 *[id*=2]'));
+ $RunBenchmarks && this.wait(500, function() {
+ this.benchmark(function() { $$('#level1 *[id^=level2_]') }, 1000, '[^=]');
+ this.benchmark(function() { $$('#level1 *[id$=_1]') }, 1000, '[$=]');
+ this.benchmark(function() { $$('#level1 *[id*=_2]') }, 1000, '[*=]');
});
- }},
+ },
- testSelectorWithDuplicates: function() { with(this) {
- assertEnumEqual($$('div div'), $$('div div').uniq());
- assertEnumEqual($('dupL2', 'dupL3', 'dupL4', 'dupL5'), $$('#dupContainer span span'));
- $RunBenchmarks && wait(500, function() {
- benchmark(function() { $$('#dupContainer span span') }, 1000);
+ testSelectorWithDuplicates: function() {
+ this.assertEnumEqual($$('div div'), $$('div div').uniq());
+ this.assertEnumEqual($('dupL2', 'dupL3', 'dupL4', 'dupL5'), $$('#dupContainer span span'));
+ $RunBenchmarks && this.wait(500, function() {
+ this.benchmark(function() { $$('#dupContainer span span') }, 1000);
});
- }},
+ },
- testSelectorWithFirstLastOnlyNthNthLastChild: function() { with(this) {
- assertEnumEqual([$('level2_1')], $$('#level1>*:first-child'));
- assertEnumEqual($('level2_1', 'level3_1', 'level_only_child'), $$('#level1 *:first-child'));
- assertEnumEqual([$('level2_3')], $$('#level1>*:last-child'));
- assertEnumEqual($('level3_2', 'level_only_child', 'level2_3'), $$('#level1 *:last-child'));
- assertEnumEqual([$('level2_3')], $$('#level1>div:last-child'));
- assertEnumEqual([$('level2_3')], $$('#level1 div:last-child'));
- assertEnumEqual([], $$('#level1>div:first-child'));
- assertEnumEqual([], $$('#level1>span:last-child'));
- assertEnumEqual($('level2_1', 'level3_1'), $$('#level1 span:first-child'));
- assertEnumEqual([], $$('#level1:first-child'));
- assertEnumEqual([], $$('#level1>*:only-child'));
- assertEnumEqual([$('level_only_child')], $$('#level1 *:only-child'));
- assertEnumEqual([], $$('#level1:only-child'));
- assertEnumEqual([$('link_2')], $$('#p *:nth-last-child(2)'), 'nth-last-child');
- assertEnumEqual([$('link_2')], $$('#p *:nth-child(3)'), 'nth-child');
- assertEnumEqual([$('link_2')], $$('#p a:nth-child(3)'), 'nth-child');
- assertEnumEqual($('item_2', 'item_3'), $$('#list > li:nth-child(n+2)'));
- assertEnumEqual($('item_1', 'item_2'), $$('#list > li:nth-child(-n+2)'));
- $RunBenchmarks && wait(500, function() {
- benchmark(function() { $$('#level1 *:first-child') }, 1000, ':first-child');
- benchmark(function() { $$('#level1 *:last-child') }, 1000, ':last-child');
- benchmark(function() { $$('#level1 *:only-child') }, 1000, ':only-child');
+ testSelectorWithFirstLastOnlyNthNthLastChild: function() {
+ this.assertEnumEqual([$('level2_1')], $$('#level1>*:first-child'));
+ this.assertEnumEqual($('level2_1', 'level3_1', 'level_only_child'), $$('#level1 *:first-child'));
+ this.assertEnumEqual([$('level2_3')], $$('#level1>*:last-child'));
+ this.assertEnumEqual($('level3_2', 'level_only_child', 'level2_3'), $$('#level1 *:last-child'));
+ this.assertEnumEqual([$('level2_3')], $$('#level1>div:last-child'));
+ this.assertEnumEqual([$('level2_3')], $$('#level1 div:last-child'));
+ this.assertEnumEqual([], $$('#level1>div:first-child'));
+ this.assertEnumEqual([], $$('#level1>span:last-child'));
+ this.assertEnumEqual($('level2_1', 'level3_1'), $$('#level1 span:first-child'));
+ this.assertEnumEqual([], $$('#level1:first-child'));
+ this.assertEnumEqual([], $$('#level1>*:only-child'));
+ this.assertEnumEqual([$('level_only_child')], $$('#level1 *:only-child'));
+ this.assertEnumEqual([], $$('#level1:only-child'));
+ this.assertEnumEqual([$('link_2')], $$('#p *:nth-last-child(2)'), 'nth-last-child');
+ this.assertEnumEqual([$('link_2')], $$('#p *:nth-child(3)'), 'nth-child');
+ this.assertEnumEqual([$('link_2')], $$('#p a:nth-child(3)'), 'nth-child');
+ this.assertEnumEqual($('item_2', 'item_3'), $$('#list > li:nth-child(n+2)'));
+ this.assertEnumEqual($('item_1', 'item_2'), $$('#list > li:nth-child(-n+2)'));
+ $RunBenchmarks && this.wait(500, function() {
+ this.benchmark(function() { $$('#level1 *:first-child') }, 1000, ':first-child');
+ this.benchmark(function() { $$('#level1 *:last-child') }, 1000, ':last-child');
+ this.benchmark(function() { $$('#level1 *:only-child') }, 1000, ':only-child');
});
- }},
+ },
- testSelectorWithFirstLastNthNthLastOfType: function() {with(this) {
- assertEnumEqual([$('link_2')], $$('#p a:nth-of-type(2)'), 'nth-of-type');
- assertEnumEqual([$('link_1')], $$('#p a:nth-of-type(1)'), 'nth-of-type');
- assertEnumEqual([$('link_2')], $$('#p a:nth-last-of-type(1)'), 'nth-last-of-type');
- assertEnumEqual([$('link_1')], $$('#p a:first-of-type'), 'first-of-type');
- assertEnumEqual([$('link_2')], $$('#p a:last-of-type'), 'last-of-type');
- }},
+ testSelectorWithFirstLastNthNthLastOfType: function() {
+ this.assertEnumEqual([$('link_2')], $$('#p a:nth-of-type(2)'), 'nth-of-type');
+ this.assertEnumEqual([$('link_1')], $$('#p a:nth-of-type(1)'), 'nth-of-type');
+ this.assertEnumEqual([$('link_2')], $$('#p a:nth-last-of-type(1)'), 'nth-last-of-type');
+ this.assertEnumEqual([$('link_1')], $$('#p a:first-of-type'), 'first-of-type');
+ this.assertEnumEqual([$('link_2')], $$('#p a:last-of-type'), 'last-of-type');
+ },
- testSelectorWithNot: function() {with(this) {
- assertEnumEqual([$('link_2')], $$('#p a:not(a:first-of-type)'), 'first-of-type');
- assertEnumEqual([$('link_1')], $$('#p a:not(a:last-of-type)'), 'last-of-type');
- assertEnumEqual([$('link_2')], $$('#p a:not(a:nth-of-type(1))'), 'nth-of-type');
- assertEnumEqual([$('link_1')], $$('#p a:not(a:nth-last-of-type(1))'), 'nth-last-of-type');
- assertEnumEqual([$('link_2')], $$('#p a:not([rel~=nofollow])'), 'attribute 1');
- assertEnumEqual([$('link_2')], $$('#p a:not(a[rel^=external])'), 'attribute 2');
- assertEnumEqual([$('link_2')], $$('#p a:not(a[rel$=nofollow])'), 'attribute 3');
- assertEnumEqual([$('em')], $$('#p a:not(a[rel$="nofollow"]) > em'), 'attribute 4')
- assertEnumEqual([$('item_2')], $$('#list li:not(#item_1):not(#item_3)'), 'adjacent :not clauses');
- assertEnumEqual([$('son')], $$('#grandfather > div:not(#uncle) #son'));
- assertEnumEqual([$('em')], $$('#p a:not(a[rel$="nofollow"]) em'), 'attribute 4 + all descendants');
- assertEnumEqual([$('em')], $$('#p a:not(a[rel$="nofollow"])>em'), 'attribute 4 (without whitespace)');
- }},
+ testSelectorWithNot: function() {
+ this.assertEnumEqual([$('link_2')], $$('#p a:not(a:first-of-type)'), 'first-of-type');
+ this.assertEnumEqual([$('link_1')], $$('#p a:not(a:last-of-type)'), 'last-of-type');
+ this.assertEnumEqual([$('link_2')], $$('#p a:not(a:nth-of-type(1))'), 'nth-of-type');
+ this.assertEnumEqual([$('link_1')], $$('#p a:not(a:nth-last-of-type(1))'), 'nth-last-of-type');
+ this.assertEnumEqual([$('link_2')], $$('#p a:not([rel~=nofollow])'), 'attribute 1');
+ this.assertEnumEqual([$('link_2')], $$('#p a:not(a[rel^=external])'), 'attribute 2');
+ this.assertEnumEqual([$('link_2')], $$('#p a:not(a[rel$=nofollow])'), 'attribute 3');
+ this.assertEnumEqual([$('em')], $$('#p a:not(a[rel$="nofollow"]) > em'), 'attribute 4')
+ this.assertEnumEqual([$('item_2')], $$('#list li:not(#item_1):not(#item_3)'), 'adjacent :not clauses');
+ this.assertEnumEqual([$('son')], $$('#grandfather > div:not(#uncle) #son'));
+ this.assertEnumEqual([$('em')], $$('#p a:not(a[rel$="nofollow"]) em'), 'attribute 4 + all descendants');
+ this.assertEnumEqual([$('em')], $$('#p a:not(a[rel$="nofollow"])>em'), 'attribute 4 (without whitespace)');
+ },
- testSelectorWithEnabledDisabledChecked: function() {with(this) {
- assertEnumEqual([$('disabled_text_field')], $$('#troubleForm > *:disabled'));
- assertEnumEqual($('troubleForm').getInputs().without($('disabled_text_field')), $$('#troubleForm > *:enabled'));
- assertEnumEqual($('checked_box', 'checked_radio'), $$('#troubleForm *:checked'));
- }},
+ testSelectorWithEnabledDisabledChecked: function() {
+ this.assertEnumEqual([$('disabled_text_field')], $$('#troubleForm > *:disabled'));
+ this.assertEnumEqual($('troubleForm').getInputs().without($('disabled_text_field')), $$('#troubleForm > *:enabled'));
+ this.assertEnumEqual($('checked_box', 'checked_radio'), $$('#troubleForm *:checked'));
+ },
- testSelectorWithEmpty: function() {with(this) {
+ testSelectorWithEmpty: function() {
$('level3_1').innerHTML = "\t\n\n\r\n\t ";
- assertEnumEqual($('level3_1', 'level3_2', 'level_only_child', 'level2_3'), $$('#level1 *:empty'));
- assertEnumEqual([$('level_only_child')], $$('#level_only_child:empty'));
- }},
+ this.assertEnumEqual($('level3_1', 'level3_2', 'level_only_child', 'level2_3'), $$('#level1 *:empty'));
+ this.assertEnumEqual([$('level_only_child')], $$('#level_only_child:empty'));
+ },
- testIdenticalResultsFromEquivalentSelectors: function() {with(this) {
- assertEnumEqual($$('div.brothers'), $$('div[class~=brothers]'));
- assertEnumEqual($$('div.brothers'), $$('div[class~=brothers].brothers'));
- assertEnumEqual($$('div:not(.brothers)'), $$('div:not([class~=brothers])'));
- assertEnumEqual($$('li ~ li'), $$('li:not(:first-child)'));
- assertEnumEqual($$('ul > li'), $$('ul > li:nth-child(n)'));
- assertEnumEqual($$('ul > li:nth-child(even)'), $$('ul > li:nth-child(2n)'));
- assertEnumEqual($$('ul > li:nth-child(odd)'), $$('ul > li:nth-child(2n+1)'));
- assertEnumEqual($$('ul > li:first-child'), $$('ul > li:nth-child(1)'));
- assertEnumEqual($$('ul > li:last-child'), $$('ul > li:nth-last-child(1)'));
- assertEnumEqual($$('#troubleForm *:enabled'), $$('#troubleForm *:not(:disabled)'));
- assertEnumEqual($$('ul > li:nth-child(n-999)'), $$('ul > li'));
- assertEnumEqual($$('ul>li'), $$('ul > li'));
- assertEnumEqual($$('#p a:not(a[rel$="nofollow"])>em'), $$('#p a:not(a[rel$="nofollow"]) > em'))
- }},
+ testIdenticalResultsFromEquivalentSelectors: function() {
+ this.assertEnumEqual($$('div.brothers'), $$('div[class~=brothers]'));
+ this.assertEnumEqual($$('div.brothers'), $$('div[class~=brothers].brothers'));
+ this.assertEnumEqual($$('div:not(.brothers)'), $$('div:not([class~=brothers])'));
+ this.assertEnumEqual($$('li ~ li'), $$('li:not(:first-child)'));
+ this.assertEnumEqual($$('ul > li'), $$('ul > li:nth-child(n)'));
+ this.assertEnumEqual($$('ul > li:nth-child(even)'), $$('ul > li:nth-child(2n)'));
+ this.assertEnumEqual($$('ul > li:nth-child(odd)'), $$('ul > li:nth-child(2n+1)'));
+ this.assertEnumEqual($$('ul > li:first-child'), $$('ul > li:nth-child(1)'));
+ this.assertEnumEqual($$('ul > li:last-child'), $$('ul > li:nth-last-child(1)'));
+ this.assertEnumEqual($$('#troubleForm *:enabled'), $$('#troubleForm *:not(:disabled)'));
+ this.assertEnumEqual($$('ul > li:nth-child(n-999)'), $$('ul > li'));
+ this.assertEnumEqual($$('ul>li'), $$('ul > li'));
+ this.assertEnumEqual($$('#p a:not(a[rel$="nofollow"])>em'), $$('#p a:not(a[rel$="nofollow"]) > em'))
+ },
- testSelectorsThatShouldReturnNothing: function() {with(this) {
- assertEnumEqual([], $$('span:empty > *'));
- assertEnumEqual([], $$('div.brothers:not(.brothers)'));
- assertEnumEqual([], $$('#level2_2 :only-child:not(:last-child)'));
- assertEnumEqual([], $$('#level2_2 :only-child:not(:first-child)'));
- }},
+ testSelectorsThatShouldReturnNothing: function() {
+ this.assertEnumEqual([], $$('span:empty > *'));
+ this.assertEnumEqual([], $$('div.brothers:not(.brothers)'));
+ this.assertEnumEqual([], $$('#level2_2 :only-child:not(:last-child)'));
+ this.assertEnumEqual([], $$('#level2_2 :only-child:not(:first-child)'));
+ },
- testCommasFor$$: function() {with(this) {
- assertEnumEqual($('list', 'p', 'link_1', 'item_1', 'item_3', 'troubleForm'), $$('#list, .first,*[xml:lang="es-us"] , #troubleForm'));
- assertEnumEqual($('list', 'p', 'link_1', 'item_1', 'item_3', 'troubleForm'), $$('#list, .first,', '*[xml:lang="es-us"] , #troubleForm'));
- assertEnumEqual($('commaParent', 'commaChild'), $$('form[title*="commas,"], input[value="#commaOne,#commaTwo"]'));
- assertEnumEqual($('commaParent', 'commaChild'), $$('form[title*="commas,"]', 'input[value="#commaOne,#commaTwo"]'));
- }},
+ testCommasFor$$: function() {
+ this.assertEnumEqual($('list', 'p', 'link_1', 'item_1', 'item_3', 'troubleForm'), $$('#list, .first,*[xml:lang="es-us"] , #troubleForm'));
+ this.assertEnumEqual($('list', 'p', 'link_1', 'item_1', 'item_3', 'troubleForm'), $$('#list, .first,', '*[xml:lang="es-us"] , #troubleForm'));
+ this.assertEnumEqual($('commaParent', 'commaChild'), $$('form[title*="commas,"], input[value="#commaOne,#commaTwo"]'));
+ this.assertEnumEqual($('commaParent', 'commaChild'), $$('form[title*="commas,"]', 'input[value="#commaOne,#commaTwo"]'));
+ },
- testSelectorExtendsAllNodes: function(){ with(this) {
+ testSelectorExtendsAllNodes: function(){
var element = document.createElement('div');
(3).times(function(){
element.appendChild(document.createElement('div'));
@@ -442,30 +442,30 @@
$$('body')[0].appendChild(element);
var results = $$('#scratch_element div');
- assert(typeof results[0].show == 'function');
- assert(typeof results[1].show == 'function');
- assert(typeof results[2].show == 'function');
- }},
+ this.assert(typeof results[0].show == 'function');
+ this.assert(typeof results[1].show == 'function');
+ this.assert(typeof results[2].show == 'function');
+ },
- testCountedIsNotAnAttribute: function() { with(this) {
+ testCountedIsNotAnAttribute: function() {
var el = $('list');
Selector.handlers.mark([el]);
- assert(!el.innerHTML.include("_counted"));
+ this.assert(!el.innerHTML.include("_counted"));
Selector.handlers.unmark([el]);
- assert(!el.innerHTML.include("_counted"));
- }},
+ this.assert(!el.innerHTML.include("_counted"));
+ },
- testCopiedNodesGetIncluded: function(){ with(this) {
- assertElementsMatch(
+ testCopiedNodesGetIncluded: function() {
+ this.assertElementsMatch(
Selector.matchElements($('counted_container').descendants(), 'div'),
'div.is_counted'
);
$('counted_container').innerHTML += $('counted_container').innerHTML;
- assertElementsMatch(
+ this.assertElementsMatch(
Selector.matchElements($('counted_container').descendants(), 'div'), 'div.is_counted',
'div.is_counted'
);
- }}
+ }
});
// ]]>
diff --git a/test/unit/string.html b/test/unit/string.html
index babb58c..bb63b7c 100644
--- a/test/unit/string.html
+++ b/test/unit/string.html
@@ -36,116 +36,116 @@
});
new Test.Unit.Runner({
- testInterpret: function(){with(this) {
- assertIdentical('true', String.interpret(true));
- assertIdentical('123', String.interpret(123));
- assertIdentical('foo bar', String.interpret('foo bar'));
- assertIdentical(
+ testInterpret: function(){
+ this.assertIdentical('true', String.interpret(true));
+ this.assertIdentical('123', String.interpret(123));
+ this.assertIdentical('foo bar', String.interpret('foo bar'));
+ this.assertIdentical(
'object string',
String.interpret({ toString: function(){ return 'object string' } }));
- assertIdentical('0', String.interpret(0));
- assertIdentical('false', String.interpret(false));
- assertIdentical('', String.interpret(undefined));
- assertIdentical('', String.interpret(null));
- assertIdentical('', String.interpret(''));
- }},
+ this.assertIdentical('0', String.interpret(0));
+ this.assertIdentical('false', String.interpret(false));
+ this.assertIdentical('', String.interpret(undefined));
+ this.assertIdentical('', String.interpret(null));
+ this.assertIdentical('', String.interpret(''));
+ },
- testGsubWithReplacementFunction: function() {with(this) {
+ testGsubWithReplacementFunction: function() {
var source = 'foo boo boz';
- assertEqual('Foo Boo BoZ',
+ this.assertEqual('Foo Boo BoZ',
source.gsub(/[^o]+/, function(match) {
return match[0].toUpperCase()
}));
- assertEqual('f2 b2 b1z',
+ this.assertEqual('f2 b2 b1z',
source.gsub(/o+/, function(match) {
return match[0].length;
}));
- assertEqual('f0 b0 b1z',
+ this.assertEqual('f0 b0 b1z',
source.gsub(/o+/, function(match) {
return match[0].length % 2;
}));
- }},
+ },
- testGsubWithReplacementString: function() {with(this) {
+ testGsubWithReplacementString: function() {
var source = 'foo boo boz';
- assertEqual('foobooboz',
+ this.assertEqual('foobooboz',
source.gsub(/\s+/, ''));
- assertEqual(' z',
+ this.assertEqual(' z',
source.gsub(/(.)(o+)/, ''));
- assertEqual('ウィメンズ2007
クルーズコレクション',
+ this.assertEqual('ウィメンズ2007
クルーズコレクション',
'ウィメンズ2007\nクルーズコレクション'.gsub(/\n/,'
'));
- assertEqual('ウィメンズ2007
クルーズコレクション',
+ this.assertEqual('ウィメンズ2007
クルーズコレクション',
'ウィメンズ2007\nクルーズコレクション'.gsub('\n','
'));
- }},
+ },
- testGsubWithReplacementTemplateString: function() {with(this) {
+ testGsubWithReplacementTemplateString: function() {
var source = 'foo boo boz';
- assertEqual('-oo-#{1}- -oo-#{1}- -o-#{1}-z',
+ this.assertEqual('-oo-#{1}- -oo-#{1}- -o-#{1}-z',
source.gsub(/(.)(o+)/, '-#{2}-\\#{1}-'));
- assertEqual('-foo-f- -boo-b- -bo-b-z',
+ this.assertEqual('-foo-f- -boo-b- -bo-b-z',
source.gsub(/(.)(o+)/, '-#{0}-#{1}-'));
- assertEqual('-oo-f- -oo-b- -o-b-z',
+ this.assertEqual('-oo-f- -oo-b- -o-b-z',
source.gsub(/(.)(o+)/, '-#{2}-#{1}-'));
- assertEqual(' z',
+ this.assertEqual(' z',
source.gsub(/(.)(o+)/, '#{3}'));
- }},
+ },
- testSubWithReplacementFunction: function() {with(this) {
+ testSubWithReplacementFunction: function() {
var source = 'foo boo boz';
- assertEqual('Foo boo boz',
+ this.assertEqual('Foo boo boz',
source.sub(/[^o]+/, function(match) {
return match[0].toUpperCase()
}), 1);
- assertEqual('Foo Boo boz',
+ this.assertEqual('Foo Boo boz',
source.sub(/[^o]+/, function(match) {
return match[0].toUpperCase()
}, 2), 2);
- assertEqual(source,
+ this.assertEqual(source,
source.sub(/[^o]+/, function(match) {
return match[0].toUpperCase()
}, 0), 0);
- assertEqual(source,
+ this.assertEqual(source,
source.sub(/[^o]+/, function(match) {
return match[0].toUpperCase()
}, -1), -1);
- }},
+ },
- testSubWithReplacementString: function() {with(this) {
+ testSubWithReplacementString: function() {
var source = 'foo boo boz';
- assertEqual('oo boo boz',
+ this.assertEqual('oo boo boz',
source.sub(/[^o]+/, ''));
- assertEqual('oooo boz',
+ this.assertEqual('oooo boz',
source.sub(/[^o]+/, '', 2));
- assertEqual('-f-oo boo boz',
+ this.assertEqual('-f-oo boo boz',
source.sub(/[^o]+/, '-#{0}-'));
- assertEqual('-f-oo- b-oo boz',
+ this.assertEqual('-f-oo- b-oo boz',
source.sub(/[^o]+/, '-#{0}-', 2));
- }},
+ },
- testScan: function() {with(this) {
+ testScan: function() {
var source = 'foo boo boz', results = [];
var str = source.scan(/[o]+/, function(match) {
results.push(match[0].length);
});
- assertEnumEqual([2, 2, 1], results);
- assertEqual(source, source.scan(/x/, fail));
- assert(typeof str == 'string');
- }},
+ this.assertEnumEqual([2, 2, 1], results);
+ this.assertEqual(source, source.scan(/x/, this.fail));
+ this.assert(typeof str == 'string');
+ },
- testToArray: function() {with(this) {
- assertEnumEqual([],''.toArray());
- assertEnumEqual(['a'],'a'.toArray());
- assertEnumEqual(['a','b'],'ab'.toArray());
- assertEnumEqual(['f','o','o'],'foo'.toArray());
- }},
+ testToArray: function() {
+ this.assertEnumEqual([],''.toArray());
+ this.assertEnumEqual(['a'],'a'.toArray());
+ this.assertEnumEqual(['a','b'],'ab'.toArray());
+ this.assertEnumEqual(['f','o','o'],'foo'.toArray());
+ },
/*
Note that camelize() differs from its Rails counterpart,
@@ -154,217 +154,213 @@
- Looks for dashes, not underscores
- CamelCases first word if there is a front dash
*/
- testCamelize: function() {with(this) {
- assertEqual('', ''.camelize());
- assertEqual('', '-'.camelize());
- assertEqual('foo', 'foo'.camelize());
- assertEqual('foo_bar', 'foo_bar'.camelize());
- assertEqual('FooBar', '-foo-bar'.camelize());
- assertEqual('FooBar', 'FooBar'.camelize());
+ testCamelize: function() {
+ this.assertEqual('', ''.camelize());
+ this.assertEqual('', '-'.camelize());
+ this.assertEqual('foo', 'foo'.camelize());
+ this.assertEqual('foo_bar', 'foo_bar'.camelize());
+ this.assertEqual('FooBar', '-foo-bar'.camelize());
+ this.assertEqual('FooBar', 'FooBar'.camelize());
- assertEqual('fooBar', 'foo-bar'.camelize());
- assertEqual('borderBottomWidth', 'border-bottom-width'.camelize());
+ this.assertEqual('fooBar', 'foo-bar'.camelize());
+ this.assertEqual('borderBottomWidth', 'border-bottom-width'.camelize());
- assertEqual('classNameTest','class-name-test'.camelize());
- assertEqual('classNameTest','className-test'.camelize());
- assertEqual('classNameTest','class-nameTest'.camelize());
+ this.assertEqual('classNameTest','class-name-test'.camelize());
+ this.assertEqual('classNameTest','className-test'.camelize());
+ this.assertEqual('classNameTest','class-nameTest'.camelize());
- /* benchmark(function(){
+ /* this.benchmark(function(){
'class-name-test'.camelize();
},10000); */
- }},
+ },
- testCapitalize: function() {with(this) {
- assertEqual('',''.capitalize());
- assertEqual('Ä','ä'.capitalize());
- assertEqual('A','A'.capitalize());
- assertEqual('Hello','hello'.capitalize());
- assertEqual('Hello','HELLO'.capitalize());
- assertEqual('Hello','Hello'.capitalize());
- assertEqual('Hello world','hello WORLD'.capitalize());
- }},
+ testCapitalize: function() {
+ this.assertEqual('',''.capitalize());
+ this.assertEqual('Ä','ä'.capitalize());
+ this.assertEqual('A','A'.capitalize());
+ this.assertEqual('Hello','hello'.capitalize());
+ this.assertEqual('Hello','HELLO'.capitalize());
+ this.assertEqual('Hello','Hello'.capitalize());
+ this.assertEqual('Hello world','hello WORLD'.capitalize());
+ },
- testUnderscore: function() {with(this) {
- assertEqual('', ''.underscore());
- assertEqual('_', '-'.underscore());
- assertEqual('foo', 'foo'.underscore());
- assertEqual('foo', 'Foo'.underscore());
- assertEqual('foo_bar', 'foo_bar'.underscore());
- assertEqual('border_bottom', 'borderBottom'.underscore());
- assertEqual('border_bottom_width', 'borderBottomWidth'.underscore());
- assertEqual('border_bottom_width', 'border-Bottom-Width'.underscore());
- }},
+ testUnderscore: function() {
+ this.assertEqual('', ''.underscore());
+ this.assertEqual('_', '-'.underscore());
+ this.assertEqual('foo', 'foo'.underscore());
+ this.assertEqual('foo', 'Foo'.underscore());
+ this.assertEqual('foo_bar', 'foo_bar'.underscore());
+ this.assertEqual('border_bottom', 'borderBottom'.underscore());
+ this.assertEqual('border_bottom_width', 'borderBottomWidth'.underscore());
+ this.assertEqual('border_bottom_width', 'border-Bottom-Width'.underscore());
+ },
- testDasherize: function() {with(this) {
- assertEqual('', ''.dasherize());
- assertEqual('foo', 'foo'.dasherize());
- assertEqual('Foo', 'Foo'.dasherize());
- assertEqual('foo-bar', 'foo-bar'.dasherize());
- assertEqual('border-bottom-width', 'border_bottom_width'.dasherize());
- }},
+ testDasherize: function() {
+ this.assertEqual('', ''.dasherize());
+ this.assertEqual('foo', 'foo'.dasherize());
+ this.assertEqual('Foo', 'Foo'.dasherize());
+ this.assertEqual('foo-bar', 'foo-bar'.dasherize());
+ this.assertEqual('border-bottom-width', 'border_bottom_width'.dasherize());
+ },
- testTruncate: function() {with(this) {
+ testTruncate: function() {
var source = 'foo boo boz foo boo boz foo boo boz foo boo boz';
- assertEqual(source, source.truncate(source.length));
- assertEqual('foo boo boz foo boo boz foo...', source.truncate(0));
- assertEqual('fo...', source.truncate(5));
- assertEqual('foo b', source.truncate(5, ''));
+ this.assertEqual(source, source.truncate(source.length));
+ this.assertEqual('foo boo boz foo boo boz foo...', source.truncate(0));
+ this.assertEqual('fo...', source.truncate(5));
+ this.assertEqual('foo b', source.truncate(5, ''));
- assert(typeof 'foo'.truncate(5) == 'string');
- assert(typeof 'foo bar baz'.truncate(5) == 'string');
- }},
+ this.assert(typeof 'foo'.truncate(5) == 'string');
+ this.assert(typeof 'foo bar baz'.truncate(5) == 'string');
+ },
- testStrip: function() {with(this) {
- assertEqual('hello world', ' hello world '.strip());
- assertEqual('hello world', 'hello world'.strip());
- assertEqual('hello \n world', ' hello \n world '.strip());
- assertEqual('', ' '.strip());
- }},
+ testStrip: function() {
+ this.assertEqual('hello world', ' hello world '.strip());
+ this.assertEqual('hello world', 'hello world'.strip());
+ this.assertEqual('hello \n world', ' hello \n world '.strip());
+ this.assertEqual('', ' '.strip());
+ },
- testStripTags: function() {with(this) {
- assertEqual('hello world', 'hello world'.stripTags());
- assertEqual('hello world', 'hello world'.stripTags());
- assertEqual('hello world', 'hello world'.stripTags());
- assertEqual('hello world', 'hello world'.stripTags());
- assertEqual('1\n2', '1\n2'.stripTags());
- }},
+ testStripTags: function() {
+ this.assertEqual('hello world', 'hello world'.stripTags());
+ this.assertEqual('hello world', 'hello world'.stripTags());
+ this.assertEqual('hello world', 'hello world'.stripTags());
+ this.assertEqual('hello world', 'hello world'.stripTags());
+ this.assertEqual('1\n2', '1\n2'.stripTags());
+ },
- testStripScripts: function() {with(this) {
- assertEqual('foo bar', 'foo bar'.stripScripts());
- assertEqual('foo bar', ('foo
diff --git a/test/unit/unit_tests.html b/test/unit/unit_tests.html
index 998ed0a..8975afb 100644
--- a/test/unit/unit_tests.html
+++ b/test/unit/unit_tests.html
@@ -56,144 +56,142 @@
new Test.Unit.Runner({
- testIsRunningFromRake: function() { with(this) {
+ testIsRunningFromRake: function() {
if (window.location.toString().startsWith('http')) {
- assert(isRunningFromRake);
- info('These tests are running from rake.')
+ this.assert(this.isRunningFromRake);
+ this.info('These tests are running from rake.')
} else {
- assert(!isRunningFromRake);
- info('These tests are *not* running from rake.')
+ this.assert(!this.isRunningFromRake);
+ this.info('These tests are *not* running from rake.')
}
- }},
+ },
testBuildMessage: function() {
this.assertEqual("'foo' 'bar'", this.buildMessage('', '? ?', 'foo', 'bar'))
},
- testAssertEqual: function() { with(this) {
- assertEqual(0, 0);
- assertEqual(0, 0, "test");
+ testAssertEqual: function() {
+ this.assertEqual(0, 0);
+ this.assertEqual(0, 0, "test");
- assertEqual(0,'0');
- assertEqual(65.0, 65);
+ this.assertEqual(0,'0');
+ this.assertEqual(65.0, 65);
- assertEqual("a", "a");
- assertEqual("a", "a", "test");
+ this.assertEqual("a", "a");
+ this.assertEqual("a", "a", "test");
- assertNotEqual(0, 1);
- assertNotEqual("a","b");
- assertNotEqual({},{});
- assertNotEqual([],[]);
- assertNotEqual([],{});
- }},
+ this.assertNotEqual(0, 1);
+ this.assertNotEqual("a","b");
+ this.assertNotEqual({},{});
+ this.assertNotEqual([],[]);
+ this.assertNotEqual([],{});
+ },
- testAssertEnumEqual: function() { with(this) {
- assertEnumEqual([], []);
- assertEnumEqual(['a', 'b'], ['a', 'b']);
- assertEnumEqual(['1', '2'], [1, 2]);
- assertEnumNotEqual(['1', '2'], [1, 2, 3]);
- }},
+ testAssertEnumEqual: function() {
+ this.assertEnumEqual([], []);
+ this.assertEnumEqual(['a', 'b'], ['a', 'b']);
+ this.assertEnumEqual(['1', '2'], [1, 2]);
+ this.assertEnumNotEqual(['1', '2'], [1, 2, 3]);
+ },
- testAssertHashEqual: function() { with(this) {
- assertHashEqual({}, {});
- assertHashEqual({a:'b'}, {a:'b'});
- assertHashEqual({a:'b', c:'d'}, {c:'d', a:'b'});
- assertHashNotEqual({a:'b', c:'d'}, {c:'d', a:'boo!'});
- }},
+ testAssertHashEqual: function() {
+ this.assertHashEqual({}, {});
+ this.assertHashEqual({a:'b'}, {a:'b'});
+ this.assertHashEqual({a:'b', c:'d'}, {c:'d', a:'b'});
+ this.assertHashNotEqual({a:'b', c:'d'}, {c:'d', a:'boo!'});
+ },
- testAssertRespondsTo: function() { with(this) {
- assertRespondsTo('isNice', testObj);
- assertRespondsTo('isBroken', testObj);
- }},
+ testAssertRespondsTo: function() {
+ this.assertRespondsTo('isNice', testObj);
+ this.assertRespondsTo('isBroken', testObj);
+ },
- testAssertIdentical: function() { with(this) {
- assertIdentical(0, 0);
- assertIdentical(0, 0, "test");
- assertIdentical(1, 1);
- assertIdentical('a', 'a');
- assertIdentical('a', 'a', "test");
- assertIdentical('', '');
- assertIdentical(undefined, undefined);
- assertIdentical(null, null);
- assertIdentical(true, true);
- assertIdentical(false, false);
+ testAssertIdentical: function() {
+ this.assertIdentical(0, 0);
+ this.assertIdentical(0, 0, "test");
+ this.assertIdentical(1, 1);
+ this.assertIdentical('a', 'a');
+ this.assertIdentical('a', 'a', "test");
+ this.assertIdentical('', '');
+ this.assertIdentical(undefined, undefined);
+ this.assertIdentical(null, null);
+ this.assertIdentical(true, true);
+ this.assertIdentical(false, false);
var obj = {a:'b'};
- assertIdentical(obj, obj);
+ this.assertIdentical(obj, obj);
- assertNotIdentical({1:2,3:4},{1:2,3:4});
+ this.assertNotIdentical({1:2,3:4},{1:2,3:4});
- assertIdentical(1, 1.0); // both are typeof == 'number'
+ this.assertIdentical(1, 1.0); // both are typeof == 'number'
- assertNotIdentical(1, '1');
- assertNotIdentical(1, '1.0');
- }},
+ this.assertNotIdentical(1, '1');
+ this.assertNotIdentical(1, '1.0');
+ },
- testAssertNullAndAssertUndefined: function() { with(this) {
- assertNull(null);
- assertNotNull(undefined);
- assertNotNull(0);
- assertNotNull('');
- assertNotUndefined(null);
- assertUndefined(undefined);
- assertNotUndefined(0);
- assertNotUndefined('');
- assertNullOrUndefined(null);
- assertNullOrUndefined(undefined);
- assertNotNullOrUndefined(0);
- assertNotNullOrUndefined('');
- }},
+ testAssertNullAndAssertUndefined: function() {
+ this.assertNull(null);
+ this.assertNotNull(undefined);
+ this.assertNotNull(0);
+ this.assertNotNull('');
+ this.assertNotUndefined(null);
+ this.assertUndefined(undefined);
+ this.assertNotUndefined(0);
+ this.assertNotUndefined('');
+ this.assertNullOrUndefined(null);
+ this.assertNullOrUndefined(undefined);
+ this.assertNotNullOrUndefined(0);
+ this.assertNotNullOrUndefined('');
+ },
- testAssertMatch: function() { with(this) {
- assertMatch(/knowmad.jpg$/, 'http://script.aculo.us/images/knowmad.jpg');
- assertMatch(/Fuc/, 'Thomas Fuchs');
- assertMatch(/^\$(\d{1,3}(\,\d{3})*|(\d+))(\.\d{2})?$/, '$19.95');
- assertMatch(/(\d{3}\) ?)|(\d{3}[- \.])?\d{3}[- \.]\d{4}(\s(x\d+)?){0,1}$/, '704-343-9330');
- assertMatch(/^(?:(?:(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(\/|-|\.)(?:0?2\1(?:29)))|(?:(?:(?:1[6-9]|[2-9]\d)?\d{2})(\/|-|\.)(?:(?:(?:0?[13578]|1[02])\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\2(?:0?[1-9]|1\d|2[0-8]))))$/, '2001-06-16');
- assertMatch(/^((0?[123456789])|(1[012]))\s*:\s*([012345]\d)(\s*:\s*([012345]\d))?\s*[ap]m\s*-\s*((0?[123456789])|(1[012]))\s*:\s*([012345]\d)(\s*:\s*([012345]\d))?\s*[ap]m$/i, '2:00PM-2:15PM');
- assertNoMatch(/zubar/, 'foo bar');
- }},
+ testAssertMatch: function() {
+ this.assertMatch(/knowmad.jpg$/, 'http://script.aculo.us/images/knowmad.jpg');
+ this.assertMatch(/Fuc/, 'Thomas Fuchs');
+ this.assertMatch(/^\$(\d{1,3}(\,\d{3})*|(\d+))(\.\d{2})?$/, '$19.95');
+ this.assertMatch(/(\d{3}\) ?)|(\d{3}[- \.])?\d{3}[- \.]\d{4}(\s(x\d+)?){0,1}$/, '704-343-9330');
+ this.assertMatch(/^(?:(?:(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(\/|-|\.)(?:0?2\1(?:29)))|(?:(?:(?:1[6-9]|[2-9]\d)?\d{2})(\/|-|\.)(?:(?:(?:0?[13578]|1[02])\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\2(?:0?[1-9]|1\d|2[0-8]))))$/, '2001-06-16');
+ this.assertMatch(/^((0?[123456789])|(1[012]))\s*:\s*([012345]\d)(\s*:\s*([012345]\d))?\s*[ap]m\s*-\s*((0?[123456789])|(1[012]))\s*:\s*([012345]\d)(\s*:\s*([012345]\d))?\s*[ap]m$/i, '2:00PM-2:15PM');
+ this.assertNoMatch(/zubar/, 'foo bar');
+ },
- testAssertInstanceOf: function() { with(this) {
- assertInstanceOf(String, new String);
- assertInstanceOf(RegExp, /foo/);
- assertNotInstanceOf(String, {});
- }},
+ testAssertInstanceOf: function() {
+ this.assertInstanceOf(String, new String);
+ this.assertInstanceOf(RegExp, /foo/);
+ this.assertNotInstanceOf(String, {});
+ },
- testAssertVisible: function() { with(this) {
- assertVisible('testcss1');
- assertNotVisible('testcss1_span');
- //assertNotVisible('testcss2', "Due to a Safari bug, this test fails in Safari.");
+ testAssertVisible: function() {
+ this.assertVisible('testcss1');
+ this.assertNotVisible('testcss1_span');
+ //this.assertNotVisible('testcss2', "Due to a Safari bug, this test fails in Safari.");
Element.hide('testcss1');
- assertNotVisible('testcss1');
- assertNotVisible('testcss1_span');
+ this.assertNotVisible('testcss1');
+ this.assertNotVisible('testcss1_span');
Element.show('testcss1');
- assertVisible('testcss1');
- assertNotVisible('testcss1_span');
+ this.assertVisible('testcss1');
+ this.assertNotVisible('testcss1_span');
Element.show('testcss1_span');
- assertVisible('testcss1_span');
+ this.assertVisible('testcss1_span');
Element.hide('testcss1');
- assertNotVisible('testcss1_span'); // hidden by parent
- }},
+ this.assertNotVisible('testcss1_span'); // hidden by parent
+ },
- testAssertElementsMatch: function() { with(this) {
- assertElementsMatch($$('#tlist'), '#tlist');
- assertElementMatches($('tlist'), '#tlist');
- }}
-
+ testAssertElementsMatch: function() {
+ this.assertElementsMatch($$('#tlist'), '#tlist');
+ this.assertElementMatches($('tlist'), '#tlist');
+ }
});
new Test.Unit.Runner({
- testDummy: function() { with(this) {
- assert(true);
- }},
+ testDummy: function() {
+ this.assert(true);
+ },
- testMultipleTestRunner: function() { with(this) {
- assertEqual('passed', $('testlog_2').down('td', 1).innerHTML);
- }}
-
+ testMultipleTestRunner: function() {
+ this.assertEqual('passed', $('testlog_2').down('td', 1).innerHTML);
+ }
}, {testLog: 'testlog_2'});
// ]]>