Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit95137e2

Browse files
committed
Add tests for the BASE64 encoding
1 parent153d203 commit95137e2

File tree

3 files changed

+207
-0
lines changed

3 files changed

+207
-0
lines changed

‎libs/network/test/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
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‎

Lines changed: 1 addition & 0 deletions
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 ;
Lines changed: 205 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,205 @@
1+
#defineBOOST_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+
usingnamespaceboost::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::stringinput("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)
[8]ページ先頭
©2009-2025 Movatter.jp