Deprecating Element.elements for Element.children.

tests/html/documentfragment_test.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library DocumentFragmentTest;
 import '../../pkg/unittest/lib/unittest.dart';
 import '../../pkg/unittest/lib/html_config.dart';
 import 'dart:html';
 part 'util.dart';
 
@@ skipping 42 matching lines @@
     // that'll intercept these calls without implementing the entire
     // CSSStyleDeclaration interface, so we'll settle for them being no-ops.
     style.cssText = '* {color: blue}';
     style.removeProperty('color');
     style.setProperty('color', 'blue');
   }
 
   group('constructors', () {
     test('0-argument makes an empty fragment', () {
       final fragment = new DocumentFragment();
-      expect(fragment.elements, equals([]));
+      expect(fragment.children, equals([]));
     });
 
     test('.html parses input as HTML', () {
       final fragment = new DocumentFragment.html('<a>foo</a>');
-      expect(fragment.elements[0], isAnchorElement);
+      expect(fragment.children[0], isAnchorElement);
     });
 
     // test('.svg parses input as SVG', () {
     //   final fragment = new DocumentFragment.svg('<a>foo</a>');
-    //   expect(fragment.elements[0] is SVGAElement, isTrue);
+    //   expect(fragment.children[0] is SVGAElement, isTrue);
     // });
 
     // TODO(nweiz): enable this once XML is ported.
     // test('.xml parses input as XML', () {
     //   final fragment = new DocumentFragment.xml('<a>foo</a>');
-    //   expect(fragment.elements[0] is XMLElement, isTrue);
+    //   expect(fragment.children[0] is XMLElement, isTrue);
     // });
   });
 
   test('Unsupported operations throw errors', () {
     var emptyFragment = new DocumentFragment();
     expectUnsupported(() => emptyFragment.attributes = {});
     expectUnsupported(() => emptyFragment.classes = []);
     expectUnsupported(() => emptyFragment.classes.add('foo'));
     expectUnsupported(() => emptyFragment.dataAttributes = {});
     expectUnsupported(() => emptyFragment.contentEditable = "true");
     expectUnsupported(() => emptyFragment.dir);
     expectUnsupported(() => emptyFragment.dir = "ltr");
     expectUnsupported(() => emptyFragment.draggable = true);
     expectUnsupported(() => emptyFragment.hidden = true);
     expectUnsupported(() => emptyFragment.id = "foo");
     expectUnsupported(() => emptyFragment.lang);
     expectUnsupported(() => emptyFragment.lang = "en");
     expectUnsupported(() => emptyFragment.scrollLeft = 10);
     expectUnsupported(() => emptyFragment.scrollTop = 10);
     expectUnsupported(() => emptyFragment.spellcheck = true);
     expectUnsupported(() => emptyFragment.translate = true);
     expectUnsupported(() => emptyFragment.tabIndex = 5);
     expectUnsupported(() => emptyFragment.title = "foo");
     expectUnsupported(() => emptyFragment.webkitdropzone = "foo");
     expectUnsupported(() => emptyFragment.webkitRegionOverflow = "foo");
   });
 
