Start cleaning up the HTML tests.

pkg/dev_compiler/test/codegen/lib/html/element_classes_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 ElementTest;
-import 'package:unittest/unittest.dart';
-import 'package:unittest/html_config.dart';
 import 'dart:collection';
 import 'dart:html';
 
+import 'package:minitest/minitest.dart';
+
 Element makeElement() => new Element.tag('div');
 
 Element makeElementWithClasses() =>
     new Element.html('<div class="foo bar baz"></div>');
 
-Set<String> makeClassSet() => makeElementWithClasses().classes;
+CssClassSet makeClassSet() => makeElementWithClasses().classes;
 
 Element makeListElement() =>
     new Element.html('<ul class="foo bar baz">'
         '<li class="quux qux">'
         '<li class="meta">'
         '<li class="classy lassy">'
         '<li class="qux lassy">'
         '</ul>');
 
 Element listElement;
@@ skipping 13 matching lines @@
 
 /// Returns a canonical string for Set<String> and lists of Element's classes.
 String view(var e) {
   if (e is Set) return '${e.toList()..sort()}';
   if (e is Element) return view(e.classes);
   if (e is Iterable) return '${e.map(view).toList()}';
   throw new ArgumentError('Cannot make canonical view string for: $e}');
 }
 
 main() {
-  useHtmlConfiguration();
-
   Set<String> extractClasses(Element el) {
     final match = new RegExp('class="([^"]+)"').firstMatch(el.outerHtml);
     return new LinkedHashSet.from(match[1].split(' '));
   }
 
-
   test('affects the "class" attribute', () {
     final el = makeElementWithClasses();
     el.classes.add('qux');
-    expect(extractClasses(el), orderedEquals(['foo', 'bar', 'baz', 'qux']));
+    expect(extractClasses(el), equals(['foo', 'bar', 'baz', 'qux']));
   });
 
   test('is affected by the "class" attribute', () {
     final el = makeElementWithClasses();
     el.attributes['class'] = 'foo qux';
-    expect(el.classes, orderedEquals(['foo', 'qux']));
+    expect(el.classes, equals(['foo', 'qux']));
   });
 
   test('classes=', () {
     final el = makeElementWithClasses();
     el.classes = ['foo', 'qux'];
-    expect(el.classes, orderedEquals(['foo', 'qux']));
-    expect(extractClasses(el), orderedEquals(['foo', 'qux']));
+    expect(el.classes, equals(['foo', 'qux']));
+    expect(extractClasses(el), equals(['foo', 'qux']));
   });
 
   test('toString', () {
     expect(makeClassSet().toString().split(' '),
-        orderedEquals(['foo', 'bar', 'baz']));
+        equals(['foo', 'bar', 'baz']));
     expect(makeElement().classes.toString(), '');
   });
 
   test('forEach', () {
     final classes = <String>[];
     makeClassSet().forEach(classes.add);
-    expect(classes, orderedEquals(['foo', 'bar', 'baz']));
+    expect(classes, equals(['foo', 'bar', 'baz']));
   });
 
   test('iterator', () {
     final classes = <String>[];
     for (var el in makeClassSet()) {
       classes.add(el);
     }
-    expect(classes, orderedEquals(['foo', 'bar', 'baz']));
+    expect(classes, equals(['foo', 'bar', 'baz']));
   });
 
   test('map', () {
     expect(makeClassSet().map((c) => c.toUpperCase()).toList(),
-        orderedEquals(['FOO', 'BAR', 'BAZ']));
+        equals(['FOO', 'BAR', 'BAZ']));
   });
 
   test('where', () {
     expect(makeClassSet().where((c) => c.contains('a')).toList(),
-        orderedEquals(['bar', 'baz']));
+        equals(['bar', 'baz']));
   });
 
   test('every', () {
     expect(makeClassSet().every((c) => c is String), isTrue);
     expect(makeClassSet().every((c) => c.contains('a')), isFalse);
   });
 
   test('any', () {
     expect(makeClassSet().any((c) => c.contains('a')), isTrue);
     expect(makeClassSet().any((c) => c is num), isFalse);
@@ skipping 20 matching lines @@
     final classes = makeClassSet();
     expect(classes.contains(1), isFalse);
     expect(() => classes.contains(''), throws);
     expect(() => classes.contains('foo bar'), throws);
   });
 
   test('add', () {
     final classes = makeClassSet();
     var added = classes.add('qux');
     expect(added, isTrue);
-    expect(classes, orderedEquals(['foo', 'bar', 'baz', 'qux']));
+    expect(classes, equals(['foo', 'bar', 'baz', 'qux']));
 
     added = classes.add('qux');
     expect(added, isFalse);
     final list = new List.from(classes);
     list.sort((a, b) => a.compareTo(b));
-    expect(list, orderedEquals(['bar', 'baz', 'foo', 'qux']),
+    expect(list, equals(['bar', 'baz', 'foo', 'qux']),
         reason: "The class set shouldn't have duplicate elements.");
   });
 
   test('add-bad', () {
     final classes = makeClassSet();
     expect(() => classes.add(''), throws);
     expect(() => classes.add('foo bar'), throws);
   });
 
   test('remove', () {
     final classes = makeClassSet();
     classes.remove('bar');
-    expect(classes, orderedEquals(['foo', 'baz']));
+    expect(classes, equals(['foo', 'baz']));
     classes.remove('qux');
-    expect(classes, orderedEquals(['foo', 'baz']));
+    expect(classes, equals(['foo', 'baz']));
   });
 
   test('remove-bad', () {
     final classes = makeClassSet();
     expect(() => classes.remove(''), throws);
     expect(() => classes.remove('foo bar'), throws);
   });
 
   test('toggle', () {
     final classes = makeClassSet();
     classes.toggle('bar');
-    expect(classes, orderedEquals(['foo', 'baz']));
+    expect(classes, equals(['foo', 'baz']));
     classes.toggle('qux');
-    expect(classes, orderedEquals(['foo', 'baz', 'qux']));
+    expect(classes, equals(['foo', 'baz', 'qux']));
 
     classes.toggle('qux', true);
-    expect(classes, orderedEquals(['foo', 'baz', 'qux']));
+    expect(classes, equals(['foo', 'baz', 'qux']));
     classes.toggle('qux', false);
-    expect(classes, orderedEquals(['foo', 'baz']));
+    expect(classes, equals(['foo', 'baz']));
     classes.toggle('qux', false);
-    expect(classes, orderedEquals(['foo', 'baz']));
+    expect(classes, equals(['foo', 'baz']));
     classes.toggle('qux', true);
-    expect(classes, orderedEquals(['foo', 'baz', 'qux']));
+    expect(classes, equals(['foo', 'baz', 'qux']));
   });
 
   test('toggle-bad', () {
     final classes = makeClassSet();
     expect(() => classes.toggle(''), throws);
     expect(() => classes.toggle('', true), throws);
     expect(() => classes.toggle('', false), throws);
     expect(() => classes.toggle('foo bar'), throws);
     expect(() => classes.toggle('foo bar', true), throws);
     expect(() => classes.toggle('foo bar', false), throws);
   });
 
   test('addAll', () {
     final classes = makeClassSet();
     classes.addAll(['bar', 'qux', 'bip']);
-    expect(classes, orderedEquals(['foo', 'bar', 'baz', 'qux', 'bip']));
+    expect(classes, equals(['foo', 'bar', 'baz', 'qux', 'bip']));
   });
 
   test('removeAll', () {
     final classes = makeClassSet();
     classes.removeAll(['bar', 'baz', 'qux']);
-    expect(classes, orderedEquals(['foo']));
+    expect(classes, equals(['foo']));
   });
 
   test('toggleAll', () {
     final classes = makeClassSet();
     classes.toggleAll(['bar', 'foo']);
-    expect(classes, orderedEquals(['baz']));
+    expect(classes, equals(['baz']));
     classes.toggleAll(['qux', 'quux']);
-    expect(classes, orderedEquals(['baz', 'qux', 'quux']));
+    expect(classes, equals(['baz', 'qux', 'quux']));
     classes.toggleAll(['bar', 'foo'], true);
-    expect(classes, orderedEquals(['baz', 'qux', 'quux', 'bar', 'foo']));
+    expect(classes, equals(['baz', 'qux', 'quux', 'bar', 'foo']));
     classes.toggleAll(['baz', 'quux'], false);
-    expect(classes, orderedEquals(['qux','bar', 'foo']));
+    expect(classes, equals(['qux','bar', 'foo']));
   });
 
   test('retainAll', () {
     final classes = makeClassSet();
     classes.retainAll(['bar', 'baz', 'qux']);
-    expect(classes, orderedEquals(['bar', 'baz']));
+    expect(classes, equals(['bar', 'baz']));
   });
 
   test('removeWhere', () {
     final classes = makeClassSet();
     classes.removeWhere((s) => s.startsWith('b'));
-    expect(classes, orderedEquals(['foo']));
+    expect(classes, equals(['foo']));
   });
 
   test('retainWhere', () {
     final classes = makeClassSet();
     classes.retainWhere((s) => s.startsWith('b'));
-    expect(classes, orderedEquals(['bar', 'baz']));
+    expect(classes, equals(['bar', 'baz']));
   });
 
   test('containsAll', () {
     final classes = makeClassSet();
     expect(classes.containsAll(['foo', 'baz']), isTrue);
     expect(classes.containsAll(['foo', 'qux']), isFalse);
     expect(classes.containsAll(['foo', 'baz'].toSet()), isTrue);
     expect(classes.containsAll(['foo', 'qux'].toSet()), isFalse);
   });
 
   test('intersection', () {
     final classes = makeClassSet();
     expect(classes.intersection(['foo', 'qux', 'baz'].toSet()),
         unorderedEquals(['foo', 'baz']));
   });
 
   test('clear', () {
     final classes = makeClassSet();
     classes.clear();
     expect(classes, equals([]));
   });
 
   test('order', () {
     var classes = makeClassSet();
     classes.add('aardvark');
-    expect(classes, orderedEquals(['foo', 'bar', 'baz', 'aardvark']));
+    expect(classes, equals(['foo', 'bar', 'baz', 'aardvark']));
     classes.toggle('baz');
-    expect(classes, orderedEquals(['foo', 'bar', 'aardvark']));
+    expect(classes, equals(['foo', 'bar', 'aardvark']));
     classes.toggle('baz');
-    expect(classes, orderedEquals(['foo', 'bar', 'aardvark', 'baz']));
+    expect(classes, equals(['foo', 'bar', 'aardvark', 'baz']));
   });
 
   tearDown(listElementTearDown);
 
   test('list_view', () {
     // Test that the 'view' helper function is behaving.
     var elements = listElementSetup();
     expect(view(elements.classes), '[classy, lassy, meta, quux, qux]');
     expect(view(elements),
         '[[quux, qux], [meta], [classy, lassy], [lassy, qux]]');
   });
 
   test('listClasses=', () {
     var elements =  listElementSetup();
     elements.classes = ['foo', 'qux'];
     elements = document.queryAll('li');
     for (Element e in elements) {
-      expect(e.classes, orderedEquals(['foo', 'qux']));
-      expect(extractClasses(e), orderedEquals(['foo', 'qux']));
+      expect(e.classes, equals(['foo', 'qux']));
+      expect(extractClasses(e), equals(['foo', 'qux']));
     }
 
     elements.classes = [];
     expect(view(elements.classes), '[]');
     expect(view(elements), '[[], [], [], []]');
   });
 
   test('listMap', () {
     var elements = listElementSetup();
     expect(elements.classes.map((c) => c.toUpperCase()).toList(),
@@ skipping 87 matching lines @@
     expect(view(elements.classes), '[quux, qux]');
     expect(view(elements), '[[quux, qux], [], [], [qux]]');
   });
 
   test('listContainsAll', () {
     var elements = listElementSetup();
     expect(elements.classes.containsAll(['qux', 'meta', 'mornin']), isFalse);
     expect(elements.classes.containsAll(['qux', 'lassy', 'classy']), isTrue);
   });
 }