From 92398275b100786abfb6fa24cab3bd6c15c7ca18 Mon Sep 17 00:00:00 2001 From: Dnomd343 Date: Sun, 8 Sep 2024 17:03:24 +0800 Subject: [PATCH] test: optimize AllCases test suites --- src/core_test/cases/all_cases.cc | 65 ++++++++++++++----------- src/core_test/cases/basic_ranges.cc | 24 +++++---- src/core_test/cases/cases_helper.h | 40 --------------- src/core_test/cases/helper/block_num.cc | 2 + src/core_test/cases/helper/cases.h | 41 +++++++++++++--- src/core_test/cases/ranges.cc | 2 + 6 files changed, 89 insertions(+), 85 deletions(-) delete mode 100644 src/core_test/cases/cases_helper.h diff --git a/src/core_test/cases/all_cases.cc b/src/core_test/cases/all_cases.cc index eb014c0..fbc3e63 100644 --- a/src/core_test/cases/all_cases.cc +++ b/src/core_test/cases/all_cases.cc @@ -1,11 +1,26 @@ -#include "hash.h" -#include "cases_helper.h" +#include + +#include "helper/cases.h" +#include "utility/hash.h" +#include "utility/exposer.h" +#include "short_code/short_code.h" #include "common_code/common_code.h" +using klotski::array_sum; using klotski::cases::Ranges; +using klotski::cases::AllCases; +using klotski::cases::BasicRanges; + +using klotski::codec::ShortCode; using klotski::codec::CommonCode; -static constexpr auto ALL_CASES_XXH3 = std::to_array({ +using klotski::cases::ALL_CASES_NUM_; +using klotski::codec::SHORT_CODE_LIMIT; + +/// Forcibly modify private variables to reset state. +EXPOSE_VAR(AllCases, bool, available_) + +constexpr auto ALL_CASES_XXH3 = std::to_array({ 0x71c8ff7a71c93da0, 0x2a5247ee8bfed666, 0xf4efc8fc692d58e2, 0x2d06800538d394c2, 0xb3f7cc1b962d6944, 0x7e2792f8ab777faa, 0x4b8e78026cca8a27, 0x2d06800538d394c2, 0x8acd688c5ab93c42, 0xedca5101ed81cc77, 0xe8dc9d30c91ce682, 0x2d06800538d394c2, @@ -40,31 +55,24 @@ protected: }; TEST_FF(AllCases, content) { - auto verify = [](const uint64_t head) { + for (auto head : Heads) { auto &cases = AllCases::instance().fetch()[head]; - + EXPECT_SORTED_AND_UNIQUE(cases); EXPECT_EQ(cases.size(), ALL_CASES_NUM[head]); // size verify EXPECT_EQ(hash::xxh3(cases), ALL_CASES_XXH3[head]); // checksum verify + EXPECT_SUBSET(BasicRanges::instance().fetch(), cases); // subset verify + EXPECT_COMMON_CODES(head, cases); // release verify + } - EXPECT_TRUE(std::ranges::is_sorted(cases.begin(), cases.end())); - const auto match = std::ranges::adjacent_find(cases.begin(), cases.end()); - EXPECT_EQ(match, cases.end()); // no duplicates - - auto &all = BasicRanges::instance().fetch(); // subset verify - EXPECT_TRUE(std::ranges::includes(all.begin(), all.end(), cases.begin(), cases.end())); - - for (const auto range : cases) { - CommonCode::check(head << 32 | range); // release verify - } - }; - - for (int head = 0; head < 16; ++head) { - if (head % 4 != 3) { - verify(head); - continue; - } - EXPECT_EQ(AllCases::instance().fetch()[head].size(), 0); + ShortCode::speed_up(true); + std::vector short_codes; + short_codes.reserve(ALL_CASES_NUM_); + for (const auto code : AllCases::instance().fetch().codes()) { + short_codes.emplace_back(code.to_short_code().unwrap()); } + EXPECT_EQ(short_codes.front(), 0); + EXPECT_SORTED_AND_UNIQUE(short_codes); + EXPECT_EQ(short_codes.back(), SHORT_CODE_LIMIT - 1); } TEST_FF(AllCases, constant) { @@ -72,13 +80,14 @@ TEST_FF(AllCases, constant) { EXPECT_EQ(ALL_CASES_NUM.size(), 16); EXPECT_EQ(array_sum(ALL_CASES_NUM), ALL_CASES_NUM_); + EXPECT_EQ(ALL_CASES_NUM[3], 0); + EXPECT_EQ(ALL_CASES_NUM[7], 0); + EXPECT_EQ(ALL_CASES_NUM[11], 0); + EXPECT_EQ(ALL_CASES_NUM[15], 0); + auto ranges = BasicRanges::instance().fetch(); ranges.reverse(); - for (int head = 0; head < 16; ++head) { - if (head % 4 == 3) { - EXPECT_EQ(ALL_CASES_NUM[head], 0); - continue; - } + for (const auto head : Heads) { Ranges release; ranges.derive(head, release); EXPECT_EQ(release.size(), ALL_CASES_NUM[head]); diff --git a/src/core_test/cases/basic_ranges.cc b/src/core_test/cases/basic_ranges.cc index c40a656..96792c9 100644 --- a/src/core_test/cases/basic_ranges.cc +++ b/src/core_test/cases/basic_ranges.cc @@ -1,12 +1,22 @@ -#include "hash.h" +#include + #include "group/group.h" -#include "cases_helper.h" +#include "helper/cases.h" +#include "utility/hash.h" +#include "utility/exposer.h" +using klotski::array_sum; using klotski::cases::Ranges; +using klotski::cases::AllCases; +using klotski::cases::BasicRanges; + using klotski::cases::BLOCK_NUM; using klotski::cases::TYPE_ID_LIMIT; -static constexpr uint64_t BASIC_RANGES_XXH3 = 0x34fce9da6a052533; +/// Forcibly modify private variables to reset state. +EXPOSE_VAR(BasicRanges, bool, available_) + +constexpr uint64_t BASIC_RANGES_XXH3 = 0x34fce9da6a052533; class BasicRangesTest : public testing::Test, public Concurrent { protected: @@ -35,11 +45,7 @@ protected: TEST_FF(BasicRanges, content) { auto &ranges = BasicRanges::instance().fetch(); - - EXPECT_TRUE(std::ranges::is_sorted(ranges.begin(), ranges.end())); - const auto match = std::ranges::adjacent_find(ranges.begin(), ranges.end()); - EXPECT_EQ(match, ranges.end()); // no duplicates - + EXPECT_SORTED_AND_UNIQUE(ranges); EXPECT_EQ(ranges.size(), BASIC_RANGES_NUM_); // size verify EXPECT_EQ(hash::xxh3(ranges), BASIC_RANGES_XXH3); // checksum verify } @@ -50,7 +56,7 @@ TEST_FF(BasicRanges, constant) { EXPECT_EQ(array_sum(BASIC_RANGES_NUM), BASIC_RANGES_NUM_); for (uint32_t type_id = 0; type_id < TYPE_ID_LIMIT; ++type_id) { - auto [n, n_2x1, n_1x1] = BLOCK_NUM[type_id]; + const auto [n, n_2x1, n_1x1] = BLOCK_NUM[type_id]; Ranges ranges; ranges.spawn(n, n_2x1, n_1x1); EXPECT_EQ(ranges.size(), BASIC_RANGES_NUM[type_id]); diff --git a/src/core_test/cases/cases_helper.h b/src/core_test/cases/cases_helper.h deleted file mode 100644 index d3b7520..0000000 --- a/src/core_test/cases/cases_helper.h +++ /dev/null @@ -1,40 +0,0 @@ -#pragma once - -#include -#include - -#include "exposer.h" -#include "concurrent.h" -#include "all_cases/all_cases.h" - -using klotski::array_sum; - -using klotski::cases::AllCases; -using klotski::cases::BasicRanges; - -using klotski::cases::ALL_CASES_NUM; -using klotski::cases::ALL_CASES_NUM_; - -using klotski::cases::BASIC_RANGES_NUM; -using klotski::cases::BASIC_RANGES_NUM_; - -/// Test fixture wrapper with concurrency tools. -class Concurrent { -protected: - co::Racer racer_ {256}; - - co::Executor serial_ {1}; - co::Executor executor_ {0}; - - std::atomic counter_ {0}; - std::atomic_flag condition_ {false}; -}; - -/// Forcibly modify private variables to reset state. -EXPOSE_VAR(AllCases, bool, available_) -EXPOSE_VAR(BasicRanges, bool, available_) - -/// Test fixture macro with custom test suite name. -#define TEST_FF(test_suite_name, test_name) \ - GTEST_TEST_(test_suite_name, test_name, test_suite_name##Test, \ - ::testing::internal::GetTypeId()) diff --git a/src/core_test/cases/helper/block_num.cc b/src/core_test/cases/helper/block_num.cc index 6bcfecb..277d8b4 100644 --- a/src/core_test/cases/helper/block_num.cc +++ b/src/core_test/cases/helper/block_num.cc @@ -4,6 +4,8 @@ #include "cases.h" +using klotski::range_reverse; + /// Build the sequence list of all block numbers. static std::vector build_block_nums() { std::vector> nums; diff --git a/src/core_test/cases/helper/cases.h b/src/core_test/cases/helper/cases.h index d1ae6fd..1809282 100644 --- a/src/core_test/cases/helper/cases.h +++ b/src/core_test/cases/helper/cases.h @@ -4,7 +4,9 @@ #include #include "group/group.h" -#include "all_cases/all_cases.h" +#include "utility/concurrent.h" + +// ----------------------------------------------------------------------------------------- // using klotski::cases::Ranges; using klotski::cases::AllCases; @@ -12,9 +14,6 @@ using klotski::codec::CommonCode; using klotski::cases::BasicRanges; using klotski::cases::RangesUnion; -using klotski::array_sum; -using klotski::range_reverse; - using klotski::cases::BLOCK_NUM; using klotski::cases::ALL_CASES_NUM; using klotski::cases::ALL_CASES_NUM; @@ -26,7 +25,31 @@ constexpr auto Heads = std::to_array({ 0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14 }); -// ------------------------------------------------------------------------------------- // +// ----------------------------------------------------------------------------------------- // + +/// Test fixture wrapper with concurrency tools. +class Concurrent { +protected: + // Execute same task concurrently. + co::Racer racer_ {256}; + + // Execute assigned tasks one by one. + co::Executor serial_ {1}; + + // Execute assigned tasks on all cores. + co::Executor executor_ {0}; + + // Atomic helpers for multi-thread testing. + std::atomic counter_ {0}; + std::atomic_flag condition_ {false}; +}; + +/// Test fixture macro with custom test suite name. +#define TEST_FF(test_suite_name, test_name) \ + GTEST_TEST_(test_suite_name, test_name, test_suite_name##Test, \ + ::testing::internal::GetTypeId()) + +// ----------------------------------------------------------------------------------------- // /// Assert that Ranges are sorted and unique. #define EXPECT_SORTED_AND_UNIQUE(R) \ @@ -42,7 +65,7 @@ constexpr auto Heads = std::to_array({ for (const auto range : ranges) \ EXPECT_TRUE(CommonCode::check(static_cast(head) << 32 | range)) -// ------------------------------------------------------------------------------------- // +// ----------------------------------------------------------------------------------------- // /// The number of blocks in one klotski layout. struct block_num_t { @@ -62,7 +85,7 @@ constexpr bool operator==(const block_num_t &lhs, const block_num_t &rhs) { return lhs.n_1x1 == rhs.n_1x1 && lhs.n_1x2 == rhs.n_1x2 && lhs.n_2x1 == rhs.n_2x1; } -// ------------------------------------------------------------------------------------- // +// ----------------------------------------------------------------------------------------- // /// Calculate the block number from Range. block_num_t cal_block_num(uint32_t range); @@ -76,7 +99,7 @@ block_num_t to_block_num(uint32_t type_id); /// Get all block number combinations without dependencies. const std::vector& block_nums(); -// ------------------------------------------------------------------------------------- // +// ----------------------------------------------------------------------------------------- // // TODO: get cases with type id (filter from AllCases) @@ -87,3 +110,5 @@ const std::vector& group_union_cases(uint32_t type_id); std::vector group_cases(uint32_t type_id, uint32_t group_id); // TODO: always return ref of `std::vector` here + +// ----------------------------------------------------------------------------------------- // diff --git a/src/core_test/cases/ranges.cc b/src/core_test/cases/ranges.cc index c6829d4..95efc0d 100644 --- a/src/core_test/cases/ranges.cc +++ b/src/core_test/cases/ranges.cc @@ -4,6 +4,8 @@ #include "helper/cases.h" #include "ranges/ranges.h" +using klotski::range_reverse; + static_assert(std::is_base_of_v, Ranges>); TEST(Ranges, check) {