135 lines
4.5 KiB
C++
135 lines
4.5 KiB
C++
//@HEADER
|
|
// ************************************************************************
|
|
//
|
|
// Kokkos v. 4.0
|
|
// Copyright (2022) National Technology & Engineering
|
|
// Solutions of Sandia, LLC (NTESS).
|
|
//
|
|
// Under the terms of Contract DE-NA0003525 with NTESS,
|
|
// the U.S. Government retains certain rights in this software.
|
|
//
|
|
// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://kokkos.org/LICENSE for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//@HEADER
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <sstream>
|
|
#include <iostream>
|
|
|
|
#include <Kokkos_Core.hpp>
|
|
|
|
namespace Test {
|
|
|
|
void test_is_specialization_of() {
|
|
using Kokkos::Impl::is_specialization_of;
|
|
static_assert(is_specialization_of<Kokkos::pair<float, int>, Kokkos::pair>{},
|
|
"");
|
|
static_assert(!is_specialization_of<Kokkos::View<int*>, Kokkos::pair>{}, "");
|
|
static_assert(is_specialization_of<Kokkos::View<int*>, Kokkos::View>{}, "");
|
|
// NOTE Not removing cv-qualifiers
|
|
static_assert(!is_specialization_of<Kokkos::View<int*> const, Kokkos::View>{},
|
|
"");
|
|
// NOTE Would not compile because Kokkos::Array takes a non-type template
|
|
// parameter
|
|
// static_assert(is_specialization_of<Kokkos::Array<int, 4>, Kokkos::Array>{},
|
|
// "");
|
|
// But this is fine of course
|
|
static_assert(!is_specialization_of<Kokkos::Array<float, 2>, Kokkos::pair>{},
|
|
"");
|
|
}
|
|
|
|
namespace {
|
|
enum Enum { EZero, EOne };
|
|
enum EnumBool : bool { EBFalse, EBTrue };
|
|
enum class ScopedEnum { SEZero, SEOne };
|
|
enum class ScopedEnumShort : short { SESZero, SESOne };
|
|
class Class {};
|
|
|
|
template <typename Base, typename Derived>
|
|
inline constexpr bool is_public_unambiguous_base_of_v =
|
|
std::is_convertible_v<Derived*, Base*> && !std::is_same_v<Derived, Base>;
|
|
} // namespace
|
|
|
|
void test_to_underlying() {
|
|
using Kokkos::Impl::to_underlying;
|
|
|
|
constexpr auto e0 = to_underlying(EZero);
|
|
static_assert(e0 == 0);
|
|
|
|
constexpr auto e1 = to_underlying(EOne);
|
|
static_assert(e1 == 1);
|
|
|
|
constexpr auto eb0 = to_underlying(EBFalse);
|
|
constexpr bool b0 = false;
|
|
static_assert(std::is_same_v<decltype(eb0), decltype(b0)>);
|
|
static_assert(eb0 == b0);
|
|
|
|
constexpr auto eb1 = to_underlying(EBTrue);
|
|
constexpr bool b1 = true;
|
|
static_assert(std::is_same_v<decltype(eb1), decltype(b1)>);
|
|
static_assert(eb1 == b1);
|
|
|
|
constexpr auto se0 = to_underlying(ScopedEnum::SEZero);
|
|
static_assert(se0 == 0);
|
|
|
|
constexpr auto se1 = to_underlying(ScopedEnum::SEOne);
|
|
static_assert(se1 == 1);
|
|
|
|
constexpr auto ses0 = to_underlying(ScopedEnumShort::SESZero);
|
|
constexpr short s0 = 0;
|
|
static_assert(std::is_same_v<decltype(ses0), decltype(s0)>);
|
|
static_assert(ses0 == s0);
|
|
|
|
constexpr auto ses1 = to_underlying(ScopedEnumShort::SESOne);
|
|
constexpr short s1 = 1;
|
|
static_assert(std::is_same_v<decltype(ses1), decltype(s1)>);
|
|
static_assert(ses1 == s1);
|
|
}
|
|
|
|
void test_is_scoped_enum() {
|
|
using Kokkos::Impl::is_scoped_enum;
|
|
using Kokkos::Impl::is_scoped_enum_v;
|
|
|
|
static_assert(!is_scoped_enum<int>{});
|
|
static_assert(!is_scoped_enum<int>::value);
|
|
static_assert(!is_scoped_enum_v<int>);
|
|
static_assert(
|
|
is_public_unambiguous_base_of_v<std::false_type, is_scoped_enum<int>>);
|
|
|
|
static_assert(!is_scoped_enum<Class>{});
|
|
static_assert(!is_scoped_enum<Class>::value);
|
|
static_assert(!is_scoped_enum_v<Class>);
|
|
static_assert(
|
|
is_public_unambiguous_base_of_v<std::false_type, is_scoped_enum<Class>>);
|
|
|
|
static_assert(!is_scoped_enum<Enum>{});
|
|
static_assert(!is_scoped_enum<Enum>::value);
|
|
static_assert(!is_scoped_enum_v<Enum>);
|
|
static_assert(
|
|
is_public_unambiguous_base_of_v<std::false_type, is_scoped_enum<Enum>>);
|
|
|
|
static_assert(!is_scoped_enum<EnumBool>{});
|
|
static_assert(!is_scoped_enum<EnumBool>::value);
|
|
static_assert(!is_scoped_enum_v<EnumBool>);
|
|
static_assert(is_public_unambiguous_base_of_v<std::false_type,
|
|
is_scoped_enum<EnumBool>>);
|
|
|
|
static_assert(is_scoped_enum<ScopedEnum>{});
|
|
static_assert(is_scoped_enum<ScopedEnum>::value);
|
|
static_assert(is_scoped_enum_v<ScopedEnum>);
|
|
static_assert(is_public_unambiguous_base_of_v<std::true_type,
|
|
is_scoped_enum<ScopedEnum>>);
|
|
|
|
static_assert(is_scoped_enum<ScopedEnumShort>{});
|
|
static_assert(is_scoped_enum<ScopedEnumShort>::value);
|
|
static_assert(is_scoped_enum_v<ScopedEnumShort>);
|
|
static_assert(
|
|
is_public_unambiguous_base_of_v<std::true_type,
|
|
is_scoped_enum<ScopedEnumShort>>);
|
|
}
|
|
|
|
} // namespace Test
|