test_randx_cpp17.cpp

// test_randx_cpp17.cpp — RandX_Cpp17.hpp (C++17) 确定性单元测试（doctest 版）
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

#include "RandX_Cpp17.hpp"

#include <array>
#include <algorithm>
#include <cinttypes>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <iterator>
#include <list>
#include <sstream>
#include <vector>

// 统计检验临界值（非魔法数字：自由度 99/127，alpha=0.001 的卡方临界值）
namespace
{
    // 自由度 99, alpha=0.001 临界值 ≈ 148.2
    constexpr double CHI2_CRITICAL_DF99 = 148.2;
    // 自由度 127, alpha=0.001 临界值 ≈ 173.6
    constexpr double CHI2_CRITICAL_DF127 = 173.6;
    // 统计检验样本数与分箱数
    constexpr int STAT_N = 1'000'000;
    constexpr int STAT_BINS_100 = 100;
    constexpr int STAT_BINS_128 = 128;
    // 蒙特卡洛试验次数
    constexpr int MC_TRIALS_1K = 1000;
    constexpr int MC_TRIALS_10K = 10000;
    constexpr int MC_TRIALS_100 = 100;
    // ChaCha20 卡方检验样本数：须 < 2^20/8 = 131072 以避免触发自动 reseed（保持确定性）
    constexpr int CHACHA20_CHI2_N = 100'000;
}

using namespace RandX;

