Add more tests

Author: endurodave

.gitignore

@@ -303,4 +303,7 @@ __pycache__/
 *.xsd.cs
 
 # OpenCover UI analysis results
-OpenCover/
+OpenCover/
+
+# Integration test log output
+LogData.txt

Logger/it/Logger_IT.cpp

@@ -11,6 +11,7 @@
 #include "Logger.h"
 #include "DelegateMQ.h"
 #include "SignalThread.h"
+#include <filesystem>
 #include "IT_Util.h"		// Include this last
 
 using namespace std;
@@ -23,6 +24,16 @@ static vector<string> callbackStatus;
 static milliseconds flushDuration;
 static mutex mtx;
 
+// State for WriteSequence test
+static atomic<int> writeSeqCount{ 0 };
+static int writeSeqTarget = 0;
+static SignalThread writeSeqSignal;
+
+// State for ConcurrentWrites test
+static atomic<int> concurrentWriteCount{ 0 };
+static int concurrentWriteTarget = 0;
+static SignalThread concurrentDoneSignal;
+
 // Logger callback handler function invoked from Logger thread context
 void FlushTimeCb(milliseconds duration)
 {
@@ -37,7 +48,7 @@ void FlushTimeCb(milliseconds duration)
 // Logger callback handler function invoked from Logger thread context
 void LoggerStatusCb(const string& status)
 {
-	// Protect callbackStatus against multiple thread access by IntegrationTest 
+	// Protect callbackStatus against multiple thread access by IntegrationTest
 	// thread and Logger thread
 	lock_guard<mutex> lock(mtx);
 
@@ -48,6 +59,32 @@ void LoggerStatusCb(const string& status)
 	signalThread.SetSignal();
 }
 
+// Logger callback for WriteSequence test. Records Write success! callbacks into
+// callbackStatus and signals once writeSeqTarget writes have been confirmed.
+// Flush callbacks from the Logger timer are ignored to avoid signal interference.
+void WriteSeqCb(const string& status)
+{
+	if (status != "Write success!")
+		return;
+
+	{
+		lock_guard<mutex> lock(mtx);
+		callbackStatus.push_back(status);
+	}
+
+	if (++writeSeqCount == writeSeqTarget)
+		writeSeqSignal.SetSignal();
+}
+
+// Logger callback for ConcurrentWrites test. Counts Write success! callbacks
+// and signals once all concurrentWriteTarget writes have been confirmed.
+void ConcurrentWriteCb(const string& status)
+{
+	if (status == "Write success!")
+		if (++concurrentWriteCount == concurrentWriteTarget)
+			concurrentDoneSignal.SetSignal();
+}
+
 // Test the Logger::Write() subsystem public API. 
 TEST(Logger_IT, Write) 
 {
@@ -293,5 +330,128 @@ TEST(Logger_IT, FlushTimeSimplifiedWithLambda)
 	Logger::GetInstance().m_logData.FlushTimeDelegate -= MakeDelegate(FlushTimeLambdaCb);
 }
 
+// Verify that callbacks from multiple Write operations arrive in the correct sequence.
+// Fires 3 writes without waiting between them, then confirms the Logger thread
+// delivered all 3 callbacks in FIFO order — the same order the writes were issued.
+// Flush callbacks from the timer are filtered out by WriteSeqCb to avoid
+// interference with the sequence count.
+TEST(Logger_IT, WriteSequence)
+{
+	writeSeqCount = 0;
+	writeSeqTarget = 3;
+	{
+		lock_guard<mutex> lock(mtx);
+		callbackStatus.clear();
+	}
+
+	Logger::GetInstance().SetCallback(&WriteSeqCb);
+
+	// Queue all 3 writes without waiting between them
+	Logger::GetInstance().Write("First");
+	Logger::GetInstance().Write("Second");
+	Logger::GetInstance().Write("Third");
+
+	// Wait until all 3 write callbacks have arrived from the Logger thread
+	EXPECT_TRUE(writeSeqSignal.WaitForSignal(1000));
+
+	{
+		lock_guard<mutex> lock(mtx);
+
+		// Verify all 3 write callbacks arrived in sequence.
+		// The Logger's FIFO message queue guarantees the callbacks are
+		// delivered in the same order the Write calls were submitted.
+		ASSERT_EQ(callbackStatus.size(), 3u);
+		EXPECT_EQ(callbackStatus[0], "Write success!");
+		EXPECT_EQ(callbackStatus[1], "Write success!");
+		EXPECT_EQ(callbackStatus[2], "Write success!");
+	}
+
+	Logger::GetInstance().SetCallback(nullptr);
+}
+
+// Verify that a Flush failure is correctly detected and that buffered log data
+// is preserved across the failure for a subsequent retry.
+// Injects a fault by removing write permission from the log file, confirms
+// Flush returns false, restores permissions, then confirms Flush recovers.
+TEST(Logger_IT, FlushFaultInjection)
+{
+	namespace fs = std::filesystem;
+
+	// Ensure LogData.txt exists on disk so permissions can be applied to it
+	auto ensureRet = AsyncInvoke(
+		&Logger::GetInstance().m_logData,
+		&LogData::Flush,
+		Logger::GetInstance(),
+		milliseconds(100));
+	ASSERT_TRUE(ensureRet.has_value());
+
+	// Write a data entry that will be held in the buffer during the fault
+	AsyncInvoke(
+		&Logger::GetInstance().m_logData,
+		&LogData::Write,
+		Logger::GetInstance(),
+		milliseconds(50),
+		string("Fault injection test data"));
+
+	// Inject fault: remove write permission from the log file
+	std::error_code ec;
+	fs::permissions("LogData.txt",
+		fs::perms::owner_write | fs::perms::group_write | fs::perms::others_write,
+		fs::perm_options::remove, ec);
+	ASSERT_FALSE(ec) << "Failed to remove write permission: " << ec.message();
+
+	// Flush must fail because the file is now read-only
+	auto failRet = AsyncInvoke(
+		&Logger::GetInstance().m_logData,
+		&LogData::Flush,
+		Logger::GetInstance(),
+		milliseconds(100));
+	EXPECT_TRUE(failRet.has_value());
+	if (failRet.has_value())
+		EXPECT_FALSE(failRet.value());	// Flush should return false on fault
+
+	// Restore write permission to recover from the fault
+	fs::permissions("LogData.txt", fs::perms::owner_write, fs::perm_options::add, ec);
+	ASSERT_FALSE(ec) << "Failed to restore write permission: " << ec.message();
+
+	// Buffered data must have survived the failed flush - retry must succeed.
+	// LogData::Flush does not clear m_msgData on failure, preserving the entry.
+	auto retryRet = AsyncInvoke(
+		&Logger::GetInstance().m_logData,
+		&LogData::Flush,
+		Logger::GetInstance(),
+		milliseconds(100));
+	EXPECT_TRUE(retryRet.has_value());
+	if (retryRet.has_value())
+		EXPECT_TRUE(retryRet.value());	// Flush should succeed after recovery
+}
+
+// Stress test that fires many Write calls without waiting between them and
+// verifies the Logger thread processes every one without dropping a callback.
+// Demonstrates that the Logger's message queue handles concurrent producer load
+// and that every callback is delivered exactly once.
+TEST(Logger_IT, ConcurrentWrites)
+{
+	const int NUM_WRITES = 20;
+	concurrentWriteCount = 0;
+	concurrentWriteTarget = NUM_WRITES;
+
+	Logger::GetInstance().SetCallback(&ConcurrentWriteCb);
+
+	// Fire all writes without waiting — stress the Logger's message queue
+	for (int i = 0; i < NUM_WRITES; i++)
+		Logger::GetInstance().Write("ConcurrentWrite " + to_string(i));
+
+	// Wait until all NUM_WRITES callbacks have been received
+	EXPECT_TRUE(concurrentDoneSignal.WaitForSignal(2000))
+		<< "Timed out: only " << concurrentWriteCount.load()
+		<< " of " << NUM_WRITES << " write callbacks received";
+
+	// Every write must have produced exactly one callback
+	EXPECT_EQ(concurrentWriteCount.load(), NUM_WRITES);
+
+	Logger::GetInstance().SetCallback(nullptr);
+}
+
 // Dummy function to force linker to keep the code in this file
 void Logger_IT_ForceLink() { }