test_fixed_string.cpp

Go to the documentation of this file.

#include "gtest/gtest.h"
 
#include <string>
 
#include "kokkos-execution/impl/fixed_string.hpp"

 
namespace Tests::Impl {
 
using Kokkos::Execution::Impl::FixedString;
using namespace std::string_view_literals;

consteval bool test_FixedString_is_fixed_string() {
    static_assert(Kokkos::Execution::Impl::is_fixed_string_v<FixedString<42>>);
    static_assert(!Kokkos::Execution::Impl::is_fixed_string_v<char>);
 
    return true;
}
 
static_assert(test_FixedString_is_fixed_string());

consteval bool test_FixedString_deduces_capacity_from_literal() {
    static_assert(std::same_as<decltype(FixedString{""}), FixedString<1>>);
    static_assert(std::same_as<decltype(FixedString{"a"}), FixedString<2>>);
    static_assert(std::same_as<decltype(FixedString{"ab"}), FixedString<3>>);
    static_assert(std::same_as<decltype(FixedString{"abc"}), FixedString<4>>);
 
    return true;
}
 
static_assert(test_FixedString_deduces_capacity_from_literal());

template <size_t Size>
consteval bool test_FixedString_layout() {
    static_assert(sizeof(FixedString<Size>) == Size);
    static_assert(std::is_trivially_copyable_v<FixedString<Size>>);
    static_assert(std::is_standard_layout_v<FixedString<Size>>);
 
    return true;
}
 
static_assert(test_FixedString_layout<1>());
static_assert(test_FixedString_layout<7>());

consteval bool test_FixedString_is_constructible_from_matching_char_array_only() {
    static_assert(std::is_constructible_v<FixedString<4>, const char (&)[4]>);

    static_assert(!std::is_constructible_v<FixedString<4>, const char (&)[5]>);

    static_assert(!std::is_constructible_v<FixedString<4>, const char*>);
 
    static_assert(!std::is_constructible_v<FixedString<4>, std::string_view>);
    static_assert(!std::is_constructible_v<FixedString<4>, std::string>);
 
    return true;
}
 
static_assert(test_FixedString_is_constructible_from_matching_char_array_only());

consteval bool test_FixedString_from_literal() {
    constexpr FixedString fstr{"label"};
    static_assert(fstr.view() == "label"sv);
    static_assert(fstr.size() == 5);
 
    return true;
}
 
static_assert(test_FixedString_from_literal());

consteval bool test_FixedString_from_empty_literal() {
    constexpr FixedString fstr{""};
    static_assert(fstr.size() == 0);
    static_assert(fstr.view().empty());
    static_assert(fstr.begin() == fstr.end());
 
    return true;
}
 
static_assert(test_FixedString_from_empty_literal());

consteval bool test_view_is_noexcept() {
    static_assert(noexcept(FixedString{"abc"}.view()));
 
    return true;
}
 
static_assert(test_view_is_noexcept());

TEST(FixedStringTest, converts_to_string_view_and_string) {
    static_assert(std::is_constructible_v<std::string_view, const FixedString<6>&>);

    static_assert(std::is_constructible_v<std::string, const FixedString<6>&>);
 
    constexpr FixedString fstr{"label"};
 
    const std::string_view fstr_view = fstr;
    EXPECT_EQ(fstr_view, "label"sv);
    EXPECT_EQ(std::string(fstr), "label");
}
 
template <FixedString S>
struct Tag {
    static constexpr std::string_view value = S.view();
};

consteval bool test_FixedString_is_usable_as_a_template_parameter() {
    static_assert(Tag<"abcd">::value == "abcd"sv);
    static_assert(std::same_as<Tag<"abcd">, Tag<"abcd">>);
    static_assert(!std::same_as<Tag<"abcd">, Tag<"abdc">>);
 
    return true;
}
 
static_assert(test_FixedString_is_usable_as_a_template_parameter());
 
#if defined(__cpp_lib_is_structural)
consteval bool test_FixedString_is_structural() {
    static_assert(std::is_structural_v<FixedString{"abcd"}>);
 
    return true;
}
 
static_assert(test_FixedString_is_structural());
#endif
 
} // namespace Tests::Impl