1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 

    44 #include "qtcontactsglobal.h"

    45 #include <QSet>

    46 #include <QMetaType>

    47 #include <QTypeInfo>

    48 

    49 //TESTED_CLASS=

    50 //TESTED_FILES=

    51 

    52 QTM_USE_NAMESPACE

    53 

    54 Q_DEFINE_LATIN1_CONSTANT(a, "a");

    55 Q_DEFINE_LATIN1_CONSTANT(a2, "a");

    56 Q_DEFINE_LATIN1_CONSTANT(b, "b");

    57 Q_DEFINE_LATIN1_CONSTANT(b2, "b");

    58 Q_DEFINE_LATIN1_CONSTANT(bb, "bb");

    59 Q_DEFINE_LATIN1_CONSTANT(bb2, "bb");

    60 

    61 Q_DEFINE_LATIN1_CONSTANT(z, "");

    62 Q_DEFINE_LATIN1_CONSTANT(z2, "");

    63 

    64 Q_DEFINE_LATIN1_CONSTANT(z3, "\0");

    65 Q_DEFINE_LATIN1_CONSTANT(soup, "alphabet soup"); // but you can't have any

    66 

    67 QLatin1String ln(0);

    68 QLatin1String lz("");

    69 QLatin1String la("a");

    70 QLatin1String lb("b");

    71 QLatin1String lbb("bb");

    72 QLatin1String lsoup("alphabet soup");

    73 

    74 QString sn;

    75 QString sz("");

    76 QString sa(la);

    77 QString sb(lb);

    78 QString sbb(lbb);

    79 QString ssoup("alphabet soup");

    80 

    81 class tst_QLatin1Constant: public QObject

    82 {

    83 Q_OBJECT

    84 

    85 public:

    86     tst_QLatin1Constant();

    87     virtual ~tst_QLatin1Constant();

    88 

    89     // Overload testers

    90     int overloaded(const char *) {return 1;}

    91     //int overloaded(const QLatin1String& ) {return 2;}

    92     int overloaded(QLatin1String ) {return 3;}

    93     int overloaded(const QString& ) {return 4;}

    94     //int overloaded(QString ){return 5;}

    95     //template<int N> int overloaded(const QLatin1Constant<N>& ) {return 6;}

    96     template<int N> int overloaded(QLatin1Constant<N> ) {return 7;}

    97     int overloaded(const QVariant&) {return 8;}

    98 

    99     // More overload testers

   100     int overloaded2(QLatin1String) {return 3;}

   101     int overloaded2(const QString&) {return 4;}

   102 

   103     int overloaded3(const char*) {return 1;}

   104     int overloaded3(QLatin1String) {return 3;}

   105 

   106     int overloaded4(const char*) {return 1;}

   107     int overloaded4(const QString&) {return 4;}

   108 

   109     // Conversion testers

   110     bool charfunc(const char* str) {return qstrcmp(str, "alphabet soup") == 0;}

   111     bool latfunc(QLatin1String lat) {return qstrcmp(lat.latin1(), "alphabet soup") == 0;}

   112     bool latreffunc(const QLatin1String& lat) {return qstrcmp(lat.latin1(), "alphabet soup") == 0;}

   113     bool strfunc(QString str) {return str == QString::fromAscii("alphabet soup");}

   114     bool strreffunc(const QString& str) {return str == QString::fromAscii("alphabet soup");}

   115     bool varfunc(const QVariant& var) {return (var.type() == QVariant::String) && var.toString() == QString::fromAscii("alphabet soup");}

   116 

   117 private slots:

   118     void hash();

   119     void conversion();

   120     void overloads();

   121     void equals();

   122     void latinEquals();

   123     void stringEquals();

   124     void ordering();

   125     void latinaccessor();

   126 };

   127 

   128 tst_QLatin1Constant::tst_QLatin1Constant()

   129 {

   130 }

   131 

   132 tst_QLatin1Constant::~tst_QLatin1Constant()

   133 {

   134 }

   135 

   136 void tst_QLatin1Constant::hash()

   137 {

   138     // Test that if a == b, hash(a) == hash(b)

   139     // (also for ===)

   140     QVERIFY(qHash(a) == qHash(a));

   141     QVERIFY(qHash(a) == qHash(a2));

   142     QVERIFY(qHash(b) == qHash(b));

   143     QVERIFY(qHash(b) == qHash(b));

   144     QVERIFY(qHash(bb) == qHash(bb));

   145     QVERIFY(qHash(bb) == qHash(bb));

   146 

   147     // As a convenience, make sure that hashing

   148     // the same string gives the same results

   149     // no matter the storage

   150     QVERIFY(qHash(a) == qHash(la));

   151     QVERIFY(qHash(a) == qHash(sa));

   152 }

   153 

   154 void tst_QLatin1Constant::equals()

   155 {

   156     // Check symmetry and dupes

   157     QVERIFY(a == a);

   158     QVERIFY(a == a2);

   159     QVERIFY(a2 == a);

   160     QVERIFY(b == b);

   161     QVERIFY(b == b2);

   162     QVERIFY(b2 == b2);

   163     QVERIFY(bb == bb);

   164     QVERIFY(bb == bb2);

   165     QVERIFY(bb2 == bb);

   166 

   167     QVERIFY(z == z);

   168     QVERIFY(z == z2);

   169     QVERIFY(z2 == z);

   170 

   171     QVERIFY(z != z3);

   172     QVERIFY(z3 != z);

   173 

   174     // Now make sure that the length is taken into account

   175     QVERIFY(b != bb2);

   176     QVERIFY(bb2 != b);

   177     QVERIFY(a != z);

   178     QVERIFY(z != a);

   179 

   180     // and just in case something is really wrong

   181     QVERIFY(a != b);

   182     QVERIFY(b != a);

   183 }

   184 

   185 void tst_QLatin1Constant::latinaccessor()

   186 {

   187     QVERIFY(a.chars == a.latin1());

   188     QVERIFY(z.latin1() == z.chars);

   189 }

   190 

   191 void tst_QLatin1Constant::latinEquals()

   192 {

   193     // Test operator== with latin1 strings

   194     QVERIFY(a == la);

   195     QVERIFY(la == a);

   196     QVERIFY(a2 == la);

   197     QVERIFY(la == a2);

   198     QVERIFY(b == lb);

   199     QVERIFY(lb == b);

   200     QVERIFY(bb == lbb);

   201     QVERIFY(lbb == bb);

   202 

   203     QVERIFY(b != lbb);

   204     QVERIFY(lbb != b);

   205 

   206     QVERIFY(a != lb);

   207     QVERIFY(lb != a);

   208 

   209     QVERIFY(z == lz);

   210     QVERIFY((z == ln) == (lz == ln)); // QLatin1String(0) != QLatin1String("")

   211     QVERIFY(lz == z);

   212     QVERIFY((ln == z) == (ln == lz));

   213 }

   214 

   215 void tst_QLatin1Constant::stringEquals()

   216 {

   217     // Test operator== with QStrings

   218     QVERIFY(a == sa);

   219     QVERIFY(sa == a);

   220     QVERIFY(a2 == sa);

   221     QVERIFY(sa == a2);

   222     QVERIFY(b == sb);

   223     QVERIFY(sb == b);

   224     QVERIFY(bb == sbb);

   225     QVERIFY(sbb == bb);

   226 

   227     QVERIFY(b != sbb);

   228     QVERIFY(sbb != b);

   229 

   230     QVERIFY(a != sb);

   231     QVERIFY(sb != a);

   232 

   233     QVERIFY(z == sz);

   234     QVERIFY((z == sn) == (sz == sn)); // QString(0) != QString("")

   235     QVERIFY(sz == z);

   236     QVERIFY((sn == z) == (sn == sz));

   237 }

   238 

   239 void tst_QLatin1Constant::conversion()

   240 {

   241     QVERIFY(charfunc("alphabet soup"));

   242     QVERIFY(charfunc(soup.chars));

   243     QVERIFY(charfunc(soup.latin1()));

   244 

   245     QVERIFY(latfunc(lsoup));

   246     QVERIFY(latreffunc(lsoup));

   247 

   248     QVERIFY(strfunc(ssoup));

   249     QVERIFY(strreffunc(ssoup));

   250 

   251     // See if soup gets converted appropriately

   252     QVERIFY(latfunc(soup));

   253     QVERIFY(strfunc(soup));

   254     QVERIFY(latreffunc(soup));

   255     QVERIFY(strreffunc(soup));

   256     QVERIFY(varfunc(soup));

   257 

   258     // Now we also want to make sure that converting to QLatin1String doesn't copy the string

   259     QLatin1String lsoup2 = soup; // implicit operator QLatin1String

   260     QLatin1String lsoup3 = (QLatin1String) soup; // explicit operator QLatin1String

   261     QLatin1String lsoup4 = QLatin1String(soup); // implicit operator QLatin1String

   262 

   263     QVERIFY(lsoup2.latin1() == soup.latin1());

   264     QVERIFY(lsoup3.latin1() == soup.latin1());

   265     QVERIFY(lsoup4.latin1() == soup.latin1());

   266 }

   267 

   268 void tst_QLatin1Constant::overloads()

   269 {

   270     QVERIFY(overloaded("alphabet soup") == 1);

   271     QVERIFY(overloaded(soup) == 7);

   272     QVERIFY(overloaded(lsoup) == 2 || overloaded(lsoup) == 3);

   273     QVERIFY(overloaded(ssoup) == 4 || overloaded(ssoup) == 5);

   274 

   275     QVERIFY(overloaded2(lsoup) == 3);

   276     QVERIFY(overloaded2(ssoup) == 4);

   277     QCOMPARE(overloaded2(soup.latin1()), 4); // XXX grr, can't call with just soup [ambiguous], this goes to QString

   278 

   279     QVERIFY(overloaded3(lsoup) == 3);

   280     QCOMPARE(overloaded3(soup), 3); // XXX this goes with QLatin1String

   281 

   282     QVERIFY(overloaded4(ssoup) == 4);

   283     QCOMPARE(overloaded4(soup), 4); // XXX this goes with QString

   284 }

   285 

   286 void tst_QLatin1Constant::ordering()

   287 {

   288     QVERIFY(z < a);

   289     QVERIFY(!(a < z));

   290     QVERIFY(a < b);

   291     QVERIFY(!(b < a));

   292     QVERIFY(a < bb);

   293     QVERIFY(!(bb < a));

   294     QVERIFY(b < bb);

   295     QVERIFY(!(bb < b));

   296 

   297     QVERIFY(!(a < a));

   298     QVERIFY(!(z < z));

   299 }

   300 

   301 QTEST_MAIN(tst_QLatin1Constant)

   302 #include "tst_qlatin1constant.moc"