cppmp/test/cppmp/cppmp_traits_test.cpp

#include <gtest/gtest.h>

#include <cppmp.h>

using namespace ::testing;
using namespace ::cppmp;

struct test_obj
{
    int test(int);
    double ctest(float, std::string) const;
    static std::string sget();
};

const test_obj& static_fuu()
{
    static const test_obj value;
    return value;
}

decltype(auto) cpp_traits_lambda = [](std::string, int)->bool { return true; };

using type0 = ::cppmp::lambda_traits<decltype(&test_obj::test)>;
using type1 = ::cppmp::lambda_traits<decltype(&test_obj::ctest)>;
using type2 = ::cppmp::lambda_traits<decltype(&test_obj::sget)>;
using type3 = ::cppmp::lambda_traits<std::string(*)(bool)>;
using type4 = ::cppmp::lambda_traits<decltype(cpp_traits_lambda)>;
using type5 = ::cppmp::lambda_traits<decltype(&static_fuu)>;

static_assert(is_same<typename type0::object_type,            test_obj>::value,                         "");
static_assert(is_same<typename type0::return_type,            int>::value,                              "");
static_assert(is_same<typename type0::arguments_type,         std::tuple<int>>::value,                  "");
static_assert(                 type0::is_mutable_v     ==     true,                                     "");
static_assert(                 type0::is_static_v      ==     false,                                    "");
static_assert(                 type0::argument_count_v ==     1,                                        "");

static_assert(is_same<typename type1::object_type,            const test_obj>::value,                   "");
static_assert(is_same<typename type1::return_type,            double>::value,                           "");
static_assert(is_same<typename type1::arguments_type,         std::tuple<float, std::string>>::value,   "");
static_assert(                 type1::is_mutable_v     ==     false,                                    "");
static_assert(                 type1::is_static_v      ==     false,                                    "");
static_assert(                 type1::argument_count_v ==     2,                                        "");

static_assert(is_same<typename type2::object_type,            void>::value,                             "");
static_assert(is_same<typename type2::return_type,            std::string>::value,                      "");
static_assert(is_same<typename type2::arguments_type,         std::tuple<>>::value,                     "");
static_assert(                 type2::is_mutable_v     ==     false,                                    "");
static_assert(                 type2::is_static_v      ==     true,                                     "");
static_assert(                 type2::argument_count_v ==     0,                                        "");

static_assert(is_same<typename type3::object_type,            void>::value,                             "");
static_assert(is_same<typename type3::return_type,            std::string>::value,                      "");
static_assert(is_same<typename type3::arguments_type,         std::tuple<bool>>::value,                 "");
static_assert(                 type3::is_mutable_v     ==     false,                                    "");
static_assert(                 type3::is_static_v      ==     true,                                     "");
static_assert(                 type3::argument_count_v ==     1,                                        "");

static_assert(is_same<typename type4::return_type,            bool>::value,                             "");
static_assert(is_same<typename type4::arguments_type,         std::tuple<std::string, int>>::value,     "");
static_assert(                 type4::is_mutable_v     ==     false,                                    "");
static_assert(                 type4::is_static_v      ==     false,                                    "");
static_assert(                 type4::argument_count_v ==     2,                                        "");

static_assert(is_same<typename type5::return_type,            const test_obj&>::value,                  "");
static_assert(is_same<typename type5::arguments_type,         std::tuple<>>::value,                     "");
static_assert(                 type5::is_mutable_v     ==     false,                                    "");
static_assert(                 type5::is_static_v      ==     true,                                     "");
static_assert(                 type5::argument_count_v ==     0,                                        "");

TEST(cppmp_traits_test, dummy)
{
    (void)cpp_traits_lambda;
}