test_performance_monitoring.cpp File Reference

Unit tests for performance monitoring functionality. More...

#include <gtest/gtest.h>
#include <kcenon/monitoring/core/performance_monitor.h>
#include <chrono>
#include <random>
#include <set>
#include <thread>
#include <vector>

Include dependency graph for test_performance_monitoring.cpp:

Go to the source code of this file.

Classes
class	PerformanceMonitoringTest

Functions
	TEST_F (PerformanceMonitoringTest, RecordSingleSample)
	TEST_F (PerformanceMonitoringTest, RecordMultipleSamples)
	TEST_F (PerformanceMonitoringTest, RecordErrorSamples)
	TEST_F (PerformanceMonitoringTest, ScopedTimer)
	TEST_F (PerformanceMonitoringTest, ScopedTimerWithError)
	TEST_F (PerformanceMonitoringTest, PercentileCalculation)
	TEST_F (PerformanceMonitoringTest, ThroughputCalculation)
	TEST_F (PerformanceMonitoringTest, ClearSamples)
	TEST_F (PerformanceMonitoringTest, GetAllMetrics)
	TEST_F (PerformanceMonitoringTest, ProfilerEnableDisable)
	TEST_F (PerformanceMonitoringTest, SystemMetrics)
	TEST_F (PerformanceMonitoringTest, SystemMonitoringHistory)
	TEST_F (PerformanceMonitoringTest, PerformanceMonitorCollect)
	TEST_F (PerformanceMonitoringTest, ThresholdChecking)
	TEST_F (PerformanceMonitoringTest, GlobalPerformanceMonitor)
	TEST_F (PerformanceMonitoringTest, PerformanceBenchmark)
	TEST_F (PerformanceMonitoringTest, BenchmarkComparison)
	TEST_F (PerformanceMonitoringTest, MaxSamplesLimit)
	TEST_F (PerformanceMonitoringTest, ConcurrentRecording)
	TEST_F (PerformanceMonitoringTest, RecordCounterWithoutTags)
	TEST_F (PerformanceMonitoringTest, RecordCounterWithTags)
	TEST_F (PerformanceMonitoringTest, RecordGaugeWithTags)
	TEST_F (PerformanceMonitoringTest, RecordHistogramWithTags)
	TEST_F (PerformanceMonitoringTest, TaggedMetricsInCollect)
	TEST_F (PerformanceMonitoringTest, ClearAllMetrics)
	TEST_F (PerformanceMonitoringTest, ResetClearsTaggedMetrics)
	TEST_F (PerformanceMonitoringTest, EmptyMetricNameRejected)
	TEST_F (PerformanceMonitoringTest, TagKeyConsistency)

Detailed Description

Unit tests for performance monitoring functionality.

Definition in file test_performance_monitoring.cpp.

Function Documentation

TEST_F() [1/28]

TEST_F	(	PerformanceMonitoringTest	,
		BenchmarkComparison	)

Definition at line 349 of file test_performance_monitoring.cpp.

                                                       {
    performance_benchmark benchmark("comparison_benchmark");
    benchmark.set_iterations(50);
    benchmark.set_warmup_iterations(5);
 
    auto result = benchmark.compare(
        "fast_operation",
        []() {
            volatile int sum = 0;
            for (int i = 0; i < 100; ++i) {
                sum += i;
            }
        },
        "slow_operation",
        []() {
            volatile int sum = 0;
            for (int i = 0; i < 10000; ++i) {
                sum += i;
            }
        });
 
    ASSERT_TRUE(result.is_ok());
 
    auto [fast_metrics, slow_metrics] = result.value();
 
    EXPECT_EQ(fast_metrics.call_count, 50);
    EXPECT_EQ(slow_metrics.call_count, 50);
 
    // Fast operation should be faster than slow operation
    EXPECT_LT(fast_metrics.mean_duration, slow_metrics.mean_duration);
}

