diff --git a/include/boost/openmethod/compiler.hpp b/include/boost/openmethod/compiler.hpp
index 625aae1..f99eeab 100644
--- a/include/boost/openmethod/compiler.hpp
+++ b/include/boost/openmethod/compiler.hpp
@@ -95,7 +95,7 @@ struct generic_compiler {
         std::vector<parameter> used_by_vp;
         boost::dynamic_bitset<> used_slots;
         boost::dynamic_bitset<> reserved_slots;
-        std::size_t first_slot = 0;
+        int first_slot = 0;
         std::size_t mark = 0;   // temporary mark to detect cycles
         std::size_t weight = 0; // number of proper direct or indirect bases
         std::vector<vtbl_entry> vtbl;
@@ -562,7 +562,7 @@ void compiler<Policy>::augment_methods() {
 
                 abort();
             }
-            parameter param = {&*meth_iter, param_index++};
+
             meth_iter->vp.push_back(class_);
         }
 
diff --git a/include/boost/openmethod/core.hpp b/include/boost/openmethod/core.hpp
index eb9485e..18e54fd 100644
--- a/include/boost/openmethod/core.hpp
+++ b/include/boost/openmethod/core.hpp
@@ -196,7 +196,7 @@ using virtual_types = boost::mp11::mp_transform<
 
 template<typename T, class Policy>
 struct parameter_traits {
-    static auto peek(const T& arg) {
+    static auto peek(const T&) {
         return nullptr;
     }
 
@@ -346,15 +346,15 @@ class virtual_ptr_impl {
     virtual_ptr_impl() = default;
 
     explicit virtual_ptr_impl(std::nullptr_t)
-        : obj(nullptr), vp(box_vptr<use_indirect_vptrs>(null_vptr)) {
+        : vp(box_vptr<use_indirect_vptrs>(null_vptr)), obj(nullptr) {
     }
 
     template<
         class Other,
         typename = std::enable_if_t<std::is_constructible_v<Class*, Other*>>>
     virtual_ptr_impl(Other& other)
-        : obj(&other),
-          vp(box_vptr<use_indirect_vptrs>(Policy::dynamic_vptr(other))) {
+        : vp(box_vptr<use_indirect_vptrs>(Policy::dynamic_vptr(other))),
+          obj(&other) {
     }
 
     template<
@@ -363,8 +363,8 @@ class virtual_ptr_impl {
             Class*,
             decltype(std::declval<virtual_ptr<Other, Policy>>().get())>>>
     virtual_ptr_impl(Other* other)
-        : obj(other),
-          vp(box_vptr<use_indirect_vptrs>(Policy::dynamic_vptr(*other))) {
+        : vp(box_vptr<use_indirect_vptrs>(Policy::dynamic_vptr(*other))),
+          obj(other) {
     }
 
     template<
@@ -373,7 +373,7 @@ class virtual_ptr_impl {
             Class*,
             decltype(std::declval<virtual_ptr<Other, Policy>>().get())>>>
     virtual_ptr_impl(const virtual_ptr<Other, Policy>& other)
-        : obj(other.get()), vp(other.vp) {
+        : vp(other.vp), obj(other.get()) {
     }
 
     template<
@@ -382,7 +382,7 @@ class virtual_ptr_impl {
             Class*,
             decltype(std::declval<virtual_ptr<Other, Policy>>().get())>>>
     virtual_ptr_impl(virtual_ptr<Other, Policy>& other)
-        : obj(other.get()), vp(other.vp) {
+        : vp(other.vp), obj(other.get()) {
         // Why is this needed? Consider this conversion conversion from
         // smart to dumb pointer:
         //      virtual_ptr<std::shared_ptr<const Node>> p = ...;
@@ -397,7 +397,7 @@ class virtual_ptr_impl {
         class Other,
         typename = std::enable_if_t<std::is_constructible_v<Class*, Other*>>>
     virtual_ptr_impl(Other& other, const vptr_type& vp)
-        : obj(&other), vp(box_vptr<use_indirect_vptrs>(vp)) {
+        : vp(box_vptr<use_indirect_vptrs>(vp)), obj(&other) {
     }
 
     template<
@@ -515,7 +515,7 @@ class virtual_ptr_impl<
     }
 
     explicit virtual_ptr_impl(std::nullptr_t)
-        : obj(nullptr), vp(box_vptr<use_indirect_vptrs>(null_vptr)) {
+        : vp(box_vptr<use_indirect_vptrs>(null_vptr)), obj(nullptr) {
     }
 
     virtual_ptr_impl(const virtual_ptr_impl& other) = default;
@@ -526,8 +526,9 @@ class virtual_ptr_impl<
             same_smart_ptr<Class, Other, Policy> &&
             std::is_constructible_v<Class, const Other&>>>
     virtual_ptr_impl(const Other& other)
-        : obj(other), vp(box_vptr<use_indirect_vptrs>(
-                          other ? Policy::dynamic_vptr(*other) : null_vptr)) {
+        : vp(box_vptr<use_indirect_vptrs>(
+              other ? Policy::dynamic_vptr(*other) : null_vptr)),
+          obj(other) {
     }
 
     template<
@@ -536,8 +537,9 @@ class virtual_ptr_impl<
             same_smart_ptr<Class, Other, Policy> &&
             std::is_constructible_v<Class, Other&>>>
     virtual_ptr_impl(Other& other)
-        : obj(other), vp(box_vptr<use_indirect_vptrs>(
-                          other ? Policy::dynamic_vptr(*other) : null_vptr)) {
+        : vp(box_vptr<use_indirect_vptrs>(
+                 other ? Policy::dynamic_vptr(*other) : null_vptr)),
+             obj(other) {
     }
 
     template<
@@ -546,9 +548,9 @@ class virtual_ptr_impl<
             same_smart_ptr<Class, Other, Policy> &&
             std::is_constructible_v<Class, Other&&>>>
     virtual_ptr_impl(Other&& other)
-        : obj(std::move(other)),
-          vp(box_vptr<use_indirect_vptrs>(
-              other ? Policy::dynamic_vptr(*other) : null_vptr)) {
+        : vp(box_vptr<use_indirect_vptrs>(
+              other ? Policy::dynamic_vptr(*other) : null_vptr)),
+          obj(std::move(other)) {
     }
 
     template<
@@ -557,7 +559,7 @@ class virtual_ptr_impl<
             same_smart_ptr<Class, Other, Policy> &&
             std::is_constructible_v<Class, const Other&>>>
     virtual_ptr_impl(const virtual_ptr<Other, Policy>& other)
-        : obj(other.obj), vp(other.vp) {
+        : vp(other.vp), obj(other.obj) {
     }
 
     template<
@@ -566,11 +568,11 @@ class virtual_ptr_impl<
             same_smart_ptr<Class, Other, Policy> &&
             std::is_constructible_v<Class, Other&>>>
     virtual_ptr_impl(virtual_ptr<Other, Policy>& other)
-        : obj(other.obj), vp(other.vp) {
+        : vp(other.vp), obj(other.obj) {
     }
 
     virtual_ptr_impl(virtual_ptr_impl&& other)
-        : obj(std::move(other.obj)), vp(other.vp) {
+        : vp(other.vp), obj(std::move(other.obj)) {
         other.vp = box_vptr<use_indirect_vptrs>(null_vptr);
     }
 
@@ -580,7 +582,7 @@ class virtual_ptr_impl<
             same_smart_ptr<Class, Other, Policy> &&
             std::is_constructible_v<Class, Other&&>>>
     virtual_ptr_impl(virtual_ptr<Other, Policy>&& other)
-        : obj(std::move(other.obj)), vp(other.vp) {
+        : vp(other.vp), obj(std::move(other.obj)) {
         other.vp = box_vptr<use_indirect_vptrs>(null_vptr);
     }
 
@@ -665,7 +667,7 @@ class virtual_ptr_impl<
 
     template<typename Arg>
     virtual_ptr_impl(Arg&& obj, decltype(vp) other_vp)
-        : obj(std::forward<Arg>(obj)), vp(other_vp) {
+        : vp(other_vp), obj(std::forward<Arg>(obj)) {
     }
 
     template<class Other>
diff --git a/include/boost/openmethod/detail/trace.hpp b/include/boost/openmethod/detail/trace.hpp
index bac1c92..8428a20 100644
--- a/include/boost/openmethod/detail/trace.hpp
+++ b/include/boost/openmethod/detail/trace.hpp
@@ -41,7 +41,7 @@ struct trace_type {
     auto operator++() -> trace_type& {
         if constexpr (trace_enabled) {
             if (Policy::trace_enabled) {
-                for (int i = 0; i < indentation_level; ++i) {
+                for (std::size_t i = 0; i < indentation_level; ++i) {
                     Policy::trace_stream << "  ";
                 }
             }
@@ -96,10 +96,7 @@ template<class Policy>
 auto operator<<(trace_type<Policy>& trace, const rflush& rf) -> auto& {
     if constexpr (trace_type<Policy>::trace_enabled) {
         if (Policy::trace_enabled) {
-            auto pad = rf.width;
-            auto remain = rf.value;
-
-            int digits = 1;
+            std::size_t digits = 1;
             auto tmp = rf.value / 10;
 
             while (tmp) {
diff --git a/test/test_blackbox.cpp b/test/test_blackbox.cpp
index 588c37b..8c8294f 100644
--- a/test/test_blackbox.cpp
+++ b/test/test_blackbox.cpp
@@ -326,19 +326,19 @@ BOOST_OPENMETHOD_OVERRIDE(
     return Types(DIAGONAL_DIAGONAL, MATRIX_MATRIX);
 }
 
-BOOST_OPENMETHOD_OVERRIDE(times, (double a, const matrix& m), Types) {
+BOOST_OPENMETHOD_OVERRIDE(times, (double, const matrix&), Types) {
     return Types(SCALAR_MATRIX, NONE);
 }
 
-BOOST_OPENMETHOD_OVERRIDE(times, (double a, const diagonal_matrix& m), Types) {
+BOOST_OPENMETHOD_OVERRIDE(times, (double, const diagonal_matrix&), Types) {
     return Types(SCALAR_DIAGONAL, SCALAR_MATRIX);
 }
 
-BOOST_OPENMETHOD_OVERRIDE(times, (const diagonal_matrix& m, double a), Types) {
+BOOST_OPENMETHOD_OVERRIDE(times, (const diagonal_matrix&, double), Types) {
     return Types(DIAGONAL_SCALAR, MATRIX_SCALAR);
 }
 
-BOOST_OPENMETHOD_OVERRIDE(times, (const matrix& m, double a), Types) {
+BOOST_OPENMETHOD_OVERRIDE(times, (const matrix&, double), Types) {
     return Types(MATRIX_SCALAR, NONE);
 }
 
@@ -389,9 +389,10 @@ BOOST_OPENMETHOD_OVERRIDE(
     return Types(DIAGONAL_MATRIX, next(a, b).first);
 }
 
+
 BOOST_AUTO_TEST_CASE(ambiguity) {
     auto compiler = initialize<policy>();
-    BOOST_TEST(compiler.report.ambiguous == 1);
+    BOOST_TEST(compiler.report.ambiguous == 1u);
 
     // N2216: in case of ambiguity, pick one.
     diagonal_matrix diag1, diag2;
@@ -436,7 +437,7 @@ BOOST_OPENMETHOD_OVERRIDE(
 
 BOOST_AUTO_TEST_CASE(covariant_return_type) {
     auto compiler = initialize<policy>();
-    BOOST_TEST(compiler.report.ambiguous == 0);
+    BOOST_TEST(compiler.report.ambiguous == 0u);
 
     // N2216: use covariant return types to resolve ambiguity.
     dense_matrix left, right;
@@ -462,7 +463,7 @@ struct BOOST_OPENMETHOD_NAME(poke);
 using poke =
     method<BOOST_OPENMETHOD_NAME(poke)(virtual_<Animal&>), std::string>;
 
-auto poke_dog(Dog& dog) -> std::string {
+auto poke_dog(Dog&) -> std::string {
     return "bark";
 }
 
@@ -573,7 +574,7 @@ class Dog : public animals::Animal {};
 
 BOOST_OPENMETHOD_CLASSES(Dog, animals::Animal);
 
-BOOST_OPENMETHOD_OVERRIDE(poke, (const Dog& dog), std::string) {
+BOOST_OPENMETHOD_OVERRIDE(poke, (const Dog&), std::string) {
     return "bark";
 }
 
@@ -621,39 +622,39 @@ BOOST_AUTO_TEST_CASE(initialize_report) {
         method<meet_(virtual_<Animal&>, virtual_<Animal&>), void, policy>;
 
     auto report = initialize<policy>().report;
-    BOOST_TEST(report.not_implemented == 3);
-    BOOST_TEST(report.ambiguous == 0);
+    BOOST_TEST(report.not_implemented == 3u);
+    BOOST_TEST(report.ambiguous == 0u);
     // 'meet' dispatch table is one cell, containing 'not_implemented'
-    BOOST_TEST(report.cells == 1);
+    BOOST_TEST(report.cells == 1u);
 
     BOOST_OPENMETHOD_REGISTER(poke::override<fn<Animal>>);
     report = initialize<policy>().report;
-    BOOST_TEST(report.not_implemented == 2);
+    BOOST_TEST(report.not_implemented == 2u);
 
     BOOST_OPENMETHOD_REGISTER(pet::override<fn<Cat>>);
     BOOST_OPENMETHOD_REGISTER(pet::override<fn<Dog>>);
     report = initialize<policy>().report;
-    BOOST_TEST(report.not_implemented == 2);
+    BOOST_TEST(report.not_implemented == 2u);
 
     // create ambiguity
     BOOST_OPENMETHOD_REGISTER(meet::override<fn<Animal, Cat>>);
     BOOST_OPENMETHOD_REGISTER(meet::override<fn<Dog, Animal>>);
     report = initialize<policy>().report;
-    BOOST_TEST(report.cells == 4);
-    BOOST_TEST(report.ambiguous == 1);
+    BOOST_TEST(report.cells == 4u);
+    BOOST_TEST(report.ambiguous == 1u);
 
     BOOST_OPENMETHOD_REGISTER(meet::override<fn<Cat, Cat>>);
     report = initialize<policy>().report;
-    BOOST_TEST(report.cells == 6);
-    BOOST_TEST(report.ambiguous == 1);
+    BOOST_TEST(report.cells == 6u);
+    BOOST_TEST(report.ambiguous == 1u);
 
     // shadow ambiguity
     BOOST_OPENMETHOD_REGISTER(meet::override<fn<Dog, Dog>>);
     BOOST_OPENMETHOD_REGISTER(meet::override<fn<Dog, Cat>>);
     BOOST_OPENMETHOD_REGISTER(meet::override<fn<Cat, Dog>>);
     report = initialize<policy>().report;
-    BOOST_TEST(report.cells == 9);
-    BOOST_TEST(report.ambiguous == 0);
+    BOOST_TEST(report.cells == 9u);
+    BOOST_TEST(report.ambiguous == 0u);
 }
 
 } // namespace report
diff --git a/test/test_compiler.cpp b/test/test_compiler.cpp
index a41df35..6fea4bb 100644
--- a/test/test_compiler.cpp
+++ b/test/test_compiler.cpp
@@ -60,13 +60,15 @@ auto get_class(const Compiler& comp) {
     return comp.class_map.at(typeid(T));
 }
 
-// A   B
-//  \ / \
-//  AB   D
-//  |    |
-//  C    E
-//   \  /
-//    F
+/*
+A   B
+ \ / \
+ AB   D
+ |    |
+ C    E
+  \  /
+   F
+*/
 
 struct A {
     virtual ~A() {
@@ -174,9 +176,11 @@ struct M;
 BOOST_AUTO_TEST_CASE(test_assign_slots_a_b1_c) {
     using test_policy = test_policy_<__COUNTER__>;
 
-    //   A
-    //  / \
-    // B1  C
+    /*
+      A
+     / \
+    B1  C
+    */
 
     struct A {};
     struct B : A {};
@@ -189,11 +193,11 @@ BOOST_AUTO_TEST_CASE(test_assign_slots_a_b1_c) {
 
     auto comp = initialize<test_policy>();
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_B).slots[0] == 0);
-    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 0);
-    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 1);
-    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 0);
+    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_B).slots[0] == 0u);
+    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 0u);
+    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 1u);
+    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 0u);
 
     finalize<test_policy>();
     BOOST_TEST(test_policy::dispatch_data.empty());
@@ -202,9 +206,11 @@ BOOST_AUTO_TEST_CASE(test_assign_slots_a_b1_c) {
 BOOST_AUTO_TEST_CASE(test_assign_slots_a1_b1_c1) {
     using test_policy = test_policy_<__COUNTER__>;
 
-    //   A1
-    //  / \
-    // B1  C1
+    /*
+      A1
+     / \
+    B1  C1
+    */
 
     struct A {};
     struct B : A {};
@@ -218,27 +224,29 @@ BOOST_AUTO_TEST_CASE(test_assign_slots_a1_b1_c1) {
     ADD_METHOD(C);
     auto comp = initialize<test_policy>();
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_A).slots[0] == 0);
-    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1);
+    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_A).slots[0] == 0u);
+    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_B).slots[0] == 1);
-    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 2);
+    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_B).slots[0] == 1u);
+    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 2u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_C).slots[0] == 1);
-    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 2);
+    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_C).slots[0] == 1u);
+    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 2u);
 }
 
 BOOST_AUTO_TEST_CASE(test_assign_slots_a1_b1_d1_c1_d1) {
     using test_policy = test_policy_<__COUNTER__>;
 
-    //   A1
-    //  / \
-    // B1  C1 - slots 0-2 are wasted
-    //  \ /
-    //   D1
+    /*
+      A1
+     / \
+    B1  C1 - slots 0-2 are wasted
+     \ /
+      D1
+    */
 
     struct A {};
     struct B : virtual A {};
@@ -255,32 +263,34 @@ BOOST_AUTO_TEST_CASE(test_assign_slots_a1_b1_d1_c1_d1) {
     ADD_METHOD(D);
     auto comp = initialize<test_policy>();
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_A).slots[0] == 0);
-    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1);
+    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_A).slots[0] == 0u);
+    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_B).slots[0] == 1);
-    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 2);
+    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_B).slots[0] == 1u);
+    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 2u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_D).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_D).slots[0] == 2);
-    BOOST_TEST(get_class<D>(comp)->vtbl.size() == 4);
+    BOOST_TEST_REQUIRE(get_method(comp, m_D).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_D).slots[0] == 2u);
+    BOOST_TEST(get_class<D>(comp)->vtbl.size() == 4u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_C).slots[0] == 3);
-    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 4);
+    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_C).slots[0] == 3u);
+    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 4u);
     // slots 0-2 in C are wasted, to make room for methods in B and D
 }
 
 BOOST_AUTO_TEST_CASE(test_assign_slots_a1_b1_d1_c1_d1_e2) {
     using test_policy = test_policy_<__COUNTER__>;
 
-    //   A1
-    //  / \
-    // B1  C1 slots 0-2 are wasted
-    //  \ /  \
-    //   D1  E2 but E can use them
+    /*
+      A1
+     / \
+    B1  C1 slots 0-2 are wasted
+     \ /  \
+      D1  E2 but E can use them
+    */
 
     struct A {};
     struct B : virtual A {};
@@ -302,41 +312,43 @@ BOOST_AUTO_TEST_CASE(test_assign_slots_a1_b1_d1_c1_d1_e2) {
     ADD_METHOD_N(E, 3);
     auto comp = initialize<test_policy>();
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_A).slots[0] == 0);
-    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1);
+    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_A).slots[0] == 0u);
+    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_B).slots[0] == 1);
-    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 2);
+    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_B).slots[0] == 1u);
+    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 2u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_D).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_D).slots[0] == 2);
-    BOOST_TEST(get_class<D>(comp)->vtbl.size() == 4);
+    BOOST_TEST_REQUIRE(get_method(comp, m_D).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_D).slots[0] == 2u);
+    BOOST_TEST(get_class<D>(comp)->vtbl.size() == 4u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_C).slots[0] == 3);
-    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 4);
+    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_C).slots[0] == 3u);
+    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 4u);
     // slots 0-2 in C are wasted, to make room for methods in B and D
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_E1).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_E1).slots[0] == 1);
+    BOOST_TEST_REQUIRE(get_method(comp, m_E1).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_E1).slots[0] == 1u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_E2).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_E2).slots[0] == 2);
+    BOOST_TEST_REQUIRE(get_method(comp, m_E2).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_E2).slots[0] == 2u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_E3).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_E3).slots[0] == 4);
+    BOOST_TEST_REQUIRE(get_method(comp, m_E3).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_E3).slots[0] == 4u);
 
