| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
| 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. | |
| 4 | |
| 5 #library('XMLElementTest'); | |
| 6 #import('../../../../lib/unittest/unittest.dart'); | |
| 7 #import('../../../../lib/unittest/html_config.dart'); | |
| 8 #import('dart:html'); | |
| 9 | |
| 10 main() { | |
| 11 useHtmlConfiguration(); | |
| 12 | |
| 13 XMLElement makeElement() => new XMLElement.xml("<xml><foo/><bar/></xml>"); | |
| 14 | |
| 15 makeElementWithParent() { | |
| 16 final parent = new XMLElement.xml( | |
| 17 "<parent><before/><xml><foo/><bar/></xml><after/></parent>"); | |
| 18 return parent.elements[1]; | |
| 19 } | |
| 20 | |
| 21 group('constructors', () { | |
| 22 group('.xml', () { | |
| 23 test('with a well-formed document', () { | |
| 24 final el = makeElement(); | |
| 25 Expect.isTrue(el is XMLElement); | |
| 26 Expect.equals('foo', el.elements[0].tagName); | |
| 27 Expect.equals('bar', el.elements[1].tagName); | |
| 28 }); | |
| 29 | |
| 30 test('with too many nodes', () { | |
| 31 Expect.throws(() => new XMLElement.xml("<xml></xml>foo"), | |
| 32 (e) => e is IllegalArgumentException); | |
| 33 }); | |
| 34 | |
| 35 test('with a parse error', () { | |
| 36 Expect.throws(() => new XMLElement.xml("<xml></xml>>"), | |
| 37 (e) => e is IllegalArgumentException); | |
| 38 }); | |
| 39 | |
| 40 test('with a PARSERERROR tag', () { | |
| 41 final el = new XMLElement.xml("<xml><parsererror /></xml>"); | |
| 42 Expect.equals('parsererror', el.elements[0].tagName); | |
| 43 }); | |
| 44 | |
| 45 test('has no parent', () => | |
| 46 Expect.isNull(new XMLElement.xml('<foo/>').parent)); | |
| 47 }); | |
| 48 | |
| 49 test('.tag', () { | |
| 50 final el = new XMLElement.tag('foo'); | |
| 51 Expect.isTrue(el is XMLElement); | |
| 52 Expect.equals('foo', el.tagName); | |
| 53 }); | |
| 54 }); | |
| 55 | |
| 56 // FilteredElementList is tested more thoroughly in DocumentFragmentTests. | |
| 57 group('elements', () { | |
| 58 test('filters out non-element nodes', () { | |
| 59 final el = new XMLElement.xml("<xml>1<a/><b/>2<c/>3<d/></xml>"); | |
| 60 Expect.listEquals(["a", "b", "c", "d"], el.elements.map((e) => e.tagName))
; | |
| 61 }); | |
| 62 | |
| 63 test('overwrites nodes when set', () { | |
| 64 final el = new XMLElement.xml("<xml>1<a/><b/>2<c/>3<d/></xml>"); | |
| 65 el.elements = [new XMLElement.tag('x'), new XMLElement.tag('y')]; | |
| 66 Expect.equals("<xml><x></x><y></y></xml>", el.outerHTML); | |
| 67 }); | |
| 68 }); | |
| 69 | |
| 70 group('classes', () { | |
| 71 XMLElement makeElementWithClasses() => | |
| 72 new XMLElement.xml("<xml class='foo bar baz'></xml>"); | |
| 73 | |
| 74 Set<String> makeClassSet() => makeElementWithClasses().classes; | |
| 75 | |
| 76 test('affects the "class" attribute', () { | |
| 77 final el = makeElementWithClasses(); | |
| 78 el.classes.add('qux'); | |
| 79 Expect.setEquals(['foo', 'bar', 'baz', 'qux'], | |
| 80 el.attributes['class'].split(' ')); | |
| 81 }); | |
| 82 | |
| 83 test('is affected by the "class" attribute', () { | |
| 84 final el = makeElementWithClasses(); | |
| 85 el.attributes['class'] = 'foo qux'; | |
| 86 Expect.setEquals(['foo', 'qux'], el.classes); | |
| 87 }); | |
| 88 | |
| 89 test('classes=', () { | |
| 90 final el = makeElementWithClasses(); | |
| 91 el.classes = ['foo', 'qux']; | |
| 92 Expect.setEquals(['foo', 'qux'], el.classes); | |
| 93 Expect.setEquals(['foo', 'qux'], el.attributes['class'].split(' ')); | |
| 94 }); | |
| 95 | |
| 96 test('toString', () { | |
| 97 Expect.setEquals(['foo', 'bar', 'baz'], | |
| 98 makeClassSet().toString().split(' ')); | |
| 99 Expect.equals('', makeElement().classes.toString()); | |
| 100 }); | |
| 101 | |
| 102 test('forEach', () { | |
| 103 final classes = <String>[]; | |
| 104 makeClassSet().forEach(classes.add); | |
| 105 Expect.setEquals(['foo', 'bar', 'baz'], classes); | |
| 106 }); | |
| 107 | |
| 108 test('iterator', () { | |
| 109 final classes = <String>[]; | |
| 110 for (var el in makeClassSet()) { | |
| 111 classes.add(el); | |
| 112 } | |
| 113 Expect.setEquals(['foo', 'bar', 'baz'], classes); | |
| 114 }); | |
| 115 | |
| 116 test('map', () { | |
| 117 Expect.setEquals(['FOO', 'BAR', 'BAZ'], | |
| 118 makeClassSet().map((c) => c.toUpperCase())); | |
| 119 }); | |
| 120 | |
| 121 test('filter', () { | |
| 122 Expect.setEquals(['bar', 'baz'], | |
| 123 makeClassSet().filter((c) => c.contains('a'))); | |
| 124 }); | |
| 125 | |
| 126 test('every', () { | |
| 127 Expect.isTrue(makeClassSet().every((c) => c is String)); | |
| 128 Expect.isFalse( | |
| 129 makeClassSet().every((c) => c.contains('a'))); | |
| 130 }); | |
| 131 | |
| 132 test('some', () { | |
| 133 Expect.isTrue( | |
| 134 makeClassSet().some((c) => c.contains('a'))); | |
| 135 Expect.isFalse(makeClassSet().some((c) => c is num)); | |
| 136 }); | |
| 137 | |
| 138 test('isEmpty', () { | |
| 139 Expect.isFalse(makeClassSet().isEmpty()); | |
| 140 Expect.isTrue(makeElement().classes.isEmpty()); | |
| 141 }); | |
| 142 | |
| 143 test('length', () { | |
| 144 Expect.equals(3, makeClassSet().length); | |
| 145 Expect.equals(0, makeElement().classes.length); | |
| 146 }); | |
| 147 | |
| 148 test('contains', () { | |
| 149 Expect.isTrue(makeClassSet().contains('foo')); | |
| 150 Expect.isFalse(makeClassSet().contains('qux')); | |
| 151 }); | |
| 152 | |
| 153 test('add', () { | |
| 154 final classes = makeClassSet(); | |
| 155 classes.add('qux'); | |
| 156 Expect.setEquals(['foo', 'bar', 'baz', 'qux'], classes); | |
| 157 | |
| 158 classes.add('qux'); | |
| 159 final list = new List.from(classes); | |
| 160 list.sort((a, b) => a.compareTo(b)); | |
| 161 Expect.listEquals(['bar', 'baz', 'foo', 'qux'], list, | |
| 162 "The class set shouldn't have duplicate elements."); | |
| 163 }); | |
| 164 | |
| 165 test('remove', () { | |
| 166 final classes = makeClassSet(); | |
| 167 classes.remove('bar'); | |
| 168 Expect.setEquals(['foo', 'baz'], classes); | |
| 169 classes.remove('qux'); | |
| 170 Expect.setEquals(['foo', 'baz'], classes); | |
| 171 }); | |
| 172 | |
| 173 test('addAll', () { | |
| 174 final classes = makeClassSet(); | |
| 175 classes.addAll(['bar', 'qux', 'bip']); | |
| 176 Expect.setEquals(['foo', 'bar', 'baz', 'qux', 'bip'], classes); | |
| 177 }); | |
| 178 | |
| 179 test('removeAll', () { | |
| 180 final classes = makeClassSet(); | |
| 181 classes.removeAll(['bar', 'baz', 'qux']); | |
| 182 Expect.setEquals(['foo'], classes); | |
| 183 }); | |
| 184 | |
| 185 test('isSubsetOf', () { | |
| 186 final classes = makeClassSet(); | |
| 187 Expect.isTrue(classes.isSubsetOf(['foo', 'bar', 'baz'])); | |
| 188 Expect.isTrue(classes.isSubsetOf(['foo', 'bar', 'baz', 'qux'])); | |
| 189 Expect.isFalse(classes.isSubsetOf(['foo', 'bar', 'qux'])); | |
| 190 }); | |
| 191 | |
| 192 test('containsAll', () { | |
| 193 final classes = makeClassSet(); | |
| 194 Expect.isTrue(classes.containsAll(['foo', 'baz'])); | |
| 195 Expect.isFalse(classes.containsAll(['foo', 'qux'])); | |
| 196 }); | |
| 197 | |
| 198 test('intersection', () { | |
| 199 final classes = makeClassSet(); | |
| 200 Expect.setEquals(['foo', 'baz'], | |
| 201 classes.intersection(['foo', 'qux', 'baz'])); | |
| 202 }); | |
| 203 | |
| 204 test('clear', () { | |
| 205 final classes = makeClassSet(); | |
| 206 classes.clear(); | |
| 207 Expect.setEquals([], classes); | |
| 208 }); | |
| 209 }); | |
| 210 | |
| 211 test("no-op methods don't throw errors", () { | |
| 212 final el = makeElement(); | |
| 213 el.on.click.add((e) => null); | |
| 214 el.blur(); | |
| 215 el.focus(); | |
| 216 el.scrollByLines(2); | |
| 217 el.scrollByPages(2); | |
| 218 el.scrollIntoView(); | |
| 219 }); | |
| 220 | |
| 221 group('properties that map to attributes', () { | |
| 222 group('contentEditable', () { | |
| 223 test('get', () { | |
| 224 final el = makeElement(); | |
| 225 Expect.equals('inherit', el.contentEditable); | |
| 226 el.attributes['contentEditable'] = 'foo'; | |
| 227 Expect.equals('foo', el.contentEditable); | |
| 228 }); | |
| 229 | |
| 230 test('set', () { | |
| 231 final el = makeElement(); | |
| 232 el.contentEditable = 'foo'; | |
| 233 Expect.equals('foo', el.attributes['contentEditable']); | |
| 234 }); | |
| 235 | |
| 236 test('isContentEditable', () { | |
| 237 final el = makeElement(); | |
| 238 Expect.isFalse(el.isContentEditable); | |
| 239 el.contentEditable = 'true'; | |
| 240 Expect.isFalse(el.isContentEditable); | |
| 241 }); | |
| 242 }); | |
| 243 | |
| 244 group('draggable', () { | |
| 245 test('get', () { | |
| 246 final el = makeElement(); | |
| 247 Expect.isFalse(el.draggable); | |
| 248 el.attributes['draggable'] = 'true'; | |
| 249 Expect.isTrue(el.draggable); | |
| 250 el.attributes['draggable'] = 'foo'; | |
| 251 Expect.isFalse(el.draggable); | |
| 252 }); | |
| 253 | |
| 254 test('set', () { | |
| 255 final el = makeElement(); | |
| 256 el.draggable = true; | |
| 257 Expect.equals('true', el.attributes['draggable']); | |
| 258 el.draggable = false; | |
| 259 Expect.equals('false', el.attributes['draggable']); | |
| 260 }); | |
| 261 }); | |
| 262 | |
| 263 group('spellcheck', () { | |
| 264 test('get', () { | |
| 265 final el = makeElement(); | |
| 266 Expect.isFalse(el.spellcheck); | |
| 267 el.attributes['spellcheck'] = 'true'; | |
| 268 Expect.isTrue(el.spellcheck); | |
| 269 el.attributes['spellcheck'] = 'foo'; | |
| 270 Expect.isFalse(el.spellcheck); | |
| 271 }); | |
| 272 | |
| 273 test('set', () { | |
| 274 final el = makeElement(); | |
| 275 el.spellcheck = true; | |
| 276 Expect.equals('true', el.attributes['spellcheck']); | |
| 277 el.spellcheck = false; | |
| 278 Expect.equals('false', el.attributes['spellcheck']); | |
| 279 }); | |
| 280 }); | |
| 281 | |
| 282 group('hidden', () { | |
| 283 test('get', () { | |
| 284 final el = makeElement(); | |
| 285 Expect.isFalse(el.hidden); | |
| 286 el.attributes['hidden'] = ''; | |
| 287 Expect.isTrue(el.hidden); | |
| 288 }); | |
| 289 | |
| 290 test('set', () { | |
| 291 final el = makeElement(); | |
| 292 el.hidden = true; | |
| 293 Expect.equals('', el.attributes['hidden']); | |
| 294 el.hidden = false; | |
| 295 Expect.isFalse(el.attributes.containsKey('hidden')); | |
| 296 }); | |
| 297 }); | |
| 298 | |
| 299 group('tabIndex', () { | |
| 300 test('get', () { | |
| 301 final el = makeElement(); | |
| 302 Expect.equals(0, el.tabIndex); | |
| 303 el.attributes['tabIndex'] = '2'; | |
| 304 Expect.equals(2, el.tabIndex); | |
| 305 el.attributes['tabIndex'] = 'foo'; | |
| 306 Expect.equals(0, el.tabIndex); | |
| 307 }); | |
| 308 | |
| 309 test('set', () { | |
| 310 final el = makeElement(); | |
| 311 el.tabIndex = 15; | |
| 312 Expect.equals('15', el.attributes['tabIndex']); | |
| 313 }); | |
| 314 }); | |
| 315 | |
| 316 group('id', () { | |
| 317 test('get', () { | |
| 318 final el = makeElement(); | |
| 319 Expect.equals('', el.id); | |
| 320 el.attributes['id'] = 'foo'; | |
| 321 Expect.equals('foo', el.id); | |
| 322 }); | |
| 323 | |
| 324 test('set', () { | |
| 325 final el = makeElement(); | |
| 326 el.id = 'foo'; | |
| 327 Expect.equals('foo', el.attributes['id']); | |
| 328 }); | |
| 329 }); | |
| 330 | |
| 331 group('title', () { | |
| 332 test('get', () { | |
| 333 final el = makeElement(); | |
| 334 Expect.equals('', el.title); | |
| 335 el.attributes['title'] = 'foo'; | |
| 336 Expect.equals('foo', el.title); | |
| 337 }); | |
| 338 | |
| 339 test('set', () { | |
| 340 final el = makeElement(); | |
| 341 el.title = 'foo'; | |
| 342 Expect.equals('foo', el.attributes['title']); | |
| 343 }); | |
| 344 }); | |
| 345 | |
| 346 group('webkitdropzone', () { | |
| 347 test('get', () { | |
| 348 final el = makeElement(); | |
| 349 Expect.equals('', el.webkitdropzone); | |
| 350 el.attributes['webkitdropzone'] = 'foo'; | |
| 351 Expect.equals('foo', el.webkitdropzone); | |
| 352 }); | |
| 353 | |
| 354 test('set', () { | |
| 355 final el = makeElement(); | |
| 356 el.webkitdropzone = 'foo'; | |
| 357 Expect.equals('foo', el.attributes['webkitdropzone']); | |
| 358 }); | |
| 359 }); | |
| 360 | |
| 361 group('lang', () { | |
| 362 test('get', () { | |
| 363 final el = makeElement(); | |
| 364 Expect.equals('', el.lang); | |
| 365 el.attributes['lang'] = 'foo'; | |
| 366 Expect.equals('foo', el.lang); | |
| 367 }); | |
| 368 | |
| 369 test('set', () { | |
| 370 final el = makeElement(); | |
| 371 el.lang = 'foo'; | |
| 372 Expect.equals('foo', el.attributes['lang']); | |
| 373 }); | |
| 374 }); | |
| 375 | |
| 376 group('dir', () { | |
| 377 test('get', () { | |
| 378 final el = makeElement(); | |
| 379 Expect.equals('', el.dir); | |
| 380 el.attributes['dir'] = 'foo'; | |
| 381 Expect.equals('foo', el.dir); | |
| 382 }); | |
| 383 | |
| 384 test('set', () { | |
| 385 final el = makeElement(); | |
| 386 el.dir = 'foo'; | |
| 387 Expect.equals('foo', el.attributes['dir']); | |
| 388 }); | |
| 389 }); | |
| 390 }); | |
| 391 | |
| 392 test('set innerHTML', () { | |
| 393 final el = makeElement(); | |
| 394 el.innerHTML = "<foo>Bar<baz/></foo>"; | |
| 395 Expect.equals(1, el.nodes.length); | |
| 396 final node = el.nodes[0]; | |
| 397 Expect.isTrue(node is XMLElement); | |
| 398 Expect.equals('foo', node.tagName); | |
| 399 Expect.equals('Bar', node.nodes[0].text); | |
| 400 Expect.equals('baz', node.nodes[1].tagName); | |
| 401 }); | |
| 402 | |
| 403 test('get innerHTML/outerHTML', () { | |
| 404 final el = makeElement(); | |
| 405 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 406 el.nodes.clear(); | |
| 407 el.nodes.addAll([new Text("foo"), new XMLElement.xml("<a>bar</a>")]); | |
| 408 Expect.equals("foo<a>bar</a>", el.innerHTML); | |
| 409 Expect.equals("<xml>foo<a>bar</a></xml>", el.outerHTML); | |
| 410 }); | |
| 411 | |
| 412 test('query', () { | |
| 413 final el = makeElement(); | |
| 414 Expect.equals("foo", el.query('foo').tagName); | |
| 415 Expect.isNull(el.query('baz')); | |
| 416 }); | |
| 417 | |
| 418 test('queryAll', () { | |
| 419 final el = new XMLElement.xml( | |
| 420 "<xml><foo id='f1' /><bar><foo id='f2' /></bar></xml>"); | |
| 421 Expect.listEquals(["f1", "f2"], el.queryAll('foo').map((e) => e.id)); | |
| 422 Expect.listEquals([], el.queryAll('baz')); | |
| 423 }); | |
| 424 | |
| 425 // TODO(nweiz): re-enable this when matchesSelector works cross-browser. | |
| 426 // | |
| 427 // test('matchesSelector', () { | |
| 428 // final el = makeElement(); | |
| 429 // Expect.isTrue(el.matchesSelector('*')); | |
| 430 // Expect.isTrue(el.matchesSelector('xml')); | |
| 431 // Expect.isFalse(el.matchesSelector('html')); | |
| 432 // }); | |
| 433 | |
| 434 group('insertAdjacentElement', () { | |
| 435 test('beforeBegin with no parent does nothing', () { | |
| 436 final el = makeElement(); | |
| 437 Expect.isNull( | |
| 438 el.insertAdjacentElement("beforeBegin", new XMLElement.tag("b"))); | |
| 439 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 440 }); | |
| 441 | |
| 442 test('afterEnd with no parent does nothing', () { | |
| 443 final el = makeElement(); | |
| 444 Expect.isNull( | |
| 445 el.insertAdjacentElement("afterEnd", new XMLElement.tag("b"))); | |
| 446 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 447 }); | |
| 448 | |
| 449 test('beforeBegin with parent inserts the element', () { | |
| 450 final el = makeElementWithParent(); | |
| 451 final newEl = new XMLElement.tag("b"); | |
| 452 Expect.equals(newEl, el.insertAdjacentElement("beforeBegin", newEl)); | |
| 453 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 454 Expect.equals("<before></before><b></b><xml><foo></foo><bar></bar>" + | |
| 455 "</xml><after></after>", el.parent.innerHTML); | |
| 456 }); | |
| 457 | |
| 458 test('afterEnd with parent inserts the element', () { | |
| 459 final el = makeElementWithParent(); | |
| 460 final newEl = new XMLElement.tag("b"); | |
| 461 Expect.equals(newEl, el.insertAdjacentElement("afterEnd", newEl)); | |
| 462 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 463 Expect.equals("<before></before><xml><foo></foo><bar></bar></xml><b>" + | |
| 464 "</b><after></after>", el.parent.innerHTML); | |
| 465 }); | |
| 466 | |
| 467 test('afterBegin inserts the element', () { | |
| 468 final el = makeElement(); | |
| 469 final newEl = new XMLElement.tag("b"); | |
| 470 Expect.equals(newEl, el.insertAdjacentElement("afterBegin", newEl)); | |
| 471 Expect.equals("<b></b><foo></foo><bar></bar>", el.innerHTML); | |
| 472 }); | |
| 473 | |
| 474 test('beforeEnd inserts the element', () { | |
| 475 final el = makeElement(); | |
| 476 final newEl = new XMLElement.tag("b"); | |
| 477 Expect.equals(newEl, el.insertAdjacentElement("beforeEnd", newEl)); | |
| 478 Expect.equals("<foo></foo><bar></bar><b></b>", el.innerHTML); | |
| 479 }); | |
| 480 }); | |
| 481 | |
| 482 group('insertAdjacentText', () { | |
| 483 test('beforeBegin with no parent does nothing', () { | |
| 484 final el = makeElement(); | |
| 485 el.insertAdjacentText("beforeBegin", "foo"); | |
| 486 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 487 }); | |
| 488 | |
| 489 test('afterEnd with no parent does nothing', () { | |
| 490 final el = makeElement(); | |
| 491 el.insertAdjacentText("afterEnd", "foo"); | |
| 492 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 493 }); | |
| 494 | |
| 495 test('beforeBegin with parent inserts the text', () { | |
| 496 final el = makeElementWithParent(); | |
| 497 el.insertAdjacentText("beforeBegin", "foo"); | |
| 498 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 499 Expect.equals("<before></before>foo<xml><foo></foo><bar></bar></xml>" + | |
| 500 "<after></after>", el.parent.innerHTML); | |
| 501 }); | |
| 502 | |
| 503 test('afterEnd with parent inserts the text', () { | |
| 504 final el = makeElementWithParent(); | |
| 505 el.insertAdjacentText("afterEnd", "foo"); | |
| 506 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 507 Expect.equals("<before></before><xml><foo></foo><bar></bar></xml>foo" + | |
| 508 "<after></after>", el.parent.innerHTML); | |
| 509 }); | |
| 510 | |
| 511 test('afterBegin inserts the text', () { | |
| 512 final el = makeElement(); | |
| 513 el.insertAdjacentText("afterBegin", "foo"); | |
| 514 Expect.equals("foo<foo></foo><bar></bar>", el.innerHTML); | |
| 515 }); | |
| 516 | |
| 517 test('beforeEnd inserts the text', () { | |
| 518 final el = makeElement(); | |
| 519 el.insertAdjacentText("beforeEnd", "foo"); | |
| 520 Expect.equals("<foo></foo><bar></bar>foo", el.innerHTML); | |
| 521 }); | |
| 522 }); | |
| 523 | |
| 524 group('insertAdjacentHTML', () { | |
| 525 test('beforeBegin with no parent does nothing', () { | |
| 526 final el = makeElement(); | |
| 527 el.insertAdjacentHTML("beforeBegin", "foo<b/>"); | |
| 528 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 529 }); | |
| 530 | |
| 531 test('afterEnd with no parent does nothing', () { | |
| 532 final el = makeElement(); | |
| 533 el.insertAdjacentHTML("afterEnd", "<b/>foo"); | |
| 534 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 535 }); | |
| 536 | |
| 537 test('beforeBegin with parent inserts the HTML', () { | |
| 538 final el = makeElementWithParent(); | |
| 539 el.insertAdjacentHTML("beforeBegin", "foo<b/>"); | |
| 540 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 541 Expect.equals("<before></before>foo<b></b><xml><foo></foo><bar></bar>" + | |
| 542 "</xml><after></after>", el.parent.innerHTML); | |
| 543 }); | |
| 544 | |
| 545 test('afterEnd with parent inserts the HTML', () { | |
| 546 final el = makeElementWithParent(); | |
| 547 el.insertAdjacentHTML("afterEnd", "foo<b/>"); | |
| 548 Expect.equals("<foo></foo><bar></bar>", el.innerHTML); | |
| 549 Expect.equals("<before></before><xml><foo></foo><bar></bar></xml>foo" + | |
| 550 "<b></b><after></after>", el.parent.innerHTML); | |
| 551 }); | |
| 552 | |
| 553 test('afterBegin inserts the HTML', () { | |
| 554 final el = makeElement(); | |
| 555 el.insertAdjacentHTML("afterBegin", "foo<b/>"); | |
| 556 Expect.equals("foo<b></b><foo></foo><bar></bar>", el.innerHTML); | |
| 557 }); | |
| 558 | |
| 559 test('beforeEnd inserts the HTML', () { | |
| 560 final el = makeElement(); | |
| 561 el.insertAdjacentHTML("beforeEnd", "<b/>foo"); | |
| 562 Expect.equals("<foo></foo><bar></bar><b></b>foo", el.innerHTML); | |
| 563 }); | |
| 564 }); | |
| 565 | |
| 566 asyncTest('default rect values', 1, () { | |
| 567 makeElement().rect.then((ElementRect rect) { | |
| 568 expectEmptyRect(rect.client); | |
| 569 expectEmptyRect(rect.offset); | |
| 570 expectEmptyRect(rect.scroll); | |
| 571 expectEmptyRect(rect.bounding); | |
| 572 Expect.isTrue(rect.clientRects.isEmpty()); | |
| 573 callbackDone(); | |
| 574 }); | |
| 575 }); | |
| 576 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10173019:
Revert "Break html_tests.dart into multiple tests" (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart