test_adaptive_monitoring.cpp File Reference

Unit tests for adaptive monitoring functionality. More...

#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <memory>
#include <kcenon/monitoring/adaptive/adaptive_monitor.h>
#include <kcenon/monitoring/core/performance_monitor.h>

Include dependency graph for test_adaptive_monitoring.cpp:

Go to the source code of this file.

Classes
class	mock_collector
class	AdaptiveMonitoringTest

Functions
	TEST_F (AdaptiveMonitoringTest, AdaptiveConfigDefaults)
	TEST_F (AdaptiveMonitoringTest, LoadLevelCalculation)
	TEST_F (AdaptiveMonitoringTest, AdaptiveCollectorSampling)
	TEST_F (AdaptiveMonitoringTest, AdaptationStatistics)
	TEST_F (AdaptiveMonitoringTest, RegisterUnregisterCollector)
	TEST_F (AdaptiveMonitoringTest, StartStopMonitoring)
	TEST_F (AdaptiveMonitoringTest, CollectorPriority)
	TEST_F (AdaptiveMonitoringTest, GlobalStrategy)
	TEST_F (AdaptiveMonitoringTest, GetAllStats)
	TEST_F (AdaptiveMonitoringTest, AdaptiveScope)
	TEST_F (AdaptiveMonitoringTest, MemoryPressureAdaptation)
	TEST_F (AdaptiveMonitoringTest, SmoothingFactor)
	TEST_F (AdaptiveMonitoringTest, AdaptationInterval)
	TEST_F (AdaptiveMonitoringTest, CollectorEnableDisable)
	TEST_F (AdaptiveMonitoringTest, GlobalAdaptiveMonitor)
	TEST_F (AdaptiveMonitoringTest, AdaptiveStrategies)
	TEST_F (AdaptiveMonitoringTest, ConcurrentCollectorAccess)
	TEST_F (AdaptiveMonitoringTest, HysteresisPreventOscillation)
	TEST_F (AdaptiveMonitoringTest, HysteresisDisabled)
	TEST_F (AdaptiveMonitoringTest, CooldownPreventRapidChanges)
	TEST_F (AdaptiveMonitoringTest, GradualLoadIncrease)
	TEST_F (AdaptiveMonitoringTest, GradualLoadDecrease)
	TEST_F (AdaptiveMonitoringTest, SpikeLoadHandling)
	TEST_F (AdaptiveMonitoringTest, OscillatingLoadWithHysteresis)
	TEST_F (AdaptiveMonitoringTest, OscillatingLoadWithoutHysteresis)
	TEST_F (AdaptiveMonitoringTest, ThresholdTuningConfigDefaults)
	TEST_F (AdaptiveMonitoringTest, StatsTrackPreventedChanges)
	TEST_F (AdaptiveMonitoringTest, MemoryPressureWithThresholdTuning)

Detailed Description

Unit tests for adaptive monitoring functionality.

Definition in file test_adaptive_monitoring.cpp.

Function Documentation

TEST_F() [1/28]

TEST_F	(	AdaptiveMonitoringTest	,
		AdaptationInterval	)

Definition at line 324 of file test_adaptive_monitoring.cpp.

                                                   {
    auto mock = std::make_shared<mock_collector>("test");
    
    adaptive_config config;
    config.adaptation_interval = std::chrono::seconds(1);
    
    monitor.register_collector("test", mock, config);
    monitor.start();
    
    // Wait for at least one adaptation cycle
    std::this_thread::sleep_for(std::chrono::milliseconds(1500));
    
    auto stats = monitor.get_collector_stats("test");
    ASSERT_TRUE(stats.is_ok());
 
    // Should have adapted at least once
    EXPECT_GE(stats.value().total_adaptations, 0);
}

References kcenon::monitoring::adaptive_config::adaptation_interval.

TEST_F() [2/28]

TEST_F	(	AdaptiveMonitoringTest	,
		AdaptationStatistics	)

