[ceph.git] / ceph / src / boost / libs / test / test / utils-ts / basic_cstring-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 : basic_cstring unit test
// *****************************************************************************

#ifdef _MSC_VER
#pragma warning(disable: 4996)
#pragma warning(disable: 4267)
#endif

// Boost.Test
#include <boost/test/unit_test.hpp>

#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <boost/test/utils/basic_cstring/compare.hpp>
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/test/tools/output_test_stream.hpp>
namespace utf = boost::unit_test;
namespace tt  = boost::test_tools;
using utf::const_string;

// Boost
#include <boost/mpl/list.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/type_traits/add_const.hpp>

// STL
#include <cctype>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <stdexcept>

namespace mpl = boost::mpl;

typedef mpl::list2<char const,wchar_t const>                                base_const_char_types;
typedef mpl::list3<char,unsigned char,wchar_t>                              mutable_char_types;
typedef mpl::transform<mutable_char_types,boost::add_const<mpl::_1> >::type const_char_types;
typedef mpl::joint_view<const_char_types,mutable_char_types>                char_types;
typedef mpl::list2<char,const char>                                         io_test_types;

//____________________________________________________________________________//

template<typename CharT>
struct string_literal {
    typedef typename boost::remove_const<CharT>::type   mutable_char;

    string_literal() {}
    string_literal( char const* orig, std::size_t orig_size )
    {
        assign(orig, orig_size);
    }

    CharT*    begin() const { return const_cast<CharT*>(buff.c_str()); }

    void    assign( char const* orig, std::size_t orig_size )
    {
        buff.resize( orig_size );
        for (size_t index = 0; index < orig_size; ++index)
            buff[index] = orig[index];
    }

    std::basic_string<mutable_char> buff;
};

//____________________________________________________________________________//

template<typename CharT>
CharT*
test_string( CharT* = 0 )
{
    static string_literal<CharT> l( "test_string", 11 );

    return l.begin();
}
#define TEST_STRING test_string<CharT>( (CharT*)0 )

//____________________________________________________________________________//

template<typename CharT>
CharT*
static_literal(char const* orig, std::size_t orig_size)
{
    static string_literal<CharT> l;
    
    l.assign(orig, orig_size);

    return l.begin();
}
#define LITERAL( s ) static_literal<CharT>( s, sizeof( s ) )

#define LOCAL_DEF( name, s )                                                \
string_literal<CharT> BOOST_JOIN( sl, __LINE__)(s, sizeof( s ));            \
utf::basic_cstring<CharT> name( (CharT*)(BOOST_JOIN( sl, __LINE__).begin()))\
/**/


