]> git.stg.codes - stg.git/blob - tests/test_bfstream.cpp
Merge pull request #1 from yuriio147/mysql-store-db-port
[stg.git] / tests / test_bfstream.cpp
1 #include "tut/tut.hpp"
2
3 #include "longstring.h"
4
5 #include "stg/bfstream.h"
6
7 #include <algorithm>
8 #include <string>
9 #include <cstring>
10 #include <cstdint>
11
12 namespace
13 {
14
15 class TRACKER
16 {
17     public:
18         TRACKER() : m_lastSize(0), m_callCount(0), m_lastBlock(NULL) {}
19         ~TRACKER() { delete[] m_lastBlock; }
20         bool Call(const void * block, size_t size)
21         {
22         delete[] m_lastBlock;
23         if (size > 0)
24             {
25             m_lastBlock = new char[size];
26             memcpy(m_lastBlock,  block, size);
27             m_result.append(m_lastBlock, size);
28             }
29         else
30             m_lastBlock = NULL;
31         m_lastSize = size;
32         ++m_callCount;
33         return true;
34         }
35         size_t LastSize() const { return m_lastSize; }
36         size_t CallCount() const { return m_callCount; }
37         const void * LastBlock() const { return m_lastBlock; }
38
39         const std::string& Result() const { return m_result; }
40
41     private:
42         size_t m_lastSize;
43         size_t m_callCount;
44         char * m_lastBlock;
45
46         std::string m_result;
47 };
48
49 bool DecryptCallback(const void * block, size_t size, void * data);
50
51 class Decryptor
52 {
53     public:
54         Decryptor(const std::string & key)
55             : m_stream(key, DecryptCallback, this)
56         {}
57
58         bool Call(const void * block, size_t size)
59         {
60             m_stream.Put(block, size);
61             return true;
62         }
63
64         bool Put(const void * block, size_t size)
65         {
66             const char * data = static_cast<const char *>(block);
67             size = strnlen(data, size);
68             m_result.append(data, size);
69             return true;
70         }
71
72         void Flush()
73         {
74             m_stream.Put(NULL, 0);
75         }
76
77         const std::string & Result() const { return m_result; }
78
79     private:
80         STG::DECRYPT_STREAM m_stream;
81         std::string m_result;
82 };
83
84 bool EncryptCallback(const void * block, size_t size, void * data)
85 {
86 Decryptor & decryptor = *static_cast<Decryptor *>(data);
87 return decryptor.Call(block, size);
88 }
89
90 bool DecryptCallback(const void * block, size_t size, void * data)
91 {
92 Decryptor & decryptor = *static_cast<Decryptor *>(data);
93 return decryptor.Put(block, size);
94 }
95
96 bool Callback(const void * block, size_t size, void * data)
97 {
98 TRACKER & tracker = *static_cast<TRACKER *>(data);
99 return tracker.Call(block, size);
100 }
101
102 }
103
104 namespace tut
105 {
106     struct bfstream_data {
107     };
108
109     typedef test_group<bfstream_data> tg;
110     tg bfstream_test_group("BFStream tests group");
111
112     typedef tg::object testobject;
113
114     template<>
115     template<>
116     void testobject::test<1>()
117     {
118         set_test_name("Check bfstream mechanics");
119
120         TRACKER tracker;
121         STG::ENCRYPT_STREAM stream("pr7Hhen", Callback, &tracker);
122         ensure_equals("CallCount() == 0 after construction", tracker.CallCount(), 0);
123
124         uint32_t block[2] = {0x12345678, 0x87654321};
125         stream.Put(&block[0], sizeof(block[0]));
126         ensure_equals("CallCount() == 0 after first put", tracker.CallCount(), 0);
127         stream.Put(&block[1], sizeof(block[1]));
128         ensure_equals("CallCount() == 1 after second put", tracker.CallCount(), 1);
129
130         uint32_t block2[4] = {0x12345678, 0x87654321, 0x12345678, 0x87654321};
131         stream.Put(&block2[0], sizeof(block2[0]) * 3);
132         ensure_equals("CallCount() == 2 after third put", tracker.CallCount(), 2);
133         stream.Put(&block2[3], sizeof(block2[3]));
134         ensure_equals("CallCount() == 3 after fourth put", tracker.CallCount(), 3);
135     }
136
137     template<>
138     template<>
139     void testobject::test<2>()
140     {
141         set_test_name("Check bfstream encryption");
142
143         TRACKER tracker;
144         STG::ENCRYPT_STREAM stream("pr7Hhen", Callback, &tracker);
145
146         uint32_t block[2] = {0x12345678, 0x87654321};
147         stream.Put(&block[0], sizeof(block[0]));
148         ensure_equals("LastSize() == 0 after first put", tracker.LastSize(), 0);
149         ensure_equals("LastBlock() == NULL after first put", tracker.LastBlock(), static_cast<const void *>(NULL));
150         stream.Put(&block[1], sizeof(block[1]));
151         ensure_equals("LastSize() == 8 after second put", tracker.LastSize(), 8);
152         const uint32_t * ptr = static_cast<const uint32_t *>(tracker.LastBlock());
153         ensure_equals("ptr[0] == 0xd3988cd after second put", ptr[0], 0xd3988cd);
154         ensure_equals("ptr[1] == 0x7996c6d6 after second put", ptr[1], 0x7996c6d6);
155
156         uint32_t block2[4] = {0x12345678, 0x87654321, 0x12345678, 0x87654321};
157         stream.Put(&block2[0], sizeof(block2[0]) * 3);
158         ensure_equals("LastSize() == 8 after third put", tracker.LastSize(), 8);
159         ptr = static_cast<const uint32_t *>(tracker.LastBlock());
160         ensure_equals("ptr[0] == 0xd3988cd after third put", ptr[0], 0xd3988cd);
161         ensure_equals("ptr[1] == 0x7996c6d6 after third put", ptr[1], 0x7996c6d6);
162
163         stream.Put(&block2[3], sizeof(block2[3]));
164         ensure_equals("LastSize() == 8 after fourth put", tracker.LastSize(), 8);
165         ptr = static_cast<const uint32_t *>(tracker.LastBlock());
166         ensure_equals("ptr[0] == 0xd3988cd after fourth put", ptr[0], 0xd3988cd);
167         ensure_equals("ptr[1] == 0x7996c6d6 after fourth put", ptr[1], 0x7996c6d6);
168     }
169
170     template<>
171     template<>
172     void testobject::test<3>()
173     {
174         set_test_name("Check bfstream long string processing");
175
176         TRACKER tracker;
177         STG::ENCRYPT_STREAM estream("pr7Hhen", Callback, &tracker);
178         std::string source = "This is a test long string for checking stream encryption/decryption. \"abcdefghijklmnopqrstuvwxyz 0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\"";
179         char buffer[source.length() + 9];
180         memset(buffer, 0, sizeof(buffer));
181
182         estream.Put(source.c_str(), source.length() + 1, true);
183         ensure("Encryption long string LastSize()", tracker.LastSize() >= source.length() + 1);
184         ensure("Encryption long string LastBlock() != NULL", tracker.LastBlock() != NULL);
185         memcpy(buffer, tracker.LastBlock(), std::min(tracker.LastSize(), sizeof(buffer)));
186
187         STG::DECRYPT_STREAM dstream("pr7Hhen", Callback, &tracker);
188         dstream.Put(buffer, sizeof(buffer), true);
189         ensure("Decryption long string LastSize() decryption", tracker.LastSize() >= sizeof(buffer));
190         ensure("Decryption long string LastBlock() != NULL", tracker.LastBlock() != NULL);
191         memcpy(buffer, tracker.LastBlock(), std::min(tracker.LastSize(), sizeof(buffer)));
192
193         ensure_equals("Decrypt(Encrypt(source)) == source", std::string(buffer), source);
194     }
195
196     template<>
197     template<>
198     void testobject::test<4>()
199     {
200         set_test_name("Check bfstream very long string processing");
201
202         Decryptor decryptor("pr7Hhen");
203         STG::ENCRYPT_STREAM estream("pr7Hhen", EncryptCallback, &decryptor);
204         //char buffer[source.length() + 9];
205         //memset(buffer, 0, sizeof(buffer));
206
207         estream.Put(longString.c_str(), longString.length() + 1, true);
208         //ensure("Encryption long string LastSize()", tracker.LastSize() >= source.length() + 1);
209         //ensure("Encryption long string LastBlock() != NULL", tracker.LastBlock() != NULL);
210         //memcpy(buffer, tracker.LastBlock(), std::min(tracker.LastSize(), sizeof(buffer)));
211
212         //dstream.Put(buffer, sizeof(buffer), true);
213         //ensure("Decryption long string LastSize() decryption", tracker.LastSize() >= sizeof(buffer));
214         //ensure("Decryption long string LastBlock() != NULL", tracker.LastBlock() != NULL);
215         //memcpy(buffer, tracker.LastBlock(), std::min(tracker.LastSize(), sizeof(buffer)));
216
217         ensure_equals("Decrypt(Encrypt(source)) == source", decryptor.Result(), longString);
218     }
219
220     template<>
221     template<>
222     void testobject::test<5>()
223     {
224         set_test_name("Check bfstream mechanics");
225
226         TRACKER tracker;
227         STG::ENCRYPT_STREAM stream("pr7Hhen", Callback, &tracker);
228         ensure_equals("CallCount() == 0 after construction", tracker.CallCount(), 0);
229
230         uint32_t block[2] = {0x12345678, 0x87654321};
231         stream.Put(&block[0], sizeof(block[0]));
232         ensure_equals("CallCount() == 0 after first put", tracker.CallCount(), 0);
233         stream.Put(&block[1], sizeof(block[1]));
234         ensure_equals("CallCount() == 1 after second put", tracker.CallCount(), 1);
235         stream.Put(&block[0], 0, true); // Check last callback
236         ensure_equals("CallCount() == 2 after third (null) put", tracker.CallCount(), 2);
237     }
238
239 }