1 files changed, 311 insertions, 0 deletions
diff --git a/dom/bindings/parser/tests/test_unforgeable.py b/dom/bindings/parser/tests/test_unforgeable.py
new file mode 100644
index 0000000000..18946bcc50
--- /dev/null
+++ b/dom/bindings/parser/tests/test_unforgeable.py
@@ -0,0 +1,311 @@
+def WebIDLTest(parser, harness):
+    parser.parse(
+        """
+            interface Child : Parent {
+            };
+            interface Parent {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+        """
+    )
+
+    results = parser.finish()
+    harness.check(
+        len(results),
+        2,
+        "Should be able to inherit from an interface with "
+        "[LegacyUnforgeable] properties.",
+    )
+
+    parser = parser.reset()
+    parser.parse(
+        """
+            interface Child : Parent {
+              const short foo = 10;
+            };
+            interface Parent {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+        """
+    )
+
+    results = parser.finish()
+    harness.check(
+        len(results),
+        2,
+        "Should be able to inherit from an interface with "
+        "[LegacyUnforgeable] properties even if we have a constant with "
+        "the same name.",
+    )
+
+    parser = parser.reset()
+    parser.parse(
+        """
+            interface Child : Parent {
+              static attribute short foo;
+            };
+            interface Parent {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+        """
+    )
+
+    results = parser.finish()
+    harness.check(
+        len(results),
+        2,
+        "Should be able to inherit from an interface with "
+        "[LegacyUnforgeable] properties even if we have a static attribute "
+        "with the same name.",
+    )
+
+    parser = parser.reset()
+    parser.parse(
+        """
+            interface Child : Parent {
+              static undefined foo();
+            };
+            interface Parent {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+        """
+    )
+
+    results = parser.finish()
+    harness.check(
+        len(results),
+        2,
+        "Should be able to inherit from an interface with "
+        "[LegacyUnforgeable] properties even if we have a static operation "
+        "with the same name.",
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Child : Parent {
+              undefined foo();
+            };
+            interface Parent {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+    harness.ok(
+        threw,
+        "Should have thrown when shadowing unforgeable attribute on "
+        "parent with operation.",
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Child : Parent {
+              undefined foo();
+            };
+            interface Parent {
+              [LegacyUnforgeable] undefined foo();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+    harness.ok(
+        threw,
+        "Should have thrown when shadowing unforgeable operation on "
+        "parent with operation.",
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Child : Parent {
+              attribute short foo;
+            };
+            interface Parent {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+    harness.ok(
+        threw,
+        "Should have thrown when shadowing unforgeable attribute on "
+        "parent with attribute.",
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Child : Parent {
+              attribute short foo;
+            };
+            interface Parent {
+              [LegacyUnforgeable] undefined foo();
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+    harness.ok(
+        threw,
+        "Should have thrown when shadowing unforgeable operation on "
+        "parent with attribute.",
+    )
+
+    parser = parser.reset()
+    parser.parse(
+        """
+            interface Child : Parent {
+            };
+            interface Parent {};
+            interface mixin Mixin {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+            Parent includes Mixin;
+        """
+    )
+
+    results = parser.finish()
+    harness.check(
+        len(results),
+        4,
+        "Should be able to inherit from an interface with a "
+        "mixin with [LegacyUnforgeable] properties.",
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Child : Parent {
+              undefined foo();
+            };
+            interface Parent {};
+            interface mixin Mixin {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+            Parent includes Mixin;
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+
+    harness.ok(
+        threw,
+        "Should have thrown when shadowing unforgeable attribute "
+        "of parent's consequential interface.",
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Child : Parent {
+            };
+            interface Parent : GrandParent {};
+            interface GrandParent {};
+            interface mixin Mixin {
+              [LegacyUnforgeable] readonly attribute long foo;
+            };
+            GrandParent includes Mixin;
+            interface mixin ChildMixin {
+              undefined foo();
+            };
+            Child includes ChildMixin;
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+
+    harness.ok(
+        threw,
+        "Should have thrown when our consequential interface shadows unforgeable attribute "
+        "of ancestor's consequential interface.",
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface Child : Parent {
+            };
+            interface Parent : GrandParent {};
+            interface GrandParent {};
+            interface mixin Mixin {
+              [LegacyUnforgeable] undefined foo();
+            };
+            GrandParent includes Mixin;
+            interface mixin ChildMixin {
+              undefined foo();
+            };
+            Child includes ChildMixin;
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+
+    harness.ok(
+        threw,
+        "Should have thrown when our consequential interface shadows unforgeable operation "
+        "of ancestor's consequential interface.",
+    )
+
+    parser = parser.reset()
+    parser.parse(
+        """
+        interface iface {
+          [LegacyUnforgeable] attribute long foo;
+        };
+    """
+    )
+
+    results = parser.finish()
+    harness.check(
+        len(results), 1, "Should allow writable [LegacyUnforgeable] attribute."
+    )
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse(
+            """
+            interface iface {
+              [LegacyUnforgeable] static readonly attribute long foo;
+            };
+        """
+        )
+
+        results = parser.finish()
+    except Exception:
+        threw = True
+
+    harness.ok(threw, "Should have thrown for static [LegacyUnforgeable] attribute.")