References kcenon::monitoring::performance_benchmark::compare(), kcenon::monitoring::performance_benchmark::set_iterations(), and kcenon::monitoring::performance_benchmark::set_warmup_iterations().

Here is the call graph for this function:

TEST_F() [2/28]

TEST_F	(	PerformanceMonitoringTest	,
		ClearAllMetrics	)

Definition at line 542 of file test_performance_monitoring.cpp.

                                                   {
    monitor.record_counter("counter1", 1.0);
    monitor.record_gauge("gauge1", 10.0);
 
    EXPECT_EQ(monitor.get_all_tagged_metrics().size(), 2);
 
    monitor.clear_all_metrics();
 
    EXPECT_EQ(monitor.get_all_tagged_metrics().size(), 0);
}

TEST_F() [3/28]

TEST_F	(	PerformanceMonitoringTest	,
		ClearSamples	)

Definition at line 169 of file test_performance_monitoring.cpp.

                                                {
    profiler.record_sample("clear_test", std::chrono::nanoseconds(1000000), true);
 
    auto before_result = profiler.get_metrics("clear_test");
    ASSERT_TRUE(before_result.is_ok());
    EXPECT_EQ(before_result.value().call_count, 1);
 
    auto result = profiler.clear_samples("clear_test");
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value());
 
    // After clear, metrics may still exist but with reset values
    auto after_result = profiler.get_metrics("clear_test");
    if (after_result.is_ok()) {
        EXPECT_EQ(after_result.value().call_count, 0);
    }
}

TEST_F() [4/28]

TEST_F	(	PerformanceMonitoringTest	,
		ConcurrentRecording	)

Definition at line 401 of file test_performance_monitoring.cpp.

                                                       {
    const int num_threads = 10;
    const int samples_per_thread = 100;
 
    std::vector<std::thread> threads;
 
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([this, t, samples_per_thread]() {
            for (int i = 0; i < samples_per_thread; ++i) {
                profiler.record_sample("concurrent_test",
                                       std::chrono::nanoseconds((t + 1) * 1000000), true);
            }
        });
    }
 
    for (auto& thread : threads) {
        thread.join();
    }
 
    auto metrics_result = profiler.get_metrics("concurrent_test");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, num_threads * samples_per_thread);
}

TEST_F() [5/28]

TEST_F	(	PerformanceMonitoringTest	,
		EmptyMetricNameRejected	)

Definition at line 563 of file test_performance_monitoring.cpp.

                                                           {
    auto result = monitor.record_counter("", 1.0);
    EXPECT_FALSE(result.is_ok());
}

TEST_F() [6/28]

TEST_F	(	PerformanceMonitoringTest	,
		GetAllMetrics	)

Definition at line 187 of file test_performance_monitoring.cpp.

                                                 {
    profiler.record_sample("op1", std::chrono::nanoseconds(1000000), true);
    profiler.record_sample("op2", std::chrono::nanoseconds(2000000), true);
    profiler.record_sample("op3", std::chrono::nanoseconds(3000000), true);
 
    auto all_metrics = profiler.get_all_metrics();
    EXPECT_EQ(all_metrics.size(), 3);
 
    std::set<std::string> operation_names;
    for (const auto& metrics : all_metrics) {
        operation_names.insert(metrics.operation_name);
    }
 
    EXPECT_TRUE(operation_names.count("op1") > 0);
    EXPECT_TRUE(operation_names.count("op2") > 0);
    EXPECT_TRUE(operation_names.count("op3") > 0);
}

TEST_F() [7/28]

TEST_F	(	PerformanceMonitoringTest	,
		GlobalPerformanceMonitor	)

Definition at line 312 of file test_performance_monitoring.cpp.

                                                            {
    auto& global = global_performance_monitor();
 
    {
        PERF_TIMER("global_test_operation");
        simulate_work(std::chrono::milliseconds(10));
    }
 
    auto metrics_result = global.get_profiler().get_metrics("global_test_operation");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, 1);
    EXPECT_GE(metrics.mean_duration.count(), 10000000);
}

