Advanced Chunk Processing Library 0.2.0
A comprehensive C++ library for advanced data chunking strategies and processing operations
Loading...
Searching...
No Matches
Classes | Functions
chunk_compress_test.cpp File Reference
#include "chunk_compression.hpp"
#include <cstdint>
#include <gtest/gtest.h>
#include <limits>
#include <numeric>
#include <utility>
#include <vector>
+ Include dependency graph for chunk_compress_test.cpp:

Go to the source code of this file.

Classes

class  ChunkCompressorTest
 

Functions

template<typename T >
bool ComparePairs (const std::pair< T, size_t > &lhs, const std::pair< T, size_t > &rhs)
 
 TEST_F (ChunkCompressorTest, BasicDeltaEncode)
 
 TEST_F (ChunkCompressorTest, BasicRunLengthEncode)
 
 TEST_F (ChunkCompressorTest, DeltaDecodeEmpty)
 
 TEST_F (ChunkCompressorTest, DeltaDecodeSingle)
 
 TEST_F (ChunkCompressorTest, DeltaEncodeConstantSequence)
 
 TEST_F (ChunkCompressorTest, DeltaEncodeDecode)
 
 TEST_F (ChunkCompressorTest, DeltaEncodeEmpty)
 
 TEST_F (ChunkCompressorTest, DeltaEncodeSingle)
 
 TEST_F (ChunkCompressorTest, EmptyRunLength)
 
 TEST_F (ChunkCompressorTest, FloatingPointDelta)
 
 TEST_F (ChunkCompressorTest, FloatingPointRunLength)
 
 TEST_F (ChunkCompressorTest, LargeDeltas)
 
 TEST_F (ChunkCompressorTest, LargeSequenceCompression)
 
 TEST_F (ChunkCompressorTest, LongDeltaSequence)
 
 TEST_F (ChunkCompressorTest, NegativeDeltas)
 
 TEST_F (ChunkCompressorTest, SingleValueRunLength)
 
 TEST_F (ChunkCompressorTest, UniqueValuesRunLength)
 

Function Documentation

◆ ComparePairs()

template<typename T >
bool ComparePairs ( const std::pair< T, size_t > &  lhs,
const std::pair< T, size_t > &  rhs 
)

Definition at line 12 of file chunk_compress_test.cpp.

12 {
13 return lhs.first == rhs.first && lhs.second == rhs.second;
14}

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

◆ TEST_F() [1/17]

TEST_F ( ChunkCompressorTest  ,
BasicDeltaEncode   
)

Definition at line 61 of file chunk_compress_test.cpp.

61 {
62 std::vector<int> sequence = {10, 13, 15, 16, 20};
63 auto encoded = ChunkCompressor<int>::delta_encode(sequence);
64 EXPECT_EQ(encoded.size(), sequence.size());
65 EXPECT_EQ(encoded[0], 10); // First value unchanged
66 EXPECT_EQ(encoded[1], 3); // 13 - 10
67 EXPECT_EQ(encoded[2], 2); // 15 - 13
68 EXPECT_EQ(encoded[3], 1); // 16 - 15
69 EXPECT_EQ(encoded[4], 4); // 20 - 16
70}
chunk_compression::ChunkCompressor::delta_encode
static std::vector< T > delta_encode(const std::vector< T > &chunk)
Delta encode a chunk.
Definition chunk_compression.hpp:47

References chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [2/17]

TEST_F ( ChunkCompressorTest  ,
BasicRunLengthEncode   
)

Definition at line 26 of file chunk_compress_test.cpp.

26 {
27 auto encoded = ChunkCompressor<int>::run_length_encode(repeated_data);
28 EXPECT_EQ(encoded.size(), 3);
29 EXPECT_TRUE(ComparePairs(encoded[0], std::make_pair(1, size_t(3))));
30 EXPECT_TRUE(ComparePairs(encoded[1], std::make_pair(2, size_t(2))));
31 EXPECT_TRUE(ComparePairs(encoded[2], std::make_pair(3, size_t(4))));
32}
ComparePairs
bool ComparePairs(const std::pair< T, size_t > &lhs, const std::pair< T, size_t > &rhs)
Definition chunk_compress_test.cpp:12
chunk_compression::ChunkCompressor::run_length_encode
static std::vector< std::pair< T, size_t > > run_length_encode(const std::vector< T > &chunk)
Run-length encode a chunk.
Definition chunk_compression.hpp:20

