dom/bindings/parser/tests/test_method.py

   1 import WebIDL
   2
   3
   4 def WebIDLTest(parser, harness):
   5     parser.parse(
   6         """
   7         interface TestMethods {
   8           undefined basic();
   9           static undefined basicStatic();
  10           undefined basicWithSimpleArgs(boolean arg1, byte arg2, unsigned long arg3);
  11           boolean basicBoolean();
  12           static boolean basicStaticBoolean();
  13           boolean basicBooleanWithSimpleArgs(boolean arg1, byte arg2, unsigned long arg3);
  14           undefined optionalArg(optional byte? arg1, optional sequence<byte> arg2);
  15           undefined variadicArg(byte?... arg1);
  16           object getObject();
  17           undefined setObject(object arg1);
  18           undefined setAny(any arg1);
  19           float doFloats(float arg1);
  20         };
  21     """
  22     )
  23
  24     results = parser.finish()
  25
  26     harness.ok(True, "TestMethods interface parsed without error.")
  27     harness.check(len(results), 1, "Should be one production.")
  28     iface = results[0]
  29     harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should be an IDLInterface")
  30     harness.check(
  31         iface.identifier.QName(), "::TestMethods", "Interface has the right QName"
  32     )
  33     harness.check(iface.identifier.name, "TestMethods", "Interface has the right name")
  34     harness.check(len(iface.members), 12, "Expect 12 members")
  35
  36     methods = iface.members
  37
  38     def checkArgument(argument, QName, name, type, optional, variadic):
  39         harness.ok(isinstance(argument, WebIDL.IDLArgument), "Should be an IDLArgument")
  40         harness.check(
  41             argument.identifier.QName(), QName, "Argument has the right QName"
  42         )
  43         harness.check(argument.identifier.name, name, "Argument has the right name")
  44         harness.check(str(argument.type), type, "Argument has the right return type")
  45         harness.check(
  46             argument.optional, optional, "Argument has the right optional value"
  47         )
  48         harness.check(
  49             argument.variadic, variadic, "Argument has the right variadic value"
  50         )
  51
  52     def checkMethod(
  53         method,
  54         QName,
  55         name,
  56         signatures,
  57         static=False,
  58         getter=False,
  59         setter=False,
  60         deleter=False,
  61         legacycaller=False,
  62         stringifier=False,
  63     ):
  64         harness.ok(isinstance(method, WebIDL.IDLMethod), "Should be an IDLMethod")
  65         harness.ok(method.isMethod(), "Method is a method")
  66         harness.ok(not method.isAttr(), "Method is not an attr")
  67         harness.ok(not method.isConst(), "Method is not a const")
  68         harness.check(method.identifier.QName(), QName, "Method has the right QName")
  69         harness.check(method.identifier.name, name, "Method has the right name")
  70         harness.check(method.isStatic(), static, "Method has the correct static value")
  71         harness.check(method.isGetter(), getter, "Method has the correct getter value")
  72         harness.check(method.isSetter(), setter, "Method has the correct setter value")
  73         harness.check(
  74             method.isDeleter(), deleter, "Method has the correct deleter value"
  75         )
  76         harness.check(
  77             method.isLegacycaller(),
  78             legacycaller,
  79             "Method has the correct legacycaller value",
  80         )
  81         harness.check(
  82             method.isStringifier(),
  83             stringifier,
  84             "Method has the correct stringifier value",
  85         )
  86         harness.check(
  87             len(method.signatures()),
  88             len(signatures),
  89             "Method has the correct number of signatures",
  90         )
  91
  92         sigpairs = zip(method.signatures(), signatures)
  93         for gotSignature, expectedSignature in sigpairs:
  94             (gotRetType, gotArgs) = gotSignature
  95             (expectedRetType, expectedArgs) = expectedSignature
  96
  97             harness.check(
  98                 str(gotRetType), expectedRetType, "Method has the expected return type."
  99             )
 100
 101             for i in range(0, len(gotArgs)):
 102                 (QName, name, type, optional, variadic) = expectedArgs[i]
 103                 checkArgument(gotArgs[i], QName, name, type, optional, variadic)
 104
 105     checkMethod(methods[0], "::TestMethods::basic", "basic", [("Undefined", [])])
 106     checkMethod(
 107         methods[1],
 108         "::TestMethods::basicStatic",
 109         "basicStatic",
 110         [("Undefined", [])],
 111         static=True,
 112     )
 113     checkMethod(
 114         methods[2],
 115         "::TestMethods::basicWithSimpleArgs",
 116         "basicWithSimpleArgs",
 117         [
 118             (
 119                 "Undefined",
 120                 [
 121                     (
 122                         "::TestMethods::basicWithSimpleArgs::arg1",
 123                         "arg1",
 124                         "Boolean",
 125                         False,
 126                         False,
 127                     ),
 128                     (
 129                         "::TestMethods::basicWithSimpleArgs::arg2",
 130                         "arg2",
 131                         "Byte",
 132                         False,
 133                         False,
 134                     ),
 135                     (
 136                         "::TestMethods::basicWithSimpleArgs::arg3",
 137                         "arg3",
 138                         "UnsignedLong",
 139                         False,
 140                         False,
 141                     ),
 142                 ],
 143             )
 144         ],
 145     )
 146     checkMethod(
 147         methods[3], "::TestMethods::basicBoolean", "basicBoolean", [("Boolean", [])]
 148     )
 149     checkMethod(
 150         methods[4],
 151         "::TestMethods::basicStaticBoolean",
 152         "basicStaticBoolean",
 153         [("Boolean", [])],
 154         static=True,
 155     )
 156     checkMethod(
 157         methods[5],
 158         "::TestMethods::basicBooleanWithSimpleArgs",
 159         "basicBooleanWithSimpleArgs",
 160         [
 161             (
 162                 "Boolean",
 163                 [
 164                     (
 165                         "::TestMethods::basicBooleanWithSimpleArgs::arg1",
 166                         "arg1",
 167                         "Boolean",
 168                         False,
 169                         False,
 170                     ),
 171                     (
 172                         "::TestMethods::basicBooleanWithSimpleArgs::arg2",
 173                         "arg2",
 174                         "Byte",
 175                         False,
 176                         False,
 177                     ),
 178                     (
 179                         "::TestMethods::basicBooleanWithSimpleArgs::arg3",
 180                         "arg3",
 181                         "UnsignedLong",
 182                         False,
 183                         False,
 184                     ),
 185                 ],
 186             )
 187         ],
 188     )
 189     checkMethod(
 190         methods[6],
 191         "::TestMethods::optionalArg",
 192         "optionalArg",
 193         [
 194             (
 195                 "Undefined",
 196                 [
 197                     (
 198                         "::TestMethods::optionalArg::arg1",
 199                         "arg1",
 200                         "ByteOrNull",
 201                         True,
 202                         False,
 203                     ),
 204                     (
 205                         "::TestMethods::optionalArg::arg2",
 206                         "arg2",
 207                         "ByteSequence",
 208                         True,
 209                         False,
 210                     ),
 211                 ],
 212             )
 213         ],
 214     )
 215     checkMethod(
 216         methods[7],
 217         "::TestMethods::variadicArg",
 218         "variadicArg",
 219         [
 220             (
 221                 "Undefined",
 222                 [
 223                     (
 224                         "::TestMethods::variadicArg::arg1",
 225                         "arg1",
 226                         "ByteOrNull",
 227                         True,
 228                         True,
 229                     )
 230                 ],
 231             )
 232         ],
 233     )
 234     checkMethod(methods[8], "::TestMethods::getObject", "getObject", [("Object", [])])
 235     checkMethod(
 236         methods[9],
 237         "::TestMethods::setObject",
 238         "setObject",
 239         [
 240             (
 241                 "Undefined",
 242                 [("::TestMethods::setObject::arg1", "arg1", "Object", False, False)],
 243             )
 244         ],
 245     )
 246     checkMethod(
 247         methods[10],
 248         "::TestMethods::setAny",
 249         "setAny",
 250         [("Undefined", [("::TestMethods::setAny::arg1", "arg1", "Any", False, False)])],
 251     )
 252     checkMethod(
 253         methods[11],
 254         "::TestMethods::doFloats",
 255         "doFloats",
 256         [("Float", [("::TestMethods::doFloats::arg1", "arg1", "Float", False, False)])],
 257     )
 258
 259     parser = parser.reset()
 260     threw = False
 261     try:
 262         parser.parse(
 263             """
 264           interface A {
 265             undefined foo(optional float bar = 1);
 266           };
 267         """
 268         )
 269         results = parser.finish()
 270     except WebIDL.WebIDLError:
 271         threw = True
 272     harness.ok(not threw, "Should allow integer to float type corecion")
 273
 274     parser = parser.reset()
 275     threw = False
 276     try:
 277         parser.parse(
 278             """
 279           interface A {
 280             [GetterThrows] undefined foo();
 281           };
 282         """
 283         )
 284         results = parser.finish()
 285     except WebIDL.WebIDLError:
 286         threw = True
 287     harness.ok(threw, "Should not allow [GetterThrows] on methods")
 288
 289     parser = parser.reset()
 290     threw = False
 291     try:
 292         parser.parse(
 293             """
 294           interface A {
 295             [SetterThrows] undefined foo();
 296           };
 297         """
 298         )
 299         results = parser.finish()
 300     except WebIDL.WebIDLError:
 301         threw = True
 302     harness.ok(threw, "Should not allow [SetterThrows] on methods")
 303
 304     parser = parser.reset()
 305     threw = False
 306     try:
 307         parser.parse(
 308             """
 309           interface A {
 310             [Throw] undefined foo();
 311           };
 312         """
 313         )
 314         results = parser.finish()
 315     except WebIDL.WebIDLError:
 316         threw = True
 317     harness.ok(threw, "Should spell [Throws] correctly on methods")
 318
 319     parser = parser.reset()
 320     threw = False
 321     try:
 322         parser.parse(
 323             """
 324           interface A {
 325             undefined __noSuchMethod__();
 326           };
 327         """
 328         )
 329         results = parser.finish()
 330     except WebIDL.WebIDLError:
 331         threw = True
 332     harness.ok(threw, "Should not allow __noSuchMethod__ methods")
 333
 334     parser = parser.reset()
 335     threw = False
 336     try:
 337         parser.parse(
 338             """
 339           interface A {
 340             [Throws, LenientFloat]
 341             undefined foo(float myFloat);
 342             [Throws]
 343             undefined foo();
 344           };
 345         """
 346         )
 347         results = parser.finish()
 348     except WebIDL.WebIDLError:
 349         threw = True
 350     harness.ok(not threw, "Should allow LenientFloat to be only in a specific overload")
 351
 352     parser = parser.reset()
 353     parser.parse(
 354         """
 355       interface A {
 356         [Throws]
 357         undefined foo();
 358         [Throws, LenientFloat]
 359         undefined foo(float myFloat);
 360       };
 361     """
 362     )
 363     results = parser.finish()
 364     iface = results[0]
 365     methods = iface.members
 366     lenientFloat = methods[0].getExtendedAttribute("LenientFloat")
 367     harness.ok(
 368         lenientFloat is not None,
 369         "LenientFloat in overloads must be added to the method",
 370     )
 371
 372     parser = parser.reset()
 373     threw = False
 374     try:
 375         parser.parse(
 376             """
 377           interface A {
 378             [Throws, LenientFloat]
 379             undefined foo(float myFloat);
 380             [Throws]
 381             undefined foo(float myFloat, float yourFloat);
 382           };
 383         """
 384         )
 385         results = parser.finish()
 386     except WebIDL.WebIDLError:
 387         threw = True
 388     harness.ok(
 389         threw,
 390         "Should prevent overloads from getting different restricted float behavior",
 391     )
 392
 393     parser = parser.reset()
 394     threw = False
 395     try:
 396         parser.parse(
 397             """
 398           interface A {
 399             [Throws]
 400             undefined foo(float myFloat, float yourFloat);
 401             [Throws, LenientFloat]
 402             undefined foo(float myFloat);
 403           };
 404         """
 405         )
 406         results = parser.finish()
 407     except WebIDL.WebIDLError:
 408         threw = True
 409     harness.ok(
 410         threw,
 411         "Should prevent overloads from getting different restricted float behavior (2)",
 412     )
 413
 414     parser = parser.reset()
 415     threw = False
 416     try:
 417         parser.parse(
 418             """
 419           interface A {
 420             [Throws, LenientFloat]
 421             undefined foo(float myFloat);
 422             [Throws, LenientFloat]
 423             undefined foo(short myShort);
 424           };
 425         """
 426         )
 427         results = parser.finish()
 428     except WebIDL.WebIDLError:
 429         threw = True
 430     harness.ok(threw, "Should prevent overloads from getting redundant [LenientFloat]")