This source file includes following definitions.
- BOOST_AUTO_TEST_SUITE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
- BOOST_AUTO_TEST_CASE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 #include "stdafx.h"
22
23 #define BOOST_TEST_MODULE libjmmcg_tests
24 #include <boost/test/included/unit_test.hpp>
25
26 #include "core/stack_string.hpp"
27
28 typedef jmmcg::basic_stack_string<12, char> stack_string;
29
30 BOOST_AUTO_TEST_SUITE(string_tests)
31
32 BOOST_AUTO_TEST_SUITE(mixed_size_strings)
33
34 BOOST_AUTO_TEST_CASE(ctor_swap)
35 {
36 char const src1[]="small";
37 char const src2[]="a very big string";
38 stack_string s1(src1);
39 stack_string s2(src2);
40 s1.swap(s2);
41 BOOST_CHECK(!s1.empty());
42 BOOST_CHECK_EQUAL(s1.size(), sizeof(src2)-1);
43 BOOST_CHECK(std::equal(src2, src2+sizeof(src2), s1.begin()));
44 BOOST_CHECK_GE(s1.capacity(), sizeof(src2)-1);
45 BOOST_CHECK(!s2.empty());
46 BOOST_CHECK_EQUAL(s2.size(), sizeof(src1)-1);
47 BOOST_CHECK(std::equal(src1, src1+sizeof(src1), s2.begin()));
48 BOOST_CHECK_GE(s2.capacity(), sizeof(src1)-1);
49 }
50
51 BOOST_AUTO_TEST_CASE(small_big_ctor_assignment)
52 {
53 char const src1[]="small";
54 char const src2[]="a very big string";
55 stack_string s1(src1);
56 stack_string s2(src2);
57 s2=s1;
58 BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
59 BOOST_CHECK_EQUAL(s1.size(), s2.size());
60 BOOST_CHECK(std::equal(s1.begin(), s1.end(), s2.begin()));
61 BOOST_CHECK_GE(s1.capacity(), s2.capacity());
62 }
63
64 BOOST_AUTO_TEST_CASE(big_small_ctor_assignment)
65 {
66 char const src1[]="a very big string";
67 char const src2[]="small";
68 stack_string s1(src1);
69 stack_string s2(src2);
70 s2=s1;
71 BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
72 BOOST_CHECK_EQUAL(s1.size(), s2.size());
73 BOOST_CHECK(std::equal(s1.begin(), s1.end(), s2.begin()));
74 BOOST_CHECK_GE(s1.capacity(), s2.capacity());
75 }
76
77 BOOST_AUTO_TEST_CASE(small_big_ctor_move_assignment)
78 {
79 char const src1[]="small";
80 char const src2[]="a very big string";
81 stack_string s1(src1);
82 stack_string s2(src2);
83 s2=std::move(s1);
84 BOOST_CHECK(!s2.empty());
85 BOOST_CHECK_EQUAL(s2.size(), sizeof(src1)-1);
86 BOOST_CHECK(std::equal(s2.begin(), s2.end(), src1));
87 BOOST_CHECK_GE(s1.capacity(), s2.capacity());
88 }
89
90 BOOST_AUTO_TEST_CASE(big_small_ctor_move_assignment)
91 {
92 char const src1[]="a very big string";
93 char const src2[]="small";
94 stack_string s1(src1);
95 stack_string s2(src2);
96 s2=std::move(s1);
97 BOOST_CHECK(!s1.empty());
98 BOOST_CHECK_EQUAL(s1.size(), sizeof(src2)-1);
99 BOOST_CHECK(std::equal(s1.begin(), s1.end(), src2));
100 BOOST_CHECK_GE(s1.capacity(), s1.size());
101 BOOST_CHECK(!s2.empty());
102 BOOST_CHECK_EQUAL(s2.size(), sizeof(src1)-1);
103 BOOST_CHECK(std::equal(s2.begin(), s2.end(), src1));
104 BOOST_CHECK_GE(s2.capacity(), s2.size());
105 }
106
107 BOOST_AUTO_TEST_CASE(reserve_big_to_small_str)
108 {
109 char const src[]="a very big string";
110 const stack_string::size_type res(stack_string::small_string_max_size-1);
111 stack_string s(src);
112 s.reserve(res);
113 BOOST_CHECK(!s.empty());
114 BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
115 BOOST_CHECK_GE(s.capacity(), s.size());
116 BOOST_CHECK(std::equal(s.begin(), s.end(), src));
117 }
118
119 BOOST_AUTO_TEST_CASE(reserve_small_to_big_str)
120 {
121 char const src[]="small";
122 const stack_string::size_type res(stack_string::small_string_max_size+1);
123 stack_string s(src);
124 s.reserve(res);
125 BOOST_CHECK(!s.empty());
126 BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
127 BOOST_CHECK_GE(s.capacity(), res);
128 BOOST_CHECK(std::equal(s.begin(), s.end(), src));
129 }
130
131 BOOST_AUTO_TEST_CASE(resize_smaller)
132 {
133 char const src[]="a very big string";
134 const stack_string::size_type res(stack_string::small_string_max_size-1);
135 stack_string s(src);
136 s.resize(res);
137 BOOST_CHECK_EQUAL(s.size(), res);
138 BOOST_CHECK_GE(s.capacity(), sizeof(src)-1);
139 BOOST_CHECK(std::equal(s.begin(), s.end(), src));
140 }
141
142 BOOST_AUTO_TEST_CASE(resize_bigger)
143 {
144 char const src[]="small";
145 const stack_string::size_type res(stack_string::small_string_max_size+1);
146 stack_string s(src);
147 s.resize(res);
148 BOOST_CHECK_EQUAL(s.size(), res);
149 BOOST_CHECK_GE(s.capacity(), s.size());
150 BOOST_CHECK(std::equal(src, src+sizeof(src), s.begin()));
151 }
152
153 BOOST_AUTO_TEST_CASE(resize_smaller_init)
154 {
155 const stack_string::value_type fill='X';
156 char const src[]="a very big string";
157 const stack_string::size_type res(stack_string::small_string_max_size-1);
158 stack_string s(src);
159 s.resize(res, fill);
160 BOOST_CHECK_EQUAL(s.size(), res);
161 BOOST_CHECK_GE(s.capacity(), sizeof(src)-1);
162 BOOST_CHECK(std::equal(s.begin(), s.end(), src));
163 }
164
165 BOOST_AUTO_TEST_CASE(resize_bigger_init)
166 {
167 const stack_string::value_type fill='X';
168 char const src[]="small";
169 char const result[]="smallXXXXXXXXXXXX";
170 BOOST_CHECK_GT(sizeof(result)-1, stack_string::small_string_max_size);
171 const stack_string::size_type res(stack_string::small_string_max_size+1);
172 stack_string s(src);
173 s.resize(res, fill);
174 BOOST_CHECK_EQUAL(s.size(), res);
175 BOOST_CHECK_GE(s.capacity(), s.size());
176 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
177 }
178
179 BOOST_AUTO_TEST_CASE(push_back)
180 {
181 const stack_string::value_type fill='X';
182 char const src[]="smallXXXXXXXXXXX";
183 char const result[]="smallXXXXXXXXXXXX";
184 BOOST_CHECK_LE(sizeof(src)-1, stack_string::small_string_max_size);
185 BOOST_CHECK_GT(sizeof(result)-1, stack_string::small_string_max_size);
186 stack_string s(src);
187 s.push_back(fill);
188 BOOST_CHECK_EQUAL(s.size(), sizeof(src));
189 BOOST_CHECK_GE(s.capacity(), s.size());
190 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
191 }
192
193 BOOST_AUTO_TEST_CASE(insert_str_end)
194 {
195 const stack_string src("smallXXXXXX");
196 const char result[]="smallXXXXXXsmallXXXXXX";
197 BOOST_CHECK_LT(src.size(), stack_string::small_string_max_size);
198 BOOST_CHECK_GT(sizeof(result)-1, stack_string::small_string_max_size);
199 stack_string s(src);
200 const stack_string::iterator i=s.insert(s.end(), src.begin(), src.end());
201 BOOST_CHECK(!s.empty());
202 BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
203 BOOST_CHECK_GE(s.capacity(), s.size());
204 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
205 BOOST_CHECK_EQUAL(i, s.begin()+src.size());
206 }
207
208 BOOST_AUTO_TEST_CASE(insert_str_begin)
209 {
210 const stack_string src("smallXXXXXX");
211 const char result[]="smallXXXXXXsmallXXXXXX";
212 BOOST_CHECK_LT(src.size(), stack_string::small_string_max_size);
213 BOOST_CHECK_GT(sizeof(result)-1, stack_string::small_string_max_size);
214 stack_string s(src);
215 const stack_string::iterator i=s.insert(s.begin(), src.begin(), src.end());
216 BOOST_CHECK(!s.empty());
217 BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
218 BOOST_CHECK_GE(s.capacity(), s.size());
219 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
220 BOOST_CHECK_EQUAL(i, s.begin());
221 }
222
223 BOOST_AUTO_TEST_CASE(insert_str_internal)
224 {
225 const stack_string src("smallXXXXXX");
226 const char result[]="ssmallXXXXXXmallXXXXXX";
227 BOOST_CHECK_LT(src.size(), stack_string::small_string_max_size);
228 BOOST_CHECK_GT(sizeof(result)-1, stack_string::small_string_max_size);
229 stack_string s(src);
230 const stack_string::iterator i=s.insert(std::next(s.begin()), src.begin(), src.end());
231 BOOST_CHECK(!s.empty());
232 BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
233 BOOST_CHECK_GE(s.capacity(), s.size());
234 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
235 BOOST_CHECK_EQUAL(i, std::next(s.begin()));
236 }
237
238 BOOST_AUTO_TEST_CASE(erase_begin_one)
239 {
240 char const src[]="smallXXXXXXXXXXXX";
241 char const result[]="mallXXXXXXXXXXXX";
242 BOOST_CHECK_GT(sizeof(src)-1, stack_string::small_string_max_size);
243 BOOST_CHECK_LE(sizeof(result)-1, stack_string::small_string_max_size);
244 stack_string s(src);
245 const stack_string::iterator i=s.erase(s.begin(), std::next(s.begin()));
246 BOOST_CHECK(!s.empty());
247 BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
248 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
249 BOOST_CHECK_EQUAL(i, s.begin());
250 }
251
252 BOOST_AUTO_TEST_CASE(erase_end_one)
253 {
254 char const src[]="smallXXXXXXXXXXXX";
255 char const result[]="smallXXXXXXXXXXX";
256 BOOST_CHECK_GT(sizeof(src)-1, stack_string::small_string_max_size);
257 BOOST_CHECK_LE(sizeof(result)-1, stack_string::small_string_max_size);
258 stack_string s(src);
259 const stack_string::iterator i=s.erase(std::prev(s.end()), s.end());
260 BOOST_CHECK(!s.empty());
261 BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
262 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
263 BOOST_CHECK_EQUAL(i, s.end());
264 }
265
266 BOOST_AUTO_TEST_CASE(erase_middle_one)
267 {
268 char const src[]= "smallXXXXXXXXXXXX";
269 char const result[]="smllXXXXXXXXXXXX";
270 BOOST_CHECK_GT(sizeof(src)-1, stack_string::small_string_max_size);
271 BOOST_CHECK_LE(sizeof(result)-1, stack_string::small_string_max_size);
272 stack_string s(src);
273 const stack_string::iterator i=s.erase(std::next(s.begin(), 2), std::next(s.begin(), 3));
274 BOOST_CHECK(!s.empty());
275 BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
276 BOOST_CHECK(std::equal(s.begin(), s.end(), result));
277 BOOST_CHECK_EQUAL(i, std::next(s.begin(), 2));
278 }
279
280 BOOST_AUTO_TEST_SUITE_END()
281
282 BOOST_AUTO_TEST_SUITE_END()