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