1 #include <gmock/gmock.h> 2 #include <gtest/gtest.h> 3 #include <memory> 4 #include <sdeventplus/event.hpp> 5 #include <sdeventplus/exception.hpp> 6 #include <sdeventplus/test/sdevent.hpp> 7 #include <type_traits> 8 9 namespace sdeventplus 10 { 11 namespace 12 { 13 14 using testing::DoAll; 15 using testing::Return; 16 using testing::SetArgPointee; 17 18 class EventTest : public testing::Test 19 { 20 protected: 21 testing::StrictMock<test::SdEventMock> mock; 22 sd_event* const expected_event = reinterpret_cast<sd_event*>(1234); 23 }; 24 25 TEST_F(EventTest, NewEventRef) 26 { 27 EXPECT_CALL(mock, sd_event_ref(expected_event)) 28 .WillOnce(Return(expected_event)); 29 Event event(expected_event, &mock); 30 EXPECT_EQ(&mock, event.getSdEvent()); 31 EXPECT_EQ(expected_event, event.get()); 32 33 EXPECT_CALL(mock, sd_event_unref(expected_event)).WillOnce(Return(nullptr)); 34 } 35 36 TEST_F(EventTest, NewEventNoRef) 37 { 38 Event event(expected_event, std::false_type(), &mock); 39 EXPECT_EQ(&mock, event.getSdEvent()); 40 EXPECT_EQ(expected_event, event.get()); 41 42 EXPECT_CALL(mock, sd_event_unref(expected_event)).WillOnce(Return(nullptr)); 43 } 44 45 TEST_F(EventTest, GetNewEvent) 46 { 47 EXPECT_CALL(mock, sd_event_new(testing::_)) 48 .WillOnce(DoAll(SetArgPointee<0>(expected_event), Return(0))); 49 Event event = Event::get_new(&mock); 50 EXPECT_EQ(&mock, event.getSdEvent()); 51 EXPECT_EQ(expected_event, event.get()); 52 53 EXPECT_CALL(mock, sd_event_unref(expected_event)).WillOnce(Return(nullptr)); 54 } 55 56 TEST_F(EventTest, GetNewEventFail) 57 { 58 EXPECT_CALL(mock, sd_event_new(testing::_)).WillOnce(Return(-EINVAL)); 59 EXPECT_THROW(Event::get_new(&mock), SdEventError); 60 } 61 62 TEST_F(EventTest, GetDefaultEvent) 63 { 64 EXPECT_CALL(mock, sd_event_default(testing::_)) 65 .WillOnce(DoAll(SetArgPointee<0>(expected_event), Return(0))); 66 Event event = Event::get_default(&mock); 67 EXPECT_EQ(&mock, event.getSdEvent()); 68 EXPECT_EQ(expected_event, event.get()); 69 70 EXPECT_CALL(mock, sd_event_unref(expected_event)).WillOnce(Return(nullptr)); 71 } 72 73 TEST_F(EventTest, GetDefaultEventFail) 74 { 75 EXPECT_CALL(mock, sd_event_default(testing::_)).WillOnce(Return(-EINVAL)); 76 EXPECT_THROW(Event::get_default(&mock), SdEventError); 77 } 78 79 class EventMethodTest : public EventTest 80 { 81 protected: 82 std::unique_ptr<Event> event; 83 84 void SetUp() 85 { 86 event = 87 std::make_unique<Event>(expected_event, std::false_type(), &mock); 88 } 89 90 void TearDown() 91 { 92 EXPECT_CALL(mock, sd_event_unref(expected_event)) 93 .WillOnce(Return(nullptr)); 94 } 95 }; 96 97 TEST_F(EventMethodTest, PrepareSuccessNone) 98 { 99 EXPECT_CALL(mock, sd_event_prepare(expected_event)).WillOnce(Return(0)); 100 EXPECT_EQ(0, event->prepare()); 101 } 102 103 TEST_F(EventMethodTest, PrepareSuccessReady) 104 { 105 const int events_ready = 10; 106 EXPECT_CALL(mock, sd_event_prepare(expected_event)) 107 .WillOnce(Return(events_ready)); 108 EXPECT_EQ(events_ready, event->prepare()); 109 } 110 111 TEST_F(EventMethodTest, PrepareInternalError) 112 { 113 EXPECT_CALL(mock, sd_event_prepare(expected_event)) 114 .WillOnce(Return(-EINVAL)); 115 EXPECT_THROW(event->prepare(), SdEventError); 116 } 117 118 TEST_F(EventMethodTest, WaitSuccessNone) 119 { 120 const std::chrono::microseconds timeout{20}; 121 EXPECT_CALL(mock, sd_event_wait(expected_event, timeout.count())) 122 .WillOnce(Return(0)); 123 EXPECT_EQ(0, event->wait(timeout)); 124 } 125 126 TEST_F(EventMethodTest, WaitSuccessReady) 127 { 128 const int events_ready = 10; 129 EXPECT_CALL(mock, sd_event_wait(expected_event, static_cast<uint64_t>(-1))) 130 .WillOnce(Return(events_ready)); 131 EXPECT_EQ(events_ready, event->wait(std::experimental::nullopt)); 132 } 133 134 TEST_F(EventMethodTest, WaitInternalError) 135 { 136 EXPECT_CALL(mock, sd_event_wait(expected_event, static_cast<uint64_t>(-1))) 137 .WillOnce(Return(-EINVAL)); 138 EXPECT_THROW(event->wait(std::experimental::nullopt), SdEventError); 139 } 140 141 TEST_F(EventMethodTest, DispatchInitial) 142 { 143 EXPECT_CALL(mock, sd_event_dispatch(expected_event)).WillOnce(Return(0)); 144 EXPECT_EQ(0, event->dispatch()); 145 } 146 147 TEST_F(EventMethodTest, DispatchDone) 148 { 149 const int done_code = 10; 150 EXPECT_CALL(mock, sd_event_dispatch(expected_event)) 151 .WillOnce(Return(done_code)); 152 EXPECT_EQ(done_code, event->dispatch()); 153 } 154 155 TEST_F(EventMethodTest, DispatchInternalError) 156 { 157 EXPECT_CALL(mock, sd_event_dispatch(expected_event)) 158 .WillOnce(Return(-EINVAL)); 159 EXPECT_THROW(event->dispatch(), SdEventError); 160 } 161 162 TEST_F(EventMethodTest, RunSuccessNone) 163 { 164 const std::chrono::microseconds timeout{20}; 165 EXPECT_CALL(mock, sd_event_run(expected_event, timeout.count())) 166 .WillOnce(Return(0)); 167 EXPECT_EQ(0, event->run(timeout)); 168 } 169 170 TEST_F(EventMethodTest, RunSuccessReady) 171 { 172 const int events_ready = 10; 173 EXPECT_CALL(mock, sd_event_run(expected_event, static_cast<uint64_t>(-1))) 174 .WillOnce(Return(events_ready)); 175 EXPECT_EQ(events_ready, event->run(std::experimental::nullopt)); 176 } 177 178 TEST_F(EventMethodTest, RunInternalError) 179 { 180 EXPECT_CALL(mock, sd_event_run(expected_event, static_cast<uint64_t>(-1))) 181 .WillOnce(Return(-EINVAL)); 182 EXPECT_THROW(event->run(std::experimental::nullopt), SdEventError); 183 } 184 185 TEST_F(EventMethodTest, LoopSuccess) 186 { 187 EXPECT_CALL(mock, sd_event_loop(expected_event)).WillOnce(Return(0)); 188 EXPECT_EQ(0, event->loop()); 189 } 190 191 TEST_F(EventMethodTest, LoopUserError) 192 { 193 const int user_error = 10; 194 EXPECT_CALL(mock, sd_event_loop(expected_event)) 195 .WillOnce(Return(user_error)); 196 EXPECT_EQ(user_error, event->loop()); 197 } 198 199 TEST_F(EventMethodTest, LoopInternalError) 200 { 201 EXPECT_CALL(mock, sd_event_loop(expected_event)).WillOnce(Return(-EINVAL)); 202 EXPECT_THROW(event->loop(), SdEventError); 203 } 204 205 TEST_F(EventMethodTest, ExitSuccess) 206 { 207 EXPECT_CALL(mock, sd_event_exit(expected_event, 0)).WillOnce(Return(2)); 208 event->exit(0); 209 EXPECT_CALL(mock, sd_event_exit(expected_event, 0)).WillOnce(Return(0)); 210 event->exit(0); 211 EXPECT_CALL(mock, sd_event_exit(expected_event, 10)).WillOnce(Return(0)); 212 event->exit(10); 213 } 214 215 TEST_F(EventMethodTest, ExitInternalError) 216 { 217 EXPECT_CALL(mock, sd_event_exit(expected_event, 5)) 218 .WillOnce(Return(-EINVAL)); 219 EXPECT_THROW(event->exit(5), SdEventError); 220 } 221 222 TEST_F(EventMethodTest, GetExitCodeSuccess) 223 { 224 EXPECT_CALL(mock, sd_event_get_exit_code(expected_event, testing::_)) 225 .WillOnce(DoAll(SetArgPointee<1>(1), Return(0))); 226 EXPECT_EQ(1, event->get_exit_code()); 227 228 EXPECT_CALL(mock, sd_event_get_exit_code(expected_event, testing::_)) 229 .WillOnce(DoAll(SetArgPointee<1>(0), Return(2))); 230 EXPECT_EQ(0, event->get_exit_code()); 231 } 232 233 TEST_F(EventMethodTest, GetExitCodeError) 234 { 235 EXPECT_CALL(mock, sd_event_get_exit_code(expected_event, testing::_)) 236 .WillOnce(Return(-EINVAL)); 237 EXPECT_THROW(event->get_exit_code(), SdEventError); 238 } 239 240 TEST_F(EventMethodTest, GetWatchdogSuccess) 241 { 242 EXPECT_CALL(mock, sd_event_get_watchdog(expected_event)) 243 .WillOnce(Return(0)); 244 EXPECT_FALSE(event->get_watchdog()); 245 246 EXPECT_CALL(mock, sd_event_get_watchdog(expected_event)) 247 .WillOnce(Return(2)); 248 EXPECT_TRUE(event->get_watchdog()); 249 } 250 251 TEST_F(EventMethodTest, GetWatchdogError) 252 { 253 EXPECT_CALL(mock, sd_event_get_watchdog(expected_event)) 254 .WillOnce(Return(-EINVAL)); 255 EXPECT_THROW(event->get_watchdog(), SdEventError); 256 } 257 258 TEST_F(EventMethodTest, SetWatchdogSuccess) 259 { 260 // Disable 261 EXPECT_CALL(mock, sd_event_set_watchdog(expected_event, false)) 262 .WillOnce(Return(0)); 263 EXPECT_FALSE(event->set_watchdog(false)); 264 265 // Enable but not supported 266 EXPECT_CALL(mock, sd_event_set_watchdog(expected_event, true)) 267 .WillOnce(Return(0)); 268 EXPECT_FALSE(event->set_watchdog(true)); 269 270 // Enabled and supported 271 EXPECT_CALL(mock, sd_event_set_watchdog(expected_event, true)) 272 .WillOnce(Return(2)); 273 EXPECT_TRUE(event->set_watchdog(true)); 274 } 275 276 TEST_F(EventMethodTest, SetWatchdogError) 277 { 278 EXPECT_CALL(mock, sd_event_set_watchdog(expected_event, 1)) 279 .WillOnce(Return(-EINVAL)); 280 EXPECT_THROW(event->set_watchdog(1), SdEventError); 281 } 282 283 } // namespace 284 } // namespace sdeventplus 285