Compiler Explorer

Source code

#include <https://raw.githubusercontent.com/reacfen/uninttp/main/uninttp/uni_auto.hpp>
#include <gtest/gtest.h>
#include <string_view>
#include <type_traits>
#include <string>

using namespace uninttp;

template <uni_auto Value>
auto fun() -> uni_auto_t<Value>;

using number_type = int;

number_type global_object {};
number_type global_array[4] {};

void some_fun() {}

struct some_class {
    number_type mem_var {};
    void mem_fun() {}
};

some_class global_inst;

enum class some_enum { some_value };

TEST(main_tests, works_with_arrays) {
    constexpr number_type arr1[4] {};
    constexpr some_class arr2[4] {};
    constexpr number_type* arr3[4] {};
    constexpr some_class* arr4[4] {};
    constexpr void(*arr5[4])() {};

static constexpr number_type arr6[4] {};
    static constexpr some_class arr7[4] {};
    static constexpr number_type* arr8[4] {};
    static constexpr some_class* arr9[4] {};
    static constexpr void(*arr10[4])() {};

static_assert(std::is_same_v<decltype(fun<arr1>()), const number_type(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr2>()), const some_class(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr3>()), number_type *const(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr4>()), some_class *const(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr5>()), void (*const (&)[4])()>);

static_assert(std::is_same_v<decltype(fun<arr6>()), const number_type(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr7>()), const some_class(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr8>()), number_type *const(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr9>()), some_class *const(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<arr10>()), void (*const (&)[4])()>);
}

TEST(main_tests, works_with_strings) {
    static_assert(std::is_same_v<decltype(fun<"some string">()), decltype("some string")&>);
    static_assert(std::is_same_v<decltype(fun<L"some string">()), decltype(L"some string")&>);
    static_assert(std::is_same_v<decltype(fun<u8"some string">()), decltype(u8"some string")&>);
    static_assert(std::is_same_v<decltype(fun<u"some string">()), decltype(u"some string")&>);
    static_assert(std::is_same_v<decltype(fun<U"some string">()), decltype(U"some string")&>);

static auto str1 = "some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str1>>()), const char*&>);

static constexpr auto str2 = "some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str2>>()), const char *const&>);

static std::string str3 = "some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str3>>()), std::string&>);

static const std::string str4 = "some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str4>>()), const std::string&>);

static std::string_view str5 = "some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str5>>()), std::string_view&>);

static constexpr std::string_view str6 = "some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str6>>()), const std::string_view&>);

/////////////////////////////////////////

static auto str7 = L"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str7>>()), const wchar_t*&>);

static constexpr auto str8 = L"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str8>>()), const wchar_t *const&>);

static std::wstring str9 = L"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str9>>()), std::wstring&>);

static const std::wstring str10 = L"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str10>>()), const std::wstring&>);

static std::wstring_view str11 = L"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str11>>()), std::wstring_view&>);

static constexpr std::wstring_view str12 = L"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str12>>()), const std::wstring_view&>);

/////////////////////////////////////////

static auto str13 = u8"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str13>>()), const char8_t*&>);

static constexpr auto str14 = u8"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str14>>()), const char8_t *const&>);

static std::u8string str15 = u8"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str15>>()), std::u8string&>);

static const std::u8string str16 = u8"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str16>>()), const std::u8string&>);

static std::u8string_view str17 = u8"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str17>>()), std::u8string_view&>);

static constexpr std::u8string_view str18 = u8"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str18>>()), const std::u8string_view&>);static auto str19 = u"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str19>>()), const char16_t*&>);

/////////////////////////////////////////

static constexpr auto str20 = u"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str20>>()), const char16_t *const&>);

static std::u16string str21 = u"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str21>>()), std::u16string&>);

static const std::u16string str22 = u"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str22>>()), const std::u16string&>);

static std::u16string_view str23 = u"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str23>>()), std::u16string_view&>);

static constexpr std::u16string_view str24 = u"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str24>>()), const std::u16string_view&>);

/////////////////////////////////////////

static constexpr auto str25 = U"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str25>>()), const char32_t *const&>);

static std::u32string str26 = U"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str26>>()), std::u32string&>);

static const std::u32string str27 = U"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str27>>()), const std::u32string&>);

static std::u32string_view str28 = U"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str28>>()), std::u32string_view&>);

static constexpr std::u32string_view str29 = U"some string";
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<str29>>()), const std::u32string_view&>);
}

