From 954833060bfc0ef0a024c624da0572a2fca2e08c Mon Sep 17 00:00:00 2001 From: Dnomd343 Date: Sun, 29 Jan 2023 18:55:39 +0800 Subject: [PATCH] test: enhance common code string check --- src/klotski_core/common_code/serialize.cc | 15 ++++---- test/all_cases.cc | 6 ++-- test/common_code.cc | 42 ++++++++++++++++++++--- 3 files changed, 48 insertions(+), 15 deletions(-) diff --git a/src/klotski_core/common_code/serialize.cc b/src/klotski_core/common_code/serialize.cc index 141e61a..4ec63e6 100644 --- a/src/klotski_core/common_code/serialize.cc +++ b/src/klotski_core/common_code/serialize.cc @@ -3,16 +3,16 @@ using klotski::CommonCode; inline uint8_t binary_count(uint32_t bin) { // get number of non-zero bits - bin -= (bin >> 1) & 0x55555555; - bin = (bin & 0x33333333) + ((bin >> 2) & 0x33333333); - bin = ((bin >> 4) + bin) & 0x0F0F0F0F; + bin -= (bin >> 1) & 0x55'55'55'55; + bin = (bin & 0x33'33'33'33) + ((bin >> 2) & 0x33'33'33'33); + bin = ((bin >> 4) + bin) & 0x0F'0F'0F'0F; bin += bin >> 8; bin += bin >> 16; - return bin & 0b111111; + return bin & 0b11'11'11; } /// NOTE: input should not be zero -inline uint32_t last_zero_num(uint32_t bin) { // get last zero number +inline uint8_t last_zero_num(uint32_t bin) { // get last zero number bin ^= (bin - 1); return binary_count(bin >> 1); } @@ -25,8 +25,9 @@ std::string CommonCode::to_string(bool shorten) const { // convert uint64_t code char result[10]; // max length 9-bits sprintf(result, "%09lX", code); if (shorten) { // remove `0` after common code - if (code == 0x000000000) { - return "0"; // special case -> only one `0` + if ((uint32_t)code == 0x00'00'00'00) { // low 32-bits are zero + result[1] = '\0'; // only keep first character + return result; } result[9 - last_zero_num(code) / 4] = '\0'; // truncate string } diff --git a/test/all_cases.cc b/test/all_cases.cc index 7680a9d..b936526 100644 --- a/test/all_cases.cc +++ b/test/all_cases.cc @@ -10,8 +10,6 @@ using klotski::ALL_CASES_SIZE; using klotski::BASIC_RANGES_SIZE; using klotski::ALL_CASES_SIZE_SUM; -const static int TEST_THREAD_NUM = 8; - /// basic ranges constants const char BASIC_RANGES_MD5[] = "6f385dc171e201089ff96bb010b47212"; @@ -20,7 +18,7 @@ const char ALL_CASES_MD5[] = "3888e9fab8d3cbb50908b12b147cfb23"; /// basic ranges mutex check TEST(AllCases, basic_ranges_mutex) { - std::thread threads[TEST_THREAD_NUM]; + std::thread threads[4]; EXPECT_EQ(BasicRanges::status(), BasicRanges::NO_INIT); for (auto &t : threads) { t = std::thread(BasicRanges::build); @@ -52,7 +50,7 @@ TEST(AllCases, basic_ranges_data) { /// basic ranges mutex check TEST(AllCases, all_cases_mutex) { - std::thread threads[TEST_THREAD_NUM]; + std::thread threads[4]; EXPECT_EQ(AllCases::status(), AllCases::NO_INIT); for (auto &t : threads) { t = std::thread(AllCases::build); diff --git a/test/common_code.cc b/test/common_code.cc index bd8bb7d..be2c357 100644 --- a/test/common_code.cc +++ b/test/common_code.cc @@ -1,3 +1,5 @@ +#include +#include #include "all_cases.h" #include "common_code.h" #include "gtest/gtest.h" @@ -12,23 +14,54 @@ const static uint64_t TEST_CODE = 0x1A9BF0C00; const static std::string TEST_CODE_STR = "1A9BF0C00"; TEST(CommonCode, code_verify) { - for (uint64_t head = 0; head < 16; ++head) { + std::thread threads[16]; + auto test = [](uint64_t head) { for (const auto &range : AllCases::fetch()[head]) { uint64_t code = head << 32 | range; EXPECT_EQ(CommonCode::check(code), true); // test static `check` interface auto tmp = CommonCode::unsafe_create(code); // test dynamic `valid` interface EXPECT_EQ(tmp.valid(), true); } + }; + for (uint64_t head = 0; head < 16; ++head) { + threads[head] = std::thread(test, head); + } + for (auto &t : threads) { + t.join(); } } TEST(CommonCode, code_string) { - for (uint64_t head = 0; head < 16; ++head) { + std::thread threads[16]; + auto test = [](uint64_t head) { for (const auto &range : AllCases::fetch()[head]) { + std::string code_str; uint64_t code = head << 32 | range; auto common_code = CommonCode::unsafe_create(code); - EXPECT_EQ(CommonCode::from_string(common_code.to_string()), common_code); + + code_str = common_code.to_string(true); // with shorten + EXPECT_LE(code_str.size(), 9); // length -> (0, 9] + EXPECT_NE(code_str.size(), 0); + if (code != 0) { // skip special code string `0` + EXPECT_NE(code_str.back(), '0'); + } + EXPECT_EQ(CommonCode::from_string(code_str), common_code); + + code_str = common_code.to_string(false); // without shorten + EXPECT_EQ(code_str.size(), 9); // length = 9 + for (const auto &c : code_str) { + EXPECT_EQ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F'), true); + } + EXPECT_EQ(CommonCode::from_string(code_str), common_code); // test upper cases + std::transform(code_str.begin(), code_str.end(), code_str.begin(), ::tolower); + EXPECT_EQ(CommonCode::from_string(code_str), common_code); // test lower cases } + }; + for (uint64_t head = 0; head < 16; ++head) { + threads[head] = std::thread(test, head); + } + for (auto &t : threads) { + t.join(); } } @@ -41,12 +74,13 @@ TEST(CommonCode, constructors) { TEST(CommonCode, operators) { EXPECT_EQ(CommonCode(TEST_CODE), CommonCode(TEST_CODE)); // operator `==` - std::cout << CommonCode(TEST_CODE) << std::endl; // ostream test + std::cout << "TEST OUTPUT -> " << CommonCode(TEST_CODE) << std::endl; // ostream test EXPECT_EQ((uint64_t)CommonCode(TEST_CODE), TEST_CODE); // convert as uint64_t EXPECT_EQ(CommonCode(TEST_CODE).unwrap(), TEST_CODE); } TEST(CommonCode, code_convert) { + EXPECT_STREQ(CommonCode(TEST_CODE).to_string().c_str(), TEST_CODE_STR.c_str()); EXPECT_EQ(CommonCode(CommonCode(TEST_CODE).to_string()), CommonCode(TEST_CODE)); EXPECT_EQ(CommonCode(TEST_CODE).to_raw_code(), RawCode::from_common_code(TEST_CODE)); EXPECT_EQ(CommonCode(TEST_CODE).to_short_code(), ShortCode::from_common_code(TEST_CODE));