boost/openmethod
2
0
Fork 0
mirror of https://github.com/boostorg/openmethod.git synced 2026-01-19 04:22:12 +00:00
Code Issues Projects Releases Wiki Activity

fix warnings

Browse Source
This commit is contained in:
Jean-Louis Leroy
2025-04-27 11:26:26 -05:00
parent 415c12b3da
commit fcccfc0772
12 changed files with 158 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/boost/openmethod/compiler.hpp
View File

@@ -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_);
}

46
include/boost/openmethod/core.hpp
View File

@@ -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>

7
include/boost/openmethod/detail/trace.hpp
View File

@@ -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) {

39
test/test_blackbox.cpp
View File

@@ -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

172
test/test_compiler.cpp
View File

@@ -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);
}

2
test/test_core.cpp
View File

@@ -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>;

12
test/test_custom_rtti.cpp
View File

@@ -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");

6
test/test_intrusive.cpp
View File

@@ -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";
}

8
test/test_namespaces.cpp
View File

@@ -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";
}

3
test/test_pointer_to_method.cpp
View File

@@ -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");
}

8
test/test_rolex.cpp
View File

@@ -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;
}

1
test/test_virtual_ptr_dispatch.cpp
View File

@@ -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) {