[c] support dynamic loading on Windows: test

Create a test for dynamic loading.  The main program loads a shared library that exports the default registry, then a shared library that exports a method and adds it to the registry, then load a shared library that adds an overrider to the method.  Check that all the static state is unique and the same for all libraries. The libraries export functions that make it possible for the main program to check that:
- the registry state is the same for all libraries (use `id()`)
- the policies that contain static state all use the same variables (again use `id()`).
- the method is the same in all libraries (check `&fn`).
On msvc, use `boost_openmethod_declspec` to import and export the variables as needed. Take inspiration from the example in `shared_libs`. Put the new test in `test/dynamic_loading`.

Author: jll63

CLAUDE.md

@@ -74,6 +74,7 @@ ctest -R test_dispatch  # Run specific test by name
 - Test files: `test/test_*.cpp` - Standard unit tests using Boost.Test
 - Compile-fail tests: `test/compile_fail_*.cpp` - Tests that should fail to compile
 - Mixed build test: `test/mix_release_debug/` - Tests mixing debug/release builds
+- Dynamic loading test: `test/dynamic_loading/` - Tests shared library support (requires Boost.DLL)
 - 21+ test files covering dispatch, policies, virtual_ptr, RTTI, errors, etc.
 
 ### Debug Mode Features
@@ -165,35 +166,53 @@ Tests require these C++17 features (checked by Boost.Build):
 **Overview**: The library supports shared library usage on Windows with proper dllexport/dllimport decoration.
 
 **Key Pattern - Decoratable Static Variables**:
-All policy static variables use `BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(name)` macro to enable DLL decoration. This generates three specializations of `global_state_<name>`:
+All policy static variables use `BOOST_OPENMETHOD_DETAIL_MAKE_STATICS(name)` macro (in `preamble.hpp`) to enable DLL decoration. This generates three specializations of `static_<name>`:
 - Default (no attributes)
-- `__declspec(dllexport)` when registry has dllexport attributes
-- `__declspec(dllimport)` when registry has dllimport attributes
-
-**Affected Policies**:
-- `stderr_output::fn::os` - Output stream (via `global_state_os`)
-- `default_error_handler::fn::handler` - Error handler function (via `global_state_handler`)
-- `fast_perfect_hash::fn::hash_fn` - Hash factors struct (via `global_state_hash_fn`)
-- `vptr_map::fn::vptrs` - V-table pointer map (via `global_state_vptrs`)
+- `BOOST_SYMBOL_EXPORT` when registry has dllexport attributes
+- `BOOST_SYMBOL_IMPORT` when registry has dllimport attributes
+
+The attributes are selected via `get_attributes<Guide>` which uses ADL to call `boost_openmethod_declspec(Guide)`.
+
+**Affected Policies** (actual symbol names from `nm -D`):
+- `stderr_output::fn::os` - Output stream (via `static_os`)
+- `default_error_handler::fn::handler` - Error handler function (via `static_handler`)
+- `fast_perfect_hash::fn::hash_fn` - Hash factors struct (via `static_hash_fn`)
+- `vptr_map::fn::vptrs` - V-table pointer map (via `static_vptrs`)
 - `vptr_vector::fn::vptr_vector_vptrs` / `vptr_vector_indirect_vptrs` - V-table vectors
+- Registry state itself: `static_st<registry_state<Registry>>::st` - class/method/overrider lists
 
 **Example Usage**:
 ```cpp
 // In header shared between library and client
 #ifdef LIBRARY_NAME
-#define MY_API boost::openmethod::declspec::dllexport
+#define MY_API boost::openmethod::dllexport
 #else
-#define MY_API boost::openmethod::declspec::dllimport
+#define MY_API boost::openmethod::dllimport
 #endif
 
 namespace boost::openmethod {
-    MY_API boost_openmethod_attributes(default_registry_attributes);
+    MY_API boost_openmethod_declspec(default_registry_attributes);
 }
 
 BOOST_OPENMETHOD(my_method, (virtual_ptr<MyClass>), void, MY_API);
 ```
 
