--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qtmobility/tests/auto/qlatin1constant/tst_qlatin1constant.cpp	Mon May 03 13:18:40 2010 +0300
@@ -0,0 +1,299 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $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 <QtTest/QtTest>
+
+#include "qtcontactsglobal.h"
+#include <QSet>
+#include <QMetaType>
+#include <QTypeInfo>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+QTM_USE_NAMESPACE
+
+Q_DEFINE_LATIN1_CONSTANT(a, "a");
+Q_DEFINE_LATIN1_CONSTANT(a2, "a");
+Q_DEFINE_LATIN1_CONSTANT(b, "b");
+Q_DEFINE_LATIN1_CONSTANT(b2, "b");
+Q_DEFINE_LATIN1_CONSTANT(bb, "bb");
+Q_DEFINE_LATIN1_CONSTANT(bb2, "bb");
+
+Q_DEFINE_LATIN1_CONSTANT(z, "");
+Q_DEFINE_LATIN1_CONSTANT(z2, "");
+
+Q_DEFINE_LATIN1_CONSTANT(z3, "\0");
+Q_DEFINE_LATIN1_CONSTANT(soup, "alphabet soup"); // but you can't have any
+
+QLatin1String ln(0);
+QLatin1String lz("");
+QLatin1String la("a");
+QLatin1String lb("b");
+QLatin1String lbb("bb");
+QLatin1String lsoup("alphabet soup");
+
+QString sn;
+QString sz("");
+QString sa(la);
+QString sb(lb);
+QString sbb(lbb);
+QString ssoup("alphabet soup");
+
+class tst_QLatin1Constant: public QObject
+{
+Q_OBJECT
+
+public:
+    tst_QLatin1Constant();
+    virtual ~tst_QLatin1Constant();
+
+    // Overload testers
+    int overloaded(const char *) {return 1;}
+    //int overloaded(const QLatin1String& ) {return 2;}
+    int overloaded(QLatin1String ) {return 3;}
+    int overloaded(const QString& ) {return 4;}
+    //int overloaded(QString ){return 5;}
+    //template<int N> int overloaded(const QLatin1Constant<N>& ) {return 6;}
+    template<int N> int overloaded(QLatin1Constant<N> ) {return 7;}
+    int overloaded(const QVariant&) {return 8;}
+
+    // More overload testers
+    int overloaded2(QLatin1String) {return 3;}
+    int overloaded2(const QString&) {return 4;}
+
+    int overloaded3(const char*) {return 1;}
+    int overloaded3(QLatin1String) {return 3;}
+
+    int overloaded4(const char*) {return 1;}
+    int overloaded4(const QString&) {return 4;}
+
+    // Conversion testers
+    bool charfunc(const char* str) {return qstrcmp(str, "alphabet soup") == 0;}
+    bool latfunc(QLatin1String lat) {return qstrcmp(lat.latin1(), "alphabet soup") == 0;}
+    bool latreffunc(const QLatin1String& lat) {return qstrcmp(lat.latin1(), "alphabet soup") == 0;}
+    bool strfunc(QString str) {return str == QString::fromAscii("alphabet soup");}
+    bool strreffunc(const QString& str) {return str == QString::fromAscii("alphabet soup");}
+    bool varfunc(const QVariant& var) {return (var.type() == QVariant::String) && var.toString() == QString::fromAscii("alphabet soup");}
+
+private slots:
+    void hash();
+    void conversion();
+    void overloads();
+    void equals();
+    void latinEquals();
+    void stringEquals();
+    void ordering();
+    void latinaccessor();
+};
+
+tst_QLatin1Constant::tst_QLatin1Constant()
+{
+}
+
+tst_QLatin1Constant::~tst_QLatin1Constant()
+{
+}
+
+void tst_QLatin1Constant::hash()
+{
+    // Test that if a == b, hash(a) == hash(b)
+    // (also for ===)
+    QVERIFY(qHash(a) == qHash(a));
+    QVERIFY(qHash(a) == qHash(a2));
+    QVERIFY(qHash(b) == qHash(b));
+    QVERIFY(qHash(b) == qHash(b));
+    QVERIFY(qHash(bb) == qHash(bb));
+    QVERIFY(qHash(bb) == qHash(bb));
+
+    // As a convenience, make sure that hashing
+    // the same string gives the same results
+    // no matter the storage
+    QVERIFY(qHash(a) == qHash(la));
+    QVERIFY(qHash(a) == qHash(sa));
+}
+
+void tst_QLatin1Constant::equals()
+{
+    // Check symmetry and dupes
+    QVERIFY(a == a);
+    QVERIFY(a == a2);
+    QVERIFY(a2 == a);
+    QVERIFY(b == b);
+    QVERIFY(b == b2);
+    QVERIFY(b2 == b2);
+    QVERIFY(bb == bb);
+    QVERIFY(bb == bb2);
+    QVERIFY(bb2 == bb);
+
+    QVERIFY(z == z);
+    QVERIFY(z == z2);
+    QVERIFY(z2 == z);
+
+    // Now make sure that the length is taken into account
+    QVERIFY(b != bb2);
+    QVERIFY(bb2 != b);
+    QVERIFY(a != z);
+    QVERIFY(z != a);
+
+    // and just in case something is really wrong
+    QVERIFY(a != b);
+    QVERIFY(b != a);
+}
+
+void tst_QLatin1Constant::latinaccessor()
+{
+    QVERIFY(a.chars == a.latin1());
+    QVERIFY(z.latin1() == z.chars);
+}
+
+void tst_QLatin1Constant::latinEquals()
+{
+    // Test operator== with latin1 strings
+    QVERIFY(a == la);
+    QVERIFY(la == a);
+    QVERIFY(a2 == la);
+    QVERIFY(la == a2);
+    QVERIFY(b == lb);
+    QVERIFY(lb == b);
+    QVERIFY(bb == lbb);
+    QVERIFY(lbb == bb);
+
+    QVERIFY(b != lbb);
+    QVERIFY(lbb != b);
+
+    QVERIFY(a != lb);
+    QVERIFY(lb != a);
+
+    QVERIFY(z == lz);
+    QVERIFY((z == ln) == (lz == ln)); // QLatin1String(0) != QLatin1String("")
+    QVERIFY(lz == z);
+    QVERIFY((ln == z) == (ln == lz));
+}
+
+void tst_QLatin1Constant::stringEquals()
+{
+    // Test operator== with QStrings
+    QVERIFY(a == sa);
+    QVERIFY(sa == a);
+    QVERIFY(a2 == sa);
+    QVERIFY(sa == a2);
+    QVERIFY(b == sb);
+    QVERIFY(sb == b);
+    QVERIFY(bb == sbb);
+    QVERIFY(sbb == bb);
+
+    QVERIFY(b != sbb);
+    QVERIFY(sbb != b);
+
+    QVERIFY(a != sb);
+    QVERIFY(sb != a);
+
+    QVERIFY(z == sz);
+    QVERIFY((z == sn) == (sz == sn)); // QString(0) != QString("")
+    QVERIFY(sz == z);
+    QVERIFY((sn == z) == (sn == sz));
+}
+
+void tst_QLatin1Constant::conversion()
+{
+    QVERIFY(charfunc("alphabet soup"));
+    QVERIFY(charfunc(soup.chars));
+    QVERIFY(charfunc(soup.latin1()));
+
+    QVERIFY(latfunc(lsoup));
+    QVERIFY(latreffunc(lsoup));
+
+    QVERIFY(strfunc(ssoup));
+    QVERIFY(strreffunc(ssoup));
+
+    // See if soup gets converted appropriately
+    QVERIFY(latfunc(soup));
+    QVERIFY(strfunc(soup));
+    QVERIFY(latreffunc(soup));
+    QVERIFY(strreffunc(soup));
+    QVERIFY(varfunc(soup));
+
+    // Now we also want to make sure that converting to QLatin1String doesn't copy the string
+    QLatin1String lsoup2 = soup; // implicit operator QLatin1String
+    QLatin1String lsoup3 = (QLatin1String) soup; // explicit operator QLatin1String
+    QLatin1String lsoup4 = QLatin1String(soup); // implicit operator QLatin1String
+
+    QVERIFY(lsoup2.latin1() == soup.latin1());
+    QVERIFY(lsoup3.latin1() == soup.latin1());
+    QVERIFY(lsoup4.latin1() == soup.latin1());
+}
+
+void tst_QLatin1Constant::overloads()
+{
+    QVERIFY(overloaded("alphabet soup") == 1);
+    QVERIFY(overloaded(soup) == 7);
+    QVERIFY(overloaded(lsoup) == 2 || overloaded(lsoup) == 3);
+    QVERIFY(overloaded(ssoup) == 4 || overloaded(ssoup) == 5);
+
+    QVERIFY(overloaded2(lsoup) == 3);
+    QVERIFY(overloaded2(ssoup) == 4);
+    QCOMPARE(overloaded2(soup.latin1()), 4); // XXX grr, can't call with just soup [ambiguous], this goes to QString
+
+    QVERIFY(overloaded3(lsoup) == 3);
+    QCOMPARE(overloaded3(soup), 3); // XXX this goes with QLatin1String
+
+    QVERIFY(overloaded4(ssoup) == 4);
+    QCOMPARE(overloaded4(soup), 4); // XXX this goes with QString
+}
+
+void tst_QLatin1Constant::ordering()
+{
+    QVERIFY(z < a);
+    QVERIFY(!(a < z));
+    QVERIFY(a < b);
+    QVERIFY(!(b < a));
+    QVERIFY(a < bb);
+    QVERIFY(!(bb < a));
+    QVERIFY(b < bb);
+    QVERIFY(!(bb < b));
+
+    QVERIFY(!(a < a));
+    QVERIFY(!(z < z));
+}
+
+QTEST_MAIN(tst_QLatin1Constant)
+#include "tst_qlatin1constant.moc"