Белан Вадим. b52

CMakeLists.txt

@@ -9,5 +9,13 @@ 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)
+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,13 +1,8 @@
-// Copyright 2021 GHA Test Team
+// Copyright 2024 Vadim Belan
 
 #ifndef INCLUDE_TIMEDDOOR_H_
 #define INCLUDE_TIMEDDOOR_H_
 
-class DoorTimerAdapter;
-class Timer;
-class Door;
-class TimedDoor;
-
 class TimerClient {
  public:
   virtual void Timeout() = 0;
@@ -20,30 +15,35 @@ class Door {
   virtual bool isDoorOpened() = 0;
 };
 
+class TimedDoor;
+
 class DoorTimerAdapter : public TimerClient {
  private:
   TimedDoor& door;
  public:
   explicit DoorTimerAdapter(TimedDoor&);
-  void Timeout();
+  void Timeout() override;
+  TimedDoor& getDoor() const;
 };
 
 class TimedDoor : public Door {
  private:
-  DoorTimerAdapter * adapter;
+  DoorTimerAdapter* adapter;
   int iTimeout;
-  bool opened;
+  bool isOpened;
  public:
   explicit TimedDoor(int);
-  bool isDoorOpened();
-  void unlock();
-  void lock();
-  void DoorTimeOut();
+  bool isDoorOpened() override;
+  void unlock() override;
+  void lock() override;
+  int getTimeOut() const;
   void throwState();
+  DoorTimerAdapter* getAdapter();
 };
 
 class Timer {
-  TimerClient *client;
+ private:
+  TimerClient* client;
   void sleep(int);
  public:
   void tregister(int, TimerClient*);

src/CMakeLists.txt

@@ -27,4 +27,4 @@ install(TARGETS ${PROJECT_NAME}
 install(TARGETS ${PROJECT_NAME}.info
         RUNTIME DESTINATION "${tool_dest}"
     COMPONENT library)
-install(FILES ${header} DESTINATION "${include_dest}")
+install(FILES ${header} DESTINATION "${include_dest}")

src/TimedDoor.cpp

@@ -0,0 +1,55 @@
+// Copyright 2024 Vadim Belan
+
+#include <stdexcept>
+#include <thread>  // NOLINT [build/c++11]
+#include <chrono>  // NOLINT [build/c++11]
+#include "TimedDoor.h"
+
+DoorTimerAdapter::DoorTimerAdapter(TimedDoor& door) : door(door) {}
+
+void DoorTimerAdapter::Timeout() {
+    if (door.isDoorOpened()) {
+        door.throwState();
+    }
+}
+
+TimedDoor& DoorTimerAdapter::getDoor() const {
+    return door;
+}
+
+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 left open!");
+}
+
+DoorTimerAdapter* TimedDoor::getAdapter() {
+    return adapter;
+}
+
+void Timer::tregister(int timeout, TimerClient* client) {
+    this->client = client;
+    sleep(timeout);
+    client->Timeout();
+}
+
+void Timer::sleep(int seconds) {
+    std::this_thread::sleep_for(std::chrono::seconds(seconds));
+}

src/main.cpp

@@ -1,11 +1,12 @@
-// Copyright 2021 GHA Test Team
-#include "TimedDoor.h"
+// Copyright 2024 Vadim Belan
+
 #include <iostream>
+#include "TimedDoor.h"
 
 int main() {
-  TimedDoor tDoor(5);
-  tDoor.lock();
-  tDoor.unlock();
+    TimedDoor tDoor(5);
+    tDoor.lock();
+    tDoor.unlock();
 
-  return 0;
+    return 0;
 }

test/CMakeLists.txt

@@ -7,4 +7,4 @@ target_compile_definitions(${PROJECT_NAME}.test
   PRIVATE TEST_DIR="${CMAKE_CURRENT_LIST_DIR}/test")
 
 install(TARGETS ${PROJECT_NAME}.test
-        DESTINATION "${tool_dest}")
+        DESTINATION "${tool_dest}")

test/tests.cpp

@@ -1,6 +1,97 @@
-// Copyright 2021 GHA Test Team
+// Copyright 2024 Vadim Belan
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
-#include <cstdint>
+#include <thread>  // NOLINT [build/c++11]
 #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));
+    MOCK_METHOD(void, throwState, (), ());
+};
+
+class TimedDoorTest : public testing::Test {
+ protected:
+    TimedDoor* timedDoor;
+    Timer* timer;
+
+    void SetUp() override {
+        timedDoor = new TimedDoor(2);
+        timer = new Timer();
+    }
+
+    void TearDown() override {
+        delete timedDoor;
+        delete timer;
+    }
+};
+
+TEST_F(TimedDoorTest, DoorInitiallyClosed) {
+    EXPECT_FALSE(timedDoor->isDoorOpened());
+}
+
+TEST_F(TimedDoorTest, UnlockDoor) {
+    timedDoor->unlock();
+    EXPECT_TRUE(timedDoor->isDoorOpened());
+}
+
+TEST_F(TimedDoorTest, LockDoor) {
+    timedDoor->unlock();
+    timedDoor->lock();
+    EXPECT_FALSE(timedDoor->isDoorOpened());
+}
+
+TEST_F(TimedDoorTest, TimeoutThrowsExceptionIfDoorOpened) {
+    timedDoor->unlock();
+    EXPECT_THROW({
+        timer->tregister(timedDoor->getTimeOut(), timedDoor->getAdapter());
+    }, std::runtime_error);
+}
+
+TEST_F(TimedDoorTest, TimeoutDoesNotThrowIfDoorClosed) {
+    EXPECT_NO_THROW({
+        timer->tregister(timedDoor->getTimeOut(), timedDoor->getAdapter());
+    });
+}
+
+TEST(MockedDoorTest, TimerCallsTimeout) {
+    MockTimerClient mockClient;
+    EXPECT_CALL(mockClient, Timeout()).Times(1);
+
+    Timer timer;
+    timer.tregister(1, &mockClient);
+}
+
+TEST_F(TimedDoorTest, AdapterLinksToTimedDoor) {
+    DoorTimerAdapter adapter(*timedDoor);
+    EXPECT_EQ(&adapter.getDoor(), timedDoor);
+}
+
+TEST_F(TimedDoorTest, DoorInitiallyLocked) {
+    EXPECT_FALSE(timedDoor->isDoorOpened());
+}
+
+TEST_F(TimedDoorTest, UnlockingAndLockingDoorTwice) {
+    timedDoor->unlock();
+    timedDoor->lock();
+    timedDoor->unlock();
+    timedDoor->lock();
+    EXPECT_FALSE(timedDoor->isDoorOpened());
+}
+
+TEST_F(TimedDoorTest, UnlockingDoorAndThenTimingOut) {
+    timedDoor->unlock();
+    std::this_thread::sleep_for
+    (std::chrono::seconds(timedDoor->getTimeOut() + 1));
+    EXPECT_THROW({
+        timer->tregister(timedDoor->getTimeOut(), timedDoor->getAdapter());
+    }, std::runtime_error);
+}