refactor(tests): organize test namespaces

Makefile

@@ -1,21 +1,30 @@
+export ROOT_DIR := $(CURDIR)
+
+export BUILD_DIR := $(ROOT_DIR)/build
+
+export CC := gcc
+
+export CXXFLAGS := \
+	-std=c++17 \
+	-Wall \
+	-Wextra \
+	-Werror
+
+export LDLIBS := -lstdc++
+
 .PHONY: all logger app tests clean
 
-
 all: logger app tests
 
-
 logger:
 	$(MAKE) -C logger
 
-
 app: logger
 	$(MAKE) -C app
 
-
-tests: logger
+tests:
 	$(MAKE) -C tests
 
-
 clean:
 	$(MAKE) -C logger clean
 	$(MAKE) -C app clean

app/Makefile

@@ -1,41 +1,23 @@
-ROOT_DIR := $(abspath ..)
-
-CC := gcc
-
-CXXFLAGS := -std=c++17 \
-            -Wall \
-            -Wextra \
-            -Werror \
+CXXFLAGS := \
 	-I$(ROOT_DIR)/core/include \
 	-I$(ROOT_DIR)/logger/include
 
 LDFLAGS := -L$(ROOT_DIR)/build \
-           -llogger \
-           -lstdc++ \
-           -Wl,-rpath,$(ROOT_DIR)/build
+           -Wl,-rpath,'$$ORIGIN'
 
-BUILD_DIR := $(ROOT_DIR)/build
+LDLIBS += -llogger
 
 TARGET := $(BUILD_DIR)/logger_app
 
 SRC := src/main.cpp
 
-
 .PHONY: all clean
 
-
 all: $(TARGET)
 
-
 $(TARGET): $(SRC)
 	@mkdir -p $(BUILD_DIR)
-
-	$(CC) \
-		$(CXXFLAGS) \
-		$< \
-		-o $@ \
-		$(LDFLAGS)
-
+	$(CC) $(CXXFLAGS) $(LDFLAGS) $^ -o $@ $(LDLIBS)
 
 clean:
 	rm -f $(TARGET)

app/include/log_message.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+
+#include "log_level.hpp"
+
+namespace app {
+
+/**
+ * @brief Сообщение, передаваемое в поток записи.
+ *
+ * Содержит текст сообщения и уровень логирования,
+ * с которым оно должно быть записано в журнал.
+ */
+struct LogMessage {
+  /**
+   * @brief Уровень логирования сообщения.
+   */
+  logger::LogLevel level;
+
+  /**
+   * @brief Текст сообщения.
+   */
+  std::string message;
+};
+
+} // namespace app

app/include/message_queue.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+
+#include "log_message.hpp"
+
+namespace app {
+
+/**
+ * @brief Потокобезопасная очередь сообщений.
+ *
+ * Используется для передачи сообщений от потока,
+ * принимающего ввод пользователя, к потоку,
+ * выполняющему запись в журнал.
+ */
+class MessageQueue {
+public:
+  /**
+   * @brief Добавляет сообщение в очередь.
+   *
+   * Метод является потокобезопасным.
+   *
+   * @param message Сообщение для передачи.
+   */
+  void push(LogMessage message);
+
+  /**
+   * @brief Извлекает сообщение из очереди.
+   *
+   * Если очередь пуста, метод блокирует вызывающий
+   * поток до появления нового сообщения.
+   *
+   * Метод является потокобезопасным.
+   *
+   * @return Следующее сообщение из очереди.
+   */
+  [[nodiscard]]
+  LogMessage pop();
+
+  /**
+   * @brief Проверяет, пуста ли очередь.
+   *
+   * Метод является потокобезопасным.
+   *
+   * @return true, если очередь не содержит сообщений.
+   * @return false, если очередь содержит хотя бы одно сообщение.
+   */
+  [[nodiscard]]
+  bool empty() const;
+
+private:
+  /**
+   * @brief Очередь сообщений.
+   */
+  std::queue<LogMessage> queue_;
+
+  /**
+   * @brief Мьютекс для синхронизации доступа к очереди.
+   */
+  mutable std::mutex mutex_;
+
+  /**
+   * @brief Условная переменная для ожидания новых сообщений.
+   */
+  std::condition_variable conditionVariable_;
+};
+
+} // namespace app

