advanced_chunk_strategies_test.cpp File Reference

#include "chunk_strategies.hpp"
#include <functional>
#include <gtest/gtest.h>
#include <vector>

Include dependency graph for advanced_chunk_strategies_test.cpp:

Go to the source code of this file.

Classes
class	AdvancedChunkStrategiesTest

Functions
	TEST_F (AdvancedChunkStrategiesTest, EmptyInput)
	TEST_F (AdvancedChunkStrategiesTest, MultiDimensionalThresholds)
	TEST_F (AdvancedChunkStrategiesTest, PatternBasedCyclicDetection)
	TEST_F (AdvancedChunkStrategiesTest, PatternBasedPredicate)
	TEST_F (AdvancedChunkStrategiesTest, SingleElementInput)

Function Documentation

TEST_F() [1/5]

TEST_F	(	AdvancedChunkStrategiesTest	,
		EmptyInput
	)

Definition at line 48 of file advanced_chunk_strategies_test.cpp.

                                                {
    // Test with pattern size
    chunk_processing::PatternBasedStrategy<double> size_strategy(2);
    auto size_chunks = size_strategy.apply(empty_data);
    EXPECT_TRUE(size_chunks.empty());
 
    // Test with predicate
    chunk_processing::PatternBasedStrategy<double> pred_strategy([](double) { return true; });
    auto pred_chunks = pred_strategy.apply(empty_data);
    EXPECT_TRUE(pred_chunks.empty());
}

References chunk_processing::PatternBasedStrategy< T >::apply().

TEST_F() [2/5]

TEST_F	(	AdvancedChunkStrategiesTest	,
		MultiDimensionalThresholds
	)

Definition at line 60 of file advanced_chunk_strategies_test.cpp.

                                                                {
    auto vector_distance = [](const std::vector<double>& a, const std::vector<double>& b) {
        double sum = 0.0;
        for (size_t i = 0; i < a.size(); ++i) {
            sum += (a[i] - b[i]) * (a[i] - b[i]);
        }
        return std::sqrt(sum);
    };
 
    auto predicate = [vector_distance](const std::vector<double>& vec) {
        return vector_distance(vec, {0.0, 0.0}) > 2.0;
    };
 
    chunk_processing::PatternBasedStrategy<std::vector<double>> strategy(predicate);
    auto chunks = strategy.apply(multi_dim_data);
 
    EXPECT_GT(chunks.size(), 0);
    for (const auto& chunk : chunks) {
        EXPECT_GT(chunk.size(), 0);
        for (const auto& vec : chunk) {
            EXPECT_EQ(vec.size(), 2);
        }
    }
}

References chunk_processing::PatternBasedStrategy< T >::apply().

TEST_F() [3/5]

TEST_F	(	AdvancedChunkStrategiesTest	,
		PatternBasedCyclicDetection
	)

Definition at line 24 of file advanced_chunk_strategies_test.cpp.

                                                                 {
    chunk_processing::PatternBasedStrategy<int> strategy(3); // Pattern size of 3
    auto chunks = strategy.apply(cyclic_data);
 
    EXPECT_GT(chunks.size(), 0);
    for (const auto& chunk : chunks) {
        EXPECT_EQ(chunk.size(), 3);
    }
}

References chunk_processing::PatternBasedStrategy< T >::apply().

TEST_F() [4/5]

TEST_F	(	AdvancedChunkStrategiesTest	,
		PatternBasedPredicate
	)

Definition at line 16 of file advanced_chunk_strategies_test.cpp.

                                                           {
    auto predicate = [](double val) { return val > 2.0; };
    chunk_processing::PatternBasedStrategy<double> strategy(predicate);
 
    auto chunks = strategy.apply(test_data);
    EXPECT_GT(chunks.size(), 0);
}

References chunk_processing::PatternBasedStrategy< T >::apply().

TEST_F() [5/5]

TEST_F	(	AdvancedChunkStrategiesTest	,
		SingleElementInput
	)

Definition at line 34 of file advanced_chunk_strategies_test.cpp.

                                                        {
    // Test with pattern size
    chunk_processing::PatternBasedStrategy<double> size_strategy(2);
    auto size_chunks = size_strategy.apply(single_element);
    EXPECT_EQ(size_chunks.size(), 1);
    EXPECT_EQ(size_chunks[0].size(), 1);
 
    // Test with predicate
    chunk_processing::PatternBasedStrategy<double> pred_strategy([](double) { return true; });
    auto pred_chunks = pred_strategy.apply(single_element);
    EXPECT_EQ(pred_chunks.size(), 1);
    EXPECT_EQ(pred_chunks[0].size(), 1);
}

References chunk_processing::PatternBasedStrategy< T >::apply().