// Copyright (C) 2008 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#include <string>
#include <memory>
#include <array>
#include <tuple>
#include <utility>
#include <dlib/invoke.h>
#include "tester.h"
namespace
{
using namespace test;
using namespace dlib;
logger dlog("test.invoke");
// ----------------------------------------------------------------------------------------
static const std::string run1_str1 = "hello there 1";
static const std::string run1_str2 = "hello there 2";
static const std::string run1_str3 = "hello there 3";
static const std::string run1_str4 = "hello there 4";
static const std::string run1_str5 = "hello there 5";
void func_testargs(int i, std::string ref1, const std::string& ref2, const std::string& ref3, std::string& ref4)
{
DLIB_TEST(i > 0);
DLIB_TEST(ref1 == run1_str1);
DLIB_TEST(ref2 == run1_str2);
DLIB_TEST(ref3 == run1_str3);
DLIB_TEST(ref4 == run1_str4);
ref4 = run1_str5;
}
int func_return_addition(int i, int j)
{
return i + j;
}
void test_functions()
{
static_assert(dlib::is_invocable<decltype(func_testargs), int, std::string, const std::string&, const std::string&, std::string&>::value, "should be invocable!");
static_assert(dlib::is_invocable<decltype(func_testargs), int, std::string, std::string, const std::string&, std::string&>::value, "should be invocable!");
static_assert(dlib::is_invocable<decltype(func_testargs), int, std::string, std::string, std::string, std::string&>::value, "should be invocable!");
static_assert(dlib::is_invocable<decltype(func_testargs), int, std::string, std::string, std::string, std::reference_wrapper<std::string>>::value, "should be invocable!");
{
std::string str = run1_str4;
dlib::invoke(func_testargs, 1, run1_str1, run1_str2, std::cref(run1_str3), std::ref(str));
DLIB_TEST(str == run1_str5);
}
{
std::string str = run1_str4;
dlib::apply(func_testargs, std::make_tuple(1, run1_str1, run1_str2, std::cref(run1_str3), std::ref(str)));
DLIB_TEST(str == run1_str5);
}
{
for (int i = -10 ; i <= 10 ; i++)
{
for (int j = -10 ; j <= 10 ; j++)
{
DLIB_TEST(dlib::invoke(func_return_addition, i, j) == (i+j));
DLIB_TEST(dlib::apply(func_return_addition, std::make_tuple(i, j)) == (i+j));
}
}
}
}
// ----------------------------------------------------------------------------------------
void test_lambdas()
{
{
std::string str = run1_str4;
dlib::invoke([](int i, std::string ref1, const std::string& ref2, const std::string& ref3, std::string& ref4) {
DLIB_TEST(i > 0);
DLIB_TEST(ref1 == run1_str1);
DLIB_TEST(ref2 == run1_str2);
DLIB_TEST(ref3 == run1_str3);
DLIB_TEST(ref4 == run1_str4);
ref4 = run1_str5;
}, 1, run1_str1, run1_str2, std::cref(run1_str3), std::ref(str));
DLIB_TEST(str == run1_str5);
}
{
std::string str = run1_str4;
dlib::apply([](int i, std::string ref1, const std::string& ref2, const std::string& ref3, std::string& ref4) {
DLIB_TEST(i > 0);
DLIB_TEST(ref1 == run1_str1);
DLIB_TEST(ref2 == run1_str2);
DLIB_TEST(ref3 == run1_str3);
DLIB_TEST(ref4 == run1_str4);
ref4 = run1_str5;
}, std::make_tuple(1, run1_str1, run1_str2, std::cref(run1_str3), std::ref(str)));
DLIB_TEST(str == run1_str5);
}
{
for (int i = -10 ; i <= 10 ; i++)
{
for (int j = -10 ; j <= 10 ; j++)
{
DLIB_TEST(dlib::invoke([](int i, int j) {return i + j;}, i, j) == (i+j));
DLIB_TEST(dlib::apply([](int i, int j) {return i + j;}, std::make_tuple(i,j)) == (i+j));
}
}
}
}
// ----------------------------------------------------------------------------------------
struct example_struct
{
example_struct(int i_ = 0) : i(i_) {}
example_struct(const example_struct&) = delete;
example_struct& operator=(const example_struct&) = delete;
example_struct(example_struct&& other) : i(other.i) {other.i = 0;}
example_struct& operator=(example_struct&& other) {i = other.i; other.i = 0; return *this;}
int get_i() const {return i;}
int i = 0;
};
void test_member_functions_and_data()
{
example_struct obj1(10);
std::unique_ptr<example_struct> obj2(new example_struct(11));
std::shared_ptr<example_struct> obj3(new example_struct(12));
DLIB_TEST(dlib::invoke(&example_struct::get_i, obj1) == 10);
DLIB_TEST(dlib::invoke(&example_struct::i, obj1) == 10);
DLIB_TEST(dlib::invoke(&example_struct::get_i, &obj1) == 10);
DLIB_TEST(dlib::invoke(&example_struct::i, &obj1) == 10);
DLIB_TEST(dlib::invoke(&example_struct::get_i, obj2) == 11);
DLIB_TEST(dlib::invoke(&example_struct::i, obj2) == 11);
DLIB_TEST(dlib::invoke(&example_struct::get_i, obj3) == 12);
DLIB_TEST(dlib::invoke(&example_struct::i, obj3) == 12);
}
// ----------------------------------------------------------------------------------------
int return_int()
{
return 0;
}
int& return_int_ref()
{
static int i = 0;
return i;
}
const int& return_int_const_ref()
{
static const int i = 0;
return i;
}
int* return_int_pointer()
{
static int i = 0;
return &i;
}
const int* return_int_const_pointer()
{
static const int i = 0;
return &i;
}
void test_return_types()
{
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(return_int)>>::value, "bad type");
static_assert(std::is_same<int&, dlib::invoke_result_t<decltype(return_int_ref)>>::value, "bad type");
static_assert(std::is_same<const int&, dlib::invoke_result_t<decltype(return_int_const_ref)>>::value, "bad type");
static_assert(std::is_same<int*, dlib::invoke_result_t<decltype(return_int_pointer)>>::value, "bad type");
static_assert(std::is_same<const int*, dlib::invoke_result_t<decltype(return_int_const_pointer)>>::value, "bad type");
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(&example_struct::get_i), const example_struct&>>::value, "bad type");
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(&example_struct::get_i), example_struct&>>::value, "bad type");
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(&example_struct::get_i), const example_struct*>>::value, "bad type");
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(&example_struct::get_i), example_struct*>>::value, "bad type");
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(&example_struct::get_i), std::unique_ptr<example_struct>>>::value, "bad type");
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(&example_struct::get_i), std::shared_ptr<example_struct>>>::value, "bad type");
static_assert(std::is_same<const int&, dlib::invoke_result_t<decltype(&example_struct::i), const example_struct&>>::value, "bad type");
static_assert(std::is_same<int&, dlib::invoke_result_t<decltype(&example_struct::i), example_struct&>>::value, "bad type");
static_assert(std::is_same<const int&, dlib::invoke_result_t<decltype(&example_struct::i), const example_struct*>>::value, "bad type");
static_assert(std::is_same<int&, dlib::invoke_result_t<decltype(&example_struct::i), example_struct*>>::value, "bad type");
static_assert(std::is_same<int&, dlib::invoke_result_t<decltype(&example_struct::i), std::unique_ptr<example_struct>>>::value, "bad type");
static_assert(std::is_same<int&, dlib::invoke_result_t<decltype(&example_struct::i), std::shared_ptr<example_struct>>>::value, "bad type");
auto lambda_func_return_int = []() -> int {return 0;};
static_assert(std::is_same<int, dlib::invoke_result_t<decltype(lambda_func_return_int)>>::value, "bad type");
}
// ----------------------------------------------------------------------------------------
void test_make_from_tuple()
{
struct multi_args_object
{
multi_args_object(int i_, int j_) : i(i_), j(j_) {}
int i = 0;
int j = 0;
};
{
auto obj = dlib::make_from_tuple<multi_args_object>(std::make_tuple(1, 2));
static_assert(std::is_same<decltype(obj), multi_args_object>::value, "bad type");
DLIB_TEST(obj.i == 1);
DLIB_TEST(obj.j == 2);
}
{
std::array<int,2> a = {3, 4};
auto obj = dlib::make_from_tuple<multi_args_object>(a);
static_assert(std::is_same<decltype(obj), multi_args_object>::value, "bad type");
DLIB_TEST(obj.i == 3);
DLIB_TEST(obj.j == 4);
}
{
auto obj = dlib::make_from_tuple<multi_args_object>(std::make_pair(5, 6));
static_assert(std::is_same<decltype(obj), multi_args_object>::value, "bad type");
DLIB_TEST(obj.i == 5);
DLIB_TEST(obj.j == 6);
}
}
// ----------------------------------------------------------------------------------------
const char* func_return_c_string()
{
return "hello darkness my old friend";
}
struct obj_return_c_string
{
obj_return_c_string() = default;
obj_return_c_string(const obj_return_c_string& rhs) = delete;
obj_return_c_string(obj_return_c_string&& rhs) = delete;
const char* run()
{
return "i've come to talk with you again";
}
};
void test_invoke_r()
{
{
static_assert(dlib::is_invocable_r<std::string, decltype(func_return_c_string)>::value, "should be invocable");
auto str = dlib::invoke_r<std::string>(func_return_c_string);
static_assert(std::is_same<decltype(str), std::string>::value, "bad return type");
DLIB_TEST(str == "hello darkness my old friend");
}
{
obj_return_c_string obj;
static_assert(dlib::is_invocable_r<std::string, decltype(&obj_return_c_string::run), decltype(obj)>::value, "should be invocable");
auto str = dlib::invoke_r<std::string>(&obj_return_c_string::run, obj);
static_assert(std::is_same<decltype(str), std::string>::value, "bad return type");
DLIB_TEST(str == "i've come to talk with you again");
}
{
obj_return_c_string obj;
static_assert(dlib::is_invocable_r<std::string, decltype(&obj_return_c_string::run), decltype(&obj)>::value, "should be invocable");
auto str = dlib::invoke_r<std::string>(&obj_return_c_string::run, &obj);
static_assert(std::is_same<decltype(str), std::string>::value, "bad return type");
DLIB_TEST(str == "i've come to talk with you again");
}
{
auto obj = std::make_shared<obj_return_c_string>();
static_assert(dlib::is_invocable_r<std::string, decltype(&obj_return_c_string::run), decltype(obj)>::value, "should be invocable");
auto str = dlib::invoke_r<std::string>(&obj_return_c_string::run, obj);
static_assert(std::is_same<decltype(str), std::string>::value, "bad return type");
DLIB_TEST(str == "i've come to talk with you again");
}
{
std::unique_ptr<obj_return_c_string> obj(new obj_return_c_string());
static_assert(dlib::is_invocable_r<std::string, decltype(&obj_return_c_string::run), decltype(obj)>::value, "should be invocable");
auto str = dlib::invoke_r<std::string>(&obj_return_c_string::run, obj);
static_assert(std::is_same<decltype(str), std::string>::value, "bad return type");
DLIB_TEST(str == "i've come to talk with you again");
}
{
auto lambda_return_c_string = [] {
return "because a vision softly creeping";
};
static_assert(dlib::is_invocable_r<std::string, decltype(lambda_return_c_string)>::value, "should be invocable");
auto str = dlib::invoke_r<std::string>(lambda_return_c_string);
static_assert(std::is_same<decltype(str), std::string>::value, "bad return type");
DLIB_TEST(str == "because a vision softly creeping");
}
}
// ----------------------------------------------------------------------------------------
constexpr int multiply_ints(int i, int j)
{
return i*j;
}
struct constexpr_object
{
constexpr int multiply_ints(int i, int j) const
{
return i*j;
}
};
void test_constexpr()
{
static_assert(dlib::invoke(multiply_ints, 2, 5) == 10, "this should be constexpr");
static_assert(dlib::invoke_r<long>(multiply_ints, 2, 5) == 10, "this should be constexpr");
constexpr constexpr_object constexpr_obj;
static_assert(dlib::invoke(&constexpr_object::multiply_ints, constexpr_obj, 2, 5) == 10, "this should be constexpr");
static_assert(dlib::invoke_r<long>(&constexpr_object::multiply_ints, constexpr_obj, 2, 5) == 10, "this should be constexpr");
}
// ----------------------------------------------------------------------------------------
class invoke_tester : public tester
{
public:
invoke_tester(
) : tester("test_invoke",
"Runs tests on dlib::invoke and dlib::apply")
{}
void perform_test(
)
{
test_functions();
test_lambdas();
test_member_functions_and_data();
test_return_types();
test_make_from_tuple();
test_invoke_r();
test_constexpr();
}
} a;
}