[ceph.git] / ceph / src / boost / libs / test / test / writing-test-ts / boost_check_equal-str-test.cpp

//  (C) Copyright Gennadiy Rozental 2001-2015.
//  Distributed under the Boost Software License, Version 1.0.
//  (See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org/libs/test for the library home page.
//
//  File        : $RCSfile$
//
//  Version     : $Revision$
//
//  Description : unit test for string comparison specializations
// *****************************************************************************

#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <boost/test/utils/is_cstring.hpp>

BOOST_AUTO_TEST_CASE( check_is_cstring_concept )
{
  namespace bp = boost::unit_test;
  BOOST_TEST((bp::is_cstring<char const*>::value));
  BOOST_TEST((bp::is_cstring<char const []>::value));
  BOOST_TEST((bp::is_cstring<char []>::value));
  BOOST_TEST((bp::is_cstring<char *>::value));
  BOOST_TEST((!bp::is_cstring<std::string>::value));
  BOOST_TEST((!bp::is_cstring< bp::basic_cstring<char> >::value));

  BOOST_TEST((!bp::is_cstring< std::vector<char> >::value));
}

#if defined(BOOST_TEST_STRING_VIEW)
BOOST_AUTO_TEST_CASE( check_is_cstring_concept_string_view )
{
  namespace bp = boost::unit_test;
  BOOST_TEST((!bp::is_cstring< std::string_view >::value));
}
#endif

BOOST_AUTO_TEST_CASE( check_is_cstring_comparable_concept )
{
  namespace bp = boost::unit_test;
  BOOST_TEST((bp::is_cstring_comparable<char const*>::value));
  BOOST_TEST((bp::is_cstring_comparable<char const []>::value));
  BOOST_TEST((bp::is_cstring_comparable<char []>::value));
  BOOST_TEST((bp::is_cstring_comparable<char *>::value));
  BOOST_TEST((bp::is_cstring_comparable<std::string>::value));
  BOOST_TEST((bp::is_cstring_comparable< bp::basic_cstring<char> >::value));

  BOOST_TEST((!bp::is_cstring_comparable< std::vector<char> >::value));
}

#if defined(BOOST_TEST_STRING_VIEW)
BOOST_AUTO_TEST_CASE( check_is_cstring_comparable_concept_string_view )
{
  namespace bp = boost::unit_test;
  BOOST_TEST((bp::is_cstring_comparable< std::string_view >::value));
}
#endif

//____________________________________________________________________________//