References kcenon::monitoring::global_performance_monitor(), and PERF_TIMER.

Here is the call graph for this function:

TEST_F() [8/28]

TEST_F	(	PerformanceMonitoringTest	,
		MaxSamplesLimit	)

Definition at line 381 of file test_performance_monitoring.cpp.

                                                   {
    profiler.set_max_samples(10);
 
    // Record 20 samples
    for (int i = 0; i < 20; ++i) {
        profiler.record_sample("limit_test", std::chrono::nanoseconds(i * 1000000), true);
    }
 
    auto metrics_result = profiler.get_metrics("limit_test");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    // Call count should still be 20
    EXPECT_EQ(metrics.call_count, 20);
 
    // But only last 10 samples should be in statistics
    // The minimum should be from sample 10 (10ms), not sample 0 (0ms)
    EXPECT_GE(metrics.min_duration.count(), 10000000);
}

TEST_F() [9/28]

TEST_F	(	PerformanceMonitoringTest	,
		PercentileCalculation	)

Definition at line 125 of file test_performance_monitoring.cpp.

                                                         {
    // Generate 100 samples with known distribution
    for (int i = 1; i <= 100; ++i) {
        profiler.record_sample("percentile_test",
                               std::chrono::nanoseconds(i * 1000000),  // i ms
                               true);
    }
 
    auto metrics_result = profiler.get_metrics("percentile_test");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, 100);
 
    // P50 should be around 50ms
    EXPECT_GE(metrics.median_duration.count(), 49000000);
    EXPECT_LE(metrics.median_duration.count(), 51000000);
 
    // P95 should be around 95ms
    EXPECT_GE(metrics.p95_duration.count(), 94000000);
    EXPECT_LE(metrics.p95_duration.count(), 96000000);
 
    // P99 should be around 99ms
    EXPECT_GE(metrics.p99_duration.count(), 98000000);
    EXPECT_LE(metrics.p99_duration.count(), 100000000);
}

TEST_F() [10/28]

TEST_F	(	PerformanceMonitoringTest	,
		PerformanceBenchmark	)

Definition at line 328 of file test_performance_monitoring.cpp.

                                                        {
    performance_benchmark benchmark("test_benchmark");
    benchmark.set_iterations(100);
    benchmark.set_warmup_iterations(10);
 
    auto result = benchmark.run("simple_operation", []() {
        // Simulate some simple work
        volatile int sum = 0;
        for (int i = 0; i < 1000; ++i) {
            sum += i;
        }
    });
 
    ASSERT_TRUE(result.is_ok());
 
    auto metrics = result.value();
    EXPECT_EQ(metrics.call_count, 100);
    EXPECT_GT(metrics.mean_duration.count(), 0);
    EXPECT_GE(metrics.max_duration.count(), metrics.min_duration.count());
}

References kcenon::monitoring::performance_benchmark::run(), kcenon::monitoring::performance_benchmark::set_iterations(), and kcenon::monitoring::performance_benchmark::set_warmup_iterations().

Here is the call graph for this function:

TEST_F() [11/28]

TEST_F	(	PerformanceMonitoringTest	,
		PerformanceMonitorCollect	)

Definition at line 269 of file test_performance_monitoring.cpp.

                                                             {
    // Record some performance samples
    monitor.get_profiler().record_sample("collect_test", std::chrono::nanoseconds(5000000), true);
 
    auto init_result = monitor.initialize();
    ASSERT_TRUE(init_result.is_ok());
 
    auto snapshot_result = monitor.collect();
    ASSERT_TRUE(snapshot_result.is_ok());
 
    auto snapshot = snapshot_result.value();
    EXPECT_EQ(snapshot.source_id, "performance_monitor");
    EXPECT_GT(snapshot.metrics.size(), 0);
 
    // Check for expected metrics
    bool found_perf_metric = false;
 
    for (const auto& metric : snapshot.metrics) {
        if (metric.name.find("collect_test") != std::string::npos) {
            found_perf_metric = true;
        }
    }
 
    EXPECT_TRUE(found_perf_metric);
    // System metrics may or may not be present depending on platform
}