// ============================================================================
// 已知序列断言（seed=12345）— 7 引擎 KAT
// 与 test_randx.cpp 期望值完全一致（见附录 C 双标准同步策略）
// ============================================================================
TEST_SUITE("已知序列 seed=12345")
{
    TEST_CASE("Xoshiro256StarStar")
    {
        Xoshiro256StarStar rng{ 12345 };
        const std::uint64_t expected[] = {
            13720838825685603483ULL, 2398916695208396998ULL,
            17770384849984869256ULL, 891717726879801395ULL,
            10241316046318454344ULL
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }

    TEST_CASE("Xoroshiro128StarStar")
    {
        Xoroshiro128StarStar rng{ 12345 };
        const std::uint64_t expected[] = {
            9940793396233540349ULL, 8784320640503919345ULL,
            16208043774633962581ULL, 11032235639386297630ULL,
            4698907930579033109ULL
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }

    TEST_CASE("Xoshiro128StarStar")
    {
        Xoshiro128StarStar rng{ 12345 };
        const std::uint32_t expected[] = {
            1096865841U, 933661059U, 3314798965U, 1305642763U, 1040785987U
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }

    TEST_CASE("Xoroshiro64StarStar")
    {
        Xoroshiro64StarStar rng{ 12345 };
        const std::uint32_t expected[] = {
            63958076U, 2181105171U, 532052331U, 3458610118U, 2965685819U
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }

    TEST_CASE("SplitMix64")
    {
        SplitMix64 rng{ 12345 };
        const std::uint64_t expected[] = {
            2454886589211414944ULL, 3778200017661327597ULL,
            2205171434679333405ULL, 3248800117070709450ULL,
            9350289611492784363ULL
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }

    TEST_CASE("SFC64")
    {
        SFC64 rng{ 12345 };
        const std::uint64_t expected[] = {
            13526236746588683560ULL, 8823148983839225293ULL,
            5240613241081073383ULL, 17030394482648619497ULL,
            7698197985592869707ULL
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }

    TEST_CASE("RomuDuoJr")
    {
        RomuDuoJr rng{ 12345 };
        const std::uint64_t expected[] = {
            2454886589211414944ULL, 12510505629750556783ULL,
            16962469053573158940ULL, 8350026492023846583ULL,
            15401281827437905834ULL
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }
}

// ============================================================================
// 引擎基础设施
// ============================================================================
TEST_SUITE("引擎基础设施")
{
    TEST_CASE("MakeStreamEngine 多流不重叠")
    {
        auto s0 = MakeStreamEngine<Xoshiro256StarStar>(0, 12345);
        auto s1 = MakeStreamEngine<Xoshiro256StarStar>(1, 12345);
        bool allSame = true;
        for (int i = 0; i < 10; ++i)
        {
            if (s0() != s1()) allSame = false;
        }
        CHECK_FALSE(allSame);
    }

    TEST_CASE("serialize / deserialize 状态恢复")
    {
        Xoshiro256StarStar rng{ 99999 };
        rng.discard(10);
        auto state = rng.serialize();
        Xoshiro256StarStar rng2{ state };
        for (int i = 0; i < 10; ++i)
            CHECK(rng() == rng2());
    }

    TEST_CASE("discard 与连续调用等价")
    {
        Xoshiro256StarStar a{ 42 };
        Xoshiro256StarStar b{ 42 };
        a.discard(100);
        for (int i = 0; i < 100; ++i) b();
        CHECK(a() == b());
    }

    TEST_CASE("operator== / != 相等性")
    {
        Xoshiro256StarStar a{ 1 }, b{ 1 }, c{ 2 };
        CHECK(a == b);
        CHECK(a != c);
    }

    TEST_CASE("jump / longJump 不崩溃")
    {
        Xoshiro256StarStar rng{ 777 };
        rng.jump();
        rng.longJump();
        (void)rng();
    }

    TEST_CASE("std::seed_seq 播种确定性")
    {
        std::seed_seq seq{ 1, 2, 3, 4, 5, 6, 7, 8 };
        Xoshiro256StarStar rng1{ seq };
        std::seed_seq seq2{ 1, 2, 3, 4, 5, 6, 7, 8 };
        Xoshiro256StarStar rng2{ seq2 };
        CHECK(rng1() == rng2());
        CHECK(rng1() == rng2());
    }
}

// ============================================================================
// 便捷 API
// ============================================================================
TEST_SUITE("便捷 API")
{
    TEST_CASE("RandInt / RandReal 范围闭/半开区间")
    {
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            int v = RandInt(1, 6);
            CHECK(v >= 1);
            CHECK(v <= 6);
        }
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            double v = RandReal();
            CHECK(v >= 0.0);
            CHECK(v < 1.0);
        }
    }

    TEST_CASE("RandNormal 均值接近 0")
    {
        double sum = 0;
        for (int i = 0; i < MC_TRIALS_10K; ++i)
            sum += RandNormal(0.0, 1.0);
        double mean = sum / MC_TRIALS_10K;
        CHECK(mean > -0.1);
        CHECK(mean < 0.1);
    }

    TEST_CASE("RandShuffle 保持元素集合")
    {
        std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        std::vector<int> orig = v;
        RandShuffle(v);
        CHECK(v != orig);
        std::sort(v.begin(), v.end());
        CHECK(v == orig);
    }

    TEST_CASE("RandWeighted 零权重不被选中")
    {
        std::vector<double> weights = { 0.0, 0.0, 1.0, 0.0 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandWeighted(weights) == 2);
    }

    TEST_CASE("RandElement 容器版返回元素引用")
    {
        std::array<int, 3> arr = { {10, 20, 30} };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            int v = RandElement(arr);
            CHECK((v == 10 || v == 20 || v == 30));
        }
    }

    TEST_CASE("Reseed 可重播种确定性")
    {
        Reseed(42);
        const auto a = RandInt(0, 1000000);
        Reseed(42);
        const auto b = RandInt(0, 1000000);
        CHECK(a == b);
    }

    TEST_CASE("扩展便捷 API 集成")
    {
        // RandSample：无放回抽样
        std::vector<int> pool = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        auto sample = RandSample(pool, 3);
        CHECK(sample.size() == 3);
        for (const auto& x : sample)
            CHECK(std::find(pool.begin(), pool.end(), x) != pool.end());
        CHECK((sample[0] != sample[1] || sample[1] != sample[2] || sample[0] != sample[2]));

        // RandPermutation：随机排列
        auto perm = RandPermutation(10);
        CHECK(perm.size() == 10);
        auto sorted_perm = perm;
        std::sort(sorted_perm.begin(), sorted_perm.end());
        for (std::size_t i = 0; i < 10; ++i)
            CHECK(sorted_perm[i] == static_cast<int>(i));

        // RandString：随机字符串
        auto str = RandString(16);
        CHECK(str.size() == 16);
        auto str2 = RandString(8, "01");
        CHECK(str2.size() == 8);
        for (const auto& c : str2) CHECK((c == '0' || c == '1'));

        // RandExp：指数分布（验证非负）
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandExp() >= 0.0);

        // RandPoisson：泊松分布（验证非负）
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandPoisson() >= 0);

        // RandGamma：伽马分布（验证正数）
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandGamma() > 0.0);

        // RandBits：N 位随机数
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            CHECK(RandBits<8>() < 256);
            CHECK(RandBits<1>() < 2);
        }

        // RandUUID：格式验证
        auto uuid = RandUUID();
        CHECK(uuid.size() == 36);
        CHECK(uuid[8] == '-');
        CHECK(uuid[13] == '-');
        CHECK(uuid[18] == '-');
        CHECK(uuid[23] == '-');
        CHECK(uuid[14] == '4');  // 版本号
        CHECK((uuid[19] == '8' || uuid[19] == '9' || uuid[19] == 'a' || uuid[19] == 'b'));
    }

    // ============================================================
    // 新增分布（v1.2）：Bernoulli/Binomial/LogNormal/Geometric/
    // Cauchy/Weibull/ExtremeValue/ChiSquared/StudentT/FisherF/Beta
    // ============================================================
    TEST_CASE("RandBernoulli 与 RandBool 引擎重载等价")
    {
        Xoshiro256StarStar rng1{ 42 }, rng2{ 42 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandBernoulli(rng1, 0.3) == RandBool(rng2, 0.3));
    }

    TEST_CASE("RandBinomial 范围与均值")
    {
        // t=60, p=0.5：理论均值 30，方差 15
        double sum = 0;
        for (int i = 0; i < MC_TRIALS_10K; ++i)
        {
            int v = RandBinomial(60, 0.5);
            CHECK(v >= 0);
            CHECK(v <= 60);
            sum += v;
        }
        const double mean = sum / MC_TRIALS_10K;
        CHECK(mean > 25.0);
        CHECK(mean < 35.0);
    }

    TEST_CASE("RandLogNormal 正数")
    {
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandLogNormal(0.0, 1.0) > 0.0);
    }

    TEST_CASE("RandGeometric 非负")
    {
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandGeometric(0.3) >= 0);
    }

    TEST_CASE("RandCauchy 有限值占绝大多数")
    {
        // Cauchy 重尾，理论上 P(|x|<1e6)≈0.99968，inf 极罕见
        int finiteCount = 0;
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            const double v = RandCauchy(0.0, 1.0);
            if (std::isfinite(v)) ++finiteCount;
        }
        CHECK(finiteCount >= MC_TRIALS_100 - 5);
    }

    TEST_CASE("RandWeibull 非负")
    {
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandWeibull(2.0, 1.0) >= 0.0);
    }

    TEST_CASE("RandExtremeValue 有限值")
    {
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            const double v = RandExtremeValue(0.0, 1.0);
            CHECK(std::isfinite(v));
        }
    }

    TEST_CASE("RandChiSquared 非负")
    {
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandChiSquared(4.0) >= 0.0);
    }

    TEST_CASE("RandStudentT 有限值占绝大多数")
    {
        // 自由度 4：有限方差但重尾
        int finiteCount = 0;
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            const double v = RandStudentT(4.0);
            if (std::isfinite(v)) ++finiteCount;
        }
        CHECK(finiteCount >= MC_TRIALS_100 - 5);
    }

    TEST_CASE("RandFisherF 非负")
    {
        for (int i = 0; i < MC_TRIALS_100; ++i)
            CHECK(RandFisherF(5.0, 5.0) >= 0.0);
    }

    TEST_CASE("RandBeta 范围 [0,1] 与均值")
    {
        // a=2, b=2：理论均值 0.5，方差 0.05
        double sum = 0;
        for (int i = 0; i < MC_TRIALS_10K; ++i)
        {
            const double v = RandBeta(2.0, 2.0);
            CHECK(v >= 0.0);
            CHECK(v <= 1.0);
            sum += v;
        }
        const double mean = sum / MC_TRIALS_10K;
        CHECK(mean > 0.4);
        CHECK(mean < 0.6);
    }

    TEST_CASE("新分布引擎重载确定性")
    {
        Xoshiro256StarStar rng1{ 12345 }, rng2{ 12345 };
        CHECK(RandBinomial(rng1, 10, 0.5) == RandBinomial(rng2, 10, 0.5));
        CHECK(RandLogNormal(rng1, 0.0, 1.0) == RandLogNormal(rng2, 0.0, 1.0));
        CHECK(RandGeometric(rng1, 0.3) == RandGeometric(rng2, 0.3));
        CHECK(RandCauchy(rng1, 0.0, 1.0) == RandCauchy(rng2, 0.0, 1.0));
        CHECK(RandWeibull(rng1, 2.0, 1.0) == RandWeibull(rng2, 2.0, 1.0));
        CHECK(RandExtremeValue(rng1, 0.0, 1.0) == RandExtremeValue(rng2, 0.0, 1.0));
        CHECK(RandChiSquared(rng1, 4.0) == RandChiSquared(rng2, 4.0));
        CHECK(RandStudentT(rng1, 4.0) == RandStudentT(rng2, 4.0));
        CHECK(RandFisherF(rng1, 5.0, 5.0) == RandFisherF(rng2, 5.0, 5.0));
        CHECK(RandBeta(rng1, 2.0, 2.0) == RandBeta(rng2, 2.0, 2.0));
    }
}

// ============================================================================
// 新增 API（C++17 SFINAE）：RandChar / RandElement 迭代器版 / RandFill / RandVector / operator<<>> 
// ============================================================================
TEST_SUITE("新增 API")
{
    TEST_CASE("RandChar 范围与类型")
    {
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            char c = RandChar('a', 'z');
            CHECK(c >= 'a');
            CHECK(c <= 'z');
        }
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            wchar_t wc = RandChar<wchar_t>(L'a', L'z');
            CHECK(wc >= L'a');
            CHECK(wc <= L'z');
        }
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            char16_t c16 = RandChar<char16_t>(u'a', u'z');
            CHECK(c16 >= u'a');
            CHECK(c16 <= u'z');
        }
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            char32_t c32 = RandChar<char32_t>(U'a', U'z');
            CHECK(c32 >= U'a');
            CHECK(c32 <= U'z');
        }
        // RandChar(max) 单参版
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            char c = RandChar<char>('z');
            CHECK(c >= char{});
            CHECK(c <= 'z');
        }
    }

#if defined(__cpp_char8_t) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
    TEST_CASE("RandChar char8_t（C++20+ 条件启用）")
    {
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            char8_t c = RandChar<char8_t>(u8'a', u8'z');
            CHECK(c >= u8'a');
            CHECK(c <= u8'z');
        }
    }