Definition at line 125 of file test_adaptive_monitoring.cpp.

                                                     {
    auto mock = std::make_shared<mock_collector>("test_collector");
 
    adaptive_config config;
    config.enable_hysteresis = false;  // Disable for predictable behavior
    config.enable_cooldown = false;
    config.smoothing_factor = 1.0;  // No smoothing for predictable behavior
    adaptive_collector collector(mock, config);
 
    // Simulate load changes
    system_metrics low_load;
    low_load.cpu_usage_percent = 30.0;
    low_load.memory_usage_percent = 40.0;
 
    system_metrics high_load;
    high_load.cpu_usage_percent = 85.0;
    high_load.memory_usage_percent = 70.0;
 
    // Adapt to low load
    collector.adapt(low_load);
    auto stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::low);
 
    // Adapt to high load
    collector.adapt(high_load);
    stats = collector.get_stats();
    // With smoothing disabled, 85% CPU should go to critical (>80%)
    EXPECT_EQ(stats.current_load_level, load_level::critical);
    EXPECT_GT(stats.total_adaptations, 0);
    EXPECT_GT(stats.downscale_count, 0);
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::system_metrics::memory_usage_percent, and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [3/28]

TEST_F	(	AdaptiveMonitoringTest	,
		AdaptiveCollectorSampling	)

