1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// SPDX-FileCopyrightText: Copyright Contributors to the Kokkos project
#include <cstdlib>
#include <gtest/gtest.h>
#include <Kokkos_Macros.hpp>
#ifdef KOKKOS_ENABLE_EXPERIMENTAL_CXX20_MODULES
import kokkos.core;
#else
#include <Kokkos_Core.hpp>
#endif
#include "KokkosExecutionEnvironmentNeverInitializedFixture.hpp"
namespace {
using ScopeGuard_DeathTest = KokkosExecutionEnvironmentNeverInitialized;
/**
* Test to create a scope guard normally.
*/
TEST_F(ScopeGuard_DeathTest, create) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
// run it in a different process so side effects are not kept
EXPECT_EXIT(
{
{
Kokkos::ScopeGuard guard{};
if (!Kokkos::is_initialized()) std::exit(EXIT_FAILURE);
if (Kokkos::is_finalized()) std::exit(EXIT_FAILURE);
}
if (Kokkos::is_initialized()) std::exit(EXIT_FAILURE);
if (!Kokkos::is_finalized()) std::exit(EXIT_FAILURE);
std::exit(EXIT_SUCCESS);
},
testing::ExitedWithCode(EXIT_SUCCESS), "");
}
/**
* Test to create a scope guard with an argument.
*/
TEST_F(ScopeGuard_DeathTest, create_argument) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
// run it in a different process so side effects are not kept
EXPECT_EXIT(
{
{
Kokkos::InitializationSettings settings{};
Kokkos::ScopeGuard guard{settings};
}
std::exit(EXIT_SUCCESS);
},
testing::ExitedWithCode(EXIT_SUCCESS), "");
}
/**
* Test to create another scope guard when one has been created.
*/
TEST_F(ScopeGuard_DeathTest, create_while_initialize) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
EXPECT_DEATH(
{
Kokkos::ScopeGuard guard1{};
// create a second scope guard while there is one already existing
Kokkos::ScopeGuard guard2{};
},
"Creating a ScopeGuard while Kokkos is initialized");
}
/**
* Test to create a scope guard when initialization has been done manually.
*/
TEST_F(ScopeGuard_DeathTest, create_after_initialize) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
EXPECT_DEATH(
{
Kokkos::initialize();
// create a scope guard after manual initialization
Kokkos::ScopeGuard guard{};
},
"Creating a ScopeGuard while Kokkos is initialized");
}
/**
* Test to create another scope guard when one has been destroyed.
*/
TEST_F(ScopeGuard_DeathTest, create_after_finalize) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
EXPECT_DEATH(
{
{ Kokkos::ScopeGuard guard1{}; }
// create a second scope guard while the first one has been destroyed
// already
Kokkos::ScopeGuard guard2{};
},
"Creating a ScopeGuard after Kokkos was finalized");
}
/**
* Test to destroy a scope guard when finalization has been done manually.
*/
TEST_F(ScopeGuard_DeathTest, destroy_after_finalize) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
EXPECT_DEATH(
{
// create a scope guard and finalize it manually
Kokkos::ScopeGuard guard{};
Kokkos::finalize();
},
"Destroying a ScopeGuard after Kokkos was finalized");
}
/**
* Static tests
*/
// Test scope guard is not copyable.
static_assert(!std::is_copy_assignable_v<Kokkos::ScopeGuard>);
static_assert(!std::is_copy_constructible_v<Kokkos::ScopeGuard>);
// Test scope guard is not movable.
static_assert(!std::is_move_assignable_v<Kokkos::ScopeGuard>);
static_assert(!std::is_move_constructible_v<Kokkos::ScopeGuard>);
} // namespace
|
