Support JS$ prefix for dart and fix bug where _operator_getter and the [] operator were used incons…

tests/html/js_package_dom_test.dart

Index: tests/html/js_package_dom_test.dart
diff --git a/tests/html/js_package_dom_test.dart b/tests/html/js_package_dom_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..aeb513b385292435d34acc8c72812ff243554b43
--- /dev/null
+++ b/tests/html/js_package_dom_test.dart
@@ -0,0 +1,168 @@
+// 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 js_package_dom_test;
+
+import 'package:js/js.dart';
+import 'package:unittest/unittest.dart';
+import 'package:unittest/html_config.dart';
+import 'package:unittest/html_individual_config.dart';
+import 'simple_dom.dart' as dom;
+
+import 'dart:html' as html;
+import 'dart:js' as js;
+
+@JS()
+@anonymous
+class ExampleLiteral {
+  external factory ExampleLiteral({a, b});
+  external get a;
+  external get b;
+}
+
+main() {
+  useHtmlIndividualConfiguration();
+
+  group('no wrappers', () {
+    test('simple', () {
+      expect(identical(html.window, dom.window), isTrue);
+    });
+  });
+
+  group('type checks', () {
+    test('simple', () {
+      expect(dom.window is html.Window, isTrue);
+      expect(dom.window is js.JsObject, isFalse);
+
+      expect(dom.window.document is html.Document, isTrue);
+      expect(dom.window.document is js.JsObject, isFalse);
+      expect(dom.window.document.JS$addEventListener is Function, isTrue);
+    });
+  });
+
+  group('expando', () {
+    test('simple', () {
+      dom.window.document.exampleNodeExpando = 42;
+      expect(dom.window.document.exampleNodeExpando, equals(42));
+
+      expect((html.window.document as dynamic).exampleNodeExpando, equals(42));
+
+      // Not an actual expando specified in simple_dom.dart.
+      expect(() => (dom.window.document as dynamic).exampleInvalidNodeExpando, throws);
+    });
+  });
+
+  group('event listener', () {
+    test('allowInterop dom', () {
+      var eventType = 'dummyEvent';
+      dom.Event e = new dom.Event(eventType);
+      var listenerCalls = 0;
+      eventListener(dom.Event event) {
+        expect(event.type, equals(eventType));
+        listenerCalls++;
+      }
+
+      var eventListenerCaptureThisCalls = 0;
+      eventListenerCaptureThis(dom.Node that, dom.Event event) {
+        print(that);
+        expect(identical(that, dom.document), isTrue);
+        expect(event.type, equals(eventType));
+        eventListenerCaptureThisCalls++;
+      }
+
+      var interopListener = allowInterop(eventListener);
+      dom.document.JS$addEventListener(eventType, interopListener);
+
+      var interopListenerCaptureThis = allowInteropCaptureThis(eventListenerCaptureThis);
+      dom.document.JS$addEventListener(eventType, interopListenerCaptureThis);
+
+      dom.document.dispatchEvent(e);
+
+      expect(listenerCalls, equals(1));
+      expect(eventListenerCaptureThisCalls, equals(1));
+
+      dom.document.dispatchEvent(new dom.Event(eventType));
+
+      expect(listenerCalls, equals(2));
+      expect(eventListenerCaptureThisCalls, equals(2));
+
+      // Verify that event listeners can be removed.
+      dom.document.JS$removeEventListener(eventType, interopListener);
+      dom.document.JS$removeEventListener(eventType, interopListenerCaptureThis);
+      dom.document.dispatchEvent(new dom.Event(eventType));
+
+      expect(eventListenerCaptureThisCalls, equals(2));
+      expect(listenerCalls, equals(2));
+    });
+
+    // This test is identical to the previous test except we intentionally call
+    // addEventlistener instead of JS$addEventListener so that we fall back to
+    // the dart:html version. This verifies the two versions are compatible.
+    test('allowInterop html', () {
+      var eventType = 'dummyEvent';
+      dom.Event e = new dom.Event(eventType);
+      var listenerCalls = 0;
+      eventListener(dom.Event event) {
+        expect(event.type, equals(eventType));
+        listenerCalls++;
+      }
+
+      var eventListenerCaptureThisCalls = 0;
+      eventListenerCaptureThis(dom.Node that, dom.Event event) {
+        expect(identical(that, dom.document), isTrue);
+        expect(event.type, equals(eventType));
+        eventListenerCaptureThisCalls++;
+      }
+
+      var interopListener = allowInterop(eventListener);
+      dom.document.addEventListener(eventType, interopListener);
+
+      var interopListenerCaptureThis = allowInteropCaptureThis(eventListenerCaptureThis);
+      dom.document.addEventListener(eventType, interopListenerCaptureThis);
+
+      dom.document.dispatchEvent(e);
+
+      expect(listenerCalls, equals(1));
+      expect(eventListenerCaptureThisCalls, equals(1));
+
+      dom.document.dispatchEvent(new dom.Event(eventType));
+
+      expect(listenerCalls, equals(2));
+      expect(eventListenerCaptureThisCalls, equals(2));
+
+      // Verify that dom removeEventLister is compatible with dart:html
+      // addEventlistener.
+      dom.document.JS$removeEventListener(eventType, interopListener);
+      dom.document.JS$removeEventListener(eventType, interopListenerCaptureThis);
+      dom.document.dispatchEvent(new dom.Event(eventType));
+
+      expect(eventListenerCaptureThisCalls, equals(2));
+      expect(listenerCalls, equals(2));
+    });
+  });
+
+  group('dartium', () {
+    test('type checks', () {
+      expect(dom.window is dom.Window, isTrue);
+      expect(dom.window.document is dom.Document, isTrue);
+    });
+    // These tests only pass in Dartium as the checks to make them pass in
+    // dart2js could not be implemented efficiently. 
+    test('forgot allowIntero', () {
+      var eventListener = (event) => true;
+      expect(() => dom.document.exampleNodeExpando = eventListener, throws);
+      expect(() => dom.document.JS$addEventListener('foo', eventListener), throws);
+      // Test that forgetting to call allowInterop is caught for top level
+      // methods.
+      expect(() => dom.documentAddEventListener('foo', eventListener), throws);
+
+      // Test that it is caught for object literal constructors
+      expect(() => new ExampleLiteral(a: "foo", b: eventListener), throws);
+
+      // This does not throw as this actually invokes the dart:html version as
+      // dart:html wins naming conflicts with JS interop.
+      dom.document.addEventListener('foo', eventListener);
+    });
+  });
+}