Start cleaning up the HTML tests.

pkg/dev_compiler/test/codegen/lib/html/element_classes_svg_test.dart

 // Copyright (c) 2015, 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 'dart:svg' as svg;
 
+import 'package:minitest/minitest.dart';
+
 // Test for `querySelectorAll(xxx).classes.op()` where the query returns mixed
 // Html and Svg elements.
 
 Element makeElementsContainer() {
   var e = new Element.html(
       '<ul class="yes foo">'
       '<li class="yes quux qux">'
       '</ul>');
   final svgContent = r"""
 <svg version="1.1">
@@ skipping 24 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(' '));
   }
 
   tearDown(elementsTearDown);
 
   test('list_view', () {
     // Test that the 'view' helper function is behaving.
     var elements = elementsSetup();
     expect(view(elements.classes), '[classy, foo, quux, qux, yes]');
     expect(view(elements),
         '[[foo, yes], [quux, qux, yes], [qux, yes], [classy, yes]]');
   });
 
   test('listClasses=', () {
     var elements =  elementsSetup();
 
     elements.classes = ['foo', 'qux'];
     expect(view(elements.classes), '[foo, qux]');
     expect(view(elements), '[[foo, qux], [foo, qux], [foo, qux], [foo, qux]]');
 
     var elements2 = document.querySelectorAll('.qux');
     expect(view(elements2.classes), '[foo, qux]');
     expect(view(elements2), '[[foo, qux], [foo, qux], [foo, qux], [foo, qux]]');
 
     for (Element e in elements2) {
-      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(elements2.classes), '[]');
     expect(view(elements2), '[[], [], [], []]');
   });
 
   test('listMap', () {
     var elements = elementsSetup();
     expect(elements.classes.map((c) => c.toUpperCase()).toList(),
         unorderedEquals(['YES', 'FOO', 'QUX', 'QUUX', 'CLASSY']));
   });
 
   test('listContains', () {
     var elements = elementsSetup();
     expect(elements.classes.contains('classy'), isTrue);
     expect(elements.classes.contains('troll'), isFalse);
   });
 
-
   test('listAdd', () {
     var elements =  elementsSetup();
     var added = elements.classes.add('lassie');
     expect(added, isNull);
 
     expect(view(elements.classes), '[classy, foo, lassie, quux, qux, yes]');
     expect(view(elements),
         '[[foo, lassie, yes], [lassie, quux, qux, yes], '
         '[lassie, qux, yes], [classy, lassie, yes]]');
   });
@@ skipping 74 matching lines @@
     expect(view(elements),
         '[[], [quux, qux], [qux], []]');
   });
 
   test('listContainsAll', () {
     var elements = elementsSetup();
     expect(elements.classes.containsAll(['qux', 'mornin']), isFalse);
     expect(elements.classes.containsAll(['qux', 'classy']), isTrue);
   });
 }