/*
 * Module code.
 *
 * Generated by SIP 4.16.8
 *
 * Copyright (c) 2015 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt5.
 * 
 * This file may be used under the terms of the GNU General Public License
 * version 3.0 as published by the Free Software Foundation and appearing in
 * the file LICENSE included in the packaging of this file.  Please review the
 * following information to ensure the GNU General Public License version 3.0
 * requirements will be met: http://www.gnu.org/copyleft/gpl.html.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPIQtTest.h"

#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_QtTest[] = {
    'P', 'y', 'Q', 't', '5', '.', 'Q', 't', 'C', 'o', 'r', 'e', '.', 'p', 'y', 'q', 't', 'W', 'r', 'a', 'p', 'p', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'Q', 'T', 'e', 's', 't', ':', ':', 'Q', 'T', 'o', 'u', 'c', 'h', 'E', 'v', 'e', 'n', 't', 'S', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0,
    'q', 'W', 'a', 'i', 't', 'F', 'o', 'r', 'W', 'i', 'n', 'd', 'o', 'w', 'E', 'x', 'p', 'o', 's', 'e', 'd', 0,
    'q', 'W', 'a', 'i', 't', 'F', 'o', 'r', 'W', 'i', 'n', 'd', 'o', 'w', 'A', 'c', 't', 'i', 'v', 'e', 0,
    'Q', 'T', 'e', 's', 't', ':', ':', 'M', 'o', 'u', 's', 'e', 'A', 'c', 't', 'i', 'o', 'n', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'S', 'u', 'b', 'W', 'i', 'n', 'd', 'o', 'w', 's', 0,
    'i', 's', 'S', 'i', 'g', 'n', 'a', 'l', 'C', 'o', 'n', 'n', 'e', 'c', 't', 'e', 'd', 0,
    's', 'e', 'n', 'd', 'e', 'r', 'S', 'i', 'g', 'n', 'a', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    's', 'i', 'p', '.', 's', 'i', 'm', 'p', 'l', 'e', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 0,
    'Q', 'T', 'e', 's', 't', ':', ':', 'K', 'e', 'y', 'A', 'c', 't', 'i', 'o', 'n', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'O', 'l', 'd', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 0,
    'a', 's', 'p', 'e', 'c', 't', 'R', 'a', 't', 'i', 'o', 'M', 'o', 'd', 'e', 0,
    'w', 'a', 'i', 't', 'F', 'o', 'r', 'E', 'v', 'e', 'n', 't', 's', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'd', 'S', 'i', 'g', 'n', 'a', 'l', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    't', 'h', 'r', 'e', 's', 'h', 'o', 'l', 'd', 'T', 'i', 'm', 'e', 0,
    't', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'M', 'o', 'd', 'e', 0,
    'p', 'r', 'o', 'c', 'e', 's', 's', 'E', 'v', 'e', 'n', 't', 's', 0,
    'm', 'o', 'u', 's', 'e', 'R', 'e', 'l', 'e', 'a', 's', 'e', 0,
    'M', 'o', 'u', 's', 'e', 'R', 'e', 'l', 'e', 'a', 's', 'e', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'R', 'e', 'g', 'i', 'o', 'n', 0,
    't', 'a', 'r', 'g', 'e', 't', 'O', 'f', 'f', 's', 'e', 't', 0,
    'm', 'i', 'd', 'L', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    'b', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'R', 'e', 'c', 't', 0,
    'P', 'y', 'Q', 't', '5', '.', 'Q', 't', 'T', 'e', 's', 't', 0,
    'm', 'o', 'u', 's', 'e', 'D', 'C', 'l', 'i', 'c', 'k', 0,
    'M', 'o', 'u', 's', 'e', 'D', 'C', 'l', 'i', 'c', 'k', 0,
    'm', 'a', 't', 'c', 'h', 'P', 'o', 'l', 'i', 'c', 'y', 0,
    'c', 'u', 's', 't', 'o', 'm', 'E', 'v', 'e', 'n', 't', 0,
    'e', 'v', 'e', 'n', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    '_', '_', 'd', 'e', 'l', 'i', 't', 'e', 'm', '_', '_', 0,
    '_', '_', 's', 'e', 't', 'i', 't', 'e', 'm', '_', '_', 0,
    '_', '_', 'g', 'e', 't', 'i', 't', 'e', 'm', '_', '_', 0,
    's', 't', 'a', 't', 'i', 'o', 'n', 'a', 'r', 'y', 0,
    'm', 'o', 'u', 's', 'e', 'P', 'r', 'e', 's', 's', 0,
    'm', 'o', 'u', 's', 'e', 'C', 'l', 'i', 'c', 'k', 0,
    'M', 'o', 'u', 's', 'e', 'C', 'l', 'i', 'c', 'k', 0,
    'M', 'o', 'u', 's', 'e', 'P', 'r', 'e', 's', 's', 0,
    'k', 'e', 'y', 'R', 'e', 'l', 'e', 'a', 's', 'e', 0,
    'Q', 'S', 'i', 'g', 'n', 'a', 'l', 'S', 'p', 'y', 0,
    'm', 'o', 'u', 's', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'c', 'o', 'n', 's', 't', 'r', 'a', 'i', 'n', 't', 0,
    'r', 'e', 'p', 'e', 'a', 't', 'T', 'i', 'm', 'e', 0,
    't', 'o', 'u', 'c', 'h', 'E', 'v', 'e', 'n', 't', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 'S', 'p', 'a', 'n', 0,
    'g', 'e', 'n', 'M', 'i', 'p', 'M', 'a', 'p', 's', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    'm', 'o', 'u', 's', 'e', 'M', 'o', 'v', 'e', 0,
    'k', 'e', 'y', 'C', 'l', 'i', 'c', 'k', 's', 0,
    'o', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'l', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'a', 'l', 'i', 'g', 'n', 'm', 'e', 'n', 't', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    'M', 'o', 'u', 's', 'e', 'M', 'o', 'v', 'e', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'k', 'e', 'y', 'P', 'r', 'e', 's', 's', 0,
    'k', 'e', 'y', 'C', 'l', 'i', 'c', 'k', 0,
    'k', 'e', 'y', 'E', 'v', 'e', 'n', 't', 0,
    's', 'h', 'o', 'r', 't', 'c', 'u', 't', 0,
    'u', 's', 'e', 'r', 'D', 'a', 't', 'a', 0,
    'm', 'o', 'd', 'i', 'f', 'i', 'e', 'r', 0,
    'f', 'i', 'l', 'l', 'R', 'u', 'l', 'e', 0,
    't', 'a', 'b', 'A', 'r', 'r', 'a', 'y', 0,
    't', 'a', 'b', 'S', 't', 'o', 'p', 's', 0,
    'n', 'a', 'm', 'e', 'T', 'y', 'p', 'e', 0,
    'p', 'o', 's', 'i', 't', 'i', 'o', 'n', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'y', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'x', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'r', 'o', 'w', 'S', 'p', 'a', 'n', 0,
    'e', 'x', 'p', 'o', 's', 'e', 'd', 0,
    'b', 'u', 'f', 'f', 'e', 'r', 's', 0,
    's', 'o', 'u', 'r', 'c', 'e', 's', 0,
    'q', 'u', 'a', 'l', 'i', 't', 'y', 0,
    'r', 'e', 'l', 'e', 'a', 's', 'e', 0,
    't', 'i', 'm', 'e', 'o', 'u', 't', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    '_', '_', 'l', 'e', 'n', '_', '_', 0,
    'i', 's', 'V', 'a', 'l', 'i', 'd', 0,
    'q', 'S', 'l', 'e', 'e', 'p', 0,
    's', 'u', 'n', 'k', 'e', 'n', 0,
    'l', 'a', 'y', 'e', 'r', 's', 0,
    's', 't', 'r', 'i', 'd', 'e', 0,
    'w', 'i', 'n', 'd', 'o', 'w', 0,
    'c', 'o', 'm', 'm', 'i', 't', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 0,
    's', 'i', 'g', 'n', 'a', 'l', 0,
    's', 'e', 'n', 'd', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', '9', 0,
    'v', 'a', 'l', 'u', 'e', '8', 0,
    'v', 'a', 'l', 'u', 'e', '7', 0,
    'v', 'a', 'l', 'u', 'e', '6', 0,
    'v', 'a', 'l', 'u', 'e', '5', 0,
    'v', 'a', 'l', 'u', 'e', '4', 0,
    'v', 'a', 'l', 'u', 'e', '3', 0,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 's', 't', 'e', 'm', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'o', 'f', 'f', 's', 'e', 't', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'f', 'i', 'l', 't', 'e', 'r', 0,
    'o', 'p', 't', 'i', 'o', 'n', 0,
    'l', 'o', 'c', 'a', 'l', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    'p', 'r', 'e', 's', 's', 0,
    'q', 'W', 'a', 'i', 't', 0,
    'Q', 'T', 'e', 's', 't', 0,
    'b', 'r', 'u', 's', 'h', 0,
    'd', 'e', 'l', 'a', 'y', 0,
    't', 'y', 'p', 'e', 's', 0,
    'o', 'r', 'd', 'e', 'r', 0,
    'r', 'o', 'l', 'e', 's', 0,
    'f', 'l', 'a', 'g', 's', 0,
    'e', 'v', 'e', 'n', 't', 0,
    'm', 's', 'e', 'c', 's', 0,
    's', 't', 'a', 't', 'e', 0,
    'w', 'a', 'i', 't', 0,
    'm', 'o', 'v', 'e', 0,
    'm', 'o', 'd', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    'f', 'i', 'l', 'l', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'o', 'r', 't', 0,
    'p', 'e', 'n', 0,
    'p', 'o', 's', 0,
    's', 'w', 0,
    's', 'y', 0,
    's', 'x', 0,
};
#line 93 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
// Imports from QtCore.
pyqt5_qttest_get_pyqtsignal_parts_t pyqt5_qttest_get_pyqtsignal_parts;
#line 179 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"


/* Convert to a sub-class if possible. */
extern "C" {static const sipTypeDef *sipSubClass_QSignalSpy(void **);}
static const sipTypeDef *sipSubClass_QSignalSpy(void **sipCppRet)
{
    QObject *sipCpp = reinterpret_cast<QObject *>(*sipCppRet);
    const sipTypeDef *sipType;

#line 30 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
    sipType = (sipCpp->inherits("QSignalSpy") ? sipType_QSignalSpy : 0);
#line 191 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

    return sipType;
}
static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QTest__MouseAction, {0}}, sipNameNr_MouseAction, 1, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QTest__KeyAction, {0}}, sipNameNr_KeyAction, 1, NULL},
};


