From 46163663e956b988719563eae18773a2dedd424e Mon Sep 17 00:00:00 2001 From: Denis Dzyubenko Date: Tue, 12 Apr 2011 14:48:13 +0200 Subject: Added support for libICU for collation and toLower/toUpper. This patch uses icu to do string collation via QString::localeAwareCompare function and for QString::toLower/toUpper - which is important e.g. for turkish locales where uppercased 'i' is not a latin 'I'. Based on the patch by Harald Fernengel Reviewed-by: Harald Fernengel Reviewed-by: Zeno Albisser --- config.tests/unix/icu/icu.cpp | 54 +++++++++ config.tests/unix/icu/icu.pro | 4 + configure | 34 +++++- src/corelib/tools/qlocale.cpp | 14 +++ src/corelib/tools/qlocale_icu.cpp | 224 +++++++++++++++++++++++++++++++++++++ src/corelib/tools/qstring.cpp | 35 +++++- src/corelib/tools/tools.pri | 5 + tests/auto/qstring/qstring.pro | 2 + tests/auto/qstring/tst_qstring.cpp | 55 +++++++++ 9 files changed, 425 insertions(+), 2 deletions(-) create mode 100644 config.tests/unix/icu/icu.cpp create mode 100644 config.tests/unix/icu/icu.pro create mode 100644 src/corelib/tools/qlocale_icu.cpp diff --git a/config.tests/unix/icu/icu.cpp b/config.tests/unix/icu/icu.cpp new file mode 100644 index 0000000..f03b160 --- /dev/null +++ b/config.tests/unix/icu/icu.cpp @@ -0,0 +1,54 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the config.tests of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include +#include + +int main(int, char **) +{ + UErrorCode status = U_ZERO_ERROR; + UCollator *collator = ucol_open("ru_RU", &status); + if (U_FAILURE(status)) + return 0; + ucol_close(collator); + return 0; +} diff --git a/config.tests/unix/icu/icu.pro b/config.tests/unix/icu/icu.pro new file mode 100644 index 0000000..8e58334 --- /dev/null +++ b/config.tests/unix/icu/icu.pro @@ -0,0 +1,4 @@ +SOURCES = icu.cpp +CONFIG -= qt dylib app_bundle +unix:LIBS += -licuuc -licui18n +win32:LIBS += -licuin diff --git a/configure b/configure index 4d25ec2..bf67205 100755 --- a/configure +++ b/configure @@ -832,6 +832,7 @@ CFG_PULSEAUDIO=auto CFG_COREWLAN=auto CFG_ICD=auto CFG_NOPROCESS=no +CFG_ICU=auto # initalize variables used for installation QT_INSTALL_PREFIX= @@ -1040,7 +1041,7 @@ while [ "$#" -gt 0 ]; do VAL=no ;; #Qt style yes options - -incremental|-qvfb|-profile|-shared|-static|-sm|-xinerama|-xshape|-xsync|-xinput|-egl|-reduce-exports|-pch|-separate-debug-info|-stl|-freetype|-xcursor|-xfixes|-xrandr|-xrender|-mitshm|-fontconfig|-xkb|-nis|-qdbus|-dbus|-dbus-linked|-glib|-gstreamer|-gtkstyle|-cups|-iconv|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-accessibility|-confirm-license|-gnumake|-framework|-qt3support|-debug-and-release|-exceptions|-cocoa|-carbon|-universal|-prefix-install|-silent|-armfpa|-optimized-qmake|-dwarf2|-reduce-relocations|-sse|-openssl|-openssl-linked|-ptmalloc|-xmlpatterns|-phonon|-phonon-backend|-multimedia|-audio-backend|-svg|-declarative|-declarative-debug|-javascript-jit|-script|-scripttools|-rpath|-force-pkg-config|-s60|-usedeffiles) + -incremental|-qvfb|-profile|-shared|-static|-sm|-xinerama|-xshape|-xsync|-xinput|-egl|-reduce-exports|-pch|-separate-debug-info|-stl|-freetype|-xcursor|-xfixes|-xrandr|-xrender|-mitshm|-fontconfig|-xkb|-nis|-qdbus|-dbus|-dbus-linked|-glib|-gstreamer|-gtkstyle|-cups|-iconv|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-accessibility|-confirm-license|-gnumake|-framework|-qt3support|-debug-and-release|-exceptions|-cocoa|-carbon|-universal|-prefix-install|-silent|-armfpa|-optimized-qmake|-dwarf2|-reduce-relocations|-sse|-openssl|-openssl-linked|-ptmalloc|-xmlpatterns|-phonon|-phonon-backend|-multimedia|-audio-backend|-svg|-declarative|-declarative-debug|-javascript-jit|-script|-scripttools|-rpath|-force-pkg-config|-s60|-usedeffiles|-icu) VAR=`echo $1 | sed "s,^-\(.*\),\1,"` VAL=yes ;; @@ -2376,6 +2377,13 @@ while [ "$#" -gt 0 ]; do QT_CFLAGS_FPU=$VAL fi ;; + icu) + if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then + CFG_ICU="$VAL" + else + UNKNOWN_OPT=yes + fi + ;; *) UNKNOWN_OPT=yes ;; @@ -5679,6 +5687,25 @@ if [ "$PLATFORM_X11" = "yes" -o "$PLATFORM_QWS" = "yes" -o "$PLATFORM_QPA" = "ye CFG_ICD=no fi + # auto-detect libicu support + if [ "$CFG_ICU" != "no" ]; then + if "$unixtests/compile.test" "$XQMAKESPEC" "$QMAKE_CONFIG" $OPT_VERBOSE "$relpath" "$outpath" config.tests/unix/icu "ICU" $L_FLAGS $I_FLAGS $l_FLAGS; then + [ "$CFG_ICU" = "auto" ] && CFG_ICU=yes + else + if [ "$CFG_ICU" = "auto" ]; then + CFG_ICU=no + elif [ "$CFG_CONFIGURE_EXIT_ON_ERROR" = "yes" ]; then + # CFG_ICU is "yes" + + echo "The ICU library support cannot be enabled." + echo " Turn on verbose messaging (-v) to $0 to see the final report." + echo " If you believe this message is in error you may use the continue" + echo " switch (-continue) to $0 to continue." + exit 101 + fi + fi + fi + # Auto-detect PulseAudio support if [ "$CFG_PULSEAUDIO" != "no" ]; then if [ -n "$PKG_CONFIG" ]; then @@ -7337,6 +7364,10 @@ if [ "$CFG_ICD" = "yes" ]; then QT_CONFIG="$QT_CONFIG icd" fi +if [ "$CFG_ICU" = "yes" ]; then + QT_CONFIG="$QT_CONFIG icu" +fi + # # Some Qt modules are too advanced in C++ for some old compilers # Detect here the platforms where they are known to work. @@ -8727,6 +8758,7 @@ if [ "$PLATFORM_MAC" = "yes" ]; then echo "CoreWlan support ....... $CFG_COREWLAN" fi echo "ICD support ............ $CFG_ICD" +echo "libICU support ......... $CFG_ICU" echo [ "$CFG_PTMALLOC" != "no" ] && echo "Use ptmalloc ........... $CFG_PTMALLOC" diff --git a/src/corelib/tools/qlocale.cpp b/src/corelib/tools/qlocale.cpp index d986b9b..5c4085a 100644 --- a/src/corelib/tools/qlocale.cpp +++ b/src/corelib/tools/qlocale.cpp @@ -86,6 +86,10 @@ static QLocalePrivate *system_lp = 0; Q_GLOBAL_STATIC(QLocalePrivate, globalLocalePrivate) #endif +#ifdef QT_USE_ICU +extern bool qt_initIcu(const QString &localeName); +#endif + /****************************************************************************** ** Helpers for accessing Qt locale database */ @@ -520,6 +524,12 @@ void QLocalePrivate::updateSystemPrivate() res = sys_locale->query(QSystemLocale::PositiveSign, QVariant()); if (!res.isNull()) system_lp->m_plus = res.toString().at(0).unicode(); + +#ifdef QT_USE_ICU + if (!default_lp) + qt_initIcu(system_lp->bcp47Name()); +#endif + } #endif @@ -879,6 +889,10 @@ void QLocale::setDefault(const QLocale &locale) { default_lp = locale.d(); default_number_options = locale.numberOptions(); + +#ifdef QT_USE_ICU + qt_initIcu(locale.bcp47Name()); +#endif } /*! diff --git a/src/corelib/tools/qlocale_icu.cpp b/src/corelib/tools/qlocale_icu.cpp new file mode 100644 index 0000000..0e283dd --- /dev/null +++ b/src/corelib/tools/qlocale_icu.cpp @@ -0,0 +1,224 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qglobal.h" +#include "qlibrary.h" +#include "qdebug.h" + +#include "unicode/uversion.h" +#include "unicode/ucol.h" + +QT_BEGIN_NAMESPACE + +typedef UCollator *(*Ptr_ucol_open)(const char *loc, UErrorCode *status); +typedef void (*Ptr_ucol_close)(UCollator *coll); +typedef UCollationResult (*Ptr_ucol_strcoll)(const UCollator *coll, const UChar *source, int32_t sourceLength, const UChar *target, int32_t targetLength); +typedef int32_t (*Ptr_u_strToCase)(UChar *dest, int32_t destCapacity, const UChar *src, int32_t srcLength, const char *locale, UErrorCode *pErrorCode); + +static Ptr_ucol_open ptr_ucol_open = 0; +static Ptr_ucol_strcoll ptr_ucol_strcoll = 0; +static Ptr_ucol_close ptr_ucol_close = 0; +static Ptr_u_strToCase ptr_u_strToUpper = 0; +static Ptr_u_strToCase ptr_u_strToLower = 0; + +enum LibLoadStatus +{ + ErrorLoading = -1, + NotLoaded = 0, + Loaded = 1 +}; + +static LibLoadStatus status = NotLoaded; + +static UCollator *icuCollator = 0; + +#define STRINGIFY2(x) #x +#define STRINGIFY(x) STRINGIFY2(x) + +bool qt_initIcu(const QString &localeString) +{ + if (status == ErrorLoading) + return false; + + if (status == NotLoaded) { + + // resolve libicui18n + QLibrary lib(QLatin1String("icui18n"), QLatin1String(U_ICU_VERSION_SHORT)); + if (!lib.load()) { + qWarning() << "Unable to load library icui18n" << lib.errorString(); + status = ErrorLoading; + return false; + } + + ptr_ucol_open = (Ptr_ucol_open)lib.resolve("ucol_open"); + ptr_ucol_close = (Ptr_ucol_close)lib.resolve("ucol_close"); + ptr_ucol_strcoll = (Ptr_ucol_strcoll)lib.resolve("ucol_strcoll"); + + if (!ptr_ucol_open || !ptr_ucol_close || !ptr_ucol_strcoll) { + // try again with decorated symbol names + ptr_ucol_open = (Ptr_ucol_open)lib.resolve("ucol_open" STRINGIFY(U_ICU_VERSION_SUFFIX)); + ptr_ucol_close = (Ptr_ucol_close)lib.resolve("ucol_close" STRINGIFY(U_ICU_VERSION_SUFFIX)); + ptr_ucol_strcoll = (Ptr_ucol_strcoll)lib.resolve("ucol_strcoll" STRINGIFY(U_ICU_VERSION_SUFFIX)); + } + + if (!ptr_ucol_open || !ptr_ucol_close || !ptr_ucol_strcoll) { + ptr_ucol_open = 0; + ptr_ucol_close = 0; + ptr_ucol_strcoll = 0; + + qWarning("Unable to find symbols in icui18n"); + status = ErrorLoading; + return false; + } + + // resolve libicuuc + QLibrary ucLib(QLatin1String("icuuc"), QLatin1String(U_ICU_VERSION_SHORT)); + if (!ucLib.load()) { + qWarning() << "Unable to load library icuuc" << ucLib.errorString(); + status = ErrorLoading; + return false; + } + + ptr_u_strToUpper = (Ptr_u_strToCase)ucLib.resolve("u_strToUpper"); + ptr_u_strToLower = (Ptr_u_strToCase)ucLib.resolve("u_strToLower"); + + if (!ptr_u_strToUpper || !ptr_u_strToLower) { + ptr_u_strToUpper = (Ptr_u_strToCase)ucLib.resolve("u_strToUpper" STRINGIFY(U_ICU_VERSION_SUFFIX)); + ptr_u_strToLower = (Ptr_u_strToCase)ucLib.resolve("u_strToLower" STRINGIFY(U_ICU_VERSION_SUFFIX)); + } + + if (!ptr_u_strToUpper || !ptr_u_strToLower) { + ptr_u_strToUpper = 0; + ptr_u_strToLower = 0; + + qWarning("Unable to find symbols in icuuc"); + status = ErrorLoading; + return false; + } + + // success :) + status = Loaded; + } + + if (icuCollator) { + ptr_ucol_close(icuCollator); + icuCollator = 0; + } + + UErrorCode icuStatus = U_ZERO_ERROR; + icuCollator = ptr_ucol_open(localeString.toLatin1().constData(), &icuStatus); + + if (!icuCollator) { + qWarning("Unable to open locale %s in ICU, error code %d", qPrintable(localeString), icuStatus); + return false; + } + + return true; +} + +bool qt_ucol_strcoll(const QChar *source, int sourceLength, const QChar *target, int targetLength, int *result) +{ + Q_ASSERT(result); + Q_ASSERT(source); + Q_ASSERT(target); + + if (!icuCollator) + return false; + + *result = ptr_ucol_strcoll(icuCollator, reinterpret_cast(source), int32_t(sourceLength), + reinterpret_cast(target), int32_t(targetLength)); + + return true; +} + +// caseFunc can either be u_strToUpper or u_strToLower +static bool qt_u_strToCase(const QString &str, QString *out, const QLocale &locale, Ptr_u_strToCase caseFunc) +{ + Q_ASSERT(out); + + if (!icuCollator) + return false; + + QString result(str.size(), Qt::Uninitialized); + + UErrorCode status = U_ZERO_ERROR; + + int32_t size = caseFunc(reinterpret_cast(result.data()), result.size(), + reinterpret_cast(str.constData()), str.size(), + locale.bcp47Name().toLatin1().constData(), &status); + + if (U_FAILURE(status)) + return false; + + if (size < result.size()) { + result.resize(size); + } else if (size > result.size()) { + // the resulting string is larger than our source string + result.resize(size); + + status = U_ZERO_ERROR; + size = caseFunc(reinterpret_cast(result.data()), result.size(), + reinterpret_cast(str.constData()), str.size(), + locale.bcp47Name().toLatin1().constData(), &status); + + if (U_FAILURE(status)) + return false; + + // if the sizes don't match now, we give up. + if (size != result.size()) + return false; + } + + *out = result; + return true; +} + +bool qt_u_strToUpper(const QString &str, QString *out, const QLocale &locale) +{ + return qt_u_strToCase(str, out, locale, ptr_u_strToUpper); +} + +bool qt_u_strToLower(const QString &str, QString *out, const QLocale &locale) +{ + return qt_u_strToCase(str, out, locale, ptr_u_strToLower); +} + +QT_END_NAMESPACE diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp index b7272ec..5493ba9 100644 --- a/src/corelib/tools/qstring.cpp +++ b/src/corelib/tools/qstring.cpp @@ -106,6 +106,14 @@ QTextCodec *QString::codecForCStrings; static QHash *asciiCache = 0; #endif +#ifdef QT_USE_ICU +// qlocale_icu.cpp +extern bool qt_ucol_strcoll(const QChar *source, int sourceLength, const QChar *target, int targetLength, int *result); +extern bool qt_u_strToUpper(const QString &str, QString *out, const QLocale &locale); +extern bool qt_u_strToLower(const QString &str, QString *out, const QLocale &locale); +#endif + + // internal int qFindString(const QChar *haystack, int haystackLen, int from, const QChar *needle, int needleLen, Qt::CaseSensitivity cs); @@ -431,7 +439,6 @@ const QString::Null QString::null = { }; \ingroup shared \ingroup string-processing - QString stores a string of 16-bit \l{QChar}s, where each QChar corresponds one Unicode 4.0 character. (Unicode characters with code values above 65535 are stored using surrogate pairs, @@ -4829,6 +4836,14 @@ int QString::localeAwareCompare_helper(const QChar *data1, int length1, TPtrC p2 = TPtrC16(reinterpret_cast(data2), length2); return p1.CompareC(p2); #elif defined(Q_OS_UNIX) +# if defined(QT_USE_ICU) + int res; + if (qt_ucol_strcoll(data1, length1, data2, length2, &res)) { + if (res == 0) + res = ucstrcmp(data1, length1, data2, length2); + return res; + } // else fall through +# endif // declared in int delta = strcoll(toLocal8Bit_helper(data1, length1), toLocal8Bit_helper(data2, length2)); if (delta == 0) @@ -4964,6 +4979,15 @@ QString QString::toLower() const if (!d->size) return *this; +#ifdef QT_USE_ICU + { + QString result; + if (qt_u_strToLower(*this, &result, QLocale())) + return result; + // else fall through and use Qt's toUpper + } +#endif + const ushort *e = d->data + d->size; // this avoids one out of bounds check in the loop @@ -5055,6 +5079,15 @@ QString QString::toUpper() const if (!d->size) return *this; +#ifdef QT_USE_ICU + { + QString result; + if (qt_u_strToUpper(*this, &result, QLocale())) + return result; + // else fall through and use Qt's toUpper + } +#endif + const ushort *e = d->data + d->size; // this avoids one out of bounds check in the loop diff --git a/src/corelib/tools/tools.pri b/src/corelib/tools/tools.pri index 849dc63..0c2cf16 100644 --- a/src/corelib/tools/tools.pri +++ b/src/corelib/tools/tools.pri @@ -97,6 +97,11 @@ else:SOURCES += tools/qelapsedtimer_generic.cpp contains(QT_CONFIG, zlib):include($$PWD/../../3rdparty/zlib.pri) else:include($$PWD/../../3rdparty/zlib_dependency.pri) +contains(QT_CONFIG,icu) { + SOURCES += tools/qlocale_icu.cpp + DEFINES += QT_USE_ICU +} + DEFINES += HB_EXPORT=Q_CORE_EXPORT INCLUDEPATH += ../3rdparty/harfbuzz/src HEADERS += ../3rdparty/harfbuzz/src/harfbuzz.h diff --git a/tests/auto/qstring/qstring.pro b/tests/auto/qstring/qstring.pro index e980042..1c123ad 100644 --- a/tests/auto/qstring/qstring.pro +++ b/tests/auto/qstring/qstring.pro @@ -7,3 +7,5 @@ QT = core DEFINES += QT_NO_CAST_TO_ASCII CONFIG += parallel_test + +contains(QT_CONFIG,icu):DEFINES += QT_USE_ICU diff --git a/tests/auto/qstring/tst_qstring.cpp b/tests/auto/qstring/tst_qstring.cpp index 25e16fe..3d80e80 100644 --- a/tests/auto/qstring/tst_qstring.cpp +++ b/tests/auto/qstring/tst_qstring.cpp @@ -222,6 +222,8 @@ private slots: void task262677remove(); void QTBUG10404_compareRef(); void QTBUG9281_arg_locale(); + + void toUpperLower_icu(); }; typedef QList IntList; @@ -1603,6 +1605,11 @@ void tst_QString::toUpper() QCOMPARE( lower.toUpper(), upper); +#ifdef QT_USE_ICU + // test doesn't work with ICU support, since QChar is unaware of any locale + QEXPECT_FAIL("", "test doesn't work with ICU support, since QChar is unaware of any locale", Continue); + QVERIFY(false); +#else for (int i = 0; i < 65536; ++i) { QString str(1, QChar(i)); QString upper = str.toUpper(); @@ -1610,6 +1617,7 @@ void tst_QString::toUpper() if (upper.length() == 1) QVERIFY(upper == QString(1, QChar(i).toUpper())); } +#endif } void tst_QString::toLower() @@ -1641,6 +1649,11 @@ void tst_QString::toLower() upper += QChar(QChar::lowSurrogate(0x10400)); QCOMPARE( upper.toLower(), lower); +#ifdef QT_USE_ICU + // test doesn't work with ICU support, since QChar is unaware of any locale + QEXPECT_FAIL("", "test doesn't work with ICU support, since QChar is unaware of any locale", Continue); + QVERIFY(false); +#else for (int i = 0; i < 65536; ++i) { QString str(1, QChar(i)); QString lower = str.toLower(); @@ -1648,6 +1661,7 @@ void tst_QString::toLower() if (lower.length() == 1) QVERIFY(str.toLower() == QString(1, QChar(i).toLower())); } +#endif } void tst_QString::trimmed() @@ -4352,6 +4366,8 @@ void tst_QString::localeAwareCompare() #elif defined (Q_WS_MAC) QSKIP("Setting the locale is not supported on OS X (you can set the C locale, but that won't affect CFStringCompare which is used to compare strings)", SkipAll); +#elif defined(QT_USE_ICU) + QLocale::setDefault(QLocale(locale)); #else if (!locale.isEmpty()) { const char *newLocale = setlocale(LC_ALL, locale.toLatin1()); @@ -4363,6 +4379,11 @@ void tst_QString::localeAwareCompare() } #endif +#ifdef QT_USE_ICU + // ### for c1, ICU disagrees with libc on how to compare + QEXPECT_FAIL("c1", "ICU disagrees with test", Abort); +#endif + int testres = QString::localeAwareCompare(s1, s2); if (result < 0) { QVERIFY(testres < 0); @@ -5065,6 +5086,40 @@ void tst_QString::QTBUG9281_arg_locale() QLocale::setDefault(QLocale::C); } +void tst_QString::toUpperLower_icu() +{ +#ifndef QT_USE_ICU + QSKIP("Qt was built without ICU support", SkipAll); +#endif + + QString s = QString::fromLatin1("i"); + + QCOMPARE(s.toUpper(), QString::fromLatin1("I")); + QCOMPARE(s.toLower(), QString::fromLatin1("i")); + + QLocale::setDefault(QLocale(QLocale::Turkish, QLocale::Turkey)); + + // turkish locale has a capital I with a dot (U+0130, utf8 c4b0) + + QCOMPARE(s.toUpper(), QString::fromUtf8("\xc4\xb0")); + QCOMPARE(QString::fromUtf8("\xc4\xb0").toLower(), s); + + // nothing should happen here + QCOMPARE(s.toLower(), s); + QCOMPARE(QString::fromLatin1("I").toUpper(), QString::fromLatin1("I")); + + // U+0131, utf8 c4b1 is the lower-case i without a dot + QString sup = QString::fromUtf8("\xc4\xb1"); + + QCOMPARE(sup.toUpper(), QString::fromLatin1("I")); + QCOMPARE(QString::fromLatin1("I").toLower(), sup); + + // nothing should happen here + QCOMPARE(sup.toLower(), sup); + QCOMPARE(QString::fromLatin1("i").toLower(), QString::fromLatin1("i")); + + // the cleanup function will restore the default locale +} QTEST_APPLESS_MAIN(tst_QString) -- cgit v0.12