advanced_structures_test.cpp File Reference

#include "advanced_structures.hpp"
#include "gtest/gtest.h"
#include <algorithm>
#include <iostream>
#include <random>
#include <vector>

Include dependency graph for advanced_structures_test.cpp:

Go to the source code of this file.

Classes
class	ChunkBPlusTreeTest
	Test fixture for ChunkBPlusTree tests. More...
class	ChunkSkipListTest
	Test fixture for ChunkSkipList tests. More...

Functions
template<typename T >
void	printVector (const std::vector< T > &vec)
	Helper function to print a vector.
	TEST (BloomFilterChunkTest, BasicOperations)
	Tests basic operations of BloomFilterChunk.
	TEST (ChunkDequeTest, BasicOperations)
	Tests basic operations of ChunkDeque.
	TEST (ChunkStackTest, BasicOperations)
	Tests basic operations of ChunkStack.
	TEST (ChunkTreapTest, BasicOperations)
	Tests basic operations of ChunkTreap.
	TEST (FractalPatternsChunkTest, BasicOperations)
	Tests basic operations of FractalPatternsChunk.
	TEST (GraphBasedChunkTest, BasicOperations)
	Tests basic operations of GraphBasedChunk.
	TEST (SemanticBoundariesChunkTest, BasicOperations)
	Tests basic operations of SemanticBoundariesChunk.
	TEST_F (ChunkBPlusTreeTest, BasicOperations)
	Tests basic operations of ChunkBPlusTree.
	TEST_F (ChunkBPlusTreeTest, EdgeCases)
	Tests edge cases for ChunkBPlusTree.
	TEST_F (ChunkSkipListTest, BasicOperations)
	Tests basic operations of ChunkSkipList.
	TEST_F (ChunkSkipListTest, EmptyOperations)
	Tests empty operations of ChunkSkipList.
	TEST_F (ChunkSkipListTest, StressTest)
	Stress test for ChunkSkipList.

Function Documentation

printVector()

template<typename T >

void printVector

(

const std::vector< T > &

vec

)

Helper function to print a vector.

Template Parameters

T	The type of elements in the vector

Parameters

vec	The vector to print

Definition at line 16 of file advanced_structures_test.cpp.

                                          {
    std::cout << "[";
    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << vec[i];
        if (i < vec.size() - 1) {
            std::cout << ", ";
        }
    }
    std::cout << "]";
}

TEST() [1/7]

TEST	(	BloomFilterChunkTest	,
		BasicOperations
	)

Tests basic operations of BloomFilterChunk.

Definition at line 224 of file advanced_structures_test.cpp.

                                            {
    BloomFilterChunk<int> chunk;
    std::vector<int> data = {1, 2, 3, 4, 5};
    auto result = chunk.chunk(data);
    EXPECT_GT(result.size(), 0);
}

References advanced_structures::BloomFilterChunk< T >::chunk().

TEST() [2/7]

TEST	(	ChunkDequeTest	,
		BasicOperations
	)

Tests basic operations of ChunkDeque.

Definition at line 155 of file advanced_structures_test.cpp.

                                      {
    ChunkDeque<int> deque;
    EXPECT_TRUE(deque.empty());
 
    deque.push_back(1);
    deque.push_front(0);
    EXPECT_EQ(deque.size(), 2);
 
    EXPECT_EQ(deque.pop_back(), 1);
    EXPECT_EQ(deque.pop_front(), 0);
    EXPECT_TRUE(deque.empty());
}

References advanced_structures::ChunkDeque< T >::empty(), advanced_structures::ChunkDeque< T >::pop_back(), advanced_structures::ChunkDeque< T >::pop_front(), advanced_structures::ChunkDeque< T >::push_back(), advanced_structures::ChunkDeque< T >::push_front(), and advanced_structures::ChunkDeque< T >::size().

TEST() [3/7]

TEST	(	ChunkStackTest	,
		BasicOperations
	)

Tests basic operations of ChunkStack.

Definition at line 171 of file advanced_structures_test.cpp.

                                      {
    ChunkStack<int> stack;
    EXPECT_TRUE(stack.empty());
 
    stack.push(1);
    stack.push(2);
    EXPECT_EQ(stack.size(), 2);
 
    EXPECT_EQ(stack.pop(), 2);
    EXPECT_EQ(stack.pop(), 1);
    EXPECT_TRUE(stack.empty());
}

References advanced_structures::ChunkStack< T >::empty(), advanced_structures::ChunkStack< T >::pop(), advanced_structures::ChunkStack< T >::push(), and advanced_structures::ChunkStack< T >::size().

TEST() [4/7]

TEST	(	ChunkTreapTest	,
		BasicOperations
	)

Tests basic operations of ChunkTreap.

Definition at line 187 of file advanced_structures_test.cpp.

                                      {
    ChunkTreap<int> treap;
    EXPECT_FALSE(treap.search(5));
 
    treap.insert(5);
    treap.insert(3);
    treap.insert(8);
 
    EXPECT_TRUE(treap.search(5));
    EXPECT_TRUE(treap.search(3));
    EXPECT_TRUE(treap.search(8));
    EXPECT_FALSE(treap.search(10));
}

References advanced_structures::ChunkTreap< T >::insert(), and advanced_structures::ChunkTreap< T >::search().

TEST() [5/7]

TEST	(	FractalPatternsChunkTest	,
		BasicOperations
	)

Tests basic operations of FractalPatternsChunk.

