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