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