std::ifstream f(path);

std::ostringstream ss;

ss << f.rdbuf();

return ss.str();

std::println("Running logger class tests:");

// 1. Constructor creates the log file

std::println(" test_file_created...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "info");

Diskerror::Logger::info("startup message");

}

assert(fs::exists(LOG_FILE));

auto content = read_file(LOG_FILE);

assert(content.find("startup message") != std::string::npos);

std::println(" OK");

// 2. Destructor closes the file (second logger can reopen it)

std::println(" test_destructor_closes_file...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "info");

Diskerror::Logger::info("first run");

}

{

Diskerror::Logger log(LOG_FILE, "info");

Diskerror::Logger::info("second run");

}

content = read_file(LOG_FILE);

assert(content.find("first run") != std::string::npos);

assert(content.find("second run") != std::string::npos);

std::println(" OK");

// 3. Level filtering — "warn" should suppress info and debug

std::println(" test_level_filtering_warn...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "warn");

Diskerror::Logger::debug("should not appear");

Diskerror::Logger::info("should not appear either");

Diskerror::Logger::warn("visible warning");

Diskerror::Logger::error("visible error");

}

content = read_file(LOG_FILE);

assert(content.find("should not appear") == std::string::npos);

assert(content.find("should not appear either") == std::string::npos);

assert(content.find("visible warning") != std::string::npos);

assert(content.find("visible error") != std::string::npos);

std::println(" OK");

// 4. Level filtering — "trace" enables everything

std::println(" test_level_filtering_trace...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "trace");

Diskerror::Logger::trace("t msg");

Diskerror::Logger::debug("d msg");

Diskerror::Logger::info("i msg");

Diskerror::Logger::warn("w msg");

Diskerror::Logger::error("e msg");

Diskerror::Logger::critical("c msg");

}

content = read_file(LOG_FILE);

assert(content.find("[TRACE]") != std::string::npos);

assert(content.find("[DEBUG]") != std::string::npos);

assert(content.find("[INFO ]") != std::string::npos);

assert(content.find("[WARN ]") != std::string::npos);

assert(content.find("[ERROR]") != std::string::npos);

assert(content.find("[CRITICAL]") != std::string::npos);

std::println(" OK");

// 5. Level filtering — "critical" suppresses everything below

std::println(" test_level_filtering_critical...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "critical");

Diskerror::Logger::trace("no");

Diskerror::Logger::debug("no");

Diskerror::Logger::info("no");

Diskerror::Logger::warn("no");

Diskerror::Logger::error("no");

Diskerror::Logger::critical("yes critical");

}

content = read_file(LOG_FILE);

assert(content.find("yes critical") != std::string::npos);

// Only one line should be present (the critical one)

// Count newlines — should be exactly 1

auto lines = std::count(content.begin(), content.end(), '\n');

assert(lines == 1);

std::println(" OK");

// 6. Timestamp format (YYYY-MM-DD HH:MM:SS.mmmm)

std::println(" test_timestamp_format...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "info");

Diskerror::Logger::info("timestamp check");

}

content = read_file(LOG_FILE);

assert(content.find("202") != std::string::npos);

auto dot_pos = content.find('.');

assert(dot_pos != std::string::npos);

// 4 digits after the dot (microseconds mod 10000), then space

assert(content[dot_pos + 5] == ' ');

std::println(" OK");

// 7. Log tags present in output

std::println(" test_log_tags...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "info");

Diskerror::Logger::info("tag test");

}

content = read_file(LOG_FILE);

assert(content.find("[INFO ]") != std::string::npos);

std::println(" OK");

// 8. Invalid level defaults to warn

std::println(" test_invalid_level_defaults_to_warn...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "nonsense");

Diskerror::Logger::info("should be hidden");

Diskerror::Logger::warn("should be visible");

}

content = read_file(LOG_FILE);

assert(content.find("should be hidden") == std::string::npos);

assert(content.find("should be visible") != std::string::npos);

std::println(" OK");

// 9. Multiple entries accumulate

std::println(" test_accumulation...");

cleanup();

{

Diskerror::Logger log(LOG_FILE, "info");

Diskerror::Logger::info("line one");

Diskerror::Logger::info("line two");

Diskerror::Logger::info("line three");

}

