root/examples/stack_string_default_ctors.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
  19. BOOST_AUTO_TEST_CASE
  20. BOOST_AUTO_TEST_CASE
  21. BOOST_AUTO_TEST_CASE
  22. BOOST_AUTO_TEST_CASE
  23. BOOST_AUTO_TEST_CASE
  24. BOOST_AUTO_TEST_CASE
  25. BOOST_AUTO_TEST_CASE
  26. BOOST_AUTO_TEST_CASE
  27. BOOST_AUTO_TEST_CASE
  28. BOOST_AUTO_TEST_CASE
  29. BOOST_AUTO_TEST_CASE

   1 /******************************************************************************
   2 ** $Header: svn+ssh://jmmcg@svn.code.sf.net/p/libjmmcg/code/trunk/libjmmcg/examples/stack_string_default_ctors.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 #include <sstream>
  29 
  30 typedef jmmcg::stack_string stack_string;
  31 
  32 BOOST_AUTO_TEST_SUITE(string_tests)
  33 
  34 BOOST_AUTO_TEST_SUITE(default_ctors)
  35 
  36 /**
  37         Test that we can default construct & delete a stack_string object.
  38 */
  39 BOOST_AUTO_TEST_CASE(default_ctor)
  40 {
  41         stack_string s;
  42 }
  43 
  44 /**
  45         Test that we can default construct & delete a stack_string object.
  46 */
  47 BOOST_AUTO_TEST_CASE(default_ctor_empty)
  48 {
  49         stack_string s;
  50         BOOST_CHECK(s.empty());
  51         BOOST_CHECK_EQUAL(s.size(), stack_string::size_type());
  52         BOOST_CHECK_EQUAL(s.capacity(), stack_string::size_type());
  53 }
  54 /* TODO
  55 BOOST_AUTO_TEST_CASE(nullptr_ctor)
  56 {
  57         bool exception_caught=false;
  58         try {
  59                 char const *src=nullptr;
  60                 stack_string s(src);
  61         } catch (stack_string::exception const &e) {
  62                 exception_caught=true;
  63         }
  64         BOOST_CHECK(exception_caught);
  65 }
  66 */
  67 BOOST_AUTO_TEST_CASE(default_ctor_cctor)
  68 {
  69         stack_string s1;
  70         stack_string s2(s1);
  71         BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
  72         BOOST_CHECK_EQUAL(s1.size(), s2.size());
  73         BOOST_CHECK_EQUAL(s1.capacity(), s2.capacity());
  74 }
  75 
  76 BOOST_AUTO_TEST_CASE(default_ctor_move_ctor)
  77 {
  78         stack_string s1;
  79         stack_string s2(std::move(s1));
  80         BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
  81         BOOST_CHECK_EQUAL(s1.size(), s2.size());
  82         BOOST_CHECK_EQUAL(s1.capacity(), s2.capacity());
  83 }
  84 
  85 BOOST_AUTO_TEST_CASE(default_ctor_swap)
  86 {
  87         stack_string s1, s2;
  88         s1.swap(s2);
  89         BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
  90         BOOST_CHECK_EQUAL(s1.size(), s2.size());
  91         BOOST_CHECK_EQUAL(s1.capacity(), s2.capacity());
  92 }
  93 
  94 BOOST_AUTO_TEST_CASE(default_ctor_assignment)
  95 {
  96         stack_string s1;
  97         stack_string s2;
  98         s2=s1;
  99         BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
 100         BOOST_CHECK_EQUAL(s1.size(), s2.size());
 101         BOOST_CHECK_EQUAL(s1.capacity(), s2.capacity());
 102 }
 103 
 104 BOOST_AUTO_TEST_CASE(default_ctor_move_assignment)
 105 {
 106         stack_string s1;
 107         stack_string s2;
 108         s2=std::move(s1);
 109         BOOST_CHECK_EQUAL(s1.empty(), s2.empty());
 110         BOOST_CHECK_EQUAL(s1.size(), s2.size());
 111         BOOST_CHECK_EQUAL(s1.capacity(), s2.capacity());
 112 }
 113 
 114 BOOST_AUTO_TEST_CASE(self_assignment)
 115 {
 116         stack_string s;
 117         s=s;
 118         BOOST_CHECK(s.empty());
 119         BOOST_CHECK_EQUAL(s.size(), stack_string::size_type());
 120         BOOST_CHECK_EQUAL(s.capacity(), stack_string::size_type());
 121 }
 122 
 123 BOOST_AUTO_TEST_CASE(equality)
 124 {
 125         stack_string s1, s2;
 126         BOOST_CHECK(s1==s2);
 127 }
 128 
 129 BOOST_AUTO_TEST_CASE(inequality)
 130 {
 131         stack_string s1, s2;
 132         BOOST_CHECK(!(s1!=s2));
 133 }
 134 
 135 BOOST_AUTO_TEST_CASE(clear)
 136 {
 137         stack_string s;
 138         s.clear();
 139         BOOST_CHECK(s.empty());
 140         BOOST_CHECK_EQUAL(s.size(), stack_string::size_type());
 141         BOOST_CHECK_EQUAL(s.capacity(), stack_string::size_type());
 142 }
 143 
 144 BOOST_AUTO_TEST_CASE(reserve)
 145 {
 146         const stack_string::size_type res(1);
 147         stack_string s;
 148         s.reserve(res);
 149         BOOST_CHECK(s.empty());
 150         BOOST_CHECK_EQUAL(s.size(), stack_string::size_type());
 151         BOOST_CHECK_EQUAL(s.capacity(), res);
 152 }
 153 
 154 BOOST_AUTO_TEST_CASE(rereserve_bigger)
 155 {
 156         const stack_string::size_type res1(1);
 157         const stack_string::size_type res2(2);
 158         stack_string s;
 159         s.reserve(res1);
 160         s.reserve(res2);
 161         BOOST_CHECK_EQUAL(s.capacity(), res2);
 162 }
 163 
 164 BOOST_AUTO_TEST_CASE(rereserve_smaller)
 165 {
 166         const stack_string::size_type res1(2);
 167         const stack_string::size_type res2(1);
 168         stack_string s;
 169         s.reserve(res1);
 170         s.reserve(res2);
 171         BOOST_CHECK_EQUAL(s.capacity(), res1);
 172 }
 173 
 174 BOOST_AUTO_TEST_CASE(resize)
 175 {
 176         const stack_string::size_type res(1);
 177         stack_string s;
 178         s.resize(res);
 179         BOOST_CHECK_EQUAL(s.size(), res);
 180         BOOST_CHECK_LE(s.size(), s.capacity());
 181 }
 182 
 183 BOOST_AUTO_TEST_CASE(reresize_bigger)
 184 {
 185         const stack_string::size_type res1(1);
 186         const stack_string::size_type res2(2);
 187         stack_string s;
 188         s.resize(res1);
 189         s.resize(res2);
 190         BOOST_CHECK_EQUAL(s.size(), res2);
 191         BOOST_CHECK_LE(s.size(), s.capacity());
 192 }
 193 
 194 BOOST_AUTO_TEST_CASE(reresize_smaller)
 195 {
 196         const stack_string::size_type res1(2);
 197         const stack_string::size_type res2(1);
 198         stack_string s;
 199         s.resize(res1);
 200         s.resize(res2);
 201         BOOST_CHECK_EQUAL(s.size(), res2);
 202         BOOST_CHECK_GE(s.capacity(), res1);
 203 }
 204 
 205 BOOST_AUTO_TEST_CASE(resize_init)
 206 {
 207         const stack_string::size_type res(1);
 208         const stack_string::value_type fill='X';
 209         stack_string s;
 210         s.resize(res, fill);
 211         BOOST_CHECK_EQUAL(s.size(), res);
 212         BOOST_CHECK_LE(s.size(), s.capacity());
 213         BOOST_CHECK_EQUAL(s[0], fill);
 214 }
 215 
 216 BOOST_AUTO_TEST_CASE(reresize_bigger_init)
 217 {
 218         const stack_string::size_type res1(1);
 219         const stack_string::size_type res2(2);
 220         const stack_string::value_type fill='X';
 221         stack_string s;
 222         s.resize(res1, fill);
 223         s.resize(res2, fill);
 224         BOOST_CHECK_EQUAL(s.size(), res2);
 225         BOOST_CHECK_LE(s.size(), s.capacity());
 226         BOOST_CHECK_EQUAL(s[0], fill);
 227         BOOST_CHECK_EQUAL(s[1], fill);
 228 }
 229 
 230 BOOST_AUTO_TEST_CASE(reresize_smaller_init)
 231 {
 232         const stack_string::size_type res1(2);
 233         const stack_string::size_type res2(1);
 234         const stack_string::value_type fill='X';
 235         stack_string s;
 236         s.resize(res1, fill);
 237         s.resize(res2, fill);
 238         BOOST_CHECK_EQUAL(s.size(), res2);
 239         BOOST_CHECK_GE(s.capacity(), res1);
 240         BOOST_CHECK_EQUAL(s[0], fill);
 241 }
 242 
 243 BOOST_AUTO_TEST_CASE(push_back)
 244 {
 245         const stack_string::value_type fill='X';
 246         stack_string s;
 247         s.push_back(fill);
 248         BOOST_CHECK_EQUAL(s.size(), stack_string::size_type(1));
 249         BOOST_CHECK_GE(s.capacity(), s.size());
 250         BOOST_CHECK_EQUAL(s[0], fill);
 251 }
 252 
 253 BOOST_AUTO_TEST_CASE(insert_nullptr)
 254 {
 255         stack_string s1, s2;
 256         const stack_string::iterator i=s1.insert(s1.end(), s2.begin(), s2.begin());
 257         BOOST_CHECK(s1.empty());
 258         BOOST_CHECK_EQUAL(s1.size(), stack_string::size_type());
 259         BOOST_CHECK_EQUAL(i, s1.end());
 260 }
 261 
 262 BOOST_AUTO_TEST_CASE(erase)
 263 {
 264         stack_string s;
 265         const stack_string::iterator i=s.erase(s.begin(), s.end());
 266         BOOST_CHECK(s.empty());
 267         BOOST_CHECK_EQUAL(s.size(), stack_string::size_type());
 268         BOOST_CHECK_EQUAL(i, s.end());
 269 }
 270 
 271 BOOST_AUTO_TEST_CASE(replace_dest_empty)
 272 {
 273         stack_string s1, s2;
 274         s1.replace(s1.begin(), s1.begin(), s2.begin(), s2.end());
 275         BOOST_CHECK(s1.empty());
 276         BOOST_CHECK_EQUAL(s1.size(), stack_string::size_type());
 277 }
 278 
 279 BOOST_AUTO_TEST_CASE(replace_src_empty)
 280 {
 281         stack_string s1, s2;
 282         s1.replace(s1.begin(), s1.end(), s2.begin(), s2.begin());
 283         BOOST_CHECK(s1.empty());
 284         BOOST_CHECK_EQUAL(s1.size(), stack_string::size_type());
 285 }
 286 
 287 BOOST_AUTO_TEST_CASE(replace_both_empty)
 288 {
 289         stack_string s1, s2;
 290         s1.replace(s1.begin(), s1.begin(), s2.begin(), s2.begin());
 291         BOOST_CHECK(s1.empty());
 292         BOOST_CHECK_EQUAL(s1.size(), stack_string::size_type());
 293 }
 294 
 295 BOOST_AUTO_TEST_CASE(hash)
 296 {
 297         stack_string s;
 298         BOOST_CHECK_EQUAL(std::hash<stack_string>()(s), std::size_t());
 299 }
 300 
 301 BOOST_AUTO_TEST_CASE(insert)
 302 {
 303         stack_string s;
 304         std::stringstream ss;
 305         ss<<s;
 306         BOOST_CHECK_EQUAL(ss.str(), std::string(""));
 307 }
 308 
 309 BOOST_AUTO_TEST_CASE(extract)
 310 {
 311         stack_string s;
 312         std::stringstream ss;
 313         ss>>s;
 314         BOOST_CHECK(s.empty());
 315 }
 316 
 317 BOOST_AUTO_TEST_SUITE_END()
 318 
 319 BOOST_AUTO_TEST_SUITE_END()

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