//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( constructors_test, CharT )
{
    {
        utf::basic_cstring<CharT> bcs;
        BOOST_TEST( bcs.size() == 0U );
        BOOST_TEST( bcs.is_empty() );
    }

    {
        utf::basic_cstring<CharT> bcs( utf::basic_cstring<CharT>::null_str() );
        BOOST_TEST( bcs.size() == 0U );
        BOOST_TEST( bcs.is_empty() );
    }

    {
        utf::basic_cstring<CharT> bcs( 0 );
        BOOST_TEST( bcs.size() == 0U );
        BOOST_TEST( bcs.is_empty() );
    }

    {
        typedef typename utf::basic_cstring<CharT>::traits_type traits;

        utf::basic_cstring<CharT> bcs( TEST_STRING );
        BOOST_TEST( traits::compare( bcs.begin(), TEST_STRING, bcs.size() ) == 0 );
        BOOST_TEST( bcs.size() == traits::length( TEST_STRING ) );

        utf::basic_cstring<CharT> bcs1( bcs );
        BOOST_TEST( traits::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
    }

    {
        typedef typename utf::basic_cstring<CharT>::traits_type traits;

        utf::basic_cstring<CharT> bcs( TEST_STRING, 4 );
        BOOST_TEST( traits::compare( bcs.begin(), LITERAL( "test" ), bcs.size() ) == 0 );
    }

    {
        typedef typename utf::basic_cstring<CharT>::traits_type traits;

        utf::basic_cstring<CharT> bcs( TEST_STRING, TEST_STRING + 6 );
        BOOST_TEST( traits::compare( bcs.begin(), LITERAL( "test_s" ), bcs.size() ) == 0 );
    }
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( constructors_std_string_test, CharT )
{
    typedef typename utf::basic_cstring<CharT>::traits_type traits;

    {
        typename utf::basic_cstring<CharT>::std_string l( TEST_STRING );

        utf::basic_cstring<CharT> bcs( l );
        BOOST_TEST( traits::compare( bcs.begin(), TEST_STRING, bcs.size() ) == 0 );
    }

}

//____________________________________________________________________________//

void array_construction_test()
{
    const_string bcs_array[] = { "str1", "str2" };

    BOOST_TEST( const_string::traits_type::compare( bcs_array[0].begin(), "str1", bcs_array[0].size() ) == 0 );
    BOOST_TEST( const_string::traits_type::compare( bcs_array[1].begin(), "str2", bcs_array[1].size() ) == 0 );

    const_string bcs( "abc" );
    BOOST_TEST( const_string::traits_type::compare( bcs.begin(), "abc", bcs.size() ) == 0 );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( data_access_test, CharT )
{
    typedef typename utf::basic_cstring<CharT>::traits_type traits_type;

    utf::basic_cstring<CharT> bcs1( TEST_STRING );
    BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
    BOOST_TEST( traits_type::compare( bcs1.begin(), bcs1.begin(), bcs1.size() ) == 0 );

    BOOST_TEST( bcs1[0] == 't' );
    BOOST_TEST( bcs1[4] == '_' );
    BOOST_TEST( bcs1[bcs1.size()-1] == 'g' );

    BOOST_TEST( bcs1[0] == bcs1.at( 0 ) );
    BOOST_TEST( bcs1[2] == bcs1.at( 5 ) );
    BOOST_TEST( bcs1.at( bcs1.size() - 1 ) == 'g' );
    BOOST_TEST( bcs1.at( bcs1.size() ) == 0 );
    BOOST_TEST( bcs1.at( bcs1.size()+1 ) == 0 );

    BOOST_TEST( utf::first_char( bcs1 ) == 't' );
    BOOST_TEST( utf::last_char( bcs1 ) == 'g' );

    BOOST_TEST( utf::first_char( utf::basic_cstring<CharT>() ) == 0 );
    BOOST_TEST( utf::last_char( utf::basic_cstring<CharT>() ) == 0 );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( size_test, CharT )
{
    utf::basic_cstring<CharT> bcs1;

    BOOST_TEST( bcs1.size() == 0U );
    BOOST_TEST( bcs1.is_empty() );

    bcs1 = TEST_STRING;
    BOOST_TEST( bcs1.size() == 11U );

    bcs1.clear();
    BOOST_TEST( bcs1.size() == 0U );
    BOOST_TEST( bcs1.is_empty() );

    bcs1 = utf::basic_cstring<CharT>( TEST_STRING, 4 );
    BOOST_TEST( bcs1.size() == 4U );

    bcs1.resize( 5 );
    BOOST_TEST( bcs1.size() == 4U );

    bcs1.resize( 3 );
    BOOST_TEST( bcs1.size() == 3U );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( asignment_test, CharT )
{
    typedef typename utf::basic_cstring<CharT>::traits_type traits_type;

    utf::basic_cstring<CharT> bcs1;
    string_literal<CharT> l( "test", 4 );

    bcs1 = l.begin();
    BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "test" ), bcs1.size() ) == 0 );

    utf::basic_cstring<CharT> bcs2( TEST_STRING );
    bcs1 = bcs2;
    BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );

    bcs1.assign( l.begin() );
    BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "test" ), bcs1.size() ) == 0 );

    bcs1.assign( l.begin()+1, l.begin()+3 );
    BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "est" ), bcs1.size() ) == 0 );

    bcs1.assign( bcs2, 4, 3 );
    BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "_st" ), bcs1.size() ) == 0 );

    bcs1.swap( bcs2 );
    BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
    BOOST_TEST( traits_type::compare( bcs2.begin(), LITERAL( "_st" ), bcs2.size() ) == 0 );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( asignment_std_string_test, CharT )
{
    typedef typename utf::basic_cstring<CharT>::traits_type traits_type;

    utf::basic_cstring<CharT> bcs1;
    typename utf::basic_cstring<CharT>::std_string l( TEST_STRING );

    bcs1 = l;
    BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );

    bcs1.assign( l );
    BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );

    bcs1.assign( l, 1, 2 );
    BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "es" ), bcs1.size() ) == 0 );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( comparison_test, CharT )
{
    utf::basic_cstring<CharT> bcs1( TEST_STRING );
    utf::basic_cstring<CharT> bcs2( TEST_STRING );

    BOOST_TEST(( bcs1 == TEST_STRING ));
    BOOST_TEST(( TEST_STRING == bcs1 ));
    BOOST_TEST(( bcs1 == bcs2 ));

    bcs1.resize( 4 );

    BOOST_TEST(( bcs1 == LITERAL( "test" ) ));

    BOOST_TEST(( bcs1 != TEST_STRING ));
    BOOST_TEST(( TEST_STRING != bcs1 ));
    BOOST_TEST(( bcs1 != bcs2 ));

    LOCAL_DEF( bcs3, "TeSt" );
    BOOST_TEST( utf::case_ins_eq( bcs1, bcs3 ) );
}

//____________________________________________________________________________//

BOOST_TEST_DONT_PRINT_LOG_VALUE( std::wstring )

