Adding synchronous measurement methods to Element.

tests/html/element_test.dart

 // Copyright (c) 2011, 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('../../pkg/unittest/unittest.dart');
 #import('../../pkg/unittest/html_config.dart');
 #import('dart:html');
 
 expectLargeRect(ClientRect rect) {
   Expect.equals(rect.top, 0);
   Expect.equals(rect.left, 0);
   Expect.isTrue(rect.width > 100);
   Expect.isTrue(rect.height > 100);
   Expect.equals(rect.bottom, rect.top + rect.height);
   Expect.equals(rect.right, rect.left + rect.width);
 }
 
 void testEventHelper(EventListenerList listenerList, String type,
     [Function registerOnEventListener = null]) {
+  testMultipleEventHelper(listenerList, [type], registerOnEventListener);
+}
+
+// Allows testing where we polyfill different browsers firing different events.
+void testMultipleEventHelper(EventListenerList listenerList, List<String> types,
+    [Function registerOnEventListener = null]) {
   bool firedWhenAddedToListenerList = false;
   bool firedOnEvent = false;
   listenerList.add((e) {
     firedWhenAddedToListenerList = true;
   });
   if (registerOnEventListener != null) {
     registerOnEventListener((e) {
       firedOnEvent = true;
     });
   }
-  final event = new Event(type);
-  listenerList.dispatch(event);
+  for (var type in types) {
+    final event = new Event(type);
+    listenerList.dispatch(event);
+  }
 
   Expect.isTrue(firedWhenAddedToListenerList);
   if (registerOnEventListener != null) {
     Expect.isTrue(firedOnEvent);
   }
 }
 
 void testConstructorHelper(String tag, String htmlSnippet,
     String expectedText, Function isExpectedClass) {
   Expect.isTrue(isExpectedClass(new Element.tag(tag)));
@@ skipping 25 matching lines @@
     final element = new Element.tag("div");
     element.style.width = '200px';
     element.style.height = '200px';
     container.elements.add(element);
     document.body.elements.add(container);
 
     element.rect.then(expectAsync1((rect) {
       expectLargeRect(rect.client);
       expectLargeRect(rect.offset);
       expectLargeRect(rect.scroll);
-      Expect.equals(rect.bounding.left, 8);
-      Expect.equals(rect.bounding.top, 8);
-      Expect.isTrue(rect.clientRects.length > 0);
+      expect(rect.bounding.left, 8);
+      expect(rect.bounding.top, 8);
+      expect(rect.clientRects.length, greaterThan(0));
       container.remove();
     }));
   });
 
