test_metrics.cpp File Reference

#include "chunk_metrics.hpp"
#include "test_base.hpp"
#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <future>
#include <iostream>
#include <limits>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <thread>
#include <vector>

Include dependency graph for test_metrics.cpp:

Go to the source code of this file.

Classes
class	ChunkMetricsTest

Functions
	TEST_F (ChunkMetricsTest, CacheClear)
	TEST_F (ChunkMetricsTest, CohesionCalculation)
	TEST_F (ChunkMetricsTest, EmptyChunks)
	TEST_F (ChunkMetricsTest, QualityScore)
	TEST_F (ChunkMetricsTest, SeparationCalculation)
	TEST_F (ChunkMetricsTest, SilhouetteScore)
	TEST_F (ChunkMetricsTest, SingleChunk)
	TEST_F (ChunkMetricsTest, SizeMetrics)

Function Documentation

TEST_F() [1/8]

TEST_F	(	ChunkMetricsTest	,
		CacheClear
	)

Definition at line 196 of file test_metrics.cpp.

                                     {
    analyzer->compute_cohesion(well_separated_chunks);
    analyzer->compute_separation(well_separated_chunks);
    analyzer->clear_cache();
    // Verify the function runs without errors
    EXPECT_NO_THROW(analyzer->compute_cohesion(well_separated_chunks));
}

TEST_F() [2/8]

TEST_F	(	ChunkMetricsTest	,
		CohesionCalculation
	)

Definition at line 101 of file test_metrics.cpp.

                                              {
    ASSERT_TRUE(analyzer != nullptr) << "Analyzer is null";
    ASSERT_FALSE(well_separated_chunks.empty()) << "Well separated chunks is empty";
    ASSERT_FALSE(mixed_cohesion_chunks.empty()) << "Mixed cohesion chunks is empty";
 
    try {
        double high_cohesion = 0.0;
        double mixed_cohesion = 0.0;
        
        bool success = analyzer->compare_cohesion(
            well_separated_chunks,
            mixed_cohesion_chunks,
            high_cohesion,
            mixed_cohesion
        );
 
        ASSERT_TRUE(success) << "Cohesion comparison failed";
        ASSERT_TRUE(std::isfinite(high_cohesion)) << "High cohesion is not finite";
        ASSERT_TRUE(std::isfinite(mixed_cohesion)) << "Mixed cohesion is not finite";
        
        EXPECT_GT(high_cohesion, mixed_cohesion) 
            << "High cohesion (" << high_cohesion 
            << ") should be greater than mixed cohesion (" << mixed_cohesion << ")";
            
    } catch (const std::exception& e) {
        FAIL() << "Unexpected exception: " << e.what();
    }
}

TEST_F() [3/8]

TEST_F	(	ChunkMetricsTest	,
		EmptyChunks
	)

Definition at line 179 of file test_metrics.cpp.

                                      {
    std::vector<std::vector<double>> empty_chunks;
    EXPECT_THROW(analyzer->compute_quality_score(empty_chunks), std::invalid_argument);
    EXPECT_THROW(analyzer->compute_cohesion(empty_chunks), std::invalid_argument);
    EXPECT_THROW(analyzer->compute_separation(empty_chunks), std::invalid_argument);
    EXPECT_THROW(analyzer->compute_silhouette_score(empty_chunks), std::invalid_argument);
    EXPECT_THROW(analyzer->compute_size_metrics(empty_chunks), std::invalid_argument);
}

TEST_F() [4/8]

TEST_F	(	ChunkMetricsTest	,
		QualityScore
	)

Definition at line 142 of file test_metrics.cpp.

                                       {
    ASSERT_TRUE(analyzer != nullptr);
 
    try {
        auto result = run_safely([this]() -> std::pair<double, double> {
            std::unique_lock<std::mutex> lock(test_mutex_);
 
            double high_quality = analyzer->compute_quality_score(well_separated_chunks);
            analyzer->clear_cache();
            double mixed_quality = analyzer->compute_quality_score(mixed_cohesion_chunks);
 
            if (!std::isfinite(high_quality) || !std::isfinite(mixed_quality)) {
                throw std::runtime_error("Invalid quality score results");
            }
 
            return std::make_pair(high_quality, mixed_quality);
        });
 
        EXPECT_GT(result.first, result.second)
            << "High quality should be greater than mixed quality";
        EXPECT_GE(result.first, 0.0) << "Quality score should be non-negative";
        EXPECT_LE(result.first, 1.0) << "Quality score should not exceed 1.0";
 
    } catch (const std::exception& e) {
        FAIL() << "Unexpected exception: " << e.what();
    }
}

TEST_F() [5/8]

TEST_F	(	ChunkMetricsTest	,
		SeparationCalculation
	)

Definition at line 130 of file test_metrics.cpp.

                                                {
    double separation = analyzer->compute_separation(well_separated_chunks);
    EXPECT_GT(separation, 0.0);
    EXPECT_LE(separation, 1.0);
}

TEST_F() [6/8]

TEST_F	(	ChunkMetricsTest	,
		SilhouetteScore
	)

Definition at line 136 of file test_metrics.cpp.

                                          {
    double silhouette = analyzer->compute_silhouette_score(well_separated_chunks);
    EXPECT_GE(silhouette, -1.0);
    EXPECT_LE(silhouette, 1.0);
}

TEST_F() [7/8]

TEST_F	(	ChunkMetricsTest	,
		SingleChunk
	)

Definition at line 188 of file test_metrics.cpp.

                                      {
    std::vector<std::vector<double>> single_chunk = {{1.0, 2.0, 3.0}};
    EXPECT_NO_THROW(analyzer->compute_cohesion(single_chunk));
    EXPECT_THROW(analyzer->compute_separation(single_chunk), std::invalid_argument);
    EXPECT_THROW(analyzer->compute_silhouette_score(single_chunk), std::invalid_argument);
    EXPECT_NO_THROW(analyzer->compute_quality_score(single_chunk));
}

TEST_F() [8/8]

TEST_F	(	ChunkMetricsTest	,
		SizeMetrics
	)

Definition at line 170 of file test_metrics.cpp.

                                      {
    auto metrics = analyzer->compute_size_metrics(well_separated_chunks);
 
    EXPECT_EQ(metrics["average_size"], 3.0);
    EXPECT_EQ(metrics["max_size"], 3.0);
    EXPECT_EQ(metrics["min_size"], 3.0);
    EXPECT_NEAR(metrics["size_variance"], 0.0, 1e-10);
}