TEST(main_tests, works_with_lvalue_references) {
    static some_class global_class_obj;
    static some_class global_class_array[4] {};
    static some_class* global_class_pointer = global_class_array;
    static number_type* global_pointer = global_array;

static_assert(std::is_same_v<decltype(fun<promote_to_ref<global_class_obj>>()), some_class&>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<global_class_array>>()), some_class(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<global_class_pointer>>()), some_class*&>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<global_array>>()), number_type(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<global_object>>()), number_type&>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<global_pointer>>()), number_type*&>);

static number_type arr1[4] {};
    static some_class arr2[4] {};
    static number_type* arr3[4] {};
    static some_class* arr4[4] {};
    static void(*arr5[4])() {};

static_assert(std::is_same_v<decltype(fun<promote_to_ref<arr1>>()), number_type(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<arr2>>()), some_class(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<arr3>>()), number_type*(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<arr4>>()), some_class*(&)[4]>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<arr5>>()), void (*(&)[4])()>);
}

TEST(main_tests, works_with_integral_types) {
    static_assert(std::is_same_v<decltype(fun<static_cast<short>(1)>()), short>);
    static_assert(std::is_same_v<decltype(fun<false>()), bool>);
    static_assert(std::is_same_v<decltype(fun<'A'>()), char>);
    static_assert(std::is_same_v<decltype(fun<static_cast<signed char>('F')>()), signed char>);
    static_assert(std::is_same_v<decltype(fun<static_cast<unsigned char>('G')>()), unsigned char>);
    static_assert(std::is_same_v<decltype(fun<L'B'>()), wchar_t>);
    static_assert(std::is_same_v<decltype(fun<static_cast<char8_t>('C')>()), char8_t>);
    static_assert(std::is_same_v<decltype(fun<static_cast<char16_t>('D')>()), char16_t>);
    static_assert(std::is_same_v<decltype(fun<static_cast<char32_t>('E')>()), char32_t>);
    static_assert(std::is_same_v<decltype(fun<2>()), int>);
    static_assert(std::is_same_v<decltype(fun<3l>()), long>);
    static_assert(std::is_same_v<decltype(fun<4ll>()), long long>);
    static_assert(std::is_same_v<decltype(fun<static_cast<unsigned short>(1)>()), unsigned short>);
    static_assert(std::is_same_v<decltype(fun<2u>()), unsigned>);
    static_assert(std::is_same_v<decltype(fun<3ul>()), unsigned long>);
    static_assert(std::is_same_v<decltype(fun<4ull>()), unsigned long long>);
    static_assert(std::is_same_v<decltype(fun<1.0>()), double>);
    static_assert(std::is_same_v<decltype(fun<2.0f>()), float>);
}

TEST(main_tests, works_with_pointer_to_objects) {
    static_assert(std::is_same_v<decltype(fun<&global_array>()), number_type(*)[4]>);
    static_assert(std::is_same_v<decltype(fun<&global_object>()), number_type*>);

constexpr auto p1 = global_array;
    static_assert(std::is_same_v<decltype(fun<p1>()), number_type*>);

constexpr auto p2 = &global_object;
    static_assert(std::is_same_v<decltype(fun<p2>()), number_type*>);

static auto p3 = global_array;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<p3>>()), number_type*&>);

static auto p4 = &global_object;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<p4>>()), number_type*&>);

static constexpr auto p5 = global_array;
    static_assert(std::is_same_v<decltype(fun<p5>()), number_type *>);

static constexpr auto p6 = &global_object;
    static_assert(std::is_same_v<decltype(fun<p6>()), number_type *>);

constexpr auto p7 = &global_inst;
    static_assert(std::is_same_v<decltype(fun<p7>()), some_class*>);

static auto p8 = &global_inst;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<p8>>()), some_class*&>);

static constexpr auto p9 = &global_inst;
    static_assert(std::is_same_v<decltype(fun<p9>()), some_class*>);
}

TEST(main_tests, works_with_function_pointers) {
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<some_fun>>()), void(&)()>);
    static_assert(std::is_same_v<decltype(fun<&some_fun>()), void(*)()>);

constexpr auto fun1 = some_fun;
    static_assert(std::is_same_v<decltype(fun<fun1>()), void(*)()>);

static auto fun2 = some_fun;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<fun2>>()), void(*&)()>);

static constexpr auto fun3 = some_fun;
    static_assert(std::is_same_v<decltype(fun<fun3>()), void(*)()>);

