utils_test.cpp File Reference

#include "utils.hpp"
#include <gtest/gtest.h>
#include <vector>

Include dependency graph for utils_test.cpp:

Go to the source code of this file.

Classes
class	ChunkGeneratorTest
class	ChunkManipulatorTest
class	StatisticsTest

Functions
	TEST_F (ChunkGeneratorTest, GenerateRandomChunks)
	TEST_F (ChunkGeneratorTest, GenerateRandomData)
	TEST_F (ChunkGeneratorTest, LargeDataGeneration)
	TEST_F (ChunkGeneratorTest, ZeroSizeGeneration)
	TEST_F (ChunkManipulatorTest, EmptyChunkOperations)
	TEST_F (ChunkManipulatorTest, FilterChunks)
	TEST_F (ChunkManipulatorTest, MergeChunks)
	TEST_F (ChunkManipulatorTest, TransformChunks)
	TEST_F (StatisticsTest, HandleSpecialValues)
	TEST_F (StatisticsTest, MeanCalculation)
	TEST_F (StatisticsTest, MedianCalculation)
	TEST_F (StatisticsTest, ModeCalculation)

Function Documentation

TEST_F() [1/12]

TEST_F	(	ChunkGeneratorTest	,
		GenerateRandomChunks
	)

Definition at line 92 of file utils_test.cpp.

                                                 {
    const size_t num_chunks = 5;
    const size_t chunk_size = 10;
 
    auto chunks =
        ChunkGenerator<double>::generate_random_chunks(num_chunks, chunk_size, min_val, max_val);
    EXPECT_EQ(chunks.size(), num_chunks);
 
    for (const auto& chunk : chunks) {
        EXPECT_EQ(chunk.size(), chunk_size);
        for (const auto& val : chunk) {
            EXPECT_GE(val, min_val);
            EXPECT_LE(val, max_val);
        }
    }
}

References chunk_utils::ChunkGenerator< T >::generate_random_chunks().

TEST_F() [2/12]

TEST_F	(	ChunkGeneratorTest	,
		GenerateRandomData
	)

Definition at line 81 of file utils_test.cpp.

                                               {
    auto data = ChunkGenerator<double>::generate_random_data(test_size, min_val, max_val);
    EXPECT_EQ(data.size(), test_size);
 
    // Check bounds
    for (const auto& val : data) {
        EXPECT_GE(val, min_val);
        EXPECT_LE(val, max_val);
    }
}

References chunk_utils::ChunkGenerator< T >::generate_random_data().

TEST_F() [3/12]

TEST_F	(	ChunkGeneratorTest	,
		LargeDataGeneration
	)

Definition at line 144 of file utils_test.cpp.

                                                {
    const size_t large_size = 1000000;
    auto large_data = ChunkGenerator<double>::generate_random_data(large_size, min_val, max_val);
    EXPECT_EQ(large_data.size(), large_size);
}

References chunk_utils::ChunkGenerator< T >::generate_random_data().

TEST_F() [4/12]

TEST_F	(	ChunkGeneratorTest	,
		ZeroSizeGeneration
	)

Definition at line 135 of file utils_test.cpp.

                                               {
    auto empty_data = ChunkGenerator<double>::generate_random_data(0, min_val, max_val);
    EXPECT_TRUE(empty_data.empty());
 
    auto empty_chunks = ChunkGenerator<double>::generate_random_chunks(0, 5, min_val, max_val);
    EXPECT_TRUE(empty_chunks.empty());
}

References chunk_utils::ChunkGenerator< T >::generate_random_chunks(), and chunk_utils::ChunkGenerator< T >::generate_random_data().

TEST_F() [5/12]

TEST_F	(	ChunkManipulatorTest	,
		EmptyChunkOperations
	)

Definition at line 119 of file utils_test.cpp.

                                                   {
    // Merge with empty chunks
    auto merged_empty = ChunkManipulator<double>::merge_chunks(chunks1, empty_chunks);
    EXPECT_EQ(merged_empty.size(), chunks1.size());
 
    // Filter empty chunks
    auto filtered_empty = ChunkManipulator<double>::filter_chunks(
        empty_chunks, [](const std::vector<double>&) { return true; });
    EXPECT_TRUE(filtered_empty.empty());
 
    // Transform empty chunks
    auto transformed_empty = ChunkManipulator<double>::transform_chunks(
        empty_chunks, [](const std::vector<double>& chunk) { return chunk; });
    EXPECT_TRUE(transformed_empty.empty());
}

