/*
 * Copyright (C) 2009 Google Inc. All rights reserved.
 * Copyright (C) 2010 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary formstrArg, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
 *     its contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIEstrArg, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

// This IDL file is for testing the bindings code generator and for tracking
// changes in its ouput.

enum TestEnumType { "", "EnumValue1", "EnumValue2", "EnumValue3" };

[
    Constructor(in [Callback] TestCallback testCallback),
    InterfaceName=TestObject
] interface TestObj {
    // Attributes
    readonly attribute long            readOnlyLongAttr;
    readonly attribute DOMString       readOnlyStringAttr;
    readonly attribute TestObj         readOnlyTestObjAttr;
    static readonly attribute long     staticReadOnlyLongAttr;
    static attribute DOMString         staticStringAttr;
    static readonly attribute TestSubObjConstructor TestSubObj;
    attribute TestEnumType             enumAttr;
    attribute short                    shortAttr;
    attribute unsigned short           unsignedShortAttr;
    attribute long                     longAttr;
    attribute long long                longLongAttr;
    attribute unsigned long long       unsignedLongLongAttr;
    attribute DOMString                stringAttr;
    [V8MeasureAs=TestFeature] attribute TestObj testObjAttr;

    // WK_ucfirst, WK_lcfirst exceptional cases.
    attribute TestObj                  XMLObjAttr;
    attribute boolean                  create;

    // Reflected DOM attributes
    [Reflect] attribute DOMString reflectedStringAttr;
    [Reflect] attribute long reflectedIntegralAttr;
    [Reflect] attribute unsigned long reflectedUnsignedIntegralAttr;
    [Reflect] attribute boolean reflectedBooleanAttr;
    [Reflect, URL] attribute DOMString reflectedURLAttr;
    [Reflect=customContentStringAttr] attribute DOMString reflectedStringAttr;
    [Reflect=customContentIntegralAttr] attribute long reflectedCustomIntegralAttr;
    [Reflect=customContentBooleanAttr] attribute boolean reflectedCustomBooleanAttr;
    [Reflect=customContentURLAttr, URL] attribute DOMString reflectedCustomURLAttr;

    // TypedArray attribute
    attribute Float32Array typedArrayAttr;

    // Methods
    void    voidMethod();
    void    voidMethodWithArgs(in long longArg, in DOMString strArg, in TestObj objArg);
    long    longMethod();
    long    longMethodWithArgs(in long longArg, in DOMString strArg, in TestObj objArg);
    [V8MeasureAs=TestFeature] TestObj objMethod();
    TestObj objMethodWithArgs(in long longArg, in DOMString strArg, in TestObj objArg);

    void methodWithSequenceArg(in sequence<ScriptProfile> sequenceArg);
    sequence<ScriptProfile> methodReturningSequence(in long longArg);

    void methodWithEnumArg(in TestEnumType enumArg);
    TestObj methodThatRequiresAllArgsAndThrows(in DOMString strArg, in TestObj objArg)
        raises(DOMException);

    void serializedValue(in SerializedScriptValue serializedArg);
    void optionsObject(in Dictionary oo, in [Optional] Dictionary ooo);

    // Exceptions
    void methodWithException() raises(DOMException);
    attribute long attrWithGetterException getter raises(DOMException);
    attribute long attrWithSetterException setter raises(DOMException);
    attribute DOMString stringAttrWithGetterException getter raises(DOMException);
    attribute DOMString stringAttrWithSetterException setter raises(DOMException);

    // 'Custom' extended attribute
    [Custom] attribute long            customAttr;
    [Custom, V8MeasureAs=CustomTestFeature] void customMethod();
    [Custom] void customMethodWithArgs(in long longArg, in DOMString strArg, in TestObj objArg);

    void addEventListener(in DOMString type, 
                          in EventListener listener, 
                          in [Optional] boolean useCapture);
    void removeEventListener(in DOMString type, 
                             in EventListener listener, 
                             in [Optional] boolean useCapture);

    // 'CallWith' extended attribute
    [CallWith=ScriptState] void withScriptStateVoid();
    [CallWith=ScriptState] TestObj withScriptStateObj();
    [CallWith=ScriptState] void withScriptStateVoidException()
        raises(DOMException);
    [CallWith=ScriptState] TestObj withScriptStateObjException()
        raises(DOMException);
    [CallWith=ScriptExecutionContext] void withScriptExecutionContext();
    [CallWith=ScriptExecutionContext|ScriptState] void withScriptExecutionContextAndScriptState();
    [CallWith=ScriptExecutionContext|ScriptState] TestObj withScriptExecutionContextAndScriptStateObjException()
        raises(DOMException);
    [CallWith=  ScriptExecutionContext  |  ScriptState  ] TestObj withScriptExecutionContextAndScriptStateWithSpaces();
    [CallWith=ScriptArguments|CallStack] void withScriptArgumentsAndCallStack();

    [CallWith=ScriptState] attribute long withScriptStateAttribute;
    [CallWith=ScriptExecutionContext] attribute TestObj withScriptExecutionContextAttribute;
    [CallWith=ScriptState] attribute TestObj withScriptStateAttributeRaises
        getter raises(DOMException);
    [CallWith=ScriptExecutionContext] attribute TestObj withScriptExecutionContextAttributeRaises
        getter raises(DOMException);
    [CallWith=ScriptExecutionContext|ScriptState] attribute TestObj withScriptExecutionContextAndScriptStateAttribute;
    [CallWith=ScriptExecutionContext|ScriptState] attribute TestObj withScriptExecutionContextAndScriptStateAttributeRaises
        getter raises(DOMException);
    [CallWith=  ScriptExecutionContext  |  ScriptState  ] attribute TestObj withScriptExecutionContextAndScriptStateWithSpacesAttribute;
    [CallWith=ScriptArguments|CallStack] attribute TestObj withScriptArgumentsAndCallStackAttribute;

    // 'Optional' extended attribute
    void    methodWithOptionalArg(in [Optional] long opt);
    void    methodWithNonOptionalArgAndOptionalArg(in long nonOpt, in [Optional] long opt);
    void    methodWithNonOptionalArgAndTwoOptionalArgs(in long nonOpt, in [Optional] long opt1, in [Optional] long opt2);
    void    methodWithOptionalString(in [Optional] DOMString str);
    void    methodWithOptionalStringIsUndefined(in [Optional=DefaultIsUndefined] DOMString str);
    void    methodWithOptionalStringIsNullString(in [Optional=DefaultIsNullString] DOMString str);

#if defined(TESTING_V8) || defined(TESTING_JS)
    // 'Callback' extended attribute
    void    methodWithCallbackArg(in [Callback] TestCallback callback);
    void    methodWithNonCallbackArgAndCallbackArg(in long nonCallback, in [Callback] TestCallback callback);
    void    methodWithCallbackAndOptionalArg(in [Callback, Optional] TestCallback callback);
    // static methods with 'Callback' extended attribute
    static void    staticMethodWithCallbackAndOptionalArg(in [Callback, Optional] TestCallback callback);
    static void    staticMethodWithCallbackArg(in [Callback] TestCallback callback);
#endif

#if defined(TESTING_V8)
    // 'EnforceRange' extended attribute
    void    methodWithEnforceRangeInt32(in [EnforceRange] long value);
    void    methodWithEnforceRangeUInt32(in [EnforceRange] unsigned long value);
    void    methodWithEnforceRangeInt64(in [EnforceRange] long long value);
    void    methodWithEnforceRangeUInt64(in [EnforceRange] unsigned long long value);

    attribute [EnforceRange] long enforcedRangeLongAttr;
    attribute [EnforceRange] unsigned long enforcedRangeUnsignedLongAttr;
    attribute [EnforceRange] long long enforcedRangeLongLongAttr;
    attribute [EnforceRange] unsigned long long enforcedRangeUnsignedLongLongAttr;
#endif

    // 'Conditional' extended attribute
    [Conditional=Condition1] attribute long conditionalAttr1;
    [Conditional=Condition1&Condition2] attribute long conditionalAttr2;
    [Conditional=Condition1|Condition2] attribute long conditionalAttr3;

    // 'Conditional' extended method
    [Conditional=Condition1] DOMString conditionalMethod1();
    [Conditional=Condition1&Condition2] void conditionalMethod2();
    [Conditional=Condition1|Condition2] void conditionalMethod3();

    [Conditional=Condition1] attribute TestObjectAConstructor conditionalAttr4;
    [Conditional=Condition1&Condition2] attribute TestObjectBConstructor conditionalAttr5;
    [Conditional=Condition1|Condition2] attribute TestObjectCConstructor conditionalAttr6;

    [Conditional=Condition1] const unsigned short CONDITIONAL_CONST = 0;

#if defined(TESTING_V8) || defined(TESTING_JS)
    [CachedAttribute] readonly attribute any cachedAttribute1;
    [CachedAttribute] readonly attribute any cachedAttribute2;
#endif
    
    attribute any anyAttribute;

#if defined(TESTING_V8) || defined(TESTING_JS)
    // Overloads
    void    overloadedMethod(in TestObj? objArg, in [StrictTypeChecking] DOMString strArg);
    void    overloadedMethod(in TestObj? objArg, in [Optional] long longArg);
    void    overloadedMethod(in [StrictTypeChecking] DOMString strArg);
    void    overloadedMethod(in long longArg);
    void    overloadedMethod(in [Callback] TestCallback callback);
    void    overloadedMethod(in DOMStringList? listArg);
    void    overloadedMethod(in DOMString[]? arrayArg);
    void    overloadedMethod(in TestObj objArg);
    void    overloadedMethod(in DOMString[] arrayArg);
    void    overloadedMethod(in sequence<unsigned long> arrayArg);
    void    overloadedMethod(in DOMString strArg);
#endif

    // Class methods within JavaScript (like what's used for IDBKeyRange).
    static void classMethod();
    static long classMethodWithOptional(in [Optional] long arg);
    [Custom] static void classMethod2(in long arg);

    // Static method with conditional on overloaded methods
    [Conditional=Condition1] static void overloadedMethod1(in long arg);
    [Conditional=Condition1] static void overloadedMethod1(in [StrictTypeChecking] DOMString type);

    void classMethodWithClamp(in [Clamp] unsigned short objArgsShort, in [Clamp] unsigned long objArgsLong);

#if defined(TESTING_V8)
    // 'V8EnabledAtRuntime' methods and attributes.
    [V8EnabledAtRuntime] void enabledAtRuntimeMethod1(in long longArg);
    [V8EnabledAtRuntime=FeatureName] void enabledAtRuntimeMethod2(in long longArg);
    [V8EnabledAtRuntime] attribute long enabledAtRuntimeAttr1;
    [V8EnabledAtRuntime=FeatureName] attribute long enabledAtRuntimeAttr2;
    // 'V8EnabledPerContext' methods and attributes.
    [V8EnabledPerContext] void enabledPerContextMethod1(in long longArg);
    [V8EnabledPerContext=FeatureName] void enabledPerContextMethod2(in long longArg);
    [V8EnabledPerContext] attribute long enabledPerContextAttr1;
    [V8EnabledPerContext=FeatureName] attribute long enabledPerContextAttr2;
#endif


#if defined(TESTING_V8)
    attribute float[]                   floatArray;
    attribute double[]                  doubleArray;
#endif

#if defined(TESTING_JS)
    void methodWithUnsignedLongSequence(in sequence<unsigned long> unsignedLongSequence);
#endif
#if defined(TESTING_V8) || defined(TESTING_JS)
    DOMString[] stringArrayFunction(in DOMString[] values) raises(DOMException);
    DOMStringList domStringListFunction(in DOMStringList values) raises(DOMException);
#endif

    [CheckSecurityForNode] readonly attribute Document contentDocument;
    [CheckSecurityForNode] SVGDocument getSVGDocument()
        raises(DOMException);

    void convert1(in [TreatReturnedNullStringAs=Null] a value);
    void convert2(in [TreatReturnedNullStringAs=Undefined] b value);
    void convert4(in [TreatNullAs=NullString] d value);
    void convert5(in [TreatNullAs=NullString, TreatUndefinedAs=NullString] e value);

    attribute SVGPoint mutablePoint;
    [Immutable] attribute SVGPoint immutablePoint;
    SVGPoint mutablePointFunction();
    [Immutable] SVGPoint immutablePointFunction();

    [ImplementedAs=banana] void orange();
    [ImplementedAs=blueberry] attribute long strawberry;

    [StrictTypeChecking] attribute float strictFloat;
    [StrictTypeChecking] bool strictFunction(in DOMString str, in float a, in long b)
        raises(DOMException);

    // ObjectiveC reserved words.
    readonly attribute long      description;
    attribute long               id;
    readonly attribute DOMString hash;

    // Check constants and enums.
    const unsigned short CONST_VALUE_0 = 0;
    const unsigned short CONST_VALUE_1 = 1;
    const unsigned short CONST_VALUE_2 = 2;
    const unsigned short CONST_VALUE_4 = 4;
    const unsigned short CONST_VALUE_8 = 8;
    const short CONST_VALUE_9 = -1;
    const DOMString CONST_VALUE_10 = "my constant string";
    const unsigned short CONST_VALUE_11 = 0xffffffff;
    const unsigned short CONST_VALUE_12 = 0x01;
    const unsigned short CONST_VALUE_13 = 0X20;
    const unsigned short CONST_VALUE_14 = 0x1abc;
    [Reflect=CONST_IMPL] const unsigned short CONST_JAVASCRIPT = 15;

    [Replaceable] readonly attribute long replaceableAttribute;

    void variadicStringMethod(in DOMString head, in DOMString... tail);
    void variadicDoubleMethod(in double head, in double... tail);
    void variadicNodeMethod(in Node head, in Node... tail);

    // Nullable attributes.
    readonly attribute double? nullableDoubleAttribute;
    readonly attribute long? nullableLongAttribute;
    readonly attribute boolean? nullableBooleanAttribute;
    readonly attribute DOMString? nullableStringAttribute;

    attribute long? nullableLongSettableAttribute;

    attribute long? nullableStringValue
        getter raises(DOMException);

#if defined(TESTING_V8)
    [V8PerWorldBindings] readonly attribute TestObj perWorldReadOnlyAttribute;
    [V8PerWorldBindings] attribute TestObj perWorldAttribute;
    [V8PerWorldBindings] void perWorldMethod();
    [V8PerWorldBindings] void overloadedPerWorldMethod(in long longArg);
    [V8PerWorldBindings] void overloadedPerWorldMethod(in DOMString strArg, in long longArg);
#endif
};