/*
 * This defines each type in this module.
 */
static sipTypeDef *typesTable[] = {
    &sipTypeDef_QtTest_QSignalSpy.super.ctd_base,
    &sipTypeDef_QtTest_QTest.super.ctd_base,
    &enumTypes[1].etd_base,
    &enumTypes[0].etd_base,
    &sipTypeDef_QtTest_QTest_QTouchEventSequence.super.ctd_base,
};


/* This defines the modules that this module needs to import. */
static sipImportedModuleDef importsTable[] = {
    {"PyQt5.QtCore", 1, NULL},
    {"PyQt5.QtGui", -1, NULL},
    {"PyQt5.QtWidgets", -1, NULL},
    {NULL, -1, NULL}
};


/* This defines the class sub-convertors that this module defines. */
static sipSubClassConvertorDef convertorsTable[] = {
    {sipSubClass_QSignalSpy, {162, 0, 0}, NULL},
    {NULL, {0, 0, 0}, NULL}
};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtTest = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt5_QtTest,
    0,
    -1,
    sipStrings_QtTest,
    importsTable,
    NULL,
    5,
    typesTable,
    NULL,
    0,
    NULL,
    0,
    NULL,
    NULL,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI_QtTest;
const sipExportedModuleDef *sipModuleAPI_QtTest_QtCore;
const sipExportedModuleDef *sipModuleAPI_QtTest_QtGui;
const sipExportedModuleDef *sipModuleAPI_QtTest_QtWidgets;

sip_qt_metaobject_func sip_QtTest_qt_metaobject;
sip_qt_metacall_func sip_QtTest_qt_metacall;
sip_qt_metacast_func sip_QtTest_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtTest
#define SIP_MODULE_TYPE         PyObject *
#define SIP_MODULE_DISCARD(r)   Py_DECREF(r)
#define SIP_MODULE_RETURN(r)    return (r)
#else
#define SIP_MODULE_ENTRY        initQtTest
#define SIP_MODULE_TYPE         void
#define SIP_MODULE_DISCARD(r)
#define SIP_MODULE_RETURN(r)    return
#endif

#if defined(SIP_STATIC_MODULE)
extern "C" SIP_MODULE_TYPE SIP_MODULE_ENTRY()
#else
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
    static PyMethodDef sip_methods[] = {
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt5.QtTest",
        NULL,
        -1,
        sip_methods,
        NULL,
        NULL,
        NULL,
        NULL
    };
