Modified unittest to use new argument syntax.

tests/html/instance_of_test.dart

Index: tests/html/instance_of_test.dart
===================================================================
--- tests/html/instance_of_test.dart	(revision 14114)
+++ tests/html/instance_of_test.dart	(working copy)
@@ -11,46 +11,79 @@
   canvas.attributes['height'] = 100;
   document.body.nodes.add(canvas);
 
+  var isCanvasRenderingContext = 
+      new isInstanceOf<CanvasRenderingContext>('CanvasRenderingContext');
+  var isCanvasRenderingContext2D = 
+      new isInstanceOf<CanvasRenderingContext2D>('CanvasRenderingContext2D');
+  var isElement = new isInstanceOf<Element>('Element');
+  var isCanvasElement = new isInstanceOf<CanvasElement>('CanvasElement');
+  var isImageData = new isInstanceOf<ImageData>('ImageData');
+  //var isCanvasPixelArray =
+  //    new isInstanceOf<CanvasPixelArray>('CanvasPixelArray');
+  var isUint8ClampedArray = 
+      new isInstanceOf<Uint8ClampedArray>('Uint8ClampedArray');
+
+  // TODO(gram): A number of tests here have a commenteded out version that
+  // uses the matchers above. As dart2js returns true for is/is! regardless 

[Siggi Cherem (dart-lang), 2012/10/26 00:44:51]

that's what I was worried about. then below: wont
  expect(_, isElement)
always pass? even if I pass something of the wrong type?

For instance,
   expect(new Foo(), isElement) // would pass
when:
   expect(new Foo() is Element, isTrue) // fails?

[gram, 2012/10/26 22:26:27]

Yes, for now, these will always pass in dart2js. I didn't realize that these
would work correctly in the non-templated version, but it seems they do. So I
will have to undo all the type tests. I am going to leave the new versions in
but commented out so that when the time comes we can easily clean this up.

+  // of arguments these don't work if they use isNot. For now those are
+  // written in a different way but should ultimately be replaced by the
+  // commented-out versions. These have been marked with //* to distinguish
+  // from tests that were already commented out.
   useHtmlConfiguration();
   test('Instanceof', () {
-    Expect.isFalse(canvas is CanvasRenderingContext);
-    Expect.isFalse(canvas is CanvasRenderingContext2D);
-    Expect.isTrue(canvas is Element);
-    Expect.isTrue(canvas is CanvasElement);
-    Expect.isFalse(canvas is ImageData);
-    // Expect.isFalse(canvas is CanvasPixelArray);
+    //* expect(canvas, isNot(isCanvasRenderingContext));
+    expect(canvas is! CanvasRenderingContext, isTrue);
+    //* expect(canvas, isNot(isCanvasRenderingContext2D));
+    expect(canvas is! CanvasRenderingContext2D, isTrue);
+    expect(canvas, isElement);
+    expect(canvas, isCanvasElement);
+    //* expect(canvas, isNot(isImageData));
+    expect(canvas is! ImageData, isTrue);
+    // expect(canvas, isNot(isCanvasPixelArray));
 
     CanvasRenderingContext2D context = canvas.getContext('2d');
-    Expect.isTrue(context is CanvasRenderingContext);
-    Expect.isTrue(context is CanvasRenderingContext2D);
-    Expect.isFalse(context is Element);
-    Expect.isFalse(context is CanvasElement);
-    Expect.isFalse(context is ImageData);
-    // Expect.isFalse(context is CanvasPixelArray);
+    expect(context, isCanvasRenderingContext);
+    expect(context, isCanvasRenderingContext2D);
+    //* expect(context, isNot(isElement));
+    expect(context is! Element, isTrue);
+    //* expect(context, isNot(isCanvasElement));
+    expect(context is! CanvasElement, isTrue);
+    //* expect(context, isNot(isImageData));
+    expect(context is! ImageData, isTrue);
+    // expect(context, isNot(isCanvasPixelArray));
 
     // FIXME(b/5286633): Interface injection type check workaround.
     var image = context.createImageData(canvas.width as Dynamic,
                                         canvas.height as Dynamic);
-    Expect.isFalse(image is CanvasRenderingContext);
-    Expect.isFalse(image is CanvasRenderingContext2D);
-    Expect.isFalse(image is Element);
-    Expect.isFalse(image is CanvasElement);
-    Expect.isTrue(image is ImageData);
-    // Expect.isFalse(image is CanvasPixelArray);
+    //* expect(image, isNot(isCanvasRenderingContext));
+    expect(image is! CanvasRenderingContext, isTrue);
+    //* expect(image, isNot(isCanvasRenderingContext2D));
+    expect(image is! CanvasRenderingContext2D, isTrue);
+    //* expect(image, isNot(isElement));
+    expect(image is! Element, isTrue);
+    //* expect(image, isNot(isCanvasElement));
+    expect(image is! CanvasElement, isTrue);
+    expect(image, isImageData);
+    // expect(image, isNot(isCanvasPixelArray));
 
     // Include CanvasPixelArray since constructor and prototype are not
     // available until one is created.
     var bytes = image.data;
-    Expect.isFalse(bytes is CanvasRenderingContext);
-    Expect.isFalse(bytes is CanvasRenderingContext2D);
-    Expect.isFalse(bytes is Element);
-    Expect.isFalse(bytes is CanvasElement);
-    Expect.isFalse(bytes is ImageData);
-    Expect.isTrue(bytes is Uint8ClampedArray);
+    //* expect(bytes, isNot(isCanvasRenderingContext));
+    expect(bytes is! CanvasRenderingContext, isTrue);
+    //* expect(bytes, isNot(isCanvasRenderingContext2D));
+    expect(bytes is! CanvasRenderingContext2D, isTrue);
+    //* expect(bytes, isNot(isElement));
+    expect(bytes is! Element, isTrue);
+    //* expect(bytes, isNot(isCanvasElement));
+    expect(bytes is! CanvasElement, isTrue);
+    //* expect(bytes, isNot(isImageData));
+    expect(bytes is! ImageData, isTrue);
+    expect(bytes, isUint8ClampedArray);
 
     // FIXME: Ensure this is an SpanElement when we next update
     // WebKit IDL.
     var span = new Element.tag('span');
-    Expect.isTrue(span is Element);
+    expect(span, isElement);
   });
 }