Skip to content

Commit 95137e2

Browse files
prantlfprantlf
committed
Add tests for the BASE64 encoding
1 parent 153d203 commit 95137e2

File tree

3 files changed

+207
-0
lines changed

3 files changed

+207
-0
lines changed

‎libs/network/test/CMakeLists.txt

+1
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@ if (Boost_FOUND)
1414
message_test
1515
message_transform_test
1616
utils_thread_pool
17+
utils_base64_test
1718
)
1819
foreach (test ${TESTS})
1920
if (${CMAKE_CXX_COMPILER_ID} MATCHES GNU)

‎libs/network/test/Jamfile.v2

+1
Original file line numberDiff line numberDiff line change
@@ -53,3 +53,4 @@ build-project uri ;
5353

5454
run message_test.cpp ;
5555
run message_transform_test.cpp ;
56+
run utils_base64_test.cpp ;

‎libs/network/test/utils_base64_test.cpp

+205
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,205 @@
1+
#define BOOST_TEST_MODULE BASE64 Test
2+
#include <boost/config/warning_disable.hpp>
3+
#include <boost/test/unit_test.hpp>
4+
#include <boost/network/utils/base64/encode.hpp>
5+
#include <boost/network/utils/base64/encode-io.hpp>
6+
#include <boost/array.hpp>
7+
#include <algorithm>
8+
#include <iterator>
9+
#include <string>
10+
#include <vector>
11+
#include <sstream>
12+
13+
using namespace boost::network::utils;
14+
15+
// proves that all public functions are compilable; the result check
16+
// is very minimum here, so that the test doesn't look so stupid ;-)
17+
BOOST_AUTO_TEST_CASE(interface_test) {
18+
std::string result;
19+
base64::state<char> state;
20+
21+
// check string literal
22+
BOOST_CHECK_EQUAL(base64::encode<char>("abc"), "YWJj");
23+
24+
base64::encode("abc", std::back_inserter(result));
25+
BOOST_CHECK_EQUAL(result, "YWJj");
26+
27+
result.clear();
28+
base64::encode("abc", std::back_inserter(result), state);
29+
BOOST_CHECK_EQUAL(result, "YWJj");
30+
31+
// check std::string
32+
std::string input("abc");
33+
34+
BOOST_CHECK_EQUAL(base64::encode<char>(input), "YWJj");
35+
36+
result.clear();
37+
base64::encode(input, std::back_inserter(result));
38+
BOOST_CHECK_EQUAL(result, "YWJj");
39+
40+
result.clear();
41+
base64::encode(input.begin(), input.end(), std::back_inserter(result));
42+
BOOST_CHECK_EQUAL(result, "YWJj");
43+
44+
result.clear();
45+
base64::encode(input, std::back_inserter(result), state);
46+
BOOST_CHECK_EQUAL(result, "YWJj");
47+
48+
result.clear();
49+
base64::encode(input.begin(), input.end(), std::back_inserter(result), state);
50+
BOOST_CHECK_EQUAL(result, "YWJj");
51+
52+
// check array of chars
53+
char char_array[] = { 'a', 'b', 'c' };
54+
55+
BOOST_CHECK_EQUAL(base64::encode<char>(char_array), "YWJj");
56+
57+
// check boost::array of chars
58+
boost::array<char, 3> char_boost_array = { { 'a', 'b', 'c' } };
59+
60+
BOOST_CHECK_EQUAL(base64::encode<char>(char_boost_array), "YWJj");
61+
62+
// check std::vector of chars
63+
std::vector<char> char_vector(char_array, char_array + 3);
64+
65+
BOOST_CHECK_EQUAL(base64::encode<char>(char_vector), "YWJj");
66+
67+
// check array of ints
68+
int int_array[] = { 'a', 'b', 'c' };
69+
70+
BOOST_CHECK_EQUAL(base64::encode<char>(int_array), "YWJj");
71+
72+
// check boost::array of ints
73+
boost::array<int, 3> int_boost_array = { { 'a', 'b', 'c' } };
74+
75+
BOOST_CHECK_EQUAL(base64::encode<char>(int_boost_array), "YWJj");
76+
77+
// check std::vector of ints
78+
std::vector<int> int_vector(int_array, int_array + 3);
79+
80+
BOOST_CHECK_EQUAL(base64::encode<char>(int_vector), "YWJj");
81+
82+
// check that base64::encode_rest is compilable and callable
83+
result.clear();
84+
base64::encode_rest(std::back_inserter(result), state);
85+
BOOST_CHECK_EQUAL(result, "");
86+
87+
// check that the iostream interface is compilable and callable
88+
std::ostringstream output;
89+
output << base64::io::encode("abc") <<
90+
base64::io::encode(input.begin(), input.end()) <<
91+
base64::io::encode(int_array) <<
92+
base64::io::encode(int_boost_array) <<
93+
base64::io::encode(char_array) <<
94+
base64::io::encode(char_boost_array) <<
95+
base64::io::encode(char_vector) <<
96+
base64::io::encode_rest<char>;
97+
BOOST_CHECK_EQUAL(output.str(), "YWJjYWJjYWJjYWJjYWJjYWJjYWJj");
98+
}
99+
100+
// checks that functions encoding a single chunk append the correct padding
101+
// if the input byte count is not divisible by 3
102+
BOOST_AUTO_TEST_CASE(padding_test) {
103+
BOOST_CHECK_EQUAL(base64::encode<char>(""), "");
104+
BOOST_CHECK_EQUAL(base64::encode<char>("a"), "YQ==");
105+
BOOST_CHECK_EQUAL(base64::encode<char>("aa"), "YWE=");
106+
BOOST_CHECK_EQUAL(base64::encode<char>("aaa"), "YWFh");
107+
}
108+
109+
// check that functions using encoding state interrupt and resume encoding
110+
// correcly if the byte count of the partial input is not divisible by 3
111+
BOOST_AUTO_TEST_CASE(state_test) {
112+
base64::state<char> state;
113+
std::string result;
114+
115+
// check encoding empty input; including the state value
116+
base64::encode("", std::back_inserter(result), state);
117+
BOOST_CHECK_EQUAL(result, "");
118+
BOOST_CHECK(state.empty());
119+
result.clear();
120+
state.clear();
121+
122+
// check one third of quantum which needs two character padding;
123+
// including how the state develops when encoded by single character
124+
base64::encode("a", std::back_inserter(result), state);
125+
BOOST_CHECK_EQUAL(result, "Y");
126+
BOOST_CHECK(!state.empty());
127+
base64::encode_rest(std::back_inserter(result), state);
128+
BOOST_CHECK_EQUAL(result, "YQ==");
129+
BOOST_CHECK(state.empty());
130+
result.clear();
131+
state.clear();
132+
133+
// check two thirds of quantum which needs one character padding;
134+
// including how the state develops when encoded by single character
135+
base64::encode("a", std::back_inserter(result), state);
136+
BOOST_CHECK_EQUAL(result, "Y");
137+
BOOST_CHECK(!state.empty());
138+
base64::encode("a", std::back_inserter(result), state);
139+
BOOST_CHECK_EQUAL(result, "YW");
140+
BOOST_CHECK(!state.empty());
141+
base64::encode_rest(std::back_inserter(result), state);
142+
BOOST_CHECK_EQUAL(result, "YWE=");
143+
BOOST_CHECK(state.empty());
144+
result.clear();
145+
state.clear();
146+
147+
// check a complete quantum which needs no padding; including
148+
// how the state develops when encoded by single character
149+
base64::encode("a", std::back_inserter(result), state);
150+
BOOST_CHECK_EQUAL(result, "Y");
151+
BOOST_CHECK(!state.empty());
152+
base64::encode("a", std::back_inserter(result), state);
153+
BOOST_CHECK_EQUAL(result, "YW");
154+
BOOST_CHECK(!state.empty());
155+
base64::encode("a", std::back_inserter(result), state);
156+
BOOST_CHECK_EQUAL(result, "YWFh");
157+
BOOST_CHECK(state.empty());
158+
base64::encode_rest(std::back_inserter(result), state);
159+
BOOST_CHECK_EQUAL(result, "YWFh");
160+
BOOST_CHECK(state.empty());
161+
}
162+
163+
// checks that the base64 output can be returned as wchar_t too
164+
BOOST_AUTO_TEST_CASE(wide_character_test) {
165+
BOOST_CHECK(base64::encode<wchar_t>("abc") == L"YWJj");
166+
BOOST_CHECK(base64::encode<wchar_t>(std::string("abc")) == L"YWJj");
167+
168+
std::wostringstream output;
169+
output << base64::io::encode("abc") << base64::io::encode_rest<char>;
170+
BOOST_CHECK(output.str() == L"YWJj");
171+
}
172+
173+
// checks that the base64-io manipulators are compilable and work
174+
BOOST_AUTO_TEST_CASE(io_test) {
175+
// check complete quantum where no state has to be remembered
176+
std::ostringstream output;
177+
output << base64::io::encode("abc") << base64::io::encode_rest<char>;
178+
BOOST_CHECK_EQUAL(output.str(), "YWJj");
179+
180+
// check that encode_rest clears the state
181+
output.str("");
182+
output << base64::io::encode("a");
183+
BOOST_CHECK(!base64::io::empty_state<char>(output));
184+
output << base64::io::encode_rest<char>;
185+
BOOST_CHECK(base64::io::empty_state<char>(output));
186+
187+
// check that forced clearing the state works
188+
output.str("");
189+
output << base64::io::encode("a");
190+
BOOST_CHECK(!base64::io::empty_state<char>(output));
191+
output << base64::io::clear_state<char>;
192+
BOOST_CHECK(base64::io::empty_state<char>(output));
193+
194+
// check one third of quantum which has to be remembered in state
195+
output.str("");
196+
output << base64::io::encode("a") << base64::io::encode("bc") <<
197+
base64::io::encode_rest<char>;
198+
BOOST_CHECK_EQUAL(output.str(), "YWJj");
199+
200+
// check two thirds of quantum which have to be remembered in state.
201+
output.str("");
202+
output << base64::io::encode("ab") << base64::io::encode("c") <<
203+
base64::io::encode_rest<char>;
204+
BOOST_CHECK_EQUAL(output.str(), "YWJj");
205+
}

0 commit comments

Comments
 (0)