References kcenon::monitoring::metric::name.

TEST_F() [12/28]

TEST_F	(	PerformanceMonitoringTest	,
		ProfilerEnableDisable	)

Definition at line 205 of file test_performance_monitoring.cpp.

                                                         {
    profiler.set_enabled(false);
 
    auto result = profiler.record_sample("disabled_test", std::chrono::nanoseconds(1000000), true);
    ASSERT_TRUE(result.is_ok());
 
    // Sample should not be recorded when disabled
    auto metrics_result = profiler.get_metrics("disabled_test");
    ASSERT_FALSE(metrics_result.is_ok());
 
    profiler.set_enabled(true);
    profiler.record_sample("enabled_test", std::chrono::nanoseconds(1000000), true);
 
    metrics_result = profiler.get_metrics("enabled_test");
    ASSERT_TRUE(metrics_result.is_ok());
}

TEST_F() [13/28]

TEST_F	(	PerformanceMonitoringTest	,
		RecordCounterWithoutTags	)

Definition at line 431 of file test_performance_monitoring.cpp.

                                                            {
    auto result = monitor.record_counter("requests_total", 1.0);
    ASSERT_TRUE(result.is_ok());
 
    result = monitor.record_counter("requests_total", 2.0);
    ASSERT_TRUE(result.is_ok());
 
    auto tagged_metrics = monitor.get_all_tagged_metrics();
    ASSERT_EQ(tagged_metrics.size(), 1);
 
    EXPECT_EQ(tagged_metrics[0].name, "requests_total");
    EXPECT_EQ(tagged_metrics[0].value, 3.0);  // 1.0 + 2.0
    EXPECT_EQ(tagged_metrics[0].type, recorded_metric_type::counter);
    EXPECT_TRUE(tagged_metrics[0].tags.empty());
}

TEST_F() [14/28]

TEST_F	(	PerformanceMonitoringTest	,
		RecordCounterWithTags	)

Definition at line 447 of file test_performance_monitoring.cpp.

                                                         {
    tag_map tags1 = {{"method", "GET"}, {"endpoint", "/api/users"}};
    tag_map tags2 = {{"method", "POST"}, {"endpoint", "/api/users"}};
 
    auto result = monitor.record_counter("http_requests", 1.0, tags1);
    ASSERT_TRUE(result.is_ok());
 
    result = monitor.record_counter("http_requests", 1.0, tags2);
    ASSERT_TRUE(result.is_ok());
 
    result = monitor.record_counter("http_requests", 1.0, tags1);
    ASSERT_TRUE(result.is_ok());
 
    auto tagged_metrics = monitor.get_all_tagged_metrics();
    ASSERT_EQ(tagged_metrics.size(), 2);  // Two different tag combinations
 
    // Find GET metric
    auto get_it = std::find_if(tagged_metrics.begin(), tagged_metrics.end(),
        [](const tagged_metric& m) {
            return m.tags.count("method") && m.tags.at("method") == "GET";
        });
    ASSERT_NE(get_it, tagged_metrics.end());
    EXPECT_EQ(get_it->value, 2.0);  // Two GET requests
 
    // Find POST metric
    auto post_it = std::find_if(tagged_metrics.begin(), tagged_metrics.end(),
        [](const tagged_metric& m) {
            return m.tags.count("method") && m.tags.at("method") == "POST";
        });
    ASSERT_NE(post_it, tagged_metrics.end());
    EXPECT_EQ(post_it->value, 1.0);  // One POST request
}

TEST_F() [15/28]

TEST_F	(	PerformanceMonitoringTest	,
		RecordErrorSamples	)

