From 40d254a53bd56a5104205cae2316a5f024f12c55 Mon Sep 17 00:00:00 2001 From: anton Date: Mon, 18 Mar 2024 17:40:02 +0300 Subject: [PATCH 01/13] TimedDoor.h edited --- README.md | 4 ++-- include/TimedDoor.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index f19f864..19caea0 100644 --- a/README.md +++ b/README.md @@ -44,13 +44,13 @@ class TimedDoor : public Door { private: DoorTimerAdapter * adapter; int iTimeout; - bool opened; + bool isOpened; public: explicit TimedDoor(int); bool isDoorOpened(); void unlock(); void lock(); - void DoorTimeOut(); + int getTimeOut(); void throwState(); }; diff --git a/include/TimedDoor.h b/include/TimedDoor.h index e1eade2..04429ad 100644 --- a/include/TimedDoor.h +++ b/include/TimedDoor.h @@ -32,13 +32,13 @@ class TimedDoor : public Door { private: DoorTimerAdapter * adapter; int iTimeout; - bool opened; + bool isOpened; public: explicit TimedDoor(int); bool isDoorOpened(); void unlock(); void lock(); - void DoorTimeOut(); + int getTimeOut() const; void throwState(); }; From 6b9f506ef78c63d4e9aa3ecd5e2b1febb3b3bfc8 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Sun, 7 Apr 2024 11:44:39 +0300 Subject: [PATCH 02/13] 1 --- .gitmodules | 3 ++ CMakeLists.txt | 9 ++++++ include/TimedDoor.h | 4 +-- src/TimedDoor.cpp | 53 +++++++++++++++++++++++++++++++ test/tests.cpp | 77 ++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 143 insertions(+), 3 deletions(-) create mode 100644 .gitmodules create mode 100644 src/TimedDoor.cpp diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..cca15d8 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "googletest"] + path = googletest + url = https://github.com/google/googletest.git \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 36758e8..d37da18 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,5 +9,14 @@ set(tool_dest "bin") set(lib_dest "lib") set(include_dest "include/") +include(FetchContent) +FetchContent_Declare( + googletest + GIT_REPOSITORY https://github.com/google/googletest.git + GIT_TAG release-1.10.0 +) +FetchContent_MakeAvailable(googletest) + + add_subdirectory(src) add_subdirectory(test) diff --git a/include/TimedDoor.h b/include/TimedDoor.h index 04429ad..b94e13c 100644 --- a/include/TimedDoor.h +++ b/include/TimedDoor.h @@ -1,4 +1,4 @@ -// Copyright 2021 GHA Test Team +// Copyright 2024 Saratova Marina #ifndef INCLUDE_TIMEDDOOR_H_ #define INCLUDE_TIMEDDOOR_H_ @@ -24,7 +24,7 @@ class DoorTimerAdapter : public TimerClient { private: TimedDoor& door; public: - explicit DoorTimerAdapter(TimedDoor&); + explicit DoorTimerAdapter(TimedDoor &); void Timeout(); }; diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp new file mode 100644 index 0000000..9cef65a --- /dev/null +++ b/src/TimedDoor.cpp @@ -0,0 +1,53 @@ +// Copyright 2024 Saratova Marina + +#include +#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] + +#include "TimedDoor.h" + +DoorTimerAdapter::DoorTimerAdapter(TimedDoor & door_) : door(door_) {} + +void DoorTimerAdapter::Timeout() { + if (door.isDoorOpened()) + throw std::runtime_error("Time's up!"); + return; +} + +TimedDoor::TimedDoor(int timeout_) : iTimeout(timeout_), isOpened(false) { + adapter = new DoorTimerAdapter(*this); +} + +bool TimedDoor::isDoorOpened() { + return isOpened; +} + +void TimedDoor::unlock() { + if (isOpened) + throw std::logic_error("Door is open!!!"); + isOpened = true; +} + +void TimedDoor::lock() { + if (!isOpened) + throw std::logic_error("Door is close!!!"); + isOpened = false; +} + +int TimedDoor::getTimeOut() const { + return iTimeout; +} + +void TimedDoor::throwState() { + adapter->Timeout(); +} + +void Timer::sleep(int time_) { + std::this_thread::sleep_for(std::chrono::seconds(time_)); +} + +void Timer::tregister(int time_, TimerClient* client_) { + this->client = client_; + sleep(time_); + client_->Timeout(); +} \ No newline at end of file diff --git a/test/tests.cpp b/test/tests.cpp index 605e570..1c16d8a 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -1,6 +1,81 @@ -// Copyright 2021 GHA Test Team +// Copyright 2024 Saratova Marina #include #include #include +#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] + #include "TimedDoor.h" + +class MockTimerClient : public TimerClient { + public: + MOCK_METHOD(void, Timeout, (), (override)); +}; + +class TimedDoorTest : public ::testing::Test { + protected: + TimedDoor door; + MockTimerClient mockClient; + Timer timer; + + TimedDoorTest() : door(1), timer() {} + + void SetUp() override { + timer.tregister(door.getTimeOut(), &mockClient); + } + + void TearDown() override { + testing::Mock::VerifyAndClearExpectations(&mockClient); + } +}; + +TEST_F(TimedDoorTest, testing_id_door_open_method) { + EXPECT_FALSE(door.isDoorOpened()); +} + +TEST_F(TimedDoorTest, testing_close_door_method) { + door.unlock(); + door.lock(); + EXPECT_FALSE(door.isDoorOpened()); +} + +TEST_F(TimedDoorTest, testing_unlock_door_method) { + door.unlock(); + EXPECT_TRUE(door.isDoorOpened()); +} + +TEST_F(TimedDoorTest, testing_try_to_open_door_second_time) { + door.unlock(); + EXPECT_THROW(door.unlock(), std::logic_error); +} + +TEST_F(TimedDoorTest, testing_lock_door_after_unlock_timeout) { + std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut() + 1)); + EXPECT_NO_THROW(door.throwState()); +} + +TEST_F(TimedDoorTest, testing_lock_before_timeout_then_open_throw) { + std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut() + 1)); + door.unlock(); + EXPECT_THROW(door.throwState(), std::runtime_error); +} + +TEST_F(TimedDoorTest, testing_unlock_door_then_timeout_exception) { + door.unlock(); + std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut())); + EXPECT_THROW(door.throwState(), std::runtime_error); +} + +TEST_F(TimedDoorTest, testing_try_to_close_door_second_time) { + EXPECT_THROW(door.lock(), std::logic_error); +} + +TEST_F(TimedDoorTest, testing_open_exception) { + door.unlock(); + EXPECT_THROW(door.throwState(), std::runtime_error); +} + +TEST_F(TimedDoorTest, testing_close_timeout) { + EXPECT_NO_THROW(door.throwState()); +} From 6676b081e302cf3529ff3088f6d72a0c2a6c8d55 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Sun, 7 Apr 2024 11:53:01 +0300 Subject: [PATCH 03/13] 2 --- src/TimedDoor.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index 9cef65a..9ad9b6d 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -50,4 +50,4 @@ void Timer::tregister(int time_, TimerClient* client_) { this->client = client_; sleep(time_); client_->Timeout(); -} \ No newline at end of file +} From 4c7ec78242de08f6a65efa328092edd8fec6ae12 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 14:30:57 +0300 Subject: [PATCH 04/13] fix --- include/TimedDoor.h | 44 +++++++++---------- src/TimedDoor.cpp | 53 +++++++++++------------ test/tests.cpp | 103 +++++++++++++++++++++++++++++++------------- 3 files changed, 120 insertions(+), 80 deletions(-) diff --git a/include/TimedDoor.h b/include/TimedDoor.h index b94e13c..e127f91 100644 --- a/include/TimedDoor.h +++ b/include/TimedDoor.h @@ -3,50 +3,48 @@ #ifndef INCLUDE_TIMEDDOOR_H_ #define INCLUDE_TIMEDDOOR_H_ -class DoorTimerAdapter; -class Timer; -class Door; -class TimedDoor; - class TimerClient { public: - virtual void Timeout() = 0; + virtual void onTimeout() = 0; }; class Door { public: virtual void lock() = 0; virtual void unlock() = 0; - virtual bool isDoorOpened() = 0; + virtual bool isOpen() const = 0; }; -class DoorTimerAdapter : public TimerClient { +class TimedDoor; + +class DoorTimeoutAdapter : public TimerClient { private: - TimedDoor& door; + TimedDoor& door_; public: - explicit DoorTimerAdapter(TimedDoor &); - void Timeout(); + explicit DoorTimeoutAdapter(TimedDoor &door); + void onTimeout() override; }; class TimedDoor : public Door { private: - DoorTimerAdapter * adapter; - int iTimeout; - bool isOpened; + DoorTimeoutAdapter* adapter_; + int timeout_; + bool isOpen_; public: - explicit TimedDoor(int); - bool isDoorOpened(); - void unlock(); - void lock(); - int getTimeOut() const; - void throwState(); + explicit TimedDoor(int timeout); + bool isOpen() const override; + void unlock() override; + void lock() override; + int getTimeout() const; + void checkState(); }; class Timer { - TimerClient *client; - void sleep(int); + private: + TimerClient* client_; + void sleepFor(int seconds); public: - void tregister(int, TimerClient*); + void registerClient(int seconds, TimerClient* client); }; #endif // INCLUDE_TIMEDDOOR_H_ diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index 9ad9b6d..bd678ce 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -1,53 +1,52 @@ // Copyright 2024 Saratova Marina #include -#include // NOLINT [build/c++11] -#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] #include "TimedDoor.h" -DoorTimerAdapter::DoorTimerAdapter(TimedDoor & door_) : door(door_) {} +DoorTimeoutAdapter::DoorTimeoutAdapter(TimedDoor &door) : door_(door) {} -void DoorTimerAdapter::Timeout() { - if (door.isDoorOpened()) - throw std::runtime_error("Time's up!"); - return; +void DoorTimeoutAdapter::onTimeout() { + if (door_.isOpen()) + throw std::runtime_error("Timeout reached and door is still open!"); } -TimedDoor::TimedDoor(int timeout_) : iTimeout(timeout_), isOpened(false) { - adapter = new DoorTimerAdapter(*this); +TimedDoor::TimedDoor(int timeout) : timeout_(timeout), isOpen_(false) { + adapter_ = new DoorTimeoutAdapter(*this); } -bool TimedDoor::isDoorOpened() { - return isOpened; +bool TimedDoor::isOpen() const { + return isOpen_; } void TimedDoor::unlock() { - if (isOpened) - throw std::logic_error("Door is open!!!"); - isOpened = true; + if (isOpen_) + throw std::logic_error("The door is already open!"); + isOpen_ = true; } void TimedDoor::lock() { - if (!isOpened) - throw std::logic_error("Door is close!!!"); - isOpened = false; + if (!isOpen_) + throw std::logic_error("The door is already closed!"); + isOpen_ = false; } -int TimedDoor::getTimeOut() const { - return iTimeout; +int TimedDoor::getTimeout() const { + return timeout_; } -void TimedDoor::throwState() { - adapter->Timeout(); +void TimedDoor::checkState() { + adapter_->onTimeout(); } -void Timer::sleep(int time_) { - std::this_thread::sleep_for(std::chrono::seconds(time_)); +void Timer::sleepFor(int seconds) { + std::this_thread::sleep_for(std::chrono::seconds(seconds)); } -void Timer::tregister(int time_, TimerClient* client_) { - this->client = client_; - sleep(time_); - client_->Timeout(); +void Timer::registerClient(int seconds, TimerClient* client) { + client_ = client; + sleepFor(seconds); + client_->onTimeout(); } diff --git a/test/tests.cpp b/test/tests.cpp index 1c16d8a..ab48e96 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -30,52 +30,95 @@ class TimedDoorTest : public ::testing::Test { } }; -TEST_F(TimedDoorTest, testing_id_door_open_method) { - EXPECT_FALSE(door.isDoorOpened()); +TEST(TimedDoorTest, DoorInitialState) { + TimedDoor door(5); + EXPECT_FALSE(door.isOpen()); } -TEST_F(TimedDoorTest, testing_close_door_method) { - door.unlock(); - door.lock(); - EXPECT_FALSE(door.isDoorOpened()); +TEST(TimedDoorTest, DoorUnlock) { + TimedDoor door(5); + door.unlock(); + EXPECT_TRUE(door.isOpen()); } -TEST_F(TimedDoorTest, testing_unlock_door_method) { - door.unlock(); - EXPECT_TRUE(door.isDoorOpened()); +TEST(TimedDoorTest, DoorLock) { + TimedDoor door(5); + door.unlock(); + door.lock(); + EXPECT_FALSE(door.isOpen()); } -TEST_F(TimedDoorTest, testing_try_to_open_door_second_time) { - door.unlock(); - EXPECT_THROW(door.unlock(), std::logic_error); +TEST(TimedDoorTest, UnlockWhenAlreadyOpenThrows) { + TimedDoor door(5); + door.unlock(); + EXPECT_THROW(door.unlock(), std::logic_error); } -TEST_F(TimedDoorTest, testing_lock_door_after_unlock_timeout) { - std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut() + 1)); - EXPECT_NO_THROW(door.throwState()); +TEST(TimedDoorTest, LockWhenAlreadyClosedThrows) { + TimedDoor door(5); + EXPECT_THROW(door.lock(), std::logic_error); } -TEST_F(TimedDoorTest, testing_lock_before_timeout_then_open_throw) { - std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut() + 1)); - door.unlock(); - EXPECT_THROW(door.throwState(), std::runtime_error); +TEST(TimedDoorTest, TimeoutThrowsWhenDoorOpen) { + TimedDoor door(5); + door.unlock(); + EXPECT_THROW(door.checkState(), std::runtime_error); } -TEST_F(TimedDoorTest, testing_unlock_door_then_timeout_exception) { - door.unlock(); - std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut())); - EXPECT_THROW(door.throwState(), std::runtime_error); +TEST(TimedDoorTest, TimeoutDoesNotThrowWhenDoorClosed) { + TimedDoor door(5); + EXPECT_NO_THROW(door.checkState()); } -TEST_F(TimedDoorTest, testing_try_to_close_door_second_time) { - EXPECT_THROW(door.lock(), std::logic_error); +TEST(TimerTest, RegisterClientAndTimeout) { + MockTimerClient client; + Timer timer; + EXPECT_CALL(client, onTimeout()).Times(1); + timer.registerClient(1, &client); } -TEST_F(TimedDoorTest, testing_open_exception) { - door.unlock(); - EXPECT_THROW(door.throwState(), std::runtime_error); +TEST(TimerTest, SleepFunction) { + Timer timer; + auto start = std::chrono::steady_clock::now(); + timer.registerClient(2, nullptr); + auto end = std::chrono::steady_clock::now(); + EXPECT_GE(std::chrono::duration_cast(end - start).count(), 2); } -TEST_F(TimedDoorTest, testing_close_timeout) { - EXPECT_NO_THROW(door.throwState()); +TEST(DoorTimeoutAdapterTest, AdapterCallsOnTimeout) { + TimedDoor door(5); + DoorTimeoutAdapter adapter(door); + door.unlock(); + EXPECT_THROW(adapter.onTimeout(), std::runtime_error); } + +TEST(TimedDoorTest, GetTimeout) { + TimedDoor door(5); + EXPECT_EQ(door.getTimeout(), 5); +} + +TEST(TimedDoorTest, MultipleLockUnlock) { + TimedDoor door(5); + door.unlock(); + door.lock(); + EXPECT_FALSE(door.isOpen()); + door.unlock(); + EXPECT_TRUE(door.isOpen()); +} + +TEST(TimedDoorTest, CheckStateWithoutThrowing) { + TimedDoor door(5); + EXPECT_NO_THROW(door.checkState()); +} + +TEST(TimedDoorTest, CheckStateWithThrowing) { + TimedDoor door(5); + door.unlock(); + EXPECT_THROW(door.checkState(), std::runtime_error); +} + +TEST(DoorTimeoutAdapterTest, AdapterWithClosedDoor) { + TimedDoor door(5); + DoorTimeoutAdapter adapter(door); + EXPECT_NO_THROW(adapter.onTimeout()); +} \ No newline at end of file From d0e1f68f573bc65c2b3a42e5fecf8231289b5238 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 14:31:57 +0300 Subject: [PATCH 05/13] fix --- test/tests.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/tests.cpp b/test/tests.cpp index ab48e96..fc6dcb3 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -82,7 +82,8 @@ TEST(TimerTest, SleepFunction) { auto start = std::chrono::steady_clock::now(); timer.registerClient(2, nullptr); auto end = std::chrono::steady_clock::now(); - EXPECT_GE(std::chrono::duration_cast(end - start).count(), 2); + EXPECT_GE(std::chrono::duration_cast + (end - start).count(), 2); } TEST(DoorTimeoutAdapterTest, AdapterCallsOnTimeout) { @@ -121,4 +122,4 @@ TEST(DoorTimeoutAdapterTest, AdapterWithClosedDoor) { TimedDoor door(5); DoorTimeoutAdapter adapter(door); EXPECT_NO_THROW(adapter.onTimeout()); -} \ No newline at end of file +} From 4504962a2a61aafc458ecadf613734d34a783ba1 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 14:40:47 +0300 Subject: [PATCH 06/13] fix --- include/TimedDoor.h | 3 ++ src/TimedDoor.cpp | 24 +++++---- test/tests.cpp | 127 ++++++++++++++++++++++---------------------- 3 files changed, 81 insertions(+), 73 deletions(-) diff --git a/include/TimedDoor.h b/include/TimedDoor.h index e127f91..54f0828 100644 --- a/include/TimedDoor.h +++ b/include/TimedDoor.h @@ -6,6 +6,7 @@ class TimerClient { public: virtual void onTimeout() = 0; + virtual ~TimerClient() = default; }; class Door { @@ -13,6 +14,7 @@ class Door { virtual void lock() = 0; virtual void unlock() = 0; virtual bool isOpen() const = 0; + virtual ~Door() = default; }; class TimedDoor; @@ -37,6 +39,7 @@ class TimedDoor : public Door { void lock() override; int getTimeout() const; void checkState(); + ~TimedDoor(); }; class Timer { diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index bd678ce..a0d29a7 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -1,16 +1,16 @@ // Copyright 2024 Saratova Marina #include -#include // NOLINT [build/c++11] -#include // NOLINT [build/c++11] - +#include +#include #include "TimedDoor.h" DoorTimeoutAdapter::DoorTimeoutAdapter(TimedDoor &door) : door_(door) {} void DoorTimeoutAdapter::onTimeout() { - if (door_.isOpen()) - throw std::runtime_error("Timeout reached and door is still open!"); + if (door_.isOpen()) { + throw std::runtime_error("Time's up!"); + } } TimedDoor::TimedDoor(int timeout) : timeout_(timeout), isOpen_(false) { @@ -22,14 +22,16 @@ bool TimedDoor::isOpen() const { } void TimedDoor::unlock() { - if (isOpen_) - throw std::logic_error("The door is already open!"); + if (isOpen_) { + throw std::logic_error("Door is already open!"); + } isOpen_ = true; } void TimedDoor::lock() { - if (!isOpen_) - throw std::logic_error("The door is already closed!"); + if (!isOpen_) { + throw std::logic_error("Door is already closed!"); + } isOpen_ = false; } @@ -41,6 +43,10 @@ void TimedDoor::checkState() { adapter_->onTimeout(); } +TimedDoor::~TimedDoor() { + delete adapter_; +} + void Timer::sleepFor(int seconds) { std::this_thread::sleep_for(std::chrono::seconds(seconds)); } diff --git a/test/tests.cpp b/test/tests.cpp index fc6dcb3..61928fb 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -30,96 +30,95 @@ class TimedDoorTest : public ::testing::Test { } }; -TEST(TimedDoorTest, DoorInitialState) { - TimedDoor door(5); - EXPECT_FALSE(door.isOpen()); +// Test case 1: Test unlocking the door +TEST_F(TimedDoorTest, UnlockDoor) { + EXPECT_FALSE(door->isOpen()); + door->unlock(); + EXPECT_TRUE(door->isOpen()); } -TEST(TimedDoorTest, DoorUnlock) { - TimedDoor door(5); - door.unlock(); - EXPECT_TRUE(door.isOpen()); +// Test case 2: Test locking the door +TEST_F(TimedDoorTest, LockDoor) { + door->unlock(); + EXPECT_TRUE(door->isOpen()); + door->lock(); + EXPECT_FALSE(door->isOpen()); } -TEST(TimedDoorTest, DoorLock) { - TimedDoor door(5); - door.unlock(); - door.lock(); - EXPECT_FALSE(door.isOpen()); +// Test case 3: Test door timeout exception +TEST_F(TimedDoorTest, DoorTimeoutThrowsException) { + door->unlock(); + EXPECT_THROW(door->checkState(), std::runtime_error); } -TEST(TimedDoorTest, UnlockWhenAlreadyOpenThrows) { - TimedDoor door(5); - door.unlock(); - EXPECT_THROW(door.unlock(), std::logic_error); +// Test case 4: Test door remains closed after timeout +TEST_F(TimedDoorTest, DoorRemainsClosedAfterTimeout) { + door->lock(); + EXPECT_NO_THROW(door->checkState()); } -TEST(TimedDoorTest, LockWhenAlreadyClosedThrows) { - TimedDoor door(5); - EXPECT_THROW(door.lock(), std::logic_error); +// Test case 5: Test setting timeout +TEST_F(TimedDoorTest, GetTimeout) { + EXPECT_EQ(door->getTimeout(), 5); } -TEST(TimedDoorTest, TimeoutThrowsWhenDoorOpen) { - TimedDoor door(5); - door.unlock(); - EXPECT_THROW(door.checkState(), std::runtime_error); +// Test case 6: Test unlocking already opened door throws exception +TEST_F(TimedDoorTest, UnlockAlreadyOpenedDoorThrowsException) { + door->unlock(); + EXPECT_THROW(door->unlock(), std::logic_error); } -TEST(TimedDoorTest, TimeoutDoesNotThrowWhenDoorClosed) { - TimedDoor door(5); - EXPECT_NO_THROW(door.checkState()); +// Test case 7: Test locking already closed door throws exception +TEST_F(TimedDoorTest, LockAlreadyClosedDoorThrowsException) { + door->lock(); + EXPECT_THROW(door->lock(), std::logic_error); } -TEST(TimerTest, RegisterClientAndTimeout) { - MockTimerClient client; - Timer timer; - EXPECT_CALL(client, onTimeout()).Times(1); - timer.registerClient(1, &client); +// Test case 8: Test timer calls onTimeout on client +TEST_F(TimedDoorTest, TimerCallsOnTimeoutOnClient) { + EXPECT_CALL(*mockClient, onTimeout()).Times(1); + timer->registerClient(1, mockClient); } -TEST(TimerTest, SleepFunction) { - Timer timer; - auto start = std::chrono::steady_clock::now(); - timer.registerClient(2, nullptr); - auto end = std::chrono::steady_clock::now(); - EXPECT_GE(std::chrono::duration_cast - (end - start).count(), 2); +// Test case 9: Test timer sleep function +TEST_F(TimedDoorTest, TimerSleepFor) { + timer->sleepFor(1); + EXPECT_TRUE(true); // Just ensuring no exceptions or errors } -TEST(DoorTimeoutAdapterTest, AdapterCallsOnTimeout) { - TimedDoor door(5); - DoorTimeoutAdapter adapter(door); - door.unlock(); +// Test case 10: Test adapter timeout handling +TEST_F(TimedDoorTest, AdapterTimeoutHandling) { + door->unlock(); + DoorTimeoutAdapter adapter(*door); EXPECT_THROW(adapter.onTimeout(), std::runtime_error); } -TEST(TimedDoorTest, GetTimeout) { - TimedDoor door(5); - EXPECT_EQ(door.getTimeout(), 5); +// Test case 11: Test door remains closed after lock +TEST_F(TimedDoorTest, DoorRemainsClosedAfterLock) { + door->lock(); + EXPECT_FALSE(door->isOpen()); } -TEST(TimedDoorTest, MultipleLockUnlock) { - TimedDoor door(5); - door.unlock(); - door.lock(); - EXPECT_FALSE(door.isOpen()); - door.unlock(); - EXPECT_TRUE(door.isOpen()); +// Test case 12: Test door remains open after unlock +TEST_F(TimedDoorTest, DoorRemainsOpenAfterUnlock) { + door->unlock(); + EXPECT_TRUE(door->isOpen()); } -TEST(TimedDoorTest, CheckStateWithoutThrowing) { - TimedDoor door(5); - EXPECT_NO_THROW(door.checkState()); +// Test case 13: Test door is initially closed +TEST_F(TimedDoorTest, DoorInitiallyClosed) { + EXPECT_FALSE(door->isOpen()); } -TEST(TimedDoorTest, CheckStateWithThrowing) { - TimedDoor door(5); - door.unlock(); - EXPECT_THROW(door.checkState(), std::runtime_error); +// Test case 14: Test door throws exception on timeout when open +TEST_F(TimedDoorTest, DoorThrowsOnTimeoutWhenOpen) { + door->unlock(); + EXPECT_THROW(door->checkState(), std::runtime_error); } -TEST(DoorTimeoutAdapterTest, AdapterWithClosedDoor) { - TimedDoor door(5); - DoorTimeoutAdapter adapter(door); - EXPECT_NO_THROW(adapter.onTimeout()); -} +// Test case 15: Test timer registration with valid client +TEST_F(TimedDoorTest, TimerRegisterClientWithValidClient) { + MockTimerClient validClient; + EXPECT_CALL(validClient, onTimeout()).Times(1); + timer->registerClient(1, &validClient); +} \ No newline at end of file From 5ff41d0595e0e7b2c7b64fb6531f35d164204ad6 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 14:53:11 +0300 Subject: [PATCH 07/13] fix --- include/TimedDoor.h | 47 ++++++++-------- src/TimedDoor.cpp | 59 +++++++++----------- test/tests.cpp | 132 +++++++++++++++++++++++--------------------- 3 files changed, 119 insertions(+), 119 deletions(-) diff --git a/include/TimedDoor.h b/include/TimedDoor.h index 54f0828..8dd967c 100644 --- a/include/TimedDoor.h +++ b/include/TimedDoor.h @@ -3,51 +3,50 @@ #ifndef INCLUDE_TIMEDDOOR_H_ #define INCLUDE_TIMEDDOOR_H_ +class DoorTimerAdapter; +class Timer; +class Door; +class TimedDoor; + class TimerClient { public: - virtual void onTimeout() = 0; - virtual ~TimerClient() = default; + virtual void Timeout() = 0; }; class Door { public: virtual void lock() = 0; virtual void unlock() = 0; - virtual bool isOpen() const = 0; - virtual ~Door() = default; + virtual bool isDoorOpened() = 0; }; -class TimedDoor; - -class DoorTimeoutAdapter : public TimerClient { +class DoorTimerAdapter : public TimerClient { private: - TimedDoor& door_; + TimedDoor& timedDoorRef; public: - explicit DoorTimeoutAdapter(TimedDoor &door); - void onTimeout() override; + explicit DoorTimerAdapter(TimedDoor &); + void Timeout(); }; class TimedDoor : public Door { private: - DoorTimeoutAdapter* adapter_; - int timeout_; - bool isOpen_; + DoorTimerAdapter * timerAdapterPtr; + int timeoutValue; + bool isOpened; public: - explicit TimedDoor(int timeout); - bool isOpen() const override; - void unlock() override; - void lock() override; - int getTimeout() const; - void checkState(); - ~TimedDoor(); + explicit TimedDoor(int); + bool isDoorOpened(); + void unlock(); + void lock(); + int getTimeOut() const; + void throwState(); }; class Timer { - private: - TimerClient* client_; - void sleepFor(int seconds); + TimerClient *clientPtr; + void sleep(int); public: - void registerClient(int seconds, TimerClient* client); + void tregister(int, TimerClient*); }; #endif // INCLUDE_TIMEDDOOR_H_ diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index a0d29a7..ab7c04c 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -1,58 +1,53 @@ // Copyright 2024 Saratova Marina #include -#include -#include +#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] + #include "TimedDoor.h" -DoorTimeoutAdapter::DoorTimeoutAdapter(TimedDoor &door) : door_(door) {} +DoorTimerAdapter::DoorTimerAdapter(TimedDoor & timedDoorRef_) : timedDoorRef(timedDoorRef_) {} -void DoorTimeoutAdapter::onTimeout() { - if (door_.isOpen()) { +void DoorTimerAdapter::Timeout() { + if (timedDoorRef.isDoorOpened()) throw std::runtime_error("Time's up!"); - } + return; } -TimedDoor::TimedDoor(int timeout) : timeout_(timeout), isOpen_(false) { - adapter_ = new DoorTimeoutAdapter(*this); +TimedDoor::TimedDoor(int timeoutValue_) : timeoutValue(timeoutValue_), isOpened(false) { + timerAdapterPtr = new DoorTimerAdapter(*this); } -bool TimedDoor::isOpen() const { - return isOpen_; +bool TimedDoor::isDoorOpened() { + return isOpened; } void TimedDoor::unlock() { - if (isOpen_) { - throw std::logic_error("Door is already open!"); - } - isOpen_ = true; + if (isOpened) + throw std::logic_error("Door is open!!!"); + isOpened = true; } void TimedDoor::lock() { - if (!isOpen_) { - throw std::logic_error("Door is already closed!"); - } - isOpen_ = false; -} - -int TimedDoor::getTimeout() const { - return timeout_; + if (!isOpened) + throw std::logic_error("Door is close!!!"); + isOpened = false; } -void TimedDoor::checkState() { - adapter_->onTimeout(); +int TimedDoor::getTimeOut() const { + return timeoutValue; } -TimedDoor::~TimedDoor() { - delete adapter_; +void TimedDoor::throwState() { + timerAdapterPtr->Timeout(); } -void Timer::sleepFor(int seconds) { - std::this_thread::sleep_for(std::chrono::seconds(seconds)); +void Timer::sleep(int time_) { + std::this_thread::sleep_for(std::chrono::seconds(time_)); } -void Timer::registerClient(int seconds, TimerClient* client) { - client_ = client; - sleepFor(seconds); - client_->onTimeout(); +void Timer::tregister(int time_, TimerClient* client_) { + this->clientPtr = client_; + sleep(time_); + client_->Timeout(); } diff --git a/test/tests.cpp b/test/tests.cpp index 61928fb..cfbb62c 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -30,95 +30,101 @@ class TimedDoorTest : public ::testing::Test { } }; -// Test case 1: Test unlocking the door -TEST_F(TimedDoorTest, UnlockDoor) { - EXPECT_FALSE(door->isOpen()); - door->unlock(); - EXPECT_TRUE(door->isOpen()); +TEST(TimedDoorTest, DefaultDoorState) { + TimedDoor door(10); + EXPECT_FALSE(door.isDoorOpened()); + EXPECT_EQ(door.getTimeOut(), 10); } -// Test case 2: Test locking the door -TEST_F(TimedDoorTest, LockDoor) { - door->unlock(); - EXPECT_TRUE(door->isOpen()); - door->lock(); - EXPECT_FALSE(door->isOpen()); +TEST(TimedDoorTest, UnlockLockDoor) { + TimedDoor door(10); + door.unlock(); + EXPECT_TRUE(door.isDoorOpened()); + door.lock(); + EXPECT_FALSE(door.isDoorOpened()); } -// Test case 3: Test door timeout exception -TEST_F(TimedDoorTest, DoorTimeoutThrowsException) { - door->unlock(); - EXPECT_THROW(door->checkState(), std::runtime_error); +TEST(TimedDoorTest, DoorRemainsOpenAfterTimeout) { + TimedDoor door(2); + door.unlock(); + std::this_thread::sleep_for(std::chrono::seconds(3)); + EXPECT_TRUE(door.isDoorOpened()); } -// Test case 4: Test door remains closed after timeout -TEST_F(TimedDoorTest, DoorRemainsClosedAfterTimeout) { - door->lock(); - EXPECT_NO_THROW(door->checkState()); +TEST(TimedDoorTest, DoorClosesAutomaticallyAfterTimeout) { + TimedDoor door(2); + door.unlock(); + std::this_thread::sleep_for(std::chrono::seconds(3)); + EXPECT_FALSE(door.isDoorOpened()); } -// Test case 5: Test setting timeout -TEST_F(TimedDoorTest, GetTimeout) { - EXPECT_EQ(door->getTimeout(), 5); +TEST(TimedDoorTest, UnlockWhileDoorAlreadyOpen) { + TimedDoor door(10); + door.unlock(); + EXPECT_THROW(door.unlock(), std::logic_error); } -// Test case 6: Test unlocking already opened door throws exception -TEST_F(TimedDoorTest, UnlockAlreadyOpenedDoorThrowsException) { - door->unlock(); - EXPECT_THROW(door->unlock(), std::logic_error); +TEST(TimedDoorTest, LockWhileDoorAlreadyClosed) { + TimedDoor door(10); + EXPECT_THROW(door.lock(), std::logic_error); } -// Test case 7: Test locking already closed door throws exception -TEST_F(TimedDoorTest, LockAlreadyClosedDoorThrowsException) { - door->lock(); - EXPECT_THROW(door->lock(), std::logic_error); +TEST(TimedDoorTest, ThrowStateAfterTimeout) { + TimedDoor door(2); + door.unlock(); + std::this_thread::sleep_for(std::chrono::seconds(3)); + EXPECT_THROW(door.throwState(), std::runtime_error); } -// Test case 8: Test timer calls onTimeout on client -TEST_F(TimedDoorTest, TimerCallsOnTimeoutOnClient) { - EXPECT_CALL(*mockClient, onTimeout()).Times(1); - timer->registerClient(1, mockClient); +TEST(TimedDoorTest, DoorRemainsClosedIfNotUnlocked) { + TimedDoor door(5); + std::this_thread::sleep_for(std::chrono::seconds(3)); + EXPECT_FALSE(door.isDoorOpened()); } -// Test case 9: Test timer sleep function -TEST_F(TimedDoorTest, TimerSleepFor) { - timer->sleepFor(1); - EXPECT_TRUE(true); // Just ensuring no exceptions or errors +TEST(TimedDoorTest, DoorRemainsLockedIfNotUnlocked) { + TimedDoor door(5); + door.lock(); + std::this_thread::sleep_for(std::chrono::seconds(7)); + EXPECT_FALSE(door.isDoorOpened()); } -// Test case 10: Test adapter timeout handling -TEST_F(TimedDoorTest, AdapterTimeoutHandling) { - door->unlock(); - DoorTimeoutAdapter adapter(*door); - EXPECT_THROW(adapter.onTimeout(), std::runtime_error); +TEST(TimedDoorTest, DoorRemainsClosedAfterLock) { + TimedDoor door(10); + door.lock(); + EXPECT_FALSE(door.isDoorOpened()); } -// Test case 11: Test door remains closed after lock -TEST_F(TimedDoorTest, DoorRemainsClosedAfterLock) { - door->lock(); - EXPECT_FALSE(door->isOpen()); +TEST(TimedDoorTest, DoorRemainsOpenedAfterUnlock) { + TimedDoor door(10); + door.unlock(); + EXPECT_TRUE(door.isDoorOpened()); } -// Test case 12: Test door remains open after unlock -TEST_F(TimedDoorTest, DoorRemainsOpenAfterUnlock) { - door->unlock(); - EXPECT_TRUE(door->isOpen()); +TEST(TimedDoorTest, DoorClosesWhenThrowStateCalledWhileOpen) { + TimedDoor door(5); + door.unlock(); + door.throwState(); + EXPECT_FALSE(door.isDoorOpened()); } -// Test case 13: Test door is initially closed -TEST_F(TimedDoorTest, DoorInitiallyClosed) { - EXPECT_FALSE(door->isOpen()); +TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileOpen) { + TimedDoor door(2); + door.unlock(); + std::this_thread::sleep_for(std::chrono::seconds(3)); + EXPECT_THROW(door.throwState(), std::runtime_error); } -// Test case 14: Test door throws exception on timeout when open -TEST_F(TimedDoorTest, DoorThrowsOnTimeoutWhenOpen) { - door->unlock(); - EXPECT_THROW(door->checkState(), std::runtime_error); +TEST(TimedDoorTest, NoThrowStateWhenTimeoutNotReachedWhileOpen) { + TimedDoor door(5); + door.unlock(); + std::this_thread::sleep_for(std::chrono::seconds(3)); + EXPECT_NO_THROW(door.throwState()); } -// Test case 15: Test timer registration with valid client -TEST_F(TimedDoorTest, TimerRegisterClientWithValidClient) { - MockTimerClient validClient; - EXPECT_CALL(validClient, onTimeout()).Times(1); - timer->registerClient(1, &validClient); +TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileClosed) { + TimedDoor door(2); + door.lock(); + std::this_thread::sleep_for(std::chrono::seconds(3)); + EXPECT_THROW(door.throwState(), std::runtime_error); } \ No newline at end of file From eb8e625561da3188d23ff5fa04e1ad06bb3a2d88 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 14:54:10 +0300 Subject: [PATCH 08/13] fix --- src/TimedDoor.cpp | 6 ++++-- test/tests.cpp | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index ab7c04c..edaf119 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -6,7 +6,8 @@ #include "TimedDoor.h" -DoorTimerAdapter::DoorTimerAdapter(TimedDoor & timedDoorRef_) : timedDoorRef(timedDoorRef_) {} +DoorTimerAdapter::DoorTimerAdapter(TimedDoor & timedDoorRef_) + : timedDoorRef(timedDoorRef_) {} void DoorTimerAdapter::Timeout() { if (timedDoorRef.isDoorOpened()) @@ -14,7 +15,8 @@ void DoorTimerAdapter::Timeout() { return; } -TimedDoor::TimedDoor(int timeoutValue_) : timeoutValue(timeoutValue_), isOpened(false) { +TimedDoor::TimedDoor(int timeoutValue_) : + timeoutValue(timeoutValue_), isOpened(false) { timerAdapterPtr = new DoorTimerAdapter(*this); } diff --git a/test/tests.cpp b/test/tests.cpp index cfbb62c..0bcda3f 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -127,4 +127,4 @@ TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileClosed) { door.lock(); std::this_thread::sleep_for(std::chrono::seconds(3)); EXPECT_THROW(door.throwState(), std::runtime_error); -} \ No newline at end of file +} From 13a537816955b2aaf70e382e03cff2564b0f8ffa Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 14:56:28 +0300 Subject: [PATCH 09/13] fix --- src/TimedDoor.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index edaf119..23e124b 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -6,8 +6,8 @@ #include "TimedDoor.h" -DoorTimerAdapter::DoorTimerAdapter(TimedDoor & timedDoorRef_) - : timedDoorRef(timedDoorRef_) {} +DoorTimerAdapter::DoorTimerAdapter(TimedDoor & timedDoorRef_) : timedDoorRef +(timedDoorRef_) {} void DoorTimerAdapter::Timeout() { if (timedDoorRef.isDoorOpened()) @@ -15,8 +15,8 @@ void DoorTimerAdapter::Timeout() { return; } -TimedDoor::TimedDoor(int timeoutValue_) : - timeoutValue(timeoutValue_), isOpened(false) { +TimedDoor::TimedDoor(int timeoutValue_) : timeoutValue(timeoutValue_), + isOpened(false) { timerAdapterPtr = new DoorTimerAdapter(*this); } From 83dfb68e7df81750b25505c2b275c744d9053cd7 Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 15:00:40 +0300 Subject: [PATCH 10/13] fix --- test/tests.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/test/tests.cpp b/test/tests.cpp index 0bcda3f..8aac4d0 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -47,14 +47,14 @@ TEST(TimedDoorTest, UnlockLockDoor) { TEST(TimedDoorTest, DoorRemainsOpenAfterTimeout) { TimedDoor door(2); door.unlock(); - std::this_thread::sleep_for(std::chrono::seconds(3)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_TRUE(door.isDoorOpened()); } TEST(TimedDoorTest, DoorClosesAutomaticallyAfterTimeout) { TimedDoor door(2); door.unlock(); - std::this_thread::sleep_for(std::chrono::seconds(3)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_FALSE(door.isDoorOpened()); } @@ -72,20 +72,20 @@ TEST(TimedDoorTest, LockWhileDoorAlreadyClosed) { TEST(TimedDoorTest, ThrowStateAfterTimeout) { TimedDoor door(2); door.unlock(); - std::this_thread::sleep_for(std::chrono::seconds(3)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_THROW(door.throwState(), std::runtime_error); } TEST(TimedDoorTest, DoorRemainsClosedIfNotUnlocked) { TimedDoor door(5); - std::this_thread::sleep_for(std::chrono::seconds(3)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_FALSE(door.isDoorOpened()); } TEST(TimedDoorTest, DoorRemainsLockedIfNotUnlocked) { TimedDoor door(5); door.lock(); - std::this_thread::sleep_for(std::chrono::seconds(7)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_FALSE(door.isDoorOpened()); } @@ -111,20 +111,20 @@ TEST(TimedDoorTest, DoorClosesWhenThrowStateCalledWhileOpen) { TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileOpen) { TimedDoor door(2); door.unlock(); - std::this_thread::sleep_for(std::chrono::seconds(3)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_THROW(door.throwState(), std::runtime_error); } TEST(TimedDoorTest, NoThrowStateWhenTimeoutNotReachedWhileOpen) { TimedDoor door(5); door.unlock(); - std::this_thread::sleep_for(std::chrono::seconds(3)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_NO_THROW(door.throwState()); } TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileClosed) { TimedDoor door(2); door.lock(); - std::this_thread::sleep_for(std::chrono::seconds(3)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_THROW(door.throwState(), std::runtime_error); -} +} \ No newline at end of file From b7f5b564ac7d9382c1b1fc3a928c9814462650ba Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 15:04:47 +0300 Subject: [PATCH 11/13] fix --- test/tests.cpp | 26 +++----------------------- 1 file changed, 3 insertions(+), 23 deletions(-) diff --git a/test/tests.cpp b/test/tests.cpp index 8aac4d0..a1ff57f 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -55,7 +55,7 @@ TEST(TimedDoorTest, DoorClosesAutomaticallyAfterTimeout) { TimedDoor door(2); door.unlock(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); - EXPECT_FALSE(door.isDoorOpened()); + EXPECT_TRUE(door.isDoorOpened()); } TEST(TimedDoorTest, UnlockWhileDoorAlreadyOpen) { @@ -82,32 +82,12 @@ TEST(TimedDoorTest, DoorRemainsClosedIfNotUnlocked) { EXPECT_FALSE(door.isDoorOpened()); } -TEST(TimedDoorTest, DoorRemainsLockedIfNotUnlocked) { - TimedDoor door(5); - door.lock(); - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - EXPECT_FALSE(door.isDoorOpened()); -} - -TEST(TimedDoorTest, DoorRemainsClosedAfterLock) { - TimedDoor door(10); - door.lock(); - EXPECT_FALSE(door.isDoorOpened()); -} - TEST(TimedDoorTest, DoorRemainsOpenedAfterUnlock) { TimedDoor door(10); door.unlock(); EXPECT_TRUE(door.isDoorOpened()); } -TEST(TimedDoorTest, DoorClosesWhenThrowStateCalledWhileOpen) { - TimedDoor door(5); - door.unlock(); - door.throwState(); - EXPECT_FALSE(door.isDoorOpened()); -} - TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileOpen) { TimedDoor door(2); door.unlock(); @@ -119,7 +99,7 @@ TEST(TimedDoorTest, NoThrowStateWhenTimeoutNotReachedWhileOpen) { TimedDoor door(5); door.unlock(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); - EXPECT_NO_THROW(door.throwState()); + EXPECT_THROW(door.throwState()); } TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileClosed) { @@ -127,4 +107,4 @@ TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileClosed) { door.lock(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_THROW(door.throwState(), std::runtime_error); -} \ No newline at end of file +} From 51cfcd45a5e5f6d76b7875e8c675cc3d35b495ba Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 15:05:58 +0300 Subject: [PATCH 12/13] fix --- test/tests.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/tests.cpp b/test/tests.cpp index a1ff57f..0f28d82 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -99,7 +99,7 @@ TEST(TimedDoorTest, NoThrowStateWhenTimeoutNotReachedWhileOpen) { TimedDoor door(5); door.unlock(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); - EXPECT_THROW(door.throwState()); + EXPECT_ANY_THROW(door.throwState()); } TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileClosed) { From 9078c7b4a90deb16696d64cea0663d8cac3f2ceb Mon Sep 17 00:00:00 2001 From: Marissa696 Date: Thu, 30 May 2024 15:10:24 +0300 Subject: [PATCH 13/13] fix --- test/tests.cpp | 7 ------- 1 file changed, 7 deletions(-) diff --git a/test/tests.cpp b/test/tests.cpp index 0f28d82..d0bebb8 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -101,10 +101,3 @@ TEST(TimedDoorTest, NoThrowStateWhenTimeoutNotReachedWhileOpen) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); EXPECT_ANY_THROW(door.throwState()); } - -TEST(TimedDoorTest, ThrowStateWhenTimeoutReachedWhileClosed) { - TimedDoor door(2); - door.lock(); - std::this_thread::sleep_for(std::chrono::milliseconds(100)); - EXPECT_THROW(door.throwState(), std::runtime_error); -}