libjmmcg  release_579_6_g8cffd
A C++ library containing an eclectic mix of useful, advanced components.
stack_strings_mixed_size.cpp
Go to the documentation of this file.
1 /******************************************************************************
2 ** Copyright © 2013 by J.M.McGuiness, coder@hussar.me.uk
3 **
4 ** This library is free software; you can redistribute it and/or
5 ** modify it under the terms of the GNU Lesser General Public
6 ** License as published by the Free Software Foundation; either
7 ** version 2.1 of the License, or (at your option) any later version.
8 **
9 ** This library is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 ** Lesser General Public License for more details.
13 **
14 ** You should have received a copy of the GNU Lesser General Public
15 ** License along with this library; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18 
19 #include "stdafx.h"
20 
21 #define BOOST_TEST_MODULE libjmmcg_tests
22 #include <boost/test/included/unit_test.hpp>
23 
24 #include "core/stack_string.hpp"
25 
26 using namespace libjmmcg;
27 
28 using stack_string_12=basic_stack_string<12, char>;
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_12 s1(src1);
39  stack_string_12 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_12 s1(src1);
56  stack_string_12 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_12 s1(src1);
69  stack_string_12 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_12 s1(src1);
82  stack_string_12 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_12 s1(src1);
95  stack_string_12 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_12::size_type res(stack_string_12::small_string_max_size-1);
111  stack_string_12 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_12::size_type res(stack_string_12::small_string_max_size+1);
123  stack_string_12 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_12::size_type res(stack_string_12::small_string_max_size-1);
135  stack_string_12 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_12::size_type res(stack_string_12::small_string_max_size+1);
146  stack_string_12 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_12::value_type fill='X';
156  char const src[]="a very big string";
157  const stack_string_12::size_type res(stack_string_12::small_string_max_size-1);
158  stack_string_12 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_12::value_type fill='X';
168  char const src[]="small";
169  char const result[]="smallXXXXXXXXXXXX";
170  BOOST_CHECK_GT(sizeof(result)-1, stack_string_12::small_string_max_size);
171  const stack_string_12::size_type res(stack_string_12::small_string_max_size+1);
172  stack_string_12 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_12::value_type fill='X';
182  char const src[]="smallXXXXXXXXXXX";
183  char const result[]="smallXXXXXXXXXXXX";
184  BOOST_CHECK_LE(sizeof(src)-1, stack_string_12::small_string_max_size);
185  BOOST_CHECK_GT(sizeof(result)-1, stack_string_12::small_string_max_size);
186  stack_string_12 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_12 src("smallXXXXXX");
196  const char result[]="smallXXXXXXsmallXXXXXX";
197  BOOST_CHECK_LT(src.size(), stack_string_12::small_string_max_size);
198  BOOST_CHECK_GT(sizeof(result)-1, stack_string_12::small_string_max_size);
199  stack_string_12 s(src);
200  const stack_string_12::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_12 src("smallXXXXXX");
211  const char result[]="smallXXXXXXsmallXXXXXX";
212  BOOST_CHECK_LT(src.size(), stack_string_12::small_string_max_size);
213  BOOST_CHECK_GT(sizeof(result)-1, stack_string_12::small_string_max_size);
214  stack_string_12 s(src);
215  const stack_string_12::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_12 src("smallXXXXXX");
226  const char result[]="ssmallXXXXXXmallXXXXXX";
227  BOOST_CHECK_LT(src.size(), stack_string_12::small_string_max_size);
228  BOOST_CHECK_GT(sizeof(result)-1, stack_string_12::small_string_max_size);
229  stack_string_12 s(src);
230  const stack_string_12::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_12::small_string_max_size);
243  BOOST_CHECK_LE(sizeof(result)-1, stack_string_12::small_string_max_size);
244  stack_string_12 s(src);
245  const stack_string_12::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_12::small_string_max_size);
257  BOOST_CHECK_LE(sizeof(result)-1, stack_string_12::small_string_max_size);
258  stack_string_12 s(src);
259  const stack_string_12::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_12::small_string_max_size);
271  BOOST_CHECK_LE(sizeof(result)-1, stack_string_12::small_string_max_size);
272  stack_string_12 s(src);
273  const stack_string_12::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()