-    BOOST_TEST(get_class<E>(comp)->vtbl.size() == 5);
+    BOOST_TEST(get_class<E>(comp)->vtbl.size() == 5u);
 }
 
 BOOST_AUTO_TEST_CASE(test_assign_slots_a1_c1_b1) {
     using test_policy = test_policy_<__COUNTER__>;
 
-    // A1  B1
-    //  \  /
-    //   C1
+    /*
+    A1  B1
+     \  /
+      C1
+    */
 
     struct A {};
     struct B {};
@@ -350,16 +362,16 @@ BOOST_AUTO_TEST_CASE(test_assign_slots_a1_c1_b1) {
     ADD_METHOD(C);
     auto comp = initialize<test_policy>();
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_A).slots[0] == 0);
-    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1);
+    BOOST_TEST_REQUIRE(get_method(comp, m_A).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_A).slots[0] == 0u);
+    BOOST_TEST(get_class<A>(comp)->vtbl.size() == 1u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_C).slots[0] == 1);
-    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 3);
+    BOOST_TEST_REQUIRE(get_method(comp, m_C).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_C).slots[0] == 1u);
+    BOOST_TEST(get_class<C>(comp)->vtbl.size() == 3u);
 
-    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1);
-    BOOST_TEST(get_method(comp, m_B).slots[0] == 2);
+    BOOST_TEST_REQUIRE(get_method(comp, m_B).slots.size() == 1u);
+    BOOST_TEST(get_method(comp, m_B).slots[0] == 2u);
     BOOST_TEST(get_class<B>(comp)->first_slot == 2);