#endif

    TEST_CASE("RandChar 引擎重载")
    {
        Xoshiro256StarStar rng{ 12345 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            char c = RandChar<char>(rng, 'a', 'z');
            CHECK(c >= 'a');
            CHECK(c <= 'z');
        }
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            char c = RandChar<char>(rng, 'z');
            CHECK(c >= char{});
            CHECK(c <= 'z');
        }
    }

    TEST_CASE("RandElement 迭代器版（随机访问）")
    {
        std::vector<int> v = { 10, 20, 30, 40, 50 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            auto it = RandElement(v.begin(), v.end());
            CHECK(it >= v.begin());
            CHECK(it < v.end());
            CHECK(*it >= 10);
            CHECK(*it <= 50);
        }
        // 引擎重载
        Xoshiro256StarStar rng{ 12345 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            auto it = RandElement(rng, v.begin(), v.end());
            CHECK(it >= v.begin());
            CHECK(it < v.end());
        }
    }

    TEST_CASE("RandElement 迭代器版（输入迭代器 reservoir sampling）")
    {
        std::list<int> l = { 100, 200, 300, 400, 500 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            auto val = RandElement(l.begin(), l.end());
            CHECK(val >= 100);
            CHECK(val <= 500);
        }
        // 引擎重载
        Xoshiro256StarStar rng{ 12345 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            auto val = RandElement(rng, l.begin(), l.end());
            CHECK(val >= 100);
            CHECK(val <= 500);
        }
    }

    TEST_CASE("RandElement 空范围抛异常")
    {
        std::vector<int> empty;
        CHECK_THROWS_AS((void)RandElement(empty.begin(), empty.end()), std::invalid_argument);
    }

    TEST_CASE("RandFill 填充范围")
    {
        std::array<int, 100> arr{};
        RandFill(arr.begin(), arr.end(), 0, 99);
        for (const auto& v : arr)
        {
            CHECK(v >= 0);
            CHECK(v <= 99);
        }
        // 浮点版
        std::vector<double> v(100);
        RandFill(v.begin(), v.end(), 0.0, 1.0);
        for (const auto& d : v)
        {
            CHECK(d >= 0.0);
            CHECK(d < 1.0);
        }
        // 引擎重载
        Xoshiro256StarStar rng{ 12345 };
        std::vector<int> v2(100);
        RandFill(rng, v2.begin(), v2.end(), 1, 10);
        for (const auto& i : v2)
        {
            CHECK(i >= 1);
            CHECK(i <= 10);
        }
    }

    TEST_CASE("RandVector 生成 vector")
    {
        auto vi = RandVector(0, 99, 100);
        CHECK(vi.size() == 100);
        for (const auto& v : vi)
        {
            CHECK(v >= 0);
            CHECK(v <= 99);
        }
        auto vd = RandVector(0.0, 1.0, 100);
        CHECK(vd.size() == 100);
        for (const auto& v : vd)
        {
            CHECK(v >= 0.0);
            CHECK(v < 1.0);
        }
        // 引擎重载
        Xoshiro256StarStar rng{ 12345 };
        auto vi2 = RandVector(rng, 1, 6, 50);
        CHECK(vi2.size() == 50);
        for (const auto& v : vi2)
        {
            CHECK(v >= 1);
            CHECK(v <= 6);
        }
        auto vd2 = RandVector(rng, 0.0, 10.0, 50);
        CHECK(vd2.size() == 50);
        for (const auto& v : vd2)
        {
            CHECK(v >= 0.0);
            CHECK(v < 10.0);
        }
    }

    TEST_CASE("operator<< / operator>> 流式序列化")
    {
        Xoshiro256StarStar rng1{ 12345 };
        // 推进若干步
        for (int i = 0; i < 10; ++i) (void)rng1();

        std::stringstream ss;
        ss << rng1;
        CHECK((ss.good() || ss.eof()));

        Xoshiro256StarStar rng2{ 99999 };
        ss >> rng2;
        CHECK((ss.good() || ss.eof()));

        // 恢复后两个引擎状态一致，后续输出相同
        CHECK(rng1 == rng2);
        CHECK(rng1() == rng2());
    }

    TEST_CASE("operator>> 失败时设置 failbit 且状态不变")
    {
        Xoshiro256StarStar rng1{ 12345 };
        Xoshiro256StarStar rng2{ 12345 };
        // 推进若干步，使状态非默认
        for (int i = 0; i < 5; ++i) (void)rng1(), (void)rng2();

        std::stringstream ss("not a number");  // 故意错误输入
        ss >> rng1;
        CHECK((ss.failbit & ss.rdstate()) != 0);
        // 状态未改变
        CHECK(rng1 == rng2);
    }

    TEST_CASE("operator<< 不应匹配 SplitMix64（标量 state_type）")
    {
        // 此测试主要保证编译期 SFINAE 排除标量引擎
        static_assert(!detail::is_serializable_engine_v<SplitMix64>,
            "SplitMix64 must not be serializable (scalar state_type)");
        static_assert(detail::is_serializable_engine_v<Xoshiro256StarStar>,
            "Xoshiro256StarStar must be serializable");
    }
}