References chunk_utils::ChunkManipulator< T >::filter_chunks(), chunk_utils::ChunkManipulator< T >::merge_chunks(), and chunk_utils::ChunkManipulator< T >::transform_chunks().

TEST_F() [6/12]

TEST_F	(	ChunkManipulatorTest	,
		FilterChunks
	)

Definition at line 54 of file utils_test.cpp.

                                           {
    auto filtered = ChunkManipulator<double>::filter_chunks(
        chunks1, [](const std::vector<double>& chunk) { return chunk[0] > 2.0; });
    EXPECT_EQ(filtered.size(), 1);
    EXPECT_EQ(filtered[0], std::vector<double>({3.0, 4.0}));
}

References chunk_utils::ChunkManipulator< T >::filter_chunks().

TEST_F() [7/12]

TEST_F	(	ChunkManipulatorTest	,
		MergeChunks
	)

Definition at line 47 of file utils_test.cpp.

                                          {
    auto merged = ChunkManipulator<double>::merge_chunks(chunks1, chunks2);
    EXPECT_EQ(merged.size(), 4);
    EXPECT_EQ(merged[0], std::vector<double>({1.0, 2.0}));
    EXPECT_EQ(merged[3], std::vector<double>({7.0, 8.0}));
}

References chunk_utils::ChunkManipulator< T >::merge_chunks().

TEST_F() [8/12]

TEST_F	(	ChunkManipulatorTest	,
		TransformChunks
	)

Definition at line 61 of file utils_test.cpp.

                                              {
    auto transformed =
        ChunkManipulator<double>::transform_chunks(chunks1, [](const std::vector<double>& chunk) {
            std::vector<double> result = chunk;
            for (auto& val : result)
                val *= 2;
            return result;
        });
    EXPECT_EQ(transformed.size(), 2);
    EXPECT_EQ(transformed[0], std::vector<double>({2.0, 4.0}));
}

References chunk_utils::ChunkManipulator< T >::transform_chunks().

TEST_F() [9/12]

TEST_F	(	StatisticsTest	,
		HandleSpecialValues
	)

Definition at line 110 of file utils_test.cpp.

                                            {
    std::vector<double> special_values = {std::numeric_limits<double>::infinity(),
                                          -std::numeric_limits<double>::infinity(),
                                          std::numeric_limits<double>::quiet_NaN()};
 
    // Mean should handle special values
    EXPECT_FALSE(std::isfinite(Statistics<double>::mean(special_values)));
}

TEST_F() [10/12]

TEST_F	(	StatisticsTest	,
		MeanCalculation
	)

Definition at line 15 of file utils_test.cpp.

                                        {
    EXPECT_DOUBLE_EQ(Statistics<double>::mean(test_data), 3.0);
    EXPECT_DOUBLE_EQ(Statistics<double>::mean(empty_data), 0.0);
}

TEST_F() [11/12]

TEST_F	(	StatisticsTest	,
		MedianCalculation
	)

Definition at line 20 of file utils_test.cpp.

                                          {
    EXPECT_DOUBLE_EQ(Statistics<double>::median(test_data), 3.0);
    EXPECT_DOUBLE_EQ(Statistics<double>::median(empty_data), 0.0);
 
    // Even number of elements
    std::vector<double> even_data = {1.0, 2.0, 3.0, 4.0};
    EXPECT_DOUBLE_EQ(Statistics<double>::median(even_data), 2.5);
}

TEST_F() [12/12]

TEST_F	(	StatisticsTest	,
		ModeCalculation
	)

Definition at line 29 of file utils_test.cpp.

                                        {
    auto mode_result = Statistics<double>::mode(duplicate_data);
    EXPECT_DOUBLE_EQ(mode_result.first, 2.0);
    EXPECT_EQ(mode_result.second, 2);
 
    auto empty_mode = Statistics<double>::mode(empty_data);
    EXPECT_DOUBLE_EQ(empty_mode.first, 0.0);
    EXPECT_EQ(empty_mode.second, 0);
}

References chunk_utils::Statistics< T >::mode().