app/src/message_queue.cpp

@@ -0,0 +1,31 @@
+#include "message_queue.hpp"
+
+namespace app {
+
+void MessageQueue::push(LogMessage message) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  queue_.push(std::move(message));
+
+  conditionVariable_.notify_one();
+}
+
+LogMessage MessageQueue::pop() {
+  std::unique_lock<std::mutex> lock(mutex_);
+
+  conditionVariable_.wait(lock, [this]() { return !queue_.empty(); });
+
+  auto message = std::move(queue_.front());
+
+  queue_.pop();
+
+  return message;
+}
+
+bool MessageQueue::empty() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  return queue_.empty();
+}
+
+} // namespace app

logger/Makefile

@@ -1,41 +1,24 @@
-ROOT_DIR := $(abspath ..)
-
-CC := gcc
-
-CXXFLAGS := -std=c++17 \
-            -Wall \
-            -Wextra \
-            -Werror \
-            -fPIC \
+CXXFLAGS += \
 	-I$(ROOT_DIR)/core/include \
 	-Iinclude
 
-LDFLAGS := -lstdc++
-
-BUILD_DIR := $(ROOT_DIR)/build
+LDFLAGS := \
+	-shared \
+	-Wl,--no-undefined
 
 TARGET := $(BUILD_DIR)/liblogger.so
 
-SRC := src/logger.cpp \
+SRC := \
+	src/logger.cpp \
 	src/time_utils.cpp
 
-
 .PHONY: all clean
 
-
 all: $(TARGET)
 
-
 $(TARGET): $(SRC)
 	@mkdir -p $(BUILD_DIR)
-
-	$(CC) \
-		$(CXXFLAGS) \
-		-shared \
-		$^ \
-		-o $@ \
-		$(LDFLAGS)
-
+	$(CC) $(CXXFLAGS) $(LDFLAGS) $^ -o $@ $(LDLIBS)
 
 clean:
 	rm -f $(TARGET)

tests/Makefile

@@ -1,62 +1,13 @@
 ROOT_DIR := $(abspath ..)
 
-CXX := gcc
-
-CXXFLAGS := -std=c++17 \
-            -Wall \
-            -Wextra \
-            -Werror \
-            -I$(ROOT_DIR)/core/include \
-            -I$(ROOT_DIR)/logger/include \
-            -Ihelpers
-
-LDFLAGS := -lstdc++
-
-BUILD_DIR := $(ROOT_DIR)/build
-
-
-RESULT_TEST_BIN := $(BUILD_DIR)/result_test
-LOGGER_TEST_BIN := $(BUILD_DIR)/logger_test
-SCOPED_FILE_TEST_BIN := $(BUILD_DIR)/scoped_file_test
-
-
-RESULT_TEST_SRC := core/result_test.cpp
-LOGGER_TEST_SRC := core/logger_test.cpp
-SCOPED_FILE_TEST_SRC := helpers/scoped_file_test.cpp
-
-
-LOGGER_SRC := $(ROOT_DIR)/logger/src/logger.cpp \
-              $(ROOT_DIR)/logger/src/time_utils.cpp
-
-
-.PHONY: all test clean
-
-
-all: test
-
-
-test: $(RESULT_TEST_BIN) \
-      $(LOGGER_TEST_BIN) \
-      $(SCOPED_FILE_TEST_BIN)
-	$(RESULT_TEST_BIN)
-	$(LOGGER_TEST_BIN)
-	$(SCOPED_FILE_TEST_BIN)
-
-
-$(RESULT_TEST_BIN): $(RESULT_TEST_SRC)
-	@mkdir -p $(BUILD_DIR)
-	$(CXX) $(CXXFLAGS) $< -o $@ $(LDFLAGS)
-
-
-$(LOGGER_TEST_BIN): $(LOGGER_TEST_SRC) $(LOGGER_SRC)
-	@mkdir -p $(BUILD_DIR)
-	$(CXX) $(CXXFLAGS) $^ -o $@ $(LDFLAGS)
-
-
-$(SCOPED_FILE_TEST_BIN): $(SCOPED_FILE_TEST_SRC)
-	@mkdir -p $(BUILD_DIR)
-	$(CXX) $(CXXFLAGS) $< -o $@ $(LDFLAGS)
+.PHONY: all clean
 
