OLD | NEW |
1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #library('DocumentFragmentTest'); | 5 #library('DocumentFragmentTest'); |
6 #import('../../pkg/unittest/unittest.dart'); | 6 #import('../../pkg/unittest/unittest.dart'); |
7 #import('../../pkg/unittest/html_config.dart'); | 7 #import('../../pkg/unittest/html_config.dart'); |
8 #import('dart:html'); | 8 #import('dart:html'); |
9 #source('util.dart'); | 9 #source('util.dart'); |
10 | 10 |
11 main() { | 11 main() { |
12 useHtmlConfiguration(); | 12 useHtmlConfiguration(); |
13 | 13 |
| 14 var isAnchorElement = |
| 15 predicate((x) => x is AnchorElement, 'is an AnchorElement'); |
| 16 |
14 Collection<String> _nodeStrings(Collection<Node> input) { | 17 Collection<String> _nodeStrings(Collection<Node> input) { |
15 var out = new List<String>(); | 18 var out = new List<String>(); |
16 for (Node n in input) { | 19 for (Node n in input) { |
17 if (n is Element) { | 20 if (n is Element) { |
18 Element e = n; | 21 Element e = n; |
19 out.add(e.tagName); | 22 out.add(e.tagName); |
20 } else { | 23 } else { |
21 out.add(n.text); | 24 out.add(n.text); |
22 } | 25 } |
23 } | 26 } |
24 return out; | 27 return out; |
25 }; | 28 }; |
26 | 29 |
27 assertConstError(void fn()) { | 30 assertConstError(void fn()) { |
28 try { | 31 try { |
29 fn(); | 32 fn(); |
30 } catch (e) { | 33 } catch (e) { |
31 if (e is UnsupportedError) { | 34 if (e is UnsupportedError) { |
32 return; | 35 return; |
33 } | 36 } |
34 } | 37 } |
35 Expect.fail('Expected immutability error'); | 38 expect(true, isFalse, reason: 'Expected immutability error'); |
36 }; | 39 }; |
37 | 40 |
38 void expectEmptyStyleDeclaration(CSSStyleDeclaration style) { | 41 void expectEmptyStyleDeclaration(CSSStyleDeclaration style) { |
39 Expect.equals("", style.cssText); | 42 expect(style.cssText, equals('')); |
40 Expect.equals("", style.getPropertyPriority('color')); | 43 expect(style.getPropertyPriority('color'), equals('')); |
41 Expect.equals("", style.item(0)); | 44 expect(style.item(0), equals('')); |
42 Expect.equals(0, style.length); | 45 expect(style.length, isZero); |
43 // TODO(jacobr): these checks throw NotImplementedExceptions in dartium. | 46 // TODO(jacobr): these checks throw NotImplementedExceptions in dartium. |
44 // Expect.isNull(style.parentRule); | 47 // expect(style.parentRule, isNull); |
45 // Expect.isNull(style.getPropertyCSSValue('color')); | 48 // expect(style.getPropertyCSSValue('color'), isNull); |
46 // Expect.isNull(style.getPropertyShorthand('color')); | 49 // expect(style.getPropertyShorthand('color'), isNull); |
47 // Expect.isFalse(style.isPropertyImplicit('color')); | 50 // expect(style.isPropertyImplicit('color'), isFalse); |
48 | 51 |
49 // Ideally these would throw errors, but it's not possible to create a class | 52 // Ideally these would throw errors, but it's not possible to create a class |
50 // that'll intercept these calls without implementing the entire | 53 // that'll intercept these calls without implementing the entire |
51 // CSSStyleDeclaration interface, so we'll settle for them being no-ops. | 54 // CSSStyleDeclaration interface, so we'll settle for them being no-ops. |
52 style.cssText = '* {color: blue}'; | 55 style.cssText = '* {color: blue}'; |
53 style.removeProperty('color'); | 56 style.removeProperty('color'); |
54 style.setProperty('color', 'blue'); | 57 style.setProperty('color', 'blue'); |
55 } | 58 } |
56 | 59 |
57 group('constructors', () { | 60 group('constructors', () { |
58 test('0-argument makes an empty fragment', () { | 61 test('0-argument makes an empty fragment', () { |
59 final fragment = new DocumentFragment(); | 62 final fragment = new DocumentFragment(); |
60 Expect.listEquals([], fragment.elements); | 63 expect(fragment.elements, equals([])); |
61 }); | 64 }); |
62 | 65 |
63 test('.html parses input as HTML', () { | 66 test('.html parses input as HTML', () { |
64 final fragment = new DocumentFragment.html('<a>foo</a>'); | 67 final fragment = new DocumentFragment.html('<a>foo</a>'); |
65 Expect.isTrue(fragment.elements[0] is AnchorElement); | 68 expect(fragment.elements[0], isAnchorElement); |
66 }); | 69 }); |
67 | 70 |
68 // test('.svg parses input as SVG', () { | 71 // test('.svg parses input as SVG', () { |
69 // final fragment = new DocumentFragment.svg('<a>foo</a>'); | 72 // final fragment = new DocumentFragment.svg('<a>foo</a>'); |
70 // Expect.isTrue(fragment.elements[0] is SVGAElement); | 73 // expect(fragment.elements[0] is SVGAElement, isTrue); |
71 // }); | 74 // }); |
72 | 75 |
73 // TODO(nweiz): enable this once XML is ported. | 76 // TODO(nweiz): enable this once XML is ported. |
74 // test('.xml parses input as XML', () { | 77 // test('.xml parses input as XML', () { |
75 // final fragment = new DocumentFragment.xml('<a>foo</a>'); | 78 // final fragment = new DocumentFragment.xml('<a>foo</a>'); |
76 // Expect.isTrue(fragment.elements[0] is XMLElement); | 79 // expect(fragment.elements[0] is XMLElement, isTrue); |
77 // }); | 80 // }); |
78 }); | 81 }); |
79 | 82 |
80 test('Unsupported operations throw errors', () { | 83 test('Unsupported operations throw errors', () { |
81 var emptyFragment = new DocumentFragment(); | 84 var emptyFragment = new DocumentFragment(); |
82 expectUnsupported(() => emptyFragment.attributes = {}); | 85 expectUnsupported(() => emptyFragment.attributes = {}); |
83 expectUnsupported(() => emptyFragment.classes = []); | 86 expectUnsupported(() => emptyFragment.classes = []); |
84 expectUnsupported(() => emptyFragment.classes.add('foo')); | 87 expectUnsupported(() => emptyFragment.classes.add('foo')); |
85 expectUnsupported(() => emptyFragment.dataAttributes = {}); | 88 expectUnsupported(() => emptyFragment.dataAttributes = {}); |
86 expectUnsupported(() => emptyFragment.contentEditable = "true"); | 89 expectUnsupported(() => emptyFragment.contentEditable = "true"); |
(...skipping 22 matching lines...) Expand all Loading... |
109 fragment = new DocumentFragment(); | 112 fragment = new DocumentFragment(); |
110 elements = fragment.elements; | 113 elements = fragment.elements; |
111 fragment.nodes.addAll( | 114 fragment.nodes.addAll( |
112 [new Text("1"), new Element.tag("A"), new Element.tag("B"), | 115 [new Text("1"), new Element.tag("A"), new Element.tag("B"), |
113 new Text("2"), new Element.tag("I"), new Text("3"), | 116 new Text("2"), new Element.tag("I"), new Text("3"), |
114 new Element.tag("U")]); | 117 new Element.tag("U")]); |
115 }; | 118 }; |
116 | 119 |
117 test('is initially empty', () { | 120 test('is initially empty', () { |
118 elements = new DocumentFragment().elements; | 121 elements = new DocumentFragment().elements; |
119 Expect.listEquals([], elements); | 122 expect(elements, equals([])); |
120 Expect.isTrue(elements.isEmpty); | 123 expect(elements.isEmpty, isTrue); |
121 }); | 124 }); |
122 | 125 |
123 test('filters out non-element nodes', () { | 126 test('filters out non-element nodes', () { |
124 init(); | 127 init(); |
125 Expect.listEquals(["1", "A", "B", "2", "I", "3", "U"], | 128 expect(_nodeStrings(fragment.nodes), |
126 _nodeStrings(fragment.nodes)); | 129 orderedEquals(["1", "A", "B", "2", "I", "3", "U"])); |
127 Expect.listEquals(["A", "B", "I", "U"], _nodeStrings(elements)); | 130 expect(_nodeStrings(elements), |
| 131 orderedEquals(["A", "B", "I", "U"])); |
128 }); | 132 }); |
129 | 133 |
130 test('only indexes elements, not other nodes', () { | 134 test('only indexes elements, not other nodes', () { |
131 init(); | 135 init(); |
132 elements[1] = new Element.tag("BR"); | 136 elements[1] = new Element.tag("BR"); |
133 Expect.listEquals(["1", "A", "BR", "2", "I", "3", "U"], | 137 expect(_nodeStrings(fragment.nodes), |
134 _nodeStrings(fragment.nodes)); | 138 orderedEquals(["1", "A", "BR", "2", "I", "3", "U"])); |
135 Expect.listEquals(["A", "BR", "I", "U"], _nodeStrings(elements)); | 139 expect(_nodeStrings(elements), |
| 140 orderedEquals(["A", "BR", "I", "U"])); |
136 }); | 141 }); |
137 | 142 |
138 test('adds to both elements and nodes', () { | 143 test('adds to both elements and nodes', () { |
139 init(); | 144 init(); |
140 elements.add(new Element.tag("UL")); | 145 elements.add(new Element.tag("UL")); |
141 Expect.listEquals(["1", "A", "B", "2", "I", "3", "U", "UL"], | 146 expect(_nodeStrings(fragment.nodes), |
142 _nodeStrings(fragment.nodes)); | 147 orderedEquals(["1", "A", "B", "2", "I", "3", "U", "UL"])); |
143 Expect.listEquals(["A", "B", "I", "U", "UL"], _nodeStrings(elements)); | 148 expect(_nodeStrings(elements), |
| 149 orderedEquals(["A", "B", "I", "U", "UL"])); |
144 }); | 150 }); |
145 | 151 |
146 test('removes only elements, from both elements and nodes', () { | 152 test('removes only elements, from both elements and nodes', () { |
147 init(); | 153 init(); |
148 Expect.equals("U", elements.removeLast().tagName); | 154 expect(elements.removeLast().tagName, equals('U')); |
149 Expect.listEquals(["1", "A", "B", "2", "I", "3"], | 155 expect(_nodeStrings(fragment.nodes), |
150 _nodeStrings(fragment.nodes)); | 156 orderedEquals(["1", "A", "B", "2", "I", "3"])); |
151 Expect.listEquals(["A", "B", "I"], _nodeStrings(elements)); | 157 expect(_nodeStrings(elements), |
| 158 orderedEquals(["A", "B", "I"])); |
152 | 159 |
153 Expect.equals("I", elements.removeLast().tagName); | 160 expect(elements.removeLast().tagName, "I"); |
154 Expect.listEquals(["1", "A", "B", "2", "3"], | 161 expect(_nodeStrings(fragment.nodes), |
155 _nodeStrings(fragment.nodes)); | 162 equals(["1", "A", "B", "2", "3"])); |
156 Expect.listEquals(["A", "B"], _nodeStrings(elements)); | 163 expect(_nodeStrings(elements), equals(["A", "B"])); |
157 }); | 164 }); |
158 | 165 |
159 test('accessors are wrapped', () { | 166 test('accessors are wrapped', () { |
160 init(); | 167 init(); |
161 Expect.equals("A", elements[0].tagName); | 168 expect(elements[0].tagName, "A"); |
162 Expect.listEquals( | 169 expect(_nodeStrings(elements.filter((e) => e.tagName == "I")), ["I"]); |
163 ["I"], _nodeStrings(elements.filter((e) => e.tagName == "I"))); | 170 expect(elements.every((e) => e is Element), isTrue); |
164 Expect.isTrue(elements.every((e) => e is Element)); | 171 expect(elements.some((e) => e.tagName == "U"), isTrue); |
165 Expect.isTrue(elements.some((e) => e.tagName == "U")); | 172 expect(elements.isEmpty, isFalse); |
166 Expect.isFalse(elements.isEmpty); | 173 expect(elements.length, 4); |
167 Expect.equals(4, elements.length); | 174 expect(elements[2].tagName, "I"); |
168 Expect.equals("I", elements[2].tagName); | 175 expect(elements.last.tagName, "U"); |
169 Expect.equals("U", elements.last.tagName); | |
170 }); | 176 }); |
171 | 177 |
172 test('setting elements overwrites nodes as well', () { | 178 test('setting elements overwrites nodes as well', () { |
173 init(); | 179 init(); |
174 fragment.elements = [new Element.tag("DIV"), new Element.tag("HEAD")]; | 180 fragment.elements = [new Element.tag("DIV"), new Element.tag("HEAD")]; |
175 Expect.listEquals(["DIV", "HEAD"], _nodeStrings(fragment.nodes)); | 181 expect(_nodeStrings(fragment.nodes), equals(["DIV", "HEAD"])); |
176 }); | 182 }); |
177 }); | 183 }); |
178 | 184 |
179 test('setting innerHTML works', () { | 185 test('setting innerHTML works', () { |
180 var fragment = new DocumentFragment(); | 186 var fragment = new DocumentFragment(); |
181 fragment.nodes.add(new Text("foo")); | 187 fragment.nodes.add(new Text("foo")); |
182 fragment.innerHTML = "<a>bar</a>baz"; | 188 fragment.innerHTML = "<a>bar</a>baz"; |
183 Expect.listEquals(["A", "baz"], _nodeStrings(fragment.nodes)); | 189 expect(_nodeStrings(fragment.nodes), equals(["A", "baz"])); |
184 }); | 190 }); |
185 | 191 |
186 test('getting innerHTML works', () { | 192 test('getting innerHTML works', () { |
187 var fragment = new DocumentFragment(); | 193 var fragment = new DocumentFragment(); |
188 fragment.nodes.addAll([new Text("foo"), new Element.html("<A>bar</A>")]); | 194 fragment.nodes.addAll([new Text("foo"), new Element.html("<A>bar</A>")]); |
189 Expect.equals("foo<a>bar</a>", fragment.innerHTML); | 195 expect(fragment.innerHTML, "foo<a>bar</a>"); |
190 Expect.equals("foo<a>bar</a>", fragment.outerHTML); | 196 expect(fragment.outerHTML, "foo<a>bar</a>"); |
191 }); | 197 }); |
192 | 198 |
193 group('insertAdjacentElement', () { | 199 group('insertAdjacentElement', () { |
194 getFragment() => new DocumentFragment.html("<a>foo</a>"); | 200 getFragment() => new DocumentFragment.html("<a>foo</a>"); |
195 | 201 |
196 test('beforeBegin does nothing', () { | 202 test('beforeBegin does nothing', () { |
197 var fragment = getFragment(); | 203 var fragment = getFragment(); |
198 Expect.isNull( | 204 expect(fragment.insertAdjacentElement("beforeBegin", |
199 fragment.insertAdjacentElement("beforeBegin", new Element.tag("b"))); | 205 new Element.tag("b")), isNull); |
200 Expect.equals("<a>foo</a>", fragment.innerHTML); | 206 expect(fragment.innerHTML, "<a>foo</a>"); |
201 }); | 207 }); |
202 | 208 |
203 test('afterEnd does nothing', () { | 209 test('afterEnd does nothing', () { |
204 var fragment = getFragment(); | 210 var fragment = getFragment(); |
205 Expect.isNull( | 211 expect(fragment.insertAdjacentElement("afterEnd", |
206 fragment.insertAdjacentElement("afterEnd", new Element.tag("b"))); | 212 new Element.tag("b")), isNull); |
207 Expect.equals("<a>foo</a>", fragment.innerHTML); | 213 expect(fragment.innerHTML, "<a>foo</a>"); |
208 }); | 214 }); |
209 | 215 |
210 test('afterBegin inserts the element', () { | 216 test('afterBegin inserts the element', () { |
211 var fragment = getFragment(); | 217 var fragment = getFragment(); |
212 var el = new Element.tag("b"); | 218 var el = new Element.tag("b"); |
213 Expect.equals(el, fragment.insertAdjacentElement("afterBegin", el)); | 219 expect(fragment.insertAdjacentElement("afterBegin", el), equals(el)); |
214 Expect.equals("<b></b><a>foo</a>", fragment.innerHTML); | 220 expect(fragment.innerHTML, "<b></b><a>foo</a>"); |
215 }); | 221 }); |
216 | 222 |
217 test('beforeEnd inserts the element', () { | 223 test('beforeEnd inserts the element', () { |
218 var fragment = getFragment(); | 224 var fragment = getFragment(); |
219 var el = new Element.tag("b"); | 225 var el = new Element.tag("b"); |
220 Expect.equals(el, fragment.insertAdjacentElement("beforeEnd", el)); | 226 expect(fragment.insertAdjacentElement("beforeEnd", el), equals(el)); |
221 Expect.equals("<a>foo</a><b></b>", fragment.innerHTML); | 227 expect(fragment.innerHTML, "<a>foo</a><b></b>"); |
222 }); | 228 }); |
223 }); | 229 }); |
224 | 230 |
225 group('insertAdjacentText', () { | 231 group('insertAdjacentText', () { |
226 getFragment() => new DocumentFragment.html("<a>foo</a>"); | 232 getFragment() => new DocumentFragment.html("<a>foo</a>"); |
227 | 233 |
228 test('beforeBegin does nothing', () { | 234 test('beforeBegin does nothing', () { |
229 var fragment = getFragment(); | 235 var fragment = getFragment(); |
230 fragment.insertAdjacentText("beforeBegin", "foo"); | 236 fragment.insertAdjacentText("beforeBegin", "foo"); |
231 Expect.equals("<a>foo</a>", fragment.innerHTML); | 237 expect(fragment.innerHTML, "<a>foo</a>"); |
232 }); | 238 }); |
233 | 239 |
234 test('afterEnd does nothing', () { | 240 test('afterEnd does nothing', () { |
235 var fragment = getFragment(); | 241 var fragment = getFragment(); |
236 fragment.insertAdjacentText("afterEnd", "foo"); | 242 fragment.insertAdjacentText("afterEnd", "foo"); |
237 Expect.equals("<a>foo</a>", fragment.innerHTML); | 243 expect(fragment.innerHTML, "<a>foo</a>"); |
238 }); | 244 }); |
239 | 245 |
240 test('afterBegin inserts the text', () { | 246 test('afterBegin inserts the text', () { |
241 var fragment = getFragment(); | 247 var fragment = getFragment(); |
242 fragment.insertAdjacentText("afterBegin", "foo"); | 248 fragment.insertAdjacentText("afterBegin", "foo"); |
243 Expect.equals("foo<a>foo</a>", fragment.innerHTML); | 249 expect(fragment.innerHTML, "foo<a>foo</a>"); |
244 }); | 250 }); |
245 | 251 |
246 test('beforeEnd inserts the text', () { | 252 test('beforeEnd inserts the text', () { |
247 var fragment = getFragment(); | 253 var fragment = getFragment(); |
248 fragment.insertAdjacentText("beforeEnd", "foo"); | 254 fragment.insertAdjacentText("beforeEnd", "foo"); |
249 Expect.equals("<a>foo</a>foo", fragment.innerHTML); | 255 expect(fragment.innerHTML, "<a>foo</a>foo"); |
250 }); | 256 }); |
251 }); | 257 }); |
252 | 258 |
253 group('insertAdjacentHTML', () { | 259 group('insertAdjacentHTML', () { |
254 getFragment() => new DocumentFragment.html("<a>foo</a>"); | 260 getFragment() => new DocumentFragment.html("<a>foo</a>"); |
255 | 261 |
256 test('beforeBegin does nothing', () { | 262 test('beforeBegin does nothing', () { |
257 var fragment = getFragment(); | 263 var fragment = getFragment(); |
258 fragment.insertAdjacentHTML("beforeBegin", "foo<br>"); | 264 fragment.insertAdjacentHTML("beforeBegin", "foo<br>"); |
259 Expect.equals("<a>foo</a>", fragment.innerHTML); | 265 expect(fragment.innerHTML, "<a>foo</a>"); |
260 }); | 266 }); |
261 | 267 |
262 test('afterEnd does nothing', () { | 268 test('afterEnd does nothing', () { |
263 var fragment = getFragment(); | 269 var fragment = getFragment(); |
264 fragment.insertAdjacentHTML("afterEnd", "<br>foo"); | 270 fragment.insertAdjacentHTML("afterEnd", "<br>foo"); |
265 Expect.equals("<a>foo</a>", fragment.innerHTML); | 271 expect(fragment.innerHTML, "<a>foo</a>"); |
266 }); | 272 }); |
267 | 273 |
268 test('afterBegin inserts the HTML', () { | 274 test('afterBegin inserts the HTML', () { |
269 var fragment = getFragment(); | 275 var fragment = getFragment(); |
270 fragment.insertAdjacentHTML("afterBegin", "foo<br>"); | 276 fragment.insertAdjacentHTML("afterBegin", "foo<br>"); |
271 Expect.equals("foo<br><a>foo</a>", fragment.innerHTML); | 277 expect(fragment.innerHTML, "foo<br><a>foo</a>"); |
272 }); | 278 }); |
273 | 279 |
274 test('beforeEnd inserts the HTML', () { | 280 test('beforeEnd inserts the HTML', () { |
275 var fragment = getFragment(); | 281 var fragment = getFragment(); |
276 fragment.insertAdjacentHTML("beforeEnd", "<br>foo"); | 282 fragment.insertAdjacentHTML("beforeEnd", "<br>foo"); |
277 Expect.equals("<a>foo</a><br>foo", fragment.innerHTML); | 283 expect(fragment.innerHTML, "<a>foo</a><br>foo"); |
278 }); | 284 }); |
279 }); | 285 }); |
280 | 286 |
281 // Just test that these methods don't throw errors | 287 // Just test that these methods don't throw errors |
282 test("no-op methods don't throw errors", () { | 288 test("no-op methods don't throw errors", () { |
283 var fragment = new DocumentFragment(); | 289 var fragment = new DocumentFragment(); |
284 fragment.on.click.add((e) => null); | 290 fragment.on.click.add((e) => null); |
285 fragment.blur(); | 291 fragment.blur(); |
286 fragment.focus(); | 292 fragment.focus(); |
287 fragment.click(); | 293 fragment.click(); |
288 fragment.scrollByLines(2); | 294 fragment.scrollByLines(2); |
289 fragment.scrollByPages(2); | 295 fragment.scrollByPages(2); |
290 fragment.scrollIntoView(); | 296 fragment.scrollIntoView(); |
291 fragment.webkitRequestFullScreen(2); | 297 fragment.webkitRequestFullScreen(2); |
292 }); | 298 }); |
293 | 299 |
294 test('default values', () { | 300 test('default values', () { |
295 var fragment = new DocumentFragment(); | 301 var fragment = new DocumentFragment(); |
296 fragment.rect.then(expectAsync1((ElementRect rect) { | 302 fragment.rect.then(expectAsync1((ElementRect rect) { |
297 expectEmptyRect(rect.client); | 303 expectEmptyRect(rect.client); |
298 expectEmptyRect(rect.offset); | 304 expectEmptyRect(rect.offset); |
299 expectEmptyRect(rect.scroll); | 305 expectEmptyRect(rect.scroll); |
300 expectEmptyRect(rect.bounding); | 306 expectEmptyRect(rect.bounding); |
301 Expect.isTrue(rect.clientRects.isEmpty); | 307 expect(rect.clientRects.isEmpty, isTrue); |
302 })); | 308 })); |
303 Expect.equals("false", fragment.contentEditable); | 309 expect(fragment.contentEditable, "false"); |
304 Expect.equals(-1, fragment.tabIndex); | 310 expect(fragment.tabIndex, -1); |
305 Expect.equals("", fragment.id); | 311 expect(fragment.id, ""); |
306 Expect.equals("", fragment.title); | 312 expect(fragment.title, ""); |
307 Expect.equals("", fragment.tagName); | 313 expect(fragment.tagName, ""); |
308 Expect.equals("", fragment.webkitdropzone); | 314 expect(fragment.webkitdropzone, ""); |
309 Expect.equals("", fragment.webkitRegionOverflow); | 315 expect(fragment.webkitRegionOverflow, ""); |
310 Expect.isFalse(fragment.isContentEditable); | 316 expect(fragment.isContentEditable, isFalse); |
311 Expect.isFalse(fragment.draggable); | 317 expect(fragment.draggable, isFalse); |
312 Expect.isFalse(fragment.hidden); | 318 expect(fragment.hidden, isFalse); |
313 Expect.isFalse(fragment.spellcheck); | 319 expect(fragment.spellcheck, isFalse); |
314 Expect.isFalse(fragment.translate); | 320 expect(fragment.translate, isFalse); |
315 Expect.isNull(fragment.nextElementSibling); | 321 expect(fragment.nextElementSibling, isNull); |
316 Expect.isNull(fragment.previousElementSibling); | 322 expect(fragment.previousElementSibling, isNull); |
317 Expect.isNull(fragment.offsetParent); | 323 expect(fragment.offsetParent, isNull); |
318 Expect.isNull(fragment.parent); | 324 expect(fragment.parent, isNull); |
319 Expect.isTrue(fragment.attributes.isEmpty); | 325 expect(fragment.attributes.isEmpty, isTrue); |
320 Expect.isTrue(fragment.classes.isEmpty); | 326 expect(fragment.classes.isEmpty, isTrue); |
321 Expect.isTrue(fragment.dataAttributes.isEmpty); | 327 expect(fragment.dataAttributes.isEmpty, isTrue); |
322 Expect.isFalse(fragment.matchesSelector("foo")); | 328 expect(fragment.matchesSelector("foo"), isFalse); |
323 Expect.isFalse(fragment.matchesSelector("*")); | 329 expect(fragment.matchesSelector("*"), isFalse); |
324 }); | 330 }); |
325 | 331 |
326 test('style', () { | 332 test('style', () { |
327 var fragment = new DocumentFragment(); | 333 var fragment = new DocumentFragment(); |
328 var style = fragment.style; | 334 var style = fragment.style; |
329 expectEmptyStyleDeclaration(style); | 335 expectEmptyStyleDeclaration(style); |
330 fragment.computedStyle.then(expectAsync1((computedStyle) { | 336 fragment.computedStyle.then(expectAsync1((computedStyle) { |
331 expectEmptyStyleDeclaration(computedStyle); | 337 expectEmptyStyleDeclaration(computedStyle); |
332 })); | 338 })); |
333 }); | 339 }); |
334 | 340 |
335 // TODO(nweiz): re-enable when const is better supported in dartc and/or frog | 341 // TODO(nweiz): re-enable when const is better supported in dartc and/or frog |
336 // test('const fields are immutable', () { | 342 // test('const fields are immutable', () { |
337 // var fragment = new DocumentFragment(); | 343 // var fragment = new DocumentFragment(); |
338 // assertConstError(() => fragment.attributes['title'] = 'foo'); | 344 // assertConstError(() => fragment.attributes['title'] = 'foo'); |
339 // assertConstError(() => fragment.dataAttributes['title'] = 'foo'); | 345 // assertConstError(() => fragment.dataAttributes['title'] = 'foo'); |
340 // fragment.rect.then((ElementRect rect) { | 346 // fragment.rect.then((ElementRect rect) { |
341 // assertConstError(() => rect.clientRects.add(null)); | 347 // assertConstError(() => rect.clientRects.add(null)); |
342 // callbackDone(); | 348 // callbackDone(); |
343 // }); | 349 // }); |
344 // // Issue 174: #classes is currently not const | 350 // // Issue 174: #classes is currently not const |
345 // // assertConstError(() => fragment.classes.add('foo')); | 351 // // assertConstError(() => fragment.classes.add('foo')); |
346 // }); | 352 // }); |
347 | 353 |
348 test('query searches the fragment', () { | 354 test('query searches the fragment', () { |
349 var fragment = new DocumentFragment.html( | 355 var fragment = new DocumentFragment.html( |
350 "<div class='foo'><a>foo</a><b>bar</b></div>"); | 356 "<div class='foo'><a>foo</a><b>bar</b></div>"); |
351 Expect.equals("A", fragment.query(".foo a").tagName); | 357 expect(fragment.query(".foo a").tagName, "A"); |
352 Expect.listEquals(["A", "B"], _nodeStrings(fragment.queryAll(".foo *"))); | 358 expect(_nodeStrings(fragment.queryAll(".foo *")), equals(["A", "B"])); |
353 }); | 359 }); |
354 } | 360 } |
OLD | NEW |