Task3

CMakeLists.txt

@@ -8,6 +8,15 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -g")
 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)

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();
 };
 

include/TimedDoor.h

@@ -1,4 +1,4 @@
-// Copyright 2021 GHA Test Team
+// Copyright 2024 Kokin Ivan
 
 #ifndef INCLUDE_TIMEDDOOR_H_
 #define 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();
 };
 

src/TimedDoor.cpp

@@ -0,0 +1,60 @@
+// Copyright 2024 Kokin Ivan
+
+#include <stdexcept>
+#include <thread> // NOLINT [build/c++11]
+#include <chrono> // NOLINT [build/c++11]
+
+#include "TimedDoor.h"
+
+void Timer::sleep(int sec) {
+    std::this_thread::sleep_for(std::chrono::seconds(sec));
+}
+
+void Timer::tregister(int sec, TimerClient* timer) {
+    client = timer;
+    sleep(sec);
+    client->Timeout();
+    client = nullptr;
+}
+
+DoorTimerAdapter::DoorTimerAdapter(TimedDoor& door) : door(door) {}
+
+void DoorTimerAdapter::Timeout() {
+    if (door.isDoorOpened()) {
+        throw std::runtime_error("Door open so looooooong");
+    }
+}
+
+TimedDoor::TimedDoor(int timeout) : iTimeout(timeout), isOpened(false) {
+    adapter = new DoorTimerAdapter(*this);
+}
+
+bool TimedDoor::isDoorOpened() {
+    return isOpened;
+}
+
+void TimedDoor::lock() {
+    if (!isOpened) {
+        throw std::logic_error("Error! Door locked");
+    }
+    isOpened = false;
+}
+
+void TimedDoor::unlock() {
+    if (isOpened) {
+        throw std::logic_error("Error! Door unlocked");
+    }
+    isOpened = true;
+}
+
+int TimedDoor::getTimeOut() const {
+    return iTimeout;
+}
+
+void TimedDoor::throwState() {
+    if (isOpened) {
+        throw std::runtime_error("Error! Opened");
+    } else {
+        throw std::runtime_error("Error! Closed");
+    }
+}

src/main.cpp

@@ -1,4 +1,4 @@
-// Copyright 2021 GHA Test Team
+// Copyright 2024 Kokin Ivan
 #include "TimedDoor.h"
 #include <iostream>
 

test/tests.cpp

@@ -1,6 +1,81 @@
-// Copyright 2021 GHA Test Team
+// Copyright 2024 Kokin Ivan
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <cstdint>
+#include <thread> // NOLINT [build/c++11]
+#include <chrono> // 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 *timerC;
+    Timer timer;
+ public:
+    TimedDoorTest() : door(1), timer() {}
+ protected:
+    void SetUp() override {
+        timerC = new MockTimerClient();
+    }
+
+    void TearDown() override {
+        delete timerC;
+    }
+};
+
+TEST_F(TimedDoorTest, TimedDoorLockedDef) {
+    EXPECT_FALSE(door.isDoorOpened());
+}
+
+TEST_F(TimedDoorTest, DoorTimerAdapter) {
+    DoorTimerAdapter adapter(door);
+    EXPECT_NO_THROW(adapter.Timeout());
+}
+
+TEST_F(TimedDoorTest, TimedDoorLock) {
+    EXPECT_THROW(door.lock(), std::logic_error);
+}
+
+TEST_F(TimedDoorTest, Lock) {
+    door.unlock();
+    door.lock();
+    EXPECT_FALSE(door.isDoorOpened());
+}
+
+TEST_F(TimedDoorTest, opened_exception_throw) {
+    door.unlock();
+    EXPECT_THROW(door.throwState(), std::runtime_error);
+}
+
+TEST_F(TimedDoorTest, throw_lock) {
+    door.unlock();
+    door.lock();
+    EXPECT_THROW(door.throwState(), std::runtime_error);
+}
+
+TEST_F(TimedDoorTest, Unclock_test) {
+    door.unlock();
+    EXPECT_THROW(door.unlock(), std::logic_error);
+}
+
+TEST_F(TimedDoorTest, TimerTimeoutCall) {
+    EXPECT_CALL(*timerC, Timeout()).Times(1);
+    timer.tregister(100, timerC);
+}
+
+TEST_F(TimedDoorTest, TimeoutThrowsOnUnlocked) {
+    DoorTimerAdapter adapter(door);
+    door.unlock();
+    EXPECT_THROW(adapter.Timeout(), std::runtime_error);
+}
+
+TEST_F(TimedDoorTest, unlock_door_test) {
+    door.unlock();
+    EXPECT_TRUE(door.isDoorOpened());
+}