Gitiles
Code Review Sign In
gerrit.openbmc.org / openbmc / sdeventplus / 8f90e28b500d384fbabcf97119879c7ba3c88724 / . / test / sdref.cpp
blob: 6bb54109c99e05c0878590155a0b7e11a4410861 [file] [log] [blame]
William A. Kennington III8f90e282018-07-17 14:40:14 -0700[diff] [blame^]1#include <gmock/gmock.h>
2#include <gtest/gtest.h>
3#include <sdeventplus/sdevent.hpp>
4#include <sdeventplus/sdref.hpp>
5#include <sdeventplus/test/sdevent.hpp>
6#include <systemd/sd-event.h>
7#include <type_traits>
8#include <utility>
9
10namespace sdeventplus
11{
12namespace
13{
14
15class SdRefTest : public testing::Test
16{
17 protected:
18 sd_event *const expected_event = reinterpret_cast<sd_event *>(1234);
19 sd_event *const expected_event2 = reinterpret_cast<sd_event *>(2345);
20 testing::StrictMock<SdEventMock> mock;
21 testing::StrictMock<SdEventMock> mock2;
22};
23
24TEST_F(SdRefTest, ConstructRef)
25{
26 EXPECT_CALL(mock, sd_event_ref(expected_event))
27 .WillOnce(testing::Return(expected_event));
28 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
29 &SdEventInterface::sd_event_unref, &mock);
30 EXPECT_EQ(expected_event, event.get());
31
32 EXPECT_CALL(mock, sd_event_unref(expected_event))
33 .WillOnce(testing::Return(nullptr));
34}
35
36TEST_F(SdRefTest, ConstructNoRef)
37{
38 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
39 &SdEventInterface::sd_event_unref, std::false_type(),
40 &mock);
41 EXPECT_EQ(expected_event, event.get());
42
43 EXPECT_CALL(mock, sd_event_unref(expected_event))
44 .WillOnce(testing::Return(nullptr));
45}
46
47TEST_F(SdRefTest, CopyConstruct)
48{
49 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
50 &SdEventInterface::sd_event_unref, std::false_type(),
51 &mock);
52 EXPECT_EQ(expected_event, event.get());
53
54 EXPECT_CALL(mock, sd_event_ref(expected_event))
55 .WillOnce(testing::Return(expected_event));
56 SdRef<sd_event> event2(event);
57 EXPECT_EQ(expected_event, event2.get());
58
59 EXPECT_CALL(mock, sd_event_unref(expected_event))
60 .Times(2)
61 .WillRepeatedly(testing::Return(nullptr));
62}
63
64TEST_F(SdRefTest, MoveConstruct)
65{
66 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
67 &SdEventInterface::sd_event_unref, std::false_type(),
68 &mock);
69 EXPECT_EQ(expected_event, event.get());
70
71 SdRef<sd_event> event2(std::move(event));
72 EXPECT_EQ(expected_event, event2.get());
73
74 EXPECT_CALL(mock, sd_event_unref(expected_event))
75 .WillOnce(testing::Return(nullptr));
76}
77
78TEST_F(SdRefTest, CopyAssignOverValid)
79{
80 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
81 &SdEventInterface::sd_event_unref, std::false_type(),
82 &mock);
83 EXPECT_EQ(expected_event, event.get());
84 SdRef<sd_event> event2(expected_event2, &SdEventInterface::sd_event_ref,
85 &SdEventInterface::sd_event_unref, std::false_type(),
86 &mock2);
87 EXPECT_EQ(expected_event2, event2.get());
88
89 EXPECT_CALL(mock2, sd_event_unref(expected_event2))
90 .WillOnce(testing::Return(nullptr));
91 EXPECT_CALL(mock, sd_event_ref(expected_event))
92 .WillOnce(testing::Return(expected_event));
93 event2 = event;
94 EXPECT_EQ(expected_event, event2.get());
95
96 EXPECT_CALL(mock, sd_event_unref(expected_event))
97 .Times(2)
98 .WillRepeatedly(testing::Return(nullptr));
99}
100
101TEST_F(SdRefTest, CopyAssignOverMoved)
102{
103 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
104 &SdEventInterface::sd_event_unref, std::false_type(),
105 &mock);
106 EXPECT_EQ(expected_event, event.get());
107 SdRef<sd_event> event2(expected_event2, &SdEventInterface::sd_event_ref,
108 &SdEventInterface::sd_event_unref, std::false_type(),
109 &mock2);
110 EXPECT_EQ(expected_event2, event2.get());
111 {
112 SdRef<sd_event> event_mover(std::move(event2));
113 EXPECT_EQ(expected_event2, event_mover.get());
114
115 EXPECT_CALL(mock2, sd_event_unref(expected_event2))
116 .WillOnce(testing::Return(nullptr));
117 }
118
119 EXPECT_CALL(mock, sd_event_ref(expected_event))
120 .WillOnce(testing::Return(expected_event));
121 event2 = event;
122 EXPECT_EQ(expected_event, event2.get());
123
124 EXPECT_CALL(mock, sd_event_unref(expected_event))
125 .Times(2)
126 .WillRepeatedly(testing::Return(nullptr));
127}
128
129TEST_F(SdRefTest, CopySelf)
130{
131 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
132 &SdEventInterface::sd_event_unref, std::false_type(),
133 &mock);
134 EXPECT_EQ(expected_event, event.get());
135
136 event = event;
137 EXPECT_CALL(mock, sd_event_unref(expected_event))
138 .WillOnce(testing::Return(nullptr));
139}
140
141TEST_F(SdRefTest, MoveAssignOverValid)
142{
143 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
144 &SdEventInterface::sd_event_unref, std::false_type(),
145 &mock);
146 EXPECT_EQ(expected_event, event.get());
147 SdRef<sd_event> event2(expected_event2, &SdEventInterface::sd_event_ref,
148 &SdEventInterface::sd_event_unref, std::false_type(),
149 &mock2);
150 EXPECT_EQ(expected_event2, event2.get());
151
152 EXPECT_CALL(mock2, sd_event_unref(expected_event2))
153 .WillOnce(testing::Return(nullptr));
154 event2 = std::move(event);
155 EXPECT_EQ(expected_event, event2.get());
156
157 EXPECT_CALL(mock, sd_event_unref(expected_event))
158 .WillOnce(testing::Return(nullptr));
159}
160
161TEST_F(SdRefTest, MoveAssignOverMoved)
162{
163 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
164 &SdEventInterface::sd_event_unref, std::false_type(),
165 &mock);
166 EXPECT_EQ(expected_event, event.get());
167 SdRef<sd_event> event2(expected_event2, &SdEventInterface::sd_event_ref,
168 &SdEventInterface::sd_event_unref, std::false_type(),
169 &mock2);
170 EXPECT_EQ(expected_event2, event2.get());
171 {
172 SdRef<sd_event> event_mover(std::move(event2));
173 EXPECT_EQ(expected_event2, event_mover.get());
174
175 EXPECT_CALL(mock2, sd_event_unref(expected_event2))
176 .WillOnce(testing::Return(nullptr));
177 }
178
179 event2 = std::move(event);
180 EXPECT_EQ(expected_event, event2.get());
181
182 EXPECT_CALL(mock, sd_event_unref(expected_event))
183 .WillOnce(testing::Return(nullptr));
184}
185
186TEST_F(SdRefTest, MoveSelf)
187{
188 SdRef<sd_event> event(expected_event, &SdEventInterface::sd_event_ref,
189 &SdEventInterface::sd_event_unref, std::false_type(),
190 &mock);
191 EXPECT_EQ(expected_event, event.get());
192 event = std::move(event);
193 EXPECT_CALL(mock, sd_event_unref(expected_event))
194 .WillOnce(testing::Return(nullptr));
195}
196
197} // namespace
198} // namespace sdeventplus