The Tor Browser: dom/bindings/parser/tests/test_union.py@6474c204b198 (annotated)

dom/bindings/parser/tests/test_union.py@6474c204b198 (annotated)

dom/bindings/parser/tests/test_union.py

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 import WebIDL
 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
     # combinations(range(4), 3) --> 012 013 023 123
     pool = tuple(iterable)
     n = len(pool)
     if r > n:
         return
     indices = range(r)
     yield tuple(pool[i] for i in indices)
     while True:
         for i in reversed(range(r)):
             if indices[i] != i + n - r:
                 break
         else:
             return
         indices[i] += 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):
     # combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
     pool = tuple(iterable)
     n = len(pool)
     if not n and r:
         return
     indices = [0] * r
     yield tuple(pool[i] for i in indices)
     while True:
         for i in reversed(range(r)):
             if indices[i] != n - 1:
                 break
         else:
             return
         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",
              #"sequence<float>",
              "object",
              "ArrayBuffer",
              #"Date",
              "TestInterface1",
              "TestInterface2"]
     testPre = """
         interface TestInterface1 {
         };
         interface TestInterface2 {
         };
         """
     interface = testPre + """
         interface PrepareForTest {
         """
     for (i, type) in enumerate(types):
         interface += string.Template("""
           readonly attribute ${type} attr${i};
         """).substitute(i=i, type=type)
     interface += """
         };
         """
     parser.parse(interface)
     results = parser.finish()
     iface = results[2]
     parser = parser.reset()
     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])]
         return "(" + " or ".join(t) + ")"
     # typeCombinations is an iterable of tuples containing the name of the type
     # as a string and the parsed IDL type.
     def unionTypes(typeCombinations, predicate):
         for c in typeCombinations:
             if predicate(t[1] for t in c):
                 yield unionTypeName([t[0] for t in c])
     # We limit invalid union types with a union member type to the subset of 3
     # types with one invalid combination.
     # typeCombinations is an iterable of tuples containing the name of the type
     # 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]))):
                 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 + """
         interface TestUnion {
         """
     for (i, type) in enumerate(validUnionTypes):
         interface += string.Template("""
           void method${i}(${type} arg);
           ${type} returnMethod${i}();
           attribute ${type} attr${i};
           void arrayMethod${i}(${type}[] arg);
           ${type}[] arrayReturnMethod${i}();
           attribute ${type}[] arrayAttr${i};
           void optionalMethod${i}(${type}? arg);
         """).substitute(i=i, type=type)
     interface += """
         };
         """
     parser.parse(interface)
     results = parser.finish()
     parser = parser.reset()
     for invalid in invalidUnionTypes:
         interface = testPre + string.Template("""
             interface TestUnion {
               void method(${type} arg);
             };
         """).substitute(type=invalid)
         threw = False
         try:
             parser.parse(interface)
             results = parser.finish()
         except:
             threw = True
         harness.ok(threw, "Should have thrown.")
         parser = parser.reset()

The Tor Browser / annotate

dom/bindings/parser/tests/test_union.py@6474c204b198 (annotated)

dom/bindings/parser/tests/test_union.py