huffman/huffman_testing.cpp at master · rhazarian/huffman · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include <sstream>
#include <random>
#include <gtest/gtest.h>

#include "lib/huffman.h"

namespace {
std::string compress_decompress(std::string const& str) {
    std::istringstream in(str);
    std::ostringstream compressed_out;
    compress(in, compressed_out);
    std::istringstream compressed_in(compressed_out.str());
    std::ostringstream decompressed_out;
    decompress(compressed_in, decompressed_out);
    return decompressed_out.str();
}
}

TEST(correctness, blank) // NOLINT
{
    std::string str;
    EXPECT_EQ(str, compress_decompress(str));
}

namespace {

std::mt19937 gen(0); // NOLINT
std::uniform_int_distribution<> char_dist(std::numeric_limits<char>::min(), std::numeric_limits<char>::max()); // NOLINT

char random_char()
{
    return static_cast<char>(char_dist(gen));
}

std::string random_string(size_t n)
{
    std::string str;
    str.reserve(n);
    for (size_t i = 0; i < n; ++i) {
        str.push_back(random_char());
    }
    return str;
}

std::uniform_int_distribution<> short_str_dist(0, 500); // NOLINT

size_t random_short_str_length()
{
    return static_cast<size_t>(short_str_dist(gen));
}

}

TEST(correctness, random_short_strings) // NOLINT
{
    constexpr size_t LOOP_COUNT = 100;
    for (size_t i = 0; i < LOOP_COUNT; ++i) {
        std::string str = random_string(random_short_str_length());
        EXPECT_EQ(str, compress_decompress(str));
    }
}

namespace {

std::uniform_int_distribution<> long_str_dist(10000, 100000); // NOLINT

size_t random_long_str_length()
{
    return static_cast<size_t>(long_str_dist(gen));
}

}

TEST(correctness, random_long_strings) // NOLINT
{
    constexpr size_t LOOP_COUNT = 50;
    for (size_t i = 0; i < LOOP_COUNT; ++i) {
        std::string str = random_string(random_long_str_length());
        EXPECT_EQ(str, compress_decompress(str));
    }
}

namespace {

std::uniform_int_distribution<> long_long_str_dist(100000, 1000000); // NOLINT

size_t random_long_long_str_length()
{
    return static_cast<size_t>(long_long_str_dist(gen));
}

}

TEST(correctness, random_long_long_strings) // NOLINT
{
    constexpr size_t LOOP_COUNT = 25;
    for (size_t i = 0; i < LOOP_COUNT; ++i) {
        std::string str = random_string(random_long_long_str_length());
        EXPECT_EQ(str, compress_decompress(str));
    }
}