]> git.stg.codes - stg.git/blob - tests/test_bfstream.cpp
Finalize transition to Boost.UnitTest.
[stg.git] / tests / test_bfstream.cpp
1 #define BOOST_TEST_MODULE STGBFStream
2
3 #include "longstring.h"
4
5 #include "stg/bfstream.h"
6
7 #pragma GCC diagnostic push
8 #pragma GCC diagnostic ignored "-Wold-style-cast"
9 #pragma GCC diagnostic ignored "-Wunused-parameter"
10 #pragma GCC diagnostic ignored "-Wsign-compare"
11 #pragma GCC diagnostic ignored "-Wparentheses"
12 #include <boost/test/unit_test.hpp>
13 #pragma GCC diagnostic pop
14
15 #include <algorithm>
16 #include <string>
17 #include <cstring>
18 #include <cstdint>
19
20 namespace
21 {
22
23 class Tracker
24 {
25     public:
26         Tracker() : m_lastSize(0), m_callCount(0), m_lastBlock(NULL) {}
27         ~Tracker() { delete[] m_lastBlock; }
28         void Call(const void* block, size_t size)
29         {
30             delete[] m_lastBlock;
31             if (size > 0)
32             {
33                 m_lastBlock = new char[size];
34                 memcpy(m_lastBlock,  block, size);
35                 m_result.append(m_lastBlock, size);
36             }
37             else
38                 m_lastBlock = NULL;
39             m_lastSize = size;
40             ++m_callCount;
41         }
42         size_t LastSize() const { return m_lastSize; }
43         size_t CallCount() const { return m_callCount; }
44         const void* LastBlock() const { return m_lastBlock; }
45
46         const std::string& Result() const { return m_result; }
47
48     private:
49         size_t m_lastSize;
50         size_t m_callCount;
51         char* m_lastBlock;
52
53         std::string m_result;
54 };
55
56 bool DecryptCallback(const void* block, size_t size, void* data);
57
58 class Decryptor
59 {
60     public:
61         Decryptor(const std::string& key)
62             : m_stream(key, DecryptCallback, this)
63         {}
64
65         void Call(const void* block, size_t size)
66         {
67             m_stream.Put(block, size);
68         }
69
70         void Put(const void* block, size_t size)
71         {
72             const auto* data = static_cast<const char*>(block);
73             size = strnlen(data, size);
74             m_result.append(data, size);
75         }
76
77         void Flush()
78         {
79             m_stream.Put(NULL, 0);
80         }
81
82         const std::string & Result() const { return m_result; }
83
84     private:
85         STG::DECRYPT_STREAM m_stream;
86         std::string m_result;
87 };
88
89 bool EncryptCallback(const void* block, size_t size, void* data)
90 {
91     auto& decryptor = *static_cast<Decryptor*>(data);
92     decryptor.Call(block, size);
93     return true;
94 }
95
96 bool DecryptCallback(const void* block, size_t size, void* data)
97 {
98     auto& decryptor = *static_cast<Decryptor*>(data);
99     decryptor.Put(block, size);
100     return true;
101 }
102
103 bool Callback(const void* block, size_t size, void* data)
104 {
105     auto& tracker = *static_cast<Tracker*>(data);
106     tracker.Call(block, size);
107     return true;
108 }
109
110 }
111
112 BOOST_AUTO_TEST_SUITE(BFStream)
113
114 BOOST_AUTO_TEST_CASE(Mechanics)
115 {
116     Tracker tracker;
117     STG::ENCRYPT_STREAM stream("pr7Hhen", Callback, &tracker);
118     BOOST_CHECK_EQUAL(tracker.CallCount(), 0);
119
120     uint32_t block[2] = {0x12345678, 0x87654321};
121     stream.Put(&block[0], sizeof(block[0]));
122     BOOST_CHECK_EQUAL(tracker.CallCount(), 0);
123     stream.Put(&block[1], sizeof(block[1]));
124     BOOST_CHECK_EQUAL(tracker.CallCount(), 1);
125
126     uint32_t block2[4] = {0x12345678, 0x87654321, 0x12345678, 0x87654321};
127     stream.Put(&block2[0], sizeof(block2[0]) * 3);
128     BOOST_CHECK_EQUAL(tracker.CallCount(), 2);
129     stream.Put(&block2[3], sizeof(block2[3]));
130     BOOST_CHECK_EQUAL(tracker.CallCount(), 3);
131 }
132
133 BOOST_AUTO_TEST_CASE(Encryption)
134 {
135     Tracker tracker;
136     STG::ENCRYPT_STREAM stream("pr7Hhen", Callback, &tracker);
137
138     uint32_t block[2] = {0x12345678, 0x87654321};
139     stream.Put(&block[0], sizeof(block[0]));
140     BOOST_CHECK_EQUAL(tracker.LastSize(), 0);
141     BOOST_CHECK_EQUAL(tracker.LastBlock(), static_cast<const void *>(NULL));
142     stream.Put(&block[1], sizeof(block[1]));
143     BOOST_CHECK_EQUAL(tracker.LastSize(), 8);
144     const uint32_t * ptr = static_cast<const uint32_t *>(tracker.LastBlock());
145     BOOST_CHECK_EQUAL(ptr[0], 0xd3988cd);
146     BOOST_CHECK_EQUAL(ptr[1], 0x7996c6d6);
147
148     uint32_t block2[4] = {0x12345678, 0x87654321, 0x12345678, 0x87654321};
149     stream.Put(&block2[0], sizeof(block2[0]) * 3);
150     BOOST_CHECK_EQUAL(tracker.LastSize(), 8);
151     ptr = static_cast<const uint32_t *>(tracker.LastBlock());
152     BOOST_CHECK_EQUAL(ptr[0], 0xd3988cd);
153     BOOST_CHECK_EQUAL(ptr[1], 0x7996c6d6);
154
155     stream.Put(&block2[3], sizeof(block2[3]));
156     BOOST_CHECK_EQUAL(tracker.LastSize(), 8);
157     ptr = static_cast<const uint32_t *>(tracker.LastBlock());
158     BOOST_CHECK_EQUAL(ptr[0], 0xd3988cd);
159     BOOST_CHECK_EQUAL(ptr[1], 0x7996c6d6);
160 }
161
162 BOOST_AUTO_TEST_CASE(LongStringProcessing)
163 {
164     Tracker tracker;
165     STG::ENCRYPT_STREAM estream("pr7Hhen", Callback, &tracker);
166     const std::string source = "This is a test long string for checking stream encryption/decryption. \"abcdefghijklmnopqrstuvwxyz 0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\"";
167     std::vector<char> buffer(source.length() + 9, 0);
168
169     estream.Put(source.c_str(), source.length() + 1, true);
170     BOOST_CHECK(tracker.LastSize() >= source.length() + 1);
171     BOOST_CHECK(tracker.LastBlock() != NULL);
172     memcpy(buffer.data(), tracker.LastBlock(), std::min(tracker.LastSize(), buffer.size()));
173
174     STG::DECRYPT_STREAM dstream("pr7Hhen", Callback, &tracker);
175     dstream.Put(buffer.data(), buffer.size(), true);
176     BOOST_CHECK(tracker.LastSize() >= buffer.size());
177     BOOST_CHECK(tracker.LastBlock() != NULL);
178     memcpy(buffer.data(), tracker.LastBlock(), std::min(tracker.LastSize(), buffer.size()));
179
180     BOOST_CHECK_EQUAL(std::string(buffer.data()), source);
181 }
182
183 BOOST_AUTO_TEST_CASE(VeryLongStringProcessing)
184 {
185     Decryptor decryptor("pr7Hhen");
186     STG::ENCRYPT_STREAM estream("pr7Hhen", EncryptCallback, &decryptor);
187
188     estream.Put(longString.c_str(), longString.length() + 1, true);
189
190     BOOST_CHECK_EQUAL(decryptor.Result(), longString);
191 }
192
193 BOOST_AUTO_TEST_CASE(Mechanics2)
194 {
195     Tracker tracker;
196     STG::ENCRYPT_STREAM stream("pr7Hhen", Callback, &tracker);
197     BOOST_CHECK_EQUAL(tracker.CallCount(), 0);
198
199     uint32_t block[2] = {0x12345678, 0x87654321};
200     stream.Put(&block[0], sizeof(block[0]));
201     BOOST_CHECK_EQUAL(tracker.CallCount(), 0);
202     stream.Put(&block[1], sizeof(block[1]));
203     BOOST_CHECK_EQUAL(tracker.CallCount(), 1);
204     stream.Put(&block[0], 0, true); // Check last callback
205     BOOST_CHECK_EQUAL(tracker.CallCount(), 2);
206 }
207
208 BOOST_AUTO_TEST_SUITE_END()