dom/bindings/parser/tests/test_special_method_signature_mismatch.py

   1 import WebIDL
   2
   3
   4 def WebIDLTest(parser, harness):
   5     threw = False
   6     try:
   7         parser.parse(
   8             """
   9             interface SpecialMethodSignatureMismatch1 {
  10               getter long long foo(long index);
  11             };
  12         """
  13         )
  14
  15         parser.finish()
  16     except WebIDL.WebIDLError:
  17         threw = True
  18
  19     harness.ok(threw, "Should have thrown.")
  20
  21     threw = False
  22     try:
  23         parser.parse(
  24             """
  25             interface SpecialMethodSignatureMismatch2 {
  26               getter undefined foo(unsigned long index);
  27             };
  28         """
  29         )
  30
  31         parser.finish()
  32     except WebIDL.WebIDLError:
  33         threw = True
  34
  35     harness.ok(threw, "Should have thrown.")
  36
  37     threw = False
  38     try:
  39         parser.parse(
  40             """
  41             interface SpecialMethodSignatureMismatch3 {
  42               getter boolean foo(unsigned long index, boolean extraArg);
  43             };
  44         """
  45         )
  46
  47         parser.finish()
  48     except WebIDL.WebIDLError:
  49         threw = True
  50
  51     harness.ok(threw, "Should have thrown.")
  52
  53     threw = False
  54     try:
  55         parser.parse(
  56             """
  57             interface SpecialMethodSignatureMismatch4 {
  58               getter boolean foo(unsigned long... index);
  59             };
  60         """
  61         )
  62
  63         parser.finish()
  64     except WebIDL.WebIDLError:
  65         threw = True
  66
  67     harness.ok(threw, "Should have thrown.")
  68
  69     threw = False
  70     try:
  71         parser.parse(
  72             """
  73             interface SpecialMethodSignatureMismatch5 {
  74               getter boolean foo(optional unsigned long index);
  75             };
  76         """
  77         )
  78
  79         parser.finish()
  80     except WebIDL.WebIDLError:
  81         threw = True
  82
  83     harness.ok(threw, "Should have thrown.")
  84
  85     threw = False
  86     try:
  87         parser.parse(
  88             """
  89             interface SpecialMethodSignatureMismatch6 {
  90               getter boolean foo();
  91             };
  92         """
  93         )
  94
  95         parser.finish()
  96     except WebIDL.WebIDLError:
  97         threw = True
  98
  99     harness.ok(threw, "Should have thrown.")
 100
 101     threw = False
 102     try:
 103         parser.parse(
 104             """
 105             interface SpecialMethodSignatureMismatch7 {
 106               deleter long long foo(long index);
 107             };
 108         """
 109         )
 110
 111         parser.finish()
 112     except WebIDL.WebIDLError:
 113         threw = True
 114
 115     harness.ok(threw, "Should have thrown.")
 116
 117     threw = False
 118     try:
 119         parser.parse(
 120             """
 121             interface SpecialMethodSignatureMismatch9 {
 122               deleter boolean foo(unsigned long index, boolean extraArg);
 123             };
 124         """
 125         )
 126
 127         parser.finish()
 128     except WebIDL.WebIDLError:
 129         threw = True
 130
 131     harness.ok(threw, "Should have thrown.")
 132
 133     threw = False
 134     try:
 135         parser.parse(
 136             """
 137             interface SpecialMethodSignatureMismatch10 {
 138               deleter boolean foo(unsigned long... index);
 139             };
 140         """
 141         )
 142
 143         parser.finish()
 144     except WebIDL.WebIDLError:
 145         threw = True
 146
 147     harness.ok(threw, "Should have thrown.")
 148
 149     threw = False
 150     try:
 151         parser.parse(
 152             """
 153             interface SpecialMethodSignatureMismatch11 {
 154               deleter boolean foo(optional unsigned long index);
 155             };
 156         """
 157         )
 158
 159         parser.finish()
 160     except WebIDL.WebIDLError:
 161         threw = True
 162
 163     harness.ok(threw, "Should have thrown.")
 164
 165     threw = False
 166     try:
 167         parser.parse(
 168             """
 169             interface SpecialMethodSignatureMismatch12 {
 170               deleter boolean foo();
 171             };
 172         """
 173         )
 174
 175         parser.finish()
 176     except WebIDL.WebIDLError:
 177         threw = True
 178
 179     harness.ok(threw, "Should have thrown.")
 180
 181     threw = False
 182     try:
 183         parser.parse(
 184             """
 185             interface SpecialMethodSignatureMismatch13 {
 186               setter long long foo(long index, long long value);
 187             };
 188         """
 189         )
 190
 191         parser.finish()
 192     except WebIDL.WebIDLError:
 193         threw = True
 194
 195     harness.ok(threw, "Should have thrown.")
 196
 197     threw = False
 198     try:
 199         parser.parse(
 200             """
 201             interface SpecialMethodSignatureMismatch15 {
 202               setter boolean foo(unsigned long index, boolean value, long long extraArg);
 203             };
 204         """
 205         )
 206
 207         parser.finish()
 208     except WebIDL.WebIDLError:
 209         threw = True
 210
 211     harness.ok(threw, "Should have thrown.")
 212
 213     threw = False
 214     try:
 215         parser.parse(
 216             """
 217             interface SpecialMethodSignatureMismatch16 {
 218               setter boolean foo(unsigned long index, boolean... value);
 219             };
 220         """
 221         )
 222
 223         parser.finish()
 224     except WebIDL.WebIDLError:
 225         threw = True
 226
 227     harness.ok(threw, "Should have thrown.")
 228
 229     threw = False
 230     try:
 231         parser.parse(
 232             """
 233             interface SpecialMethodSignatureMismatch17 {
 234               setter boolean foo(unsigned long index, optional boolean value);
 235             };
 236         """
 237         )
 238
 239         parser.finish()
 240     except WebIDL.WebIDLError:
 241         threw = True
 242
 243     harness.ok(threw, "Should have thrown.")
 244
 245     threw = False
 246     try:
 247         parser.parse(
 248             """
 249             interface SpecialMethodSignatureMismatch18 {
 250               setter boolean foo();
 251             };
 252         """
 253         )
 254
 255         parser.finish()
 256     except WebIDL.WebIDLError:
 257         threw = True
 258
 259     harness.ok(threw, "Should have thrown.")