Revert "Add tests for Element#elements."

client/html/src/ElementWrappingImplementation.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.
 
 // TODO(jacobr): use Lists.dart to remove some of the duplicated functionality.
 class _ChildrenElementList implements ElementList {
   // Raw Element.
   final _element;
   final _childElements;
 
   _ChildrenElementList._wrap(var element)
     : _childElements = element.children,
       _element = element;
 
   List<Element> _toList() {
     final output = new List(_childElements.length);
     for (int i = 0, len = _childElements.length; i < len; i++) {
       output[i] = LevelDom.wrapElement(_childElements[i]);
     }
     return output;
   }
 
   Element get first() {
     return LevelDom.wrapElement(_element.firstElementChild);
   }
 
-  void forEach(void f(Element element)) => _toList().forEach(f);
+  void forEach(void f(Element element)) {
+    for (var element in _childElements) {
+      f(LevelDom.wrapElement(element));
+    }
+  }
 
-  Collection map(f(Element element)) => _toList().map(f);
+  Collection map(f(Element element)) {
+    List output = new List();
+    forEach((Element element) {
+      output.add(f(element));
+    });
+    return output;
+  }
 
-  Collection<Element> filter(bool f(Element element)) => _toList().filter(f);
+  Collection<Element> filter(bool f(Element element)) {
+    List<Element> output = new List<Element>();
+    forEach((Element element) {
+      if (f(element)) {
+        output.add(element);
+      }
+    });
+    return output;
+  }
 
   bool every(bool f(Element element)) {
     for(Element element in this) {
       if (!f(element)) {
         return false;
       }
     };
     return true;
   }
 
   bool some(bool f(Element element)) {
     for(Element element in this) {
       if (f(element)) {
         return true;
       }
     };
     return false;
   }
 
   bool isEmpty() {
-    return _element.firstElementChild === null;
+    return _element.firstElementChild !== null;
   }
 
   int get length() {
     return _childElements.length;
   }
 
   Element operator [](int index) {
     return LevelDom.wrapElement(_childElements[index]);
   }
 
@@ skipping 22 matching lines @@
   }
 
   void sort(int compare(Element a, Element b)) {
     throw const UnsupportedOperationException('TODO(jacobr): should we impl?');
   }
 
   void copyFrom(List<Object> src, int srcStart, int dstStart, int count) {
     throw 'Not impl yet. todo(jacobr)';
   }
 
-  void setRange(int start, int length, List from, [int startFrom = 0]) =>
-    Lists.setRange(this, start, length, from, startFrom);
+  void setRange(int start, int length, List from, [int startFrom = 0]) {
+    throw const NotImplementedException();
+  }
 
-  void removeRange(int start, int length) =>
-    Lists.removeRange(this, start, length, (i) => this[i].remove());
+  void removeRange(int start, int length) {
+    throw const NotImplementedException();
+  }
 
   void insertRange(int start, int length, [initialValue = null]) {
     throw const NotImplementedException();
   }
 
-  List getRange(int start, int length) => Lists.getRange(this, start, length);
+  List getRange(int start, int length) {
+    throw const NotImplementedException();
+  }
 
   int indexOf(Element element, [int start = 0]) {
-    return Lists.indexOf(this, element, start, this.length);
+    return _Lists.indexOf(this, element, start, this.length);
   }
 
   int lastIndexOf(Element element, [int start = null]) {
     if (start === null) start = length - 1;
-    return Lists.lastIndexOf(this, element, start);
+    return _Lists.lastIndexOf(this, element, start);
   }
 
   void clear() {
     // It is unclear if we want to keep non element nodes?
     _element.textContent = '';
   }
 
   Element removeLast() {
     final last = this.last();
     if (last != null) {
@@ skipping 630 matching lines @@
 
   ElementEvents get on() {
     if (_on === null) {
       _on = new ElementEventsImplementation._wrap(_ptr);
     }
     return _on;
   }
 
   Element clone(bool deep) => super.clone(deep);
 }