+all:
+	$(MAKE) -C app
+	$(MAKE) -C core
+	$(MAKE) -C logger
 
 clean:
-	rm -rf $(BUILD_DIR)
+	$(MAKE) -C app clean
+	$(MAKE) -C core clean
+	$(MAKE) -C logger clean

tests/app/Makefile

@@ -0,0 +1,23 @@
+CXXFLAGS += \
+	-I$(ROOT_DIR)/app/include \
+	-I$(ROOT_DIR)/logger/include \
+	-Ihelpers
+
+TARGET := $(BUILD_DIR)/app_test
+
+SRC := \
+	$(ROOT_DIR)/app/src/message_queue.cpp \
+	helpers/thread_test_utils.cpp \
+	message_queue_test.cpp
+
+.PHONY: all clean
+
+all: $(TARGET)
+	$(TARGET)
+
+$(TARGET): $(SRC)
+	@mkdir -p $(BUILD_DIR)
+	$(CC) $(CXXFLAGS) $^ -o $@ $(LDLIBS)
+
+clean:
+	rm -f $(TARGET)

tests/app/helpers/thread_test_utils.cpp

@@ -0,0 +1,23 @@
+#include "thread_test_utils.hpp"
+
+#include <cassert>
+#include <cstddef>
+#include <thread>
+
+namespace app::tests::helpers {
+
+std::thread createProducer(MessageQueue &queue, std::size_t threadIndex,
+                           std::size_t messagesCount) {
+  return std::thread([&queue, threadIndex, messagesCount]() {
+    for (std::size_t messageIndex = 0; messageIndex < messagesCount;
+         ++messageIndex) {
+      queue.push({
+          logger::LogLevel::info(),
+          "Thread " + std::to_string(threadIndex) + ", message " +
+              std::to_string(messageIndex),
+      });
+    }
+  });
+}
+
+} // namespace app::tests::helpers

tests/app/helpers/thread_test_utils.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstddef>
+#include <thread>
+
+#include "message_queue.hpp"
+
+namespace app::tests::helpers {
+
+std::thread createProducer(MessageQueue &queue, std::size_t threadIndex,
+                           std::size_t messagesCount);
+
+} // namespace app::tests::helpers

tests/app/message_queue_test.cpp

@@ -0,0 +1,105 @@
+#include <cassert>
+#include <thread>
+#include <vector>
+
+#include "log_level.hpp"
+#include "message_queue.hpp"
+#include "thread_test_utils.hpp"
+
+namespace app::tests {
+
+using namespace app;
+
+void testPushAndPop() {
+  MessageQueue queue;
+
+  queue.push({logger::LogLevel::info(), "Hello"});
+
+  auto message = queue.pop();
+
+  assert(message.level == logger::LogLevel::info());
+  assert(message.message == "Hello");
+}
+
+void testFifoOrder() {
+  MessageQueue queue;
+
+  queue.push({logger::LogLevel::debug(), "first"});
+  queue.push({logger::LogLevel::info(), "second"});
+  queue.push({logger::LogLevel::error(), "third"});
+
+  assert(queue.pop().message == "first");
+  assert(queue.pop().message == "second");
+  assert(queue.pop().message == "third");
+}
+
+void testPopWaitsForMessage() {
+  MessageQueue queue;
+
+  bool received = false;
+
+  std::thread worker([&]() {
+    auto message = queue.pop();
+
+    assert(message.level == logger::LogLevel::error());
+    assert(message.message == "Delayed");
+
+    received = true;
+  });
+
+  // Даём потоку worker возможность дойти до queue.pop()
+  // и заблокироваться в ожидании сообщения.
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+  assert(!received);
+
+  // Добавляем сообщение и тем самым разблокируем worker.
+  queue.push({logger::LogLevel::error(), "Delayed"});
+
+  // Ожидаем полного завершения потока worker.
+  worker.join();
+
+  assert(received);
+}
+
+void testConcurrentPushAndPop() {
+  MessageQueue queue;
+
+  constexpr std::size_t threadCount = 8;
+  constexpr std::size_t messagesPerThread = 1000;
+
+  std::vector<std::thread> producers;
+
+  for (std::size_t i = 0; i < threadCount; ++i) {
+    producers.emplace_back(
+        helpers::createProducer(queue, i, messagesPerThread));
+  }
+  const auto expectedMessages = threadCount * messagesPerThread;
+
+  for (std::size_t i = 0; i < expectedMessages; ++i) {
+    auto message = queue.pop();
+
+    assert(!message.message.empty());
+  }
+
+  for (auto &producer : producers) {
+    producer.join();
+  }
+
+  assert(queue.empty());
+}
+
+void runTests() {
+  testPushAndPop();
+  testFifoOrder();
+  testPopWaitsForMessage();
+  testConcurrentPushAndPop();
+}
+
+} // namespace app::tests
+
+int main() {
+  app::tests::runTests();
+
+  return 0;
+}

