Add supported checks to the SVG library, and library cleanup.

tests/html/svg_test.dart

Index: tests/html/svg_test.dart
diff --git a/tests/html/svg_test.dart b/tests/html/svg_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..0c6071271a20b03c9b751c1567df2493c3d2b38a
--- /dev/null
+++ b/tests/html/svg_test.dart
@@ -0,0 +1,247 @@
+// 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 SVGTest;
+import '../../pkg/unittest/lib/unittest.dart';
+import '../../pkg/unittest/lib/html_individual_config.dart';
+import 'dart:html';
+import 'dart:svg' as svg;
+
+main() {
+  useHtmlIndividualConfiguration();
+
+  group('svgPresence', () {
+    var isSvgElement = predicate((x) => x is svg.SvgElement, 'is a SvgElement');
+
+    test('simpleRect', () {
+      var div = new Element.tag('div');
+      document.body.nodes.add(div);
+      div.innerHtml = r'''
+<svg id='svg1' width='200' height='100'>
+<rect id='rect1' x='10' y='20' width='130' height='40' rx='5'fill='blue'></rect>
+</svg>
+
+''';
+
+      var e = document.query('#svg1');
+      expect(e, isNotNull);
+
+      svg.RectElement r = document.query('#rect1');
+      expect(r.x.baseVal.value, 10);
+      expect(r.y.baseVal.value, 20);
+      expect(r.height.baseVal.value, 40);
+      expect(r.width.baseVal.value, 130);
+      expect(r.rx.baseVal.value, 5);
+    });
+
+    test('trailing newline', () {
+      // Ensures that we handle SVG with trailing newlines.
+      var logo = new svg.SvgElement.svg("""
+        <svg xmlns='http://www.w3.org/2000/svg' version='1.1'>
+          <path/>
+        </svg>
+        """);
+
+    expect(logo, isSvgElement);
+
+    });
+  });
+
+  group('svgInterfaceMatch', () {
+    // Test that SVG elements explicitly implement the IDL interfaces (is-checks
+    // only, see SVGTest3 for behavioural tests).
+    insertTestDiv() {
+      var element = new Element.tag('div');
+      element.innerHtml = r'''
+<svg id='svg1' width='200' height='100'>
+<rect id='rect1' x='10' y='20' width='130' height='40' rx='5'fill='blue'></rect>
+</svg>
+''';
+      document.body.nodes.add(element);
+      return element;
+    }
+
+
+    var isElement = predicate((x) => x is Element, 'is an Element');
+    var isSvgElement = predicate((x) => x is svg.SvgElement, 'is a SvgElement');
+    var isSvgSvgElement =
+        predicate((x) => x is svg.SvgSvgElement, 'is a SvgSvgElement');
+    var isNode = predicate((x) => x is Node, 'is a Node');
+    var isSvgTests = predicate((x) => x is svg.Tests, 'is a svg.Tests');
+    var isSvgLangSpace = predicate((x) => x is svg.LangSpace, 'is a svg.LangSpace');
+    var isSvgExternalResourcesRequired =
+        predicate((x) => x is svg.ExternalResourcesRequired,
+            'is a svg.ExternalResourcesRequired');
+    var isSvgTransformable =
+        predicate((x) => x is svg.Transformable, 'is a svg.Transformable');
+    var isSvgLocatable =
+        predicate((x) => x is svg.Locatable, 'is a svg.Locatable');
+    var isSvgNumber = predicate((x) => x is svg.Number, 'is a svg.Number');
+    var isSvgRect = predicate((x) => x is svg.Rect, 'is a svg.Rect');
+
+    test('rect_isChecks', () {
+        var div = insertTestDiv();
+        var r = document.query('#rect1');
+
+        // Direct inheritance chain
+        expect(r, isSvgElement);
+        expect(r, isElement);
+        expect(r, isNode);
+
+        // Other implemented interfaces.
+        expect(r, isSvgTests);
+        expect(r, isSvgLangSpace);
+        expect(r, isSvgExternalResourcesRequired);
+        expect(r, isSvgTransformable);
+        expect(r, isSvgLocatable);
+
+        // Interfaces not implemented.
+        expect(r, isNot(isSvgNumber));
+        expect(r, isNot(isSvgRect));
+        expect(r, isNot(isSvgSvgElement));
+
+        div.remove();
+      });
+    });
+
+  insertTestDiv() {
+    var element = new Element.tag('div');
+    element.innerHtml = r'''
+<svg id='svg1' width='200' height='100'>
+<rect id='rect1' x='10' y='20' width='130' height='40' rx='5'fill='blue'></rect>
+</svg>
+''';
+    document.body.nodes.add(element);
+    return element;
+  }
+
+  group('supported_externalResourcesRequired', () {
+    test('supported', () {
+      var div = insertTestDiv();
+      var r = document.query('#rect1');
+      expect(svg.ExternalResourcesRequired.supported(r), true);
+      div.remove();
+    });
+  });
+
+  group('supported_langSpace', () {
+    test('supported', () {
+      var div = insertTestDiv();
+      var r = document.query('#rect1');
+      expect(svg.LangSpace.supported(r), true);
+      div.remove();
+    });
+  });
+
+  group('svgBehavioral', () {
+
+    // Test that SVG elements have the operations advertised through all the IDL
+    // interfaces.  This is a 'duck typing' test, and does not explicitly use
+    // 'is' checks on the expected interfaces (that is in the test group above).
+
+    var isString = predicate((x) => x is String, 'is a String');
+    var isStringList = predicate((x) => x is List<String>, 'is a List<String>');
+    var isSvgMatrix = predicate((x) => x is svg.Matrix, 'is a svg.Matrix');
+    var isSvgAnimatedBoolean =
+        predicate((x) => x is svg.AnimatedBoolean, 'is an svg.AnimatedBoolean');
+    var isSvgAnimatedString =
+        predicate((x) => x is svg.AnimatedString, 'is an svg.AnimatedString');
+    var isSvgRect = predicate((x) => x is svg.Rect, 'is a svg.Rect');
+    var isSvgAnimatedTransformList =
+        predicate((x) => x is svg.AnimatedTransformList,
+            'is an svg.AnimatedTransformList');
+    var isCssStyleDeclaration =
+        predicate((x) => x is CssStyleDeclaration, 'is a CssStyleDeclaration');
+    var isCssValue = predicate((x) => x is CssValue, 'is a CssValue');
+
+    /// Verifies that [e] supports the operations on the svg.Tests interface.
+    checkSvgTests(e) {
+      // Just check that the operations seem to exist.
+      var rx = e.requiredExtensions;
+      expect(rx, isStringList);
+      var rf = e.requiredFeatures;
+      expect(rf, isStringList);
+      var sl = e.systemLanguage;
+      expect(sl, isStringList);
+
+      bool hasDoDo = e.hasExtension("DoDo");
+      expect(hasDoDo, isFalse);
+    }
+
+    /// Verifies that [e] supports the operations on the svg.Locatable interface.
+    checkSvgLocatable(e) {
+      var v1 = e.farthestViewportElement;
+      var v2 = e.nearestViewportElement;
+      expect(v1, same(v2));
+
+      var bbox = e.getBBox();
+      expect(bbox, isSvgRect);
+
+      var ctm = e.getCtm();
+      expect(ctm, isSvgMatrix);
+
+      var sctm = e.getScreenCtm();
+      expect(sctm, isSvgMatrix);
+
+      var xf2e = e.getTransformToElement(e);
+      expect(xf2e, isSvgMatrix);
+    }
+
+    /**
+     * Verifies that [e] supports the operations on the svg.Transformable
+     * interface.
+     */
+    checkSvgTransformable(e) {
+      var trans = e.transform;
+      expect(trans, isSvgAnimatedTransformList);
+    }
+
+    testRect(name, checker) {
+      test(name, () {
+        var div = insertTestDiv();
+        var r = document.query('#rect1');
+        checker(r);
+        div.remove();
+      });
+    }
+
+    /**
+     * Verifies that [e] supports the operations on the svg.LangSpace interface.
+     */
+    checkSvgLangSpace(e) {
+      if (svg.LangSpace.supported(e)) {
+        // Just check that the attributes seem to exist.
+        var lang = e.xmllang;
+        e.xmllang = lang;
+
+        String space = e.xmlspace;
+        e.xmlspace = space;
+
+        expect(lang, isString);
+        expect(space, isString);
+      }
+    }
+
+    /**
+     * Verifies that [e] supports the operations on the
+     * svg.ExternalResourcesRequired interface.
+     */
+    checkSvgExternalResourcesRequired(e) {
+      if (svg.ExternalResourcesRequired.supported(e)) {
+        var b = e.externalResourcesRequired;
+        expect(b, isSvgAnimatedBoolean);
+        expect(b.baseVal, isFalse);
+        expect(b.animVal, isFalse);
+      }
+    }
+
+    testRect('rect_SvgTests', checkSvgTests);
+    testRect('rect_SvgLangSpace', checkSvgLangSpace);
+    testRect('rect_SvgExternalResourcesRequired',
+             checkSvgExternalResourcesRequired);
+    testRect('rect_SvgLocatable', checkSvgLocatable);
+    testRect('rect_SvgTransformable', checkSvgTransformable);
+  });
+
+}