// ============================================================================
// RandSample 迭代器版（v1.2 新增）
// ============================================================================
TEST_SUITE("RandSample 迭代器版")
{
    TEST_CASE("随机访问路径（索引分支）：n·64>=size 走索引数组")
    {
        std::vector<int> v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        // n=5, size=10, n·64=320 >= 10 → 索引数组分支
        auto sample = RandSample(v.begin(), v.end(), 5);
        CHECK(sample.size() == 5);
        for (int x : sample)
        {
            CHECK(x >= 0);
            CHECK(x <= 9);
            CHECK(std::count(sample.begin(), sample.end(), x) == 1);
        }
    }

    TEST_CASE("随机访问路径（hash-set 分支）：n·64<size 走 hash-set")
    {
        std::vector<int> v(10000);
        for (int i = 0; i < 10000; ++i) v[static_cast<std::size_t>(i)] = i;
        // n=5, size=10000, n·64=320 < 10000 → hash-set 分支
        auto sample = RandSample(v.begin(), v.end(), 5);
        CHECK(sample.size() == 5);
        for (int x : sample)
        {
            CHECK(x >= 0);
            CHECK(x <= 9999);
            CHECK(std::count(sample.begin(), sample.end(), x) == 1);
        }
    }

    TEST_CASE("输入路径：std::list 走 reservoir sampling")
    {
        std::list<int> lst = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
        auto sample = RandSample(lst.begin(), lst.end(), 3);
        CHECK(sample.size() == 3);
        for (int x : sample)
        {
            bool found = false;
            for (int e : lst) if (e == x) { found = true; break; }
            CHECK(found);
        }
        std::sort(sample.begin(), sample.end());
        for (std::size_t i = 1; i < sample.size(); ++i)
            CHECK(sample[i] != sample[i - 1]);
    }

    TEST_CASE("流式输入：std::istream_iterator 走 reservoir")
    {
        std::istringstream iss("1 2 3 4 5 6 7 8 9 10");
        std::istream_iterator<int> first(iss);
        std::istream_iterator<int> last;
        auto sample = RandSample(first, last, 3);
        CHECK(sample.size() == 3);
        for (int x : sample)
        {
            CHECK(x >= 1);
            CHECK(x <= 10);
        }
        std::sort(sample.begin(), sample.end());
        for (std::size_t i = 1; i < sample.size(); ++i)
            CHECK(sample[i] != sample[i - 1]);
    }

    TEST_CASE("边界：n=0 返回空")
    {
        std::vector<int> v = { 1, 2, 3, 4, 5 };
        auto s1 = RandSample(v.begin(), v.end(), 0);
        CHECK(s1.empty());
        std::list<int> lst = { 1, 2, 3 };
        auto s2 = RandSample(lst.begin(), lst.end(), 0);
        CHECK(s2.empty());
    }

    TEST_CASE("边界：n>=size 返回全部")
    {
        std::vector<int> v = { 1, 2, 3, 4, 5 };
        auto s1 = RandSample(v.begin(), v.end(), 5);
        CHECK(s1.size() == 5);
        auto s2 = RandSample(v.begin(), v.end(), 10);
        CHECK(s2.size() == 5);
        std::list<int> lst = { 10, 20, 30 };
        auto s3 = RandSample(lst.begin(), lst.end(), 3);
        CHECK(s3.size() == 3);
        auto s4 = RandSample(lst.begin(), lst.end(), 10);
        CHECK(s4.size() == 3);
    }

    TEST_CASE("边界：空范围返回空")
    {
        std::vector<int> empty;
        auto s1 = RandSample(empty.begin(), empty.end(), 3);
        CHECK(s1.empty());
        std::list<int> emptyLst;
        auto s2 = RandSample(emptyLst.begin(), emptyLst.end(), 3);
        CHECK(s2.empty());
    }

    TEST_CASE("引擎重载确定性（随机访问）")
    {
        std::vector<int> v(1000);
        for (int i = 0; i < 1000; ++i) v[static_cast<std::size_t>(i)] = i;
        Xoshiro256StarStar rng1{ 42 }, rng2{ 42 };
        auto s1 = RandSample(rng1, v.begin(), v.end(), 10);
        auto s2 = RandSample(rng2, v.begin(), v.end(), 10);
        CHECK(s1 == s2);
    }

    TEST_CASE("引擎重载确定性（输入迭代器 reservoir）")
    {
        std::list<int> lst = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 };
        Xoshiro256StarStar rng1{ 42 }, rng2{ 42 };
        auto s1 = RandSample(rng1, lst.begin(), lst.end(), 5);
        auto s2 = RandSample(rng2, lst.begin(), lst.end(), 5);
        CHECK(s1 == s2);
    }

    TEST_CASE("均匀性（reservoir）：前后半段均衡，验证 i+1 修复")
    {
        // N=200, n=10, TRIALS=10000；期望各半段被选 50000 次
        // 修复前 dist(0,i-1) 会使后半段过选；修复后 dist(0,i) 均匀
        constexpr int N = 200;
        constexpr int n = 10;
        constexpr int TRIALS = 10000;
        std::vector<int> v(static_cast<std::size_t>(N));
        for (int i = 0; i < N; ++i) v[static_cast<std::size_t>(i)] = i;
        int firstHalf = 0, secondHalf = 0;
        for (int t = 0; t < TRIALS; ++t)
        {
            auto s = RandSample(v.begin(), v.end(), n);
            for (int x : s)
            {
                if (x < N / 2) ++firstHalf;
                else ++secondHalf;
            }
        }
        // ±10% 容差（修复前差值极大，可稳定捕获 BUG）
        CHECK(firstHalf > 45000);
        CHECK(firstHalf < 55000);
        CHECK(secondHalf > 45000);
        CHECK(secondHalf < 55000);
    }

    TEST_CASE("均匀性（hash-set）：前后半段均衡")
    {
        // n·64 < size 强制走 hash-set 分支：N=10000, n=5, n·64=320<10000
        constexpr int N = 10000;
        constexpr int n = 5;
        constexpr int TRIALS = 10000;
        std::vector<int> v(static_cast<std::size_t>(N));
        for (int i = 0; i < N; ++i) v[static_cast<std::size_t>(i)] = i;
        int firstHalf = 0, secondHalf = 0;
        for (int t = 0; t < TRIALS; ++t)
        {
            auto s = RandSample(v.begin(), v.end(), n);
            for (int x : s)
            {
                if (x < N / 2) ++firstHalf;
                else ++secondHalf;
            }
        }
        // 期望各 25000，±15% 容差
        CHECK(firstHalf > 21250);
        CHECK(firstHalf < 28750);
        CHECK(secondHalf > 21250);
        CHECK(secondHalf < 28750);
    }
}

// ============================================================================
// 统计自检（Chi-Square 频率检验）
// ============================================================================
TEST_SUITE("Chi-Square 频率检验")
{
    TEST_CASE("Xoshiro256StarStar 均匀性 df=99")
    {
        constexpr double EXPECTED = static_cast<double>(STAT_N) / STAT_BINS_100;

        Xoshiro256StarStar rng{ 98765 };
        std::array<int, STAT_BINS_100> counts{};
        for (int i = 0; i < STAT_N; ++i)
            ++counts[RandInt(rng, 0, STAT_BINS_100 - 1)];

        double chi2 = 0.0;
        for (int i = 0; i < STAT_BINS_100; ++i)
        {
            const double diff = counts[i] - EXPECTED;
            chi2 += diff * diff / EXPECTED;
        }
        CHECK(chi2 < CHI2_CRITICAL_DF99);
    }

    TEST_CASE("SFC64 原始输出均匀性 df=127")
    {
        constexpr double EXPECTED = static_cast<double>(STAT_N) / STAT_BINS_128;

        SFC64 rng{ 54321 };
        std::array<int, STAT_BINS_128> counts{};
        for (int i = 0; i < STAT_N; ++i)
            ++counts[rng() & 127];

        double chi2 = 0.0;
        for (int i = 0; i < STAT_BINS_128; ++i)
        {
            const double diff = counts[i] - EXPECTED;
            chi2 += diff * diff / EXPECTED;
        }
        CHECK(chi2 < CHI2_CRITICAL_DF127);
    }

    TEST_CASE("RomuDuoJr 原始输出均匀性 df=127")
    {
        constexpr double EXPECTED = static_cast<double>(STAT_N) / STAT_BINS_128;

        RomuDuoJr rng{ 54321 };
        std::array<int, STAT_BINS_128> counts{};
        for (int i = 0; i < STAT_N; ++i)
            ++counts[rng() & 127];

        double chi2 = 0.0;
        for (int i = 0; i < STAT_BINS_128; ++i)
        {
            const double diff = counts[i] - EXPECTED;
            chi2 += diff * diff / EXPECTED;
        }
        CHECK(chi2 < CHI2_CRITICAL_DF127);
    }
}