-    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 1);
+    BOOST_TEST(get_class<B>(comp)->vtbl.size() == 1u);
 }
diff --git a/test/test_core.cpp b/test/test_core.cpp
index 526a4f3..22618cd 100644
--- a/test/test_core.cpp
+++ b/test/test_core.cpp
@@ -169,7 +169,6 @@ BOOST_AUTO_TEST_CASE(test_policy) {
 }
 
 BOOST_AUTO_TEST_CASE(test_type_id_list) {
-    type_id expected[] = {type_id(&typeid(a)), type_id(&typeid(b))};
     auto iter = type_id_list<mp11::mp_list<a&, b&>, default_policy>::begin;
     auto last = type_id_list<mp11::mp_list<a&, b&>, default_policy>::end;
     BOOST_TEST_REQUIRE(last - iter == 2);
@@ -254,7 +253,6 @@ BOOST_AUTO_TEST_CASE(casts) {
               carnivore)
               .c) == &dog.c);
 
-    using voidp = const void*;
     using virtual_animal_t = virtual_type<const Animal&, default_policy>;
     static_assert(std::is_same_v<virtual_animal_t, Animal>, "animal");
     using virtual_mammal_t = virtual_type<const Mammal&, default_policy>;
diff --git a/test/test_custom_rtti.cpp b/test/test_custom_rtti.cpp
index e2f20e4..7c82879 100644
--- a/test/test_custom_rtti.cpp
+++ b/test/test_custom_rtti.cpp
@@ -192,9 +192,9 @@ void call_poke(Animal& a, std::ostream& os) {
 // TAILCALL
 
 BOOST_AUTO_TEST_CASE(custom_rtti_simple) {
-    BOOST_TEST(Animal::static_type == 0);
-    BOOST_TEST(Dog::static_type == 1);
-    BOOST_TEST(Cat::static_type == 2);
+    BOOST_TEST(Animal::static_type == 0u);
+    BOOST_TEST(Dog::static_type == 1u);
+    BOOST_TEST(Cat::static_type == 2u);
     initialize<test_policy>();
 
     Animal &&a = Dog("Snoopy"), &&b = Cat("Sylvester");
@@ -348,9 +348,9 @@ void call_poke(Animal& a, std::ostream& os) {
 // TAILCALL
 
 BOOST_AUTO_TEST_CASE(virtual_base) {
-    BOOST_TEST(Animal::static_type == 0);
-    BOOST_TEST(Dog::static_type == 1);
-    BOOST_TEST(Cat::static_type == 2);
+    BOOST_TEST(Animal::static_type == 0u);
+    BOOST_TEST(Dog::static_type == 1u);
+    BOOST_TEST(Cat::static_type == 2u);
     initialize<test_policy>();
 
     Animal &&a = Dog("Snoopy"), &&b = Cat("Sylvester");
diff --git a/test/test_intrusive.cpp b/test/test_intrusive.cpp
index 92a2126..e82547a 100644
--- a/test/test_intrusive.cpp
+++ b/test/test_intrusive.cpp
@@ -85,15 +85,15 @@ DomesticCat::~DomesticCat() {
 }
 
 BOOST_OPENMETHOD_OVERRIDE(
-    speak, (const Animal& animal, std::ostream& os), void) {
+    speak, (const Animal&, std::ostream& os), void) {
     os << "???\n";
 }
 
-BOOST_OPENMETHOD_OVERRIDE(speak, (const Cat& animal, std::ostream& os), void) {
+BOOST_OPENMETHOD_OVERRIDE(speak, (const Cat&, std::ostream& os), void) {
     os << "meow\n";
 }
 
-BOOST_OPENMETHOD_OVERRIDE(describe, (const Pet& pet, std::ostream& os), void) {
+BOOST_OPENMETHOD_OVERRIDE(describe, (const Pet&, std::ostream& os), void) {
     os << "I am a pet\n";
 }
 
diff --git a/test/test_namespaces.cpp b/test/test_namespaces.cpp
index 4692d80..834f560 100644
--- a/test/test_namespaces.cpp
+++ b/test/test_namespaces.cpp
@@ -40,7 +40,7 @@ BOOST_OPENMETHOD(poke, (virtual_<interfaces::Animal&>), std::string);
 
 namespace canis {
 // implement 'poke' for dogs
-BOOST_OPENMETHOD_OVERRIDE(poke, (Dog & dog), std::string) {
+BOOST_OPENMETHOD_OVERRIDE(poke, (Dog &), std::string) {
     return "bark";
 }
 
@@ -62,17 +62,17 @@ BOOST_OPENMETHOD_OVERRIDE(
 }
 
 BOOST_OPENMETHOD_OVERRIDE(
-    meet, (canis::Dog & dog1, canis::Dog& dog2), std::string) {
+    meet, (canis::Dog &, canis::Dog&), std::string) {
     return "wag tail";
 }
 
 BOOST_OPENMETHOD_OVERRIDE(
-    meet, (canis::Dog & dog, felis::Cat& cat), std::string) {
+    meet, (canis::Dog &, felis::Cat&), std::string) {
     return "chase";
 }
 
 BOOST_OPENMETHOD_OVERRIDE(
-    meet, (felis::Cat & cat, canis::Dog& dog), std::string) {
+    meet, (felis::Cat &, canis::Dog&), std::string) {
     return "run";
 }
 
diff --git a/test/test_pointer_to_method.cpp b/test/test_pointer_to_method.cpp
index 90f3824..7d99c1e 100644
--- a/test/test_pointer_to_method.cpp
+++ b/test/test_pointer_to_method.cpp
@@ -25,7 +25,7 @@ BOOST_OPENMETHOD_CLASSES(Animal, Dog, Animal);
 
 BOOST_OPENMETHOD(poke, (virtual_<Animal&>), std::string);
 
-BOOST_OPENMETHOD_OVERRIDE(poke, (Dog & dog), std::string) {
+BOOST_OPENMETHOD_OVERRIDE(poke, (Dog &), std::string) {
     return "bark";
 }
 
@@ -33,6 +33,5 @@ BOOST_AUTO_TEST_CASE(noadl) {
     boost::openmethod::initialize();
     std::string (*stimulus)(Animal&) = poke;
     Dog snoopy;
-    Animal& animal = snoopy;
     BOOST_TEST(stimulus(snoopy) == "bark");
 }
diff --git a/test/test_rolex.cpp b/test/test_rolex.cpp
index b403316..c23e265 100644
--- a/test/test_rolex.cpp
+++ b/test/test_rolex.cpp
@@ -51,28 +51,28 @@ BOOST_OPENMETHOD_OVERRIDE(pay, (virtual_ptr<Manager> exec), double) {
 
 BOOST_OPENMETHOD_OVERRIDE(
     approve,
-    (virtual_ptr<const Role> r, virtual_ptr<const Expense> e, double amount),
+    (virtual_ptr<const Role>, virtual_ptr<const Expense>, double),
     bool) {
     return false;
 }
 
 BOOST_OPENMETHOD_OVERRIDE(
     approve,
-    (virtual_ptr<const Employee> r, virtual_ptr<const Public> e, double amount),
+    (virtual_ptr<const Employee>, virtual_ptr<const Public>, double),
     bool) {
     return true;
 }
 
 BOOST_OPENMETHOD_OVERRIDE(
     approve,
-    (virtual_ptr<const Manager> r, virtual_ptr<const Taxi> e, double amount),
+    (virtual_ptr<const Manager>, virtual_ptr<const Taxi>, double),
     bool) {
     return true;
 }
 
 BOOST_OPENMETHOD_OVERRIDE(
     approve,
-    (virtual_ptr<const Founder> r, virtual_ptr<const Expense> e, double amount),
+    (virtual_ptr<const Founder>, virtual_ptr<const Expense>, double),
     bool) {
     return true;
 }
diff --git a/test/test_virtual_ptr_dispatch.cpp b/test/test_virtual_ptr_dispatch.cpp
index 50fc5c7..337cc3d 100644
--- a/test/test_virtual_ptr_dispatch.cpp
+++ b/test/test_virtual_ptr_dispatch.cpp
@@ -241,7 +241,6 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(
         (vptr_player(bear).vptr() == Policy::template static_vptr<Bear>));
 
     vptr_bear virtual_bear_ptr(bear);
-    vptr_player virtual_player_ptr = virtual_bear_ptr;
 
     struct upcast {
         static void fn(vptr_player) {