content = read_file(LOG_FILE);

assert(content.find("line one") != std::string::npos);

assert(content.find("line two") != std::string::npos);

assert(content.find("line three") != std::string::npos);

std::println(" OK");

// 10. Bad file path throws

std::println(" test_bad_path_throws...");

{

bool threw = false;

try {

Diskerror::Logger log("/no/such/directory/bad.log", "info");

} catch (const std::runtime_error& e) {

threw = true;

assert(std::string(e.what()).find("failed to open") != std::string::npos);

}

assert(threw);

}

std::println(" OK");

// 11. Constructor creates a missing containing directory (e.g. ~/.ragger/logs)

std::println(" test_creates_missing_directory...");

{

fs::remove_all("/tmp/ragger_test_logdir");

std::string nested = "/tmp/ragger_test_logdir/nested/activity.log";

assert(!fs::exists("/tmp/ragger_test_logdir"));

{

Diskerror::Logger log(nested, "info");

Diskerror::Logger::info("dir autocreate check");

}

assert(fs::exists(nested));

content = read_file(nested);

assert(content.find("dir autocreate check") != std::string::npos);

fs::remove_all("/tmp/ragger_test_logdir");

}

std::println(" OK");

// 12. Size-based rotation: once the file crosses max_size, it's renamed

// to a timestamped backup and a fresh empty file continues at the same path.

std::println(" test_size_based_rotation...");

{

std::string dir = "/tmp/ragger_test_rotate";

std::string path = dir + "/activity.log";

fs::remove_all(dir);

fs::create_directories(dir);

// Seed the file past the 1MB threshold so the logger's very first

// append (which checks size after writing) triggers rotation.

{

std::ofstream seed(path);

seed << std::string(1024 * 1024 + 10, 'x'); // > 1MB

}

{

Diskerror::Logger log(path, "info", /*maxSizeMb=*/1, /*maxAgeDays=*/0);

Diskerror::Logger::info("triggers rotation");

// Second write lands in the fresh post-rotation file.

Diskerror::Logger::info("post rotation");

}

int backups = 0;

std::string backup_path;

for (const auto& e : fs::directory_iterator(dir)) {

if (e.path().filename().string().rfind("activity.log.", 0) == 0) {

++backups;

backup_path = e.path().string();

}

}

assert(backups == 1);

// The pre-rotation content (seeded data + "triggers rotation") is in

// the backup; the fresh file has only "post rotation".

auto backup_content = read_file(backup_path);

assert(backup_content.find("triggers rotation") != std::string::npos);

content = read_file(path);

assert(content.find("post rotation") != std::string::npos);

assert(content.find("triggers rotation") == std::string::npos);

assert(content.size() < 1024 * 1024); // fresh file, not the seeded giant one

fs::remove_all(dir);

}

std::println(" OK");

// 13. Age-based cleanup: a backup older than max_age_days is deleted on

// the next rotation; one younger than the cutoff survives.

std::println(" test_age_based_cleanup...");

{

std::string dir = "/tmp/ragger_test_agesweep";

std::string path = dir + "/activity.log";

fs::remove_all(dir);

fs::create_directories(dir);

std::string old_backup = dir + "/activity.log.20200101-000000";

std::string young_backup = dir + "/activity.log.20990101-000000"; // far future, never "old"

{ std::ofstream f(old_backup); f << "old"; }

{ std::ofstream f(young_backup); f << "young"; }

// Backdate old_backup's mtime well past the 1-day cutoff used below.

auto ancient = std::chrono::file_clock::now() - std::chrono::hours(24 * 30);

fs::last_write_time(old_backup, ancient);

{

std::ofstream seed(path);

seed << std::string(1024 * 1024 + 10, 'x');

}

Diskerror::Logger log(path, "info", /*maxSizeMb=*/1, /*maxAgeDays=*/1);

Diskerror::Logger::info("triggers rotation + sweep");

assert(!fs::exists(old_backup)); // swept (30 days old, cutoff is 1 day)

assert(fs::exists(young_backup)); // untouched (2099 mtime, not old)

fs::remove_all(dir);

}

std::println(" OK");

cleanup();

std::println("test_logger: all passed");

return 0;