summaryrefslogtreecommitdiff
path: root/chromium/third_party/blink/renderer/bindings/scripts/overload_set_algorithm_test.py
blob: 44ccd2095b16bb4556f486e7bcaee4d29ff07e44 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
# Copyright 2017 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# pylint: disable=import-error,print-statement,relative-import,protected-access

"""Unit tests for overload_set_algorithm.py."""

import unittest
from overload_set_algorithm import effective_overload_set


class EffectiveOverloadSetTest(unittest.TestCase):
    def test_example_in_comments(self):
        operation_list = [
            # f1: f(optional long x)
            {'arguments': [{'idl_type_object': 'long',
                            'is_optional': True,
                            'is_variadic': False}]},
            # f2: f(DOMString s)
            {'arguments': [{'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': False}]}]

        overload_set = [
            # <f1, (long), (optional)>
            ({'arguments': [{'idl_type_object': 'long',
                             'is_optional': True,
                             'is_variadic': False}]},
             ('long',),
             ('optional',)),
            # <f1, (), ()>
            ({'arguments': [{'idl_type_object': 'long',
                             'is_optional': True,
                             'is_variadic': False}]},
             (),
             ()),
            # <f2, (DOMString), (required)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False}]},
             ('DOMString',),
             ('required',))]

        self.assertEqual(effective_overload_set(operation_list), overload_set)

    def test_example_in_spec(self):
        """Tests the example provided in Web IDL spec:
           https://heycam.github.io/webidl/#dfn-effective-overload-set,
           look for example right after the algorithm."""
        operation_list = [
            # f1: f(DOMString a)
            {'arguments': [{'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': False}]},
            # f2: f(Node a, DOMString b, double... c)
            {'arguments': [{'idl_type_object': 'Node',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'double',
                            'is_optional': False,
                            'is_variadic': True}]},
            # f3: f()
            {'arguments': []},
            # f4: f(Event a, DOMString b, optional DOMString c, double... d)
            {'arguments': [{'idl_type_object': 'Event',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'DOMString',
                            'is_optional': True,
                            'is_variadic': False},
                           {'idl_type_object': 'double',
                            'is_optional': False,
                            'is_variadic': True}]}]

        overload_set = [
            # <f1, (DOMString), (required)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False}]},
             ('DOMString',),
             ('required',)),
            # <f2, (Node, DOMString, double), (required, required, variadic)>
            ({'arguments': [{'idl_type_object': 'Node',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'double',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Node', 'DOMString', 'double'),
             ('required', 'required', 'variadic')),
            # <f2, (Node, DOMString, double, double),
            #      (required, required, variadic, variadic)>
            ({'arguments': [{'idl_type_object': 'Node',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'double',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Node', 'DOMString', 'double', 'double'),
             ('required', 'required', 'variadic', 'variadic')),
            # <f2, (Node, DOMString), (required, required)>
            ({'arguments': [{'idl_type_object': 'Node',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'double',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Node', 'DOMString'),
             ('required', 'required')),
            # <f3, (), ()>
            ({'arguments': []},
             (),
             ()),
            # <f4, (Event, DOMString, DOMString, double),
            #      (required, required, optional, variadic)>
            ({'arguments': [{'idl_type_object': 'Event',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': True,
                             'is_variadic': False},
                            {'idl_type_object': 'double',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Event', 'DOMString', 'DOMString', 'double'),
             ('required', 'required', 'optional', 'variadic')),
            # <f4, (Event, DOMString, DOMString),
            #      (required, required, optional)>
            ({'arguments': [{'idl_type_object': 'Event',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': True,
                             'is_variadic': False},
                            {'idl_type_object': 'double',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Event', 'DOMString', 'DOMString'),
             ('required', 'required', 'optional')),
            # <f4, (Event, DOMString), (required, required)>
            ({'arguments': [{'idl_type_object': 'Event',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': True,
                             'is_variadic': False},
                            {'idl_type_object': 'double',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Event', 'DOMString'),
             ('required', 'required'))]

        self.assertEqual(effective_overload_set(operation_list), overload_set)

    def test_element_create_proposed_syntax(self):
        """Tests the proposed syntax for the convenience method Element.create.
           Github issue: https://github.com/whatwg/dom/issues/477"""
        operation_list = [
            # f1: f(DOMString tag, Record<DOMString, DOMString> attrs, (Node or DOMString)... children)
            {'arguments': [{'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'record<DOMString, DOMString>',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'NodeOrDOMString',
                            'is_optional': False,
                            'is_variadic': True}]},
            # f2: f(DOMString tag, (Node or DOMString)... children)
            {'arguments': [{'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'NodeOrDOMString',
                            'is_optional': False,
                            'is_variadic': True}]}]

        overload_set = [
            # <f1, (DOMString, Record, NodeOrDOMString), (required, required, variadic)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'record<DOMString, DOMString>',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'NodeOrDOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString', 'record<DOMString, DOMString>', 'NodeOrDOMString'),
             ('required', 'required', 'variadic')),
            # <f1, (DOMString, Record), (required, required)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'record<DOMString, DOMString>',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'NodeOrDOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString', 'record<DOMString, DOMString>'),
             ('required', 'required')),
            # <f2, (DOMString, NodeOrDOMString), (required, variadic)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'NodeOrDOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString', 'NodeOrDOMString'),
             ('required', 'variadic')),
            # <f2, (DOMString, NodeOrDOMString, NodeOrDOMString), (required, variadic, variadic)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'NodeOrDOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString', 'NodeOrDOMString', 'NodeOrDOMString'),
             ('required', 'variadic', 'variadic')),
            # <f2, (DOMString), (required)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'NodeOrDOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString',),
             ('required',))]

        self.assertEqual(effective_overload_set(operation_list), overload_set)

    def test_optional_preceding_variadic(self):
        operation_list = [
            # f1: f(Node a, optional long b, DOMString... c)
            {'arguments': [{'idl_type_object': 'Node',
                            'is_optional': False,
                            'is_variadic': False},
                           {'idl_type_object': 'long',
                            'is_optional': True,
                            'is_variadic': False},
                           {'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': True}]},
            # f2: f(DOMString... a)
            {'arguments': [{'idl_type_object': 'DOMString',
                            'is_optional': False,
                            'is_variadic': True}]}]

        overload_set = [
            # <f1, (Node, long, DOMString), (required, optional, variadic)>
            ({'arguments': [{'idl_type_object': 'Node',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'long',
                             'is_optional': True,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Node', 'long', 'DOMString'),
             ('required', 'optional', 'variadic')),
            # <f1, (Node, long), (required, optional)>
            ({'arguments': [{'idl_type_object': 'Node',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'long',
                             'is_optional': True,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Node', 'long'),
             ('required', 'optional')),
            # <f1, (Node), (required)>
            ({'arguments': [{'idl_type_object': 'Node',
                             'is_optional': False,
                             'is_variadic': False},
                            {'idl_type_object': 'long',
                             'is_optional': True,
                             'is_variadic': False},
                            {'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('Node',),
             ('required',)),
            # <f2, (DOMString), (variadic)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString',),
             ('variadic',)),
            # <f2, (DOMString, DOMString), (variadic, variadic)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString', 'DOMString'),
             ('variadic', 'variadic')),
            # <f2, (DOMString, DOMString, DOMString), (variadic, variadic, variadic)>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             ('DOMString', 'DOMString', 'DOMString'),
             ('variadic', 'variadic', 'variadic')),
            # <f2, (), ()>
            ({'arguments': [{'idl_type_object': 'DOMString',
                             'is_optional': False,
                             'is_variadic': True}]},
             (),
             ())]

        self.assertEqual(effective_overload_set(operation_list), overload_set)