-See `doc/modules/ROOT/examples/shared_libs/` for complete examples.
+**Critical: Exporting the Registry State**:
+`static_st<registry_state<...>>::st` (the list of registered classes/methods/overriders) is only
+instantiated and exported from a shared library when that library compiles code that actually
+registers classes or methods (i.e., `BOOST_OPENMETHOD_CLASSES` or `BOOST_OPENMETHOD` macros).
+If a library is meant to "own" the registry state, it must include a header that triggers these
+registrations — it is not enough to just declare `boost_openmethod_declspec`.
+
+See `doc/modules/ROOT/examples/shared_libs/` and `test/dynamic_loading/` for complete examples.
+
+**Dynamic Loading Test** (`test/dynamic_loading/`):
+Verifies shared state across libraries using `id()` functions on all policy statics:
+- `classes.hpp` — class definitions + `BOOST_OPENMETHOD_CLASSES` (included by lib_registry with dllexport to force `st` export)
+- `lib_registry.cpp` — compiled with `REGISTRY_API=dllexport`, exports all registry statics
+- `lib_method.cpp` — compiled with `METHOD_API=dllexport`, imports registry from lib_registry
+- `lib_overrider.cpp` — dynamically loaded at runtime, adds a Dog overrider
+- `main.cpp` — loads lib_overrider, checks all `id()` values match, calls `initialize()`, tests dispatch
 
 ### Custom RTTI
 When `<typeinfo>` is unavailable or insufficient, use static_rtti or implement custom RTTI. See `doc/modules/ROOT/examples/custom_rtti/` and policies in `include/boost/openmethod/policies/`.
@@ -269,10 +288,10 @@ The v-table pointer enables O(1) method dispatch.
 
 When adding static variables to policies:
 
-1. **Declare the variable storage** in `detail` namespace using `BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(variable_name)`
-2. **Use type alias** in policy's `fn<Registry>` class: `using var_storage = detail::global_state_variable_name<Type, Registry>`
+1. **Declare the variable storage** in `detail` namespace using `BOOST_OPENMETHOD_DETAIL_MAKE_STATICS(variable_name)` (defined in `preamble.hpp`)
+2. **Use type alias** in policy's `fn<Registry>` class: `using var_storage = detail::static_variable_name<Type, Registry>`
 3. **Access via storage**: `var_storage::variable_name` instead of direct static member
-4. **Define specialization** outside class: `template<class Registry> Type detail::global_state_variable_name<Type, Registry>::variable_name;`
+4. **Definition is generated** by the macro: `template<class Registry> Type detail::static_variable_name<Type, Registry, Enable>::variable_name;`
 
 This pattern ensures static variables can be properly decorated with dllexport/dllimport for shared library usage.
 
@@ -303,12 +322,12 @@ struct hash_fn {
         return (mult * reinterpret_cast<uintptr>(type)) >> shift;
     }
 };