-  group('elements', () {
+  group('children', () {
     var fragment;
-    var elements;
+    var children;
 
     init() {
       fragment = new DocumentFragment();
-      elements = fragment.elements;
+      children = fragment.children;
       fragment.nodes.addAll(
         [new Text("1"), new Element.tag("A"), new Element.tag("B"),
          new Text("2"), new Element.tag("I"), new Text("3"),
          new Element.tag("U")]);
     };
 
     test('is initially empty', () {
-      elements = new DocumentFragment().elements;
-      expect(elements, equals([]));
-      expect(elements.isEmpty, isTrue);
+      children = new DocumentFragment().children;
+      expect(children, equals([]));
+      expect(children.isEmpty, isTrue);
     });
 
     test('filters out non-element nodes', () {
       init();
       expect(_nodeStrings(fragment.nodes),
           orderedEquals(["1", "A", "B", "2", "I", "3", "U"]));
-      expect(_nodeStrings(elements),
+      expect(_nodeStrings(children),
           orderedEquals(["A", "B", "I", "U"]));
     });
 
-    test('only indexes elements, not other nodes', () {
+    test('only indexes children, not other nodes', () {
       init();
-      elements[1] = new Element.tag("BR");
+      children[1] = new Element.tag("BR");
       expect(_nodeStrings(fragment.nodes),
           orderedEquals(["1", "A", "BR", "2", "I", "3", "U"]));
-      expect(_nodeStrings(elements),
+      expect(_nodeStrings(children),
           orderedEquals(["A", "BR", "I", "U"]));
     });
 
-    test('adds to both elements and nodes', () {
+    test('adds to both children and nodes', () {
       init();
-      elements.add(new Element.tag("UL"));
+      children.add(new Element.tag("UL"));
       expect(_nodeStrings(fragment.nodes),
           orderedEquals(["1", "A", "B", "2", "I", "3", "U", "UL"]));
-      expect(_nodeStrings(elements),
+      expect(_nodeStrings(children),
           orderedEquals(["A", "B", "I", "U", "UL"]));
     });
 
-    test('removes only elements, from both elements and nodes', () {
+    test('removes only children, from both children and nodes', () {
       init();
-      expect(elements.removeLast().tagName, equals('U'));
+      expect(children.removeLast().tagName, equals('U'));
       expect(_nodeStrings(fragment.nodes),
           orderedEquals(["1", "A", "B", "2", "I", "3"]));
-      expect(_nodeStrings(elements),
+      expect(_nodeStrings(children),
           orderedEquals(["A", "B", "I"]));
 
-      expect(elements.removeLast().tagName, "I");
-      expect(_nodeStrings(fragment.nodes), 
+      expect(children.removeLast().tagName, "I");
+      expect(_nodeStrings(fragment.nodes),
           equals(["1", "A", "B", "2", "3"]));
-      expect(_nodeStrings(elements), equals(["A", "B"]));
+      expect(_nodeStrings(children), equals(["A", "B"]));
     });
 
     test('accessors are wrapped', () {
       init();
-      expect(elements[0].tagName, "A");
-      expect(_nodeStrings(elements.filter((e) => e.tagName == "I")), ["I"]);
-      expect(elements.every((e) => e is Element), isTrue);
-      expect(elements.some((e) => e.tagName == "U"), isTrue);
-      expect(elements.isEmpty, isFalse);
-      expect(elements.length, 4);
-      expect(elements[2].tagName, "I");
-      expect(elements.last.tagName, "U");
+      expect(children[0].tagName, "A");
+      expect(_nodeStrings(children.filter((e) => e.tagName == "I")), ["I"]);
+      expect(children.every((e) => e is Element), isTrue);
+      expect(children.some((e) => e.tagName == "U"), isTrue);
+      expect(children.isEmpty, isFalse);
+      expect(children.length, 4);
+      expect(children[2].tagName, "I");
+      expect(children.last.tagName, "U");
     });
 
-    test('setting elements overwrites nodes as well', () {
+    test('setting children overwrites nodes as well', () {
       init();
-      fragment.elements = [new Element.tag("DIV"), new Element.tag("HEAD")];
+      fragment.children = [new Element.tag("DIV"), new Element.tag("HEAD")];
       expect(_nodeStrings(fragment.nodes), equals(["DIV", "HEAD"]));
     });
   });
 
   test('setting innerHTML works', () {
     var fragment = new DocumentFragment();
     fragment.nodes.add(new Text("foo"));
     fragment.innerHTML = "<a>bar</a>baz";
     expect(_nodeStrings(fragment.nodes), equals(["A", "baz"]));
   });
@@ skipping 153 matching lines @@
   //   // assertConstError(() => fragment.classes.add('foo'));
   // });
 
   test('query searches the fragment', () {
     var fragment = new DocumentFragment.html(
       "<div class='foo'><a>foo</a><b>bar</b></div>");
     expect(fragment.query(".foo a").tagName, "A");
     expect(_nodeStrings(fragment.queryAll(".foo *")), equals(["A", "B"]));
   });
 }