// ============================================================================
// RandChar / RandString 预设字符集（v1.2 新增）
// ============================================================================
TEST_SUITE("RandChar 预设字符集")
{
    TEST_CASE("RandChar(CharSet::Lower) 全部属于 [a-z]")
    {
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            char c = RandChar(CharSet::Lower);
            CHECK(c >= 'a');
            CHECK(c <= 'z');
        }
    }

    TEST_CASE("RandChar(CharSet::Hex) 全部属于 [0-9a-f]")
    {
        const std::string hexSet = "0123456789abcdef";
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            char c = RandChar(CharSet::Hex);
            CHECK(hexSet.find(c) != std::string::npos);
        }
    }

    TEST_CASE("RandChar 9 种字符集全覆盖")
    {
        using CS = CharSet;
        const std::string alnum = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        const std::string alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        const std::string lower = "abcdefghijklmnopqrstuvwxyz";
        const std::string upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        const std::string digit = "0123456789";
        const std::string hexS = "0123456789abcdef";
        const std::string printable = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
        const std::string base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        const std::string base64UrlSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            CHECK(alnum.find(RandChar(CS::Alphanumeric)) != std::string::npos);
            CHECK(alpha.find(RandChar(CS::Alpha)) != std::string::npos);
            CHECK(lower.find(RandChar(CS::Lower)) != std::string::npos);
            CHECK(upper.find(RandChar(CS::Upper)) != std::string::npos);
            CHECK(digit.find(RandChar(CS::Digit)) != std::string::npos);
            CHECK(hexS.find(RandChar(CS::Hex)) != std::string::npos);
            CHECK(printable.find(RandChar(CS::Printable)) != std::string::npos);
            CHECK(base64.find(RandChar(CS::Base64)) != std::string::npos);
            CHECK(base64UrlSafe.find(RandChar(CS::Base64UrlSafe)) != std::string::npos);
        }
    }

    TEST_CASE("RandChar 引擎重载确定性")
    {
        Xoshiro256StarStar rng1{ 42 }, rng2{ 42 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            CHECK(RandChar(rng1, CharSet::Hex) == RandChar(rng2, CharSet::Hex));
        }
    }

    TEST_CASE("RandChar 引擎重载支持非 Xoshiro256StarStar 引擎")
    {
        // 验证 RandChar(Engine&, CharSet) 对 SFC64 / RomuDuoJr 等任意引擎均可编译且确定性成立
        SFC64 sfc1{ 42 }, sfc2{ 42 };
        RomuDuoJr romu1{ 42 }, romu2{ 42 };
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            CHECK(RandChar(sfc1, CharSet::Hex) == RandChar(sfc2, CharSet::Hex));
            CHECK(RandChar(romu1, CharSet::Lower) == RandChar(romu2, CharSet::Lower));
        }
    }

    TEST_CASE("RandString 引擎重载确定性与字符集")
    {
        // 验证 RandString(Engine&, n, CharSet) 引擎重载
        Xoshiro256StarStar rng1{ 42 }, rng2{ 42 };
        const std::string hexSet = "0123456789abcdef";
        auto s1 = RandString(rng1, 32, CharSet::Hex);
        auto s2 = RandString(rng2, 32, CharSet::Hex);
        CHECK(s1.size() == 32);
        CHECK(s1 == s2);
        for (char c : s1)
            CHECK(hexSet.find(c) != std::string::npos);

        // 非默认引擎也应可工作
        SFC64 sfc{ 7 };
        auto s3 = RandString(sfc, 16, CharSet::Base64);
        const std::string base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        CHECK(s3.size() == 16);
        for (char c : s3)
            CHECK(base64.find(c) != std::string::npos);
    }

    TEST_CASE("RandString(n, CharSet::Digit) 全部属于 [0-9]")
    {
        const std::string digit = "0123456789";
        auto s = RandString(100, CharSet::Digit);
        CHECK(s.size() == 100);
        for (char c : s)
            CHECK(digit.find(c) != std::string::npos);
    }

    TEST_CASE("RandString(16, CharSet::Hex) 长度与字符集")
    {
        const std::string hexSet = "0123456789abcdef";
        auto s = RandString(16, CharSet::Hex);
        CHECK(s.size() == 16);
        for (char c : s)
            CHECK(hexSet.find(c) != std::string::npos);
    }

    TEST_CASE("RandString(12, CharSet::Base64) RFC 4648 合规")
    {
        const std::string base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        auto s = RandString(12, CharSet::Base64);
        CHECK(s.size() == 12);
        for (char c : s)
            CHECK(base64.find(c) != std::string::npos);
    }

    TEST_CASE("RandChar(CharSet::Base64UrlSafe) 全部属于 URL-safe 字母表")
    {
        const std::string urlSafeSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
        for (int i = 0; i < MC_TRIALS_1K; ++i)
        {
            char c = RandChar(CharSet::Base64UrlSafe);
            CHECK(urlSafeSet.find(c) != std::string::npos);
        }
    }

    TEST_CASE("RandString(12, CharSet::Base64UrlSafe) RFC 4648 §5 合规")
    {
        const std::string urlSafeSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
        auto s = RandString(12, CharSet::Base64UrlSafe);
        CHECK(s.size() == 12);
        for (char c : s)
            CHECK(urlSafeSet.find(c) != std::string::npos);
    }

    TEST_CASE("Base64 vs Base64UrlSafe 仅末两字符不同（引擎重载同种子）")
    {
        // 引擎重载下 uniform_int_distribution(0,63) 产生相同索引序列，
        // 仅 index=62（Base64:'+' / UrlSafe:'-'）与 index=63（Base64:'/' / UrlSafe:'_'）处字符不同
        Xoshiro256StarStar rng1{ 42 }, rng2{ 42 };
        const std::string base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        const std::string urlSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
        for (int i = 0; i < MC_TRIALS_100; ++i)
        {
            char c1 = RandChar(rng1, CharSet::Base64);
            char c2 = RandChar(rng2, CharSet::Base64UrlSafe);
            // 同索引：若 index<62 则字符相同，index=62/63 则不同
            if (c1 == c2)
            {
                CHECK(base64.find(c1) < 62);
            }
            else
            {
                // 差异仅允许在 +→- 与 /→_（doctest 禁止 || 于 CHECK 宏内，先求值 bool）
                const bool validDiff = (c1 == '+' && c2 == '-') || (c1 == '/' && c2 == '_');
                CHECK(validDiff);
            }
        }
    }

    TEST_CASE("RandChar(CharSet::Hex) 均匀性 ±3σ")
    {
        // Hex 字符集 = "0123456789abcdef" 共 16 个字符（标准小写 hex）
        // 各字符期望频率 1/16，N=22000 采样，每字符期望 1375 次
        // σ = sqrt(N * p * (1-p)) = sqrt(22000 * 1/16 * 15/16) ≈ 35.90
        const std::string hexSet = "0123456789abcdef";
        const std::size_t cat = hexSet.size();
        constexpr int N = 22000;
        const int expected = N / static_cast<int>(cat);
        const double p = 1.0 / static_cast<double>(cat);
        const double sigma = std::sqrt(static_cast<double>(N) * p * (1.0 - p));
        std::vector<int> counts(cat, 0);
        for (int i = 0; i < N; ++i)
        {
            char c = RandChar(CharSet::Hex);
            auto idx = hexSet.find(c);
            CHECK(idx != std::string::npos);
            ++counts[idx];
        }
        for (std::size_t i = 0; i < cat; ++i)
        {
            const double dev = std::abs(counts[i] - expected);
            CHECK(dev < 3.0 * sigma);
        }
    }
}