BOOST_AUTO_TEST_CASE( check_string_compare )
{

    char const* buf_ptr_cch     = "0abc";
    char const  buf_array_cch[] = "1abc";
    char        buf_array_ch[]  = "2abc";
    char*       buf_ptr_ch      = buf_array_ch + 1;
    std::string buf_str         = "3abc";

    buf_ptr_cch++;
    buf_str = buf_str.substr(1);

    BOOST_TEST((void*)buf_ptr_cch != (void*)(buf_array_cch + 1));
    BOOST_TEST((void*)buf_ptr_cch != (void*)(buf_array_ch + 1));
    BOOST_TEST((void*)(buf_array_cch +1) != (void*)(buf_array_ch + 1));

    BOOST_TEST(buf_ptr_cch == buf_ptr_cch);
#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
    BOOST_TEST(buf_ptr_cch == (buf_array_cch + 1));
    BOOST_TEST(buf_ptr_cch == (buf_array_ch + 1));
    BOOST_TEST(buf_ptr_cch == buf_ptr_ch);
    BOOST_TEST(buf_ptr_cch == buf_str);
#endif

#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
    BOOST_TEST((buf_array_cch + 1) == buf_ptr_cch);
    BOOST_TEST((buf_array_cch + 1) == (buf_array_cch + 1));
    BOOST_TEST((buf_array_cch + 1) == buf_ptr_ch);
    BOOST_TEST((buf_array_cch + 1) == (buf_array_ch + 1));
    BOOST_TEST((buf_array_cch + 1) == buf_str);
#endif

    BOOST_TEST(buf_ptr_ch == buf_ptr_ch);
#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
    BOOST_TEST(buf_ptr_ch == buf_ptr_cch);
    BOOST_TEST(buf_ptr_ch == (buf_array_cch + 1));
    BOOST_TEST(buf_ptr_ch == (buf_array_ch + 1));
    BOOST_TEST(buf_ptr_ch == buf_str);
#endif

#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
    BOOST_TEST((buf_array_ch + 1) == buf_ptr_cch);
    BOOST_TEST((buf_array_ch + 1) == (buf_array_cch + 1));
    BOOST_TEST((buf_array_ch + 1) == buf_ptr_ch);
    BOOST_TEST((buf_array_ch + 1) == (buf_array_ch + 1));
    BOOST_TEST((buf_array_ch + 1) == buf_str);
#endif

    BOOST_TEST(buf_str == buf_ptr_cch);
    BOOST_TEST(buf_str == (buf_array_cch + 1));
    BOOST_TEST(buf_str == buf_ptr_ch);
    BOOST_TEST(buf_str == (buf_array_ch + 1));
    BOOST_TEST(buf_str == buf_str);

    BOOST_TEST(buf_ptr_cch == buf_str);
    //BOOST_TEST((buf_array_cch + 1) == buf_str); // does not compile
    BOOST_TEST(buf_ptr_ch == buf_str);
    //BOOST_TEST((buf_array_ch + 1) == buf_str); // does not compile
    BOOST_TEST(buf_str == buf_str);

#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
    BOOST_TEST( buf_ptr_cch == buf_ptr_cch, boost::test_tools::per_element() );
    BOOST_TEST( buf_ptr_cch <= "abd" , boost::test_tools::per_element() );
    BOOST_TEST( buf_ptr_cch >= "aba" , boost::test_tools::per_element() );
    BOOST_TEST( buf_str == buf_ptr_cch , boost::test_tools::per_element() );
    BOOST_TEST( buf_str <= "abd" , boost::test_tools::per_element() );
    BOOST_TEST( buf_str >= "aba" , boost::test_tools::per_element() );

    BOOST_TEST( buf_ptr_cch <= buf_ptr_cch, boost::test_tools::lexicographic() );
    BOOST_TEST( buf_ptr_cch >= buf_ptr_cch, boost::test_tools::lexicographic() );
    BOOST_TEST( buf_ptr_cch <= "abc" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_ptr_cch < "abd" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_ptr_cch < "abcd" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_ptr_cch >= "abc" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_ptr_cch > "aba" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_ptr_cch > "abad" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_str <= buf_ptr_cch , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_str >= buf_ptr_cch , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_str <= "abc" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_str < "abd" , boost::test_tools::lexicographic() );
    BOOST_TEST( buf_str > "aba" , boost::test_tools::lexicographic() );
#endif

}

