Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/diag/UnitTestString.cpp

raw
1 // Copyright 2002 - 2008, 2010, 2011 National Technology Engineering
2 // Solutions of Sandia, LLC (NTESS). Under the terms of Contract
3 // DE-NA0003525 with NTESS, the U.S. Government retains certain rights
4 // in this software.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
8 // met:
9 //
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 //
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following
15 // disclaimer in the documentation and/or other materials provided
16 // with the distribution.
17 //
18 // * Neither the name of NTESS nor the names of its contributors
19 // may be used to endorse or promote products derived from this
20 // software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 //
34
35 #include "gtest/gtest.h"
36 #include "stk_util/diag/String.hpp" // for String, operator==, StringBase
37 #include "stk_util/diag/StringUtil.hpp" // for case_strcmp
38 #include <string> // for string
39
40 TEST(StkString, case_insensitivity)
41 {
42 sierra::String ABC("ABC");
43 sierra::String abc("abc");
44 bool strings_match_by_case_insensitivity = ABC == abc;
45 EXPECT_TRUE(strings_match_by_case_insensitivity);
46 }
47
48 TEST(StkString, case_sensitive_comparison_with_sierra_string)
49 {
50 sierra::String ABC("ABC");
51 sierra::String abc("abc");
52 bool strings_do_not_match = sierra::case_strcmp(ABC, abc);
53 EXPECT_FALSE(strings_do_not_match);
54 }
55
56 TEST(StkString, case_sensitive_comparison_with_std_string)
57 {
58 std::string ABC("ABC");
59 std::string abc("abc");
60 bool strings_do_not_match = sierra::case_strcmp(ABC, abc);
61 EXPECT_FALSE(strings_do_not_match);
62 }
63
64 namespace
65 {
66 class TestClass
67 {
68 public:
69 TestClass() = default;
70
71 const sierra::String str_member;
72 };
73 } // namespace
74
75 TEST(StkString, default_constructible)
76 {
77 sierra::String s;
78 EXPECT_TRUE(s.empty());
79
80 sierra::StringBase<sierra::char_label_traits> s_label;
81 EXPECT_TRUE(s_label.empty());
82
83 // If we change the default constructor to "StringBase() = default" this fails to compile unfortunately
84 TestClass d;
85 EXPECT_TRUE(d.str_member.empty());
86 }
87
88 TEST(StkString, char_label_traits_append)
89 {
90 sierra::StringBase<sierra::char_label_traits> s_label;
91
92 s_label.append("abc", 3);
93 EXPECT_EQ("abc", s_label.s_str());
94
95 s_label.append("def");
96 EXPECT_EQ("abc_def", s_label.s_str());
97 }
98
99 TEST(StkJoinString, emptyContainer)
100 {
101 const std::set<sierra::String> emptyVect;
102 EXPECT_EQ("", stk::util::join(emptyVect, ", "));
103 }
104
105 TEST(StkJoinString, emptyIterRange)
106 {
107 const std::set<sierra::String> emptyVect;
108 EXPECT_EQ("", stk::util::join(emptyVect.begin(), emptyVect.end(), ", "));
109 }
110
111 TEST(StkJoinString, containerContents)
112 {
113 const std::vector<sierra::String> theVect{"a", "b", "c"};
114 EXPECT_EQ("a, b, c", stk::util::join(theVect, ", "));
115 }
116
117 TEST(StkJoinString, iterRangeContents)
118 {
119 const std::vector<sierra::String> theVect{"a", "b", "c"};
120 EXPECT_EQ("a, b, c", stk::util::join(theVect.begin(), theVect.end(), ", "));
121 }
122
123 TEST(StkJoinString, containerNonString)
124 {
125 const std::vector<int> theVect{0, 1, 2};
126 EXPECT_EQ("0, 1, 2", stk::util::join(theVect, ", "));
127 }
128
129 TEST(StkJoinString, iterRangeNonString)
130 {
131 const std::vector<int> theVect{0, 1, 2};
132 EXPECT_EQ("0, 1, 2", stk::util::join(theVect.begin(), theVect.end(), ", "));
133 }
134
135 TEST(StkConstructString, fromConstCharPtr)
136 {
137 const char * const str = "test message";
138 const sierra::String sierra_str{str};
139 EXPECT_EQ(str, sierra_str);
140 }
141
142 TEST(StkConstructString, fromNullPtr)
143 {
144 const char * const str = nullptr;
145 const sierra::String sierra_str{str};
146 EXPECT_TRUE(sierra_str.empty());
147 }
148
149 TEST(StkConstructString, fromStdString)
150 {
151 const std::string str = "test message";
152 const sierra::String sierra_str{str};
153 EXPECT_EQ(str, sierra_str);
154 }
155
156 TEST(StkConstructString, fromStringLiteral)
157 {
158 const std::string str = "test message";
159 const sierra::String sierra_str{"test message"};
160 EXPECT_EQ(str, sierra_str);
161 }
162
163 TEST(StkConstructString, fromTemporaryStdString)
164 {
165 const std::string str = "test message";
166 const sierra::String sierra_str{std::string("test message")};
167 EXPECT_EQ(str, sierra_str);
168 }
169
170 TEST(StkConstructString, fromStdStringView)
171 {
172 const std::string_view str = "test message";
173 const sierra::String sierra_str{str};
174 EXPECT_EQ(sierra::String(str), sierra_str);
175 }
176
177 TEST(StkAssignString, fromConstCharPtr)
178 {
179 const char * const str = "test message";
180 sierra::String sierra_str;
181 sierra_str.assign(str);
182 EXPECT_EQ(str, sierra_str);
183 }
184
185 TEST(StkAssignString, fromNullPtr)
186 {
187 const char * const str = nullptr;
188 sierra::String sierra_str;
189 sierra_str.assign(str);
190 EXPECT_TRUE(sierra_str.empty());
191 }
192
193 TEST(StkAssignString, fromStdString)
194 {
195 const std::string str = "test message";
196 sierra::String sierra_str;
197 sierra_str.assign(str);
198 EXPECT_EQ(str, sierra_str);
199 }
200
201 namespace {
202 sierra::String func_taking_sierra_string(const sierra::String & sierra_str)
203 {
204 return sierra_str;
205 }
206 }
207
208 // Note, following two require non explicit converting constructor for StringViewLike -> StringBase
209 // I think we should deprecate this behavior.
210 TEST(StkString, canCallSierraStringFunctionWithStandardString)
211 {
212 const std::string str = "test message";
213
214 const sierra::String sierra_str = func_taking_sierra_string(str);
215 EXPECT_EQ(str, sierra_str);
216 }
217
218 TEST(StkString, canCallSierraStringFunctionWithStringView)
219 {
220 const std::string_view str = "test message";
221
222 //explicit conversion from string view
223 const sierra::String sierra_str = func_taking_sierra_string(sierra::String(str));
224 EXPECT_EQ(sierra::String(str), sierra_str);
225 }
226
227 TEST(StkAssignToString, fromStdStringView)
228 {
229 const std::string_view str = "test message";
230 sierra::String sierra_str;
231 sierra_str = str;
232 EXPECT_EQ(sierra::String(str), sierra_str);
233 }
234
235 TEST(StkAssignToString, fromStdString)
236 {
237 const std::string str = "test message";
238 sierra::String sierra_str;
239 sierra_str = str;
240 EXPECT_EQ(sierra::String(str), sierra_str);
241 }
242
243 TEST(StkAssignToString, fromConstCharPtr)
244 {
245 const char * str = "test message";
246 sierra::String sierra_str;
247 sierra_str = str;
248 EXPECT_EQ(sierra::String(str), sierra_str);
249 }
250
251 TEST(StkAssignToString, fromNullPtr)
252 {
253 const char * str = nullptr;
254 sierra::String sierra_str;
255 sierra_str = str;
256 EXPECT_EQ(sierra::String(), sierra_str);
257 }
258
259 TEST(StkAppendToString, fromStdStringView)
260 {
261 const std::string_view str = "test message";
262 sierra::String sierra_str{"first: "};
263 sierra_str.append(str);
264 EXPECT_EQ(sierra::String("first: test message"), sierra_str);
265 }
266
267 TEST(StkAppendToString, fromStdString)
268 {
269 const std::string str = "test message";
270 sierra::String sierra_str{"first: "};
271 sierra_str.append(str);
272 EXPECT_EQ(sierra::String("first: test message"), sierra_str);
273 }
274
275 TEST(StkAppendToString, fromConstCharPtr)
276 {
277 const char * str = "test message";
278 sierra::String sierra_str{"first: "};
279 sierra_str.append(str);
280 EXPECT_EQ(sierra::String("first: test message"), sierra_str);
281 }
282
283 TEST(StkOperatorPlusEqToString, fromStdStringView)
284 {
285 const std::string_view str = "test message";
286 sierra::String sierra_str{"first: "};
287 sierra_str += str;
288 EXPECT_EQ(sierra::String("first: test message"), sierra_str);
289 }
290
291 TEST(StkOperatorPlusEqToString, fromStdString)
292 {
293 const std::string str = "test message";
294 sierra::String sierra_str{"first: "};
295 sierra_str += str;
296 EXPECT_EQ(sierra::String("first: test message"), sierra_str);
297 }
298
299 TEST(StkOperatorPlusEqToString, fromConstCharPtr)
300 {
301 const char * str = "test message";
302 sierra::String sierra_str{"first: "};
303 sierra_str += str;
304 EXPECT_EQ(sierra::String("first: test message"), sierra_str);
305 }
306
307 TEST(StkStringComparison, equalStrings)
308 {
309 sierra::String str_1{"abcdefg"};
310 sierra::String str_2{"AbcdEfg"};
311 EXPECT_TRUE(str_1 == str_2);
312 EXPECT_TRUE(str_1 <= str_2);
313 EXPECT_TRUE(str_1 >= str_2);
314 EXPECT_FALSE(str_1 < str_2);
315 EXPECT_FALSE(str_1 > str_2);
316 EXPECT_FALSE(str_1 != str_2);
317 }
318
319 using SierraStd = std::pair<sierra::String, std::string>;
320 using StdSierra = std::pair<std::string, sierra::String>;
321 using CharSierra = std::pair<const char *, sierra::String>;
322 using SierraChar = std::pair<sierra::String, const char *>;
323 using StringViewSierra = std::pair<std::string_view, sierra::String>;
324 using SierraStringView = std::pair<sierra::String, std::string_view>;
325
326 template <typename T>
327 class StringTypePairFixture : public testing::Test
328 {
329 public:
330 using Type = T;
331 };
332
333 typedef ::testing::Types<SierraStd, StdSierra, CharSierra, SierraChar, StringViewSierra, SierraStringView> MyTypes;
334 TYPED_TEST_SUITE(StringTypePairFixture, MyTypes,);
335 TYPED_TEST(StringTypePairFixture, str1LessThanStr2ByLength)
336 {
337 typename TypeParam::first_type str_1{"abcdef"};
338 typename TypeParam::second_type str_2{"AbcdEfg"};
339 EXPECT_FALSE(str_1 == str_2);
340 EXPECT_TRUE(str_1 <= str_2);
341 EXPECT_FALSE(str_1 >= str_2);
342 EXPECT_TRUE(str_1 < str_2);
343 EXPECT_FALSE(str_1 > str_2);
344 EXPECT_TRUE(str_1 != str_2);
345 }
346
347 TYPED_TEST(StringTypePairFixture, str1LessThanStr2ByCharacter)
348 {
349 typename TypeParam::first_type str_1{"abbdefg"};
350 typename TypeParam::second_type str_2{"AbcdEfg"};
351 EXPECT_FALSE(str_1 == str_2);
352 EXPECT_TRUE(str_1 <= str_2);
353 EXPECT_FALSE(str_1 >= str_2);
354 EXPECT_TRUE(str_1 < str_2);
355 EXPECT_FALSE(str_1 > str_2);
356 EXPECT_TRUE(str_1 != str_2);
357 }
358
359
360 TYPED_TEST(StringTypePairFixture, str1GreaterThanStr2)
361 {
362 typename TypeParam::first_type str_1{"AbcdEfg"};
363 typename TypeParam::second_type str_2{"abcdef"};
364 EXPECT_FALSE(str_1 == str_2);
365 EXPECT_FALSE(str_1 <= str_2);
366 EXPECT_TRUE(str_1 >= str_2);
367 EXPECT_FALSE(str_1 < str_2);
368 EXPECT_TRUE(str_1 > str_2);
369 EXPECT_TRUE(str_1 != str_2);
370 }
371
372 TYPED_TEST(StringTypePairFixture, operatorPlus)
373 {
374 typename TypeParam::first_type str_1{"oNe string, "};
375 typename TypeParam::second_type str_2{"two string"};
376 const sierra::String expected{"ONE STRING, TWO STRING"};
377 EXPECT_EQ(expected, str_1 + str_2);
378 }
379
380 TEST(StkStringComparison, equalIdentifiers)
381 {
382 sierra::Identifier str_1{"abc defg"};
383 sierra::Identifier str_2{"Abc_dEfg"};
384 EXPECT_TRUE(str_1 == str_2);
385 EXPECT_TRUE(str_1 <= str_2);
386 EXPECT_TRUE(str_1 >= str_2);
387 EXPECT_FALSE(str_1 < str_2);
388 EXPECT_FALSE(str_1 > str_2);
389 EXPECT_FALSE(str_1 != str_2);
390 }
391
392 TEST(StkStringComparison, compareWithNullPtr)
393 {
394 sierra::Identifier str_1{"abc defg"};
395 const char * str_2 = nullptr;
396 EXPECT_EQ(-1, str_1.compare(str_2));
397 }
398
399 TEST(StkStringComparison, compareEmptyWithNull)
400 {
401 sierra::Identifier str_1{};
402 const char * str_2 = nullptr;
403 EXPECT_EQ(0, str_1.compare(str_2));
404 }
405
406 namespace {
407 sierra::Identifier func_taking_sierra_identifier(const sierra::Identifier & identifier)
408 {
409 return identifier;
410 }
411 }
412
413 TEST(StkStringIdentfierConversions, equalIdentifiers)
414 {
415 sierra::String identifier_to_string_construction(sierra::Identifier("test"));
416 sierra::String string_to_identifier_construction(sierra::String("test"));
417
418 //test implicit move conversions -- future work to deprecate these
419 func_taking_sierra_string(sierra::Identifier("test"));
420 func_taking_sierra_identifier(sierra::String("test"));
421
422 //test implicit copy conversions -- future work to deprecate these
423 const sierra::Identifier sierra_identifier("test");
424 const sierra::String sierra_string("test");
425 func_taking_sierra_string(sierra_identifier);
426 func_taking_sierra_identifier(sierra_string);
427
428 //shouldbe nondeprecated versions
429 func_taking_sierra_string(sierra::String(sierra_identifier));
430 func_taking_sierra_identifier(sierra::Identifier(sierra_string));
431
432 std::string_view test = std::string_view(sierra_string);
433 test = "";
434 }