Definition at line 82 of file test_performance_monitoring.cpp.

                                                      {
    profiler.record_sample("error_operation", std::chrono::nanoseconds(1000000), true);
    profiler.record_sample("error_operation", std::chrono::nanoseconds(2000000), false);
    profiler.record_sample("error_operation", std::chrono::nanoseconds(3000000), false);
    profiler.record_sample("error_operation", std::chrono::nanoseconds(4000000), true);
 
    auto metrics_result = profiler.get_metrics("error_operation");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, 4);
    EXPECT_EQ(metrics.error_count, 2);
}

TEST_F() [16/28]

TEST_F	(	PerformanceMonitoringTest	,
		RecordGaugeWithTags	)

Definition at line 480 of file test_performance_monitoring.cpp.

                                                       {
    tag_map tags = {{"pool", "database"}, {"host", "db-primary"}};
 
    auto result = monitor.record_gauge("active_connections", 10.0, tags);
    ASSERT_TRUE(result.is_ok());
 
    result = monitor.record_gauge("active_connections", 15.0, tags);
    ASSERT_TRUE(result.is_ok());
 
    auto tagged_metrics = monitor.get_all_tagged_metrics();
    ASSERT_EQ(tagged_metrics.size(), 1);
 
    EXPECT_EQ(tagged_metrics[0].name, "active_connections");
    EXPECT_EQ(tagged_metrics[0].value, 15.0);  // Gauge replaces value
    EXPECT_EQ(tagged_metrics[0].type, recorded_metric_type::gauge);
    EXPECT_EQ(tagged_metrics[0].tags.size(), 2);
    EXPECT_EQ(tagged_metrics[0].tags.at("pool"), "database");
}

TEST_F() [17/28]

TEST_F	(	PerformanceMonitoringTest	,
		RecordHistogramWithTags	)

Definition at line 499 of file test_performance_monitoring.cpp.

                                                           {
    tag_map tags = {{"service", "auth"}, {"operation", "login"}};
 
    for (double i = 1.0; i <= 5.0; i += 1.0) {
        auto result = monitor.record_histogram("request_duration_ms", i * 100.0, tags);
        ASSERT_TRUE(result.is_ok());
    }
 
    auto tagged_metrics = monitor.get_all_tagged_metrics();
    ASSERT_EQ(tagged_metrics.size(), 1);
 
    EXPECT_EQ(tagged_metrics[0].name, "request_duration_ms");
    EXPECT_EQ(tagged_metrics[0].value, 500.0);  // Last value
    EXPECT_EQ(tagged_metrics[0].type, recorded_metric_type::histogram);
}

TEST_F() [18/28]

TEST_F	(	PerformanceMonitoringTest	,
		RecordMultipleSamples	)

Definition at line 57 of file test_performance_monitoring.cpp.

                                                         {
    std::vector<std::chrono::nanoseconds> durations = {
        std::chrono::nanoseconds(1000000),  // 1ms
        std::chrono::nanoseconds(2000000),  // 2ms
        std::chrono::nanoseconds(3000000),  // 3ms
        std::chrono::nanoseconds(4000000),  // 4ms
        std::chrono::nanoseconds(5000000)   // 5ms
    };
 
    for (const auto& duration : durations) {
        profiler.record_sample("multi_operation", duration, true);
    }
 
    auto metrics_result = profiler.get_metrics("multi_operation");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, 5);
    EXPECT_EQ(metrics.error_count, 0);
    EXPECT_EQ(metrics.min_duration.count(), 1000000);
    EXPECT_EQ(metrics.max_duration.count(), 5000000);
    EXPECT_EQ(metrics.median_duration.count(), 3000000);
    EXPECT_EQ(metrics.mean_duration.count(), 3000000);
}

TEST_F() [19/28]

TEST_F	(	PerformanceMonitoringTest	,
		RecordSingleSample	)