BOOST_TEST_CASE_TEMPLATE_FUNCTION( comparison_std_string_test, CharT )
{
    utf::basic_cstring<CharT> bcs1( TEST_STRING );
    typename utf::basic_cstring<CharT>::std_string l( TEST_STRING );

    BOOST_TEST( bcs1 == l );
    BOOST_TEST( l == bcs1 );

    bcs1.resize( 4 );

    BOOST_TEST( bcs1 != l );
    BOOST_TEST( l != bcs1 );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( ordering_test, CharT )
{
    LOCAL_DEF( bcs1, "aBcd" );
    LOCAL_DEF( bcs2, "aBbdd" );
    LOCAL_DEF( bcs3, "aBbde" );
    LOCAL_DEF( bcs4, "abab" );

    BOOST_TEST(( bcs1 < bcs2 ));
    BOOST_TEST(( bcs2 < bcs3 ));
    BOOST_TEST(( bcs1 < bcs3 ));
    BOOST_TEST(( bcs1 < bcs4 ));

    utf::case_ins_less<CharT> cil;
    BOOST_TEST( cil( bcs4, bcs1 ) );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( trim_test, CharT )
{
    LOCAL_DEF( bcs0, "tes" );

    bcs0.trim_right( 1 );
    BOOST_TEST( bcs0.size() == 2U );
    BOOST_TEST( bcs0[0] == 't' );

    bcs0.trim_left( 1 );
    BOOST_TEST( bcs0.size() == 1U );
    BOOST_TEST( bcs0[0] == 'e' );

    bcs0.trim_left( 1 );
    BOOST_TEST( bcs0.is_empty() );

    bcs0 = TEST_STRING;
    bcs0.trim_left( 11 );
    BOOST_TEST( bcs0.is_empty() );

    bcs0 = TEST_STRING;
    bcs0.trim_right( 11 );
    BOOST_TEST( bcs0.is_empty() );

    bcs0 = TEST_STRING;
    bcs0.trim_right( bcs0.size() - bcs0.find( LITERAL( "t_s" ) ) - 3 );
    BOOST_TEST( bcs0 == LITERAL( "test_s" ) );

    bcs0.trim_left( bcs0.find( LITERAL( "t_s" ) ) );
    BOOST_TEST( bcs0 == LITERAL( "t_s" ) );

    LOCAL_DEF( bcs1, "abcd   " );
    LOCAL_DEF( bcs2, "     abcd" );
    LOCAL_DEF( bcs3, "  abcd  " );

    bcs1.trim_right();
    BOOST_TEST( bcs1 == LITERAL( "abcd" ) );

    bcs2.trim_left();
    BOOST_TEST( bcs2 == LITERAL( "abcd" ) );

    bcs3.trim( LITERAL( "\"" ) );
    BOOST_TEST( bcs3 == LITERAL( "  abcd  " ) );

    bcs3.trim();
    BOOST_TEST( bcs3 == LITERAL( "abcd" ) );

    bcs3.trim();
    BOOST_TEST( bcs3 == LITERAL( "abcd" ) );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( io_test, CharT )
{
    utf::basic_cstring<CharT> bcs1( TEST_STRING );
    bcs1.trim_right( 7 );

    tt::output_test_stream ostr;

    ostr << std::setw( 6 ) << bcs1;
    BOOST_TEST( ostr.is_equal( "  test" ) );

    ostr << std::setw( 3 ) << bcs1;
    BOOST_TEST( ostr.is_equal( "test" ) );

    ostr << std::setw( 5 ) << std::setiosflags( std::ios::left ) << bcs1;
    BOOST_TEST( ostr.is_equal( "test " ) );
}

//____________________________________________________________________________//

BOOST_TEST_CASE_TEMPLATE_FUNCTION( find_test, CharT )
{
    typedef typename utf::basic_cstring<CharT>::size_type size;
    utf::basic_cstring<CharT> bcs1( TEST_STRING );

    size not_found = (size)utf::basic_cstring<CharT>::npos;

    BOOST_TEST( bcs1.find( utf::basic_cstring<CharT>() ) == not_found );
    BOOST_TEST( bcs1.find( LITERAL( "test" ) ) == (size)0 );
    BOOST_TEST( bcs1.find( TEST_STRING ) == (size)0 );
    BOOST_TEST( bcs1.find( LITERAL( "test_string " ) ) == not_found );
    BOOST_TEST( bcs1.find( LITERAL( " test_string" ) ) == not_found );
    BOOST_TEST( bcs1.find( LITERAL( "est" ) ) == (size)1 );
    BOOST_TEST( bcs1.find( LITERAL( "t_st" ) ) == (size)3 );
    BOOST_TEST( bcs1.find( LITERAL( "ing" ) ) == (size)8 );
    BOOST_TEST( bcs1.find( LITERAL( "tst" ) ) == not_found );

    BOOST_TEST( bcs1.rfind( utf::basic_cstring<CharT>() ) == not_found );
    BOOST_TEST( bcs1.rfind( LITERAL( "test" ) ) == (size)0 );
    BOOST_TEST( bcs1.rfind( TEST_STRING ) == (size)0 );
    BOOST_TEST( bcs1.rfind( LITERAL( "test_string " ) ) == not_found );
    BOOST_TEST( bcs1.rfind( LITERAL( " test_string" ) ) == not_found );
    BOOST_TEST( bcs1.rfind( LITERAL( "est" ) ) == (size)1 );
    BOOST_TEST( bcs1.rfind( LITERAL( "t_st" ) ) == (size)3 );
    BOOST_TEST( bcs1.rfind( LITERAL( "ing" ) ) == (size)8 );
    BOOST_TEST( bcs1.rfind( LITERAL( "tst" ) ) == not_found );
}

//____________________________________________________________________________//

void const_conversion()
{
    char arr[] = { "ABC" };

    utf::basic_cstring<char> str1( arr );
    utf::basic_cstring<char const> str2;

    str2.assign( str1 );

    BOOST_TEST( str1 == "ABC" );
    BOOST_TEST( str2 == "ABC" );
}

//____________________________________________________________________________//

#if defined(BOOST_TEST_STRING_VIEW)
BOOST_TEST_CASE_TEMPLATE_FUNCTION( string_view_support, CharT )
{
  using namespace std::literals;
  typedef std::basic_string_view<CharT> string_view_t;
  namespace utf = boost::unit_test;

  {
    string_view_t sv = LITERAL("");

    utf::stringview_cstring_helper<CharT, string_view_t> svh = sv;
    BOOST_TEST( svh.size() == 0U );
    BOOST_TEST( svh.is_empty() );
  }


  {
    string_view_t sv = LITERAL("bla");

    utf::stringview_cstring_helper<CharT, string_view_t> svh = sv;
    BOOST_TEST( svh.size() == 3U );
    BOOST_TEST( !svh.is_empty() );
  }
}
#endif


//____________________________________________________________________________//

utf::test_suite*
init_unit_test_suite( int /*argc*/, char* /*argv*/[] )
{
    utf::test_suite* test= BOOST_TEST_SUITE("basic_cstring test");

    test->add( BOOST_TEST_CASE_TEMPLATE( constructors_test, char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( constructors_std_string_test, base_const_char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( asignment_std_string_test, base_const_char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( comparison_std_string_test, base_const_char_types ) );
    test->add( BOOST_TEST_CASE( array_construction_test ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( data_access_test, char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( size_test, char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( asignment_test, char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( comparison_test, char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( ordering_test, char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( trim_test, char_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( io_test, io_test_types ) );
    test->add( BOOST_TEST_CASE_TEMPLATE( find_test, char_types ) );
    test->add( BOOST_TEST_CASE( &const_conversion ) );
  
#if defined(BOOST_TEST_STRING_VIEW)
    test->add( BOOST_TEST_CASE_TEMPLATE( string_view_support, char_types ) );
#endif

    return test;
}

// 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 : basic_cstring unit test
	13	// *****************************************************************************
	14
	15	#ifdef _MSC_VER
	16	#pragma warning(disable: 4996)
	17	#pragma warning(disable: 4267)
	18	#endif
	19
	20	// Boost.Test
	21	#include <boost/test/unit_test.hpp>
	22
	23	#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
	24	#include <boost/test/utils/basic_cstring/compare.hpp>
	25	#include <boost/test/utils/basic_cstring/io.hpp>
	26	#include <boost/test/tools/output_test_stream.hpp>
	27	namespace utf = boost::unit_test;
	28	namespace tt = boost::test_tools;
	29	using utf::const_string;
	30
	31	// Boost
	32	#include <boost/mpl/list.hpp>
	33	#include <boost/mpl/joint_view.hpp>
	34	#include <boost/mpl/transform.hpp>
	35	#include <boost/type_traits/add_const.hpp>
	36
	37	// STL
	38	#include <cctype>
	39	#include <ctime>
	40	#include <iomanip>
	41	#include <iostream>
	42	#include <stdexcept>
	43
	44	namespace mpl = boost::mpl;
	45
	46	typedef mpl::list2<char const,wchar_t const> base_const_char_types;
	47	typedef mpl::list3<char,unsigned char,wchar_t> mutable_char_types;
	48	typedef mpl::transform<mutable_char_types,boost::add_const<mpl::_1> >::type const_char_types;
	49	typedef mpl::joint_view<const_char_types,mutable_char_types> char_types;
	50	typedef mpl::list2<char,const char> io_test_types;
	51
	52	//____________________________________________________________________________//
	53
	54	template<typename CharT>
	55	struct string_literal {
	56	typedef typename boost::remove_const<CharT>::type mutable_char;
	57
	58	string_literal() {}
	59	string_literal( char const* orig, std::size_t orig_size )
	60	{
	61	assign(orig, orig_size);
	62	}
	63
	64	CharT* begin() const { return const_cast<CharT*>(buff.c_str()); }
65
66	void assign( char const* orig, std::size_t orig_size )
67	{
68	buff.resize( orig_size );
69	for (size_t index = 0; index < orig_size; ++index)
70	buff[index] = orig[index];
71	}
72
73	std::basic_string<mutable_char> buff;
74	};
75
76	//____________________________________________________________________________//
77
78	template<typename CharT>
79	CharT*
80	test_string( CharT* = 0 )
81	{
82	static string_literal<CharT> l( "test_string", 11 );
83
84	return l.begin();
85	}
86	#define TEST_STRING test_string<CharT>( (CharT*)0 )
87
88	//____________________________________________________________________________//
89
90	template<typename CharT>
91	CharT*
92	static_literal(char const* orig, std::size_t orig_size)
93	{
94	static string_literal<CharT> l;
95
96	l.assign(orig, orig_size);
97
98	return l.begin();
99	}
100	#define LITERAL( s ) static_literal<CharT>( s, sizeof( s ) )
101
102	#define LOCAL_DEF( name, s ) \
103	string_literal<CharT> BOOST_JOIN( sl, __LINE__)(s, sizeof( s )); \
104	utf::basic_cstring<CharT> name( (CharT*)(BOOST_JOIN( sl, __LINE__).begin()))\
105	/**/
106
107
108	//____________________________________________________________________________//
109
110	BOOST_TEST_CASE_TEMPLATE_FUNCTION( constructors_test, CharT )
111	{
112	{
113	utf::basic_cstring<CharT> bcs;
114	BOOST_TEST( bcs.size() == 0U );
115	BOOST_TEST( bcs.is_empty() );
116	}
117
118	{
119	utf::basic_cstring<CharT> bcs( utf::basic_cstring<CharT>::null_str() );
120	BOOST_TEST( bcs.size() == 0U );
121	BOOST_TEST( bcs.is_empty() );
122	}
123
124	{
125	utf::basic_cstring<CharT> bcs( 0 );
126	BOOST_TEST( bcs.size() == 0U );
127	BOOST_TEST( bcs.is_empty() );
128	}
129
130	{
131	typedef typename utf::basic_cstring<CharT>::traits_type traits;
132
133	utf::basic_cstring<CharT> bcs( TEST_STRING );
134	BOOST_TEST( traits::compare( bcs.begin(), TEST_STRING, bcs.size() ) == 0 );
135	BOOST_TEST( bcs.size() == traits::length( TEST_STRING ) );
136
137	utf::basic_cstring<CharT> bcs1( bcs );
138	BOOST_TEST( traits::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
139	}
140
141	{
142	typedef typename utf::basic_cstring<CharT>::traits_type traits;
143
144	utf::basic_cstring<CharT> bcs( TEST_STRING, 4 );
145	BOOST_TEST( traits::compare( bcs.begin(), LITERAL( "test" ), bcs.size() ) == 0 );
146	}
147
148	{
149	typedef typename utf::basic_cstring<CharT>::traits_type traits;
150
151	utf::basic_cstring<CharT> bcs( TEST_STRING, TEST_STRING + 6 );
152	BOOST_TEST( traits::compare( bcs.begin(), LITERAL( "test_s" ), bcs.size() ) == 0 );
153	}
154	}
155
156	//____________________________________________________________________________//
157
158	BOOST_TEST_CASE_TEMPLATE_FUNCTION( constructors_std_string_test, CharT )
159	{
160	typedef typename utf::basic_cstring<CharT>::traits_type traits;
161
162	{
163	typename utf::basic_cstring<CharT>::std_string l( TEST_STRING );
164
165	utf::basic_cstring<CharT> bcs( l );
166	BOOST_TEST( traits::compare( bcs.begin(), TEST_STRING, bcs.size() ) == 0 );
167	}
168
169	}
170
171	//____________________________________________________________________________//
172
173	void array_construction_test()
174	{
175	const_string bcs_array[] = { "str1", "str2" };
176
177	BOOST_TEST( const_string::traits_type::compare( bcs_array[0].begin(), "str1", bcs_array[0].size() ) == 0 );
178	BOOST_TEST( const_string::traits_type::compare( bcs_array[1].begin(), "str2", bcs_array[1].size() ) == 0 );
179
180	const_string bcs( "abc" );
181	BOOST_TEST( const_string::traits_type::compare( bcs.begin(), "abc", bcs.size() ) == 0 );
182	}
183
184	//____________________________________________________________________________//
185
186	BOOST_TEST_CASE_TEMPLATE_FUNCTION( data_access_test, CharT )
187	{
188	typedef typename utf::basic_cstring<CharT>::traits_type traits_type;
189
190	utf::basic_cstring<CharT> bcs1( TEST_STRING );
191	BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
192	BOOST_TEST( traits_type::compare( bcs1.begin(), bcs1.begin(), bcs1.size() ) == 0 );
193
194	BOOST_TEST( bcs1[0] == 't' );
195	BOOST_TEST( bcs1[4] == '_' );
196	BOOST_TEST( bcs1[bcs1.size()-1] == 'g' );
197
198	BOOST_TEST( bcs1[0] == bcs1.at( 0 ) );
199	BOOST_TEST( bcs1[2] == bcs1.at( 5 ) );
200	BOOST_TEST( bcs1.at( bcs1.size() - 1 ) == 'g' );
201	BOOST_TEST( bcs1.at( bcs1.size() ) == 0 );
202	BOOST_TEST( bcs1.at( bcs1.size()+1 ) == 0 );
203
204	BOOST_TEST( utf::first_char( bcs1 ) == 't' );
205	BOOST_TEST( utf::last_char( bcs1 ) == 'g' );
206
207	BOOST_TEST( utf::first_char( utf::basic_cstring<CharT>() ) == 0 );
208	BOOST_TEST( utf::last_char( utf::basic_cstring<CharT>() ) == 0 );
209	}
210
211	//____________________________________________________________________________//
212
213	BOOST_TEST_CASE_TEMPLATE_FUNCTION( size_test, CharT )
214	{
215	utf::basic_cstring<CharT> bcs1;
216
217	BOOST_TEST( bcs1.size() == 0U );
218	BOOST_TEST( bcs1.is_empty() );
219
220	bcs1 = TEST_STRING;
221	BOOST_TEST( bcs1.size() == 11U );
222
223	bcs1.clear();
224	BOOST_TEST( bcs1.size() == 0U );
225	BOOST_TEST( bcs1.is_empty() );
226
227	bcs1 = utf::basic_cstring<CharT>( TEST_STRING, 4 );
228	BOOST_TEST( bcs1.size() == 4U );
229
230	bcs1.resize( 5 );
231	BOOST_TEST( bcs1.size() == 4U );
232
233	bcs1.resize( 3 );
234	BOOST_TEST( bcs1.size() == 3U );
235	}
236
237	//____________________________________________________________________________//
238
239	BOOST_TEST_CASE_TEMPLATE_FUNCTION( asignment_test, CharT )
240	{
241	typedef typename utf::basic_cstring<CharT>::traits_type traits_type;
242
243	utf::basic_cstring<CharT> bcs1;
244	string_literal<CharT> l( "test", 4 );
245
246	bcs1 = l.begin();
247	BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "test" ), bcs1.size() ) == 0 );
248
249	utf::basic_cstring<CharT> bcs2( TEST_STRING );
250	bcs1 = bcs2;
251	BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
252
253	bcs1.assign( l.begin() );
254	BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "test" ), bcs1.size() ) == 0 );
255
256	bcs1.assign( l.begin()+1, l.begin()+3 );
257	BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "est" ), bcs1.size() ) == 0 );
258
259	bcs1.assign( bcs2, 4, 3 );
260	BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "_st" ), bcs1.size() ) == 0 );
261
262	bcs1.swap( bcs2 );
263	BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
264	BOOST_TEST( traits_type::compare( bcs2.begin(), LITERAL( "_st" ), bcs2.size() ) == 0 );
265	}
266
267	//____________________________________________________________________________//
268
269	BOOST_TEST_CASE_TEMPLATE_FUNCTION( asignment_std_string_test, CharT )
270	{
271	typedef typename utf::basic_cstring<CharT>::traits_type traits_type;
272
273	utf::basic_cstring<CharT> bcs1;
274	typename utf::basic_cstring<CharT>::std_string l( TEST_STRING );
275
276	bcs1 = l;
277	BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
278
279	bcs1.assign( l );
280	BOOST_TEST( traits_type::compare( bcs1.begin(), TEST_STRING, bcs1.size() ) == 0 );
281
282	bcs1.assign( l, 1, 2 );
283	BOOST_TEST( traits_type::compare( bcs1.begin(), LITERAL( "es" ), bcs1.size() ) == 0 );
284	}
285
286	//____________________________________________________________________________//
287
288	BOOST_TEST_CASE_TEMPLATE_FUNCTION( comparison_test, CharT )
289	{
290	utf::basic_cstring<CharT> bcs1( TEST_STRING );
291	utf::basic_cstring<CharT> bcs2( TEST_STRING );
292
293	BOOST_TEST(( bcs1 == TEST_STRING ));
294	BOOST_TEST(( TEST_STRING == bcs1 ));
295	BOOST_TEST(( bcs1 == bcs2 ));
296
297	bcs1.resize( 4 );
298
299	BOOST_TEST(( bcs1 == LITERAL( "test" ) ));
300
301	BOOST_TEST(( bcs1 != TEST_STRING ));
302	BOOST_TEST(( TEST_STRING != bcs1 ));
303	BOOST_TEST(( bcs1 != bcs2 ));
304
305	LOCAL_DEF( bcs3, "TeSt" );
306	BOOST_TEST( utf::case_ins_eq( bcs1, bcs3 ) );
307	}
308
309	//____________________________________________________________________________//
310
311	BOOST_TEST_DONT_PRINT_LOG_VALUE( std::wstring )
312
313	BOOST_TEST_CASE_TEMPLATE_FUNCTION( comparison_std_string_test, CharT )
314	{
315	utf::basic_cstring<CharT> bcs1( TEST_STRING );
316	typename utf::basic_cstring<CharT>::std_string l( TEST_STRING );
317
318	BOOST_TEST( bcs1 == l );
319	BOOST_TEST( l == bcs1 );
320
321	bcs1.resize( 4 );
322
323	BOOST_TEST( bcs1 != l );
324	BOOST_TEST( l != bcs1 );
325	}
326
327	//____________________________________________________________________________//
328
329	BOOST_TEST_CASE_TEMPLATE_FUNCTION( ordering_test, CharT )
330	{
331	LOCAL_DEF( bcs1, "aBcd" );
332	LOCAL_DEF( bcs2, "aBbdd" );
333	LOCAL_DEF( bcs3, "aBbde" );
334	LOCAL_DEF( bcs4, "abab" );
335
336	BOOST_TEST(( bcs1 < bcs2 ));
337	BOOST_TEST(( bcs2 < bcs3 ));
338	BOOST_TEST(( bcs1 < bcs3 ));
339	BOOST_TEST(( bcs1 < bcs4 ));
340
341	utf::case_ins_less<CharT> cil;
342	BOOST_TEST( cil( bcs4, bcs1 ) );
343	}
344
345	//____________________________________________________________________________//
346
347	BOOST_TEST_CASE_TEMPLATE_FUNCTION( trim_test, CharT )
348	{
349	LOCAL_DEF( bcs0, "tes" );
350
351	bcs0.trim_right( 1 );
352	BOOST_TEST( bcs0.size() == 2U );
353	BOOST_TEST( bcs0[0] == 't' );
354
355	bcs0.trim_left( 1 );
356	BOOST_TEST( bcs0.size() == 1U );
357	BOOST_TEST( bcs0[0] == 'e' );
358
359	bcs0.trim_left( 1 );
360	BOOST_TEST( bcs0.is_empty() );
361
362	bcs0 = TEST_STRING;
363	bcs0.trim_left( 11 );
364	BOOST_TEST( bcs0.is_empty() );
365
366	bcs0 = TEST_STRING;
367	bcs0.trim_right( 11 );
368	BOOST_TEST( bcs0.is_empty() );
369
370	bcs0 = TEST_STRING;
371	bcs0.trim_right( bcs0.size() - bcs0.find( LITERAL( "t_s" ) ) - 3 );
372	BOOST_TEST( bcs0 == LITERAL( "test_s" ) );
373
374	bcs0.trim_left( bcs0.find( LITERAL( "t_s" ) ) );
375	BOOST_TEST( bcs0 == LITERAL( "t_s" ) );
376
377	LOCAL_DEF( bcs1, "abcd " );
378	LOCAL_DEF( bcs2, " abcd" );
379	LOCAL_DEF( bcs3, " abcd " );
380
381	bcs1.trim_right();
382	BOOST_TEST( bcs1 == LITERAL( "abcd" ) );
383
384	bcs2.trim_left();
385	BOOST_TEST( bcs2 == LITERAL( "abcd" ) );
386
387	bcs3.trim( LITERAL( "\"" ) );
388	BOOST_TEST( bcs3 == LITERAL( " abcd " ) );
389
390	bcs3.trim();
391	BOOST_TEST( bcs3 == LITERAL( "abcd" ) );
392
393	bcs3.trim();
394	BOOST_TEST( bcs3 == LITERAL( "abcd" ) );
395	}
396
397	//____________________________________________________________________________//
398
399	BOOST_TEST_CASE_TEMPLATE_FUNCTION( io_test, CharT )
400	{
401	utf::basic_cstring<CharT> bcs1( TEST_STRING );
402	bcs1.trim_right( 7 );
403
404	tt::output_test_stream ostr;
405
406	ostr << std::setw( 6 ) << bcs1;
407	BOOST_TEST( ostr.is_equal( " test" ) );
408
409	ostr << std::setw( 3 ) << bcs1;
410	BOOST_TEST( ostr.is_equal( "test" ) );
411
412	ostr << std::setw( 5 ) << std::setiosflags( std::ios::left ) << bcs1;
413	BOOST_TEST( ostr.is_equal( "test " ) );
414	}
415
416	//____________________________________________________________________________//
417
418	BOOST_TEST_CASE_TEMPLATE_FUNCTION( find_test, CharT )
419	{
420	typedef typename utf::basic_cstring<CharT>::size_type size;
421	utf::basic_cstring<CharT> bcs1( TEST_STRING );
422
423	size not_found = (size)utf::basic_cstring<CharT>::npos;
424
425	BOOST_TEST( bcs1.find( utf::basic_cstring<CharT>() ) == not_found );
426	BOOST_TEST( bcs1.find( LITERAL( "test" ) ) == (size)0 );
427	BOOST_TEST( bcs1.find( TEST_STRING ) == (size)0 );
428	BOOST_TEST( bcs1.find( LITERAL( "test_string " ) ) == not_found );
429	BOOST_TEST( bcs1.find( LITERAL( " test_string" ) ) == not_found );
430	BOOST_TEST( bcs1.find( LITERAL( "est" ) ) == (size)1 );
431	BOOST_TEST( bcs1.find( LITERAL( "t_st" ) ) == (size)3 );
432	BOOST_TEST( bcs1.find( LITERAL( "ing" ) ) == (size)8 );
433	BOOST_TEST( bcs1.find( LITERAL( "tst" ) ) == not_found );
434
435	BOOST_TEST( bcs1.rfind( utf::basic_cstring<CharT>() ) == not_found );
436	BOOST_TEST( bcs1.rfind( LITERAL( "test" ) ) == (size)0 );
437	BOOST_TEST( bcs1.rfind( TEST_STRING ) == (size)0 );
438	BOOST_TEST( bcs1.rfind( LITERAL( "test_string " ) ) == not_found );
439	BOOST_TEST( bcs1.rfind( LITERAL( " test_string" ) ) == not_found );
440	BOOST_TEST( bcs1.rfind( LITERAL( "est" ) ) == (size)1 );
441	BOOST_TEST( bcs1.rfind( LITERAL( "t_st" ) ) == (size)3 );
442	BOOST_TEST( bcs1.rfind( LITERAL( "ing" ) ) == (size)8 );
443	BOOST_TEST( bcs1.rfind( LITERAL( "tst" ) ) == not_found );
444	}
445
446	//____________________________________________________________________________//
447
448	void const_conversion()
449	{
450	char arr[] = { "ABC" };
451
452	utf::basic_cstring<char> str1( arr );
453	utf::basic_cstring<char const> str2;
454
455	str2.assign( str1 );
456
457	BOOST_TEST( str1 == "ABC" );
458	BOOST_TEST( str2 == "ABC" );
459	}
460
92f5a8d4 TL	461	//____________________________________________________________________________//
	462
	463	#if defined(BOOST_TEST_STRING_VIEW)
	464	BOOST_TEST_CASE_TEMPLATE_FUNCTION( string_view_support, CharT )
	465	{
	466	using namespace std::literals;
	467	typedef std::basic_string_view<CharT> string_view_t;
	468	namespace utf = boost::unit_test;
	469
	470	{
	471	string_view_t sv = LITERAL("");
	472
	473	utf::stringview_cstring_helper<CharT, string_view_t> svh = sv;
	474	BOOST_TEST( svh.size() == 0U );
	475	BOOST_TEST( svh.is_empty() );
	476	}
	477
	478
	479	{
	480	string_view_t sv = LITERAL("bla");
	481
	482	utf::stringview_cstring_helper<CharT, string_view_t> svh = sv;
	483	BOOST_TEST( svh.size() == 3U );
	484	BOOST_TEST( !svh.is_empty() );
	485	}
	486	}
	487	#endif
	488
	489
7c673cae FG	490	//____________________________________________________________________________//
	491
	492	utf::test_suite*
	493	init_unit_test_suite( int /argc/, char* /argv/[] )
	494	{
	495	utf::test_suite* test= BOOST_TEST_SUITE("basic_cstring test");
	496
	497	test->add( BOOST_TEST_CASE_TEMPLATE( constructors_test, char_types ) );
	498	test->add( BOOST_TEST_CASE_TEMPLATE( constructors_std_string_test, base_const_char_types ) );
	499	test->add( BOOST_TEST_CASE_TEMPLATE( asignment_std_string_test, base_const_char_types ) );
	500	test->add( BOOST_TEST_CASE_TEMPLATE( comparison_std_string_test, base_const_char_types ) );
	501	test->add( BOOST_TEST_CASE( array_construction_test ) );
	502	test->add( BOOST_TEST_CASE_TEMPLATE( data_access_test, char_types ) );
	503	test->add( BOOST_TEST_CASE_TEMPLATE( size_test, char_types ) );
	504	test->add( BOOST_TEST_CASE_TEMPLATE( asignment_test, char_types ) );
	505	test->add( BOOST_TEST_CASE_TEMPLATE( comparison_test, char_types ) );
	506	test->add( BOOST_TEST_CASE_TEMPLATE( ordering_test, char_types ) );
	507	test->add( BOOST_TEST_CASE_TEMPLATE( trim_test, char_types ) );
	508	test->add( BOOST_TEST_CASE_TEMPLATE( io_test, io_test_types ) );
	509	test->add( BOOST_TEST_CASE_TEMPLATE( find_test, char_types ) );
	510	test->add( BOOST_TEST_CASE( &const_conversion ) );
92f5a8d4 TL	511
	512	#if defined(BOOST_TEST_STRING_VIEW)
	513	test->add( BOOST_TEST_CASE_TEMPLATE( string_view_support, char_types ) );
	514	#endif
7c673cae FG	515
	516	return test;
	517	}
	518
	519	// EOF