root/examples/stack_strings_mixed_size.cpp

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. BOOST_AUTO_TEST_SUITE
  2. BOOST_AUTO_TEST_CASE
  3. BOOST_AUTO_TEST_CASE
  4. BOOST_AUTO_TEST_CASE
  5. BOOST_AUTO_TEST_CASE
  6. BOOST_AUTO_TEST_CASE
  7. BOOST_AUTO_TEST_CASE
  8. BOOST_AUTO_TEST_CASE
  9. BOOST_AUTO_TEST_CASE
  10. BOOST_AUTO_TEST_CASE
  11. BOOST_AUTO_TEST_CASE
  12. BOOST_AUTO_TEST_CASE
  13. BOOST_AUTO_TEST_CASE
  14. BOOST_AUTO_TEST_CASE
  15. BOOST_AUTO_TEST_CASE
  16. BOOST_AUTO_TEST_CASE
  17. BOOST_AUTO_TEST_CASE
  18. BOOST_AUTO_TEST_CASE

   1 /******************************************************************************
   2 ** $Header: svn+ssh://jmmcg@svn.code.sf.net/p/libjmmcg/code/trunk/libjmmcg/examples/stack_strings_mixed_size.cpp 2185 2017-10-13 10:14:17Z jmmcg $
   3 **
   4 ** Copyright © 2013 by J.M.McGuiness, coder@hussar.me.uk
   5 **
   6 ** This library is free software; you can redistribute it and/or
   7 ** modify it under the terms of the GNU Lesser General Public
   8 ** License as published by the Free Software Foundation; either
   9 ** version 2.1 of the License, or (at your option) any later version.
  10 **
  11 ** This library is distributed in the hope that it will be useful,
  12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14 ** Lesser General Public License for more details.
  15 **
  16 ** You should have received a copy of the GNU Lesser General Public
  17 ** License along with this library; if not, write to the Free Software
  18 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  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()

/* [<][>][^][v][top][bottom][index][help] */