Definition at line 214 of file advanced_structures_test.cpp.

                                                {
    FractalPatternsChunk<int> chunk;
    std::vector<int> data = {1, 2, 3, 4, 5, 1, 2, 3};
    auto result = chunk.chunk(data);
    EXPECT_GT(result.size(), 0);
}

References advanced_structures::FractalPatternsChunk< T >::chunk().

TEST() [6/7]

TEST	(	GraphBasedChunkTest	,
		BasicOperations
	)

Tests basic operations of GraphBasedChunk.

Definition at line 234 of file advanced_structures_test.cpp.

                                           {
    GraphBasedChunk<int> chunk;
    std::vector<int> data = {1, 2, 3, 4, 5};
    auto result = chunk.chunk(data);
    EXPECT_GT(result.size(), 0);
}

References advanced_structures::GraphBasedChunk< T >::chunk().

TEST() [7/7]

TEST	(	SemanticBoundariesChunkTest	,
		BasicOperations
	)

Tests basic operations of SemanticBoundariesChunk.

Definition at line 204 of file advanced_structures_test.cpp.

                                                   {
    SemanticBoundariesChunk<std::string> chunk;
    std::vector<std::string> data = {"This", "is", "a", "test", "sentence"};
    auto result = chunk.chunk(data);
    EXPECT_GT(result.size(), 0);
}

References advanced_structures::SemanticBoundariesChunk< T >::chunk().

TEST_F() [1/5]

TEST_F	(	ChunkBPlusTreeTest	,
		BasicOperations
	)

Tests basic operations of ChunkBPlusTree.

Definition at line 87 of file advanced_structures_test.cpp.

                                            {
    ChunkBPlusTree<int> tree;
 
    // Test insertion
    std::vector<int> values = {3, 7, 1, 5, 9, 2, 8, 4, 6};
    for (int val : values) {
        tree.insert(val);
    }
 
    // Test if values exist in tree
    for (int val : values) {
        EXPECT_TRUE(tree.search(val));
    }
 
    // Test non-existent values
    EXPECT_FALSE(tree.search(0));
    EXPECT_FALSE(tree.search(10));
}

References advanced_structures::ChunkBPlusTree< T >::insert(), and advanced_structures::ChunkBPlusTree< T >::search().

TEST_F() [2/5]

TEST_F	(	ChunkBPlusTreeTest	,
		EdgeCases
	)

Tests edge cases for ChunkBPlusTree.

Definition at line 141 of file advanced_structures_test.cpp.

                                      {
    ChunkBPlusTree<int> tree;
    tree.insert(1);
    tree.insert(2);
 
    // Verify insertions using find
    EXPECT_TRUE(tree.search(1));
    EXPECT_TRUE(tree.search(2));
    EXPECT_FALSE(tree.search(3));
}

References advanced_structures::ChunkBPlusTree< T >::insert(), and advanced_structures::ChunkBPlusTree< T >::search().

TEST_F() [3/5]

TEST_F	(	ChunkSkipListTest	,
		BasicOperations
	)

Tests basic operations of ChunkSkipList.

Definition at line 52 of file advanced_structures_test.cpp.

                                           {
    ChunkSkipList<int> skip_list;
 
    // Test insertion
    skip_list.insert(5);
    skip_list.insert(10);
    skip_list.insert(7);
 
    // Test search
    EXPECT_TRUE(skip_list.search(5));
    EXPECT_TRUE(skip_list.search(7));
    EXPECT_TRUE(skip_list.search(10));
    EXPECT_FALSE(skip_list.search(6));
 
    // Test with random data
    std::vector<int> numbers(100);
    std::iota(numbers.begin(), numbers.end(), 1);
    std::random_device rd;
    std::mt19937 gen(rd());
    std::shuffle(numbers.begin(), numbers.end(), gen);
 
    ChunkSkipList<int> large_list;
    for (int num : numbers) {
        large_list.insert(num);
    }
 
    // Verify all numbers can be found
    for (int num : numbers) {
        EXPECT_TRUE(large_list.search(num));
    }
}

References advanced_structures::ChunkSkipList< T >::insert(), and advanced_structures::ChunkSkipList< T >::search().

TEST_F() [4/5]

TEST_F	(	ChunkSkipListTest	,
		EmptyOperations
	)

Tests empty operations of ChunkSkipList.

Definition at line 132 of file advanced_structures_test.cpp.

                                           {
    ChunkSkipList<int> list;
    EXPECT_TRUE(list.search(1) == false);
    EXPECT_TRUE(list.search(0) == false);
}

References advanced_structures::ChunkSkipList< T >::search().

TEST_F() [5/5]

TEST_F	(	ChunkSkipListTest	,
		StressTest
	)

Stress test for ChunkSkipList.

Definition at line 109 of file advanced_structures_test.cpp.

                                      {
    ChunkSkipList<int> skip_list;
    const int NUM_ELEMENTS = 10000;
 
    // Insert many elements
    for (int i = 0; i < NUM_ELEMENTS; i++) {
        skip_list.insert(i);
    }
 
    // Verify all elements can be found
    for (int i = 0; i < NUM_ELEMENTS; i++) {
        EXPECT_TRUE(skip_list.search(i));
    }
 
    // Verify non-existent elements are not found
    for (int i = NUM_ELEMENTS; i < NUM_ELEMENTS + 100; i++) {
        EXPECT_FALSE(skip_list.search(i));
    }
}

References advanced_structures::ChunkSkipList< T >::insert(), and advanced_structures::ChunkSkipList< T >::search().