mirror of
https://github.com/servo/servo.git
synced 2025-08-05 21:50:18 +01:00
Remove [PrimaryGlobal]
This commit is contained in:
parent
84693d8117
commit
2660f35925
167 changed files with 417 additions and 829 deletions
|
@ -1,8 +1,10 @@
|
|||
import traceback
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global]
|
||||
[Global, Exposed=TestConstructorGlobal]
|
||||
interface TestConstructorGlobal {
|
||||
constructor();
|
||||
};
|
||||
|
@ -18,7 +20,8 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global, NamedConstructor=FooBar]
|
||||
[Global, Exposed=TestNamedConstructorGlobal,
|
||||
NamedConstructor=FooBar]
|
||||
interface TestNamedConstructorGlobal {
|
||||
};
|
||||
""")
|
||||
|
@ -32,7 +35,8 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[NamedConstructor=FooBar, Global]
|
||||
[NamedConstructor=FooBar, Global,
|
||||
Exposed=TestNamedConstructorGlobal]
|
||||
interface TestNamedConstructorGlobal {
|
||||
};
|
||||
""")
|
||||
|
@ -46,7 +50,7 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global, HTMLConstructor]
|
||||
[Global, HTMLConstructor, Exposed=TestHTMLConstructorGlobal]
|
||||
interface TestHTMLConstructorGlobal {
|
||||
};
|
||||
""")
|
||||
|
@ -61,7 +65,7 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[HTMLConstructor, Global]
|
||||
[HTMLConstructor, Global, Exposed=TestHTMLConstructorGlobal]
|
||||
interface TestHTMLConstructorGlobal {
|
||||
};
|
||||
""")
|
||||
|
|
|
@ -736,3 +736,17 @@ def WebIDLTest(parser, harness):
|
|||
threw = True
|
||||
|
||||
harness.ok(threw, "Only unrestricted values can be initialized to NaN")
|
||||
|
||||
parser = parser.reset();
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
dictionary Foo {
|
||||
long module;
|
||||
};
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(not threw, "Should be able to use 'module' as a dictionary member name")
|
||||
|
|
|
@ -59,8 +59,6 @@ def WebIDLTest(parser, harness):
|
|||
void passKid(Kid arg);
|
||||
void passParent(Parent arg);
|
||||
void passGrandparent(Grandparent arg);
|
||||
void passImplemented(Implemented arg);
|
||||
void passImplementedParent(ImplementedParent arg);
|
||||
void passUnrelated1(Unrelated1 arg);
|
||||
void passUnrelated2(Unrelated2 arg);
|
||||
void passArrayBuffer(ArrayBuffer arg);
|
||||
|
@ -70,9 +68,6 @@ def WebIDLTest(parser, harness):
|
|||
interface Kid : Parent {};
|
||||
interface Parent : Grandparent {};
|
||||
interface Grandparent {};
|
||||
interface Implemented : ImplementedParent {};
|
||||
Parent implements Implemented;
|
||||
interface ImplementedParent {};
|
||||
interface Unrelated1 {};
|
||||
interface Unrelated2 {};
|
||||
""")
|
||||
|
@ -156,8 +151,7 @@ def WebIDLTest(parser, harness):
|
|||
argTypes = [ "long", "short", "long?", "short?", "boolean",
|
||||
"boolean?", "DOMString", "ByteString", "Enum", "Enum2",
|
||||
"Interface", "Interface?",
|
||||
"AncestorInterface", "UnrelatedInterface",
|
||||
"ImplementedInterface", "CallbackInterface",
|
||||
"AncestorInterface", "UnrelatedInterface", "CallbackInterface",
|
||||
"CallbackInterface?", "CallbackInterface2",
|
||||
"object", "Callback", "Callback2", "Dict",
|
||||
"Dict2", "sequence<long>", "sequence<short>",
|
||||
|
@ -190,7 +184,7 @@ def WebIDLTest(parser, harness):
|
|||
bufferSourceTypes = ["ArrayBuffer", "ArrayBufferView", "Uint8Array", "Uint16Array"]
|
||||
sharedBufferSourceTypes = ["SharedArrayBuffer"]
|
||||
interfaces = [ "Interface", "Interface?", "AncestorInterface",
|
||||
"UnrelatedInterface", "ImplementedInterface" ] + bufferSourceTypes + sharedBufferSourceTypes
|
||||
"UnrelatedInterface" ] + bufferSourceTypes + sharedBufferSourceTypes
|
||||
nullables = (["long?", "short?", "boolean?", "Interface?",
|
||||
"CallbackInterface?", "Dict", "Dict2",
|
||||
"Date?", "any", "Promise<any>?"] +
|
||||
|
@ -230,7 +224,6 @@ def WebIDLTest(parser, harness):
|
|||
setDistinguishable("AncestorInterface", notRelatedInterfaces)
|
||||
setDistinguishable("UnrelatedInterface",
|
||||
allBut(argTypes, ["object", "UnrelatedInterface"]))
|
||||
setDistinguishable("ImplementedInterface", notRelatedInterfaces)
|
||||
setDistinguishable("CallbackInterface", nonUserObjects)
|
||||
setDistinguishable("CallbackInterface?", allBut(nonUserObjects, nullables))
|
||||
setDistinguishable("CallbackInterface2", nonUserObjects)
|
||||
|
@ -272,8 +265,6 @@ def WebIDLTest(parser, harness):
|
|||
interface Interface : AncestorInterface {};
|
||||
interface AncestorInterface {};
|
||||
interface UnrelatedInterface {};
|
||||
interface ImplementedInterface {};
|
||||
Interface implements ImplementedInterface;
|
||||
callback interface CallbackInterface {};
|
||||
callback interface CallbackInterface2 {};
|
||||
callback Callback = any();
|
||||
|
|
|
@ -2,9 +2,9 @@ import WebIDL
|
|||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
[PrimaryGlobal] interface Foo {};
|
||||
[Global=(Bar1,Bar2)] interface Bar {};
|
||||
[Global=Baz2] interface Baz {};
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global=(Bar, Bar1,Bar2), Exposed=Bar] interface Bar {};
|
||||
[Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
|
||||
|
||||
[Exposed=(Foo,Bar1)]
|
||||
interface Iface {
|
||||
|
@ -51,10 +51,11 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[PrimaryGlobal] interface Foo {};
|
||||
[Global=(Bar1,Bar2)] interface Bar {};
|
||||
[Global=Baz2] interface Baz {};
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global=(Bar, Bar1, Bar2), Exposed=Bar] interface Bar {};
|
||||
[Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
|
||||
|
||||
[Exposed=Foo]
|
||||
interface Iface2 {
|
||||
void method3();
|
||||
};
|
||||
|
@ -80,9 +81,9 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[PrimaryGlobal] interface Foo {};
|
||||
[Global=(Bar1,Bar2)] interface Bar {};
|
||||
[Global=Baz2] interface Baz {};
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global=(Bar, Bar1, Bar2), Exposed=Bar] interface Bar {};
|
||||
[Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
|
||||
|
||||
[Exposed=Foo]
|
||||
interface Iface3 {
|
||||
|
@ -90,11 +91,11 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
|
||||
[Exposed=(Foo,Bar1)]
|
||||
interface Mixin {
|
||||
interface mixin Mixin {
|
||||
void method5();
|
||||
};
|
||||
|
||||
Iface3 implements Mixin;
|
||||
Iface3 includes Mixin;
|
||||
""")
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 6, "Should know about six things");
|
||||
|
@ -181,8 +182,8 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global] interface Foo {};
|
||||
[Global] interface Bar {};
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global, Exposed=Bar] interface Bar {};
|
||||
|
||||
[Exposed=Foo]
|
||||
interface Baz {
|
||||
|
@ -198,25 +199,40 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(threw, "Should have thrown on member exposed where its interface is not.")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global] interface Foo {};
|
||||
[Global] interface Bar {};
|
||||
parser.parse("""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global, Exposed=Bar] interface Bar {};
|
||||
|
||||
[Exposed=Foo]
|
||||
interface Baz {
|
||||
void method();
|
||||
};
|
||||
[Exposed=Foo]
|
||||
interface Baz {
|
||||
void method();
|
||||
};
|
||||
|
||||
[Exposed=Bar]
|
||||
interface Mixin {};
|
||||
[Exposed=Bar]
|
||||
interface mixin Mixin {
|
||||
void otherMethod();
|
||||
};
|
||||
|
||||
Baz implements Mixin;
|
||||
""")
|
||||
Baz includes Mixin;
|
||||
""")
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(len(results), 5, "Should know about five things");
|
||||
iface = results[2]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should have an interface here");
|
||||
members = iface.members
|
||||
harness.check(len(members), 2, "Should have two members")
|
||||
|
||||
harness.ok(members[0].exposureSet == set(["Foo"]),
|
||||
"method should have the right exposure set")
|
||||
harness.ok(members[0]._exposureGlobalNames == set(["Foo"]),
|
||||
"method should have the right exposure global names")
|
||||
|
||||
harness.ok(members[1].exposureSet == set(["Bar"]),
|
||||
"otherMethod should have the right exposure set")
|
||||
harness.ok(members[1]._exposureGlobalNames == set(["Bar"]),
|
||||
"otherMethod should have the right exposure global names")
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown on LHS of implements being exposed where RHS is not.")
|
||||
|
|
|
@ -1,9 +1,10 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
[Global]
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo : Bar {
|
||||
getter any(DOMString name);
|
||||
};
|
||||
[Exposed=Foo]
|
||||
interface Bar {};
|
||||
""")
|
||||
|
||||
|
@ -18,7 +19,7 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global]
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo {
|
||||
getter any(DOMString name);
|
||||
setter void(DOMString name, any arg);
|
||||
|
@ -36,7 +37,7 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global]
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo {
|
||||
getter any(DOMString name);
|
||||
deleter void(DOMString name);
|
||||
|
@ -54,7 +55,7 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global, OverrideBuiltins]
|
||||
[Global, OverrideBuiltins, Exposed=Foo]
|
||||
interface Foo {
|
||||
};
|
||||
""")
|
||||
|
@ -70,10 +71,10 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global]
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo : Bar {
|
||||
};
|
||||
[OverrideBuiltins]
|
||||
[OverrideBuiltins, Exposed=Foo]
|
||||
interface Bar {
|
||||
};
|
||||
""")
|
||||
|
@ -89,9 +90,10 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global]
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo {
|
||||
};
|
||||
[Exposed=Foo]
|
||||
interface Bar : Foo {
|
||||
};
|
||||
""")
|
||||
|
|
|
@ -1,216 +0,0 @@
|
|||
# Import the WebIDL module, so we can do isinstance checks and whatnot
|
||||
import WebIDL
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
# Basic functionality
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
A implements B;
|
||||
interface B {
|
||||
attribute long x;
|
||||
};
|
||||
interface A {
|
||||
attribute long y;
|
||||
};
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(not threw, "Should not have thrown on implements statement "
|
||||
"before interfaces")
|
||||
harness.check(len(results), 3, "We have three statements")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface), "B is an interface")
|
||||
harness.check(len(results[1].members), 1, "B has one member")
|
||||
A = results[2]
|
||||
harness.ok(isinstance(A, WebIDL.IDLInterface), "A is an interface")
|
||||
harness.check(len(A.members), 2, "A has two members")
|
||||
harness.check(A.members[0].identifier.name, "y", "First member is 'y'")
|
||||
harness.check(A.members[1].identifier.name, "x", "Second member is 'x'")
|
||||
|
||||
# Duplicated member names not allowed
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
C implements D;
|
||||
interface D {
|
||||
attribute long x;
|
||||
};
|
||||
interface C {
|
||||
attribute long x;
|
||||
};
|
||||
""")
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown on implemented interface duplicating "
|
||||
"a name on base interface")
|
||||
|
||||
# Same, but duplicated across implemented interfaces
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
E implements F;
|
||||
E implements G;
|
||||
interface F {
|
||||
attribute long x;
|
||||
};
|
||||
interface G {
|
||||
attribute long x;
|
||||
};
|
||||
interface E {};
|
||||
""")
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown on implemented interfaces "
|
||||
"duplicating each other's member names")
|
||||
|
||||
# Same, but duplicated across indirectly implemented interfaces
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
H implements I;
|
||||
H implements J;
|
||||
I implements K;
|
||||
interface K {
|
||||
attribute long x;
|
||||
};
|
||||
interface L {
|
||||
attribute long x;
|
||||
};
|
||||
interface I {};
|
||||
interface J : L {};
|
||||
interface H {};
|
||||
""")
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown on indirectly implemented interfaces "
|
||||
"duplicating each other's member names")
|
||||
|
||||
# Same, but duplicated across an implemented interface and its parent
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
M implements N;
|
||||
interface O {
|
||||
attribute long x;
|
||||
};
|
||||
interface N : O {
|
||||
attribute long x;
|
||||
};
|
||||
interface M {};
|
||||
""")
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown on implemented interface and its "
|
||||
"ancestor duplicating member names")
|
||||
|
||||
# Reset the parser so we can actually find things where we expect
|
||||
# them in the list
|
||||
parser = parser.reset()
|
||||
|
||||
# Diamonds should be allowed
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
P implements Q;
|
||||
P implements R;
|
||||
Q implements S;
|
||||
R implements S;
|
||||
interface Q {};
|
||||
interface R {};
|
||||
interface S {
|
||||
attribute long x;
|
||||
};
|
||||
interface P {};
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(not threw, "Diamond inheritance is fine")
|
||||
harness.check(results[6].identifier.name, "S", "We should be looking at 'S'")
|
||||
harness.check(len(results[6].members), 1, "S should have one member")
|
||||
harness.check(results[6].members[0].identifier.name, "x",
|
||||
"S's member should be 'x'")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface TestInterface {
|
||||
};
|
||||
callback interface TestCallbackInterface {
|
||||
};
|
||||
TestInterface implements TestCallbackInterface;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should not allow callback interfaces on the right-hand side "
|
||||
"of 'implements'")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface TestInterface {
|
||||
};
|
||||
callback interface TestCallbackInterface {
|
||||
};
|
||||
TestCallbackInterface implements TestInterface;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should not allow callback interfaces on the left-hand side of "
|
||||
"'implements'")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface TestInterface {
|
||||
};
|
||||
dictionary Dict {
|
||||
};
|
||||
Dict implements TestInterface;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should not allow non-interfaces on the left-hand side "
|
||||
"of 'implements'")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface TestInterface {
|
||||
};
|
||||
dictionary Dict {
|
||||
};
|
||||
TestInterface implements Dict;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should not allow non-interfaces on the right-hand side "
|
||||
"of 'implements'")
|
||||
|
|
@ -80,100 +80,6 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
harness.ok(threw, "Should not allow indirect cycles in interface inheritance chains")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface A {};
|
||||
interface B {};
|
||||
A implements B;
|
||||
B implements A;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow cycles via implements")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface A {};
|
||||
interface C {};
|
||||
interface B {};
|
||||
A implements C;
|
||||
C implements B;
|
||||
B implements A;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow indirect cycles via implements")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface A : B {};
|
||||
interface B {};
|
||||
B implements A;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow inheriting from an interface that implements us")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface A : B {};
|
||||
interface B {};
|
||||
interface C {};
|
||||
B implements C;
|
||||
C implements A;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow inheriting from an interface that indirectly implements us")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface A : B {};
|
||||
interface B : C {};
|
||||
interface C {};
|
||||
C implements A;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow indirectly inheriting from an interface that implements us")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface A : B {};
|
||||
interface B : C {};
|
||||
interface C {};
|
||||
interface D {};
|
||||
C implements D;
|
||||
D implements A;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow indirectly inheriting from an interface that indirectly implements us")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
|
@ -377,7 +283,7 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[Global] interface Window {};
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
[Exposed=Window, LegacyWindowAlias=(C, D)]
|
||||
|
@ -419,7 +325,8 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global] interface Window {};
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window]
|
||||
interface A {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
|
@ -434,9 +341,10 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global] interface Window {};
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
[Exposed=Window]
|
||||
interface A {};
|
||||
""")
|
||||
results = parser.finish()
|
||||
|
@ -449,7 +357,7 @@ def WebIDLTest(parser, harness):
|
|||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global] interface Window {};
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
|
|
|
@ -252,16 +252,6 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
""", mapRWMembers, numProductions=2)
|
||||
|
||||
shouldPass("Implements with maplike/setlike",
|
||||
"""
|
||||
interface Foo1 {
|
||||
maplike<long, long>;
|
||||
};
|
||||
interface Foo2 {
|
||||
};
|
||||
Foo2 implements Foo1;
|
||||
""", mapRWMembers, numProductions=3)
|
||||
|
||||
shouldPass("JS Implemented maplike interface",
|
||||
"""
|
||||
[JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1"]
|
||||
|
@ -350,31 +340,6 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
""")
|
||||
|
||||
shouldFail("Consequential interface with conflicting maplike/setlike",
|
||||
"""
|
||||
interface Foo1 {
|
||||
maplike<long, long>;
|
||||
};
|
||||
interface Foo2 {
|
||||
setlike<long>;
|
||||
};
|
||||
Foo2 implements Foo1;
|
||||
""")
|
||||
|
||||
shouldFail("Consequential interfaces with conflicting maplike/setlike",
|
||||
"""
|
||||
interface Foo1 {
|
||||
maplike<long, long>;
|
||||
};
|
||||
interface Foo2 {
|
||||
setlike<long>;
|
||||
};
|
||||
interface Foo3 {
|
||||
};
|
||||
Foo3 implements Foo1;
|
||||
Foo3 implements Foo2;
|
||||
""")
|
||||
|
||||
#
|
||||
# Member name collision tests
|
||||
#
|
||||
|
@ -477,52 +442,28 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
""", mapRWMembers, numProductions=3)
|
||||
|
||||
shouldFail("Interface with consequential maplike/setlike interface member collision",
|
||||
shouldFail("Maplike interface with mixin member collision",
|
||||
"""
|
||||
interface Foo1 {
|
||||
void entries();
|
||||
};
|
||||
interface Foo2 {
|
||||
maplike<long, long>;
|
||||
};
|
||||
Foo1 implements Foo2;
|
||||
interface mixin Foo2 {
|
||||
void entries();
|
||||
};
|
||||
Foo1 includes Foo2;
|
||||
""")
|
||||
|
||||
shouldFail("Maplike interface with consequential interface member collision",
|
||||
"""
|
||||
interface Foo1 {
|
||||
maplike<long, long>;
|
||||
};
|
||||
interface Foo2 {
|
||||
void entries();
|
||||
};
|
||||
Foo1 implements Foo2;
|
||||
""")
|
||||
|
||||
shouldPass("Consequential Maplike interface with inherited interface member collision",
|
||||
"""
|
||||
interface Foo1 {
|
||||
maplike<long, long>;
|
||||
};
|
||||
interface Foo2 {
|
||||
void entries();
|
||||
};
|
||||
interface Foo3 : Foo2 {
|
||||
};
|
||||
Foo3 implements Foo1;
|
||||
""", mapRWMembers, numProductions=4)
|
||||
|
||||
shouldPass("Inherited Maplike interface with consequential interface member collision",
|
||||
"""
|
||||
interface Foo1 {
|
||||
maplike<long, long>;
|
||||
};
|
||||
interface Foo2 {
|
||||
interface mixin Foo2 {
|
||||
void entries();
|
||||
};
|
||||
interface Foo3 : Foo1 {
|
||||
};
|
||||
Foo3 implements Foo2;
|
||||
Foo3 includes Foo2;
|
||||
""", mapRWMembers, numProductions=4)
|
||||
|
||||
shouldFail("Inheritance of name collision with child maplike/setlike",
|
||||
|
@ -645,7 +586,7 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
""")
|
||||
|
||||
shouldPass("Implemented interface with readonly allowable overrides",
|
||||
shouldPass("Interface with readonly allowable overrides",
|
||||
"""
|
||||
interface Foo1 {
|
||||
readonly setlike<long>;
|
||||
|
|
|
@ -337,10 +337,48 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(threw,
|
||||
"Should fail if an interface mixin includes maplike")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface Interface {
|
||||
attribute short attr;
|
||||
};
|
||||
interface mixin Mixin {
|
||||
attribute short attr;
|
||||
};
|
||||
Interface includes Mixin;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should fail if the included mixin interface has duplicated member")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface Interface {};
|
||||
interface mixin Mixin1 {
|
||||
attribute short attr;
|
||||
};
|
||||
interface mixin Mixin2 {
|
||||
attribute short attr;
|
||||
};
|
||||
Interface includes Mixin1;
|
||||
Interface includes Mixin2;
|
||||
""")
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should fail if the included mixin interfaces have duplicated member")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[Global] interface Window {};
|
||||
[Global] interface Worker {};
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Global, Exposed=Worker] interface Worker {};
|
||||
[Exposed=Window]
|
||||
interface Base {};
|
||||
interface mixin Mixin {
|
||||
|
@ -356,8 +394,8 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[Global] interface Window {};
|
||||
[Global] interface Worker {};
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Global, Exposed=Worker] interface Worker {};
|
||||
[Exposed=Window]
|
||||
interface Base {};
|
||||
[Exposed=Window]
|
||||
|
@ -371,3 +409,29 @@ def WebIDLTest(parser, harness):
|
|||
attr = base.members[0]
|
||||
harness.check(attr.exposureSet, set(["Window"]),
|
||||
"Should follow [Exposed] on interface mixin")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Global, Exposed=Worker] interface Worker {};
|
||||
[Exposed=Window]
|
||||
interface Base1 {};
|
||||
[Exposed=Worker]
|
||||
interface Base2 {};
|
||||
interface mixin Mixin {
|
||||
attribute short a;
|
||||
};
|
||||
Base1 includes Mixin;
|
||||
Base2 includes Mixin;
|
||||
""")
|
||||
results = parser.finish()
|
||||
base = results[2]
|
||||
attr = base.members[0]
|
||||
harness.check(attr.exposureSet, set(["Window", "Worker"]),
|
||||
"Should expose on all globals where including interfaces are "
|
||||
"exposed")
|
||||
base = results[3]
|
||||
attr = base.members[0]
|
||||
harness.check(attr.exposureSet, set(["Window", "Worker"]),
|
||||
"Should expose on all globals where including interfaces are "
|
||||
"exposed")
|
||||
|
|
|
@ -288,33 +288,32 @@ def WebIDLTest(parser, harness):
|
|||
threw = True
|
||||
harness.ok(threw, "[SecureContext] must appear on interfaces that inherit from another [SecureContext] interface")
|
||||
|
||||
# Test 'implements'. The behavior tested here may have to change depending
|
||||
# on the resolution of https://github.com/heycam/webidl/issues/118
|
||||
# Test 'includes'.
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[SecureContext]
|
||||
interface TestSecureContextInterfaceThatImplementsNonSecureContextInterface {
|
||||
interface TestSecureContextInterfaceThatIncludesNonSecureContextMixin {
|
||||
const octet TEST_CONSTANT = 0;
|
||||
};
|
||||
interface TestNonSecureContextInterface {
|
||||
interface mixin TestNonSecureContextMixin {
|
||||
const octet TEST_CONSTANT_2 = 0;
|
||||
readonly attribute byte testAttribute2;
|
||||
void testMethod2(byte foo);
|
||||
};
|
||||
TestSecureContextInterfaceThatImplementsNonSecureContextInterface implements TestNonSecureContextInterface;
|
||||
TestSecureContextInterfaceThatIncludesNonSecureContextMixin includes TestNonSecureContextMixin;
|
||||
""")
|
||||
results = parser.finish()
|
||||
harness.check(len(results[0].members), 4, "TestSecureContextInterfaceThatImplementsNonSecureContextInterface should have two members")
|
||||
harness.check(len(results[0].members), 4, "TestSecureContextInterfaceThatImplementsNonSecureContextInterface should have four members")
|
||||
harness.ok(results[0].getExtendedAttribute("SecureContext"),
|
||||
"Interface should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[0].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to constant members even when other members are copied from a non-[SecureContext] interface")
|
||||
harness.ok(results[0].members[1].getExtendedAttribute("SecureContext") is None,
|
||||
"Constants copied from non-[SecureContext] interface should not be [SecureContext]")
|
||||
"Constants copied from non-[SecureContext] mixin should not be [SecureContext]")
|
||||
harness.ok(results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"Attributes copied from non-[SecureContext] interface should not be [SecureContext]")
|
||||
"Attributes copied from non-[SecureContext] mixin should not be [SecureContext]")
|
||||
harness.ok(results[0].members[3].getExtendedAttribute("SecureContext") is None,
|
||||
"Methods copied from non-[SecureContext] interface should not be [SecureContext]")
|
||||
"Methods copied from non-[SecureContext] mixin should not be [SecureContext]")
|
||||
|
||||
# Test SecureContext and NoInterfaceObject
|
||||
parser = parser.reset()
|
||||
|
|
|
@ -141,16 +141,16 @@ def WebIDLTest(parser, harness):
|
|||
interface Child : Parent {
|
||||
};
|
||||
interface Parent {};
|
||||
interface Consequential {
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
};
|
||||
Parent implements Consequential;
|
||||
Parent includes Mixin;
|
||||
""")
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 4,
|
||||
"Should be able to inherit from an interface with a "
|
||||
"consequential interface with [Unforgeable] properties.")
|
||||
"mixin with [Unforgeable] properties.")
|
||||
|
||||
parser = parser.reset();
|
||||
threw = False
|
||||
|
@ -160,10 +160,10 @@ def WebIDLTest(parser, harness):
|
|||
void foo();
|
||||
};
|
||||
interface Parent {};
|
||||
interface Consequential {
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
};
|
||||
Parent implements Consequential;
|
||||
Parent includes Mixin;
|
||||
""")
|
||||
|
||||
results = parser.finish()
|
||||
|
@ -182,14 +182,14 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
interface Parent : GrandParent {};
|
||||
interface GrandParent {};
|
||||
interface Consequential {
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
};
|
||||
GrandParent implements Consequential;
|
||||
interface ChildConsequential {
|
||||
GrandParent includes Mixin;
|
||||
interface mixin ChildMixin {
|
||||
void foo();
|
||||
};
|
||||
Child implements ChildConsequential;
|
||||
Child includes ChildMixin;
|
||||
""")
|
||||
|
||||
results = parser.finish()
|
||||
|
@ -208,14 +208,14 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
interface Parent : GrandParent {};
|
||||
interface GrandParent {};
|
||||
interface Consequential {
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] void foo();
|
||||
};
|
||||
GrandParent implements Consequential;
|
||||
interface ChildConsequential {
|
||||
GrandParent includes Mixin;
|
||||
interface mixin ChildMixin {
|
||||
void foo();
|
||||
};
|
||||
Child implements ChildConsequential;
|
||||
Child includes ChildMixin;
|
||||
""")
|
||||
|
||||
results = parser.finish()
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue