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
gram
2012/10/26 22:26:27
Yes, for now, these will always pass in dart2js. I
|
+ // 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); |
}); |
} |