Definition at line 98 of file test_adaptive_monitoring.cpp.

                                                          {
    auto mock = std::make_shared<mock_collector>("test_collector");
 
    adaptive_config config;
    config.idle_sampling_rate = 1.0;  // Always sample
    config.enable_hysteresis = false;  // Disable for predictable behavior
    config.enable_cooldown = false;
    adaptive_collector collector(mock, config);
 
    // Should collect when sampling rate is 1.0
    auto result = collector.collect();
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(mock->get_collect_count(), 1);
 
    // Change config to lower sampling rate
    config.critical_sampling_rate = 0.0;  // Never sample
    collector.set_config(config);
 
    // Force adaptation to critical level
    system_metrics sys_metrics;
    sys_metrics.cpu_usage_percent = 90.0;  // Critical load
    collector.adapt(sys_metrics);
 
    auto stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::critical);
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::adaptive_collector::collect(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::critical_sampling_rate, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::adaptive_config::idle_sampling_rate, and kcenon::monitoring::adaptive_collector::set_config().

Here is the call graph for this function:

TEST_F() [4/28]

TEST_F	(	AdaptiveMonitoringTest	,
		AdaptiveConfigDefaults	)

Definition at line 74 of file test_adaptive_monitoring.cpp.

                                                       {
    adaptive_config config;
    
    EXPECT_EQ(config.idle_threshold, 20.0);
    EXPECT_EQ(config.low_threshold, 40.0);
    EXPECT_EQ(config.moderate_threshold, 60.0);
    EXPECT_EQ(config.high_threshold, 80.0);
    
    EXPECT_EQ(config.strategy, adaptation_strategy::balanced);
    EXPECT_EQ(config.smoothing_factor, 0.7);
}

References kcenon::monitoring::adaptive_config::high_threshold, kcenon::monitoring::adaptive_config::idle_threshold, kcenon::monitoring::adaptive_config::low_threshold, kcenon::monitoring::adaptive_config::moderate_threshold, kcenon::monitoring::adaptive_config::smoothing_factor, and kcenon::monitoring::adaptive_config::strategy.

TEST_F() [5/28]

TEST_F	(	AdaptiveMonitoringTest	,
		AdaptiveScope	)

Definition at line 252 of file test_adaptive_monitoring.cpp.

                                              {
    auto mock = std::make_shared<mock_collector>("scoped");
    
    {
        adaptive_scope scope("scoped", mock);
        EXPECT_TRUE(scope.is_registered());
        
        // Collector should be registered
        // Use the monitor member instead of global monitor
        auto stats = global_adaptive_monitor().get_collector_stats("scoped");
        EXPECT_TRUE(stats.is_ok());
    }
    // Scope destroyed, collector should be unregistered
 
    auto stats = global_adaptive_monitor().get_collector_stats("scoped");
    EXPECT_FALSE(stats.is_ok());
}

References kcenon::monitoring::adaptive_monitor::get_collector_stats(), kcenon::monitoring::global_adaptive_monitor(), and kcenon::monitoring::adaptive_scope::is_registered().

Here is the call graph for this function:

TEST_F() [6/28]

TEST_F	(	AdaptiveMonitoringTest	,
		AdaptiveStrategies	)

Definition at line 368 of file test_adaptive_monitoring.cpp.

                                                   {
    auto mock = std::make_shared<mock_collector>("test");
    
    // Test conservative strategy
    adaptive_config conservative_config;
    conservative_config.strategy = adaptation_strategy::conservative;
    adaptive_collector conservative_collector(mock, conservative_config);
    
    system_metrics metrics;
    metrics.cpu_usage_percent = 50.0;  // Moderate load
    
    conservative_collector.adapt(metrics);
    auto conservative_stats = conservative_collector.get_stats();
    
    // Test aggressive strategy
    adaptive_config aggressive_config;
    aggressive_config.strategy = adaptation_strategy::aggressive;
    adaptive_collector aggressive_collector(mock, aggressive_config);
    
    aggressive_collector.adapt(metrics);
    auto aggressive_stats = aggressive_collector.get_stats();
    
    // Conservative should have lower load level than aggressive
    EXPECT_LE(static_cast<int>(conservative_stats.current_load_level),
              static_cast<int>(aggressive_stats.current_load_level));
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_collector::get_stats(), and kcenon::monitoring::adaptive_config::strategy.

Here is the call graph for this function:

TEST_F() [7/28]

TEST_F	(	AdaptiveMonitoringTest	,
		CollectorEnableDisable	)

Definition at line 343 of file test_adaptive_monitoring.cpp.

                                                       {
    auto mock = std::make_shared<mock_collector>("test");
    adaptive_collector collector(mock);
    
    EXPECT_TRUE(collector.is_enabled());
    
    collector.set_enabled(false);
    EXPECT_FALSE(collector.is_enabled());
    
    // When disabled, should always sample
    auto result = collector.collect();
    EXPECT_TRUE(result.is_ok());
}

References kcenon::monitoring::adaptive_collector::collect(), kcenon::monitoring::adaptive_collector::is_enabled(), and kcenon::monitoring::adaptive_collector::set_enabled().

Here is the call graph for this function:

TEST_F() [8/28]

TEST_F	(	AdaptiveMonitoringTest	,
		CollectorPriority	)

Definition at line 200 of file test_adaptive_monitoring.cpp.

                                                  {
    auto high_priority = std::make_shared<mock_collector>("high");
    auto medium_priority = std::make_shared<mock_collector>("medium");
    auto low_priority = std::make_shared<mock_collector>("low");
    
    monitor.register_collector("high", high_priority);
    monitor.register_collector("medium", medium_priority);
    monitor.register_collector("low", low_priority);
    
    // Set priorities
    monitor.set_collector_priority("high", 100);
    monitor.set_collector_priority("medium", 50);
    monitor.set_collector_priority("low", 10);
    
    // Get active collectors (should be ordered by priority)
    auto active = monitor.get_active_collectors();
    EXPECT_GE(active.size(), 1);
    if (active.size() > 0) {
        EXPECT_EQ(active[0], "high");
    }
}

References kcenon::monitoring::active.

TEST_F() [9/28]

TEST_F	(	AdaptiveMonitoringTest	,
		ConcurrentCollectorAccess	)

Definition at line 395 of file test_adaptive_monitoring.cpp.

                                                          {
    const int num_threads = 10;
    const int collectors_per_thread = 5;
 
    std::vector<std::thread> threads;
 
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([this, t, collectors_per_thread]() {
            for (int c = 0; c < collectors_per_thread; ++c) {
                std::string name = "collector_" + std::to_string(t) + "_" + std::to_string(c);
                auto mock = std::make_shared<mock_collector>(name);
 
                monitor.register_collector(name, mock);
 
                // Random operations
                if (c % 2 == 0) {
                    monitor.set_collector_priority(name, t * 10 + c);
                }
 
                if (c % 3 == 0) {
                    monitor.get_collector_stats(name);
                }
            }
        });
    }
 
    for (auto& thread : threads) {
        thread.join();
    }
 
    auto all_stats = monitor.get_all_stats();
    EXPECT_EQ(all_stats.size(), num_threads * collectors_per_thread);
}

TEST_F() [10/28]

TEST_F	(	AdaptiveMonitoringTest	,
		CooldownPreventRapidChanges	)

Definition at line 495 of file test_adaptive_monitoring.cpp.

                                                            {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = false;  // Disable hysteresis for this test
    config.enable_cooldown = true;
    config.cooldown_period = std::chrono::milliseconds(100);
    config.smoothing_factor = 1.0;
 
    adaptive_collector collector(mock, config);
 
    // First adaptation - sets initial level and last_level_change timestamp
    // Default level is moderate, 85% CPU should trigger critical
    system_metrics metrics;
    metrics.cpu_usage_percent = 85.0;  // Critical
    collector.adapt(metrics);
 
    auto stats = collector.get_stats();
    // First adaptation sets initial values, triggering a change from default moderate to critical
    EXPECT_EQ(stats.current_load_level, load_level::critical);
    EXPECT_EQ(stats.total_adaptations, 1);
 
    // Try immediate change to idle (within cooldown period)
    metrics.cpu_usage_percent = 10.0;
    collector.adapt(metrics);
 
    stats = collector.get_stats();
    // Should be prevented by cooldown - still at critical
    EXPECT_EQ(stats.current_load_level, load_level::critical);
    EXPECT_EQ(stats.cooldown_prevented_changes, 1);
 
    // Wait for cooldown period to expire
    std::this_thread::sleep_for(std::chrono::milliseconds(110));
 
    // Now change should succeed
    collector.adapt(metrics);
    stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::idle);
    EXPECT_EQ(stats.total_adaptations, 2);
 
    // Verify another immediate change is blocked
    metrics.cpu_usage_percent = 85.0;
    collector.adapt(metrics);
 
    stats = collector.get_stats();
    // Should still be idle due to cooldown
    EXPECT_EQ(stats.current_load_level, load_level::idle);
    EXPECT_EQ(stats.cooldown_prevented_changes, 2);
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::adaptive_config::cooldown_period, kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [11/28]

TEST_F	(	AdaptiveMonitoringTest	,
		GetAllStats	)

Definition at line 239 of file test_adaptive_monitoring.cpp.

                                            {
    auto mock1 = std::make_shared<mock_collector>("collector1");
    auto mock2 = std::make_shared<mock_collector>("collector2");
    
    monitor.register_collector("collector1", mock1);
    monitor.register_collector("collector2", mock2);
    
    auto all_stats = monitor.get_all_stats();
    EXPECT_EQ(all_stats.size(), 2);
    EXPECT_TRUE(all_stats.find("collector1") != all_stats.end());
    EXPECT_TRUE(all_stats.find("collector2") != all_stats.end());
}

TEST_F() [12/28]

TEST_F	(	AdaptiveMonitoringTest	,
		GlobalAdaptiveMonitor	)

Definition at line 357 of file test_adaptive_monitoring.cpp.

                                                      {
    auto& global = global_adaptive_monitor();
    
    auto mock = std::make_shared<mock_collector>("global_test");
    auto result = global.register_collector("global_test", mock);
    ASSERT_TRUE(result.is_ok());
    
    // Cleanup
    global.unregister_collector("global_test");
}

References kcenon::monitoring::global_adaptive_monitor().

Here is the call graph for this function:

TEST_F() [13/28]

TEST_F	(	AdaptiveMonitoringTest	,
		GlobalStrategy	)

Definition at line 222 of file test_adaptive_monitoring.cpp.

                                               {
    auto mock = std::make_shared<mock_collector>("test");
    monitor.register_collector("test", mock);
    
    // Set global strategy
    monitor.set_global_strategy(adaptation_strategy::conservative);
    
    // Force adaptation
    auto result = monitor.force_adaptation();
    ASSERT_TRUE(result.is_ok());
    
    // Check that strategy was applied
    auto stats_result = monitor.get_collector_stats("test");
    ASSERT_TRUE(stats_result.is_ok());
    // Strategy effects would be visible in adaptation behavior
}

TEST_F() [14/28]

TEST_F	(	AdaptiveMonitoringTest	,
		GradualLoadDecrease	)

Definition at line 583 of file test_adaptive_monitoring.cpp.

                                                    {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = false;
    config.enable_cooldown = false;
    config.smoothing_factor = 1.0;
 
    adaptive_collector collector(mock, config);
 
    // Start at critical load
    system_metrics metrics;
    metrics.cpu_usage_percent = 90.0;
    collector.adapt(metrics);
 
    // Gradually decrease load
    std::vector<std::pair<double, load_level>> load_progression = {
        {75.0, load_level::high},
        {55.0, load_level::moderate},
        {35.0, load_level::low},
        {15.0, load_level::idle}
    };
 
    for (const auto& [cpu, expected_level] : load_progression) {
        metrics.cpu_usage_percent = cpu;
        collector.adapt(metrics);
        auto stats = collector.get_stats();
 
        EXPECT_EQ(stats.current_load_level, expected_level)
            << "Failed at CPU " << cpu << "%";
    }
 
    auto stats = collector.get_stats();
    EXPECT_EQ(stats.upscale_count, 4);  // 4 decreases in load
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::cpu, kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [15/28]

TEST_F	(	AdaptiveMonitoringTest	,
		GradualLoadIncrease	)

Definition at line 545 of file test_adaptive_monitoring.cpp.

                                                    {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = false;
    config.enable_cooldown = false;
    config.smoothing_factor = 1.0;
 
    adaptive_collector collector(mock, config);
 
    // Gradually increase load from idle to critical
    std::vector<std::pair<double, load_level>> load_progression = {
        {10.0, load_level::idle},
        {25.0, load_level::low},
        {45.0, load_level::moderate},
        {65.0, load_level::high},
        {85.0, load_level::critical}
    };
 
    for (const auto& [cpu, expected_level] : load_progression) {
        system_metrics metrics;
        metrics.cpu_usage_percent = cpu;
        metrics.memory_usage_percent = 30.0;
 
        collector.adapt(metrics);
        auto stats = collector.get_stats();
 
        EXPECT_EQ(stats.current_load_level, expected_level)
            << "Failed at CPU " << cpu << "%";
    }
 
    auto stats = collector.get_stats();
    // Note: First adaptation from moderate (default) to idle counts as upscale
    // Then 4 changes: idle->low->moderate->high->critical (all downscales)
    EXPECT_GE(stats.total_adaptations, 4);
    EXPECT_GE(stats.downscale_count, 4);
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::cpu, kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::system_metrics::memory_usage_percent, and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [16/28]

TEST_F	(	AdaptiveMonitoringTest	,
		HysteresisDisabled	)

Definition at line 469 of file test_adaptive_monitoring.cpp.

                                                   {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = false;  // Disable hysteresis
    config.enable_cooldown = false;
    config.smoothing_factor = 1.0;
 
    adaptive_collector collector(mock, config);
 
    // Start at low load (30%)
    system_metrics metrics;
    metrics.cpu_usage_percent = 30.0;
    collector.adapt(metrics);
 
    auto stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::low);
 
    // Move to just above threshold (41%) - should change immediately
    metrics.cpu_usage_percent = 41.0;
    collector.adapt(metrics);
 
    stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::moderate);  // Should change immediately
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [17/28]

TEST_F	(	AdaptiveMonitoringTest	,
		HysteresisPreventOscillation	)

Definition at line 433 of file test_adaptive_monitoring.cpp.

                                                             {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = true;
    config.hysteresis_margin = 5.0;  // 5% margin
    config.enable_cooldown = false;  // Disable cooldown for this test
    config.smoothing_factor = 1.0;   // No smoothing for predictable behavior
 
    adaptive_collector collector(mock, config);
 
    // Start at low load (30%)
    system_metrics metrics;
    metrics.cpu_usage_percent = 30.0;
    metrics.memory_usage_percent = 30.0;
    collector.adapt(metrics);
 
    auto stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::low);
 
    // Move to just above threshold (41%) - should NOT change due to hysteresis
    // Threshold for moderate is 40%, margin is 5%, so need > 45% to change
    metrics.cpu_usage_percent = 41.0;
    collector.adapt(metrics);
 
    stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::low);  // Should stay at low
 
    // Move to well above threshold (50%) - should change
    metrics.cpu_usage_percent = 50.0;
    collector.adapt(metrics);
 
    stats = collector.get_stats();
    EXPECT_EQ(stats.current_load_level, load_level::moderate);  // Now should be moderate
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::adaptive_config::hysteresis_margin, kcenon::monitoring::system_metrics::memory_usage_percent, and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [18/28]

TEST_F	(	AdaptiveMonitoringTest	,
		LoadLevelCalculation	)

Definition at line 86 of file test_adaptive_monitoring.cpp.

                                                     {
    adaptive_config config;
    
    EXPECT_EQ(config.get_interval_for_load(load_level::idle), 
              std::chrono::milliseconds(100));
    EXPECT_EQ(config.get_interval_for_load(load_level::critical), 
              std::chrono::milliseconds(5000));
    
    EXPECT_EQ(config.get_sampling_rate_for_load(load_level::idle), 1.0);
    EXPECT_EQ(config.get_sampling_rate_for_load(load_level::critical), 0.1);
}

References kcenon::monitoring::adaptive_config::get_interval_for_load(), and kcenon::monitoring::adaptive_config::get_sampling_rate_for_load().

Here is the call graph for this function:

TEST_F() [19/28]

TEST_F	(	AdaptiveMonitoringTest	,
		MemoryPressureAdaptation	)

Definition at line 270 of file test_adaptive_monitoring.cpp.

                                                         {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.memory_warning_threshold = 70.0;
    config.memory_critical_threshold = 85.0;
    config.enable_hysteresis = false;  // Disable for predictable behavior
    config.enable_cooldown = false;
 
    adaptive_collector collector(mock, config);
 
    // High memory usage should affect load level
    system_metrics metrics;
    metrics.cpu_usage_percent = 30.0;  // Low CPU
    metrics.memory_usage_percent = 90.0;  // Critical memory
 
    collector.adapt(metrics);
    auto stats = collector.get_stats();
 
    // Should be at least high load due to memory pressure
    EXPECT_GE(static_cast<int>(stats.current_load_level),
              static_cast<int>(load_level::high));
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::adaptive_config::memory_critical_threshold, kcenon::monitoring::system_metrics::memory_usage_percent, and kcenon::monitoring::adaptive_config::memory_warning_threshold.

Here is the call graph for this function:

TEST_F() [20/28]

TEST_F	(	AdaptiveMonitoringTest	,
		MemoryPressureWithThresholdTuning	)

Definition at line 768 of file test_adaptive_monitoring.cpp.

                                                                  {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = true;
    config.hysteresis_margin = 5.0;
    config.enable_cooldown = false;
    config.smoothing_factor = 1.0;
    config.memory_critical_threshold = 85.0;
 
    adaptive_collector collector(mock, config);
 
    // Start with low CPU but critical memory
    system_metrics metrics;
    metrics.cpu_usage_percent = 30.0;  // Low CPU
    metrics.memory_usage_percent = 90.0;  // Critical memory
 
    collector.adapt(metrics);
    auto stats = collector.get_stats();
 
    // Memory pressure should override CPU and push to high+ level
    EXPECT_GE(static_cast<int>(stats.current_load_level),
              static_cast<int>(load_level::high));
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::adaptive_config::hysteresis_margin, kcenon::monitoring::adaptive_config::memory_critical_threshold, kcenon::monitoring::system_metrics::memory_usage_percent, and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [21/28]

TEST_F	(	AdaptiveMonitoringTest	,
		OscillatingLoadWithHysteresis	)

Definition at line 666 of file test_adaptive_monitoring.cpp.

                                                              {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = true;
    config.hysteresis_margin = 5.0;
    config.enable_cooldown = false;
    config.smoothing_factor = 1.0;  // No smoothing for predictable behavior
 
    adaptive_collector collector(mock, config);
 
    // Start at moderate threshold boundary (40%)
    system_metrics metrics;
    metrics.cpu_usage_percent = 40.0;
    collector.adapt(metrics);
 
    auto initial_stats = collector.get_stats();
    uint64_t initial_adaptations = initial_stats.total_adaptations;
 
    // Oscillate around threshold boundary (38-42%)
    // With 5% hysteresis, these should not cause level changes
    for (int i = 0; i < 10; ++i) {
        metrics.cpu_usage_percent = (i % 2 == 0) ? 38.0 : 42.0;
        collector.adapt(metrics);
    }
 
    auto final_stats = collector.get_stats();
    // Should have minimal adaptations due to hysteresis
    EXPECT_LE(final_stats.total_adaptations - initial_adaptations, 2);
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::adaptive_config::hysteresis_margin, kcenon::monitoring::adaptive_config::smoothing_factor, and kcenon::monitoring::adaptation_stats::total_adaptations.

Here is the call graph for this function:

TEST_F() [22/28]

TEST_F	(	AdaptiveMonitoringTest	,
		OscillatingLoadWithoutHysteresis	)

Definition at line 697 of file test_adaptive_monitoring.cpp.

                                                                 {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = false;  // Disable hysteresis
    config.enable_cooldown = false;
    config.smoothing_factor = 1.0;
 
    adaptive_collector collector(mock, config);
 
    // Start at moderate threshold boundary
    system_metrics metrics;
    metrics.cpu_usage_percent = 40.0;
    collector.adapt(metrics);
 
    auto initial_stats = collector.get_stats();
    uint64_t initial_adaptations = initial_stats.total_adaptations;
 
    // Oscillate around threshold boundary (38-42%)
    for (int i = 0; i < 10; ++i) {
        metrics.cpu_usage_percent = (i % 2 == 0) ? 38.0 : 42.0;
        collector.adapt(metrics);
    }
 
    auto final_stats = collector.get_stats();
    // Without hysteresis, should have many adaptations
    EXPECT_GT(final_stats.total_adaptations - initial_adaptations, 5);
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::adaptive_config::smoothing_factor, and kcenon::monitoring::adaptation_stats::total_adaptations.

Here is the call graph for this function:

TEST_F() [23/28]

TEST_F	(	AdaptiveMonitoringTest	,
		RegisterUnregisterCollector	)

Definition at line 157 of file test_adaptive_monitoring.cpp.

                                                            {
    auto mock = std::make_shared<mock_collector>("test_collector");
    
    // Register collector
    auto result = monitor.register_collector("test", mock);
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value());
    
    // Try to register again (should fail)
    result = monitor.register_collector("test", mock);
    ASSERT_FALSE(result.is_ok());
    EXPECT_EQ(result.error().code, static_cast<int>(monitoring_error_code::already_exists));
    
    // Unregister
    result = monitor.unregister_collector("test");
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(result.value());
    
    // Try to unregister non-existent (should fail)
    result = monitor.unregister_collector("test");
    ASSERT_FALSE(result.is_ok());
    EXPECT_EQ(result.error().code, static_cast<int>(monitoring_error_code::not_found));
}

TEST_F() [24/28]

TEST_F	(	AdaptiveMonitoringTest	,
		SmoothingFactor	)

Definition at line 294 of file test_adaptive_monitoring.cpp.

                                                {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.smoothing_factor = 0.5;  // Equal weight to old and new
    config.enable_hysteresis = false;
    config.enable_cooldown = false;
 
    adaptive_collector collector(mock, config);
 
    // First adaptation
    system_metrics metrics1;
    metrics1.cpu_usage_percent = 20.0;
    collector.adapt(metrics1);
 
    auto stats1 = collector.get_stats();
    // First adaptation sets initial value directly
    EXPECT_NEAR(stats1.average_cpu_usage, 20.0, 1.0);
 
    // Second adaptation
    system_metrics metrics2;
    metrics2.cpu_usage_percent = 60.0;
    collector.adapt(metrics2);
 
    auto stats2 = collector.get_stats();
    // Should be smoothed: 0.5 * 60 + 0.5 * 20 = 40
    EXPECT_GT(stats2.average_cpu_usage, 20.0);
    EXPECT_LE(stats2.average_cpu_usage, 60.0);  // Changed from < to <= for boundary case
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [25/28]

TEST_F	(	AdaptiveMonitoringTest	,
		SpikeLoadHandling	)

Definition at line 619 of file test_adaptive_monitoring.cpp.

                                                  {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = false;  // Disable hysteresis for predictable spike response
    config.enable_cooldown = false;    // Disable cooldown to focus on smoothing behavior
    config.smoothing_factor = 0.5;     // 50% smoothing
 
    adaptive_collector collector(mock, config);
 
    // Establish baseline at moderate load
    // Note: First adaptation sets the initial average directly
    system_metrics metrics;
    metrics.cpu_usage_percent = 50.0;
    collector.adapt(metrics);
 
    auto baseline_stats = collector.get_stats();
    // 50% is in the moderate range (40-60%)
    EXPECT_EQ(baseline_stats.current_load_level, load_level::moderate);
 
    // Sudden spike - simulate extremely high load
    metrics.cpu_usage_percent = 100.0;
    collector.adapt(metrics);
 
    auto spike_stats = collector.get_stats();
    // Due to smoothing: 0.5 * 100 + 0.5 * 50 = 75 -> high level (60-80%)
    EXPECT_GE(static_cast<int>(spike_stats.current_load_level),
              static_cast<int>(load_level::high));
 
    // Continue spike to push into critical
    metrics.cpu_usage_percent = 100.0;
    collector.adapt(metrics);
 
    auto continued_spike_stats = collector.get_stats();
    // Smoothed: 0.5 * 100 + 0.5 * 75 = 87.5 -> critical (>80%)
    EXPECT_EQ(continued_spike_stats.current_load_level, load_level::critical);
 
    // Return to normal - smoothing should bring it down gradually
    metrics.cpu_usage_percent = 40.0;
    collector.adapt(metrics);
 
    auto recovery_stats = collector.get_stats();
    // Smoothed: 0.5 * 40 + 0.5 * 87.5 = 63.75 -> high level
    EXPECT_LE(static_cast<int>(recovery_stats.current_load_level),
              static_cast<int>(continued_spike_stats.current_load_level));
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [26/28]

TEST_F	(	AdaptiveMonitoringTest	,
		StartStopMonitoring	)

Definition at line 181 of file test_adaptive_monitoring.cpp.

                                                    {
    auto mock = std::make_shared<mock_collector>("test_collector");
    monitor.register_collector("test", mock);
    
    EXPECT_FALSE(monitor.is_running());
    
    auto result = monitor.start();
    ASSERT_TRUE(result.is_ok());
    EXPECT_TRUE(monitor.is_running());
    
    // Start again (should succeed but do nothing)
    result = monitor.start();
    ASSERT_TRUE(result.is_ok());
    
    result = monitor.stop();
    ASSERT_TRUE(result.is_ok());
    EXPECT_FALSE(monitor.is_running());
}

TEST_F() [27/28]

TEST_F	(	AdaptiveMonitoringTest	,
		StatsTrackPreventedChanges	)

Definition at line 736 of file test_adaptive_monitoring.cpp.

                                                           {
    auto mock = std::make_shared<mock_collector>("test");
 
    adaptive_config config;
    config.enable_hysteresis = true;
    config.hysteresis_margin = 10.0;  // Large margin
    config.enable_cooldown = true;
    config.cooldown_period = std::chrono::milliseconds(500);
    config.smoothing_factor = 1.0;
 
    adaptive_collector collector(mock, config);
 
    // Initial adaptation
    system_metrics metrics;
    metrics.cpu_usage_percent = 30.0;
    collector.adapt(metrics);
 
    // Try changes within hysteresis margin
    metrics.cpu_usage_percent = 42.0;  // Just above 40% threshold, but within 10% margin
    collector.adapt(metrics);
 
    // Try rapid changes (within cooldown)
    metrics.cpu_usage_percent = 60.0;
    collector.adapt(metrics);
    metrics.cpu_usage_percent = 30.0;
    collector.adapt(metrics);
 
    auto stats = collector.get_stats();
    // Should have tracked at least one prevented change
    EXPECT_GE(stats.cooldown_prevented_changes + stats.hysteresis_prevented_changes, 0);
}

References kcenon::monitoring::adaptive_collector::adapt(), kcenon::monitoring::adaptive_config::cooldown_period, kcenon::monitoring::system_metrics::cpu_usage_percent, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, kcenon::monitoring::adaptive_collector::get_stats(), kcenon::monitoring::adaptive_config::hysteresis_margin, and kcenon::monitoring::adaptive_config::smoothing_factor.

Here is the call graph for this function:

TEST_F() [28/28]

TEST_F	(	AdaptiveMonitoringTest	,
		ThresholdTuningConfigDefaults	)

Definition at line 726 of file test_adaptive_monitoring.cpp.

                                                              {
    adaptive_config config;
 
    // Verify new ARC-005 defaults
    EXPECT_EQ(config.hysteresis_margin, 5.0);
    EXPECT_EQ(config.cooldown_period, std::chrono::milliseconds(1000));
    EXPECT_TRUE(config.enable_hysteresis);
    EXPECT_TRUE(config.enable_cooldown);
}

References kcenon::monitoring::adaptive_config::cooldown_period, kcenon::monitoring::adaptive_config::enable_cooldown, kcenon::monitoring::adaptive_config::enable_hysteresis, and kcenon::monitoring::adaptive_config::hysteresis_margin.