Definition at line 39 of file test_performance_monitoring.cpp.

                                                      {
    auto result = profiler.record_sample("test_operation",
                                         std::chrono::nanoseconds(1000000),  // 1ms
                                         true);
 
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value());
 
    auto metrics_result = profiler.get_metrics("test_operation");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.operation_name, "test_operation");
    EXPECT_EQ(metrics.call_count, 1);
    EXPECT_EQ(metrics.error_count, 0);
    EXPECT_EQ(metrics.mean_duration.count(), 1000000);
}

TEST_F() [20/28]

TEST_F	(	PerformanceMonitoringTest	,
		ResetClearsTaggedMetrics	)

Definition at line 553 of file test_performance_monitoring.cpp.

                                                            {
    monitor.record_counter("test_counter", 1.0);
 
    EXPECT_EQ(monitor.get_all_tagged_metrics().size(), 1);
 
    monitor.reset();
 
    EXPECT_EQ(monitor.get_all_tagged_metrics().size(), 0);
}

TEST_F() [21/28]

TEST_F	(	PerformanceMonitoringTest	,
		ScopedTimer	)

Definition at line 96 of file test_performance_monitoring.cpp.

                                               {
    {
        scoped_timer timer(&profiler, "scoped_operation");
        simulate_work(std::chrono::milliseconds(10));
    }
 
    auto metrics_result = profiler.get_metrics("scoped_operation");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, 1);
    EXPECT_GE(metrics.mean_duration.count(), 10000000);  // At least 10ms
}

References kcenon::monitoring::timer.

TEST_F() [22/28]

TEST_F	(	PerformanceMonitoringTest	,
		ScopedTimerWithError	)

Definition at line 110 of file test_performance_monitoring.cpp.

                                                        {
    {
        scoped_timer timer(&profiler, "error_scoped_operation");
        simulate_work(std::chrono::milliseconds(5));
        timer.mark_failed();
    }
 
    auto metrics_result = profiler.get_metrics("error_scoped_operation");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, 1);
    EXPECT_EQ(metrics.error_count, 1);
}

References kcenon::monitoring::timer.

TEST_F() [23/28]

TEST_F	(	PerformanceMonitoringTest	,
		SystemMetrics	)

Definition at line 222 of file test_performance_monitoring.cpp.

                                                 {
    system_monitor sys_monitor;
 
    auto result = sys_monitor.get_current_metrics();
    ASSERT_TRUE(result.is_ok());
 
    auto metrics = result.value();
 
    // Basic sanity checks
    EXPECT_GE(metrics.cpu_usage_percent, 0.0);
    EXPECT_LE(metrics.cpu_usage_percent, 100.0);
 
    EXPECT_GE(metrics.memory_usage_percent, 0.0);
    EXPECT_LE(metrics.memory_usage_percent, 100.0);
 
    EXPECT_GT(metrics.memory_usage_bytes, 0);
    EXPECT_GT(metrics.thread_count, 0);
}

References kcenon::monitoring::system_monitor::get_current_metrics().

Here is the call graph for this function:

TEST_F() [24/28]

TEST_F	(	PerformanceMonitoringTest	,
		SystemMonitoringHistory	)

Definition at line 241 of file test_performance_monitoring.cpp.

                                                           {
    system_monitor sys_monitor;
 
    auto start_result = sys_monitor.start_monitoring(std::chrono::milliseconds(100));
    ASSERT_TRUE(start_result.is_ok());
 
    // Poll for samples instead of sleeping for fixed duration
    auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5);
    std::vector<system_metrics> history;
    while (std::chrono::steady_clock::now() < deadline) {
        history = sys_monitor.get_history(std::chrono::seconds(1));
        if (history.size() >= 2) {
            break;
        }
        std::this_thread::yield();
    }
 
    EXPECT_GE(history.size(), 2);  // Should have at least 2 samples (relaxed for CI)
 
    // Check that timestamps are increasing
    for (size_t i = 1; i < history.size(); ++i) {
        EXPECT_GT(history[i].timestamp, history[i - 1].timestamp);
    }
 
    auto stop_result = sys_monitor.stop_monitoring();
    ASSERT_TRUE(stop_result.is_ok());
}