#endif

    PyObject *sipModule, *sipModuleDict;
    PyObject *sip_sipmod, *sip_capiobj;

    /* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
    sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
    sipModule = Py_InitModule(sipName_PyQt5_QtTest, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5_QtTest), sip_methods);
#endif

    if (sipModule == NULL)
        SIP_MODULE_RETURN(NULL);

    sipModuleDict = PyModule_GetDict(sipModule);

    /* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
    sip_sipmod = PyImport_ImportModule(SIP_MODULE_NAME);
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#endif

    if (sip_sipmod == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

    sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
    Py_DECREF(sip_sipmod);

#if defined(SIP_USE_PYCAPSULE)
    if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
    if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

#if defined(SIP_USE_PYCAPSULE)
    sipAPI_QtTest = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_QtTest = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

#if defined(SIP_USE_PYCAPSULE)
    if (sipAPI_QtTest == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }
#endif

    /* Export the module and publish it's API. */
    if (sipExportModule(&sipModuleAPI_QtTest,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    sip_QtTest_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtTest_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtTest_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

    if (!sip_QtTest_qt_metacast)
        Py_FatalError("Unable to import qtcore_qt_metacast");

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_QtTest,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    /* Get the APIs of the modules that this one is dependent on. */
    sipModuleAPI_QtTest_QtCore = sipModuleAPI_QtTest.em_imports[0].im_module;
    sipModuleAPI_QtTest_QtGui = sipModuleAPI_QtTest.em_imports[1].im_module;
    sipModuleAPI_QtTest_QtWidgets = sipModuleAPI_QtTest.em_imports[2].im_module;
#line 98 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
// Imports from QtCore.
pyqt5_qttest_get_pyqtsignal_parts = (pyqt5_qttest_get_pyqtsignal_parts_t)sipImportSymbol("pyqt5_get_pyqtsignal_parts");
#line 394 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

    SIP_MODULE_RETURN(sipModule);
}

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestcase.sip"
#include <qtestcase.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestkeyboard.sip"
#include <qtestkeyboard.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestmouse.sip"
#include <qtestmouse.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestsystem.sip"
#include <qtestsystem.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtesttouch.sip"
#include <qtesttouch.h>
#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtesttouch.sip"
#include <qtesttouch.h>
#line 411 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

#line 32 "sip/QtWidgets/qwidget.sip"
#include <qwidget.h>
#line 415 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtGui/qtouchdevice.sip"
#include <qtouchdevice.h>
#line 418 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 26 "sip/QtGui/qwindow.sip"
#include <qwindow.h>
#line 421 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 424 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"


PyDoc_STRVAR(doc_QTest_QTouchEventSequence_press, "QTest.QTouchEventSequence.press(int, QPoint, QWindow window=None) -> QTest.QTouchEventSequence\n"
    "QTest.QTouchEventSequence.press(int, QPoint, QWidget) -> QTest.QTouchEventSequence");

extern "C" {static PyObject *meth_QTest_QTouchEventSequence_press(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_QTouchEventSequence_press(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QPoint* a1;
        QWindow* a2 = 0;
        QTest::QTouchEventSequence *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_window,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiJ9|J8", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0, sipType_QPoint, &a1, sipType_QWindow, &a2))
        {
            QTest::QTouchEventSequence*sipRes;

            sipRes = &sipCpp->press(a0,*a1,a2);

            return sipConvertFromType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    {
        int a0;
        const QPoint* a1;
        QWidget* a2;
        QTest::QTouchEventSequence *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiJ9J8", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0, sipType_QPoint, &a1, sipType_QWidget, &a2))
        {
            QTest::QTouchEventSequence*sipRes;

            sipRes = &sipCpp->press(a0,*a1,a2);

            return sipConvertFromType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QTouchEventSequence, sipName_press, doc_QTest_QTouchEventSequence_press);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_QTouchEventSequence_move, "QTest.QTouchEventSequence.move(int, QPoint, QWindow window=None) -> QTest.QTouchEventSequence\n"
    "QTest.QTouchEventSequence.move(int, QPoint, QWidget) -> QTest.QTouchEventSequence");

extern "C" {static PyObject *meth_QTest_QTouchEventSequence_move(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_QTouchEventSequence_move(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QPoint* a1;
        QWindow* a2 = 0;
        QTest::QTouchEventSequence *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_window,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiJ9|J8", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0, sipType_QPoint, &a1, sipType_QWindow, &a2))
        {
            QTest::QTouchEventSequence*sipRes;

            sipRes = &sipCpp->move(a0,*a1,a2);

            return sipConvertFromType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    {
        int a0;
        const QPoint* a1;
        QWidget* a2;
        QTest::QTouchEventSequence *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiJ9J8", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0, sipType_QPoint, &a1, sipType_QWidget, &a2))
        {
            QTest::QTouchEventSequence*sipRes;

            sipRes = &sipCpp->move(a0,*a1,a2);

            return sipConvertFromType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QTouchEventSequence, sipName_move, doc_QTest_QTouchEventSequence_move);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_QTouchEventSequence_release, "QTest.QTouchEventSequence.release(int, QPoint, QWindow window=None) -> QTest.QTouchEventSequence\n"
    "QTest.QTouchEventSequence.release(int, QPoint, QWidget) -> QTest.QTouchEventSequence");

extern "C" {static PyObject *meth_QTest_QTouchEventSequence_release(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_QTouchEventSequence_release(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QPoint* a1;
        QWindow* a2 = 0;
        QTest::QTouchEventSequence *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_window,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiJ9|J8", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0, sipType_QPoint, &a1, sipType_QWindow, &a2))
        {
            QTest::QTouchEventSequence*sipRes;

            sipRes = &sipCpp->release(a0,*a1,a2);

            return sipConvertFromType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    {
        int a0;
        const QPoint* a1;
        QWidget* a2;
        QTest::QTouchEventSequence *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiJ9J8", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0, sipType_QPoint, &a1, sipType_QWidget, &a2))
        {
            QTest::QTouchEventSequence*sipRes;

            sipRes = &sipCpp->release(a0,*a1,a2);

            return sipConvertFromType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QTouchEventSequence, sipName_release, doc_QTest_QTouchEventSequence_release);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_QTouchEventSequence_stationary, "QTest.QTouchEventSequence.stationary(int) -> QTest.QTouchEventSequence");

extern "C" {static PyObject *meth_QTest_QTouchEventSequence_stationary(PyObject *, PyObject *);}
static PyObject *meth_QTest_QTouchEventSequence_stationary(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QTest::QTouchEventSequence *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0))
        {
            QTest::QTouchEventSequence*sipRes;

            sipRes = &sipCpp->stationary(a0);

            return sipConvertFromType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QTouchEventSequence, sipName_stationary, doc_QTest_QTouchEventSequence_stationary);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_QTouchEventSequence_commit, "QTest.QTouchEventSequence.commit(bool processEvents=True)");

extern "C" {static PyObject *meth_QTest_QTouchEventSequence_commit(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_QTouchEventSequence_commit(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0 = 1;
        QTest::QTouchEventSequence *sipCpp;

        static const char *sipKwdList[] = {
            sipName_processEvents,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|b", &sipSelf, sipType_QTest_QTouchEventSequence, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->commit(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QTouchEventSequence, sipName_commit, doc_QTest_QTouchEventSequence_commit);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QTest_QTouchEventSequence(void *, const sipTypeDef *);}
static void *cast_QTest_QTouchEventSequence(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QTest_QTouchEventSequence)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QTest_QTouchEventSequence(void *, int);}
static void release_QTest_QTouchEventSequence(void *sipCppV,int)
{
    delete reinterpret_cast<QTest::QTouchEventSequence *>(sipCppV);
}


extern "C" {static void dealloc_QTest_QTouchEventSequence(sipSimpleWrapper *);}
static void dealloc_QTest_QTouchEventSequence(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QTest_QTouchEventSequence(sipGetAddress(sipSelf),0);
    }
}


static PyMethodDef methods_QTest_QTouchEventSequence[] = {
    {SIP_MLNAME_CAST(sipName_commit), (PyCFunction)meth_QTest_QTouchEventSequence_commit, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_QTouchEventSequence_commit)},
    {SIP_MLNAME_CAST(sipName_move), (PyCFunction)meth_QTest_QTouchEventSequence_move, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_QTouchEventSequence_move)},
    {SIP_MLNAME_CAST(sipName_press), (PyCFunction)meth_QTest_QTouchEventSequence_press, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_QTouchEventSequence_press)},
    {SIP_MLNAME_CAST(sipName_release), (PyCFunction)meth_QTest_QTouchEventSequence_release, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_QTouchEventSequence_release)},
    {SIP_MLNAME_CAST(sipName_stationary), meth_QTest_QTouchEventSequence_stationary, METH_VARARGS, SIP_MLDOC_CAST(doc_QTest_QTouchEventSequence_stationary)}
};


pyqt5ClassTypeDef sipTypeDef_QtTest_QTest_QTouchEventSequence = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QTest__QTouchEventSequence,
        {0}
    },
    {
        sipNameNr_QTouchEventSequence,
        {1, 255, 0},
        5, methods_QTest_QTouchEventSequence,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    sipNameNr_PyQt5_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QTest_QTouchEventSequence,
    0,
    0,
    0,
    release_QTest_QTouchEventSequence,
    cast_QTest_QTouchEventSequence,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestcase.sip"
#include <qtestcase.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestkeyboard.sip"
#include <qtestkeyboard.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestmouse.sip"
#include <qtestmouse.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestsystem.sip"
#include <qtestsystem.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtesttouch.sip"
#include <qtesttouch.h>
#line 749 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

#line 32 "sip/QtWidgets/qwidget.sip"
#include <qwidget.h>
#line 753 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 756 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 759 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 762 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 26 "sip/QtGui/qwindow.sip"
#include <qwindow.h>
#line 765 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 768 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestcase.sip"
#include <qtestcase.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestkeyboard.sip"
#include <qtestkeyboard.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestmouse.sip"
#include <qtestmouse.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtestsystem.sip"
#include <qtestsystem.h>
#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtesttouch.sip"
#include <qtesttouch.h>
#line 32 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtesttouch.sip"
#include <qtesttouch.h>
#line 781 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtGui/qtouchdevice.sip"
#include <qtouchdevice.h>
#line 784 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"


PyDoc_STRVAR(doc_QTest_touchEvent, "QTest.touchEvent(QWidget, QTouchDevice) -> QTest.QTouchEventSequence\n"
    "QTest.touchEvent(QWindow, QTouchDevice) -> QTest.QTouchEventSequence");

extern "C" {static PyObject *meth_QTest_touchEvent(PyObject *, PyObject *);}
static PyObject *meth_QTest_touchEvent(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        QTouchDevice* a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J8", sipType_QWidget, &a0, sipType_QTouchDevice, &a1))
        {
            QTest::QTouchEventSequence*sipRes = 0;

#line 53 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtesttouch.sip"
        // Disable auto-committing so that we can copy the instance around.
        sipRes = new QTest::QTouchEventSequence(QTest::touchEvent(a0, a1, false));
#line 806 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            return sipConvertFromNewType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    {
        QWindow* a0;
        QTouchDevice* a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J8", sipType_QWindow, &a0, sipType_QTouchDevice, &a1))
        {
            QTest::QTouchEventSequence*sipRes = 0;

#line 59 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qtesttouch.sip"
        // Disable auto-committing so that we can copy the instance around.
        sipRes = new QTest::QTouchEventSequence(QTest::touchEvent(a0, a1, false));
#line 823 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            return sipConvertFromNewType(sipRes,sipType_QTest_QTouchEventSequence,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_touchEvent, doc_QTest_touchEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_qWaitForWindowExposed, "QTest.qWaitForWindowExposed(QWindow, int timeout=5000) -> bool\n"
    "QTest.qWaitForWindowExposed(QWidget, int timeout=1000) -> bool");

extern "C" {static PyObject *meth_QTest_qWaitForWindowExposed(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_qWaitForWindowExposed(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWindow* a0;
        int a1 = 5000;

        static const char *sipKwdList[] = {
            NULL,
            sipName_timeout,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8|i", sipType_QWindow, &a0, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = QTest::qWaitForWindowExposed(a0,a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        QWidget* a0;
        int a1 = 1000;

        static const char *sipKwdList[] = {
            NULL,
            sipName_timeout,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8|i", sipType_QWidget, &a0, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = QTest::qWaitForWindowExposed(a0,a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_qWaitForWindowExposed, doc_QTest_qWaitForWindowExposed);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_qWaitForWindowActive, "QTest.qWaitForWindowActive(QWindow, int timeout=5000) -> bool\n"
    "QTest.qWaitForWindowActive(QWidget, int timeout=1000) -> bool");

extern "C" {static PyObject *meth_QTest_qWaitForWindowActive(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_qWaitForWindowActive(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWindow* a0;
        int a1 = 5000;

        static const char *sipKwdList[] = {
            NULL,
            sipName_timeout,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8|i", sipType_QWindow, &a0, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = QTest::qWaitForWindowActive(a0,a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        QWidget* a0;
        int a1 = 1000;

        static const char *sipKwdList[] = {
            NULL,
            sipName_timeout,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8|i", sipType_QWidget, &a0, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = QTest::qWaitForWindowActive(a0,a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_qWaitForWindowActive, doc_QTest_qWaitForWindowActive);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_qWait, "QTest.qWait(int)");

extern "C" {static PyObject *meth_QTest_qWait(PyObject *, PyObject *);}
static PyObject *meth_QTest_qWait(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            QTest::qWait(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_qWait, doc_QTest_qWait);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_waitForEvents, "QTest.waitForEvents()");

extern "C" {static PyObject *meth_QTest_waitForEvents(PyObject *, PyObject *);}
static PyObject *meth_QTest_waitForEvents(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            QTest::waitForEvents();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_waitForEvents, doc_QTest_waitForEvents);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_mouseEvent, "QTest.mouseEvent(QTest.MouseAction, QWidget, Qt.MouseButton, Qt.KeyboardModifiers, QPoint, int delay=-1)\n"
    "QTest.mouseEvent(QTest.MouseAction, QWindow, Qt.MouseButton, Qt.KeyboardModifiers, QPoint, int delay=-1)");

extern "C" {static PyObject *meth_QTest_mouseEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_mouseEvent(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QTest::MouseAction a0;
        QWidget* a1;
        Qt::MouseButton a2;
        Qt::KeyboardModifiers* a3;
        int a3State = 0;
        QPoint* a4;
        int a5 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "EJ8EJ1J9|i", sipType_QTest_MouseAction, &a0, sipType_QWidget, &a1, sipType_Qt_MouseButton, &a2, sipType_Qt_KeyboardModifiers, &a3, &a3State, sipType_QPoint, &a4, &a5))
        {
            QTest::mouseEvent(a0,a1,a2,*a3,*a4,a5);
            sipReleaseType(a3,sipType_Qt_KeyboardModifiers,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QTest::MouseAction a0;
        QWindow* a1;
        Qt::MouseButton a2;
        Qt::KeyboardModifiers* a3;
        int a3State = 0;
        QPoint* a4;
        int a5 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            NULL,
            NULL,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "EJ8EJ1J9|i", sipType_QTest_MouseAction, &a0, sipType_QWindow, &a1, sipType_Qt_MouseButton, &a2, sipType_Qt_KeyboardModifiers, &a3, &a3State, sipType_QPoint, &a4, &a5))
        {
            QTest::mouseEvent(a0,a1,a2,*a3,*a4,a5);
            sipReleaseType(a3,sipType_Qt_KeyboardModifiers,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_mouseEvent, doc_QTest_mouseEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_mouseRelease, "QTest.mouseRelease(QWidget, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)\n"
    "QTest.mouseRelease(QWindow, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)");

extern "C" {static PyObject *meth_QTest_mouseRelease(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_mouseRelease(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWidget, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mouseRelease(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWindow, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mouseRelease(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_mouseRelease, doc_QTest_mouseRelease);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_mousePress, "QTest.mousePress(QWidget, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)\n"
    "QTest.mousePress(QWindow, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)");

extern "C" {static PyObject *meth_QTest_mousePress(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_mousePress(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWidget, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mousePress(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWindow, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mousePress(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_mousePress, doc_QTest_mousePress);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_mouseMove, "QTest.mouseMove(QWidget, QPoint pos=QPoint(), int delay=-1)\n"
    "QTest.mouseMove(QWindow, QPoint pos=QPoint(), int delay=-1)");

extern "C" {static PyObject *meth_QTest_mouseMove(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_mouseMove(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        QPoint a1def = QPoint();
        QPoint* a1 = &a1def;
        int a2 = -1;

        static const char *sipKwdList[] = {
            NULL,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8|J9i", sipType_QWidget, &a0, sipType_QPoint, &a1, &a2))
        {
            QTest::mouseMove(a0,*a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        QPoint a1def = QPoint();
        QPoint* a1 = &a1def;
        int a2 = -1;

        static const char *sipKwdList[] = {
            NULL,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8|J9i", sipType_QWindow, &a0, sipType_QPoint, &a1, &a2))
        {
            QTest::mouseMove(a0,*a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_mouseMove, doc_QTest_mouseMove);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_mouseDClick, "QTest.mouseDClick(QWidget, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)\n"
    "QTest.mouseDClick(QWindow, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)");

extern "C" {static PyObject *meth_QTest_mouseDClick(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_mouseDClick(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWidget, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mouseDClick(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWindow, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mouseDClick(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_mouseDClick, doc_QTest_mouseDClick);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_mouseClick, "QTest.mouseClick(QWidget, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)\n"
    "QTest.mouseClick(QWindow, Qt.MouseButton, Qt.KeyboardModifiers modifier=0, QPoint pos=QPoint(), int delay=-1)");

extern "C" {static PyObject *meth_QTest_mouseClick(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_mouseClick(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWidget, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mouseClick(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        Qt::MouseButton a1;
        Qt::KeyboardModifiers a2def = 0;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        QPoint a3def = QPoint();
        QPoint* a3 = &a3def;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_pos,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1J9i", sipType_QWindow, &a0, sipType_Qt_MouseButton, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, sipType_QPoint, &a3, &a4))
        {
            QTest::mouseClick(a0,a1,*a2,*a3,a4);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_mouseClick, doc_QTest_mouseClick);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_keyRelease, "QTest.keyRelease(QWidget, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyRelease(QWidget, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyRelease(QWindow, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyRelease(QWindow, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)");

extern "C" {static PyObject *meth_QTest_keyRelease(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_keyRelease(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        Qt::Key a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1i", sipType_QWidget, &a0, sipType_Qt_Key, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyRelease(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWidget* a0;
        char a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8c|J1i", sipType_QWidget, &a0, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyRelease(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        char a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8c|J1i", sipType_QWindow, &a0, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyRelease(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        Qt::Key a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1i", sipType_QWindow, &a0, sipType_Qt_Key, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyRelease(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_keyRelease, doc_QTest_keyRelease);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_keyPress, "QTest.keyPress(QWidget, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyPress(QWidget, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyPress(QWindow, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyPress(QWindow, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)");

extern "C" {static PyObject *meth_QTest_keyPress(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_keyPress(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        Qt::Key a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1i", sipType_QWidget, &a0, sipType_Qt_Key, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyPress(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWidget* a0;
        char a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8c|J1i", sipType_QWidget, &a0, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyPress(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        char a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8c|J1i", sipType_QWindow, &a0, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyPress(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        Qt::Key a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1i", sipType_QWindow, &a0, sipType_Qt_Key, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyPress(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_keyPress, doc_QTest_keyPress);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_keyEvent, "QTest.keyEvent(QTest.KeyAction, QWidget, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyEvent(QTest.KeyAction, QWidget, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyEvent(QTest.KeyAction, QWindow, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyEvent(QTest.KeyAction, QWindow, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)");

extern "C" {static PyObject *meth_QTest_keyEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_keyEvent(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QTest::KeyAction a0;
        QWidget* a1;
        Qt::Key a2;
        Qt::KeyboardModifiers a3def = Qt::NoModifier;
        Qt::KeyboardModifiers* a3 = &a3def;
        int a3State = 0;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "EJ8E|J1i", sipType_QTest_KeyAction, &a0, sipType_QWidget, &a1, sipType_Qt_Key, &a2, sipType_Qt_KeyboardModifiers, &a3, &a3State, &a4))
        {
            QTest::keyEvent(a0,a1,a2,*a3,a4);
            sipReleaseType(a3,sipType_Qt_KeyboardModifiers,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QTest::KeyAction a0;
        QWidget* a1;
        char a2;
        Qt::KeyboardModifiers a3def = Qt::NoModifier;
        Qt::KeyboardModifiers* a3 = &a3def;
        int a3State = 0;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "EJ8c|J1i", sipType_QTest_KeyAction, &a0, sipType_QWidget, &a1, &a2, sipType_Qt_KeyboardModifiers, &a3, &a3State, &a4))
        {
            QTest::keyEvent(a0,a1,a2,*a3,a4);
            sipReleaseType(a3,sipType_Qt_KeyboardModifiers,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QTest::KeyAction a0;
        QWindow* a1;
        char a2;
        Qt::KeyboardModifiers a3def = Qt::NoModifier;
        Qt::KeyboardModifiers* a3 = &a3def;
        int a3State = 0;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "EJ8c|J1i", sipType_QTest_KeyAction, &a0, sipType_QWindow, &a1, &a2, sipType_Qt_KeyboardModifiers, &a3, &a3State, &a4))
        {
            QTest::keyEvent(a0,a1,a2,*a3,a4);
            sipReleaseType(a3,sipType_Qt_KeyboardModifiers,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QTest::KeyAction a0;
        QWindow* a1;
        Qt::Key a2;
        Qt::KeyboardModifiers a3def = Qt::NoModifier;
        Qt::KeyboardModifiers* a3 = &a3def;
        int a3State = 0;
        int a4 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "EJ8E|J1i", sipType_QTest_KeyAction, &a0, sipType_QWindow, &a1, sipType_Qt_Key, &a2, sipType_Qt_KeyboardModifiers, &a3, &a3State, &a4))
        {
            QTest::keyEvent(a0,a1,a2,*a3,a4);
            sipReleaseType(a3,sipType_Qt_KeyboardModifiers,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_keyEvent, doc_QTest_keyEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_keyClicks, "QTest.keyClicks(QWidget, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)");

extern "C" {static PyObject *meth_QTest_keyClicks(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_keyClicks(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        const QString* a1;
        int a1State = 0;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8J1|J1i", sipType_QWidget, &a0, sipType_QString,&a1, &a1State, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyClicks(a0,*a1,*a2,a3);
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_keyClicks, doc_QTest_keyClicks);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_keyClick, "QTest.keyClick(QWidget, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyClick(QWidget, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyClick(QWindow, Qt.Key, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)\n"
    "QTest.keyClick(QWindow, str, Qt.KeyboardModifiers modifier=Qt.NoModifier, int delay=-1)");

extern "C" {static PyObject *meth_QTest_keyClick(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QTest_keyClick(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QWidget* a0;
        Qt::Key a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1i", sipType_QWidget, &a0, sipType_Qt_Key, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyClick(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWidget* a0;
        char a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8c|J1i", sipType_QWidget, &a0, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyClick(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        Qt::Key a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8E|J1i", sipType_QWindow, &a0, sipType_Qt_Key, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyClick(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        QWindow* a0;
        char a1;
        Qt::KeyboardModifiers a2def = Qt::NoModifier;
        Qt::KeyboardModifiers* a2 = &a2def;
        int a2State = 0;
        int a3 = -1;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_modifier,
            sipName_delay,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8c|J1i", sipType_QWindow, &a0, &a1, sipType_Qt_KeyboardModifiers, &a2, &a2State, &a3))
        {
            QTest::keyClick(a0,a1,*a2,a3);
            sipReleaseType(a2,sipType_Qt_KeyboardModifiers,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_keyClick, doc_QTest_keyClick);

    return NULL;
}


PyDoc_STRVAR(doc_QTest_qSleep, "QTest.qSleep(int)");

extern "C" {static PyObject *meth_QTest_qSleep(PyObject *, PyObject *);}
static PyObject *meth_QTest_qSleep(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            QTest::qSleep(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_qSleep, doc_QTest_qSleep);

    return NULL;
}


static PyMethodDef methods_QTest[] = {
    {SIP_MLNAME_CAST(sipName_keyClick), (PyCFunction)meth_QTest_keyClick, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_keyClick)},
    {SIP_MLNAME_CAST(sipName_keyClicks), (PyCFunction)meth_QTest_keyClicks, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_keyClicks)},
    {SIP_MLNAME_CAST(sipName_keyEvent), (PyCFunction)meth_QTest_keyEvent, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_keyEvent)},
    {SIP_MLNAME_CAST(sipName_keyPress), (PyCFunction)meth_QTest_keyPress, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_keyPress)},
    {SIP_MLNAME_CAST(sipName_keyRelease), (PyCFunction)meth_QTest_keyRelease, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_keyRelease)},
    {SIP_MLNAME_CAST(sipName_mouseClick), (PyCFunction)meth_QTest_mouseClick, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_mouseClick)},
    {SIP_MLNAME_CAST(sipName_mouseDClick), (PyCFunction)meth_QTest_mouseDClick, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_mouseDClick)},
    {SIP_MLNAME_CAST(sipName_mouseEvent), (PyCFunction)meth_QTest_mouseEvent, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_mouseEvent)},
    {SIP_MLNAME_CAST(sipName_mouseMove), (PyCFunction)meth_QTest_mouseMove, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_mouseMove)},
    {SIP_MLNAME_CAST(sipName_mousePress), (PyCFunction)meth_QTest_mousePress, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_mousePress)},
    {SIP_MLNAME_CAST(sipName_mouseRelease), (PyCFunction)meth_QTest_mouseRelease, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_mouseRelease)},
    {SIP_MLNAME_CAST(sipName_qSleep), meth_QTest_qSleep, METH_VARARGS, SIP_MLDOC_CAST(doc_QTest_qSleep)},
    {SIP_MLNAME_CAST(sipName_qWait), meth_QTest_qWait, METH_VARARGS, SIP_MLDOC_CAST(doc_QTest_qWait)},
    {SIP_MLNAME_CAST(sipName_qWaitForWindowActive), (PyCFunction)meth_QTest_qWaitForWindowActive, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_qWaitForWindowActive)},
    {SIP_MLNAME_CAST(sipName_qWaitForWindowExposed), (PyCFunction)meth_QTest_qWaitForWindowExposed, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QTest_qWaitForWindowExposed)},
    {SIP_MLNAME_CAST(sipName_touchEvent), meth_QTest_touchEvent, METH_VARARGS, SIP_MLDOC_CAST(doc_QTest_touchEvent)},
    {SIP_MLNAME_CAST(sipName_waitForEvents), meth_QTest_waitForEvents, METH_VARARGS, SIP_MLDOC_CAST(doc_QTest_waitForEvents)}
};

static sipEnumMemberDef enummembers_QTest[] = {
    {sipName_Click, static_cast<int>(QTest::Click), 2},
    {sipName_MouseClick, static_cast<int>(QTest::MouseClick), 3},
    {sipName_MouseDClick, static_cast<int>(QTest::MouseDClick), 3},
    {sipName_MouseMove, static_cast<int>(QTest::MouseMove), 3},
    {sipName_MousePress, static_cast<int>(QTest::MousePress), 3},
    {sipName_MouseRelease, static_cast<int>(QTest::MouseRelease), 3},
    {sipName_Press, static_cast<int>(QTest::Press), 2},
    {sipName_Release, static_cast<int>(QTest::Release), 2},
};


pyqt5ClassTypeDef sipTypeDef_QtTest_QTest = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_NAMESPACE,
        sipNameNr_QTest,
        {0}
    },
    {
        sipNameNr_QTest,
        {0, 0, 1},
        17, methods_QTest,
        8, enummembers_QTest,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
#include <qsignalspy.h>
#line 2049 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2053 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 2056 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 32 "sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 2059 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qmetaobject.sip"
#include <qmetaobject.h>
#line 2062 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 26 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2065 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 241 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2068 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 229 "sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 2071 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 28 "sip/QtCore/qobject.sip"
#include <qobject.h>
#line 2074 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 27 "sip/QtCore/qstring.sip"
#include <qstring.h>
#line 2077 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 36 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2080 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 144 "sip/QtCore/qpycore_qlist.sip"
#include <qlist.h>
#line 2083 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2086 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 26 "sip/QtCore/qthread.sip"
#include <qthread.h>
#line 2089 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 2092 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 2095 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 30 "sip/QtCore/qregularexpression.sip"
#include <qregularexpression.h>
#line 2098 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
#line 26 "sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 2101 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"


class sipQSignalSpy : public QSignalSpy
{
public:
    sipQSignalSpy(const QObject*,const char*);
    virtual ~sipQSignalSpy();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const QMetaMethod&);
    void sipProtectVirt_disconnectNotify(bool,const QMetaMethod&);
    int sipProtect_senderSignalIndex() const;
    bool sipProtect_isSignalConnected(const QMetaMethod&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const QMetaMethod&);
    void connectNotify(const QMetaMethod&);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSignalSpy(const sipQSignalSpy &);
    sipQSignalSpy &operator = (const sipQSignalSpy &);

    char sipPyMethods[7];
};

sipQSignalSpy::sipQSignalSpy(const QObject*a0,const char*a1): QSignalSpy(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSignalSpy::~sipQSignalSpy()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQSignalSpy::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : sip_QtTest_qt_metaobject(sipPySelf,sipType_QSignalSpy);
}

int sipQSignalSpy::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QSignalSpy::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtTest_qt_metacall(sipPySelf,sipType_QSignalSpy,_c,_id,_a);

    return _id;
}

void *sipQSignalSpy::qt_metacast(const char *_clname)
{
    void *sipCpp;

    return (sip_QtTest_qt_metacast(sipPySelf, sipType_QSignalSpy, _clname, &sipCpp) ? sipCpp : QSignalSpy::qt_metacast(_clname));
}

void sipQSignalSpy::disconnectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QSignalSpy::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtTest_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtTest_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQSignalSpy::connectNotify(const QMetaMethod& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QSignalSpy::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMetaMethod&);

    ((sipVH_QtCore_46)(sipModuleAPI_QtTest_QtCore->em_virthandlers[46]))(sipGILState, sipModuleAPI_QtTest_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQSignalSpy::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QSignalSpy::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtTest_QtCore->em_virthandlers[25]))(sipGILState, sipModuleAPI_QtTest_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQSignalSpy::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QSignalSpy::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_47)(sipModuleAPI_QtTest_QtCore->em_virthandlers[47]))(sipGILState, sipModuleAPI_QtTest_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

void sipQSignalSpy::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QSignalSpy::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtTest_QtCore->em_virthandlers[9]))(sipGILState, sipModuleAPI_QtTest_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

bool sipQSignalSpy::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QSignalSpy::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_26)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_26)(sipModuleAPI_QtTest_QtCore->em_virthandlers[26]))(sipGILState, sipModuleAPI_QtTest_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0, a1);
}

bool sipQSignalSpy::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QSignalSpy::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtTest_QtCore->em_virthandlers[5]))(sipGILState, sipModuleAPI_QtTest_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth, a0);
}

QObject* sipQSignalSpy::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQSignalSpy::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQSignalSpy::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQSignalSpy::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQSignalSpy::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQSignalSpy::sipProtectVirt_connectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQSignalSpy::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const QMetaMethod& a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQSignalSpy::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

bool sipQSignalSpy::sipProtect_isSignalConnected(const QMetaMethod& a0) const
{
    return QObject::isSignalConnected(a0);
}


PyDoc_STRVAR(doc_QSignalSpy_sender, "QSignalSpy.sender() -> QObject");

extern "C" {static PyObject *meth_QSignalSpy_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSignalSpy, &sipCpp))
        {
            QObject*sipRes = 0;

#line 546 "sip/QtCore/qobject.sip"
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (!sipRes)
        {
            typedef QObject *(*qtcore_qobject_sender_t)();
        
            static qtcore_qobject_sender_t qtcore_qobject_sender = 0;
        
            if (!qtcore_qobject_sender)
                qtcore_qobject_sender = (qtcore_qobject_sender_t)sipImportSymbol("qtcore_qobject_sender");
        
            if (qtcore_qobject_sender)
                sipRes = qtcore_qobject_sender();
        }
#line 2389 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_sender, doc_QSignalSpy_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_receivers, "QSignalSpy.receivers(signal) -> int");

extern "C" {static PyObject *meth_QSignalSpy_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QSignalSpy, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 575 "sip/QtCore/qobject.sip"
        // We need to handle the signal object.  Import the helper if it hasn't already
        // been done.
        typedef sipErrorState (*pyqt5_get_signal_signature_t)(PyObject *, const QObject *, const QByteArray &);
        
        static pyqt5_get_signal_signature_t pyqt5_get_signal_signature = 0;
        
        if (!pyqt5_get_signal_signature)
            pyqt5_get_signal_signature = (pyqt5_get_signal_signature_t)sipImportSymbol("pyqt5_get_signal_signature");
        
        if (pyqt5_get_signal_signature)
        {
            QByteArray signal_signature;
            
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            if ((sipError = pyqt5_get_signal_signature(a0, sipCpp, signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->receivers(signal_signature.constData());
            }
        #else
            if ((sipError = pyqt5_get_signal_signature(a0, static_cast<const QObject *>(sipCpp), signal_signature)) == sipErrorNone)
            {
                sipRes = sipCpp->sipProtect_receivers(signal_signature.constData());
            }
        #endif
            else if (sipError == sipErrorContinue)
            {
                sipError = sipBadCallableArg(0, a0);
            }
        }
#line 2448 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_receivers, doc_QSignalSpy_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_timerEvent, "QSignalSpy.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QSignalSpy_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSignalSpy, &sipCpp, sipType_QTimerEvent, &a0))
        {
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_timerEvent, doc_QSignalSpy_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_childEvent, "QSignalSpy.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QSignalSpy_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSignalSpy, &sipCpp, sipType_QChildEvent, &a0))
        {
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_childEvent, doc_QSignalSpy_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_customEvent, "QSignalSpy.customEvent(QEvent)");

extern "C" {static PyObject *meth_QSignalSpy_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSignalSpy, &sipCpp, sipType_QEvent, &a0))
        {
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_customEvent, doc_QSignalSpy_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_connectNotify, "QSignalSpy.connectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_QSignalSpy_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSignalSpy, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_connectNotify, doc_QSignalSpy_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_disconnectNotify, "QSignalSpy.disconnectNotify(QMetaMethod)");

extern "C" {static PyObject *meth_QSignalSpy_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QMetaMethod* a0;
        sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSignalSpy, &sipCpp, sipType_QMetaMethod, &a0))
        {
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,*a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_disconnectNotify, doc_QSignalSpy_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_senderSignalIndex, "QSignalSpy.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QSignalSpy_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSignalSpy, &sipCpp))
        {
            int sipRes;

            sipRes = sipCpp->sipProtect_senderSignalIndex();

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_senderSignalIndex, doc_QSignalSpy_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_isSignalConnected, "QSignalSpy.isSignalConnected(QMetaMethod) -> bool");

extern "C" {static PyObject *meth_QSignalSpy_isSignalConnected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_isSignalConnected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QMetaMethod* a0;
        const sipQSignalSpy *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSignalSpy, &sipCpp, sipType_QMetaMethod, &a0))
        {
            bool sipRes;

            sipRes = sipCpp->sipProtect_isSignalConnected(*a0);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_isSignalConnected, doc_QSignalSpy_isSignalConnected);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_isValid, "QSignalSpy.isValid() -> bool");

extern "C" {static PyObject *meth_QSignalSpy_isValid(PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSignalSpy *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSignalSpy, &sipCpp))
        {
            bool sipRes;

            sipRes = sipCpp->isValid();

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_isValid, doc_QSignalSpy_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_signal, "QSignalSpy.signal() -> QByteArray");

extern "C" {static PyObject *meth_QSignalSpy_signal(PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_signal(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSignalSpy *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSignalSpy, &sipCpp))
        {
            QByteArray*sipRes;

            sipRes = new QByteArray(sipCpp->signal());

            return sipConvertFromNewType(sipRes,sipType_QByteArray,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_signal, doc_QSignalSpy_signal);

    return NULL;
}


PyDoc_STRVAR(doc_QSignalSpy_wait, "QSignalSpy.wait(int timeout=5000) -> bool");

extern "C" {static PyObject *meth_QSignalSpy_wait(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSignalSpy_wait(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0 = 5000;
        QSignalSpy *sipCpp;

        static const char *sipKwdList[] = {
            sipName_timeout,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|i", &sipSelf, sipType_QSignalSpy, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->wait(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName_wait, doc_QSignalSpy_wait);

    return NULL;
}


extern "C" {static int slot_QSignalSpy___delitem__(PyObject *,PyObject *);}
static int slot_QSignalSpy___delitem__(PyObject *sipSelf,PyObject *sipArg)
{
    QSignalSpy *sipCpp = reinterpret_cast<QSignalSpy *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSignalSpy));

    if (!sipCpp)
        return -1;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            int sipIsErr = 0;

#line 75 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
        int len;
        
        len = sipCpp->count();
        
        if ((a0 = (int)sipConvertFromSequenceIndex(a0, len)) < 0)
            sipIsErr = 1;
        else
            sipCpp->removeAt(a0);
#line 2778 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            if (sipIsErr)
                return -1;

            return 0;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName___delitem__, NULL);

    return -1;
}


extern "C" {static int slot_QSignalSpy___setitem__(PyObject *,PyObject *);}
static int slot_QSignalSpy___setitem__(PyObject *sipSelf,PyObject *sipArgs)
{
    QSignalSpy *sipCpp = reinterpret_cast<QSignalSpy *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSignalSpy));

    if (!sipCpp)
        return -1;

    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QList<QVariant>* a1;
        int a1State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "iJ1", &a0, sipType_QList_0100QVariant,&a1, &a1State))
        {
            int sipIsErr = 0;

#line 65 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
        int len = sipCpp->count();
        
        if ((a0 = (int)sipConvertFromSequenceIndex(a0, len)) < 0)
            sipIsErr = 1;
        else
            (*sipCpp)[a0] = *a1;
#line 2820 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"
            sipReleaseType(const_cast<QList<QVariant> *>(a1),sipType_QList_0100QVariant,a1State);

            if (sipIsErr)
                return -1;

            return 0;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName___setitem__, NULL);

    return -1;
}


extern "C" {static PyObject *slot_QSignalSpy___getitem__(PyObject *,PyObject *);}
static PyObject *slot_QSignalSpy___getitem__(PyObject *sipSelf,PyObject *sipArg)
{
    QSignalSpy *sipCpp = reinterpret_cast<QSignalSpy *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSignalSpy));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            QList<QVariant>*sipRes = 0;
            int sipIsErr = 0;

#line 55 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
        SIP_SSIZE_T idx = sipConvertFromSequenceIndex(a0, sipCpp->count());
        
        if (idx < 0)
            sipIsErr = 1;
        else
            sipRes = new QList<QVariant>(sipCpp->at((int)idx));
#line 2862 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            if (sipIsErr)
                return 0;

            return sipConvertFromNewType(sipRes,sipType_QList_0100QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSignalSpy, sipName___getitem__, NULL);

    return 0;
}


extern "C" {static SIP_SSIZE_T slot_QSignalSpy___len__(PyObject *);}
static SIP_SSIZE_T slot_QSignalSpy___len__(PyObject *sipSelf)
{
    QSignalSpy *sipCpp = reinterpret_cast<QSignalSpy *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSignalSpy));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes = 0;

#line 50 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
        sipRes = sipCpp->count();
#line 2893 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSignalSpy(void *, const sipTypeDef *);}
static void *cast_QSignalSpy(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSignalSpy)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QSignalSpy *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSignalSpy(void *, int);}
static void release_QSignalSpy(void *sipCppV,int)
{
    QSignalSpy *sipCpp = reinterpret_cast<QSignalSpy *>(sipCppV);

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();
}


extern "C" {static void dealloc_QSignalSpy(sipSimpleWrapper *);}
static void dealloc_QSignalSpy(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSignalSpy *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSignalSpy(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSignalSpy(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSignalSpy(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQSignalSpy *sipCpp = 0;

    {
        PyObject * a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "P0", &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 36 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/sip/QtTest/qsignalspy.sip"
        QObject *sender;
        QByteArray signal_signature;
        
        if ((sipError = pyqt5_qttest_get_pyqtsignal_parts(a0, &sender, signal_signature)) == sipErrorNone)
            sipCpp = new sipQSignalSpy(sender, signal_signature.constData());
        else if (sipError == sipErrorContinue)
            sipError = sipBadCallableArg(0, a0);
#line 2965 "/usr/src/ports/python-pyqt5/python-pyqt5-5.4.2-1.i686/build/QtTest/sipQtTestpart0.cpp"

            if (sipError == sipErrorNone)
            {
                sipCpp->sipPySelf = sipSelf;

                return sipCpp;
            }

            if (sipUnused)
            {
                Py_XDECREF(*sipUnused);
            }

            sipAddException(sipError, sipParseErr);

            if (sipError == sipErrorFail)
                return NULL;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSignalSpy[] = {{162, 0, 1}};


/* Define this type's Python slots. */
static sipPySlotDef slots_QSignalSpy[] = {
    {(void *)slot_QSignalSpy___delitem__, delitem_slot},
    {(void *)slot_QSignalSpy___setitem__, setitem_slot},
    {(void *)slot_QSignalSpy___getitem__, getitem_slot},
    {(void *)slot_QSignalSpy___len__, len_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QSignalSpy[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QSignalSpy_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QSignalSpy_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QSignalSpy_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QSignalSpy_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isSignalConnected), (PyCFunction)meth_QSignalSpy_isSignalConnected, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QSignalSpy_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QSignalSpy_isValid)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QSignalSpy_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QSignalSpy_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QSignalSpy_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_signal), meth_QSignalSpy_signal, METH_VARARGS, SIP_MLDOC_CAST(doc_QSignalSpy_signal)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QSignalSpy_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_wait), (PyCFunction)meth_QSignalSpy_wait, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSignalSpy_wait)}
};

PyDoc_STRVAR(doc_QSignalSpy, "\1QSignalSpy(signal)");


pyqt5ClassTypeDef sipTypeDef_QtTest_QSignalSpy = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QSignalSpy,
        {0}
    },
    {
        sipNameNr_QSignalSpy,
        {0, 0, 1},
        12, methods_QSignalSpy,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSignalSpy,
    -1,
    -1,
    supers_QSignalSpy,
    slots_QSignalSpy,
    init_type_QSignalSpy,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSignalSpy,
    0,
    0,
    0,
    release_QSignalSpy,
    cast_QSignalSpy,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QSignalSpy::staticMetaObject,
    0,
    0,
    0
};
