mirror of
https://github.com/servo/servo.git
synced 2025-08-03 04:30:10 +01:00
Update WebIDL
This commit is contained in:
parent
6f563830d1
commit
4d393612b4
77 changed files with 9035 additions and 4668 deletions
File diff suppressed because it is too large
Load diff
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface DoubleNull {
|
||||
attribute any? foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface ArgumentIdentifierConflict {
|
||||
undefined foo(boolean arg1, boolean arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,17 +1,22 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
undefined foo(object constructor);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should have an interface");
|
||||
iface = results[0];
|
||||
harness.check(len(iface.members), 1, "Should have an operation");
|
||||
operation = iface.members[0];
|
||||
harness.check(len(operation.signatures()), 1, "Should have one signature");
|
||||
(retval, args) = operation.signatures()[0];
|
||||
harness.check(len(args), 1, "Should have an argument");
|
||||
harness.check(args[0].identifier.name, "constructor",
|
||||
"Should have an identifier named 'constructor'");
|
||||
harness.check(len(results), 1, "Should have an interface")
|
||||
iface = results[0]
|
||||
harness.check(len(iface.members), 1, "Should have an operation")
|
||||
operation = iface.members[0]
|
||||
harness.check(len(operation.signatures()), 1, "Should have one signature")
|
||||
(retval, args) = operation.signatures()[0]
|
||||
harness.check(len(args), 1, "Should have an argument")
|
||||
harness.check(
|
||||
args[0].identifier.name,
|
||||
"constructor",
|
||||
"Should have an identifier named 'constructor'",
|
||||
)
|
||||
|
|
|
@ -1,14 +0,0 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface UndefinedArgument1 {
|
||||
undefined foo(undefined arg2);
|
||||
};
|
||||
""")
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown.")
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestArrayBuffer {
|
||||
attribute ArrayBuffer bufferAttr;
|
||||
undefined bufferMethod(ArrayBuffer arg1, ArrayBuffer? arg2, sequence<ArrayBuffer> arg3);
|
||||
|
@ -36,7 +38,8 @@ def WebIDLTest(parser, harness):
|
|||
attribute Float64Array float64ArrayAttr;
|
||||
undefined float64ArrayMethod(Float64Array arg1, Float64Array? arg2, sequence<Float64Array> arg3);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
|
@ -55,24 +58,35 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(attr.type.isSpiderMonkeyInterface(), "Should test as a js interface")
|
||||
|
||||
(retType, arguments) = method.signatures()[0]
|
||||
harness.ok(retType.isUndefined(), "Should have a undefined return type")
|
||||
harness.ok(retType.isUndefined(), "Should have an undefined return type")
|
||||
harness.check(len(arguments), 3, "Expect 3 arguments")
|
||||
|
||||
harness.check(str(arguments[0].type), t, "Expect an ArrayBuffer type")
|
||||
harness.ok(arguments[0].type.isSpiderMonkeyInterface(), "Should test as a js interface")
|
||||
harness.check(str(arguments[0].type), t, "Expect an ArrayBuffer type")
|
||||
harness.ok(
|
||||
arguments[0].type.isSpiderMonkeyInterface(), "Should test as a js interface"
|
||||
)
|
||||
|
||||
harness.check(str(arguments[1].type), t + "OrNull", "Expect an ArrayBuffer type")
|
||||
harness.ok(arguments[1].type.inner.isSpiderMonkeyInterface(), "Should test as a js interface")
|
||||
harness.check(
|
||||
str(arguments[1].type), t + "OrNull", "Expect an ArrayBuffer type"
|
||||
)
|
||||
harness.ok(
|
||||
arguments[1].type.inner.isSpiderMonkeyInterface(),
|
||||
"Should test as a js interface",
|
||||
)
|
||||
|
||||
harness.check(str(arguments[2].type), t + "Sequence", "Expect an ArrayBuffer type")
|
||||
harness.ok(arguments[2].type.inner.isSpiderMonkeyInterface(), "Should test as a js interface")
|
||||
harness.check(
|
||||
str(arguments[2].type), t + "Sequence", "Expect an ArrayBuffer type"
|
||||
)
|
||||
harness.ok(
|
||||
arguments[2].type.inner.isSpiderMonkeyInterface(),
|
||||
"Should test as a js interface",
|
||||
)
|
||||
|
||||
|
||||
checkStuff(members[0], members[1], "ArrayBuffer")
|
||||
checkStuff(members[2], members[3], "ArrayBufferView")
|
||||
checkStuff(members[4], members[5], "Int8Array")
|
||||
checkStuff(members[6], members[7], "Uint8Array")
|
||||
checkStuff(members[8], members[9], "Uint8ClampedArray")
|
||||
checkStuff(members[0], members[1], "ArrayBuffer")
|
||||
checkStuff(members[2], members[3], "ArrayBufferView")
|
||||
checkStuff(members[4], members[5], "Int8Array")
|
||||
checkStuff(members[6], members[7], "Uint8Array")
|
||||
checkStuff(members[8], members[9], "Uint8ClampedArray")
|
||||
checkStuff(members[10], members[11], "Int16Array")
|
||||
checkStuff(members[12], members[13], "Uint16Array")
|
||||
checkStuff(members[14], members[15], "Int32Array")
|
||||
|
|
|
@ -1,31 +1,35 @@
|
|||
import WebIDL
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
testData = [("::TestAttr%s::b", "b", "Byte%s", False),
|
||||
("::TestAttr%s::rb", "rb", "Byte%s", True),
|
||||
("::TestAttr%s::o", "o", "Octet%s", False),
|
||||
("::TestAttr%s::ro", "ro", "Octet%s", True),
|
||||
("::TestAttr%s::s", "s", "Short%s", False),
|
||||
("::TestAttr%s::rs", "rs", "Short%s", True),
|
||||
("::TestAttr%s::us", "us", "UnsignedShort%s", False),
|
||||
("::TestAttr%s::rus", "rus", "UnsignedShort%s", True),
|
||||
("::TestAttr%s::l", "l", "Long%s", False),
|
||||
("::TestAttr%s::rl", "rl", "Long%s", True),
|
||||
("::TestAttr%s::ul", "ul", "UnsignedLong%s", False),
|
||||
("::TestAttr%s::rul", "rul", "UnsignedLong%s", True),
|
||||
("::TestAttr%s::ll", "ll", "LongLong%s", False),
|
||||
("::TestAttr%s::rll", "rll", "LongLong%s", True),
|
||||
("::TestAttr%s::ull", "ull", "UnsignedLongLong%s", False),
|
||||
("::TestAttr%s::rull", "rull", "UnsignedLongLong%s", True),
|
||||
("::TestAttr%s::str", "str", "String%s", False),
|
||||
("::TestAttr%s::rstr", "rstr", "String%s", True),
|
||||
("::TestAttr%s::obj", "obj", "Object%s", False),
|
||||
("::TestAttr%s::robj", "robj", "Object%s", True),
|
||||
("::TestAttr%s::object", "object", "Object%s", False),
|
||||
("::TestAttr%s::f", "f", "Float%s", False),
|
||||
("::TestAttr%s::rf", "rf", "Float%s", True)]
|
||||
|
||||
parser.parse("""
|
||||
def WebIDLTest(parser, harness):
|
||||
testData = [
|
||||
("::TestAttr%s::b", "b", "Byte%s", False),
|
||||
("::TestAttr%s::rb", "rb", "Byte%s", True),
|
||||
("::TestAttr%s::o", "o", "Octet%s", False),
|
||||
("::TestAttr%s::ro", "ro", "Octet%s", True),
|
||||
("::TestAttr%s::s", "s", "Short%s", False),
|
||||
("::TestAttr%s::rs", "rs", "Short%s", True),
|
||||
("::TestAttr%s::us", "us", "UnsignedShort%s", False),
|
||||
("::TestAttr%s::rus", "rus", "UnsignedShort%s", True),
|
||||
("::TestAttr%s::l", "l", "Long%s", False),
|
||||
("::TestAttr%s::rl", "rl", "Long%s", True),
|
||||
("::TestAttr%s::ul", "ul", "UnsignedLong%s", False),
|
||||
("::TestAttr%s::rul", "rul", "UnsignedLong%s", True),
|
||||
("::TestAttr%s::ll", "ll", "LongLong%s", False),
|
||||
("::TestAttr%s::rll", "rll", "LongLong%s", True),
|
||||
("::TestAttr%s::ull", "ull", "UnsignedLongLong%s", False),
|
||||
("::TestAttr%s::rull", "rull", "UnsignedLongLong%s", True),
|
||||
("::TestAttr%s::str", "str", "String%s", False),
|
||||
("::TestAttr%s::rstr", "rstr", "String%s", True),
|
||||
("::TestAttr%s::obj", "obj", "Object%s", False),
|
||||
("::TestAttr%s::robj", "robj", "Object%s", True),
|
||||
("::TestAttr%s::object", "object", "Object%s", False),
|
||||
("::TestAttr%s::f", "f", "Float%s", False),
|
||||
("::TestAttr%s::rf", "rf", "Float%s", True),
|
||||
]
|
||||
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestAttr {
|
||||
attribute byte b;
|
||||
readonly attribute byte rb;
|
||||
|
@ -77,13 +81,13 @@ def WebIDLTest(parser, harness):
|
|||
attribute float? f;
|
||||
readonly attribute float? rf;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
def checkAttr(attr, QName, name, type, readonly):
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute),
|
||||
"Should be an IDLAttribute")
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
harness.ok(attr.isAttr(), "Attr is an Attr")
|
||||
harness.ok(not attr.isMethod(), "Attr is not an method")
|
||||
harness.ok(not attr.isConst(), "Attr is not a const")
|
||||
|
@ -95,11 +99,14 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(True, "TestAttr interface parsed without error.")
|
||||
harness.check(len(results), 2, "Should be two productions.")
|
||||
iface = results[0]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestAttr", "Interface has the right QName")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestAttr", "Interface has the right QName"
|
||||
)
|
||||
harness.check(iface.identifier.name, "TestAttr", "Interface has the right name")
|
||||
harness.check(len(iface.members), len(testData), "Expect %s members" % len(testData))
|
||||
harness.check(
|
||||
len(iface.members), len(testData), "Expect %s members" % len(testData)
|
||||
)
|
||||
|
||||
attrs = iface.members
|
||||
|
||||
|
@ -110,11 +117,16 @@ def WebIDLTest(parser, harness):
|
|||
checkAttr(attr, QName % "", name, type % "", readonly)
|
||||
|
||||
iface = results[1]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestAttrNullable", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "TestAttrNullable", "Interface has the right name")
|
||||
harness.check(len(iface.members), len(testData), "Expect %s members" % len(testData))
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestAttrNullable", "Interface has the right QName"
|
||||
)
|
||||
harness.check(
|
||||
iface.identifier.name, "TestAttrNullable", "Interface has the right name"
|
||||
)
|
||||
harness.check(
|
||||
len(iface.members), len(testData), "Expect %s members" % len(testData)
|
||||
)
|
||||
|
||||
attrs = iface.members
|
||||
|
||||
|
@ -127,11 +139,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[SetterThrows] readonly attribute boolean foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
@ -140,11 +154,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Throw] readonly attribute boolean foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
@ -153,24 +169,30 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[SameObject] readonly attribute boolean foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "Should not allow [SameObject] on attributes not of interface type")
|
||||
harness.ok(
|
||||
threw, "Should not allow [SameObject] on attributes not of interface type"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[SameObject] readonly attribute A foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface AttrSequenceType {
|
||||
attribute sequence<object> foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -17,51 +19,59 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface AttrUnionWithSequenceType {
|
||||
attribute (sequence<object> or DOMString) foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Attribute type must not be a union with a sequence member type")
|
||||
harness.ok(threw, "Attribute type must not be a union with a sequence member type")
|
||||
|
||||
parser.reset()
|
||||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface AttrNullableUnionWithSequenceType {
|
||||
attribute (sequence<object>? or DOMString) foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Attribute type must not be a union with a nullable sequence "
|
||||
"member type")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Attribute type must not be a union with a nullable sequence " "member type",
|
||||
)
|
||||
|
||||
parser.reset()
|
||||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface AttrUnionWithUnionWithSequenceType {
|
||||
attribute ((sequence<object> or DOMString) or AttrUnionWithUnionWithSequenceType) foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Attribute type must not be a union type with a union member "
|
||||
"type that has a sequence member type")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Attribute type must not be a union type with a union member "
|
||||
"type that has a sequence member type",
|
||||
)
|
||||
|
|
|
@ -1,14 +1,16 @@
|
|||
# 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("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [EnforceRange] long Foo;
|
||||
typedef [Clamp] long Bar;
|
||||
typedef [TreatNullAs=EmptyString] DOMString Baz;
|
||||
typedef [LegacyNullToEmptyString] DOMString Baz;
|
||||
dictionary A {
|
||||
required [EnforceRange] long a;
|
||||
required [Clamp] long b;
|
||||
|
@ -19,11 +21,12 @@ def WebIDLTest(parser, harness):
|
|||
attribute Foo typedefFoo;
|
||||
attribute [EnforceRange] long foo;
|
||||
attribute [Clamp] long bar;
|
||||
attribute [TreatNullAs=EmptyString] DOMString baz;
|
||||
attribute [LegacyNullToEmptyString] DOMString baz;
|
||||
undefined method([EnforceRange] long foo, [Clamp] long bar,
|
||||
[TreatNullAs=EmptyString] DOMString baz);
|
||||
[LegacyNullToEmptyString] DOMString baz);
|
||||
undefined method2(optional [EnforceRange] long foo, optional [Clamp] long bar,
|
||||
optional [TreatNullAs=EmptyString] DOMString baz);
|
||||
optional [LegacyNullToEmptyString] DOMString baz);
|
||||
undefined method3(optional [LegacyNullToEmptyString] UTF8String foo = "");
|
||||
};
|
||||
interface C {
|
||||
attribute [EnforceRange] long? foo;
|
||||
|
@ -40,34 +43,88 @@ def WebIDLTest(parser, harness):
|
|||
interface Iterable {
|
||||
iterable<[Clamp] long, [EnforceRange] long>;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(not threw, "Should not have thrown on parsing normal")
|
||||
if not threw:
|
||||
harness.check(results[0].innerType.hasEnforceRange(), True, "Foo is [EnforceRange]")
|
||||
harness.check(
|
||||
results[0].innerType.hasEnforceRange(), True, "Foo is [EnforceRange]"
|
||||
)
|
||||
harness.check(results[1].innerType.hasClamp(), True, "Bar is [Clamp]")
|
||||
harness.check(results[2].innerType.treatNullAsEmpty, True, "Baz is [TreatNullAs=EmptyString]")
|
||||
harness.check(
|
||||
results[2].innerType.legacyNullToEmptyString,
|
||||
True,
|
||||
"Baz is [LegacyNullToEmptyString]",
|
||||
)
|
||||
A = results[3]
|
||||
harness.check(A.members[0].type.hasEnforceRange(), True, "A.a is [EnforceRange]")
|
||||
harness.check(
|
||||
A.members[0].type.hasEnforceRange(), True, "A.a is [EnforceRange]"
|
||||
)
|
||||
harness.check(A.members[1].type.hasClamp(), True, "A.b is [Clamp]")
|
||||
harness.check(A.members[2].type.hasEnforceRange(), True, "A.c is [EnforceRange]")
|
||||
harness.check(A.members[3].type.hasEnforceRange(), True, "A.d is [EnforceRange]")
|
||||
harness.check(
|
||||
A.members[2].type.hasEnforceRange(), True, "A.c is [EnforceRange]"
|
||||
)
|
||||
harness.check(
|
||||
A.members[3].type.hasEnforceRange(), True, "A.d is [EnforceRange]"
|
||||
)
|
||||
B = results[4]
|
||||
harness.check(B.members[0].type.hasEnforceRange(), True, "B.typedefFoo is [EnforceRange]")
|
||||
harness.check(B.members[1].type.hasEnforceRange(), True, "B.foo is [EnforceRange]")
|
||||
harness.check(
|
||||
B.members[0].type.hasEnforceRange(), True, "B.typedefFoo is [EnforceRange]"
|
||||
)
|
||||
harness.check(
|
||||
B.members[1].type.hasEnforceRange(), True, "B.foo is [EnforceRange]"
|
||||
)
|
||||
harness.check(B.members[2].type.hasClamp(), True, "B.bar is [Clamp]")
|
||||
harness.check(B.members[3].type.treatNullAsEmpty, True, "B.baz is [TreatNullAs=EmptyString]")
|
||||
harness.check(
|
||||
B.members[3].type.legacyNullToEmptyString,
|
||||
True,
|
||||
"B.baz is [LegacyNullToEmptyString]",
|
||||
)
|
||||
method = B.members[4].signatures()[0][1]
|
||||
harness.check(method[0].type.hasEnforceRange(), True, "foo argument of method is [EnforceRange]")
|
||||
harness.check(method[1].type.hasClamp(), True, "bar argument of method is [Clamp]")
|
||||
harness.check(method[2].type.treatNullAsEmpty, True, "baz argument of method is [TreatNullAs=EmptyString]")
|
||||
harness.check(
|
||||
method[0].type.hasEnforceRange(),
|
||||
True,
|
||||
"foo argument of method is [EnforceRange]",
|
||||
)
|
||||
harness.check(
|
||||
method[1].type.hasClamp(), True, "bar argument of method is [Clamp]"
|
||||
)
|
||||
harness.check(
|
||||
method[2].type.legacyNullToEmptyString,
|
||||
True,
|
||||
"baz argument of method is [LegacyNullToEmptyString]",
|
||||
)
|
||||
method2 = B.members[5].signatures()[0][1]
|
||||
harness.check(method[0].type.hasEnforceRange(), True, "foo argument of method2 is [EnforceRange]")
|
||||
harness.check(method[1].type.hasClamp(), True, "bar argument of method2 is [Clamp]")
|
||||
harness.check(method[2].type.treatNullAsEmpty, True, "baz argument of method2 is [TreatNullAs=EmptyString]")
|
||||
harness.check(
|
||||
method2[0].type.hasEnforceRange(),
|
||||
True,
|
||||
"foo argument of method2 is [EnforceRange]",
|
||||
)
|
||||
harness.check(
|
||||
method2[1].type.hasClamp(), True, "bar argument of method2 is [Clamp]"
|
||||
)
|
||||
harness.check(
|
||||
method2[2].type.legacyNullToEmptyString,
|
||||
True,
|
||||
"baz argument of method2 is [LegacyNullToEmptyString]",
|
||||
)
|
||||
|
||||
method3 = B.members[6].signatures()[0][1]
|
||||
harness.check(
|
||||
method3[0].type.legacyNullToEmptyString,
|
||||
True,
|
||||
"bar argument of method2 is [LegacyNullToEmptyString]",
|
||||
)
|
||||
harness.check(
|
||||
method3[0].defaultValue.type.isUTF8String(),
|
||||
True,
|
||||
"default value of bar argument of method2 is correctly coerced to UTF8String",
|
||||
)
|
||||
|
||||
C = results[5]
|
||||
harness.ok(C.members[0].type.nullable(), "C.foo is nullable")
|
||||
harness.ok(C.members[0].type.hasEnforceRange(), "C.foo has [EnforceRange]")
|
||||
|
@ -75,12 +132,18 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(C.members[1].type.hasClamp(), "C.bar has [Clamp]")
|
||||
method = C.members[2].signatures()[0][1]
|
||||
harness.ok(method[0].type.nullable(), "foo argument of method is nullable")
|
||||
harness.ok(method[0].type.hasEnforceRange(), "foo argument of method has [EnforceRange]")
|
||||
harness.ok(
|
||||
method[0].type.hasEnforceRange(),
|
||||
"foo argument of method has [EnforceRange]",
|
||||
)
|
||||
harness.ok(method[1].type.nullable(), "bar argument of method is nullable")
|
||||
harness.ok(method[1].type.hasClamp(), "bar argument of method has [Clamp]")
|
||||
method2 = C.members[3].signatures()[0][1]
|
||||
harness.ok(method2[0].type.nullable(), "foo argument of method2 is nullable")
|
||||
harness.ok(method2[0].type.hasEnforceRange(), "foo argument of method2 has [EnforceRange]")
|
||||
harness.ok(
|
||||
method2[0].type.hasEnforceRange(),
|
||||
"foo argument of method2 has [EnforceRange]",
|
||||
)
|
||||
harness.ok(method2[1].type.nullable(), "bar argument of method2 is nullable")
|
||||
harness.ok(method2[1].type.hasClamp(), "bar argument of method2 has [Clamp]")
|
||||
|
||||
|
@ -88,7 +151,8 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [AllowShared] ArrayBufferView Foo;
|
||||
dictionary A {
|
||||
required [AllowShared] ArrayBufferView a;
|
||||
|
@ -115,7 +179,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Iterable {
|
||||
iterable<[Clamp] long, [AllowShared] ArrayBufferView>;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -131,63 +196,101 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(B.members[0].type.hasAllowShared(), "B.typedefFoo is [AllowShared]")
|
||||
harness.ok(B.members[1].type.hasAllowShared(), "B.foo is [AllowShared]")
|
||||
method = B.members[2].signatures()[0][1]
|
||||
harness.ok(method[0].type.hasAllowShared(), "foo argument of method is [AllowShared]")
|
||||
harness.ok(
|
||||
method[0].type.hasAllowShared(), "foo argument of method is [AllowShared]"
|
||||
)
|
||||
method2 = B.members[3].signatures()[0][1]
|
||||
harness.ok(method2[0].type.hasAllowShared(), "foo argument of method2 is [AllowShared]")
|
||||
harness.ok(
|
||||
method2[0].type.hasAllowShared(), "foo argument of method2 is [AllowShared]"
|
||||
)
|
||||
C = results[3]
|
||||
harness.ok(C.members[0].type.nullable(), "C.foo is nullable")
|
||||
harness.ok(C.members[0].type.hasAllowShared(), "C.foo is [AllowShared]")
|
||||
method = C.members[1].signatures()[0][1]
|
||||
harness.ok(method[0].type.nullable(), "foo argument of method is nullable")
|
||||
harness.ok(method[0].type.hasAllowShared(), "foo argument of method is [AllowShared]")
|
||||
harness.ok(
|
||||
method[0].type.hasAllowShared(), "foo argument of method is [AllowShared]"
|
||||
)
|
||||
method2 = C.members[2].signatures()[0][1]
|
||||
harness.ok(method2[0].type.nullable(), "foo argument of method2 is nullable")
|
||||
harness.ok(method2[0].type.hasAllowShared(), "foo argument of method2 is [AllowShared]")
|
||||
harness.ok(
|
||||
method2[0].type.hasAllowShared(), "foo argument of method2 is [AllowShared]"
|
||||
)
|
||||
|
||||
ATTRIBUTES = [("[Clamp]", "long"), ("[EnforceRange]", "long"),
|
||||
("[TreatNullAs=EmptyString]", "DOMString"), ("[AllowShared]", "ArrayBufferView")]
|
||||
ATTRIBUTES = [
|
||||
("[Clamp]", "long"),
|
||||
("[EnforceRange]", "long"),
|
||||
("[LegacyNullToEmptyString]", "DOMString"),
|
||||
("[AllowShared]", "ArrayBufferView"),
|
||||
]
|
||||
TEMPLATES = [
|
||||
("required dictionary members", """
|
||||
(
|
||||
"required dictionary members",
|
||||
"""
|
||||
dictionary Foo {
|
||||
%s required %s foo;
|
||||
};
|
||||
"""),
|
||||
("optional arguments", """
|
||||
""",
|
||||
),
|
||||
(
|
||||
"optional arguments",
|
||||
"""
|
||||
interface Foo {
|
||||
undefined foo(%s optional %s foo);
|
||||
};
|
||||
"""),
|
||||
("typedefs", """
|
||||
""",
|
||||
),
|
||||
(
|
||||
"typedefs",
|
||||
"""
|
||||
%s typedef %s foo;
|
||||
"""),
|
||||
("attributes", """
|
||||
""",
|
||||
),
|
||||
(
|
||||
"attributes",
|
||||
"""
|
||||
interface Foo {
|
||||
%s attribute %s foo;
|
||||
};
|
||||
"""),
|
||||
("readonly attributes", """
|
||||
""",
|
||||
),
|
||||
(
|
||||
"readonly attributes",
|
||||
"""
|
||||
interface Foo {
|
||||
readonly attribute %s %s foo;
|
||||
};
|
||||
"""),
|
||||
("readonly unresolved attributes", """
|
||||
""",
|
||||
),
|
||||
(
|
||||
"readonly unresolved attributes",
|
||||
"""
|
||||
interface Foo {
|
||||
readonly attribute Bar baz;
|
||||
};
|
||||
typedef %s %s Bar;
|
||||
"""),
|
||||
("method", """
|
||||
""",
|
||||
),
|
||||
(
|
||||
"method",
|
||||
"""
|
||||
interface Foo {
|
||||
%s %s foo();
|
||||
};
|
||||
"""),
|
||||
("interface","""
|
||||
""",
|
||||
),
|
||||
(
|
||||
"interface",
|
||||
"""
|
||||
%s
|
||||
interface Foo {
|
||||
attribute %s foo;
|
||||
};
|
||||
"""),
|
||||
("partial interface","""
|
||||
""",
|
||||
),
|
||||
(
|
||||
"partial interface",
|
||||
"""
|
||||
interface Foo {
|
||||
undefined foo();
|
||||
};
|
||||
|
@ -195,20 +298,29 @@ def WebIDLTest(parser, harness):
|
|||
partial interface Foo {
|
||||
attribute %s bar;
|
||||
};
|
||||
"""),
|
||||
("interface mixin","""
|
||||
""",
|
||||
),
|
||||
(
|
||||
"interface mixin",
|
||||
"""
|
||||
%s
|
||||
interface mixin Foo {
|
||||
attribute %s foo;
|
||||
};
|
||||
"""),
|
||||
("namespace","""
|
||||
""",
|
||||
),
|
||||
(
|
||||
"namespace",
|
||||
"""
|
||||
%s
|
||||
namespace Foo {
|
||||
attribute %s foo;
|
||||
};
|
||||
"""),
|
||||
("partial namespace","""
|
||||
""",
|
||||
),
|
||||
(
|
||||
"partial namespace",
|
||||
"""
|
||||
namespace Foo {
|
||||
undefined foo();
|
||||
};
|
||||
|
@ -216,14 +328,18 @@ def WebIDLTest(parser, harness):
|
|||
partial namespace Foo {
|
||||
attribute %s bar;
|
||||
};
|
||||
"""),
|
||||
("dictionary","""
|
||||
""",
|
||||
),
|
||||
(
|
||||
"dictionary",
|
||||
"""
|
||||
%s
|
||||
dictionary Foo {
|
||||
%s foo;
|
||||
};
|
||||
""")
|
||||
];
|
||||
""",
|
||||
),
|
||||
]
|
||||
|
||||
for (name, template) in TEMPLATES:
|
||||
parser = parser.reset()
|
||||
|
@ -242,15 +358,16 @@ def WebIDLTest(parser, harness):
|
|||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow %s on %s" % (attribute, name))
|
||||
harness.ok(threw, "Should not allow %s on %s" % (attribute, name))
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [Clamp, EnforceRange] long Foo;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -260,23 +377,26 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [EnforceRange, Clamp] long Foo;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow mixing [Clamp] and [EnforceRange]")
|
||||
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [Clamp] long Foo;
|
||||
typedef [EnforceRange] Foo bar;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -286,25 +406,36 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [EnforceRange] long Foo;
|
||||
typedef [Clamp] Foo bar;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow mixing [Clamp] and [EnforceRange] via typedefs")
|
||||
|
||||
TYPES = ["DOMString", "unrestricted float", "float", "unrestricted double", "double"]
|
||||
TYPES = [
|
||||
"DOMString",
|
||||
"unrestricted float",
|
||||
"float",
|
||||
"unrestricted double",
|
||||
"double",
|
||||
]
|
||||
|
||||
for type in TYPES:
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [Clamp] %s Foo;
|
||||
""" % type)
|
||||
"""
|
||||
% type
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -314,58 +445,70 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [EnforceRange] %s Foo;
|
||||
""" % type)
|
||||
"""
|
||||
% type
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow [EnforceRange] on %s" % type)
|
||||
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
typedef [TreatNullAs=EmptyString] long Foo;
|
||||
""")
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [LegacyNullToEmptyString] long Foo;
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow [TreatNullAs] on long")
|
||||
harness.ok(threw, "Should not allow [LegacyNullToEmptyString] on long")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
typedef [TreatNullAs=EmptyString] JSString Foo;
|
||||
""")
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [LegacyNullToEmptyString] JSString Foo;
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow [TreatNullAs] on JSString")
|
||||
harness.ok(threw, "Should not allow [LegacyNullToEmptyString] on JSString")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
typedef [TreatNullAs=EmptyString] DOMString? Foo;
|
||||
""")
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [LegacyNullToEmptyString] DOMString? Foo;
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow [TreatNullAs] on nullable DOMString")
|
||||
harness.ok(
|
||||
threw, "Should not allow [LegacyNullToEmptyString] on nullable DOMString"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [AllowShared] DOMString Foo;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -374,9 +517,11 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef [AllowShared=something] ArrayBufferView Foo;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -385,31 +530,41 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
undefined foo([Clamp] Bar arg);
|
||||
};
|
||||
typedef long Bar;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(not threw, "Should allow type attributes on unresolved types")
|
||||
harness.check(results[0].members[0].signatures()[0][1][0].type.hasClamp(), True,
|
||||
"Unresolved types with type attributes should correctly resolve with attributes")
|
||||
harness.check(
|
||||
results[0].members[0].signatures()[0][1][0].type.hasClamp(),
|
||||
True,
|
||||
"Unresolved types with type attributes should correctly resolve with attributes",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
undefined foo(Bar arg);
|
||||
};
|
||||
typedef [Clamp] long Bar;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(not threw, "Should allow type attributes on typedefs")
|
||||
harness.check(results[0].members[0].signatures()[0][1][0].type.hasClamp(), True,
|
||||
"Unresolved types that resolve to typedefs with attributes should correctly resolve with attributes")
|
||||
harness.check(
|
||||
results[0].members[0].signatures()[0][1][0].type.hasClamp(),
|
||||
True,
|
||||
"Unresolved types that resolve to typedefs with attributes should correctly resolve with attributes",
|
||||
)
|
||||
|
|
|
@ -1,11 +1,14 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Test {
|
||||
attribute long b;
|
||||
};
|
||||
""");
|
||||
"""
|
||||
)
|
||||
|
||||
attr = parser.finish()[0].members[0]
|
||||
harness.check(attr.type.filename(), '<builtin>', 'Filename on builtin type')
|
||||
harness.check(attr.type.filename(), "<builtin>", "Filename on builtin type")
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestBuiltins {
|
||||
attribute boolean b;
|
||||
attribute byte s8;
|
||||
|
@ -12,30 +14,46 @@ def WebIDLTest(parser, harness):
|
|||
attribute unsigned long u32;
|
||||
attribute long long s64;
|
||||
attribute unsigned long long u64;
|
||||
attribute DOMTimeStamp ts;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestBuiltins interface parsed without error.")
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
iface = results[0]
|
||||
harness.check(iface.identifier.QName(), "::TestBuiltins", "Interface has the right QName")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestBuiltins", "Interface has the right QName"
|
||||
)
|
||||
harness.check(iface.identifier.name, "TestBuiltins", "Interface has the right name")
|
||||
harness.check(iface.parent, None, "Interface has no parent")
|
||||
|
||||
members = iface.members
|
||||
harness.check(len(members), 10, "Should be one production")
|
||||
harness.check(len(members), 9, "Should be one production")
|
||||
|
||||
names = ["b", "s8", "u8", "s16", "u16", "s32", "u32", "s64", "u64", "ts"]
|
||||
types = ["Boolean", "Byte", "Octet", "Short", "UnsignedShort", "Long", "UnsignedLong", "LongLong", "UnsignedLongLong", "UnsignedLongLong"]
|
||||
for i in range(10):
|
||||
types = [
|
||||
"Boolean",
|
||||
"Byte",
|
||||
"Octet",
|
||||
"Short",
|
||||
"UnsignedShort",
|
||||
"Long",
|
||||
"UnsignedLong",
|
||||
"LongLong",
|
||||
"UnsignedLongLong",
|
||||
"UnsignedLongLong",
|
||||
]
|
||||
for i in range(9):
|
||||
attr = members[i]
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
harness.check(attr.identifier.QName(), "::TestBuiltins::" + names[i], "Attr has correct QName")
|
||||
harness.check(
|
||||
attr.identifier.QName(),
|
||||
"::TestBuiltins::" + names[i],
|
||||
"Attr has correct QName",
|
||||
)
|
||||
harness.check(attr.identifier.name, names[i], "Attr has correct name")
|
||||
harness.check(str(attr.type), types[i], "Attr type is the correct name")
|
||||
harness.ok(attr.type.isPrimitive(), "Should be a primitive type")
|
||||
|
|
|
@ -2,24 +2,30 @@
|
|||
|
||||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestByteString {
|
||||
attribute ByteString bs;
|
||||
attribute DOMString ds;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish();
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestByteString interface parsed without error.")
|
||||
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
iface = results[0]
|
||||
harness.check(iface.identifier.QName(), "::TestByteString", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "TestByteString", "Interface has the right name")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestByteString", "Interface has the right QName"
|
||||
)
|
||||
harness.check(
|
||||
iface.identifier.name, "TestByteString", "Interface has the right name"
|
||||
)
|
||||
harness.check(iface.parent, None, "Interface has no parent")
|
||||
|
||||
members = iface.members
|
||||
|
@ -27,7 +33,9 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
attr = members[0]
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
harness.check(attr.identifier.QName(), "::TestByteString::bs", "Attr has correct QName")
|
||||
harness.check(
|
||||
attr.identifier.QName(), "::TestByteString::bs", "Attr has correct QName"
|
||||
)
|
||||
harness.check(attr.identifier.name, "bs", "Attr has correct name")
|
||||
harness.check(str(attr.type), "ByteString", "Attr type is the correct name")
|
||||
harness.ok(attr.type.isByteString(), "Should be ByteString type")
|
||||
|
@ -37,7 +45,9 @@ def WebIDLTest(parser, harness):
|
|||
# now check we haven't broken DOMStrings in the process.
|
||||
attr = members[1]
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
harness.check(attr.identifier.QName(), "::TestByteString::ds", "Attr has correct QName")
|
||||
harness.check(
|
||||
attr.identifier.QName(), "::TestByteString::ds", "Attr has correct QName"
|
||||
)
|
||||
harness.check(attr.identifier.name, "ds", "Attr has correct name")
|
||||
harness.check(str(attr.type), "String", "Attr type is the correct name")
|
||||
harness.ok(attr.type.isDOMString(), "Should be DOMString type")
|
||||
|
@ -47,53 +57,69 @@ def WebIDLTest(parser, harness):
|
|||
# Cannot represent constant ByteString in IDL.
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface ConstByteString {
|
||||
const ByteString foo = "hello"
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
except WebIDL.WebIDLError:
|
||||
threw = True
|
||||
harness.ok(threw, "Should have thrown a WebIDL error for ByteString default in interface")
|
||||
harness.ok(
|
||||
threw, "Should have thrown a WebIDL error for ByteString default in interface"
|
||||
)
|
||||
|
||||
# Can have optional ByteStrings with default values
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface OptionalByteString {
|
||||
undefined passByteString(optional ByteString arg = "hello");
|
||||
};
|
||||
""")
|
||||
results2 = parser.finish();
|
||||
};
|
||||
"""
|
||||
)
|
||||
results2 = parser.finish()
|
||||
except WebIDL.WebIDLError as e:
|
||||
harness.ok(False,
|
||||
"Should not have thrown a WebIDL error for ByteString "
|
||||
"default in dictionary. " + str(e))
|
||||
harness.ok(
|
||||
False,
|
||||
"Should not have thrown a WebIDL error for ByteString "
|
||||
"default in dictionary. " + str(e),
|
||||
)
|
||||
|
||||
# Can have a default ByteString value in a dictionary
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary OptionalByteStringDict {
|
||||
ByteString item = "some string";
|
||||
};
|
||||
""")
|
||||
results3 = parser.finish();
|
||||
"""
|
||||
)
|
||||
results3 = parser.finish()
|
||||
except WebIDL.WebIDLError as e:
|
||||
harness.ok(False,
|
||||
"Should not have thrown a WebIDL error for ByteString "
|
||||
"default in dictionary. " + str(e))
|
||||
harness.ok(
|
||||
False,
|
||||
"Should not have thrown a WebIDL error for ByteString "
|
||||
"default in dictionary. " + str(e),
|
||||
)
|
||||
|
||||
# Don't allow control characters in ByteString literals
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary OptionalByteStringDict2 {
|
||||
ByteString item = "\x03";
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results4 = parser.finish()
|
||||
except WebIDL.WebIDLError as e:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown a WebIDL error for invalid ByteString "
|
||||
"default in dictionary")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown a WebIDL error for invalid ByteString "
|
||||
"default in dictionary",
|
||||
)
|
||||
|
|
|
@ -1,32 +1,37 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestCallback {
|
||||
attribute CallbackType? listener;
|
||||
};
|
||||
|
||||
callback CallbackType = boolean (unsigned long arg);
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestCallback interface parsed without error.")
|
||||
harness.check(len(results), 2, "Should be two productions.")
|
||||
iface = results[0]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestCallback", "Interface has the right QName")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestCallback", "Interface has the right QName"
|
||||
)
|
||||
harness.check(iface.identifier.name, "TestCallback", "Interface has the right name")
|
||||
harness.check(len(iface.members), 1, "Expect %s members" % 1)
|
||||
|
||||
attr = iface.members[0]
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute),
|
||||
"Should be an IDLAttribute")
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
harness.ok(attr.isAttr(), "Should be an attribute")
|
||||
harness.ok(not attr.isMethod(), "Attr is not an method")
|
||||
harness.ok(not attr.isConst(), "Attr is not a const")
|
||||
harness.check(attr.identifier.QName(), "::TestCallback::listener", "Attr has the right QName")
|
||||
harness.check(
|
||||
attr.identifier.QName(), "::TestCallback::listener", "Attr has the right QName"
|
||||
)
|
||||
harness.check(attr.identifier.name, "listener", "Attr has the right name")
|
||||
t = attr.type
|
||||
harness.ok(not isinstance(t, WebIDL.IDLWrapperType), "Attr has the right type")
|
||||
|
|
|
@ -1,33 +1,46 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestCallbackConstructor {
|
||||
attribute CallbackConstructorType? constructorAttribute;
|
||||
};
|
||||
|
||||
callback constructor CallbackConstructorType = TestCallbackConstructor (unsigned long arg);
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestCallbackConstructor interface parsed without error.")
|
||||
harness.check(len(results), 2, "Should be two productions.")
|
||||
iface = results[0]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestCallbackConstructor", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "TestCallbackConstructor", "Interface has the right name")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(),
|
||||
"::TestCallbackConstructor",
|
||||
"Interface has the right QName",
|
||||
)
|
||||
harness.check(
|
||||
iface.identifier.name, "TestCallbackConstructor", "Interface has the right name"
|
||||
)
|
||||
harness.check(len(iface.members), 1, "Expect %s members" % 1)
|
||||
|
||||
attr = iface.members[0]
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute),
|
||||
"Should be an IDLAttribute")
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
harness.ok(attr.isAttr(), "Should be an attribute")
|
||||
harness.ok(not attr.isMethod(), "Attr is not an method")
|
||||
harness.ok(not attr.isConst(), "Attr is not a const")
|
||||
harness.check(attr.identifier.QName(), "::TestCallbackConstructor::constructorAttribute", "Attr has the right QName")
|
||||
harness.check(attr.identifier.name, "constructorAttribute", "Attr has the right name")
|
||||
harness.check(
|
||||
attr.identifier.QName(),
|
||||
"::TestCallbackConstructor::constructorAttribute",
|
||||
"Attr has the right QName",
|
||||
)
|
||||
harness.check(
|
||||
attr.identifier.name, "constructorAttribute", "Attr has the right name"
|
||||
)
|
||||
t = attr.type
|
||||
harness.ok(not isinstance(t, WebIDL.IDLWrapperType), "Attr has the right type")
|
||||
harness.ok(isinstance(t, WebIDL.IDLNullableType), "Attr has the right type")
|
||||
|
@ -39,25 +52,33 @@ def WebIDLTest(parser, harness):
|
|||
parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[TreatNonObjectAsNull]
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyTreatNonObjectAsNull]
|
||||
callback constructor CallbackConstructorType = object ();
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should throw on TreatNonObjectAsNull callback constructors")
|
||||
harness.ok(
|
||||
threw, "Should throw on LegacyTreatNonObjectAsNull callback constructors"
|
||||
)
|
||||
|
||||
parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[MOZ_CAN_RUN_SCRIPT_BOUNDARY]
|
||||
callback constructor CallbackConstructorType = object ();
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not permit MOZ_CAN_RUN_SCRIPT_BOUNDARY callback constructors")
|
||||
harness.ok(
|
||||
threw, "Should not permit MOZ_CAN_RUN_SCRIPT_BOUNDARY callback constructors"
|
||||
)
|
||||
|
|
|
@ -1,11 +1,14 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
callback interface TestCallbackInterface {
|
||||
attribute boolean bool;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
|
@ -16,13 +19,15 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestInterface {
|
||||
};
|
||||
callback interface TestCallbackInterface : TestInterface {
|
||||
attribute boolean bool;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -32,13 +37,15 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestInterface : TestCallbackInterface {
|
||||
};
|
||||
callback interface TestCallbackInterface {
|
||||
attribute boolean bool;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -46,7 +53,8 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(threw, "Should not allow callback parent of non-callback interface")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
callback interface TestCallbackInterface1 {
|
||||
undefined foo();
|
||||
};
|
||||
|
@ -86,9 +94,13 @@ def WebIDLTest(parser, harness):
|
|||
callback interface TestCallbackInterface10 : TestCallbackInterface1 {
|
||||
undefined bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
for (i, iface) in enumerate(results):
|
||||
harness.check(iface.isSingleOperationInterface(), i < 4,
|
||||
"Interface %s should be a single operation interface" %
|
||||
iface.identifier.name)
|
||||
harness.check(
|
||||
iface.isSingleOperationInterface(),
|
||||
i < 4,
|
||||
"Interface %s should be a single operation interface"
|
||||
% iface.identifier.name,
|
||||
)
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions(DOMString a)] undefined foo(boolean arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -16,11 +18,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions(DOMString b)] readonly attribute boolean bar;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -31,54 +35,72 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions] attribute boolean bar;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as e:
|
||||
harness.ok(False, "Shouldn't have thrown for [CEReactions] used on writable attribute. %s" % e)
|
||||
harness.ok(
|
||||
False,
|
||||
"Shouldn't have thrown for [CEReactions] used on writable attribute. %s"
|
||||
% e,
|
||||
)
|
||||
threw = True
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions] undefined foo(boolean arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as e:
|
||||
harness.ok(False, "Shouldn't have thrown for [CEReactions] used on regular operations. %s" % e)
|
||||
harness.ok(
|
||||
False,
|
||||
"Shouldn't have thrown for [CEReactions] used on regular operations. %s"
|
||||
% e,
|
||||
)
|
||||
threw = True
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions] readonly attribute boolean A;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown for [CEReactions] used on a readonly attribute")
|
||||
harness.ok(
|
||||
threw, "Should have thrown for [CEReactions] used on a readonly attribute"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[CEReactions]
|
||||
interface Foo {
|
||||
}
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -89,45 +111,47 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions] getter any(DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [CEReactions] used on a named getter")
|
||||
harness.ok(threw, "Should have thrown for [CEReactions] used on a named getter")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions] legacycaller double compute(double x);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [CEReactions] used on a legacycaller")
|
||||
harness.ok(threw, "Should have thrown for [CEReactions] used on a legacycaller")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
[CEReactions] stringifier DOMString ();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [CEReactions] used on a stringifier")
|
||||
|
||||
harness.ok(threw, "Should have thrown for [CEReactions] used on a stringifier")
|
||||
|
|
|
@ -1,23 +1,28 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {
|
||||
any foo;
|
||||
[ChromeOnly] any bar;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should have a dictionary")
|
||||
members = results[0].members;
|
||||
members = results[0].members
|
||||
harness.check(len(members), 2, "Should have two members")
|
||||
# Note that members are ordered lexicographically, so "bar" comes
|
||||
# before "foo".
|
||||
harness.ok(members[0].getExtendedAttribute("ChromeOnly"),
|
||||
"First member is not ChromeOnly")
|
||||
harness.ok(not members[1].getExtendedAttribute("ChromeOnly"),
|
||||
"Second member is ChromeOnly")
|
||||
harness.ok(
|
||||
members[0].getExtendedAttribute("ChromeOnly"), "First member is not ChromeOnly"
|
||||
)
|
||||
harness.ok(
|
||||
not members[1].getExtendedAttribute("ChromeOnly"), "Second member is ChromeOnly"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {
|
||||
any foo;
|
||||
any bar;
|
||||
|
@ -26,14 +31,16 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[Constant, Cached] readonly attribute Dict dict;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2, "Should have a dictionary and an interface")
|
||||
|
||||
parser = parser.reset()
|
||||
exception = None
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {
|
||||
any foo;
|
||||
[ChromeOnly] any bar;
|
||||
|
@ -42,21 +49,25 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[Constant, Cached] readonly attribute Dict dict;
|
||||
};
|
||||
""")
|
||||
results = parser.finish()
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as e:
|
||||
exception = e
|
||||
exception = e
|
||||
|
||||
harness.ok(exception, "Should have thrown.")
|
||||
harness.check(exception.message,
|
||||
"[Cached] and [StoreInSlot] must not be used on an attribute "
|
||||
"whose type contains a [ChromeOnly] dictionary member",
|
||||
"Should have thrown the right exception")
|
||||
harness.check(
|
||||
exception.message,
|
||||
"[Cached] and [StoreInSlot] must not be used on an attribute "
|
||||
"whose type contains a [ChromeOnly] dictionary member",
|
||||
"Should have thrown the right exception",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
exception = None
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary ParentDict {
|
||||
[ChromeOnly] any bar;
|
||||
};
|
||||
|
@ -68,21 +79,25 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[Constant, Cached] readonly attribute Dict dict;
|
||||
};
|
||||
""")
|
||||
results = parser.finish()
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as e:
|
||||
exception = e
|
||||
exception = e
|
||||
|
||||
harness.ok(exception, "Should have thrown (2).")
|
||||
harness.check(exception.message,
|
||||
"[Cached] and [StoreInSlot] must not be used on an attribute "
|
||||
"whose type contains a [ChromeOnly] dictionary member",
|
||||
"Should have thrown the right exception (2)")
|
||||
harness.check(
|
||||
exception.message,
|
||||
"[Cached] and [StoreInSlot] must not be used on an attribute "
|
||||
"whose type contains a [ChromeOnly] dictionary member",
|
||||
"Should have thrown the right exception (2)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
exception = None
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary GrandParentDict {
|
||||
[ChromeOnly] any baz;
|
||||
};
|
||||
|
@ -98,13 +113,16 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[Constant, Cached] readonly attribute Dict dict;
|
||||
};
|
||||
""")
|
||||
results = parser.finish()
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as e:
|
||||
exception = e
|
||||
exception = e
|
||||
|
||||
harness.ok(exception, "Should have thrown (3).")
|
||||
harness.check(exception.message,
|
||||
"[Cached] and [StoreInSlot] must not be used on an attribute "
|
||||
"whose type contains a [ChromeOnly] dictionary member",
|
||||
"Should have thrown the right exception (3)")
|
||||
harness.check(
|
||||
exception.message,
|
||||
"[Cached] and [StoreInSlot] must not be used on an attribute "
|
||||
"whose type contains a [ChromeOnly] dictionary member",
|
||||
"Should have thrown the right exception (3)",
|
||||
)
|
||||
|
|
|
@ -22,8 +22,10 @@ expected = [
|
|||
("::TestConsts::udbi", "udbi", "UnrestrictedDouble", 2),
|
||||
]
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestConsts {
|
||||
const byte zero = 0;
|
||||
const byte b = -1;
|
||||
|
@ -45,22 +47,25 @@ def WebIDLTest(parser, harness):
|
|||
const unrestricted float ufli = 2;
|
||||
const unrestricted double udbi = 2;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestConsts interface parsed without error.")
|
||||
harness.check(len(results), 1, "Should be one production.")
|
||||
iface = results[0]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestConsts", "Interface has the right QName")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestConsts", "Interface has the right QName"
|
||||
)
|
||||
harness.check(iface.identifier.name, "TestConsts", "Interface has the right name")
|
||||
harness.check(len(iface.members), len(expected), "Expect %s members" % len(expected))
|
||||
harness.check(
|
||||
len(iface.members), len(expected), "Expect %s members" % len(expected)
|
||||
)
|
||||
|
||||
for (const, (QName, name, type, value)) in zip(iface.members, expected):
|
||||
harness.ok(isinstance(const, WebIDL.IDLConst),
|
||||
"Should be an IDLConst")
|
||||
harness.ok(isinstance(const, WebIDL.IDLConst), "Should be an IDLConst")
|
||||
harness.ok(const.isConst(), "Const is a const")
|
||||
harness.ok(not const.isAttr(), "Const is not an attr")
|
||||
harness.ok(not const.isMethod(), "Const is not a method")
|
||||
|
@ -68,19 +73,23 @@ def WebIDLTest(parser, harness):
|
|||
harness.check(const.identifier.name, name, "Const has the right name")
|
||||
harness.check(str(const.type), type, "Const has the right type")
|
||||
harness.ok(const.type.isPrimitive(), "All consts should be primitive")
|
||||
harness.check(str(const.value.type), str(const.type),
|
||||
"Const's value has the same type as the type")
|
||||
harness.check(
|
||||
str(const.value.type),
|
||||
str(const.type),
|
||||
"Const's value has the same type as the type",
|
||||
)
|
||||
harness.check(const.value.value, value, "Const value has the right value.")
|
||||
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestConsts {
|
||||
const boolean? zero = 0;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
|
|
@ -1,21 +1,39 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
def checkArgument(argument, QName, name, type, optional, variadic):
|
||||
harness.ok(isinstance(argument, WebIDL.IDLArgument),
|
||||
"Should be an IDLArgument")
|
||||
harness.check(argument.identifier.QName(), QName, "Argument has the right QName")
|
||||
harness.ok(isinstance(argument, WebIDL.IDLArgument), "Should be an IDLArgument")
|
||||
harness.check(
|
||||
argument.identifier.QName(), QName, "Argument has the right QName"
|
||||
)
|
||||
harness.check(argument.identifier.name, name, "Argument has the right name")
|
||||
harness.check(str(argument.type), type, "Argument has the right return type")
|
||||
harness.check(argument.optional, optional, "Argument has the right optional value")
|
||||
harness.check(argument.variadic, variadic, "Argument has the right variadic value")
|
||||
harness.check(
|
||||
argument.optional, optional, "Argument has the right optional value"
|
||||
)
|
||||
harness.check(
|
||||
argument.variadic, variadic, "Argument has the right variadic value"
|
||||
)
|
||||
|
||||
def checkMethod(method, QName, name, signatures,
|
||||
static=True, getter=False, setter=False, deleter=False,
|
||||
legacycaller=False, stringifier=False, chromeOnly=False,
|
||||
htmlConstructor=False, secureContext=False, pref=None, func=None):
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod),
|
||||
"Should be an IDLMethod")
|
||||
def checkMethod(
|
||||
method,
|
||||
QName,
|
||||
name,
|
||||
signatures,
|
||||
static=True,
|
||||
getter=False,
|
||||
setter=False,
|
||||
deleter=False,
|
||||
legacycaller=False,
|
||||
stringifier=False,
|
||||
chromeOnly=False,
|
||||
htmlConstructor=False,
|
||||
secureContext=False,
|
||||
pref=None,
|
||||
func=None,
|
||||
):
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod), "Should be an IDLMethod")
|
||||
harness.ok(method.isMethod(), "Method is a method")
|
||||
harness.ok(not method.isAttr(), "Method is not an attr")
|
||||
harness.ok(not method.isConst(), "Method is not a const")
|
||||
|
@ -24,23 +42,58 @@ def WebIDLTest(parser, harness):
|
|||
harness.check(method.isStatic(), static, "Method has the correct static value")
|
||||
harness.check(method.isGetter(), getter, "Method has the correct getter value")
|
||||
harness.check(method.isSetter(), setter, "Method has the correct setter value")
|
||||
harness.check(method.isDeleter(), deleter, "Method has the correct deleter value")
|
||||
harness.check(method.isLegacycaller(), legacycaller, "Method has the correct legacycaller value")
|
||||
harness.check(method.isStringifier(), stringifier, "Method has the correct stringifier value")
|
||||
harness.check(method.getExtendedAttribute("ChromeOnly") is not None, chromeOnly, "Method has the correct value for ChromeOnly")
|
||||
harness.check(method.isHTMLConstructor(), htmlConstructor, "Method has the correct htmlConstructor value")
|
||||
harness.check(len(method.signatures()), len(signatures), "Method has the correct number of signatures")
|
||||
harness.check(method.getExtendedAttribute("Pref"), pref, "Method has the correct pref value")
|
||||
harness.check(method.getExtendedAttribute("Func"), func, "Method has the correct func value")
|
||||
harness.check(method.getExtendedAttribute("SecureContext") is not None, secureContext, "Method has the correct SecureContext value")
|
||||
harness.check(
|
||||
method.isDeleter(), deleter, "Method has the correct deleter value"
|
||||
)
|
||||
harness.check(
|
||||
method.isLegacycaller(),
|
||||
legacycaller,
|
||||
"Method has the correct legacycaller value",
|
||||
)
|
||||
harness.check(
|
||||
method.isStringifier(),
|
||||
stringifier,
|
||||
"Method has the correct stringifier value",
|
||||
)
|
||||
harness.check(
|
||||
method.getExtendedAttribute("ChromeOnly") is not None,
|
||||
chromeOnly,
|
||||
"Method has the correct value for ChromeOnly",
|
||||
)
|
||||
harness.check(
|
||||
method.isHTMLConstructor(),
|
||||
htmlConstructor,
|
||||
"Method has the correct htmlConstructor value",
|
||||
)
|
||||
harness.check(
|
||||
len(method.signatures()),
|
||||
len(signatures),
|
||||
"Method has the correct number of signatures",
|
||||
)
|
||||
harness.check(
|
||||
method.getExtendedAttribute("Pref"),
|
||||
pref,
|
||||
"Method has the correct pref value",
|
||||
)
|
||||
harness.check(
|
||||
method.getExtendedAttribute("Func"),
|
||||
func,
|
||||
"Method has the correct func value",
|
||||
)
|
||||
harness.check(
|
||||
method.getExtendedAttribute("SecureContext") is not None,
|
||||
secureContext,
|
||||
"Method has the correct SecureContext value",
|
||||
)
|
||||
|
||||
sigpairs = zip(method.signatures(), signatures)
|
||||
for (gotSignature, expectedSignature) in sigpairs:
|
||||
(gotRetType, gotArgs) = gotSignature
|
||||
(expectedRetType, expectedArgs) = expectedSignature
|
||||
|
||||
harness.check(str(gotRetType), expectedRetType,
|
||||
"Method has the expected return type.")
|
||||
harness.check(
|
||||
str(gotRetType), expectedRetType, "Method has the expected return type."
|
||||
)
|
||||
|
||||
for i in range(0, len(gotArgs)):
|
||||
(QName, name, type, optional, variadic) = expectedArgs[i]
|
||||
|
@ -48,33 +101,88 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
def checkResults(results):
|
||||
harness.check(len(results), 3, "Should be three productions")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[2], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(
|
||||
isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface"
|
||||
)
|
||||
harness.ok(
|
||||
isinstance(results[1], WebIDL.IDLInterface), "Should be an IDLInterface"
|
||||
)
|
||||
harness.ok(
|
||||
isinstance(results[2], WebIDL.IDLInterface), "Should be an IDLInterface"
|
||||
)
|
||||
|
||||
checkMethod(results[0].ctor(), "::TestConstructorNoArgs::constructor",
|
||||
"constructor", [("TestConstructorNoArgs (Wrapper)", [])])
|
||||
harness.check(len(results[0].members), 0,
|
||||
"TestConstructorNoArgs should not have members")
|
||||
checkMethod(results[1].ctor(), "::TestConstructorWithArgs::constructor",
|
||||
"constructor",
|
||||
[("TestConstructorWithArgs (Wrapper)",
|
||||
[("::TestConstructorWithArgs::constructor::name", "name", "String", False, False)])])
|
||||
harness.check(len(results[1].members), 0,
|
||||
"TestConstructorWithArgs should not have members")
|
||||
checkMethod(results[2].ctor(), "::TestConstructorOverloads::constructor",
|
||||
"constructor",
|
||||
[("TestConstructorOverloads (Wrapper)",
|
||||
[("::TestConstructorOverloads::constructor::foo", "foo", "Object", False, False)]),
|
||||
("TestConstructorOverloads (Wrapper)",
|
||||
[("::TestConstructorOverloads::constructor::bar", "bar", "Boolean", False, False)])])
|
||||
harness.check(len(results[2].members), 0,
|
||||
"TestConstructorOverloads should not have members")
|
||||
checkMethod(
|
||||
results[0].ctor(),
|
||||
"::TestConstructorNoArgs::constructor",
|
||||
"constructor",
|
||||
[("TestConstructorNoArgs (Wrapper)", [])],
|
||||
)
|
||||
harness.check(
|
||||
len(results[0].members), 0, "TestConstructorNoArgs should not have members"
|
||||
)
|
||||
checkMethod(
|
||||
results[1].ctor(),
|
||||
"::TestConstructorWithArgs::constructor",
|
||||
"constructor",
|
||||
[
|
||||
(
|
||||
"TestConstructorWithArgs (Wrapper)",
|
||||
[
|
||||
(
|
||||
"::TestConstructorWithArgs::constructor::name",
|
||||
"name",
|
||||
"String",
|
||||
False,
|
||||
False,
|
||||
)
|
||||
],
|
||||
)
|
||||
],
|
||||
)
|
||||
harness.check(
|
||||
len(results[1].members),
|
||||
0,
|
||||
"TestConstructorWithArgs should not have members",
|
||||
)
|
||||
checkMethod(
|
||||
results[2].ctor(),
|
||||
"::TestConstructorOverloads::constructor",
|
||||
"constructor",
|
||||
[
|
||||
(
|
||||
"TestConstructorOverloads (Wrapper)",
|
||||
[
|
||||
(
|
||||
"::TestConstructorOverloads::constructor::foo",
|
||||
"foo",
|
||||
"Object",
|
||||
False,
|
||||
False,
|
||||
)
|
||||
],
|
||||
),
|
||||
(
|
||||
"TestConstructorOverloads (Wrapper)",
|
||||
[
|
||||
(
|
||||
"::TestConstructorOverloads::constructor::bar",
|
||||
"bar",
|
||||
"Boolean",
|
||||
False,
|
||||
False,
|
||||
)
|
||||
],
|
||||
),
|
||||
],
|
||||
)
|
||||
harness.check(
|
||||
len(results[2].members),
|
||||
0,
|
||||
"TestConstructorOverloads should not have members",
|
||||
)
|
||||
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestConstructorNoArgs {
|
||||
constructor();
|
||||
};
|
||||
|
@ -87,111 +195,146 @@ def WebIDLTest(parser, harness):
|
|||
constructor(object foo);
|
||||
constructor(boolean bar);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
checkResults(results)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestPrefConstructor {
|
||||
[Pref="dom.webidl.test1"] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
|
||||
checkMethod(results[0].ctor(), "::TestPrefConstructor::constructor",
|
||||
"constructor", [("TestPrefConstructor (Wrapper)", [])],
|
||||
pref=["dom.webidl.test1"])
|
||||
checkMethod(
|
||||
results[0].ctor(),
|
||||
"::TestPrefConstructor::constructor",
|
||||
"constructor",
|
||||
[("TestPrefConstructor (Wrapper)", [])],
|
||||
pref=["dom.webidl.test1"],
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestChromeOnlyConstructor {
|
||||
[ChromeOnly] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
|
||||
checkMethod(results[0].ctor(), "::TestChromeOnlyConstructor::constructor",
|
||||
"constructor", [("TestChromeOnlyConstructor (Wrapper)", [])],
|
||||
chromeOnly=True)
|
||||
checkMethod(
|
||||
results[0].ctor(),
|
||||
"::TestChromeOnlyConstructor::constructor",
|
||||
"constructor",
|
||||
[("TestChromeOnlyConstructor (Wrapper)", [])],
|
||||
chromeOnly=True,
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestSCConstructor {
|
||||
[SecureContext] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
|
||||
checkMethod(results[0].ctor(), "::TestSCConstructor::constructor",
|
||||
"constructor", [("TestSCConstructor (Wrapper)", [])],
|
||||
secureContext=True)
|
||||
checkMethod(
|
||||
results[0].ctor(),
|
||||
"::TestSCConstructor::constructor",
|
||||
"constructor",
|
||||
[("TestSCConstructor (Wrapper)", [])],
|
||||
secureContext=True,
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestFuncConstructor {
|
||||
[Func="Document::IsWebAnimationsEnabled"] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
|
||||
checkMethod(results[0].ctor(), "::TestFuncConstructor::constructor",
|
||||
"constructor", [("TestFuncConstructor (Wrapper)", [])],
|
||||
func=["Document::IsWebAnimationsEnabled"])
|
||||
checkMethod(
|
||||
results[0].ctor(),
|
||||
"::TestFuncConstructor::constructor",
|
||||
"constructor",
|
||||
[("TestFuncConstructor (Wrapper)", [])],
|
||||
func=["Document::IsWebAnimationsEnabled"],
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestPrefChromeOnlySCFuncConstructor {
|
||||
[ChromeOnly, Pref="dom.webidl.test1", SecureContext, Func="Document::IsWebAnimationsEnabled"]
|
||||
constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
|
||||
checkMethod(results[0].ctor(), "::TestPrefChromeOnlySCFuncConstructor::constructor",
|
||||
"constructor", [("TestPrefChromeOnlySCFuncConstructor (Wrapper)", [])],
|
||||
func=["Document::IsWebAnimationsEnabled"], pref=["dom.webidl.test1"],
|
||||
chromeOnly=True, secureContext=True)
|
||||
checkMethod(
|
||||
results[0].ctor(),
|
||||
"::TestPrefChromeOnlySCFuncConstructor::constructor",
|
||||
"constructor",
|
||||
[("TestPrefChromeOnlySCFuncConstructor (Wrapper)", [])],
|
||||
func=["Document::IsWebAnimationsEnabled"],
|
||||
pref=["dom.webidl.test1"],
|
||||
chromeOnly=True,
|
||||
secureContext=True,
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructor {
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
|
||||
checkMethod(results[0].ctor(), "::TestHTMLConstructor::constructor",
|
||||
"constructor", [("TestHTMLConstructor (Wrapper)", [])],
|
||||
htmlConstructor=True)
|
||||
checkMethod(
|
||||
results[0].ctor(),
|
||||
"::TestHTMLConstructor::constructor",
|
||||
"constructor",
|
||||
[("TestHTMLConstructor (Wrapper)", [])],
|
||||
htmlConstructor=True,
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestChromeOnlyConstructor {
|
||||
constructor()
|
||||
[ChromeOnly] constructor(DOMString a);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -202,11 +345,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorWithArgs {
|
||||
[HTMLConstructor] constructor(DOMString a);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -217,11 +362,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
callback interface TestHTMLConstructorOnCallbackInterface {
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -232,12 +379,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
constructor();
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -247,165 +396,187 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
[Throws]
|
||||
constructor();
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have both a throwing constructor and a HTMLConstructor")
|
||||
harness.ok(threw, "Can't have both a throwing constructor and a HTMLConstructor")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
constructor(DOMString a);
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have both a HTMLConstructor and a constructor operation")
|
||||
harness.ok(threw, "Can't have both a HTMLConstructor and a constructor operation")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
[Throws]
|
||||
constructor(DOMString a);
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have both a HTMLConstructor and a throwing constructor "
|
||||
"operation")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Can't have both a HTMLConstructor and a throwing constructor " "operation",
|
||||
)
|
||||
|
||||
# Test HTMLConstructor and [ChromeOnly] constructor operation
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
[ChromeOnly]
|
||||
constructor();
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have both a ChromeOnly constructor and a HTMLConstructor")
|
||||
harness.ok(threw, "Can't have both a ChromeOnly constructor and a HTMLConstructor")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
[Throws, ChromeOnly]
|
||||
constructor();
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have both a throwing chromeonly constructor and a "
|
||||
"HTMLConstructor")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Can't have both a throwing chromeonly constructor and a " "HTMLConstructor",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
[ChromeOnly]
|
||||
constructor(DOMString a);
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have both a HTMLConstructor and a chromeonly constructor "
|
||||
"operation")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Can't have both a HTMLConstructor and a chromeonly constructor " "operation",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestHTMLConstructorAndConstructor {
|
||||
[Throws, ChromeOnly]
|
||||
constructor(DOMString a);
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have both a HTMLConstructor and a throwing chromeonly "
|
||||
"constructor operation")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Can't have both a HTMLConstructor and a throwing chromeonly "
|
||||
"constructor operation",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[NoInterfaceObject]
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyNoInterfaceObject]
|
||||
interface InterfaceWithoutInterfaceObject {
|
||||
constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have a constructor operation on a [NoInterfaceObject] "
|
||||
"interface")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Can't have a constructor operation on a [LegacyNoInterfaceObject] "
|
||||
"interface",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface InterfaceWithPartial {
|
||||
};
|
||||
|
||||
partial interface InterfaceWithPartial {
|
||||
constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have a constructor operation on a partial interface")
|
||||
harness.ok(threw, "Can't have a constructor operation on a partial interface")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface InterfaceWithMixin {
|
||||
};
|
||||
|
||||
|
@ -414,11 +585,10 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
|
||||
InterfaceWithMixin includes Mixin
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Can't have a constructor operation on a mixin")
|
||||
|
||||
harness.ok(threw, "Can't have a constructor operation on a mixin")
|
||||
|
|
|
@ -1,14 +1,17 @@
|
|||
import traceback
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=TestConstructorGlobal]
|
||||
interface TestConstructorGlobal {
|
||||
constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -19,12 +22,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global, Exposed=TestNamedConstructorGlobal,
|
||||
NamedConstructor=FooBar]
|
||||
interface TestNamedConstructorGlobal {
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=TestLegacyFactoryFunctionGlobal,
|
||||
LegacyFactoryFunction=FooBar]
|
||||
interface TestLegacyFactoryFunctionGlobal {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -34,12 +39,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[NamedConstructor=FooBar, Global,
|
||||
Exposed=TestNamedConstructorGlobal]
|
||||
interface TestNamedConstructorGlobal {
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyFactoryFunction=FooBar, Global,
|
||||
Exposed=TestLegacyFactoryFunctionGlobal]
|
||||
interface TestLegacyFactoryFunctionGlobal {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -49,12 +56,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=TestHTMLConstructorGlobal]
|
||||
interface TestHTMLConstructorGlobal {
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,12 +1,14 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[NoInterfaceObject]
|
||||
interface TestConstructorNoInterfaceObject {
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyNoInterfaceObject]
|
||||
interface TestConstructorLegacyNoInterfaceObject {
|
||||
constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -16,23 +18,27 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
parser = parser.reset()
|
||||
|
||||
parser.parse("""
|
||||
[NoInterfaceObject, NamedConstructor=FooBar]
|
||||
interface TestNamedConstructorNoInterfaceObject {
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyNoInterfaceObject, LegacyFactoryFunction=FooBar]
|
||||
interface TestLegacyFactoryFunctionLegacyNoInterfaceObject {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
# Test HTMLConstructor and NoInterfaceObject
|
||||
# Test HTMLConstructor and LegacyNoInterfaceObject
|
||||
parser = parser.reset()
|
||||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[NoInterfaceObject]
|
||||
interface TestHTMLConstructorNoInterfaceObject {
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyNoInterfaceObject]
|
||||
interface TestHTMLConstructorLegacyNoInterfaceObject {
|
||||
[HTMLConstructor] constructor();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,15 +1,20 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo;
|
||||
interface Bar;
|
||||
interface Foo;
|
||||
""");
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
# There should be no duplicate interfaces in the result.
|
||||
expectedNames = sorted(['Foo', 'Bar'])
|
||||
expectedNames = sorted(["Foo", "Bar"])
|
||||
actualNames = sorted(map(lambda iface: iface.identifier.name, results))
|
||||
harness.check(actualNames, expectedNames, "Parser shouldn't output duplicate names.")
|
||||
harness.check(
|
||||
actualNames, expectedNames, "Parser shouldn't output duplicate names."
|
||||
)
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict2 : Dict1 {
|
||||
long child = 5;
|
||||
Dict1 aaandAnother;
|
||||
|
@ -8,27 +9,33 @@ def WebIDLTest(parser, harness):
|
|||
long parent;
|
||||
double otherParent;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
dict1 = results[1];
|
||||
dict2 = results[0];
|
||||
dict1 = results[1]
|
||||
dict2 = results[0]
|
||||
|
||||
harness.check(len(dict1.members), 2, "Dict1 has two members")
|
||||
harness.check(len(dict2.members), 2, "Dict2 has four members")
|
||||
|
||||
harness.check(dict1.members[0].identifier.name, "otherParent",
|
||||
"'o' comes before 'p'")
|
||||
harness.check(dict1.members[1].identifier.name, "parent",
|
||||
"'o' really comes before 'p'")
|
||||
harness.check(dict2.members[0].identifier.name, "aaandAnother",
|
||||
"'a' comes before 'c'")
|
||||
harness.check(dict2.members[1].identifier.name, "child",
|
||||
"'a' really comes before 'c'")
|
||||
harness.check(
|
||||
dict1.members[0].identifier.name, "otherParent", "'o' comes before 'p'"
|
||||
)
|
||||
harness.check(
|
||||
dict1.members[1].identifier.name, "parent", "'o' really comes before 'p'"
|
||||
)
|
||||
harness.check(
|
||||
dict2.members[0].identifier.name, "aaandAnother", "'a' comes before 'c'"
|
||||
)
|
||||
harness.check(
|
||||
dict2.members[1].identifier.name, "child", "'a' really comes before 'c'"
|
||||
)
|
||||
|
||||
# Test partial dictionary.
|
||||
parser = parser.reset();
|
||||
parser.parse("""
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
long c;
|
||||
long g;
|
||||
|
@ -37,30 +44,29 @@ def WebIDLTest(parser, harness):
|
|||
long h;
|
||||
long d;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
dict1 = results[0];
|
||||
dict1 = results[0]
|
||||
harness.check(len(dict1.members), 4, "Dict1 has four members")
|
||||
harness.check(dict1.members[0].identifier.name, "c",
|
||||
"c should be first")
|
||||
harness.check(dict1.members[1].identifier.name, "d",
|
||||
"d should come after c")
|
||||
harness.check(dict1.members[2].identifier.name, "g",
|
||||
"g should come after d")
|
||||
harness.check(dict1.members[3].identifier.name, "h",
|
||||
"h should be last")
|
||||
harness.check(dict1.members[0].identifier.name, "c", "c should be first")
|
||||
harness.check(dict1.members[1].identifier.name, "d", "d should come after c")
|
||||
harness.check(dict1.members[2].identifier.name, "g", "g should come after d")
|
||||
harness.check(dict1.members[3].identifier.name, "h", "h should be last")
|
||||
|
||||
# Now reset our parser
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {
|
||||
long prop = 5;
|
||||
long prop;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -68,28 +74,33 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(threw, "Should not allow name duplication in a dictionary")
|
||||
|
||||
# Test no name duplication across normal and partial dictionary.
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
long prop = 5;
|
||||
};
|
||||
partial dictionary A {
|
||||
long prop;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow name duplication across normal and partial dictionary")
|
||||
harness.ok(
|
||||
threw, "Should not allow name duplication across normal and partial dictionary"
|
||||
)
|
||||
|
||||
# Now reset our parser again
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict1 : Dict2 {
|
||||
long prop = 5;
|
||||
};
|
||||
|
@ -99,24 +110,28 @@ def WebIDLTest(parser, harness):
|
|||
dictionary Dict3 {
|
||||
double prop;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow name duplication in a dictionary and "
|
||||
"its ancestor")
|
||||
harness.ok(
|
||||
threw, "Should not allow name duplication in a dictionary and " "its ancestor"
|
||||
)
|
||||
|
||||
# More reset
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Iface {};
|
||||
dictionary Dict : Iface {
|
||||
long prop;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -127,10 +142,12 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A : B {};
|
||||
dictionary B : A {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -140,27 +157,33 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
[TreatNullAs=EmptyString] DOMString foo;
|
||||
[LegacyNullToEmptyString] DOMString foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow [TreatNullAs] on dictionary members");
|
||||
harness.ok(
|
||||
threw, "Should not allow [LegacyNullToEmptyString] on dictionary members"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(A arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -170,13 +193,15 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional A arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -186,47 +211,53 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo((A or DOMString) arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Trailing union arg containing a dictionary must be optional")
|
||||
harness.ok(threw, "Trailing union arg containing a dictionary must be optional")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional (A or DOMString) arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Trailing union arg containing a dictionary must have a default value")
|
||||
harness.ok(
|
||||
threw, "Trailing union arg containing a dictionary must have a default value"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(A arg1, optional long arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -236,13 +267,15 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional A arg1, optional long arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -252,245 +285,289 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(A arg1, optional long arg2, long arg3);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(not threw,
|
||||
"Dictionary arg followed by non-optional arg doesn't have to be optional")
|
||||
harness.ok(
|
||||
not threw,
|
||||
"Dictionary arg followed by non-optional arg doesn't have to be optional",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo((A or DOMString) arg1, optional long arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Union arg containing dictionary followed by optional arg must "
|
||||
"be optional")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Union arg containing dictionary followed by optional arg must " "be optional",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional (A or DOMString) arg1, optional long arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Union arg containing dictionary followed by optional arg must "
|
||||
"have a default value")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Union arg containing dictionary followed by optional arg must "
|
||||
"have a default value",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(A arg1, long arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Dictionary arg followed by required arg can be required")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional A? arg1 = {});
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = x
|
||||
|
||||
harness.ok(threw, "Optional dictionary arg must not be nullable")
|
||||
harness.ok("nullable" in str(threw),
|
||||
"Must have the expected exception for optional nullable dictionary arg")
|
||||
harness.ok(
|
||||
"nullable" in str(threw),
|
||||
"Must have the expected exception for optional nullable dictionary arg",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
required long x;
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(A? arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = x
|
||||
|
||||
harness.ok(threw, "Required dictionary arg must not be nullable")
|
||||
harness.ok("nullable" in str(threw),
|
||||
"Must have the expected exception for required nullable "
|
||||
"dictionary arg")
|
||||
harness.ok(
|
||||
"nullable" in str(threw),
|
||||
"Must have the expected exception for required nullable " "dictionary arg",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional (A or long)? arg1 = {});
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = x
|
||||
|
||||
harness.ok(threw, "Dictionary arg must not be in an optional nullable union")
|
||||
harness.ok("nullable" in str(threw),
|
||||
"Must have the expected exception for optional nullable union "
|
||||
"arg containing dictionary")
|
||||
harness.ok(
|
||||
"nullable" in str(threw),
|
||||
"Must have the expected exception for optional nullable union "
|
||||
"arg containing dictionary",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
required long x;
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo((A or long)? arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = x
|
||||
|
||||
harness.ok(threw, "Dictionary arg must not be in a required nullable union")
|
||||
harness.ok("nullable" in str(threw),
|
||||
"Must have the expected exception for required nullable union "
|
||||
"arg containing dictionary")
|
||||
harness.ok(
|
||||
"nullable" in str(threw),
|
||||
"Must have the expected exception for required nullable union "
|
||||
"arg containing dictionary",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(sequence<A?> arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(not threw,
|
||||
"Nullable union should be allowed in a sequence argument")
|
||||
harness.ok(not threw, "Nullable union should be allowed in a sequence argument")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional (A or long?) arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Dictionary must not be in a union with a nullable type")
|
||||
harness.ok(threw, "Dictionary must not be in a union with a nullable type")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional (long? or A) arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"A nullable type must not be in a union with a dictionary")
|
||||
harness.ok(threw, "A nullable type must not be in a union with a dictionary")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
A? doFoo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Dictionary return value can be nullable")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional A arg = {});
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Dictionary arg should actually parse")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional (A or DOMString) arg = {});
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Union arg containing a dictionary should actually parse")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
};
|
||||
interface X {
|
||||
undefined doFoo(optional (A or DOMString) arg = "abc");
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Union arg containing a dictionary with string default should actually parse")
|
||||
harness.ok(
|
||||
True,
|
||||
"Union arg containing a dictionary with string default should actually parse",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
Foo foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -500,7 +577,8 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo3 : Foo {
|
||||
short d;
|
||||
};
|
||||
|
@ -516,78 +594,102 @@ def WebIDLTest(parser, harness):
|
|||
dictionary Foo {
|
||||
Foo1 b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Member type must not be a Dictionary that "
|
||||
"inherits from its Dictionary.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Member type must not be a Dictionary that " "inherits from its Dictionary.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
(Foo or DOMString)[]? b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Member type must not be a Nullable type "
|
||||
"whose inner type includes its Dictionary.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Member type must not be a Nullable type "
|
||||
"whose inner type includes its Dictionary.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
(DOMString or Foo) b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Member type must not be a Union type, one of "
|
||||
"whose member types includes its Dictionary.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Member type must not be a Union type, one of "
|
||||
"whose member types includes its Dictionary.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
sequence<sequence<sequence<Foo>>> c;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Member type must not be a Sequence type "
|
||||
"whose element type includes its Dictionary.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Member type must not be a Sequence type "
|
||||
"whose element type includes its Dictionary.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
(DOMString or Foo)[] d;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Member type must not be an Array type "
|
||||
"whose element type includes its Dictionary.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Member type must not be an Array type "
|
||||
"whose element type includes its Dictionary.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
Foo1 b;
|
||||
};
|
||||
|
@ -603,34 +705,41 @@ def WebIDLTest(parser, harness):
|
|||
dictionary Foo1 : Foo2 {
|
||||
long a;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Member type must not be a Dictionary, one of whose "
|
||||
"members or inherited members has a type that includes "
|
||||
"its Dictionary.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Member type must not be a Dictionary, one of whose "
|
||||
"members or inherited members has a type that includes "
|
||||
"its Dictionary.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
};
|
||||
|
||||
dictionary Bar {
|
||||
Foo? d;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Member type must not be a nullable dictionary")
|
||||
|
||||
parser = parser.reset();
|
||||
parser.parse("""
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
unrestricted float urFloat = 0;
|
||||
unrestricted float urFloat2 = 1.1;
|
||||
|
@ -648,103 +757,117 @@ def WebIDLTest(parser, harness):
|
|||
unrestricted double negativeInfUrDouble = -Infinity;
|
||||
unrestricted double nanUrDouble = NaN;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Parsing default values for unrestricted types succeeded.")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
double f = Infinity;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Only unrestricted values can be initialized to Infinity")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
double f = -Infinity;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Only unrestricted values can be initialized to -Infinity")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
double f = NaN;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Only unrestricted values can be initialized to NaN")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
float f = Infinity;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Only unrestricted values can be initialized to Infinity")
|
||||
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
float f = -Infinity;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Only unrestricted values can be initialized to -Infinity")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
float f = NaN;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Only unrestricted values can be initialized to NaN")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo {
|
||||
long module;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
|
|
@ -1,8 +1,13 @@
|
|||
import traceback
|
||||
|
||||
|
||||
def firstArgType(method):
|
||||
return method.signatures()[0][1][0].type
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
// Give our dictionary a required member so we don't need to
|
||||
// mess with optional and default values.
|
||||
dictionary Dict {
|
||||
|
@ -17,7 +22,8 @@ def WebIDLTest(parser, harness):
|
|||
undefined passNullableUnion((object? or DOMString) arg);
|
||||
undefined passNullable(Foo? arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
iface = results[2]
|
||||
|
@ -30,31 +36,38 @@ def WebIDLTest(parser, harness):
|
|||
dictType = firstArgType(dictMethod)
|
||||
ifaceType = firstArgType(ifaceMethod)
|
||||
|
||||
harness.ok(dictType.isDictionary(), "Should have dictionary type");
|
||||
harness.ok(ifaceType.isInterface(), "Should have interface type");
|
||||
harness.ok(ifaceType.isCallbackInterface(), "Should have callback interface type");
|
||||
harness.ok(dictType.isDictionary(), "Should have dictionary type")
|
||||
harness.ok(ifaceType.isInterface(), "Should have interface type")
|
||||
harness.ok(ifaceType.isCallbackInterface(), "Should have callback interface type")
|
||||
|
||||
harness.ok(not dictType.isDistinguishableFrom(ifaceType),
|
||||
"Dictionary not distinguishable from callback interface")
|
||||
harness.ok(not ifaceType.isDistinguishableFrom(dictType),
|
||||
"Callback interface not distinguishable from dictionary")
|
||||
harness.ok(
|
||||
not dictType.isDistinguishableFrom(ifaceType),
|
||||
"Dictionary not distinguishable from callback interface",
|
||||
)
|
||||
harness.ok(
|
||||
not ifaceType.isDistinguishableFrom(dictType),
|
||||
"Callback interface not distinguishable from dictionary",
|
||||
)
|
||||
|
||||
nullableUnionType = firstArgType(nullableUnionMethod)
|
||||
nullableIfaceType = firstArgType(nullableIfaceMethod)
|
||||
|
||||
harness.ok(nullableUnionType.isUnion(), "Should have union type");
|
||||
harness.ok(nullableIfaceType.isInterface(), "Should have interface type");
|
||||
harness.ok(nullableIfaceType.nullable(), "Should have nullable type");
|
||||
harness.ok(nullableUnionType.isUnion(), "Should have union type")
|
||||
harness.ok(nullableIfaceType.isInterface(), "Should have interface type")
|
||||
harness.ok(nullableIfaceType.nullable(), "Should have nullable type")
|
||||
|
||||
harness.ok(not nullableUnionType.isDistinguishableFrom(nullableIfaceType),
|
||||
"Nullable type not distinguishable from union with nullable "
|
||||
"member type")
|
||||
harness.ok(not nullableIfaceType.isDistinguishableFrom(nullableUnionType),
|
||||
"Union with nullable member type not distinguishable from "
|
||||
"nullable type")
|
||||
harness.ok(
|
||||
not nullableUnionType.isDistinguishableFrom(nullableIfaceType),
|
||||
"Nullable type not distinguishable from union with nullable " "member type",
|
||||
)
|
||||
harness.ok(
|
||||
not nullableIfaceType.isDistinguishableFrom(nullableUnionType),
|
||||
"Union with nullable member type not distinguishable from " "nullable type",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIface {
|
||||
undefined passKid(Kid arg);
|
||||
undefined passParent(Parent arg);
|
||||
|
@ -70,7 +83,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Grandparent {};
|
||||
interface Unrelated1 {};
|
||||
interface Unrelated2 {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
iface = results[0]
|
||||
|
@ -80,21 +94,26 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
for type1 in argTypes:
|
||||
for type2 in argTypes:
|
||||
distinguishable = (type1 is not type2 and
|
||||
(type1 in unrelatedTypes or
|
||||
type2 in unrelatedTypes))
|
||||
distinguishable = type1 is not type2 and (
|
||||
type1 in unrelatedTypes or type2 in unrelatedTypes
|
||||
)
|
||||
|
||||
harness.check(type1.isDistinguishableFrom(type2),
|
||||
distinguishable,
|
||||
"Type %s should %sbe distinguishable from type %s" %
|
||||
(type1, "" if distinguishable else "not ", type2))
|
||||
harness.check(type2.isDistinguishableFrom(type1),
|
||||
distinguishable,
|
||||
"Type %s should %sbe distinguishable from type %s" %
|
||||
(type2, "" if distinguishable else "not ", type1))
|
||||
harness.check(
|
||||
type1.isDistinguishableFrom(type2),
|
||||
distinguishable,
|
||||
"Type %s should %sbe distinguishable from type %s"
|
||||
% (type1, "" if distinguishable else "not ", type2),
|
||||
)
|
||||
harness.check(
|
||||
type2.isDistinguishableFrom(type1),
|
||||
distinguishable,
|
||||
"Type %s should %sbe distinguishable from type %s"
|
||||
% (type2, "" if distinguishable else "not ", type1),
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Dummy {};
|
||||
interface TestIface {
|
||||
undefined method(long arg1, TestIface arg2);
|
||||
|
@ -102,17 +121,19 @@ def WebIDLTest(parser, harness):
|
|||
undefined method(long arg1, Dummy arg2);
|
||||
undefined method(DOMString arg1, DOMString arg2, DOMString arg3);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results[1].members), 1,
|
||||
"Should look like we have one method")
|
||||
harness.check(len(results[1].members[0].signatures()), 4,
|
||||
"Should have four signatures")
|
||||
harness.check(len(results[1].members), 1, "Should look like we have one method")
|
||||
harness.check(
|
||||
len(results[1].members[0].signatures()), 4, "Should have four signatures"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Dummy {};
|
||||
interface TestIface {
|
||||
undefined method(long arg1, TestIface arg2);
|
||||
|
@ -120,19 +141,23 @@ def WebIDLTest(parser, harness):
|
|||
undefined method(any arg1, Dummy arg2);
|
||||
undefined method(DOMString arg1, DOMString arg2, DOMString arg3);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should throw when args before the distinguishing arg are not "
|
||||
"all the same type")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should throw when args before the distinguishing arg are not "
|
||||
"all the same type",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Dummy {};
|
||||
interface TestIface {
|
||||
undefined method(long arg1, TestIface arg2);
|
||||
|
@ -140,7 +165,8 @@ def WebIDLTest(parser, harness):
|
|||
undefined method(any arg1, DOMString arg2);
|
||||
undefined method(DOMString arg1, DOMString arg2, DOMString arg3);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -148,57 +174,133 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(threw, "Should throw when there is no distinguishing index")
|
||||
|
||||
# Now let's test our whole distinguishability table
|
||||
argTypes = [ "long", "short", "long?", "short?", "boolean",
|
||||
"boolean?", "DOMString", "ByteString", "UTF8String", "Enum", "Enum2",
|
||||
"Interface", "Interface?",
|
||||
"AncestorInterface", "UnrelatedInterface", "CallbackInterface",
|
||||
"CallbackInterface?", "CallbackInterface2",
|
||||
"object", "Callback", "Callback2", "Dict",
|
||||
"Dict2", "sequence<long>", "sequence<short>",
|
||||
"record<DOMString, object>",
|
||||
"record<USVString, Dict>",
|
||||
"record<ByteString, long>",
|
||||
"record<UTF8String, long>",
|
||||
"any", "Promise<any>", "Promise<any>?",
|
||||
"USVString", "JSString", "ArrayBuffer", "ArrayBufferView",
|
||||
"Uint8Array", "Uint16Array",
|
||||
"(long or Callback)", "(long or Dict)",
|
||||
argTypes = [
|
||||
"long",
|
||||
"short",
|
||||
"long?",
|
||||
"short?",
|
||||
"boolean",
|
||||
"boolean?",
|
||||
"undefined",
|
||||
"undefined?",
|
||||
"DOMString",
|
||||
"ByteString",
|
||||
"UTF8String",
|
||||
"Enum",
|
||||
"Enum2",
|
||||
"Interface",
|
||||
"Interface?",
|
||||
"AncestorInterface",
|
||||
"UnrelatedInterface",
|
||||
"CallbackInterface",
|
||||
"CallbackInterface?",
|
||||
"CallbackInterface2",
|
||||
"object",
|
||||
"Callback",
|
||||
"Callback2",
|
||||
"Dict",
|
||||
"Dict2",
|
||||
"sequence<long>",
|
||||
"sequence<short>",
|
||||
"record<DOMString, object>",
|
||||
"record<USVString, Dict>",
|
||||
"record<ByteString, long>",
|
||||
"record<UTF8String, long>",
|
||||
"any",
|
||||
"Promise<any>",
|
||||
"Promise<any>?",
|
||||
"USVString",
|
||||
"JSString",
|
||||
"ArrayBuffer",
|
||||
"ArrayBufferView",
|
||||
"Uint8Array",
|
||||
"Uint16Array",
|
||||
"(long or Callback)",
|
||||
"(long or Dict)",
|
||||
]
|
||||
|
||||
# Try to categorize things a bit to keep list lengths down
|
||||
def allBut(list1, list2):
|
||||
return [a for a in list1 if a not in list2 and
|
||||
(a != "any" and a != "Promise<any>" and a != "Promise<any>?")]
|
||||
unions = [ "(long or Callback)", "(long or Dict)" ]
|
||||
numerics = [ "long", "short", "long?", "short?" ]
|
||||
booleans = [ "boolean", "boolean?" ]
|
||||
return [
|
||||
a
|
||||
for a in list1
|
||||
if a not in list2
|
||||
and (a != "any" and a != "Promise<any>" and a != "Promise<any>?")
|
||||
]
|
||||
|
||||
unions = ["(long or Callback)", "(long or Dict)"]
|
||||
numerics = ["long", "short", "long?", "short?"]
|
||||
booleans = ["boolean", "boolean?"]
|
||||
undefineds = ["undefined", "undefined?"]
|
||||
primitives = numerics + booleans
|
||||
nonNumerics = allBut(argTypes, numerics + unions)
|
||||
nonBooleans = allBut(argTypes, booleans)
|
||||
strings = [ "DOMString", "ByteString", "Enum", "Enum2", "USVString", "JSString", "UTF8String" ]
|
||||
strings = [
|
||||
"DOMString",
|
||||
"ByteString",
|
||||
"Enum",
|
||||
"Enum2",
|
||||
"USVString",
|
||||
"JSString",
|
||||
"UTF8String",
|
||||
]
|
||||
nonStrings = allBut(argTypes, strings)
|
||||
nonObjects = primitives + strings
|
||||
objects = allBut(argTypes, nonObjects )
|
||||
nonObjects = undefineds + primitives + strings
|
||||
objects = allBut(argTypes, nonObjects)
|
||||
bufferSourceTypes = ["ArrayBuffer", "ArrayBufferView", "Uint8Array", "Uint16Array"]
|
||||
interfaces = [ "Interface", "Interface?", "AncestorInterface",
|
||||
"UnrelatedInterface" ] + bufferSourceTypes
|
||||
nullables = (["long?", "short?", "boolean?", "Interface?",
|
||||
"CallbackInterface?", "Dict", "Dict2",
|
||||
"Date?", "any", "Promise<any>?"] +
|
||||
allBut(unions, [ "(long or Callback)" ]))
|
||||
sequences = [ "sequence<long>", "sequence<short>" ]
|
||||
interfaces = [
|
||||
"Interface",
|
||||
"Interface?",
|
||||
"AncestorInterface",
|
||||
"UnrelatedInterface",
|
||||
] + bufferSourceTypes
|
||||
nullables = [
|
||||
"long?",
|
||||
"short?",
|
||||
"boolean?",
|
||||
"undefined?",
|
||||
"Interface?",
|
||||
"CallbackInterface?",
|
||||
"Dict",
|
||||
"Dict2",
|
||||
"Date?",
|
||||
"any",
|
||||
"Promise<any>?",
|
||||
] + allBut(unions, ["(long or Callback)"])
|
||||
sequences = ["sequence<long>", "sequence<short>"]
|
||||
nonUserObjects = nonObjects + interfaces + sequences
|
||||
otherObjects = allBut(argTypes, nonUserObjects + ["object"])
|
||||
notRelatedInterfaces = (nonObjects + ["UnrelatedInterface"] +
|
||||
otherObjects + sequences + bufferSourceTypes)
|
||||
records = [ "record<DOMString, object>", "record<USVString, Dict>",
|
||||
"record<ByteString, long>", "record<UTF8String, long>" ] # JSString not supported in records
|
||||
notRelatedInterfaces = (
|
||||
nonObjects
|
||||
+ ["UnrelatedInterface"]
|
||||
+ otherObjects
|
||||
+ sequences
|
||||
+ bufferSourceTypes
|
||||
)
|
||||
records = [
|
||||
"record<DOMString, object>",
|
||||
"record<USVString, Dict>",
|
||||
"record<ByteString, long>",
|
||||
"record<UTF8String, long>",
|
||||
] # JSString not supported in records
|
||||
dictionaryLike = (
|
||||
[
|
||||
"Dict",
|
||||
"Dict2",
|
||||
"CallbackInterface",
|
||||
"CallbackInterface?",
|
||||
"CallbackInterface2",
|
||||
]
|
||||
+ records
|
||||
+ allBut(unions, ["(long or Callback)"])
|
||||
)
|
||||
|
||||
# Build a representation of the distinguishability table as a dict
|
||||
# of dicts, holding True values where needed, holes elsewhere.
|
||||
data = dict();
|
||||
data = dict()
|
||||
for type in argTypes:
|
||||
data[type] = dict()
|
||||
|
||||
def setDistinguishable(type, types):
|
||||
for other in types:
|
||||
data[type][other] = True
|
||||
|
@ -209,6 +311,10 @@ def WebIDLTest(parser, harness):
|
|||
setDistinguishable("short?", allBut(nonNumerics, nullables))
|
||||
setDistinguishable("boolean", nonBooleans)
|
||||
setDistinguishable("boolean?", allBut(nonBooleans, nullables))
|
||||
setDistinguishable("undefined", allBut(argTypes, undefineds + dictionaryLike))
|
||||
setDistinguishable(
|
||||
"undefined?", allBut(argTypes, undefineds + dictionaryLike + nullables)
|
||||
)
|
||||
setDistinguishable("DOMString", nonStrings)
|
||||
setDistinguishable("ByteString", nonStrings)
|
||||
setDistinguishable("UTF8String", nonStrings)
|
||||
|
@ -219,36 +325,44 @@ def WebIDLTest(parser, harness):
|
|||
setDistinguishable("Interface", notRelatedInterfaces)
|
||||
setDistinguishable("Interface?", allBut(notRelatedInterfaces, nullables))
|
||||
setDistinguishable("AncestorInterface", notRelatedInterfaces)
|
||||
setDistinguishable("UnrelatedInterface",
|
||||
allBut(argTypes, ["object", "UnrelatedInterface"]))
|
||||
setDistinguishable("CallbackInterface", nonUserObjects)
|
||||
setDistinguishable("CallbackInterface?", allBut(nonUserObjects, nullables))
|
||||
setDistinguishable("CallbackInterface2", nonUserObjects)
|
||||
setDistinguishable(
|
||||
"UnrelatedInterface", allBut(argTypes, ["object", "UnrelatedInterface"])
|
||||
)
|
||||
setDistinguishable("CallbackInterface", allBut(nonUserObjects, undefineds))
|
||||
setDistinguishable(
|
||||
"CallbackInterface?", allBut(nonUserObjects, nullables + undefineds)
|
||||
)
|
||||
setDistinguishable("CallbackInterface2", allBut(nonUserObjects, undefineds))
|
||||
setDistinguishable("object", nonObjects)
|
||||
setDistinguishable("Callback", nonUserObjects)
|
||||
setDistinguishable("Callback2", nonUserObjects)
|
||||
setDistinguishable("Dict", allBut(nonUserObjects, nullables))
|
||||
setDistinguishable("Dict2", allBut(nonUserObjects, nullables))
|
||||
setDistinguishable("sequence<long>",
|
||||
allBut(argTypes, sequences + ["object"]))
|
||||
setDistinguishable("sequence<short>",
|
||||
allBut(argTypes, sequences + ["object"]))
|
||||
setDistinguishable("record<DOMString, object>", nonUserObjects)
|
||||
setDistinguishable("record<USVString, Dict>", nonUserObjects)
|
||||
setDistinguishable("Dict", allBut(nonUserObjects, nullables + undefineds))
|
||||
setDistinguishable("Dict2", allBut(nonUserObjects, nullables + undefineds))
|
||||
setDistinguishable("sequence<long>", allBut(argTypes, sequences + ["object"]))
|
||||
setDistinguishable("sequence<short>", allBut(argTypes, sequences + ["object"]))
|
||||
setDistinguishable("record<DOMString, object>", allBut(nonUserObjects, undefineds))
|
||||
setDistinguishable("record<USVString, Dict>", allBut(nonUserObjects, undefineds))
|
||||
# JSString not supported in records
|
||||
setDistinguishable("record<ByteString, long>", nonUserObjects)
|
||||
setDistinguishable("record<UTF8String, long>", nonUserObjects)
|
||||
setDistinguishable("record<ByteString, long>", allBut(nonUserObjects, undefineds))
|
||||
setDistinguishable("record<UTF8String, long>", allBut(nonUserObjects, undefineds))
|
||||
setDistinguishable("any", [])
|
||||
setDistinguishable("Promise<any>", [])
|
||||
setDistinguishable("Promise<any>?", [])
|
||||
setDistinguishable("ArrayBuffer", allBut(argTypes, ["ArrayBuffer", "object"]))
|
||||
setDistinguishable("ArrayBufferView", allBut(argTypes, ["ArrayBufferView", "Uint8Array", "Uint16Array", "object"]))
|
||||
setDistinguishable("Uint8Array", allBut(argTypes, ["ArrayBufferView", "Uint8Array", "object"]))
|
||||
setDistinguishable("Uint16Array", allBut(argTypes, ["ArrayBufferView", "Uint16Array", "object"]))
|
||||
setDistinguishable("(long or Callback)",
|
||||
allBut(nonUserObjects, numerics))
|
||||
setDistinguishable("(long or Dict)",
|
||||
allBut(nonUserObjects, numerics + nullables))
|
||||
setDistinguishable(
|
||||
"ArrayBufferView",
|
||||
allBut(argTypes, ["ArrayBufferView", "Uint8Array", "Uint16Array", "object"]),
|
||||
)
|
||||
setDistinguishable(
|
||||
"Uint8Array", allBut(argTypes, ["ArrayBufferView", "Uint8Array", "object"])
|
||||
)
|
||||
setDistinguishable(
|
||||
"Uint16Array", allBut(argTypes, ["ArrayBufferView", "Uint16Array", "object"])
|
||||
)
|
||||
setDistinguishable("(long or Callback)", allBut(nonUserObjects, numerics))
|
||||
setDistinguishable(
|
||||
"(long or Dict)", allBut(nonUserObjects, numerics + nullables + undefineds)
|
||||
)
|
||||
|
||||
def areDistinguishable(type1, type2):
|
||||
return data[type1].get(type2, False)
|
||||
|
@ -271,10 +385,18 @@ def WebIDLTest(parser, harness):
|
|||
interface TestInterface {%s
|
||||
};
|
||||
"""
|
||||
methodTemplate = """
|
||||
undefined myMethod(%s arg);"""
|
||||
methods = (methodTemplate % type1) + (methodTemplate % type2)
|
||||
if type1 in undefineds or type2 in undefineds:
|
||||
methods = """
|
||||
(%s or %s) myMethod();""" % (
|
||||
type1,
|
||||
type2,
|
||||
)
|
||||
else:
|
||||
methodTemplate = """
|
||||
undefined myMethod(%s arg);"""
|
||||
methods = (methodTemplate % type1) + (methodTemplate % type2)
|
||||
idl = idlTemplate % methods
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
|
@ -284,11 +406,17 @@ def WebIDLTest(parser, harness):
|
|||
threw = True
|
||||
|
||||
if areDistinguishable(type1, type2):
|
||||
harness.ok(not threw,
|
||||
"Should not throw for '%s' and '%s' because they are distinguishable" % (type1, type2))
|
||||
harness.ok(
|
||||
not threw,
|
||||
"Should not throw for '%s' and '%s' because they are distinguishable"
|
||||
% (type1, type2),
|
||||
)
|
||||
else:
|
||||
harness.ok(threw,
|
||||
"Should throw for '%s' and '%s' because they are not distinguishable" % (type1, type2))
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should throw for '%s' and '%s' because they are not distinguishable"
|
||||
% (type1, type2),
|
||||
)
|
||||
|
||||
# Enumerate over everything in both orders, since order matters in
|
||||
# terms of our implementation of distinguishability checks
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface DoubleNull {
|
||||
attribute byte?? foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface DuplicateQualifiers1 {
|
||||
getter getter byte foo(unsigned long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -15,11 +17,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface DuplicateQualifiers2 {
|
||||
setter setter byte foo(unsigned long index, byte value);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -29,11 +33,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface DuplicateQualifiers4 {
|
||||
deleter deleter byte foo(unsigned long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -43,11 +49,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface DuplicateQualifiers5 {
|
||||
getter deleter getter byte foo(unsigned long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,11 +1,14 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
enum TestEmptyEnum {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
harness.ok(False, "Should have thrown!")
|
||||
except:
|
||||
|
|
|
@ -1,13 +1,16 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface X {
|
||||
const sequence<long> foo = [];
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -17,29 +20,35 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
parser = parser.reset()
|
||||
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface X {
|
||||
undefined foo(optional sequence<long> arg = []);
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(isinstance(
|
||||
results[0].members[0].signatures()[0][1][0].defaultValue,
|
||||
WebIDL.IDLEmptySequenceValue),
|
||||
"Should have IDLEmptySequenceValue as default value of argument")
|
||||
harness.ok(
|
||||
isinstance(
|
||||
results[0].members[0].signatures()[0][1][0].defaultValue,
|
||||
WebIDL.IDLEmptySequenceValue,
|
||||
),
|
||||
"Should have IDLEmptySequenceValue as default value of argument",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary X {
|
||||
sequence<long> foo = [];
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
|
||||
harness.ok(isinstance(results[0].members[0].defaultValue,
|
||||
WebIDL.IDLEmptySequenceValue),
|
||||
"Should have IDLEmptySequenceValue as default value of "
|
||||
"dictionary member")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(
|
||||
isinstance(results[0].members[0].defaultValue, WebIDL.IDLEmptySequenceValue),
|
||||
"Should have IDLEmptySequenceValue as default value of " "dictionary member",
|
||||
)
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
enum TestEnum {
|
||||
"",
|
||||
"foo",
|
||||
|
@ -12,16 +14,15 @@ def WebIDLTest(parser, harness):
|
|||
TestEnum doFoo(boolean arg);
|
||||
readonly attribute TestEnum foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestEnumInterfaces interface parsed without error.")
|
||||
harness.check(len(results), 2, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLEnum),
|
||||
"Should be an IDLEnum")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLEnum), "Should be an IDLEnum")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
|
||||
enum = results[0]
|
||||
harness.check(enum.identifier.QName(), "::TestEnum", "Enum has the right QName")
|
||||
|
@ -30,32 +31,41 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
iface = results[1]
|
||||
|
||||
harness.check(iface.identifier.QName(), "::TestEnumInterface", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "TestEnumInterface", "Interface has the right name")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestEnumInterface", "Interface has the right QName"
|
||||
)
|
||||
harness.check(
|
||||
iface.identifier.name, "TestEnumInterface", "Interface has the right name"
|
||||
)
|
||||
harness.check(iface.parent, None, "Interface has no parent")
|
||||
|
||||
members = iface.members
|
||||
harness.check(len(members), 2, "Should be one production")
|
||||
harness.ok(isinstance(members[0], WebIDL.IDLMethod),
|
||||
"Should be an IDLMethod")
|
||||
harness.ok(isinstance(members[0], WebIDL.IDLMethod), "Should be an IDLMethod")
|
||||
method = members[0]
|
||||
harness.check(method.identifier.QName(), "::TestEnumInterface::doFoo",
|
||||
"Method has correct QName")
|
||||
harness.check(
|
||||
method.identifier.QName(),
|
||||
"::TestEnumInterface::doFoo",
|
||||
"Method has correct QName",
|
||||
)
|
||||
harness.check(method.identifier.name, "doFoo", "Method has correct name")
|
||||
|
||||
signatures = method.signatures()
|
||||
harness.check(len(signatures), 1, "Expect one signature")
|
||||
|
||||
(returnType, arguments) = signatures[0]
|
||||
harness.check(str(returnType), "TestEnum (Wrapper)", "Method type is the correct name")
|
||||
harness.check(
|
||||
str(returnType), "TestEnum (Wrapper)", "Method type is the correct name"
|
||||
)
|
||||
harness.check(len(arguments), 1, "Method has the right number of arguments")
|
||||
arg = arguments[0]
|
||||
harness.ok(isinstance(arg, WebIDL.IDLArgument), "Should be an IDLArgument")
|
||||
harness.check(str(arg.type), "Boolean", "Argument has the right type")
|
||||
|
||||
attr = members[1]
|
||||
harness.check(attr.identifier.QName(), "::TestEnumInterface::foo",
|
||||
"Attr has correct QName")
|
||||
harness.check(
|
||||
attr.identifier.QName(), "::TestEnumInterface::foo", "Attr has correct QName"
|
||||
)
|
||||
harness.check(attr.identifier.name, "foo", "Attr has correct name")
|
||||
|
||||
harness.check(str(attr.type), "TestEnum (Wrapper)", "Attr type is the correct name")
|
||||
|
@ -64,7 +74,8 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
enum Enum {
|
||||
"a",
|
||||
"b",
|
||||
|
@ -73,7 +84,8 @@ def WebIDLTest(parser, harness):
|
|||
interface TestInterface {
|
||||
undefined foo(optional Enum e = "d");
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -82,12 +94,14 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
# Now reset our parser
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
enum Enum {
|
||||
"a",
|
||||
"b",
|
||||
"c",
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should allow trailing comma in enum")
|
||||
|
|
|
@ -1,13 +1,16 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
enum TestEnumDuplicateValue {
|
||||
"",
|
||||
""
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
harness.ok(False, "Should have thrown!")
|
||||
except:
|
||||
harness.ok(True, "Enum TestEnumDuplicateValue should throw")
|
||||
|
|
|
@ -1,20 +1,24 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
# Check that error messages put the '^' in the right place.
|
||||
|
||||
threw = False
|
||||
input = 'interface ?'
|
||||
input = "interface ?"
|
||||
try:
|
||||
parser.parse(input)
|
||||
results = parser.finish()
|
||||
except WebIDL.WebIDLError as e:
|
||||
threw = True
|
||||
lines = str(e).split('\n')
|
||||
lines = str(e).split("\n")
|
||||
|
||||
harness.check(len(lines), 3, 'Expected number of lines in error message')
|
||||
harness.check(lines[1], input, 'Second line shows error')
|
||||
harness.check(lines[2], ' ' * (len(input) - 1) + '^',
|
||||
'Correct column pointer in error message')
|
||||
harness.check(len(lines), 3, "Expected number of lines in error message")
|
||||
harness.check(lines[1], input, "Second line shows error")
|
||||
harness.check(
|
||||
lines[2],
|
||||
" " * (len(input) - 1) + "^",
|
||||
"Correct column pointer in error message",
|
||||
)
|
||||
|
||||
harness.ok(threw, "Should have thrown.")
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
# Check that error messages put the '^' in the right place.
|
||||
|
||||
|
@ -16,13 +17,22 @@ interface ?"""
|
|||
results = parser.finish()
|
||||
except WebIDL.WebIDLError as e:
|
||||
threw = True
|
||||
lines = str(e).split('\n')
|
||||
lines = str(e).split("\n")
|
||||
|
||||
harness.check(len(lines), 3, 'Expected number of lines in error message')
|
||||
harness.ok(lines[0].endswith('line 6:10'), 'First line of error should end with "line 6:10", but was "%s".' % lines[0])
|
||||
harness.check(lines[1], 'interface ?', 'Second line of error message is the line which caused the error.')
|
||||
harness.check(lines[2], ' ' * (len('interface ?') - 1) + '^',
|
||||
'Correct column pointer in error message.')
|
||||
harness.check(len(lines), 3, "Expected number of lines in error message")
|
||||
harness.ok(
|
||||
lines[0].endswith("line 6:10"),
|
||||
'First line of error should end with "line 6:10", but was "%s".' % lines[0],
|
||||
)
|
||||
harness.check(
|
||||
lines[1],
|
||||
"interface ?",
|
||||
"Second line of error message is the line which caused the error.",
|
||||
)
|
||||
harness.check(
|
||||
lines[2],
|
||||
" " * (len("interface ?") - 1) + "^",
|
||||
"Correct column pointer in error message.",
|
||||
)
|
||||
|
||||
harness.ok(threw, "Should have thrown.")
|
||||
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global=(Bar, Bar1,Bar2), Exposed=Bar] interface Bar {};
|
||||
[Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
|
||||
|
@ -18,39 +20,56 @@ def WebIDLTest(parser, harness):
|
|||
partial interface Iface {
|
||||
undefined method2();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(len(results), 5, "Should know about five things");
|
||||
harness.check(len(results), 5, "Should know about five things")
|
||||
iface = results[3]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should have an interface here");
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should have an interface here")
|
||||
members = iface.members
|
||||
harness.check(len(members), 3, "Should have three members")
|
||||
|
||||
harness.ok(members[0].exposureSet == set(["Foo", "Bar"]),
|
||||
"method1 should have the right exposure set")
|
||||
harness.ok(members[0]._exposureGlobalNames == set(["Foo", "Bar1"]),
|
||||
"method1 should have the right exposure global names")
|
||||
harness.ok(
|
||||
members[0].exposureSet == set(["Foo", "Bar"]),
|
||||
"method1 should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[0]._exposureGlobalNames == set(["Foo", "Bar1"]),
|
||||
"method1 should have the right exposure global names",
|
||||
)
|
||||
|
||||
harness.ok(members[1].exposureSet == set(["Bar"]),
|
||||
"attr should have the right exposure set")
|
||||
harness.ok(members[1]._exposureGlobalNames == set(["Bar1"]),
|
||||
"attr should have the right exposure global names")
|
||||
harness.ok(
|
||||
members[1].exposureSet == set(["Bar"]),
|
||||
"attr should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[1]._exposureGlobalNames == set(["Bar1"]),
|
||||
"attr should have the right exposure global names",
|
||||
)
|
||||
|
||||
harness.ok(members[2].exposureSet == set(["Foo"]),
|
||||
"method2 should have the right exposure set")
|
||||
harness.ok(members[2]._exposureGlobalNames == set(["Foo"]),
|
||||
"method2 should have the right exposure global names")
|
||||
harness.ok(
|
||||
members[2].exposureSet == set(["Foo"]),
|
||||
"method2 should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[2]._exposureGlobalNames == set(["Foo"]),
|
||||
"method2 should have the right exposure global names",
|
||||
)
|
||||
|
||||
harness.ok(iface.exposureSet == set(["Foo", "Bar"]),
|
||||
"Iface should have the right exposure set")
|
||||
harness.ok(iface._exposureGlobalNames == set(["Foo", "Bar1"]),
|
||||
"Iface should have the right exposure global names")
|
||||
harness.ok(
|
||||
iface.exposureSet == set(["Foo", "Bar"]),
|
||||
"Iface should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
iface._exposureGlobalNames == set(["Foo", "Bar1"]),
|
||||
"Iface should have the right exposure global names",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global=(Bar, Bar1, Bar2), Exposed=Bar] interface Bar {};
|
||||
[Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
|
||||
|
@ -59,28 +78,36 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface2 {
|
||||
undefined method3();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(len(results), 4, "Should know about four things");
|
||||
harness.check(len(results), 4, "Should know about four things")
|
||||
iface = results[3]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should have an interface here");
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should have an interface here")
|
||||
members = iface.members
|
||||
harness.check(len(members), 1, "Should have one member")
|
||||
|
||||
harness.ok(members[0].exposureSet == set(["Foo"]),
|
||||
"method3 should have the right exposure set")
|
||||
harness.ok(members[0]._exposureGlobalNames == set(["Foo"]),
|
||||
"method3 should have the right exposure global names")
|
||||
harness.ok(
|
||||
members[0].exposureSet == set(["Foo"]),
|
||||
"method3 should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[0]._exposureGlobalNames == set(["Foo"]),
|
||||
"method3 should have the right exposure global names",
|
||||
)
|
||||
|
||||
harness.ok(iface.exposureSet == set(["Foo"]),
|
||||
"Iface2 should have the right exposure set")
|
||||
harness.ok(iface._exposureGlobalNames == set(["Foo"]),
|
||||
"Iface2 should have the right exposure global names")
|
||||
harness.ok(
|
||||
iface.exposureSet == set(["Foo"]), "Iface2 should have the right exposure set"
|
||||
)
|
||||
harness.ok(
|
||||
iface._exposureGlobalNames == set(["Foo"]),
|
||||
"Iface2 should have the right exposure global names",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global=(Bar, Bar1, Bar2), Exposed=Bar] interface Bar {};
|
||||
[Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
|
||||
|
@ -96,33 +123,43 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
|
||||
Iface3 includes Mixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 6, "Should know about six things");
|
||||
harness.check(len(results), 6, "Should know about six things")
|
||||
iface = results[3]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should have an interface here");
|
||||
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"]),
|
||||
"method4 should have the right exposure set")
|
||||
harness.ok(members[0]._exposureGlobalNames == set(["Foo"]),
|
||||
"method4 should have the right exposure global names")
|
||||
harness.ok(
|
||||
members[0].exposureSet == set(["Foo"]),
|
||||
"method4 should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[0]._exposureGlobalNames == set(["Foo"]),
|
||||
"method4 should have the right exposure global names",
|
||||
)
|
||||
|
||||
harness.ok(members[1].exposureSet == set(["Foo", "Bar"]),
|
||||
"method5 should have the right exposure set")
|
||||
harness.ok(members[1]._exposureGlobalNames == set(["Foo", "Bar1"]),
|
||||
"method5 should have the right exposure global names")
|
||||
harness.ok(
|
||||
members[1].exposureSet == set(["Foo", "Bar"]),
|
||||
"method5 should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[1]._exposureGlobalNames == set(["Foo", "Bar1"]),
|
||||
"method5 should have the right exposure global names",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Exposed=Foo]
|
||||
interface Bar {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -133,12 +170,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Bar {
|
||||
[Exposed=Foo]
|
||||
readonly attribute bool attr;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -149,12 +188,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Bar {
|
||||
[Exposed=Foo]
|
||||
undefined operation();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -165,12 +206,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Bar {
|
||||
[Exposed=Foo]
|
||||
const long constant = 5;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -181,7 +224,8 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global, Exposed=Bar] interface Bar {};
|
||||
|
||||
|
@ -190,16 +234,20 @@ def WebIDLTest(parser, harness):
|
|||
[Exposed=Bar]
|
||||
undefined method();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown on member exposed where its interface is not.")
|
||||
harness.ok(
|
||||
threw, "Should have thrown on member exposed where its interface is not."
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global, Exposed=Bar] interface Bar {};
|
||||
|
||||
|
@ -214,25 +262,122 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
|
||||
Baz includes Mixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(len(results), 5, "Should know about five things");
|
||||
harness.check(len(results), 5, "Should know about five things")
|
||||
iface = results[2]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should have an interface here");
|
||||
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[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")
|
||||
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",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global, Exposed=Bar] interface Bar {};
|
||||
|
||||
[Exposed=*]
|
||||
interface Baz {
|
||||
undefined methodWild();
|
||||
};
|
||||
|
||||
[Exposed=Bar]
|
||||
interface mixin Mixin {
|
||||
undefined methodNotWild();
|
||||
};
|
||||
|
||||
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", "Bar"]),
|
||||
"methodWild should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[0]._exposureGlobalNames == set(["Foo", "Bar"]),
|
||||
"methodWild should have the right exposure global names",
|
||||
)
|
||||
|
||||
harness.ok(
|
||||
members[1].exposureSet == set(["Bar"]),
|
||||
"methodNotWild should have the right exposure set",
|
||||
)
|
||||
harness.ok(
|
||||
members[1]._exposureGlobalNames == set(["Bar"]),
|
||||
"methodNotWild should have the right exposure global names",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global, Exposed=Bar] interface Bar {};
|
||||
|
||||
[Exposed=Foo]
|
||||
interface Baz {
|
||||
[Exposed=*]
|
||||
undefined method();
|
||||
};
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw, "Should have thrown on member exposed where its interface is not."
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo] interface Foo {};
|
||||
[Global, Exposed=Bar] interface Bar {};
|
||||
|
||||
[Exposed=(Foo,*)]
|
||||
interface Baz {
|
||||
undefined method();
|
||||
};
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown on a wildcard in an identifier list.")
|
||||
|
|
|
@ -1,74 +1,91 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
[NoInterfaceObject]
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyNoInterfaceObject]
|
||||
interface TestExtendedAttr {
|
||||
[Unforgeable] readonly attribute byte b;
|
||||
[LegacyUnforgeable] readonly attribute byte b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Pref="foo.bar",Pref=flop]
|
||||
interface TestExtendedAttr {
|
||||
[Pref="foo.bar"] attribute byte b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
interface TestLenientThis {
|
||||
[LenientThis] attribute byte b;
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestLegacyLenientThis {
|
||||
[LegacyLenientThis] attribute byte b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.ok(results[0].members[0].hasLenientThis(),
|
||||
"Should have a lenient this")
|
||||
harness.ok(
|
||||
results[0].members[0].hasLegacyLenientThis(), "Should have a lenient this"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface TestLenientThis2 {
|
||||
[LenientThis=something] attribute byte b;
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestLegacyLenientThis2 {
|
||||
[LegacyLenientThis=something] attribute byte b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "[LenientThis] must take no arguments")
|
||||
harness.ok(threw, "[LegacyLenientThis] must take no arguments")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestClamp {
|
||||
undefined testClamp([Clamp] long foo);
|
||||
undefined testNotClamp(long foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
# Pull out the first argument out of the arglist of the first (and
|
||||
# only) signature.
|
||||
harness.ok(results[0].members[0].signatures()[0][1][0].type.hasClamp(),
|
||||
"Should be clamped")
|
||||
harness.ok(not results[0].members[1].signatures()[0][1][0].type.hasClamp(),
|
||||
"Should not be clamped")
|
||||
harness.ok(
|
||||
results[0].members[0].signatures()[0][1][0].type.hasClamp(), "Should be clamped"
|
||||
)
|
||||
harness.ok(
|
||||
not results[0].members[1].signatures()[0][1][0].type.hasClamp(),
|
||||
"Should not be clamped",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestClamp2 {
|
||||
undefined testClamp([Clamp=something] long foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -76,32 +93,39 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(threw, "[Clamp] must take no arguments")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestEnforceRange {
|
||||
undefined testEnforceRange([EnforceRange] long foo);
|
||||
undefined testNotEnforceRange(long foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
# Pull out the first argument out of the arglist of the first (and
|
||||
# only) signature.
|
||||
harness.ok(results[0].members[0].signatures()[0][1][0].type.hasEnforceRange(),
|
||||
"Should be enforceRange")
|
||||
harness.ok(not results[0].members[1].signatures()[0][1][0].type.hasEnforceRange(),
|
||||
"Should not be enforceRange")
|
||||
harness.ok(
|
||||
results[0].members[0].signatures()[0][1][0].type.hasEnforceRange(),
|
||||
"Should be enforceRange",
|
||||
)
|
||||
harness.ok(
|
||||
not results[0].members[1].signatures()[0][1][0].type.hasEnforceRange(),
|
||||
"Should not be enforceRange",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestEnforceRange2 {
|
||||
undefined testEnforceRange([EnforceRange=something] long foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "[EnforceRange] must take no arguments")
|
||||
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef float myFloat;
|
||||
typedef unrestricted float myUnrestrictedFloat;
|
||||
interface FloatTypes {
|
||||
|
@ -15,14 +17,14 @@ def WebIDLTest(parser, harness):
|
|||
attribute double ld;
|
||||
|
||||
undefined m1(float arg1, double arg2, float? arg3, double? arg4,
|
||||
myFloat arg5, unrestricted float arg6,
|
||||
unrestricted double arg7, unrestricted float? arg8,
|
||||
unrestricted double? arg9, myUnrestrictedFloat arg10);
|
||||
myFloat arg5, unrestricted float arg6,
|
||||
unrestricted double arg7, unrestricted float? arg8,
|
||||
unrestricted double? arg9, myUnrestrictedFloat arg10);
|
||||
[LenientFloat]
|
||||
undefined m2(float arg1, double arg2, float? arg3, double? arg4,
|
||||
myFloat arg5, unrestricted float arg6,
|
||||
unrestricted double arg7, unrestricted float? arg8,
|
||||
unrestricted double? arg9, myUnrestrictedFloat arg10);
|
||||
myFloat arg5, unrestricted float arg6,
|
||||
unrestricted double arg7, unrestricted float? arg8,
|
||||
unrestricted double? arg9, myUnrestrictedFloat arg10);
|
||||
[LenientFloat]
|
||||
undefined m3(float arg);
|
||||
[LenientFloat]
|
||||
|
@ -32,14 +34,14 @@ def WebIDLTest(parser, harness):
|
|||
[LenientFloat]
|
||||
undefined m6(sequence<float> arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(len(results), 3, "Should be two typedefs and one interface.")
|
||||
iface = results[2]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
types = [a.type for a in iface.members if a.isAttr()]
|
||||
harness.ok(types[0].isFloat(), "'float' is a float")
|
||||
harness.ok(not types[0].isUnrestricted(), "'float' is not unrestricted")
|
||||
|
@ -55,71 +57,89 @@ def WebIDLTest(parser, harness):
|
|||
argtypes = [a.type for a in method.signatures()[0][1]]
|
||||
for (idx, type) in enumerate(argtypes):
|
||||
harness.ok(type.isFloat(), "Type %d should be float" % idx)
|
||||
harness.check(type.isUnrestricted(), idx >= 5,
|
||||
"Type %d should %sbe unrestricted" % (
|
||||
idx, "" if idx >= 4 else "not "))
|
||||
harness.check(
|
||||
type.isUnrestricted(),
|
||||
idx >= 5,
|
||||
"Type %d should %sbe unrestricted" % (idx, "" if idx >= 4 else "not "),
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface FloatTypes {
|
||||
[LenientFloat]
|
||||
long m(float arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "[LenientFloat] only allowed on undefined-retuning methods")
|
||||
harness.ok(threw, "[LenientFloat] only allowed on methods returning undefined")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface FloatTypes {
|
||||
[LenientFloat]
|
||||
undefined m(unrestricted float arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "[LenientFloat] only allowed on methods with unrestricted float args")
|
||||
harness.ok(
|
||||
threw, "[LenientFloat] only allowed on methods with unrestricted float args"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface FloatTypes {
|
||||
[LenientFloat]
|
||||
undefined m(sequence<unrestricted float> arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "[LenientFloat] only allowed on methods with unrestricted float args (2)")
|
||||
harness.ok(
|
||||
threw, "[LenientFloat] only allowed on methods with unrestricted float args (2)"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface FloatTypes {
|
||||
[LenientFloat]
|
||||
undefined m((unrestricted float or FloatTypes) arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "[LenientFloat] only allowed on methods with unrestricted float args (3)")
|
||||
harness.ok(
|
||||
threw, "[LenientFloat] only allowed on methods with unrestricted float args (3)"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface FloatTypes {
|
||||
[LenientFloat]
|
||||
readonly attribute float foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "[LenientFloat] only allowed on writable attributes")
|
||||
|
|
|
@ -1,14 +1,17 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface ForwardDeclared;
|
||||
interface ForwardDeclared;
|
||||
|
||||
interface TestForwardDecl {
|
||||
attribute ForwardDeclared foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
|
|
|
@ -1,106 +1,129 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo : Bar {
|
||||
getter any(DOMString name);
|
||||
};
|
||||
[Exposed=Foo]
|
||||
interface Bar {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(results[0].isOnGlobalProtoChain(),
|
||||
"[Global] interface should be on global's proto chain")
|
||||
harness.ok(results[1].isOnGlobalProtoChain(),
|
||||
"[Global] interface should be on global's proto chain")
|
||||
harness.ok(
|
||||
results[0].isOnGlobalProtoChain(),
|
||||
"[Global] interface should be on global's proto chain",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].isOnGlobalProtoChain(),
|
||||
"[Global] interface should be on global's proto chain",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo {
|
||||
getter any(DOMString name);
|
||||
setter undefined(DOMString name, any arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [Global] used on an interface with a "
|
||||
"named setter")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown for [Global] used on an interface with a " "named setter",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo {
|
||||
getter any(DOMString name);
|
||||
deleter undefined(DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [Global] used on an interface with a "
|
||||
"named deleter")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown for [Global] used on an interface with a " "named deleter",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[Global, OverrideBuiltins, Exposed=Foo]
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, LegacyOverrideBuiltIns, Exposed=Foo]
|
||||
interface Foo {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [Global] used on an interface with a "
|
||||
"[OverrideBuiltins]")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown for [Global] used on an interface with a "
|
||||
"[LegacyOverrideBuiltIns]",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo : Bar {
|
||||
};
|
||||
[OverrideBuiltins, Exposed=Foo]
|
||||
[LegacyOverrideBuiltIns, Exposed=Foo]
|
||||
interface Bar {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [Global] used on an interface with an "
|
||||
"[OverrideBuiltins] ancestor")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown for [Global] used on an interface with an "
|
||||
"[LegacyOverrideBuiltIns] ancestor",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Foo]
|
||||
interface Foo {
|
||||
};
|
||||
[Exposed=Foo]
|
||||
interface Bar : Foo {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown for [Global] used on an interface with a "
|
||||
"descendant")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown for [Global] used on an interface with a " "descendant",
|
||||
)
|
||||
|
|
|
@ -1,39 +1,49 @@
|
|||
# Import the WebIDL module, so we can do isinstance checks and whatnot
|
||||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
enum Foo { "a" };
|
||||
interface Foo;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(False, "Should fail to parse")
|
||||
except Exception as e:
|
||||
harness.ok("Name collision" in e.message,
|
||||
"Should have name collision for interface")
|
||||
harness.ok(
|
||||
"Name collision" in str(e), "Should have name collision for interface"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Foo { long x; };
|
||||
enum Foo { "a" };
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(False, "Should fail to parse")
|
||||
except Exception as e:
|
||||
harness.ok("Name collision" in e.message,
|
||||
"Should have name collision for dictionary")
|
||||
harness.ok(
|
||||
"Name collision" in str(e), "Should have name collision for dictionary"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
enum Foo { "a" };
|
||||
enum Foo { "b" };
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(False, "Should fail to parse")
|
||||
except Exception as e:
|
||||
harness.ok("Multiple unresolvable definitions" in e.message,
|
||||
"Should have name collision for dictionary")
|
||||
|
||||
harness.ok(
|
||||
"Multiple unresolvable definitions" in str(e),
|
||||
"Should have name collision for dictionary",
|
||||
)
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIncompleteParent : NotYetDefined {
|
||||
undefined foo();
|
||||
};
|
||||
|
@ -11,7 +13,8 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
interface EvenHigherOnTheChain {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
parser.finish()
|
||||
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIncompleteTypes {
|
||||
attribute FooInterface attr1;
|
||||
|
||||
|
@ -10,35 +12,50 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
interface FooInterface {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestIncompleteTypes interface parsed without error.")
|
||||
harness.check(len(results), 2, "Should be two productions.")
|
||||
iface = results[0]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestIncompleteTypes", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "TestIncompleteTypes", "Interface has the right name")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(),
|
||||
"::TestIncompleteTypes",
|
||||
"Interface has the right QName",
|
||||
)
|
||||
harness.check(
|
||||
iface.identifier.name, "TestIncompleteTypes", "Interface has the right name"
|
||||
)
|
||||
harness.check(len(iface.members), 2, "Expect 2 members")
|
||||
|
||||
attr = iface.members[0]
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute),
|
||||
"Should be an IDLAttribute")
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
method = iface.members[1]
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod),
|
||||
"Should be an IDLMethod")
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod), "Should be an IDLMethod")
|
||||
|
||||
harness.check(attr.identifier.QName(), "::TestIncompleteTypes::attr1",
|
||||
"Attribute has the right QName")
|
||||
harness.check(attr.type.name, "FooInterface",
|
||||
"Previously unresolved type has the right name")
|
||||
harness.check(
|
||||
attr.identifier.QName(),
|
||||
"::TestIncompleteTypes::attr1",
|
||||
"Attribute has the right QName",
|
||||
)
|
||||
harness.check(
|
||||
attr.type.name, "FooInterface", "Previously unresolved type has the right name"
|
||||
)
|
||||
|
||||
harness.check(method.identifier.QName(), "::TestIncompleteTypes::method1",
|
||||
"Attribute has the right QName")
|
||||
harness.check(
|
||||
method.identifier.QName(),
|
||||
"::TestIncompleteTypes::method1",
|
||||
"Attribute has the right QName",
|
||||
)
|
||||
(returnType, args) = method.signatures()[0]
|
||||
harness.check(returnType.name, "FooInterface",
|
||||
"Previously unresolved type has the right name")
|
||||
harness.check(args[0].type.name, "FooInterface",
|
||||
"Previously unresolved type has the right name")
|
||||
harness.check(
|
||||
returnType.name, "FooInterface", "Previously unresolved type has the right name"
|
||||
)
|
||||
harness.check(
|
||||
args[0].type.name,
|
||||
"FooInterface",
|
||||
"Previously unresolved type has the right name",
|
||||
)
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("interface Foo { };")
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Empty interface parsed without error.")
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
iface = results[0]
|
||||
harness.check(iface.identifier.QName(), "::Foo", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "Foo", "Interface has the right name")
|
||||
|
@ -16,16 +16,15 @@ def WebIDLTest(parser, harness):
|
|||
results = parser.finish()
|
||||
harness.ok(True, "Empty interface parsed without error.")
|
||||
harness.check(len(results), 2, "Should be two productions")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
iface = results[1]
|
||||
harness.check(iface.identifier.QName(), "::Bar", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "Bar", "Interface has the right name")
|
||||
harness.ok(isinstance(iface.parent, WebIDL.IDLInterface),
|
||||
"Interface has a parent")
|
||||
harness.ok(isinstance(iface.parent, WebIDL.IDLInterface), "Interface has a parent")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface QNameBase {
|
||||
attribute long foo;
|
||||
};
|
||||
|
@ -34,32 +33,42 @@ def WebIDLTest(parser, harness):
|
|||
attribute long long foo;
|
||||
attribute byte bar;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2, "Should be two productions")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(results[1].parent, results[0], "Inheritance chain is right")
|
||||
harness.check(len(results[0].members), 1, "Expect 1 productions")
|
||||
harness.check(len(results[1].members), 2, "Expect 2 productions")
|
||||
base = results[0]
|
||||
derived = results[1]
|
||||
harness.check(base.members[0].identifier.QName(), "::QNameBase::foo",
|
||||
"Member has the right QName")
|
||||
harness.check(derived.members[0].identifier.QName(), "::QNameDerived::foo",
|
||||
"Member has the right QName")
|
||||
harness.check(derived.members[1].identifier.QName(), "::QNameDerived::bar",
|
||||
"Member has the right QName")
|
||||
harness.check(
|
||||
base.members[0].identifier.QName(),
|
||||
"::QNameBase::foo",
|
||||
"Member has the right QName",
|
||||
)
|
||||
harness.check(
|
||||
derived.members[0].identifier.QName(),
|
||||
"::QNameDerived::foo",
|
||||
"Member has the right QName",
|
||||
)
|
||||
harness.check(
|
||||
derived.members[1].identifier.QName(),
|
||||
"::QNameDerived::bar",
|
||||
"Member has the right QName",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A : B {};
|
||||
interface B : A {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -69,32 +78,42 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A : C {};
|
||||
interface C : B {};
|
||||
interface B : A {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow indirect cycles in interface inheritance chains")
|
||||
harness.ok(
|
||||
threw, "Should not allow indirect cycles in interface inheritance chains"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A;
|
||||
interface B : A {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should not allow inheriting from an interface that is only forward declared")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow inheriting from an interface that is only forward declared",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
constructor();
|
||||
constructor(long arg);
|
||||
|
@ -105,26 +124,43 @@ def WebIDLTest(parser, harness):
|
|||
readonly attribute boolean y;
|
||||
undefined foo(long arg);
|
||||
};
|
||||
""");
|
||||
results = parser.finish();
|
||||
harness.check(len(results), 2,
|
||||
"Should have two results with partial interface")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2, "Should have two results with partial interface")
|
||||
iface = results[0]
|
||||
harness.check(len(iface.members), 3,
|
||||
"Should have three members with partial interface")
|
||||
harness.check(iface.members[0].identifier.name, "x",
|
||||
"First member should be x with partial interface")
|
||||
harness.check(iface.members[1].identifier.name, "foo",
|
||||
"Second member should be foo with partial interface")
|
||||
harness.check(len(iface.members[1].signatures()), 2,
|
||||
"Should have two foo signatures with partial interface")
|
||||
harness.check(iface.members[2].identifier.name, "y",
|
||||
"Third member should be y with partial interface")
|
||||
harness.check(len(iface.ctor().signatures()), 2,
|
||||
"Should have two constructors with partial interface")
|
||||
harness.check(
|
||||
len(iface.members), 3, "Should have three members with partial interface"
|
||||
)
|
||||
harness.check(
|
||||
iface.members[0].identifier.name,
|
||||
"x",
|
||||
"First member should be x with partial interface",
|
||||
)
|
||||
harness.check(
|
||||
iface.members[1].identifier.name,
|
||||
"foo",
|
||||
"Second member should be foo with partial interface",
|
||||
)
|
||||
harness.check(
|
||||
len(iface.members[1].signatures()),
|
||||
2,
|
||||
"Should have two foo signatures with partial interface",
|
||||
)
|
||||
harness.check(
|
||||
iface.members[2].identifier.name,
|
||||
"y",
|
||||
"Third member should be y with partial interface",
|
||||
)
|
||||
harness.check(
|
||||
len(iface.ctor().signatures()),
|
||||
2,
|
||||
"Should have two constructors with partial interface",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
partial interface A {
|
||||
readonly attribute boolean y;
|
||||
undefined foo(long arg);
|
||||
|
@ -135,236 +171,289 @@ def WebIDLTest(parser, harness):
|
|||
readonly attribute boolean x;
|
||||
undefined foo();
|
||||
};
|
||||
""");
|
||||
results = parser.finish();
|
||||
harness.check(len(results), 2,
|
||||
"Should have two results with reversed partial interface")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(
|
||||
len(results), 2, "Should have two results with reversed partial interface"
|
||||
)
|
||||
iface = results[1]
|
||||
harness.check(len(iface.members), 3,
|
||||
"Should have three members with reversed partial interface")
|
||||
harness.check(iface.members[0].identifier.name, "x",
|
||||
"First member should be x with reversed partial interface")
|
||||
harness.check(iface.members[1].identifier.name, "foo",
|
||||
"Second member should be foo with reversed partial interface")
|
||||
harness.check(len(iface.members[1].signatures()), 2,
|
||||
"Should have two foo signatures with reversed partial interface")
|
||||
harness.check(iface.members[2].identifier.name, "y",
|
||||
"Third member should be y with reversed partial interface")
|
||||
harness.check(len(iface.ctor().signatures()), 2,
|
||||
"Should have two constructors with reversed partial interface")
|
||||
harness.check(
|
||||
len(iface.members),
|
||||
3,
|
||||
"Should have three members with reversed partial interface",
|
||||
)
|
||||
harness.check(
|
||||
iface.members[0].identifier.name,
|
||||
"x",
|
||||
"First member should be x with reversed partial interface",
|
||||
)
|
||||
harness.check(
|
||||
iface.members[1].identifier.name,
|
||||
"foo",
|
||||
"Second member should be foo with reversed partial interface",
|
||||
)
|
||||
harness.check(
|
||||
len(iface.members[1].signatures()),
|
||||
2,
|
||||
"Should have two foo signatures with reversed partial interface",
|
||||
)
|
||||
harness.check(
|
||||
iface.members[2].identifier.name,
|
||||
"y",
|
||||
"Third member should be y with reversed partial interface",
|
||||
)
|
||||
harness.check(
|
||||
len(iface.ctor().signatures()),
|
||||
2,
|
||||
"Should have two constructors with reversed partial interface",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
readonly attribute boolean x;
|
||||
};
|
||||
interface A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow two non-partial interfaces with the same name")
|
||||
harness.ok(threw, "Should not allow two non-partial interfaces with the same name")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
partial interface A {
|
||||
readonly attribute boolean x;
|
||||
};
|
||||
partial interface A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Must have a non-partial interface for a given name")
|
||||
harness.ok(threw, "Must have a non-partial interface for a given name")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
boolean x;
|
||||
};
|
||||
partial interface A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow a name collision between partial interface "
|
||||
"and other object")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow a name collision between partial interface "
|
||||
"and other object",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
boolean x;
|
||||
};
|
||||
interface A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow a name collision between interface "
|
||||
"and other object")
|
||||
harness.ok(
|
||||
threw, "Should not allow a name collision between interface " "and other object"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
boolean x;
|
||||
};
|
||||
interface A;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow a name collision between external interface "
|
||||
"and other object")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow a name collision between external interface "
|
||||
"and other object",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
readonly attribute boolean x;
|
||||
};
|
||||
interface A;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow a name collision between external interface "
|
||||
"and interface")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow a name collision between external interface " "and interface",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A;
|
||||
interface A;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(len(results) == 1 and
|
||||
isinstance(results[0], WebIDL.IDLExternalInterface),
|
||||
"Should allow name collisions between external interface "
|
||||
"declarations")
|
||||
harness.ok(
|
||||
len(results) == 1 and isinstance(results[0], WebIDL.IDLExternalInterface),
|
||||
"Should allow name collisions between external interface " "declarations",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SomeRandomAnnotation]
|
||||
interface A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow unknown extended attributes on interfaces")
|
||||
harness.ok(threw, "Should not allow unknown extended attributes on interfaces")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
[Exposed=Window, LegacyWindowAlias=(C, D)]
|
||||
interface E {};
|
||||
""");
|
||||
results = parser.finish();
|
||||
harness.check(results[1].legacyWindowAliases, ["A"],
|
||||
"Should support a single identifier")
|
||||
harness.check(results[2].legacyWindowAliases, ["C", "D"],
|
||||
"Should support an identifier list")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(
|
||||
results[1].legacyWindowAliases, ["A"], "Should support a single identifier"
|
||||
)
|
||||
harness.check(
|
||||
results[2].legacyWindowAliases, ["C", "D"], "Should support an identifier list"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyWindowAlias]
|
||||
interface A {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [LegacyWindowAlias] with no value")
|
||||
harness.ok(threw, "Should not allow [LegacyWindowAlias] with no value")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Exposed=Worker, LegacyWindowAlias=B]
|
||||
interface A {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [LegacyWindowAlias] without Window exposure")
|
||||
harness.ok(threw, "Should not allow [LegacyWindowAlias] without Window exposure")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window]
|
||||
interface A {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [LegacyWindowAlias] to conflict with other identifiers")
|
||||
harness.ok(
|
||||
threw, "Should not allow [LegacyWindowAlias] to conflict with other identifiers"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
[Exposed=Window]
|
||||
interface A {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [LegacyWindowAlias] to conflict with other identifiers")
|
||||
harness.ok(
|
||||
threw, "Should not allow [LegacyWindowAlias] to conflict with other identifiers"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface B {};
|
||||
[Exposed=Window, LegacyWindowAlias=A]
|
||||
interface C {};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [LegacyWindowAlias] to conflict with other identifiers")
|
||||
harness.ok(
|
||||
threw, "Should not allow [LegacyWindowAlias] to conflict with other identifiers"
|
||||
)
|
||||
|
|
|
@ -1,12 +1,14 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface IdentifierConflict {
|
||||
const byte thing1 = 1;
|
||||
const unsigned long thing1 = 1;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,12 +1,14 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface IdentifierConflictAcrossMembers1 {
|
||||
const byte thing1 = 1;
|
||||
readonly attribute long thing1;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -16,12 +18,14 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface IdentifierConflictAcrossMembers2 {
|
||||
readonly attribute long thing1;
|
||||
const byte thing1 = 1;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -31,12 +35,14 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface IdentifierConflictAcrossMembers3 {
|
||||
getter boolean thing1(DOMString name);
|
||||
readonly attribute long thing1;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -46,12 +52,14 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface IdentifierConflictAcrossMembers1 {
|
||||
const byte thing1 = 1;
|
||||
long thing1();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -1,33 +1,46 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("interface mixin Foo { };")
|
||||
results = parser.finish()
|
||||
harness.ok(True, "Empty interface mixin parsed without error.")
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterfaceMixin),
|
||||
"Should be an IDLInterfaceMixin")
|
||||
harness.ok(
|
||||
isinstance(results[0], WebIDL.IDLInterfaceMixin),
|
||||
"Should be an IDLInterfaceMixin",
|
||||
)
|
||||
mixin = results[0]
|
||||
harness.check(mixin.identifier.QName(), "::Foo", "Interface mixin has the right QName")
|
||||
harness.check(
|
||||
mixin.identifier.QName(), "::Foo", "Interface mixin has the right QName"
|
||||
)
|
||||
harness.check(mixin.identifier.name, "Foo", "Interface mixin has the right name")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin QNameBase {
|
||||
const long foo = 3;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should be one productions")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterfaceMixin),
|
||||
"Should be an IDLInterfaceMixin")
|
||||
harness.ok(
|
||||
isinstance(results[0], WebIDL.IDLInterfaceMixin),
|
||||
"Should be an IDLInterfaceMixin",
|
||||
)
|
||||
harness.check(len(results[0].members), 1, "Expect 1 productions")
|
||||
mixin = results[0]
|
||||
harness.check(mixin.members[0].identifier.QName(), "::QNameBase::foo",
|
||||
"Member has the right QName")
|
||||
harness.check(
|
||||
mixin.members[0].identifier.QName(),
|
||||
"::QNameBase::foo",
|
||||
"Member has the right QName",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
readonly attribute boolean x;
|
||||
undefined foo();
|
||||
|
@ -36,24 +49,40 @@ def WebIDLTest(parser, harness):
|
|||
readonly attribute boolean y;
|
||||
undefined foo(long arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2,
|
||||
"Should have two results with partial interface mixin")
|
||||
harness.check(
|
||||
len(results), 2, "Should have two results with partial interface mixin"
|
||||
)
|
||||
mixin = results[0]
|
||||
harness.check(len(mixin.members), 3,
|
||||
"Should have three members with partial interface mixin")
|
||||
harness.check(mixin.members[0].identifier.name, "x",
|
||||
"First member should be x with partial interface mixin")
|
||||
harness.check(mixin.members[1].identifier.name, "foo",
|
||||
"Second member should be foo with partial interface mixin")
|
||||
harness.check(len(mixin.members[1].signatures()), 2,
|
||||
"Should have two foo signatures with partial interface mixin")
|
||||
harness.check(mixin.members[2].identifier.name, "y",
|
||||
"Third member should be y with partial interface mixin")
|
||||
harness.check(
|
||||
len(mixin.members), 3, "Should have three members with partial interface mixin"
|
||||
)
|
||||
harness.check(
|
||||
mixin.members[0].identifier.name,
|
||||
"x",
|
||||
"First member should be x with partial interface mixin",
|
||||
)
|
||||
harness.check(
|
||||
mixin.members[1].identifier.name,
|
||||
"foo",
|
||||
"Second member should be foo with partial interface mixin",
|
||||
)
|
||||
harness.check(
|
||||
len(mixin.members[1].signatures()),
|
||||
2,
|
||||
"Should have two foo signatures with partial interface mixin",
|
||||
)
|
||||
harness.check(
|
||||
mixin.members[2].identifier.name,
|
||||
"y",
|
||||
"Third member should be y with partial interface mixin",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
partial interface mixin A {
|
||||
readonly attribute boolean y;
|
||||
undefined foo(long arg);
|
||||
|
@ -62,285 +91,334 @@ def WebIDLTest(parser, harness):
|
|||
readonly attribute boolean x;
|
||||
undefined foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2,
|
||||
"Should have two results with reversed partial interface mixin")
|
||||
harness.check(
|
||||
len(results), 2, "Should have two results with reversed partial interface mixin"
|
||||
)
|
||||
mixin = results[1]
|
||||
harness.check(len(mixin.members), 3,
|
||||
"Should have three members with reversed partial interface mixin")
|
||||
harness.check(mixin.members[0].identifier.name, "x",
|
||||
"First member should be x with reversed partial interface mixin")
|
||||
harness.check(mixin.members[1].identifier.name, "foo",
|
||||
"Second member should be foo with reversed partial interface mixin")
|
||||
harness.check(len(mixin.members[1].signatures()), 2,
|
||||
"Should have two foo signatures with reversed partial interface mixin")
|
||||
harness.check(mixin.members[2].identifier.name, "y",
|
||||
"Third member should be y with reversed partial interface mixin")
|
||||
harness.check(
|
||||
len(mixin.members),
|
||||
3,
|
||||
"Should have three members with reversed partial interface mixin",
|
||||
)
|
||||
harness.check(
|
||||
mixin.members[0].identifier.name,
|
||||
"x",
|
||||
"First member should be x with reversed partial interface mixin",
|
||||
)
|
||||
harness.check(
|
||||
mixin.members[1].identifier.name,
|
||||
"foo",
|
||||
"Second member should be foo with reversed partial interface mixin",
|
||||
)
|
||||
harness.check(
|
||||
len(mixin.members[1].signatures()),
|
||||
2,
|
||||
"Should have two foo signatures with reversed partial interface mixin",
|
||||
)
|
||||
harness.check(
|
||||
mixin.members[2].identifier.name,
|
||||
"y",
|
||||
"Third member should be y with reversed partial interface mixin",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Interface {};
|
||||
interface mixin Mixin {
|
||||
attribute short x;
|
||||
};
|
||||
Interface includes Mixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
iface = results[0]
|
||||
harness.check(len(iface.members), 1, "Should merge members from mixins")
|
||||
harness.check(iface.members[0].identifier.name, "x",
|
||||
"Should merge members from mixins")
|
||||
harness.check(
|
||||
iface.members[0].identifier.name, "x", "Should merge members from mixins"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
readonly attribute boolean x;
|
||||
};
|
||||
interface mixin A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow two non-partial interface mixins with the same name")
|
||||
harness.ok(
|
||||
threw, "Should not allow two non-partial interface mixins with the same name"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
partial interface mixin A {
|
||||
readonly attribute boolean x;
|
||||
};
|
||||
partial interface mixin A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Must have a non-partial interface mixin for a given name")
|
||||
harness.ok(threw, "Must have a non-partial interface mixin for a given name")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
boolean x;
|
||||
};
|
||||
partial interface mixin A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow a name collision between partial interface "
|
||||
"mixin and other object")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow a name collision between partial interface "
|
||||
"mixin and other object",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary A {
|
||||
boolean x;
|
||||
};
|
||||
interface mixin A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow a name collision between interface mixin "
|
||||
"and other object")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow a name collision between interface mixin " "and other object",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
readonly attribute boolean x;
|
||||
};
|
||||
interface A;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow a name collision between external interface "
|
||||
"and interface mixin")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow a name collision between external interface "
|
||||
"and interface mixin",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SomeRandomAnnotation]
|
||||
interface mixin A {
|
||||
readonly attribute boolean y;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow unknown extended attributes on interface mixins")
|
||||
harness.ok(
|
||||
threw, "Should not allow unknown extended attributes on interface mixins"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
getter double (DOMString propertyName);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow getters on interface mixins")
|
||||
harness.ok(threw, "Should not allow getters on interface mixins")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
setter undefined (DOMString propertyName, double propertyValue);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow setters on interface mixins")
|
||||
harness.ok(threw, "Should not allow setters on interface mixins")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
deleter undefined (DOMString propertyName);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow deleters on interface mixins")
|
||||
harness.ok(threw, "Should not allow deleters on interface mixins")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
legacycaller double compute(double x);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow legacycallers on interface mixins")
|
||||
harness.ok(threw, "Should not allow legacycallers on interface mixins")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin A {
|
||||
inherit attribute x;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow inherited attribute on interface mixins")
|
||||
harness.ok(threw, "Should not allow inherited attribute on interface mixins")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Interface {};
|
||||
interface NotMixin {
|
||||
attribute short x;
|
||||
};
|
||||
Interface includes NotMixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should fail if the right side does not point an interface mixin")
|
||||
harness.ok(threw, "Should fail if the right side does not point an interface mixin")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin NotInterface {};
|
||||
interface mixin Mixin {
|
||||
attribute short x;
|
||||
};
|
||||
NotInterface includes Mixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should fail if the left side does not point an interface")
|
||||
harness.ok(threw, "Should fail if the left side does not point an interface")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin Mixin {
|
||||
iterable<DOMString>;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should fail if an interface mixin includes iterable")
|
||||
harness.ok(threw, "Should fail if an interface mixin includes iterable")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin Mixin {
|
||||
setlike<DOMString>;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should fail if an interface mixin includes setlike")
|
||||
harness.ok(threw, "Should fail if an interface mixin includes setlike")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface mixin Mixin {
|
||||
maplike<DOMString, DOMString>;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should fail if an interface mixin includes maplike")
|
||||
harness.ok(threw, "Should fail if an interface mixin includes maplike")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Interface {
|
||||
attribute short attr;
|
||||
};
|
||||
|
@ -348,17 +426,20 @@ def WebIDLTest(parser, harness):
|
|||
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")
|
||||
harness.ok(
|
||||
threw, "Should fail if the included mixin interface has duplicated member"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Interface {};
|
||||
interface mixin Mixin1 {
|
||||
attribute short attr;
|
||||
|
@ -368,15 +449,18 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
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")
|
||||
harness.ok(
|
||||
threw, "Should fail if the included mixin interfaces have duplicated member"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Global, Exposed=Worker] interface Worker {};
|
||||
[Exposed=Window]
|
||||
|
@ -385,15 +469,20 @@ def WebIDLTest(parser, harness):
|
|||
Base returnSelf();
|
||||
};
|
||||
Base includes Mixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
base = results[2]
|
||||
attr = base.members[0]
|
||||
harness.check(attr.exposureSet, set(["Window"]),
|
||||
"Should expose on globals where the base interfaces are exposed")
|
||||
harness.check(
|
||||
attr.exposureSet,
|
||||
set(["Window"]),
|
||||
"Should expose on globals where the base interfaces are exposed",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Global, Exposed=Worker] interface Worker {};
|
||||
[Exposed=Window]
|
||||
|
@ -403,15 +492,18 @@ def WebIDLTest(parser, harness):
|
|||
attribute short a;
|
||||
};
|
||||
Base includes Mixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
base = results[2]
|
||||
attr = base.members[0]
|
||||
harness.check(attr.exposureSet, set(["Window"]),
|
||||
"Should follow [Exposed] on interface mixin")
|
||||
harness.check(
|
||||
attr.exposureSet, set(["Window"]), "Should follow [Exposed] on interface mixin"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[Global, Exposed=Window] interface Window {};
|
||||
[Global, Exposed=Worker] interface Worker {};
|
||||
[Exposed=Window]
|
||||
|
@ -423,15 +515,20 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
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")
|
||||
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")
|
||||
harness.check(
|
||||
attr.exposureSet,
|
||||
set(["Window", "Worker"]),
|
||||
"Should expose on all globals where including interfaces are " "exposed",
|
||||
)
|
||||
|
|
|
@ -2,8 +2,9 @@
|
|||
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
|
||||
def should_throw(parser, harness, message, code):
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse(code)
|
||||
|
@ -15,44 +16,69 @@ def should_throw(parser, harness, message, code):
|
|||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
# The [LenientSetter] extended attribute MUST take no arguments.
|
||||
should_throw(parser, harness, "no arguments", """
|
||||
# The [LegacyLenientSetter] extended attribute MUST take no arguments.
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"no arguments",
|
||||
"""
|
||||
interface I {
|
||||
[LenientSetter=X] readonly attribute long A;
|
||||
[LegacyLenientSetter=X] readonly attribute long A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# An attribute with the [LenientSetter] extended attribute MUST NOT
|
||||
# An attribute with the [LegacyLenientSetter] extended attribute MUST NOT
|
||||
# also be declared with the [PutForwards] extended attribute.
|
||||
should_throw(parser, harness, "PutForwards", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"PutForwards",
|
||||
"""
|
||||
interface I {
|
||||
[PutForwards=B, LenientSetter] readonly attribute J A;
|
||||
[PutForwards=B, LegacyLenientSetter] readonly attribute J A;
|
||||
};
|
||||
interface J {
|
||||
attribute long B;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# An attribute with the [LenientSetter] extended attribute MUST NOT
|
||||
# An attribute with the [LegacyLenientSetter] extended attribute MUST NOT
|
||||
# also be declared with the [Replaceable] extended attribute.
|
||||
should_throw(parser, harness, "Replaceable", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"Replaceable",
|
||||
"""
|
||||
interface I {
|
||||
[Replaceable, LenientSetter] readonly attribute J A;
|
||||
[Replaceable, LegacyLenientSetter] readonly attribute J A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# The [LenientSetter] extended attribute MUST NOT be used on an
|
||||
# The [LegacyLenientSetter] extended attribute MUST NOT be used on an
|
||||
# attribute that is not read only.
|
||||
should_throw(parser, harness, "writable attribute", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"writable attribute",
|
||||
"""
|
||||
interface I {
|
||||
[LenientSetter] attribute long A;
|
||||
[LegacyLenientSetter] attribute long A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# The [LenientSetter] extended attribute MUST NOT be used on a
|
||||
# The [LegacyLenientSetter] extended attribute MUST NOT be used on a
|
||||
# static attribute.
|
||||
should_throw(parser, harness, "static attribute", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"static attribute",
|
||||
"""
|
||||
interface I {
|
||||
[LenientSetter] static readonly attribute long A;
|
||||
[LegacyLenientSetter] static readonly attribute long A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestMethods {
|
||||
undefined basic();
|
||||
static undefined basicStatic();
|
||||
|
@ -16,35 +18,50 @@ def WebIDLTest(parser, harness):
|
|||
undefined setAny(any arg1);
|
||||
float doFloats(float arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestMethods interface parsed without error.")
|
||||
harness.check(len(results), 1, "Should be one production.")
|
||||
iface = results[0]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestMethods", "Interface has the right QName")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestMethods", "Interface has the right QName"
|
||||
)
|
||||
harness.check(iface.identifier.name, "TestMethods", "Interface has the right name")
|
||||
harness.check(len(iface.members), 12, "Expect 12 members")
|
||||
|
||||
methods = iface.members
|
||||
|
||||
def checkArgument(argument, QName, name, type, optional, variadic):
|
||||
harness.ok(isinstance(argument, WebIDL.IDLArgument),
|
||||
"Should be an IDLArgument")
|
||||
harness.check(argument.identifier.QName(), QName, "Argument has the right QName")
|
||||
harness.ok(isinstance(argument, WebIDL.IDLArgument), "Should be an IDLArgument")
|
||||
harness.check(
|
||||
argument.identifier.QName(), QName, "Argument has the right QName"
|
||||
)
|
||||
harness.check(argument.identifier.name, name, "Argument has the right name")
|
||||
harness.check(str(argument.type), type, "Argument has the right return type")
|
||||
harness.check(argument.optional, optional, "Argument has the right optional value")
|
||||
harness.check(argument.variadic, variadic, "Argument has the right variadic value")
|
||||
harness.check(
|
||||
argument.optional, optional, "Argument has the right optional value"
|
||||
)
|
||||
harness.check(
|
||||
argument.variadic, variadic, "Argument has the right variadic value"
|
||||
)
|
||||
|
||||
def checkMethod(method, QName, name, signatures,
|
||||
static=False, getter=False, setter=False,
|
||||
deleter=False, legacycaller=False, stringifier=False):
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod),
|
||||
"Should be an IDLMethod")
|
||||
def checkMethod(
|
||||
method,
|
||||
QName,
|
||||
name,
|
||||
signatures,
|
||||
static=False,
|
||||
getter=False,
|
||||
setter=False,
|
||||
deleter=False,
|
||||
legacycaller=False,
|
||||
stringifier=False,
|
||||
):
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod), "Should be an IDLMethod")
|
||||
harness.ok(method.isMethod(), "Method is a method")
|
||||
harness.ok(not method.isAttr(), "Method is not an attr")
|
||||
harness.ok(not method.isConst(), "Method is not a const")
|
||||
|
@ -53,72 +70,202 @@ def WebIDLTest(parser, harness):
|
|||
harness.check(method.isStatic(), static, "Method has the correct static value")
|
||||
harness.check(method.isGetter(), getter, "Method has the correct getter value")
|
||||
harness.check(method.isSetter(), setter, "Method has the correct setter value")
|
||||
harness.check(method.isDeleter(), deleter, "Method has the correct deleter value")
|
||||
harness.check(method.isLegacycaller(), legacycaller, "Method has the correct legacycaller value")
|
||||
harness.check(method.isStringifier(), stringifier, "Method has the correct stringifier value")
|
||||
harness.check(len(method.signatures()), len(signatures), "Method has the correct number of signatures")
|
||||
harness.check(
|
||||
method.isDeleter(), deleter, "Method has the correct deleter value"
|
||||
)
|
||||
harness.check(
|
||||
method.isLegacycaller(),
|
||||
legacycaller,
|
||||
"Method has the correct legacycaller value",
|
||||
)
|
||||
harness.check(
|
||||
method.isStringifier(),
|
||||
stringifier,
|
||||
"Method has the correct stringifier value",
|
||||
)
|
||||
harness.check(
|
||||
len(method.signatures()),
|
||||
len(signatures),
|
||||
"Method has the correct number of signatures",
|
||||
)
|
||||
|
||||
sigpairs = zip(method.signatures(), signatures)
|
||||
for (gotSignature, expectedSignature) in sigpairs:
|
||||
(gotRetType, gotArgs) = gotSignature
|
||||
(expectedRetType, expectedArgs) = expectedSignature
|
||||
|
||||
harness.check(str(gotRetType), expectedRetType,
|
||||
"Method has the expected return type.")
|
||||
harness.check(
|
||||
str(gotRetType), expectedRetType, "Method has the expected return type."
|
||||
)
|
||||
|
||||
for i in range(0, len(gotArgs)):
|
||||
(QName, name, type, optional, variadic) = expectedArgs[i]
|
||||
checkArgument(gotArgs[i], QName, name, type, optional, variadic)
|
||||
|
||||
checkMethod(methods[0], "::TestMethods::basic", "basic", [("Undefined", [])])
|
||||
checkMethod(methods[1], "::TestMethods::basicStatic", "basicStatic",
|
||||
[("Undefined", [])], static=True)
|
||||
checkMethod(methods[2], "::TestMethods::basicWithSimpleArgs",
|
||||
"basicWithSimpleArgs",
|
||||
[("Undefined",
|
||||
[("::TestMethods::basicWithSimpleArgs::arg1", "arg1", "Boolean", False, False),
|
||||
("::TestMethods::basicWithSimpleArgs::arg2", "arg2", "Byte", False, False),
|
||||
("::TestMethods::basicWithSimpleArgs::arg3", "arg3", "UnsignedLong", False, False)])])
|
||||
checkMethod(methods[3], "::TestMethods::basicBoolean", "basicBoolean", [("Boolean", [])])
|
||||
checkMethod(methods[4], "::TestMethods::basicStaticBoolean", "basicStaticBoolean", [("Boolean", [])], static=True)
|
||||
checkMethod(methods[5], "::TestMethods::basicBooleanWithSimpleArgs",
|
||||
"basicBooleanWithSimpleArgs",
|
||||
[("Boolean",
|
||||
[("::TestMethods::basicBooleanWithSimpleArgs::arg1", "arg1", "Boolean", False, False),
|
||||
("::TestMethods::basicBooleanWithSimpleArgs::arg2", "arg2", "Byte", False, False),
|
||||
("::TestMethods::basicBooleanWithSimpleArgs::arg3", "arg3", "UnsignedLong", False, False)])])
|
||||
checkMethod(methods[6], "::TestMethods::optionalArg",
|
||||
"optionalArg",
|
||||
[("Undefined",
|
||||
[("::TestMethods::optionalArg::arg1", "arg1", "ByteOrNull", True, False),
|
||||
("::TestMethods::optionalArg::arg2", "arg2", "ByteSequence", True, False)])])
|
||||
checkMethod(methods[7], "::TestMethods::variadicArg",
|
||||
"variadicArg",
|
||||
[("Undefined",
|
||||
[("::TestMethods::variadicArg::arg1", "arg1", "ByteOrNull", True, True)])])
|
||||
checkMethod(methods[8], "::TestMethods::getObject",
|
||||
"getObject", [("Object", [])])
|
||||
checkMethod(methods[9], "::TestMethods::setObject",
|
||||
"setObject",
|
||||
[("Undefined",
|
||||
[("::TestMethods::setObject::arg1", "arg1", "Object", False, False)])])
|
||||
checkMethod(methods[10], "::TestMethods::setAny",
|
||||
"setAny",
|
||||
[("Undefined",
|
||||
[("::TestMethods::setAny::arg1", "arg1", "Any", False, False)])])
|
||||
checkMethod(methods[11], "::TestMethods::doFloats",
|
||||
"doFloats",
|
||||
[("Float",
|
||||
[("::TestMethods::doFloats::arg1", "arg1", "Float", False, False)])])
|
||||
checkMethod(
|
||||
methods[1],
|
||||
"::TestMethods::basicStatic",
|
||||
"basicStatic",
|
||||
[("Undefined", [])],
|
||||
static=True,
|
||||
)
|
||||
checkMethod(
|
||||
methods[2],
|
||||
"::TestMethods::basicWithSimpleArgs",
|
||||
"basicWithSimpleArgs",
|
||||
[
|
||||
(
|
||||
"Undefined",
|
||||
[
|
||||
(
|
||||
"::TestMethods::basicWithSimpleArgs::arg1",
|
||||
"arg1",
|
||||
"Boolean",
|
||||
False,
|
||||
False,
|
||||
),
|
||||
(
|
||||
"::TestMethods::basicWithSimpleArgs::arg2",
|
||||
"arg2",
|
||||
"Byte",
|
||||
False,
|
||||
False,
|
||||
),
|
||||
(
|
||||
"::TestMethods::basicWithSimpleArgs::arg3",
|
||||
"arg3",
|
||||
"UnsignedLong",
|
||||
False,
|
||||
False,
|
||||
),
|
||||
],
|
||||
)
|
||||
],
|
||||
)
|
||||
checkMethod(
|
||||
methods[3], "::TestMethods::basicBoolean", "basicBoolean", [("Boolean", [])]
|
||||
)
|
||||
checkMethod(
|
||||
methods[4],
|
||||
"::TestMethods::basicStaticBoolean",
|
||||
"basicStaticBoolean",
|
||||
[("Boolean", [])],
|
||||
static=True,
|
||||
)
|
||||
checkMethod(
|
||||
methods[5],
|
||||
"::TestMethods::basicBooleanWithSimpleArgs",
|
||||
"basicBooleanWithSimpleArgs",
|
||||
[
|
||||
(
|
||||
"Boolean",
|
||||
[
|
||||
(
|
||||
"::TestMethods::basicBooleanWithSimpleArgs::arg1",
|
||||
"arg1",
|
||||
"Boolean",
|
||||
False,
|
||||
False,
|
||||
),
|
||||
(
|
||||
"::TestMethods::basicBooleanWithSimpleArgs::arg2",
|
||||
"arg2",
|
||||
"Byte",
|
||||
False,
|
||||
False,
|
||||
),
|
||||
(
|
||||
"::TestMethods::basicBooleanWithSimpleArgs::arg3",
|
||||
"arg3",
|
||||
"UnsignedLong",
|
||||
False,
|
||||
False,
|
||||
),
|
||||
],
|
||||
)
|
||||
],
|
||||
)
|
||||
checkMethod(
|
||||
methods[6],
|
||||
"::TestMethods::optionalArg",
|
||||
"optionalArg",
|
||||
[
|
||||
(
|
||||
"Undefined",
|
||||
[
|
||||
(
|
||||
"::TestMethods::optionalArg::arg1",
|
||||
"arg1",
|
||||
"ByteOrNull",
|
||||
True,
|
||||
False,
|
||||
),
|
||||
(
|
||||
"::TestMethods::optionalArg::arg2",
|
||||
"arg2",
|
||||
"ByteSequence",
|
||||
True,
|
||||
False,
|
||||
),
|
||||
],
|
||||
)
|
||||
],
|
||||
)
|
||||
checkMethod(
|
||||
methods[7],
|
||||
"::TestMethods::variadicArg",
|
||||
"variadicArg",
|
||||
[
|
||||
(
|
||||
"Undefined",
|
||||
[
|
||||
(
|
||||
"::TestMethods::variadicArg::arg1",
|
||||
"arg1",
|
||||
"ByteOrNull",
|
||||
True,
|
||||
True,
|
||||
)
|
||||
],
|
||||
)
|
||||
],
|
||||
)
|
||||
checkMethod(methods[8], "::TestMethods::getObject", "getObject", [("Object", [])])
|
||||
checkMethod(
|
||||
methods[9],
|
||||
"::TestMethods::setObject",
|
||||
"setObject",
|
||||
[
|
||||
(
|
||||
"Undefined",
|
||||
[("::TestMethods::setObject::arg1", "arg1", "Object", False, False)],
|
||||
)
|
||||
],
|
||||
)
|
||||
checkMethod(
|
||||
methods[10],
|
||||
"::TestMethods::setAny",
|
||||
"setAny",
|
||||
[("Undefined", [("::TestMethods::setAny::arg1", "arg1", "Any", False, False)])],
|
||||
)
|
||||
checkMethod(
|
||||
methods[11],
|
||||
"::TestMethods::doFloats",
|
||||
"doFloats",
|
||||
[("Float", [("::TestMethods::doFloats::arg1", "arg1", "Float", False, False)])],
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
undefined foo(optional float bar = 1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
@ -127,11 +274,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[GetterThrows] undefined foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
@ -140,11 +289,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[SetterThrows] undefined foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
@ -153,11 +304,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Throw] undefined foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
@ -166,11 +319,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
undefined __noSuchMethod__();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
@ -179,77 +334,96 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Throws, LenientFloat]
|
||||
undefined foo(float myFloat);
|
||||
[Throws]
|
||||
undefined foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(not threw, "Should allow LenientFloat to be only in a specific overload")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Throws]
|
||||
undefined foo();
|
||||
[Throws, LenientFloat]
|
||||
undefined foo(float myFloat);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
iface = results[0]
|
||||
methods = iface.members
|
||||
lenientFloat = methods[0].getExtendedAttribute("LenientFloat")
|
||||
harness.ok(lenientFloat is not None, "LenientFloat in overloads must be added to the method")
|
||||
harness.ok(
|
||||
lenientFloat is not None,
|
||||
"LenientFloat in overloads must be added to the method",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Throws, LenientFloat]
|
||||
undefined foo(float myFloat);
|
||||
[Throws]
|
||||
undefined foo(float myFloat, float yourFloat);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "Should prevent overloads from getting different restricted float behavior")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should prevent overloads from getting different restricted float behavior",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Throws]
|
||||
undefined foo(float myFloat, float yourFloat);
|
||||
[Throws, LenientFloat]
|
||||
undefined foo(float myFloat);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "Should prevent overloads from getting different restricted float behavior (2)")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should prevent overloads from getting different restricted float behavior (2)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Throws, LenientFloat]
|
||||
undefined foo(float myFloat);
|
||||
[Throws, LenientFloat]
|
||||
undefined foo(short myShort);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
|
|
|
@ -5,13 +5,13 @@ def WebIDLTest(parser, harness):
|
|||
attribute any foo;
|
||||
any bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1, "Should have a thing.")
|
||||
harness.ok(results[0].isNamespace(), "Our thing should be a namespace");
|
||||
harness.check(len(results[0].members), 2,
|
||||
"Should have two things in our namespace")
|
||||
harness.ok(results[0].isNamespace(), "Our thing should be a namespace")
|
||||
harness.check(len(results[0].members), 2, "Should have two things in our namespace")
|
||||
harness.ok(results[0].members[0].isAttr(), "First member is attribute")
|
||||
harness.ok(results[0].members[0].isStatic(), "Attribute should be static")
|
||||
harness.ok(results[0].members[1].isMethod(), "Second member is method")
|
||||
|
@ -26,17 +26,17 @@ def WebIDLTest(parser, harness):
|
|||
partial namespace MyNamespace {
|
||||
any bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2, "Should have things.")
|
||||
harness.ok(results[0].isNamespace(), "Our thing should be a namespace");
|
||||
harness.check(len(results[0].members), 2,
|
||||
"Should have two things in our namespace")
|
||||
harness.ok(results[0].isNamespace(), "Our thing should be a namespace")
|
||||
harness.check(len(results[0].members), 2, "Should have two things in our namespace")
|
||||
harness.ok(results[0].members[0].isAttr(), "First member is attribute")
|
||||
harness.ok(results[0].members[0].isStatic(), "Attribute should be static");
|
||||
harness.ok(results[0].members[0].isStatic(), "Attribute should be static")
|
||||
harness.ok(results[0].members[1].isMethod(), "Second member is method")
|
||||
harness.ok(results[0].members[1].isStatic(), "Operation should be static");
|
||||
harness.ok(results[0].members[1].isStatic(), "Operation should be static")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
|
@ -47,17 +47,17 @@ def WebIDLTest(parser, harness):
|
|||
namespace MyNamespace {
|
||||
attribute any foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2, "Should have things.")
|
||||
harness.ok(results[1].isNamespace(), "Our thing should be a namespace");
|
||||
harness.check(len(results[1].members), 2,
|
||||
"Should have two things in our namespace")
|
||||
harness.ok(results[1].isNamespace(), "Our thing should be a namespace")
|
||||
harness.check(len(results[1].members), 2, "Should have two things in our namespace")
|
||||
harness.ok(results[1].members[0].isAttr(), "First member is attribute")
|
||||
harness.ok(results[1].members[0].isStatic(), "Attribute should be static");
|
||||
harness.ok(results[1].members[0].isStatic(), "Attribute should be static")
|
||||
harness.ok(results[1].members[1].isMethod(), "Second member is method")
|
||||
harness.ok(results[1].members[1].isStatic(), "Operation should be static");
|
||||
harness.ok(results[1].members[1].isStatic(), "Operation should be static")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
@ -67,7 +67,8 @@ def WebIDLTest(parser, harness):
|
|||
namespace MyNamespace {
|
||||
static attribute any foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -82,7 +83,8 @@ def WebIDLTest(parser, harness):
|
|||
namespace MyNamespace {
|
||||
static any bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -101,7 +103,8 @@ def WebIDLTest(parser, harness):
|
|||
interface MyNamespace {
|
||||
any baz();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -120,7 +123,8 @@ def WebIDLTest(parser, harness):
|
|||
namespace MyNamespace {
|
||||
any bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -139,7 +143,8 @@ def WebIDLTest(parser, harness):
|
|||
namespace MyNamespace {
|
||||
any bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -158,7 +163,8 @@ def WebIDLTest(parser, harness):
|
|||
interface MyNamespace {
|
||||
any bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -177,7 +183,8 @@ def WebIDLTest(parser, harness):
|
|||
partial interface MyNamespace {
|
||||
any baz();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -196,7 +203,8 @@ def WebIDLTest(parser, harness):
|
|||
namespace MyNamespace {
|
||||
any bar();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -215,7 +223,8 @@ def WebIDLTest(parser, harness):
|
|||
partial namespace MyNamespace {
|
||||
any baz();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
# Import the WebIDL module, so we can do isinstance checks and whatnot
|
||||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
# Basic functionality
|
||||
parser.parse(
|
||||
|
@ -9,7 +10,8 @@ def WebIDLTest(parser, harness):
|
|||
[NewObject] readonly attribute Iface attr;
|
||||
[NewObject] Iface method();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(results, "Should not have thrown on basic [NewObject] usage")
|
||||
|
||||
|
@ -21,7 +23,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[Pure, NewObject] readonly attribute Iface attr;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -35,7 +38,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[Pure, NewObject] Iface method();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -49,7 +53,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[Cached, NewObject, Affects=Nothing] readonly attribute Iface attr;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -63,7 +68,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Iface {
|
||||
[StoreInSlot, NewObject, Affects=Nothing] readonly attribute Iface attr;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestNullableEquivalency1 {
|
||||
attribute long a;
|
||||
attribute long? b;
|
||||
|
@ -53,22 +55,24 @@ def WebIDLTest(parser, harness):
|
|||
attribute object a;
|
||||
attribute object? b;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
for decl in parser.finish():
|
||||
if decl.isInterface():
|
||||
checkEquivalent(decl, harness)
|
||||
|
||||
|
||||
def checkEquivalent(iface, harness):
|
||||
type1 = iface.members[0].type
|
||||
type2 = iface.members[1].type
|
||||
|
||||
harness.check(type1.nullable(), False, 'attr1 should not be nullable')
|
||||
harness.check(type2.nullable(), True, 'attr2 should be nullable')
|
||||
harness.check(type1.nullable(), False, "attr1 should not be nullable")
|
||||
harness.check(type2.nullable(), True, "attr2 should be nullable")
|
||||
|
||||
# We don't know about type1, but type2, the nullable type, definitely
|
||||
# shouldn't be builtin.
|
||||
harness.check(type2.builtin, False, 'attr2 should not be builtin')
|
||||
harness.check(type2.builtin, False, "attr2 should not be builtin")
|
||||
|
||||
# Ensure that all attributes of type2 match those in type1, except for:
|
||||
# - names on an ignore list,
|
||||
|
@ -78,10 +82,22 @@ def checkEquivalent(iface, harness):
|
|||
#
|
||||
# Yes, this is an ugly, fragile hack. But it finds bugs...
|
||||
for attr in dir(type1):
|
||||
if attr.startswith('_') or \
|
||||
attr in ['nullable', 'builtin', 'filename', 'location',
|
||||
'inner', 'QName', 'getDeps', 'name', 'prettyName'] or \
|
||||
(hasattr(type(type1), attr) and not callable(getattr(type1, attr))):
|
||||
if (
|
||||
attr.startswith("_")
|
||||
or attr
|
||||
in [
|
||||
"nullable",
|
||||
"builtin",
|
||||
"filename",
|
||||
"location",
|
||||
"inner",
|
||||
"QName",
|
||||
"getDeps",
|
||||
"name",
|
||||
"prettyName",
|
||||
]
|
||||
or (hasattr(type(type1), attr) and not callable(getattr(type1, attr)))
|
||||
):
|
||||
continue
|
||||
|
||||
a1 = getattr(type1, attr)
|
||||
|
@ -96,20 +112,30 @@ def checkEquivalent(iface, harness):
|
|||
try:
|
||||
a2 = getattr(type2, attr)
|
||||
except:
|
||||
harness.ok(False, 'Missing %s attribute on type %s in %s' % (attr, type2, iface))
|
||||
harness.ok(
|
||||
False,
|
||||
"Missing %s attribute on type %s in %s" % (attr, type2, iface),
|
||||
)
|
||||
continue
|
||||
|
||||
if not callable(a2):
|
||||
harness.ok(False, "%s attribute on type %s in %s wasn't callable" % (attr, type2, iface))
|
||||
harness.ok(
|
||||
False,
|
||||
"%s attribute on type %s in %s wasn't callable"
|
||||
% (attr, type2, iface),
|
||||
)
|
||||
continue
|
||||
|
||||
v2 = a2()
|
||||
harness.check(v2, v1, '%s method return value' % attr)
|
||||
harness.check(v2, v1, "%s method return value" % attr)
|
||||
else:
|
||||
try:
|
||||
a2 = getattr(type2, attr)
|
||||
except:
|
||||
harness.ok(False, 'Missing %s attribute on type %s in %s' % (attr, type2, iface))
|
||||
harness.ok(
|
||||
False,
|
||||
"Missing %s attribute on type %s in %s" % (attr, type2, iface),
|
||||
)
|
||||
continue
|
||||
|
||||
harness.check(a2, a1, '%s attribute should match' % attr)
|
||||
harness.check(a2, a1, "%s attribute should match" % attr)
|
||||
|
|
|
@ -1,14 +0,0 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
interface NullableUndefined {
|
||||
undefined? foo();
|
||||
};
|
||||
""")
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown.")
|
|
@ -0,0 +1,288 @@
|
|||
# This Source Code Form is subject to the terms of the Mozilla Public
|
||||
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
|
||||
# Test dictionary as inner type
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
dictionary A {
|
||||
boolean member;
|
||||
};
|
||||
interface B {
|
||||
attribute ObservableArray<A> foo;
|
||||
};
|
||||
""",
|
||||
"use dictionary as inner type",
|
||||
)
|
||||
|
||||
# Test sequence as inner type
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
attribute ObservableArray<sequence<boolean>> foo;
|
||||
};
|
||||
""",
|
||||
"use sequence as inner type",
|
||||
)
|
||||
|
||||
# Test sequence<dictionary> as inner type
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
dictionary A {
|
||||
boolean member;
|
||||
};
|
||||
interface B {
|
||||
attribute ObservableArray<sequence<A>> foo;
|
||||
};
|
||||
""",
|
||||
"use sequence<dictionary> as inner type",
|
||||
)
|
||||
|
||||
# Test record as inner type
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
attribute ObservableArray<record<DOMString, boolean>> foo;
|
||||
};
|
||||
""",
|
||||
"use record as inner type",
|
||||
)
|
||||
|
||||
# Test record<dictionary> as inner type
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
dictionary A {
|
||||
boolean member;
|
||||
};
|
||||
interface B {
|
||||
attribute ObservableArray<record<DOMString, A>> foo;
|
||||
};
|
||||
""",
|
||||
"use record<dictionary> as inner type",
|
||||
)
|
||||
|
||||
# Test observable array as inner type
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
attribute ObservableArray<ObservableArray<boolean>> foo;
|
||||
};
|
||||
""",
|
||||
"use ObservableArray as inner type",
|
||||
)
|
||||
|
||||
# Test nullable attribute
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
attribute ObservableArray<boolean>? foo;
|
||||
};
|
||||
""",
|
||||
"nullable",
|
||||
)
|
||||
|
||||
# Test sequence
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
undefined foo(sequence<ObservableArray<boolean>> foo);
|
||||
};
|
||||
""",
|
||||
"used in sequence",
|
||||
)
|
||||
|
||||
# Test record
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
undefined foo(record<DOMString, ObservableArray<boolean>> foo);
|
||||
};
|
||||
""",
|
||||
"used in record",
|
||||
)
|
||||
|
||||
# Test promise
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
Promise<ObservableArray<boolean>> foo();
|
||||
};
|
||||
""",
|
||||
"used in promise",
|
||||
)
|
||||
|
||||
# Test union
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
attribute (DOMString or ObservableArray<boolean>>) foo;
|
||||
};
|
||||
""",
|
||||
"used in union",
|
||||
)
|
||||
|
||||
# Test dictionary member
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
dictionary A {
|
||||
ObservableArray<boolean> foo;
|
||||
};
|
||||
""",
|
||||
"used on dictionary member type",
|
||||
)
|
||||
|
||||
# Test argument
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
undefined foo(ObservableArray<boolean> foo);
|
||||
};
|
||||
""",
|
||||
"used on argument",
|
||||
)
|
||||
|
||||
# Test static attribute
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
static attribute ObservableArray<boolean> foo;
|
||||
};
|
||||
""",
|
||||
"used on static attribute type",
|
||||
)
|
||||
|
||||
# Test iterable
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
iterable<ObservableArray<boolean>>;
|
||||
};
|
||||
""",
|
||||
"used in iterable",
|
||||
)
|
||||
|
||||
# Test maplike
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
maplike<long, ObservableArray<boolean>>;
|
||||
};
|
||||
""",
|
||||
"used in maplike",
|
||||
)
|
||||
|
||||
# Test setlike
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
setlike<ObservableArray<boolean>>;
|
||||
};
|
||||
""",
|
||||
"used in setlike",
|
||||
)
|
||||
|
||||
# Test JS implemented interface
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
[JSImplementation="@mozilla.org/dom/test-interface-js;1"]
|
||||
interface A {
|
||||
readonly attribute ObservableArray<boolean> foo;
|
||||
};
|
||||
""",
|
||||
"used in JS implemented interface",
|
||||
)
|
||||
|
||||
# Test namespace
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
namespace A {
|
||||
readonly attribute ObservableArray<boolean> foo;
|
||||
};
|
||||
""",
|
||||
"used in namespaces",
|
||||
)
|
||||
|
||||
# Test [Cached] extended attribute
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
[Cached, Pure]
|
||||
readonly attribute ObservableArray<boolean> foo;
|
||||
};
|
||||
""",
|
||||
"have Cached extended attribute",
|
||||
)
|
||||
|
||||
# Test [StoreInSlot] extended attribute
|
||||
harness.should_throw(
|
||||
parser,
|
||||
"""
|
||||
interface A {
|
||||
[StoreInSlot, Pure]
|
||||
readonly attribute ObservableArray<boolean> foo;
|
||||
};
|
||||
""",
|
||||
"have StoreInSlot extended attribute",
|
||||
)
|
||||
|
||||
# Test regular attribute
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
readonly attribute ObservableArray<boolean> foo;
|
||||
attribute ObservableArray<[Clamp] octet> bar;
|
||||
attribute ObservableArray<long?> baz;
|
||||
attribute ObservableArray<(boolean or long)> qux;
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
A = results[0]
|
||||
foo = A.members[0]
|
||||
harness.ok(foo.readonly, "A.foo is readonly attribute")
|
||||
harness.ok(foo.type.isObservableArray(), "A.foo is ObservableArray type")
|
||||
harness.check(
|
||||
foo.slotIndices[A.identifier.name], 0, "A.foo should be stored in slot"
|
||||
)
|
||||
bar = A.members[1]
|
||||
harness.ok(bar.type.isObservableArray(), "A.bar is ObservableArray type")
|
||||
harness.check(
|
||||
bar.slotIndices[A.identifier.name], 1, "A.bar should be stored in slot"
|
||||
)
|
||||
harness.ok(bar.type.inner.hasClamp(), "A.bar's inner type should be clamped")
|
||||
baz = A.members[2]
|
||||
harness.ok(baz.type.isObservableArray(), "A.baz is ObservableArray type")
|
||||
harness.check(
|
||||
baz.slotIndices[A.identifier.name], 2, "A.baz should be stored in slot"
|
||||
)
|
||||
harness.ok(baz.type.inner.nullable(), "A.baz's inner type should be nullable")
|
||||
qux = A.members[3]
|
||||
harness.ok(qux.type.isObservableArray(), "A.qux is ObservableArray type")
|
||||
harness.check(
|
||||
qux.slotIndices[A.identifier.name], 3, "A.qux should be stored in slot"
|
||||
)
|
||||
harness.ok(qux.type.inner.isUnion(), "A.qux's inner type should be union")
|
|
@ -1,30 +1,35 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface OptionalConstraints1 {
|
||||
undefined foo(optional byte arg1, byte arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(not threw,
|
||||
"Should not have thrown on non-optional argument following "
|
||||
"optional argument.")
|
||||
harness.ok(
|
||||
not threw,
|
||||
"Should not have thrown on non-optional argument following "
|
||||
"optional argument.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface OptionalConstraints2 {
|
||||
undefined foo(optional byte arg1 = 1, optional byte arg2 = 2,
|
||||
optional byte arg3, optional byte arg4 = 4,
|
||||
optional byte arg5, optional byte arg6 = 9);
|
||||
optional byte arg3, optional byte arg4 = 4,
|
||||
optional byte arg5, optional byte arg6 = 9);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
args = results[0].members[0].signatures()[0][1]
|
||||
harness.check(len(args), 6, "Should have 6 arguments")
|
||||
harness.check(args[5].defaultValue.value, 9,
|
||||
"Should have correct default value")
|
||||
harness.check(args[5].defaultValue.value, 9, "Should have correct default value")
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestOverloads {
|
||||
undefined basic();
|
||||
undefined basic(long arg1);
|
||||
|
@ -14,21 +16,29 @@ def WebIDLTest(parser, harness):
|
|||
undefined optionalTest();
|
||||
undefined optionalTest(optional long num1, long num2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True, "TestOverloads interface parsed without error.")
|
||||
harness.check(len(results), 1, "Should be one production.")
|
||||
iface = results[0]
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.check(iface.identifier.QName(), "::TestOverloads", "Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "TestOverloads", "Interface has the right name")
|
||||
harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestOverloads", "Interface has the right QName"
|
||||
)
|
||||
harness.check(
|
||||
iface.identifier.name, "TestOverloads", "Interface has the right name"
|
||||
)
|
||||
harness.check(len(iface.members), 4, "Expect %s members" % 4)
|
||||
|
||||
member = iface.members[0]
|
||||
harness.check(member.identifier.QName(), "::TestOverloads::basic", "Method has the right QName")
|
||||
harness.check(
|
||||
member.identifier.QName(),
|
||||
"::TestOverloads::basic",
|
||||
"Method has the right QName",
|
||||
)
|
||||
harness.check(member.identifier.name, "basic", "Method has the right name")
|
||||
harness.check(member.hasOverloads(), True, "Method has overloads")
|
||||
|
||||
|
@ -37,24 +47,28 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
(retval, argumentSet) = signatures[0]
|
||||
|
||||
harness.check(str(retval), "Undefined", "Expect a undefined retval")
|
||||
harness.check(str(retval), "Undefined", "Expect an undefined retval")
|
||||
harness.check(len(argumentSet), 0, "Expect an empty argument set")
|
||||
|
||||
(retval, argumentSet) = signatures[1]
|
||||
harness.check(str(retval), "Undefined", "Expect a undefined retval")
|
||||
harness.check(str(retval), "Undefined", "Expect an undefined retval")
|
||||
harness.check(len(argumentSet), 1, "Expect an argument set with one argument")
|
||||
|
||||
argument = argumentSet[0]
|
||||
harness.ok(isinstance(argument, WebIDL.IDLArgument),
|
||||
"Should be an IDLArgument")
|
||||
harness.check(argument.identifier.QName(), "::TestOverloads::basic::arg1", "Argument has the right QName")
|
||||
harness.ok(isinstance(argument, WebIDL.IDLArgument), "Should be an IDLArgument")
|
||||
harness.check(
|
||||
argument.identifier.QName(),
|
||||
"::TestOverloads::basic::arg1",
|
||||
"Argument has the right QName",
|
||||
)
|
||||
harness.check(argument.identifier.name, "arg1", "Argument has the right name")
|
||||
harness.check(str(argument.type), "Long", "Argument has the right type")
|
||||
|
||||
member = iface.members[3]
|
||||
harness.check(len(member.overloadsForArgCount(0)), 1,
|
||||
"Only one overload for no args")
|
||||
harness.check(len(member.overloadsForArgCount(1)), 0,
|
||||
"No overloads for one arg")
|
||||
harness.check(len(member.overloadsForArgCount(2)), 1,
|
||||
"Only one overload for two args")
|
||||
harness.check(
|
||||
len(member.overloadsForArgCount(0)), 1, "Only one overload for no args"
|
||||
)
|
||||
harness.check(len(member.overloadsForArgCount(1)), 0, "No overloads for one arg")
|
||||
harness.check(
|
||||
len(member.overloadsForArgCount(2)), 1, "Only one overload for two args"
|
||||
)
|
||||
|
|
|
@ -1,157 +1,177 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
legacycaller Promise<any> foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow Promise return values for legacycaller.")
|
||||
harness.ok(threw, "Should not allow Promise return values for legacycaller.")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
Promise<any> foo();
|
||||
long foo(long arg);
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow overloads which have both Promise and "
|
||||
"non-Promise return types.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow overloads which have both Promise and "
|
||||
"non-Promise return types.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
long foo(long arg);
|
||||
Promise<any> foo();
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow overloads which have both Promise and "
|
||||
"non-Promise return types.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow overloads which have both Promise and "
|
||||
"non-Promise return types.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
Promise<any>? foo();
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow nullable Promise return values.")
|
||||
harness.ok(threw, "Should not allow nullable Promise return values.")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
undefined foo(Promise<any>? arg);
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow nullable Promise arguments.")
|
||||
harness.ok(threw, "Should not allow nullable Promise arguments.")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
Promise<any> foo();
|
||||
Promise<any> foo(long arg);
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(True,
|
||||
"Should allow overloads which only have Promise and return "
|
||||
"types.")
|
||||
harness.ok(
|
||||
True, "Should allow overloads which only have Promise and return " "types."
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
attribute Promise<any> attr;
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow writable Promise-typed attributes.")
|
||||
harness.ok(threw, "Should not allow writable Promise-typed attributes.")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[LenientSetter] readonly attribute Promise<any> attr;
|
||||
[LegacyLenientSetter] readonly attribute Promise<any> attr;
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [LenientSetter] Promise-typed attributes.")
|
||||
harness.ok(
|
||||
threw, "Should not allow [LegacyLenientSetter] Promise-typed attributes."
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[PutForwards=bar] readonly attribute Promise<any> attr;
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [PutForwards] Promise-typed attributes.")
|
||||
harness.ok(threw, "Should not allow [PutForwards] Promise-typed attributes.")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[Replaceable] readonly attribute Promise<any> attr;
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [Replaceable] Promise-typed attributes.")
|
||||
harness.ok(threw, "Should not allow [Replaceable] Promise-typed attributes.")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface A {
|
||||
[SameObject] readonly attribute Promise<any> attr;
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should not allow [SameObject] Promise-typed attributes.")
|
||||
harness.ok(threw, "Should not allow [SameObject] Promise-typed attributes.")
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIface {
|
||||
static attribute boolean prototype;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -15,11 +17,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIface {
|
||||
static boolean prototype();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -29,11 +33,13 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIface {
|
||||
const boolean prototype = true;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -42,39 +48,60 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
# Make sure that we can parse non-static attributes with 'prototype' as identifier.
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIface {
|
||||
attribute boolean prototype;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
testIface = results[0];
|
||||
harness.check(testIface.members[0].isStatic(), False, "Attribute should not be static")
|
||||
harness.check(testIface.members[0].identifier.name, "prototype", "Attribute identifier should be 'prototype'")
|
||||
testIface = results[0]
|
||||
harness.check(
|
||||
testIface.members[0].isStatic(), False, "Attribute should not be static"
|
||||
)
|
||||
harness.check(
|
||||
testIface.members[0].identifier.name,
|
||||
"prototype",
|
||||
"Attribute identifier should be 'prototype'",
|
||||
)
|
||||
|
||||
# Make sure that we can parse non-static operations with 'prototype' as identifier.
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestIface {
|
||||
boolean prototype();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
testIface = results[0];
|
||||
harness.check(testIface.members[0].isStatic(), False, "Operation should not be static")
|
||||
harness.check(testIface.members[0].identifier.name, "prototype", "Operation identifier should be 'prototype'")
|
||||
testIface = results[0]
|
||||
harness.check(
|
||||
testIface.members[0].isStatic(), False, "Operation should not be static"
|
||||
)
|
||||
harness.check(
|
||||
testIface.members[0].identifier.name,
|
||||
"prototype",
|
||||
"Operation identifier should be 'prototype'",
|
||||
)
|
||||
|
||||
# Make sure that we can parse dictionary members with 'prototype' as identifier.
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary TestDict {
|
||||
boolean prototype;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
testDict = results[0];
|
||||
harness.check(testDict.members[0].identifier.name, "prototype", "Dictionary member should be 'prototype'")
|
||||
|
||||
testDict = results[0]
|
||||
harness.check(
|
||||
testDict.members[0].identifier.name,
|
||||
"prototype",
|
||||
"Dictionary member should be 'prototype'",
|
||||
)
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface I {
|
||||
[PutForwards=B] readonly attribute long A;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -13,16 +15,18 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
harness.ok(threw, "Should have thrown.")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface I {
|
||||
[PutForwards=B] readonly attribute J A;
|
||||
};
|
||||
interface J {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -30,17 +34,19 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
harness.ok(threw, "Should have thrown.")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface I {
|
||||
[PutForwards=B] attribute J A;
|
||||
};
|
||||
interface J {
|
||||
attribute long B;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -48,17 +54,19 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
harness.ok(threw, "Should have thrown.")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface I {
|
||||
[PutForwards=B] static readonly attribute J A;
|
||||
};
|
||||
interface J {
|
||||
attribute long B;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -66,17 +74,19 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
harness.ok(threw, "Should have thrown.")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
callback interface I {
|
||||
[PutForwards=B] readonly attribute J A;
|
||||
};
|
||||
interface J {
|
||||
attribute long B;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -84,10 +94,11 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
harness.ok(threw, "Should have thrown.")
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface I {
|
||||
[PutForwards=C] readonly attribute J A;
|
||||
[PutForwards=C] readonly attribute J B;
|
||||
|
@ -98,7 +109,8 @@ def WebIDLTest(parser, harness):
|
|||
interface K {
|
||||
[PutForwards=A] readonly attribute I D;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,18 +1,22 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {};
|
||||
interface RecordArg {
|
||||
undefined foo(record<DOMString, Dict> arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(len(results), 2, "Should know about two things");
|
||||
harness.ok(isinstance(results[1], WebIDL.IDLInterface),
|
||||
"Should have an interface here");
|
||||
harness.check(len(results), 2, "Should know about two things")
|
||||
harness.ok(
|
||||
isinstance(results[1], WebIDL.IDLInterface), "Should have an interface here"
|
||||
)
|
||||
members = results[1].members
|
||||
harness.check(len(members), 1, "Should have one member")
|
||||
harness.ok(members[0].isMethod(), "Should have method")
|
||||
|
@ -20,34 +24,38 @@ def WebIDLTest(parser, harness):
|
|||
args = signature[1]
|
||||
harness.check(len(args), 1, "Should have one arg")
|
||||
harness.ok(args[0].type.isRecord(), "Should have a record type here")
|
||||
harness.ok(args[0].type.inner.isDictionary(),
|
||||
"Should have a dictionary inner type")
|
||||
harness.ok(args[0].type.inner.isDictionary(), "Should have a dictionary inner type")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface RecordUndefinedArg {
|
||||
undefined foo(record<DOMString, undefined> arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw, "Should have thrown because record can't have undefined as value type.")
|
||||
harness.ok(
|
||||
threw, "Should have thrown because record can't have undefined as value type."
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {
|
||||
record<DOMString, Dict> val;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should have thrown on dictionary containing itself via record.")
|
||||
harness.ok(threw, "Should have thrown on dictionary containing itself via record.")
|
||||
|
|
|
@ -2,8 +2,9 @@
|
|||
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
|
||||
def should_throw(parser, harness, message, code):
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse(code)
|
||||
|
@ -16,43 +17,68 @@ def should_throw(parser, harness, message, code):
|
|||
|
||||
def WebIDLTest(parser, harness):
|
||||
# The [Replaceable] extended attribute MUST take no arguments.
|
||||
should_throw(parser, harness, "no arguments", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"no arguments",
|
||||
"""
|
||||
interface I {
|
||||
[Replaceable=X] readonly attribute long A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# An attribute with the [Replaceable] extended attribute MUST NOT also be
|
||||
# declared with the [PutForwards] extended attribute.
|
||||
should_throw(parser, harness, "PutForwards", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"PutForwards",
|
||||
"""
|
||||
interface I {
|
||||
[PutForwards=B, Replaceable] readonly attribute J A;
|
||||
};
|
||||
interface J {
|
||||
attribute long B;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# The [Replaceable] extended attribute MUST NOT be used on an attribute
|
||||
# that is not read only.
|
||||
should_throw(parser, harness, "writable attribute", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"writable attribute",
|
||||
"""
|
||||
interface I {
|
||||
[Replaceable] attribute long A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# The [Replaceable] extended attribute MUST NOT be used on a static
|
||||
# attribute.
|
||||
should_throw(parser, harness, "static attribute", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"static attribute",
|
||||
"""
|
||||
interface I {
|
||||
[Replaceable] static readonly attribute long A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
||||
# The [Replaceable] extended attribute MUST NOT be used on an attribute
|
||||
# declared on a callback interface.
|
||||
should_throw(parser, harness, "callback interface", """
|
||||
should_throw(
|
||||
parser,
|
||||
harness,
|
||||
"callback interface",
|
||||
"""
|
||||
callback interface I {
|
||||
[Replaceable] readonly attribute long A;
|
||||
};
|
||||
""")
|
||||
""",
|
||||
)
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SecureContext]
|
||||
interface TestSecureContextOnInterface {
|
||||
const octet TEST_CONSTANT = 0;
|
||||
|
@ -13,27 +15,47 @@ def WebIDLTest(parser, harness):
|
|||
readonly attribute byte testAttribute2;
|
||||
undefined testMethod2(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results[0].members), 6, "TestSecureContextOnInterface should have six 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")
|
||||
harness.ok(results[0].members[1].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members")
|
||||
harness.ok(results[0].members[2].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members")
|
||||
harness.ok(results[0].members[3].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to constant members from partial interface")
|
||||
harness.ok(results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members from partial interface")
|
||||
harness.ok(results[0].members[5].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members from partial interface")
|
||||
harness.check(
|
||||
len(results[0].members),
|
||||
6,
|
||||
"TestSecureContextOnInterface should have six 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",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[1].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[2].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[3].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to constant members from partial interface",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members from partial interface",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[5].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members from partial interface",
|
||||
)
|
||||
|
||||
# Same thing, but with the partial interface specified first:
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
partial interface TestSecureContextOnInterfaceAfterPartialInterface {
|
||||
const octet TEST_CONSTANT_2 = 0;
|
||||
readonly attribute byte testAttribute2;
|
||||
|
@ -45,26 +67,46 @@ def WebIDLTest(parser, harness):
|
|||
readonly attribute byte testAttribute;
|
||||
undefined testMethod(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results[1].members), 6, "TestSecureContextOnInterfaceAfterPartialInterface should have six members")
|
||||
harness.ok(results[1].getExtendedAttribute("SecureContext"),
|
||||
"Interface should have [SecureContext] extended attribute")
|
||||
harness.ok(results[1].members[0].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to constant members")
|
||||
harness.ok(results[1].members[1].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members")
|
||||
harness.ok(results[1].members[2].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members")
|
||||
harness.ok(results[1].members[3].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to constant members from partial interface")
|
||||
harness.ok(results[1].members[4].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members from partial interface")
|
||||
harness.ok(results[1].members[5].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members from partial interface")
|
||||
harness.check(
|
||||
len(results[1].members),
|
||||
6,
|
||||
"TestSecureContextOnInterfaceAfterPartialInterface should have six members",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].getExtendedAttribute("SecureContext"),
|
||||
"Interface should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].members[0].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to constant members",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].members[1].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].members[2].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].members[3].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to constant members from partial interface",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].members[4].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to attribute members from partial interface",
|
||||
)
|
||||
harness.ok(
|
||||
results[1].members[5].getExtendedAttribute("SecureContext"),
|
||||
"[SecureContext] should propagate from interface to method members from partial interface",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestSecureContextOnPartialInterface {
|
||||
const octet TEST_CONSTANT = 0;
|
||||
readonly attribute byte testAttribute;
|
||||
|
@ -76,26 +118,46 @@ def WebIDLTest(parser, harness):
|
|||
readonly attribute byte testAttribute2;
|
||||
undefined testMethod2(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results[0].members), 6, "TestSecureContextOnPartialInterface should have six members")
|
||||
harness.ok(results[0].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface")
|
||||
harness.ok(results[0].members[0].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface's constant members")
|
||||
harness.ok(results[0].members[1].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface's attribute members")
|
||||
harness.ok(results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface's method members")
|
||||
harness.ok(results[0].members[3].getExtendedAttribute("SecureContext"),
|
||||
"Constant members from [SecureContext] partial interface should be [SecureContext]")
|
||||
harness.ok(results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"Attribute members from [SecureContext] partial interface should be [SecureContext]")
|
||||
harness.ok(results[0].members[5].getExtendedAttribute("SecureContext"),
|
||||
"Method members from [SecureContext] partial interface should be [SecureContext]")
|
||||
harness.check(
|
||||
len(results[0].members),
|
||||
6,
|
||||
"TestSecureContextOnPartialInterface should have six members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[0].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface's constant members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[1].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface's attribute members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] should not propagate from a partial interface to the interface's method members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[3].getExtendedAttribute("SecureContext"),
|
||||
"Constant members from [SecureContext] partial interface should be [SecureContext]",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"Attribute members from [SecureContext] partial interface should be [SecureContext]",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[5].getExtendedAttribute("SecureContext"),
|
||||
"Method members from [SecureContext] partial interface should be [SecureContext]",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestSecureContextOnInterfaceMembers {
|
||||
const octet TEST_NON_SECURE_CONSTANT_1 = 0;
|
||||
[SecureContext]
|
||||
|
@ -110,32 +172,58 @@ def WebIDLTest(parser, harness):
|
|||
undefined testSecureMethod(byte foo);
|
||||
undefined testNonSecureMethod2(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results[0].members), 9, "TestSecureContextOnInterfaceMembers should have nine members")
|
||||
harness.ok(results[0].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] on members should not propagate up to the interface")
|
||||
harness.ok(results[0].members[0].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[1].getExtendedAttribute("SecureContext"),
|
||||
"Constant should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[3].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"Attribute should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[5].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[6].getExtendedAttribute("SecureContext") is None,
|
||||
"Method should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[7].getExtendedAttribute("SecureContext"),
|
||||
"Method should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[8].getExtendedAttribute("SecureContext") is None,
|
||||
"Method should not have [SecureContext] extended attribute")
|
||||
harness.check(
|
||||
len(results[0].members),
|
||||
9,
|
||||
"TestSecureContextOnInterfaceMembers should have nine members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].getExtendedAttribute("SecureContext") is None,
|
||||
"[SecureContext] on members should not propagate up to the interface",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[0].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[1].getExtendedAttribute("SecureContext"),
|
||||
"Constant should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[3].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"Attribute should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[5].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[6].getExtendedAttribute("SecureContext") is None,
|
||||
"Method should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[7].getExtendedAttribute("SecureContext"),
|
||||
"Method should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[8].getExtendedAttribute("SecureContext") is None,
|
||||
"Method should not have [SecureContext] extended attribute",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestSecureContextOnPartialInterfaceMembers {
|
||||
};
|
||||
partial interface TestSecureContextOnPartialInterfaceMembers {
|
||||
|
@ -152,37 +240,62 @@ def WebIDLTest(parser, harness):
|
|||
undefined testSecureMethod(byte foo);
|
||||
undefined testNonSecureMethod2(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results[0].members), 9, "TestSecureContextOnPartialInterfaceMembers should have nine members")
|
||||
harness.ok(results[0].members[0].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant from partial interface should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[1].getExtendedAttribute("SecureContext"),
|
||||
"Constant from partial interface should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant from partial interface should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[3].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute from partial interface should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"Attribute from partial interface should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[5].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute from partial interface should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[6].getExtendedAttribute("SecureContext") is None,
|
||||
"Method from partial interface should not have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[7].getExtendedAttribute("SecureContext"),
|
||||
"Method from partial interface should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[8].getExtendedAttribute("SecureContext") is None,
|
||||
"Method from partial interface should not have [SecureContext] extended attribute")
|
||||
harness.check(
|
||||
len(results[0].members),
|
||||
9,
|
||||
"TestSecureContextOnPartialInterfaceMembers should have nine members",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[0].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant from partial interface should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[1].getExtendedAttribute("SecureContext"),
|
||||
"Constant from partial interface should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"Constant from partial interface should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[3].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute from partial interface should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[4].getExtendedAttribute("SecureContext"),
|
||||
"Attribute from partial interface should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[5].getExtendedAttribute("SecureContext") is None,
|
||||
"Attribute from partial interface should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[6].getExtendedAttribute("SecureContext") is None,
|
||||
"Method from partial interface should not have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[7].getExtendedAttribute("SecureContext"),
|
||||
"Method from partial interface should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[8].getExtendedAttribute("SecureContext") is None,
|
||||
"Method from partial interface should not have [SecureContext] extended attribute",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SecureContext=something]
|
||||
interface TestSecureContextTakesNoValue1 {
|
||||
const octet TEST_SECURE_CONSTANT = 0;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -191,7 +304,8 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestSecureContextForOverloads1 {
|
||||
[SecureContext]
|
||||
undefined testSecureMethod(byte foo);
|
||||
|
@ -199,16 +313,21 @@ def WebIDLTest(parser, harness):
|
|||
partial interface TestSecureContextForOverloads1 {
|
||||
undefined testSecureMethod(byte foo, byte bar);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw, "If [SecureContext] appears on an overloaded operation, then it MUST appear on all overloads")
|
||||
harness.ok(
|
||||
threw,
|
||||
"If [SecureContext] appears on an overloaded operation, then it MUST appear on all overloads",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestSecureContextForOverloads2 {
|
||||
[SecureContext]
|
||||
undefined testSecureMethod(byte foo);
|
||||
|
@ -217,31 +336,40 @@ def WebIDLTest(parser, harness):
|
|||
[SecureContext]
|
||||
undefined testSecureMethod(byte foo, byte bar);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(not threw, "[SecureContext] can appear on an overloaded operation if it appears on all overloads")
|
||||
harness.ok(
|
||||
not threw,
|
||||
"[SecureContext] can appear on an overloaded operation if it appears on all overloads",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SecureContext]
|
||||
interface TestSecureContextOnInterfaceAndMember {
|
||||
[SecureContext]
|
||||
undefined testSecureMethod(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw, "[SecureContext] must not appear on an interface and interface member")
|
||||
harness.ok(
|
||||
threw, "[SecureContext] must not appear on an interface and interface member"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestSecureContextOnPartialInterfaceAndMember {
|
||||
};
|
||||
[SecureContext]
|
||||
|
@ -249,16 +377,21 @@ def WebIDLTest(parser, harness):
|
|||
[SecureContext]
|
||||
undefined testSecureMethod(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw, "[SecureContext] must not appear on a partial interface and one of the partial interface's member's")
|
||||
harness.ok(
|
||||
threw,
|
||||
"[SecureContext] must not appear on a partial interface and one of the partial interface's member's",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SecureContext]
|
||||
interface TestSecureContextOnInterfaceAndPartialInterfaceMember {
|
||||
};
|
||||
|
@ -266,31 +399,41 @@ def WebIDLTest(parser, harness):
|
|||
[SecureContext]
|
||||
undefined testSecureMethod(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw, "[SecureContext] must not appear on an interface and one of its partial interface's member's")
|
||||
harness.ok(
|
||||
threw,
|
||||
"[SecureContext] must not appear on an interface and one of its partial interface's member's",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SecureContext]
|
||||
interface TestSecureContextOnInheritedInterface {
|
||||
};
|
||||
interface TestSecureContextNotOnInheritingInterface : TestSecureContextOnInheritedInterface {
|
||||
undefined testSecureMethod(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw, "[SecureContext] must appear on interfaces that inherit from another [SecureContext] interface")
|
||||
harness.ok(
|
||||
threw,
|
||||
"[SecureContext] must appear on interfaces that inherit from another [SecureContext] interface",
|
||||
)
|
||||
|
||||
# Test 'includes'.
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[SecureContext]
|
||||
interface TestSecureContextInterfaceThatIncludesNonSecureContextMixin {
|
||||
const octet TEST_CONSTANT = 0;
|
||||
|
@ -301,31 +444,56 @@ def WebIDLTest(parser, harness):
|
|||
undefined testMethod2(byte foo);
|
||||
};
|
||||
TestSecureContextInterfaceThatIncludesNonSecureContextMixin includes TestNonSecureContextMixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
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] mixin should not be [SecureContext]")
|
||||
harness.ok(results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"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] mixin should not be [SecureContext]")
|
||||
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] mixin should not be [SecureContext]",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[2].getExtendedAttribute("SecureContext") is None,
|
||||
"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] mixin should not be [SecureContext]",
|
||||
)
|
||||
|
||||
# Test SecureContext and NoInterfaceObject
|
||||
# Test SecureContext and LegacyNoInterfaceObject
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
[NoInterfaceObject, SecureContext]
|
||||
interface TestSecureContextNoInterfaceObject {
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyNoInterfaceObject, SecureContext]
|
||||
interface TestSecureContextLegacyNoInterfaceObject {
|
||||
undefined testSecureMethod(byte foo);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results[0].members), 1, "TestSecureContextNoInterfaceObject should have only one member")
|
||||
harness.ok(results[0].getExtendedAttribute("SecureContext"),
|
||||
"Interface should have [SecureContext] extended attribute")
|
||||
harness.ok(results[0].members[0].getExtendedAttribute("SecureContext"),
|
||||
"Interface member should have [SecureContext] extended attribute")
|
||||
harness.check(
|
||||
len(results[0].members),
|
||||
1,
|
||||
"TestSecureContextLegacyNoInterfaceObject should have only one member",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].getExtendedAttribute("SecureContext"),
|
||||
"Interface should have [SecureContext] extended attribute",
|
||||
)
|
||||
harness.ok(
|
||||
results[0].members[0].getExtendedAttribute("SecureContext"),
|
||||
"Interface member should have [SecureContext] extended attribute",
|
||||
)
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch1 {
|
||||
getter long long foo(long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -15,11 +17,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch2 {
|
||||
getter undefined foo(unsigned long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -29,11 +33,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch3 {
|
||||
getter boolean foo(unsigned long index, boolean extraArg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -43,11 +49,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch4 {
|
||||
getter boolean foo(unsigned long... index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -57,11 +65,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch5 {
|
||||
getter boolean foo(optional unsigned long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -71,11 +81,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch6 {
|
||||
getter boolean foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -85,11 +97,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch7 {
|
||||
deleter long long foo(long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -99,11 +113,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch9 {
|
||||
deleter boolean foo(unsigned long index, boolean extraArg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -113,11 +129,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch10 {
|
||||
deleter boolean foo(unsigned long... index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -127,11 +145,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch11 {
|
||||
deleter boolean foo(optional unsigned long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -141,11 +161,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch12 {
|
||||
deleter boolean foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -155,11 +177,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch13 {
|
||||
setter long long foo(long index, long long value);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -169,11 +193,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch15 {
|
||||
setter boolean foo(unsigned long index, boolean value, long long extraArg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -183,11 +209,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch16 {
|
||||
setter boolean foo(unsigned long index, boolean... value);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -197,11 +225,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch17 {
|
||||
setter boolean foo(unsigned long index, optional boolean value);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -211,11 +241,13 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodSignatureMismatch18 {
|
||||
setter boolean foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethods {
|
||||
getter long long (unsigned long index);
|
||||
setter long long (unsigned long index, long long value);
|
||||
|
@ -14,47 +16,90 @@ def WebIDLTest(parser, harness):
|
|||
interface SpecialMethodsCombination {
|
||||
getter deleter boolean (DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
def checkMethod(method, QName, name,
|
||||
static=False, getter=False, setter=False,
|
||||
deleter=False, legacycaller=False, stringifier=False):
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod),
|
||||
"Should be an IDLMethod")
|
||||
def checkMethod(
|
||||
method,
|
||||
QName,
|
||||
name,
|
||||
static=False,
|
||||
getter=False,
|
||||
setter=False,
|
||||
deleter=False,
|
||||
legacycaller=False,
|
||||
stringifier=False,
|
||||
):
|
||||
harness.ok(isinstance(method, WebIDL.IDLMethod), "Should be an IDLMethod")
|
||||
harness.check(method.identifier.QName(), QName, "Method has the right QName")
|
||||
harness.check(method.identifier.name, name, "Method has the right name")
|
||||
harness.check(method.isStatic(), static, "Method has the correct static value")
|
||||
harness.check(method.isGetter(), getter, "Method has the correct getter value")
|
||||
harness.check(method.isSetter(), setter, "Method has the correct setter value")
|
||||
harness.check(method.isDeleter(), deleter, "Method has the correct deleter value")
|
||||
harness.check(method.isLegacycaller(), legacycaller, "Method has the correct legacycaller value")
|
||||
harness.check(method.isStringifier(), stringifier, "Method has the correct stringifier value")
|
||||
harness.check(
|
||||
method.isDeleter(), deleter, "Method has the correct deleter value"
|
||||
)
|
||||
harness.check(
|
||||
method.isLegacycaller(),
|
||||
legacycaller,
|
||||
"Method has the correct legacycaller value",
|
||||
)
|
||||
harness.check(
|
||||
method.isStringifier(),
|
||||
stringifier,
|
||||
"Method has the correct stringifier value",
|
||||
)
|
||||
|
||||
harness.check(len(results), 2, "Expect 2 interfaces")
|
||||
|
||||
iface = results[0]
|
||||
harness.check(len(iface.members), 6, "Expect 6 members")
|
||||
|
||||
checkMethod(iface.members[0], "::SpecialMethods::__indexedgetter", "__indexedgetter",
|
||||
getter=True)
|
||||
checkMethod(iface.members[1], "::SpecialMethods::__indexedsetter", "__indexedsetter",
|
||||
setter=True)
|
||||
checkMethod(iface.members[2], "::SpecialMethods::__namedgetter", "__namedgetter",
|
||||
getter=True)
|
||||
checkMethod(iface.members[3], "::SpecialMethods::__namedsetter", "__namedsetter",
|
||||
setter=True)
|
||||
checkMethod(iface.members[4], "::SpecialMethods::__nameddeleter", "__nameddeleter",
|
||||
deleter=True)
|
||||
checkMethod(
|
||||
iface.members[0],
|
||||
"::SpecialMethods::__indexedgetter",
|
||||
"__indexedgetter",
|
||||
getter=True,
|
||||
)
|
||||
checkMethod(
|
||||
iface.members[1],
|
||||
"::SpecialMethods::__indexedsetter",
|
||||
"__indexedsetter",
|
||||
setter=True,
|
||||
)
|
||||
checkMethod(
|
||||
iface.members[2],
|
||||
"::SpecialMethods::__namedgetter",
|
||||
"__namedgetter",
|
||||
getter=True,
|
||||
)
|
||||
checkMethod(
|
||||
iface.members[3],
|
||||
"::SpecialMethods::__namedsetter",
|
||||
"__namedsetter",
|
||||
setter=True,
|
||||
)
|
||||
checkMethod(
|
||||
iface.members[4],
|
||||
"::SpecialMethods::__nameddeleter",
|
||||
"__nameddeleter",
|
||||
deleter=True,
|
||||
)
|
||||
|
||||
iface = results[1]
|
||||
harness.check(len(iface.members), 1, "Expect 1 member")
|
||||
|
||||
checkMethod(iface.members[0], "::SpecialMethodsCombination::__namedgetterdeleter",
|
||||
"__namedgetterdeleter", getter=True, deleter=True)
|
||||
checkMethod(
|
||||
iface.members[0],
|
||||
"::SpecialMethodsCombination::__namedgetterdeleter",
|
||||
"__namedgetterdeleter",
|
||||
getter=True,
|
||||
deleter=True,
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
|
||||
threw = False
|
||||
try:
|
||||
|
@ -63,11 +108,10 @@ def WebIDLTest(parser, harness):
|
|||
interface IndexedDeleter {
|
||||
deleter undefined(unsigned long index);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "There are no indexed deleters")
|
||||
|
||||
|
||||
|
|
|
@ -1,14 +1,17 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodUniqueness1 {
|
||||
getter deleter boolean (DOMString name);
|
||||
getter boolean (DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -18,12 +21,14 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodUniqueness1 {
|
||||
deleter boolean (DOMString name);
|
||||
getter deleter boolean (DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -33,12 +38,14 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface SpecialMethodUniqueness1 {
|
||||
setter boolean (DOMString name);
|
||||
setter boolean (DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,27 +1,34 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.ok(isinstance(results[0].members[0], WebIDL.IDLMethod),
|
||||
"Stringifer should be method")
|
||||
harness.ok(
|
||||
isinstance(results[0].members[0], WebIDL.IDLMethod),
|
||||
"Stringifer should be method",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier;
|
||||
stringifier;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -32,12 +39,14 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier;
|
||||
stringifier DOMString foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -45,70 +54,107 @@ def WebIDLTest(parser, harness):
|
|||
harness.ok(threw, "Should not allow a 'stringifier;' and a 'stringifier()'")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier attribute DOMString foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(isinstance(results[0].members[0], WebIDL.IDLAttribute),
|
||||
"Stringifier attribute should be an attribute")
|
||||
harness.ok(
|
||||
isinstance(results[0].members[0], WebIDL.IDLAttribute),
|
||||
"Stringifier attribute should be an attribute",
|
||||
)
|
||||
stringifier = results[0].members[1]
|
||||
harness.ok(isinstance(stringifier, WebIDL.IDLMethod),
|
||||
"Stringifier attribute should insert a method")
|
||||
harness.ok(stringifier.isStringifier(),
|
||||
"Inserted method should be a stringifier")
|
||||
harness.ok(
|
||||
isinstance(stringifier, WebIDL.IDLMethod),
|
||||
"Stringifier attribute should insert a method",
|
||||
)
|
||||
harness.ok(stringifier.isStringifier(), "Inserted method should be a stringifier")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {};
|
||||
interface mixin TestStringifierMixin {
|
||||
stringifier attribute DOMString foo;
|
||||
};
|
||||
TestStringifier includes TestStringifierMixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.ok(isinstance(results[0].members[0], WebIDL.IDLAttribute),
|
||||
"Stringifier attribute should be an attribute")
|
||||
harness.ok(
|
||||
isinstance(results[0].members[0], WebIDL.IDLAttribute),
|
||||
"Stringifier attribute should be an attribute",
|
||||
)
|
||||
stringifier = results[0].members[1]
|
||||
harness.ok(isinstance(stringifier, WebIDL.IDLMethod),
|
||||
"Stringifier attribute should insert a method")
|
||||
harness.ok(stringifier.isStringifier(),
|
||||
"Inserted method should be a stringifier")
|
||||
harness.ok(
|
||||
isinstance(stringifier, WebIDL.IDLMethod),
|
||||
"Stringifier attribute should insert a method",
|
||||
)
|
||||
harness.ok(stringifier.isStringifier(), "Inserted method should be a stringifier")
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier attribute USVString foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
stringifier = results[0].members[1]
|
||||
harness.ok(stringifier.signatures()[0][0].isUSVString(),
|
||||
"Stringifier attributes should allow USVString")
|
||||
harness.ok(
|
||||
stringifier.signatures()[0][0].isUSVString(),
|
||||
"Stringifier attributes should allow USVString",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
[Throws, NeedsSubjectPrincipal]
|
||||
stringifier attribute USVString foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
stringifier = results[0].members[1]
|
||||
harness.ok(stringifier.getExtendedAttribute("Throws"),
|
||||
"Stringifier attributes should support [Throws]")
|
||||
harness.ok(stringifier.getExtendedAttribute("NeedsSubjectPrincipal"),
|
||||
"Stringifier attributes should support [NeedsSubjectPrincipal]")
|
||||
harness.ok(
|
||||
stringifier.getExtendedAttribute("Throws"),
|
||||
"Stringifier attributes should support [Throws]",
|
||||
)
|
||||
harness.ok(
|
||||
stringifier.getExtendedAttribute("NeedsSubjectPrincipal"),
|
||||
"Stringifier attributes should support [NeedsSubjectPrincipal]",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier attribute UTF8String foo;
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
stringifier = results[0].members[1]
|
||||
harness.ok(
|
||||
stringifier.signatures()[0][0].isUTF8String(),
|
||||
"Stringifier attributes should allow UTF8String",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier attribute ByteString foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -118,12 +164,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier;
|
||||
stringifier attribute DOMString foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -133,12 +181,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestStringifier {
|
||||
stringifier attribute DOMString foo;
|
||||
stringifier attribute DOMString bar;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
|
|
@ -6,7 +6,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Test {
|
||||
object toJSON();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -21,7 +22,8 @@ def WebIDLTest(parser, harness):
|
|||
object toJSON(object arg);
|
||||
object toJSON(long arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -35,7 +37,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Test {
|
||||
object toJSON(object arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -49,7 +52,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Test {
|
||||
long toJSON();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -63,11 +67,14 @@ def WebIDLTest(parser, harness):
|
|||
interface Test {
|
||||
[Default] object toJSON();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(not threw, "Should allow a default toJSON method with 'object' as return type.")
|
||||
harness.ok(
|
||||
not threw, "Should allow a default toJSON method with 'object' as return type."
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
@ -77,119 +84,226 @@ def WebIDLTest(parser, harness):
|
|||
interface Test {
|
||||
[Default] long toJSON();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw, "Should not allow a default toJSON method with non-'object' as return type.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should not allow a default toJSON method with non-'object' as return type.",
|
||||
)
|
||||
|
||||
JsonTypes = [ "byte", "octet", "short", "unsigned short", "long", "unsigned long", "long long",
|
||||
"unsigned long long", "float", "unrestricted float", "double", "unrestricted double", "boolean",
|
||||
"DOMString", "ByteString", "UTF8String", "USVString", "Enum", "InterfaceWithToJSON", "object" ]
|
||||
JsonTypes = [
|
||||
"byte",
|
||||
"octet",
|
||||
"short",
|
||||
"unsigned short",
|
||||
"long",
|
||||
"unsigned long",
|
||||
"long long",
|
||||
"unsigned long long",
|
||||
"float",
|
||||
"unrestricted float",
|
||||
"double",
|
||||
"unrestricted double",
|
||||
"boolean",
|
||||
"DOMString",
|
||||
"ByteString",
|
||||
"UTF8String",
|
||||
"USVString",
|
||||
"Enum",
|
||||
"InterfaceWithToJSON",
|
||||
"object",
|
||||
]
|
||||
|
||||
nonJsonTypes = [ "InterfaceWithoutToJSON", "any", "Int8Array", "Int16Array", "Int32Array","Uint8Array",
|
||||
"Uint16Array", "Uint32Array", "Uint8ClampedArray", "Float32Array", "Float64Array", "ArrayBuffer" ]
|
||||
nonJsonTypes = [
|
||||
"InterfaceWithoutToJSON",
|
||||
"any",
|
||||
"Int8Array",
|
||||
"Int16Array",
|
||||
"Int32Array",
|
||||
"Uint8Array",
|
||||
"Uint16Array",
|
||||
"Uint32Array",
|
||||
"Uint8ClampedArray",
|
||||
"Float32Array",
|
||||
"Float64Array",
|
||||
"ArrayBuffer",
|
||||
]
|
||||
|
||||
def doTest(testIDL, shouldThrow, description):
|
||||
p = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
p.parse(testIDL +
|
||||
"""
|
||||
p.parse(
|
||||
testIDL
|
||||
+ """
|
||||
enum Enum { "a", "b", "c" };
|
||||
interface InterfaceWithToJSON { long toJSON(); };
|
||||
interface InterfaceWithoutToJSON {};
|
||||
""");
|
||||
p.finish();
|
||||
"""
|
||||
)
|
||||
p.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(x.message == "toJSON method has non-JSON return type", x)
|
||||
harness.check(threw, shouldThrow, description)
|
||||
|
||||
|
||||
for type in JsonTypes:
|
||||
doTest("interface Test { %s toJSON(); };" % type, False,
|
||||
"%s should be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { %s toJSON(); };" % type,
|
||||
False,
|
||||
"%s should be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Test { sequence<%s> toJSON(); };" % type, False,
|
||||
"sequence<%s> should be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { sequence<%s> toJSON(); };" % type,
|
||||
False,
|
||||
"sequence<%s> should be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("dictionary Foo { %s foo; }; "
|
||||
"interface Test { Foo toJSON(); }; " % type, False,
|
||||
"dictionary containing only JSON type (%s) should be a JSON type" % type)
|
||||
doTest(
|
||||
"dictionary Foo { %s foo; }; " "interface Test { Foo toJSON(); }; " % type,
|
||||
False,
|
||||
"dictionary containing only JSON type (%s) should be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("dictionary Foo { %s foo; }; dictionary Bar : Foo { }; "
|
||||
"interface Test { Bar toJSON(); }; " % type, False,
|
||||
"dictionary whose ancestors only contain JSON types should be a JSON type")
|
||||
doTest(
|
||||
"dictionary Foo { %s foo; }; dictionary Bar : Foo { }; "
|
||||
"interface Test { Bar toJSON(); }; " % type,
|
||||
False,
|
||||
"dictionary whose ancestors only contain JSON types should be a JSON type",
|
||||
)
|
||||
|
||||
doTest("dictionary Foo { any foo; }; dictionary Bar : Foo { %s bar; };"
|
||||
"interface Test { Bar toJSON(); };" % type, True,
|
||||
"dictionary whose ancestors contain non-JSON types should not be a JSON type")
|
||||
doTest(
|
||||
"dictionary Foo { any foo; }; dictionary Bar : Foo { %s bar; };"
|
||||
"interface Test { Bar toJSON(); };" % type,
|
||||
True,
|
||||
"dictionary whose ancestors contain non-JSON types should not be a JSON type",
|
||||
)
|
||||
|
||||
doTest("interface Test { record<DOMString, %s> toJSON(); };" % type, False,
|
||||
"record<DOMString, %s> should be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { record<DOMString, %s> toJSON(); };" % type,
|
||||
False,
|
||||
"record<DOMString, %s> should be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Test { record<ByteString, %s> toJSON(); };" % type, False,
|
||||
"record<ByteString, %s> should be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { record<ByteString, %s> toJSON(); };" % type,
|
||||
False,
|
||||
"record<ByteString, %s> should be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Test { record<UTF8String, %s> toJSON(); };" % type, False,
|
||||
"record<UTF8String, %s> should be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { record<UTF8String, %s> toJSON(); };" % type,
|
||||
False,
|
||||
"record<UTF8String, %s> should be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Test { record<USVString, %s> toJSON(); };" % type, False,
|
||||
"record<USVString, %s> should be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { record<USVString, %s> toJSON(); };" % type,
|
||||
False,
|
||||
"record<USVString, %s> should be a JSON type" % type,
|
||||
)
|
||||
|
||||
otherUnionType = "Foo" if type != "object" else "long"
|
||||
doTest("interface Foo { object toJSON(); };"
|
||||
"interface Test { (%s or %s) toJSON(); };" % (otherUnionType, type), False,
|
||||
"union containing only JSON types (%s or %s) should be a JSON type" %(otherUnionType, type))
|
||||
doTest(
|
||||
"interface Foo { object toJSON(); };"
|
||||
"interface Test { (%s or %s) toJSON(); };" % (otherUnionType, type),
|
||||
False,
|
||||
"union containing only JSON types (%s or %s) should be a JSON type"
|
||||
% (otherUnionType, type),
|
||||
)
|
||||
|
||||
doTest("interface test { %s? toJSON(); };" % type, False,
|
||||
"Nullable type (%s) should be a JSON type" % type)
|
||||
doTest(
|
||||
"interface test { %s? toJSON(); };" % type,
|
||||
False,
|
||||
"Nullable type (%s) should be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Foo : InterfaceWithoutToJSON { %s toJSON(); };"
|
||||
"interface Test { Foo toJSON(); };" % type, False,
|
||||
"interface with toJSON should be a JSON type")
|
||||
doTest(
|
||||
"interface Foo : InterfaceWithoutToJSON { %s toJSON(); };"
|
||||
"interface Test { Foo toJSON(); };" % type,
|
||||
False,
|
||||
"interface with toJSON should be a JSON type",
|
||||
)
|
||||
|
||||
doTest("interface Foo : InterfaceWithToJSON { };"
|
||||
"interface Test { Foo toJSON(); };", False,
|
||||
"inherited interface with toJSON should be a JSON type")
|
||||
doTest(
|
||||
"interface Foo : InterfaceWithToJSON { };" "interface Test { Foo toJSON(); };",
|
||||
False,
|
||||
"inherited interface with toJSON should be a JSON type",
|
||||
)
|
||||
|
||||
for type in nonJsonTypes:
|
||||
doTest("interface Test { %s toJSON(); };" % type, True,
|
||||
"%s should not be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { %s toJSON(); };" % type,
|
||||
True,
|
||||
"%s should not be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Test { sequence<%s> toJSON(); };" % type, True,
|
||||
"sequence<%s> should not be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { sequence<%s> toJSON(); };" % type,
|
||||
True,
|
||||
"sequence<%s> should not be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("dictionary Foo { %s foo; }; "
|
||||
"interface Test { Foo toJSON(); }; " % type, True,
|
||||
"Dictionary containing a non-JSON type (%s) should not be a JSON type" % type)
|
||||
doTest(
|
||||
"dictionary Foo { %s foo; }; " "interface Test { Foo toJSON(); }; " % type,
|
||||
True,
|
||||
"Dictionary containing a non-JSON type (%s) should not be a JSON type"
|
||||
% type,
|
||||
)
|
||||
|
||||
doTest("dictionary Foo { %s foo; }; dictionary Bar : Foo { }; "
|
||||
"interface Test { Bar toJSON(); }; " % type, True,
|
||||
"dictionary whose ancestors only contain non-JSON types should not be a JSON type")
|
||||
doTest(
|
||||
"dictionary Foo { %s foo; }; dictionary Bar : Foo { }; "
|
||||
"interface Test { Bar toJSON(); }; " % type,
|
||||
True,
|
||||
"dictionary whose ancestors only contain non-JSON types should not be a JSON type",
|
||||
)
|
||||
|
||||
doTest("interface Test { record<DOMString, %s> toJSON(); };" % type, True,
|
||||
"record<DOMString, %s> should not be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { record<DOMString, %s> toJSON(); };" % type,
|
||||
True,
|
||||
"record<DOMString, %s> should not be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Test { record<ByteString, %s> toJSON(); };" % type, True,
|
||||
"record<ByteString, %s> should not be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { record<ByteString, %s> toJSON(); };" % type,
|
||||
True,
|
||||
"record<ByteString, %s> should not be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("interface Test { record<USVString, %s> toJSON(); };" % type, True,
|
||||
"record<USVString, %s> should not be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Test { record<USVString, %s> toJSON(); };" % type,
|
||||
True,
|
||||
"record<USVString, %s> should not be a JSON type" % type,
|
||||
)
|
||||
|
||||
if type != "any":
|
||||
doTest("interface Foo { object toJSON(); }; "
|
||||
"interface Test { (Foo or %s) toJSON(); };" % type, True,
|
||||
"union containing a non-JSON type (%s) should not be a JSON type" % type)
|
||||
doTest(
|
||||
"interface Foo { object toJSON(); }; "
|
||||
"interface Test { (Foo or %s) toJSON(); };" % type,
|
||||
True,
|
||||
"union containing a non-JSON type (%s) should not be a JSON type"
|
||||
% type,
|
||||
)
|
||||
|
||||
doTest("interface test { %s? toJSON(); };" % type, True,
|
||||
"Nullable type (%s) should not be a JSON type" % type)
|
||||
doTest(
|
||||
"interface test { %s? toJSON(); };" % type,
|
||||
True,
|
||||
"Nullable type (%s) should not be a JSON type" % type,
|
||||
)
|
||||
|
||||
doTest("dictionary Foo { long foo; any bar; };"
|
||||
"interface Test { Foo toJSON(); };", True,
|
||||
"dictionary containing a non-JSON type should not be a JSON type")
|
||||
doTest(
|
||||
"dictionary Foo { long foo; any bar; };" "interface Test { Foo toJSON(); };",
|
||||
True,
|
||||
"dictionary containing a non-JSON type should not be a JSON type",
|
||||
)
|
||||
|
||||
doTest("interface Foo : InterfaceWithoutToJSON { }; "
|
||||
"interface Test { Foo toJSON(); };", True,
|
||||
"interface without toJSON should not be a JSON type")
|
||||
doTest(
|
||||
"interface Foo : InterfaceWithoutToJSON { }; "
|
||||
"interface Test { Foo toJSON(); };",
|
||||
True,
|
||||
"interface without toJSON should not be a JSON type",
|
||||
)
|
||||
|
|
|
@ -1,14 +1,17 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[TreatNonCallableAsNull] callback Function = any(any... arguments);
|
||||
|
||||
interface TestTreatNonCallableAsNull1 {
|
||||
attribute Function? onfoo;
|
||||
attribute Function onbar;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
|
@ -22,13 +25,15 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
callback Function = any(any... arguments);
|
||||
|
||||
interface TestTreatNonCallableAsNull2 {
|
||||
[TreatNonCallableAsNull] attribute Function onfoo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -40,14 +45,16 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
callback Function = any(any... arguments);
|
||||
|
||||
[TreatNonCallableAsNull]
|
||||
interface TestTreatNonCallableAsNull3 {
|
||||
attribute Function onfoo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
@ -59,10 +66,12 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
[TreatNonCallableAsNull, TreatNonObjectAsNull]
|
||||
parser.parse(
|
||||
"""
|
||||
[TreatNonCallableAsNull, LegacyTreatNonObjectAsNull]
|
||||
callback Function = any(any... arguments);
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef long mylong;
|
||||
typedef long? mynullablelong;
|
||||
interface Foo {
|
||||
|
@ -8,22 +9,28 @@ def WebIDLTest(parser, harness):
|
|||
undefined bar(optional mynullablelong arg = null);
|
||||
undefined baz(mylong arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(results[2].members[1].signatures()[0][1][0].type.name, "LongOrNull",
|
||||
"Should expand typedefs")
|
||||
harness.check(
|
||||
results[2].members[1].signatures()[0][1][0].type.name,
|
||||
"LongOrNull",
|
||||
"Should expand typedefs",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef long? mynullablelong;
|
||||
interface Foo {
|
||||
undefined foo(mynullablelong? Y);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -33,12 +40,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
typedef long? mynullablelong;
|
||||
interface Foo {
|
||||
const mynullablelong? X = 5;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
@ -48,29 +57,38 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
const mynullablelong? X = 5;
|
||||
};
|
||||
typedef long? mynullablelong;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown on nullable inside nullable const typedef "
|
||||
"after interface.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown on nullable inside nullable const typedef "
|
||||
"after interface.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
const mylong X = 5;
|
||||
};
|
||||
typedef long mylong;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(results[0].members[0].type.name, "Long",
|
||||
"Should expand typedefs that come before interface")
|
||||
harness.check(
|
||||
results[0].members[0].type.name,
|
||||
"Long",
|
||||
"Should expand typedefs that come before interface",
|
||||
)
|
||||
|
|
|
@ -5,12 +5,15 @@ def WebIDLTest(parser, harness):
|
|||
"""
|
||||
typedef long foo;
|
||||
typedef long foo;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as e:
|
||||
exception = e
|
||||
|
||||
harness.ok(exception, "Should have thrown.")
|
||||
harness.ok("Multiple unresolvable definitions of identifier 'foo'" in str(exception),
|
||||
"Should have a sane exception message")
|
||||
harness.ok(
|
||||
"Multiple unresolvable definitions of identifier 'foo'" in str(exception),
|
||||
"Should have a sane exception message",
|
||||
)
|
||||
|
|
|
@ -0,0 +1,246 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {
|
||||
undefined undefinedMember;
|
||||
double bar;
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "undefined must not be used as the type of a dictionary member")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
dictionary Dict {
|
||||
(undefined or double) undefinedMemberOfUnionInDict;
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of a dictionary member, "
|
||||
"whether directly or in a union",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
double bar(undefined foo);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of a regular operation)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
getter double(undefined name);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of a getter)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
setter undefined(DOMString name, undefined value);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of a setter)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
deleter undefined (undefined name);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of a deleter)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
constructor (undefined foo);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of a constructor)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
callback Callback = undefined (undefined foo);
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of a callback)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
async iterable(undefined name);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of an async iterable "
|
||||
"iterator)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
static double bar(undefined foo);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined must not be used as the type of an argument in any "
|
||||
"circumstance (so not as the argument of a static operation)",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
const undefined FOO = undefined;
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined is not a valid type for a constant",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Foo {
|
||||
const any FOO = undefined;
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(
|
||||
threw,
|
||||
"undefined is not a valid value for a constant",
|
||||
)
|
|
@ -10,18 +10,21 @@ def WebIDLTest(parser, harness):
|
|||
interface Baz : Bar {
|
||||
getter long(DOMString name);
|
||||
};
|
||||
""");
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 3, "Should have three interfaces")
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyUnenumerableNamedProperties]
|
||||
interface NoNamedGetter {
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -31,12 +34,14 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyUnenumerableNamedProperties=Foo]
|
||||
interface ShouldNotHaveArg {
|
||||
getter long(DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
@ -46,7 +51,8 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
[LegacyUnenumerableNamedProperties]
|
||||
interface Foo {
|
||||
getter long(DOMString name);
|
||||
|
@ -56,7 +62,8 @@ def WebIDLTest(parser, harness):
|
|||
interface Baz : Bar {
|
||||
getter long(DOMString name);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
|
|
|
@ -1,253 +1,311 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2,
|
||||
"Should be able to inherit from an interface with "
|
||||
"[Unforgeable] properties.")
|
||||
harness.check(
|
||||
len(results),
|
||||
2,
|
||||
"Should be able to inherit from an interface with "
|
||||
"[LegacyUnforgeable] properties.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser.parse("""
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
const short foo = 10;
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2,
|
||||
"Should be able to inherit from an interface with "
|
||||
"[Unforgeable] properties even if we have a constant with "
|
||||
"the same name.")
|
||||
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("""
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
static attribute short foo;
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2,
|
||||
"Should be able to inherit from an interface with "
|
||||
"[Unforgeable] properties even if we have a static attribute "
|
||||
"with the same name.")
|
||||
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("""
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
static undefined foo();
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 2,
|
||||
"Should be able to inherit from an interface with "
|
||||
"[Unforgeable] properties even if we have a static operation "
|
||||
"with the same name.")
|
||||
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();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
undefined foo();
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should have thrown when shadowing unforgeable attribute on "
|
||||
"parent with operation.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown when shadowing unforgeable attribute on "
|
||||
"parent with operation.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
undefined foo();
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] undefined foo();
|
||||
[LegacyUnforgeable] undefined foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should have thrown when shadowing unforgeable operation on "
|
||||
"parent with operation.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown when shadowing unforgeable operation on "
|
||||
"parent with operation.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
attribute short foo;
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should have thrown when shadowing unforgeable attribute on "
|
||||
"parent with attribute.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown when shadowing unforgeable attribute on "
|
||||
"parent with attribute.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
attribute short foo;
|
||||
};
|
||||
interface Parent {
|
||||
[Unforgeable] undefined foo();
|
||||
[LegacyUnforgeable] undefined foo();
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except Exception as x:
|
||||
threw = True
|
||||
harness.ok(threw,
|
||||
"Should have thrown when shadowing unforgeable operation on "
|
||||
"parent with attribute.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown when shadowing unforgeable operation on "
|
||||
"parent with attribute.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser.parse("""
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
};
|
||||
interface Parent {};
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[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 [Unforgeable] properties.")
|
||||
harness.check(
|
||||
len(results),
|
||||
4,
|
||||
"Should be able to inherit from an interface with a "
|
||||
"mixin with [LegacyUnforgeable] properties.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
undefined foo();
|
||||
};
|
||||
interface Parent {};
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
Parent includes Mixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown when shadowing unforgeable attribute "
|
||||
"of parent's consequential interface.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown when shadowing unforgeable attribute "
|
||||
"of parent's consequential interface.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
};
|
||||
interface Parent : GrandParent {};
|
||||
interface GrandParent {};
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] readonly attribute long foo;
|
||||
[LegacyUnforgeable] readonly attribute long foo;
|
||||
};
|
||||
GrandParent includes Mixin;
|
||||
interface mixin ChildMixin {
|
||||
undefined foo();
|
||||
};
|
||||
Child includes ChildMixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown when our consequential interface shadows unforgeable attribute "
|
||||
"of ancestor's consequential interface.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown when our consequential interface shadows unforgeable attribute "
|
||||
"of ancestor's consequential interface.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface Child : Parent {
|
||||
};
|
||||
interface Parent : GrandParent {};
|
||||
interface GrandParent {};
|
||||
interface mixin Mixin {
|
||||
[Unforgeable] undefined foo();
|
||||
[LegacyUnforgeable] undefined foo();
|
||||
};
|
||||
GrandParent includes Mixin;
|
||||
interface mixin ChildMixin {
|
||||
undefined foo();
|
||||
};
|
||||
Child includes ChildMixin;
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown when our consequential interface shadows unforgeable operation "
|
||||
"of ancestor's consequential interface.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown when our consequential interface shadows unforgeable operation "
|
||||
"of ancestor's consequential interface.",
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser.parse("""
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface iface {
|
||||
[Unforgeable] attribute long foo;
|
||||
[LegacyUnforgeable] attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
harness.check(len(results), 1,
|
||||
"Should allow writable [Unforgeable] attribute.")
|
||||
harness.check(
|
||||
len(results), 1, "Should allow writable [LegacyUnforgeable] attribute."
|
||||
)
|
||||
|
||||
parser = parser.reset();
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface iface {
|
||||
[Unforgeable] static readonly attribute long foo;
|
||||
[LegacyUnforgeable] static readonly attribute long foo;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw, "Should have thrown for static [Unforgeable] attribute.")
|
||||
harness.ok(threw, "Should have thrown for static [LegacyUnforgeable] attribute.")
|
||||
|
|
|
@ -3,12 +3,15 @@ import itertools
|
|||
import string
|
||||
|
||||
# We'd like to use itertools.chain but it's 2.6 or higher.
|
||||
|
||||
|
||||
def chain(*iterables):
|
||||
# chain('ABC', 'DEF') --> A B C D E F
|
||||
for it in iterables:
|
||||
for element in it:
|
||||
yield element
|
||||
|
||||
|
||||
# We'd like to use itertools.combinations but it's 2.6 or higher.
|
||||
def combinations(iterable, r):
|
||||
# combinations('ABCD', 2) --> AB AC AD BC BD CD
|
||||
|
@ -26,10 +29,11 @@ def combinations(iterable, r):
|
|||
else:
|
||||
return
|
||||
indices[i] += 1
|
||||
for j in range(i+1, r):
|
||||
indices[j] = indices[j-1] + 1
|
||||
for j in range(i + 1, r):
|
||||
indices[j] = indices[j - 1] + 1
|
||||
yield tuple(pool[i] for i in indices)
|
||||
|
||||
|
||||
# We'd like to use itertools.combinations_with_replacement but it's 2.7 or
|
||||
# higher.
|
||||
def combinations_with_replacement(iterable, r):
|
||||
|
@ -49,27 +53,30 @@ def combinations_with_replacement(iterable, r):
|
|||
indices[i:] = [indices[i] + 1] * (r - i)
|
||||
yield tuple(pool[i] for i in indices)
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
types = ["float",
|
||||
"double",
|
||||
"short",
|
||||
"unsigned short",
|
||||
"long",
|
||||
"unsigned long",
|
||||
"long long",
|
||||
"unsigned long long",
|
||||
"boolean",
|
||||
"byte",
|
||||
"octet",
|
||||
"DOMString",
|
||||
"ByteString",
|
||||
"USVString",
|
||||
#"sequence<float>",
|
||||
"object",
|
||||
"ArrayBuffer",
|
||||
#"Date",
|
||||
"TestInterface1",
|
||||
"TestInterface2"]
|
||||
types = [
|
||||
"float",
|
||||
"double",
|
||||
"short",
|
||||
"unsigned short",
|
||||
"long",
|
||||
"unsigned long",
|
||||
"long long",
|
||||
"unsigned long long",
|
||||
"boolean",
|
||||
"byte",
|
||||
"octet",
|
||||
"DOMString",
|
||||
"ByteString",
|
||||
"USVString",
|
||||
# "sequence<float>",
|
||||
"object",
|
||||
"ArrayBuffer",
|
||||
# "Date",
|
||||
"TestInterface1",
|
||||
"TestInterface2",
|
||||
]
|
||||
|
||||
testPre = """
|
||||
interface TestInterface1 {
|
||||
|
@ -78,13 +85,18 @@ def WebIDLTest(parser, harness):
|
|||
};
|
||||
"""
|
||||
|
||||
interface = testPre + """
|
||||
interface = (
|
||||
testPre
|
||||
+ """
|
||||
interface PrepareForTest {
|
||||
"""
|
||||
)
|
||||
for (i, type) in enumerate(types):
|
||||
interface += string.Template("""
|
||||
interface += string.Template(
|
||||
"""
|
||||
readonly attribute ${type} attr${i};
|
||||
""").substitute(i=i, type=type)
|
||||
"""
|
||||
).substitute(i=i, type=type)
|
||||
interface += """
|
||||
};
|
||||
"""
|
||||
|
@ -98,8 +110,10 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
def typesAreDistinguishable(t):
|
||||
return all(u[0].isDistinguishableFrom(u[1]) for u in combinations(t, 2))
|
||||
|
||||
def typesAreNotDistinguishable(t):
|
||||
return any(not u[0].isDistinguishableFrom(u[1]) for u in combinations(t, 2))
|
||||
|
||||
def unionTypeName(t):
|
||||
if len(t) > 2:
|
||||
t[0:2] = [unionTypeName(t[0:2])]
|
||||
|
@ -118,29 +132,40 @@ def WebIDLTest(parser, harness):
|
|||
# as a string and the parsed IDL type.
|
||||
def invalidUnionWithUnion(typeCombinations):
|
||||
for c in typeCombinations:
|
||||
if (typesAreNotDistinguishable((c[0][1], c[1][1])) and
|
||||
typesAreDistinguishable((c[1][1], c[2][1])) and
|
||||
typesAreDistinguishable((c[0][1], c[2][1]))):
|
||||
if (
|
||||
typesAreNotDistinguishable((c[0][1], c[1][1]))
|
||||
and typesAreDistinguishable((c[1][1], c[2][1]))
|
||||
and typesAreDistinguishable((c[0][1], c[2][1]))
|
||||
):
|
||||
yield unionTypeName([t[0] for t in c])
|
||||
|
||||
# Create a list of tuples containing the name of the type as a string and
|
||||
# the parsed IDL type.
|
||||
types = zip(types, (a.type for a in iface.members))
|
||||
|
||||
validUnionTypes = chain(unionTypes(combinations(types, 2), typesAreDistinguishable),
|
||||
unionTypes(combinations(types, 3), typesAreDistinguishable))
|
||||
invalidUnionTypes = chain(unionTypes(combinations_with_replacement(types, 2), typesAreNotDistinguishable),
|
||||
invalidUnionWithUnion(combinations(types, 3)))
|
||||
interface = testPre + """
|
||||
validUnionTypes = chain(
|
||||
unionTypes(combinations(types, 2), typesAreDistinguishable),
|
||||
unionTypes(combinations(types, 3), typesAreDistinguishable),
|
||||
)
|
||||
invalidUnionTypes = chain(
|
||||
unionTypes(combinations_with_replacement(types, 2), typesAreNotDistinguishable),
|
||||
invalidUnionWithUnion(combinations(types, 3)),
|
||||
)
|
||||
interface = (
|
||||
testPre
|
||||
+ """
|
||||
interface TestUnion {
|
||||
"""
|
||||
)
|
||||
for (i, type) in enumerate(validUnionTypes):
|
||||
interface += string.Template("""
|
||||
interface += string.Template(
|
||||
"""
|
||||
undefined method${i}(${type} arg);
|
||||
${type} returnMethod${i}();
|
||||
attribute ${type} attr${i};
|
||||
undefined optionalMethod${i}(${type}? arg);
|
||||
""").substitute(i=i, type=type)
|
||||
"""
|
||||
).substitute(i=i, type=type)
|
||||
interface += """
|
||||
};
|
||||
"""
|
||||
|
@ -150,11 +175,16 @@ def WebIDLTest(parser, harness):
|
|||
parser = parser.reset()
|
||||
|
||||
for invalid in invalidUnionTypes:
|
||||
interface = testPre + string.Template("""
|
||||
interface = (
|
||||
testPre
|
||||
+ string.Template(
|
||||
"""
|
||||
interface TestUnion {
|
||||
undefined method(${type} arg);
|
||||
};
|
||||
""").substitute(type=invalid)
|
||||
"""
|
||||
).substitute(type=invalid)
|
||||
)
|
||||
|
||||
threw = False
|
||||
try:
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface AnyNotInUnion {
|
||||
undefined foo((any or DOMString) arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
|
|
|
@ -1,53 +1,60 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface OneNullableInUnion {
|
||||
undefined foo((object? or DOMString?) arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Two nullable member types of a union should have thrown.")
|
||||
harness.ok(threw, "Two nullable member types of a union should have thrown.")
|
||||
|
||||
parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface NullableInNullableUnion {
|
||||
undefined foo((object? or DOMString)? arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"A nullable union type with a nullable member type should have "
|
||||
"thrown.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"A nullable union type with a nullable member type should have " "thrown.",
|
||||
)
|
||||
|
||||
parser.reset()
|
||||
threw = False
|
||||
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface NullableInUnionNullableUnionHelper {
|
||||
};
|
||||
interface NullableInUnionNullableUnion {
|
||||
undefined foo(((object? or DOMString) or NullableInUnionNullableUnionHelper)? arg);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"A nullable union type with a nullable member type should have "
|
||||
"thrown.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"A nullable union type with a nullable member type should have " "thrown.",
|
||||
)
|
||||
|
|
|
@ -2,23 +2,27 @@
|
|||
|
||||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface TestUSVString {
|
||||
attribute USVString svs;
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish();
|
||||
results = parser.finish()
|
||||
|
||||
harness.check(len(results), 1, "Should be one production")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
|
||||
"Should be an IDLInterface")
|
||||
harness.ok(isinstance(results[0], WebIDL.IDLInterface), "Should be an IDLInterface")
|
||||
iface = results[0]
|
||||
harness.check(iface.identifier.QName(), "::TestUSVString",
|
||||
"Interface has the right QName")
|
||||
harness.check(iface.identifier.name, "TestUSVString",
|
||||
"Interface has the right name")
|
||||
harness.check(
|
||||
iface.identifier.QName(), "::TestUSVString", "Interface has the right QName"
|
||||
)
|
||||
harness.check(
|
||||
iface.identifier.name, "TestUSVString", "Interface has the right name"
|
||||
)
|
||||
harness.check(iface.parent, None, "Interface has no parent")
|
||||
|
||||
members = iface.members
|
||||
|
@ -26,11 +30,11 @@ def WebIDLTest(parser, harness):
|
|||
|
||||
attr = members[0]
|
||||
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
|
||||
harness.check(attr.identifier.QName(), "::TestUSVString::svs",
|
||||
"Attr has correct QName")
|
||||
harness.check(
|
||||
attr.identifier.QName(), "::TestUSVString::svs", "Attr has correct QName"
|
||||
)
|
||||
harness.check(attr.identifier.name, "svs", "Attr has correct name")
|
||||
harness.check(str(attr.type), "USVString",
|
||||
"Attr type is the correct name")
|
||||
harness.check(str(attr.type), "USVString", "Attr type is the correct name")
|
||||
harness.ok(attr.type.isUSVString(), "Should be USVString type")
|
||||
harness.ok(attr.type.isString(), "Should be String collective type")
|
||||
harness.ok(not attr.type.isDOMString(), "Should be not be DOMString type")
|
||||
|
|
|
@ -1,9 +1,12 @@
|
|||
import WebIDL
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
callback TestVariadicCallback = any(any... arguments);
|
||||
""")
|
||||
"""
|
||||
)
|
||||
|
||||
results = parser.finish()
|
||||
|
||||
|
|
|
@ -1,61 +1,72 @@
|
|||
def WebIDLTest(parser, harness):
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface VariadicConstraints1 {
|
||||
undefined foo(byte... arg1, byte arg2);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown on variadic argument followed by required "
|
||||
"argument.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown on variadic argument followed by required " "argument.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface VariadicConstraints2 {
|
||||
undefined foo(byte... arg1, optional byte arg2);
|
||||
};
|
||||
""")
|
||||
results = parser.finish();
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown on variadic argument followed by optional "
|
||||
"argument.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown on variadic argument followed by optional " "argument.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface VariadicConstraints3 {
|
||||
undefined foo(optional byte... arg1);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
except:
|
||||
threw = True
|
||||
|
||||
harness.ok(threw,
|
||||
"Should have thrown on variadic argument explicitly flagged as "
|
||||
"optional.")
|
||||
harness.ok(
|
||||
threw,
|
||||
"Should have thrown on variadic argument explicitly flagged as " "optional.",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse("""
|
||||
parser.parse(
|
||||
"""
|
||||
interface VariadicConstraints4 {
|
||||
undefined foo(byte... arg1 = 0);
|
||||
};
|
||||
""")
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue