← Back to branch summary

~gabriel1984sibiu/minitube/qt5.6

« back to all changes in this revision

Viewing changes to tests/auto/corelib/plugin/quuid/tst_quuid.cpp

  • Committer: Grevutiu Gabriel
  • Date: 2017-06-13 08:43:17 UTC
  • Revision ID: gabriel1984sibiu@gmail.com-20170613084317-ek0zqe0u9g3ocvi8
Original upstream code

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/corelib/plugin/quuid/tst_quuid.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2016 The Qt Company Ltd.
 
4
** Contact: https://www.qt.io/licensing/
 
5
**
 
6
** This file is part of the test suite of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and The Qt Company. For licensing terms
 
14
** and conditions see https://www.qt.io/terms-conditions. For further
 
15
** information use the contact form at https://www.qt.io/contact-us.
 
16
**
 
17
** GNU General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU
 
19
** General Public License version 3 as published by the Free Software
 
20
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
 
21
** included in the packaging of this file. Please review the following
 
22
** information to ensure the GNU General Public License requirements will
 
23
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
 
24
**
 
25
** $QT_END_LICENSE$
 
26
**
 
27
****************************************************************************/
 
28
 
 
29
 
 
30
#include <QtTest/QtTest>
 
31
 
 
32
#include <qcoreapplication.h>
 
33
#include <quuid.h>
 
34
 
 
35
class tst_QUuid : public QObject
 
36
{
 
37
    Q_OBJECT
 
38
 
 
39
private slots:
 
40
    void initTestCase();
 
41
 
 
42
    void fromChar();
 
43
    void toString();
 
44
    void fromString();
 
45
    void toByteArray();
 
46
    void fromByteArray();
 
47
    void toRfc4122();
 
48
    void fromRfc4122();
 
49
    void createUuidV3OrV5();
 
50
    void check_QDataStream();
 
51
    void isNull();
 
52
    void equal();
 
53
    void notEqual();
 
54
    void cpp11();
 
55
 
 
56
    // Only in Qt > 3.2.x
 
57
    void generate();
 
58
    void less();
 
59
    void more();
 
60
    void variants();
 
61
    void versions();
 
62
 
 
63
    void threadUniqueness();
 
64
    void processUniqueness();
 
65
 
 
66
    void hash();
 
67
 
 
68
    void qvariant();
 
69
    void qvariant_conversion();
 
70
 
 
71
    void darwinTypes();
 
72
 
 
73
public:
 
74
    // Variables
 
75
    QUuid uuidNS;
 
76
    QUuid uuidA;
 
77
    QUuid uuidB;
 
78
    QUuid uuidC;
 
79
    QUuid uuidD;
 
80
};
 
81
 
 
82
void tst_QUuid::initTestCase()
 
83
{
 
84
    //It's NameSpace_DNS in RFC4122
 
85
    //"{6ba7b810-9dad-11d1-80b4-00c04fd430c8}";
 
86
    uuidNS = QUuid(0x6ba7b810, 0x9dad, 0x11d1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8);
 
87
 
 
88
    //"{fc69b59e-cc34-4436-a43c-ee95d128b8c5}";
 
89
    uuidA = QUuid(0xfc69b59e, 0xcc34, 0x4436, 0xa4, 0x3c, 0xee, 0x95, 0xd1, 0x28, 0xb8, 0xc5);
 
90
 
 
91
    //"{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}";
 
92
    uuidB = QUuid(0x1ab6e93a, 0xb1cb, 0x4a87, 0xba, 0x47, 0xec, 0x7e, 0x99, 0x03, 0x9a, 0x7b);
 
93
 
 
94
#ifndef QT_NO_PROCESS
 
95
    // chdir to the directory containing our testdata, then refer to it with relative paths
 
96
    QString testdata_dir = QFileInfo(QFINDTESTDATA("testProcessUniqueness")).absolutePath();
 
97
    QVERIFY2(QDir::setCurrent(testdata_dir), qPrintable("Could not chdir to " + testdata_dir));
 
98
#endif
 
99
 
 
100
    //"{3d813cbb-47fb-32ba-91df-831e1593ac29}"; http://www.rfc-editor.org/errata_search.php?rfc=4122&eid=1352
 
101
    uuidC = QUuid(0x3d813cbb, 0x47fb, 0x32ba, 0x91, 0xdf, 0x83, 0x1e, 0x15, 0x93, 0xac, 0x29);
 
102
 
 
103
    //"{21f7f8de-8051-5b89-8680-0195ef798b6a}";
 
104
    uuidD = QUuid(0x21f7f8de, 0x8051, 0x5b89, 0x86, 0x80, 0x01, 0x95, 0xef, 0x79, 0x8b, 0x6a);
 
105
}
 
