dom/bindings/parser/tests/test_enum.py

   1 import WebIDL
   2
   3
   4 def WebIDLTest(parser, harness):
   5     parser.parse(
   6         """
   7         enum TestEnum {
   8           "",
   9           "foo",
  10           "bar"
  11         };
  12
  13         interface TestEnumInterface {
  14           TestEnum doFoo(boolean arg);
  15           readonly attribute TestEnum foo;
  16         };
  17     """
  18     )
  19
  20     results = parser.finish()
  21
  22     harness.ok(True, "TestEnumInterfaces interface parsed without error.")
  23     harness.check(len(results), 2, "Should be one production")
  24     harness.ok(isinstance(results[0], WebIDL.IDLEnum), "Should be an IDLEnum")
  25     harness.ok(isinstance(results[1], WebIDL.IDLInterface), "Should be an IDLInterface")
  26
  27     enum = results[0]
  28     harness.check(enum.identifier.QName(), "::TestEnum", "Enum has the right QName")
  29     harness.check(enum.identifier.name, "TestEnum", "Enum has the right name")
  30     harness.check(enum.values(), ["", "foo", "bar"], "Enum has the right values")
  31
  32     iface = results[1]
  33
  34     harness.check(
  35         iface.identifier.QName(), "::TestEnumInterface", "Interface has the right QName"
  36     )
  37     harness.check(
  38         iface.identifier.name, "TestEnumInterface", "Interface has the right name"
  39     )
  40     harness.check(iface.parent, None, "Interface has no parent")
  41
  42     members = iface.members
  43     harness.check(len(members), 2, "Should be one production")
  44     harness.ok(isinstance(members[0], WebIDL.IDLMethod), "Should be an IDLMethod")
  45     method = members[0]
  46     harness.check(
  47         method.identifier.QName(),
  48         "::TestEnumInterface::doFoo",
  49         "Method has correct QName",
  50     )
  51     harness.check(method.identifier.name, "doFoo", "Method has correct name")
  52
  53     signatures = method.signatures()
  54     harness.check(len(signatures), 1, "Expect one signature")
  55
  56     (returnType, arguments) = signatures[0]
  57     harness.check(
  58         str(returnType), "TestEnum (Wrapper)", "Method type is the correct name"
  59     )
  60     harness.check(len(arguments), 1, "Method has the right number of arguments")
  61     arg = arguments[0]
  62     harness.ok(isinstance(arg, WebIDL.IDLArgument), "Should be an IDLArgument")
  63     harness.check(str(arg.type), "Boolean", "Argument has the right type")
  64
  65     attr = members[1]
  66     harness.check(
  67         attr.identifier.QName(), "::TestEnumInterface::foo", "Attr has correct QName"
  68     )
  69     harness.check(attr.identifier.name, "foo", "Attr has correct name")
  70
  71     harness.check(str(attr.type), "TestEnum (Wrapper)", "Attr type is the correct name")
  72
  73     # Now reset our parser
  74     parser = parser.reset()
  75     threw = False
  76     try:
  77         parser.parse(
  78             """
  79           enum Enum {
  80             "a",
  81             "b",
  82             "c"
  83           };
  84           interface TestInterface {
  85             undefined foo(optional Enum e = "d");
  86           };
  87         """
  88         )
  89         parser.finish()
  90     except WebIDL.WebIDLError:
  91         threw = True
  92
  93     harness.ok(threw, "Should not allow a bogus default value for an enum")
  94
  95     # Now reset our parser
  96     parser = parser.reset()
  97     parser.parse(
  98         """
  99       enum Enum {
 100         "a",
 101         "b",
 102         "c",
 103       };
 104     """
 105     )
 106     results = parser.finish()
 107     harness.check(len(results), 1, "Should allow trailing comma in enum")