@@ -0,0 +1,43 @@
+#pragma once
+
+#include "polyfill_v1/type_traits.hpp"
+#include <utility>
+
+namespace testing_v1 {
+
+template <class Action> struct test_t;
+
+void run_all();
+
+class Private {
+  friend void run_all();
+  template <class> friend struct test_t;
+
+  class Static;
+
+  class test_base_t;
+  template <class Action> class test_t;
+};
+
+} // namespace testing_v1
+
+class testing_v1::Private::test_base_t {
+  friend class Static;
+  template <class> friend class test_t;
+
+  ~test_base_t();
+  test_base_t();
+
+  virtual void run() = 0;
+};
+
+template <class Action> class testing_v1::Private::test_t : test_base_t {
+  friend class Static;
+  template <class> friend struct testing_v1::test_t;
+
+  template <class ForwardableAction> test_t(ForwardableAction &&action);
+
+  void run() override;
+
+  std::conditional_t<std::is_function_v<Action>, Action *, Action> action;
+};
@@ -1,13 +1,22 @@
 #pragma once
 
-#include "polyfill_v1/type_traits.hpp"
+#include "testing_v1/private.hpp"
 
 namespace testing_v1 {
 
 // test.hpp ====================================================================
 
 /// Holds a registered test action and should only be used at namespace scope.
-template <class Action> struct test_t;
+template <class Action> struct test_t : Private::test_t<Action> {
+  /// Constructs a test from the given action.
+  template <class ForwardableAction> test_t(ForwardableAction &&action);
+
+  /// Tests are not CopyConstructible.
+  test_t(const test_t &) = delete;
+
+  /// Tests are not CopyAssignable.
+  test_t &operator=(const test_t &) = delete;
+};
 
 /// Creates and registers a test action and should only be used at namespace
 /// scope.
 
@@ -4,35 +4,19 @@
 
 #include <utility>
 
-namespace testing_v1 {
-
-class test_private;
-
-class test_base_t {
-  friend class test_private;
-
-  test_base_t(const test_base_t &) = delete;
-  test_base_t &operator=(const test_base_t &) = delete;
-
-  virtual void run() = 0;
-
-protected:
-  test_base_t();
-  ~test_base_t();
-};
-
-} // namespace testing_v1
-
-template <class Action> struct testing_v1::test_t : test_base_t {
-  template <class ForwardableAction>
-  test_t(ForwardableAction &&action)
-      : action(std::forward<ForwardableAction>(action)) {}
+template <class Action>
+template <class ForwardableAction>
+testing_v1::Private::test_t<Action>::test_t(ForwardableAction &&action)
+    : action(std::forward<ForwardableAction>(action)) {}
 
-  void run() override { action(); }
+template <class Action> void testing_v1::Private::test_t<Action>::run() {
+  action();
+}
 
-private:
-  std::conditional_t<std::is_function_v<Action>, Action *, Action> action;
-};
+template <class Action>
+template <class ForwardableAction>
+testing_v1::test_t<Action>::test_t(ForwardableAction &&action)
+    : Private::test_t<Action>(std::forward<ForwardableAction>(action)) {}
 
 template <class Action>
 testing_v1::test_t<std::remove_cvref_t<Action>>
 
@@ -13,29 +13,31 @@ void testing_v1::verify(bool ok) {
   exit(1);
 }
 
-class testing_v1::test_private {
+class testing_v1::Private::Static {
+  friend void run_all();
   friend class test_base_t;
 
-  using tests_t = std::vector<testing_v1::test_base_t *>;
+  using tests_t = std::vector<test_base_t *>;
 
   static tests_t &tests() {
     static tests_t tests;
     return tests;
   }
 
-public:
   static void run_all() {
     for (auto test : tests())
       test->run();
   }
 };
 
-testing_v1::test_base_t::test_base_t() {
-  test_private::tests().push_back(this);
+void testing_v1::run_all() { Private::Static::run_all(); }
+
+testing_v1::Private::test_base_t::test_base_t() {
+  Static::tests().push_back(this);
 }
 
-testing_v1::test_base_t::~test_base_t() {
-  auto &tests = test_private::tests();
+testing_v1::Private::test_base_t::~test_base_t() {
+  auto &tests = Static::tests();
   auto it = std::find(tests.rbegin(), tests.rend(), this);
   if (it != tests.rend()) {
     std::swap(*it, tests.back());
@@ -44,6 +46,6 @@ testing_v1::test_base_t::~test_base_t() {
 }
 
 int main() {
-  testing_v1::test_private::run_all();
+  testing_v1::run_all();
   return 0;
 }