whytofly
/
qt6-bb10
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tst_qhashfunctions: Test non-zero seeds too 

Change-Id: Ib0e40a7a3ebc44329f23fffd14b2e927021a1a2e
Reviewed-by: David Faure <david.faure@kdab.com>
bb10
Thiago Macieira 2017-04-06 13:33:00 -07:00
parent 2019e78d87
commit e7493c8b54
1 changed files with 70 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
tests/auto/corelib/tools/qhashfunctions/tst_qhashfunctions.cpp
View File

@ -37,11 +37,22 @@
class tst_QHashFunctions : public QObject
{
Q_OBJECT
public:
enum {
// random value
RandomSeed = 1045982819
};
uint seed;
public slots:
void initTestCase();
void init();
private Q_SLOTS:
void qhash();
void qhash_of_empty_and_null_qstring();
void qhash_of_empty_and_null_qbytearray();
void fp_qhash_of_zero_is_zero();
void fp_qhash_of_zero_is_seed();
void qthash_data();
void qthash();
void range();
@ -50,12 +61,27 @@ private Q_SLOTS:
void setGlobalQHashSeed();
};
void tst_QHashFunctions::initTestCase()
{
Q_STATIC_ASSERT(int(RandomSeed) > 0);
QTest::addColumn<uint>("seedValue");
QTest::newRow("zero-seed") << 0U;
QTest::newRow("non-zero-seed") << uint(RandomSeed);
}
void tst_QHashFunctions::init()
{
QFETCH_GLOBAL(uint, seedValue);
seed = seedValue;
}
void tst_QHashFunctions::qhash()
{
{
QBitArray a1;
QBitArray a2;
QVERIFY(qHash(a1) == 0);
QCOMPARE(qHash(a1, seed), seed);
a1.resize(1);
a1.setBit(0, true);
@ -63,53 +89,53 @@ void tst_QHashFunctions::qhash()
a2.resize(1);
a2.setBit(0, false);
uint h1 = qHash(a1);
uint h2 = qHash(a2);
uint h1 = qHash(a1, seed);
uint h2 = qHash(a2, seed);
QVERIFY(h1 != h2);
QVERIFY(h1 != h2); // not guaranteed
a2.setBit(0, true);
QVERIFY(h1 == qHash(a2));
QVERIFY(h1 == qHash(a2, seed));
a1.fill(true, 8);
a1.resize(7);
h1 = qHash(a1);
h1 = qHash(a1, seed);
a2.fill(true, 7);
h2 = qHash(a2);
h2 = qHash(a2, seed);
QVERIFY(h1 == h2);
a2.setBit(0, false);
uint h3 = qHash(a2);
QVERIFY(h2 != h3);
uint h3 = qHash(a2, seed);
QVERIFY(h2 != h3); // not guaranteed
a2.setBit(0, true);
QVERIFY(h2 == qHash(a2));
QVERIFY(h2 == qHash(a2, seed));
a2.setBit(6, false);
uint h4 = qHash(a2);
QVERIFY(h2 != h4);
uint h4 = qHash(a2, seed);
QVERIFY(h2 != h4); // not guaranteed
a2.setBit(6, true);
QVERIFY(h2 == qHash(a2));
QVERIFY(h2 == qHash(a2, seed));
QVERIFY(h3 != h4);
QVERIFY(h3 != h4); // not guaranteed
}
{
QPair<int, int> p12(1, 2);
QPair<int, int> p21(2, 1);
QVERIFY(qHash(p12) == qHash(p12));
QVERIFY(qHash(p21) == qHash(p21));
QVERIFY(qHash(p12) != qHash(p21));
QVERIFY(qHash(p12, seed) == qHash(p12, seed));
QVERIFY(qHash(p21, seed) == qHash(p21, seed));
QVERIFY(qHash(p12, seed) != qHash(p21, seed)); // not guaranteed
QPair<int, int> pA(0x12345678, 0x12345678);
QPair<int, int> pB(0x12345675, 0x12345675);
QVERIFY(qHash(pA) != qHash(pB));
QVERIFY(qHash(pA, seed) != qHash(pB, seed)); // not guaranteed
}
{
@ -118,14 +144,14 @@ void tst_QHashFunctions::qhash()
using QT_PREPEND_NAMESPACE(qHash);
QVERIFY(qHash(p12) == qHash(p12));
QVERIFY(qHash(p21) == qHash(p21));
QVERIFY(qHash(p12) != qHash(p21));
QVERIFY(qHash(p12, seed) == qHash(p12, seed));
QVERIFY(qHash(p21, seed) == qHash(p21, seed));
QVERIFY(qHash(p12, seed) != qHash(p21, seed)); // not guaranteed
std::pair<int, int> pA(0x12345678, 0x12345678);
std::pair<int, int> pB(0x12345675, 0x12345675);
QVERIFY(qHash(pA) != qHash(pB));
QVERIFY(qHash(pA, seed) != qHash(pB, seed)); // not guaranteed
}
}
@ -133,27 +159,27 @@ void tst_QHashFunctions::qhash_of_empty_and_null_qstring()
{
QString null, empty("");
QCOMPARE(null, empty);
QCOMPARE(qHash(null), qHash(empty));
QCOMPARE(qHash(null, seed), qHash(empty, seed));
}
void tst_QHashFunctions::qhash_of_empty_and_null_qbytearray()
{
QByteArray null, empty("");
QCOMPARE(null, empty);
QCOMPARE(qHash(null), qHash(empty));
QCOMPARE(qHash(null, seed), qHash(empty, seed));
}
void tst_QHashFunctions::fp_qhash_of_zero_is_zero()
void tst_QHashFunctions::fp_qhash_of_zero_is_seed()
{
QCOMPARE(qHash(-0.0f), 0U);
QCOMPARE(qHash( 0.0f), 0U);
QCOMPARE(qHash(-0.0f, seed), seed);
QCOMPARE(qHash( 0.0f, seed), seed);
QCOMPARE(qHash(-0.0 ), 0U);
QCOMPARE(qHash( 0.0 ), 0U);
QCOMPARE(qHash(-0.0 , seed), seed);
QCOMPARE(qHash( 0.0 , seed), seed);
#ifndef Q_OS_DARWIN
QCOMPARE(qHash(-0.0L), 0U);
QCOMPARE(qHash( 0.0L), 0U);
QCOMPARE(qHash(-0.0L, seed), seed);
QCOMPARE(qHash( 0.0L, seed), seed);
#endif
}
@ -188,10 +214,10 @@ void tst_QHashFunctions::range()
static const size_t numInts = sizeof ints / sizeof *ints;
// empty range just gives the seed:
QCOMPARE(qHashRange(ints, ints, 0xdeadbeefU), 0xdeadbeefU);
// verify that order matters:
QVERIFY(qHashRange(ints, ints + numInts) !=
qHashRange(std::reverse_iterator<const int*>(ints + numInts), std::reverse_iterator<const int*>(ints)));
QCOMPARE(qHashRange(ints, ints, seed), seed);
// verify that order matters (test not guaranteed):
QVERIFY(qHashRange(ints, ints + numInts, seed) !=
qHashRange(std::reverse_iterator<const int*>(ints + numInts), std::reverse_iterator<const int*>(ints), seed));
{
// verify that the input iterator category suffices:
@ -200,13 +226,13 @@ void tst_QHashFunctions::range()
std::copy(ints, ints + numInts, std::ostream_iterator<int>(sstream, " "));
sstream.seekg(0);
std::istream_iterator<int> it(sstream), end;
QCOMPARE(qHashRange(ints, ints + numInts), qHashRange(it, end));
QCOMPARE(qHashRange(ints, ints + numInts, seed), qHashRange(it, end, seed));
}
SomeNamespace::Hashable hashables[] = {{0}, {1}, {2}, {3}, {4}, {5}};
static const size_t numHashables = sizeof hashables / sizeof *hashables;
// compile check: is qHash() found using ADL?
(void)qHashRange(hashables, hashables + numHashables);
(void)qHashRange(hashables, hashables + numHashables, seed);
}
void tst_QHashFunctions::rangeCommutative()
@ -215,10 +241,10 @@ void tst_QHashFunctions::rangeCommutative()
static const size_t numInts = sizeof ints / sizeof *ints;
// empty range just gives the seed:
QCOMPARE(qHashRangeCommutative(ints, ints, 0xdeadbeefU), 0xdeadbeefU);
// verify that order doesn't matter:
QCOMPARE(qHashRangeCommutative(ints, ints + numInts),
qHashRangeCommutative(std::reverse_iterator<int*>(ints + numInts), std::reverse_iterator<int*>(ints)));
QCOMPARE(qHashRangeCommutative(ints, ints, seed), seed);
// verify that order doesn't matter (test not guaranteed):
QCOMPARE(qHashRangeCommutative(ints, ints + numInts, seed),
qHashRangeCommutative(std::reverse_iterator<int*>(ints + numInts), std::reverse_iterator<int*>(ints), seed));
{
// verify that the input iterator category suffices:
@ -226,13 +252,13 @@ void tst_QHashFunctions::rangeCommutative()
std::copy(ints, ints + numInts, std::ostream_iterator<int>(sstream, " "));
sstream.seekg(0);
std::istream_iterator<int> it(sstream), end;
QCOMPARE(qHashRangeCommutative(ints, ints + numInts), qHashRangeCommutative(it, end));
QCOMPARE(qHashRangeCommutative(ints, ints + numInts, seed), qHashRangeCommutative(it, end, seed));
}
SomeNamespace::Hashable hashables[] = {{0}, {1}, {2}, {3}, {4}, {5}};
static const size_t numHashables = sizeof hashables / sizeof *hashables;
// compile check: is qHash() found using ADL?
(void)qHashRangeCommutative(hashables, hashables + numHashables);
(void)qHashRangeCommutative(hashables, hashables + numHashables, seed);
}
void tst_QHashFunctions::setGlobalQHashSeed()