References ComparePairs(), and chunk_compression::ChunkCompressor< T >::run_length_encode().

◆ TEST_F() [3/17]

TEST_F ( ChunkCompressorTest  ,
DeltaDecodeEmpty   
)

Definition at line 100 of file chunk_compress_test.cpp.

100 {
101 auto decoded = ChunkCompressor<int>::delta_decode(empty_data);
102 EXPECT_TRUE(decoded.empty());
103}
chunk_compression::ChunkCompressor::delta_decode
static std::vector< T > delta_decode(const std::vector< T > &chunk)
Delta decode a chunk.
Definition chunk_compression.hpp:67

References chunk_compression::ChunkCompressor< T >::delta_decode().

◆ TEST_F() [4/17]

TEST_F ( ChunkCompressorTest  ,
DeltaDecodeSingle   
)

Definition at line 105 of file chunk_compress_test.cpp.

105 {
106 auto decoded = ChunkCompressor<int>::delta_decode(single_value);
107 EXPECT_EQ(decoded, single_value);
108}

References chunk_compression::ChunkCompressor< T >::delta_decode().

◆ TEST_F() [5/17]

TEST_F ( ChunkCompressorTest  ,
DeltaEncodeConstantSequence   
)

Definition at line 72 of file chunk_compress_test.cpp.

72 {
73 std::vector<int> constant = {5, 5, 5, 5, 5};
74 auto encoded = ChunkCompressor<int>::delta_encode(constant);
75 EXPECT_EQ(encoded[0], 5);
76 for (size_t i = 1; i < encoded.size(); ++i) {
77 EXPECT_EQ(encoded[i], 0);
78 }
79}

References chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [6/17]

TEST_F ( ChunkCompressorTest  ,
DeltaEncodeDecode   
)

Definition at line 93 of file chunk_compress_test.cpp.

93 {
94 std::vector<int> original = {10, 13, 15, 16, 20};
95 auto encoded = ChunkCompressor<int>::delta_encode(original);
96 auto decoded = ChunkCompressor<int>::delta_decode(encoded);
97 EXPECT_EQ(decoded, original);
98}

References chunk_compression::ChunkCompressor< T >::delta_decode(), and chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [7/17]

TEST_F ( ChunkCompressorTest  ,
DeltaEncodeEmpty   
)

Definition at line 81 of file chunk_compress_test.cpp.

81 {
82 auto encoded = ChunkCompressor<int>::delta_encode(empty_data);
83 EXPECT_TRUE(encoded.empty());
84}

References chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [8/17]

TEST_F ( ChunkCompressorTest  ,
DeltaEncodeSingle   
)

Definition at line 86 of file chunk_compress_test.cpp.

86 {
87 auto encoded = ChunkCompressor<int>::delta_encode(single_value);
88 EXPECT_EQ(encoded.size(), 1);
89 EXPECT_EQ(encoded[0], single_value[0]);
90}

References chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [9/17]

TEST_F ( ChunkCompressorTest  ,
EmptyRunLength   
)

Definition at line 48 of file chunk_compress_test.cpp.

48 {
49 auto encoded = ChunkCompressor<int>::run_length_encode(empty_data);
50 EXPECT_TRUE(encoded.empty());
51}

References chunk_compression::ChunkCompressor< T >::run_length_encode().

◆ TEST_F() [10/17]

TEST_F ( ChunkCompressorTest  ,
FloatingPointDelta   
)

Definition at line 127 of file chunk_compress_test.cpp.

127 {
128 std::vector<double> float_sequence = {1.5, 2.5, 2.0, 3.5};
129 auto encoded = ChunkCompressor<double>::delta_encode(float_sequence);
130 auto decoded = ChunkCompressor<double>::delta_decode(encoded);
131
132 for (size_t i = 0; i < float_sequence.size(); ++i) {
133 EXPECT_DOUBLE_EQ(decoded[i], float_sequence[i]);
134 }
135}

References chunk_compression::ChunkCompressor< T >::delta_decode(), and chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [11/17]

TEST_F ( ChunkCompressorTest  ,
FloatingPointRunLength   
)