constexpr auto fun4 = &some_fun;
    static_assert(std::is_same_v<decltype(fun<fun4>()), void(*)()>);

static auto fun5 = &some_fun;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<fun5>>()), void(*&)()>);

static constexpr auto fun6 = &some_fun;
    static_assert(std::is_same_v<decltype(fun<fun6>()), void(*)()>);
}

TEST(main_tests, works_with_pointer_to_member_objects) {
    static_assert(std::is_same_v<decltype(fun<&some_class::mem_var>()), number_type some_class::*>);

constexpr auto mem_obj1 = &some_class::mem_var;
    static_assert(std::is_same_v<decltype(fun<mem_obj1>()), number_type some_class::*>);

static auto mem_obj2 = &some_class::mem_var;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<mem_obj2>>()), number_type some_class::*&>);

static constexpr auto mem_obj3 = &some_class::mem_var;
    static_assert(std::is_same_v<decltype(fun<mem_obj3>()), number_type some_class::*>);
}

TEST(main_tests, works_with_pointer_to_member_functions) {
    static_assert(std::is_same_v<decltype(fun<&some_class::mem_fun>()), void(some_class::*)()>);

constexpr auto mem_fun1 = &some_class::mem_fun;
    static_assert(std::is_same_v<decltype(fun<mem_fun1>()), void(some_class::*)()>);

static auto mem_fun2 = &some_class::mem_fun;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<mem_fun2>>()), void(some_class::*&)()>);

static constexpr auto mem_fun3 = &some_class::mem_fun;
    static_assert(std::is_same_v<decltype(fun<mem_fun3>()), void(some_class::*)()>);
}

TEST(main_tests, works_with_enumeration_types) {
    static_assert(std::is_same_v<decltype(fun<some_enum::some_value>()), some_enum>);

constexpr auto e1 = some_enum::some_value;
    static_assert(std::is_same_v<decltype(fun<e1>()), some_enum>);

static auto e2 = some_enum::some_value;
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<e2>>()), some_enum&>);

static constexpr auto e3 = some_enum::some_value;
    static_assert(std::is_same_v<decltype(fun<e3>()), some_enum>);
}

TEST(main_tests, works_with_nullptr) {
    static_assert(std::is_same_v<decltype(fun<nullptr>()), std::nullptr_t>);

constexpr auto n1 = nullptr;
    static_assert(std::is_same_v<decltype(fun<n1>()), std::nullptr_t>);

static auto n2 = nullptr;
    static_assert(std::is_same_v<decltype(fun<n2>()), std::nullptr_t>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<n2>>()), std::nullptr_t&>);

static constexpr auto n3 = nullptr;
    static_assert(std::is_same_v<decltype(fun<n3>()), std::nullptr_t>);
}

TEST(main_tests, works_with_classes) {
    static_assert(std::is_same_v<decltype(fun<some_class{}>()), some_class>);

constexpr auto obj1 = some_class{};
    static_assert(std::is_same_v<decltype(fun<obj1>()), some_class>);

static auto obj2 = some_class{};
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<obj2>>()), some_class&>);

static constexpr auto obj3 = some_class{};
    static_assert(std::is_same_v<decltype(fun<obj3>()), some_class>);
}

TEST(main_tests, works_with_functors) {
    constexpr auto f1 = [] {};
    static_assert(std::is_same_v<decltype(fun<f1>()), std::remove_const_t<decltype(f1)>>);

static auto f2 = [] {};
    static_assert(std::is_same_v<decltype(fun<f2>()), decltype(f2)>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<f2>>()), decltype(f2)&>);

static constexpr auto f3 = [] {};
    static_assert(std::is_same_v<decltype(fun<f3>()), std::remove_const_t<decltype(f3)>>);

struct Funct {
        void operator()() const {}
    };
    static_assert(std::is_same_v<decltype(fun<Funct{}>()), Funct>);

constexpr auto funct1 = Funct{};
    static_assert(std::is_same_v<decltype(fun<funct1>()), Funct>);

static auto funct2 = Funct{};
    static_assert(std::is_same_v<decltype(fun<funct2>()), Funct>);
    static_assert(std::is_same_v<decltype(fun<promote_to_ref<funct2>>()), Funct&>);

static constexpr auto funct3 = Funct{};
    static_assert(std::is_same_v<decltype(fun<funct3>()), Funct>);
}

int main(int argc, char* argv[]) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}