Index: tests/html/element_test.dart |
=================================================================== |
--- tests/html/element_test.dart (revision 14114) |
+++ tests/html/element_test.dart (working copy) |
@@ -8,12 +8,12 @@ |
#import('dart:html'); |
expectLargeRect(ClientRect rect) { |
- Expect.equals(rect.top, 0); |
- Expect.equals(rect.left, 0); |
- Expect.isTrue(rect.width > 100); |
- Expect.isTrue(rect.height > 100); |
- Expect.equals(rect.bottom, rect.top + rect.height); |
- Expect.equals(rect.right, rect.left + rect.width); |
+ expect(rect.top, 0); |
+ expect(rect.left, 0); |
+ expect(rect.width, greaterThan(100)); |
+ expect(rect.height, greaterThan(100)); |
+ expect(rect.bottom, rect.top + rect.height); |
+ expect(rect.right, rect.left + rect.width); |
} |
void testEventHelper(EventListenerList listenerList, String type, |
@@ -38,23 +38,31 @@ |
listenerList.dispatch(event); |
} |
- Expect.isTrue(firedWhenAddedToListenerList); |
+ expect(firedWhenAddedToListenerList, isTrue); |
if (registerOnEventListener != null) { |
- Expect.isTrue(firedOnEvent); |
+ expect(firedOnEvent, isTrue); |
} |
} |
void testConstructorHelper(String tag, String htmlSnippet, |
String expectedText, Function isExpectedClass) { |
- Expect.isTrue(isExpectedClass(new Element.tag(tag))); |
+ expect(isExpectedClass(new Element.tag(tag)), isTrue); |
final elementFromSnippet = new Element.html(htmlSnippet); |
- Expect.isTrue(isExpectedClass(elementFromSnippet)); |
- Expect.equals(expectedText, elementFromSnippet.text); |
+ expect(isExpectedClass(elementFromSnippet), isTrue); |
+ expect(elementFromSnippet.text, expectedText); |
} |
main() { |
useHtmlConfiguration(); |
+ var isHRElement = new isInstanceOf<HRElement>('HRElement'); |
+ var isBRElement = new isInstanceOf<BRElement>('BRElement'); |
+ var isInputElement = new isInstanceOf<InputElement>('InputElement'); |
+ var isImageElement = new isInstanceOf<ImageElement>('ImageElement'); |
+ var isSpanElement = new isInstanceOf<SpanElement>('SpanElement'); |
+ var isAnchorElement = new isInstanceOf<AnchorElement>('AnchorElement'); |
+ var isElementList = new isInstanceOf<List<Element>>('List<Element>'); |
+ |
Element makeElement() => new Element.tag('div'); |
Element makeElementWithChildren() => |
@@ -63,7 +71,7 @@ |
test('computedStyle', () { |
final element = document.body; |
element.computedStyle.then(expectAsync1((style) { |
- Expect.equals(style.getPropertyValue('left'), 'auto'); |
+ expect(style.getPropertyValue('left'), 'auto'); |
})); |
}); |
@@ -113,12 +121,11 @@ |
group('constructors', () { |
test('error', () { |
- Expect.throws(() => new Element.html('<br/><br/>'), |
- (e) => e is ArgumentError); |
+ expect(() => new Element.html('<br/><br/>'), throwsArgumentError); |
}); |
test('.html has no parent', () => |
- Expect.isNull(new Element.html('<br/>').parent)); |
+ expect(new Element.html('<br/>').parent, isNull)); |
test('a', () => testConstructorHelper('a', '<a>foo</a>', 'foo', |
(element) => element is AnchorElement)); |
@@ -434,136 +441,136 @@ |
data-foo2="bar2" dir="rtl"> |
</div>'''); |
final attributes = element.attributes; |
- Expect.equals(attributes['class'], 'foo'); |
- Expect.equals(attributes['style'], 'overflow: hidden'); |
- Expect.equals(attributes['data-foo'], 'bar'); |
- Expect.equals(attributes['data-foo2'], 'bar2'); |
- Expect.equals(attributes.length, 5); |
- Expect.equals(element.dataAttributes.length, 2); |
+ expect(attributes['class'], 'foo'); |
+ expect(attributes['style'], 'overflow: hidden'); |
+ expect(attributes['data-foo'], 'bar'); |
+ expect(attributes['data-foo2'], 'bar2'); |
+ expect(attributes.length, 5); |
+ expect(element.dataAttributes.length, 2); |
element.dataAttributes['foo'] = 'baz'; |
- Expect.equals(element.dataAttributes['foo'], 'baz'); |
- Expect.equals(attributes['data-foo'], 'baz'); |
+ expect(element.dataAttributes['foo'], 'baz'); |
+ expect(attributes['data-foo'], 'baz'); |
attributes['data-foo2'] = 'baz2'; |
- Expect.equals(attributes['data-foo2'], 'baz2'); |
- Expect.equals(element.dataAttributes['foo2'], 'baz2'); |
- Expect.equals(attributes['dir'], 'rtl'); |
+ expect(attributes['data-foo2'], 'baz2'); |
+ expect(element.dataAttributes['foo2'], 'baz2'); |
+ expect(attributes['dir'], 'rtl'); |
final dataAttributes = element.dataAttributes; |
dataAttributes.remove('foo2'); |
- Expect.equals(attributes.length, 4); |
- Expect.equals(dataAttributes.length, 1); |
+ expect(attributes.length, 4); |
+ expect(dataAttributes.length, 1); |
attributes.remove('style'); |
- Expect.equals(attributes.length, 3); |
+ expect(attributes.length, 3); |
dataAttributes['foo3'] = 'baz3'; |
- Expect.equals(dataAttributes.length, 2); |
- Expect.equals(attributes.length, 4); |
+ expect(dataAttributes.length, 2); |
+ expect(attributes.length, 4); |
attributes['style'] = 'width: 300px;'; |
- Expect.equals(attributes.length, 5); |
+ expect(attributes.length, 5); |
}); |
test('coercion', () { |
final element = new Element.tag('div'); |
element.attributes['foo'] = 42; |
element.attributes['bar'] = 3.1; |
- Expect.equals(element.attributes['foo'], '42'); |
- Expect.equals(element.attributes['bar'], '3.1'); |
+ expect(element.attributes['foo'], '42'); |
+ expect(element.attributes['bar'], '3.1'); |
}); |
}); |
group('elements', () { |
test('is a subset of nodes', () { |
var el = new Element.html("<div>Foo<br/><img/></div>"); |
- Expect.equals(3, el.nodes.length); |
- Expect.equals(2, el.elements.length); |
- Expect.equals(el.nodes[1], el.elements[0]); |
- Expect.equals(el.nodes[2], el.elements[1]); |
+ expect(el.nodes.length, 3); |
+ expect(el.elements.length, 2); |
+ expect(el.nodes[1], el.elements[0]); |
+ expect(el.nodes[2], el.elements[1]); |
}); |
test('changes when an element is added to nodes', () { |
var el = new Element.html("<div>Foo<br/><img/></div>"); |
el.nodes.add(new Element.tag('hr')); |
- Expect.equals(3, el.elements.length); |
- Expect.isTrue(el.elements[2] is HRElement); |
- Expect.equals(el.nodes[3], el.elements[2]); |
+ expect(el.elements.length, 3); |
+ expect(el.elements[2], isHRElement); |
+ expect(el.nodes[3], el.elements[2]); |
}); |
test('changes nodes when an element is added', () { |
var el = new Element.html("<div>Foo<br/><img/></div>"); |
el.elements.add(new Element.tag('hr')); |
- Expect.equals(4, el.nodes.length); |
- Expect.isTrue(el.nodes[3] is HRElement); |
- Expect.equals(el.elements[2], el.nodes[3]); |
+ expect(el.nodes.length, 4); |
+ expect(el.nodes[3], isHRElement); |
+ expect(el.elements[2], el.nodes[3]); |
}); |
test('last', () { |
var el = makeElementWithChildren(); |
- Expect.isTrue(el.elements.last is InputElement); |
+ expect(el.elements.last, isInputElement); |
}); |
test('forEach', () { |
var els = []; |
var el = makeElementWithChildren(); |
el.elements.forEach((n) => els.add(n)); |
- Expect.isTrue(els[0] is BRElement); |
- Expect.isTrue(els[1] is ImageElement); |
- Expect.isTrue(els[2] is InputElement); |
+ expect(els[0], isBRElement); |
+ expect(els[1], isImageElement); |
+ expect(els[2], isInputElement); |
}); |
test('filter', () { |
var filtered = makeElementWithChildren().elements. |
filter((n) => n is ImageElement); |
- Expect.equals(1, filtered.length); |
- Expect.isTrue(filtered[0] is ImageElement); |
- Expect.isTrue(filtered is List<Element>); |
+ expect(1, filtered.length); |
+ expect(filtered[0], isImageElement); |
+ expect(filtered, isElementList); |
}); |
test('every', () { |
var el = makeElementWithChildren(); |
- Expect.isTrue(el.elements.every((n) => n is Element)); |
- Expect.isFalse(el.elements.every((n) => n is InputElement)); |
+ expect(el.elements.every((n) => n is Element), isTrue); |
+ expect(el.elements.every((n) => n is InputElement), isFalse); |
}); |
test('some', () { |
var el = makeElementWithChildren(); |
- Expect.isTrue(el.elements.some((n) => n is InputElement)); |
- Expect.isFalse(el.elements.some((n) => n is SVGElement)); |
+ expect(el.elements.some((n) => n is InputElement), isTrue); |
+ expect(el.elements.some((n) => n is SVGElement), isFalse); |
}); |
test('isEmpty', () { |
- Expect.isTrue(makeElement().elements.isEmpty); |
- Expect.isFalse(makeElementWithChildren().elements.isEmpty); |
+ expect(makeElement().elements.isEmpty, isTrue); |
+ expect(makeElementWithChildren().elements.isEmpty, isFalse); |
}); |
test('length', () { |
- Expect.equals(0, makeElement().elements.length); |
- Expect.equals(3, makeElementWithChildren().elements.length); |
+ expect(makeElement().elements.length, 0); |
+ expect(makeElementWithChildren().elements.length, 3); |
}); |
test('[]', () { |
var el = makeElementWithChildren(); |
- Expect.isTrue(el.elements[0] is BRElement); |
- Expect.isTrue(el.elements[1] is ImageElement); |
- Expect.isTrue(el.elements[2] is InputElement); |
+ expect(el.elements[0], isBRElement); |
+ expect(el.elements[1], isImageElement); |
+ expect(el.elements[2], isInputElement); |
}); |
test('[]=', () { |
var el = makeElementWithChildren(); |
el.elements[1] = new Element.tag('hr'); |
- Expect.isTrue(el.elements[0] is BRElement); |
- Expect.isTrue(el.elements[1] is HRElement); |
- Expect.isTrue(el.elements[2] is InputElement); |
+ expect(el.elements[0], isBRElement); |
+ expect(el.elements[1], isHRElement); |
+ expect(el.elements[2], isInputElement); |
}); |
test('add', () { |
var el = makeElement(); |
el.elements.add(new Element.tag('hr')); |
- Expect.isTrue(el.elements.last is HRElement); |
+ expect(el.elements.last, isHRElement); |
}); |
test('addLast', () { |
var el = makeElement(); |
el.elements.addLast(new Element.tag('hr')); |
- Expect.isTrue(el.elements.last is HRElement); |
+ expect(el.elements.last, isHRElement); |
}); |
test('iterator', () { |
@@ -572,9 +579,9 @@ |
for (var subel in el.elements) { |
els.add(subel); |
} |
- Expect.isTrue(els[0] is BRElement); |
- Expect.isTrue(els[1] is ImageElement); |
- Expect.isTrue(els[2] is InputElement); |
+ expect(els[0], isBRElement); |
+ expect(els[1], isImageElement); |
+ expect(els[2], isInputElement); |
}); |
test('addAll', () { |
@@ -584,31 +591,31 @@ |
new Element.tag('a'), |
new Element.tag('h1') |
]); |
- Expect.isTrue(el.elements[0] is BRElement); |
- Expect.isTrue(el.elements[1] is ImageElement); |
- Expect.isTrue(el.elements[2] is InputElement); |
- Expect.isTrue(el.elements[3] is SpanElement); |
- Expect.isTrue(el.elements[4] is AnchorElement); |
- Expect.isTrue(el.elements[5] is HeadingElement); |
+ expect(el.elements[0], isBRElement); |
+ expect(el.elements[1], isImageElement); |
+ expect(el.elements[2], isInputElement); |
+ expect(el.elements[3], isSpanElement); |
+ expect(el.elements[4], isAnchorElement); |
+ expect(el.elements[5], new isInstanceOf<Element>('HeadingElement')); |
}); |
test('clear', () { |
var el = makeElementWithChildren(); |
el.elements.clear(); |
- Expect.listEquals([], el.elements); |
+ expect(el.elements, equals([])); |
}); |
test('removeLast', () { |
var el = makeElementWithChildren(); |
- Expect.isTrue(el.elements.removeLast() is InputElement); |
- Expect.equals(2, el.elements.length); |
- Expect.isTrue(el.elements.removeLast() is ImageElement); |
- Expect.equals(1, el.elements.length); |
+ expect(el.elements.removeLast(), isInputElement); |
+ expect(el.elements.length, 2); |
+ expect(el.elements.removeLast(), isImageElement); |
+ expect(el.elements.length, 1); |
}); |
test('getRange', () { |
var el = makeElementWithChildren(); |
- Expect.isTrue(el.elements.getRange(1, 1) is List<Element>); |
+ expect(el.elements.getRange(1, 1), isElementList); |
}); |
}); |
@@ -631,61 +638,61 @@ |
void testUnsupported(String name, void f()) { |
test(name, () { |
- Expect.throws(f, (e) => e is UnsupportedError); |
+ expect(f, throwsUnsupportedError); |
}); |
} |
test('last', () { |
- Expect.isTrue(getQueryAll().last is HRElement); |
+ expect(getQueryAll().last, isHRElement); |
}); |
test('forEach', () { |
var els = []; |
getQueryAll().forEach((el) => els.add(el)); |
- Expect.isTrue(els[0] is AnchorElement); |
- Expect.isTrue(els[1] is SpanElement); |
- Expect.isTrue(els[2] is HRElement); |
+ expect(els[0], isAnchorElement); |
+ expect(els[1], isSpanElement); |
+ expect(els[2], isHRElement); |
}); |
test('map', () { |
var texts = getQueryAll().map((el) => el.text); |
- Expect.listEquals(['Dart!', 'Hello', ''], texts); |
+ expect(texts, equals(['Dart!', 'Hello', ''])); |
}); |
test('filter', () { |
var filtered = getQueryAll().filter((n) => n is SpanElement); |
- Expect.equals(1, filtered.length); |
- Expect.isTrue(filtered[0] is SpanElement); |
- Expect.isTrue(filtered is List<Element>); |
+ expect(filtered.length, 1); |
+ expect(filtered[0], isSpanElement); |
+ expect(filtered, isElementList); |
}); |
test('every', () { |
var el = getQueryAll(); |
- Expect.isTrue(el.every((n) => n is Element)); |
- Expect.isFalse(el.every((n) => n is SpanElement)); |
+ expect(el.every((n) => n is Element), isTrue); |
+ expect(el.every((n) => n is SpanElement), isFalse); |
}); |
test('some', () { |
var el = getQueryAll(); |
- Expect.isTrue(el.some((n) => n is SpanElement)); |
- Expect.isFalse(el.some((n) => n is SVGElement)); |
+ expect(el.some((n) => n is SpanElement), isTrue); |
+ expect(el.some((n) => n is SVGElement), isFalse); |
}); |
test('isEmpty', () { |
- Expect.isTrue(getEmptyQueryAll().isEmpty); |
- Expect.isFalse(getQueryAll().isEmpty); |
+ expect(getEmptyQueryAll().isEmpty, isTrue); |
+ expect(getQueryAll().isEmpty, isFalse); |
}); |
test('length', () { |
- Expect.equals(0, getEmptyQueryAll().length); |
- Expect.equals(3, getQueryAll().length); |
+ expect(getEmptyQueryAll().length, 0); |
+ expect(getQueryAll().length, 3); |
}); |
test('[]', () { |
var els = getQueryAll(); |
- Expect.isTrue(els[0] is AnchorElement); |
- Expect.isTrue(els[1] is SpanElement); |
- Expect.isTrue(els[2] is HRElement); |
+ expect(els[0], isAnchorElement); |
+ expect(els[1], isSpanElement); |
+ expect(els[2], isHRElement); |
}); |
test('iterator', () { |
@@ -693,13 +700,13 @@ |
for (var subel in getQueryAll()) { |
els.add(subel); |
} |
- Expect.isTrue(els[0] is AnchorElement); |
- Expect.isTrue(els[1] is SpanElement); |
- Expect.isTrue(els[2] is HRElement); |
+ expect(els[0], isAnchorElement); |
+ expect(els[1], isSpanElement); |
+ expect(els[2], isHRElement); |
}); |
test('getRange', () { |
- Expect.isTrue(getQueryAll().getRange(1, 1) is List<Element>); |
+ expect(getQueryAll().getRange(1, 1) is List<Element>, isTrue); |
}); |
testUnsupported('[]=', () => getQueryAll()[1] = new Element.tag('br')); |
@@ -733,16 +740,16 @@ |
test('filter', () { |
var filtered = makeElList().filter((n) => n is ImageElement); |
- Expect.equals(1, filtered.length); |
- Expect.isTrue(filtered[0] is ImageElement); |
- Expect.isTrue(filtered is List<Element>); |
+ expect(filtered.length, 1); |
+ expect(filtered[0], isImageElement); |
+ expect(filtered, isElementList); |
}); |
test('getRange', () { |
var range = makeElList().getRange(1, 2); |
- Expect.isTrue(range is List<Element>); |
- Expect.isTrue(range[0] is ImageElement); |
- Expect.isTrue(range[1] is InputElement); |
+ expect(range, isElementList); |
+ expect(range[0], isImageElement); |
+ expect(range[1], isInputElement); |
}); |
}); |
} |