contrib/atf/atf-c++/detail/text_test.cpp

   1 // Copyright (c) 2007 The NetBSD Foundation, Inc.
   2 // All rights reserved.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions
   6 // are met:
   7 // 1. Redistributions of source code must retain the above copyright
   8 //    notice, this list of conditions and the following disclaimer.
   9 // 2. Redistributions in binary form must reproduce the above copyright
  10 //    notice, this list of conditions and the following disclaimer in the
  11 //    documentation and/or other materials provided with the distribution.
  12 //
  13 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  14 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  15 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  16 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  18 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  20 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  22 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  24 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25
  26 #include "atf-c++/detail/text.hpp"
  27
  28 #include <cstring>
  29 #include <set>
  30 #include <vector>
  31
  32 #include <atf-c++.hpp>
  33
  34 // ------------------------------------------------------------------------
  35 // Test cases for the free functions.
  36 // ------------------------------------------------------------------------
  37
  38 ATF_TEST_CASE(duplicate);
  39 ATF_TEST_CASE_HEAD(duplicate)
  40 {
  41     set_md_var("descr", "Tests the duplicate function");
  42 }
  43 ATF_TEST_CASE_BODY(duplicate)
  44 {
  45     using atf::text::duplicate;
  46
  47     const char* orig = "foo";
  48
  49     char* copy = duplicate(orig);
  50     ATF_REQUIRE_EQ(std::strlen(copy), 3);
  51     ATF_REQUIRE(std::strcmp(copy, "foo") == 0);
  52
  53     std::strcpy(copy, "bar");
  54     ATF_REQUIRE(std::strcmp(copy, "bar") == 0);
  55     ATF_REQUIRE(std::strcmp(orig, "foo") == 0);
  56 }
  57
  58 ATF_TEST_CASE(join);
  59 ATF_TEST_CASE_HEAD(join)
  60 {
  61     set_md_var("descr", "Tests the join function");
  62 }
  63 ATF_TEST_CASE_BODY(join)
  64 {
  65     using atf::text::join;
  66
  67     // First set of tests using a non-sorted collection, std::vector.
  68     {
  69         std::vector< std::string > words;
  70         std::string str;
  71
  72         words.clear();
  73         str = join(words, ",");
  74         ATF_REQUIRE_EQ(str, "");
  75
  76         words.clear();
  77         words.push_back("");
  78         str = join(words, ",");
  79         ATF_REQUIRE_EQ(str, "");
  80
  81         words.clear();
  82         words.push_back("");
  83         words.push_back("");
  84         str = join(words, ",");
  85         ATF_REQUIRE_EQ(str, ",");
  86
  87         words.clear();
  88         words.push_back("foo");
  89         words.push_back("");
  90         words.push_back("baz");
  91         str = join(words, ",");
  92         ATF_REQUIRE_EQ(str, "foo,,baz");
  93
  94         words.clear();
  95         words.push_back("foo");
  96         words.push_back("bar");
  97         words.push_back("baz");
  98         str = join(words, ",");
  99         ATF_REQUIRE_EQ(str, "foo,bar,baz");
 100     }
 101
 102     // Second set of tests using a sorted collection, std::set.
 103     {
 104         std::set< std::string > words;
 105         std::string str;
 106
 107         words.clear();
 108         str = join(words, ",");
 109         ATF_REQUIRE_EQ(str, "");
 110
 111         words.clear();
 112         words.insert("");
 113         str = join(words, ",");
 114         ATF_REQUIRE_EQ(str, "");
 115
 116         words.clear();
 117         words.insert("foo");
 118         words.insert("");
 119         words.insert("baz");
 120         str = join(words, ",");
 121         ATF_REQUIRE_EQ(str, ",baz,foo");
 122
 123         words.clear();
 124         words.insert("foo");
 125         words.insert("bar");
 126         words.insert("baz");
 127         str = join(words, ",");
 128         ATF_REQUIRE_EQ(str, "bar,baz,foo");
 129     }
 130 }
 131
 132 ATF_TEST_CASE(match);
 133 ATF_TEST_CASE_HEAD(match)
 134 {
 135     set_md_var("descr", "Tests the match function");
 136 }
 137 ATF_TEST_CASE_BODY(match)
 138 {
 139     using atf::text::match;
 140
 141     ATF_REQUIRE_THROW(std::runtime_error, match("", "["));
 142
 143     ATF_REQUIRE(match("", ""));
 144     ATF_REQUIRE(!match("foo", ""));
 145
 146     ATF_REQUIRE(match("", ".*"));
 147     ATF_REQUIRE(match("", "[a-z]*"));
 148
 149     ATF_REQUIRE(match("hello", "hello"));
 150     ATF_REQUIRE(match("hello", "[a-z]+"));
 151     ATF_REQUIRE(match("hello", "^[a-z]+$"));
 152
 153     ATF_REQUIRE(!match("hello", "helooo"));
 154     ATF_REQUIRE(!match("hello", "[a-z]+5"));
 155     ATF_REQUIRE(!match("hello", "^ [a-z]+$"));
 156 }
 157
 158 ATF_TEST_CASE(split);
 159 ATF_TEST_CASE_HEAD(split)
 160 {
 161     set_md_var("descr", "Tests the split function");
 162 }
 163 ATF_TEST_CASE_BODY(split)
 164 {
 165     using atf::text::split;
 166
 167     std::vector< std::string > words;
 168
 169     words = split("", " ");
 170     ATF_REQUIRE_EQ(words.size(), 0);
 171
 172     words = split(" ", " ");
 173     ATF_REQUIRE_EQ(words.size(), 0);
 174
 175     words = split("    ", " ");
 176     ATF_REQUIRE_EQ(words.size(), 0);
 177
 178     words = split("a b", " ");
 179     ATF_REQUIRE_EQ(words.size(), 2);
 180     ATF_REQUIRE_EQ(words[0], "a");
 181     ATF_REQUIRE_EQ(words[1], "b");
 182
 183     words = split("a b c d", " ");
 184     ATF_REQUIRE_EQ(words.size(), 4);
 185     ATF_REQUIRE_EQ(words[0], "a");
 186     ATF_REQUIRE_EQ(words[1], "b");
 187     ATF_REQUIRE_EQ(words[2], "c");
 188     ATF_REQUIRE_EQ(words[3], "d");
 189
 190     words = split("foo bar", " ");
 191     ATF_REQUIRE_EQ(words.size(), 2);
 192     ATF_REQUIRE_EQ(words[0], "foo");
 193     ATF_REQUIRE_EQ(words[1], "bar");
 194
 195     words = split("foo bar baz foobar", " ");
 196     ATF_REQUIRE_EQ(words.size(), 4);
 197     ATF_REQUIRE_EQ(words[0], "foo");
 198     ATF_REQUIRE_EQ(words[1], "bar");
 199     ATF_REQUIRE_EQ(words[2], "baz");
 200     ATF_REQUIRE_EQ(words[3], "foobar");
 201
 202     words = split(" foo bar", " ");
 203     ATF_REQUIRE_EQ(words.size(), 2);
 204     ATF_REQUIRE_EQ(words[0], "foo");
 205     ATF_REQUIRE_EQ(words[1], "bar");
 206
 207     words = split("foo  bar", " ");
 208     ATF_REQUIRE_EQ(words.size(), 2);
 209     ATF_REQUIRE_EQ(words[0], "foo");
 210     ATF_REQUIRE_EQ(words[1], "bar");
 211
 212     words = split("foo bar ", " ");
 213     ATF_REQUIRE_EQ(words.size(), 2);
 214     ATF_REQUIRE_EQ(words[0], "foo");
 215     ATF_REQUIRE_EQ(words[1], "bar");
 216
 217     words = split("  foo  bar  ", " ");
 218     ATF_REQUIRE_EQ(words.size(), 2);
 219     ATF_REQUIRE_EQ(words[0], "foo");
 220     ATF_REQUIRE_EQ(words[1], "bar");
 221 }
 222
 223 ATF_TEST_CASE(split_delims);
 224 ATF_TEST_CASE_HEAD(split_delims)
 225 {
 226     set_md_var("descr", "Tests the split function using different delimiters");
 227 }
 228 ATF_TEST_CASE_BODY(split_delims)
 229 {
 230     using atf::text::split;
 231
 232     std::vector< std::string > words;
 233
 234     words = split("", "/");
 235     ATF_REQUIRE_EQ(words.size(), 0);
 236
 237     words = split(" ", "/");
 238     ATF_REQUIRE_EQ(words.size(), 1);
 239     ATF_REQUIRE_EQ(words[0], " ");
 240
 241     words = split("    ", "/");
 242     ATF_REQUIRE_EQ(words.size(), 1);
 243     ATF_REQUIRE_EQ(words[0], "    ");
 244
 245     words = split("a/b", "/");
 246     ATF_REQUIRE_EQ(words.size(), 2);
 247     ATF_REQUIRE_EQ(words[0], "a");
 248     ATF_REQUIRE_EQ(words[1], "b");
 249
 250     words = split("aLONGDELIMbcdLONGDELIMef", "LONGDELIM");
 251     ATF_REQUIRE_EQ(words.size(), 3);
 252     ATF_REQUIRE_EQ(words[0], "a");
 253     ATF_REQUIRE_EQ(words[1], "bcd");
 254     ATF_REQUIRE_EQ(words[2], "ef");
 255 }
 256
 257 ATF_TEST_CASE(trim);
 258 ATF_TEST_CASE_HEAD(trim)
 259 {
 260     set_md_var("descr", "Tests the trim function");
 261 }
 262 ATF_TEST_CASE_BODY(trim)
 263 {
 264     using atf::text::trim;
 265
 266     ATF_REQUIRE_EQ(trim(""), "");
 267     ATF_REQUIRE_EQ(trim(" "), "");
 268     ATF_REQUIRE_EQ(trim("\t"), "");
 269
 270     ATF_REQUIRE_EQ(trim(" foo"), "foo");
 271     ATF_REQUIRE_EQ(trim("\t foo"), "foo");
 272     ATF_REQUIRE_EQ(trim(" \tfoo"), "foo");
 273     ATF_REQUIRE_EQ(trim("foo\t "), "foo");
 274     ATF_REQUIRE_EQ(trim("foo \t"), "foo");
 275
 276     ATF_REQUIRE_EQ(trim("foo bar"), "foo bar");
 277     ATF_REQUIRE_EQ(trim("\t foo bar"), "foo bar");
 278     ATF_REQUIRE_EQ(trim(" \tfoo bar"), "foo bar");
 279     ATF_REQUIRE_EQ(trim("foo bar\t "), "foo bar");
 280     ATF_REQUIRE_EQ(trim("foo bar \t"), "foo bar");
 281 }
 282
 283 ATF_TEST_CASE(to_bool);
 284 ATF_TEST_CASE_HEAD(to_bool)
 285 {
 286     set_md_var("descr", "Tests the to_string function");
 287 }
 288 ATF_TEST_CASE_BODY(to_bool)
 289 {
 290     using atf::text::to_bool;
 291
 292     ATF_REQUIRE(to_bool("true"));
 293     ATF_REQUIRE(to_bool("TRUE"));
 294     ATF_REQUIRE(to_bool("yes"));
 295     ATF_REQUIRE(to_bool("YES"));
 296
 297     ATF_REQUIRE(!to_bool("false"));
 298     ATF_REQUIRE(!to_bool("FALSE"));
 299     ATF_REQUIRE(!to_bool("no"));
 300     ATF_REQUIRE(!to_bool("NO"));
 301
 302     ATF_REQUIRE_THROW(std::runtime_error, to_bool(""));
 303     ATF_REQUIRE_THROW(std::runtime_error, to_bool("tru"));
 304     ATF_REQUIRE_THROW(std::runtime_error, to_bool("true2"));
 305     ATF_REQUIRE_THROW(std::runtime_error, to_bool("fals"));
 306     ATF_REQUIRE_THROW(std::runtime_error, to_bool("false2"));
 307 }
 308
 309 ATF_TEST_CASE(to_bytes);
 310 ATF_TEST_CASE_HEAD(to_bytes)
 311 {
 312     set_md_var("descr", "Tests the to_bytes function");
 313 }
 314 ATF_TEST_CASE_BODY(to_bytes)
 315 {
 316     using atf::text::to_bytes;
 317
 318     ATF_REQUIRE_EQ(0, to_bytes("0"));
 319     ATF_REQUIRE_EQ(12345, to_bytes("12345"));
 320     ATF_REQUIRE_EQ(2 * 1024, to_bytes("2k"));
 321     ATF_REQUIRE_EQ(4 * 1024 * 1024, to_bytes("4m"));
 322     ATF_REQUIRE_EQ(int64_t(8) * 1024 * 1024 * 1024, to_bytes("8g"));
 323     ATF_REQUIRE_EQ(int64_t(16) * 1024 * 1024 * 1024 * 1024, to_bytes("16t"));
 324
 325     ATF_REQUIRE_THROW_RE(std::runtime_error, "Empty", to_bytes(""));
 326     ATF_REQUIRE_THROW_RE(std::runtime_error, "Unknown size unit 'd'",
 327                          to_bytes("12d"));
 328     ATF_REQUIRE_THROW(std::runtime_error, to_bytes(" "));
 329     ATF_REQUIRE_THROW(std::runtime_error, to_bytes(" k"));
 330 }
 331
 332 ATF_TEST_CASE(to_string);
 333 ATF_TEST_CASE_HEAD(to_string)
 334 {
 335     set_md_var("descr", "Tests the to_string function");
 336 }
 337 ATF_TEST_CASE_BODY(to_string)
 338 {
 339     using atf::text::to_string;
 340
 341     ATF_REQUIRE_EQ(to_string('a'), "a");
 342     ATF_REQUIRE_EQ(to_string("a"), "a");
 343     ATF_REQUIRE_EQ(to_string(5), "5");
 344 }
 345
 346 ATF_TEST_CASE(to_type);
 347 ATF_TEST_CASE_HEAD(to_type)
 348 {
 349     set_md_var("descr", "Tests the to_type function");
 350 }
 351 ATF_TEST_CASE_BODY(to_type)
 352 {
 353     using atf::text::to_type;
 354
 355     ATF_REQUIRE_EQ(to_type< int >("0"), 0);
 356     ATF_REQUIRE_EQ(to_type< int >("1234"), 1234);
 357     ATF_REQUIRE_THROW(std::runtime_error, to_type< int >("   "));
 358     ATF_REQUIRE_THROW(std::runtime_error, to_type< int >("0 a"));
 359     ATF_REQUIRE_THROW(std::runtime_error, to_type< int >("a"));
 360
 361     ATF_REQUIRE_EQ(to_type< float >("0.5"), 0.5);
 362     ATF_REQUIRE_EQ(to_type< float >("1234.5"), 1234.5);
 363     ATF_REQUIRE_THROW(std::runtime_error, to_type< float >("0.5 a"));
 364     ATF_REQUIRE_THROW(std::runtime_error, to_type< float >("a"));
 365
 366     ATF_REQUIRE_EQ(to_type< std::string >("a"), "a");
 367 }
 368
 369 // ------------------------------------------------------------------------
 370 // Main.
 371 // ------------------------------------------------------------------------
 372
 373 ATF_INIT_TEST_CASES(tcs)
 374 {
 375     // Add the test cases for the free functions.
 376     ATF_ADD_TEST_CASE(tcs, duplicate);
 377     ATF_ADD_TEST_CASE(tcs, join);
 378     ATF_ADD_TEST_CASE(tcs, match);
 379     ATF_ADD_TEST_CASE(tcs, split);
 380     ATF_ADD_TEST_CASE(tcs, split_delims);
 381     ATF_ADD_TEST_CASE(tcs, trim);
 382     ATF_ADD_TEST_CASE(tcs, to_bool);
 383     ATF_ADD_TEST_CASE(tcs, to_bytes);
 384     ATF_ADD_TEST_CASE(tcs, to_string);
 385     ATF_ADD_TEST_CASE(tcs, to_type);
 386 }