106
 
 
107
void tst_QUuid::fromChar()
 
108
{
 
109
    QCOMPARE(uuidA, QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}"));
 
110
    QCOMPARE(uuidA, QUuid("fc69b59e-cc34-4436-a43c-ee95d128b8c5}"));
 
111
    QCOMPARE(uuidA, QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c5"));
 
112
    QCOMPARE(uuidA, QUuid("fc69b59e-cc34-4436-a43c-ee95d128b8c5"));
 
113
    QCOMPARE(QUuid(), QUuid("{fc69b59e-cc34-4436-a43c-ee95d128b8c"));
 
114
    QCOMPARE(QUuid(), QUuid("{fc69b59e-cc34"));
 
115
    QCOMPARE(QUuid(), QUuid("fc69b59e-cc34-"));
 
116
    QCOMPARE(QUuid(), QUuid("fc69b59e-cc34"));
 
117
    QCOMPARE(QUuid(), QUuid("cc34"));
 
118
    QCOMPARE(QUuid(), QUuid(NULL));
 
119
 
 
120
    QCOMPARE(uuidB, QUuid(QString("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}")));
 
121
}
 
122
 
 
123
void tst_QUuid::toString()
 
124
{
 
125
    QCOMPARE(uuidA.toString(), QString("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}"));
 
126
 
 
127
    QCOMPARE(uuidB.toString(), QString("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}"));
 
128
}
 
129
 
 
130
void tst_QUuid::fromString()
 
131
{
 
132
    QCOMPARE(uuidA, QUuid(QString("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}")));
 
133
    QCOMPARE(uuidA, QUuid(QString("fc69b59e-cc34-4436-a43c-ee95d128b8c5}")));
 
134
    QCOMPARE(uuidA, QUuid(QString("{fc69b59e-cc34-4436-a43c-ee95d128b8c5")));
 
135
    QCOMPARE(uuidA, QUuid(QString("fc69b59e-cc34-4436-a43c-ee95d128b8c5")));
 
136
    QCOMPARE(QUuid(), QUuid(QString("{fc69b59e-cc34-4436-a43c-ee95d128b8c")));
 
137
 
 
138
    QCOMPARE(uuidB, QUuid(QString("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}")));
 
139
}
 
140
 
 
141
void tst_QUuid::toByteArray()
 
142
{
 
143
    QCOMPARE(uuidA.toByteArray(), QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}"));
 
144
 
 
145
    QCOMPARE(uuidB.toByteArray(), QByteArray("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}"));
 
146
}
 
147
 
 
148
void tst_QUuid::fromByteArray()
 
149
{
 
150
    QCOMPARE(uuidA, QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c5}")));
 
151
    QCOMPARE(uuidA, QUuid(QByteArray("fc69b59e-cc34-4436-a43c-ee95d128b8c5}")));
 
152
    QCOMPARE(uuidA, QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c5")));
 
153
    QCOMPARE(uuidA, QUuid(QByteArray("fc69b59e-cc34-4436-a43c-ee95d128b8c5")));
 
154
    QCOMPARE(QUuid(), QUuid(QByteArray("{fc69b59e-cc34-4436-a43c-ee95d128b8c")));
 
155
 
 
156
    QCOMPARE(uuidB, QUuid(QByteArray("{1ab6e93a-b1cb-4a87-ba47-ec7e99039a7b}")));
 
157
}
 
158
 
 
159
void tst_QUuid::toRfc4122()
 
160
{
 
161
    QCOMPARE(uuidA.toRfc4122(), QByteArray::fromHex("fc69b59ecc344436a43cee95d128b8c5"));
 
162
 
 
163
    QCOMPARE(uuidB.toRfc4122(), QByteArray::fromHex("1ab6e93ab1cb4a87ba47ec7e99039a7b"));
 
164
}
 
165
 
 
166
void tst_QUuid::fromRfc4122()
 
167
{
 
168
    QCOMPARE(uuidA, QUuid::fromRfc4122(QByteArray::fromHex("fc69b59ecc344436a43cee95d128b8c5")));
 
169
 
 
170
    QCOMPARE(uuidB, QUuid::fromRfc4122(QByteArray::fromHex("1ab6e93ab1cb4a87ba47ec7e99039a7b")));
 
171
}
 
172
 
 
173
void tst_QUuid::createUuidV3OrV5()
 
174
{
 
175
    //"www.widgets.com" is also from RFC4122
 
176
    QCOMPARE(uuidC, QUuid::createUuidV3(uuidNS, QByteArray("www.widgets.com")));
 
177
    QCOMPARE(uuidC, QUuid::createUuidV3(uuidNS, QString("www.widgets.com")));
 
178
 
 
179
    QCOMPARE(uuidD, QUuid::createUuidV5(uuidNS, QByteArray("www.widgets.com")));
 
180
    QCOMPARE(uuidD, QUuid::createUuidV5(uuidNS, QString("www.widgets.com")));
 
181
}
 
182
 
 
183
void tst_QUuid::check_QDataStream()
 
184
{
 
185
    QUuid tmp;
 
186
    QByteArray ar;
 
187
    {
 
188
        QDataStream out(&ar,QIODevice::WriteOnly);
 
189
        out.setByteOrder(QDataStream::BigEndian);
 
190
        out << uuidA;
 
191
    }
 
192
    {
 
193
        QDataStream in(&ar,QIODevice::ReadOnly);
 
194
        in.setByteOrder(QDataStream::BigEndian);
 
195
        in >> tmp;
 
196
        QCOMPARE(uuidA, tmp);
 
197
    }
 
198
    {
 
199
        QDataStream out(&ar,QIODevice::WriteOnly);
 
200
        out.setByteOrder(QDataStream::LittleEndian);
 
201
        out << uuidA;
 
202
    }
 
203
    {
 
204
        QDataStream in(&ar,QIODevice::ReadOnly);
 
205
        in.setByteOrder(QDataStream::LittleEndian);
 
206
        in >> tmp;
 
207
        QCOMPARE(uuidA, tmp);
 
208
    }
 
209
}
 
210
 
 
211
void tst_QUuid::isNull()
 
212
{
 
213
    QVERIFY( !uuidA.isNull() );
 
214
 
 
215
    QUuid should_be_null_uuid;
 
216
    QVERIFY( should_be_null_uuid.isNull() );
 
217
}
 
218
 
 
219
 
 
220
void tst_QUuid::equal()
 
221
{
 
222
    QVERIFY( !(uuidA == uuidB) );
 
223
 
 
224
    QUuid copy(uuidA);
 
225
    QCOMPARE(uuidA, copy);
 
226
 
 
227
    QUuid assigned;
 
228
    assigned = uuidA;
 
229
    QCOMPARE(uuidA, assigned);
 
230
}
 
231
 
 
232
 
 
233
void tst_QUuid::notEqual()
 
234
{
 
235
    QVERIFY( uuidA != uuidB );
 
236
}
 
237
 
 
238
void tst_QUuid::cpp11() {
 
239
#ifdef Q_COMPILER_UNIFORM_INIT
 
240
    // "{fc69b59e-cc34-4436-a43c-ee95d128b8c5}" cf, initTestCase
 
241
    Q_DECL_CONSTEXPR QUuid u1{0xfc69b59e, 0xcc34, 0x4436, 0xa4, 0x3c, 0xee, 0x95, 0xd1, 0x28, 0xb8, 0xc5};
 
242
    Q_DECL_CONSTEXPR QUuid u2 = {0xfc69b59e, 0xcc34, 0x4436, 0xa4, 0x3c, 0xee, 0x95, 0xd1, 0x28, 0xb8, 0xc5};
 
243
    Q_UNUSED(u1);
 
244
    Q_UNUSED(u2);
 
245
#else
 
246
    QSKIP("This compiler is not in C++11 mode or it doesn't support uniform initialization");
 
247
#endif
 
248
}
 
249
 
 
250
void tst_QUuid::generate()
 
251
{
 
252
    QUuid shouldnt_be_null_uuidA = QUuid::createUuid();
 
253
    QUuid shouldnt_be_null_uuidB = QUuid::createUuid();
 
254
    QVERIFY( !shouldnt_be_null_uuidA.isNull() );
 
255
    QVERIFY( !shouldnt_be_null_uuidB.isNull() );
 
256
    QVERIFY( shouldnt_be_null_uuidA != shouldnt_be_null_uuidB );
 
257
}
 
258
 
 
259
 
 
260
void tst_QUuid::less()
 
261
{
 
262
    QVERIFY(  uuidB <  uuidA);
 
263
    QVERIFY(  uuidB <= uuidA);
 
264
    QVERIFY(!(uuidA <  uuidB) );
 
265
    QVERIFY(!(uuidA <= uuidB));
 
266
 
 
267
    QUuid null_uuid;
 
268
    QVERIFY(null_uuid < uuidA); // Null uuid is always less than a valid one
 
269
    QVERIFY(null_uuid <= uuidA);
 
270
 
 
271
    QVERIFY(null_uuid <= null_uuid);
 
272
    QVERIFY(uuidA <= uuidA);
 
273
}
 
274
 
 
275
 
 
276
void tst_QUuid::more()
 
277
{
 
278
    QVERIFY(  uuidA >  uuidB);
 
279
    QVERIFY(  uuidA >= uuidB);
 
280
    QVERIFY(!(uuidB >  uuidA));
 
281
    QVERIFY(!(uuidB >= uuidA));
 
282
 
 
283
    QUuid null_uuid;
 
284
    QVERIFY(!(null_uuid >  uuidA)); // Null uuid is always less than a valid one
 
285
    QVERIFY(!(null_uuid >= uuidA));
 
286
 
 
287
    QVERIFY(null_uuid >= null_uuid);
 
288
    QVERIFY(uuidA >= uuidA);
 
289
}
 
290
 
 
291
 
 
292
void tst_QUuid::variants()
 
293
{
 
294
    QVERIFY( uuidA.variant() == QUuid::DCE );
 
295
    QVERIFY( uuidB.variant() == QUuid::DCE );
 
296
 
 
297
    QUuid NCS = "{3a2f883c-4000-000d-0000-00fb40000000}";
 
298
    QVERIFY( NCS.variant() == QUuid::NCS );
 
299
}
 
300
 
 
301
 
 
302
void tst_QUuid::versions()
 
303
{
 
304
    QVERIFY( uuidA.version() == QUuid::Random );
 
305
    QVERIFY( uuidB.version() == QUuid::Random );
 
306
 
 
307
    QUuid DCE_time= "{406c45a0-3b7e-11d0-80a3-0000c08810a7}";
 
308
    QVERIFY( DCE_time.version() == QUuid::Time );
 
309
 
 
310
    QUuid NCS = "{3a2f883c-4000-000d-0000-00fb40000000}";
 
311
    QVERIFY( NCS.version() == QUuid::VerUnknown );
 
312
}
 
313
 
 
314
class UuidThread : public QThread
 
315
{
 
316
public:
 
317
    QUuid uuid;
 
318
 
 
319
    void run()
 
320
    {
 
321
        uuid = QUuid::createUuid();
 
322
    }
 
323
};
 
324
 
 
325
void tst_QUuid::threadUniqueness()
 
326
{
 
327
    QVector<UuidThread *> threads(qMax(2, QThread::idealThreadCount()));
 
328
    for (int i = 0; i < threads.count(); ++i)
 
329
        threads[i] = new UuidThread;
 
330
    for (int i = 0; i < threads.count(); ++i)
 
331
        threads[i]->start();
 
332
    for (int i = 0; i < threads.count(); ++i)
 
333
        QVERIFY(threads[i]->wait(1000));
 
334
    for (int i = 1; i < threads.count(); ++i)
 
335
        QVERIFY(threads[0]->uuid != threads[i]->uuid);
 
336
    qDeleteAll(threads);
 
337
}
 
338
 
 
339
void tst_QUuid::processUniqueness()
 
340
{
 
341
#ifdef QT_NO_PROCESS
 
342
    QSKIP("No qprocess support", SkipAll);
 
343
#else
 
344
    QProcess process;
 
345
    QString processOneOutput;
 
346
    QString processTwoOutput;
 
347
 
 
348
    // Start it once
 
349
#ifdef Q_OS_MAC
 
350
    process.start("testProcessUniqueness/testProcessUniqueness.app");
 
351
#else
 
352
    process.start("testProcessUniqueness/testProcessUniqueness");
 
353
#endif
 
354
    QVERIFY(process.waitForFinished());
 
355
    processOneOutput = process.readAllStandardOutput();
 
356
 
 
357
    // Start it twice
 
358
#ifdef Q_OS_MAC
 
359
    process.start("testProcessUniqueness/testProcessUniqueness.app");
 
360
#else
 
361
    process.start("testProcessUniqueness/testProcessUniqueness");
 
362
#endif
 
363
    QVERIFY(process.waitForFinished());
 
364
    processTwoOutput = process.readAllStandardOutput();
 
365
 
 
366
    // They should be *different*!
 
367
    QVERIFY(processOneOutput != processTwoOutput);
 
368
#endif
 
369
}
 
370
 
 
371
void tst_QUuid::hash()
 
372
{
 
373
    uint h = qHash(uuidA);
 
374
    QCOMPARE(qHash(uuidA), h);
 
375
    QCOMPARE(qHash(QUuid(uuidA.toString())), h);
 
376
}
 
377
 
 
378
void tst_QUuid::qvariant()
 
379
{
 
380
    QUuid uuid = QUuid::createUuid();
 
381
    QVariant v = QVariant::fromValue(uuid);
 
382
    QVERIFY(!v.isNull());
 
383
    QCOMPARE(v.type(), QVariant::Uuid);
 
384
 
 
385
    QUuid uuid2 = v.value<QUuid>();
 
386
    QVERIFY(!uuid2.isNull());
 
387
    QCOMPARE(uuid, uuid2);
 
388
}
 
389
 
 
390
void tst_QUuid::qvariant_conversion()
 
391
{
 
392
    QUuid uuid = QUuid::createUuid();
 
393
    QVariant v = QVariant::fromValue(uuid);
 
394
 
 
395
    QVERIFY(v.canConvert<QString>());
 
396
    QCOMPARE(v.toString(), uuid.toString());
 
397
    QCOMPARE(v.value<QString>(), uuid.toString());
 
398
    QVERIFY(!v.canConvert<int>());
 
399
    QVERIFY(!v.canConvert<QStringList>());
 
400
 
 
401
    // try reverse conversion QString -> QUuid
 
402
    QVariant sv = QVariant::fromValue(uuid.toString());
 
403
    QCOMPARE(sv.type(), QVariant::String);
 
404
    QVERIFY(sv.canConvert<QUuid>());
 
405
    QCOMPARE(sv.value<QUuid>(), uuid);
 
406
}
 
407
 
 
408
void tst_QUuid::darwinTypes()
 
409
{
 
410
#ifndef Q_OS_DARWIN
 
411
    QSKIP("This is a Darwin-only test");
 
412
#else
 
413
    extern void tst_QUuid_darwinTypes(); // in tst_quuid_darwin.mm
 
414
    tst_QUuid_darwinTypes();
 
415
#endif
 
416
}
 
417
 
 
418
QTEST_MAIN(tst_QUuid)
 
419
#include "tst_quuid.moc"