jyapayne/PySide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove wrapper for classes: QString, QStringRef, QLatin1String, QStringMatcher, QChar and QLatin1Char.

Browse source
This commit is contained in:
Hugo Parente Lima 2010-06-03 15:34:17 -03:00
commit e39bfefde9
32 changed files with 187 additions and 1189 deletions
Download patch file Download diff file Expand all files Collapse all files

7
PySide/QtCore/CMakeLists.txt
View file

@ -49,7 +49,6 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qbitarray_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qbuffer_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qbuffer_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qbytearray_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qbytearray_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qbytearraymatcher_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qbytearraymatcher_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qchar_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qchildevent_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qchildevent_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qcoreapplication_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qcoreapplication_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qcryptographichash_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qcryptographichash_wrapper.cpp
@ -69,8 +68,6 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qfsfileengine_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qgenericargument_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qgenericargument_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qgenericreturnargument_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qgenericreturnargument_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qiodevice_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qiodevice_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qlatin1char_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qlatin1string_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qlibraryinfo_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qlibraryinfo_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qline_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qline_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qlinef_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qlinef_wrapper.cpp
@ -101,10 +98,6 @@ ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsignalmapper_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsize_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsize_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsizef_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsizef_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsocketnotifier_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsocketnotifier_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qstring_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qstringlist_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qstringmatcher_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qstringref_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsysinfo_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsysinfo_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsystemlocale_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsystemlocale_wrapper.cpp
${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsystemsemaphore_wrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/PySide/QtCore/qsystemsemaphore_wrapper.cpp

43
PySide/QtCore/glue/qstring_bufferprotocol.cpp
View file

@ -1,43 +0,0 @@
#if PY_VERSION_HEX < 0x03000000
// QByteArray buffer protocol functions
// see: http://www.python.org/dev/peps/pep-3118/
extern "C" {
static Py_ssize_t SbkQString_segcountproc(PyObject* self, Py_ssize_t* lenp)
{
if (lenp)
*lenp = self->ob_type->tp_as_sequence->sq_length(self);
return 1;
}
static Py_ssize_t SbkQString_readbufferproc(PyObject* self, Py_ssize_t segment, char** ptrptr)
{
if (segment || Shiboken::cppObjectIsInvalid(self))
return -1;
QString* cppSelf = Converter<QString*>::toCpp(self);
QByteArray decodedData = cppSelf->toLocal8Bit();
Shiboken::AutoDecRef decodedString(PyString_FromStringAndSize(decodedData.constData(), decodedData.size()));
// delete __encodedStr attr if it exists
Shiboken::AutoDecRef attrName(PyString_FromStringAndSize("__encodedStr", sizeof("__encodedStr")-1));
if (PyObject_HasAttr(self, attrName))
PyObject_DelAttr(self, attrName);
PyObject_SetAttr(self, attrName, decodedString);
*ptrptr = PyString_AS_STRING(decodedString.object());
return decodedData.size();
}
PyBufferProcs SbkQStringBufferProc = {
/*bf_getreadbuffer*/ 0,
/*bf_getwritebuffer*/ 0,
/*bf_getsegcount*/ &SbkQString_segcountproc,
/*bf_getcharbuffer*/ &SbkQString_readbufferproc
};
}
#endif

6
PySide/QtCore/glue/qstring_hashfunc.cpp
View file

@ -1,6 +0,0 @@
static long QStringCustomHashFunction(const QString& str)
{
QByteArray data = str.toUtf8();
Shiboken::AutoDecRef unicodeObj(PyUnicode_DecodeUTF8(data.constData(), data.length(), 0));
return unicodeObj->ob_type->tp_hash(unicodeObj);
}

42
PySide/QtCore/qchar_conversions.h
View file

@ -1,30 +1,30 @@
namespace Shiboken { namespace Shiboken {
inline bool Shiboken::Converter<QChar >::isConvertible(PyObject* pyObj)
{
return PyObject_TypeCheck(pyObj, SbkType<QChar>())
|| SbkPySide_QtCore_QChar_SpecialCharacter_Check(pyObj)
|| SbkQLatin1Char_Check(pyObj)
|| (PyString_Check(pyObj) && (PyString_Size(pyObj) == 1))
|| PyInt_Check(pyObj);
}
inline QChar Shiboken::Converter<QChar >::toCpp(PyObject* pyObj) template<>
class Converter<QChar>
{ {
if (!Shiboken_TypeCheck(pyObj, QChar)) { public:
if (SbkPySide_QtCore_QChar_SpecialCharacter_Check(pyObj)) static bool isConvertible(PyObject* pyObj)
return QChar(Shiboken::Converter<QChar::SpecialCharacter >::toCpp(pyObj)); {
else if (SbkQLatin1Char_Check(pyObj)) return (PyString_Check(pyObj) && (PyString_Size(pyObj) == 1))
return QChar(Shiboken::Converter<QLatin1Char >::toCpp(pyObj)); || PyInt_Check(pyObj);
else if (PyString_Check(pyObj) && PyString_Size(pyObj) == 1) }
static QChar toCpp(PyObject* pyObj)
{
if (PyString_Check(pyObj) && PyString_Size(pyObj) == 1)
return QChar(Shiboken::Converter<char >::toCpp(pyObj)); return QChar(Shiboken::Converter<char >::toCpp(pyObj));
else if (PyInt_Check(pyObj)) else if (PyInt_Check(pyObj))
return QChar(Shiboken::Converter<int >::toCpp(pyObj)); return QChar(Shiboken::Converter<int >::toCpp(pyObj));
return QChar();
} }
return *Converter<QChar*>::toCpp(pyObj);
}
inline PyObject* Converter<QChar>::toPython(const QChar& cppObj) static PyObject* toPython(void* cppObj) { return toPython(*reinterpret_cast<QChar*>(cppObj)); }
{ static PyObject* toPython(const QChar& cppObj)
return ValueTypeConverter<QChar>::toPython(cppObj); {
} wchar_t c = (wchar_t)cppObj.unicode();
PyObject* pyObj = PyUnicode_FromWideChar(&c, 1);
return pyObj;
}
};
} }

128
PySide/QtCore/qstring_conversions.h
View file

@ -1,72 +1,70 @@
namespace Shiboken { namespace Shiboken {
inline bool Converter<QString>::isConvertible(PyObject* pyObj)
{
SbkBaseWrapperType* shiboType = reinterpret_cast<SbkBaseWrapperType*>(SbkType<QString>());
return PyString_Check(pyObj)
|| PyObject_TypeCheck(pyObj, SbkType<QString>())
|| PyUnicode_Check(pyObj)
|| SbkQByteArray_Check(pyObj)
|| SbkQLatin1String_Check(pyObj)
|| pyObj == Py_None
#if PY_VERSION_HEX < 0x03000000
|| (pyObj->ob_type->tp_as_buffer
&& PyType_HasFeature(pyObj->ob_type, Py_TPFLAGS_HAVE_GETCHARBUFFER)
&& pyObj->ob_type->tp_as_buffer->bf_getcharbuffer)
#endif
|| SbkQChar_Check(pyObj)
|| (shiboType->ext_isconvertible && shiboType->ext_isconvertible(pyObj));
}
inline QString Converter<QString>::toCpp(PyObject* pyObj) template<>
class Converter<QString>
{ {
SbkBaseWrapperType* shiboType = reinterpret_cast<SbkBaseWrapperType*>(SbkType<QString>()); public:
if (SbkQChar_Check(pyObj)) { static bool isConvertible(PyObject* pyObj)
return QString(Converter< QChar >::toCpp(pyObj)); {
} else if (SbkQByteArray_Check(pyObj)) { return PyString_Check(pyObj)
return QString(Converter< QByteArray >::toCpp(pyObj)); || PyUnicode_Check(pyObj)
} else if (SbkQLatin1String_Check(pyObj)) { || SbkQByteArray_Check(pyObj)
return QString(Converter< QLatin1String >::toCpp(pyObj)); || pyObj == Py_None
} else if (PyUnicode_Check(pyObj)) { #if PY_VERSION_HEX < 0x03000000
Py_UNICODE* unicode = PyUnicode_AS_UNICODE(pyObj); || (pyObj->ob_type->tp_as_buffer
#if defined(Py_UNICODE_WIDE) && PyType_HasFeature(pyObj->ob_type, Py_TPFLAGS_HAVE_GETCHARBUFFER)
// cast as Py_UNICODE can be a different type && pyObj->ob_type->tp_as_buffer->bf_getcharbuffer)
return QString::fromUcs4(reinterpret_cast<const uint*>(unicode)); #endif
#else ;
return QString::fromUtf16(unicode, PyUnicode_GET_SIZE(pyObj)); }
#endif
} else if (PyString_Check(pyObj)) { static QString toCpp(PyObject* pyObj)
return QString(Converter< char * >::toCpp(pyObj)); {
} else if (pyObj == Py_None) { if (PyUnicode_Check(pyObj)) {
Py_UNICODE* unicode = PyUnicode_AS_UNICODE(pyObj);
#if defined(Py_UNICODE_WIDE)
// cast as Py_UNICODE can be a different type
return QString::fromUcs4(reinterpret_cast<const uint*>(unicode));
#else
return QString::fromUtf16(unicode, PyUnicode_GET_SIZE(pyObj));
#endif
} else if (PyString_Check(pyObj)) {
return QString(Converter< char * >::toCpp(pyObj));
} else if (pyObj == Py_None) {
return QString();
} else if (SbkQByteArray_Check(pyObj)) {
return QString(Converter< QByteArray >::toCpp(pyObj));
}
#if PY_VERSION_HEX < 0x03000000
// Support for buffer objects on QString constructor
else if (pyObj->ob_type->tp_as_buffer
&& PyType_HasFeature(pyObj->ob_type, Py_TPFLAGS_HAVE_GETCHARBUFFER)
&& pyObj->ob_type->tp_as_buffer->bf_getcharbuffer) {
QByteArray data;
PyBufferProcs* bufferProcs = pyObj->ob_type->tp_as_buffer;
int segments = bufferProcs->bf_getsegcount(pyObj, 0);
for (int i = 0; i < segments; ++i) {
char* segmentData;
int length = bufferProcs->bf_getcharbuffer(pyObj, i, &segmentData);
if (length == -1)
break;
data.append(segmentData, length);
}
return QString(data);
}
#endif
return QString(); return QString();
} }
#if PY_VERSION_HEX < 0x03000000
// Support for buffer objects on QString constructor
else if (pyObj->ob_type->tp_as_buffer
&& PyType_HasFeature(pyObj->ob_type, Py_TPFLAGS_HAVE_GETCHARBUFFER)
&& pyObj->ob_type->tp_as_buffer->bf_getcharbuffer) {
QByteArray data;
PyBufferProcs* bufferProcs = pyObj->ob_type->tp_as_buffer;
int segments = bufferProcs->bf_getsegcount(pyObj, 0);
for (int i = 0; i < segments; ++i) {
char* segmentData;
int length = bufferProcs->bf_getcharbuffer(pyObj, i, &segmentData);
if (length == -1)
break;
data.append(segmentData, length);
}
return QString(data);
}
#endif
else if (shiboType->ext_isconvertible && shiboType->ext_tocpp && shiboType->ext_isconvertible(pyObj)) {
QString* cptr = reinterpret_cast<QString*>(shiboType->ext_tocpp(pyObj));
std::auto_ptr<QString> cptr_auto_ptr(cptr);
return *cptr;
}
return *Converter<QString*>::toCpp(pyObj);
}
inline PyObject* Converter<QString>::toPython(const QString& cppObj) static PyObject* toPython(void* cppObj) { return toPython(*reinterpret_cast<QString*>(cppObj)); }
{ static PyObject* toPython(const QString& cppObj)
return ValueTypeConverter<QString>::toPython(cppObj); {
} const int N = cppObj.length();
wchar_t* str = new wchar_t[N];
cppObj.toWCharArray(str);
PyObject* pyObj = PyUnicode_FromWideChar(str, N);
delete[] str;
return pyObj;
}
};
} }

16
PySide/QtCore/qstringlist_conversions.h
View file

@ -1,17 +1,5 @@
namespace Shiboken namespace Shiboken
{ {
inline bool Converter<QStringList>::isConvertible(PyObject* pyObj) template<>
{ struct Converter<QStringList> : StdListConverter<QStringList> {};
return StdListConverter<QStringList>::isConvertible(pyObj);
}
inline QStringList Converter<QStringList>::toCpp(PyObject* pyObj)
{
return StdListConverter<QStringList>::toCpp(pyObj);
}
inline PyObject* Converter<QStringList>::toPython(const QStringList& cppObj)
{
return ValueTypeConverter<QStringList>::toPython(cppObj);
}
} }

19
PySide/QtCore/qstringref_conversions.h Normal file
View file

@ -0,0 +1,19 @@
namespace Shiboken {
template<>
struct Converter<QStringRef> : public Converter<QString>
{
static PyObject* toPython(void* cppObj) { return toPython(*reinterpret_cast<QStringRef*>(cppObj)); }
static PyObject* toPython(const QStringRef& cppObj)
{
const QString* str = cppObj.string();
return Converter<QString>::toPython(*str);
}
static QStringRef toCpp(PyObject* pyObj)
{
return QStringRef();
}
};
}

371
PySide/QtCore/typesystem_core.xml
View file

@ -39,8 +39,15 @@
<rejection class="QFutureSynchronizer"/> <rejection class="QFutureSynchronizer"/>
<rejection class="QByteArray" function-name="contains"/> <rejection class="QByteArray" function-name="contains"/>
<rejection class="QRunnable"/> <rejection class="QRunnable"/>
<rejection class="QLatin1String" />
<rejection class="QLatin1Char" />
<rejection class="QStringMatcher" />
<rejection class="QSharedPointer"/> <rejection class="QSharedPointer"/>
<rejection class="QWeakPointer"/> <rejection class="QWeakPointer"/>
<rejection class="std::string"/>
<rejection class="std::wstring"/>
<rejection class="QStdWString"/>
<rejection class="QByteRef"/>
<rejection class="QChildEvent" field-name="c"/> <rejection class="QChildEvent" field-name="c"/>
<rejection class="QTimerEvent" field-name="id"/> <rejection class="QTimerEvent" field-name="id"/>
<rejection class="QEvent" field-name="t"/> <rejection class="QEvent" field-name="t"/>
@ -66,15 +73,6 @@
<!-- From Qt4.6 ^^^ --> <!-- From Qt4.6 ^^^ -->
<enum-type name="QXmlStreamReader::Error"/> <enum-type name="QXmlStreamReader::Error"/>
<enum-type name="QXmlStreamReader::TokenType"/> <enum-type name="QXmlStreamReader::TokenType"/>
<enum-type name="QString::NormalizationForm" />
<enum-type name="QString::SectionFlag" />
<enum-type name="QString::SplitBehavior"/>
<enum-type name="QChar::Decomposition" />
<enum-type name="QChar::Direction" />
<enum-type name="QChar::Joining" />
<enum-type name="QChar::SpecialCharacter" />
<enum-type name="QChar::UnicodeVersion" />
<enum-type name="QChar::CombiningClass" />
<enum-type name="QLineF::IntersectType" /> <enum-type name="QLineF::IntersectType" />
<enum-type name="QVariant::Type" /> <enum-type name="QVariant::Type" />
<!-- From Qt4.6 --> <!-- From Qt4.6 -->
@ -111,8 +109,6 @@
<primitive-type name="qreal"/> <primitive-type name="qreal"/>
<primitive-type name="float"/> <primitive-type name="float"/>
<primitive-type name="qint64"/> <primitive-type name="qint64"/>
<primitive-type name="__int64"/>
<primitive-type name="unsigned __int64"/>
<primitive-type name="unsigned long long"/> <primitive-type name="unsigned long long"/>
<primitive-type name="long long"/> <primitive-type name="long long"/>
<primitive-type name="qlonglong" target-lang-api-name="PyLong" /> <primitive-type name="qlonglong" target-lang-api-name="PyLong" />
@ -134,8 +130,7 @@
<primitive-type name="long"/> <primitive-type name="long"/>
<primitive-type name="unsigned long"/> <primitive-type name="unsigned long"/>
<primitive-type name="WId"/> <primitive-type name="WId"/>
<primitive-type name="Qt::HANDLE" target-lang-api-name="PyLong"/> <primitive-type name="Qt::HANDLE" target-lang-api-name="PyLong">
<primitive-type name="QByteRef">
<!-- FIXME APIExtractor or shiboken do not support multiple includes by primitive type --> <!-- FIXME APIExtractor or shiboken do not support multiple includes by primitive type -->
<include file-name="QTextDocument" location="global"/> <include file-name="QTextDocument" location="global"/>
</primitive-type> </primitive-type>
@ -145,9 +140,20 @@
<include file-name="QtConcurrentFilter" location="global"/> <include file-name="QtConcurrentFilter" location="global"/>
</primitive-type> </primitive-type>
<primitive-type name="std::string"/> <primitive-type name="QString">
<primitive-type name="std::wstring"/> <include file-name="QString" location="global"/>
<primitive-type name="QStdWString"/> <conversion-rule file="qstring_conversions.h" />
</primitive-type>
<container-type name="QStringList" type="list">
<include file-name="QStringList" location="global"/>
<conversion-rule file="qstringlist_conversions.h" />
</container-type>
<primitive-type name="QStringRef">
<conversion-rule file="qstringref_conversions.h" />
</primitive-type>
<primitive-type name="QChar">
<conversion-rule file="qchar_conversions.h" />
</primitive-type>
<container-type name="QSet" type="set"> <container-type name="QSet" type="set">
<conversion-rule file="qset_conversions.h"/> <conversion-rule file="qset_conversions.h"/>
@ -242,7 +248,6 @@
<rejection class="*" field-name="staticMetaObject"/> <rejection class="*" field-name="staticMetaObject"/>
<!-- not support array in property --> <!-- not support array in property -->
<rejection class="QTextCodec::ConverterState" field-name="state_data"/> <rejection class="QTextCodec::ConverterState" field-name="state_data"/>
<rejection class="QString" field-name="null"/>
<rejection class="QVariant" field-name="handler"/> <rejection class="QVariant" field-name="handler"/>
<rejection class="QUuid" field-name="data1"/> <rejection class="QUuid" field-name="data1"/>
<rejection class="QUuid" field-name="data2"/> <rejection class="QUuid" field-name="data2"/>
@ -542,20 +547,6 @@
<rejection class="QVariant" function-name="setValue"/> <rejection class="QVariant" function-name="setValue"/>
<rejection class="QVariant" function-name="data"/> <rejection class="QVariant" function-name="data"/>
<rejection class="QVariant" function-name="constData"/> <rejection class="QVariant" function-name="constData"/>
<rejection class="QString" function-name="constData"/>
<rejection class="QString" function-name="constBegin"/>
<rejection class="QString" function-name="constEnd"/>
<rejection class="QString" function-name="begin"/>
<rejection class="QString" function-name="end"/>
<rejection class="QString" function-name="data"/>
<rejection class="QString" function-name="unicode"/>
<rejection class="QString" function-name="utf16"/>
<rejection class="QString" function-name="fromLatin1_helper"/>
<rejection class="QString" function-name="fromAscii_helper"/>
<rejection class="QString" function-name="toWCharArray"/>
<rejection class="QString" function-name="sprintf"/>
<rejection class="QString" function-name="vsprintf"/>
<rejection class="QString" function-name="fromStdWString"/>
<rejection class="QStringRef" function-name="constData"/> <rejection class="QStringRef" function-name="constData"/>
<rejection class="QStringRef" function-name="data"/> <rejection class="QStringRef" function-name="data"/>
<rejection class="QStringRef" function-name="unicode"/> <rejection class="QStringRef" function-name="unicode"/>
@ -699,7 +690,6 @@
<enum-type name="QDirIterator::IteratorFlag" flags="QDirIterator::IteratorFlags"/> <enum-type name="QDirIterator::IteratorFlag" flags="QDirIterator::IteratorFlags"/>
<enum-type name="Qt::EventPriority"/> <enum-type name="Qt::EventPriority"/>
<enum-type name="Qt::MaskMode"/> <enum-type name="Qt::MaskMode"/>
<enum-type name="QChar::Category" />
<enum-type name="QCryptographicHash::Algorithm"/> <enum-type name="QCryptographicHash::Algorithm"/>
<enum-type name="QReadWriteLock::RecursionMode"/> <enum-type name="QReadWriteLock::RecursionMode"/>
<enum-type name="QtConcurrent::ReduceOption" flags="QtConcurrent::ReduceOptions"/> <enum-type name="QtConcurrent::ReduceOption" flags="QtConcurrent::ReduceOptions"/>
@ -722,6 +712,8 @@
<!--signal/slot--> <!--signal/slot-->
<inject-code class="target" position="end"> <inject-code class="target" position="end">
Shiboken::TypeResolver::createValueTypeResolver&lt;QString>("unicode");
Shiboken::TypeResolver::createValueTypeResolver&lt;QString>("str");
PySide::init(module); PySide::init(module);
</inject-code> </inject-code>
<inject-code class="native" position="beginning"> <inject-code class="native" position="beginning">
@ -772,224 +764,6 @@
</modify-function> </modify-function>
</object-type> </object-type>
<value-type name="QString" hash-function="QStringCustomHashFunction">
<extra-includes>
<include file-name="QTextCodec" location="global"/>
</extra-includes>
<conversion-rule file="qstring_conversions.h" />
<modify-documentation xpath="/description/section[@id='initializing-a-string']/para[2]" />
<modify-documentation xpath="/description/section[@id='initializing-a-string']/para[3]" />
<!-- Custom hash function -->
<inject-code class="native" position="beginning" file="glue/qstring_hashfunc.cpp" />
<!-- buffer protocol -->
<inject-code class="native" position="beginning" file="glue/qstring_bufferprotocol.cpp" />
<inject-code class="target" position="end">
#if PY_VERSION_HEX &lt; 0x03000000
Shiboken::SbkType&lt;QString>()->tp_as_buffer = &amp;SbkQStringBufferProc;
Shiboken::SbkType&lt;QString>()->tp_flags |= Py_TPFLAGS_HAVE_GETCHARBUFFER;
#endif
</inject-code>
<!-- the number(qlonglong) is enough for python -->
<modify-function signature="number(uint,int)" remove="all" />
<modify-function signature="number(int,int)" remove="all" />
<modify-function signature="number(ulong,int)" remove="all" />
<modify-function signature="number(qlonglong,int)" remove="all" />
<modify-function signature="number(qulonglong,int)" remove="all" />
<modify-function signature="insert(int,const QChar*,int)" remove="all" />
<modify-function signature="QString(const QChar*, int)" remove="all" />
<modify-function signature="fromStdString(std::string)" remove="all"/>
<modify-function signature="toStdString()const" remove="all"/>
<modify-function signature="toStdWString()const" remove="all"/>
<modify-function signature="operator+=(char)" remove="all"/>
<modify-function signature="toUShort(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="toDouble(bool*)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*"/>
</inject-code>
</modify-function>
<modify-function signature="toFloat(bool*)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*"/>
</inject-code>
</modify-function>
<modify-function signature="toInt(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="toLong(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="toLongLong(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="toShort(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="toUInt(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="toULong(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="toULongLong(bool*,int)const">
<modify-argument index="1">
<remove-argument/>
</modify-argument>
<inject-code class="target" position="beginning">
<insert-template name="fix_bool*,arg"/>
</inject-code>
</modify-function>
<modify-function signature="setUtf16(const ushort*,int)" remove="all" />
<modify-function signature="fromUtf16(const ushort*,int)" remove="all" />
<modify-function signature="fromRawData(const QChar*,int)" remove="all" />
<modify-function signature="setUnicode(const QChar*,int)" remove="all" />
<modify-function signature="fromUcs4(const uint*,int)" remove="all" />
<modify-function signature="toUcs4()const" remove="all" />
<!-- Remove conflict signatures in python -->
<modify-function signature="arg(int, int, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(qlonglong, int, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(qulonglong, int, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(short, int, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(uint, int, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(ulong, int, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(ushort, int, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(char, int, const QChar&amp;) const" remove="all"/>
<modify-function signature="arg(QChar, int, const QChar&amp;) const" remove="all"/>
<add-function signature="__str__()" return-type="PyObject*">
<inject-code class="target" position="beginning">
QByteArray utf8 = %CPPSELF.toUtf8();
%PYARG_0 = PyUnicode_DecodeUTF8(utf8.data(), utf8.count(), 0);
</inject-code>
</add-function>
<add-function signature="__len__">
<inject-code class="target" position="beginning">
return %CPPSELF.count();
</inject-code>
</add-function>
<add-function signature="__getitem__">
<inject-code class="target" position="beginning">
if (_i &lt; 0 || _i >= %CPPSELF.size()) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
return 0;
}
return %CONVERTTOPYTHON[%TYPE](%CPPSELF.at(_i));
</inject-code>
</add-function>
<add-function signature="__setitem__">
<inject-code class="target" position="beginning">
%CPPSELF.remove(_i, 1);
PyObject* args = Py_BuildValue("(nO)", _i, _value);
PyObject* result = SbkQStringFunc_insert(self, args);
Py_DECREF(args);
Py_XDECREF(result);
return !result ? -1 : 0;
</inject-code>
</add-function>
<add-function signature="__getslice__">
<inject-code class="target" position="beginning">
<insert-template name="get_slice"/>
</inject-code>
</add-function>
</value-type>
<value-type name="QLatin1String" />
<value-type name="QStringRef">
<modify-function signature="QStringRef(const QString*)" remove="all" />
<modify-function signature="QStringRef(const QString*,int,int)" remove="all" />
<modify-function signature="appendTo(QString*)const" remove="all" />
<modify-function signature="operator=(const QString*)" remove="all" />
</value-type>
<value-type name="QChar" hash-function="qHash">
<conversion-rule file="qchar_conversions.h" />
<modify-function signature="QChar(uchar)" remove="all"/>
<modify-function signature="QChar(short)" remove="all"/>
<modify-function signature="QChar(ushort)" remove="all"/>
<modify-function signature="QChar(uint)" remove="all"/>
<modify-function signature="QChar(char)" remove="all"/>
Implementation note: This constructor is a replacement for
QChar(char), as the char type check also catches numbers,
conflicting with QChar(int).
<add-function signature="QChar(PyString*)">
<inject-code class="target" position="beginning">
if (PyString_Size(%PYARG_1) == 1) {
char value = %CONVERTTOCPP[char](%PYARG_1);
%0 = new %TYPE(value);
} else {
PyErr_SetString(PyExc_TypeError, "expected string of size 1");
}
</inject-code>
</add-function>
<modify-function signature="combiningClass(uint)" remove="all"/>
<modify-function signature="combiningClass(ushort)" remove="all"/>
<modify-function signature="decomposition(uint)" remove="all"/>
<modify-function signature="digitValue(uint)" remove="all"/>
<modify-function signature="digitValue(ushort)" remove="all"/>
<modify-function signature="mirroredChar(uint)" remove="all"/>
<modify-function signature="mirroredChar(ushort)" remove="all"/>
<modify-function signature="toCaseFolded(uint)" remove="all"/>
<modify-function signature="toCaseFolded(ushort)" remove="all"/>
<modify-function signature="toUpper(uint)" remove="all"/>
<modify-function signature="toUpper(ushort)" remove="all"/>
<modify-function signature="toLower(uint)" remove="all"/>
<modify-function signature="toLower(ushort)" remove="all"/>
<modify-function signature="toTitleCase(uint)" remove="all"/>
<modify-function signature="toTitleCase(ushort)" remove="all"/>
<modify-function signature="unicode()" remove="all"/>
<modify-function signature="category(uint)" remove="all"/>
<modify-function signature="category(ushort)" remove="all"/>
<modify-function signature="decompositionTag(uint)" remove="all"/>
<modify-function signature="direction(uint)" remove="all"/>
<modify-function signature="direction(ushort)" remove="all"/>
<modify-function signature="joining(uint)" remove="all"/>
<modify-function signature="joining(ushort)" remove="all"/>
<modify-function signature="unicodeVersion(uint)" remove="all"/>
<modify-function signature="unicodeVersion(ushort)" remove="all"/>
</value-type>
<value-type name="QLatin1Char" />
<value-type name="QBasicTimer"/> <value-type name="QBasicTimer"/>
<value-type name="QByteArrayMatcher"/> <value-type name="QByteArrayMatcher"/>
<value-type name="QDate" hash-function="PySide::hash" > <value-type name="QDate" hash-function="PySide::hash" >
@ -1062,7 +836,6 @@
<modify-function signature="rwidth()" remove="all" /> <modify-function signature="rwidth()" remove="all" />
</value-type> </value-type>
<value-type name="QStringMatcher"/>
<value-type name="QTime" hash-function="PySide::hash"/> <value-type name="QTime" hash-function="PySide::hash"/>
<value-type name="QPersistentModelIndex"> <value-type name="QPersistentModelIndex">
<modify-function signature="internalPointer()const" remove="all"/> <modify-function signature="internalPointer()const" remove="all"/>
@ -1493,7 +1266,6 @@
<modify-function signature="QVariant(const QString&amp;)"> <modify-function signature="QVariant(const QString&amp;)">
<access modifier="private" /> <access modifier="private" />
</modify-function> </modify-function>
<modify-function signature="QVariant(const QLatin1String&amp;)" remove="all"/>
<modify-function signature="QVariant(const QStringList&amp;)" remove="all"/> <modify-function signature="QVariant(const QStringList&amp;)" remove="all"/>
<modify-function signature="QVariant(const QChar&amp;)"> <modify-function signature="QVariant(const QChar&amp;)">
<access modifier="private" /> <access modifier="private" />
@ -1635,75 +1407,6 @@
</inject-code> </inject-code>
</modify-function> </modify-function>
</value-type> </value-type>
<value-type name="QStringList">
<conversion-rule file="qstringlist_conversions.h"/>
<modify-function signature="fromVector(QVector&lt;QString>)" remove="all" />
<add-function signature="__len__">
<inject-code class="target" position="beginning">
return %CPPSELF.count();
</inject-code>
</add-function>
<add-function signature="__getitem__">
<inject-code class="target" position="beginning">
if (_i &lt; 0 || _i >= %CPPSELF.size()) {
PyErr_SetString(PyExc_IndexError, "index out of bounds");
return 0;
}
return %CONVERTTOPYTHON[QString](%CPPSELF.at(_i));
</inject-code>
</add-function>
<add-function signature="__setitem__">
<inject-code class="target" position="beginning">
PyObject* args = Py_BuildValue("(nO)", _i, _value);
PyObject* result = SbkQStringListFunc_replace(self, args);
Py_DECREF(args);
Py_XDECREF(result);
return !result ? -1 : 0;
</inject-code>
</add-function>
<add-function signature="__getslice__">
<inject-code class="target" position="beginning">
<insert-template name="get_slice"/>
</inject-code>
</add-function>
<add-function signature="__setslice__">
<inject-code class="target" position="beginning">
<!--
PyObject* result = 0;
Py_ssize_t start, end;
Py_ssize_t len = %CPPSELF->count();
if (_i1 &gt; len)
start = len;
else if (_i1 &lt; 0)
start = 0;
else
start = _i1;
if (_i2 &gt; len)
end = len;
else if (_i2 &lt; 0)
end = 0;
else
end = _i2;
if (start &lt; end) {
Py_ssize_t i;
for (Py_ssize_t i = _value->count(); i &gt; -1; i++) {
PyObject* args = Py_BuildValue("(nO)", start, %CPPSELF->at(i));
result = SbkQStringList_insert(self, args);
Py_XDECREF(args);
Py_XDECREF(result);
}
for (i = start; i &lt; end; i++)
SbkQStringList_removeAt(self, Py_BuildValue("(n)", i));
}
return !result ? -1 : 0;
-->
return 0;
</inject-code>
</add-function>
</value-type>
<object-type name="QAbstractListModel" polymorphic-id-expression="qobject_cast&lt;QAbstractListModel*&gt;(%1)"> <object-type name="QAbstractListModel" polymorphic-id-expression="qobject_cast&lt;QAbstractListModel*&gt;(%1)">
<extra-includes> <extra-includes>
<include file-name="QStringList" location="global"/> <include file-name="QStringList" location="global"/>
@ -1759,9 +1462,7 @@
<modify-function signature="operator const void *()const" remove="all"/> <modify-function signature="operator const void *()const" remove="all"/>
<modify-function signature="operator+=(const char*)" remove="all"/> <modify-function signature="operator+=(const char*)" remove="all"/>
<modify-function signature="operator=(const char*)" remove="all"/> <modify-function signature="operator=(const char*)" remove="all"/>
<modify-function signature="operator[](int)" remove="all"/>
<modify-function signature="operator[](int)const" remove="all"/> <modify-function signature="operator[](int)const" remove="all"/>
<modify-function signature="operator[](uint)" remove="all"/>
<modify-function signature="operator[](uint)const" remove="all"/> <modify-function signature="operator[](uint)const" remove="all"/>
<modify-function signature="push_back(char)" remove="all"/> <modify-function signature="push_back(char)" remove="all"/>
<modify-function signature="push_back(const QByteArray&amp;)" remove="all"/> <modify-function signature="push_back(const QByteArray&amp;)" remove="all"/>
@ -2134,15 +1835,12 @@
</modify-function> </modify-function>
</object-type> </object-type>
<object-type name="QTextDecoder"> <object-type name="QTextDecoder">
<modify-function signature="toUnicode(const char*,int)"> <modify-function signature="toUnicode(const char*,int)" remove="all" />
<remove/> <!-- Removed because it expect QString to be mutable -->
</modify-function> <modify-function signature="toUnicode(QString*,const char*,int)" remove="all" />
<modify-function signature="toUnicode(QString*,const char*,int)" remove="all"/>
</object-type> </object-type>
<object-type name="QTextEncoder"> <object-type name="QTextEncoder">
<modify-function signature="fromUnicode(const QChar*,int)"> <modify-function signature="fromUnicode(const QChar*,int)" remove="all" />
<remove/>
</modify-function>
</object-type> </object-type>
<object-type name="QTimeLine"/> <object-type name="QTimeLine"/>
<object-type name="QTranslator"> <object-type name="QTranslator">
@ -2506,7 +2204,10 @@
<modify-function signature="exec(QTextStream &amp;)" rename="exec_"/> <modify-function signature="exec(QTextStream &amp;)" rename="exec_"/>
</value-type> </value-type>
<object-type name="QTextStream" stream="yes"> <object-type name="QTextStream" stream="yes">
<!-- Removed because it expect QString to be mutable -->
<modify-function signature="QTextStream(QString*,QFlags&lt;QIODevice::OpenModeFlag&gt;)" />
<modify-function signature="QTextStream(const QByteArray&amp;, QFlags&lt;QIODevice::OpenModeFlag&gt;)" remove="all"/> <modify-function signature="QTextStream(const QByteArray&amp;, QFlags&lt;QIODevice::OpenModeFlag&gt;)" remove="all"/>
<!-- Removed because it expect QString to be mutable -->
<modify-function signature="setString(QString*,QFlags&lt;QIODevice::OpenModeFlag&gt;)" remove="all"/> <modify-function signature="setString(QString*,QFlags&lt;QIODevice::OpenModeFlag&gt;)" remove="all"/>
<modify-function signature="operator&lt;&lt;(const void*)" remove="all"/> <modify-function signature="operator&lt;&lt;(const void*)" remove="all"/>
@ -2526,6 +2227,11 @@
<modify-function signature="operator&gt;&gt;(signed short&amp;)" remove="all"/> <modify-function signature="operator&gt;&gt;(signed short&amp;)" remove="all"/>
<modify-function signature="operator&gt;&gt;(unsigned int&amp;)" remove="all"/> <modify-function signature="operator&gt;&gt;(unsigned int&amp;)" remove="all"/>
<modify-function signature="operator&gt;&gt;(unsigned short&amp;)" remove="all"/> <modify-function signature="operator&gt;&gt;(unsigned short&amp;)" remove="all"/>
<!-- Removed because it expect QChar to be mutable -->
<modify-function signature="operator&gt;&gt;(QChar&amp;)" remove="all"/>
<!-- Removed because it expect QString to be mutable -->
<modify-function signature="operator&gt;&gt;(QString&amp;)" remove="all"/>
<modify-function signature="flush()" allow-thread="yes"/> <modify-function signature="flush()" allow-thread="yes"/>
<modify-function signature="read(qint64)" allow-thread="yes"/> <modify-function signature="read(qint64)" allow-thread="yes"/>
@ -2553,10 +2259,6 @@
<modify-function signature="mid(int, int) const" remove="all"/> <modify-function signature="mid(int, int) const" remove="all"/>
<modify-function signature="toList() const" remove="all"/> <modify-function signature="toList() const" remove="all"/>
<modify-function signature="fromList(const QList&lt;QXmlStreamAttribute&gt; &amp;)" remove="all"/> <modify-function signature="fromList(const QList&lt;QXmlStreamAttribute&gt; &amp;)" remove="all"/>
<modify-function signature="value(const QString &amp;, const QLatin1String &amp;)const" remove="all" />
<modify-function signature="value(const QLatin1String &amp;, const QLatin1String &amp;)const" remove="all" />
<modify-function signature="value(const QLatin1String &amp;)const" remove="all" />
<modify-function signature="hasAttribute(const QLatin1String &amp;)const" remove="all" />
</value-type> </value-type>
<value-type name="QXmlStreamNamespaceDeclaration"/> <value-type name="QXmlStreamNamespaceDeclaration"/>
<value-type name="QXmlStreamNotationDeclaration"/> <value-type name="QXmlStreamNotationDeclaration"/>
@ -2566,6 +2268,7 @@
<modify-function signature="addData(const char*)" remove="all"/> <modify-function signature="addData(const char*)" remove="all"/>
</object-type> </object-type>
<object-type name="QXmlStreamWriter"> <object-type name="QXmlStreamWriter">
<!-- Removed because it expect QString to be mutable -->
<modify-function signature="QXmlStreamWriter(QString *)" remove="all" /> <modify-function signature="QXmlStreamWriter(QString *)" remove="all" />
<modify-function signature="codec()const" remove="all"/> <modify-function signature="codec()const" remove="all"/>
</object-type> </object-type>

6
tests/QtCore/CMakeLists.txt
View file

@ -1,5 +1,4 @@
PYSIDE_TEST(blocking_signals_test.py) PYSIDE_TEST(blocking_signals_test.py)
PYSIDE_TEST(buffer_test.py)
PYSIDE_TEST(child_event_test.py) PYSIDE_TEST(child_event_test.py)
PYSIDE_TEST(deletelater_test.py) PYSIDE_TEST(deletelater_test.py)
PYSIDE_TEST(duck_punching_test.py) PYSIDE_TEST(duck_punching_test.py)
@ -14,7 +13,6 @@ PYSIDE_TEST(qbytearray_concatenation_operator_test.py)
PYSIDE_TEST(qbytearray_operator_iadd_test.py) PYSIDE_TEST(qbytearray_operator_iadd_test.py)
PYSIDE_TEST(qbytearray_operator_test.py) PYSIDE_TEST(qbytearray_operator_test.py)
PYSIDE_TEST(qbytearray_test.py) PYSIDE_TEST(qbytearray_test.py)
PYSIDE_TEST(qchar_test.py)
PYSIDE_TEST(qcoreapplication_instance_test.py) PYSIDE_TEST(qcoreapplication_instance_test.py)
PYSIDE_TEST(qdatastream_test.py) PYSIDE_TEST(qdatastream_test.py)
PYSIDE_TEST(qdate_test.py) PYSIDE_TEST(qdate_test.py)
@ -24,7 +22,6 @@ PYSIDE_TEST(qfileinfo_test.py)
PYSIDE_TEST(qfile_test.py) PYSIDE_TEST(qfile_test.py)
PYSIDE_TEST(qflags_test.py) PYSIDE_TEST(qflags_test.py)
PYSIDE_TEST(qhandle_test.py) PYSIDE_TEST(qhandle_test.py)
PYSIDE_TEST(qlatin1string_test.py)
PYSIDE_TEST(qlinef_test.py) PYSIDE_TEST(qlinef_test.py)
PYSIDE_TEST(qlocale_test.py) PYSIDE_TEST(qlocale_test.py)
PYSIDE_TEST(qmetaobject_test.py) PYSIDE_TEST(qmetaobject_test.py)
@ -48,9 +45,6 @@ PYSIDE_TEST(qslot_object_test.py)
PYSIDE_TEST(qsrand_test.py) PYSIDE_TEST(qsrand_test.py)
PYSIDE_TEST(qstatemachine_test.py) PYSIDE_TEST(qstatemachine_test.py)
PYSIDE_TEST(qstate_test.py) PYSIDE_TEST(qstate_test.py)
PYSIDE_TEST(qstring_buffer_protocol_test.py)
PYSIDE_TEST(qstringlist_test.py)
PYSIDE_TEST(qstring_operator_test.py)
PYSIDE_TEST(qstring_test.py) PYSIDE_TEST(qstring_test.py)
PYSIDE_TEST(qtext_codec_test.py) PYSIDE_TEST(qtext_codec_test.py)
PYSIDE_TEST(qtextstream_test.py) PYSIDE_TEST(qtextstream_test.py)

13
tests/QtCore/buffer_test.py
View file

@ -1,13 +0,0 @@
#!/usr/bin/python
import unittest
from PySide.QtCore import QString
class BufferTest(unittest.TestCase):
def testQByteArray(self):
data = buffer("PySide")
str = QString(data)
self.assertEqual(data, str)
if __name__ == '__main__':
unittest.main()

11
tests/QtCore/qbytearray_operator_iadd_test.py
View file

@ -2,12 +2,12 @@
import unittest import unittest
import new import new
from PySide.QtCore import QByteArray, QString from PySide.QtCore import *
from helper.docmodifier import DocModifier from helper.docmodifier import DocModifier
class BaseQByteArrayOperatorIAdd(object): class BaseQByteArrayOperatorIAdd(object):
'''Base class for QByteArray += operator tests. '''Base class for QByteArray += operator tests.
Implementing classes should inherit from unittest.TestCase and implement Implementing classes should inherit from unittest.TestCase and implement
setUp, setting self.obj and self.orig_obj to the target QByteArray and original setUp, setting self.obj and self.orig_obj to the target QByteArray and original
one, respectively''' one, respectively'''
@ -41,13 +41,6 @@ class BaseQByteArrayOperatorIAdd(object):
self.assertEqual(self.obj, self.orig_obj + s) self.assertEqual(self.obj, self.orig_obj + s)
self.assertEqual(self.obj.size(), self.orig_obj.size() + 1) self.assertEqual(self.obj.size(), self.orig_obj.size() + 1)
def testQString(self):
'''QByteArray += QString'''
s = QString('dummy')
self.obj += s
self.assertEqual(self.obj, self.orig_obj + s)
self.assertEqual(self.obj.size(), self.orig_obj.size() + s.size())
class NullQByteArrayOperatorIAdd(unittest.TestCase, BaseQByteArrayOperatorIAdd): class NullQByteArrayOperatorIAdd(unittest.TestCase, BaseQByteArrayOperatorIAdd):
'''Test case for operator QByteArray += on null QByteArrays''' '''Test case for operator QByteArray += on null QByteArrays'''

6
tests/QtCore/qbytearray_operator_test.py
View file

@ -4,7 +4,7 @@
import unittest import unittest
from PySide.QtCore import QByteArray, QString from PySide.QtCore import *
class QByteArrayOperatorEqual(unittest.TestCase): class QByteArrayOperatorEqual(unittest.TestCase):
'''TestCase for operator QByteArray == QByteArray''' '''TestCase for operator QByteArray == QByteArray'''
@ -26,9 +26,9 @@ class QByteArrayOperatorEqual(unittest.TestCase):
self.assertEqual(QByteArray(string), string) self.assertEqual(QByteArray(string), string)
def testQString(self): def testQString(self):
#QByteArray(string) == QString(string) #QByteArray(string) == string
string = 'another test string' string = 'another test string'
self.assertEqual(QByteArray(string), QString(string)) self.assertEqual(QByteArray(string), string)
class QByteArrayOperatorAt(unittest.TestCase): class QByteArrayOperatorAt(unittest.TestCase):
'''TestCase for operator QByteArray[]''' '''TestCase for operator QByteArray[]'''

59
tests/QtCore/qchar_test.py
View file

@ -1,59 +0,0 @@
'''Test cases for QChar'''
import unittest
from PySide.QtCore import QString, QChar, QTextStream, QLatin1Char
class EqualTest(unittest.TestCase):
'''Tests for '__equal__'''
def testEqualQChar(self):
'''QChar == QChar'''
self.assertEqual(QChar('a'), QChar('a'))
def testEqualPyString(self):
'''QChar == Python string'''
self.assertEqual(QChar('a'), 'a')
class ImplicitConvQLatin1Char(unittest.TestCase):
'''Tests for implicit conversion from QLatin1Char to QChar'''
def testQLatin1CharToChar(self):
'''QLatin1Char implicitly convertible to QChar'''
stream = QTextStream()
stream.setPadChar(QLatin1Char('-'))
self.assertEqual(QChar('-'), stream.padChar())
class QCharCtorBigNumber(unittest.TestCase):
'''QChar constructors receiving ints'''
def testInt(self):
'''QChar(int)'''
codepoint = 512
qchar = QChar(codepoint)
reference = unichr(codepoint)
self.assertEqual(qchar.unicode(), codepoint)
class QCharCtorString(unittest.TestCase):
'''QChar constructor receiving strings'''
def testBasic(self):
'''QChar(char)'''
reference = 'a'
qchar = QChar(reference)
self.assertEqual(ord(reference), ord(qchar.toAscii()))
def testError(self):
'''QChar(char)'''
reference = 'aaaaaa'
self.assertRaises(TypeError, QChar, reference)
if __name__ == '__main__':
unittest.main()

3
tests/QtCore/qdatastream_test.py
View file

@ -3,8 +3,7 @@
import unittest import unittest
from PySide.QtCore import QDataStream, QString, QIODevice, QByteArray from PySide.QtCore import *
from PySide.QtCore import QBitArray, QDate, QTime, QDateTime, QLine, QChar
def create_bitarray(string): def create_bitarray(string):
array = QBitArray(len(string)) array = QBitArray(len(string))

4
tests/QtCore/qenum_test.py
View file

@ -3,7 +3,7 @@
import unittest import unittest
from PySide.QtCore import QIODevice, QString, Qt, QVariant from PySide.QtCore import *
class TestEnum(unittest.TestCase): class TestEnum(unittest.TestCase):
@ -18,7 +18,7 @@ class TestEnum(unittest.TestCase):
self.assertEqual(QIODevice.Unbuffered, 32) self.assertEqual(QIODevice.Unbuffered, 32)
def testToIntInFunction(self): def testToIntInFunction(self):
self.assertEqual(QString.number(QIODevice.WriteOnly), "2") self.assertEqual(str(int(QIODevice.WriteOnly)), "2")
class TestQFlags(unittest.TestCase): class TestQFlags(unittest.TestCase):
def testToItn(self): def testToItn(self):

21
tests/QtCore/qlatin1string_test.py
View file

@ -1,21 +0,0 @@
'''Test cases for QLatin1String'''
import unittest
from PySide.QtCore import QString, QLatin1String, QObject
class ImplicitConvQLatin1String(unittest.TestCase):
'''Tests for implicit conversion from QLatin1String to QString'''
def testQLatin1String(self):
'''QString implicit convertion from QLatin1String'''
obj = QObject()
obj.setObjectName(QLatin1String('dummy'))
self.assertEqual(QString('dummy'), obj.objectName())
if __name__ == '__main__':
unittest.main()

8
tests/QtCore/qobject_property_test.py
View file

@ -3,7 +3,7 @@
import unittest import unittest
from PySide.QtCore import QObject, QVariant, QString from PySide.QtCore import *
class PropertyCase(unittest.TestCase): class PropertyCase(unittest.TestCase):
'''Test case for QObject properties''' '''Test case for QObject properties'''
@ -41,14 +41,14 @@ class PropertyCase(unittest.TestCase):
# QVariant.toInt has a bool* arg in C++, so returns a tuple # QVariant.toInt has a bool* arg in C++, so returns a tuple
self.assertEqual(obj.property('dummy').toInt(), (42, True)) self.assertEqual(obj.property('dummy').toInt(), (42, True))
def testQStringProperty(self): def testStringProperty(self):
obj = QObject() obj = QObject()
self.assert_(not obj.setProperty('dummy', QString('data'))) self.assert_(not obj.setProperty('dummy', 'data'))
prop = obj.property('dummy') prop = obj.property('dummy')
self.assert_(isinstance(prop, QVariant)) self.assert_(isinstance(prop, QVariant))
self.assert_(prop.isValid()) self.assert_(prop.isValid())
self.assertEqual(obj.property('dummy').toString(), QString('data')) self.assertEqual(obj.property('dummy').toString(), 'data')
def testImplicitQVariantProperty(self): def testImplicitQVariantProperty(self):
obj = QObject() obj = QObject()

20
tests/QtCore/qstring_buffer_protocol_test.py
View file

@ -1,20 +0,0 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''Tests QString implementation of Python buffer protocol'''
import unittest
from os.path import isdir
from PySide.QtCore import QString
class QStringBufferProtocolTest(unittest.TestCase):
'''Tests QString implementation of Python buffer protocol'''
def testQStringBufferProtocol(self):
#Tests QString implementation of Python buffer protocol using the os.path.isdir
#function which an unicode object or other object implementing the Python buffer protocol
isdir(QString('/tmp'))
if __name__ == '__main__':
unittest.main()

161
tests/QtCore/qstring_operator_test.py
View file

@ -1,161 +0,0 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''Test cases for QString operators'''
import unittest
from PySide.QtCore import QString, QByteArray
class QStringOperatorEqual(unittest.TestCase):
'''TestCase for operator QString == QString'''
def testDefault(self):
#QString() == QString()
obj1 = QString()
obj2 = QString()
self.assertEqual(obj1, obj2)
def testSimple(self):
#QString(some_string) == QString(some_string)
string = 'egg snakes'
self.assertEqual(QString(string), QString(string))
def testUnicode(self):
#QString(unicode) == QString(unicode)
string = u'àâãá'
self.assertEqual(QString(string), QString(string))
def testPyString(self):
#QString(string) == string
string = 'my test string'
self.assertEqual(QString(string), string)
self.assertEqual(string, QString(string))
def testPyUnicodeString(self):
#QString(unicode) == unicode
string = u'àâãá'
self.assertEqual(QString(string), string)
self.assertEqual(string, unicode(QString(string)))
def testQByteArray(self):
#QString(string) == QByteArray(string)
string = 'another test string'
self.assertEqual(QString(string), QByteArray(string))
class QStringOperatorAtSetter(unittest.TestCase):
'''Test case for operator QString[] - __setitem__'''
def testSetterString(self):
'''QString[x] = pythonstring'''
obj = QString('123456')
obj[1] = '0'
self.assertEqual(obj, QString('103456'))
def testSetterStringLarge(self):
'''QString[x] = pythonstring (larget than 1 char)'''
obj = QString('123456')
obj[3] = 'abba'
self.assertEqual(obj, QString('123abba56'))
def testSetterQString(self):
'''QString[x] = QString'''
obj = QString('123456')
obj[3] = QString('string')
self.assertEqual(obj, QString('123string56'))
def testSetterQByteArray(self):
'''QString[x] = qbytearray'''
obj = QString('123456')
obj[3] = QByteArray('array')
self.assertEqual(obj, QString('123array56'))
class QStringOperatorAtSetterNegativeIndex(unittest.TestCase):
'''Test case for QString[] - __setitem__ - for negative index'''
def testSetterNegativeIndex(self):
'''QString[x] = string - negative index'''
obj = QString('123456')
obj[-3] = 'array'
self.assertEqual(obj, QString('123array56'))
class QStringOperatorAtSetterLargeIndex(unittest.TestCase):
'''Test case for QString[] - __setitem__ - for 'overflown' index'''
def testSetterLargeIndexEmpty(self):
'''QString[x] = somestring - Overflow index on empty string'''
# should pad with spaces if the index is larger
obj = QString('')
obj[2] = 'a'
self.assertEqual(obj, QString(' a'))
def testSetterLargeIndexNormal(self):
'''QString[x] = somestring - Overflow index on normal string'''
# should pad with spaces if the index is larger
obj = QString('mystring')
obj[10] = 'normal'
self.assertEqual(obj, QString('mystring normal'))
class QStringOperatorAt(unittest.TestCase):
'''TestCase for operator QString[] - __getitem__'''
def testInRange(self):
#QString[x] where x is a valid index
string = 'abcdefgh'
obj = QString(string)
for i in range(len(string)):
self.assertEqual(obj[i], string[i])
def testInRangeReverse(self):
#QString[x] where x is a valid index (reverse order)
string = 'abcdefgh'
obj = QString(string)
for i in range(len(string)-1, 0, -1):
self.assertEqual(obj[i], string[i])
def testInRangeUnicode(self):
#QString[x] where x is a valid index (unicode)
string = u'àâãá'
obj = QString(string)
for i in range(len(string)):
self.assertEqual(obj[i], string[i])
def testInRangeUnicodeReverse(self):
#QString[x] where x is a valid index (unicode) (reverse order)
string = u'àâãá'
obj = QString(string)
for i in range(len(string)-1, 0, -1):
self.assertEqual(obj[i], string[i])
def testOutOfRange(self):
#QString[x] where x is out of index
string = '1234567'
obj = QString(string)
self.assertRaises(IndexError, lambda :obj[len(string)])
def testReturnQString(self):
#QString[x] must return a QString
string = QString('123456')
data = string[0]
self.assert_(isinstance(data, QString))
class QStringOperatorAdd(unittest.TestCase):
'''TestCase for operator QString[]'''
def testOperatorAdd(self):
str1 = '123'
str2 = QString('456')
self.assertEquals('123456', str1 + str2)
self.assertEquals('456123', str2 + str1)
if __name__ == '__main__':
unittest.main()

176
tests/QtCore/qstring_test.py
View file

@ -6,173 +6,19 @@ import unittest
import ctypes import ctypes
import sys import sys
from PySide.QtCore import QString, QByteArray, QObject from PySide.QtCore import *
class QStringToNumber(unittest.TestCase):
def testReturnValueTypes(self):
obj = QString('37')
val, ok = obj.toInt()
self.assertEqual(type(val), int)
self.assertEqual(type(ok), bool)
def testToNumberInt(self):
obj = QString('37')
self.assertEqual((37, True), obj.toInt())
def testToNumberLong(self):
obj = QString('3700000')
self.assertEqual((3700000, True), obj.toInt())
def testToNumberShort(self):
obj = QString('33')
self.assertEqual((ctypes.c_short(33).value, True), obj.toShort())
def testToNumberShortNegative(self):
obj = QString('-4')
self.assertEqual((ctypes.c_short(-4).value, True), obj.toShort())
def testToNumberShortOverflow(self):
obj = QString('1000000')
self.assertEqual(False, obj.toShort()[1])
def testToNumberUInt(self):
obj = QString('33')
self.assertEqual((ctypes.c_uint(33).value, True), obj.toUInt())
def testToNumberUIntNegative(self):
obj = QString('-4')
self.assertEqual(False, obj.toUInt()[1])
def testToNumberUIntOverflow(self):
obj = QString('10000000000000')
self.assertEqual(False, obj.toUInt()[1])
def testToNumberULong(self):
obj = QString('33')
self.assertEqual((ctypes.c_ulong(33).value, True), obj.toULong())
def testToNumberULongNegative(self):
obj = QString('-4')
self.assertEqual(False, obj.toULong()[1])
def testToNumberUShort(self):
obj = QString('33')
self.assertEqual((ctypes.c_ushort(33).value, True), obj.toUShort())
def testToNumberUShortLarge(self):
obj = QString('128')
self.assertEqual((ctypes.c_ushort(128).value, True), obj.toUShort())
def testToNumberUShortOverflow(self):
obj = QString('205000')
self.assertEqual(False, obj.toUShort()[1])
def testToNumberUShortNegative(self):
obj = QString('-4')
self.assertEqual(False, obj.toUShort()[1])
def testToNumberIntUsingHex(self):
obj = QString('2A')
self.assertEquals((0, False), obj.toInt())
self.assertEqual((int(str(obj), 16), True), obj.toInt(16))
def testToNumberIntUsingHex(self):
obj = QString('101010')
self.assertEqual((int(str(obj), 2), True), obj.toInt(2))
def testToNumberFloat(self):
obj = QString('37.109')
self.assertEqual(ctypes.c_float(37.109).value,
obj.toFloat()[0])
def testToNumberDouble(self):
obj = QString('37.109')
self.assertEqual(ctypes.c_double(37.109).value,
obj.toDouble()[0])
def testToULongLong(self):
obj = QString('37109')
self.assertEqual(ctypes.c_ulong(37109).value,
obj.toULongLong()[0])
class QStringConstructor(unittest.TestCase): class QStringConstructor(unittest.TestCase):
'''Test case for QString constructors''' '''Test case for QString constructors'''
def testQStringDefault(self): def testQStringDefault(self):
#QString() obj = QObject()
obj1 = QString() obj.setObjectName('foo')
obj2 = QString() self.assertEqual(obj.objectName(), u'foo')
obj.setObjectName(u'áâãà')
self.assertEqual(obj1, obj2) self.assertEqual(obj.objectName(), u'áâãà')
obj.setObjectName(None)
def testNullQString(self): self.assertEqual(obj.objectName(), u'')
s = QString(None)
self.assertTrue(s.isNull())
def testQStringFromPy(self):
#QString(const char*)
sample = 'a new string'
obj1 = QString(sample)
obj2 = QString(sample)
self.assertEqual(obj1, obj2)
def testQStringFromUnicode(self):
sample = u'áâãà'
obj1 = QString(sample)
obj2 = QString(sample)
self.assertEqual(obj1, obj2)
self.assertEqual(obj1, sample)
self.assertEqual(obj2, sample)
def testQStringFromByteArray(self):
# QByteArray(const char *) must be working
sample = QByteArray('foo')
obj1 = QString(sample)
obj2 = QString(sample)
self.assertEqual(obj1, obj2)
def testQStringArg(self):
a = QString("%1 %2 %3").arg(1).arg("two").arg(3.14)
self.assertEquals("1 two 3.14", str(a))
def testQStringArgNegative(self):
a = QString("%1").arg(-20)
self.assertEquals("-20", str(a))
class QStringComparison(unittest.TestCase):
'''Test case for comparison to python strings'''
def testComparePyString(self):
#Compare QStrings and Python strings.
py = ''
qstr = QString()
self.assertEqual(py, qstr)
py = 'The quick brown fox jumps over the lazy dog'
qstr = QString(py)
self.assertEqual(py, qstr)
class QStringRange(unittest.TestCase):
'''Test case for ranges in python strings'''
def testSimpleRange(self):
#Test open start and open end intervals
py = 'The quick brown fox jumps over the lazy dog'
qstr = QString(py)
self.assertEqual(py[5:], qstr[5:])
self.assertEqual(py[:7], qstr[:7])
class QStringIndexOf(unittest.TestCase):
def testEmpty(self):
string = QString()
self.assertEqual(string.indexOf(QString("aaa")), -1)
self.assertEqual(string.indexOf(QString()), 0)
def testString(self):
string = QString("the quick brown fox")
self.assertEqual(string.indexOf("quick", 0), 4)
class QStringImplicitConvertion(unittest.TestCase): class QStringImplicitConvertion(unittest.TestCase):
'''Implicit conversions for QString''' '''Implicit conversions for QString'''
@ -181,12 +27,8 @@ class QStringImplicitConvertion(unittest.TestCase):
'''QString implicitly conversion: QByteArray''' '''QString implicitly conversion: QByteArray'''
obj = QObject() obj = QObject()
obj.setObjectName(QByteArray('foobar')) obj.setObjectName(QByteArray('foobar'))
self.assertEqual(obj.objectName(), QString('foobar')) self.assertEqual(obj.objectName(), u'foobar')
class QStringHash(unittest.TestCase):
def testHash(self):
self.assertEqual(hash("key"), hash(QString("key")))
self.assertEqual(hash(u"aéióu"), hash(QString(u"aéióu")))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

171
tests/QtCore/qstringlist_test.py
View file

@ -1,171 +0,0 @@
# -*- coding: utf-8 -*-
'''Test cases for QStringList'''
import unittest
from random import shuffle
from PySide.QtCore import QStringList, QString
from helper import random_string
class UsesManyStrings(unittest.TestCase):
'''Helper class to setup a list of strings and QStrings'''
def setUp(self):
#Creates a list of strings and python strings
self.size = 10
# List of Python strings
self.samples = [random_string() for x in range(self.size)]
# List of QStrings
self.strings = map(QString, self.samples)
self.obj = QStringList(self.strings)
class TestConstructorBasic(unittest.TestCase):
'''Basic constructor test'''
def testEmpty(self):
#QStringList() - default constructor
obj = QStringList()
self.assert_(isinstance(obj, QStringList))
def testQString(self):
#QStringList(QString)
qstr = QString('aaaa')
obj = QStringList(qstr)
self.assert_(isinstance(obj, QStringList))
def testPyString(self):
#QStringList(python_string) constructor
string = 'forty two'
obj = QStringList(string)
self.assert_(isinstance(obj, QStringList))
def testPyStringUnicode(self):
#QStringList(unicode python_string) constructor
string = 'Nação Zumbi'
obj = QStringList(string)
self.assert_(isinstance(obj, QStringList))
class TestConstructorList(UsesManyStrings):
'''Test case for QStringList(List) constructor'''
def testListQString(self):
#QStringList([QString]) constructor
obj = QStringList(self.strings)
self.assert_(isinstance(obj, QStringList))
def testListPyString(self):
#QStringList([python_string]) constructor
obj = QStringList(self.samples)
self.assert_(isinstance(obj, QStringList))
def testListMixed(self):
#QStringList([python_string and QString]) mixed constructor
mixed = self.samples + self.strings
shuffle(mixed)
obj = QStringList(mixed)
self.assert_(isinstance(obj, QStringList))
def testCopyList(self):
#QStringList(QStringList(list)) - copy constructor
obj = QStringList(self.strings)
obj2 = QStringList(obj)
self.assert_(isinstance(obj2, QStringList))
self.assertEqual(obj, obj2)
class TestComparison(unittest.TestCase):
'''Test case for comparison of QStringLists'''
def testEqual(self):
#QStringList == QStringList
string = QString('aaaabvbbcccedde')
obj1 = QStringList(string)
obj2 = QStringList(string)
self.assertEqual(obj1, obj2)
class TestIndexing(unittest.TestCase):
'''Test case for indexing through []'''
def testInvalidIndexEmpty(self):
#QStringList[x] for empty list
obj = QStringList()
self.assertRaises(IndexError, lambda:obj[0])
def testInvalidIndexQString(self):
#QStringList[1] raising IndexError for QStringList(QString)
obj = QStringList(QString('aaaaa'))
self.assertRaises(IndexError, lambda:obj[1])
def testValidIndexQString(self):
#QStringList[0] not raising IndexError for QStringList(QString)
string = QString('abcdefg')
obj = QStringList(string)
self.assertEqual(obj[0], string)
def testNegativeIndexing(self):
#QStringList[-1] not raising IndexError for QStringList(QString)
string = QString('abcdefg')
obj = QStringList(string)
self.assertEqual(obj[-1], string)
class TestListIndexing(UsesManyStrings):
'''Test case for indexing QStringList longer than 1 string'''
def testValid(self):
#QStringList[] for valid indexes
for i in range(self.size):
self.assertEqual(self.strings[i], self.obj[i])
def testNegativeValid(self):
#QStringList[] for valid indexes
for i in range(-1, -self.size, -1):
self.assertEqual(self.strings[i], self.obj[i])
def testInvalid(self):
#QStringList[] for invalid negative indexes
self.assertRaises(IndexError, lambda : self.obj[self.size])
self.assertRaises(IndexError, lambda : self.obj[-(self.size+1)])
class TestSlicing(UsesManyStrings):
'''Test case for slicing a QStringList'''
def testSlicing(self):
#QStringList slicing
for i in range(self.size):
self.assertEqual(self.obj[i:], self.strings[i:])
self.assertEqual(self.obj[:i], self.strings[:i])
for j in range(i):
self.assertEqual(self.obj[j:i], self.strings[j:i])
for i in range(-1, -self.size, -1):
self.assertEqual(self.obj[:i], self.strings[:i])
class TestShiftOperator(UsesManyStrings):
'''Test case for QStringList lshift operator'''
def testShiftOperator(self):
#QStringList lshift
a = QStringList()
a << "a" << "b" << "c";
self.assertEquals(3, a.count())
b = ["1", "2", "3"]
c = ["4", "5", "6"]
a << b << c
self.assertEquals(9, a.count())
def testShiftOperator(self):
#QStringList lshift
a = QStringList()
b = ["1", 2, "3"]
self.assertRaises(TypeError, a.__lshift__, b)
if __name__ == '__main__':
unittest.main()

16
tests/QtCore/qtextstream_test.py
View file

@ -3,8 +3,7 @@
import unittest import unittest
from PySide.QtCore import QTextStream, QIODevice, QString, QByteArray from PySide.QtCore import *
from PySide.QtCore import QTextCodec, QFile
class QTextStreamShiftTest(unittest.TestCase): class QTextStreamShiftTest(unittest.TestCase):
@ -16,18 +15,11 @@ class QTextStreamShiftTest(unittest.TestCase):
def testNumber(self): def testNumber(self):
'''QTextStream << number''' '''QTextStream << number'''
self.write << QString('4') self.write << '4'
self.write.flush() self.write.flush()
res = self.read.readLine() res = self.read.readLine()
self.assert_(isinstance(res, QString)) self.assert_(isinstance(res, unicode))
self.assertEqual(res, QString('4')) self.assertEqual(res, '4')
def testString(self):
self.write << QString('Test_it!')
self.write.flush()
res = QString()
self.read >> res
self.assertEqual(res, QString('Test_it!'))
class QTextStreamGetSet(unittest.TestCase): class QTextStreamGetSet(unittest.TestCase):

7
tests/QtCore/qvariant_pyobject_test.py
View file

@ -3,19 +3,17 @@
import unittest import unittest
from PySide.QtCore import QSize, QVariant, QString from PySide.QtCore import *
class Dummy(object): class Dummy(object):
'''Pure python sample class''' '''Pure python sample class'''
pass pass
class MySize(QSize): class MySize(QSize):
'''Extended class''' '''Extended class'''
pass pass
class QVariantPurePython(unittest.TestCase): class QVariantPurePython(unittest.TestCase):
'''QVariant + pure python classes''' '''QVariant + pure python classes'''
@ -26,7 +24,6 @@ class QVariantPurePython(unittest.TestCase):
# inherited type name from other binding # inherited type name from other binding
self.assertEqual('PyQt_PyObject', obj.typeName()) self.assertEqual('PyQt_PyObject', obj.typeName())
class QVariantInheritedPython(unittest.TestCase): class QVariantInheritedPython(unittest.TestCase):
'''QVariant + classes inherited from C++''' '''QVariant + classes inherited from C++'''
@ -63,7 +60,7 @@ class QVariantToPyObject(unittest.TestCase):
'''QVariant(python string).toPyObject() return an equal QString''' '''QVariant(python string).toPyObject() return an equal QString'''
d = 'abc' d = 'abc'
obj = QVariant('abc') obj = QVariant('abc')
self.assert_(isinstance(obj.toPyObject(), QString)) self.assert_(isinstance(obj.toPyObject(), unicode))
self.assertEqual(d, obj.toPyObject()) self.assertEqual(d, obj.toPyObject())

19
tests/QtCore/qvariant_test.py
View file

@ -5,7 +5,7 @@
import unittest import unittest
import sys import sys
from PySide.QtCore import QSize, QVariant, QByteArray, QStringList, QString from PySide.QtCore import *
class QVariantToNumber(unittest.TestCase): class QVariantToNumber(unittest.TestCase):
@ -50,11 +50,6 @@ class QVariantToNumber(unittest.TestCase):
class QVariantTypeName(unittest.TestCase): class QVariantTypeName(unittest.TestCase):
'''QVariant.typeName()''' '''QVariant.typeName()'''
def testTypeNameQString(self):
'''QVariant(QString).typeName()'''
obj = QVariant(QString('aaaa'))
self.assertEqual('QString', obj.typeName())
def testTypeNameString(self): def testTypeNameString(self):
'''QVariant(PyString).typeName()''' '''QVariant(PyString).typeName()'''
obj = QVariant('aaaa') obj = QVariant('aaaa')
@ -96,18 +91,6 @@ class QVariantTypeName(unittest.TestCase):
obj = QVariant(['aaa', 'bbb', 'ccc', 'dddd']) obj = QVariant(['aaa', 'bbb', 'ccc', 'dddd'])
self.assertEqual('QVariantList', obj.typeName()) self.assertEqual('QVariantList', obj.typeName())
obj = QVariant([QString('aaa'), QString('bbb'),
QString('ccc'), QString('dddd')])
self.assertEqual('QVariantList', obj.typeName())
def testTypeNameQStringList(self):
'''QVariant(QStringList).typeName()'''
obj = QVariant(QStringList())
self.assertEqual('QStringList', obj.typeName())
obj = QVariant(QStringList(['aaa', 'bbb', 'ccc']))
self.assertEqual('QStringList', obj.typeName())
class QVariantConstructor(unittest.TestCase): class QVariantConstructor(unittest.TestCase):
'''More qvariant constructions''' '''More qvariant constructions'''

4
tests/QtCore/translation_test.py
View file

@ -5,7 +5,7 @@
import os import os
import unittest import unittest
from PySide.QtCore import QObject, QTranslator, QCoreApplication, QString from PySide.QtCore import *
from helper import UsesQCoreApplication from helper import UsesQCoreApplication
@ -54,7 +54,7 @@ class TranslationTest(UsesQCoreApplication):
def testTranslateWithNoneDisambiguation(self): def testTranslateWithNoneDisambiguation(self):
value = 'String here' value = 'String here'
obj = QCoreApplication.translate('context', value, None, QCoreApplication.UnicodeUTF8) obj = QCoreApplication.translate('context', value, None, QCoreApplication.UnicodeUTF8)
self.assert_(isinstance(obj, QString)) self.assert_(isinstance(obj, unicode))
self.assertEqual(obj, value) self.assertEqual(obj, value)
if __name__ == '__main__': if __name__ == '__main__':

2
tests/QtGui/qinputdialog_get_test.py
View file

@ -15,7 +15,7 @@ class TestInputDialog(TimedQApplication):
self.assertEquals(QtGui.QInputDialog.getInteger(None, "title", "label"), (0, False)) self.assertEquals(QtGui.QInputDialog.getInteger(None, "title", "label"), (0, False))
def testGetItem(self): def testGetItem(self):
(item, bool) = QtGui.QInputDialog.getItem(None, "title", "label", QtCore.QStringList(["1", "2", "3"])) (item, bool) = QtGui.QInputDialog.getItem(None, "title", "label", ["1", "2", "3"])
self.assertEquals(str(item), "1") self.assertEquals(str(item), "1")
def testGetText(self): def testGetText(self):

2
tests/QtGui/qpixmap_test.py
View file

@ -16,7 +16,7 @@ class QPixmapTest(UsesQApplication):
self.assert_(pixmap.size().height(), 20) self.assert_(pixmap.size().height(), 20)
def testQStringConstructor(self): def testQStringConstructor(self):
pixmap = QPixmap(QString("Testing!")) pixmap = QPixmap("Testing!")
def testQVariantConstructor2(self): def testQVariantConstructor2(self):
v = QVariant(QPixmap()) v = QVariant(QPixmap())

15
tests/QtGui/qstring_qkeysequence_test.py
View file

@ -5,7 +5,7 @@
import unittest import unittest
from helper import UsesQApplication from helper import UsesQApplication
from PySide.QtCore import QString from PySide.QtCore import *
from PySide.QtGui import QKeySequence, QAction from PySide.QtGui import QKeySequence, QAction
class QStringQKeySequenceTest(UsesQApplication): class QStringQKeySequenceTest(UsesQApplication):
@ -14,21 +14,12 @@ class QStringQKeySequenceTest(UsesQApplication):
def testQStringFromQKeySequence(self): def testQStringFromQKeySequence(self):
'''Creates a QString from a QKeySequence.''' '''Creates a QString from a QKeySequence.'''
keyseq = 'Ctrl+A' keyseq = 'Ctrl+A'
a = QString(QKeySequence(keyseq)) a = QKeySequence(keyseq)
self.assertEqual(a, keyseq) self.assertEqual(a, keyseq)
def testQStringAsQKeySequence(self):
'''Passes a QString to an argument expecting a QKeySequence.'''
keyseq = QString('Ctrl+A')
action = QAction(None)
action.setShortcut(keyseq)
shortcut = action.shortcut()
self.assert_(isinstance(shortcut, QKeySequence))
self.assertEqual(shortcut.toString(), keyseq)
def testPythonStringAsQKeySequence(self): def testPythonStringAsQKeySequence(self):
'''Passes a Python string to an argument expecting a QKeySequence.''' '''Passes a Python string to an argument expecting a QKeySequence.'''
keyseq = 'Ctrl+A' keyseq = u'Ctrl+A'
action = QAction(None) action = QAction(None)
action.setShortcut(keyseq) action.setShortcut(keyseq)
shortcut = action.shortcut() shortcut = action.shortcut()

4
tests/QtSql/qsqldatabaseandqueries_test.py
View file

@ -5,14 +5,14 @@ import sys
import unittest import unittest
from PySide import QtSql from PySide import QtSql
from PySide.QtCore import QVariant, QString from PySide.QtCore import *
class SqlDatabaseCreationDestructionAndQueries(unittest.TestCase): class SqlDatabaseCreationDestructionAndQueries(unittest.TestCase):
'''Test cases for QtSql database creation, destruction and queries''' '''Test cases for QtSql database creation, destruction and queries'''
def setUp(self): def setUp(self):
#Acquire resources #Acquire resources
self.assertFalse(QtSql.QSqlDatabase.drivers().isEmpty(), "installed Qt has no DB drivers") self.assertFalse(not QtSql.QSqlDatabase.drivers(), "installed Qt has no DB drivers")
self.assertTrue("QSQLITE" in QtSql.QSqlDatabase.drivers(), "\"QSQLITE\" driver not available in this Qt version") self.assertTrue("QSQLITE" in QtSql.QSqlDatabase.drivers(), "\"QSQLITE\" driver not available in this Qt version")
self.db = QtSql.QSqlDatabase.addDatabase("QSQLITE") self.db = QtSql.QSqlDatabase.addDatabase("QSQLITE")
self.db.setDatabaseName(":memory:") self.db.setDatabaseName(":memory:")

4
tests/phonon/capabilities_test.py
View file

@ -1,7 +1,7 @@
import unittest import unittest
from PySide.QtCore import QString from PySide.QtCore import *
from PySide import phonon from PySide import phonon
from helper import UsesQCoreApplication from helper import UsesQCoreApplication
@ -36,7 +36,7 @@ class CapabilitiesTest(UsesQCoreApplication):
# TODO Improve this test # TODO Improve this test
mimeTypes = phonon.Phonon.BackendCapabilities.availableMimeTypes() mimeTypes = phonon.Phonon.BackendCapabilities.availableMimeTypes()
for mime in mimeTypes: for mime in mimeTypes:
self.assert_(isinstance(mime, QString)) self.assert_(isinstance(mime, unicode))
def testAudioEffects(self): def testAudioEffects(self):
# TODO Improve this test # TODO Improve this test

4
tests/signals/decorators_test.py
View file

@ -24,7 +24,7 @@ class MyObject(QObject):
def foo(self): def foo(self):
self._slotCalledCount = self._slotCalledCount + 1 self._slotCalledCount = self._slotCalledCount + 1
@Slot(QString, int) @Slot(unicode, int)
def mySlot4(self, a, b): def mySlot4(self, a, b):
self._slotCalledCount = self._slotCalledCount + 1 self._slotCalledCount = self._slotCalledCount + 1
@ -41,7 +41,7 @@ class StaticMetaObjectTest(unittest.TestCase):
self.assert_(m.indexOfSlot('mySlot2(int)') > 0) self.assert_(m.indexOfSlot('mySlot2(int)') > 0)
self.assert_(m.indexOfSlot('mySlot2(QString)') > 0) self.assert_(m.indexOfSlot('mySlot2(QString)') > 0)
self.assert_(m.indexOfSlot('mySlot3()') > 0) self.assert_(m.indexOfSlot('mySlot3()') > 0)
self.assert_(m.indexOfSlot('mySlot4(QString,int)') > 0) self.assert_(m.indexOfSlot('mySlot4(unicode,int)') > 0)
def testEmission(self): def testEmission(self):
o = MyObject() o = MyObject()

8
tests/signals/signal_object_test.py
View file

@ -11,8 +11,8 @@ class MyObject(QTimer):
sig1 = Signal() sig1 = Signal()
sig2 = Signal(int, name='rangeChanged') sig2 = Signal(int, name='rangeChanged')
sig3 = Signal(int) sig3 = Signal(int)
sig4 = Signal((int,), (QString,)) sig4 = Signal((int,), (unicode,))
sig5 = Signal((QString,), (int,)) sig5 = Signal((unicode,), (int,))
@Slot(int) @Slot(int)
@ -50,8 +50,8 @@ class SignalObjectTest(UsesQCoreApplication):
def testDictOperator(self): def testDictOperator(self):
o = MyObject() o = MyObject()
o.sig4[QString].connect(o.slotString) o.sig4[unicode].connect(o.slotString)
o.sig4[QString].emit("PySide") o.sig4[unicode].emit("PySide")
self.assertEqual(o._s, "PySide") self.assertEqual(o._s, "PySide")
def testGeneretedSignal(self): def testGeneretedSignal(self):