+  test('client position synchronous', () {
+    final container = new Element.tag("div");
+    container.style.position = 'absolute';
+    container.style.top = '8px';
+    container.style.left = '8px';
+    final element = new Element.tag("div");
+    element.style.width = '200px';
+    element.style.height = '200px';
+    container.elements.add(element);
+    document.body.elements.add(container);
+
+    expect(element.clientWidth, greaterThan(100));
+    expect(element.clientHeight, greaterThan(100));
+    expect(element.offsetWidth, greaterThan(100));
+    expect(element.offsetHeight, greaterThan(100));
+    expect(element.scrollWidth, greaterThan(100));
+    expect(element.scrollHeight, greaterThan(100));
+    expect(element.getBoundingClientRect().left, 8);
+    expect(element.getBoundingClientRect().top, 8);
+    container.remove();
+  });
+
   group('constructors', () {
     test('error', () {
       Expect.throws(() => new Element.html('<br/><br/>'),
           (e) => e is ArgumentError);
     });
 
     test('.html has no parent', () =>
         Expect.isNull(new Element.html('<br/>').parent));
 
     test('a', () => testConstructorHelper('a', '<a>foo</a>', 'foo',
@@ skipping 20 matching lines @@
         (element) => element is ButtonElement));
     test('canvas', () => testConstructorHelper('canvas',
         '<canvas>foo</canvas>', 'foo',
         (element) => element is CanvasElement));
     test('dl', () => testConstructorHelper('dl', '<dl>foo</dl>', 'foo',
         (element) => element is DListElement));
     // TODO(jacobr): WebKit doesn't yet support the DataList class.
     // test('datalist', () => testConstructorHelper('datalist',
     //     '<datalist>foo</datalist>', 'foo',
     //     (element) => element is DataListElement));
-    test('details', () => testConstructorHelper('details',
-        '<details>foo</details>', 'foo',
-        (element) => element is DetailsElement));
     test('div', () => testConstructorHelper('div', '<div>foo</div>', 'foo',
         (element) => element is DivElement));
-    test('embed', () => testConstructorHelper('embed',
-        '<embed>foo</embed>', '',
-        (element) => element is EmbedElement));
     test('fieldset', () => testConstructorHelper('fieldset',
         '<fieldset>foo</fieldset>', 'foo',
         (element) => element is FieldSetElement));
     test('font', () => testConstructorHelper('font', '<font>foo</font>', 'foo',
         (element) => element is FontElement));
     test('form', () => testConstructorHelper('form', '<form>foo</form>', 'foo',
         (element) => element is FormElement));
     test('hr', () => testConstructorHelper('hr', '<hr>', '',
         (element) => element is HRElement));
     test('head', () => testConstructorHelper('head',
@@ skipping 11 matching lines @@
         (element) => element is HeadingElement));
     test('h6', () => testConstructorHelper('h6', '<h6>foo</h6>', 'foo',
         (element) => element is HeadingElement));
     test('iframe', () => testConstructorHelper('iframe',
         '<iframe>foo</iframe>', 'foo',
         (element) => element is IFrameElement));
     test('img', () => testConstructorHelper('img', '<img>', '',
         (element) => element is ImageElement));
     test('input', () => testConstructorHelper('input', '<input/>', '',
         (element) => element is InputElement));
-    test('keygen', () => testConstructorHelper('keygen', '<keygen>', '',
-        (element) => element is KeygenElement));
     test('li', () => testConstructorHelper('li', '<li>foo</li>', 'foo',
         (element) => element is LIElement));
     test('label', () => testConstructorHelper('label',
         '<label>foo</label>', 'foo',
         (element) => element is LabelElement));
     test('legend', () => testConstructorHelper('legend',
         '<legend>foo</legend>', 'foo',
         (element) => element is LegendElement));
     test('link', () => testConstructorHelper('link', '<link>', '',
         (element) => element is LinkElement));
     test('map', () => testConstructorHelper('map', '<map>foo</map>', 'foo',
         (element) => element is MapElement));
-    test('marquee', () => testConstructorHelper('marquee',
-        '<marquee>foo</marquee>', 'foo',
-        (element) => element is MarqueeElement));
     test('menu', () => testConstructorHelper('menu', '<menu>foo</menu>', 'foo',
         (element) => element is MenuElement));
     test('meta', () => testConstructorHelper('meta', '<meta>', '',
         (element) => element is MetaElement));
-    test('meter', () => testConstructorHelper('meter',
-        '<meter>foo</meter>', 'foo',
-        (element) => element is MeterElement));
     test('del', () => testConstructorHelper('del', '<del>foo</del>', 'foo',
         (element) => element is ModElement));
     test('ins', () => testConstructorHelper('ins', '<ins>foo</ins>', 'foo',
         (element) => element is ModElement));
     test('ol', () => testConstructorHelper('ol', '<ol>foo</ol>', 'foo',
         (element) => element is OListElement));
-    test('object', () => testConstructorHelper('object',
-        '<object>foo</object>', 'foo',
-        (element) => element is ObjectElement));
     test('optgroup', () => testConstructorHelper('optgroup',
         '<optgroup>foo</optgroup>', 'foo',
         (element) => element is OptGroupElement));
     test('option', () => testConstructorHelper('option',
         '<option>foo</option>', 'foo',
         (element) => element is OptionElement));
     test('output', () => testConstructorHelper('output',
         '<output>foo</output>', 'foo',
         (element) => element is OutputElement));
     test('p', () => testConstructorHelper('p', '<p>foo</p>', 'foo',
@@ skipping 160 matching lines @@
             element, 'mousemove', listener, true));
     testEventHelper(on.mouseOut, 'mouseout',
         (listener) => Testing.addEventListener(
             element, 'mouseout', listener, true));
     testEventHelper(on.mouseOver, 'mouseover',
         (listener) => Testing.addEventListener(
             element, 'mouseover', listener, true));
     testEventHelper(on.mouseUp, 'mouseup',
         (listener) => Testing.addEventListener(
             element, 'mouseup', listener, true));
-    testEventHelper(on.mouseWheel, 'mousewheel',
+    // Browsers have different events that they use, so fire all variants.
+    testMultipleEventHelper(on.mouseWheel,
+        ['mousewheel', 'wheel', 'DOMMouseScroll'],
         (listener) => Testing.addEventListener(
             element, 'mousewheel', listener, true));
     testEventHelper(on.paste, 'paste',
         (listener) => Testing.addEventListener(
             element, 'paste', listener, true));
     testEventHelper(on.reset, 'reset',
         (listener) => Testing.addEventListener(
             element, 'reset', listener, true));
     testEventHelper(on.scroll, 'scroll',
         (listener) => Testing.addEventListener(
@@ skipping 16 matching lines @@
     testEventHelper(on.touchEnd, 'touchend',
         (listener) => Testing.addEventListener(
             element, 'touchend', listener, true));
     testEventHelper(on.touchLeave, 'touchleave');
     testEventHelper(on.touchMove, 'touchmove',
         (listener) => Testing.addEventListener(
             element, 'touchmove', listener, true));
     testEventHelper(on.touchStart, 'touchstart',
         (listener) => Testing.addEventListener(
             element, 'touchstart', listener, true));
-    testEventHelper(on.transitionEnd, 'webkitTransitionEnd');
-    testEventHelper(on.fullscreenChange, 'webkitfullscreenchange',
-        (listener) => Testing.addEventListener(element,
-            'webkitfullscreenchange', listener, true));
   });
 
   group('attributes', () {
       test('manipulation', () {
         final element = new Element.html(
             '''<div class="foo" style="overflow: hidden" data-foo="bar"
                    data-foo2="bar2" dir="rtl">
                </div>''');
         final attributes = element.attributes;
         Expect.equals(attributes['class'], 'foo');
@@ skipping 301 matching lines @@
     });
 
     test('getRange', () {
       var range = makeElList().getRange(1, 2);
       Expect.isTrue(range is List<Element>);
       Expect.isTrue(range[0] is ImageElement);
       Expect.isTrue(range[1] is InputElement);
     });
   });
 }