Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update the WebIDL parser

Browse source
This commit is contained in:
Anthony Ramine 2018-09-14 11:15:35 +02:00
parent 70a0174b0a
commit 2b574bbdf8
6 changed files with 284 additions and 108 deletions
Download patch file Download diff file Expand all files Collapse all files

14
components/script/dom/bindings/codegen/parser/tests/test_cereactions.py
View file

@ -131,17 +131,3 @@ def WebIDLTest(parser, harness):
harness.ok(threw,
"Should have thrown for [CEReactions] used on a stringifier")
parser = parser.reset()
threw = False
try:
parser.parse("""
interface Foo {
[CEReactions] jsonifier;
};
""")
results = parser.finish()
except:
threw = True
harness.ok(threw, "Should have thrown for [CEReactions] used on a jsonifier")

29
components/script/dom/bindings/codegen/parser/tests/test_interface.py
View file

@ -374,32 +374,3 @@ def WebIDLTest(parser, harness):
threw = True
harness.ok(threw,
"Should not allow unknown extended attributes on interfaces")
parser = parser.reset()
threw = False
try:
parser.parse("""
interface B {};
[ArrayClass]
interface A : B {
};
""")
results = parser.finish()
except:
threw = True
harness.ok(threw,
"Should not allow [ArrayClass] on interfaces with parents")
parser = parser.reset()
threw = False
try:
parser.parse("""
[ArrayClass]
interface A {
};
""")
results = parser.finish()
except:
threw = True
harness.ok(not threw,
"Should allow [ArrayClass] on interfaces without parents")

192
components/script/dom/bindings/codegen/parser/tests/test_toJSON.py Normal file
View file

@ -0,0 +1,192 @@
def WebIDLTest(parser, harness):
threw = False
try:
parser.parse(
"""
interface Test {
object toJSON();
};
""")
results = parser.finish()
except:
threw = True
harness.ok(not threw, "Should allow a toJSON method.")
parser = parser.reset()
threw = False
try:
parser.parse(
"""
interface Test {
object toJSON(object arg);
object toJSON(long arg);
};
""")
results = parser.finish()
except:
threw = True
harness.ok(threw, "Should not allow overloads of a toJSON method.")
parser = parser.reset()
threw = False
try:
parser.parse(
"""
interface Test {
object toJSON(object arg);
};
""")
results = parser.finish()
except:
threw = True
harness.ok(threw, "Should not allow a toJSON method with arguments.")
parser = parser.reset()
threw = False
try:
parser.parse(
"""
interface Test {
long toJSON();
};
""")
results = parser.finish()
except:
threw = True
harness.ok(not threw, "Should allow a toJSON method with 'long' as return type.")
parser = parser.reset()
threw = False
try:
parser.parse(
"""
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.")
parser = parser.reset()
threw = False
try:
parser.parse(
"""
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.")
JsonTypes = [ "byte", "octet", "short", "unsigned short", "long", "unsigned long", "long long",
"unsigned long long", "float", "unrestricted float", "double", "unrestricted double", "boolean",
"DOMString", "ByteString", "USVString", "Enum", "InterfaceWithToJSON", "object" ]
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 +
"""
enum Enum { "a", "b", "c" };
interface InterfaceWithToJSON { long toJSON(); };
interface InterfaceWithoutToJSON {};
""");
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 { 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; }; 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("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<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 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 : 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 { 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; }; 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<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)
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 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("interface Foo : InterfaceWithoutToJSON { }; "
"interface Test { Foo toJSON(); };", True,
"interface without toJSON should not be a JSON type")