test(boost-family): 大测试成员 — 一个工程覆盖全部 23 个小依赖包

新增 tests/examples/boost-family/:消费 modular-boost 家族所有没有专属
成员的小包(align/bind/compat/container/container-hash/core/describe/
endian/intrusive/io/logic/move/mp11/optional/predef/preprocessor/
smart-ptr/static-string/system/type-index/utility/variant2/winapi),
按主题分 6 个 tests/*.cpp,每个组件都有可失败的行为断言:

  core-smart      core(addressof/empty_value/ref) + smart-ptr + move
  containers      container(vector) + intrusive(list) + optional + static-string
  meta            mp11 + describe + preprocessor + type-index + predef
  system-errors   system(error_code/system_error) + compat(invoke) + bind
  bytes-logic     endian + container-hash + logic(tribool) + align
  io-platform     io(ios_flags_saver) + utility(compressed_pair) + winapi

实测踩坑固化进注释:tribool 连 operator! 都返回 tribool(取 bool 走
explicit 转换/indeterminate());boost/winapi 头非 Windows 平台 #error
(include 与断言均在 _WIN32 门控内,由 windows CI 腿真实覆盖);
intrusive::list 析构前必须 clear(带链析构触发调试断言)。

mcpp 2026.8.27.2 本地冷验证:6/6 test result ok。

Author: wellwei

.agents/docs/2026-09-05-add-boost-beast-plan.md

@@ -127,7 +127,18 @@ throw-exception）；仓库 URL 与注释中保留上游仓原名 `container_has
   消费 TU；真实跑 `steady_timer` + `io_context::run`、post/defer、
   co_spawn/awaitable、tcp endpoint。`#include <boost/asio.hpp>` 单体头
   顺带验证 disable 宏守卫下单体 include 可用。
-- 两成员只消费 `compat` 命名空间，继承根 workspace 的 `[indices]`
+- `tests/examples/boost-family/`：**大测试成员**，一次性消费全部 23 个没有
+  专属成员的小依赖包（align/bind/compat/container/container-hash/core/
+  describe/endian/intrusive/io/logic/move/mp11/optional/predef/preprocessor/
+  smart-ptr/static-string/system/type-index/utility/variant2/winapi），
+  按主题分 6 个 tests/*.cpp（core-smart / containers / meta /
+  system-errors / bytes-logic / io-platform），每个组件都有可失败断言。
+  实测踩坑三则已固化进测试注释：boost::logic::tribool 连 `operator!` 都
+  返回 tribool（取 bool 只能 explicit 转换或 indeterminate()）；
+  boost/winapi 头在非 Windows 平台 `#error`（include 与断言都在
+  `#ifdef _WIN32` 内，由 windows CI 腿真实覆盖）；intrusive::list 析构前
+  必须 clear（调试断言 hook 不得带链析构）。
+- 三成员只消费 `compat` 命名空间，继承根 workspace 的 `[indices]`
   重定向，不声明自己的 indices。
 - 正向验证在 CI（linux/macos/windows 三平台）；无 feature 需要负向验证
   （无源码门控），disable 宏的"负向"体现在：闭包树里根本没有

CHANGELOG.md

@@ -20,7 +20,12 @@
   feature 携带 `BOOST_ASIO_DISABLE_BOOST_CONTEXT_FIBER` / `..._DATE_TIME`
   与 `BOOST_ASIO_HAS_THREADS`（llvm-on-Windows 无 `_MT`/`BOOST_HAS_THREADS`，
   不钉定会静默退化为 null_thread 且 VERSION_TAG 跨 TU 漂移），保持家族
-  header-only。新增 `boost-beast` 与 `boost-asio` 两个工作区成员。
+  header-only。新增 `boost-beast`、`boost-asio`、`boost-family` 三个工作区
+  成员；其中 `boost-family` 为大测试成员，一个工程 6 个测试文件覆盖全部
+  23 个没有专属成员的小依赖包（core/smart-ptr、container/intrusive/
+  optional/static-string、mp11/describe/preprocessor/type-index/predef、
+  system/compat/bind、endian/container-hash/logic/align、io/utility/
+  winapi）。
 - 收录 `gzj-creator.galay` 5.0.2 原生 Form-A 模块包，覆盖 `galay.utils` 与
   `galay.kernel` 默认模块，并加入 Unix 示例工程和索引文档。
 

mcpp.toml

@@ -16,6 +16,7 @@ members = [
     "tests/examples/boost-beast",
     "tests/examples/boost-config",
     "tests/examples/boost-ext.ut",
+    "tests/examples/boost-family",
     "tests/examples/boost-throw-exception",
     "tests/examples/boost-type-traits",
     "tests/examples/boost-uuid",

tests/examples/boost-family/mcpp.toml

@@ -0,0 +1,32 @@
+# compat boost 家族"大测试"成员:为每个没有专属成员的小依赖包提供行为断言。
+# 消费全部 23 个小包(boost-beast / boost-asio / 既有 uuid/config/assert/
+# throw-exception/type-traits 各有专属成员,不在其中),按主题分成 6 个
+# tests/*.cpp,每个组件都有可失败的有效断言。
+[package]
+name = "boost-family-tests"
+version = "0.1.0"
+
+[dependencies.compat]
+boost-align = "1.92.0"
+boost-bind = "1.92.0"
+boost-compat = "1.92.0"
+boost-container = "1.92.0"
+boost-container-hash = "1.92.0"
+boost-core = "1.92.0"
+boost-describe = "1.92.0"
+boost-endian = "1.92.0"
+boost-intrusive = "1.92.0"
+boost-io = "1.92.0"
+boost-logic = "1.92.0"
+boost-move = "1.92.0"
+boost-mp11 = "1.92.0"
+boost-optional = "1.92.0"
+boost-predef = "1.92.0"
+boost-preprocessor = "1.92.0"
+boost-smart-ptr = "1.92.0"
+boost-static-string = "1.92.0"
+boost-system = "1.92.0"
+boost-type-index = "1.92.0"
+boost-utility = "1.92.0"
+boost-variant2 = "1.92.0"
+boost-winapi = "1.92.0"

tests/examples/boost-family/tests/bytes-logic.cpp

@@ -0,0 +1,64 @@
+// boost-endian (byte-order conversion), boost-container-hash (hashing),
+// boost-logic (tribool) and boost-align (pointer alignment helpers).
+#include <boost/align/align_down.hpp>
+#include <boost/align/align_up.hpp>
+#include <boost/align/is_aligned.hpp>
+#include <boost/container_hash/hash.hpp>
+#include <boost/endian/conversion.hpp>
+#include <boost/logic/tribool.hpp>
+
+#include <cstdint>
+#include <vector>
+
+int main() {
+    bool ok = true;
+
+    // endian: reversing is an involution with byte-exact results.
+    {
+        std::uint32_t x = 0x01020304u;
+        ok = ok && boost::endian::endian_reverse(x) == 0x04030201u;
+        ok = ok &&
+             boost::endian::endian_reverse(boost::endian::endian_reverse(x)) == x;
+    }
+
+    // container-hash: deterministic within a process; combining is stable.
+    {
+        boost::hash<std::string> hs;
+        ok = ok && hs("abc") == hs("abc");
+
+        const std::vector<int> v1{1, 2, 3}, v2{1, 2, 3};
+        std::size_t seed = 0;
+        boost::hash_range(seed, v1.begin(), v1.end());
+        std::size_t seed2 = 0;
+        boost::hash_range(seed2, v2.begin(), v2.end());
+        ok = ok && seed == seed2 && seed != 0;
+    }
+
+    // logic: three-valued truth table entry points used by beast::detect_ssl.
+    // Every operator (including !) returns tribool; the explicit conversion
+    // and the indeterminate() free function are the way back to bool.
+    {
+        using boost::logic::indeterminate;
+        using boost::logic::tribool;
+        tribool t = true, f = false, i = indeterminate;
+
+        ok = ok && static_cast<bool>(t) && !static_cast<bool>(f);
+        ok = ok && indeterminate(i);
+        ok = ok && indeterminate(t && i);
+        ok = ok && static_cast<bool>(t || i);          // true dominates OR
+        ok = ok && !static_cast<bool>(f && i);         // false dominates AND
+        ok = ok && indeterminate(i || f) && indeterminate(i && t);
+    }
+
+    // align: round-tripping through align_up lands on the boundary and
+    // align_down undoes it.
+    {
+        alignas(64) char raw[128];
+        ok = ok && boost::alignment::is_aligned(boost::alignment::align_up(raw, 64), 64);
+        ok = ok && boost::alignment::align_down(
+                        boost::alignment::align_up(raw, 64), 64) ==
+                        boost::alignment::align_up(raw, 64);
+    }
+
+    return ok ? 0 : 1;
+}

tests/examples/boost-family/tests/containers.cpp

@@ -0,0 +1,60 @@
+// boost-container (vector), boost-intrusive (list), boost-optional
+// and boost-static-string.
+#include <boost/container/vector.hpp>
+#include <boost/intrusive/list.hpp>
+#include <boost/optional.hpp>
+#include <boost/static_string/static_string.hpp>
+
+int main() {
+    bool ok = true;
+
+    // container: an STL-compatible vector that is not std::vector.
+    {
+        boost::container::vector<int> vec;
+        for (int i = 0; i < 100; ++i) vec.push_back(i);
+        ok = ok && vec.size() == 100 && vec.back() == 99 && vec[42] == 42;
+    }
+
+    // intrusive: the list only links; ownership stays with the nodes.
+    {
+        namespace intr = boost::intrusive;
+        struct Node : intr::list_base_hook<> {
+            int v;
+            explicit Node(int x) : v(x) {}
+        };
+        intr::list<Node> lst;
+        Node a(1), b(2), c(3);
+        lst.push_back(a);
+        lst.push_back(b);
+        lst.push_back(c);
+        ok = ok && lst.size() == 3 && lst.front().v == 1 && lst.back().v == 3;
+
+        lst.pop_front();
+        ok = ok && lst.front().v == 2 && a.v == 1;  // a outlives its unlinking
+
+        lst.clear();  // unlink everything: hooks must not die while linked
+        ok = ok && lst.empty();
+    }
+
+    // optional: empty/engaged lifecycle and value_or fallback.
+    {
+        boost::optional<int> o;
+        ok = ok && !o && o.value_or(-1) == -1;
+
+        o = 9;
+        ok = ok && o && *o == 9 && o.value() == 9;
+
+        o.reset();
+        ok = ok && !o;
+    }
+
+    // static-string: fixed-capacity string with a compile-time bound.
+    {
+        boost::static_strings::static_string<8> s("abc");
+        s += "def";
+        ok = ok && s == "abcdef" && s.size() == 6;
+        ok = ok && s.compare(0, 3, "abc") == 0;
+    }
+
+    return ok ? 0 : 1;
+}

tests/examples/boost-family/tests/core-smart.cpp

@@ -0,0 +1,52 @@
+// boost-core (addressof / empty_value / ref), boost-smart-ptr
+// (shared_ptr/weak_ptr/make_shared) and boost-move (movelib::unique_ptr).
+#include <boost/core/addressof.hpp>
+#include <boost/core/empty_value.hpp>
+#include <boost/core/ref.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/move/make_unique.hpp>
+#include <boost/move/unique_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+int main() {
+    bool ok = true;
+
+    // core: addressof survives overloaded operator&, ref wraps without copies.
+    {
+        struct Tricky {
+            int v = 7;
+            Tricky* operator&() const { return nullptr; }
+        } tricky;
+        ok = ok && boost::addressof(tricky) != nullptr;
+        ok = ok && boost::addressof(tricky)->v == 7;
+
+        auto r = boost::cref(tricky.v);
+        ok = ok && r.get() == 7;
+    }
+
+    // core: empty_value with a non-empty payload stores and returns it.
+    {
+        boost::empty_value<int> ev(boost::empty_init_t(), 42);
+        ok = ok && ev.get() == 42;
+    }
+
+    // smart-ptr: reference counting across shared/weak.
+    {
+        boost::shared_ptr<int> sp = boost::make_shared<int>(5);
+        boost::weak_ptr<int> wp = sp;
+        ok = ok && sp.use_count() == 1 && *sp == 5 && !wp.expired();
+
+        sp.reset();
+        ok = ok && wp.expired() && wp.lock() == boost::shared_ptr<int>();
+    }
+
+    // move: movelib::unique_ptr transfers sole ownership.
+    {
+        boost::movelib::unique_ptr<int> up = boost::movelib::make_unique<int>(11);
+        boost::movelib::unique_ptr<int> up2 = boost::move(up);
+        ok = ok && !up && up2 && *up2 == 11;
+    }
+
+    return ok ? 0 : 1;
+}

tests/examples/boost-family/tests/io-platform.cpp

@@ -0,0 +1,58 @@
+// boost-io (stream state savers), boost-utility (compressed_pair) and
+// boost-winapi (WinAPI type shims — compilable only where Win32 exists).
+#include <boost/compressed_pair.hpp>
+#include <boost/io/ios_state.hpp>
+
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#ifdef _WIN32
+#include <boost/winapi/basic_types.hpp>
+#endif
+
+int main() {
+    bool ok = true;
+
+    // io: RAII flag saver restores the stream's formatting state.
+    {
+        std::ostringstream os;
+        os << 255;
+        ok = ok && os.str() == "255";
+
+        os.str("");
+        {
+            boost::io::ios_flags_saver fs(os);
+            os << std::hex << 255;
+            ok = ok && os.str() == "ff";
+        }
+
+        os.str("");
+        os << 255;
+        ok = ok && os.str() == "255";  // hex did not leak
+    }
+
+    // utility: compressed_pair — empty-base-optimized pair with accessors.
+    {
+        boost::compressed_pair<int, std::string> cp(3, "three");
+        ok = ok && cp.first() == 3 && cp.second() == "three";
+
+        // Both members empty: compiles and stays stateless in practice.
+        struct Nothing {};
+        boost::compressed_pair<Nothing, Nothing> empty_pair{};
+        ok = ok && sizeof(empty_pair) <= sizeof(Nothing) * 2;
+    }
+
+    // winapi: the shims declare the Win32 surface themselves, but the
+    // headers are Windows-only to compile (they #error elsewhere), so real
+    // assertions run under the Windows CI leg only.
+    {
+#ifdef _WIN32
+        ok = ok && std::is_pointer<boost::winapi::HANDLE_>::value;
+        ok = ok && std::is_integral<boost::winapi::DWORD_>::value;
+        ok = ok && sizeof(boost::winapi::DWORD_) >= 4;
+#endif
+    }
+
+    return ok ? 0 : 1;
+}

tests/examples/boost-family/tests/meta.cpp

@@ -0,0 +1,71 @@
+// boost-mp11 (list metaprogramming), boost-describe (enum reflection),
+// boost-preprocessor (token repetition), boost-type-index (runtime type
+// identity) and boost-predef (platform/compiler detection).
+#include <boost/describe.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/predef.h>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/type_index.hpp>
+
+#include <string>
+
+// Enumerators must be visible at global scope for the describe macros.
+enum class Color { red = 1, green = 2, blue = 4 };
+BOOST_DESCRIBE_ENUM(Color, red, green, blue)
+
+#define FAMILY_INC(z, n, d) + (n)
+
+int main() {
+    bool ok = true;
+
+    // mp11: list size and per-type iteration.
+    {
+        using L = boost::mp11::mp_list<int, long, char>;
+        ok = ok && boost::mp11::mp_size<L>::value == 3;
+
+        int total = 0;
+        boost::mp11::mp_for_each<L>([&](auto t) { total += sizeof(decltype(t)); });
+        ok = ok && total > 0 && total >= 3;
+    }
+
+    // describe: enumerate (name, value) pairs without RTTI tricks.
+    {
+        int count = 0;
+        bool blueNamed = false;
+        boost::mp11::mp_for_each<boost::describe::describe_enumerators<Color>>(
+            [&](auto d) {
+                ++count;
+                if (d.value == Color::blue)
+                    blueNamed = std::string(d.name) == "blue";
+            });
+        ok = ok && count == 3 && blueNamed;
+    }
+
+    // preprocessor: stringize/cat composition and unrolled repetition.
+    {
+        ok = ok && std::string(BOOST_PP_STRINGIZE(BOOST_PP_CAT(fo, o))) == "foo";
+
+        int total = BOOST_PP_REPEAT(5, FAMILY_INC, 0);  // + 0 + 1 + 2 + 3 + 4
+        ok = ok && total == 10;
+    }
+
+    // type-index: runtime type identity with a readable name.
+    {
+        namespace ti = boost::typeindex;
+        ok = ok && ti::type_id<int>() == ti::type_id<int>();
+        ok = ok && ti::type_id<int>() != ti::type_id<long>();
+        ok = ok && std::string(ti::type_id<int>().pretty_name()).find("int") !=
+                        std::string::npos;
+    }
+
+    // predef: the platform and compiler we run the index's CI on must be
+    // detected (predef defines every macro, 0 when not detected).
+    {
+        ok = ok && (BOOST_OS_LINUX || BOOST_OS_MACOS || BOOST_OS_WINDOWS) != 0;
+        ok = ok && (BOOST_COMP_CLANG || BOOST_COMP_GNUC || BOOST_COMP_MSVC) != 0;
+    }
+
+    return ok ? 0 : 1;
+}