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