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
|
//===-- SubsystemRAIITest.cpp -----------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "gtest/gtest-spi.h"
#include "gtest/gtest.h"
#include "TestingSupport/SubsystemRAII.h"
using namespace lldb_private;
namespace {
enum class SystemState {
/// Start state of the subsystem.
Start,
/// Initialize has been called but Terminate hasn't been called yet.
Initialized,
/// Terminate has been called.
Terminated
};
struct TestSubsystem {
static SystemState state;
static void Initialize() {
assert(state == SystemState::Start);
state = SystemState::Initialized;
}
static void Terminate() {
assert(state == SystemState::Initialized);
state = SystemState::Terminated;
}
};
} // namespace
SystemState TestSubsystem::state = SystemState::Start;
TEST(SubsystemRAIITest, NormalSubsystem) {
// Tests that SubsystemRAII handles Initialize functions that return void.
EXPECT_EQ(SystemState::Start, TestSubsystem::state);
{
SubsystemRAII<TestSubsystem> subsystem;
EXPECT_EQ(SystemState::Initialized, TestSubsystem::state);
}
EXPECT_EQ(SystemState::Terminated, TestSubsystem::state);
}
static const char *SubsystemErrorString = "Initialize failed";
namespace {
struct TestSubsystemWithError {
static SystemState state;
static bool will_fail;
static llvm::Error Initialize() {
assert(state == SystemState::Start);
state = SystemState::Initialized;
if (will_fail)
return llvm::make_error<llvm::StringError>(
SubsystemErrorString, llvm::inconvertibleErrorCode());
return llvm::Error::success();
}
static void Terminate() {
assert(state == SystemState::Initialized);
state = SystemState::Terminated;
}
/// Reset the subsystem to the default state for testing.
static void Reset() { state = SystemState::Start; }
};
} // namespace
SystemState TestSubsystemWithError::state = SystemState::Start;
bool TestSubsystemWithError::will_fail = false;
TEST(SubsystemRAIITest, SubsystemWithErrorSuccess) {
// Tests that SubsystemRAII handles llvm::success() returned from
// Initialize.
TestSubsystemWithError::Reset();
EXPECT_EQ(SystemState::Start, TestSubsystemWithError::state);
{
TestSubsystemWithError::will_fail = false;
SubsystemRAII<TestSubsystemWithError> subsystem;
EXPECT_EQ(SystemState::Initialized, TestSubsystemWithError::state);
}
EXPECT_EQ(SystemState::Terminated, TestSubsystemWithError::state);
}
TEST(SubsystemRAIITest, SubsystemWithErrorFailure) {
// Tests that SubsystemRAII handles any errors returned from
// Initialize.
TestSubsystemWithError::Reset();
EXPECT_EQ(SystemState::Start, TestSubsystemWithError::state);
TestSubsystemWithError::will_fail = true;
EXPECT_FATAL_FAILURE(SubsystemRAII<TestSubsystemWithError> subsystem,
SubsystemErrorString);
}
|