References kcenon::monitoring::system_monitor::get_history(), kcenon::monitoring::system_monitor::start_monitoring(), and kcenon::monitoring::system_monitor::stop_monitoring().

Here is the call graph for this function:

TEST_F() [25/28]

TEST_F	(	PerformanceMonitoringTest	,
		TaggedMetricsInCollect	)

Definition at line 515 of file test_performance_monitoring.cpp.

                                                          {
    tag_map tags = {{"method", "GET"}, {"status", "200"}};
    monitor.record_counter("http_requests", 5.0, tags);
 
    auto init_result = monitor.initialize();
    ASSERT_TRUE(init_result.is_ok());
 
    auto snapshot_result = monitor.collect();
    ASSERT_TRUE(snapshot_result.is_ok());
 
    auto snapshot = snapshot_result.value();
 
    // Find our tagged metric in the snapshot
    bool found = false;
    for (const auto& metric : snapshot.metrics) {
        if (metric.name == "http_requests" && !metric.tags.empty()) {
            found = true;
            EXPECT_EQ(metric.value, 5.0);
            EXPECT_EQ(metric.tags.size(), 2);
            EXPECT_EQ(metric.tags.at("method"), "GET");
            EXPECT_EQ(metric.tags.at("status"), "200");
            break;
        }
    }
    EXPECT_TRUE(found);
}

References kcenon::monitoring::metric::name, kcenon::monitoring::metric::tags, and kcenon::monitoring::metric::value.

TEST_F() [26/28]

TEST_F	(	PerformanceMonitoringTest	,
		TagKeyConsistency	)

Definition at line 568 of file test_performance_monitoring.cpp.

                                                     {
    // Tags with same keys in different order should produce same metric
    tag_map tags1 = {{"a", "1"}, {"b", "2"}};
    tag_map tags2 = {{"b", "2"}, {"a", "1"}};
 
    monitor.record_counter("test_metric", 1.0, tags1);
    monitor.record_counter("test_metric", 1.0, tags2);
 
    auto tagged_metrics = monitor.get_all_tagged_metrics();
    ASSERT_EQ(tagged_metrics.size(), 1);  // Should be same metric
    EXPECT_EQ(tagged_metrics[0].value, 2.0);  // Both increments combined
}

TEST_F() [27/28]

TEST_F	(	PerformanceMonitoringTest	,
		ThresholdChecking	)

Definition at line 296 of file test_performance_monitoring.cpp.

                                                     {
    monitor.set_cpu_threshold(0.0);  // Set impossibly low threshold
    monitor.set_memory_threshold(0.0);
    monitor.set_latency_threshold(std::chrono::milliseconds(0));
 
    // Record a sample to trigger latency threshold
    monitor.get_profiler().record_sample("threshold_test", std::chrono::nanoseconds(1000000), true);
 
    auto init_result = monitor.initialize();
    ASSERT_TRUE(init_result.is_ok());
 
    auto threshold_result = monitor.check_thresholds();
    ASSERT_TRUE(threshold_result.is_ok());
    EXPECT_TRUE(threshold_result.value());  // Should exceed thresholds
}

TEST_F() [28/28]

TEST_F	(	PerformanceMonitoringTest	,
		ThroughputCalculation	)

Definition at line 152 of file test_performance_monitoring.cpp.

                                                         {
    // Record 10 operations each taking 100ms
    for (int i = 0; i < 10; ++i) {
        profiler.record_sample("throughput_test",
                               std::chrono::nanoseconds(100000000),  // 100ms
                               true);
    }
 
    auto metrics_result = profiler.get_metrics("throughput_test");
    ASSERT_TRUE(metrics_result.is_ok());
 
    auto metrics = metrics_result.value();
    EXPECT_EQ(metrics.call_count, 10);
    // Throughput calculation depends on implementation
    EXPECT_GE(metrics.throughput, 0.0);
}