libs/test/test/writing-test-ts/boost_check_equal-str-test.cpp

   1 //  (C) Copyright Gennadiy Rozental 2001-2015.
   2 //  Distributed under the Boost Software License, Version 1.0.
   3 //  (See accompanying file LICENSE_1_0.txt or copy at
   4 //  http://www.boost.org/LICENSE_1_0.txt)
   5
   6 //  See http://www.boost.org/libs/test for the library home page.
   7 //
   8 //  File        : $RCSfile$
   9 //
  10 //  Version     : $Revision$
  11 //
  12 //  Description : unit test for string comparison specializations
  13 // *****************************************************************************
  14
  15 #define BOOST_TEST_MAIN
  16 #include <boost/test/unit_test.hpp>
  17 #include <boost/test/utils/is_cstring.hpp>
  18
  19 BOOST_AUTO_TEST_CASE( check_is_cstring_concept )
  20 {
  21   namespace bp = boost::unit_test;
  22   BOOST_TEST((bp::is_cstring<char const*>::value));
  23   BOOST_TEST((bp::is_cstring<char const []>::value));
  24   BOOST_TEST((bp::is_cstring<char []>::value));
  25   BOOST_TEST((bp::is_cstring<char *>::value));
  26   BOOST_TEST((!bp::is_cstring<std::string>::value));
  27   BOOST_TEST((!bp::is_cstring< bp::basic_cstring<char> >::value));
  28
  29   BOOST_TEST((!bp::is_cstring< std::vector<char> >::value));
  30 }
  31
  32 #if defined(BOOST_TEST_STRING_VIEW)
  33 BOOST_AUTO_TEST_CASE( check_is_cstring_concept_string_view )
  34 {
  35   namespace bp = boost::unit_test;
  36   BOOST_TEST((!bp::is_cstring< std::string_view >::value));
  37 }
  38 #endif
  39
  40 BOOST_AUTO_TEST_CASE( check_is_cstring_comparable_concept )
  41 {
  42   namespace bp = boost::unit_test;
  43   BOOST_TEST((bp::is_cstring_comparable<char const*>::value));
  44   BOOST_TEST((bp::is_cstring_comparable<char const []>::value));
  45   BOOST_TEST((bp::is_cstring_comparable<char []>::value));
  46   BOOST_TEST((bp::is_cstring_comparable<char *>::value));
  47   BOOST_TEST((bp::is_cstring_comparable<std::string>::value));
  48   BOOST_TEST((bp::is_cstring_comparable< bp::basic_cstring<char> >::value));
  49
  50   BOOST_TEST((!bp::is_cstring_comparable< std::vector<char> >::value));
  51 }
  52
  53 #if defined(BOOST_TEST_STRING_VIEW)
  54 BOOST_AUTO_TEST_CASE( check_is_cstring_comparable_concept_string_view )
  55 {
  56   namespace bp = boost::unit_test;
  57   BOOST_TEST((bp::is_cstring_comparable< std::string_view >::value));
  58 }
  59 #endif
  60
  61 //____________________________________________________________________________//
  62
  63 BOOST_AUTO_TEST_CASE( check_string_compare )
  64 {
  65
  66     char const* buf_ptr_cch     = "0abc";
  67     char const  buf_array_cch[] = "1abc";
  68     char        buf_array_ch[]  = "2abc";
  69     char*       buf_ptr_ch      = buf_array_ch + 1;
  70     std::string buf_str         = "3abc";
  71
  72     buf_ptr_cch++;
  73     buf_str = buf_str.substr(1);
  74
  75     BOOST_TEST((void*)buf_ptr_cch != (void*)(buf_array_cch + 1));
  76     BOOST_TEST((void*)buf_ptr_cch != (void*)(buf_array_ch + 1));
  77     BOOST_TEST((void*)(buf_array_cch +1) != (void*)(buf_array_ch + 1));
  78
  79     BOOST_TEST(buf_ptr_cch == buf_ptr_cch);
  80 #ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
  81     BOOST_TEST(buf_ptr_cch == (buf_array_cch + 1));
  82     BOOST_TEST(buf_ptr_cch == (buf_array_ch + 1));
  83     BOOST_TEST(buf_ptr_cch == buf_ptr_ch);
  84     BOOST_TEST(buf_ptr_cch == buf_str);
  85 #endif
  86
  87 #ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
  88     BOOST_TEST((buf_array_cch + 1) == buf_ptr_cch);
  89     BOOST_TEST((buf_array_cch + 1) == (buf_array_cch + 1));
  90     BOOST_TEST((buf_array_cch + 1) == buf_ptr_ch);
  91     BOOST_TEST((buf_array_cch + 1) == (buf_array_ch + 1));
  92     BOOST_TEST((buf_array_cch + 1) == buf_str);
  93 #endif
  94
  95     BOOST_TEST(buf_ptr_ch == buf_ptr_ch);
  96 #ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
  97     BOOST_TEST(buf_ptr_ch == buf_ptr_cch);
  98     BOOST_TEST(buf_ptr_ch == (buf_array_cch + 1));
  99     BOOST_TEST(buf_ptr_ch == (buf_array_ch + 1));
 100     BOOST_TEST(buf_ptr_ch == buf_str);
 101 #endif
 102
 103 #ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
 104     BOOST_TEST((buf_array_ch + 1) == buf_ptr_cch);
 105     BOOST_TEST((buf_array_ch + 1) == (buf_array_cch + 1));
 106     BOOST_TEST((buf_array_ch + 1) == buf_ptr_ch);
 107     BOOST_TEST((buf_array_ch + 1) == (buf_array_ch + 1));
 108     BOOST_TEST((buf_array_ch + 1) == buf_str);
 109 #endif
 110
 111     BOOST_TEST(buf_str == buf_ptr_cch);
 112     BOOST_TEST(buf_str == (buf_array_cch + 1));
 113     BOOST_TEST(buf_str == buf_ptr_ch);
 114     BOOST_TEST(buf_str == (buf_array_ch + 1));
 115     BOOST_TEST(buf_str == buf_str);
 116
 117     BOOST_TEST(buf_ptr_cch == buf_str);
 118     //BOOST_TEST((buf_array_cch + 1) == buf_str); // does not compile
 119     BOOST_TEST(buf_ptr_ch == buf_str);
 120     //BOOST_TEST((buf_array_ch + 1) == buf_str); // does not compile
 121     BOOST_TEST(buf_str == buf_str);
 122
 123 #ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
 124     BOOST_TEST( buf_ptr_cch == buf_ptr_cch, boost::test_tools::per_element() );
 125     BOOST_TEST( buf_ptr_cch <= "abd" , boost::test_tools::per_element() );
 126     BOOST_TEST( buf_ptr_cch >= "aba" , boost::test_tools::per_element() );
 127     BOOST_TEST( buf_str == buf_ptr_cch , boost::test_tools::per_element() );
 128     BOOST_TEST( buf_str <= "abd" , boost::test_tools::per_element() );
 129     BOOST_TEST( buf_str >= "aba" , boost::test_tools::per_element() );
 130
 131     BOOST_TEST( buf_ptr_cch <= buf_ptr_cch, boost::test_tools::lexicographic() );
 132     BOOST_TEST( buf_ptr_cch >= buf_ptr_cch, boost::test_tools::lexicographic() );
 133     BOOST_TEST( buf_ptr_cch <= "abc" , boost::test_tools::lexicographic() );
 134     BOOST_TEST( buf_ptr_cch < "abd" , boost::test_tools::lexicographic() );
 135     BOOST_TEST( buf_ptr_cch < "abcd" , boost::test_tools::lexicographic() );
 136     BOOST_TEST( buf_ptr_cch >= "abc" , boost::test_tools::lexicographic() );
 137     BOOST_TEST( buf_ptr_cch > "aba" , boost::test_tools::lexicographic() );
 138     BOOST_TEST( buf_ptr_cch > "abad" , boost::test_tools::lexicographic() );
 139     BOOST_TEST( buf_str <= buf_ptr_cch , boost::test_tools::lexicographic() );
 140     BOOST_TEST( buf_str >= buf_ptr_cch , boost::test_tools::lexicographic() );
 141     BOOST_TEST( buf_str <= "abc" , boost::test_tools::lexicographic() );
 142     BOOST_TEST( buf_str < "abd" , boost::test_tools::lexicographic() );
 143     BOOST_TEST( buf_str > "aba" , boost::test_tools::lexicographic() );
 144 #endif
 145
 146 }
 147
 148 #if defined(BOOST_TEST_STRING_VIEW)
 149 BOOST_AUTO_TEST_CASE( check_string_view_compare )
 150 {
 151     namespace bp = boost::unit_test;
 152     using namespace std::literals;
 153
 154     std::string str = "str";
 155     std::string_view sv = "sv";
 156
 157     BOOST_TEST((!bp::is_cstring< decltype(sv) >::value));
 158
 159     BOOST_TEST_CHECK(str == str);
 160     BOOST_TEST_CHECK(sv == sv);
 161     BOOST_TEST_CHECK(str != sv);
 162     BOOST_TEST_CHECK(sv != str);
 163
 164     //  comparisons based on size
 165     BOOST_TEST_CHECK(str >= sv);
 166     BOOST_TEST_CHECK(sv <= str);
 167     BOOST_TEST_CHECK(str > sv);
 168     BOOST_TEST_CHECK(sv < str);
 169
 170     BOOST_TEST_CHECK(str <= sv, boost::test_tools::lexicographic());
 171     BOOST_TEST_CHECK(sv >= str, boost::test_tools::lexicographic());
 172     BOOST_TEST_CHECK(str < sv, boost::test_tools::lexicographic());
 173     BOOST_TEST_CHECK(sv > str, boost::test_tools::lexicographic());
 174
 175     std::string_view s1 = "this_is_string_view"sv;
 176     BOOST_TEST(s1 == s1);
 177     BOOST_TEST(s1 <= s1);
 178     BOOST_TEST(s1 >= s1);
 179     BOOST_TEST(s1 == "this_is_string_view"s);
 180
 181     BOOST_TEST(s1 <= "this_is_string_view2"sv);
 182
 183     // lexicographic compare
 184     BOOST_TEST_CHECK("str" <= sv, boost::test_tools::lexicographic());
 185     BOOST_TEST_CHECK(sv >= "str", boost::test_tools::lexicographic());
 186     BOOST_TEST_CHECK("str" < sv, boost::test_tools::lexicographic());
 187     BOOST_TEST_CHECK(sv > "str", boost::test_tools::lexicographic());
 188
 189     BOOST_TEST_CHECK("str"sv <= sv, boost::test_tools::lexicographic());
 190     BOOST_TEST_CHECK(sv >= "str"sv, boost::test_tools::lexicographic());
 191     BOOST_TEST_CHECK("str"sv < sv, boost::test_tools::lexicographic());
 192     BOOST_TEST_CHECK(sv > "str"sv, boost::test_tools::lexicographic());
 193
 194     // per element, left-right operand
 195     BOOST_TEST( "sv" <= sv , boost::test_tools::per_element() );
 196     BOOST_TEST( "sv" >= sv , boost::test_tools::per_element() );
 197     BOOST_TEST( "sv" == sv , boost::test_tools::per_element() );
 198
 199     BOOST_TEST( sv <= "sv" , boost::test_tools::per_element() );
 200     BOOST_TEST( sv >= "sv" , boost::test_tools::per_element() );
 201     BOOST_TEST( sv == "sv" , boost::test_tools::per_element() );
 202
 203     BOOST_TEST( "rv" <= sv , boost::test_tools::per_element() );
 204     BOOST_TEST( "tv" >= sv , boost::test_tools::per_element() );
 205     BOOST_TEST( "tw" != sv , boost::test_tools::per_element() );
 206
 207     BOOST_TEST( sv <= "tv" , boost::test_tools::per_element() );
 208     BOOST_TEST( sv >= "rv" , boost::test_tools::per_element() );
 209     BOOST_TEST( sv != "ru" , boost::test_tools::per_element() );
 210
 211 }
 212 #endif
 213
 214 // EOF