[WebIDL] Add support for modern callback syntax
[WebKit.git] / Source / WebCore / bindings / scripts / test / TestObj.idl
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  * Copyright (C) 2010 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary form, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 // This IDL file is for testing the bindings code generator and for tracking
31 // changes in its output.
32
33 enum TestEnumType { "", "enumValue1", "EnumValue2", "EnumValue3" };
34
35 // Leading underscore on an enum should be removed.
36 enum _optional { "", "OptionalValue1", "OptionalValue2", "OptionalValue3" };
37
38 [ImplementedAs=AlternateEnumName] enum TestEnumTypeWithAlternateImplementationName { "enumValue1", "EnumValue2" };
39
40 [Conditional=Condition1] enum TestEnumA { "A" };
41 [Conditional=Condition1&Condition2] enum TestEnumB { "B" };
42 [Conditional=Condition1|Condition2] enum TestEnumC { "C" };
43
44 enum TestObjKind { "quick", "dead" };
45 enum ObjSize { "small", "much-much-larger" };
46 enum TestConfidence { "high", "kinda-low" };
47
48 [
49     ConstructorCallWith=Document,
50     Constructor(TestCallbackInterface testCallback, TestCallbackFunction testCallbackFunction),
51     InterfaceName=TestObject
52 ] interface TestObj {
53     // Attributes
54     readonly attribute long            readOnlyLongAttr;
55     readonly attribute DOMString       readOnlyStringAttr;
56     readonly attribute TestObj         readOnlyTestObjAttr;
57     static readonly attribute long     staticReadOnlyLongAttr;
58     static attribute DOMString         staticStringAttr;
59     static readonly attribute TestSubObjConstructor TestSubObj;
60     [EnabledBySetting=TestSetting] attribute TestSubObjConstructor TestSubObjEnabledBySetting;
61     attribute TestEnumType             enumAttr;
62     attribute byte                     byteAttr;
63     attribute octet                    octetAttr;
64     [Unscopable] attribute short                    shortAttr;
65     [Clamp] attribute short            clampedShortAttr;
66     [EnforceRange] attribute short     enforceRangeShortAttr;
67     attribute unsigned short           unsignedShortAttr;
68     attribute long                     longAttr;
69     attribute long long                longLongAttr;
70     attribute unsigned long long       unsignedLongLongAttr;
71     attribute DOMString                stringAttr;
72 #if defined(TESTING_JS)
73     attribute USVString                usvstringAttr;
74 #endif
75     attribute TestObj                  testObjAttr;
76     attribute TestObj?                 testNullableObjAttr;
77     [LenientThis] attribute TestObj    lenientTestObjAttr;
78     [Unforgeable] readonly attribute DOMString unforgeableAttr;
79     [TreatNullAs=EmptyString] attribute DOMString stringAttrTreatingNullAsEmptyString;
80 #if defined(TESTING_JS)
81     [TreatNullAs=EmptyString] attribute USVString usvstringAttrTreatingNullAsEmptyString;
82 #endif
83
84     attribute TestEnumTypeWithAlternateImplementationName implementationEnumAttr;
85
86     // WK_ucfirst, WK_lcfirst exceptional cases.
87     attribute TestObj                  XMLObjAttr;
88     attribute boolean                  create;
89
90     // Reflected DOM attributes
91     [Reflect] attribute DOMString reflectedStringAttr;
92 #if defined(TESTING_JS)
93     [Reflect] attribute USVString reflectedUSVStringAttr;
94 #endif
95     [Reflect] attribute long reflectedIntegralAttr;
96     [Reflect] attribute unsigned long reflectedUnsignedIntegralAttr;
97     [Reflect] attribute boolean reflectedBooleanAttr;
98     [Reflect, URL] attribute DOMString reflectedURLAttr;
99 #if defined(TESTING_JS)
100     [Reflect, URL] attribute USVString reflectedUSVURLAttr;
101 #endif
102     [Reflect=customContentStringAttr] attribute DOMString reflectedStringAttr;
103     [Reflect=customContentIntegralAttr] attribute long reflectedCustomIntegralAttr;
104     [Reflect=customContentBooleanAttr] attribute boolean reflectedCustomBooleanAttr;
105     [Reflect=customContentURLAttr, URL] attribute DOMString reflectedCustomURLAttr;
106
107     // [EnabledAtRuntime] attributes and operations.
108     [Conditional=TEST_FEATURE, EnabledAtRuntime=TestFeature] attribute DOMString enabledAtRuntimeAttribute;
109     [Conditional=TEST_FEATURE, EnabledAtRuntime=TestFeature] void enabledAtRuntimeOperation(DOMString testParam);
110     [Conditional=TEST_FEATURE, EnabledAtRuntime=TestFeature] void enabledAtRuntimeOperation(long testParam);
111
112     // TypedArray attribute
113     attribute Float32Array typedArrayAttr;
114
115     [EnabledAtRuntime=DOMIterator] iterable<DOMString>;
116
117     // Methods
118     [Unscopable] void voidMethod();
119     void voidMethodWithArgs(long longArg, DOMString strArg, TestObj objArg);
120     byte byteMethod();
121     byte byteMethodWithArgs(byte byteArg, DOMString strArg, TestObj objArg);
122     octet octetMethod();
123     octet octetMethodWithArgs(octet octetArg, DOMString strArg, TestObj objArg);
124     long longMethod();
125     long longMethodWithArgs(long longArg, DOMString strArg, TestObj objArg);
126     TestObj objMethod();
127     TestObj objMethodWithArgs(long longArg, DOMString strArg, TestObj objArg);
128     [Unforgeable] long unforgeableMethod();
129     void methodWithArgTreatingNullAsEmptyString([TreatNullAs=EmptyString] DOMString arg);
130     void methodWithXPathNSResolverParameter(XPathNSResolver resolver);
131
132     // Nullable String return values.
133     DOMString? nullableStringMethod();
134     static DOMString? nullableStringStaticMethod();
135     getter DOMString? nullableStringSpecialMethod(unsigned long index);
136
137     void methodWithEnumArg(TestEnumType enumArg);
138     void methodWithStandaloneEnumArg(TestStandaloneEnumeration enumArg);
139     void methodWithOptionalEnumArg(optional TestEnumType enumArg);
140     void methodWithOptionalEnumArgAndDefaultValue(optional TestEnumType enumArg = "EnumValue1");
141     [MayThrowLegacyException] TestObj methodThatRequiresAllArgsAndThrows(DOMString strArg, TestObj objArg);
142
143 #if defined(TESTING_JS)
144     void methodWithUSVStringArg(USVString str);
145     void methodWithNullableUSVStringArg(USVString? str);
146     void methodWithUSVStringArgTreatingNullAsEmptyString([TreatNullAs=EmptyString] USVString str);
147 #endif
148
149     void serializedValue(SerializedScriptValue serializedArg);
150     void optionsObject(Dictionary oo, optional Dictionary ooo);
151
152     // Exceptions
153     [MayThrowException] void methodWithException();
154     [MayThrowException] long methodWithExceptionReturningLong();
155     [MayThrowException] TestObj methodWithExceptionReturningObject();
156     [MayThrowLegacyException] void methodWithLegacyException();
157     [GetterMayThrowException] attribute long attributeWithGetterException;
158     [GetterMayThrowLegacyException] attribute long attributeWithGetterLegacyException;
159     [SetterMayThrowException] attribute long attributeWithSetterException;
160     [SetterMayThrowLegacyException] attribute long attributeWithSetterLegacyException;
161     [GetterMayThrowLegacyException] attribute DOMString stringAttrWithGetterException;
162     [SetterMayThrowLegacyException] attribute DOMString stringAttrWithSetterException;
163
164     // 'Custom' extended attribute
165     [Custom] attribute long            customAttr;
166     [Custom] void customMethod();
167     [Custom] void customMethodWithArgs(long longArg, DOMString strArg, TestObj objArg);
168
169     // 'JSBuiltin' extended attribute
170     [Conditional=Condition3, JSBuiltin] void jsBuiltinMethod();
171     [Conditional=Condition3, JSBuiltin] void jsBuiltinMethodWithArgs(long longArg, DOMString strArg, TestObj objArg);
172     [Conditional=Condition4, JSBuiltin] attribute TestObj jsBuiltinAttribute;
173     [Conditional=Condition4, JSBuiltin] readonly attribute TestObj jsBuiltinReadOnlyAttribute;
174
175     // Private extended attribute
176     [PrivateIdentifier] DOMString privateMethod(DOMString argument);
177     [PrivateIdentifier, PublicIdentifier] DOMString publicAndPrivateMethod(DOMString argument);
178
179     void addEventListener(DOMString type, EventListener listener, optional boolean useCapture = false);
180     void removeEventListener(DOMString type, EventListener listener, optional boolean useCapture = false);
181     attribute EventHandler onfoo;
182     [ImplementedAs=onfoo] attribute EventHandler onwebkitfoo;
183
184     // 'CallWith' extended attribute
185     [CallWith=ScriptState] void withScriptStateVoid();
186     [CallWith=ScriptState] TestObj withScriptStateObj();
187     [CallWith=ScriptState, MayThrowLegacyException] void withScriptStateVoidException();
188     [CallWith=ScriptState, MayThrowLegacyException] TestObj withScriptStateObjException();
189     [CallWith=ScriptExecutionContext] void withScriptExecutionContext();
190     [CallWith=ScriptExecutionContext&ScriptState] void withScriptExecutionContextAndScriptState();
191     [CallWith=ScriptExecutionContext&ScriptState, MayThrowLegacyException] TestObj withScriptExecutionContextAndScriptStateObjException();
192     [CallWith=  ScriptExecutionContext  &  ScriptState  ] TestObj withScriptExecutionContextAndScriptStateWithSpaces();
193     [CallWith=ScriptArguments&CallStack] void withScriptArgumentsAndCallStack();
194     [CallWith=Document] void withDocumentArgument();
195     [CallWith=CallerDocument] void withCallerDocumentArgument();
196     [CallWith=CallerWindow] void withCallerWindowArgument();
197
198     [CallWith=ScriptState] attribute long withScriptStateAttribute;
199     [CallWith=ScriptState, SetterCallWith=ActiveWindow&FirstWindow] attribute long withCallWithAndSetterCallWithAttribute;
200     [CallWith=ScriptExecutionContext] attribute TestObj withScriptExecutionContextAttribute;
201     [CallWith=ScriptState, GetterMayThrowLegacyException] attribute TestObj withScriptStateAttributeRaises;
202     [CallWith=ScriptExecutionContext, GetterMayThrowLegacyException] attribute TestObj withScriptExecutionContextAttributeRaises;
203     [CallWith=ScriptExecutionContext&ScriptState] attribute TestObj withScriptExecutionContextAndScriptStateAttribute;
204     [CallWith=ScriptExecutionContext&ScriptState,GetterMayThrowLegacyException] attribute TestObj withScriptExecutionContextAndScriptStateAttributeRaises;
205     [CallWith=  ScriptExecutionContext  &  ScriptState  ] attribute TestObj withScriptExecutionContextAndScriptStateWithSpacesAttribute;
206     [CallWith=ScriptArguments&CallStack] attribute TestObj withScriptArgumentsAndCallStackAttribute;
207
208     // Optional parameters.
209     void    methodWithOptionalArg(optional long opt);
210     void    methodWithOptionalArgAndDefaultValue(optional long opt = 666);
211     void    methodWithNonOptionalArgAndOptionalArg(long nonOpt, optional long opt);
212     void    methodWithNonOptionalArgAndTwoOptionalArgs(long nonOpt, optional long opt1, optional long opt2);
213     void    methodWithOptionalString(optional DOMString str);
214 #if defined(TESTING_JS)
215     void    methodWithOptionalUSVString(optional USVString str);
216 #endif
217     void    methodWithOptionalAtomicString([AtomicString] optional DOMString str);
218     void    methodWithOptionalStringAndDefaultValue(optional DOMString str = "foo");
219     void    methodWithOptionalAtomicStringAndDefaultValue([AtomicString] optional DOMString str = "foo");
220     void    methodWithOptionalStringIsNull(optional DOMString str = null);
221     void    methodWithOptionalStringIsUndefined(optional DOMString str = "undefined");
222     void    methodWithOptionalAtomicStringIsNull([AtomicString] optional DOMString str = null);
223     void    methodWithOptionalStringIsEmptyString(optional DOMString str = "");
224 #if defined(TESTING_JS)
225     void    methodWithOptionalUSVStringIsEmptyString(optional USVString str = "");
226 #endif
227     void    methodWithOptionalAtomicStringIsEmptyString([AtomicString] optional DOMString str = "");
228     void    methodWithOptionalDoubleIsNaN(optional unrestricted double number = NaN);
229     void    methodWithOptionalFloatIsNaN(optional unrestricted float number = NaN);
230     void    methodWithOptionalLongLong(optional long long number);
231     void    methodWithOptionalLongLongIsZero(optional long long number = 0);
232     void    methodWithOptionalUnsignedLongLong(optional unsigned long long number);
233     void    methodWithOptionalUnsignedLongLongIsZero(optional unsigned long long number = 0);
234     void    methodWithOptionalSequence(optional sequence<DOMString> array);
235     void    methodWithOptionalSequenceIsEmpty(optional sequence<DOMString> array = []);
236     void    methodWithOptionalBoolean(optional boolean b);
237     void    methodWithOptionalBooleanIsFalse(optional boolean b = false);
238     void    methodWithOptionalAny(optional any a);
239     void    methodWithOptionalNullableWrapper(optional TestObj? obj);
240     void    methodWithOptionalNullableWrapperIsNull(optional TestObj? obj = null);
241     void    methodWithOptionalXPathNSResolver(optional XPathNSResolver? resolver);
242
243 #if defined(TESTING_JS)
244     // Callback interface parameters.
245     void    methodWithCallbackArg(TestCallbackInterface callback);
246     void    methodWithNonCallbackArgAndCallbackArg(long nonCallback, TestCallbackInterface callback);
247     void    methodWithCallbackAndOptionalArg(optional TestCallbackInterface? callback);
248
249     // Callback function parameters.
250     void    methodWithCallbackFunctionArg(TestCallbackFunction callback);
251     void    methodWithNonCallbackArgAndCallbackFunctionArg(long nonCallback, TestCallbackFunction callback);
252     void    methodWithCallbackFunctionAndOptionalArg(optional TestCallbackFunction? callback);
253
254     // static methods with 'Callback' extended attribute
255     static void    staticMethodWithCallbackAndOptionalArg(optional TestCallbackInterface? callback);
256     static void    staticMethodWithCallbackArg(TestCallbackInterface callback);
257 #endif
258
259     // 'Conditional' extended attribute
260     [Conditional=Condition1] attribute long conditionalAttr1;
261     [Conditional=Condition1&Condition2] attribute long conditionalAttr2;
262     [Conditional=Condition1|Condition2] attribute long conditionalAttr3;
263
264     // 'Conditional' extended method
265     [Conditional=Condition1] DOMString conditionalMethod1();
266     [Conditional=Condition1&Condition2] void conditionalMethod2();
267     [Conditional=Condition1|Condition2] void conditionalMethod3();
268
269     [Conditional=Condition1] attribute TestObjectAConstructor conditionalAttr4;
270     [Conditional=Condition1&Condition2] attribute TestObjectBConstructor conditionalAttr5;
271     [Conditional=Condition1|Condition2] attribute TestObjectCConstructor conditionalAttr6;
272
273     [Conditional=Condition1] const unsigned short CONDITIONAL_CONST = 0;
274
275 #if defined(TESTING_JS)
276     [CachedAttribute] readonly attribute any cachedAttribute1;
277     [CachedAttribute] readonly attribute any cachedAttribute2;
278 #endif
279     
280     attribute any anyAttribute;
281
282 #if defined(TESTING_JS)
283     // Overloads
284     void    overloadedMethod(TestObj? objArg, DOMString strArg);
285     void    overloadedMethod(TestObj? objArg, optional long longArg);
286     void    overloadedMethod(DOMString strArg);
287     void    overloadedMethod(long longArg);
288     void    overloadedMethod(TestCallbackInterface callback);
289     void    overloadedMethod(DOMStringList? listArg);
290     void    overloadedMethod(sequence<DOMString>? arrayArg);
291     void    overloadedMethod(TestObj objArg);
292     void    overloadedMethod(DOMWindow window);
293     void    overloadedMethod(sequence<DOMString> arrayArg);
294     void    overloadedMethod(sequence<unsigned long> arrayArg);
295     void    overloadedMethod(DOMString strArg);
296
297     // FIXME: Implement support for overloaded functions with variadic arguments.
298     void    overloadedMethod(Blob... blobArgs);
299
300     void overloadedMethodWithOptionalParameter(DOMString strArg, optional TestObj? objArg = null);
301     void overloadedMethodWithOptionalParameter(TestObj? objArg, optional long longArg);
302
303     void overloadedMethodWithDistinguishingUnion((TestObj or TestNode) objectOrNode);
304     void overloadedMethodWithDistinguishingUnion(long value);
305
306     void overloadedMethodWith2DistinguishingUnions((TestObj or TestNode) objectOrNode);
307     void overloadedMethodWith2DistinguishingUnions((TestInterface or DOMString or long) value);
308
309     void overloadedMethodWithNonDistinguishingUnion((TestObj or TestNode) objectOrNode, TestObj object);
310     void overloadedMethodWithNonDistinguishingUnion((TestObj or TestNode) objectOrNode, TestNode node);
311
312     void overloadWithNullableUnion((TestObj or TestNode)? objectOrNode);
313     void overloadWithNullableUnion(long index);
314
315     void overloadWithOptionalUnion(optional (DOMString or boolean) objectOrNode = true);
316     void overloadWithOptionalUnion(long index);
317
318     void overloadWithNullableNonDistinguishingParameter(TestObj? obj, TestNode node);
319     void overloadWithNullableNonDistinguishingParameter(TestNode? node, long index);
320 #endif
321
322     // Class methods within JavaScript (like what's used for IDBKeyRange).
323     static void classMethod();
324     static long classMethodWithOptional(optional long arg);
325     [Custom] static void classMethod2(long arg);
326
327     // Static method with conditional on overloaded methods
328     [Conditional=Condition1] static void overloadedMethod1(long arg);
329     [Conditional=Condition1] static void overloadedMethod1(DOMString type);
330
331     void classMethodWithClamp([Clamp] unsigned short objArgsShort, [Clamp] unsigned long objArgsLong);
332     void classMethodWithEnforceRange([EnforceRange] unsigned short objArgsShort, [EnforceRange] unsigned long objArgsLong);
333
334 #if defined(TESTING_JS)
335     void methodWithUnsignedLongSequence(sequence<unsigned long> unsignedLongSequence);
336     [MayThrowLegacyException] sequence<DOMString> stringArrayFunction(sequence<DOMString> values);
337     [MayThrowLegacyException] DOMStringList domStringListFunction(DOMStringList values);
338
339     void methodWithAndWithoutNullableSequence(sequence<unsigned long> arrayArg, sequence<unsigned long>? nullableArrayArg);
340
341     Element? getElementById([RequiresExistingAtomicString] DOMString elementId);
342 #endif
343
344     [CheckSecurityForNode] readonly attribute Document contentDocument;
345     [CheckSecurityForNode, MayThrowLegacyException] SVGDocument getSVGDocument();
346
347     void convert1(TestNode value);
348     void convert2(TestNode? value);
349     void convert3(DOMString value);
350     void convert4(DOMString? value);
351
352     attribute SVGPoint mutablePoint;
353     [Immutable] attribute SVGPoint immutablePoint;
354     SVGPoint mutablePointFunction();
355     [Immutable] SVGPoint immutablePointFunction();
356
357     [ImplementedAs=banana] void orange();
358     [ImplementedAs=blueberry] attribute long strawberry;
359
360     // ObjectiveC reserved words.
361     readonly attribute long      description;
362     attribute long               id;
363     readonly attribute DOMString hash;
364
365     // Check constants and enums.
366     const unsigned short CONST_VALUE_0 = 0;
367     const unsigned short CONST_VALUE_1 = 1;
368     const unsigned short CONST_VALUE_2 = 2;
369     const unsigned short CONST_VALUE_4 = 4;
370     const unsigned short CONST_VALUE_8 = 8;
371     const short CONST_VALUE_9 = -1;
372     const unsigned short CONST_VALUE_11 = 0xffffffff;
373     const unsigned short CONST_VALUE_12 = 0x01;
374     const unsigned short CONST_VALUE_13 = 0X20;
375     const unsigned short CONST_VALUE_14 = 0x1abc;
376     [Reflect=CONST_IMPL] const unsigned short CONST_JAVASCRIPT = 15;
377
378     [Replaceable] readonly attribute long replaceableAttribute;
379
380     void variadicStringMethod(DOMString head, DOMString... tail);
381     void variadicDoubleMethod(unrestricted double head, unrestricted double... tail);
382     void variadicNodeMethod(Node head, Node... tail);
383     void variadicUnionMethod(DOMString head, (Node or DOMString)... tail);
384
385     // Nullable attributes.
386     readonly attribute unrestricted double? nullableDoubleAttribute;
387     readonly attribute long? nullableLongAttribute;
388     readonly attribute boolean? nullableBooleanAttribute;
389     readonly attribute DOMString? nullableStringAttribute;
390
391     attribute long? nullableLongSettableAttribute;
392     attribute DOMString? nullableStringSettableAttribute;
393 #if defined(TESTING_JS)
394     attribute USVString? nullableUSVStringSettableAttribute;
395 #endif
396
397     [GetterMayThrowLegacyException] attribute long? nullableStringValue;
398
399     // Identifiers with a leading underscore, which should be removed.
400     const unsigned short               _readonly = 0;
401     readonly attribute DOMString       _attribute;
402     attribute _optional                attributeWithReservedEnumType;
403     void _any(unrestricted float a, long b);
404
405
406     readonly attribute Promise testReadOnlyPromiseAttribute;
407     // Promise function
408     Promise testPromiseFunction();
409     Promise testPromiseFunctionWithFloatArgument(float a);
410     [MayThrowLegacyException] Promise testPromiseFunctionWithException();
411     Promise testPromiseFunctionWithOptionalIntArgument(optional long a);
412     Promise testPromiseOverloadedFunction(float a);
413     Promise testPromiseOverloadedFunction(FetchRequest request);
414     static Promise testStaticPromiseFunction();
415     [MayThrowLegacyException] static Promise testStaticPromiseFunctionWithException();
416     [Custom] Promise testCustomPromiseFunction();
417
418     // PutForwards
419     [PutForwards=name] readonly attribute TestNode putForwardsAttribute;
420     [PutForwards=name] readonly attribute TestNode? putForwardsNullableAttribute;
421
422 #if defined(TESTING_JS)
423     // Overloading with conditionals.
424     [Conditional=CONDITION1] void conditionalOverload(DOMString str);
425     [Conditional=CONDITION2] void conditionalOverload(long a);
426
427     void singleConditionalOverload(DOMString str);
428     [Conditional=CONDITION] void singleConditionalOverload(long a);
429 #endif
430
431     void attachShadowRoot(TestDictionary init);
432     void operationWithExternalDictionaryParameter(TestStandaloneDictionary dict);
433
434     stringifier attribute USVString stringifierAttribute;
435
436     serializer = {create, readOnlyStringAttr, enumAttr, longAttr};
437
438     void bufferSourceParameter(BufferSource data);
439 };
440
441 // The following comment should not generate any code.
442 // TestObj implements TestImplements;
443
444 typedef any AnyTypedef;
445
446 dictionary TestDictionary {
447     TestEnumType enumerationValueWithoutDefault;
448     TestEnumType enumerationValueWithDefault = "enumValue1";
449     TestEnumType enumerationValueWithEmptyStringDefault = "";
450     DOMString stringWithDefault = "defaultString";
451     DOMString stringWithoutDefault;
452     DOMString? nullableStringWithDefault = null;
453     boolean booleanWithDefault = false;
454     boolean booleanWithoutDefault;
455     sequence<DOMString> sequenceOfStrings;
456     double restrictedDouble;
457     unrestricted double unrestrictedDouble;
458     double restrictedDoubleWithDefault = 0;
459     unrestricted double unrestrictedDoubleWithDefault = 0;
460     float restrictedFloat;
461     unrestricted float unrestrictedFloat;
462     float restrictedFloatWithDefault = 0;
463     unrestricted float unrestrictedFloatWithDefault = 0;
464     [Clamp] byte smallIntegerClamped;
465     byte smallIntegerWithDefault;
466     [EnforceRange] octet smallUnsignedIntegerEnforcedRange;
467     octet smallUnsignedIntegerWithDefault = 0;
468     long integer;
469     long integerWithDefault = 0;
470     unsigned long unsignedInteger;
471     unsigned long unsignedIntegerWithDefault = 0;
472     long long largeInteger;
473     long long largeIntegerWithDefault = 0;
474     unsigned long long unsignedLargeInteger;
475     unsigned long long unsignedLargeIntegerWithDefault = 0;
476     long? nullableIntegerWithDefault = null;
477     Node? nullableNode = null;
478     any anyValue;
479     any anyValueWithNullDefault = null;
480     AnyTypedef anyTypedefValue;
481     TestDictionaryThatShouldTolerateNull dictionaryMember;
482     (long or Node) unionMember;
483     (long or Node)? nullableUnionMember = null;
484     BufferSource bufferSourceValue;
485 };
486
487 dictionary TestDictionaryThatShouldNotTolerateNull {
488     required TestEnumType requiredEnumerationValue;
489     boolean booleanWithoutDefault;
490     required Node nonNullableNode;
491     required TestDictionary requiredDictionaryMember;
492 };
493
494 dictionary TestDictionaryThatShouldTolerateNull {
495     TestEnumType enumerationValue;
496     boolean booleanWithoutDefault;
497 };
498
499 [
500     ImplementedAs=AlternateDictionaryName
501 ] dictionary TestDictionaryWithAlternateImplementationName {
502     TestEnumType enumerationValue;
503     boolean booleanWithoutDefault;
504 };
505
506 dictionary ParentDictionary {
507     boolean parentMember2;
508     boolean parentMember1;
509 };
510
511 dictionary ChildDictionary : ParentDictionary {
512     boolean childMember2;
513     boolean childMember1;
514 };
515
516 [
517     Conditional=Condition1
518 ] dictionary TestConditionalDictionaryA {
519     DOMString stringWithoutDefault;
520 };
521
522 [
523     Conditional=Condition1&Condition2
524 ] dictionary TestConditionalDictionaryB {
525     DOMString stringWithoutDefault;
526 };
527
528 [
529     Conditional=Condition1|Condition2
530 ] dictionary TestConditionalDictionaryC {
531     DOMString stringWithoutDefault;
532 };