17edbf9cc200d032e61c141b660f5f09a584952f
[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(TestCallback 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 methodWithOptionalEnumArg(optional TestEnumType enumArg);
139     void methodWithOptionalEnumArgAndDefaultValue(optional TestEnumType enumArg = "EnumValue1");
140     [MayThrowLegacyException] TestObj methodThatRequiresAllArgsAndThrows(DOMString strArg, TestObj objArg);
141
142 #if defined(TESTING_JS)
143     void methodWithUSVStringArg(USVString str);
144     void methodWithNullableUSVStringArg(USVString? str);
145     void methodWithUSVStringArgTreatingNullAsEmptyString([TreatNullAs=EmptyString] USVString str);
146 #endif
147
148     void serializedValue(SerializedScriptValue serializedArg);
149     void optionsObject(Dictionary oo, optional Dictionary ooo);
150
151     // Exceptions
152     [MayThrowException] void methodWithException();
153     [MayThrowException] long methodWithExceptionReturningLong();
154     [MayThrowException] TestObj methodWithExceptionReturningObject();
155     [MayThrowLegacyException] void methodWithLegacyException();
156     [GetterMayThrowException] attribute long attributeWithGetterException;
157     [GetterMayThrowLegacyException] attribute long attributeWithGetterLegacyException;
158     [SetterMayThrowException] attribute long attributeWithSetterException;
159     [SetterMayThrowLegacyException] attribute long attributeWithSetterLegacyException;
160     [GetterMayThrowLegacyException] attribute DOMString stringAttrWithGetterException;
161     [SetterMayThrowLegacyException] attribute DOMString stringAttrWithSetterException;
162
163     // 'Custom' extended attribute
164     [Custom] attribute long            customAttr;
165     [Custom] void customMethod();
166     [Custom] void customMethodWithArgs(long longArg, DOMString strArg, TestObj objArg);
167
168     // 'JSBuiltin' extended attribute
169     [Conditional=Condition3, JSBuiltin] void jsBuiltinMethod();
170     [Conditional=Condition3, JSBuiltin] void jsBuiltinMethodWithArgs(long longArg, DOMString strArg, TestObj objArg);
171     [Conditional=Condition4, JSBuiltin] attribute TestObj jsBuiltinAttribute;
172     [Conditional=Condition4, JSBuiltin] readonly attribute TestObj jsBuiltinReadOnlyAttribute;
173
174     // Private extended attribute
175     [PrivateIdentifier] DOMString privateMethod(DOMString argument);
176     [PrivateIdentifier, PublicIdentifier] DOMString publicAndPrivateMethod(DOMString argument);
177
178     void addEventListener(DOMString type, EventListener listener, optional boolean useCapture = false);
179     void removeEventListener(DOMString type, EventListener listener, optional boolean useCapture = false);
180     attribute EventHandler onfoo;
181     [ImplementedAs=onfoo] attribute EventHandler onwebkitfoo;
182
183     // 'CallWith' extended attribute
184     [CallWith=ScriptState] void withScriptStateVoid();
185     [CallWith=ScriptState] TestObj withScriptStateObj();
186     [CallWith=ScriptState, MayThrowLegacyException] void withScriptStateVoidException();
187     [CallWith=ScriptState, MayThrowLegacyException] TestObj withScriptStateObjException();
188     [CallWith=ScriptExecutionContext] void withScriptExecutionContext();
189     [CallWith=ScriptExecutionContext&ScriptState] void withScriptExecutionContextAndScriptState();
190     [CallWith=ScriptExecutionContext&ScriptState, MayThrowLegacyException] TestObj withScriptExecutionContextAndScriptStateObjException();
191     [CallWith=  ScriptExecutionContext  &  ScriptState  ] TestObj withScriptExecutionContextAndScriptStateWithSpaces();
192     [CallWith=ScriptArguments&CallStack] void withScriptArgumentsAndCallStack();
193     [CallWith=Document] void withDocumentArgument();
194     [CallWith=CallerDocument] void withCallerDocumentArgument();
195     [CallWith=CallerWindow] void withCallerWindowArgument();
196
197     [CallWith=ScriptState] attribute long withScriptStateAttribute;
198     [CallWith=ScriptState, SetterCallWith=ActiveWindow&FirstWindow] attribute long withCallWithAndSetterCallWithAttribute;
199     [CallWith=ScriptExecutionContext] attribute TestObj withScriptExecutionContextAttribute;
200     [CallWith=ScriptState, GetterMayThrowLegacyException] attribute TestObj withScriptStateAttributeRaises;
201     [CallWith=ScriptExecutionContext, GetterMayThrowLegacyException] attribute TestObj withScriptExecutionContextAttributeRaises;
202     [CallWith=ScriptExecutionContext&ScriptState] attribute TestObj withScriptExecutionContextAndScriptStateAttribute;
203     [CallWith=ScriptExecutionContext&ScriptState,GetterMayThrowLegacyException] attribute TestObj withScriptExecutionContextAndScriptStateAttributeRaises;
204     [CallWith=  ScriptExecutionContext  &  ScriptState  ] attribute TestObj withScriptExecutionContextAndScriptStateWithSpacesAttribute;
205     [CallWith=ScriptArguments&CallStack] attribute TestObj withScriptArgumentsAndCallStackAttribute;
206
207     // Optional parameters.
208     void    methodWithOptionalArg(optional long opt);
209     void    methodWithOptionalArgAndDefaultValue(optional long opt = 666);
210     void    methodWithNonOptionalArgAndOptionalArg(long nonOpt, optional long opt);
211     void    methodWithNonOptionalArgAndTwoOptionalArgs(long nonOpt, optional long opt1, optional long opt2);
212     void    methodWithOptionalString(optional DOMString str);
213 #if defined(TESTING_JS)
214     void    methodWithOptionalUSVString(optional USVString str);
215 #endif
216     void    methodWithOptionalAtomicString([AtomicString] optional DOMString str);
217     void    methodWithOptionalStringAndDefaultValue(optional DOMString str = "foo");
218     void    methodWithOptionalAtomicStringAndDefaultValue([AtomicString] optional DOMString str = "foo");
219     void    methodWithOptionalStringIsNull(optional DOMString str = null);
220     void    methodWithOptionalStringIsUndefined(optional DOMString str = "undefined");
221     void    methodWithOptionalAtomicStringIsNull([AtomicString] optional DOMString str = null);
222     void    methodWithOptionalStringIsEmptyString(optional DOMString str = "");
223 #if defined(TESTING_JS)
224     void    methodWithOptionalUSVStringIsEmptyString(optional USVString str = "");
225 #endif
226     void    methodWithOptionalAtomicStringIsEmptyString([AtomicString] optional DOMString str = "");
227     void    methodWithOptionalDoubleIsNaN(optional unrestricted double number = NaN);
228     void    methodWithOptionalFloatIsNaN(optional unrestricted float number = NaN);
229     void    methodWithOptionalLongLong(optional long long number);
230     void    methodWithOptionalLongLongIsZero(optional long long number = 0);
231     void    methodWithOptionalUnsignedLongLong(optional unsigned long long number);
232     void    methodWithOptionalUnsignedLongLongIsZero(optional unsigned long long number = 0);
233     void    methodWithOptionalSequence(optional sequence<DOMString> array);
234     void    methodWithOptionalSequenceIsEmpty(optional sequence<DOMString> array = []);
235     void    methodWithOptionalBoolean(optional boolean b);
236     void    methodWithOptionalBooleanIsFalse(optional boolean b = false);
237     void    methodWithOptionalAny(optional any a);
238     void    methodWithOptionalNullableWrapper(optional TestObj? obj);
239     void    methodWithOptionalNullableWrapperIsNull(optional TestObj? obj = null);
240     void    methodWithOptionalXPathNSResolver(optional XPathNSResolver? resolver);
241
242 #if defined(TESTING_JS)
243     // Callback interface parameters.
244     void    methodWithCallbackArg(TestCallback callback);
245     void    methodWithNonCallbackArgAndCallbackArg(long nonCallback, TestCallback callback);
246     void    methodWithCallbackAndOptionalArg(optional TestCallback? callback);
247
248     // Callback function parameters.
249     void    methodWithCallbackFunctionArg(TestCallbackFunction callback);
250     void    methodWithNonCallbackArgAndCallbackFunctionArg(long nonCallback, TestCallbackFunction callback);
251     void    methodWithCallbackFunctionAndOptionalArg(optional TestCallbackFunction? callback);
252
253     // static methods with 'Callback' extended attribute
254     static void    staticMethodWithCallbackAndOptionalArg(optional TestCallback? callback);
255     static void    staticMethodWithCallbackArg(TestCallback callback);
256 #endif
257
258     // 'Conditional' extended attribute
259     [Conditional=Condition1] attribute long conditionalAttr1;
260     [Conditional=Condition1&Condition2] attribute long conditionalAttr2;
261     [Conditional=Condition1|Condition2] attribute long conditionalAttr3;
262
263     // 'Conditional' extended method
264     [Conditional=Condition1] DOMString conditionalMethod1();
265     [Conditional=Condition1&Condition2] void conditionalMethod2();
266     [Conditional=Condition1|Condition2] void conditionalMethod3();
267
268     [Conditional=Condition1] attribute TestObjectAConstructor conditionalAttr4;
269     [Conditional=Condition1&Condition2] attribute TestObjectBConstructor conditionalAttr5;
270     [Conditional=Condition1|Condition2] attribute TestObjectCConstructor conditionalAttr6;
271
272     [Conditional=Condition1] const unsigned short CONDITIONAL_CONST = 0;
273
274 #if defined(TESTING_JS)
275     [CachedAttribute] readonly attribute any cachedAttribute1;
276     [CachedAttribute] readonly attribute any cachedAttribute2;
277 #endif
278     
279     attribute any anyAttribute;
280
281 #if defined(TESTING_JS)
282     // Overloads
283     void    overloadedMethod(TestObj? objArg, DOMString strArg);
284     void    overloadedMethod(TestObj? objArg, optional long longArg);
285     void    overloadedMethod(DOMString strArg);
286     void    overloadedMethod(long longArg);
287     void    overloadedMethod(TestCallback callback);
288     void    overloadedMethod(DOMStringList? listArg);
289     void    overloadedMethod(sequence<DOMString>? arrayArg);
290     void    overloadedMethod(TestObj objArg);
291     void    overloadedMethod(DOMWindow window);
292     void    overloadedMethod(sequence<DOMString> arrayArg);
293     void    overloadedMethod(sequence<unsigned long> arrayArg);
294     void    overloadedMethod(DOMString strArg);
295
296     // FIXME: Implement support for overloaded functions with variadic arguments.
297     void    overloadedMethod(Blob... blobArgs);
298
299     void overloadedMethodWithOptionalParameter(DOMString strArg, optional TestObj? objArg = null);
300     void overloadedMethodWithOptionalParameter(TestObj? objArg, optional long longArg);
301 #endif
302
303     // Class methods within JavaScript (like what's used for IDBKeyRange).
304     static void classMethod();
305     static long classMethodWithOptional(optional long arg);
306     [Custom] static void classMethod2(long arg);
307
308     // Static method with conditional on overloaded methods
309     [Conditional=Condition1] static void overloadedMethod1(long arg);
310     [Conditional=Condition1] static void overloadedMethod1(DOMString type);
311
312     void classMethodWithClamp([Clamp] unsigned short objArgsShort, [Clamp] unsigned long objArgsLong);
313     void classMethodWithEnforceRange([EnforceRange] unsigned short objArgsShort, [EnforceRange] unsigned long objArgsLong);
314
315 #if defined(TESTING_JS)
316     void methodWithUnsignedLongSequence(sequence<unsigned long> unsignedLongSequence);
317     [MayThrowLegacyException] sequence<DOMString> stringArrayFunction(sequence<DOMString> values);
318     [MayThrowLegacyException] DOMStringList domStringListFunction(DOMStringList values);
319
320     void methodWithAndWithoutNullableSequence(sequence<unsigned long> arrayArg, sequence<unsigned long>? nullableArrayArg);
321
322     Element? getElementById([RequiresExistingAtomicString] DOMString elementId);
323 #endif
324
325     [CheckSecurityForNode] readonly attribute Document contentDocument;
326     [CheckSecurityForNode, MayThrowLegacyException] SVGDocument getSVGDocument();
327
328     void convert1(TestNode value);
329     void convert2(TestNode? value);
330     void convert3(DOMString value);
331     void convert4(DOMString? value);
332
333     attribute SVGPoint mutablePoint;
334     [Immutable] attribute SVGPoint immutablePoint;
335     SVGPoint mutablePointFunction();
336     [Immutable] SVGPoint immutablePointFunction();
337
338     [ImplementedAs=banana] void orange();
339     [ImplementedAs=blueberry] attribute long strawberry;
340
341     // ObjectiveC reserved words.
342     readonly attribute long      description;
343     attribute long               id;
344     readonly attribute DOMString hash;
345
346     // Check constants and enums.
347     const unsigned short CONST_VALUE_0 = 0;
348     const unsigned short CONST_VALUE_1 = 1;
349     const unsigned short CONST_VALUE_2 = 2;
350     const unsigned short CONST_VALUE_4 = 4;
351     const unsigned short CONST_VALUE_8 = 8;
352     const short CONST_VALUE_9 = -1;
353     const unsigned short CONST_VALUE_11 = 0xffffffff;
354     const unsigned short CONST_VALUE_12 = 0x01;
355     const unsigned short CONST_VALUE_13 = 0X20;
356     const unsigned short CONST_VALUE_14 = 0x1abc;
357     [Reflect=CONST_IMPL] const unsigned short CONST_JAVASCRIPT = 15;
358
359     [Replaceable] readonly attribute long replaceableAttribute;
360
361     void variadicStringMethod(DOMString head, DOMString... tail);
362     void variadicDoubleMethod(unrestricted double head, unrestricted double... tail);
363     void variadicNodeMethod(Node head, Node... tail);
364     void variadicUnionMethod(DOMString head, (Node or DOMString)... tail);
365
366     // Nullable attributes.
367     readonly attribute unrestricted double? nullableDoubleAttribute;
368     readonly attribute long? nullableLongAttribute;
369     readonly attribute boolean? nullableBooleanAttribute;
370     readonly attribute DOMString? nullableStringAttribute;
371
372     attribute long? nullableLongSettableAttribute;
373     attribute DOMString? nullableStringSettableAttribute;
374 #if defined(TESTING_JS)
375     attribute USVString? nullableUSVStringSettableAttribute;
376 #endif
377
378     [GetterMayThrowLegacyException] attribute long? nullableStringValue;
379
380     // Identifiers with a leading underscore, which should be removed.
381     const unsigned short               _readonly = 0;
382     readonly attribute DOMString       _attribute;
383     attribute _optional                attributeWithReservedEnumType;
384     void _any(unrestricted float a, long b);
385
386
387     readonly attribute Promise testReadOnlyPromiseAttribute;
388     // Promise function
389     Promise testPromiseFunction();
390     Promise testPromiseFunctionWithFloatArgument(float a);
391     [MayThrowLegacyException] Promise testPromiseFunctionWithException();
392     Promise testPromiseFunctionWithOptionalIntArgument(optional long a);
393     Promise testPromiseOverloadedFunction(float a);
394     Promise testPromiseOverloadedFunction(FetchRequest request);
395     static Promise testStaticPromiseFunction();
396     [MayThrowLegacyException] static Promise testStaticPromiseFunctionWithException();
397     [Custom] Promise testCustomPromiseFunction();
398
399     // PutForwards
400     [PutForwards=name] readonly attribute TestNode putForwardsAttribute;
401     [PutForwards=name] readonly attribute TestNode? putForwardsNullableAttribute;
402
403 #if defined(TESTING_JS)
404     // Overloading with conditionals.
405     [Conditional=CONDITION1] void conditionalOverload(DOMString str);
406     [Conditional=CONDITION2] void conditionalOverload(long a);
407
408     void singleConditionalOverload(DOMString str);
409     [Conditional=CONDITION] void singleConditionalOverload(long a);
410 #endif
411
412     void attachShadowRoot(TestDictionary init);
413     void operationWithExternalDictionaryParameter(TestStandaloneDictionary dict);
414
415     stringifier attribute USVString stringifierAttribute;
416
417     serializer = {create, readOnlyStringAttr, enumAttr, longAttr};
418
419     void bufferSourceParameter(BufferSource data);
420 };
421
422 // The following comment should not generate any code.
423 // TestObj implements TestImplements;
424
425 typedef any AnyTypedef;
426
427 dictionary TestDictionary {
428     TestEnumType enumerationValueWithoutDefault;
429     TestEnumType enumerationValueWithDefault = "enumValue1";
430     TestEnumType enumerationValueWithEmptyStringDefault = "";
431     DOMString stringWithDefault = "defaultString";
432     DOMString stringWithoutDefault;
433     DOMString? nullableStringWithDefault = null;
434     boolean booleanWithDefault = false;
435     boolean booleanWithoutDefault;
436     sequence<DOMString> sequenceOfStrings;
437     double restrictedDouble;
438     unrestricted double unrestrictedDouble;
439     double restrictedDoubleWithDefault = 0;
440     unrestricted double unrestrictedDoubleWithDefault = 0;
441     float restrictedFloat;
442     unrestricted float unrestrictedFloat;
443     float restrictedFloatWithDefault = 0;
444     unrestricted float unrestrictedFloatWithDefault = 0;
445     [Clamp] byte smallIntegerClamped;
446     byte smallIntegerWithDefault;
447     [EnforceRange] octet smallUnsignedIntegerEnforcedRange;
448     octet smallUnsignedIntegerWithDefault = 0;
449     long integer;
450     long integerWithDefault = 0;
451     unsigned long unsignedInteger;
452     unsigned long unsignedIntegerWithDefault = 0;
453     long long largeInteger;
454     long long largeIntegerWithDefault = 0;
455     unsigned long long unsignedLargeInteger;
456     unsigned long long unsignedLargeIntegerWithDefault = 0;
457     long? nullableIntegerWithDefault = null;
458     Node? nullableNode = null;
459     any anyValue;
460     any anyValueWithNullDefault = null;
461     AnyTypedef anyTypedefValue;
462     TestDictionaryThatShouldTolerateNull dictionaryMember;
463     (long or Node) unionMember;
464     (long or Node)? nullableUnionMember = null;
465     BufferSource bufferSourceValue;
466 };
467
468 dictionary TestDictionaryThatShouldNotTolerateNull {
469     required TestEnumType requiredEnumerationValue;
470     boolean booleanWithoutDefault;
471     required Node nonNullableNode;
472     required TestDictionary requiredDictionaryMember;
473 };
474
475 dictionary TestDictionaryThatShouldTolerateNull {
476     TestEnumType enumerationValue;
477     boolean booleanWithoutDefault;
478 };
479
480 [
481     ImplementedAs=AlternateDictionaryName
482 ] dictionary TestDictionaryWithAlternateImplementationName {
483     TestEnumType enumerationValue;
484     boolean booleanWithoutDefault;
485 };
486
487 dictionary ParentDictionary {
488     boolean parentMember2;
489     boolean parentMember1;
490 };
491
492 dictionary ChildDictionary : ParentDictionary {
493     boolean childMember2;
494     boolean childMember1;
495 };
496