From 487b393548ecd5c6883f3ba7da5272a378c2ed82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BC=D0=B5=D0=B4=D0=BE=D0=B2=20=D0=9A=D0=B5?= =?UTF-8?q?=D0=BD=D0=B0=D0=BD=20=D0=AD=D0=BB=D1=8C=D1=87=D0=B8=D0=BD=20?= =?UTF-8?q?=D0=9E=D0=B3=D0=BB=D1=8B?= Date: Sun, 29 Sep 2024 16:44:49 +0300 Subject: [PATCH 1/6] update --- src/TimedDoor.cpp | 49 +++++++++++++++++++++++++ src/main.cpp | 2 +- test/tests.cpp | 91 ++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 140 insertions(+), 2 deletions(-) create mode 100644 src/TimedDoor.cpp diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp new file mode 100644 index 0000000..3546f99 --- /dev/null +++ b/src/TimedDoor.cpp @@ -0,0 +1,49 @@ +// Copyright 2024 MamedovKenan +#include "TimedDoor.h" +#include +#include +#include + +DoorTimerAdapter::DoorTimerAdapter(TimedDoor& d) : door(d) {} + +void DoorTimerAdapter::Timeout() { + if (door.isDoorOpened()) { + door.throwState(); + } +} + +TimedDoor::TimedDoor(int timeout) : iTimeout(timeout), isOpened(false) { + adapter = new DoorTimerAdapter(*this); +} + +bool TimedDoor::isDoorOpened() { + return isOpened; +} + +void TimedDoor::unlock() { + isOpened = true; +} + +void TimedDoor::lock() { + isOpened = false; +} + +int TimedDoor::getTimeOut() const { + return iTimeout; +} + +void TimedDoor::throwState() { + throw std::runtime_error("Door is open for too long!"); +} + +void Timer::tregister(int seconds, TimerClient* client) { + this->client = client; + std::thread([this, seconds]() { + sleep(seconds); + client->Timeout(); + }).detach(); +} + +void Timer::sleep(int seconds) { + std::this_thread::sleep_for(std::chrono::seconds(seconds)); +} diff --git a/src/main.cpp b/src/main.cpp index 9b83162..10d7668 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,4 +1,4 @@ -// Copyright 2021 GHA Test Team +// Copyright 2024 MamedovKenan #include "TimedDoor.h" #include diff --git a/test/tests.cpp b/test/tests.cpp index 605e570..a4333d9 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -1,6 +1,95 @@ -// Copyright 2021 GHA Test Team +// Copyright 2024 MamedovKenan #include #include #include #include "TimedDoor.h" + +class MockTimerClient : public TimerClient { + public: + MOCK_METHOD(void, Timeout, (), (override)); +}; + +class MockDoor : public Door { + public: + MOCK_METHOD(void, lock, (), (override)); + MOCK_METHOD(void, unlock, (), (override)); + MOCK_METHOD(bool, isDoorOpened, (), (override)); +}; + +class TimedDoorTest : public ::testing::Test { + protected: + TimedDoor* door; + Timer* timer; + + void SetUp() override { + door = new TimedDoor(5); + timer = new Timer(); + } + + void TearDown() override { + delete door; + delete timer; + } +}; + +TEST_F(TimedDoorTest, DoorInitiallyClosed) { + EXPECT_FALSE(door->isDoorOpened()); +} + +TEST_F(TimedDoorTest, DoorCanBeUnlocked) { + door->unlock(); + EXPECT_TRUE(door->isDoorOpened()); +} + +TEST_F(TimedDoorTest, DoorCanBeLocked) { + door->unlock(); + door->lock(); + EXPECT_FALSE(door->isDoorOpened()); +} + +TEST_F(TimedDoorTest, TimeoutThrowsWhenDoorOpenedTooLong) { + door->unlock(); + EXPECT_THROW(timer->tregister(1, door), std::runtime_error); +} + +TEST_F(TimedDoorTest, TimeoutDoesNotThrowWhenDoorClosed) { + door->lock(); + EXPECT_NO_THROW(timer->tregister(1, door)); +} + +TEST_F(TimedDoorTest, AdapterTimeoutCallsThrowState) { + MockDoor mockDoor; + EXPECT_CALL(mockDoor, isDoorOpened()) + .WillOnce(testing::Return(true)); + + DoorTimerAdapter adapter(mockDoor); + EXPECT_THROW(adapter.Timeout(), std::runtime_error); +} + +TEST_F(TimedDoorTest, TimerCallsTimeout) { + MockTimerClient mockClient; + EXPECT_CALL(mockClient, Timeout()).Times(1); + + timer->tregister(1, &mockClient); + std::this_thread::sleep_for(std::chrono::seconds(2)); +} + +TEST_F(TimedDoorTest, MultipleTimeouts) { + MockTimerClient mockClient; + EXPECT_CALL(mockClient, Timeout()).Times(2); + + timer->tregister(1, &mockClient); + timer->tregister(2, &mockClient); + std::this_thread::sleep_for(std::chrono::seconds(3)); +} + +TEST_F(TimedDoorTest, DoorTimeoutAfterUnlock) { + door->unlock(); + EXPECT_THROW(timer->tregister(1, door), std::runtime_error); +} + +TEST_F(TimedDoorTest, DoorDoesNotThrowAfterLock) { + door->lock(); + EXPECT_NO_THROW(timer->tregister(1, door)); +} From 63fc8285f31c7d63b01d63e3a0ab5d34d5bf9e28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BC=D0=B5=D0=B4=D0=BE=D0=B2=20=D0=9A=D0=B5?= =?UTF-8?q?=D0=BD=D0=B0=D0=BD=20=D0=AD=D0=BB=D1=8C=D1=87=D0=B8=D0=BD=20?= =?UTF-8?q?=D0=9E=D0=B3=D0=BB=D1=8B?= Date: Sun, 29 Sep 2024 16:54:39 +0300 Subject: [PATCH 2/6] fix --- src/TimedDoor.cpp | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index 3546f99..fe4d4ae 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -1,5 +1,5 @@ // Copyright 2024 MamedovKenan -#include "TimedDoor.h" +#include "../include/TimedDoor.h" #include #include #include @@ -7,43 +7,46 @@ DoorTimerAdapter::DoorTimerAdapter(TimedDoor& d) : door(d) {} void DoorTimerAdapter::Timeout() { - if (door.isDoorOpened()) { - door.throwState(); - } + if (door.isDoorOpened()) { + door.throwState(); + } } TimedDoor::TimedDoor(int timeout) : iTimeout(timeout), isOpened(false) { - adapter = new DoorTimerAdapter(*this); + adapter = new DoorTimerAdapter(*this); } bool TimedDoor::isDoorOpened() { - return isOpened; + return isOpened; } void TimedDoor::unlock() { - isOpened = true; + isOpened = true; + Timer timer; + timer.tregister(iTimeout, adapter); } void TimedDoor::lock() { - isOpened = false; + isOpened = false; } int TimedDoor::getTimeOut() const { - return iTimeout; + return iTimeout; } void TimedDoor::throwState() { - throw std::runtime_error("Door is open for too long!"); + throw std::runtime_error("Door is open for too long!"); } void Timer::tregister(int seconds, TimerClient* client) { - this->client = client; - std::thread([this, seconds]() { - sleep(seconds); - client->Timeout(); - }).detach(); + this->client = client; + + std::thread([this, seconds]() { + sleep(seconds); + client->Timeout(); + }).detach(); } void Timer::sleep(int seconds) { - std::this_thread::sleep_for(std::chrono::seconds(seconds)); + std::this_thread::sleep_for(std::chrono::seconds(seconds)); } From d771522e2fc9b6310e799989b41a8f40a932d15f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BC=D0=B5=D0=B4=D0=BE=D0=B2=20=D0=9A=D0=B5?= =?UTF-8?q?=D0=BD=D0=B0=D0=BD=20=D0=AD=D0=BB=D1=8C=D1=87=D0=B8=D0=BD=20?= =?UTF-8?q?=D0=9E=D0=B3=D0=BB=D1=8B?= Date: Sun, 29 Sep 2024 17:09:58 +0300 Subject: [PATCH 3/6] fix --- .vscode/settings.json | 3 +++ include/TimedDoor.h | 2 +- src/TimedDoor.cpp | 9 +++++---- 3 files changed, 9 insertions(+), 5 deletions(-) create mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..85bdc9d --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "C_Cpp.default.compilerPath": "" +} \ No newline at end of file diff --git a/include/TimedDoor.h b/include/TimedDoor.h index 04429ad..465c1a6 100644 --- a/include/TimedDoor.h +++ b/include/TimedDoor.h @@ -1,4 +1,4 @@ -// Copyright 2021 GHA Test Team +// Copyright 2024 MamedovKenan #ifndef INCLUDE_TIMEDDOOR_H_ #define INCLUDE_TIMEDDOOR_H_ diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index fe4d4ae..a078dce 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -1,8 +1,9 @@ // Copyright 2024 MamedovKenan -#include "../include/TimedDoor.h" + +#include "TimedDoor.h" #include -#include -#include +#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] DoorTimerAdapter::DoorTimerAdapter(TimedDoor& d) : door(d) {} @@ -41,7 +42,7 @@ void TimedDoor::throwState() { void Timer::tregister(int seconds, TimerClient* client) { this->client = client; - std::thread([this, seconds]() { + std::thread([this, seconds, client]() { sleep(seconds); client->Timeout(); }).detach(); From 95609c3e4c116e3ee6b32fa4fb0013a789ee803e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BC=D0=B5=D0=B4=D0=BE=D0=B2=20=D0=9A=D0=B5?= =?UTF-8?q?=D0=BD=D0=B0=D0=BD=20=D0=AD=D0=BB=D1=8C=D1=87=D0=B8=D0=BD=20?= =?UTF-8?q?=D0=9E=D0=B3=D0=BB=D1=8B?= Date: Sun, 29 Sep 2024 17:13:11 +0300 Subject: [PATCH 4/6] fix --- .github/workflows/release.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index e67c64f..df92952 100755 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -7,7 +7,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Install gtest manually - run: sudo apt-get install libgtest-dev && cd /usr/src/gtest && sudo cmake CMakeLists.txt && sudo make && ls -l lib && sudo cp lib/*.a /usr/lib && sudo ln -s /usr/lib/libgtest.a /usr/local/lib/libgtest.a && sudo ln -s /usr/lib/libgtest_main.a /usr/local/lib/libgtest_main.a + run: sudo apt-get install libgtest-dev libgmock-dev && cd /usr/src/gtest && sudo cmake CMakeLists.txt && sudo make && ls -l lib && sudo cp lib/*.a /usr/lib && sudo ln -s /usr/lib/libgtest.a /usr/local/lib/libgtest.a && sudo ln -s /usr/lib/libgtest_main.a /usr/local/lib/libgtest_main.a - uses: actions/checkout@v1 - name: configure run: mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS="-Werror" .. From c75665c182fcc61c87db9d9bdfe07cdb38d97059 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BC=D0=B5=D0=B4=D0=BE=D0=B2=20=D0=9A=D0=B5?= =?UTF-8?q?=D0=BD=D0=B0=D0=BD=20=D0=AD=D0=BB=D1=8C=D1=87=D0=B8=D0=BD=20?= =?UTF-8?q?=D0=9E=D0=B3=D0=BB=D1=8B?= Date: Sun, 29 Sep 2024 17:27:52 +0300 Subject: [PATCH 5/6] fix --- test/tests.cpp | 126 ++++++++++++++++++++++++------------------------- 1 file changed, 61 insertions(+), 65 deletions(-) diff --git a/test/tests.cpp b/test/tests.cpp index a4333d9..b7821dc 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -1,95 +1,91 @@ // Copyright 2024 MamedovKenan -#include -#include -#include +#include "gtest/gtest.h" #include "TimedDoor.h" +#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] +#include +#include -class MockTimerClient : public TimerClient { - public: - MOCK_METHOD(void, Timeout, (), (override)); -}; +using ::testing::Mock; class MockDoor : public Door { - public: - MOCK_METHOD(void, lock, (), (override)); - MOCK_METHOD(void, unlock, (), (override)); - MOCK_METHOD(bool, isDoorOpened, (), (override)); +public: + MOCK_METHOD(void, lock, (), (override)); + MOCK_METHOD(void, unlock, (), (override)); + MOCK_METHOD(bool, isDoorOpened, (), (override)); }; class TimedDoorTest : public ::testing::Test { - protected: - TimedDoor* door; - Timer* timer; - - void SetUp() override { - door = new TimedDoor(5); - timer = new Timer(); - } - - void TearDown() override { - delete door; - delete timer; - } +protected: + TimedDoor* door; + Timer* timer; + DoorTimerAdapter* adapter; + + void SetUp() override { + door = new TimedDoor(1); + timer = new Timer(); + adapter = new DoorTimerAdapter(*door); + } + + void TearDown() override { + delete door; + delete timer; + delete adapter; + } }; -TEST_F(TimedDoorTest, DoorInitiallyClosed) { - EXPECT_FALSE(door->isDoorOpened()); -} - -TEST_F(TimedDoorTest, DoorCanBeUnlocked) { - door->unlock(); - EXPECT_TRUE(door->isDoorOpened()); -} - -TEST_F(TimedDoorTest, DoorCanBeLocked) { - door->unlock(); - door->lock(); - EXPECT_FALSE(door->isDoorOpened()); -} - TEST_F(TimedDoorTest, TimeoutThrowsWhenDoorOpenedTooLong) { - door->unlock(); - EXPECT_THROW(timer->tregister(1, door), std::runtime_error); + door->unlock(); + EXPECT_THROW(timer->tregister(1, adapter), std::runtime_error); } TEST_F(TimedDoorTest, TimeoutDoesNotThrowWhenDoorClosed) { - door->lock(); - EXPECT_NO_THROW(timer->tregister(1, door)); + door->lock(); + EXPECT_NO_THROW(timer->tregister(1, adapter)); } TEST_F(TimedDoorTest, AdapterTimeoutCallsThrowState) { - MockDoor mockDoor; - EXPECT_CALL(mockDoor, isDoorOpened()) - .WillOnce(testing::Return(true)); + door->unlock(); + timer->tregister(1, adapter); + EXPECT_THROW(adapter->Timeout(), std::runtime_error); +} - DoorTimerAdapter adapter(mockDoor); - EXPECT_THROW(adapter.Timeout(), std::runtime_error); +TEST_F(TimedDoorTest, DoorIsInitiallyClosed) { + EXPECT_FALSE(door->isDoorOpened()); } -TEST_F(TimedDoorTest, TimerCallsTimeout) { - MockTimerClient mockClient; - EXPECT_CALL(mockClient, Timeout()).Times(1); +TEST_F(TimedDoorTest, DoorCanBeOpenedAndClosed) { + door->unlock(); + EXPECT_TRUE(door->isDoorOpened()); + door->lock(); + EXPECT_FALSE(door->isDoorOpened()); +} - timer->tregister(1, &mockClient); - std::this_thread::sleep_for(std::chrono::seconds(2)); +TEST_F(TimedDoorTest, TimeoutWithMultipleRegisters) { + door->unlock(); + timer->tregister(1, adapter); + std::this_thread::sleep_for(std::chrono::seconds(2)); + EXPECT_THROW(adapter->Timeout(), std::runtime_error); } -TEST_F(TimedDoorTest, MultipleTimeouts) { - MockTimerClient mockClient; - EXPECT_CALL(mockClient, Timeout()).Times(2); +TEST_F(TimedDoorTest, TimeoutDoesNotThrowWhenDoorLocked) { + door->lock(); + EXPECT_NO_THROW(timer->tregister(1, adapter)); +} - timer->tregister(1, &mockClient); - timer->tregister(2, &mockClient); - std::this_thread::sleep_for(std::chrono::seconds(3)); +TEST_F(TimedDoorTest, AdapterCallsThrowStateOnTimeout) { + door->unlock(); + EXPECT_CALL(*door, throwState()).Times(1); + adapter->Timeout(); } -TEST_F(TimedDoorTest, DoorTimeoutAfterUnlock) { - door->unlock(); - EXPECT_THROW(timer->tregister(1, door), std::runtime_error); +TEST_F(TimedDoorTest, TimerWorksCorrectly) { + door->lock(); + EXPECT_NO_THROW(timer->tregister(2, adapter)); } -TEST_F(TimedDoorTest, DoorDoesNotThrowAfterLock) { - door->lock(); - EXPECT_NO_THROW(timer->tregister(1, door)); +TEST_F(TimedDoorTest, TimerDoesNotCallWhenDoorClosed) { + door->lock(); + EXPECT_NO_THROW(timer->tregister(1, adapter)); } From 479e2d52db216d557117c4830b2e1f19b4227715 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B0=D0=BC=D0=B5=D0=B4=D0=BE=D0=B2=20=D0=9A=D0=B5?= =?UTF-8?q?=D0=BD=D0=B0=D0=BD=20=D0=AD=D0=BB=D1=8C=D1=87=D0=B8=D0=BD=20?= =?UTF-8?q?=D0=9E=D0=B3=D0=BB=D1=8B?= Date: Sun, 29 Sep 2024 17:50:11 +0300 Subject: [PATCH 6/6] fix files --- include/TimedDoor.h | 38 ++++++++-------- src/TimedDoor.cpp | 35 ++++++++------- test/tests.cpp | 103 ++++++++++++++++++++------------------------ 3 files changed, 82 insertions(+), 94 deletions(-) diff --git a/include/TimedDoor.h b/include/TimedDoor.h index 465c1a6..6b60059 100644 --- a/include/TimedDoor.h +++ b/include/TimedDoor.h @@ -10,43 +10,43 @@ class TimedDoor; class TimerClient { public: - virtual void Timeout() = 0; + virtual void Timeout() = 0; }; class Door { public: - virtual void lock() = 0; - virtual void unlock() = 0; - virtual bool isDoorOpened() = 0; + virtual void lock() = 0; + virtual void unlock() = 0; + virtual bool isDoorOpened() = 0; }; class DoorTimerAdapter : public TimerClient { private: - TimedDoor& door; + TimedDoor& door; public: - explicit DoorTimerAdapter(TimedDoor&); - void Timeout(); + explicit DoorTimerAdapter(TimedDoor &); + void Timeout(); }; class TimedDoor : public Door { private: - DoorTimerAdapter * adapter; - int iTimeout; - bool isOpened; + DoorTimerAdapter * adapter; + int iTimeout; + bool isOpened; public: - explicit TimedDoor(int); - bool isDoorOpened(); - void unlock(); - void lock(); - int getTimeOut() const; - void throwState(); + explicit TimedDoor(int); + bool isDoorOpened(); + void unlock(); + void lock(); + int getTimeOut() const; + void throwState(); }; class Timer { - TimerClient *client; - void sleep(int); + TimerClient *client; + void sleep(int); public: - void tregister(int, TimerClient*); + void tregister(int, TimerClient*); }; #endif // INCLUDE_TIMEDDOOR_H_ diff --git a/src/TimedDoor.cpp b/src/TimedDoor.cpp index a078dce..464e7ab 100644 --- a/src/TimedDoor.cpp +++ b/src/TimedDoor.cpp @@ -1,19 +1,19 @@ // Copyright 2024 MamedovKenan -#include "TimedDoor.h" #include #include // NOLINT [build/c++11] #include // NOLINT [build/c++11] +#include "TimedDoor.h" -DoorTimerAdapter::DoorTimerAdapter(TimedDoor& d) : door(d) {} +DoorTimerAdapter::DoorTimerAdapter(TimedDoor& door_) : door(door_) {} void DoorTimerAdapter::Timeout() { - if (door.isDoorOpened()) { - door.throwState(); - } + if (door.isDoorOpened()) + throw std::runtime_error("Time's up!"); + return; } -TimedDoor::TimedDoor(int timeout) : iTimeout(timeout), isOpened(false) { +TimedDoor::TimedDoor(int timeout_) : iTimeout(timeout_), isOpened(false) { adapter = new DoorTimerAdapter(*this); } @@ -22,12 +22,14 @@ bool TimedDoor::isDoorOpened() { } void TimedDoor::unlock() { + if (isOpened) + throw std::logic_error("Door is already opened"); isOpened = true; - Timer timer; - timer.tregister(iTimeout, adapter); } void TimedDoor::lock() { + if (!isOpened) + throw std::logic_error("Door is already closed"); isOpened = false; } @@ -36,18 +38,15 @@ int TimedDoor::getTimeOut() const { } void TimedDoor::throwState() { - throw std::runtime_error("Door is open for too long!"); + adapter->Timeout(); } -void Timer::tregister(int seconds, TimerClient* client) { - this->client = client; - - std::thread([this, seconds, client]() { - sleep(seconds); - client->Timeout(); - }).detach(); +void Timer::sleep(int time_) { + std::this_thread::sleep_for(std::chrono::seconds(time_)); } -void Timer::sleep(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(); } diff --git a/test/tests.cpp b/test/tests.cpp index b7821dc..d8a5a42 100644 --- a/test/tests.cpp +++ b/test/tests.cpp @@ -1,91 +1,80 @@ // Copyright 2024 MamedovKenan -#include "gtest/gtest.h" -#include "TimedDoor.h" -#include // NOLINT [build/c++11] -#include // NOLINT [build/c++11] -#include +#include #include +#include +#include // NOLINT [build/c++11] +#include // NOLINT [build/c++11] +#include "TimedDoor.h" -using ::testing::Mock; - -class MockDoor : public Door { -public: - MOCK_METHOD(void, lock, (), (override)); - MOCK_METHOD(void, unlock, (), (override)); - MOCK_METHOD(bool, isDoorOpened, (), (override)); +class MockTimerClient : public TimerClient { + public: + MOCK_METHOD(void, Timeout, (), (override)); }; class TimedDoorTest : public ::testing::Test { -protected: - TimedDoor* door; - Timer* timer; - DoorTimerAdapter* adapter; + protected: + TimedDoor door; + MockTimerClient mockClient; + Timer timer; + + TimedDoorTest() : door(1), timer() {} void SetUp() override { - door = new TimedDoor(1); - timer = new Timer(); - adapter = new DoorTimerAdapter(*door); + timer.tregister(door.getTimeOut(), &mockClient); } void TearDown() override { - delete door; - delete timer; - delete adapter; + testing::Mock::VerifyAndClearExpectations(&mockClient); } }; -TEST_F(TimedDoorTest, TimeoutThrowsWhenDoorOpenedTooLong) { - door->unlock(); - EXPECT_THROW(timer->tregister(1, adapter), std::runtime_error); +TEST_F(TimedDoorTest, Timeout) { + door.unlock(); + std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut())); + EXPECT_THROW(door.throwState(), std::runtime_error); } -TEST_F(TimedDoorTest, TimeoutDoesNotThrowWhenDoorClosed) { - door->lock(); - EXPECT_NO_THROW(timer->tregister(1, adapter)); +TEST_F(TimedDoorTest, LockUnlock) { + std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut() + 1)); + EXPECT_NO_THROW(door.throwState()); } -TEST_F(TimedDoorTest, AdapterTimeoutCallsThrowState) { - door->unlock(); - timer->tregister(1, adapter); - EXPECT_THROW(adapter->Timeout(), std::runtime_error); +TEST_F(TimedDoorTest, LockBeforeTimeout) { + std::this_thread::sleep_for(std::chrono::seconds(door.getTimeOut() + 1)); + door.unlock(); + EXPECT_THROW(door.throwState(), std::runtime_error); } -TEST_F(TimedDoorTest, DoorIsInitiallyClosed) { - EXPECT_FALSE(door->isDoorOpened()); +TEST_F(TimedDoorTest, UnlockMth) { + door.unlock(); + EXPECT_TRUE(door.isDoorOpened()); } -TEST_F(TimedDoorTest, DoorCanBeOpenedAndClosed) { - door->unlock(); - EXPECT_TRUE(door->isDoorOpened()); - door->lock(); - EXPECT_FALSE(door->isDoorOpened()); +TEST_F(TimedDoorTest, LockMth) { + door.unlock(); + door.lock(); + EXPECT_FALSE(door.isDoorOpened()); } -TEST_F(TimedDoorTest, TimeoutWithMultipleRegisters) { - door->unlock(); - timer->tregister(1, adapter); - std::this_thread::sleep_for(std::chrono::seconds(2)); - EXPECT_THROW(adapter->Timeout(), std::runtime_error); +TEST_F(TimedDoorTest, ClosedDoor) { + EXPECT_FALSE(door.isDoorOpened()); } -TEST_F(TimedDoorTest, TimeoutDoesNotThrowWhenDoorLocked) { - door->lock(); - EXPECT_NO_THROW(timer->tregister(1, adapter)); +TEST_F(TimedDoorTest, UnlockThrow) { + door.unlock(); + EXPECT_THROW(door.unlock(), std::logic_error); } -TEST_F(TimedDoorTest, AdapterCallsThrowStateOnTimeout) { - door->unlock(); - EXPECT_CALL(*door, throwState()).Times(1); - adapter->Timeout(); +TEST_F(TimedDoorTest, ThrowState) { + door.unlock(); + EXPECT_THROW(door.throwState(), std::runtime_error); } -TEST_F(TimedDoorTest, TimerWorksCorrectly) { - door->lock(); - EXPECT_NO_THROW(timer->tregister(2, adapter)); +TEST_F(TimedDoorTest, CloseBefore) { + EXPECT_NO_THROW(door.throwState()); } -TEST_F(TimedDoorTest, TimerDoesNotCallWhenDoorClosed) { - door->lock(); - EXPECT_NO_THROW(timer->tregister(1, adapter)); +TEST_F(TimedDoorTest, LockDtw) { + EXPECT_THROW(door.lock(), std::logic_error); }