tests/core/Makefile

@@ -0,0 +1,18 @@
+CXXFLAGS += \
+	-I$(ROOT_DIR)/core/include
+
+TARGET := $(BUILD_DIR)/result_test
+
+SRC := result_test.cpp
+
+.PHONY: all clean
+
+all: $(TARGET)
+	$(TARGET)
+
+$(TARGET): $(SRC)
+	@mkdir -p $(BUILD_DIR)
+	$(CC) $(CXXFLAGS) $^ -o $@ $(LDLIBS)
+
+clean:
+	rm -f $(TARGET)

tests/core/logger_test.cpp

@@ -1,123 +0,0 @@
-#include <cassert>
-#include <fstream>
-#include <string>
-
-#include "logger.hpp"
-
-namespace {
-
-using namespace logger;
-
-void testLoggerCreation() {
-  Logger logger("test.log", LogLevel::info());
-
-  assert(logger.getFileName() == "test.log");
-  assert(logger.getLogLevel() == LogLevel::info());
-}
-
-void testWithLogLevel() {
-  Logger logger("test.log", LogLevel::info());
-
-  auto debugLogger = logger.withLogLevel(LogLevel::debug());
-
-  // Исходный объект не изменился
-  assert(logger.getLogLevel() == LogLevel::info());
-
-  // Новый объект получил новый уровень
-  assert(debugLogger.getLogLevel() == LogLevel::debug());
-
-  // Имя файла сохранилось
-  assert(debugLogger.getFileName() == "test.log");
-}
-
-void testWithFileName() {
-  Logger logger("old.log", LogLevel::info());
-
-  auto newLogger = logger.withFileName("new.log");
-
-  // Исходный объект не изменился
-  assert(logger.getFileName() == "old.log");
-
-  // Новый объект получил новый файл
-  assert(newLogger.getFileName() == "new.log");
-
-  // Уровень сохранился
-  assert(newLogger.getLogLevel() == LogLevel::info());
-}
-
-void testWriteLogSuccess() {
-  const std::string fileName = "logger_test.log";
-
-  Logger logger(fileName, LogLevel::info());
-
-  auto result = logger.writeMessage(LogLevel::info(), "Application started");
-
-  assert(result.isSuccess());
-  assert(result.getValue());
-
-  std::ifstream file(fileName);
-
-  assert(file.is_open());
-
-  std::string content;
-  std::getline(file, content);
-
-  assert(content.find("Application started") != std::string::npos);
-
-  file.close();
-
-  std::remove(fileName.c_str());
-}
-
-void testWriteLogFailure() {
-  Logger logger("/invalid/path/logger.log", LogLevel::info());
-
-  auto result = logger.writeMessage(LogLevel::info(), "message");
-
-  assert(result.isFailure());
-  assert(!result.getError().empty());
-}
-
-void testMultipleWrites() {
-  const std::string fileName = "multiple.log";
-
-  Logger logger(fileName, LogLevel::info());
-
-  assert(logger.writeMessage(LogLevel::info(), "first").isSuccess());
-
-  assert(logger.writeMessage(LogLevel::error(), "second").isSuccess());
-
-  std::ifstream file(fileName);
-
-  assert(file.is_open());
-
-  std::string line1;
-  std::string line2;
-
-  std::getline(file, line1);
-  std::getline(file, line2);
-
-  assert(line1.find("first") != std::string::npos);
-  assert(line2.find("second") != std::string::npos);
-
-  file.close();
-
-  std::remove(fileName.c_str());
-}
-
-void runTests() {
-  testLoggerCreation();
-  testWithLogLevel();
-  testWithFileName();
-  testWriteLogSuccess();
-  testWriteLogFailure();
-  testMultipleWrites();
-}
-
-} // namespace
-
-int main() {
-  runTests();
-
-  return 0;
-}