Definition at line 53 of file chunk_compress_test.cpp.

53 {
54 auto encoded = ChunkCompressor<double>::run_length_encode(floating_data);
55 EXPECT_EQ(encoded.size(), 2);
56 EXPECT_TRUE(ComparePairs(encoded[0], std::make_pair(1.5, size_t(2))));
57 EXPECT_TRUE(ComparePairs(encoded[1], std::make_pair(2.5, size_t(3))));
58}

References ComparePairs(), and chunk_compression::ChunkCompressor< T >::run_length_encode().

◆ TEST_F() [12/17]

TEST_F ( ChunkCompressorTest  ,
LargeDeltas   
)

Definition at line 111 of file chunk_compress_test.cpp.

111 {
112 std::vector<int> large_values = {std::numeric_limits<int>::max() - 2,
113 std::numeric_limits<int>::max() - 1,
114 std::numeric_limits<int>::max()};
115 auto encoded = ChunkCompressor<int>::delta_encode(large_values);
116 auto decoded = ChunkCompressor<int>::delta_decode(encoded);
117 EXPECT_EQ(decoded, large_values);
118}

References chunk_compression::ChunkCompressor< T >::delta_decode(), and chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [13/17]

TEST_F ( ChunkCompressorTest  ,
LargeSequenceCompression   
)

Definition at line 138 of file chunk_compress_test.cpp.

138 {
139 std::vector<int> large_sequence(10000, 42); // Long sequence of same value
140 auto encoded = ChunkCompressor<int>::run_length_encode(large_sequence);
141 EXPECT_EQ(encoded.size(), 1);
142 EXPECT_TRUE(ComparePairs(encoded[0], std::make_pair(42, size_t(10000))));
143}

References ComparePairs(), and chunk_compression::ChunkCompressor< T >::run_length_encode().

◆ TEST_F() [14/17]

TEST_F ( ChunkCompressorTest  ,
LongDeltaSequence   
)

Definition at line 145 of file chunk_compress_test.cpp.

145 {
146 std::vector<int> long_sequence(10000);
147 std::iota(long_sequence.begin(), long_sequence.end(), 0); // 0,1,2,3,...
148 auto encoded = ChunkCompressor<int>::delta_encode(long_sequence);
149 auto decoded = ChunkCompressor<int>::delta_decode(encoded);
150 EXPECT_EQ(decoded, long_sequence);
151}

References chunk_compression::ChunkCompressor< T >::delta_decode(), and chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [15/17]

TEST_F ( ChunkCompressorTest  ,
NegativeDeltas   
)

Definition at line 120 of file chunk_compress_test.cpp.

120 {
121 std::vector<int> alternating = {5, 3, 8, 1, 6};
122 auto encoded = ChunkCompressor<int>::delta_encode(alternating);
123 auto decoded = ChunkCompressor<int>::delta_decode(encoded);
124 EXPECT_EQ(decoded, alternating);
125}

References chunk_compression::ChunkCompressor< T >::delta_decode(), and chunk_compression::ChunkCompressor< T >::delta_encode().

◆ TEST_F() [16/17]

TEST_F ( ChunkCompressorTest  ,
SingleValueRunLength   
)

Definition at line 34 of file chunk_compress_test.cpp.

34 {
35 auto encoded = ChunkCompressor<int>::run_length_encode(single_value);
36 EXPECT_EQ(encoded.size(), 1);
37 EXPECT_TRUE(ComparePairs(encoded[0], std::make_pair(5, size_t(1))));
38}

References ComparePairs(), and chunk_compression::ChunkCompressor< T >::run_length_encode().

◆ TEST_F() [17/17]

TEST_F ( ChunkCompressorTest  ,
UniqueValuesRunLength   
)

Definition at line 40 of file chunk_compress_test.cpp.

40 {
41 auto encoded = ChunkCompressor<int>::run_length_encode(unique_data);
42 EXPECT_EQ(encoded.size(), unique_data.size());
43 for (size_t i = 0; i < encoded.size(); ++i) {
44 EXPECT_TRUE(ComparePairs(encoded[i], std::make_pair(unique_data[i], size_t(1))));
45 }
46}

References ComparePairs(), and chunk_compression::ChunkCompressor< T >::run_length_encode().