1import WebIDL
2
3
4def WebIDLTest(parser, harness):
5    parser.parse(
6        """
7      [Global, Exposed=Foo] interface Foo {};
8      [Global=(Bar, Bar1,Bar2), Exposed=Bar] interface Bar {};
9      [Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
10
11      [Exposed=(Foo,Bar1)]
12      interface Iface {
13        void method1();
14
15        [Exposed=Bar1]
16        readonly attribute any attr;
17      };
18
19      [Exposed=Foo]
20      partial interface Iface {
21        void method2();
22      };
23    """
24    )
25
26    results = parser.finish()
27
28    harness.check(len(results), 5, "Should know about five things")
29    iface = results[3]
30    harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should have an interface here")
31    members = iface.members
32    harness.check(len(members), 3, "Should have three members")
33
34    harness.ok(
35        members[0].exposureSet == set(["Foo", "Bar"]),
36        "method1 should have the right exposure set",
37    )
38    harness.ok(
39        members[0]._exposureGlobalNames == set(["Foo", "Bar1"]),
40        "method1 should have the right exposure global names",
41    )
42
43    harness.ok(
44        members[1].exposureSet == set(["Bar"]),
45        "attr should have the right exposure set",
46    )
47    harness.ok(
48        members[1]._exposureGlobalNames == set(["Bar1"]),
49        "attr should have the right exposure global names",
50    )
51
52    harness.ok(
53        members[2].exposureSet == set(["Foo"]),
54        "method2 should have the right exposure set",
55    )
56    harness.ok(
57        members[2]._exposureGlobalNames == set(["Foo"]),
58        "method2 should have the right exposure global names",
59    )
60
61    harness.ok(
62        iface.exposureSet == set(["Foo", "Bar"]),
63        "Iface should have the right exposure set",
64    )
65    harness.ok(
66        iface._exposureGlobalNames == set(["Foo", "Bar1"]),
67        "Iface should have the right exposure global names",
68    )
69
70    parser = parser.reset()
71    parser.parse(
72        """
73      [Global, Exposed=Foo] interface Foo {};
74      [Global=(Bar, Bar1, Bar2), Exposed=Bar] interface Bar {};
75      [Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
76
77      [Exposed=Foo]
78      interface Iface2 {
79        void method3();
80      };
81    """
82    )
83    results = parser.finish()
84
85    harness.check(len(results), 4, "Should know about four things")
86    iface = results[3]
87    harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should have an interface here")
88    members = iface.members
89    harness.check(len(members), 1, "Should have one member")
90
91    harness.ok(
92        members[0].exposureSet == set(["Foo"]),
93        "method3 should have the right exposure set",
94    )
95    harness.ok(
96        members[0]._exposureGlobalNames == set(["Foo"]),
97        "method3 should have the right exposure global names",
98    )
99
100    harness.ok(
101        iface.exposureSet == set(["Foo"]), "Iface2 should have the right exposure set"
102    )
103    harness.ok(
104        iface._exposureGlobalNames == set(["Foo"]),
105        "Iface2 should have the right exposure global names",
106    )
107
108    parser = parser.reset()
109    parser.parse(
110        """
111      [Global, Exposed=Foo] interface Foo {};
112      [Global=(Bar, Bar1, Bar2), Exposed=Bar] interface Bar {};
113      [Global=(Baz, Baz2), Exposed=Baz] interface Baz {};
114
115      [Exposed=Foo]
116      interface Iface3 {
117        void method4();
118      };
119
120      [Exposed=(Foo,Bar1)]
121      interface mixin Mixin {
122        void method5();
123      };
124
125      Iface3 includes Mixin;
126    """
127    )
128    results = parser.finish()
129    harness.check(len(results), 6, "Should know about six things")
130    iface = results[3]
131    harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should have an interface here")
132    members = iface.members
133    harness.check(len(members), 2, "Should have two members")
134
135    harness.ok(
136        members[0].exposureSet == set(["Foo"]),
137        "method4 should have the right exposure set",
138    )
139    harness.ok(
140        members[0]._exposureGlobalNames == set(["Foo"]),
141        "method4 should have the right exposure global names",
142    )
143
144    harness.ok(
145        members[1].exposureSet == set(["Foo", "Bar"]),
146        "method5 should have the right exposure set",
147    )
148    harness.ok(
149        members[1]._exposureGlobalNames == set(["Foo", "Bar1"]),
150        "method5 should have the right exposure global names",
151    )
152
153    parser = parser.reset()
154    threw = False
155    try:
156        parser.parse(
157            """
158            [Exposed=Foo]
159            interface Bar {
160            };
161        """
162        )
163
164        results = parser.finish()
165    except Exception as x:
166        threw = True
167
168    harness.ok(threw, "Should have thrown on invalid Exposed value on interface.")
169
170    parser = parser.reset()
171    threw = False
172    try:
173        parser.parse(
174            """
175            interface Bar {
176              [Exposed=Foo]
177              readonly attribute bool attr;
178            };
179        """
180        )
181
182        results = parser.finish()
183    except Exception as x:
184        threw = True
185
186    harness.ok(threw, "Should have thrown on invalid Exposed value on attribute.")
187
188    parser = parser.reset()
189    threw = False
190    try:
191        parser.parse(
192            """
193            interface Bar {
194              [Exposed=Foo]
195              void operation();
196            };
197        """
198        )
199
200        results = parser.finish()
201    except Exception as x:
202        threw = True
203
204    harness.ok(threw, "Should have thrown on invalid Exposed value on operation.")
205
206    parser = parser.reset()
207    threw = False
208    try:
209        parser.parse(
210            """
211            interface Bar {
212              [Exposed=Foo]
213              const long constant = 5;
214            };
215        """
216        )
217
218        results = parser.finish()
219    except Exception as x:
220        threw = True
221
222    harness.ok(threw, "Should have thrown on invalid Exposed value on constant.")
223
224    parser = parser.reset()
225    threw = False
226    try:
227        parser.parse(
228            """
229            [Global, Exposed=Foo] interface Foo {};
230            [Global, Exposed=Bar] interface Bar {};
231
232            [Exposed=Foo]
233            interface Baz {
234              [Exposed=Bar]
235              void method();
236            };
237        """
238        )
239
240        results = parser.finish()
241    except Exception as x:
242        threw = True
243
244    harness.ok(
245        threw, "Should have thrown on member exposed where its interface is not."
246    )
247
248    parser = parser.reset()
249    parser.parse(
250        """
251        [Global, Exposed=Foo] interface Foo {};
252        [Global, Exposed=Bar] interface Bar {};
253
254        [Exposed=Foo]
255        interface Baz {
256          void method();
257        };
258
259        [Exposed=Bar]
260        interface mixin Mixin {
261          void otherMethod();
262        };
263
264        Baz includes Mixin;
265    """
266    )
267
268    results = parser.finish()
269
270    harness.check(len(results), 5, "Should know about five things")
271    iface = results[2]
272    harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should have an interface here")
273    members = iface.members
274    harness.check(len(members), 2, "Should have two members")
275
276    harness.ok(
277        members[0].exposureSet == set(["Foo"]),
278        "method should have the right exposure set",
279    )
280    harness.ok(
281        members[0]._exposureGlobalNames == set(["Foo"]),
282        "method should have the right exposure global names",
283    )
284
285    harness.ok(
286        members[1].exposureSet == set(["Bar"]),
287        "otherMethod should have the right exposure set",
288    )
289    harness.ok(
290        members[1]._exposureGlobalNames == set(["Bar"]),
291        "otherMethod should have the right exposure global names",
292    )
293
294    parser = parser.reset()
295    parser.parse(
296        """
297        [Global, Exposed=Foo] interface Foo {};
298        [Global, Exposed=Bar] interface Bar {};
299
300        [Exposed=*]
301        interface Baz {
302          void methodWild();
303        };
304
305        [Exposed=Bar]
306        interface mixin Mixin {
307          void methodNotWild();
308        };
309
310        Baz includes Mixin;
311    """
312    )
313
314    results = parser.finish()
315
316    harness.check(len(results), 5, "Should know about five things")
317    iface = results[2]
318    harness.ok(isinstance(iface, WebIDL.IDLInterface), "Should have an interface here")
319    members = iface.members
320    harness.check(len(members), 2, "Should have two members")
321
322    harness.ok(
323        members[0].exposureSet == set(["Foo", "Bar"]),
324        "methodWild should have the right exposure set",
325    )
326    harness.ok(
327        members[0]._exposureGlobalNames == set(["Foo", "Bar"]),
328        "methodWild should have the right exposure global names",
329    )
330
331    harness.ok(
332        members[1].exposureSet == set(["Bar"]),
333        "methodNotWild should have the right exposure set",
334    )
335    harness.ok(
336        members[1]._exposureGlobalNames == set(["Bar"]),
337        "methodNotWild should have the right exposure global names",
338    )
339
340    parser = parser.reset()
341    threw = False
342    try:
343        parser.parse(
344            """
345            [Global, Exposed=Foo] interface Foo {};
346            [Global, Exposed=Bar] interface Bar {};
347
348            [Exposed=Foo]
349            interface Baz {
350              [Exposed=*]
351              void method();
352            };
353        """
354        )
355
356        results = parser.finish()
357    except Exception as x:
358        threw = True
359
360    harness.ok(
361        threw, "Should have thrown on member exposed where its interface is not."
362    )
363
364    parser = parser.reset()
365    threw = False
366    try:
367        parser.parse(
368            """
369            [Global, Exposed=Foo] interface Foo {};
370            [Global, Exposed=Bar] interface Bar {};
371
372            [Exposed=(Foo,*)]
373            interface Baz {
374              void method();
375            };
376        """
377        )
378
379        results = parser.finish()
380    except Exception as x:
381        threw = True
382
383    harness.ok(threw, "Should have thrown on a wildcard in an identifier list.")
384