Start cleaning up the HTML tests.

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

 // Copyright (c) 2013, 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 jsTest;
-
-import 'dart:async';
 import 'dart:html';
 import 'dart:typed_data' show ByteBuffer, Int32List;
 import 'dart:indexed_db' show IdbFactory, KeyRange;
 import 'dart:js';
 
-import 'package:unittest/unittest.dart';
-import 'package:unittest/html_individual_config.dart';
+import 'package:minitest/minitest.dart';
 
 _injectJs() {
   final script = new ScriptElement();
   script.type = 'text/javascript';
   script.innerHtml = r"""
 var x = 42;
 
 var _x = 123;
 
 var myArray = ["value1"];
@@ skipping 198 matching lines @@
 }
 
 class TestDartObject {}
 
 class Callable {
   call() => 'called';
 }
 
 main() {
   _injectJs();
-  useHtmlIndividualConfiguration();
 
   group('identity', () {
 
     test('context instances should be identical', () {
       var c1 = context;
       var c2 = context;
       expect(identical(c1, c2), isTrue);
     });
 
     test('identical JS objects should have identical proxies', () {
@@ skipping 23 matching lines @@
       expect(identical(f1, f2), isTrue);
     });
 
     // TODO(justinfagnani): old tests duplicate checks above, remove
     // on test next cleanup pass
     test('test proxy equality', () {
       var foo1 = new JsObject(context['Foo'], [1]);
       var foo2 = new JsObject(context['Foo'], [2]);
       context['foo1'] = foo1;
       context['foo2'] = foo2;
-      expect(foo1, isNot(equals(context['foo2'])));
+      expect(foo1, notEquals(context['foo2']));
       expect(foo2, equals(context['foo2']));
       context.deleteProperty('foo1');
       context.deleteProperty('foo2');
     });
 
     test('retrieve same dart Object', () {
       final obj = new Object();
       context['obj'] = obj;
       expect(context['obj'], same(obj));
       context.deleteProperty('obj');
@@ skipping 30 matching lines @@
     });
 
   });
 
   group('new_JsObject', () {
 
     test('new Foo()', () {
       var foo = new JsObject(context['Foo'], [42]);
       expect(foo['a'], equals(42));
       expect(foo.callMethod('bar'), equals(42));
-      expect(() => foo.callMethod('baz'), throwsA(isNoSuchMethodError));
+      expect(() => foo.callMethod('baz'), throwsNoSuchMethodError);
     });
 
     test('new container.Foo()', () {
       final Foo2 = context['container']['Foo'];
       final foo = new JsObject(Foo2, [42]);
       expect(foo['a'], 42);
       expect(Foo2['b'], 38);
     });
 
     test('new Array()', () {
       var a = new JsObject(context['Array']);
-      expect(a, new isInstanceOf<JsArray>());
+      expect(a is JsArray, isTrue);
 
       // Test that the object still behaves via the base JsObject interface.
       // JsArray specific tests are below.
       expect(a['length'], 0);
 
       a.callMethod('push', ["value 1"]);
       expect(a['length'], 1);
       expect(a[0], "value 1");
 
       a.callMethod('pop');
@@ skipping 86 matching lines @@
         expect(o["f$i"], i);
       }
       expect(o['constructor'], equals(context['Baz']));
     });
   });
 
   group('JsFunction and callMethod', () {
 
     test('new JsObject can return a JsFunction', () {
       var f = new JsObject(context['Function']);
-      expect(f, new isInstanceOf<JsFunction>());
+      expect(f is JsFunction, isTrue);
     });
 
     test('JsFunction.apply on a function defined in JS', () {
       expect(context['razzle'].apply([]), equals(42));
     });
 
     test('JsFunction.apply on a function that uses this', () {
       var object = new Object();
       expect(context['returnThis'].apply([], thisArg: object), same(object));
     });
 
     test('JsObject.callMethod on a function defined in JS', () {
       expect(context.callMethod('razzle'), equals(42));
-      expect(() => context.callMethod('dazzle'), throwsA(isNoSuchMethodError));
+      expect(() => context.callMethod('dazzle'), throwsNoSuchMethodError);
     });
 
     test('callMethod with many arguments', () {
       expect(context.callMethod('varArgs', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
         equals(55));
     });
 
     test('access a property of a function', () {
       expect(context.callMethod('Bar'), "ret_value");
       expect(context['Bar']['foo'], "property_value");
     });
 /*
  TODO(jacobr): evaluate whether we should be in the business of throwing
  ArgumentError outside of checked mode. In unchecked mode this should just
  return a NoSuchMethodError as the class lacks a method "true".
 
     test('callMethod throws if name is not a String or num', () {
       expect(() => context.callMethod(true),
-          throwsA(new isInstanceOf<ArgumentError>()));
+          throwsArgumentError);
     });
 */
   });
 
   group('JsArray', () {
 
     test('new JsArray()', () {
       var array = new JsArray();
       var arrayType = context['Array'];
       expect(array.instanceof(arrayType), true);
       expect(array, []);
       // basic check that it behaves like a List
       array.addAll([1, 2, 3]);
       expect(array, [1, 2, 3]);
     });
 
     test('new JsArray.from()', () {
       var array = new JsArray.from([1, 2, 3]);
       var arrayType = context['Array'];
       expect(array.instanceof(arrayType), true);
       expect(array, [1, 2, 3]);
     });
 
     test('get Array from JS', () {
       context['a'] = new JsObject(context['Array'], [1, 2, 3]);
       expect(context.callMethod('isPropertyInstanceOf',
           ['a', context['Array']]), isTrue);
       var a = context['a'];
-      expect(a, new isInstanceOf<JsArray>());
+      expect(a is JsArray, isTrue);
       expect(a, [1, 2, 3]);
       context.deleteProperty('a');
     });
 
     test('pass Array to JS', () {
       context['a'] = [1, 2, 3];
       expect(context.callMethod('isPropertyInstanceOf',
           ['a', context['Array']]), isTrue);
       var a = context['a'];
-      expect(a, new isInstanceOf<List>());
-      expect(a, isNot(new isInstanceOf<JsArray>()));
+      expect(a is List, isTrue);
+      expect(a is JsArray, isFalse);
       expect(a, [1, 2, 3]);
       context.deleteProperty('a');
     });
 
     test('[]', () {
       var array = new JsArray.from([1, 2]);
       expect(array[0], 1);
       expect(array[1], 2);
-      expect(() => array[-1], throwsA(isRangeError));
-      expect(() => array[2], throwsA(isRangeError));
+      expect(() => array[-1], throwsRangeError);
+      expect(() => array[2], throwsRangeError);
     });
 
    test('[]=', () {
-      var array = new JsArray.from([1, 2]);
+      var array = new JsArray<Object>.from([1, 2]);
       array[0] = 'd';
       array[1] = 'e';
       expect(array, ['d', 'e']);
-      expect(() => array[-1] = 3, throwsA(isRangeError));
-      expect(() => array[2] = 3, throwsA(isRangeError));
+      expect(() => array[-1] = 3, throwsRangeError);
+      expect(() => array[2] = 3, throwsRangeError);
     });
 
     test('length', () {
       var array = new JsArray.from([1, 2, 3]);
       expect(array.length, 3);
       array.add(4);
       expect(array.length, 4);
       array.length = 2;
       expect(array, [1, 2]);
       array.length = 3;
@@ skipping 18 matching lines @@
     });
 
     test('insert', () {
       var array = new JsArray.from([]);
       array.insert(0, 'b');
       expect(array, ['b']);
       array.insert(0, 'a');
       expect(array, ['a', 'b']);
       array.insert(2, 'c');
       expect(array, ['a', 'b', 'c']);
-      expect(() => array.insert(4, 'e'), throwsA(isRangeError));
-      expect(() => array.insert(-1, 'e'), throwsA(isRangeError));
+      expect(() => array.insert(4, 'e'), throwsRangeError);
+      expect(() => array.insert(-1, 'e'), throwsRangeError);
     });
 
     test('removeAt', () {
       var array = new JsArray.from(['a', 'b', 'c']);
       expect(array.removeAt(1), 'b');
       expect(array, ['a', 'c']);
-      expect(() => array.removeAt(2), throwsA(isRangeError));
-      expect(() => array.removeAt(-1), throwsA(isRangeError));
+      expect(() => array.removeAt(2), throwsRangeError);
+      expect(() => array.removeAt(-1), throwsRangeError);
     });
 
     test('removeLast', () {
       var array = new JsArray.from(['a', 'b', 'c']);
       expect(array.removeLast(), 'c');
       expect(array, ['a', 'b']);
       array.length = 0;
-      expect(() => array.removeLast(), throwsA(isRangeError));
+      expect(() => array.removeLast(), throwsRangeError);
     });
 
     test('removeRange', () {
       var array = new JsArray.from(['a', 'b', 'c', 'd']);
       array.removeRange(1, 3);
       expect(array, ['a', 'd']);
-      expect(() => array.removeRange(-1, 2), throwsA(isRangeError));
-      expect(() => array.removeRange(0, 3), throwsA(isRangeError));
-      expect(() => array.removeRange(2, 1), throwsA(isRangeError));
+      expect(() => array.removeRange(-1, 2), throwsRangeError);
+      expect(() => array.removeRange(0, 3), throwsRangeError);
+      expect(() => array.removeRange(2, 1), throwsRangeError);
     });
 
     test('setRange', () {
       var array = new JsArray.from(['a', 'b', 'c', 'd']);
       array.setRange(1, 3, ['e', 'f']);
       expect(array, ['a', 'e', 'f', 'd']);
       array.setRange(3, 4, ['g', 'h', 'i'], 1);
       expect(array, ['a', 'e', 'f', 'h']);
     });
 
@@ skipping 17 matching lines @@
       var node = new JsObject.fromBrowserObject(new DivElement());
       context.callMethod('addTestProperty', [node]);
       expect(node is JsObject, isTrue);
       // TODO(justinfagnani): make this work in IE9
       // expect(node.instanceof(context['HTMLDivElement']), isTrue);
       expect(node['testProperty'], 'test');
     });
 
     test('primitives and null throw ArgumentError', () {
       for (var v in ['a', 1, 2.0, true, null]) {
-        expect(() => new JsObject.fromBrowserObject(v),
-            throwsA(new isInstanceOf<ArgumentError>()));
+        expect(() => new JsObject.fromBrowserObject(v), throwsArgumentError);
       }
     });
 
   });
 
   group('Dart_functions', () {
     test('invoke Dart callback from JS', () {
       expect(() => context.callMethod('invokeCallback'), throws);
 
       context['callback'] = () => 42;
@@ skipping 64 matching lines @@
     test('convert a Map', () {
       var map = {'a': 1, 'b': 2, 'c': 3};
       var jsMap = new JsObject.jsify(map);
       expect(!context.callMethod('isArray', [jsMap]), isTrue);
       for (final key in map.keys) {
         expect(context.callMethod('checkMap', [jsMap, key, map[key]]), isTrue);
       }
     });
 
     test('deep convert a complex object', () {
-      final object = {
+      dynamic object = {
         'a': [1, [2, 3]],
         'b': {
           'c': 3,
           'd': new JsObject(context['Foo'], [42])
         },
         'e': null
       };
       var jsObject = new JsObject.jsify(object);
       expect(jsObject['a'][0], equals(object['a'][0]));
       expect(jsObject['a'][1][0], equals(object['a'][1][0]));
       expect(jsObject['a'][1][1], equals(object['a'][1][1]));
       expect(jsObject['b']['c'], equals(object['b']['c']));
       expect(jsObject['b']['d'], equals(object['b']['d']));
       expect(jsObject['b']['d'].callMethod('bar'), equals(42));
       expect(jsObject['e'], isNull);
     });
 
     test('throws if object is not a Map or Iterable', () {
-      expect(() => new JsObject.jsify('a'),
-          throwsA(new isInstanceOf<ArgumentError>()));
+      expect(() => new JsObject.jsify('a'), throwsArgumentError);
     });
   });
 
   group('JsObject_methods', () {
 
     test('hashCode and ==', () {
       final o1 = context['Object'];
       final o2 = context['Object'];
       expect(o1 == o2, isTrue);
       expect(o1.hashCode == o2.hashCode, isTrue);
@@ skipping 27 matching lines @@
       expect(context['Object'].callMethod('keys', [object])['length'], 1);
       expect(context['Object'].callMethod('keys', [object])[0], "a");
       object.deleteProperty("a");
       expect(context['Object'].callMethod('keys', [object])['length'], 0);
     });
 
 /* TODO(jacobr): this is another test that is inconsistent with JS semantics.
     test('deleteProperty throws if name is not a String or num', () {
       var object = new JsObject.jsify({});
       expect(() => object.deleteProperty(true),
-          throwsA(new isInstanceOf<ArgumentError>()));
+          throwsArgumentError);
     });
   */
 
     test('hasProperty', () {
       var object = new JsObject.jsify({});
       object['a'] = 1;
       expect(object.hasProperty('a'), isTrue);
       expect(object.hasProperty('b'), isFalse);
     });
 
 /* TODO(jacobr): is this really the correct unchecked mode behavior?
     test('hasProperty throws if name is not a String or num', () {
       var object = new JsObject.jsify({});
       expect(() => object.hasProperty(true),
-          throwsA(new isInstanceOf<ArgumentError>()));
+          throwsArgumentError);
     });
 */
 
     test('[] and []=', () {
       final myArray = context['myArray'];
       expect(myArray['length'], equals(1));
       expect(myArray[0], equals("value1"));
       myArray[0] = "value2";
       expect(myArray['length'], equals(1));
       expect(myArray[0], equals("value2"));
 
       final foo = new JsObject(context['Foo'], [1]);
       foo["getAge"] = () => 10;
       expect(foo.callMethod('getAge'), equals(10));
     });
 
 /* TODO(jacobr): remove as we should only throw this in checked mode.
     test('[] and []= throw if name is not a String or num', () {
       var object = new JsObject.jsify({});
       expect(() => object[true],
-          throwsA(new isInstanceOf<ArgumentError>()));
+          throwsArgumentError);
       expect(() => object[true] = 1,
-          throwsA(new isInstanceOf<ArgumentError>()));
+          throwsArgumentError);
     });
 */
   });
 
   group('transferrables', () {
 
     group('JS->Dart', () {
 
       test('DateTime', () {
         var date = context.callMethod('getNewDate');
@@ skipping 64 matching lines @@
       test('ImageData', () {
         var node = context.callMethod('getNewImageData');
         expect(node is ImageData, isTrue);
       });
 
       test('typed data: Int32Array', () {
         if (Platform.supportsTypedData) {
           var list = context.callMethod('getNewInt32Array');
           print(list);
           expect(list is Int32List, isTrue);
-          expect(list, orderedEquals([1, 2, 3, 4, 5, 6, 7, 8]));
+          expect(list, equals([1, 2, 3, 4, 5, 6, 7, 8]));
         }
       });
 
     });
 
     group('Dart->JS', () {
 
       test('Date', () {
         context['o'] = new DateTime(1995, 12, 17);
         var dateType = context['Date'];
@@ skipping 51 matching lines @@
               isTrue);
           context.deleteProperty('o');
         }
       });
 
       // this test fails in IE9 for very weird, but unknown, reasons
       // the expression context['ImageData'] fails if useHtmlConfiguration()
       // is called, or if the other tests in this file are enabled
       skipIE9_test('ImageData', () {
         var canvas = new CanvasElement();
-        var ctx = canvas.getContext('2d');
+        var ctx = canvas.getContext('2d') as CanvasRenderingContext2D;
         context['o'] = ctx.createImageData(1, 1);
         var imageDataType = context['ImageData'];
         expect(context.callMethod('isPropertyInstanceOf', ['o', imageDataType]),
             isTrue);
         context.deleteProperty('o');
       });
 
       test('typed data: Int32List', () {
         if (Platform.supportsTypedData) {
           context['o'] = new Int32List.fromList([1, 2, 3, 4]);
           var listType = context['Int32Array'];
           // TODO(jacobr): make this test pass. Currently some type information
           // is lost when typed arrays are passed between JS and Dart.
           // expect(context.callMethod('isPropertyInstanceOf', ['o', listType]),
           //    isTrue);
           context.deleteProperty('o');
         }
       });
 
     });
   });
 
 }