128 lines
3.9 KiB
C++
128 lines
3.9 KiB
C++
#include "precompiled_unittests_core.h"
|
|
|
|
#include "core/Seeder.h"
|
|
#include "core/UUID.h"
|
|
#include "core/AdaptersInterfaces/Adapter_SafeRandom.h"
|
|
|
|
namespace ITF
|
|
{
|
|
// gtest & gmock use namespace testing
|
|
using namespace testing;
|
|
|
|
class Adapter_SafeRandom_Mock : public Adapter_SafeRandom
|
|
{
|
|
public:
|
|
ErrorCode generate(size_t len, ITF::u8* buffer) const override
|
|
{
|
|
for (size_t i(0); i < len; ++i)
|
|
{
|
|
buffer[i] = m_Seeder.GetU32(0xff);
|
|
}
|
|
return Error_Ok;
|
|
}
|
|
private:
|
|
ITF::Seeder m_Seeder;
|
|
};
|
|
|
|
//anonymous
|
|
TEST(UUID, test_NullIds)
|
|
{
|
|
UUID uuid;
|
|
|
|
//default constructor should be clean
|
|
EXPECT_EQ(UUID::Nil, uuid);
|
|
EXPECT_BTRUE(uuid.isNil());
|
|
|
|
//going to valid and then back to null
|
|
EXPECT_BTRUE(uuid.fromString("e5d5eda2-a754-4dba-81e7-52c74ee7674d"));
|
|
EXPECT_BFALSE(uuid.isNil());
|
|
uuid.makeNil();
|
|
EXPECT_EQ(UUID::Nil, uuid);
|
|
EXPECT_BTRUE(uuid.isNil());
|
|
|
|
//check null ids as string
|
|
EXPECT_STREQ(uuid.toString().cStr(), "00000000-0000-0000-0000-000000000000");
|
|
}
|
|
|
|
//converts UUIDs to and from strings, checking for validity
|
|
TEST(UUID, test_StringConversion)
|
|
{
|
|
UUID uuid;
|
|
|
|
const char* validIdStr = "e5d5eda2-a754-4dba-81e7-52c74ee7674d";
|
|
|
|
//convert from long strings
|
|
EXPECT_EQ(uuid.fromString(validIdStr), true);
|
|
EXPECT_BFALSE(uuid.isNil());
|
|
EXPECT_STREQ(uuid.toString().cStr(), validIdStr);
|
|
|
|
const char* bracketsTest = "{12345678-1234-5678-1234-567812345678}";
|
|
const char* bracketsTestClean = "12345678-1234-5678-1234-567812345678";
|
|
EXPECT_EQ(uuid.fromString(bracketsTest), true);
|
|
EXPECT_BFALSE(uuid.isNil());
|
|
EXPECT_STREQ(uuid.toString().cStr(), bracketsTestClean);
|
|
}
|
|
|
|
//checks if different id versions are being reported correctly
|
|
TEST(UUID, test_Versioning)
|
|
{
|
|
const String8 validIdStrVersions[] =
|
|
{ "ba5bdcde-9751-11e4-b100-123b93f75cba"
|
|
, "df6a0fe0-9752-21e4-b4a9-0800200c9a66"
|
|
, "c478211b-224d-30b1-9116-c06048999ce2"
|
|
, "dcafcc69-ec43-43f2-9a4f-fe3fcc82a5e2"
|
|
, "12345678-1234-5678-1234-567812345678"};
|
|
|
|
for (size_t version=0; version < ITF_ARRAY_SIZE(validIdStrVersions); ++version)
|
|
{
|
|
UUID uuid(validIdStrVersions[version]);
|
|
EXPECT_EQ(uuid.toString(), validIdStrVersions[version]);
|
|
}
|
|
}
|
|
|
|
//checks comparison operators (=, ==, !=, < and >) between UUIDs
|
|
TEST(UUID, test_ComparisonOperators)
|
|
{
|
|
//check comparisons between a valid and a null id
|
|
UUID uuidA;
|
|
UUID uuidB("ba5bdcde-9751-11e4-b100-123b93f75cba");
|
|
EXPECT_BTRUE(uuidA < uuidB);
|
|
EXPECT_BTRUE(uuidB > uuidA);
|
|
EXPECT_NE(uuidA, uuidB);
|
|
|
|
//equality comparison of a copy constructor
|
|
UUID uuidC(uuidB);
|
|
EXPECT_EQ(uuidB, uuidC);
|
|
|
|
//comparisons between 2 valid and different ids
|
|
UUID uuidD("dcafcc69-ec43-43f2-9a4f-fe3fcc82a5e2");
|
|
EXPECT_NE(uuidB, uuidD);
|
|
EXPECT_BTRUE( uuidD > uuidB);
|
|
EXPECT_BTRUE( uuidB < uuidD);
|
|
EXPECT_BFALSE(uuidD < uuidB);
|
|
EXPECT_BFALSE(uuidB > uuidD);
|
|
|
|
//comparisons following an assignment operator
|
|
uuidD = uuidB;
|
|
EXPECT_EQ(uuidB, uuidD);
|
|
EXPECT_BFALSE(uuidD > uuidB);
|
|
EXPECT_BFALSE(uuidB < uuidD);
|
|
}
|
|
|
|
//checks the creation of random uuids (v4)
|
|
TEST(UUID, test_MakeRandom)
|
|
{
|
|
UUID uuid;
|
|
Adapter_SafeRandom_Mock sra;
|
|
|
|
//check if a number of random ids are generated, unique and valid
|
|
std::set<UUID> uniqueIds;
|
|
for (size_t i = 0; i < 10; ++i)
|
|
{
|
|
uuid.makeRandom();
|
|
EXPECT_BFALSE(uuid.isNil());
|
|
EXPECT_EQ(uniqueIds.find(uuid), uniqueIds.end());
|
|
uniqueIds.insert(uuid);
|
|
}
|
|
}
|
|
}
|