libjmmcg  release_579_6_g8cffd
A C++ library containing an eclectic mix of useful, advanced components.
stack_string_big.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 #pragma GCC diagnostic ignored "-Wself-assign-overloaded"
27 #pragma GCC diagnostic ignored "-Wself-move"
28 
29 using namespace libjmmcg;
30 
31 using stack_string_12=basic_stack_string<12, char>;
32 
33 BOOST_AUTO_TEST_SUITE(string_tests)
34 
35 BOOST_AUTO_TEST_SUITE(big_string)
36 
37 BOOST_AUTO_TEST_CASE(ctor)
38 {
39  char const src[]="a very very big string";
40  BOOST_CHECK_GT(sizeof(src)-1, stack_string_12::small_string_max_size);
41  stack_string_12 s(src);
42  BOOST_CHECK(!s.empty());
43  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
44  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
45  BOOST_CHECK_GE(s.capacity(), s.size());
46 }
47 
48 BOOST_AUTO_TEST_CASE(ctor_cctor)
49 {
50  char const src[]="a very very big string";
51  stack_string_12 s1(src);
52  stack_string_12 s2(s1);
53  BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
54  BOOST_CHECK_EQUAL(s1.size(), s2.size());
55  BOOST_CHECK(std::equal(s1.begin(), s1.end(), s2.begin()));
56  BOOST_CHECK_GE(s1.capacity(), s2.capacity());
57 }
58 
59 BOOST_AUTO_TEST_CASE(ctor_move_ctor)
60 {
61  char const src[]="a very very big string";
62  stack_string_12 s1(src);
63  stack_string_12 s2(std::move(s1));
64  BOOST_CHECK(s1.empty());
65  BOOST_CHECK_EQUAL(s1.size(), stack_string_12::size_type());
66  BOOST_CHECK(!s2.empty());
67  BOOST_CHECK_EQUAL(s2.size(), sizeof(src)-1);
68  BOOST_CHECK(std::equal(s2.begin(), s2.end(), src));
69  BOOST_CHECK_GE(s1.capacity(), stack_string_12::size_type());
70  BOOST_CHECK_GE(s2.capacity(), s2.size());
71 }
72 
73 BOOST_AUTO_TEST_CASE(index)
74 {
75  char const src[]="a very very big string";
76  stack_string_12 s(src);
77  BOOST_CHECK_EQUAL(s[0], 'a');
78  BOOST_CHECK_EQUAL(s[1], ' ');
79  BOOST_CHECK_EQUAL(s[2], 'v');
80  BOOST_CHECK_EQUAL(s[3], 'e');
81  BOOST_CHECK_EQUAL(s[4], 'r');
82  BOOST_CHECK_EQUAL(s[5], 'y');
83  BOOST_CHECK_EQUAL(s[6], ' ');
84  BOOST_CHECK_EQUAL(s[7], 'v');
85  BOOST_CHECK_EQUAL(s[8], 'e');
86  BOOST_CHECK_EQUAL(s[9], 'r');
87  BOOST_CHECK_EQUAL(s[10], 'y');
88  BOOST_CHECK_EQUAL(s[11], ' ');
89  BOOST_CHECK_EQUAL(s[12], 'b');
90  BOOST_CHECK_EQUAL(s[13], 'i');
91  BOOST_CHECK_EQUAL(s[14], 'g');
92  BOOST_CHECK_EQUAL(s[15], ' ');
93  BOOST_CHECK_EQUAL(s[16], 's');
94  BOOST_CHECK_EQUAL(s[17], 't');
95  BOOST_CHECK_EQUAL(s[18], 'r');
96  BOOST_CHECK_EQUAL(s[19], 'i');
97  BOOST_CHECK_EQUAL(s[20], 'n');
98  BOOST_CHECK_EQUAL(s[21], 'g');
99 }
100 
101 BOOST_AUTO_TEST_CASE(default_ctor_swap)
102 {
103  char const src[]="a very very big string";
104  stack_string_12 s1(src);
105  stack_string_12 s2;
106  s1.swap(s2);
107  BOOST_CHECK(s1.empty());
108  BOOST_CHECK_EQUAL(s1.size(), stack_string_12::size_type());
109  BOOST_CHECK(!s2.empty());
110  BOOST_CHECK_EQUAL(s2.size(), sizeof(src)-1);
111  BOOST_CHECK(std::equal(src, src+sizeof(src), s2.begin()));
112  BOOST_CHECK_GE(s1.capacity(), stack_string_12::size_type());
113  BOOST_CHECK_GE(s2.capacity(), s2.size());
114 }
115 
116 BOOST_AUTO_TEST_CASE(ctor_swap)
117 {
118  char const src1[]="a very very big string";
119  char const src2[]="another very big string";
120  stack_string_12 s1(src1);
121  stack_string_12 s2(src2);
122  s1.swap(s2);
123  BOOST_CHECK(!s1.empty());
124  BOOST_CHECK_EQUAL(s1.size(), sizeof(src2)-1);
125  BOOST_CHECK(std::equal(s1.begin(), s1.end(), src2));
126  BOOST_CHECK(!s2.empty());
127  BOOST_CHECK_EQUAL(s2.size(), sizeof(src1)-1);
128  BOOST_CHECK(std::equal(s2.begin(), s2.end(), src1));
129  BOOST_CHECK_GE(s1.capacity(), sizeof(src2)-1);
130  BOOST_CHECK_GE(s2.capacity(), sizeof(src1)-1);
131 }
132 
133 BOOST_AUTO_TEST_CASE(cctor_swap)
134 {
135  char const src[]="a very very big string";
136  stack_string_12 s1(src);
137  stack_string_12 s2(s1);
138  s1.swap(s2);
139  BOOST_CHECK(!s1.empty());
140  BOOST_CHECK_EQUAL(s1.size(), sizeof(src)-1);
141  BOOST_CHECK(std::equal(s1.begin(), s1.end(), src));
142  BOOST_CHECK(!s2.empty());
143  BOOST_CHECK_EQUAL(s2.size(), sizeof(src)-1);
144  BOOST_CHECK(std::equal(s2.begin(), s2.end(), src));
145  BOOST_CHECK_GE(s1.capacity(), s2.capacity());
146 }
147 
148 BOOST_AUTO_TEST_CASE(ctor_assignment)
149 {
150  char const src[]="a very very big string";
151  stack_string_12 s1(src);
152  stack_string_12 s2;
153  s2=s1;
154  BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
155  BOOST_CHECK_EQUAL(s1.size(), s2.size());
156  BOOST_CHECK_GE(s1.capacity(), s2.capacity());
157 }
158 
159 BOOST_AUTO_TEST_CASE(two_ctor_assignment)
160 {
161  char const src1[]="a very very big string";
162  char const src2[]="another very big string";
163  stack_string_12 s1(src1);
164  stack_string_12 s2(src2);
165  s2=s1;
166  BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
167  BOOST_CHECK_EQUAL(s1.size(), s2.size());
168  BOOST_CHECK(std::equal(s1.begin(), s1.end(), s2.begin()));
169  BOOST_CHECK_GE(s1.capacity(), s2.capacity());
170 }
171 
172 BOOST_AUTO_TEST_CASE(ctor_move_assignment)
173 {
174  char const src[]="a very very big string";
175  stack_string_12 s1(src);
176  stack_string_12 s2;
177  s2=std::move(s1);
178  BOOST_CHECK(s1.empty());
179  BOOST_CHECK_EQUAL(s1.size(), stack_string_12::size_type());
180  BOOST_CHECK_EQUAL(s1.capacity(), s1.size());
181  BOOST_CHECK(!s2.empty());
182  BOOST_CHECK_EQUAL(s2.size(), sizeof(src)-1);
183  BOOST_CHECK(std::equal(s2.begin(), s2.end(), src));
184  BOOST_CHECK_GE(s2.capacity(), s2.size());
185 }
186 
187 BOOST_AUTO_TEST_CASE(two_ctor_move_assignment)
188 {
189  char const src1[]="a very very big string";
190  char const src2[]="another very big string";
191  stack_string_12 s1(src1);
192  stack_string_12 s2(src2);
193  s2=std::move(s1);
194  BOOST_CHECK(!s2.empty());
195  BOOST_CHECK_EQUAL(s2.size(), sizeof(src1)-1);
196  BOOST_CHECK(std::equal(s2.begin(), s2.end(), src1));
197  BOOST_CHECK_GE(s1.capacity(), s2.capacity());
198 }
199 
200 BOOST_AUTO_TEST_CASE(self_assignment)
201 {
202  char const src[]="a very very big string";
203  stack_string_12 s(src);
204  s=s;
205  BOOST_CHECK(!s.empty());
206  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
207  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
208  BOOST_CHECK_GE(s.capacity(), s.size());
209 }
210 
211 BOOST_AUTO_TEST_CASE(self_move_assignment)
212 {
213  char const src[]="a very very big string";
214  stack_string_12 s(src);
215  s=std::move(s);
216  BOOST_CHECK(!s.empty());
217  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
218  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
219  BOOST_CHECK_GE(s.capacity(), s.size());
220 }
221 
222 BOOST_AUTO_TEST_CASE(equality)
223 {
224  char const src[]="a very very big string";
225  stack_string_12 s1(src), s2(src);
226  BOOST_CHECK(s1==s2);
227 }
228 
229 BOOST_AUTO_TEST_CASE(inequality)
230 {
231  char const src1[]="a very very big string ";
232  char const src2[]="another very very big string";
233  stack_string_12 s1(src1), s2(src2);
234  BOOST_CHECK(s1!=s2);
235 }
236 
237 BOOST_AUTO_TEST_CASE(inequality_sizes1)
238 {
239  char const src1[]="another very very big string";
240  char const src2[]="a very very big string";
241  stack_string_12 s1(src1), s2(src2);
242  BOOST_CHECK(s1!=s2);
243 }
244 
245 BOOST_AUTO_TEST_CASE(inequality_sizes2)
246 {
247  char const src1[]="a very very big string";
248  char const src2[]="another very very big string";
249  stack_string_12 s1(src1), s2(src2);
250  BOOST_CHECK(s1!=s2);
251 }
252 
253 BOOST_AUTO_TEST_CASE(clear)
254 {
255  char const src[]="a very very big string";
256  stack_string_12 s(src);
257  s.clear();
258  BOOST_CHECK(s.empty());
259  BOOST_CHECK_EQUAL(s.size(), stack_string_12::size_type());
260  BOOST_CHECK_GE(s.capacity(), sizeof(src)-1);
261 }
262 
263 BOOST_AUTO_TEST_CASE(reserve_smaller)
264 {
265  const stack_string_12::size_type res(1);
266  char const src[]="a very very big string";
267  stack_string_12 s(src);
268  s.reserve(res);
269  BOOST_CHECK(!s.empty());
270  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
271  BOOST_CHECK_GE(s.capacity(), s.size());
272  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
273 }
274 
275 BOOST_AUTO_TEST_CASE(reserve_bigger)
276 {
277  char const src[]="a very very big string";
278  const stack_string_12::size_type res(sizeof(src)+1);
279  stack_string_12 s(src);
280  s.reserve(res);
281  BOOST_CHECK(!s.empty());
282  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
283  BOOST_CHECK_GE(s.capacity(), res);
284  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
285 }
286 
287 BOOST_AUTO_TEST_CASE(rereserve_bigger)
288 {
289  char const src[]="a very very big string";
290  const stack_string_12::size_type res1(sizeof(src)+1);
291  const stack_string_12::size_type res2(sizeof(src)+2);
292  stack_string_12 s(src);
293  s.reserve(res1);
294  s.reserve(res2);
295  BOOST_CHECK(!s.empty());
296  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
297  BOOST_CHECK_GE(s.capacity(), res2);
298  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
299 }
300 
301 BOOST_AUTO_TEST_CASE(rereserve_smaller)
302 {
303  char const src[]="a very very big string";
304  const stack_string_12::size_type res1(sizeof(src)+1);
305  const stack_string_12::size_type res2(sizeof(src)-2);
306  stack_string_12 s(src);
307  s.reserve(res1);
308  s.reserve(res2);
309  BOOST_CHECK(!s.empty());
310  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
311  BOOST_CHECK_GE(s.capacity(), res1);
312 }
313 
314 BOOST_AUTO_TEST_CASE(resize_smaller)
315 {
316  char const src[]="a very very big string";
317  const stack_string_12::size_type res(sizeof(src)-1);
318  BOOST_CHECK_GT(res, stack_string_12::small_string_max_size);
319  stack_string_12 s(src);
320  s.resize(res);
321  BOOST_CHECK_EQUAL(s.size(), res);
322  BOOST_CHECK_GE(s.capacity(), sizeof(src)-1);
323  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
324 }
325 
326 BOOST_AUTO_TEST_CASE(resize_bigger)
327 {
328  char const src[]="a very very big string";
329  const stack_string_12::size_type res(sizeof(src)+1);
330  stack_string_12 s(src);
331  s.resize(res);
332  BOOST_CHECK_EQUAL(s.size(), res);
333  BOOST_CHECK_GE(s.capacity(), s.size());
334  BOOST_CHECK(std::equal(s.begin(), std::prev(s.end()), src));
335 }
336 
337 BOOST_AUTO_TEST_CASE(reresize_bigger)
338 {
339  char const src[]="a very very big string";
340  const stack_string_12::size_type res1(sizeof(src)+1);
341  const stack_string_12::size_type res2(res1+1);
342  stack_string_12 s(src);
343  s.resize(res1);
344  s.resize(res2);
345  BOOST_CHECK_EQUAL(s.size(), res2);
346  BOOST_CHECK_GE(s.capacity(), s.size());
347  BOOST_CHECK(std::equal(s.begin(), std::prev(s.end(), res2-sizeof(src)), src));
348 }
349 
350 BOOST_AUTO_TEST_CASE(reresize_smaller)
351 {
352  char const src[]="a very very big string";
353  const stack_string_12::size_type res1(sizeof(src)+1);
354  const stack_string_12::size_type res2(res1-1);
355  BOOST_CHECK_GT(res1, stack_string_12::small_string_max_size);
356  BOOST_CHECK_GT(res2, stack_string_12::small_string_max_size);
357  stack_string_12 s(src);
358  s.resize(res1);
359  s.resize(res2);
360  BOOST_CHECK_EQUAL(s.size(), res2);
361  BOOST_CHECK_GE(s.capacity(), res1);
362  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
363 }
364 
365 BOOST_AUTO_TEST_CASE(resize_smaller_init)
366 {
367  const stack_string_12::value_type fill='X';
368  char const src[]="a very very big string";
369  const stack_string_12::size_type res(sizeof(src)-1);
370  BOOST_CHECK_GT(res, stack_string_12::small_string_max_size);
371  stack_string_12 s(src);
372  s.resize(res, fill);
373  BOOST_CHECK_EQUAL(s.size(), res);
374  BOOST_CHECK_GE(s.capacity(), sizeof(src)-1);
375  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
376 }
377 
378 BOOST_AUTO_TEST_CASE(resize_bigger_init)
379 {
380  const stack_string_12::value_type fill='X';
381  char const src[]="a very very big string";
382  char const result[]="a very very big stringXX";
383  const stack_string_12::size_type res(sizeof(src)+1);
384  BOOST_CHECK_GT(res, stack_string_12::small_string_max_size);
385  stack_string_12 s(src);
386  s.resize(res, fill);
387  BOOST_CHECK_EQUAL(s.size(), res);
388  BOOST_CHECK_GE(s.capacity(), s.size());
389  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
390 }
391 
392 BOOST_AUTO_TEST_CASE(reresize_bigger_init)
393 {
394  const stack_string_12::value_type fill='X';
395  char const src[]="a very very big string";
396  char const result[]="a very very big stringXXX";
397  const stack_string_12::size_type res1(sizeof(src)+1);
398  const stack_string_12::size_type res2(res1+1);
399  BOOST_CHECK_GT(res1, stack_string_12::small_string_max_size);
400  BOOST_CHECK_GT(res2, stack_string_12::small_string_max_size);
401  stack_string_12 s(src);
402  s.resize(res1, fill);
403  s.resize(res2, fill);
404  BOOST_CHECK_EQUAL(s.size(), res2);
405  BOOST_CHECK_GE(s.capacity(), s.size());
406  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
407 }
408 
409 BOOST_AUTO_TEST_CASE(reresize_smaller_init)
410 {
411  const stack_string_12::value_type fill='X';
412  char const src[]="a very very big string";
413  char const result[]="a very very big stringX";
414  const stack_string_12::size_type res1(sizeof(src)+1);
415  const stack_string_12::size_type res2(res1-1);
416  BOOST_CHECK_GT(res1, stack_string_12::small_string_max_size);
417  BOOST_CHECK_GT(res2, stack_string_12::small_string_max_size);
418  stack_string_12 s(src);
419  s.resize(res1, fill);
420  s.resize(res2, fill);
421  BOOST_CHECK_EQUAL(s.size(), res2);
422  BOOST_CHECK_GE(s.capacity(), res1);
423  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
424 }
425 
426 BOOST_AUTO_TEST_CASE(push_back)
427 {
428  const stack_string_12::value_type fill='X';
429  char const src[]="a very very big string";
430  char const result[]="a very very big stringX";
431  stack_string_12 s(src);
432  s.push_back(fill);
433  BOOST_CHECK_EQUAL(s.size(), sizeof(src));
434  BOOST_CHECK_GE(s.capacity(), s.size());
435  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
436 }
437 
438 BOOST_AUTO_TEST_CASE(insert_str)
439 {
440  const stack_string_12 src("a very very big string");
441  BOOST_CHECK_GT(sizeof(src)-1, stack_string_12::small_string_max_size);
442  stack_string_12 s;
443  const stack_string_12::iterator i=s.insert(s.end(), src.begin(), src.end());
444  BOOST_CHECK(!s.empty());
445  BOOST_CHECK_EQUAL(s.size(), src.size());
446  BOOST_CHECK(std::equal(s.begin(), s.end(), src.begin()));
447  BOOST_CHECK_EQUAL(i, s.begin());
448 }
449 
450 BOOST_AUTO_TEST_CASE(insert_str_end)
451 {
452  const stack_string_12 src("a very very big string");
453  BOOST_CHECK_GT(sizeof(src)-1, stack_string_12::small_string_max_size);
454  const char result[]="a very very big stringa very very big string";
455  stack_string_12 s(src);
456  const stack_string_12::iterator i=s.insert(s.end(), src.begin(), src.end());
457  BOOST_CHECK(!s.empty());
458  BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
459  BOOST_CHECK_GE(s.capacity(), s.size());
460  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
461  BOOST_CHECK_EQUAL(i, s.begin()+src.size());
462 }
463 
464 BOOST_AUTO_TEST_CASE(insert_str_begin)
465 {
466  const stack_string_12 src("a very very big string");
467  BOOST_CHECK_GT(sizeof(src)-1, stack_string_12::small_string_max_size);
468  const char result[]="a very very big stringa very very big string";
469  stack_string_12 s(src);
470  const stack_string_12::iterator i=s.insert(s.begin(), src.begin(), src.end());
471  BOOST_CHECK(!s.empty());
472  BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
473  BOOST_CHECK_GE(s.capacity(), s.size());
474  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
475  BOOST_CHECK_EQUAL(i, s.begin());
476 }
477 
478 BOOST_AUTO_TEST_CASE(insert_str_internal)
479 {
480  const stack_string_12 src("a very very big string");
481  BOOST_CHECK_GT(sizeof(src)-1, stack_string_12::small_string_max_size);
482  const char result[]="aa very very big string very very big string";
483  stack_string_12 s(src);
484  const stack_string_12::iterator i=s.insert(std::next(s.begin()), src.begin(), src.end());
485  BOOST_CHECK(!s.empty());
486  BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
487  BOOST_CHECK_GE(s.capacity(), s.size());
488  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
489  BOOST_CHECK_EQUAL(i, std::next(s.begin()));
490 }
491 
492 BOOST_AUTO_TEST_CASE(erase_all)
493 {
494  stack_string_12 src("a very very big string");
495  const stack_string_12::iterator i=src.erase(src.begin(), src.end());
496  BOOST_CHECK(src.empty());
497  BOOST_CHECK_EQUAL(src.size(), stack_string_12::size_type());
498  BOOST_CHECK_EQUAL(i, src.end());
499 }
500 
501 BOOST_AUTO_TEST_CASE(erase_none)
502 {
503  char const src[]="a very very big string";
504  stack_string_12 s(src);
505  const stack_string_12::iterator i=s.erase(s.begin(), s.begin());
506  BOOST_CHECK(!s.empty());
507  BOOST_CHECK_EQUAL(s.size(), sizeof(src)-1);
508  BOOST_CHECK(std::equal(s.begin(), s.end(), src));
509  BOOST_CHECK_EQUAL(i, s.begin());
510 }
511 
512 BOOST_AUTO_TEST_CASE(erase_begin_one)
513 {
514  char const src[]="a very very big string";
515  char const result[]=" very very big string";
516  stack_string_12 s(src);
517  const stack_string_12::iterator i=s.erase(s.begin(), std::next(s.begin()));
518  BOOST_CHECK(!s.empty());
519  BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
520  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
521  BOOST_CHECK_EQUAL(i, s.begin());
522 }
523 
524 BOOST_AUTO_TEST_CASE(erase_end_one)
525 {
526  char const src[]="a very very big string";
527  char const result[]="a very very big strin";
528  stack_string_12 s(src);
529  const stack_string_12::iterator i=s.erase(std::prev(s.end()), s.end());
530  BOOST_CHECK(!s.empty());
531  BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
532  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
533  BOOST_CHECK_EQUAL(i, s.end());
534 }
535 
536 BOOST_AUTO_TEST_CASE(erase_middle_one)
537 {
538  char const src[]="a very very big string";
539  char const result[]="a ery very big string";
540  stack_string_12 s(src);
541  const stack_string_12::iterator i=s.erase(std::next(s.begin(), 2), std::next(s.begin(), 3));
542  BOOST_CHECK(!s.empty());
543  BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
544  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
545  BOOST_CHECK_EQUAL(i, std::next(s.begin(), 2));
546 }
547 
548 BOOST_AUTO_TEST_CASE(erase_middle_two)
549 {
550  char const src[]="a very very big string";
551  char const result[]="a ry very big string";
552  stack_string_12 s(src);
553  const stack_string_12::iterator i=s.erase(std::next(s.begin(), 2), std::next(s.begin(), 4));
554  BOOST_CHECK(!s.empty());
555  BOOST_CHECK_EQUAL(s.size(), sizeof(result)-1);
556  BOOST_CHECK(std::equal(s.begin(), s.end(), result));
557  BOOST_CHECK_EQUAL(i, std::next(s.begin(), 2));
558 }
559 
560 BOOST_AUTO_TEST_CASE(replace_dest_empty)
561 {
562  char const src[]="a very very big string";
563  stack_string_12 s1, s2(src);
564  s1.replace(s1.begin(), s1.begin(), s2.begin(), s2.end());
565  BOOST_CHECK(!s1.empty());
566  BOOST_CHECK_EQUAL(s1.size(), sizeof(src)-1);
567  BOOST_CHECK(std::equal(s1.begin(), s1.end(), src));
568 }
569 
570 BOOST_AUTO_TEST_CASE(replace_src_empty)
571 {
572  char const src[]="a very very big string";
573  stack_string_12 s1(src), s2;
574  s1.replace(s1.begin(), s1.end(), s2.begin(), s2.begin());
575  BOOST_CHECK(s1.empty());
576  BOOST_CHECK_EQUAL(s1.size(), stack_string_12::size_type());
577 }
578 
579 BOOST_AUTO_TEST_CASE(replace_both_empty)
580 {
581  char const src[]="a very very big string";
582  stack_string_12 s1(src), s2;
583  s1.replace(s1.begin(), s1.begin(), s2.begin(), s2.begin());
584  BOOST_CHECK(!s1.empty());
585  BOOST_CHECK_EQUAL(s1.size(), sizeof(src)-1);
586  BOOST_CHECK(std::equal(s1.begin(), s1.end(), src));
587 }
588 
589 BOOST_AUTO_TEST_CASE(replace_begin_shrink)
590 {
591  char const src[]="a very very big string";
592  char const result[]="aery very big string";
593  stack_string_12 s1(src), s2(src);
594  s1.replace(s1.begin(), std::next(s1.begin(), 3), s2.begin(), std::next(s2.begin()));
595  BOOST_CHECK(!s1.empty());
596  BOOST_CHECK_EQUAL(s1.size(), sizeof(result)-1);
597  BOOST_CHECK(std::equal(s1.begin(), s1.end(), result));
598 }
599 
600 BOOST_AUTO_TEST_CASE(replace_end_shrink)
601 {
602  char const src[]="a very very big string";
603  char const result[]="a very very big stra";
604  stack_string_12 s1(src), s2(src);
605  s1.replace(std::prev(s1.end(), 3), s1.end(), s2.begin(), std::next(s2.begin()));
606  BOOST_CHECK(!s1.empty());
607  BOOST_CHECK_EQUAL(s1.size(), sizeof(result)-1);
608  BOOST_CHECK(std::equal(s1.begin(), s1.end(), result));
609 }
610 
611 BOOST_AUTO_TEST_CASE(replace_middle_shrink)
612 {
613  char const src[]="a very very big string";
614  char const result[]="aaery very big string";
615  stack_string_12 s1(src), s2(src);
616  s1.replace(std::next(s1.begin()), std::next(s1.begin(), 3), s2.begin(), std::next(s2.begin()));
617  BOOST_CHECK(!s1.empty());
618  BOOST_CHECK_EQUAL(s1.size(), sizeof(result)-1);
619  BOOST_CHECK(std::equal(s1.begin(), s1.end(), result));
620 }
621 
622 BOOST_AUTO_TEST_CASE(replace_begin_grow)
623 {
624  char const src[]="a very very big string";
625  char const result[]="a very very big stringvery very big string";
626  stack_string_12 s1(src), s2(src);
627  s1.replace(s1.begin(), std::next(s1.begin(), 2), s2.begin(), s2.end());
628  BOOST_CHECK(!s1.empty());
629  BOOST_CHECK_EQUAL(s1.size(), sizeof(result)-1);
630  BOOST_CHECK(std::equal(s1.begin(), s1.end(), result));
631 }
632 
633 BOOST_AUTO_TEST_CASE(replace_end_grow)
634 {
635  char const src[]="a very very big string";
636  char const result[]="a very very big stria very very big string";
637  stack_string_12 s1(src), s2(src);
638  s1.replace(std::prev(s1.end(), 2), s1.end(), s2.begin(), s2.end());
639  BOOST_CHECK(!s1.empty());
640  BOOST_CHECK_EQUAL(s1.size(), sizeof(result)-1);
641  BOOST_CHECK(std::equal(s1.begin(), s1.end(), result));
642 }
643 
644 BOOST_AUTO_TEST_CASE(replace_middle_grow)
645 {
646  char const src[]="a very very big string";
647  char const result[]="a a very very big stringry very big string";
648  stack_string_12 s1(src), s2(src);
649  s1.replace(std::next(s1.begin(), 2), std::next(s1.begin(), 4), s2.begin(), s2.end());
650  BOOST_CHECK(!s1.empty());
651  BOOST_CHECK_EQUAL(s1.size(), sizeof(result)-1);
652  BOOST_CHECK(std::equal(s1.begin(), s1.end(), result));
653 }
654 
655 BOOST_AUTO_TEST_CASE(insert)
656 {
657  char const src[]="a very very big string";
658  stack_string_12 s(src);
659  std::stringstream ss;
660  ss<<s;
661  BOOST_CHECK_EQUAL(ss.str(), std::string(src));
662 }
663 
664 BOOST_AUTO_TEST_CASE(extract)
665 {
666  char const src[]="a very very big string";
667  stack_string_12 s;
668  const stack_string_12 res(src);
669  std::stringstream ss;
670  ss<<src;
671  ss>>s;
672  BOOST_CHECK_EQUAL(s, res);
673 }
674 
675 BOOST_AUTO_TEST_SUITE_END()
676 
677 BOOST_AUTO_TEST_SUITE_END()