// ============================================================================
// ChaCha20 CSPRNG（RFC 8439 §2.3.2 KAT + URBG 基础 + 构造异常 + 统计检验）
// ============================================================================
TEST_SUITE("ChaCha20 CSPRNG")
{
    TEST_CASE("RFC 8439 §2.3.2 KAT（counter=1，前 8 个 uint64 输出）")
    {
        // RFC 8439 §2.3.2 官方测试向量
        // key   = 00:01:02:...:1f（32 字节）
        // nonce = 00:00:00:09:00:00:00:4a:00:00:00:00（12 字节）
        // counter = 1
        // 一个 block = 64 字节 = 8 个 uint64（小端序组装）
        const std::uint8_t key[32] = {
            0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
            0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
            0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
            0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f
        };
        const std::uint8_t nonce[12] = {
            0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x4a,0x00,0x00,0x00,0x00
        };
        ChaCha20 rng(key, 32, nonce, 12, 1);

        // RFC 8439 §2.3.2 输出字节流（64 字节，按小端序组装为 uint64）
        // 经 pycryptodome 交叉验证，与 RFC 8439 官方测试向量一致
        const std::uint64_t expected[8] = {
            0x15593bd1e4e7f110ULL,  // 10 f1 e7 e4 d1 3b 59 15
            0xc47120a31fdd0f50ULL,  // 50 0f dd 1f a3 20 71 c4
            0x0368c033c7f4d1c7ULL,  // c7 d1 f4 c7 33 c0 68 03
            0x4e6cd4c39aaa2204ULL,  // 04 22 aa 9a c3 d4 6c 4e
            0x09aa9f07466482d2ULL,  // d2 82 64 46 07 9f aa 09
            0xa2028bd905d7c214ULL,  // 14 c2 d7 05 d9 8b 02 a2
            0xb94e16ded19c12b5ULL,  // b5 12 9c d1 de 16 4e b9
            0x4e3c50a2e883d0cbULL   // cb d0 83 e8 a2 50 3c 4e
        };
        for (auto e : expected)
            CHECK(rng() == e);
    }

    TEST_CASE("min/max 与 result_type")
    {
        static_assert(std::is_same_v<ChaCha20::result_type, std::uint64_t>);
        CHECK(ChaCha20::min() == 0);
        CHECK(ChaCha20::max() == UINT64_MAX);
    }

    TEST_CASE("构造方式 2 确定性复现")
    {
        ChaCha20 a{ 42 };
        ChaCha20 b{ 42 };
        for (int i = 0; i < 20; ++i)
            CHECK(a() == b());
    }

    TEST_CASE("构造方式 3 异常：key 长度非法")
    {
        const std::uint8_t badKey[16] = { 0 };
        const std::uint8_t nonce[12] = { 0 };
        CHECK_THROWS_AS(ChaCha20(badKey, 16, nonce, 12), std::invalid_argument);
    }

    TEST_CASE("构造方式 3 异常：nonce 长度非法")
    {
        const std::uint8_t key[32] = { 0 };
        const std::uint8_t badNonce[8] = { 0 };
        CHECK_THROWS_AS(ChaCha20(key, 32, badNonce, 8), std::invalid_argument);
    }

    TEST_CASE("discard 与连续调用等价")
    {
        ChaCha20 a{ 999 };
        ChaCha20 b{ 999 };
        a.discard(100);
        for (int i = 0; i < 100; ++i) b();
        CHECK(a() == b());
    }

    TEST_CASE("不同种子产生不同序列")
    {
        ChaCha20 a{ 1 };
        ChaCha20 b{ 2 };
        bool allSame = true;
        for (int i = 0; i < 10; ++i)
        {
            if (a() != b()) allSame = false;
        }
        CHECK_FALSE(allSame);
    }

    TEST_CASE("原始输出均匀性 df=127")
    {
        // 使用 CHACHA20_CHI2_N（非 STAT_N）以避免触发自动 reseed，保持确定性
        constexpr double EXPECTED = static_cast<double>(CHACHA20_CHI2_N) / STAT_BINS_128;

        ChaCha20 rng{ 54321 };
        std::array<int, STAT_BINS_128> counts{};
        for (int i = 0; i < CHACHA20_CHI2_N; ++i)
            ++counts[rng() & 127];

        double chi2 = 0.0;
        for (int i = 0; i < STAT_BINS_128; ++i)
        {
            const double diff = counts[i] - EXPECTED;
            chi2 += diff * diff / EXPECTED;
        }
        CHECK(chi2 < CHI2_CRITICAL_DF127);
    }

    // ── 设计文档 §5.1 要求：字节缓存 / 自动 reseed / 手动 reseed() ──

    TEST_CASE("字节缓存：前 8 次同一 block，第 9 次触发新 block")
    {
        // 一个 block = 64 字节 = 8 个 uint64
        // 实例 A(counter=0) 的第 9 次输出 = 实例 B(counter=1) 的第 1 次输出
        const std::uint8_t key[32] = {
            0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
            0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
            0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
            0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f
        };
        const std::uint8_t nonce[12] = {
            0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x4a,0x00,0x00,0x00,0x00
        };
        ChaCha20 a(key, 32, nonce, 12, 0);
        // 消费前 8 个 uint64（block 0）
        for (int i = 0; i < 8; ++i) (void)a();
        // 第 9 次输出 = block 1 的第 1 个 uint64
        const std::uint64_t ninth = a();
        // 实例 B 从 counter=1 开始，第 1 次输出应等于 A 的第 9 次
        ChaCha20 b(key, 32, nonce, 12, 1);
        CHECK(ninth == b());
    }

    TEST_CASE("默认构造函数在 2^20 字节阈值后自动 reseed")
    {
        if (!IsOsCryptoEntropyAvailable()) return;
        // 默认构造函数启用 m_autoReseed = true
        // ChaCha20ReseedThreshold = 2^20 字节，每次 operator() 输出 8 字节
        constexpr unsigned long long ReseedCalls = (1ULL << 20) / 8;
        ChaCha20 a;
        ChaCha20 b;
        // a 不触发 reseed（仅消费 8 字节）
        (void)a();
        // b discard 超过阈值，触发自动 reseed
        b.discard(ReseedCalls + 8);
        // reseed 后 b 输出与 a 不同
        bool different = false;
        for (int i = 0; i < 16; ++i)
        {
            if (a() != b()) { different = true; break; }
        }
        CHECK(different);
    }

    TEST_CASE("确定性种子 ChaCha20(seed) 在超过 1MB 后依然保持完全确定性")
    {
        constexpr unsigned long long ReseedCalls = (1ULL << 20) / 8;
        ChaCha20 a{ 42 };
        ChaCha20 b{ 42 };
        a.discard(ReseedCalls + 16);
        b.discard(ReseedCalls + 16);
        for (int i = 0; i < 16; ++i)
        {
            CHECK(a() == b());
        }
    }

    TEST_CASE("reseed() 手动触发后输出序列改变")
    {
        if (!IsOsCryptoEntropyAvailable()) return;
        ChaCha20 a{ 42 };
        ChaCha20 b{ 42 };
        // reseed 前：a 和 b 输出一致（同种子确定性）
        for (int i = 0; i < 8; ++i) CHECK(a() == b());
        // b 手动 reseed（引入 OS 熵）
        b.reseed();
        // reseed 后：b 输出与 a 不同（概率性断言）
        bool different = false;
        for (int i = 0; i < 16; ++i)
        {
            if (a() != b()) { different = true; break; }
        }
        CHECK(different);
    }
}