-BOOST_OPENMETHOD_DETAIL_MAKE_SYMBOL_WITH_ATTRIBUTES(hash_fn);
+BOOST_OPENMETHOD_DETAIL_MAKE_STATICS(hash_fn);  // generates static_hash_fn<Type, Registry, Enable>
 
 // In policy
 template<class Registry>
 class fn {
-    using factors_storage = detail::global_state_hash_fn<detail::hash_fn, Registry>;
+    using factors_storage = detail::static_hash_fn<detail::hash_fn, Registry>;
 public:
     static auto hash(type_id type) -> std::size_t {
         return factors_storage::hash_fn(type);  // Use via storage

test/CMakeLists.txt

@@ -102,3 +102,7 @@ openmethod_compile_fail_test(
     compile_fail_virtual_parameter_private_base_core "must be an unambiguous accessible base")
 openmethod_compile_fail_test(
     compile_fail_repeated_inheritance "repeated inheritance")
+
+if (TARGET Boost::dll)
+    add_subdirectory(dynamic_loading)
+endif()

test/dynamic_loading/CMakeLists.txt

@@ -0,0 +1,48 @@
+# Copyright (c) 2018-2025 Jean-Louis Leroy
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt
+# or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+# lib_registry: exports the default registry's static policy state
+add_library(dl_test_registry SHARED EXCLUDE_FROM_ALL lib_registry.cpp)
+target_compile_definitions(
+    dl_test_registry PRIVATE BOOST_OPENMETHOD_DYNAMIC_LOADING_REGISTRY_EXPORTS)
+target_link_libraries(dl_test_registry PUBLIC Boost::openmethod)
+
+# lib_method: exports the speak method; imports registry state from lib_registry
+add_library(dl_test_method SHARED EXCLUDE_FROM_ALL lib_method.cpp)
+target_compile_definitions(
+    dl_test_method PRIVATE BOOST_OPENMETHOD_DYNAMIC_LOADING_METHOD_EXPORTS)
+target_link_libraries(dl_test_method PUBLIC Boost::openmethod dl_test_registry)
+
+# lib_overrider: adds a Dog overrider; imported at runtime via Boost.DLL
+add_library(dl_test_overrider SHARED EXCLUDE_FROM_ALL lib_overrider.cpp)
+target_link_libraries(dl_test_overrider PRIVATE Boost::openmethod dl_test_method)
+
+# Test executable: links against lib_method (and lib_registry transitively);
+# dynamically loads lib_overrider at runtime.
+add_executable(
+    boost_openmethod-test_dynamic_loading EXCLUDE_FROM_ALL main.cpp)
+target_link_libraries(
+    boost_openmethod-test_dynamic_loading
+    PRIVATE Boost::openmethod Boost::unit_test_framework Boost::dll
+            dl_test_method)
+
+# Put all outputs in the same directory so Boost.DLL can locate the shared
+# libraries relative to the test executable at runtime.
+foreach(
+    target dl_test_registry dl_test_method dl_test_overrider
+           boost_openmethod-test_dynamic_loading)
+    set_target_properties(
+        ${target}
+        PROPERTIES
+            RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+            LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+            ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+endforeach()
+
+add_test(
+    NAME boost_openmethod-test_dynamic_loading
+    COMMAND boost_openmethod-test_dynamic_loading)
+add_dependencies(
+    tests boost_openmethod-test_dynamic_loading dl_test_overrider)

test/dynamic_loading/classes.hpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2018-2025 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include "registry.hpp"
+
+#include <boost/openmethod.hpp>
+
+struct Animal {
+    virtual ~Animal() = default;
+};
+
+struct Dog : Animal {};
+
+BOOST_OPENMETHOD_CLASSES(Animal, Dog);

test/dynamic_loading/lib_method.cpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2018-2025 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// BOOST_OPENMETHOD_DYNAMIC_LOADING_METHOD_EXPORTS is set via CMake compile
+// definition, making METHOD_API expand to dllexport in method.hpp.
+#include "method.hpp"
+
+using namespace boost::openmethod;
+
+using Method = BOOST_OPENMETHOD_TYPE(speak, (virtual_ptr<Animal>), std::string);
+
+#ifdef _WIN32
+#define DL_EXPORT __declspec(dllexport)
+#else
+#define DL_EXPORT
+#endif
+
+extern "C" {
+
+DL_EXPORT auto dl_method_get_vptrs_id() -> const void* {
+    return default_registry::vptr::id();
+}
+
+DL_EXPORT auto dl_method_get_error_handler_id() -> const void* {
+    return default_registry::error_handler::id();
+}
+
+DL_EXPORT auto dl_method_get_output_id() -> const void* {
+    return default_registry::output::id();
+}
+
+DL_EXPORT auto dl_method_get_type_hash_id() -> const void* {
+    return default_registry::policy<policies::type_hash>::id();
+}
+
+DL_EXPORT auto dl_method_get_method_fn() -> const void* {
+    return static_cast<const void*>(&Method::fn);
+}
+
+} // extern "C"

test/dynamic_loading/lib_overrider.cpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2018-2025 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "method.hpp"
+
+using namespace boost::openmethod;
+
+BOOST_OPENMETHOD_OVERRIDE(speak, (virtual_ptr<Dog>), std::string) {
+    return "woof";
+}
+
+using Method = BOOST_OPENMETHOD_TYPE(speak, (virtual_ptr<Animal>), std::string);
+
+#ifdef _WIN32
+#define DL_EXPORT __declspec(dllexport)
+#else
+#define DL_EXPORT
+#endif
+
+extern "C" {
+
+DL_EXPORT auto dl_overrider_get_vptrs_id() -> const void* {
+    return default_registry::vptr::id();
+}
+
+DL_EXPORT auto dl_overrider_get_error_handler_id() -> const void* {
+    return default_registry::error_handler::id();
+}
+
+DL_EXPORT auto dl_overrider_get_output_id() -> const void* {
+    return default_registry::output::id();
+}
+
+DL_EXPORT auto dl_overrider_get_type_hash_id() -> const void* {
+    return default_registry::policy<policies::type_hash>::id();
+}
+
+DL_EXPORT auto dl_overrider_get_method_fn() -> const void* {
+    return static_cast<const void*>(&Method::fn);
+}
+
+} // extern "C"

test/dynamic_loading/lib_registry.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2018-2025 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// BOOST_OPENMETHOD_DYNAMIC_LOADING_REGISTRY_EXPORTS is set via CMake compile
+// definition, making REGISTRY_API expand to dllexport in registry.hpp (and
+// transitively in classes.hpp). Including classes.hpp forces
+// static_st<registry_state<...>>::st to be instantiated and exported from
+// this shared library, so other libraries can import it.
+#include "classes.hpp"
+
+using namespace boost::openmethod;
+
+#ifdef _WIN32
+#define DL_EXPORT __declspec(dllexport)
+#else
+#define DL_EXPORT
+#endif
+
+extern "C" {
+
+DL_EXPORT auto dl_registry_get_vptrs_id() -> const void* {
+    return default_registry::vptr::id();
+}
+
+DL_EXPORT auto dl_registry_get_error_handler_id() -> const void* {
+    return default_registry::error_handler::id();
+}
+
+DL_EXPORT auto dl_registry_get_output_id() -> const void* {
+    return default_registry::output::id();
+}
+
+DL_EXPORT auto dl_registry_get_type_hash_id() -> const void* {
+    return default_registry::policy<policies::type_hash>::id();
+}
+
+} // extern "C"

test/dynamic_loading/main.cpp

@@ -0,0 +1,91 @@
+// Copyright (c) 2018-2025 Jean-Louis Leroy
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_TEST_MODULE dynamic_loading
+#include <boost/test/unit_test.hpp>
+
+#include "method.hpp"
+
+#include <boost/openmethod/initialize.hpp>
+#include <boost/dll/shared_library.hpp>
+#include <boost/dll/runtime_symbol_info.hpp>
+
+using namespace boost::openmethod;
+
+using Method = BOOST_OPENMETHOD_TYPE(speak, (virtual_ptr<Animal>), std::string);
+
+// C functions exported by lib_registry (linked against the test executable)
+extern "C" {
+const void* dl_registry_get_vptrs_id();
+const void* dl_registry_get_error_handler_id();
+const void* dl_registry_get_output_id();
+const void* dl_registry_get_type_hash_id();
+}
+
+// C functions exported by lib_method (linked against the test executable)
+extern "C" {
+const void* dl_method_get_vptrs_id();
+const void* dl_method_get_error_handler_id();
+const void* dl_method_get_output_id();
+const void* dl_method_get_type_hash_id();
+const void* dl_method_get_method_fn();
+}
+
+BOOST_AUTO_TEST_CASE(test_shared_state) {
+    namespace dll = boost::dll;
+
+    // Dynamically load lib_overrider
+    dll::shared_library overrider_lib(
+        dll::program_location().parent_path() / "dl_test_overrider",
+        dll::load_mode::append_decorations);
+
+    auto overrider_get_vptrs_id =
+        overrider_lib.get<const void*()>("dl_overrider_get_vptrs_id");
+    auto overrider_get_error_handler_id =
+        overrider_lib.get<const void*()>("dl_overrider_get_error_handler_id");
+    auto overrider_get_output_id =
+        overrider_lib.get<const void*()>("dl_overrider_get_output_id");
+    auto overrider_get_type_hash_id =
+        overrider_lib.get<const void*()>("dl_overrider_get_type_hash_id");
+    auto overrider_get_method_fn =
+        overrider_lib.get<const void*()>("dl_overrider_get_method_fn");
+
+    // All libraries must share the same vptr storage
+    const void* vptrs_id = default_registry::vptr::id();
+    BOOST_TEST(dl_registry_get_vptrs_id() == vptrs_id);
+    BOOST_TEST(dl_method_get_vptrs_id() == vptrs_id);
+    BOOST_TEST(overrider_get_vptrs_id() == vptrs_id);
+
+    // All libraries must share the same error handler storage
+    const void* error_handler_id = default_registry::error_handler::id();
+    BOOST_TEST(dl_registry_get_error_handler_id() == error_handler_id);
+    BOOST_TEST(dl_method_get_error_handler_id() == error_handler_id);
+    BOOST_TEST(overrider_get_error_handler_id() == error_handler_id);
+
+    // All libraries must share the same output storage
+    const void* output_id = default_registry::output::id();
+    BOOST_TEST(dl_registry_get_output_id() == output_id);
+    BOOST_TEST(dl_method_get_output_id() == output_id);
+    BOOST_TEST(overrider_get_output_id() == output_id);
+
+    // All libraries must share the same type hash storage
+    const void* type_hash_id =
+        default_registry::policy<policies::type_hash>::id();
+    BOOST_TEST(dl_registry_get_type_hash_id() == type_hash_id);
+    BOOST_TEST(dl_method_get_type_hash_id() == type_hash_id);
+    BOOST_TEST(overrider_get_type_hash_id() == type_hash_id);
+
+    // All libraries must see the same method object
+    const void* method_fn = static_cast<const void*>(&Method::fn);
+    BOOST_TEST(dl_method_get_method_fn() == method_fn);
+    BOOST_TEST(overrider_get_method_fn() == method_fn);
+
+    // Build dispatch tables (including the Dog overrider from the loaded lib)
+    boost::openmethod::initialize();
+
+    // Verify dispatch
+    Dog dog;
+    BOOST_TEST(speak(dog) == "woof");
+}