tests/core/result_test.cpp

@@ -4,7 +4,7 @@
 
 #include "result.hpp"
 
-namespace {
+namespace core::tests {
 
 using namespace core;
 
@@ -108,9 +108,9 @@ void runAllTests() {
   testBasicResultWithCustomError();
 }
 
-} // namespace
+} // namespace core::tests
 
 int main() {
-  runAllTests();
+  core::tests::runAllTests();
   return 0;
 }

tests/logger/Makefile

@@ -0,0 +1,27 @@
+CXXFLAGS += \
+	-I$(ROOT_DIR)/core/include \
+	-I$(ROOT_DIR)/logger/include \
+	-Ihelpers
+
+TARGET := $(BUILD_DIR)/logger_test
+
+SRC := \
+	$(ROOT_DIR)/logger/src/logger.cpp \
+	$(ROOT_DIR)/logger/src/time_utils.cpp \
+	logger_test.cpp
+
+.PHONY: all clean helpers
+
+all: helpers $(TARGET)
+	$(TARGET)
+
+helpers:
+	$(MAKE) -C helpers
+
+$(TARGET): $(SRC)
+	@mkdir -p $(BUILD_DIR)
+	$(CC) $(CXXFLAGS) $^ -o $@ $(LDLIBS)
+
+clean:
+	rm -f $(TARGET)
+	$(MAKE) -C helpers clean

tests/logger/helpers/Makefile

@@ -0,0 +1,15 @@
+TARGET := $(BUILD_DIR)/scoped_file_test
+
+SRC := scoped_file_test.cpp
+
+.PHONY: all clean
+
+all: $(TARGET)
+	$(TARGET)
+
+$(TARGET): $(SRC)
+	@mkdir -p $(BUILD_DIR)
+	$(CC) $(CXXFLAGS) $^ -o $@ $(LDLIBS)
+
+clean:
+	rm -f $(TARGET)

tests/logger/helpers/scoped_file.hpp

@@ -4,7 +4,7 @@
 #include <stdexcept>
 #include <string>
 
-namespace helpers {
+namespace logger::tests::helpers {
 
 class ScopedFile {
 public:
@@ -28,4 +28,4 @@ private:
   std::string fileName_;
 };
 
-} // namespace helpers
+} // namespace logger::tests::helpers

tests/logger/helpers/scoped_file_test.cpp

@@ -8,7 +8,7 @@
 
 namespace {
 
-using namespace helpers;
+using namespace logger::tests::helpers;
 
 void testFileRemovedAfterScope() {
   const std::string fileName = "scoped_file_test.log";

tests/logger/logger_test.cpp

@@ -6,7 +6,7 @@
 #include "logger.hpp"
 #include "scoped_file.hpp"
 
-namespace {
+namespace logger::tests {
 
 using namespace logger;
 
@@ -40,7 +40,7 @@ void testWithFileName() {
 }
 
 void testWriteLogSuccess() {
-  ScopedFile file("logger_test.log");
+  helpers::ScopedFile file("logger_test.log");
 
   file.throwIfExists();
 
@@ -62,7 +62,7 @@ void testWriteLogSuccess() {
 }
 
 void testWriteLogFailure() {
-  ScopedFile file("logger_test_directory");
+  helpers::ScopedFile file("logger_test_directory");
 
   file.throwIfExists();
 
@@ -79,7 +79,7 @@ void testWriteLogFailure() {
 }
 
 void testMultipleWrites() {
-  ScopedFile file("multiple.log");
+  helpers::ScopedFile file("multiple.log");
 
   file.throwIfExists();
 
@@ -118,10 +118,10 @@ void runTests() {
   testMultipleWrites();
 }
 
-} // namespace
+} // namespace logger::tests
 
 int main() {
-  runTests();
+  logger::tests::runTests();
 
   return 0;
 }