// ============================================================================
// 密码学安全熵源（SecureRandomBytes / SecureSeed / IsOsCryptoEntropyAvailable）
// ============================================================================
TEST_SUITE("密码学安全熵源")
{
    TEST_CASE("IsOsCryptoEntropyAvailable 返回 bool")
    {
        // 仅验证返回类型与可调用性，不假设具体值（跨平台差异）
        const bool available = IsOsCryptoEntropyAvailable();
        (void)available;
    }

    TEST_CASE("SecureRandomBytes 填充缓冲区")
    {
        std::array<std::uint8_t, 64> buf{};
        SecureRandomBytes(buf.data(), buf.size());
        // 极低概率全零（2^-512），视为熵源异常
        bool allZero = true;
        for (auto b : buf) { if (b != 0) { allZero = false; break; } }
        CHECK_FALSE(allZero);
    }

    TEST_CASE("SecureRandomBytes n=0 不抛异常")
    {
        SecureRandomBytes(nullptr, 0);
    }

    TEST_CASE("SecureSeed 返回不同值")
    {
        const auto a = SecureSeed();
        const auto b = SecureSeed();
        // 极低概率相同（2^-64）
        CHECK(a != b);
    }

    TEST_CASE("ChaCha20 默认构造不抛异常（OS 熵可用时）")
    {
        if (IsOsCryptoEntropyAvailable())
        {
            ChaCha20 rng;
            (void)rng();
        }
    }

    TEST_CASE("ChaCha20 默认构造两个实例序列不同")
    {
        if (IsOsCryptoEntropyAvailable())
        {
            ChaCha20 a;
            ChaCha20 b;
            bool allSame = true;
            for (int i = 0; i < 10; ++i)
            {
                if (a() != b()) allSame = false;
            }
            CHECK_FALSE(allSame);
        }
    }
}

TEST_SUITE("缺陷修复回归测试 - CSPRNG C++17")
{
    TEST_CASE("ChaCha20 只移动不可拷贝")
    {
        static_assert(!std::is_copy_constructible_v<RandX::ChaCha20>);
        static_assert(!std::is_copy_assignable_v<RandX::ChaCha20>);
        static_assert(std::is_move_constructible_v<RandX::ChaCha20>);
        static_assert(std::is_move_assignable_v<RandX::ChaCha20>);

        RandX::ChaCha20 rng1(12345ULL);
        RandX::ChaCha20 rng2 = std::move(rng1);
        (void)rng2();
    }
}

TEST_SUITE("缺陷修复回归测试 - 数学算法 C++17")
{
    TEST_CASE("RandBeta 极端非正规数参数不坍缩为0")
    {
        RandX::Xoshiro256StarStar rng(123);
        double betaVal = RandX::RandBeta(rng, 1.0, 1e-300);
        CHECK(betaVal > 0.0);
    }
}

TEST_SUITE("缺陷修复回归测试 - 容器与边界 C++17")
{
    TEST_CASE("RandElement 支持原生 C 风格数组")
    {
        int arr[5] = { 10, 20, 30, 40, 50 };
        int val = RandX::RandElement(arr);
        CHECK((val >= 10 && val <= 50));
    }
}

TEST_SUITE("缺陷修复回归测试 - 性能与API C++17")
{
    TEST_CASE("RandUUID 格式正确与随机性")
    {
        std::string u1 = RandX::RandUUID();
        std::string u2 = RandX::RandUUID();
        CHECK(u1.length() == 36);
        CHECK(u1[8] == '-');
        CHECK(u1[13] == '-');
        CHECK(u1[14] == '4');
        CHECK(u1[18] == '-');
        CHECK((u1[19] == '8' || u1[19] == '9' || u1[19] == 'a' || u1[19] == 'b'));
        CHECK(u1[23] == '-');
        CHECK(u1 != u2);
    }

    TEST_CASE("ChaCha20 不可拷贝但可移动")
    {
        CHECK(!std::is_copy_constructible_v<RandX::ChaCha20>);
        CHECK(!std::is_copy_assignable_v<RandX::ChaCha20>);
        CHECK(std::is_move_constructible_v<RandX::ChaCha20>);
        CHECK(std::is_move_assignable_v<RandX::ChaCha20>);
    }

    TEST_CASE("RandUUID 在 32 位引擎下无高位置零损坏")
    {
        RandX::Xoshiro128StarStar rng32{ 12345 };
        std::string u = RandX::RandUUID(rng32);
        CHECK(u.length() == 36);
        CHECK(u.substr(0, 8) != "00000000");
        CHECK(u.substr(24, 8) != "00000000");
    }

    TEST_CASE("RandPoisson 期望为 0 时合法返回 0")
    {
        CHECK(RandX::RandPoisson(0.0) == 0);
    }

    TEST_CASE("RandWeighted 引擎重载与分布对象高频复用 C++17")
    {
        RandX::Xoshiro256StarStar rng{ 42 };
        std::vector<double> weights = { 10.0, 0.0, 0.0 };
        CHECK(RandX::RandWeighted(rng, weights) == 0);

        std::discrete_distribution<std::size_t> dist(weights.begin(), weights.end());
        CHECK(RandX::RandWeighted(dist) == 0);
        CHECK(RandX::RandWeighted(rng, dist) == 0);
    }

}

TEST_SUITE("边界用例")
{
    TEST_CASE("RandInt(min, min) 始终返回 min")
    {
        RandX::Reseed(42);
        for (int i = 0; i < 100; ++i)
            CHECK(RandX::RandInt(7, 7) == 7);
        for (int i = 0; i < 100; ++i)
            CHECK(RandX::RandInt(-3, -3) == -3);
    }

    TEST_CASE("RandReal(min, min) 始终返回 min")
    {
        RandX::Reseed(42);
        for (int i = 0; i < 100; ++i)
            CHECK(RandX::RandReal(2.5, 2.5) == 2.5);
    }

    TEST_CASE("RandBool(0.0) 始终 false / RandBool(1.0) 始终 true")
    {
        RandX::Reseed(42);
        for (int i = 0; i < 100; ++i)
            CHECK_FALSE(RandX::RandBool(0.0));
        for (int i = 0; i < 100; ++i)
            CHECK(RandX::RandBool(1.0));
    }

    TEST_CASE("RandElement 单元素容器始终返回该元素")
    {
        RandX::Reseed(42);
        std::vector<int> single = { 99 };
        for (int i = 0; i < 50; ++i)
            CHECK(RandX::RandElement(single) == 99);
    }

    TEST_CASE("RandElement 右值容器按值返回（不悬垂）")
    {
        RandX::Reseed(42);
        int val = RandX::RandElement(std::vector<int>{10, 20, 30});
        CHECK((val == 10 || val == 20 || val == 30));
    }

    TEST_CASE("RandString(0) 返回空字符串")
    {
        CHECK(RandX::RandString(0).empty());
        CHECK(RandX::RandString(0, RandX::CharSet::Hex).empty());
    }

    TEST_CASE("RandString 指定 Engine 和 custom string_view 重载及空 charset 异常")
    {
        RandX::Xoshiro256StarStar rng{ 123456 };
        auto s = RandX::RandString(rng, 10, "ABC");
        CHECK(s.size() == 10);
        for (char c : s)
        {
            CHECK((c == 'A' || c == 'B' || c == 'C'));
        }
        CHECK_THROWS_AS((void)RandX::RandString(rng, 10, ""), std::invalid_argument);
        CHECK_THROWS_AS((void)RandX::RandString(10, ""), std::invalid_argument);
    }

    TEST_CASE("RandVector(..., 0) 返回空容器")
    {
        auto v = RandX::RandVector<int>(0, 10, 0);
        CHECK(v.empty());
    }

    TEST_CASE("RandSample(n=0) 返回空容器")
    {
        std::vector<int> src = {1, 2, 3, 4, 5};
        auto s = RandX::RandSample(src, 0);
        CHECK(s.empty());
    }

    TEST_CASE("RandInt 全范围 [min, max] 不溢出")
    {
        RandX::Reseed(42);
        auto v = RandX::RandInt<std::uint64_t>(0, (std::numeric_limits<std::uint64_t>::max)());
        CHECK(v >= 0);
        auto v2 = RandX::RandInt<std::int32_t>((std::numeric_limits<std::int32_t>::min)(), (std::numeric_limits<std::int32_t>::max)());
        CHECK(v2 >= (std::numeric_limits<std::int32_t>::min)());
    }

    TEST_CASE("RandWeighted 单元素权重始终返回 0")
    {
        RandX::Reseed(42);
        std::vector<double> w = {1.0};
        for (int i = 0; i < 50; ++i)
            CHECK(RandX::RandWeighted(w) == 0);
    }

    TEST_CASE("RandPermutation(0) 和 RandPermutation(1)")
    {
        auto p0 = RandX::RandPermutation(0);
        CHECK(p0.empty());
        auto p1 = RandX::RandPermutation(1);
        REQUIRE(p1.size() == 1);
        CHECK(p1[0] == 0);
    }
}

