* Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
*/
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <regex>
#include <set>
#include <thread>
#include <vector>
#include "uuid.h"
namespace A2A::Shared::Test {
using namespace testing;
const std::string UUID_PATTERN = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
const std::regex uuid_regex(UUID_PATTERN);
class UuidTest : public ::testing::Test {
protected:
void SetUp() override
{
}
void TearDown() override
{
}
bool ValidateUuidVersion4(const std::string& uuid)
{
if (!std::regex_match(uuid, uuid_regex)) {
return false;
}
if (uuid[14] != '4') {
return false;
}
char variant = uuid[19];
if (variant != '8' && variant != '9' && variant != 'a' && variant != 'b') {
return false;
}
return true;
}
};
TEST_F(UuidTest, GenerateUuid_Basic)
{
std::string uuid = GenerateUuid();
EXPECT_FALSE(uuid.empty());
EXPECT_EQ(uuid.length(), 36);
EXPECT_TRUE(std::regex_match(uuid, uuid_regex));
}
TEST_F(UuidTest, GenerateUuid_Uniqueness)
{
constexpr int NUM_UUIDS = 1000;
std::set<std::string> uuids;
for (int i = 0; i < NUM_UUIDS; ++i) {
std::string uuid = GenerateUuid();
EXPECT_TRUE(uuids.find(uuid) == uuids.end()) <<
"Duplicate UUID generated: " << uuid;
uuids.insert(uuid);
}
EXPECT_EQ(uuids.size(), NUM_UUIDS);
}
TEST_F(UuidTest, GenerateUuid_Version4Compliance)
{
constexpr int NUM_TESTS = 100;
for (int i = 0; i < NUM_TESTS; ++i) {
std::string uuid = GenerateUuid();
EXPECT_TRUE(ValidateUuidVersion4(uuid)) <<
"UUID does not comply with RFC 4122 version 4: " << uuid;
}
}
TEST_F(UuidTest, GenerateUuid_FormatParts)
{
std::string uuid = GenerateUuid();
std::vector<std::string> parts;
std::stringstream ss(uuid);
std::string part;
while (std::getline(ss, part, '-')) {
parts.push_back(part);
}
ASSERT_EQ(parts.size(), 5);
EXPECT_EQ(parts[0].length(), 8);
EXPECT_EQ(parts[1].length(), 4);
EXPECT_EQ(parts[2].length(), 4);
EXPECT_EQ(parts[3].length(), 4);
EXPECT_EQ(parts[4].length(), 12);
for (const auto& p : parts) {
for (char c : p) {
EXPECT_TRUE((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) <<
"Invalid hex character in UUID: " << c;
}
}
}
TEST_F(UuidTest, GenerateUuid_VersionBit)
{
std::string uuid = GenerateUuid();
EXPECT_EQ(uuid[14], '4');
std::string versionByteHex = uuid.substr(14, 2);
int versionByte = std::stoi(versionByteHex, nullptr, 16);
EXPECT_EQ((versionByte & 0xF0) >> 4, 4);
}
TEST_F(UuidTest, GenerateUuid_VariantBit)
{
std::string uuid = GenerateUuid();
char variantChar = uuid[19];
EXPECT_TRUE(variantChar == '8' || variantChar == '9' ||
variantChar == 'a' || variantChar == 'b') <<
"Invalid variant character: " << variantChar;
std::string variantByteHex = uuid.substr(19, 2);
int variantByte = std::stoi(variantByteHex, nullptr, 16);
EXPECT_EQ((variantByte & 0xC0) >> 6, 2);
}
TEST_F(UuidTest, GenerateUuid_HyphenPositions)
{
std::string uuid = GenerateUuid();
EXPECT_EQ(uuid[8], '-');
EXPECT_EQ(uuid[13], '-');
EXPECT_EQ(uuid[18], '-');
EXPECT_EQ(uuid[23], '-');
for (size_t i = 0; i < uuid.length(); ++i) {
if (i != 8 && i != 13 && i != 18 && i != 23) {
EXPECT_NE(uuid[i], '-') << "Unexpected hyphen at position " << i;
}
}
}
TEST_F(UuidTest, GenerateUuid_MultiThreaded)
{
constexpr int THREAD_COUNT = 10;
constexpr int UUIDS_PER_THREAD = 100;
std::vector<std::thread> threads;
std::vector<std::set<std::string>> threadUuids(THREAD_COUNT);
for (int i = 0; i < THREAD_COUNT; ++i) {
threads.emplace_back([&threadUuids, i]() {
for (int j = 0; j < UUIDS_PER_THREAD; ++j) {
threadUuids[i].insert(GenerateUuid());
}
});
}
for (auto& t : threads) {
t.join();
}
for (int i = 0; i < THREAD_COUNT; ++i) {
EXPECT_EQ(threadUuids[i].size(), UUIDS_PER_THREAD) <<
"Thread " << i << " generated duplicate UUIDs";
}
std::set<std::string> allUuids;
for (const auto& threadSet : threadUuids) {
for (const auto& uuid : threadSet) {
EXPECT_TRUE(allUuids.find(uuid) == allUuids.end()) <<
"Duplicate UUID across threads: " << uuid;
allUuids.insert(uuid);
}
}
EXPECT_EQ(allUuids.size(), THREAD_COUNT * UUIDS_PER_THREAD);
}
TEST_F(UuidTest, GenerateUuid_FallbackRandomness)
{
std::string uuid = GenerateUuid();
EXPECT_TRUE(ValidateUuidVersion4(uuid));
}
TEST_F(UuidTest, GenerateUuid_ByteDistribution)
{
constexpr int NUM_TESTS = 10000;
std::array<int, 256> byteCounts = {0};
for (int i = 0; i < NUM_TESTS; ++i) {
std::string uuid = GenerateUuid();
std::string hexStr;
for (char c : uuid) {
if (c != '-') {
hexStr += c;
}
}
for (size_t j = 0; j < hexStr.length(); j += 2) {
std::string byteStr = hexStr.substr(j, 2);
int byte = std::stoi(byteStr, nullptr, 16);
byteCounts[byte]++;
}
}
int totalBytes = NUM_TESTS * 16;
double expectedCount = static_cast<double>(totalBytes) / 256;
double tolerance = expectedCount * 0.3;
for (int i = 0; i < 256; ++i) {
bool isVersionByte = (i >= 0x40 && i <= 0x4F);
bool isVariantByte = ((i & 0xC0) == 0x80);
if (!isVersionByte && !isVariantByte) {
EXPECT_NEAR(byteCounts[i], expectedCount, tolerance) <<
"Byte value 0x" << std::hex << i << std::dec <<
" appears " << byteCounts[i] << " times, expected ~" <<
expectedCount;
}
}
}
TEST_F(UuidTest, GenerateUuid_Comparison)
{
std::string uuid1 = GenerateUuid();
std::string uuid2 = GenerateUuid();
EXPECT_NE(uuid1, uuid2);
std::vector<std::string> uuids = {uuid1, uuid2};
std::sort(uuids.begin(), uuids.end());
EXPECT_EQ(uuids.size(), 2);
EXPECT_TRUE(uuids[0] == uuid1 || uuids[0] == uuid2);
}
TEST_F(UuidTest, GenerateUuid_Performance)
{
constexpr int NUM_TESTS = 10000;
auto start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < NUM_TESTS; ++i) {
GenerateUuid();
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "Generated " << NUM_TESTS << " UUIDs in " <<
duration.count() << " ms" << std::endl;
std::cout << "Average: " << duration.count() / static_cast<double>(NUM_TESTS) <<
" ms per UUID" << std::endl;
}
TEST_F(UuidTest, GenerateUuid_Lowercase)
{
std::string uuid = GenerateUuid();
for (char c : uuid) {
if (c != '-') {
EXPECT_TRUE((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) <<
"Found uppercase character in UUID: " << c;
}
}
}
TEST_F(UuidTest, GenerateUuid_RapidGeneration)
{
constexpr int NUM_TESTS = 10000;
std::set<std::string> uuids;
for (int i = 0; i < NUM_TESTS; ++i) {
uuids.insert(GenerateUuid());
}
EXPECT_EQ(uuids.size(), NUM_TESTS);
}
TEST_F(UuidTest, GenerateUuid_Entropy)
{
constexpr int NUM_TESTS = 1000;
std::array<int, 16> nibbleCounts = {0};
for (int i = 0; i < NUM_TESTS; ++i) {
std::string uuid = GenerateUuid();
for (char c : uuid) {
if (c == '-') continue;
int value;
if (c >= '0' && c <= '9') {
value = c - '0';
} else {
value = c - 'a' + 10;
}
nibbleCounts[value]++;
}
}
int totalNibbles = NUM_TESTS * 32;
double entropy = 0.0;
for (int count : nibbleCounts) {
if (count > 0) {
double p = static_cast<double>(count) / totalNibbles;
entropy -= p * log2(p);
}
}
std::cout << "Entropy of generated UUIDs: " << entropy << " bits per nibble" << std::endl;
EXPECT_GT(entropy, 3.8);
}
}