text: // Copyright 2014 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  // This file has been auto-generated by code_generator_v8.py.
  // DO NOT MODIFY!
  
  // This file has been generated from the Jinja2 template in
  // third_party/WebKit/Source/bindings/templates/interface.cpp.tmpl
  
  // clang-format off
  #include "V8TestObject.h"
  
  #include "bindings/core/v8/BindingSecurity.h"
  #include "bindings/core/v8/Dictionary.h"
  #include "bindings/core/v8/ExceptionState.h"
  #include "bindings/core/v8/IDLTypes.h"
  #include "bindings/core/v8/NativeValueTraitsImpl.h"
  #include "bindings/core/v8/ScriptCallStack.h"
  #include "bindings/core/v8/ScriptPromise.h"
  #include "bindings/core/v8/ScriptValue.h"
  #include "bindings/core/v8/V8AbstractEventListener.h"
  #include "bindings/core/v8/V8ArrayBuffer.h"
  #include "bindings/core/v8/V8ArrayBufferView.h"
  #include "bindings/core/v8/V8Attr.h"
  #include "bindings/core/v8/V8DOMActivityLogger.h"
  #include "bindings/core/v8/V8DOMConfiguration.h"
  #include "bindings/core/v8/V8Document.h"
  #include "bindings/core/v8/V8DocumentFragment.h"
  #include "bindings/core/v8/V8DocumentType.h"
  #include "bindings/core/v8/V8Element.h"
  #include "bindings/core/v8/V8EventListenerHelper.h"
  #include "bindings/core/v8/V8EventTarget.h"
  #include "bindings/core/v8/V8Float32Array.h"
  #include "bindings/core/v8/V8HTMLCollection.h"
  #include "bindings/core/v8/V8HTMLElement.h"
  #include "bindings/core/v8/V8Int32Array.h"
  #include "bindings/core/v8/V8Iterator.h"
  #include "bindings/core/v8/V8Node.h"
  #include "bindings/core/v8/V8NodeFilterCondition.h"
  #include "bindings/core/v8/V8ShadowRoot.h"
  #include "bindings/core/v8/V8TestCallbackInterface.h"
  #include "bindings/core/v8/V8TestDictionary.h"
  #include "bindings/core/v8/V8TestInterface.h"
  #include "bindings/core/v8/V8TestInterfaceEmpty.h"
  #include "bindings/core/v8/V8TestInterfaceGarbageCollected.h"
  #include "bindings/core/v8/V8TestNode.h"
  #include "bindings/core/v8/V8TestObject.h"
  #include "bindings/core/v8/V8Uint8Array.h"
  #include "bindings/core/v8/V8Window.h"
  #include "bindings/core/v8/V8XPathNSResolver.h"
  #include "bindings/core/v8/serialization/SerializedScriptValue.h"
  #include "bindings/core/v8/serialization/SerializedScriptValueFactory.h"
  #include "bindings/core/v8/serialization/Transferables.h"
  #include "core/HTMLNames.h"
  #include "core/dom/ClassCollection.h"
  #include "core/dom/ExecutionContext.h"
  #include "core/dom/TagCollection.h"
  #include "core/frame/Deprecation.h"
  #include "core/frame/UseCounter.h"
  #include "core/html/HTMLCollection.h"
  #include "core/html/HTMLDataListOptionsCollection.h"
  #include "core/html/HTMLFormControlsCollection.h"
  #include "core/html/HTMLTableRowsCollection.h"
  #include "core/html/custom/V0CustomElementProcessingStack.h"
  #include "core/imagebitmap/ImageBitmap.h"
  #include "core/inspector/ConsoleMessage.h"
  #include "core/inspector/ScriptArguments.h"
  #include "core/origin_trials/OriginTrials.h"
  #include "core/typed_arrays/ArrayBufferViewHelpers.h"
  #include "core/typed_arrays/DOMArrayBufferBase.h"
  #include "core/typed_arrays/FlexibleArrayBufferView.h"
  #include "platform/RuntimeEnabledFeatures.h"
  #include "platform/bindings/RuntimeCallStats.h"
  #include "platform/bindings/ScriptState.h"
  #include "platform/bindings/V8ObjectConstructor.h"
  #include "platform/bindings/V8PrivateProperty.h"
  #include "platform/wtf/GetPtr.h"
  #include "platform/wtf/RefPtr.h"
  
  namespace blink {
  
  // Suppress warning: global constructors, because struct WrapperTypeInfo is trivial
  // and does not depend on another global objects.
  #if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wglobal-constructors"
  #endif
  const WrapperTypeInfo V8TestObject::wrapperTypeInfo = {
      gin::kEmbedderBlink,
      V8TestObject::domTemplate,
      V8TestObject::Trace,
      V8TestObject::TraceWrappers,
      V8TestObject::preparePrototypeAndInterfaceObject,
      "TestObject",
      nullptr,
      WrapperTypeInfo::kWrapperTypeObjectPrototype,
      WrapperTypeInfo::kObjectClassId,
      WrapperTypeInfo::kNotInheritFromActiveScriptWrappable,
      WrapperTypeInfo::kIndependent,
  };
  #if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
  #pragma clang diagnostic pop
  #endif
  
  // This static member must be declared by DEFINE_WRAPPERTYPEINFO in TestObject.h.
  // For details, see the comment of DEFINE_WRAPPERTYPEINFO in
  // platform/bindings/ScriptWrappable.h.
  const WrapperTypeInfo& TestObject::wrapper_type_info_ = V8TestObject::wrapperTypeInfo;
  
  // not [ActiveScriptWrappable]
  static_assert(
      !std::is_base_of<ActiveScriptWrappableBase, TestObject>::value,
      "TestObject inherits from ActiveScriptWrappable<>, but is not specifying "
      "[ActiveScriptWrappable] extended attribute in the IDL file.  "
      "Be consistent.");
  static_assert(
      std::is_same<decltype(&TestObject::HasPendingActivity),
                   decltype(&ScriptWrappable::HasPendingActivity)>::value,
      "TestObject is overriding hasPendingActivity(), but is not specifying "
      "[ActiveScriptWrappable] extended attribute in the IDL file.  "
      "Be consistent.");
  
  namespace TestObjectV8Internal {
  
  static void stringifierAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->stringifierAttribute(), info.GetIsolate());
  }
  
  static void stringifierAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setStringifierAttribute(cppValue);
  }
  
  static void readonlyStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->readonlyStringAttribute(), info.GetIsolate());
  }
  
  static void readonlyTestInterfaceEmptyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    TestInterfaceEmpty* cppValue(WTF::GetPtr(impl->readonlyTestInterfaceEmptyAttribute()));
  
    // Keep the wrapper object for the return value alive as long as |this|
    // object is alive in order to save creation time of the wrapper object.
    if (cppValue && DOMDataStore::SetReturnValue(info.GetReturnValue(), cppValue))
      return;
    v8::Local<v8::Value> v8Value(ToV8(cppValue, holder, info.GetIsolate()));
    V8PrivateProperty::GetSymbol(
        info.GetIsolate(), "KeepAlive#TestObject#readonlyTestInterfaceEmptyAttribute")
        .Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void readonlyLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->readonlyLongAttribute());
  }
  
  static void dateAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, V8DateOrNaN(info.GetIsolate(), impl->dateAttribute()));
  }
  
  static void dateAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "dateAttribute");
  
    // Prepare the value to be set.
    double cppValue = NativeValueTraits<IDLDate>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setDateAttribute(cppValue);
  }
  
  static void stringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->stringAttribute(), info.GetIsolate());
  }
  
  static void stringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setStringAttribute(cppValue);
  }
  
  static void byteStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->byteStringAttribute(), info.GetIsolate());
  }
  
  static void byteStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "byteStringAttribute");
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = NativeValueTraits<IDLByteString>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setByteStringAttribute(cppValue);
  }
  
  static void usvStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->usvStringAttribute(), info.GetIsolate());
  }
  
  static void usvStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "usvStringAttribute");
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = NativeValueTraits<IDLUSVString>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setUsvStringAttribute(cppValue);
  }
  
  static void domTimeStampAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, static_cast<double>(impl->domTimeStampAttribute()));
  }
  
  static void domTimeStampAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "domTimeStampAttribute");
  
    // Prepare the value to be set.
    uint64_t cppValue = NativeValueTraits<IDLUnsignedLongLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setDomTimeStampAttribute(cppValue);
  }
  
  static void booleanAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueBool(info, impl->booleanAttribute());
  }
  
  static void booleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "booleanAttribute");
  
    // Prepare the value to be set.
    bool cppValue = NativeValueTraits<IDLBoolean>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setBooleanAttribute(cppValue);
  }
  
  static void byteAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->byteAttribute());
  }
  
  static void byteAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "byteAttribute");
  
    // Prepare the value to be set.
    int8_t cppValue = NativeValueTraits<IDLByte>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setByteAttribute(cppValue);
  }
  
  static void doubleAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->doubleAttribute());
  }
  
  static void doubleAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "doubleAttribute");
  
    // Prepare the value to be set.
    double cppValue = NativeValueTraits<IDLDouble>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setDoubleAttribute(cppValue);
  }
  
  static void floatAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->floatAttribute());
  }
  
  static void floatAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "floatAttribute");
  
    // Prepare the value to be set.
    float cppValue = NativeValueTraits<IDLFloat>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setFloatAttribute(cppValue);
  }
  
  static void longAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->longAttribute());
  }
  
  static void longAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "longAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setLongAttribute(cppValue);
  }
  
  static void longLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, static_cast<double>(impl->longLongAttribute()));
  }
  
  static void longLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "longLongAttribute");
  
    // Prepare the value to be set.
    int64_t cppValue = NativeValueTraits<IDLLongLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setLongLongAttribute(cppValue);
  }
  
  static void octetAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueUnsigned(info, impl->octetAttribute());
  }
  
  static void octetAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "octetAttribute");
  
    // Prepare the value to be set.
    uint8_t cppValue = NativeValueTraits<IDLOctet>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setOctetAttribute(cppValue);
  }
  
  static void shortAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->shortAttribute());
  }
  
  static void shortAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "shortAttribute");
  
    // Prepare the value to be set.
    int16_t cppValue = NativeValueTraits<IDLShort>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setShortAttribute(cppValue);
  }
  
  static void unrestrictedDoubleAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->unrestrictedDoubleAttribute());
  }
  
  static void unrestrictedDoubleAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unrestrictedDoubleAttribute");
  
    // Prepare the value to be set.
    double cppValue = NativeValueTraits<IDLUnrestrictedDouble>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setUnrestrictedDoubleAttribute(cppValue);
  }
  
  static void unrestrictedFloatAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->unrestrictedFloatAttribute());
  }
  
  static void unrestrictedFloatAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unrestrictedFloatAttribute");
  
    // Prepare the value to be set.
    float cppValue = NativeValueTraits<IDLUnrestrictedFloat>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setUnrestrictedFloatAttribute(cppValue);
  }
  
  static void unsignedLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueUnsigned(info, impl->unsignedLongAttribute());
  }
  
  static void unsignedLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unsignedLongAttribute");
  
    // Prepare the value to be set.
    uint32_t cppValue = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setUnsignedLongAttribute(cppValue);
  }
  
  static void unsignedLongLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, static_cast<double>(impl->unsignedLongLongAttribute()));
  }
  
  static void unsignedLongLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unsignedLongLongAttribute");
  
    // Prepare the value to be set.
    uint64_t cppValue = NativeValueTraits<IDLUnsignedLongLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setUnsignedLongLongAttribute(cppValue);
  }
  
  static void unsignedShortAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueUnsigned(info, impl->unsignedShortAttribute());
  }
  
  static void unsignedShortAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unsignedShortAttribute");
  
    // Prepare the value to be set.
    uint16_t cppValue = NativeValueTraits<IDLUnsignedShort>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setUnsignedShortAttribute(cppValue);
  }
  
  static void testInterfaceEmptyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->testInterfaceEmptyAttribute()), impl);
  }
  
  static void testInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testInterfaceEmptyAttribute");
  
    // Prepare the value to be set.
    TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterfaceEmpty'.");
      return;
    }
  
    impl->setTestInterfaceEmptyAttribute(cppValue);
  }
  
  static void testObjectAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->testObjectAttribute()), impl);
  }
  
  static void testObjectAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testObjectAttribute");
  
    // Prepare the value to be set.
    TestObject* cppValue = V8TestObject::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestObject'.");
      return;
    }
  
    impl->setTestObjectAttribute(cppValue);
  }
  
  static void cssAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->cssAttribute());
  }
  
  static void cssAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "cssAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setCSSAttribute(cppValue);
  }
  
  static void imeAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->imeAttribute());
  }
  
  static void imeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "imeAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setIMEAttribute(cppValue);
  }
  
  static void svgAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->svgAttribute());
  }
  
  static void svgAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "svgAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setSVGAttribute(cppValue);
  }
  
  static void xmlAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->xmlAttribute());
  }
  
  static void xmlAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "xmlAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setXMLAttribute(cppValue);
  }
  
  static void nodeFilterAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, ToV8(WTF::GetPtr(impl->nodeFilterAttribute()), info.Holder(), info.GetIsolate()));
  }
  
  static void nodeFilterAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8NodeFilterCondition* cppValue = V8NodeFilter::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    impl->setNodeFilterAttribute(cppValue);
  }
  
  static void serializedScriptValueAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, V8Deserialize(info.GetIsolate(), WTF::GetPtr(impl->serializedScriptValueAttribute())));
  }
  
  static void serializedScriptValueAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "serializedScriptValueAttribute");
  
    // Prepare the value to be set.
    RefPtr<SerializedScriptValue> cppValue = NativeValueTraits<SerializedScriptValue>::NativeValue(info.GetIsolate(), v8Value, SerializedScriptValue::SerializeOptions(SerializedScriptValue::kNotForStorage), exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setSerializedScriptValueAttribute(cppValue);
  }
  
  static void anyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->anyAttribute().V8Value());
  }
  
  static void anyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    ScriptValue cppValue = ScriptValue(ScriptState::Current(info.GetIsolate()), v8Value);
  
    impl->setAnyAttribute(cppValue);
  }
  
  static void promiseAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->promiseAttribute().V8Value());
  }
  
  static void promiseAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    ScriptPromise cppValue = ScriptPromise::Cast(ScriptState::Current(info.GetIsolate()), v8Value);
  
    impl->setPromiseAttribute(cppValue);
  }
  
  static void windowAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->windowAttribute()), impl);
  }
  
  static void windowAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "windowAttribute");
  
    // Prepare the value to be set.
    DOMWindow* cppValue = ToDOMWindow(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'Window'.");
      return;
    }
  
    impl->setWindowAttribute(cppValue);
  }
  
  static void documentAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->documentAttribute()), impl);
  }
  
  static void documentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "documentAttribute");
  
    // Prepare the value to be set.
    Document* cppValue = V8Document::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'Document'.");
      return;
    }
  
    impl->setDocumentAttribute(cppValue);
  }
  
  static void documentFragmentAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->documentFragmentAttribute()), impl);
  }
  
  static void documentFragmentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "documentFragmentAttribute");
  
    // Prepare the value to be set.
    DocumentFragment* cppValue = V8DocumentFragment::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'DocumentFragment'.");
      return;
    }
  
    impl->setDocumentFragmentAttribute(cppValue);
  }
  
  static void documentTypeAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->documentTypeAttribute()), impl);
  }
  
  static void documentTypeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "documentTypeAttribute");
  
    // Prepare the value to be set.
    DocumentType* cppValue = V8DocumentType::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'DocumentType'.");
      return;
    }
  
    impl->setDocumentTypeAttribute(cppValue);
  }
  
  static void elementAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->elementAttribute()), impl);
  }
  
  static void elementAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "elementAttribute");
  
    // Prepare the value to be set.
    Element* cppValue = V8Element::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'Element'.");
      return;
    }
  
    impl->setElementAttribute(cppValue);
  }
  
  static void nodeAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->nodeAttribute()), impl);
  }
  
  static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "nodeAttribute");
  
    // Prepare the value to be set.
    Node* cppValue = V8Node::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'Node'.");
      return;
    }
  
    impl->setNodeAttribute(cppValue);
  }
  
  static void shadowRootAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->shadowRootAttribute()), impl);
  }
  
  static void shadowRootAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "shadowRootAttribute");
  
    // Prepare the value to be set.
    ShadowRoot* cppValue = V8ShadowRoot::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'ShadowRoot'.");
      return;
    }
  
    impl->setShadowRootAttribute(cppValue);
  }
  
  static void arrayBufferAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->arrayBufferAttribute()), impl);
  }
  
  static void arrayBufferAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "arrayBufferAttribute");
  
    // Prepare the value to be set.
    TestArrayBuffer* cppValue = v8Value->IsArrayBuffer() ? V8ArrayBuffer::toImpl(v8::Local<v8::ArrayBuffer>::Cast(v8Value)) : 0;
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'ArrayBuffer'.");
      return;
    }
  
    impl->setArrayBufferAttribute(cppValue);
  }
  
  static void float32ArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, impl->float32ArrayAttribute(), impl);
  }
  
  static void float32ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "float32ArrayAttribute");
  
    // Prepare the value to be set.
    NotShared<DOMFloat32Array> cppValue = ToNotShared<NotShared<DOMFloat32Array>>(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'Float32Array'.");
      return;
    }
  
    impl->setFloat32ArrayAttribute(cppValue);
  }
  
  static void uint8ArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, impl->uint8ArrayAttribute(), impl);
  }
  
  static void uint8ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "uint8ArrayAttribute");
  
    // Prepare the value to be set.
    NotShared<DOMUint8Array> cppValue = ToNotShared<NotShared<DOMUint8Array>>(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'Uint8Array'.");
      return;
    }
  
    impl->setUint8ArrayAttribute(cppValue);
  }
  
  static void selfAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->self()), impl);
  }
  
  static void readonlyEventTargetAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->readonlyEventTargetAttribute()), impl);
  }
  
  static void readonlyEventTargetOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->readonlyEventTargetOrNullAttribute()), impl);
  }
  
  static void readonlyWindowAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->readonlyWindowAttribute()), impl);
  }
  
  static void htmlCollectionAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->htmlCollectionAttribute()), impl);
  }
  
  static void htmlElementAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->htmlElementAttribute()), impl);
  }
  
  static void stringArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, ToV8(impl->stringArrayAttribute(), info.Holder(), info.GetIsolate()));
  }
  
  static void stringArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "stringArrayAttribute");
  
    // Prepare the value to be set.
    Vector<String> cppValue = NativeValueTraits<IDLSequence<IDLString>>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setStringArrayAttribute(cppValue);
  }
  
  static void testInterfaceEmptyArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, ToV8(impl->testInterfaceEmptyArrayAttribute(), info.Holder(), info.GetIsolate()));
  }
  
  static void testInterfaceEmptyArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testInterfaceEmptyArrayAttribute");
  
    // Prepare the value to be set.
    HeapVector<Member<TestInterfaceEmpty>> cppValue = NativeValueTraits<IDLSequence<TestInterfaceEmpty>>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setTestInterfaceEmptyArrayAttribute(cppValue);
  }
  
  static void floatArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, ToV8(impl->floatArrayAttribute(), info.Holder(), info.GetIsolate()));
  }
  
  static void floatArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "floatArrayAttribute");
  
    // Prepare the value to be set.
    Vector<float> cppValue = NativeValueTraits<IDLSequence<IDLFloat>>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setFloatArrayAttribute(cppValue);
  }
  
  static void stringFrozenArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, FreezeV8Object(ToV8(impl->stringFrozenArrayAttribute(), info.Holder(), info.GetIsolate()), info.GetIsolate()));
  }
  
  static void stringFrozenArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "stringFrozenArrayAttribute");
  
    // Prepare the value to be set.
    Vector<String> cppValue = NativeValueTraits<IDLSequence<IDLString>>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setStringFrozenArrayAttribute(cppValue);
  }
  
  static void testInterfaceEmptyFrozenArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, FreezeV8Object(ToV8(impl->testInterfaceEmptyFrozenArrayAttribute(), info.Holder(), info.GetIsolate()), info.GetIsolate()));
  }
  
  static void testInterfaceEmptyFrozenArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testInterfaceEmptyFrozenArrayAttribute");
  
    // Prepare the value to be set.
    HeapVector<Member<TestInterfaceEmpty>> cppValue = NativeValueTraits<IDLSequence<TestInterfaceEmpty>>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setTestInterfaceEmptyFrozenArrayAttribute(cppValue);
  }
  
  static void booleanOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    bool isNull = false;
  
    bool cppValue(impl->booleanOrNullAttribute(isNull));
  
    if (isNull) {
      V8SetReturnValueNull(info);
      return;
    }
  
    V8SetReturnValueBool(info, cppValue);
  }
  
  static void booleanOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "booleanOrNullAttribute");
  
    // Prepare the value to be set.
    bool cppValue = NativeValueTraits<IDLBoolean>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    bool isNull = IsUndefinedOrNull(v8Value);
    impl->setBooleanOrNullAttribute(cppValue, isNull);
  }
  
  static void stringOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueStringOrNull(info, impl->stringOrNullAttribute(), info.GetIsolate());
  }
  
  static void stringOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<kTreatNullAndUndefinedAsNullString> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setStringOrNullAttribute(cppValue);
  }
  
  static void longOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    bool isNull = false;
  
    int32_t cppValue(impl->longOrNullAttribute(isNull));
  
    if (isNull) {
      V8SetReturnValueNull(info);
      return;
    }
  
    V8SetReturnValueInt(info, cppValue);
  }
  
  static void longOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "longOrNullAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    bool isNull = IsUndefinedOrNull(v8Value);
    impl->setLongOrNullAttribute(cppValue, isNull);
  }
  
  static void testInterfaceOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->testInterfaceOrNullAttribute()), impl);
  }
  
  static void testInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testInterfaceOrNullAttribute");
  
    // Prepare the value to be set.
    TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue && !IsUndefinedOrNull(v8Value)) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterface'.");
      return;
    }
  
    impl->setTestInterfaceOrNullAttribute(cppValue);
  }
  
  static void testEnumAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->testEnumAttribute(), info.GetIsolate());
  }
  
  static void testEnumAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testEnumAttribute");
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    // Type check per: http://heycam.github.io/webidl/#dfn-attribute-setter
    // Returns undefined without setting the value if the value is invalid.
    DummyExceptionStateForTesting dummyExceptionState;
    const char* validValues[] = {
        "",
        "EnumValue1",
        "EnumValue2",
        "EnumValue3",
    };
    if (!IsValidEnum(cppValue, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", dummyExceptionState)) {
      CurrentExecutionContext(isolate)->AddConsoleMessage(ConsoleMessage::Create(kJSMessageSource, kWarningMessageLevel, dummyExceptionState.Message()));
      return;
    }
  
    impl->setTestEnumAttribute(cppValue);
  }
  
  static void testEnumOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueStringOrNull(info, impl->testEnumOrNullAttribute(), info.GetIsolate());
  }
  
  static void testEnumOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testEnumOrNullAttribute");
  
    // Prepare the value to be set.
    V8StringResource<kTreatNullAndUndefinedAsNullString> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    // Type check per: http://heycam.github.io/webidl/#dfn-attribute-setter
    // Returns undefined without setting the value if the value is invalid.
    DummyExceptionStateForTesting dummyExceptionState;
    const char* validValues[] = {
        "",
        "EnumValue1",
        "EnumValue2",
        "EnumValue3",
    };
    if (!IsValidEnum(cppValue, validValues, WTF_ARRAY_LENGTH(validValues), "TestEnum", dummyExceptionState)) {
      CurrentExecutionContext(isolate)->AddConsoleMessage(ConsoleMessage::Create(kJSMessageSource, kWarningMessageLevel, dummyExceptionState.Message()));
      return;
    }
  
    impl->setTestEnumOrNullAttribute(cppValue);
  }
  
  static void staticStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8SetReturnValueString(info, TestObject::staticStringAttribute(), info.GetIsolate());
  }
  
  static void staticStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    TestObject::setStaticStringAttribute(cppValue);
  }
  
  static void staticLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8SetReturnValueInt(info, TestObject::staticLongAttribute());
  }
  
  static void staticLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "staticLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    TestObject::setStaticLongAttribute(cppValue);
  }
  
  static void eventHandlerAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    EventListener* cppValue(WTF::GetPtr(impl->eventHandlerAttribute()));
  
    V8SetReturnValue(info, cppValue ? V8AbstractEventListener::Cast(cppValue)->GetListenerOrNull(info.GetIsolate(), impl->GetExecutionContext()) : v8::Null(info.GetIsolate()).As<v8::Value>());
  }
  
  static void eventHandlerAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    MoveEventListenerToNewWrapper(isolate, holder, impl->eventHandlerAttribute(), v8Value, V8TestObject::eventListenerCacheIndex);
  
    impl->setEventHandlerAttribute(V8EventListenerHelper::GetEventListener(ScriptState::ForReceiverObject(info), v8Value, true, kListenerFindOrCreate));
  }
  
  static void doubleOrStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    DoubleOrString result;
    impl->doubleOrStringAttribute(result);
  
    V8SetReturnValue(info, result);
  }
  
  static void doubleOrStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "doubleOrStringAttribute");
  
    // Prepare the value to be set.
    DoubleOrString cppValue;
    V8DoubleOrString::toImpl(info.GetIsolate(), v8Value, cppValue, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setDoubleOrStringAttribute(cppValue);
  }
  
  static void doubleOrStringOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    DoubleOrString result;
    impl->doubleOrStringOrNullAttribute(result);
  
    V8SetReturnValue(info, result);
  }
  
  static void doubleOrStringOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "doubleOrStringOrNullAttribute");
  
    // Prepare the value to be set.
    DoubleOrString cppValue;
    V8DoubleOrString::toImpl(info.GetIsolate(), v8Value, cppValue, UnionTypeConversionMode::kNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setDoubleOrStringOrNullAttribute(cppValue);
  }
  
  static void doubleOrNullStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    DoubleOrString result;
    impl->doubleOrNullStringAttribute(result);
  
    V8SetReturnValue(info, result);
  }
  
  static void doubleOrNullStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "doubleOrNullStringAttribute");
  
    // Prepare the value to be set.
    DoubleOrString cppValue;
    V8DoubleOrNullOrString::toImpl(info.GetIsolate(), v8Value, cppValue, UnionTypeConversionMode::kNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setDoubleOrNullStringAttribute(cppValue);
  }
  
  static void stringOrStringSequenceAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    StringOrStringSequence result;
    impl->stringOrStringSequenceAttribute(result);
  
    V8SetReturnValue(info, result);
  }
  
  static void stringOrStringSequenceAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "stringOrStringSequenceAttribute");
  
    // Prepare the value to be set.
    StringOrStringSequence cppValue;
    V8StringOrStringSequence::toImpl(info.GetIsolate(), v8Value, cppValue, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setStringOrStringSequenceAttribute(cppValue);
  }
  
  static void testEnumOrDoubleAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    TestEnumOrDouble result;
    impl->testEnumOrDoubleAttribute(result);
  
    V8SetReturnValue(info, result);
  }
  
  static void testEnumOrDoubleAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testEnumOrDoubleAttribute");
  
    // Prepare the value to be set.
    TestEnumOrDouble cppValue;
    V8TestEnumOrDouble::toImpl(info.GetIsolate(), v8Value, cppValue, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setTestEnumOrDoubleAttribute(cppValue);
  }
  
  static void unrestrictedDoubleOrStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    UnrestrictedDoubleOrString result;
    impl->unrestrictedDoubleOrStringAttribute(result);
  
    V8SetReturnValue(info, result);
  }
  
  static void unrestrictedDoubleOrStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unrestrictedDoubleOrStringAttribute");
  
    // Prepare the value to be set.
    UnrestrictedDoubleOrString cppValue;
    V8UnrestrictedDoubleOrString::toImpl(info.GetIsolate(), v8Value, cppValue, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setUnrestrictedDoubleOrStringAttribute(cppValue);
  }
  
  static void nestedUnionAtributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    DoubleOrStringOrDoubleOrStringSequence result;
    impl->nestedUnionAtribute(result);
  
    V8SetReturnValue(info, result);
  }
  
  static void nestedUnionAtributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "nestedUnionAtribute");
  
    // Prepare the value to be set.
    DoubleOrStringOrDoubleOrStringSequence cppValue;
    V8DoubleOrStringOrDoubleOrStringSequence::toImpl(info.GetIsolate(), v8Value, cppValue, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setNestedUnionAtribute(cppValue);
  }
  
  static void activityLoggingAccessForAllWorldsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingAccessForAllWorldsLongAttribute());
  }
  
  static void activityLoggingAccessForAllWorldsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingAccessForAllWorldsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingAccessForAllWorldsLongAttribute(cppValue);
  }
  
  static void activityLoggingGetterForAllWorldsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingGetterForAllWorldsLongAttribute());
  }
  
  static void activityLoggingGetterForAllWorldsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingGetterForAllWorldsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingGetterForAllWorldsLongAttribute(cppValue);
  }
  
  static void activityLoggingSetterForAllWorldsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingSetterForAllWorldsLongAttribute());
  }
  
  static void activityLoggingSetterForAllWorldsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingSetterForAllWorldsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingSetterForAllWorldsLongAttribute(cppValue);
  }
  
  static void cachedAttributeAnyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // [CachedAttribute]
    V8PrivateProperty::Symbol propertySymbol =
        V8PrivateProperty::GetSymbol(info.GetIsolate(),
            "TestObject#Cachedattributeanyattribute");
    if (!static_cast<const TestObject*>(impl)->isValueDirty()) {
      v8::Local<v8::Value> v8Value = propertySymbol.GetOrUndefined(holder);
      if (!v8Value->IsUndefined()) {
        V8SetReturnValue(info, v8Value);
        return;
      }
    }
  
    ScriptValue cppValue(impl->cachedAttributeAnyAttribute());
  
    // [CachedAttribute]
    v8::Local<v8::Value> v8Value(cppValue.V8Value());
    propertySymbol.Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void cachedAttributeAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    ScriptValue cppValue = ScriptValue(ScriptState::Current(info.GetIsolate()), v8Value);
  
    impl->setCachedAttributeAnyAttribute(cppValue);
  
    // [CachedAttribute]
    // Invalidate the cached value.
    V8PrivateProperty::GetSymbol(
        isolate, "TestObject#Cachedattributeanyattribute")
        .DeleteProperty(holder, v8::Undefined(isolate));
  }
  
  static void cachedArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // [CachedAttribute]
    V8PrivateProperty::Symbol propertySymbol =
        V8PrivateProperty::GetSymbol(info.GetIsolate(),
            "TestObject#Cachedarrayattribute");
    if (!static_cast<const TestObject*>(impl)->isArrayDirty()) {
      v8::Local<v8::Value> v8Value = propertySymbol.GetOrUndefined(holder);
      if (!v8Value->IsUndefined()) {
        V8SetReturnValue(info, v8Value);
        return;
      }
    }
  
    Vector<String> cppValue(impl->cachedArrayAttribute());
  
    // [CachedAttribute]
    v8::Local<v8::Value> v8Value(ToV8(cppValue, holder, info.GetIsolate()));
    propertySymbol.Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void cachedArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "cachedArrayAttribute");
  
    // Prepare the value to be set.
    Vector<String> cppValue = NativeValueTraits<IDLSequence<IDLString>>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setCachedArrayAttribute(cppValue);
  
    // [CachedAttribute]
    // Invalidate the cached value.
    V8PrivateProperty::GetSymbol(
        isolate, "TestObject#Cachedarrayattribute")
        .DeleteProperty(holder, v8::Undefined(isolate));
  }
  
  static void cachedStringOrNoneAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // [CachedAttribute]
    V8PrivateProperty::Symbol propertySymbol =
        V8PrivateProperty::GetSymbol(info.GetIsolate(),
            "TestObject#Cachedstringornoneattribute");
    if (!static_cast<const TestObject*>(impl)->isStringDirty()) {
      v8::Local<v8::Value> v8Value = propertySymbol.GetOrUndefined(holder);
      if (!v8Value->IsUndefined()) {
        V8SetReturnValue(info, v8Value);
        return;
      }
    }
  
    String cppValue(impl->cachedStringOrNoneAttribute());
  
    // [CachedAttribute]
    v8::Local<v8::Value> v8Value(cppValue.IsNull() ? v8::Local<v8::Value>(v8::Null(info.GetIsolate())) : V8String(info.GetIsolate(), cppValue));
    propertySymbol.Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void cachedStringOrNoneAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<kTreatNullAndUndefinedAsNullString> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setCachedStringOrNoneAttribute(cppValue);
  
    // [CachedAttribute]
    // Invalidate the cached value.
    V8PrivateProperty::GetSymbol(
        isolate, "TestObject#Cachedstringornoneattribute")
        .DeleteProperty(holder, v8::Undefined(isolate));
  }
  
  static void callWithExecutionContextAnyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExecutionContext* executionContext = CurrentExecutionContext(info.GetIsolate());
  
    V8SetReturnValue(info, impl->callWithExecutionContextAnyAttribute(executionContext).V8Value());
  }
  
  static void callWithExecutionContextAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    ScriptValue cppValue = ScriptValue(ScriptState::Current(info.GetIsolate()), v8Value);
  
    ExecutionContext* executionContext = CurrentExecutionContext(isolate);
  
    impl->setCallWithExecutionContextAnyAttribute(executionContext, cppValue);
  }
  
  static void callWithScriptStateAnyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    V8SetReturnValue(info, impl->callWithScriptStateAnyAttribute(scriptState).V8Value());
  }
  
  static void callWithScriptStateAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    ScriptValue cppValue = ScriptValue(ScriptState::Current(info.GetIsolate()), v8Value);
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    impl->setCallWithScriptStateAnyAttribute(scriptState, cppValue);
  }
  
  static void callWithExecutionContextAndScriptStateAnyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExecutionContext* executionContext = CurrentExecutionContext(info.GetIsolate());
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    V8SetReturnValue(info, impl->callWithExecutionContextAndScriptStateAnyAttribute(scriptState, executionContext).V8Value());
  }
  
  static void callWithExecutionContextAndScriptStateAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    ScriptValue cppValue = ScriptValue(ScriptState::Current(info.GetIsolate()), v8Value);
  
    ExecutionContext* executionContext = CurrentExecutionContext(isolate);
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    impl->setCallWithExecutionContextAndScriptStateAnyAttribute(scriptState, executionContext, cppValue);
  }
  
  static void checkSecurityForNodeReadonlyDocumentAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Perform a security check for the returned object.
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kGetterContext, "TestObject", "checkSecurityForNodeReadonlyDocumentAttribute");
    if (!BindingSecurity::ShouldAllowAccessTo(CurrentDOMWindow(info.GetIsolate()), WTF::GetPtr(impl->checkSecurityForNodeReadonlyDocumentAttribute()), exceptionState)) {
      V8SetReturnValueNull(info);
      return;
    }
  
    V8SetReturnValue(info, ToV8(WTF::GetPtr(impl->checkSecurityForNodeReadonlyDocumentAttribute()), ToV8(impl->contentWindow(), v8::Local<v8::Object>(), info.GetIsolate()).As<v8::Object>(), info.GetIsolate()));
  }
  
  static void customGetterLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "customGetterLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setCustomGetterLongAttribute(cppValue);
  }
  
  static void customSetterLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->customSetterLongAttribute());
  }
  
  static void deprecatedLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->deprecatedLongAttribute());
  }
  
  static void deprecatedLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "deprecatedLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setDeprecatedLongAttribute(cppValue);
  }
  
  static void enforceRangeLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->enforceRangeLongAttribute());
  }
  
  static void enforceRangeLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "enforceRangeLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kEnforceRange);
    if (exceptionState.HadException())
      return;
  
    impl->setEnforceRangeLongAttribute(cppValue);
  }
  
  static void implementedAsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->implementedAsName());
  }
  
  static void implementedAsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "implementedAsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setImplementedAsName(cppValue);
  }
  
  static void customGetterImplementedAsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "customGetterImplementedAsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setImplementedAsNameWithCustomGetter(cppValue);
  }
  
  static void customSetterImplementedAsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->implementedAsNameWithCustomGetter());
  }
  
  static void measureAsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->measureAsLongAttribute());
  }
  
  static void measureAsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "measureAsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setMeasureAsLongAttribute(cppValue);
  }
  
  static void notEnumerableLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->notEnumerableLongAttribute());
  }
  
  static void notEnumerableLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "notEnumerableLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setNotEnumerableLongAttribute(cppValue);
  }
  
  static void originTrialEnabledLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->originTrialEnabledLongAttribute());
  }
  
  static void originTrialEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "originTrialEnabledLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setOriginTrialEnabledLongAttribute(cppValue);
  }
  
  static void perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    TestInterfaceEmpty* cppValue(WTF::GetPtr(impl->perWorldBindingsReadonlyTestInterfaceEmptyAttribute()));
  
    // Keep the wrapper object for the return value alive as long as |this|
    // object is alive in order to save creation time of the wrapper object.
    if (cppValue && DOMDataStore::SetReturnValue(info.GetReturnValue(), cppValue))
      return;
    v8::Local<v8::Value> v8Value(ToV8(cppValue, holder, info.GetIsolate()));
    V8PrivateProperty::GetSymbol(
        info.GetIsolate(), "KeepAlive#TestObject#perWorldBindingsReadonlyTestInterfaceEmptyAttribute")
        .Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    TestInterfaceEmpty* cppValue(WTF::GetPtr(impl->perWorldBindingsReadonlyTestInterfaceEmptyAttribute()));
  
    // Keep the wrapper object for the return value alive as long as |this|
    // object is alive in order to save creation time of the wrapper object.
    if (cppValue && DOMDataStore::SetReturnValueForMainWorld(info.GetReturnValue(), cppValue))
      return;
    v8::Local<v8::Value> v8Value(ToV8(cppValue, holder, info.GetIsolate()));
    V8PrivateProperty::GetSymbol(
        info.GetIsolate(), "KeepAlive#TestObject#perWorldBindingsReadonlyTestInterfaceEmptyAttribute")
        .Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingAccessPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingAccessPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingAccessPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingAccessPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingGetterPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingGetterPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingGetterPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingGetterPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute());
  }
  
  static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
  }
  
  static void locationAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->location()), impl);
  }
  
  static void locationAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => location.href
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "location");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "location")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "href"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void locationWithExceptionAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->locationWithException()), impl);
  }
  
  static void locationWithExceptionAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationWithException.hrefThrows
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationWithException");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationWithException")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "hrefThrows"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void locationWithCallWithAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->locationWithCallWith()), impl);
  }
  
  static void locationWithCallWithAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationWithCallWith.hrefCallWith
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationWithCallWith");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationWithCallWith")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "hrefCallWith"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void locationByteStringAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->locationByteString()), impl);
  }
  
  static void locationByteStringAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationByteString.hrefByteString
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationByteString");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationByteString")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "hrefByteString"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void locationWithPerWorldBindingsAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->locationWithPerWorldBindings()), impl);
  }
  
  static void locationWithPerWorldBindingsAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationWithPerWorldBindings.href
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationWithPerWorldBindings");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationWithPerWorldBindings")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "href"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void locationWithPerWorldBindingsAttributeGetterForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueForMainWorld(info, WTF::GetPtr(impl->locationWithPerWorldBindings()));
  }
  
  static void locationWithPerWorldBindingsAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationWithPerWorldBindings.href
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationWithPerWorldBindings");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationWithPerWorldBindings")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "href"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void locationLegacyInterfaceTypeCheckingAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->locationLegacyInterfaceTypeChecking()), impl);
  }
  
  static void locationLegacyInterfaceTypeCheckingAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationLegacyInterfaceTypeChecking.href
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationLegacyInterfaceTypeChecking");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationLegacyInterfaceTypeChecking")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "href"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void locationGarbageCollectedAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    TestInterfaceGarbageCollected* cppValue(WTF::GetPtr(impl->locationGarbageCollected()));
  
    // Keep the wrapper object for the return value alive as long as |this|
    // object is alive in order to save creation time of the wrapper object.
    if (cppValue && DOMDataStore::SetReturnValue(info.GetReturnValue(), cppValue))
      return;
    v8::Local<v8::Value> v8Value(ToV8(cppValue, holder, info.GetIsolate()));
    V8PrivateProperty::GetSymbol(
        info.GetIsolate(), "KeepAlive#TestObject#locationGarbageCollected")
        .Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void locationGarbageCollectedAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationGarbageCollected.attr1
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationGarbageCollected");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationGarbageCollected")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "attr1"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void raisesExceptionLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kGetterContext, "TestObject", "raisesExceptionLongAttribute");
  
    int32_t cppValue(impl->raisesExceptionLongAttribute(exceptionState));
  
    if (UNLIKELY(exceptionState.HadException()))
      return;
  
    V8SetReturnValueInt(info, cppValue);
  }
  
  static void raisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "raisesExceptionLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setRaisesExceptionLongAttribute(cppValue, exceptionState);
  }
  
  static void raisesExceptionGetterLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kGetterContext, "TestObject", "raisesExceptionGetterLongAttribute");
  
    int32_t cppValue(impl->raisesExceptionGetterLongAttribute(exceptionState));
  
    if (UNLIKELY(exceptionState.HadException()))
      return;
  
    V8SetReturnValueInt(info, cppValue);
  }
  
  static void raisesExceptionGetterLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "raisesExceptionGetterLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setRaisesExceptionGetterLongAttribute(cppValue);
  }
  
  static void setterRaisesExceptionLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->setterRaisesExceptionLongAttribute());
  }
  
  static void setterRaisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "setterRaisesExceptionLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setSetterRaisesExceptionLongAttribute(cppValue, exceptionState);
  }
  
  static void raisesExceptionTestInterfaceEmptyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kGetterContext, "TestObject", "raisesExceptionTestInterfaceEmptyAttribute");
  
    TestInterfaceEmpty* cppValue(impl->raisesExceptionTestInterfaceEmptyAttribute(exceptionState));
  
    if (UNLIKELY(exceptionState.HadException()))
      return;
  
    V8SetReturnValueFast(info, cppValue, impl);
  }
  
  static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "raisesExceptionTestInterfaceEmptyAttribute");
  
    // Prepare the value to be set.
    TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterfaceEmpty'.");
      return;
    }
  
    impl->setRaisesExceptionTestInterfaceEmptyAttribute(cppValue, exceptionState);
  }
  
  static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // [CachedAttribute]
    V8PrivateProperty::Symbol propertySymbol =
        V8PrivateProperty::GetSymbol(info.GetIsolate(),
            "TestObject#Cachedattributeraisesexceptiongetteranyattribute");
    if (!static_cast<const TestObject*>(impl)->isValueDirty()) {
      v8::Local<v8::Value> v8Value = propertySymbol.GetOrUndefined(holder);
      if (!v8Value->IsUndefined()) {
        V8SetReturnValue(info, v8Value);
        return;
      }
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kGetterContext, "TestObject", "cachedAttributeRaisesExceptionGetterAnyAttribute");
  
    ScriptValue cppValue(impl->cachedAttributeRaisesExceptionGetterAnyAttribute(exceptionState));
  
    if (UNLIKELY(exceptionState.HadException()))
      return;
  
    // [CachedAttribute]
    v8::Local<v8::Value> v8Value(cppValue.V8Value());
    propertySymbol.Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "cachedAttributeRaisesExceptionGetterAnyAttribute");
  
    // Prepare the value to be set.
    ScriptValue cppValue = ScriptValue(ScriptState::Current(info.GetIsolate()), v8Value);
  
    impl->setCachedAttributeRaisesExceptionGetterAnyAttribute(cppValue, exceptionState);
  
    // [CachedAttribute]
    // Invalidate the cached value.
    V8PrivateProperty::GetSymbol(
        isolate, "TestObject#Cachedattributeraisesexceptiongetteranyattribute")
        .DeleteProperty(holder, v8::Undefined(isolate));
  }
  
  static void reflectTestInterfaceAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, impl->FastGetAttribute(HTMLNames::reflecttestinterfaceattributeAttr), impl);
  }
  
  static void reflectTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "reflectTestInterfaceAttribute");
  
    // Prepare the value to be set.
    TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterface'.");
      return;
    }
  
    impl->setAttribute(HTMLNames::reflecttestinterfaceattributeAttr, cppValue);
  }
  
  static void reflectReflectedNameAttributeTestAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, impl->FastGetAttribute(HTMLNames::reflectedNameAttributeAttr), impl);
  }
  
  static void reflectReflectedNameAttributeTestAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "reflectReflectedNameAttributeTestAttribute");
  
    // Prepare the value to be set.
    TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterface'.");
      return;
    }
  
    impl->setAttribute(HTMLNames::reflectedNameAttributeAttr, cppValue);
  }
  
  static void reflectBooleanAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueBool(info, impl->FastHasAttribute(HTMLNames::reflectbooleanattributeAttr));
  }
  
  static void reflectBooleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "reflectBooleanAttribute");
  
    // Prepare the value to be set.
    bool cppValue = NativeValueTraits<IDLBoolean>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->SetBooleanAttribute(HTMLNames::reflectbooleanattributeAttr, cppValue);
  }
  
  static void reflectLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->GetIntegralAttribute(HTMLNames::reflectlongattributeAttr));
  }
  
  static void reflectLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "reflectLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->SetIntegralAttribute(HTMLNames::reflectlongattributeAttr, cppValue);
  }
  
  static void reflectUnsignedShortAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueUnsigned(info, std::max(0, static_cast<int>(impl->FastGetAttribute(HTMLNames::reflectunsignedshortattributeAttr))));
  }
  
  static void reflectUnsignedShortAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "reflectUnsignedShortAttribute");
  
    // Prepare the value to be set.
    uint16_t cppValue = NativeValueTraits<IDLUnsignedShort>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setAttribute(HTMLNames::reflectunsignedshortattributeAttr, cppValue);
  }
  
  static void reflectUnsignedLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueUnsigned(info, std::max(0, static_cast<int>(impl->GetIntegralAttribute(HTMLNames::reflectunsignedlongattributeAttr))));
  }
  
  static void reflectUnsignedLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "reflectUnsignedLongAttribute");
  
    // Prepare the value to be set.
    uint32_t cppValue = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->SetUnsignedIntegralAttribute(HTMLNames::reflectunsignedlongattributeAttr, cppValue);
  }
  
  static void idAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetIdAttribute(), info.GetIsolate());
  }
  
  static void idAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::idAttr, cppValue);
  }
  
  static void nameAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetNameAttribute(), info.GetIsolate());
  }
  
  static void nameAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::nameAttr, cppValue);
  }
  
  static void classAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetClassAttribute(), info.GetIsolate());
  }
  
  static void classAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::classAttr, cppValue);
  }
  
  static void reflectedIdAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetIdAttribute(), info.GetIsolate());
  }
  
  static void reflectedIdAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::idAttr, cppValue);
  }
  
  static void reflectedNameAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetNameAttribute(), info.GetIsolate());
  }
  
  static void reflectedNameAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::nameAttr, cppValue);
  }
  
  static void reflectedClassAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetClassAttribute(), info.GetIsolate());
  }
  
  static void reflectedClassAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::classAttr, cppValue);
  }
  
  static void limitedToOnlyOneAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    String cppValue(impl->FastGetAttribute(HTMLNames::limitedtoonlyoneattributeAttr));
  
    if (cppValue.IsEmpty()) {
      ;
    } else if (EqualIgnoringASCIICase(cppValue, "unique")) {
      cppValue = "unique";
    } else {
      cppValue = "";
    }
  
    V8SetReturnValueString(info, cppValue, info.GetIsolate());
  }
  
  static void limitedToOnlyOneAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::limitedtoonlyoneattributeAttr, cppValue);
  }
  
  static void limitedToOnlyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    String cppValue(impl->FastGetAttribute(HTMLNames::limitedtoonlyattributeAttr));
  
    if (cppValue.IsEmpty()) {
      ;
    } else if (EqualIgnoringASCIICase(cppValue, "Per")) {
      cppValue = "Per";
    } else if (EqualIgnoringASCIICase(cppValue, "Paal")) {
      cppValue = "Paal";
    } else if (EqualIgnoringASCIICase(cppValue, "Espen")) {
      cppValue = "Espen";
    } else {
      cppValue = "";
    }
  
    V8SetReturnValueString(info, cppValue, info.GetIsolate());
  }
  
  static void limitedToOnlyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::limitedtoonlyattributeAttr, cppValue);
  }
  
  static void limitedToOnlyOtherAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    String cppValue(impl->FastGetAttribute(HTMLNames::otherAttr));
  
    if (cppValue.IsEmpty()) {
      ;
    } else if (EqualIgnoringASCIICase(cppValue, "Value1")) {
      cppValue = "Value1";
    } else if (EqualIgnoringASCIICase(cppValue, "Value2")) {
      cppValue = "Value2";
    } else {
      cppValue = "";
    }
  
    V8SetReturnValueString(info, cppValue, info.GetIsolate());
  }
  
  static void limitedToOnlyOtherAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::otherAttr, cppValue);
  }
  
  static void limitedWithMissingDefaultAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    String cppValue(impl->FastGetAttribute(HTMLNames::limitedwithmissingdefaultattributeAttr));
  
    if (cppValue.IsEmpty()) {
      cppValue = "rsa";
    } else if (EqualIgnoringASCIICase(cppValue, "rsa")) {
      cppValue = "rsa";
    } else if (EqualIgnoringASCIICase(cppValue, "dsa")) {
      cppValue = "dsa";
    } else {
      cppValue = "";
    }
  
    V8SetReturnValueString(info, cppValue, info.GetIsolate());
  }
  
  static void limitedWithMissingDefaultAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::limitedwithmissingdefaultattributeAttr, cppValue);
  }
  
  static void limitedWithInvalidMissingDefaultAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    String cppValue(impl->FastGetAttribute(HTMLNames::limitedwithinvalidmissingdefaultattributeAttr));
  
    if (cppValue.IsEmpty()) {
      cppValue = "auto";
    } else if (EqualIgnoringASCIICase(cppValue, "ltr")) {
      cppValue = "ltr";
    } else if (EqualIgnoringASCIICase(cppValue, "rtl")) {
      cppValue = "rtl";
    } else if (EqualIgnoringASCIICase(cppValue, "auto")) {
      cppValue = "auto";
    } else {
      cppValue = "ltr";
    }
  
    V8SetReturnValueString(info, cppValue, info.GetIsolate());
  }
  
  static void limitedWithInvalidMissingDefaultAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::limitedwithinvalidmissingdefaultattributeAttr, cppValue);
  }
  
  static void corsSettingAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    String cppValue(impl->FastGetAttribute(HTMLNames::corssettingattributeAttr));
  
    if (cppValue.IsNull()) {
      ;
    } else if (cppValue.IsEmpty()) {
      cppValue = "anonymous";
    } else if (EqualIgnoringASCIICase(cppValue, "anonymous")) {
      cppValue = "anonymous";
    } else if (EqualIgnoringASCIICase(cppValue, "use-credentials")) {
      cppValue = "use-credentials";
    } else {
      cppValue = "anonymous";
    }
  
    V8SetReturnValueString(info, cppValue, info.GetIsolate());
  }
  
  static void limitedWithEmptyMissingInvalidAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    String cppValue(impl->FastGetAttribute(HTMLNames::limitedwithemptymissinginvalidattributeAttr));
  
    if (cppValue.IsNull()) {
      cppValue = "missing";
    } else if (cppValue.IsEmpty()) {
      cppValue = "empty";
    } else if (EqualIgnoringASCIICase(cppValue, "empty")) {
      cppValue = "empty";
    } else if (EqualIgnoringASCIICase(cppValue, "missing")) {
      cppValue = "missing";
    } else if (EqualIgnoringASCIICase(cppValue, "invalid")) {
      cppValue = "invalid";
    } else if (EqualIgnoringASCIICase(cppValue, "a-normal")) {
      cppValue = "a-normal";
    } else {
      cppValue = "invalid";
    }
  
    V8SetReturnValueString(info, cppValue, info.GetIsolate());
  }
  
  static void RuntimeCallStatsCounterAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    RUNTIME_CALL_TIMER_SCOPE(info.GetIsolate(),
                             RuntimeCallStats::CounterId::kRuntimeCallStatsCounterAttribute_Getter);
  
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->runtimeCallStatsCounterAttribute());
  }
  
  static void RuntimeCallStatsCounterAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    RUNTIME_CALL_TIMER_SCOPE(info.GetIsolate(),
                             RuntimeCallStats::CounterId::kRuntimeCallStatsCounterAttribute_Setter);
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "RuntimeCallStatsCounterAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setRuntimeCallStatsCounterAttribute(cppValue);
  }
  
  static void RuntimeCallStatsCounterReadOnlyAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    RUNTIME_CALL_TIMER_SCOPE(info.GetIsolate(),
                             RuntimeCallStats::CounterId::kRuntimeCallStatsCounterReadOnlyAttribute_Getter);
  
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->runtimeCallStatsCounterReadOnlyAttribute());
  }
  
  static void replaceableReadonlyLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->replaceableReadonlyLongAttribute());
  }
  
  static void replaceableReadonlyLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // Prepare the value to be set.
  
    v8::Local<v8::String> propertyName = V8AtomicString(isolate, "replaceableReadonlyLongAttribute");
    V8CallBoolean(info.Holder()->CreateDataProperty(info.GetIsolate()->GetCurrentContext(), propertyName, v8Value));
  }
  
  static void locationPutForwardsAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->locationPutForwards()), impl);
  }
  
  static void locationPutForwardsAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    // [PutForwards] => locationPutForwards.href
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "locationPutForwards");
    v8::Local<v8::Value> target;
    if (!holder->Get(isolate->GetCurrentContext(), V8AtomicString(isolate, "locationPutForwards")).ToLocal(&target))
      return;
    if (!target->IsObject()) {
      exceptionState.ThrowTypeError("The attribute value is not an object");
      return;
    }
    bool result;
    if (!target.As<v8::Object>()->Set(isolate->GetCurrentContext(), V8AtomicString(isolate, "href"), v8Value).To(&result))
      return;
    if (!result)
      return;
  }
  
  static void runtimeEnabledLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->runtimeEnabledLongAttribute());
  }
  
  static void runtimeEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "runtimeEnabledLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setRuntimeEnabledLongAttribute(cppValue);
  }
  
  static void setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->setterCallWithCurrentWindowAndEnteredWindowStringAttribute(), info.GetIsolate());
  }
  
  static void setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setSetterCallWithCurrentWindowAndEnteredWindowStringAttribute(CurrentDOMWindow(info.GetIsolate()), EnteredDOMWindow(info.GetIsolate()), cppValue);
  }
  
  static void setterCallWithExecutionContextStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->setterCallWithExecutionContextStringAttribute(), info.GetIsolate());
  }
  
  static void setterCallWithExecutionContextStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    ExecutionContext* executionContext = CurrentExecutionContext(isolate);
  
    impl->setSetterCallWithExecutionContextStringAttribute(executionContext, cppValue);
  }
  
  static void treatNullAsEmptyStringStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->treatNullAsEmptyStringStringAttribute(), info.GetIsolate());
  }
  
  static void treatNullAsEmptyStringStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<kTreatNullAsEmptyString> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setTreatNullAsEmptyStringStringAttribute(cppValue);
  }
  
  static void treatNullAsNullStringStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->treatNullAsNullStringStringAttribute(), info.GetIsolate());
  }
  
  static void treatNullAsNullStringStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    V8StringResource<kTreatNullAsNullString> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setTreatNullAsNullStringStringAttribute(cppValue);
  }
  
  static void legacyInterfaceTypeCheckingFloatAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValue(info, impl->legacyInterfaceTypeCheckingFloatAttribute());
  }
  
  static void legacyInterfaceTypeCheckingFloatAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "legacyInterfaceTypeCheckingFloatAttribute");
  
    // Prepare the value to be set.
    float cppValue = NativeValueTraits<IDLFloat>::NativeValue(info.GetIsolate(), v8Value, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->setLegacyInterfaceTypeCheckingFloatAttribute(cppValue);
  }
  
  static void legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->legacyInterfaceTypeCheckingTestInterfaceAttribute()), impl);
  }
  
  static void legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    impl->setLegacyInterfaceTypeCheckingTestInterfaceAttribute(cppValue);
  }
  
  static void legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->legacyInterfaceTypeCheckingTestInterfaceOrNullAttribute()), impl);
  }
  
  static void legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Prepare the value to be set.
    TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    impl->setLegacyInterfaceTypeCheckingTestInterfaceOrNullAttribute(cppValue);
  }
  
  static void urlStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetURLAttribute(HTMLNames::urlstringattributeAttr), info.GetIsolate());
  }
  
  static void urlStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::urlstringattributeAttr, cppValue);
  }
  
  static void urlStringAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueString(info, impl->GetURLAttribute(HTMLNames::reflectUrlAttributeAttr), info.GetIsolate());
  }
  
  static void urlStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    // Skip on compact node DOMString getters.
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    // Prepare the value to be set.
    V8StringResource<> cppValue = v8Value;
    if (!cppValue.Prepare())
      return;
  
    impl->setAttribute(HTMLNames::reflectUrlAttributeAttr, cppValue);
  }
  
  static void unforgeableLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->unforgeableLongAttribute());
  }
  
  static void unforgeableLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unforgeableLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setUnforgeableLongAttribute(cppValue);
  }
  
  static void measuredLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->measuredLongAttribute());
  }
  
  static void measuredLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "measuredLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setMeasuredLongAttribute(cppValue);
  }
  
  static void sameObjectAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    TestInterfaceImplementation* cppValue(WTF::GetPtr(impl->sameObjectAttribute()));
  
    // Keep the wrapper object for the return value alive as long as |this|
    // object is alive in order to save creation time of the wrapper object.
    if (cppValue && DOMDataStore::SetReturnValue(info.GetReturnValue(), cppValue))
      return;
    v8::Local<v8::Value> v8Value(ToV8(cppValue, holder, info.GetIsolate()));
    V8PrivateProperty::GetSymbol(
        info.GetIsolate(), "KeepAlive#TestObject#sameObjectAttribute")
        .Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  }
  
  static void saveSameObjectAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    // [SaveSameObject]
    // If you see a compile error that
    //   V8PrivateProperty::GetSameObjectTestObjectSaveSameObjectAttribute
    // is not defined, then you need to register your attribute at
    // V8_PRIVATE_PROPERTY_FOR_EACH defined in V8PrivateProperty.h as
    //   X(SameObject, TestObjectSaveSameObjectAttribute)
    auto privateSameObject = V8PrivateProperty::GetSameObjectTestObjectSaveSameObjectAttribute(info.GetIsolate());
    {
      v8::Local<v8::Value> v8Value = privateSameObject.GetOrEmpty(holder);
      if (!v8Value.IsEmpty()) {
        V8SetReturnValue(info, v8Value);
        return;
      }
    }
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    TestInterfaceImplementation* cppValue(WTF::GetPtr(impl->saveSameObjectAttribute()));
  
    // Keep the wrapper object for the return value alive as long as |this|
    // object is alive in order to save creation time of the wrapper object.
    if (cppValue && DOMDataStore::SetReturnValue(info.GetReturnValue(), cppValue))
      return;
    v8::Local<v8::Value> v8Value(ToV8(cppValue, holder, info.GetIsolate()));
    V8PrivateProperty::GetSymbol(
        info.GetIsolate(), "KeepAlive#TestObject#saveSameObjectAttribute")
        .Set(holder, v8Value);
  
    V8SetReturnValue(info, v8Value);
  
    // [SaveSameObject]
    privateSameObject.Set(holder, info.GetReturnValue().Get());
  }
  
  static void staticSaveSameObjectAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    // [SaveSameObject]
    // If you see a compile error that
    //   V8PrivateProperty::GetSameObjectTestObjectStaticSaveSameObjectAttribute
    // is not defined, then you need to register your attribute at
    // V8_PRIVATE_PROPERTY_FOR_EACH defined in V8PrivateProperty.h as
    //   X(SameObject, TestObjectStaticSaveSameObjectAttribute)
    auto privateSameObject = V8PrivateProperty::GetSameObjectTestObjectStaticSaveSameObjectAttribute(info.GetIsolate());
    {
      v8::Local<v8::Value> v8Value = privateSameObject.GetOrEmpty(holder);
      if (!v8Value.IsEmpty()) {
        V8SetReturnValue(info, v8Value);
        return;
      }
    }
  
    V8SetReturnValue(info, WTF::GetPtr(TestObject::staticSaveSameObjectAttribute()), info.GetIsolate()->GetCurrentContext()->Global());
  
    // [SaveSameObject]
    privateSameObject.Set(holder, info.GetReturnValue().Get());
  }
  
  static void unscopableLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->unscopableLongAttribute());
  }
  
  static void unscopableLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unscopableLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setUnscopableLongAttribute(cppValue);
  }
  
  static void unscopableOriginTrialEnabledLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->unscopableOriginTrialEnabledLongAttribute());
  }
  
  static void unscopableOriginTrialEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unscopableOriginTrialEnabledLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setUnscopableOriginTrialEnabledLongAttribute(cppValue);
  }
  
  static void unscopableRuntimeEnabledLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueInt(info, impl->unscopableRuntimeEnabledLongAttribute());
  }
  
  static void unscopableRuntimeEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "unscopableRuntimeEnabledLongAttribute");
  
    // Prepare the value to be set.
    int32_t cppValue = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), v8Value, exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->setUnscopableRuntimeEnabledLongAttribute(cppValue);
  }
  
  static void testInterfaceAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->testInterfaceAttribute()), impl);
  }
  
  static void testInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testInterfaceAttribute");
  
    // Prepare the value to be set.
    TestInterfaceImplementation* cppValue = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterface'.");
      return;
    }
  
    impl->setTestInterfaceAttribute(cppValue);
  }
  
  static void testInterfaceGarbageCollectedAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->testInterfaceGarbageCollectedAttribute()), impl);
  }
  
  static void testInterfaceGarbageCollectedAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testInterfaceGarbageCollectedAttribute");
  
    // Prepare the value to be set.
    TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterfaceGarbageCollected'.");
      return;
    }
  
    impl->setTestInterfaceGarbageCollectedAttribute(cppValue);
  }
  
  static void testInterfaceGarbageCollectedOrNullAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueFast(info, WTF::GetPtr(impl->testInterfaceGarbageCollectedOrNullAttribute()), impl);
  }
  
  static void testInterfaceGarbageCollectedOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Isolate* isolate = info.GetIsolate();
    ALLOW_UNUSED_LOCAL(isolate);
  
    v8::Local<v8::Object> holder = info.Holder();
    ALLOW_UNUSED_LOCAL(holder);
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    ExceptionState exceptionState(isolate, ExceptionState::kSetterContext, "TestObject", "testInterfaceGarbageCollectedOrNullAttribute");
  
    // Prepare the value to be set.
    TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImplWithTypeCheck(info.GetIsolate(), v8Value);
  
    // Type check per: http://heycam.github.io/webidl/#es-interface
    if (!cppValue && !IsUndefinedOrNull(v8Value)) {
      exceptionState.ThrowTypeError("The provided value is not of type 'TestInterfaceGarbageCollected'.");
      return;
    }
  
    impl->setTestInterfaceGarbageCollectedOrNullAttribute(cppValue);
  }
  
  static void sizeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Object> holder = info.Holder();
  
    TestObject* impl = V8TestObject::toImpl(holder);
  
    V8SetReturnValueUnsigned(info, impl->size());
  }
  
  static void unscopableVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->unscopableVoidMethod();
  }
  
  static void unscopableRuntimeEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->unscopableRuntimeEnabledVoidMethod();
  }
  
  static void voidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->voidMethod();
  }
  
  static void staticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject::staticVoidMethod();
  }
  
  static void dateMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, V8DateOrNaN(info.GetIsolate(), impl->dateMethod()));
  }
  
  static void stringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueString(info, impl->stringMethod(), info.GetIsolate());
  }
  
  static void byteStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueString(info, impl->byteStringMethod(), info.GetIsolate());
  }
  
  static void usvStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueString(info, impl->usvStringMethod(), info.GetIsolate());
  }
  
  static void readonlyDOMTimeStampMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, static_cast<double>(impl->readonlyDOMTimeStampMethod()));
  }
  
  static void booleanMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueBool(info, impl->booleanMethod());
  }
  
  static void byteMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueInt(info, impl->byteMethod());
  }
  
  static void doubleMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->doubleMethod());
  }
  
  static void floatMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->floatMethod());
  }
  
  static void longMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueInt(info, impl->longMethod());
  }
  
  static void longLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, static_cast<double>(impl->longLongMethod()));
  }
  
  static void octetMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueUnsigned(info, impl->octetMethod());
  }
  
  static void shortMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueInt(info, impl->shortMethod());
  }
  
  static void unsignedLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueUnsigned(info, impl->unsignedLongMethod());
  }
  
  static void unsignedLongLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, static_cast<double>(impl->unsignedLongLongMethod()));
  }
  
  static void unsignedShortMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueUnsigned(info, impl->unsignedShortMethod());
  }
  
  static void voidMethodDateArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDateArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    double dateArg;
    dateArg = NativeValueTraits<IDLDate>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDateArg(dateArg);
  }
  
  static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodStringArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    V8StringResource<> stringArg;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    impl->voidMethodStringArg(stringArg);
  }
  
  static void voidMethodByteStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodByteStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    V8StringResource<> stringArg;
    stringArg = NativeValueTraits<IDLByteString>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodByteStringArg(stringArg);
  }
  
  static void voidMethodUSVStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodUSVStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    V8StringResource<> usvStringArg;
    usvStringArg = NativeValueTraits<IDLUSVString>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodUSVStringArg(usvStringArg);
  }
  
  static void voidMethodDOMTimeStampArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDOMTimeStampArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint64_t domTimeStampArg;
    domTimeStampArg = NativeValueTraits<IDLUnsignedLongLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDOMTimeStampArg(domTimeStampArg);
  }
  
  static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodBooleanArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    bool booleanArg;
    booleanArg = NativeValueTraits<IDLBoolean>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodBooleanArg(booleanArg);
  }
  
  static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodByteArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int8_t byteArg;
    byteArg = NativeValueTraits<IDLByte>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodByteArg(byteArg);
  }
  
  static void voidMethodDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDoubleArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    double doubleArg;
    doubleArg = NativeValueTraits<IDLDouble>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDoubleArg(doubleArg);
  }
  
  static void voidMethodFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodFloatArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    float floatArg;
    floatArg = NativeValueTraits<IDLFloat>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodFloatArg(floatArg);
  }
  
  static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodLongArg(longArg);
  }
  
  static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodLongLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int64_t longLongArg;
    longLongArg = NativeValueTraits<IDLLongLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodLongLongArg(longLongArg);
  }
  
  static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodOctetArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint8_t octetArg;
    octetArg = NativeValueTraits<IDLOctet>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodOctetArg(octetArg);
  }
  
  static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodShortArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int16_t shortArg;
    shortArg = NativeValueTraits<IDLShort>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodShortArg(shortArg);
  }
  
  static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodUnsignedLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint32_t unsignedLongArg;
    unsignedLongArg = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodUnsignedLongArg(unsignedLongArg);
  }
  
  static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodUnsignedLongLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint64_t unsignedLongLongArg;
    unsignedLongLongArg = NativeValueTraits<IDLUnsignedLongLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodUnsignedLongLongArg(unsignedLongLongArg);
  }
  
  static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodUnsignedShortArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint16_t unsignedShortArg;
    unsignedShortArg = NativeValueTraits<IDLUnsignedShort>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodUnsignedShortArg(unsignedShortArg);
  }
  
  static void testInterfaceEmptyMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->testInterfaceEmptyMethod());
  }
  
  static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestInterfaceEmptyArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestInterfaceEmpty* testInterfaceEmptyArg;
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceEmptyArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
  }
  
  static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodLongArgTestInterfaceEmptyArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 2)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(2, info.Length()));
      return;
    }
  
    int32_t longArg;
    TestInterfaceEmpty* testInterfaceEmptyArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[1]);
    if (!testInterfaceEmptyArg) {
      exceptionState.ThrowTypeError("parameter 2 is not of type 'TestInterfaceEmpty'.");
  
      return;
    }
  
    impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg);
  }
  
  static void anyMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->anyMethod().V8Value());
  }
  
  static void voidMethodEventTargetArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodEventTargetArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    EventTarget* eventTargetArg;
    eventTargetArg = V8EventTarget::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!eventTargetArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodEventTargetArg", "TestObject", "parameter 1 is not of type 'EventTarget'."));
  
      return;
    }
  
    impl->voidMethodEventTargetArg(eventTargetArg);
  }
  
  static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodAnyArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    ScriptValue anyArg;
    anyArg = ScriptValue(ScriptState::Current(info.GetIsolate()), info[0]);
  
    impl->voidMethodAnyArg(anyArg);
  }
  
  static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodAttrArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    Attr* attrArg;
    attrArg = V8Attr::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!attrArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodAttrArg", "TestObject", "parameter 1 is not of type 'Attr'."));
  
      return;
    }
  
    impl->voidMethodAttrArg(attrArg);
  }
  
  static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodDocumentArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    Document* documentArg;
    documentArg = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!documentArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodDocumentArg", "TestObject", "parameter 1 is not of type 'Document'."));
  
      return;
    }
  
    impl->voidMethodDocumentArg(documentArg);
  }
  
  static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodDocumentTypeArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    DocumentType* documentTypeArg;
    documentTypeArg = V8DocumentType::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!documentTypeArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodDocumentTypeArg", "TestObject", "parameter 1 is not of type 'DocumentType'."));
  
      return;
    }
  
    impl->voidMethodDocumentTypeArg(documentTypeArg);
  }
  
  static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodElementArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    Element* elementArg;
    elementArg = V8Element::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!elementArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodElementArg", "TestObject", "parameter 1 is not of type 'Element'."));
  
      return;
    }
  
    impl->voidMethodElementArg(elementArg);
  }
  
  static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodNodeArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    Node* nodeArg;
    nodeArg = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!nodeArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodNodeArg", "TestObject", "parameter 1 is not of type 'Node'."));
  
      return;
    }
  
    impl->voidMethodNodeArg(nodeArg);
  }
  
  static void arrayBufferMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->arrayBufferMethod());
  }
  
  static void arrayBufferViewMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->arrayBufferViewMethod());
  }
  
  static void arrayBufferViewMethodRaisesExceptionMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "arrayBufferViewMethodRaisesException");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    NotShared<TestArrayBufferView> result = impl->arrayBufferViewMethodRaisesException(exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result);
  }
  
  static void float32ArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->float32ArrayMethod());
  }
  
  static void int32ArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->int32ArrayMethod());
  }
  
  static void uint8ArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->uint8ArrayMethod());
  }
  
  static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodArrayBufferArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestArrayBuffer* arrayBufferArg;
    arrayBufferArg = info[0]->IsArrayBuffer() ? V8ArrayBuffer::toImpl(v8::Local<v8::ArrayBuffer>::Cast(info[0])) : 0;
    if (!arrayBufferArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodArrayBufferArg", "TestObject", "parameter 1 is not of type 'ArrayBuffer'."));
  
      return;
    }
  
    impl->voidMethodArrayBufferArg(arrayBufferArg);
  }
  
  static void voidMethodArrayBufferOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodArrayBufferOrNullArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestArrayBuffer* arrayBufferArg;
    arrayBufferArg = V8ArrayBuffer::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!arrayBufferArg && !IsUndefinedOrNull(info[0])) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodArrayBufferOrNullArg", "TestObject", "parameter 1 is not of type 'ArrayBuffer'."));
  
      return;
    }
  
    impl->voidMethodArrayBufferOrNullArg(arrayBufferArg);
  }
  
  static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodArrayBufferViewArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    NotShared<TestArrayBufferView> arrayBufferViewArg;
    arrayBufferViewArg = ToNotShared<NotShared<TestArrayBufferView>>(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
    if (!arrayBufferViewArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'ArrayBufferView'.");
  
      return;
    }
  
    impl->voidMethodArrayBufferViewArg(arrayBufferViewArg);
  }
  
  static void voidMethodFlexibleArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodFlexibleArrayBufferViewArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    FlexibleArrayBufferView arrayBufferViewArg;
    ToFlexibleArrayBufferView(info.GetIsolate(), info[0], arrayBufferViewArg, allocateFlexibleArrayBufferViewStorage(info[0]));
    if (!arrayBufferViewArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'ArrayBufferView'.");
  
      return;
    }
  
    impl->voidMethodFlexibleArrayBufferViewArg(arrayBufferViewArg);
  }
  
  static void voidMethodFlexibleArrayBufferViewTypedArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodFlexibleArrayBufferViewTypedArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    FlexibleFloat32ArrayView typedArrayBufferViewArg;
    ToFlexibleArrayBufferView(info.GetIsolate(), info[0], typedArrayBufferViewArg, allocateFlexibleArrayBufferViewStorage(info[0]));
    if (!typedArrayBufferViewArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'Float32Array'.");
  
      return;
    }
  
    impl->voidMethodFlexibleArrayBufferViewTypedArg(typedArrayBufferViewArg);
  }
  
  static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodFloat32ArrayArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    NotShared<DOMFloat32Array> float32ArrayArg;
    float32ArrayArg = ToNotShared<NotShared<DOMFloat32Array>>(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
    if (!float32ArrayArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'Float32Array'.");
  
      return;
    }
  
    impl->voidMethodFloat32ArrayArg(float32ArrayArg);
  }
  
  static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodInt32ArrayArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    NotShared<DOMInt32Array> int32ArrayArg;
    int32ArrayArg = ToNotShared<NotShared<DOMInt32Array>>(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
    if (!int32ArrayArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'Int32Array'.");
  
      return;
    }
  
    impl->voidMethodInt32ArrayArg(int32ArrayArg);
  }
  
  static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodUint8ArrayArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    NotShared<DOMUint8Array> uint8ArrayArg;
    uint8ArrayArg = ToNotShared<NotShared<DOMUint8Array>>(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
    if (!uint8ArrayArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'Uint8Array'.");
  
      return;
    }
  
    impl->voidMethodUint8ArrayArg(uint8ArrayArg);
  }
  
  static void voidMethodAllowSharedArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodAllowSharedArrayBufferViewArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    MaybeShared<TestArrayBufferView> arrayBufferViewArg;
    arrayBufferViewArg = ToMaybeShared<MaybeShared<TestArrayBufferView>>(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
    if (!arrayBufferViewArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'ArrayBufferView'.");
  
      return;
    }
  
    impl->voidMethodAllowSharedArrayBufferViewArg(arrayBufferViewArg);
  }
  
  static void voidMethodAllowSharedUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodAllowSharedUint8ArrayArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    MaybeShared<DOMUint8Array> uint8ArrayArg;
    uint8ArrayArg = ToMaybeShared<MaybeShared<DOMUint8Array>>(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
    if (!uint8ArrayArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'Uint8Array'.");
  
      return;
    }
  
    impl->voidMethodAllowSharedUint8ArrayArg(uint8ArrayArg);
  }
  
  static void longArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, ToV8(impl->longArrayMethod(), info.Holder(), info.GetIsolate()));
  }
  
  static void stringArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, ToV8(impl->stringArrayMethod(), info.Holder(), info.GetIsolate()));
  }
  
  static void testInterfaceEmptyArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, ToV8(impl->testInterfaceEmptyArrayMethod(), info.Holder(), info.GetIsolate()));
  }
  
  static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodArrayLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Vector<int32_t> arrayLongArg;
    arrayLongArg = NativeValueTraits<IDLSequence<IDLLong>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodArrayLongArg(arrayLongArg);
  }
  
  static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodArrayStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Vector<String> arrayStringArg;
    arrayStringArg = NativeValueTraits<IDLSequence<IDLString>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodArrayStringArg(arrayStringArg);
  }
  
  static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodArrayTestInterfaceEmptyArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    HeapVector<Member<TestInterfaceEmpty>> arrayTestInterfaceEmptyArg;
    arrayTestInterfaceEmptyArg = NativeValueTraits<IDLSequence<TestInterfaceEmpty>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg);
  }
  
  static void voidMethodNullableArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodNullableArrayLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Nullable<Vector<int32_t>> arrayLongArg;
    if (!IsUndefinedOrNull(info[0])) {
      arrayLongArg = NativeValueTraits<IDLSequence<IDLLong>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    }
  
    impl->voidMethodNullableArrayLongArg(arrayLongArg);
  }
  
  static void longSequenceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, ToV8(impl->longSequenceMethod(), info.Holder(), info.GetIsolate()));
  }
  
  static void stringSequenceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, ToV8(impl->stringSequenceMethod(), info.Holder(), info.GetIsolate()));
  }
  
  static void testInterfaceEmptySequenceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, ToV8(impl->testInterfaceEmptySequenceMethod(), info.Holder(), info.GetIsolate()));
  }
  
  static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodSequenceLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Vector<int32_t> longSequenceArg;
    longSequenceArg = NativeValueTraits<IDLSequence<IDLLong>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodSequenceLongArg(longSequenceArg);
  }
  
  static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodSequenceStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Vector<String> stringSequenceArg;
    stringSequenceArg = NativeValueTraits<IDLSequence<IDLString>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodSequenceStringArg(stringSequenceArg);
  }
  
  static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodSequenceTestInterfaceEmptyArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    HeapVector<Member<TestInterfaceEmpty>> testInterfaceEmptySequenceArg;
    testInterfaceEmptySequenceArg = NativeValueTraits<IDLSequence<TestInterfaceEmpty>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodSequenceTestInterfaceEmptyArg(testInterfaceEmptySequenceArg);
  }
  
  static void voidMethodSequenceSequenceDOMStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodSequenceSequenceDOMStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Vector<Vector<String>> stringSequenceSequenceArg;
    stringSequenceSequenceArg = NativeValueTraits<IDLSequence<IDLSequence<IDLString>>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodSequenceSequenceDOMStringArg(stringSequenceSequenceArg);
  }
  
  static void voidMethodNullableSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodNullableSequenceLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Nullable<Vector<int32_t>> longSequenceArg;
    if (!IsUndefinedOrNull(info[0])) {
      longSequenceArg = NativeValueTraits<IDLSequence<IDLLong>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    }
  
    impl->voidMethodNullableSequenceLongArg(longSequenceArg);
  }
  
  static void longFrozenArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, FreezeV8Object(ToV8(impl->longFrozenArrayMethod(), info.Holder(), info.GetIsolate()), info.GetIsolate()));
  }
  
  static void voidMethodStringFrozenArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodStringFrozenArrayMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Vector<String> stringFrozenArrayArg;
    stringFrozenArrayArg = NativeValueTraits<IDLSequence<IDLString>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodStringFrozenArrayMethod(stringFrozenArrayArg);
  }
  
  static void voidMethodTestInterfaceEmptyFrozenArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodTestInterfaceEmptyFrozenArrayMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    HeapVector<Member<TestInterfaceEmpty>> testInterfaceEmptyFrozenArrayArg;
    testInterfaceEmptyFrozenArrayArg = NativeValueTraits<IDLSequence<TestInterfaceEmpty>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodTestInterfaceEmptyFrozenArrayMethod(testInterfaceEmptyFrozenArrayArg);
  }
  
  static void nullableLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Nullable<int32_t> result = impl->nullableLongMethod();
    if (result.IsNull())
      V8SetReturnValueNull(info);
    else
      V8SetReturnValueInt(info, result.Get());
  }
  
  static void nullableStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueStringOrNull(info, impl->nullableStringMethod(), info.GetIsolate());
  }
  
  static void nullableTestInterfaceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->nullableTestInterfaceMethod());
  }
  
  static void nullableLongSequenceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Nullable<Vector<int32_t>> result = impl->nullableLongSequenceMethod();
    if (result.IsNull())
      V8SetReturnValueNull(info);
    else
      V8SetReturnValue(info, ToV8(result.Get(), info.Holder(), info.GetIsolate()));
  }
  
  static void testInterfaceGarbageCollectedOrDOMStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceGarbageCollectedOrString result;
    impl->testInterfaceGarbageCollectedOrDOMStringMethod(result);
    V8SetReturnValue(info, result);
  }
  
  static void booleanOrDOMStringOrUnrestrictedDoubleMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    BooleanOrStringOrUnrestrictedDouble result;
    impl->booleanOrDOMStringOrUnrestrictedDoubleMethod(result);
    V8SetReturnValue(info, result);
  }
  
  static void testInterfaceOrLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceOrLong result;
    impl->testInterfaceOrLongMethod(result);
    V8SetReturnValue(info, result);
  }
  
  static void staticTestInterfaceGarbageCollectedOrDOMStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestInterfaceGarbageCollectedOrString result;
    TestObject::staticTestInterfaceGarbageCollectedOrDOMStringMethod(result);
    V8SetReturnValue(info, result, info.GetIsolate()->GetCurrentContext()->Global());
  }
  
  static void voidMethodDoubleOrDOMStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDoubleOrDOMStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    DoubleOrString arg;
    V8DoubleOrString::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDoubleOrDOMStringArg(arg);
  }
  
  static void voidMethodDoubleOrDOMStringOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDoubleOrDOMStringOrNullArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    DoubleOrString arg;
    V8DoubleOrString::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDoubleOrDOMStringOrNullArg(arg);
  }
  
  static void voidMethodDoubleOrNullOrDOMStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDoubleOrNullOrDOMStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    DoubleOrString arg;
    V8DoubleOrNullOrString::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDoubleOrNullOrDOMStringArg(arg);
  }
  
  static void voidMethodDOMStringOrArrayBufferOrArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDOMStringOrArrayBufferOrArrayBufferViewArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    StringOrArrayBufferOrArrayBufferView arg;
    V8StringOrArrayBufferOrArrayBufferView::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDOMStringOrArrayBufferOrArrayBufferViewArg(arg);
  }
  
  static void voidMethodArrayBufferOrArrayBufferViewOrDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodArrayBufferOrArrayBufferViewOrDictionaryArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    ArrayBufferOrArrayBufferViewOrDictionary arg;
    V8ArrayBufferOrArrayBufferViewOrDictionary::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodArrayBufferOrArrayBufferViewOrDictionaryArg(arg);
  }
  
  static void voidMethodBooleanOrElementSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodBooleanOrElementSequenceArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    BooleanOrElementSequence arg;
    V8BooleanOrElementSequence::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodBooleanOrElementSequenceArg(arg);
  }
  
  static void voidMethodDoubleOrLongOrBooleanSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDoubleOrLongOrBooleanSequenceArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    DoubleOrLongOrBooleanSequence arg;
    V8DoubleOrLongOrBooleanSequence::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDoubleOrLongOrBooleanSequenceArg(arg);
  }
  
  static void voidMethodElementSequenceOrByteStringDoubleOrStringRecordMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodElementSequenceOrByteStringDoubleOrStringRecord");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    ElementSequenceOrByteStringDoubleOrStringRecord arg;
    V8ElementSequenceOrByteStringDoubleOrStringRecord::toImpl(info.GetIsolate(), info[0], arg, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodElementSequenceOrByteStringDoubleOrStringRecord(arg);
  }
  
  static void voidMethodArrayOfDoubleOrDOMStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodArrayOfDoubleOrDOMStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    HeapVector<DoubleOrString> arg;
    arg = ToImplArguments<HeapVector<DoubleOrString>>(info, 0, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodArrayOfDoubleOrDOMStringArg(arg);
  }
  
  static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestInterfaceEmptyOrNullArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestInterfaceEmpty* nullableTestInterfaceEmptyArg;
    nullableTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!nullableTestInterfaceEmptyArg && !IsUndefinedOrNull(info[0])) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestInterfaceEmptyOrNullArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg);
  }
  
  static void voidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestCallbackInterfaceArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestCallbackInterface* testCallbackInterfaceArg;
    if (info.Length() <= 0 || !info[0]->IsFunction()) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."));
  
      return;
    }
    testCallbackInterfaceArg = V8TestCallbackInterface::Create(v8::Local<v8::Function>::Cast(info[0]), ScriptState::Current(info.GetIsolate()));
  
    impl->voidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg);
  }
  
  static void voidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestCallbackInterface* optionalTestCallbackInterfaceArg;
    if (!IsUndefinedOrNull(info[0])) {
      if (!info[0]->IsFunction()) {
        V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodOptionalTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."));
  
        return;
      }
      optionalTestCallbackInterfaceArg = V8TestCallbackInterface::Create(v8::Local<v8::Function>::Cast(info[0]), ScriptState::Current(info.GetIsolate()));
    } else {
      optionalTestCallbackInterfaceArg = nullptr;
    }
  
    impl->voidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg);
  }
  
  static void voidMethodTestCallbackInterfaceOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestCallbackInterfaceOrNullArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestCallbackInterface* testCallbackInterfaceArg;
    if (info.Length() <= 0 || !(info[0]->IsFunction() || info[0]->IsNull())) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTestCallbackInterfaceOrNullArg", "TestObject", "The callback provided as parameter 1 is not a function."));
  
      return;
    }
    testCallbackInterfaceArg = info[0]->IsNull() ? nullptr : V8TestCallbackInterface::Create(v8::Local<v8::Function>::Cast(info[0]), ScriptState::Current(info.GetIsolate()));
  
    impl->voidMethodTestCallbackInterfaceOrNullArg(testCallbackInterfaceArg);
  }
  
  static void testEnumMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueString(info, impl->testEnumMethod(), info.GetIsolate());
  }
  
  static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodTestEnumArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    V8StringResource<> testEnumTypeArg;
    testEnumTypeArg = info[0];
    if (!testEnumTypeArg.Prepare())
      return;
    const char* validTestEnumTypeArgValues[] = {
        "",
        "EnumValue1",
        "EnumValue2",
        "EnumValue3",
    };
    if (!IsValidEnum(testEnumTypeArg, validTestEnumTypeArgValues, WTF_ARRAY_LENGTH(validTestEnumTypeArgValues), "TestEnum", exceptionState)) {
      return;
    }
  
    impl->voidMethodTestEnumArg(testEnumTypeArg);
  }
  
  static void voidMethodTestMultipleEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodTestMultipleEnumArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 2)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(2, info.Length()));
      return;
    }
  
    V8StringResource<> testEnumTypeArg;
    V8StringResource<> testEnumTypeArg2;
    testEnumTypeArg = info[0];
    if (!testEnumTypeArg.Prepare())
      return;
    const char* validTestEnumTypeArgValues[] = {
        "",
        "EnumValue1",
        "EnumValue2",
        "EnumValue3",
    };
    if (!IsValidEnum(testEnumTypeArg, validTestEnumTypeArgValues, WTF_ARRAY_LENGTH(validTestEnumTypeArgValues), "TestEnum", exceptionState)) {
      return;
    }
  
    testEnumTypeArg2 = info[1];
    if (!testEnumTypeArg2.Prepare())
      return;
    const char* validTestEnumTypeArg2Values[] = {
        "",
        "EnumValue1",
        "EnumValue2",
        "EnumValue3",
    };
    if (!IsValidEnum(testEnumTypeArg2, validTestEnumTypeArg2Values, WTF_ARRAY_LENGTH(validTestEnumTypeArg2Values), "TestEnum2", exceptionState)) {
      return;
    }
  
    impl->voidMethodTestMultipleEnumArg(testEnumTypeArg, testEnumTypeArg2);
  }
  
  static void dictionaryMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->dictionaryMethod());
  }
  
  static void testDictionaryMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestDictionary result;
    impl->testDictionaryMethod(result);
    V8SetReturnValue(info, result);
  }
  
  static void nullableTestDictionaryMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Nullable<TestDictionary> result;
    impl->nullableTestDictionaryMethod(result);
    if (result.IsNull())
      V8SetReturnValueNull(info);
    else
      V8SetReturnValue(info, result.Get());
  }
  
  static void staticTestDictionaryMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestDictionary result;
    TestObject::staticTestDictionaryMethod(result);
    V8SetReturnValue(info, result, info.GetIsolate()->GetCurrentContext()->Global());
  }
  
  static void staticNullableTestDictionaryMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    Nullable<TestDictionary> result;
    TestObject::staticNullableTestDictionaryMethod(result);
    if (result.IsNull())
      V8SetReturnValueNull(info);
    else
      V8SetReturnValue(info, result.Get(), info.GetIsolate()->GetCurrentContext()->Global());
  }
  
  static void passPermissiveDictionaryMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "passPermissiveDictionaryMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestDictionary arg;
    V8TestDictionary::toImpl(info.GetIsolate(), info[0], arg, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->passPermissiveDictionaryMethod(arg);
  }
  
  static void nodeFilterMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, ToV8(impl->nodeFilterMethod(), info.Holder(), info.GetIsolate()));
  }
  
  static void promiseMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "promiseMethod");
    ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
  
    // V8DOMConfiguration::kDoNotCheckHolder
    // Make sure that info.Holder() really points to an instance of the type.
    if (!V8TestObject::hasInstance(info.Holder(), info.GetIsolate())) {
      exceptionState.ThrowTypeError("Illegal invocation");
      return;
    }
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 3)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(3, info.Length()));
      return;
    }
  
    int32_t arg1;
    Dictionary arg2;
    V8StringResource<> arg3;
    Vector<String> variadic;
    arg1 = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    if (!IsUndefinedOrNull(info[1]) && !info[1]->IsObject()) {
      exceptionState.ThrowTypeError("parameter 2 ('arg2') is not an object.");
  
      return;
    }
    arg2 = NativeValueTraits<Dictionary>::NativeValue(info.GetIsolate(), info[1], exceptionState);
    if (exceptionState.HadException())
      return;
  
    arg3 = info[2];
    if (!arg3.Prepare(exceptionState))
      return;
  
    variadic = ToImplArguments<Vector<String>>(info, 3, exceptionState);
    if (exceptionState.HadException())
      return;
  
    V8SetReturnValue(info, impl->promiseMethod(arg1, arg2, arg3, variadic).V8Value());
  }
  
  static void promiseMethodWithoutExceptionStateMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "promiseMethodWithoutExceptionState");
    ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
  
    // V8DOMConfiguration::kDoNotCheckHolder
    // Make sure that info.Holder() really points to an instance of the type.
    if (!V8TestObject::hasInstance(info.Holder(), info.GetIsolate())) {
      exceptionState.ThrowTypeError("Illegal invocation");
      return;
    }
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Dictionary arg1;
    if (!IsUndefinedOrNull(info[0]) && !info[0]->IsObject()) {
      exceptionState.ThrowTypeError("parameter 1 ('arg1') is not an object.");
  
      return;
    }
    arg1 = NativeValueTraits<Dictionary>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    V8SetReturnValue(info, impl->promiseMethodWithoutExceptionState(arg1).V8Value());
  }
  
  static void serializedScriptValueMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, V8Deserialize(info.GetIsolate(), impl->serializedScriptValueMethod()));
  }
  
  static void xPathNSResolverMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->xPathNSResolverMethod());
  }
  
  static void voidMethodDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDictionaryArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Dictionary dictionaryArg;
    if (!IsUndefinedOrNull(info[0]) && !info[0]->IsObject()) {
      exceptionState.ThrowTypeError("parameter 1 ('dictionaryArg') is not an object.");
  
      return;
    }
    dictionaryArg = NativeValueTraits<Dictionary>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDictionaryArg(dictionaryArg);
  }
  
  static void voidMethodNodeFilterArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodNodeFilterArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    V8NodeFilterCondition* nodeFilterArg;
    nodeFilterArg = V8NodeFilterCondition::CreateOrNull(info[0], ScriptState::Current(info.GetIsolate()));
  
    impl->voidMethodNodeFilterArg(nodeFilterArg);
  }
  
  static void voidMethodPromiseArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodPromiseArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    ScriptPromise promiseArg;
    promiseArg = ScriptPromise::Cast(ScriptState::Current(info.GetIsolate()), info[0]);
    if (!promiseArg.IsUndefinedOrNull() && !promiseArg.IsObject()) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodPromiseArg", "TestObject", "parameter 1 ('promiseArg') is not an object."));
  
      return;
    }
  
    impl->voidMethodPromiseArg(promiseArg);
  }
  
  static void voidMethodSerializedScriptValueArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodSerializedScriptValueArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    RefPtr<SerializedScriptValue> serializedScriptValueArg;
    serializedScriptValueArg = NativeValueTraits<SerializedScriptValue>::NativeValue(info.GetIsolate(), info[0], SerializedScriptValue::SerializeOptions(SerializedScriptValue::kNotForStorage), exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodSerializedScriptValueArg(serializedScriptValueArg);
  }
  
  static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodXPathNSResolverArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    XPathNSResolver* xPathNSResolverArg;
    xPathNSResolverArg = ToXPathNSResolver(ScriptState::Current(info.GetIsolate()), info[0]);
    if (!xPathNSResolverArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodXPathNSResolverArg", "TestObject", "parameter 1 is not of type 'XPathNSResolver'."));
  
      return;
    }
  
    impl->voidMethodXPathNSResolverArg(xPathNSResolverArg);
  }
  
  static void voidMethodDictionarySequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDictionarySequenceArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Vector<Dictionary> dictionarySequenceArg;
    dictionarySequenceArg = NativeValueTraits<IDLSequence<Dictionary>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDictionarySequenceArg(dictionarySequenceArg);
  }
  
  static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodStringArgLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 2)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(2, info.Length()));
      return;
    }
  
    V8StringResource<> stringArg;
    int32_t longArg;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodStringArgLongArg(stringArg, longArg);
  }
  
  static void voidMethodOptionalStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> optionalStringArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      impl->voidMethodOptionalStringArg();
      return;
    }
    optionalStringArg = info[0];
    if (!optionalStringArg.Prepare())
      return;
  
    impl->voidMethodOptionalStringArg(optionalStringArg);
  }
  
  static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceEmpty* optionalTestInterfaceEmptyArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      impl->voidMethodOptionalTestInterfaceEmptyArg();
      return;
    }
    optionalTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!optionalTestInterfaceEmptyArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodOptionalTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg);
  }
  
  static void voidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t optionalLongArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      impl->voidMethodOptionalLongArg();
      return;
    }
    optionalLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodOptionalLongArg(optionalLongArg);
  }
  
  static void stringMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "stringMethodOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t optionalLongArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      V8SetReturnValueString(info, impl->stringMethodOptionalLongArg(), info.GetIsolate());
      return;
    }
    optionalLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    V8SetReturnValueString(info, impl->stringMethodOptionalLongArg(optionalLongArg), info.GetIsolate());
  }
  
  static void testInterfaceEmptyMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "testInterfaceEmptyMethodOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t optionalLongArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      V8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg());
      return;
    }
    optionalLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    V8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg(optionalLongArg));
  }
  
  static void longMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "longMethodOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t optionalLongArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      V8SetReturnValueInt(info, impl->longMethodOptionalLongArg());
      return;
    }
    optionalLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    V8SetReturnValueInt(info, impl->longMethodOptionalLongArg(optionalLongArg));
  }
  
  static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodLongArgOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t longArg;
    int32_t optionalLongArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    if (UNLIKELY(numArgsPassed <= 1)) {
      impl->voidMethodLongArgOptionalLongArg(longArg);
      return;
    }
    optionalLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg);
  }
  
  static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodLongArgOptionalLongArgOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t longArg;
    int32_t optionalLongArg1;
    int32_t optionalLongArg2;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    if (UNLIKELY(numArgsPassed <= 1)) {
      impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg);
      return;
    }
    optionalLongArg1 = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    if (UNLIKELY(numArgsPassed <= 2)) {
      impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongArg1);
      return;
    }
    optionalLongArg2 = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[2], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongArg1, optionalLongArg2);
  }
  
  static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodLongArgOptionalTestInterfaceEmptyArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t longArg;
    TestInterfaceEmpty* optionalTestInterfaceEmpty;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    if (UNLIKELY(numArgsPassed <= 1)) {
      impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg);
      return;
    }
    optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[1]);
    if (!optionalTestInterfaceEmpty) {
      exceptionState.ThrowTypeError("parameter 2 is not of type 'TestInterfaceEmpty'.");
  
      return;
    }
  
    impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInterfaceEmpty);
  }
  
  static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodTestInterfaceEmptyArgOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    TestInterfaceEmpty* optionalTestInterfaceEmpty;
    int32_t longArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    optionalTestInterfaceEmpty = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!optionalTestInterfaceEmpty) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'TestInterfaceEmpty'.");
  
      return;
    }
  
    if (UNLIKELY(numArgsPassed <= 1)) {
      impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty);
      return;
    }
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty, longArg);
  }
  
  static void voidMethodOptionalDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodOptionalDictionaryArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Dictionary optionalDictionaryArg;
    if (!IsUndefinedOrNull(info[0]) && !info[0]->IsObject()) {
      exceptionState.ThrowTypeError("parameter 1 ('optionalDictionaryArg') is not an object.");
  
      return;
    }
    optionalDictionaryArg = NativeValueTraits<Dictionary>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodOptionalDictionaryArg(optionalDictionaryArg);
  }
  
  static void voidMethodDefaultByteStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultByteStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> defaultByteStringArg;
    if (!info[0]->IsUndefined()) {
      defaultByteStringArg = NativeValueTraits<IDLByteString>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      defaultByteStringArg = "foo";
    }
  
    impl->voidMethodDefaultByteStringArg(defaultByteStringArg);
  }
  
  static void voidMethodDefaultStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> defaultStringArg;
    if (!info[0]->IsUndefined()) {
      defaultStringArg = info[0];
      if (!defaultStringArg.Prepare())
        return;
    } else {
      defaultStringArg = "foo";
    }
  
    impl->voidMethodDefaultStringArg(defaultStringArg);
  }
  
  static void voidMethodDefaultIntegerArgsMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultIntegerArgs");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t defaultLongArg;
    int64_t defaultLongLongArg;
    uint32_t defaultUnsignedArg;
    if (!info[0]->IsUndefined()) {
      defaultLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
      if (exceptionState.HadException())
        return;
    } else {
      defaultLongArg = 10;
    }
    if (!info[1]->IsUndefined()) {
      defaultLongLongArg = NativeValueTraits<IDLLongLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
      if (exceptionState.HadException())
        return;
    } else {
      defaultLongLongArg = -10;
    }
    if (!info[2]->IsUndefined()) {
      defaultUnsignedArg = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), info[2], exceptionState, kNormalConversion);
      if (exceptionState.HadException())
        return;
    } else {
      defaultUnsignedArg = 4294967295u;
    }
  
    impl->voidMethodDefaultIntegerArgs(defaultLongArg, defaultLongLongArg, defaultUnsignedArg);
  }
  
  static void voidMethodDefaultDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultDoubleArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    double defaultDoubleArg;
    if (!info[0]->IsUndefined()) {
      defaultDoubleArg = NativeValueTraits<IDLDouble>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      defaultDoubleArg = 0.5;
    }
  
    impl->voidMethodDefaultDoubleArg(defaultDoubleArg);
  }
  
  static void voidMethodDefaultTrueBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultTrueBooleanArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    bool defaultBooleanArg;
    if (!info[0]->IsUndefined()) {
      defaultBooleanArg = NativeValueTraits<IDLBoolean>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      defaultBooleanArg = true;
    }
  
    impl->voidMethodDefaultTrueBooleanArg(defaultBooleanArg);
  }
  
  static void voidMethodDefaultFalseBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultFalseBooleanArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    bool defaultBooleanArg;
    if (!info[0]->IsUndefined()) {
      defaultBooleanArg = NativeValueTraits<IDLBoolean>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      defaultBooleanArg = false;
    }
  
    impl->voidMethodDefaultFalseBooleanArg(defaultBooleanArg);
  }
  
  static void voidMethodDefaultNullableByteStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultNullableByteStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<kTreatNullAndUndefinedAsNullString> defaultStringArg;
    if (!info[0]->IsUndefined()) {
      defaultStringArg = NativeValueTraits<IDLByteString>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      defaultStringArg = nullptr;
    }
  
    impl->voidMethodDefaultNullableByteStringArg(defaultStringArg);
  }
  
  static void voidMethodDefaultNullableStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<kTreatNullAndUndefinedAsNullString> defaultStringArg;
    if (!info[0]->IsUndefined()) {
      defaultStringArg = info[0];
      if (!defaultStringArg.Prepare())
        return;
    } else {
      defaultStringArg = nullptr;
    }
  
    impl->voidMethodDefaultNullableStringArg(defaultStringArg);
  }
  
  static void voidMethodDefaultNullableTestInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceImplementation* defaultTestInterfaceArg;
    if (!info[0]->IsUndefined()) {
      defaultTestInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
      if (!defaultTestInterfaceArg && !IsUndefinedOrNull(info[0])) {
        V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodDefaultNullableTestInterfaceArg", "TestObject", "parameter 1 is not of type 'TestInterface'."));
  
        return;
      }
    } else {
      defaultTestInterfaceArg = nullptr;
    }
  
    impl->voidMethodDefaultNullableTestInterfaceArg(defaultTestInterfaceArg);
  }
  
  static void voidMethodDefaultDoubleOrStringArgsMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultDoubleOrStringArgs");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    DoubleOrString defaultLongArg;
    DoubleOrString defaultStringArg;
    DoubleOrString defaultNullArg;
    if (!info[0]->IsUndefined()) {
      V8DoubleOrString::toImpl(info.GetIsolate(), info[0], defaultLongArg, UnionTypeConversionMode::kNotNullable, exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      defaultLongArg.setDouble(10);
    }
    if (!info[1]->IsUndefined()) {
      V8DoubleOrStringOrNull::toImpl(info.GetIsolate(), info[1], defaultStringArg, UnionTypeConversionMode::kNullable, exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      defaultStringArg.setString("foo");
    }
    if (!info[2]->IsUndefined()) {
      V8DoubleOrString::toImpl(info.GetIsolate(), info[2], defaultNullArg, UnionTypeConversionMode::kNullable, exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      /* null default value */;
    }
  
    impl->voidMethodDefaultDoubleOrStringArgs(defaultLongArg, defaultStringArg, defaultNullArg);
  }
  
  static void voidMethodDefaultStringSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultStringSequenceArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Vector<String> defaultStringSequenceArg;
    if (!info[0]->IsUndefined()) {
      defaultStringSequenceArg = NativeValueTraits<IDLSequence<IDLString>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      /* Nothing to do */;
    }
  
    impl->voidMethodDefaultStringSequenceArg(defaultStringSequenceArg);
  }
  
  static void voidMethodVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodVariadicStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Vector<String> variadicStringArgs;
    variadicStringArgs = ToImplArguments<Vector<String>>(info, 0, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodVariadicStringArg(variadicStringArgs);
  }
  
  static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodStringArgVariadicStringArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    V8StringResource<> stringArg;
    Vector<String> variadicStringArgs;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    variadicStringArgs = ToImplArguments<Vector<String>>(info, 1, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs);
  }
  
  static void voidMethodVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodVariadicTestInterfaceEmptyArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    HeapVector<Member<TestInterfaceEmpty>> variadicTestInterfaceEmptyArgs;
    for (int i = 0; i < info.Length(); ++i) {
      if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
        exceptionState.ThrowTypeError("parameter 1 is not of type 'TestInterfaceEmpty'.");
  
        return;
      }
      variadicTestInterfaceEmptyArgs.push_back(V8TestInterfaceEmpty::toImpl(v8::Local<v8::Object>::Cast(info[i])));
    }
  
    impl->voidMethodVariadicTestInterfaceEmptyArg(variadicTestInterfaceEmptyArgs);
  }
  
  static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    TestInterfaceEmpty* testInterfaceEmptyArg;
    HeapVector<Member<TestInterfaceEmpty>> variadicTestInterfaceEmptyArgs;
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceEmptyArg) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'TestInterfaceEmpty'.");
  
      return;
    }
  
    for (int i = 1; i < info.Length(); ++i) {
      if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
        exceptionState.ThrowTypeError("parameter 2 is not of type 'TestInterfaceEmpty'.");
  
        return;
      }
      variadicTestInterfaceEmptyArgs.push_back(V8TestInterfaceEmpty::toImpl(v8::Local<v8::Object>::Cast(info[i])));
    }
  
    impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInterfaceEmptyArg, variadicTestInterfaceEmptyArgs);
  }
  
  static void voidMethodVariadicTestInterfaceGarbageCollectedArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodVariadicTestInterfaceGarbageCollectedArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    HeapVector<Member<TestInterfaceGarbageCollected>> variadicTestInterfaceGarbageCollectedArg;
    for (int i = 0; i < info.Length(); ++i) {
      if (!V8TestInterfaceGarbageCollected::hasInstance(info[i], info.GetIsolate())) {
        exceptionState.ThrowTypeError("parameter 1 is not of type 'TestInterfaceGarbageCollected'.");
  
        return;
      }
      variadicTestInterfaceGarbageCollectedArg.push_back(V8TestInterfaceGarbageCollected::toImpl(v8::Local<v8::Object>::Cast(info[i])));
    }
  
    impl->voidMethodVariadicTestInterfaceGarbageCollectedArg(variadicTestInterfaceGarbageCollectedArg);
  }
  
  static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodA");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodA(longArg);
  }
  
  static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodA");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg1;
    int32_t longArg2;
    longArg1 = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    longArg2 = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodA(longArg1, longArg2);
  }
  
  static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(2, info.Length())) {
      case 1:
        if (true) {
          overloadedMethodA1Method(info);
          return;
        }
        break;
      case 2:
        if (true) {
          overloadedMethodA2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodA");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodB");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodB(longArg);
  }
  
  static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodB");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    int32_t longArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    if (UNLIKELY(numArgsPassed <= 1)) {
      impl->overloadedMethodB(stringArg);
      return;
    }
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodB(stringArg, longArg);
  }
  
  static void overloadedMethodBMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(2, info.Length())) {
      case 1:
        if (info[0]->IsNumber()) {
          overloadedMethodB1Method(info);
          return;
        }
        if (true) {
          overloadedMethodB2Method(info);
          return;
        }
        if (true) {
          overloadedMethodB1Method(info);
          return;
        }
        break;
      case 2:
        if (true) {
          overloadedMethodB2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodB");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodC");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodC(longArg);
  }
  
  static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceEmpty* testInterfaceEmptyArg;
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceEmptyArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodC", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->overloadedMethodC(testInterfaceEmptyArg);
  }
  
  static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
          overloadedMethodC2Method(info);
          return;
        }
        if (true) {
          overloadedMethodC1Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodC");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodD");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodD(longArg);
  }
  
  static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodD");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Vector<int32_t> longArrayArg;
    longArrayArg = NativeValueTraits<IDLSequence<IDLLong>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodD(longArrayArg);
  }
  
  static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (info[0]->IsArray()) {
          overloadedMethodD2Method(info);
          return;
        }
        if (true) {
          overloadedMethodD1Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodD");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodE");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodE(longArg);
  }
  
  static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
    testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceEmptyOrNullArg && !IsUndefinedOrNull(info[0])) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodE", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->overloadedMethodE(testInterfaceEmptyOrNullArg);
  }
  
  static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (IsUndefinedOrNull(info[0])) {
          overloadedMethodE2Method(info);
          return;
        }
        if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
          overloadedMethodE2Method(info);
          return;
        }
        if (true) {
          overloadedMethodE1Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodE");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      impl->overloadedMethodF();
      return;
    }
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    impl->overloadedMethodF(stringArg);
  }
  
  static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodF");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    double doubleArg;
    doubleArg = NativeValueTraits<IDLDouble>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodF(doubleArg);
  }
  
  static void overloadedMethodFMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          overloadedMethodF1Method(info);
          return;
        }
        break;
      case 1:
        if (info[0]->IsUndefined()) {
          overloadedMethodF1Method(info);
          return;
        }
        if (info[0]->IsNumber()) {
          overloadedMethodF2Method(info);
          return;
        }
        if (true) {
          overloadedMethodF1Method(info);
          return;
        }
        if (true) {
          overloadedMethodF2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodF");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodG1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodG");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodG(longArg);
  }
  
  static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceEmpty* testInterfaceEmptyOrNullArg;
    if (!info[0]->IsUndefined()) {
      testInterfaceEmptyOrNullArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
      if (!testInterfaceEmptyOrNullArg && !IsUndefinedOrNull(info[0])) {
        V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodG", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
        return;
      }
    } else {
      testInterfaceEmptyOrNullArg = nullptr;
    }
  
    impl->overloadedMethodG(testInterfaceEmptyOrNullArg);
  }
  
  static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          overloadedMethodG2Method(info);
          return;
        }
        break;
      case 1:
        if (info[0]->IsUndefined()) {
          overloadedMethodG2Method(info);
          return;
        }
        if (IsUndefinedOrNull(info[0])) {
          overloadedMethodG2Method(info);
          return;
        }
        if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
          overloadedMethodG2Method(info);
          return;
        }
        if (true) {
          overloadedMethodG1Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodG");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceImplementation* testInterfaceArg;
    testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodH", "TestObject", "parameter 1 is not of type 'TestInterface'."));
  
      return;
    }
  
    impl->overloadedMethodH(testInterfaceArg);
  }
  
  static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceEmpty* testInterfaceEmptyArg;
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceEmptyArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodH", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->overloadedMethodH(testInterfaceEmptyArg);
  }
  
  static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) {
          overloadedMethodH1Method(info);
          return;
        }
        if (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
          overloadedMethodH2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodH");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodI1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    impl->overloadedMethodI(stringArg);
  }
  
  static void overloadedMethodI2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodI");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    double doubleArg;
    doubleArg = NativeValueTraits<IDLDouble>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodI(doubleArg);
  }
  
  static void overloadedMethodIMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (info[0]->IsNumber()) {
          overloadedMethodI2Method(info);
          return;
        }
        if (true) {
          overloadedMethodI1Method(info);
          return;
        }
        if (true) {
          overloadedMethodI2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodI");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodJ1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    impl->overloadedMethodJ(stringArg);
  }
  
  static void overloadedMethodJ2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodJ");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestDictionary testDictionaryArg;
    if (!IsUndefinedOrNull(info[0]) && !info[0]->IsObject()) {
      exceptionState.ThrowTypeError("parameter 1 ('testDictionaryArg') is not an object.");
  
      return;
    }
    V8TestDictionary::toImpl(info.GetIsolate(), info[0], testDictionaryArg, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodJ(testDictionaryArg);
  }
  
  static void overloadedMethodJMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (info[0]->IsObject()) {
          overloadedMethodJ2Method(info);
          return;
        }
        if (true) {
          overloadedMethodJ1Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodJ");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodK1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptValue functionArg;
    if (!(info[0]->IsObject() && v8::Local<v8::Object>::Cast(info[0])->IsCallable())) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodK", "TestObject", "The callback provided as parameter 1 is not a function."));
  
      return;
    }
    functionArg = ScriptValue(ScriptState::Current(info.GetIsolate()), info[0]);
  
    impl->overloadedMethodK(functionArg);
  }
  
  static void overloadedMethodK2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    impl->overloadedMethodK(stringArg);
  }
  
  static void overloadedMethodKMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (info[0]->IsFunction()) {
          overloadedMethodK1Method(info);
          return;
        }
        if (true) {
          overloadedMethodK2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodK");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodL1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodL");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    Vector<ScriptValue> restArgs;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    restArgs = ToImplArguments<Vector<ScriptValue>>(info, 1, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodL(longArg, restArgs);
  }
  
  static void overloadedMethodL2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodL");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    Vector<ScriptValue> restArgs;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    restArgs = ToImplArguments<Vector<ScriptValue>>(info, 1, exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedMethodL(stringArg, restArgs);
  }
  
  static void overloadedMethodLMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(2, info.Length())) {
      case 1:
        if (info[0]->IsNumber()) {
          overloadedMethodL1Method(info);
          return;
        }
        if (true) {
          overloadedMethodL2Method(info);
          return;
        }
        if (true) {
          overloadedMethodL1Method(info);
          return;
        }
        break;
      case 2:
        if (info[0]->IsNumber()) {
          overloadedMethodL1Method(info);
          return;
        }
        if (true) {
          overloadedMethodL2Method(info);
          return;
        }
        if (true) {
          overloadedMethodL1Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodL");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedMethodN1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceImplementation* testInterfaceArg;
    testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodN", "TestObject", "parameter 1 is not of type 'TestInterface'."));
  
      return;
    }
  
    impl->overloadedMethodN(testInterfaceArg);
  }
  
  static void overloadedMethodN2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestCallbackInterface* testCallbackInterfaceArg;
    if (info.Length() <= 0 || !info[0]->IsFunction()) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("overloadedMethodN", "TestObject", "The callback provided as parameter 1 is not a function."));
  
      return;
    }
    testCallbackInterfaceArg = V8TestCallbackInterface::Create(v8::Local<v8::Function>::Cast(info[0]), ScriptState::Current(info.GetIsolate()));
  
    impl->overloadedMethodN(testCallbackInterfaceArg);
  }
  
  static void overloadedMethodNMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) {
          overloadedMethodN1Method(info);
          return;
        }
        if (info[0]->IsObject()) {
          overloadedMethodN2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedMethodN");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void promiseOverloadMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "promiseOverloadMethod");
    ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
  
    // V8DOMConfiguration::kDoNotCheckHolder
    // Make sure that info.Holder() really points to an instance of the type.
    if (!V8TestObject::hasInstance(info.Holder(), info.GetIsolate())) {
      exceptionState.ThrowTypeError("Illegal invocation");
      return;
    }
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValue(info, impl->promiseOverloadMethod().V8Value());
  }
  
  static void promiseOverloadMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "promiseOverloadMethod");
    ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
  
    // V8DOMConfiguration::kDoNotCheckHolder
    // Make sure that info.Holder() really points to an instance of the type.
    if (!V8TestObject::hasInstance(info.Holder(), info.GetIsolate())) {
      exceptionState.ThrowTypeError("Illegal invocation");
      return;
    }
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    DOMWindow* arg1;
    double arg2;
    arg1 = ToDOMWindow(info.GetIsolate(), info[0]);
    if (!arg1) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'Window'.");
  
      return;
    }
  
    arg2 = NativeValueTraits<IDLDouble>::NativeValue(info.GetIsolate(), info[1], exceptionState);
    if (exceptionState.HadException())
      return;
  
    V8SetReturnValue(info, impl->promiseOverloadMethod(arg1, arg2).V8Value());
  }
  
  static void promiseOverloadMethod3Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "promiseOverloadMethod");
    ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
  
    // V8DOMConfiguration::kDoNotCheckHolder
    // Make sure that info.Holder() really points to an instance of the type.
    if (!V8TestObject::hasInstance(info.Holder(), info.GetIsolate())) {
      exceptionState.ThrowTypeError("Illegal invocation");
      return;
    }
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Document* arg1;
    double arg2;
    arg1 = V8Document::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!arg1) {
      exceptionState.ThrowTypeError("parameter 1 is not of type 'Document'.");
  
      return;
    }
  
    arg2 = NativeValueTraits<IDLDouble>::NativeValue(info.GetIsolate(), info[1], exceptionState);
    if (exceptionState.HadException())
      return;
  
    V8SetReturnValue(info, impl->promiseOverloadMethod(arg1, arg2).V8Value());
  }
  
  static void promiseOverloadMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(2, info.Length())) {
      case 0:
        if (true) {
          promiseOverloadMethod1Method(info);
          return;
        }
        break;
      case 2:
        if (V8Window::hasInstance(info[0], info.GetIsolate())) {
          promiseOverloadMethod2Method(info);
          return;
        }
        if (V8Document::hasInstance(info[0], info.GetIsolate())) {
          promiseOverloadMethod3Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "promiseOverloadMethod");
    ExceptionToRejectPromiseScope rejectPromiseScope(info, exceptionState);
  
    if (isArityError) {
      if (info.Length() >= 0) {
        exceptionState.ThrowTypeError(ExceptionMessages::InvalidArity("[0, 2]", info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedPerWorldBindingsMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->overloadedPerWorldBindingsMethod();
  }
  
  static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->overloadedPerWorldBindingsMethod();
  }
  
  static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedPerWorldBindingsMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedPerWorldBindingsMethod(longArg);
  }
  
  static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          overloadedPerWorldBindingsMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          overloadedPerWorldBindingsMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedPerWorldBindingsMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedPerWorldBindingsMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->overloadedPerWorldBindingsMethod(longArg);
  }
  
  static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          overloadedPerWorldBindingsMethod1MethodForMainWorld(info);
          return;
        }
        break;
      case 1:
        if (true) {
          overloadedPerWorldBindingsMethod2MethodForMainWorld(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedPerWorldBindingsMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedStaticMethod");
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    TestObject::overloadedStaticMethod(longArg);
  }
  
  static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedStaticMethod");
  
    int32_t longArg1;
    int32_t longArg2;
    longArg1 = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    longArg2 = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[1], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    TestObject::overloadedStaticMethod(longArg1, longArg2);
  }
  
  static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(2, info.Length())) {
      case 1:
        if (true) {
          overloadedStaticMethod1Method(info);
          return;
        }
        break;
      case 2:
        if (true) {
          overloadedStaticMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "overloadedStaticMethod");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void itemMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "item");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint32_t index;
    index = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    ScriptValue result = impl->item(scriptState, index);
    V8SetReturnValue(info, result.V8Value());
  }
  
  static void setItemMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "setItem");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    if (UNLIKELY(info.Length() < 2)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(2, info.Length()));
      return;
    }
  
    uint32_t index;
    V8StringResource<> value;
    index = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    value = info[1];
    if (!value.Prepare())
      return;
  
    String result = impl->setItem(scriptState, index, value);
    V8SetReturnValueString(info, result, info.GetIsolate());
  }
  
  static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodClampUnsignedShortArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint16_t clampUnsignedShortArg;
    clampUnsignedShortArg = NativeValueTraits<IDLUnsignedShort>::NativeValue(info.GetIsolate(), info[0], exceptionState, kClamp);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodClampUnsignedShortArg(clampUnsignedShortArg);
  }
  
  static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodClampUnsignedLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    uint32_t clampUnsignedLongArg;
    clampUnsignedLongArg = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kClamp);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodClampUnsignedLongArg(clampUnsignedLongArg);
  }
  
  static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceEmpty* defaultUndefinedTestInterfaceEmptyArg;
    defaultUndefinedTestInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!defaultUndefinedTestInterfaceEmptyArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodDefaultUndefinedTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestInterfaceEmptyArg);
  }
  
  static void voidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodDefaultUndefinedLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t defaultUndefinedLongArg;
    defaultUndefinedLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodDefaultUndefinedLongArg(defaultUndefinedLongArg);
  }
  
  static void voidMethodDefaultUndefinedStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> defaultUndefinedStringArg;
    defaultUndefinedStringArg = info[0];
    if (!defaultUndefinedStringArg.Prepare())
      return;
  
    impl->voidMethodDefaultUndefinedStringArg(defaultUndefinedStringArg);
  }
  
  static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodEnforceRangeLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t enforceRangeLongArg;
    enforceRangeLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kEnforceRange);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodEnforceRangeLongArg(enforceRangeLongArg);
  }
  
  static void voidMethodTreatNullAsEmptyStringStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTreatNullAsEmptyStringStringArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    V8StringResource<kTreatNullAsEmptyString> treatNullAsEmptyStringStringArg;
    treatNullAsEmptyStringStringArg = info[0];
    if (!treatNullAsEmptyStringStringArg.Prepare())
      return;
  
    impl->voidMethodTreatNullAsEmptyStringStringArg(treatNullAsEmptyStringStringArg);
  }
  
  static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("voidMethodTreatNullAsNullStringStringArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    V8StringResource<kTreatNullAsNullString> treatNullAsNullStringStringArg;
    treatNullAsNullStringStringArg = info[0];
    if (!treatNullAsNullStringStringArg.Prepare())
      return;
  
    impl->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringArg);
  }
  
  static void activityLoggingAccessForAllWorldsMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->activityLoggingAccessForAllWorldsMethod();
  }
  
  static void callWithExecutionContextVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ExecutionContext* executionContext = CurrentExecutionContext(info.GetIsolate());
    impl->callWithExecutionContextVoidMethod(executionContext);
  }
  
  static void callWithScriptStateVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    impl->callWithScriptStateVoidMethod(scriptState);
  }
  
  static void callWithScriptStateLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    int32_t result = impl->callWithScriptStateLongMethod(scriptState);
    V8SetReturnValueInt(info, result);
  }
  
  static void callWithScriptStateExecutionContextVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    ExecutionContext* executionContext = CurrentExecutionContext(info.GetIsolate());
    impl->callWithScriptStateExecutionContextVoidMethod(scriptState, executionContext);
  }
  
  static void callWithScriptStateScriptArgumentsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    ScriptArguments* scriptArguments(ScriptArguments::Create(scriptState, info, 0));
    impl->callWithScriptStateScriptArgumentsVoidMethod(scriptState, scriptArguments);
  }
  
  static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    bool optionalBooleanArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      ScriptArguments* scriptArguments(ScriptArguments::Create(scriptState, info, 1));
      impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(scriptState, scriptArguments);
      return;
    }
    optionalBooleanArg = NativeValueTraits<IDLBoolean>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    ScriptArguments* scriptArguments(ScriptArguments::Create(scriptState, info, 1));
    impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(scriptState, scriptArguments, optionalBooleanArg);
  }
  
  static void callWithCurrentWindowMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->callWithCurrentWindow(CurrentDOMWindow(info.GetIsolate()));
  }
  
  static void callWithCurrentWindowScriptWindowMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->callWithCurrentWindowScriptWindow(CurrentDOMWindow(info.GetIsolate()), EnteredDOMWindow(info.GetIsolate()));
  }
  
  static void callWithThisValueMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    impl->callWithThisValue(ScriptValue(scriptState, info.Holder()));
  }
  
  static void checkSecurityForNodeVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "checkSecurityForNodeVoidMethod");
    if (!BindingSecurity::ShouldAllowAccessTo(CurrentDOMWindow(info.GetIsolate()), impl->checkSecurityForNodeVoidMethod(), exceptionState)) {
      V8SetReturnValueNull(info);
      return;
    }
  
    impl->checkSecurityForNodeVoidMethod();
  }
  
  static void customCallPrologueVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8TestObject::customCallPrologueVoidMethodMethodPrologueCustom(info, impl);
    impl->customCallPrologueVoidMethod();
  }
  
  static void customCallEpilogueVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->customCallEpilogueVoidMethod();
    V8TestObject::customCallEpilogueVoidMethodMethodEpilogueCustom(info, impl);
  }
  
  static void deprecatedVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->deprecatedVoidMethod();
  }
  
  static void implementedAsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->implementedAsMethodName();
  }
  
  static void measureAsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->measureAsVoidMethod();
  }
  
  static void measureMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->measureMethod();
  }
  
  static void measureOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->measureOverloadedMethod();
  }
  
  static void measureOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "measureOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->measureOverloadedMethod(arg);
  }
  
  static void measureOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kV8TestObject_MeasureOverloadedMethod_Method);
          measureOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kV8TestObject_MeasureOverloadedMethod_Method);
          measureOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "measureOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void DeprecateAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->DeprecateAsOverloadedMethod();
  }
  
  static void DeprecateAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "DeprecateAsOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->DeprecateAsOverloadedMethod(arg);
  }
  
  static void DeprecateAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureA);
          DeprecateAsOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureB);
          DeprecateAsOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "DeprecateAsOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void DeprecateAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->DeprecateAsSameValueOverloadedMethod();
  }
  
  static void DeprecateAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "DeprecateAsSameValueOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->DeprecateAsSameValueOverloadedMethod(arg);
  }
  
  static void DeprecateAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
  
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          DeprecateAsSameValueOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          DeprecateAsSameValueOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "DeprecateAsSameValueOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void measureAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->measureAsOverloadedMethod();
  }
  
  static void measureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "measureAsOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->measureAsOverloadedMethod(arg);
  }
  
  static void measureAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureA);
          measureAsOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureB);
          measureAsOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "measureAsOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void measureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->measureAsSameValueOverloadedMethod();
  }
  
  static void measureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "measureAsSameValueOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->measureAsSameValueOverloadedMethod(arg);
  }
  
  static void measureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
          measureAsSameValueOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
          measureAsSameValueOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "measureAsSameValueOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void deprecateAsMeasureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->deprecateAsMeasureAsSameValueOverloadedMethod();
  }
  
  static void deprecateAsMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "deprecateAsMeasureAsSameValueOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->deprecateAsMeasureAsSameValueOverloadedMethod(arg);
  }
  
  static void deprecateAsMeasureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
          Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureA);
          deprecateAsMeasureAsSameValueOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
          Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureB);
          deprecateAsMeasureAsSameValueOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "deprecateAsMeasureAsSameValueOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void deprecateAsSameValueMeasureAsOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->deprecateAsSameValueMeasureAsOverloadedMethod();
  }
  
  static void deprecateAsSameValueMeasureAsOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "deprecateAsSameValueMeasureAsOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->deprecateAsSameValueMeasureAsOverloadedMethod(arg);
  }
  
  static void deprecateAsSameValueMeasureAsOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
  
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureA);
          deprecateAsSameValueMeasureAsOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureB);
          deprecateAsSameValueMeasureAsOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "deprecateAsSameValueMeasureAsOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->deprecateAsSameValueMeasureAsSameValueOverloadedMethod();
  }
  
  static void deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "deprecateAsSameValueMeasureAsSameValueOverloadedMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t arg;
    arg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->deprecateAsSameValueMeasureAsSameValueOverloadedMethod(arg);
  }
  
  static void deprecateAsSameValueMeasureAsSameValueOverloadedMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureA);
  
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 0:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureB);
          deprecateAsSameValueMeasureAsSameValueOverloadedMethod1Method(info);
          return;
        }
        break;
      case 1:
        if (true) {
          UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeatureB);
          deprecateAsSameValueMeasureAsSameValueOverloadedMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "deprecateAsSameValueMeasureAsSameValueOverloadedMethod");
  
    if (isArityError) {
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void notEnumerableVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->notEnumerableVoidMethod();
  }
  
  static void originTrialEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->originTrialEnabledVoidMethod();
  }
  
  static void perWorldBindingsOriginTrialEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->perWorldBindingsOriginTrialEnabledVoidMethod();
  }
  
  static void perWorldBindingsOriginTrialEnabledVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->perWorldBindingsOriginTrialEnabledVoidMethod();
  }
  
  static void perWorldBindingsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->perWorldBindingsVoidMethod();
  }
  
  static void perWorldBindingsVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->perWorldBindingsVoidMethod();
  }
  
  static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("perWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestInterfaceEmpty* testInterfaceEmptyArg;
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceEmptyArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("perWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
  }
  
  static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("perWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestInterfaceEmpty* testInterfaceEmptyArg;
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceEmptyArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("perWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObject", "parameter 1 is not of type 'TestInterfaceEmpty'."));
  
      return;
    }
  
    impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
  }
  
  static void postMessageImpl(const char* interfaceName, TestObject* instance, const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, interfaceName, "postMessage");
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    Transferables transferables;
    if (info.Length() > 1) {
      const int transferablesArgIndex = 1;
      if (!SerializedScriptValue::ExtractTransferables(info.GetIsolate(), info[transferablesArgIndex], transferablesArgIndex, transferables, exceptionState)) {
        return;
      }
    }
  
    RefPtr<SerializedScriptValue> message;
    if (instance->CanTransferArrayBuffersAndImageBitmaps()) {
      // This instance supports sending array buffers by move semantics.
      SerializedScriptValue::SerializeOptions options;
      options.transferables = &transferables;
      message = SerializedScriptValue::Serialize(info.GetIsolate(), info[0], options, exceptionState);
      if (exceptionState.HadException())
        return;
    } else {
      // This instance doesn't support sending array buffers and image bitmaps
      // by move semantics. Emulate it by copy-and-neuter semantics that sends
      // array buffers and image bitmaps via structured clone and then neuters
      // the original objects
  
      // Clear references to array buffers and image bitmaps from transferables
      // so that the serializer can consider the array buffers as
      // non-transferable and serialize them into the message.
      ArrayBufferArray transferableArrayBuffers = SerializedScriptValue::ExtractNonSharedArrayBuffers(transferables);
      ImageBitmapArray transferableImageBitmaps = transferables.image_bitmaps;
      transferables.image_bitmaps.clear();
      SerializedScriptValue::SerializeOptions options;
      options.transferables = &transferables;
      message = SerializedScriptValue::Serialize(info.GetIsolate(), info[0], options, exceptionState);
      if (exceptionState.HadException())
        return;
  
      // Neuter the original array buffers on the sender context.
      SerializedScriptValue::TransferArrayBufferContents(info.GetIsolate(), transferableArrayBuffers, exceptionState);
      if (exceptionState.HadException())
        return;
      // Neuter the original image bitmaps on the sender context.
      SerializedScriptValue::TransferImageBitmapContents(info.GetIsolate(), transferableImageBitmaps, exceptionState);
      if (exceptionState.HadException())
        return;
    }
  
    // FIXME: Only pass scriptState/exceptionState if instance really requires it.
    ScriptState* scriptState = ScriptState::Current(info.GetIsolate());
    message->UnregisterMemoryAllocatedWithCurrentScriptContext();
    instance->postMessage(scriptState, message.Get(), transferables.message_ports, exceptionState);
  }
  
  static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod();
  }
  
  static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod();
  }
  
  static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod();
  }
  
  static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod();
  }
  
  static void raisesExceptionVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "raisesExceptionVoidMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->raisesExceptionVoidMethod(exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
  }
  
  static void raisesExceptionStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "raisesExceptionStringMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    String result = impl->raisesExceptionStringMethod(exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValueString(info, result, info.GetIsolate());
  }
  
  static void raisesExceptionVoidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "raisesExceptionVoidMethodOptionalLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t optionalLongArg;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    if (UNLIKELY(numArgsPassed <= 0)) {
      impl->raisesExceptionVoidMethodOptionalLongArg(exceptionState);
      if (exceptionState.HadException()) {
        return;
      }
      return;
    }
    optionalLongArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->raisesExceptionVoidMethodOptionalLongArg(optionalLongArg, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
  }
  
  static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "raisesExceptionVoidMethodTestCallbackInterfaceArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    TestCallbackInterface* testCallbackInterfaceArg;
    if (info.Length() <= 0 || !info[0]->IsFunction()) {
      exceptionState.ThrowTypeError("The callback provided as parameter 1 is not a function.");
  
      return;
    }
    testCallbackInterfaceArg = V8TestCallbackInterface::Create(v8::Local<v8::Function>::Cast(info[0]), ScriptState::Current(info.GetIsolate()));
  
    impl->raisesExceptionVoidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
  }
  
  static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestCallbackInterface* optionalTestCallbackInterfaceArg;
    if (!IsUndefinedOrNull(info[0])) {
      if (!info[0]->IsFunction()) {
        exceptionState.ThrowTypeError("The callback provided as parameter 1 is not a function.");
  
        return;
      }
      optionalTestCallbackInterfaceArg = V8TestCallbackInterface::Create(v8::Local<v8::Function>::Cast(info[0]), ScriptState::Current(info.GetIsolate()));
    } else {
      optionalTestCallbackInterfaceArg = nullptr;
    }
  
    impl->raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
  }
  
  static void raisesExceptionTestInterfaceEmptyVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "raisesExceptionTestInterfaceEmptyVoidMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceEmpty* result = impl->raisesExceptionTestInterfaceEmptyVoidMethod(exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result);
  }
  
  static void raisesExceptionXPathNSResolverVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "raisesExceptionXPathNSResolverVoidMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    XPathNSResolver* result = impl->raisesExceptionXPathNSResolverVoidMethod(exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result);
  }
  
  static void callWithExecutionContextRaisesExceptionVoidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "callWithExecutionContextRaisesExceptionVoidMethodLongArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    ExecutionContext* executionContext = CurrentExecutionContext(info.GetIsolate());
    impl->callWithExecutionContextRaisesExceptionVoidMethodLongArg(executionContext, longArg, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
  }
  
  static void runtimeEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->runtimeEnabledVoidMethod();
  }
  
  static void perWorldBindingsRuntimeEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->perWorldBindingsRuntimeEnabledVoidMethod();
  }
  
  static void perWorldBindingsRuntimeEnabledVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->perWorldBindingsRuntimeEnabledVoidMethod();
  }
  
  static void runtimeEnabledOverloadedVoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    impl->runtimeEnabledOverloadedVoidMethod(stringArg);
  }
  
  static void runtimeEnabledOverloadedVoidMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "runtimeEnabledOverloadedVoidMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    impl->runtimeEnabledOverloadedVoidMethod(longArg);
  }
  
  static void runtimeEnabledOverloadedVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(1, info.Length())) {
      case 1:
        if (info[0]->IsNumber()) {
          runtimeEnabledOverloadedVoidMethod2Method(info);
          return;
        }
        if (true) {
          runtimeEnabledOverloadedVoidMethod1Method(info);
          return;
        }
        if (true) {
          runtimeEnabledOverloadedVoidMethod2Method(info);
          return;
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "runtimeEnabledOverloadedVoidMethod");
  
    if (isArityError) {
      if (info.Length() < 1) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void partiallyRuntimeEnabledOverloadedVoidMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8StringResource<> stringArg;
    stringArg = info[0];
    if (!stringArg.Prepare())
      return;
  
    impl->partiallyRuntimeEnabledOverloadedVoidMethod(stringArg);
  }
  
  static void partiallyRuntimeEnabledOverloadedVoidMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceImplementation* testInterfaceArg;
    testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!testInterfaceArg) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("partiallyRuntimeEnabledOverloadedVoidMethod", "TestObject", "parameter 1 is not of type 'TestInterface'."));
  
      return;
    }
  
    impl->partiallyRuntimeEnabledOverloadedVoidMethod(testInterfaceArg);
  }
  
  static void partiallyRuntimeEnabledOverloadedVoidMethod3Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "partiallyRuntimeEnabledOverloadedVoidMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    V8StringResource<> stringArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    stringArg = info[1];
    if (!stringArg.Prepare())
      return;
  
    impl->partiallyRuntimeEnabledOverloadedVoidMethod(longArg, stringArg);
  }
  
  static void partiallyRuntimeEnabledOverloadedVoidMethod4Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "partiallyRuntimeEnabledOverloadedVoidMethod");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    int32_t longArg;
    V8StringResource<> stringArg;
    TestInterfaceImplementation* testInterfaceArg;
    longArg = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    stringArg = info[1];
    if (!stringArg.Prepare())
      return;
  
    testInterfaceArg = V8TestInterface::toImplWithTypeCheck(info.GetIsolate(), info[2]);
    if (!testInterfaceArg) {
      exceptionState.ThrowTypeError("parameter 3 is not of type 'TestInterface'.");
  
      return;
    }
  
    impl->partiallyRuntimeEnabledOverloadedVoidMethod(longArg, stringArg, testInterfaceArg);
  }
  
  static int partiallyRuntimeEnabledOverloadedVoidMethodMethodLength() {
    if (RuntimeEnabledFeatures::FeatureName1Enabled()) {
      return 1;
    }
    if (RuntimeEnabledFeatures::FeatureName2Enabled()) {
      return 1;
    }
    return 2;
  }
  
  static int partiallyRuntimeEnabledOverloadedVoidMethodMethodMaxArg() {
    if (RuntimeEnabledFeatures::FeatureName3Enabled()) {
      return 3;
    }
    return 2;
  }
  
  static void partiallyRuntimeEnabledOverloadedVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    bool isArityError = false;
    switch (std::min(TestObjectV8Internal::partiallyRuntimeEnabledOverloadedVoidMethodMethodMaxArg(), info.Length())) {
      case 1:
        if (RuntimeEnabledFeatures::FeatureName2Enabled()) {
          if (V8TestInterface::hasInstance(info[0], info.GetIsolate())) {
            partiallyRuntimeEnabledOverloadedVoidMethod2Method(info);
            return;
          }
        }
        if (RuntimeEnabledFeatures::FeatureName1Enabled()) {
          if (true) {
            partiallyRuntimeEnabledOverloadedVoidMethod1Method(info);
            return;
          }
        }
        break;
      case 2:
        if (true) {
          partiallyRuntimeEnabledOverloadedVoidMethod3Method(info);
          return;
        }
        break;
      case 3:
        if (RuntimeEnabledFeatures::FeatureName3Enabled()) {
          if (true) {
            partiallyRuntimeEnabledOverloadedVoidMethod4Method(info);
            return;
          }
        }
        break;
      default:
        isArityError = true;
    }
  
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "partiallyRuntimeEnabledOverloadedVoidMethod");
  
    if (isArityError) {
      if (info.Length() < TestObjectV8Internal::partiallyRuntimeEnabledOverloadedVoidMethodMethodLength()) {
        exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(TestObjectV8Internal::partiallyRuntimeEnabledOverloadedVoidMethodMethodLength(), info.Length()));
        return;
      }
    }
    exceptionState.ThrowTypeError("No function was found that matched the signature provided.");
  }
  
  static void legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    TestInterfaceEmpty* testInterfaceEmptyArg;
    testInterfaceEmptyArg = V8TestInterfaceEmpty::toImplWithTypeCheck(info.GetIsolate(), info[0]);
  
    impl->legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
  }
  
  static void legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    HeapVector<Member<TestInterfaceEmpty>> testInterfaceEmptyArg;
    for (int i = 0; i < info.Length(); ++i) {
      if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
        exceptionState.ThrowTypeError("parameter 1 is not of type 'TestInterfaceEmpty'.");
  
        return;
      }
      testInterfaceEmptyArg.push_back(V8TestInterfaceEmpty::toImpl(v8::Local<v8::Object>::Cast(info[i])));
    }
  
    impl->legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArg(testInterfaceEmptyArg);
  }
  
  static void useToImpl4ArgumentsCheckingIfPossibleWithOptionalArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    Node* node1;
    Node* node2;
    int numArgsPassed = info.Length();
    while (numArgsPassed > 0) {
      if (!info[numArgsPassed - 1]->IsUndefined())
        break;
      --numArgsPassed;
    }
    node1 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!node1) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg", "TestObject", "parameter 1 is not of type 'Node'."));
  
      return;
    }
  
    if (UNLIKELY(numArgsPassed <= 1)) {
      impl->useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg(node1);
      return;
    }
    node2 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
    if (!node2) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg", "TestObject", "parameter 2 is not of type 'Node'."));
  
      return;
    }
  
    impl->useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg(node1, node2);
  }
  
  static void useToImpl4ArgumentsCheckingIfPossibleWithNullableArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 2)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", "TestObject", ExceptionMessages::NotEnoughArguments(2, info.Length())));
      return;
    }
  
    Node* node1;
    Node* node2;
    node1 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!node1) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", "TestObject", "parameter 1 is not of type 'Node'."));
  
      return;
    }
  
    node2 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
    if (!node2 && !IsUndefinedOrNull(info[1])) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", "TestObject", "parameter 2 is not of type 'Node'."));
  
      return;
    }
  
    impl->useToImpl4ArgumentsCheckingIfPossibleWithNullableArg(node1, node2);
  }
  
  static void useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg", "TestObject", ExceptionMessages::NotEnoughArguments(1, info.Length())));
      return;
    }
  
    Node* node1;
    Node* node2;
    node1 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[0]);
    if (!node1) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg", "TestObject", "parameter 1 is not of type 'Node'."));
  
      return;
    }
  
    node2 = V8Node::toImplWithTypeCheck(info.GetIsolate(), info[1]);
    if (!node2) {
      V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg", "TestObject", "parameter 2 is not of type 'Node'."));
  
      return;
    }
  
    impl->useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg(node1, node2);
  }
  
  static void unforgeableVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->unforgeableVoidMethod();
  }
  
  static void voidMethodTestInterfaceGarbageCollectedSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodTestInterfaceGarbageCollectedSequenceArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    HeapVector<Member<TestInterfaceGarbageCollected>> testInterfaceGarbageCollectedSequenceArg;
    testInterfaceGarbageCollectedSequenceArg = NativeValueTraits<IDLSequence<TestInterfaceGarbageCollected>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodTestInterfaceGarbageCollectedSequenceArg(testInterfaceGarbageCollectedSequenceArg);
  }
  
  static void voidMethodTestInterfaceGarbageCollectedArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "voidMethodTestInterfaceGarbageCollectedArrayArg");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    HeapVector<Member<TestInterfaceGarbageCollected>> testInterfaceGarbageCollectedArrayArg;
    testInterfaceGarbageCollectedArrayArg = NativeValueTraits<IDLSequence<TestInterfaceGarbageCollected>>::NativeValue(info.GetIsolate(), info[0], exceptionState);
    if (exceptionState.HadException())
      return;
  
    impl->voidMethodTestInterfaceGarbageCollectedArrayArg(testInterfaceGarbageCollectedArrayArg);
  }
  
  static void newObjectTestInterfaceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    TestInterfaceImplementation* result = impl->newObjectTestInterfaceMethod();
    // [NewObject] must always create a new wrapper.  Check that a wrapper
    // does not exist yet.
    DCHECK(!result || DOMDataStore::GetWrapper(result, info.GetIsolate()).IsEmpty());
    V8SetReturnValue(info, result);
  }
  
  static void RuntimeCallStatsCounterMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    RUNTIME_CALL_TIMER_SCOPE(info.GetIsolate(),
                             RuntimeCallStats::CounterId::kRuntimeCallStatsCounterMethod);
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    impl->RuntimeCallStatsCounterMethod();
  }
  
  static void serializerMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueString(info, impl->serializerMethod(), info.GetIsolate());
  }
  
  static void clearMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "clear");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    bool result = impl->myMaplikeClear(scriptState, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValueBool(info, result);
  }
  
  static void keysMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "keys");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    Iterator* result = impl->keysForBinding(scriptState, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result);
  }
  
  static void valuesMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "values");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    Iterator* result = impl->valuesForBinding(scriptState, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result);
  }
  
  static void forEachMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "forEach");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    ScriptValue callback;
    ScriptValue thisArg;
    if (!(info[0]->IsObject() && v8::Local<v8::Object>::Cast(info[0])->IsCallable())) {
      exceptionState.ThrowTypeError("The callback provided as parameter 1 is not a function.");
  
      return;
    }
    callback = ScriptValue(ScriptState::Current(info.GetIsolate()), info[0]);
  
    thisArg = ScriptValue(ScriptState::Current(info.GetIsolate()), info[1]);
  
    impl->forEachForBinding(scriptState, ScriptValue(scriptState, info.Holder()), callback, thisArg, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
  }
  
  static void hasMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "has");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t key;
    key = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    bool result = impl->hasForBinding(scriptState, key, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValueBool(info, result);
  }
  
  static void getMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "get");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t key;
    key = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    ScriptValue result = impl->getForBinding(scriptState, key, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result.V8Value());
  }
  
  static void deleteMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "delete");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    if (UNLIKELY(info.Length() < 1)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
      return;
    }
  
    int32_t key;
    key = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    bool result = impl->deleteForBinding(scriptState, key, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValueBool(info, result);
  }
  
  static void setMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "set");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    if (UNLIKELY(info.Length() < 2)) {
      exceptionState.ThrowTypeError(ExceptionMessages::NotEnoughArguments(2, info.Length()));
      return;
    }
  
    int32_t key;
    StringOrDouble value;
    key = NativeValueTraits<IDLLong>::NativeValue(info.GetIsolate(), info[0], exceptionState, kNormalConversion);
    if (exceptionState.HadException())
      return;
  
    V8StringOrDouble::toImpl(info.GetIsolate(), info[1], value, UnionTypeConversionMode::kNotNullable, exceptionState);
    if (exceptionState.HadException())
      return;
  
    TestObject* result = impl->setForBinding(scriptState, key, value, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result);
  }
  
  static void toJSONMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueString(info, impl->serializerMethod(), info.GetIsolate());
  }
  
  static void toStringMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    V8SetReturnValueString(info, impl->stringifierAttribute(), info.GetIsolate());
  }
  
  static void iteratorMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "iterator");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    Iterator* result = impl->GetIterator(scriptState, exceptionState);
    if (exceptionState.HadException()) {
      return;
    }
    V8SetReturnValue(info, result);
  }
  
  static void namedPropertyGetter(const AtomicString& name, const v8::PropertyCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
    ScriptValue result = impl->AnonymousNamedGetter(scriptState, name);
    if (result.IsEmpty())
      return;
    V8SetReturnValue(info, result.V8Value());
  }
  
  static void namedPropertySetter(const AtomicString& name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
    V8StringResource<> propertyValue = v8Value;
    if (!propertyValue.Prepare())
      return;
  
    bool result = impl->AnonymousNamedSetter(scriptState, name, propertyValue);
    if (!result)
      return;
    V8SetReturnValue(info, v8Value);
  }
  
  static void namedPropertyDeleter(const AtomicString& name, const v8::PropertyCallbackInfo<v8::Boolean>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    DeleteResult result = impl->AnonymousNamedDeleter(scriptState, name);
    if (result == kDeleteUnknownProperty)
      return;
    V8SetReturnValue(info, result == kDeleteSuccess);
  }
  
  static void namedPropertyQuery(const AtomicString& name, const v8::PropertyCallbackInfo<v8::Integer>& info) {
    const CString& nameInUtf8 = name.Utf8();
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kGetterContext, "TestObject", nameInUtf8.data());
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    bool result = impl->NamedPropertyQuery(scriptState, name, exceptionState);
    if (!result)
      return;
    // https://heycam.github.io/webidl/#LegacyPlatformObjectGetOwnProperty
    // 2.7. If |O| implements an interface with a named property setter, then set
    //      desc.[[Writable]] to true, otherwise set it to false.
    V8SetReturnValueInt(info, v8::None);
  }
  
  static void namedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kEnumerationContext, "TestObject");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    Vector<String> names;
    impl->NamedPropertyEnumerator(names, exceptionState);
    if (exceptionState.HadException())
      return;
    V8SetReturnValue(info, ToV8(names, info.Holder(), info.GetIsolate()).As<v8::Array>());
  }
  
  static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    // We assume that all the implementations support length() method, although
    // the spec doesn't require that length() must exist.  It's okay that
    // the interface does not have length attribute as long as the
    // implementation supports length() member function.
    if (index >= impl->length())
      return;  // Returns undefined due to out-of-range.
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    ScriptValue result = impl->item(scriptState, index);
    V8SetReturnValue(info, result.V8Value());
  }
  
  static void indexedPropertyDescriptor(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) {
    // https://heycam.github.io/webidl/#LegacyPlatformObjectGetOwnProperty
    // Steps 1.1 to 1.2.4 are covered here: we rely on indexedPropertyGetter() to
    // call the getter function and check that |index| is a valid property index,
    // in which case it will have set info.GetReturnValue() to something other
    // than undefined.
    V8TestObject::indexedPropertyGetterCallback(index, info);
    v8::Local<v8::Value> getterValue = info.GetReturnValue().Get();
    if (!getterValue->IsUndefined()) {
      // 1.2.5. Let |desc| be a newly created Property Descriptor with no fields.
      // 1.2.6. Set desc.[[Value]] to the result of converting value to an
      //        ECMAScript value.
      // 1.2.7. If O implements an interface with an indexed property setter,
      //        then set desc.[[Writable]] to true, otherwise set it to false.
      v8::PropertyDescriptor desc(getterValue, true);
      // 1.2.8. Set desc.[[Enumerable]] and desc.[[Configurable]] to true.
      desc.set_enumerable(true);
      desc.set_configurable(true);
      // 1.2.9. Return |desc|.
      V8SetReturnValue(info, desc);
    }
  }
  
  static void indexedPropertySetter(uint32_t index, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info) {
    TestObject* impl = V8TestObject::toImpl(info.Holder());
    V8StringResource<> propertyValue = v8Value;
    if (!propertyValue.Prepare())
      return;
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    bool result = impl->setItem(scriptState, index, propertyValue);
    if (!result)
      return;
    V8SetReturnValue(info, v8Value);
  }
  
  static void indexedPropertyDeleter(uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean>& info) {
    ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kIndexedDeletionContext, "TestObject");
  
    TestObject* impl = V8TestObject::toImpl(info.Holder());
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    DeleteResult result = impl->AnonymousIndexedDeleter(scriptState, index, exceptionState);
    if (exceptionState.HadException())
      return;
    if (result == kDeleteUnknownProperty)
      return;
    V8SetReturnValue(info, result == kDeleteSuccess);
  }
  
  } // namespace TestObjectV8Internal
  
  void V8TestObject::stringifierAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringifierAttributeAttributeGetter(info);
  }
  
  void V8TestObject::stringifierAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::stringifierAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::readonlyStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::readonlyStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::readonlyTestInterfaceEmptyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::readonlyTestInterfaceEmptyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::readonlyLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::readonlyLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::dateAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::dateAttributeAttributeGetter(info);
  }
  
  void V8TestObject::dateAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::dateAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::stringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::stringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::stringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::byteStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::byteStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::byteStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::byteStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::usvStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::usvStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::usvStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::usvStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::domTimeStampAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::domTimeStampAttributeAttributeGetter(info);
  }
  
  void V8TestObject::domTimeStampAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::domTimeStampAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::booleanAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::booleanAttributeAttributeGetter(info);
  }
  
  void V8TestObject::booleanAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::booleanAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::byteAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::byteAttributeAttributeGetter(info);
  }
  
  void V8TestObject::byteAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::byteAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::doubleAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::doubleAttributeAttributeGetter(info);
  }
  
  void V8TestObject::doubleAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::doubleAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::floatAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::floatAttributeAttributeGetter(info);
  }
  
  void V8TestObject::floatAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::floatAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::longAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longAttributeAttributeGetter(info);
  }
  
  void V8TestObject::longAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::longAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::longLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::longLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::longLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::octetAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::octetAttributeAttributeGetter(info);
  }
  
  void V8TestObject::octetAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::octetAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::shortAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::shortAttributeAttributeGetter(info);
  }
  
  void V8TestObject::shortAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::shortAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unrestrictedDoubleAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unrestrictedDoubleAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unrestrictedDoubleAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unrestrictedDoubleAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unrestrictedFloatAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unrestrictedFloatAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unrestrictedFloatAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unrestrictedFloatAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unsignedLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unsignedLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unsignedLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unsignedLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unsignedLongLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unsignedLongLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unsignedLongLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unsignedLongLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unsignedShortAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unsignedShortAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unsignedShortAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unsignedShortAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testInterfaceEmptyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceEmptyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceEmptyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testInterfaceEmptyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testObjectAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testObjectAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testObjectAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testObjectAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::cssAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::cssAttributeAttributeGetter(info);
  }
  
  void V8TestObject::cssAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::cssAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::imeAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::imeAttributeAttributeGetter(info);
  }
  
  void V8TestObject::imeAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::imeAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::svgAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::svgAttributeAttributeGetter(info);
  }
  
  void V8TestObject::svgAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::svgAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::xmlAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::xmlAttributeAttributeGetter(info);
  }
  
  void V8TestObject::xmlAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::xmlAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::nodeFilterAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nodeFilterAttributeAttributeGetter(info);
  }
  
  void V8TestObject::nodeFilterAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::nodeFilterAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::serializedScriptValueAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::serializedScriptValueAttributeAttributeGetter(info);
  }
  
  void V8TestObject::serializedScriptValueAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::serializedScriptValueAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::anyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::anyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::anyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::anyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::promiseAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::promiseAttributeAttributeGetter(info);
  }
  
  void V8TestObject::promiseAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::promiseAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::windowAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::windowAttributeAttributeGetter(info);
  }
  
  void V8TestObject::windowAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::windowAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::documentAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::documentAttributeAttributeGetter(info);
  }
  
  void V8TestObject::documentAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::documentAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::documentFragmentAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::documentFragmentAttributeAttributeGetter(info);
  }
  
  void V8TestObject::documentFragmentAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::documentFragmentAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::documentTypeAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::documentTypeAttributeAttributeGetter(info);
  }
  
  void V8TestObject::documentTypeAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::documentTypeAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::elementAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::elementAttributeAttributeGetter(info);
  }
  
  void V8TestObject::elementAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::elementAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::nodeAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nodeAttributeAttributeGetter(info);
  }
  
  void V8TestObject::nodeAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::nodeAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::shadowRootAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::shadowRootAttributeAttributeGetter(info);
  }
  
  void V8TestObject::shadowRootAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::shadowRootAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::arrayBufferAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::arrayBufferAttributeAttributeGetter(info);
  }
  
  void V8TestObject::arrayBufferAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::arrayBufferAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::float32ArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::float32ArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::float32ArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::float32ArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::uint8ArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::uint8ArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::uint8ArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::uint8ArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::selfAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::selfAttributeGetter(info);
  }
  
  void V8TestObject::readonlyEventTargetAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::readonlyEventTargetAttributeAttributeGetter(info);
  }
  
  void V8TestObject::readonlyEventTargetOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::readonlyEventTargetOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::readonlyWindowAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::readonlyWindowAttributeAttributeGetter(info);
  }
  
  void V8TestObject::htmlCollectionAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::htmlCollectionAttributeAttributeGetter(info);
  }
  
  void V8TestObject::htmlElementAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::htmlElementAttributeAttributeGetter(info);
  }
  
  void V8TestObject::stringArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::stringArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::stringArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testInterfaceEmptyArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceEmptyArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceEmptyArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testInterfaceEmptyArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::floatArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::floatArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::floatArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::floatArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::stringFrozenArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringFrozenArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::stringFrozenArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::stringFrozenArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testInterfaceEmptyFrozenArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceEmptyFrozenArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceEmptyFrozenArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testInterfaceEmptyFrozenArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::booleanOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::booleanOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::booleanOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::booleanOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::stringOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::stringOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::stringOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::longOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::longOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::longOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testInterfaceOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testInterfaceOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testEnumAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testEnumAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testEnumAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testEnumAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testEnumOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testEnumOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testEnumOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testEnumOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::staticStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::staticStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::staticStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::staticStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::staticLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::staticLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::staticLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::staticLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::eventHandlerAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::eventHandlerAttributeAttributeGetter(info);
  }
  
  void V8TestObject::eventHandlerAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::eventHandlerAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::doubleOrStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::doubleOrStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::doubleOrStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::doubleOrStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::doubleOrStringOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::doubleOrStringOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::doubleOrStringOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::doubleOrStringOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::doubleOrNullStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::doubleOrNullStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::doubleOrNullStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::doubleOrNullStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::stringOrStringSequenceAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringOrStringSequenceAttributeAttributeGetter(info);
  }
  
  void V8TestObject::stringOrStringSequenceAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::stringOrStringSequenceAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testEnumOrDoubleAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testEnumOrDoubleAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testEnumOrDoubleAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testEnumOrDoubleAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unrestrictedDoubleOrStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unrestrictedDoubleOrStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unrestrictedDoubleOrStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unrestrictedDoubleOrStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::nestedUnionAtributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nestedUnionAtributeAttributeGetter(info);
  }
  
  void V8TestObject::nestedUnionAtributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::nestedUnionAtributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::activityLoggingAccessForAllWorldsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingAccessForAllWorldsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingAccessForAllWorldsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::activityLoggingAccessForAllWorldsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogSetter("TestObject.activityLoggingAccessForAllWorldsLongAttribute", v8Value);
    }
  
    TestObjectV8Internal::activityLoggingAccessForAllWorldsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::activityLoggingGetterForAllWorldsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingGetterForAllWorldsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingGetterForAllWorldsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::activityLoggingGetterForAllWorldsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::activityLoggingGetterForAllWorldsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::activityLoggingSetterForAllWorldsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::activityLoggingSetterForAllWorldsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::activityLoggingSetterForAllWorldsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogSetter("TestObject.activityLoggingSetterForAllWorldsLongAttribute", v8Value);
    }
  
    TestObjectV8Internal::activityLoggingSetterForAllWorldsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::cachedAttributeAnyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::cachedAttributeAnyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::cachedAttributeAnyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::cachedAttributeAnyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::cachedArrayAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::cachedArrayAttributeAttributeGetter(info);
  }
  
  void V8TestObject::cachedArrayAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::cachedArrayAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::cachedStringOrNoneAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::cachedStringOrNoneAttributeAttributeGetter(info);
  }
  
  void V8TestObject::cachedStringOrNoneAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::cachedStringOrNoneAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::callWithExecutionContextAnyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithExecutionContextAnyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::callWithExecutionContextAnyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::callWithExecutionContextAnyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::callWithScriptStateAnyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithScriptStateAnyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::callWithScriptStateAnyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::callWithScriptStateAnyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::callWithExecutionContextAndScriptStateAnyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithExecutionContextAndScriptStateAnyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::callWithExecutionContextAndScriptStateAnyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::callWithExecutionContextAndScriptStateAnyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::checkSecurityForNodeReadonlyDocumentAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::checkSecurityForNodeReadonlyDocumentAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceEmptyConstructorAttributeConstructorGetterCallback(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) {
    Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kdeprecatedTestInterfaceEmptyConstructorAttribute);
  
    V8ConstructorAttributeGetter(property, info);
  }
  
  void V8TestObject::measureAsFeatureNameTestInterfaceEmptyConstructorAttributeConstructorGetterCallback(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) {
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kFeatureName);
  
    V8ConstructorAttributeGetter(property, info);
  }
  
  void V8TestObject::customObjectAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8TestObject::customObjectAttributeAttributeGetterCustom(info);
  }
  
  void V8TestObject::customObjectAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V8TestObject::customObjectAttributeAttributeSetterCustom(v8Value, info);
  }
  
  void V8TestObject::customGetterLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8TestObject::customGetterLongAttributeAttributeGetterCustom(info);
  }
  
  void V8TestObject::customGetterLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::customGetterLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::customGetterReadonlyObjectAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8TestObject::customGetterReadonlyObjectAttributeAttributeGetterCustom(info);
  }
  
  void V8TestObject::customSetterLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::customSetterLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::customSetterLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V8TestObject::customSetterLongAttributeAttributeSetterCustom(v8Value, info);
  }
  
  void V8TestObject::deprecatedLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kLongAttribute);
  
    TestObjectV8Internal::deprecatedLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::deprecatedLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kLongAttribute);
  
    TestObjectV8Internal::deprecatedLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::enforceRangeLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::enforceRangeLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::enforceRangeLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::enforceRangeLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::implementedAsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::implementedAsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::implementedAsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::implementedAsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::customImplementedAsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8TestObject::customImplementedAsLongAttributeAttributeGetterCustom(info);
  }
  
  void V8TestObject::customImplementedAsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V8TestObject::customImplementedAsLongAttributeAttributeSetterCustom(v8Value, info);
  }
  
  void V8TestObject::customGetterImplementedAsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8TestObject::customGetterImplementedAsLongAttributeAttributeGetterCustom(info);
  }
  
  void V8TestObject::customGetterImplementedAsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::customGetterImplementedAsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::customSetterImplementedAsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::customSetterImplementedAsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::customSetterImplementedAsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V8TestObject::customSetterImplementedAsLongAttributeAttributeSetterCustom(v8Value, info);
  }
  
  void V8TestObject::measureAsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
  
    TestObjectV8Internal::measureAsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::measureAsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
  
    TestObjectV8Internal::measureAsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::notEnumerableLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::notEnumerableLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::notEnumerableLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::notEnumerableLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::originTrialEnabledLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::originTrialEnabledLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::originTrialEnabledLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::originTrialEnabledLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterForMainWorld(info);
  }
  
  void V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingAccessPerWorldBindingsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogSetter("TestObject.activityLoggingAccessPerWorldBindingsLongAttribute", v8Value);
    }
  
    TestObjectV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingAccessPerWorldBindingsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
  }
  
  void V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogSetter("TestObject.activityLoggingAccessPerWorldBindingsLongAttribute", v8Value);
    }
  
    TestObjectV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
  }
  
  void V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogSetter("TestObject.activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", v8Value);
    }
  
    TestObjectV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
  }
  
  void V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
  }
  
  void V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingGetterPerWorldBindingsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingGetterPerWorldBindingsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
  }
  
  void V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
  }
  
  void V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      contextData->ActivityLogger()->LogGetter("TestObject.activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute");
    }
  
    TestObjectV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
  }
  
  void V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
  }
  
  void V8TestObject::locationAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationAttributeGetter(info);
  }
  
  void V8TestObject::locationAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::locationWithExceptionAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationWithExceptionAttributeGetter(info);
  }
  
  void V8TestObject::locationWithExceptionAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationWithExceptionAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::locationWithCallWithAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationWithCallWithAttributeGetter(info);
  }
  
  void V8TestObject::locationWithCallWithAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationWithCallWithAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::locationByteStringAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationByteStringAttributeGetter(info);
  }
  
  void V8TestObject::locationByteStringAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationByteStringAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::locationWithPerWorldBindingsAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationWithPerWorldBindingsAttributeGetter(info);
  }
  
  void V8TestObject::locationWithPerWorldBindingsAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationWithPerWorldBindingsAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::locationWithPerWorldBindingsAttributeGetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationWithPerWorldBindingsAttributeGetterForMainWorld(info);
  }
  
  void V8TestObject::locationWithPerWorldBindingsAttributeSetterCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationWithPerWorldBindingsAttributeSetterForMainWorld(v8Value, info);
  }
  
  void V8TestObject::locationLegacyInterfaceTypeCheckingAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationLegacyInterfaceTypeCheckingAttributeGetter(info);
  }
  
  void V8TestObject::locationLegacyInterfaceTypeCheckingAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationLegacyInterfaceTypeCheckingAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::locationGarbageCollectedAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationGarbageCollectedAttributeGetter(info);
  }
  
  void V8TestObject::locationGarbageCollectedAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationGarbageCollectedAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::raisesExceptionLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::raisesExceptionLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::raisesExceptionLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::raisesExceptionGetterLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionGetterLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::raisesExceptionGetterLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::raisesExceptionGetterLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::setterRaisesExceptionLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::setterRaisesExceptionLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::setterRaisesExceptionLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::setterRaisesExceptionLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::raisesExceptionTestInterfaceEmptyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectTestInterfaceAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectTestInterfaceAttributeAttributeGetter(info);
  }
  
  void V8TestObject::reflectTestInterfaceAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectTestInterfaceAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectReflectedNameAttributeTestAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeGetter(info);
  }
  
  void V8TestObject::reflectReflectedNameAttributeTestAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectReflectedNameAttributeTestAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectBooleanAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectBooleanAttributeAttributeGetter(info);
  }
  
  void V8TestObject::reflectBooleanAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectBooleanAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::reflectLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectUnsignedShortAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectUnsignedShortAttributeAttributeGetter(info);
  }
  
  void V8TestObject::reflectUnsignedShortAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectUnsignedShortAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectUnsignedLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectUnsignedLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::reflectUnsignedLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectUnsignedLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::idAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::idAttributeGetter(info);
  }
  
  void V8TestObject::idAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::idAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::nameAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nameAttributeGetter(info);
  }
  
  void V8TestObject::nameAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::nameAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::classAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::classAttributeGetter(info);
  }
  
  void V8TestObject::classAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::classAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectedIdAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectedIdAttributeGetter(info);
  }
  
  void V8TestObject::reflectedIdAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectedIdAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectedNameAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectedNameAttributeGetter(info);
  }
  
  void V8TestObject::reflectedNameAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectedNameAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::reflectedClassAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::reflectedClassAttributeGetter(info);
  }
  
  void V8TestObject::reflectedClassAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::reflectedClassAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::limitedToOnlyOneAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::limitedToOnlyOneAttributeAttributeGetter(info);
  }
  
  void V8TestObject::limitedToOnlyOneAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::limitedToOnlyOneAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::limitedToOnlyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::limitedToOnlyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::limitedToOnlyAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::limitedToOnlyAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::limitedToOnlyOtherAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::limitedToOnlyOtherAttributeAttributeGetter(info);
  }
  
  void V8TestObject::limitedToOnlyOtherAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::limitedToOnlyOtherAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::limitedWithMissingDefaultAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::limitedWithMissingDefaultAttributeAttributeGetter(info);
  }
  
  void V8TestObject::limitedWithMissingDefaultAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::limitedWithMissingDefaultAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::limitedWithInvalidMissingDefaultAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::limitedWithInvalidMissingDefaultAttributeAttributeGetter(info);
  }
  
  void V8TestObject::limitedWithInvalidMissingDefaultAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::limitedWithInvalidMissingDefaultAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::corsSettingAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::corsSettingAttributeAttributeGetter(info);
  }
  
  void V8TestObject::limitedWithEmptyMissingInvalidAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::limitedWithEmptyMissingInvalidAttributeAttributeGetter(info);
  }
  
  void V8TestObject::RuntimeCallStatsCounterAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::RuntimeCallStatsCounterAttributeAttributeGetter(info);
  }
  
  void V8TestObject::RuntimeCallStatsCounterAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::RuntimeCallStatsCounterAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::RuntimeCallStatsCounterReadOnlyAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::RuntimeCallStatsCounterReadOnlyAttributeAttributeGetter(info);
  }
  
  void V8TestObject::replaceableReadonlyLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::replaceableReadonlyLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::replaceableReadonlyLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::replaceableReadonlyLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::locationPutForwardsAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::locationPutForwardsAttributeGetter(info);
  }
  
  void V8TestObject::locationPutForwardsAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::locationPutForwardsAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::runtimeEnabledLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::runtimeEnabledLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::runtimeEnabledLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::runtimeEnabledLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::setterCallWithExecutionContextStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::setterCallWithExecutionContextStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::setterCallWithExecutionContextStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::setterCallWithExecutionContextStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::treatNullAsEmptyStringStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::treatNullAsEmptyStringStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::treatNullAsEmptyStringStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::treatNullAsEmptyStringStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::treatNullAsNullStringStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::treatNullAsNullStringStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::treatNullAsNullStringStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::treatNullAsNullStringStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingFloatAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::legacyInterfaceTypeCheckingFloatAttributeAttributeGetter(info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingFloatAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::legacyInterfaceTypeCheckingFloatAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeGetter(info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::urlStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::urlStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::urlStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::urlStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::urlStringAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::urlStringAttributeAttributeGetter(info);
  }
  
  void V8TestObject::urlStringAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    V0CustomElementProcessingStack::CallbackDeliveryScope deliveryScope;
  
    TestObjectV8Internal::urlStringAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unforgeableLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unforgeableLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unforgeableLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unforgeableLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::measuredLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kV8TestObject_MeasuredLongAttribute_AttributeGetter);
  
    TestObjectV8Internal::measuredLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::measuredLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kV8TestObject_MeasuredLongAttribute_AttributeSetter);
  
    TestObjectV8Internal::measuredLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::sameObjectAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::sameObjectAttributeAttributeGetter(info);
  }
  
  void V8TestObject::saveSameObjectAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::saveSameObjectAttributeAttributeGetter(info);
  }
  
  void V8TestObject::staticSaveSameObjectAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::staticSaveSameObjectAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unscopableLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unscopableLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unscopableLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unscopableLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unscopableOriginTrialEnabledLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unscopableOriginTrialEnabledLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unscopableOriginTrialEnabledLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unscopableOriginTrialEnabledLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::unscopableRuntimeEnabledLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unscopableRuntimeEnabledLongAttributeAttributeGetter(info);
  }
  
  void V8TestObject::unscopableRuntimeEnabledLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::unscopableRuntimeEnabledLongAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testInterfaceAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testInterfaceAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testInterfaceGarbageCollectedAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceGarbageCollectedAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testInterfaceGarbageCollectedAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::testInterfaceGarbageCollectedOrNullAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeGetter(info);
  }
  
  void V8TestObject::testInterfaceGarbageCollectedOrNullAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    v8::Local<v8::Value> v8Value = info[0];
  
    TestObjectV8Internal::testInterfaceGarbageCollectedOrNullAttributeAttributeSetter(v8Value, info);
  }
  
  void V8TestObject::sizeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::sizeAttributeGetter(info);
  }
  
  void V8TestObject::unscopableVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unscopableVoidMethodMethod(info);
  }
  
  void V8TestObject::unscopableRuntimeEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unscopableRuntimeEnabledVoidMethodMethod(info);
  }
  
  void V8TestObject::voidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodMethod(info);
  }
  
  void V8TestObject::staticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::staticVoidMethodMethod(info);
  }
  
  void V8TestObject::dateMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::dateMethodMethod(info);
  }
  
  void V8TestObject::stringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringMethodMethod(info);
  }
  
  void V8TestObject::byteStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::byteStringMethodMethod(info);
  }
  
  void V8TestObject::usvStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::usvStringMethodMethod(info);
  }
  
  void V8TestObject::readonlyDOMTimeStampMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::readonlyDOMTimeStampMethodMethod(info);
  }
  
  void V8TestObject::booleanMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::booleanMethodMethod(info);
  }
  
  void V8TestObject::byteMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::byteMethodMethod(info);
  }
  
  void V8TestObject::doubleMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::doubleMethodMethod(info);
  }
  
  void V8TestObject::floatMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::floatMethodMethod(info);
  }
  
  void V8TestObject::longMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longMethodMethod(info);
  }
  
  void V8TestObject::longLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longLongMethodMethod(info);
  }
  
  void V8TestObject::octetMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::octetMethodMethod(info);
  }
  
  void V8TestObject::shortMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::shortMethodMethod(info);
  }
  
  void V8TestObject::unsignedLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unsignedLongMethodMethod(info);
  }
  
  void V8TestObject::unsignedLongLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unsignedLongLongMethodMethod(info);
  }
  
  void V8TestObject::unsignedShortMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unsignedShortMethodMethod(info);
  }
  
  void V8TestObject::voidMethodDateArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDateArgMethod(info);
  }
  
  void V8TestObject::voidMethodStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodByteStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodByteStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodUSVStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodUSVStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodDOMTimeStampArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDOMTimeStampArgMethod(info);
  }
  
  void V8TestObject::voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodBooleanArgMethod(info);
  }
  
  void V8TestObject::voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodByteArgMethod(info);
  }
  
  void V8TestObject::voidMethodDoubleArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDoubleArgMethod(info);
  }
  
  void V8TestObject::voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodFloatArgMethod(info);
  }
  
  void V8TestObject::voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodLongLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodOctetArgMethod(info);
  }
  
  void V8TestObject::voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodShortArgMethod(info);
  }
  
  void V8TestObject::voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodUnsignedLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodUnsignedLongLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodUnsignedShortArgMethod(info);
  }
  
  void V8TestObject::testInterfaceEmptyMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceEmptyMethodMethod(info);
  }
  
  void V8TestObject::voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::anyMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::anyMethodMethod(info);
  }
  
  void V8TestObject::voidMethodEventTargetArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodEventTargetArgMethod(info);
  }
  
  void V8TestObject::voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodAnyArgMethod(info);
  }
  
  void V8TestObject::voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodAttrArgMethod(info);
  }
  
  void V8TestObject::voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDocumentArgMethod(info);
  }
  
  void V8TestObject::voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDocumentTypeArgMethod(info);
  }
  
  void V8TestObject::voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodElementArgMethod(info);
  }
  
  void V8TestObject::voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodNodeArgMethod(info);
  }
  
  void V8TestObject::arrayBufferMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::arrayBufferMethodMethod(info);
  }
  
  void V8TestObject::arrayBufferViewMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::arrayBufferViewMethodMethod(info);
  }
  
  void V8TestObject::arrayBufferViewMethodRaisesExceptionMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::arrayBufferViewMethodRaisesExceptionMethod(info);
  }
  
  void V8TestObject::float32ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::float32ArrayMethodMethod(info);
  }
  
  void V8TestObject::int32ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::int32ArrayMethodMethod(info);
  }
  
  void V8TestObject::uint8ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::uint8ArrayMethodMethod(info);
  }
  
  void V8TestObject::voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayBufferArgMethod(info);
  }
  
  void V8TestObject::voidMethodArrayBufferOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayBufferOrNullArgMethod(info);
  }
  
  void V8TestObject::voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayBufferViewArgMethod(info);
  }
  
  void V8TestObject::voidMethodFlexibleArrayBufferViewArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodFlexibleArrayBufferViewArgMethod(info);
  }
  
  void V8TestObject::voidMethodFlexibleArrayBufferViewTypedArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodFlexibleArrayBufferViewTypedArgMethod(info);
  }
  
  void V8TestObject::voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodFloat32ArrayArgMethod(info);
  }
  
  void V8TestObject::voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodInt32ArrayArgMethod(info);
  }
  
  void V8TestObject::voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodUint8ArrayArgMethod(info);
  }
  
  void V8TestObject::voidMethodAllowSharedArrayBufferViewArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodAllowSharedArrayBufferViewArgMethod(info);
  }
  
  void V8TestObject::voidMethodAllowSharedUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodAllowSharedUint8ArrayArgMethod(info);
  }
  
  void V8TestObject::longArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longArrayMethodMethod(info);
  }
  
  void V8TestObject::stringArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringArrayMethodMethod(info);
  }
  
  void V8TestObject::testInterfaceEmptyArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceEmptyArrayMethodMethod(info);
  }
  
  void V8TestObject::voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodNullableArrayLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodNullableArrayLongArgMethod(info);
  }
  
  void V8TestObject::longSequenceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longSequenceMethodMethod(info);
  }
  
  void V8TestObject::stringSequenceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringSequenceMethodMethod(info);
  }
  
  void V8TestObject::testInterfaceEmptySequenceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceEmptySequenceMethodMethod(info);
  }
  
  void V8TestObject::voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodSequenceLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodSequenceStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodSequenceSequenceDOMStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodSequenceSequenceDOMStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodNullableSequenceLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodNullableSequenceLongArgMethod(info);
  }
  
  void V8TestObject::longFrozenArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longFrozenArrayMethodMethod(info);
  }
  
  void V8TestObject::voidMethodStringFrozenArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodStringFrozenArrayMethodMethod(info);
  }
  
  void V8TestObject::voidMethodTestInterfaceEmptyFrozenArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestInterfaceEmptyFrozenArrayMethodMethod(info);
  }
  
  void V8TestObject::nullableLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nullableLongMethodMethod(info);
  }
  
  void V8TestObject::nullableStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nullableStringMethodMethod(info);
  }
  
  void V8TestObject::nullableTestInterfaceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nullableTestInterfaceMethodMethod(info);
  }
  
  void V8TestObject::nullableLongSequenceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nullableLongSequenceMethodMethod(info);
  }
  
  void V8TestObject::testInterfaceGarbageCollectedOrDOMStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceGarbageCollectedOrDOMStringMethodMethod(info);
  }
  
  void V8TestObject::booleanOrDOMStringOrUnrestrictedDoubleMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::booleanOrDOMStringOrUnrestrictedDoubleMethodMethod(info);
  }
  
  void V8TestObject::testInterfaceOrLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceOrLongMethodMethod(info);
  }
  
  void V8TestObject::staticTestInterfaceGarbageCollectedOrDOMStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::staticTestInterfaceGarbageCollectedOrDOMStringMethodMethod(info);
  }
  
  void V8TestObject::voidMethodDoubleOrDOMStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDoubleOrDOMStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodDoubleOrDOMStringOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDoubleOrDOMStringOrNullArgMethod(info);
  }
  
  void V8TestObject::voidMethodDoubleOrNullOrDOMStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDoubleOrNullOrDOMStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodDOMStringOrArrayBufferOrArrayBufferViewArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDOMStringOrArrayBufferOrArrayBufferViewArgMethod(info);
  }
  
  void V8TestObject::voidMethodArrayBufferOrArrayBufferViewOrDictionaryArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayBufferOrArrayBufferViewOrDictionaryArgMethod(info);
  }
  
  void V8TestObject::voidMethodBooleanOrElementSequenceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodBooleanOrElementSequenceArgMethod(info);
  }
  
  void V8TestObject::voidMethodDoubleOrLongOrBooleanSequenceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDoubleOrLongOrBooleanSequenceArgMethod(info);
  }
  
  void V8TestObject::voidMethodElementSequenceOrByteStringDoubleOrStringRecordMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodElementSequenceOrByteStringDoubleOrStringRecordMethod(info);
  }
  
  void V8TestObject::voidMethodArrayOfDoubleOrDOMStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodArrayOfDoubleOrDOMStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info);
  }
  
  void V8TestObject::voidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestCallbackInterfaceArgMethod(info);
  }
  
  void V8TestObject::voidMethodOptionalTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodOptionalTestCallbackInterfaceArgMethod(info);
  }
  
  void V8TestObject::voidMethodTestCallbackInterfaceOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestCallbackInterfaceOrNullArgMethod(info);
  }
  
  void V8TestObject::testEnumMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testEnumMethodMethod(info);
  }
  
  void V8TestObject::voidMethodTestEnumArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestEnumArgMethod(info);
  }
  
  void V8TestObject::voidMethodTestMultipleEnumArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestMultipleEnumArgMethod(info);
  }
  
  void V8TestObject::dictionaryMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::dictionaryMethodMethod(info);
  }
  
  void V8TestObject::testDictionaryMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testDictionaryMethodMethod(info);
  }
  
  void V8TestObject::nullableTestDictionaryMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nullableTestDictionaryMethodMethod(info);
  }
  
  void V8TestObject::staticTestDictionaryMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::staticTestDictionaryMethodMethod(info);
  }
  
  void V8TestObject::staticNullableTestDictionaryMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::staticNullableTestDictionaryMethodMethod(info);
  }
  
  void V8TestObject::passPermissiveDictionaryMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::passPermissiveDictionaryMethodMethod(info);
  }
  
  void V8TestObject::nodeFilterMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::nodeFilterMethodMethod(info);
  }
  
  void V8TestObject::promiseMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::promiseMethodMethod(info);
  }
  
  void V8TestObject::promiseMethodWithoutExceptionStateMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::promiseMethodWithoutExceptionStateMethod(info);
  }
  
  void V8TestObject::serializedScriptValueMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::serializedScriptValueMethodMethod(info);
  }
  
  void V8TestObject::xPathNSResolverMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::xPathNSResolverMethodMethod(info);
  }
  
  void V8TestObject::voidMethodDictionaryArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDictionaryArgMethod(info);
  }
  
  void V8TestObject::voidMethodNodeFilterArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodNodeFilterArgMethod(info);
  }
  
  void V8TestObject::voidMethodPromiseArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodPromiseArgMethod(info);
  }
  
  void V8TestObject::voidMethodSerializedScriptValueArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodSerializedScriptValueArgMethod(info);
  }
  
  void V8TestObject::voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodXPathNSResolverArgMethod(info);
  }
  
  void V8TestObject::voidMethodDictionarySequenceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDictionarySequenceArgMethod(info);
  }
  
  void V8TestObject::voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodStringArgLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodOptionalStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodOptionalStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodOptionalLongArgMethod(info);
  }
  
  void V8TestObject::stringMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::stringMethodOptionalLongArgMethod(info);
  }
  
  void V8TestObject::testInterfaceEmptyMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::testInterfaceEmptyMethodOptionalLongArgMethod(info);
  }
  
  void V8TestObject::longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::longMethodOptionalLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodLongArgOptionalLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodOptionalDictionaryArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodOptionalDictionaryArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultByteStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultByteStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultIntegerArgsMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultIntegerArgsMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultDoubleArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultDoubleArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultTrueBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultTrueBooleanArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultFalseBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultFalseBooleanArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultNullableByteStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultNullableByteStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultNullableStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultNullableStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultNullableTestInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultNullableTestInterfaceArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultDoubleOrStringArgsMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultDoubleOrStringArgsMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultStringSequenceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultStringSequenceArgMethod(info);
  }
  
  void V8TestObject::voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodVariadicStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodStringArgVariadicStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodStringArgVariadicStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodVariadicTestInterfaceGarbageCollectedArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodVariadicTestInterfaceGarbageCollectedArgMethod(info);
  }
  
  void V8TestObject::overloadedMethodAMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodAMethod(info);
  }
  
  void V8TestObject::overloadedMethodBMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodBMethod(info);
  }
  
  void V8TestObject::overloadedMethodCMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodCMethod(info);
  }
  
  void V8TestObject::overloadedMethodDMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodDMethod(info);
  }
  
  void V8TestObject::overloadedMethodEMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodEMethod(info);
  }
  
  void V8TestObject::overloadedMethodFMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodFMethod(info);
  }
  
  void V8TestObject::overloadedMethodGMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodGMethod(info);
  }
  
  void V8TestObject::overloadedMethodHMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodHMethod(info);
  }
  
  void V8TestObject::overloadedMethodIMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodIMethod(info);
  }
  
  void V8TestObject::overloadedMethodJMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodJMethod(info);
  }
  
  void V8TestObject::overloadedMethodKMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodKMethod(info);
  }
  
  void V8TestObject::overloadedMethodLMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodLMethod(info);
  }
  
  void V8TestObject::overloadedMethodNMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedMethodNMethod(info);
  }
  
  void V8TestObject::promiseOverloadMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::promiseOverloadMethodMethod(info);
  }
  
  void V8TestObject::overloadedPerWorldBindingsMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedPerWorldBindingsMethodMethod(info);
  }
  
  void V8TestObject::overloadedPerWorldBindingsMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedPerWorldBindingsMethodMethodForMainWorld(info);
  }
  
  void V8TestObject::overloadedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::overloadedStaticMethodMethod(info);
  }
  
  void V8TestObject::itemMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::itemMethod(info);
  }
  
  void V8TestObject::setItemMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::setItemMethod(info);
  }
  
  void V8TestObject::voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodClampUnsignedShortArgMethod(info);
  }
  
  void V8TestObject::voidMethodClampUnsignedLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodClampUnsignedLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultUndefinedLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultUndefinedLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodDefaultUndefinedStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodDefaultUndefinedStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodEnforceRangeLongArgMethod(info);
  }
  
  void V8TestObject::voidMethodTreatNullAsEmptyStringStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTreatNullAsEmptyStringStringArgMethod(info);
  }
  
  void V8TestObject::voidMethodTreatNullAsNullStringStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTreatNullAsNullStringStringArgMethod(info);
  }
  
  void V8TestObject::activityLoggingAccessForAllWorldsMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "activityLoggingAccessForAllWorldsMethod");
      Vector<v8::Local<v8::Value>> loggerArgs = ToImplArguments<Vector<v8::Local<v8::Value>>>(info, 0, exceptionState);
      contextData->ActivityLogger()->LogMethod("TestObject.activityLoggingAccessForAllWorldsMethod", info.Length(), loggerArgs.data());
    }
    TestObjectV8Internal::activityLoggingAccessForAllWorldsMethodMethod(info);
  }
  
  void V8TestObject::callWithExecutionContextVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithExecutionContextVoidMethodMethod(info);
  }
  
  void V8TestObject::callWithScriptStateVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithScriptStateVoidMethodMethod(info);
  }
  
  void V8TestObject::callWithScriptStateLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithScriptStateLongMethodMethod(info);
  }
  
  void V8TestObject::callWithScriptStateExecutionContextVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithScriptStateExecutionContextVoidMethodMethod(info);
  }
  
  void V8TestObject::callWithScriptStateScriptArgumentsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodMethod(info);
  }
  
  void V8TestObject::callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod(info);
  }
  
  void V8TestObject::callWithCurrentWindowMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithCurrentWindowMethod(info);
  }
  
  void V8TestObject::callWithCurrentWindowScriptWindowMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithCurrentWindowScriptWindowMethod(info);
  }
  
  void V8TestObject::callWithThisValueMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithThisValueMethod(info);
  }
  
  void V8TestObject::checkSecurityForNodeVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::checkSecurityForNodeVoidMethodMethod(info);
  }
  
  void V8TestObject::customVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    V8TestObject::customVoidMethodMethodCustom(info);
  }
  
  void V8TestObject::customCallPrologueVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::customCallPrologueVoidMethodMethod(info);
  }
  
  void V8TestObject::customCallEpilogueVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::customCallEpilogueVoidMethodMethod(info);
  }
  
  void V8TestObject::deprecatedVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    Deprecation::CountDeprecation(CurrentExecutionContext(info.GetIsolate()), WebFeature::kvoidMethod);
    TestObjectV8Internal::deprecatedVoidMethodMethod(info);
  }
  
  void V8TestObject::implementedAsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::implementedAsVoidMethodMethod(info);
  }
  
  void V8TestObject::measureAsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kTestFeature);
    TestObjectV8Internal::measureAsVoidMethodMethod(info);
  }
  
  void V8TestObject::measureMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    UseCounter::Count(CurrentExecutionContext(info.GetIsolate()), WebFeature::kV8TestObject_MeasureMethod_Method);
    TestObjectV8Internal::measureMethodMethod(info);
  }
  
  void V8TestObject::measureOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::measureOverloadedMethodMethod(info);
  }
  
  void V8TestObject::DeprecateAsOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::DeprecateAsOverloadedMethodMethod(info);
  }
  
  void V8TestObject::DeprecateAsSameValueOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::DeprecateAsSameValueOverloadedMethodMethod(info);
  }
  
  void V8TestObject::measureAsOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::measureAsOverloadedMethodMethod(info);
  }
  
  void V8TestObject::measureAsSameValueOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::measureAsSameValueOverloadedMethodMethod(info);
  }
  
  void V8TestObject::deprecateAsMeasureAsSameValueOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::deprecateAsMeasureAsSameValueOverloadedMethodMethod(info);
  }
  
  void V8TestObject::deprecateAsSameValueMeasureAsOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::deprecateAsSameValueMeasureAsOverloadedMethodMethod(info);
  }
  
  void V8TestObject::deprecateAsSameValueMeasureAsSameValueOverloadedMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::deprecateAsSameValueMeasureAsSameValueOverloadedMethodMethod(info);
  }
  
  void V8TestObject::notEnumerableVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::notEnumerableVoidMethodMethod(info);
  }
  
  void V8TestObject::originTrialEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::originTrialEnabledVoidMethodMethod(info);
  }
  
  void V8TestObject::perWorldBindingsOriginTrialEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsOriginTrialEnabledVoidMethodMethod(info);
  }
  
  void V8TestObject::perWorldBindingsOriginTrialEnabledVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsOriginTrialEnabledVoidMethodMethodForMainWorld(info);
  }
  
  void V8TestObject::perWorldBindingsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsVoidMethodMethod(info);
  }
  
  void V8TestObject::perWorldBindingsVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsVoidMethodMethodForMainWorld(info);
  }
  
  void V8TestObject::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(info);
  }
  
  void V8TestObject::postMessageMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::postMessageImpl("TestObject", V8TestObject::toImpl(info.Holder()), info);
  }
  
  void V8TestObject::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "activityLoggingForAllWorldsPerWorldBindingsVoidMethod");
      Vector<v8::Local<v8::Value>> loggerArgs = ToImplArguments<Vector<v8::Local<v8::Value>>>(info, 0, exceptionState);
      contextData->ActivityLogger()->LogMethod("TestObject.activityLoggingForAllWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data());
    }
    TestObjectV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethod(info);
  }
  
  void V8TestObject::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "activityLoggingForAllWorldsPerWorldBindingsVoidMethod");
      Vector<v8::Local<v8::Value>> loggerArgs = ToImplArguments<Vector<v8::Local<v8::Value>>>(info, 0, exceptionState);
      contextData->ActivityLogger()->LogMethod("TestObject.activityLoggingForAllWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data());
    }
    TestObjectV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodForMainWorld(info);
  }
  
  void V8TestObject::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    ScriptState* scriptState = ScriptState::ForReceiverObject(info);
    V8PerContextData* contextData = scriptState->PerContextData();
    if (contextData && contextData->ActivityLogger()) {
      ExceptionState exceptionState(info.GetIsolate(), ExceptionState::kExecutionContext, "TestObject", "activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod");
      Vector<v8::Local<v8::Value>> loggerArgs = ToImplArguments<Vector<v8::Local<v8::Value>>>(info, 0, exceptionState);
      contextData->ActivityLogger()->LogMethod("TestObject.activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data());
    }
    TestObjectV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethod(info);
  }
  
  void V8TestObject::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodForMainWorld(info);
  }
  
  void V8TestObject::raisesExceptionVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionVoidMethodMethod(info);
  }
  
  void V8TestObject::raisesExceptionStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionStringMethodMethod(info);
  }
  
  void V8TestObject::raisesExceptionVoidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionVoidMethodOptionalLongArgMethod(info);
  }
  
  void V8TestObject::raisesExceptionVoidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(info);
  }
  
  void V8TestObject::raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(info);
  }
  
  void V8TestObject::raisesExceptionTestInterfaceEmptyVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionTestInterfaceEmptyVoidMethodMethod(info);
  }
  
  void V8TestObject::raisesExceptionXPathNSResolverVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::raisesExceptionXPathNSResolverVoidMethodMethod(info);
  }
  
  void V8TestObject::callWithExecutionContextRaisesExceptionVoidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::callWithExecutionContextRaisesExceptionVoidMethodLongArgMethod(info);
  }
  
  void V8TestObject::runtimeEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::runtimeEnabledVoidMethodMethod(info);
  }
  
  void V8TestObject::perWorldBindingsRuntimeEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethod(info);
  }
  
  void V8TestObject::perWorldBindingsRuntimeEnabledVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethodForMainWorld(info);
  }
  
  void V8TestObject::runtimeEnabledOverloadedVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::runtimeEnabledOverloadedVoidMethodMethod(info);
  }
  
  void V8TestObject::partiallyRuntimeEnabledOverloadedVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::partiallyRuntimeEnabledOverloadedVoidMethodMethod(info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArgMethod(info);
  }
  
  void V8TestObject::legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArgMethod(info);
  }
  
  void V8TestObject::useToImpl4ArgumentsCheckingIfPossibleWithOptionalArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithOptionalArgMethod(info);
  }
  
  void V8TestObject::useToImpl4ArgumentsCheckingIfPossibleWithNullableArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithNullableArgMethod(info);
  }
  
  void V8TestObject::useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArgMethod(info);
  }
  
  void V8TestObject::unforgeableVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::unforgeableVoidMethodMethod(info);
  }
  
  void V8TestObject::voidMethodTestInterfaceGarbageCollectedSequenceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedSequenceArgMethod(info);
  }
  
  void V8TestObject::voidMethodTestInterfaceGarbageCollectedArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::voidMethodTestInterfaceGarbageCollectedArrayArgMethod(info);
  }
  
  void V8TestObject::newObjectTestInterfaceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::newObjectTestInterfaceMethodMethod(info);
  }
  
  void V8TestObject::RuntimeCallStatsCounterMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::RuntimeCallStatsCounterMethodMethod(info);
  }
  
  void V8TestObject::serializerMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::serializerMethodMethod(info);
  }
  
  void V8TestObject::clearMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::clearMethod(info);
  }
  
  void V8TestObject::keysMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::keysMethod(info);
  }
  
  void V8TestObject::valuesMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::valuesMethod(info);
  }
  
  void V8TestObject::forEachMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::forEachMethod(info);
  }
  
  void V8TestObject::hasMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::hasMethod(info);
  }
  
  void V8TestObject::getMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::getMethod(info);
  }
  
  void V8TestObject::deleteMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::deleteMethod(info);
  }
  
  void V8TestObject::setMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::setMethod(info);
  }
  
  void V8TestObject::toJSONMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::toJSONMethod(info);
  }
  
  void V8TestObject::toStringMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::toStringMethod(info);
  }
  
  void V8TestObject::iteratorMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::iteratorMethod(info);
  }
  
  void V8TestObject::namedPropertyGetterCallback(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
    if (!name->IsString())
      return;
    const AtomicString& propertyName = ToCoreAtomicString(name.As<v8::String>());
  
    TestObjectV8Internal::namedPropertyGetter(propertyName, info);
  }
  
  void V8TestObject::namedPropertySetterCallback(v8::Local<v8::Name> name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info) {
    if (!name->IsString())
      return;
    const AtomicString& propertyName = ToCoreAtomicString(name.As<v8::String>());
  
    TestObjectV8Internal::namedPropertySetter(propertyName, v8Value, info);
  }
  
  void V8TestObject::namedPropertyDeleterCallback(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Boolean>& info) {
    if (!name->IsString())
      return;
    const AtomicString& propertyName = ToCoreAtomicString(name.As<v8::String>());
  
    TestObjectV8Internal::namedPropertyDeleter(propertyName, info);
  }
  
  void V8TestObject::namedPropertyQueryCallback(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Integer>& info) {
    if (!name->IsString())
      return;
    const AtomicString& propertyName = ToCoreAtomicString(name.As<v8::String>());
  
    TestObjectV8Internal::namedPropertyQuery(propertyName, info);
  }
  
  void V8TestObject::namedPropertyEnumeratorCallback(const v8::PropertyCallbackInfo<v8::Array>& info) {
    TestObjectV8Internal::namedPropertyEnumerator(info);
  }
  
  void V8TestObject::indexedPropertyGetterCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::indexedPropertyGetter(index, info);
  }
  
  void V8TestObject::indexedPropertyDescriptorCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::indexedPropertyDescriptor(index, info);
  }
  
  void V8TestObject::indexedPropertySetterCallback(uint32_t index, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<v8::Value>& info) {
    TestObjectV8Internal::indexedPropertySetter(index, v8Value, info);
  }
  
  void V8TestObject::indexedPropertyDeleterCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean>& info) {
    TestObjectV8Internal::indexedPropertyDeleter(index, info);
  }
  
  void V8TestObject::indexedPropertyDefinerCallback(
      uint32_t index,
      const v8::PropertyDescriptor& desc,
      const v8::PropertyCallbackInfo<v8::Value>& info) {
    // https://heycam.github.io/webidl/#legacy-platform-object-defineownproperty
    // 3.9.3. [[DefineOwnProperty]]
    // step 1.1. If the result of calling IsDataDescriptor(Desc) is false, then
    //   return false.
    if (desc.has_get() || desc.has_set()) {
      V8SetReturnValue(info, v8::Null(info.GetIsolate()));
      if (info.ShouldThrowOnError()) {
        ExceptionState exceptionState(info.GetIsolate(),
                                      ExceptionState::kIndexedSetterContext,
                                      "TestObject");
        exceptionState.ThrowTypeError("Accessor properties are not allowed.");
      }
      return;
    }
  
    // Return nothing and fall back to indexedPropertySetterCallback.
  }
  
  // Suppress warning: global constructors, because AttributeConfiguration is trivial
  // and does not depend on another global objects.
  #if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wglobal-constructors"
  #endif
  static const V8DOMConfiguration::AttributeConfiguration V8TestObjectAttributes[] = {
      { "testInterfaceEmptyConstructorAttribute", V8TestObject::testInterfaceEmptyConstructorAttributeConstructorGetterCallback, nullptr, const_cast<WrapperTypeInfo*>(&V8TestInterfaceEmpty::wrapperTypeInfo), static_cast<v8::PropertyAttribute>(v8::DontEnum), V8DOMConfiguration::kOnInstance, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "measureAsFeatureNameTestInterfaceEmptyConstructorAttribute", V8TestObject::measureAsFeatureNameTestInterfaceEmptyConstructorAttributeConstructorGetterCallback, nullptr, const_cast<WrapperTypeInfo*>(&V8TestInterfaceEmpty::wrapperTypeInfo), static_cast<v8::PropertyAttribute>(v8::DontEnum), V8DOMConfiguration::kOnInstance, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  };
  #if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
  #pragma clang diagnostic pop
  #endif
  
  // Suppress warning: global constructors, because AttributeConfiguration is trivial
  // and does not depend on another global objects.
  #if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wglobal-constructors"
  #endif
  static const V8DOMConfiguration::AttributeConfiguration V8TestObjectLazyDataAttributes[] = {
      { "testInterfaceEmptyConstructorAttribute", V8ConstructorAttributeGetter, nullptr, const_cast<WrapperTypeInfo*>(&V8TestInterfaceEmpty::wrapperTypeInfo), static_cast<v8::PropertyAttribute>(v8::DontEnum), V8DOMConfiguration::kOnInstance, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  };
  #if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
  #pragma clang diagnostic pop
  #endif
  
  static const V8DOMConfiguration::AccessorConfiguration V8TestObjectAccessors[] = {
      { "stringifierAttribute", V8TestObject::stringifierAttributeAttributeGetterCallback, V8TestObject::stringifierAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "readonlyStringAttribute", V8TestObject::readonlyStringAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "readonlyTestInterfaceEmptyAttribute", V8TestObject::readonlyTestInterfaceEmptyAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "readonlyLongAttribute", V8TestObject::readonlyLongAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "dateAttribute", V8TestObject::dateAttributeAttributeGetterCallback, V8TestObject::dateAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "stringAttribute", V8TestObject::stringAttributeAttributeGetterCallback, V8TestObject::stringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "byteStringAttribute", V8TestObject::byteStringAttributeAttributeGetterCallback, V8TestObject::byteStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "usvStringAttribute", V8TestObject::usvStringAttributeAttributeGetterCallback, V8TestObject::usvStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "domTimeStampAttribute", V8TestObject::domTimeStampAttributeAttributeGetterCallback, V8TestObject::domTimeStampAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "booleanAttribute", V8TestObject::booleanAttributeAttributeGetterCallback, V8TestObject::booleanAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "byteAttribute", V8TestObject::byteAttributeAttributeGetterCallback, V8TestObject::byteAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "doubleAttribute", V8TestObject::doubleAttributeAttributeGetterCallback, V8TestObject::doubleAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "floatAttribute", V8TestObject::floatAttributeAttributeGetterCallback, V8TestObject::floatAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "longAttribute", V8TestObject::longAttributeAttributeGetterCallback, V8TestObject::longAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "longLongAttribute", V8TestObject::longLongAttributeAttributeGetterCallback, V8TestObject::longLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "octetAttribute", V8TestObject::octetAttributeAttributeGetterCallback, V8TestObject::octetAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "shortAttribute", V8TestObject::shortAttributeAttributeGetterCallback, V8TestObject::shortAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unrestrictedDoubleAttribute", V8TestObject::unrestrictedDoubleAttributeAttributeGetterCallback, V8TestObject::unrestrictedDoubleAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unrestrictedFloatAttribute", V8TestObject::unrestrictedFloatAttributeAttributeGetterCallback, V8TestObject::unrestrictedFloatAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unsignedLongAttribute", V8TestObject::unsignedLongAttributeAttributeGetterCallback, V8TestObject::unsignedLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unsignedLongLongAttribute", V8TestObject::unsignedLongLongAttributeAttributeGetterCallback, V8TestObject::unsignedLongLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unsignedShortAttribute", V8TestObject::unsignedShortAttributeAttributeGetterCallback, V8TestObject::unsignedShortAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testInterfaceEmptyAttribute", V8TestObject::testInterfaceEmptyAttributeAttributeGetterCallback, V8TestObject::testInterfaceEmptyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testObjectAttribute", V8TestObject::testObjectAttributeAttributeGetterCallback, V8TestObject::testObjectAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "cssAttribute", V8TestObject::cssAttributeAttributeGetterCallback, V8TestObject::cssAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "imeAttribute", V8TestObject::imeAttributeAttributeGetterCallback, V8TestObject::imeAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "svgAttribute", V8TestObject::svgAttributeAttributeGetterCallback, V8TestObject::svgAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "xmlAttribute", V8TestObject::xmlAttributeAttributeGetterCallback, V8TestObject::xmlAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "nodeFilterAttribute", V8TestObject::nodeFilterAttributeAttributeGetterCallback, V8TestObject::nodeFilterAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "serializedScriptValueAttribute", V8TestObject::serializedScriptValueAttributeAttributeGetterCallback, V8TestObject::serializedScriptValueAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "anyAttribute", V8TestObject::anyAttributeAttributeGetterCallback, V8TestObject::anyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "promiseAttribute", V8TestObject::promiseAttributeAttributeGetterCallback, V8TestObject::promiseAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "windowAttribute", V8TestObject::windowAttributeAttributeGetterCallback, V8TestObject::windowAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "documentAttribute", V8TestObject::documentAttributeAttributeGetterCallback, V8TestObject::documentAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "documentFragmentAttribute", V8TestObject::documentFragmentAttributeAttributeGetterCallback, V8TestObject::documentFragmentAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "documentTypeAttribute", V8TestObject::documentTypeAttributeAttributeGetterCallback, V8TestObject::documentTypeAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "elementAttribute", V8TestObject::elementAttributeAttributeGetterCallback, V8TestObject::elementAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "nodeAttribute", V8TestObject::nodeAttributeAttributeGetterCallback, V8TestObject::nodeAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "shadowRootAttribute", V8TestObject::shadowRootAttributeAttributeGetterCallback, V8TestObject::shadowRootAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "arrayBufferAttribute", V8TestObject::arrayBufferAttributeAttributeGetterCallback, V8TestObject::arrayBufferAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "float32ArrayAttribute", V8TestObject::float32ArrayAttributeAttributeGetterCallback, V8TestObject::float32ArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "uint8ArrayAttribute", V8TestObject::uint8ArrayAttributeAttributeGetterCallback, V8TestObject::uint8ArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "self", V8TestObject::selfAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "readonlyEventTargetAttribute", V8TestObject::readonlyEventTargetAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "readonlyEventTargetOrNullAttribute", V8TestObject::readonlyEventTargetOrNullAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "readonlyWindowAttribute", V8TestObject::readonlyWindowAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "htmlCollectionAttribute", V8TestObject::htmlCollectionAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "htmlElementAttribute", V8TestObject::htmlElementAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "stringArrayAttribute", V8TestObject::stringArrayAttributeAttributeGetterCallback, V8TestObject::stringArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testInterfaceEmptyArrayAttribute", V8TestObject::testInterfaceEmptyArrayAttributeAttributeGetterCallback, V8TestObject::testInterfaceEmptyArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "floatArrayAttribute", V8TestObject::floatArrayAttributeAttributeGetterCallback, V8TestObject::floatArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "stringFrozenArrayAttribute", V8TestObject::stringFrozenArrayAttributeAttributeGetterCallback, V8TestObject::stringFrozenArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testInterfaceEmptyFrozenArrayAttribute", V8TestObject::testInterfaceEmptyFrozenArrayAttributeAttributeGetterCallback, V8TestObject::testInterfaceEmptyFrozenArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "booleanOrNullAttribute", V8TestObject::booleanOrNullAttributeAttributeGetterCallback, V8TestObject::booleanOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "stringOrNullAttribute", V8TestObject::stringOrNullAttributeAttributeGetterCallback, V8TestObject::stringOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "longOrNullAttribute", V8TestObject::longOrNullAttributeAttributeGetterCallback, V8TestObject::longOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testInterfaceOrNullAttribute", V8TestObject::testInterfaceOrNullAttributeAttributeGetterCallback, V8TestObject::testInterfaceOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testEnumAttribute", V8TestObject::testEnumAttributeAttributeGetterCallback, V8TestObject::testEnumAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testEnumOrNullAttribute", V8TestObject::testEnumOrNullAttributeAttributeGetterCallback, V8TestObject::testEnumOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "staticStringAttribute", V8TestObject::staticStringAttributeAttributeGetterCallback, V8TestObject::staticStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "staticLongAttribute", V8TestObject::staticLongAttributeAttributeGetterCallback, V8TestObject::staticLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "eventHandlerAttribute", V8TestObject::eventHandlerAttributeAttributeGetterCallback, V8TestObject::eventHandlerAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "doubleOrStringAttribute", V8TestObject::doubleOrStringAttributeAttributeGetterCallback, V8TestObject::doubleOrStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "doubleOrStringOrNullAttribute", V8TestObject::doubleOrStringOrNullAttributeAttributeGetterCallback, V8TestObject::doubleOrStringOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "doubleOrNullStringAttribute", V8TestObject::doubleOrNullStringAttributeAttributeGetterCallback, V8TestObject::doubleOrNullStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "stringOrStringSequenceAttribute", V8TestObject::stringOrStringSequenceAttributeAttributeGetterCallback, V8TestObject::stringOrStringSequenceAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testEnumOrDoubleAttribute", V8TestObject::testEnumOrDoubleAttributeAttributeGetterCallback, V8TestObject::testEnumOrDoubleAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unrestrictedDoubleOrStringAttribute", V8TestObject::unrestrictedDoubleOrStringAttributeAttributeGetterCallback, V8TestObject::unrestrictedDoubleOrStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "nestedUnionAtribute", V8TestObject::nestedUnionAtributeAttributeGetterCallback, V8TestObject::nestedUnionAtributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "activityLoggingAccessForAllWorldsLongAttribute", V8TestObject::activityLoggingAccessForAllWorldsLongAttributeAttributeGetterCallback, V8TestObject::activityLoggingAccessForAllWorldsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "activityLoggingGetterForAllWorldsLongAttribute", V8TestObject::activityLoggingGetterForAllWorldsLongAttributeAttributeGetterCallback, V8TestObject::activityLoggingGetterForAllWorldsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "activityLoggingSetterForAllWorldsLongAttribute", V8TestObject::activityLoggingSetterForAllWorldsLongAttributeAttributeGetterCallback, V8TestObject::activityLoggingSetterForAllWorldsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "cachedAttributeAnyAttribute", V8TestObject::cachedAttributeAnyAttributeAttributeGetterCallback, V8TestObject::cachedAttributeAnyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "cachedArrayAttribute", V8TestObject::cachedArrayAttributeAttributeGetterCallback, V8TestObject::cachedArrayAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "cachedStringOrNoneAttribute", V8TestObject::cachedStringOrNoneAttributeAttributeGetterCallback, V8TestObject::cachedStringOrNoneAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "callWithExecutionContextAnyAttribute", V8TestObject::callWithExecutionContextAnyAttributeAttributeGetterCallback, V8TestObject::callWithExecutionContextAnyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "callWithScriptStateAnyAttribute", V8TestObject::callWithScriptStateAnyAttributeAttributeGetterCallback, V8TestObject::callWithScriptStateAnyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "callWithExecutionContextAndScriptStateAnyAttribute", V8TestObject::callWithExecutionContextAndScriptStateAnyAttributeAttributeGetterCallback, V8TestObject::callWithExecutionContextAndScriptStateAnyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "checkSecurityForNodeReadonlyDocumentAttribute", V8TestObject::checkSecurityForNodeReadonlyDocumentAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "customObjectAttribute", V8TestObject::customObjectAttributeAttributeGetterCallback, V8TestObject::customObjectAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "customGetterLongAttribute", V8TestObject::customGetterLongAttributeAttributeGetterCallback, V8TestObject::customGetterLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "customGetterReadonlyObjectAttribute", V8TestObject::customGetterReadonlyObjectAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "customSetterLongAttribute", V8TestObject::customSetterLongAttributeAttributeGetterCallback, V8TestObject::customSetterLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "deprecatedLongAttribute", V8TestObject::deprecatedLongAttributeAttributeGetterCallback, V8TestObject::deprecatedLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "enforceRangeLongAttribute", V8TestObject::enforceRangeLongAttributeAttributeGetterCallback, V8TestObject::enforceRangeLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "implementedAsLongAttribute", V8TestObject::implementedAsLongAttributeAttributeGetterCallback, V8TestObject::implementedAsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "customImplementedAsLongAttribute", V8TestObject::customImplementedAsLongAttributeAttributeGetterCallback, V8TestObject::customImplementedAsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "customGetterImplementedAsLongAttribute", V8TestObject::customGetterImplementedAsLongAttributeAttributeGetterCallback, V8TestObject::customGetterImplementedAsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "customSetterImplementedAsLongAttribute", V8TestObject::customSetterImplementedAsLongAttributeAttributeGetterCallback, V8TestObject::customSetterImplementedAsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "measureAsLongAttribute", V8TestObject::measureAsLongAttributeAttributeGetterCallback, V8TestObject::measureAsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "notEnumerableLongAttribute", V8TestObject::notEnumerableLongAttributeAttributeGetterCallback, V8TestObject::notEnumerableLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::DontEnum), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "perWorldBindingsReadonlyTestInterfaceEmptyAttribute", V8TestObject::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallbackForMainWorld, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kMainWorld },
      { "perWorldBindingsReadonlyTestInterfaceEmptyAttribute", V8TestObject::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kNonMainWorlds },
  
      { "activityLoggingAccessPerWorldBindingsLongAttribute", V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kMainWorld },
      { "activityLoggingAccessPerWorldBindingsLongAttribute", V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallback, V8TestObject::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kNonMainWorlds },
  
      { "activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kMainWorld },
      { "activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback, V8TestObject::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kNonMainWorlds },
  
      { "activityLoggingGetterPerWorldBindingsLongAttribute", V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kMainWorld },
      { "activityLoggingGetterPerWorldBindingsLongAttribute", V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallback, V8TestObject::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kNonMainWorlds },
  
      { "activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute", V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kMainWorld },
      { "activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute", V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback, V8TestObject::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kNonMainWorlds },
  
      { "location", V8TestObject::locationAttributeGetterCallback, V8TestObject::locationAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "locationWithException", V8TestObject::locationWithExceptionAttributeGetterCallback, V8TestObject::locationWithExceptionAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "locationWithCallWith", V8TestObject::locationWithCallWithAttributeGetterCallback, V8TestObject::locationWithCallWithAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "locationByteString", V8TestObject::locationByteStringAttributeGetterCallback, V8TestObject::locationByteStringAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "locationWithPerWorldBindings", V8TestObject::locationWithPerWorldBindingsAttributeGetterCallbackForMainWorld, V8TestObject::locationWithPerWorldBindingsAttributeSetterCallbackForMainWorld, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kMainWorld },
      { "locationWithPerWorldBindings", V8TestObject::locationWithPerWorldBindingsAttributeGetterCallback, V8TestObject::locationWithPerWorldBindingsAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kNonMainWorlds },
  
      { "locationLegacyInterfaceTypeChecking", V8TestObject::locationLegacyInterfaceTypeCheckingAttributeGetterCallback, V8TestObject::locationLegacyInterfaceTypeCheckingAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "locationGarbageCollected", V8TestObject::locationGarbageCollectedAttributeGetterCallback, V8TestObject::locationGarbageCollectedAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "raisesExceptionLongAttribute", V8TestObject::raisesExceptionLongAttributeAttributeGetterCallback, V8TestObject::raisesExceptionLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "raisesExceptionGetterLongAttribute", V8TestObject::raisesExceptionGetterLongAttributeAttributeGetterCallback, V8TestObject::raisesExceptionGetterLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "setterRaisesExceptionLongAttribute", V8TestObject::setterRaisesExceptionLongAttributeAttributeGetterCallback, V8TestObject::setterRaisesExceptionLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "raisesExceptionTestInterfaceEmptyAttribute", V8TestObject::raisesExceptionTestInterfaceEmptyAttributeAttributeGetterCallback, V8TestObject::raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "cachedAttributeRaisesExceptionGetterAnyAttribute", V8TestObject::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetterCallback, V8TestObject::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectTestInterfaceAttribute", V8TestObject::reflectTestInterfaceAttributeAttributeGetterCallback, V8TestObject::reflectTestInterfaceAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectReflectedNameAttributeTestAttribute", V8TestObject::reflectReflectedNameAttributeTestAttributeAttributeGetterCallback, V8TestObject::reflectReflectedNameAttributeTestAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectBooleanAttribute", V8TestObject::reflectBooleanAttributeAttributeGetterCallback, V8TestObject::reflectBooleanAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectLongAttribute", V8TestObject::reflectLongAttributeAttributeGetterCallback, V8TestObject::reflectLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectUnsignedShortAttribute", V8TestObject::reflectUnsignedShortAttributeAttributeGetterCallback, V8TestObject::reflectUnsignedShortAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectUnsignedLongAttribute", V8TestObject::reflectUnsignedLongAttributeAttributeGetterCallback, V8TestObject::reflectUnsignedLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "id", V8TestObject::idAttributeGetterCallback, V8TestObject::idAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "name", V8TestObject::nameAttributeGetterCallback, V8TestObject::nameAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "class", V8TestObject::classAttributeGetterCallback, V8TestObject::classAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectedId", V8TestObject::reflectedIdAttributeGetterCallback, V8TestObject::reflectedIdAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectedName", V8TestObject::reflectedNameAttributeGetterCallback, V8TestObject::reflectedNameAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "reflectedClass", V8TestObject::reflectedClassAttributeGetterCallback, V8TestObject::reflectedClassAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "limitedToOnlyOneAttribute", V8TestObject::limitedToOnlyOneAttributeAttributeGetterCallback, V8TestObject::limitedToOnlyOneAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "limitedToOnlyAttribute", V8TestObject::limitedToOnlyAttributeAttributeGetterCallback, V8TestObject::limitedToOnlyAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "limitedToOnlyOtherAttribute", V8TestObject::limitedToOnlyOtherAttributeAttributeGetterCallback, V8TestObject::limitedToOnlyOtherAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "limitedWithMissingDefaultAttribute", V8TestObject::limitedWithMissingDefaultAttributeAttributeGetterCallback, V8TestObject::limitedWithMissingDefaultAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "limitedWithInvalidMissingDefaultAttribute", V8TestObject::limitedWithInvalidMissingDefaultAttributeAttributeGetterCallback, V8TestObject::limitedWithInvalidMissingDefaultAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "corsSettingAttribute", V8TestObject::corsSettingAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "limitedWithEmptyMissingInvalidAttribute", V8TestObject::limitedWithEmptyMissingInvalidAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "RuntimeCallStatsCounterAttribute", V8TestObject::RuntimeCallStatsCounterAttributeAttributeGetterCallback, V8TestObject::RuntimeCallStatsCounterAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "RuntimeCallStatsCounterReadOnlyAttribute", V8TestObject::RuntimeCallStatsCounterReadOnlyAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "replaceableReadonlyLongAttribute", V8TestObject::replaceableReadonlyLongAttributeAttributeGetterCallback, V8TestObject::replaceableReadonlyLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "locationPutForwards", V8TestObject::locationPutForwardsAttributeGetterCallback, V8TestObject::locationPutForwardsAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "setterCallWithCurrentWindowAndEnteredWindowStringAttribute", V8TestObject::setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeGetterCallback, V8TestObject::setterCallWithCurrentWindowAndEnteredWindowStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "setterCallWithExecutionContextStringAttribute", V8TestObject::setterCallWithExecutionContextStringAttributeAttributeGetterCallback, V8TestObject::setterCallWithExecutionContextStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "treatNullAsEmptyStringStringAttribute", V8TestObject::treatNullAsEmptyStringStringAttributeAttributeGetterCallback, V8TestObject::treatNullAsEmptyStringStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "treatNullAsNullStringStringAttribute", V8TestObject::treatNullAsNullStringStringAttributeAttributeGetterCallback, V8TestObject::treatNullAsNullStringStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "legacyInterfaceTypeCheckingFloatAttribute", V8TestObject::legacyInterfaceTypeCheckingFloatAttributeAttributeGetterCallback, V8TestObject::legacyInterfaceTypeCheckingFloatAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "legacyInterfaceTypeCheckingTestInterfaceAttribute", V8TestObject::legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeGetterCallback, V8TestObject::legacyInterfaceTypeCheckingTestInterfaceAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "legacyInterfaceTypeCheckingTestInterfaceOrNullAttribute", V8TestObject::legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeGetterCallback, V8TestObject::legacyInterfaceTypeCheckingTestInterfaceOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "urlStringAttribute", V8TestObject::urlStringAttributeAttributeGetterCallback, V8TestObject::urlStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "urlStringAttribute", V8TestObject::urlStringAttributeAttributeGetterCallback, V8TestObject::urlStringAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unforgeableLongAttribute", V8TestObject::unforgeableLongAttributeAttributeGetterCallback, V8TestObject::unforgeableLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::DontDelete), V8DOMConfiguration::kOnInstance, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "measuredLongAttribute", V8TestObject::measuredLongAttributeAttributeGetterCallback, V8TestObject::measuredLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "sameObjectAttribute", V8TestObject::sameObjectAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "saveSameObjectAttribute", V8TestObject::saveSameObjectAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "staticSaveSameObjectAttribute", V8TestObject::staticSaveSameObjectAttributeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::ReadOnly), V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "unscopableLongAttribute", V8TestObject::unscopableLongAttributeAttributeGetterCallback, V8TestObject::unscopableLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testInterfaceAttribute", V8TestObject::testInterfaceAttributeAttributeGetterCallback, V8TestObject::testInterfaceAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testInterfaceGarbageCollectedAttribute", V8TestObject::testInterfaceGarbageCollectedAttributeAttributeGetterCallback, V8TestObject::testInterfaceGarbageCollectedAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "testInterfaceGarbageCollectedOrNullAttribute", V8TestObject::testInterfaceGarbageCollectedOrNullAttributeAttributeGetterCallback, V8TestObject::testInterfaceGarbageCollectedOrNullAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
      { "size", V8TestObject::sizeAttributeGetterCallback, nullptr, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::DontEnum | v8::ReadOnly), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  };
  
  static const V8DOMConfiguration::MethodConfiguration V8TestObjectMethods[] = {
      {"unscopableVoidMethod", V8TestObject::unscopableVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethod", V8TestObject::voidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"staticVoidMethod", V8TestObject::staticVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"dateMethod", V8TestObject::dateMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"stringMethod", V8TestObject::stringMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"byteStringMethod", V8TestObject::byteStringMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"usvStringMethod", V8TestObject::usvStringMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"readonlyDOMTimeStampMethod", V8TestObject::readonlyDOMTimeStampMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"booleanMethod", V8TestObject::booleanMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"byteMethod", V8TestObject::byteMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"doubleMethod", V8TestObject::doubleMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"floatMethod", V8TestObject::floatMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"longMethod", V8TestObject::longMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"longLongMethod", V8TestObject::longLongMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"octetMethod", V8TestObject::octetMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"shortMethod", V8TestObject::shortMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"unsignedLongMethod", V8TestObject::unsignedLongMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"unsignedLongLongMethod", V8TestObject::unsignedLongLongMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"unsignedShortMethod", V8TestObject::unsignedShortMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDateArg", V8TestObject::voidMethodDateArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodStringArg", V8TestObject::voidMethodStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodByteStringArg", V8TestObject::voidMethodByteStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodUSVStringArg", V8TestObject::voidMethodUSVStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDOMTimeStampArg", V8TestObject::voidMethodDOMTimeStampArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodBooleanArg", V8TestObject::voidMethodBooleanArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodByteArg", V8TestObject::voidMethodByteArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDoubleArg", V8TestObject::voidMethodDoubleArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodFloatArg", V8TestObject::voidMethodFloatArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodLongArg", V8TestObject::voidMethodLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodLongLongArg", V8TestObject::voidMethodLongLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodOctetArg", V8TestObject::voidMethodOctetArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodShortArg", V8TestObject::voidMethodShortArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodUnsignedLongArg", V8TestObject::voidMethodUnsignedLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodUnsignedLongLongArg", V8TestObject::voidMethodUnsignedLongLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodUnsignedShortArg", V8TestObject::voidMethodUnsignedShortArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testInterfaceEmptyMethod", V8TestObject::testInterfaceEmptyMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestInterfaceEmptyArg", V8TestObject::voidMethodTestInterfaceEmptyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodLongArgTestInterfaceEmptyArg", V8TestObject::voidMethodLongArgTestInterfaceEmptyArgMethodCallback, 2, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"anyMethod", V8TestObject::anyMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodEventTargetArg", V8TestObject::voidMethodEventTargetArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodAnyArg", V8TestObject::voidMethodAnyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodAttrArg", V8TestObject::voidMethodAttrArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDocumentArg", V8TestObject::voidMethodDocumentArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDocumentTypeArg", V8TestObject::voidMethodDocumentTypeArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodElementArg", V8TestObject::voidMethodElementArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodNodeArg", V8TestObject::voidMethodNodeArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"arrayBufferMethod", V8TestObject::arrayBufferMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"arrayBufferViewMethod", V8TestObject::arrayBufferViewMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"arrayBufferViewMethodRaisesException", V8TestObject::arrayBufferViewMethodRaisesExceptionMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"float32ArrayMethod", V8TestObject::float32ArrayMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"int32ArrayMethod", V8TestObject::int32ArrayMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"uint8ArrayMethod", V8TestObject::uint8ArrayMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayBufferArg", V8TestObject::voidMethodArrayBufferArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayBufferOrNullArg", V8TestObject::voidMethodArrayBufferOrNullArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayBufferViewArg", V8TestObject::voidMethodArrayBufferViewArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodFlexibleArrayBufferViewArg", V8TestObject::voidMethodFlexibleArrayBufferViewArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodFlexibleArrayBufferViewTypedArg", V8TestObject::voidMethodFlexibleArrayBufferViewTypedArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodFloat32ArrayArg", V8TestObject::voidMethodFloat32ArrayArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodInt32ArrayArg", V8TestObject::voidMethodInt32ArrayArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodUint8ArrayArg", V8TestObject::voidMethodUint8ArrayArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodAllowSharedArrayBufferViewArg", V8TestObject::voidMethodAllowSharedArrayBufferViewArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodAllowSharedUint8ArrayArg", V8TestObject::voidMethodAllowSharedUint8ArrayArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"longArrayMethod", V8TestObject::longArrayMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"stringArrayMethod", V8TestObject::stringArrayMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testInterfaceEmptyArrayMethod", V8TestObject::testInterfaceEmptyArrayMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayLongArg", V8TestObject::voidMethodArrayLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayStringArg", V8TestObject::voidMethodArrayStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayTestInterfaceEmptyArg", V8TestObject::voidMethodArrayTestInterfaceEmptyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodNullableArrayLongArg", V8TestObject::voidMethodNullableArrayLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"longSequenceMethod", V8TestObject::longSequenceMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"stringSequenceMethod", V8TestObject::stringSequenceMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testInterfaceEmptySequenceMethod", V8TestObject::testInterfaceEmptySequenceMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodSequenceLongArg", V8TestObject::voidMethodSequenceLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodSequenceStringArg", V8TestObject::voidMethodSequenceStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodSequenceTestInterfaceEmptyArg", V8TestObject::voidMethodSequenceTestInterfaceEmptyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodSequenceSequenceDOMStringArg", V8TestObject::voidMethodSequenceSequenceDOMStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodNullableSequenceLongArg", V8TestObject::voidMethodNullableSequenceLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"longFrozenArrayMethod", V8TestObject::longFrozenArrayMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodStringFrozenArrayMethod", V8TestObject::voidMethodStringFrozenArrayMethodMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestInterfaceEmptyFrozenArrayMethod", V8TestObject::voidMethodTestInterfaceEmptyFrozenArrayMethodMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"nullableLongMethod", V8TestObject::nullableLongMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"nullableStringMethod", V8TestObject::nullableStringMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"nullableTestInterfaceMethod", V8TestObject::nullableTestInterfaceMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"nullableLongSequenceMethod", V8TestObject::nullableLongSequenceMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testInterfaceGarbageCollectedOrDOMStringMethod", V8TestObject::testInterfaceGarbageCollectedOrDOMStringMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"booleanOrDOMStringOrUnrestrictedDoubleMethod", V8TestObject::booleanOrDOMStringOrUnrestrictedDoubleMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testInterfaceOrLongMethod", V8TestObject::testInterfaceOrLongMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"staticTestInterfaceGarbageCollectedOrDOMStringMethod", V8TestObject::staticTestInterfaceGarbageCollectedOrDOMStringMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDoubleOrDOMStringArg", V8TestObject::voidMethodDoubleOrDOMStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDoubleOrDOMStringOrNullArg", V8TestObject::voidMethodDoubleOrDOMStringOrNullArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDoubleOrNullOrDOMStringArg", V8TestObject::voidMethodDoubleOrNullOrDOMStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDOMStringOrArrayBufferOrArrayBufferViewArg", V8TestObject::voidMethodDOMStringOrArrayBufferOrArrayBufferViewArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayBufferOrArrayBufferViewOrDictionaryArg", V8TestObject::voidMethodArrayBufferOrArrayBufferViewOrDictionaryArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodBooleanOrElementSequenceArg", V8TestObject::voidMethodBooleanOrElementSequenceArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDoubleOrLongOrBooleanSequenceArg", V8TestObject::voidMethodDoubleOrLongOrBooleanSequenceArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodElementSequenceOrByteStringDoubleOrStringRecord", V8TestObject::voidMethodElementSequenceOrByteStringDoubleOrStringRecordMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodArrayOfDoubleOrDOMStringArg", V8TestObject::voidMethodArrayOfDoubleOrDOMStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestInterfaceEmptyOrNullArg", V8TestObject::voidMethodTestInterfaceEmptyOrNullArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestCallbackInterfaceArg", V8TestObject::voidMethodTestCallbackInterfaceArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodOptionalTestCallbackInterfaceArg", V8TestObject::voidMethodOptionalTestCallbackInterfaceArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestCallbackInterfaceOrNullArg", V8TestObject::voidMethodTestCallbackInterfaceOrNullArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testEnumMethod", V8TestObject::testEnumMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestEnumArg", V8TestObject::voidMethodTestEnumArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestMultipleEnumArg", V8TestObject::voidMethodTestMultipleEnumArgMethodCallback, 2, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"dictionaryMethod", V8TestObject::dictionaryMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testDictionaryMethod", V8TestObject::testDictionaryMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"nullableTestDictionaryMethod", V8TestObject::nullableTestDictionaryMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"staticTestDictionaryMethod", V8TestObject::staticTestDictionaryMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"staticNullableTestDictionaryMethod", V8TestObject::staticNullableTestDictionaryMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"passPermissiveDictionaryMethod", V8TestObject::passPermissiveDictionaryMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"nodeFilterMethod", V8TestObject::nodeFilterMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"promiseMethod", V8TestObject::promiseMethodMethodCallback, 3, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kDoNotCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"promiseMethodWithoutExceptionState", V8TestObject::promiseMethodWithoutExceptionStateMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kDoNotCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"serializedScriptValueMethod", V8TestObject::serializedScriptValueMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"xPathNSResolverMethod", V8TestObject::xPathNSResolverMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDictionaryArg", V8TestObject::voidMethodDictionaryArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodNodeFilterArg", V8TestObject::voidMethodNodeFilterArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodPromiseArg", V8TestObject::voidMethodPromiseArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodSerializedScriptValueArg", V8TestObject::voidMethodSerializedScriptValueArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodXPathNSResolverArg", V8TestObject::voidMethodXPathNSResolverArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDictionarySequenceArg", V8TestObject::voidMethodDictionarySequenceArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodStringArgLongArg", V8TestObject::voidMethodStringArgLongArgMethodCallback, 2, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodOptionalStringArg", V8TestObject::voidMethodOptionalStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodOptionalTestInterfaceEmptyArg", V8TestObject::voidMethodOptionalTestInterfaceEmptyArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodOptionalLongArg", V8TestObject::voidMethodOptionalLongArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"stringMethodOptionalLongArg", V8TestObject::stringMethodOptionalLongArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"testInterfaceEmptyMethodOptionalLongArg", V8TestObject::testInterfaceEmptyMethodOptionalLongArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"longMethodOptionalLongArg", V8TestObject::longMethodOptionalLongArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodLongArgOptionalLongArg", V8TestObject::voidMethodLongArgOptionalLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodLongArgOptionalLongArgOptionalLongArg", V8TestObject::voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodLongArgOptionalTestInterfaceEmptyArg", V8TestObject::voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestInterfaceEmptyArgOptionalLongArg", V8TestObject::voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodOptionalDictionaryArg", V8TestObject::voidMethodOptionalDictionaryArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultByteStringArg", V8TestObject::voidMethodDefaultByteStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultStringArg", V8TestObject::voidMethodDefaultStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultIntegerArgs", V8TestObject::voidMethodDefaultIntegerArgsMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultDoubleArg", V8TestObject::voidMethodDefaultDoubleArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultTrueBooleanArg", V8TestObject::voidMethodDefaultTrueBooleanArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultFalseBooleanArg", V8TestObject::voidMethodDefaultFalseBooleanArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultNullableByteStringArg", V8TestObject::voidMethodDefaultNullableByteStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultNullableStringArg", V8TestObject::voidMethodDefaultNullableStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultNullableTestInterfaceArg", V8TestObject::voidMethodDefaultNullableTestInterfaceArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultDoubleOrStringArgs", V8TestObject::voidMethodDefaultDoubleOrStringArgsMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultStringSequenceArg", V8TestObject::voidMethodDefaultStringSequenceArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodVariadicStringArg", V8TestObject::voidMethodVariadicStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodStringArgVariadicStringArg", V8TestObject::voidMethodStringArgVariadicStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodVariadicTestInterfaceEmptyArg", V8TestObject::voidMethodVariadicTestInterfaceEmptyArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", V8TestObject::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodVariadicTestInterfaceGarbageCollectedArg", V8TestObject::voidMethodVariadicTestInterfaceGarbageCollectedArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodA", V8TestObject::overloadedMethodAMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodB", V8TestObject::overloadedMethodBMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodC", V8TestObject::overloadedMethodCMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodD", V8TestObject::overloadedMethodDMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodE", V8TestObject::overloadedMethodEMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodF", V8TestObject::overloadedMethodFMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodG", V8TestObject::overloadedMethodGMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodH", V8TestObject::overloadedMethodHMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodI", V8TestObject::overloadedMethodIMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodJ", V8TestObject::overloadedMethodJMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodK", V8TestObject::overloadedMethodKMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodL", V8TestObject::overloadedMethodLMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedMethodN", V8TestObject::overloadedMethodNMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"promiseOverloadMethod", V8TestObject::promiseOverloadMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kDoNotCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"overloadedPerWorldBindingsMethod", V8TestObject::overloadedPerWorldBindingsMethodMethodCallbackForMainWorld, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kMainWorld},
      {"overloadedPerWorldBindingsMethod", V8TestObject::overloadedPerWorldBindingsMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kNonMainWorlds},
      {"overloadedStaticMethod", V8TestObject::overloadedStaticMethodMethodCallback, 1, v8::None, V8DOMConfiguration::kOnInterface, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"item", V8TestObject::itemMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"setItem", V8TestObject::setItemMethodCallback, 2, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodClampUnsignedShortArg", V8TestObject::voidMethodClampUnsignedShortArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodClampUnsignedLongArg", V8TestObject::voidMethodClampUnsignedLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultUndefinedTestInterfaceEmptyArg", V8TestObject::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultUndefinedLongArg", V8TestObject::voidMethodDefaultUndefinedLongArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodDefaultUndefinedStringArg", V8TestObject::voidMethodDefaultUndefinedStringArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodEnforceRangeLongArg", V8TestObject::voidMethodEnforceRangeLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTreatNullAsEmptyStringStringArg", V8TestObject::voidMethodTreatNullAsEmptyStringStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTreatNullAsNullStringStringArg", V8TestObject::voidMethodTreatNullAsNullStringStringArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"activityLoggingAccessForAllWorldsMethod", V8TestObject::activityLoggingAccessForAllWorldsMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithExecutionContextVoidMethod", V8TestObject::callWithExecutionContextVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithScriptStateVoidMethod", V8TestObject::callWithScriptStateVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithScriptStateLongMethod", V8TestObject::callWithScriptStateLongMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithScriptStateExecutionContextVoidMethod", V8TestObject::callWithScriptStateExecutionContextVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithScriptStateScriptArgumentsVoidMethod", V8TestObject::callWithScriptStateScriptArgumentsVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg", V8TestObject::callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithCurrentWindow", V8TestObject::callWithCurrentWindowMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithCurrentWindowScriptWindow", V8TestObject::callWithCurrentWindowScriptWindowMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithThisValue", V8TestObject::callWithThisValueMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"checkSecurityForNodeVoidMethod", V8TestObject::checkSecurityForNodeVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"customVoidMethod", V8TestObject::customVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"customCallPrologueVoidMethod", V8TestObject::customCallPrologueVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"customCallEpilogueVoidMethod", V8TestObject::customCallEpilogueVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"deprecatedVoidMethod", V8TestObject::deprecatedVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"implementedAsVoidMethod", V8TestObject::implementedAsVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"measureAsVoidMethod", V8TestObject::measureAsVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"measureMethod", V8TestObject::measureMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"measureOverloadedMethod", V8TestObject::measureOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"DeprecateAsOverloadedMethod", V8TestObject::DeprecateAsOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"DeprecateAsSameValueOverloadedMethod", V8TestObject::DeprecateAsSameValueOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"measureAsOverloadedMethod", V8TestObject::measureAsOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"measureAsSameValueOverloadedMethod", V8TestObject::measureAsSameValueOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"deprecateAsMeasureAsSameValueOverloadedMethod", V8TestObject::deprecateAsMeasureAsSameValueOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"deprecateAsSameValueMeasureAsOverloadedMethod", V8TestObject::deprecateAsSameValueMeasureAsOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"deprecateAsSameValueMeasureAsSameValueOverloadedMethod", V8TestObject::deprecateAsSameValueMeasureAsSameValueOverloadedMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"notEnumerableVoidMethod", V8TestObject::notEnumerableVoidMethodMethodCallback, 0, static_cast<v8::PropertyAttribute>(v8::DontEnum), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"perWorldBindingsVoidMethod", V8TestObject::perWorldBindingsVoidMethodMethodCallbackForMainWorld, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kMainWorld},
      {"perWorldBindingsVoidMethod", V8TestObject::perWorldBindingsVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kNonMainWorlds},
      {"perWorldBindingsVoidMethodTestInterfaceEmptyArg", V8TestObject::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMainWorld, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kMainWorld},
      {"perWorldBindingsVoidMethodTestInterfaceEmptyArg", V8TestObject::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kNonMainWorlds},
      {"postMessage", V8TestObject::postMessageMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"activityLoggingForAllWorldsPerWorldBindingsVoidMethod", V8TestObject::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kMainWorld},
      {"activityLoggingForAllWorldsPerWorldBindingsVoidMethod", V8TestObject::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kNonMainWorlds},
      {"activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod", V8TestObject::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kMainWorld},
      {"activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod", V8TestObject::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kNonMainWorlds},
      {"raisesExceptionVoidMethod", V8TestObject::raisesExceptionVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"raisesExceptionStringMethod", V8TestObject::raisesExceptionStringMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"raisesExceptionVoidMethodOptionalLongArg", V8TestObject::raisesExceptionVoidMethodOptionalLongArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"raisesExceptionVoidMethodTestCallbackInterfaceArg", V8TestObject::raisesExceptionVoidMethodTestCallbackInterfaceArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg", V8TestObject::raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"raisesExceptionTestInterfaceEmptyVoidMethod", V8TestObject::raisesExceptionTestInterfaceEmptyVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"raisesExceptionXPathNSResolverVoidMethod", V8TestObject::raisesExceptionXPathNSResolverVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"callWithExecutionContextRaisesExceptionVoidMethodLongArg", V8TestObject::callWithExecutionContextRaisesExceptionVoidMethodLongArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArg", V8TestObject::legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArg", V8TestObject::legacyInterfaceTypeCheckingVoidMethodTestInterfaceEmptyVariadicArgMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"useToImpl4ArgumentsCheckingIfPossibleWithOptionalArg", V8TestObject::useToImpl4ArgumentsCheckingIfPossibleWithOptionalArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"useToImpl4ArgumentsCheckingIfPossibleWithNullableArg", V8TestObject::useToImpl4ArgumentsCheckingIfPossibleWithNullableArgMethodCallback, 2, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArg", V8TestObject::useToImpl4ArgumentsCheckingIfPossibleWithUndefinedArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"unforgeableVoidMethod", V8TestObject::unforgeableVoidMethodMethodCallback, 0, static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete), V8DOMConfiguration::kOnInstance, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestInterfaceGarbageCollectedSequenceArg", V8TestObject::voidMethodTestInterfaceGarbageCollectedSequenceArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"voidMethodTestInterfaceGarbageCollectedArrayArg", V8TestObject::voidMethodTestInterfaceGarbageCollectedArrayArgMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"newObjectTestInterfaceMethod", V8TestObject::newObjectTestInterfaceMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"RuntimeCallStatsCounterMethod", V8TestObject::RuntimeCallStatsCounterMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"serializerMethod", V8TestObject::serializerMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"keys", V8TestObject::keysMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"values", V8TestObject::valuesMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"forEach", V8TestObject::forEachMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"has", V8TestObject::hasMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"get", V8TestObject::getMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"delete", V8TestObject::deleteMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"set", V8TestObject::setMethodCallback, 2, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"toJSON", V8TestObject::toJSONMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
      {"toString", V8TestObject::toStringMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds},
  };
  
  static void installV8TestObjectTemplate(
      v8::Isolate* isolate,
      const DOMWrapperWorld& world,
      v8::Local<v8::FunctionTemplate> interfaceTemplate) {
    // Initialize the interface object's template.
    V8DOMConfiguration::InitializeDOMInterfaceTemplate(isolate, interfaceTemplate, V8TestObject::wrapperTypeInfo.interface_name, v8::Local<v8::FunctionTemplate>(), V8TestObject::internalFieldCount);
  
    v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interfaceTemplate);
    ALLOW_UNUSED_LOCAL(signature);
    v8::Local<v8::ObjectTemplate> instanceTemplate = interfaceTemplate->InstanceTemplate();
    ALLOW_UNUSED_LOCAL(instanceTemplate);
    v8::Local<v8::ObjectTemplate> prototypeTemplate = interfaceTemplate->PrototypeTemplate();
    ALLOW_UNUSED_LOCAL(prototypeTemplate);
  
    // Register IDL constants, attributes and operations.
    V8DOMConfiguration::InstallAttributes(
        isolate, world, instanceTemplate, prototypeTemplate,
        V8TestObjectAttributes, WTF_ARRAY_LENGTH(V8TestObjectAttributes));
    V8DOMConfiguration::InstallLazyDataAttributes(
        isolate, world, instanceTemplate, prototypeTemplate,
        V8TestObjectLazyDataAttributes, WTF_ARRAY_LENGTH(V8TestObjectLazyDataAttributes));
    V8DOMConfiguration::InstallAccessors(
        isolate, world, instanceTemplate, prototypeTemplate, interfaceTemplate,
        signature, V8TestObjectAccessors, WTF_ARRAY_LENGTH(V8TestObjectAccessors));
    V8DOMConfiguration::InstallMethods(
        isolate, world, instanceTemplate, prototypeTemplate, interfaceTemplate,
        signature, V8TestObjectMethods, WTF_ARRAY_LENGTH(V8TestObjectMethods));
  
    // Indexed properties
    v8::IndexedPropertyHandlerConfiguration indexedPropertyHandlerConfig(
        V8TestObject::indexedPropertyGetterCallback,
        V8TestObject::indexedPropertySetterCallback,
        V8TestObject::indexedPropertyDescriptorCallback,
        V8TestObject::indexedPropertyDeleterCallback,
        IndexedPropertyEnumerator<TestObject>,
        V8TestObject::indexedPropertyDefinerCallback,
        v8::Local<v8::Value>(),
        v8::PropertyHandlerFlags::kNone);
    instanceTemplate->SetHandler(indexedPropertyHandlerConfig);
    // Named properties
    v8::NamedPropertyHandlerConfiguration namedPropertyHandlerConfig(V8TestObject::namedPropertyGetterCallback, V8TestObject::namedPropertySetterCallback, V8TestObject::namedPropertyQueryCallback, V8TestObject::namedPropertyDeleterCallback, V8TestObject::namedPropertyEnumeratorCallback, v8::Local<v8::Value>(), static_cast<v8::PropertyHandlerFlags>(int(v8::PropertyHandlerFlags::kOnlyInterceptStrings) | int(v8::PropertyHandlerFlags::kNonMasking)));
    instanceTemplate->SetHandler(namedPropertyHandlerConfig);
  
    // Iterator (@@iterator)
    static const V8DOMConfiguration::SymbolKeyedMethodConfiguration
    symbolKeyedIteratorConfiguration = {
        v8::Symbol::GetIterator,
        "entries",
        V8TestObject::iteratorMethodCallback,
        0,
        v8::DontEnum,
        V8DOMConfiguration::kOnPrototype,
        V8DOMConfiguration::kCheckHolder,
        V8DOMConfiguration::kDoNotCheckAccess
    };
    V8DOMConfiguration::InstallMethod(isolate, world, prototypeTemplate, signature, symbolKeyedIteratorConfiguration);
  
    // Custom signature
    const V8DOMConfiguration::MethodConfiguration partiallyRuntimeEnabledOverloadedVoidMethodMethodConfiguration[] = {
      {"partiallyRuntimeEnabledOverloadedVoidMethod", V8TestObject::partiallyRuntimeEnabledOverloadedVoidMethodMethodCallback, TestObjectV8Internal::partiallyRuntimeEnabledOverloadedVoidMethodMethodLength(), v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds}
    };
    for (const auto& methodConfig : partiallyRuntimeEnabledOverloadedVoidMethodMethodConfiguration)
      V8DOMConfiguration::InstallMethod(isolate, world, instanceTemplate, prototypeTemplate, interfaceTemplate, signature, methodConfig);
  
    V8TestObject::InstallRuntimeEnabledFeaturesOnTemplate(
        isolate, world, interfaceTemplate);
  }
  
  void V8TestObject::InstallRuntimeEnabledFeaturesOnTemplate(
      v8::Isolate* isolate,
      const DOMWrapperWorld& world,
      v8::Local<v8::FunctionTemplate> interface_template) {
    v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interface_template);
    ALLOW_UNUSED_LOCAL(signature);
    v8::Local<v8::ObjectTemplate> instance_template = interface_template->InstanceTemplate();
    ALLOW_UNUSED_LOCAL(instance_template);
    v8::Local<v8::ObjectTemplate> prototype_template = interface_template->PrototypeTemplate();
    ALLOW_UNUSED_LOCAL(prototype_template);
  
    // Register IDL constants, attributes and operations.
  
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      static const V8DOMConfiguration::AccessorConfiguration accessor_configurations[] = {
          { "runtimeEnabledLongAttribute", V8TestObject::runtimeEnabledLongAttributeAttributeGetterCallback, V8TestObject::runtimeEnabledLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
  
          { "unscopableRuntimeEnabledLongAttribute", V8TestObject::unscopableRuntimeEnabledLongAttributeAttributeGetterCallback, V8TestObject::unscopableRuntimeEnabledLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds },
      };
      V8DOMConfiguration::InstallAccessors(
          isolate, world, instance_template, prototype_template, interface_template,
          signature, accessor_configurations,
          WTF_ARRAY_LENGTH(accessor_configurations));
    }
  
    // Custom signature
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      const V8DOMConfiguration::MethodConfiguration unscopableRuntimeEnabledVoidMethodMethodConfiguration[] = {
        {"unscopableRuntimeEnabledVoidMethod", V8TestObject::unscopableRuntimeEnabledVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds}
      };
      for (const auto& methodConfig : unscopableRuntimeEnabledVoidMethodMethodConfiguration)
        V8DOMConfiguration::InstallMethod(isolate, world, instance_template, prototype_template, interface_template, signature, methodConfig);
    }
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      const V8DOMConfiguration::MethodConfiguration runtimeEnabledVoidMethodMethodConfiguration[] = {
        {"runtimeEnabledVoidMethod", V8TestObject::runtimeEnabledVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds}
      };
      for (const auto& methodConfig : runtimeEnabledVoidMethodMethodConfiguration)
        V8DOMConfiguration::InstallMethod(isolate, world, instance_template, prototype_template, interface_template, signature, methodConfig);
    }
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      const V8DOMConfiguration::MethodConfiguration perWorldBindingsRuntimeEnabledVoidMethodMethodConfiguration[] = {
        {"perWorldBindingsRuntimeEnabledVoidMethod", V8TestObject::perWorldBindingsRuntimeEnabledVoidMethodMethodCallbackForMainWorld, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kMainWorld},
        {"perWorldBindingsRuntimeEnabledVoidMethod", V8TestObject::perWorldBindingsRuntimeEnabledVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kNonMainWorlds}
      };
      for (const auto& methodConfig : perWorldBindingsRuntimeEnabledVoidMethodMethodConfiguration)
        V8DOMConfiguration::InstallMethod(isolate, world, instance_template, prototype_template, interface_template, signature, methodConfig);
    }
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      const V8DOMConfiguration::MethodConfiguration runtimeEnabledOverloadedVoidMethodMethodConfiguration[] = {
        {"runtimeEnabledOverloadedVoidMethod", V8TestObject::runtimeEnabledOverloadedVoidMethodMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds}
      };
      for (const auto& methodConfig : runtimeEnabledOverloadedVoidMethodMethodConfiguration)
        V8DOMConfiguration::InstallMethod(isolate, world, instance_template, prototype_template, interface_template, signature, methodConfig);
    }
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      const V8DOMConfiguration::MethodConfiguration clearMethodConfiguration[] = {
        {"clear", V8TestObject::clearMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds}
      };
      for (const auto& methodConfig : clearMethodConfiguration)
        V8DOMConfiguration::InstallMethod(isolate, world, instance_template, prototype_template, interface_template, signature, methodConfig);
    }
  }
  
  void V8TestObject::installFeatureName(v8::Isolate* isolate, const DOMWrapperWorld& world, v8::Local<v8::Object> instance, v8::Local<v8::Object> prototype, v8::Local<v8::Function> interface) {
    v8::Local<v8::FunctionTemplate> interfaceTemplate = V8TestObject::wrapperTypeInfo.domTemplate(isolate, world);
    v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interfaceTemplate);
    ALLOW_UNUSED_LOCAL(signature);
    static const V8DOMConfiguration::AccessorConfiguration accessororiginTrialEnabledLongAttributeConfiguration[] = {
    { "originTrialEnabledLongAttribute", V8TestObject::originTrialEnabledLongAttributeAttributeGetterCallback, V8TestObject::originTrialEnabledLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds }
    };
    for (const auto& accessorConfig : accessororiginTrialEnabledLongAttributeConfiguration)
      V8DOMConfiguration::InstallAccessor(isolate, world, instance, prototype, interface, signature, accessorConfig);
    static const V8DOMConfiguration::AccessorConfiguration accessorunscopableOriginTrialEnabledLongAttributeConfiguration[] = {
    { "unscopableOriginTrialEnabledLongAttribute", V8TestObject::unscopableOriginTrialEnabledLongAttributeAttributeGetterCallback, V8TestObject::unscopableOriginTrialEnabledLongAttributeAttributeSetterCallback, nullptr, nullptr, static_cast<v8::PropertyAttribute>(v8::None), V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kAllWorlds }
    };
    for (const auto& accessorConfig : accessorunscopableOriginTrialEnabledLongAttributeConfiguration)
      V8DOMConfiguration::InstallAccessor(isolate, world, instance, prototype, interface, signature, accessorConfig);
    static const V8DOMConfiguration::MethodConfiguration methodOrigintrialenabledvoidmethodConfiguration[] = {
      {"originTrialEnabledVoidMethod", V8TestObject::originTrialEnabledVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kAllWorlds}
    };
    for (const auto& methodConfig : methodOrigintrialenabledvoidmethodConfiguration)
      V8DOMConfiguration::InstallMethod(isolate, world, instance, prototype, interface, signature, methodConfig);
    static const V8DOMConfiguration::MethodConfiguration methodPerworldbindingsorigintrialenabledvoidmethodConfiguration[] = {
      {"perWorldBindingsOriginTrialEnabledVoidMethod", V8TestObject::perWorldBindingsOriginTrialEnabledVoidMethodMethodCallbackForMainWorld, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kMainWorld},
    {"perWorldBindingsOriginTrialEnabledVoidMethod", V8TestObject::perWorldBindingsOriginTrialEnabledVoidMethodMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kNonMainWorlds}
    };
    for (const auto& methodConfig : methodPerworldbindingsorigintrialenabledvoidmethodConfiguration)
      V8DOMConfiguration::InstallMethod(isolate, world, instance, prototype, interface, signature, methodConfig);
  }
  
  void V8TestObject::installFeatureName(ScriptState* scriptState, v8::Local<v8::Object> instance) {
    V8PerContextData* perContextData = V8PerContextData::From(scriptState->GetContext());
    v8::Local<v8::Object> prototype = perContextData->PrototypeForType(&V8TestObject::wrapperTypeInfo);
    v8::Local<v8::Function> interface = perContextData->ConstructorForType(&V8TestObject::wrapperTypeInfo);
    ALLOW_UNUSED_LOCAL(interface);
    installFeatureName(scriptState->GetIsolate(), scriptState->World(), instance, prototype, interface);
  }
  
  void V8TestObject::installFeatureName(ScriptState* scriptState) {
    installFeatureName(scriptState, v8::Local<v8::Object>());
  }
  
  v8::Local<v8::FunctionTemplate> V8TestObject::domTemplate(v8::Isolate* isolate, const DOMWrapperWorld& world) {
    return V8DOMConfiguration::DomClassTemplate(isolate, world, const_cast<WrapperTypeInfo*>(&wrapperTypeInfo), installV8TestObjectTemplate);
  }
  
  bool V8TestObject::hasInstance(v8::Local<v8::Value> v8Value, v8::Isolate* isolate) {
    return V8PerIsolateData::From(isolate)->HasInstance(&wrapperTypeInfo, v8Value);
  }
  
  v8::Local<v8::Object> V8TestObject::findInstanceInPrototypeChain(v8::Local<v8::Value> v8Value, v8::Isolate* isolate) {
    return V8PerIsolateData::From(isolate)->FindInstanceInPrototypeChain(&wrapperTypeInfo, v8Value);
  }
  
  TestObject* V8TestObject::toImplWithTypeCheck(v8::Isolate* isolate, v8::Local<v8::Value> value) {
    return hasInstance(value, isolate) ? toImpl(v8::Local<v8::Object>::Cast(value)) : nullptr;
  }
  
  TestObject* NativeValueTraits<TestObject>::NativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState) {
    TestObject* nativeValue = V8TestObject::toImplWithTypeCheck(isolate, value);
    if (!nativeValue) {
      exceptionState.ThrowTypeError(ExceptionMessages::FailedToConvertJSValue(
          "TestObject"));
    }
    return nativeValue;
  }
  
  void V8TestObject::preparePrototypeAndInterfaceObject(v8::Local<v8::Context> context, const DOMWrapperWorld& world, v8::Local<v8::Object> prototypeObject, v8::Local<v8::Function> interfaceObject, v8::Local<v8::FunctionTemplate> interfaceTemplate) {
    v8::Isolate* isolate = context->GetIsolate();
  
    v8::Local<v8::Name> unscopablesSymbol(v8::Symbol::GetUnscopables(isolate));
    v8::Local<v8::Object> unscopables;
    if (V8CallBoolean(prototypeObject->HasOwnProperty(context, unscopablesSymbol)))
      unscopables = prototypeObject->Get(context, unscopablesSymbol).ToLocalChecked().As<v8::Object>();
    else
      unscopables = v8::Object::New(isolate);
    unscopables->CreateDataProperty(context, V8AtomicString(isolate, "unscopableLongAttribute"), v8::True(isolate)).FromJust();
    unscopables->CreateDataProperty(context, V8AtomicString(isolate, "unscopableOriginTrialEnabledLongAttribute"), v8::True(isolate)).FromJust();
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      unscopables->CreateDataProperty(context, V8AtomicString(isolate, "unscopableRuntimeEnabledLongAttribute"), v8::True(isolate)).FromJust();
    }
    if (RuntimeEnabledFeatures::FeatureNameEnabled()) {
      unscopables->CreateDataProperty(context, V8AtomicString(isolate, "unscopableRuntimeEnabledVoidMethod"), v8::True(isolate)).FromJust();
    }
    unscopables->CreateDataProperty(context, V8AtomicString(isolate, "unscopableVoidMethod"), v8::True(isolate)).FromJust();
    prototypeObject->CreateDataProperty(context, unscopablesSymbol, unscopables).FromJust();
  }
  
  }  // namespace blink
  