summaryrefslogtreecommitdiffstats
path: root/dom/bindings/parser/tests/test_toJSON.py
diff options
context:
space:
mode:
Diffstat (limited to 'dom/bindings/parser/tests/test_toJSON.py')
-rw-r--r--dom/bindings/parser/tests/test_toJSON.py309
1 files changed, 309 insertions, 0 deletions
diff --git a/dom/bindings/parser/tests/test_toJSON.py b/dom/bindings/parser/tests/test_toJSON.py
new file mode 100644
index 0000000000..42bad30e50
--- /dev/null
+++ b/dom/bindings/parser/tests/test_toJSON.py
@@ -0,0 +1,309 @@
+def WebIDLTest(parser, harness):
+ threw = False
+ try:
+ parser.parse(
+ """
+ interface Test {
+ object toJSON();
+ };
+ """
+ )
+ parser.finish()
+ except Exception:
+ 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);
+ };
+ """
+ )
+ parser.finish()
+ except Exception:
+ 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);
+ };
+ """
+ )
+ parser.finish()
+ except Exception:
+ 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();
+ };
+ """
+ )
+ parser.finish()
+ except Exception:
+ 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();
+ };
+ """
+ )
+ parser.finish()
+ except Exception:
+ 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();
+ };
+ """
+ )
+ parser.finish()
+ except Exception:
+ 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",
+ "UTF8String",
+ "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<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,
+ )
+
+ 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",
+ )
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-09 19:07:06 +0000