// ============================================================================
// P0 / P1 / P2 缺陷修复回归测试套件 (C++17)
// ============================================================================
TEST_SUITE("P0/P1/P2 Regression Audit Suite (C++17)")
{
    TEST_CASE("Input Iterator RandElement 按值返回")
    {
        std::istringstream iss("10 20 30 40 50");
        std::istream_iterator<int> beg(iss), end;
        int val = RandX::RandElement(beg, end);
        CHECK((val == 10 || val == 20 || val == 30 || val == 40 || val == 50));
    }

    TEST_CASE("C++17 原生 C 数组支持 (RandElement / RandSample)")
    {
        int arr[5] = {10, 20, 30, 40, 50};
        int val = RandX::RandElement(arr);
        CHECK((val >= 10 && val <= 50));

        auto sampled = RandX::RandSample(arr, 3);
        CHECK(sampled.size() == 3);
    }

    TEST_CASE("Engine& 重载分布模板形参顺序推导")
    {
        RandX::Xoshiro256StarStar rng{ 12345 };
        double valNorm = RandX::RandNormal(rng);
        double valLog = RandX::RandLogNormal(rng);
        int valGeom = RandX::RandGeometric(rng);
        double valExp = RandX::RandExp(rng);
        (void)valNorm; (void)valLog; (void)valExp;
        CHECK(valGeom >= 0);
    }

    TEST_CASE("分布非法参数显式抛出 std::invalid_argument")
    {
        CHECK_THROWS_AS((void)RandX::RandGeometric(0.0), std::invalid_argument);
        CHECK_THROWS_AS((void)RandX::RandGeometric(1.5), std::invalid_argument);
        CHECK_THROWS_AS((void)RandX::RandPoisson(-1.0), std::invalid_argument);
        CHECK_THROWS_AS((void)RandX::RandNormal(0.0, -1.0), std::invalid_argument);
        CHECK_THROWS_AS((void)RandX::RandExp(-2.0), std::invalid_argument);
        CHECK_THROWS_AS((void)RandX::RandLogNormal(0.0, 0.0), std::invalid_argument);
    }

    TEST_CASE("RandSample 逆序迭代器边界")
    {
        std::vector<int> v = {1, 2, 3, 4, 5};
        auto res = RandX::RandSample(v.end(), v.begin(), 3);
        CHECK(res.empty());
    }

    TEST_CASE("ChaCha20 moved-from 自动重播种保护")
    {
        RandX::ChaCha20 a{ 12345 };
        RandX::ChaCha20 b = std::move(a);
        const std::uint64_t val1 = a();
        const std::uint64_t val2 = a();
        CHECK((val1 != 0ULL || val2 != 0ULL));
    }

    TEST_CASE("RandBits 有符号整型与自定义引擎")
    {
        std::int32_t bits32 = RandX::RandBits<32, std::int32_t>();
        (void)bits32;
        RandX::Xoshiro256StarStar rng{ 999 };
        std::uint32_t bitsRng = RandX::RandBits<16, std::uint32_t>(rng);
        CHECK(bitsRng <= 0xFFFFU);
    }

    TEST_CASE("ResetThreadLocalEngine 重置线程局部引擎")
    {
        RandX::ResetThreadLocalEngine();
        int val = RandX::RandInt(1, 100);
        CHECK((val >= 1 && val <= 100));
    }
}

TEST_SUITE("Round 2 Audit Regression Suite (C++17)")
{
    TEST_CASE("P0-1 & P1-1: 反序列化全零非法状态设置 failbit 并保持原状态，隔离流格式标志")
    {
        RandX::Xoshiro256StarStar rng{ 123456789ULL };
        const auto orig_state = rng.serialize();

        // 1. 全零状态反序列化测试
        std::istringstream bad_is("0 0 0 0");
        bad_is >> rng;
        CHECK(bad_is.fail());
        CHECK(rng.serialize() == orig_state);

        // 2. 带 std::hex 和 std::noskipws 的格式标志隔离测试
        std::ostringstream oss;
        oss << std::hex << rng;
        std::string serialized_str = oss.str();

        std::istringstream iss(serialized_str);
        iss >> std::hex >> std::noskipws >> rng;
        CHECK_FALSE(iss.fail());
        CHECK(rng.serialize() == orig_state);
    }

    TEST_CASE("P0-2: RandReal 上界紧裁剪 [min, max)")
    {
        RandX::Xoshiro256StarStar rng{ 42 };
        for (int i = 0; i < 100000; ++i)
        {
            double r = RandX::RandReal(rng, 0.0, 1.0);
            CHECK(r >= 0.0);
            CHECK(r < 1.0);
        }
    }

    TEST_CASE("P2-1: RandInt 8-bit 整型与 char 支持")
    {
        RandX::Xoshiro256StarStar rng{ 42 };
        std::uint8_t u8 = RandX::RandInt<std::uint8_t>(rng, 10, 20);
        CHECK(u8 >= 10);
        CHECK(u8 <= 20);

        std::int8_t i8 = RandX::RandInt<std::int8_t>(rng, -50, 50);
        CHECK(i8 >= -50);
        CHECK(i8 <= 50);

        char c = RandX::RandInt<char>(rng, 'a', 'z');
        CHECK(c >= 'a');
        CHECK(c <= 'z');
    }

    TEST_CASE("P1-2: RandBeta 极端参数非 NaN 测试")
    {
        RandX::Xoshiro256StarStar rng{ 100 };
        for (int i = 0; i < 1000; ++i)
        {
            double beta_small = RandX::RandBeta(rng, 0.001, 0.001);
            CHECK(std::isfinite(beta_small));
            CHECK(beta_small >= 0.0);
            CHECK(beta_small <= 1.0);

            double beta_large = RandX::RandBeta(rng, 1e6, 1e6);
            CHECK(std::isfinite(beta_large));
            CHECK(beta_large >= 0.0);
            CHECK(beta_large <= 1.0);
        }
    }

    TEST_CASE("P1-3: MakeStreamEngine 大 streamId 快速跳跃测试")
    {
        auto rng = RandX::MakeStreamEngine<RandX::Xoshiro256StarStar>(1000000ULL, 123456ULL);
        auto val = rng();
        CHECK(val != 0ULL);
    }

    TEST_CASE("P2-2: RandBits 边界位数测试")
    {
        RandX::Xoshiro256StarStar rng{ 777 };
        auto b64 = RandX::RandBits<64, std::uint64_t>(rng);
        (void)b64;
        auto b1 = RandX::RandBits<1, std::uint64_t>(rng);
        CHECK(b1 <= 1ULL);
    }
}