mirror of
https://github.com/servo/servo.git
synced 2025-08-06 06:00:15 +01:00
Create a top-level "third_party" directory
This directory now contains third_party software that is vendored into the Servo source tree. The idea is that it would eventually hold webrender and other crates from mozilla-central as well with a standard patch management approach for each.
This commit is contained in:
Martin Robinson
parent
7412e28349
commit
8be014ee46
148 changed files with 10 additions and 7 deletions
425
third_party/WebIDL/tests/test_distinguishability.py
vendored
Normal file
425
third_party/WebIDL/tests/test_distinguishability.py
vendored
Normal file
|
|
@ -0,0 +1,425 @@
|
|||
import traceback
|
||||
|
||||
|
||||
def firstArgType(method):
|
||||
return method.signatures()[0][1][0].type
|
||||
|
||||
|
||||
def WebIDLTest(parser, harness):
|
||||
parser.parse(
|
||||
"""
|
||||
// Give our dictionary a required member so we don't need to
|
||||
// mess with optional and default values.
|
||||
dictionary Dict {
|
||||
required long member;
|
||||
};
|
||||
callback interface Foo {
|
||||
};
|
||||
interface Bar {
|
||||
// Bit of a pain to get things that have dictionary types
|
||||
undefined passDict(Dict arg);
|
||||
undefined passFoo(Foo arg);
|
||||
undefined passNullableUnion((object? or DOMString) arg);
|
||||
undefined passNullable(Foo? arg);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
iface = results[2]
|
||||
harness.ok(iface.isInterface(), "Should have interface")
|
||||
dictMethod = iface.members[0]
|
||||
ifaceMethod = iface.members[1]
|
||||
nullableUnionMethod = iface.members[2]
|
||||
nullableIfaceMethod = iface.members[3]
|
||||
|
||||
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(
|
||||
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(
|
||||
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(
|
||||
"""
|
||||
interface TestIface {
|
||||
undefined passKid(Kid arg);
|
||||
undefined passParent(Parent arg);
|
||||
undefined passGrandparent(Grandparent arg);
|
||||
undefined passUnrelated1(Unrelated1 arg);
|
||||
undefined passUnrelated2(Unrelated2 arg);
|
||||
undefined passArrayBuffer(ArrayBuffer arg);
|
||||
undefined passArrayBuffer(ArrayBufferView arg);
|
||||
};
|
||||
|
||||
interface Kid : Parent {};
|
||||
interface Parent : Grandparent {};
|
||||
interface Grandparent {};
|
||||
interface Unrelated1 {};
|
||||
interface Unrelated2 {};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
|
||||
iface = results[0]
|
||||
harness.ok(iface.isInterface(), "Should have interface")
|
||||
argTypes = [firstArgType(method) for method in iface.members]
|
||||
unrelatedTypes = [firstArgType(method) for method in iface.members[-3:]]
|
||||
|
||||
for type1 in argTypes:
|
||||
for type2 in argTypes:
|
||||
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),
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
parser.parse(
|
||||
"""
|
||||
interface Dummy {};
|
||||
interface TestIface {
|
||||
undefined method(long arg1, TestIface arg2);
|
||||
undefined method(long arg1, long arg2);
|
||||
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"
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Dummy {};
|
||||
interface TestIface {
|
||||
undefined method(long arg1, TestIface arg2);
|
||||
undefined method(long arg1, long arg2);
|
||||
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",
|
||||
)
|
||||
|
||||
parser = parser.reset()
|
||||
threw = False
|
||||
try:
|
||||
parser.parse(
|
||||
"""
|
||||
interface Dummy {};
|
||||
interface TestIface {
|
||||
undefined method(long arg1, TestIface arg2);
|
||||
undefined method(long arg1, long arg2);
|
||||
undefined method(any arg1, DOMString arg2);
|
||||
undefined method(DOMString arg1, DOMString arg2, DOMString arg3);
|
||||
};
|
||||
"""
|
||||
)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
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?",
|
||||
"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?"]
|
||||
undefineds = ["undefined", "undefined?"]
|
||||
primitives = numerics + booleans
|
||||
nonNumerics = allBut(argTypes, numerics + unions)
|
||||
nonBooleans = allBut(argTypes, booleans)
|
||||
strings = [
|
||||
"DOMString",
|
||||
"ByteString",
|
||||
"Enum",
|
||||
"Enum2",
|
||||
"USVString",
|
||||
"JSString",
|
||||
"UTF8String",
|
||||
]
|
||||
nonStrings = allBut(argTypes, strings)
|
||||
nonObjects = undefineds + primitives + strings
|
||||
objects = allBut(argTypes, nonObjects)
|
||||
bufferSourceTypes = ["ArrayBuffer", "ArrayBufferView", "Uint8Array", "Uint16Array"]
|
||||
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
|
||||
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()
|
||||
for type in argTypes:
|
||||
data[type] = dict()
|
||||
|
||||
def setDistinguishable(type, types):
|
||||
for other in types:
|
||||
data[type][other] = True
|
||||
|
||||
setDistinguishable("long", nonNumerics)
|
||||
setDistinguishable("short", nonNumerics)
|
||||
setDistinguishable("long?", allBut(nonNumerics, nullables))
|
||||
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)
|
||||
setDistinguishable("USVString", nonStrings)
|
||||
setDistinguishable("JSString", nonStrings)
|
||||
setDistinguishable("Enum", nonStrings)
|
||||
setDistinguishable("Enum2", nonStrings)
|
||||
setDistinguishable("Interface", notRelatedInterfaces)
|
||||
setDistinguishable("Interface?", allBut(notRelatedInterfaces, nullables))
|
||||
setDistinguishable("AncestorInterface", notRelatedInterfaces)
|
||||
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 + 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>", 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 + undefineds)
|
||||
)
|
||||
|
||||
def areDistinguishable(type1, type2):
|
||||
return data[type1].get(type2, False)
|
||||
|
||||
def checkDistinguishability(parser, type1, type2):
|
||||
idlTemplate = """
|
||||
enum Enum { "a", "b" };
|
||||
enum Enum2 { "c", "d" };
|
||||
interface Interface : AncestorInterface {};
|
||||
interface AncestorInterface {};
|
||||
interface UnrelatedInterface {};
|
||||
callback interface CallbackInterface {};
|
||||
callback interface CallbackInterface2 {};
|
||||
callback Callback = any();
|
||||
callback Callback2 = long(short arg);
|
||||
// Give our dictionaries required members so we don't need to
|
||||
// mess with optional and default values.
|
||||
dictionary Dict { required long member; };
|
||||
dictionary Dict2 { required long member; };
|
||||
interface TestInterface {%s
|
||||
};
|
||||
"""
|
||||
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:
|
||||
parser.parse(idl)
|
||||
results = parser.finish()
|
||||
except:
|
||||
threw = True
|
||||
|
||||
if areDistinguishable(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),
|
||||
)
|
||||
|
||||
# Enumerate over everything in both orders, since order matters in
|
||||
# terms of our implementation of distinguishability checks
|
||||
for type1 in argTypes:
|
||||
for type2 in argTypes:
|
||||
checkDistinguishability(parser, type1, type2)
|
||||
Loading…
Add table
Add a link
Reference in a new issue