fix files

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_

src/TimedDoor.cpp

@@ -1,19 +1,19 @@
 // Copyright 2024 MamedovKenan
 
-#include "TimedDoor.h"
 #include <stdexcept>
 #include <thread> // NOLINT [build/c++11]
 #include <chrono> // 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();
 }

test/tests.cpp

@@ -1,91 +1,80 @@
 // Copyright 2024 MamedovKenan
 
-#include "gtest/gtest.h"
-#include "TimedDoor.h"
-#include <thread> // NOLINT [build/c++11]
-#include <chrono> // NOLINT [build/c++11]
-#include <stdexcept>
+#include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#include <cstdint>
+#include <chrono> // NOLINT [build/c++11]
+#include <thread> // 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);
 }