#if defined(BOOST_TEST_STRING_VIEW)
BOOST_AUTO_TEST_CASE( check_string_view_compare )
{
    namespace bp = boost::unit_test;
    using namespace std::literals;

    std::string str = "str";
    std::string_view sv = "sv";

    BOOST_TEST((!bp::is_cstring< decltype(sv) >::value));

    BOOST_TEST_CHECK(str == str);
    BOOST_TEST_CHECK(sv == sv);
    BOOST_TEST_CHECK(str != sv);
    BOOST_TEST_CHECK(sv != str);

    //  comparisons based on size
    BOOST_TEST_CHECK(str >= sv);
    BOOST_TEST_CHECK(sv <= str);
    BOOST_TEST_CHECK(str > sv);
    BOOST_TEST_CHECK(sv < str);
  
    BOOST_TEST_CHECK(str <= sv, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK(sv >= str, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK(str < sv, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK(sv > str, boost::test_tools::lexicographic());
  
    std::string_view s1 = "this_is_string_view"sv;
    BOOST_TEST(s1 == s1);
    BOOST_TEST(s1 <= s1);
    BOOST_TEST(s1 >= s1);
    BOOST_TEST(s1 == "this_is_string_view"s);
  
    BOOST_TEST(s1 <= "this_is_string_view2"sv);
  
    // lexicographic compare
    BOOST_TEST_CHECK("str" <= sv, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK(sv >= "str", boost::test_tools::lexicographic());
    BOOST_TEST_CHECK("str" < sv, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK(sv > "str", boost::test_tools::lexicographic());

    BOOST_TEST_CHECK("str"sv <= sv, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK(sv >= "str"sv, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK("str"sv < sv, boost::test_tools::lexicographic());
    BOOST_TEST_CHECK(sv > "str"sv, boost::test_tools::lexicographic());

    // per element, left-right operand
    BOOST_TEST( "sv" <= sv , boost::test_tools::per_element() );
    BOOST_TEST( "sv" >= sv , boost::test_tools::per_element() );
    BOOST_TEST( "sv" == sv , boost::test_tools::per_element() );

    BOOST_TEST( sv <= "sv" , boost::test_tools::per_element() );
    BOOST_TEST( sv >= "sv" , boost::test_tools::per_element() );
    BOOST_TEST( sv == "sv" , boost::test_tools::per_element() );

    BOOST_TEST( "rv" <= sv , boost::test_tools::per_element() );
    BOOST_TEST( "tv" >= sv , boost::test_tools::per_element() );
    BOOST_TEST( "tw" != sv , boost::test_tools::per_element() );

    BOOST_TEST( sv <= "tv" , boost::test_tools::per_element() );
    BOOST_TEST( sv >= "rv" , boost::test_tools::per_element() );
    BOOST_TEST( sv != "ru" , boost::test_tools::per_element() );

}
#endif

// EOF
Commit	Line	Data
7c673cae FG	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));
b32b8144 FG	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));
7c673cae FG	30	}
7c673cae FG	31
92f5a8d4 TL	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
b32b8144 FG	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	}
7c673cae	52
92f5a8d4 TL	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
b32b8144	61	//____________________________________________________________________________//
7c673cae FG	62
	63	BOOST_AUTO_TEST_CASE( check_string_compare )
	64	{
7c673cae	65
92f5a8d4 TL	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));
7c673cae FG	78
7c673cae FG	79	BOOST_TEST(buf_ptr_cch == buf_ptr_cch);
b32b8144	80	#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
92f5a8d4 TL	81	BOOST_TEST(buf_ptr_cch == (buf_array_cch + 1));
92f5a8d4 TL	82	BOOST_TEST(buf_ptr_cch == (buf_array_ch + 1));
b32b8144	83	BOOST_TEST(buf_ptr_cch == buf_ptr_ch);
7c673cae	84	BOOST_TEST(buf_ptr_cch == buf_str);
b32b8144	85	#endif
7c673cae FG	86
7c673cae FG	87	#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
92f5a8d4 TL	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);
7c673cae FG	93	#endif
7c673cae FG	94
b32b8144 FG	95	BOOST_TEST(buf_ptr_ch == buf_ptr_ch);
b32b8144 FG	96	#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
7c673cae	97	BOOST_TEST(buf_ptr_ch == buf_ptr_cch);
92f5a8d4 TL	98	BOOST_TEST(buf_ptr_ch == (buf_array_cch + 1));
92f5a8d4 TL	99	BOOST_TEST(buf_ptr_ch == (buf_array_ch + 1));
7c673cae	100	BOOST_TEST(buf_ptr_ch == buf_str);
b32b8144	101	#endif
7c673cae FG	102
7c673cae FG	103	#ifndef BOOST_TEST_MACRO_LIMITED_SUPPORT
92f5a8d4 TL	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);
7c673cae FG	109	#endif
	110
	111	BOOST_TEST(buf_str == buf_ptr_cch);
92f5a8d4	112	BOOST_TEST(buf_str == (buf_array_cch + 1));
7c673cae	113	BOOST_TEST(buf_str == buf_ptr_ch);
92f5a8d4	114	BOOST_TEST(buf_str == (buf_array_ch + 1));
7c673cae	115	BOOST_TEST(buf_str == buf_str);
b32b8144 FG	116
b32b8144 FG	117	BOOST_TEST(buf_ptr_cch == buf_str);
92f5a8d4	118	//BOOST_TEST((buf_array_cch + 1) == buf_str); // does not compile
b32b8144	119	BOOST_TEST(buf_ptr_ch == buf_str);
92f5a8d4	120	//BOOST_TEST((buf_array_ch + 1) == buf_str); // does not compile
b32b8144 FG	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
7c673cae FG	146	}
7c673cae FG	147
92f5a8d4 TL	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
7c673cae	214	// EOF