[wxWidgets.git] / tests / strings / tokenizer.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/strings/strings.cpp
// Purpose:     wxStringTokenizer unit test
// Author:      Vadim Zeitlin
// Created:     2005-12-20 (extacted from strings.cpp)
// Copyright:   (c) 2004-2005 Vadim Zeitlin
///////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif // WX_PRECOMP

#include "wx/tokenzr.h"

// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------

class TokenizerTestCase : public CppUnit::TestCase
{
public:
    TokenizerTestCase() { }

private:
    CPPUNIT_TEST_SUITE( TokenizerTestCase );
        CPPUNIT_TEST( GetCount );
        CPPUNIT_TEST( GetPosition );
        CPPUNIT_TEST( GetString );
        CPPUNIT_TEST( LastDelimiter );
        CPPUNIT_TEST( StrtokCompat );
    CPPUNIT_TEST_SUITE_END();

    void GetCount();
    void GetPosition();
    void GetString();
    void LastDelimiter();
    void StrtokCompat();

    DECLARE_NO_COPY_CLASS(TokenizerTestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( TokenizerTestCase );

// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TokenizerTestCase, "TokenizerTestCase" );

// ----------------------------------------------------------------------------
// test data
// ----------------------------------------------------------------------------

static const struct TokenizerTestData
{
    // the string to tokenize
    const wxChar *str;

    // the delimiters to use
    const wxChar *delims;

    // the tokenizer mode
    wxStringTokenizerMode mode;

    // expected number of tokens
    size_t count;
}
gs_testData[] =
{
    { wxT(""),                   wxT(" "),              wxTOKEN_DEFAULT,       0 },
    { wxT(""),                   wxT(" "),              wxTOKEN_RET_EMPTY,     0 },
    { wxT(""),                   wxT(" "),              wxTOKEN_RET_EMPTY_ALL, 0 },
    { wxT(""),                   wxT(" "),              wxTOKEN_RET_DELIMS,    0 },
    { wxT(":"),                  wxT(":"),              wxTOKEN_RET_EMPTY,     1 },
    { wxT(":"),                  wxT(":"),              wxTOKEN_RET_DELIMS,    1 },
    { wxT(":"),                  wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 2 },
    { wxT("::"),                 wxT(":"),              wxTOKEN_RET_EMPTY,     1 },
    { wxT("::"),                 wxT(":"),              wxTOKEN_RET_DELIMS,    1 },
    { wxT("::"),                 wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 3 },

    { wxT("Hello, world"),       wxT(" "),              wxTOKEN_DEFAULT,       2 },
    { wxT("Hello,   world  "),   wxT(" "),              wxTOKEN_DEFAULT,       2 },
    { wxT("Hello, world"),       wxT(","),              wxTOKEN_DEFAULT,       2 },
    { wxT("Hello, world!"),      wxT(",!"),             wxTOKEN_DEFAULT,       2 },
    { wxT("Hello,, world!"),     wxT(",!"),             wxTOKEN_DEFAULT,       3 },
    { wxT("Hello,, world!"),     wxT(",!"),             wxTOKEN_STRTOK,        2 },
    { wxT("Hello, world!"),      wxT(",!"),             wxTOKEN_RET_EMPTY_ALL, 3 },

    { wxT("username:password:uid:gid:gecos:home:shell"),
                                wxT(":"),              wxTOKEN_DEFAULT,       7 },

    { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_DEFAULT,       4 },
    { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_RET_EMPTY,     4 },
    { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 5 },
    { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_RET_DELIMS,    4 },
    { wxT("1:2::3:"),            wxT(":"),              wxTOKEN_STRTOK,        3 },

    { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_DEFAULT,       4 },
    { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_RET_EMPTY,     4 },
    { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_RET_EMPTY_ALL, 6 },
    { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_RET_DELIMS,    4 },
    { wxT("1:2::3::"),           wxT(":"),              wxTOKEN_STRTOK,        3 },

    { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_DEFAULT,       4 },
    { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_STRTOK,        4 },
    { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_RET_EMPTY,     6 },
    { wxT("1 \t3\t4  6   "),     wxDEFAULT_DELIMITERS, wxTOKEN_RET_EMPTY_ALL, 9 },

    { wxT("01/02/99"),           wxT("/-"),             wxTOKEN_DEFAULT,       3 },
    { wxT("01-02/99"),           wxT("/-"),             wxTOKEN_RET_DELIMS,    3 },
};

// helper function returning the string showing the index for which the test
// fails in the diagnostic message
static std::string Nth(size_t n)
{
    return std::string(wxString::Format(wxT("for loop index %lu"),
                                        (unsigned long)n).mb_str());
}

// ----------------------------------------------------------------------------
// the tests
// ----------------------------------------------------------------------------

void TokenizerTestCase::GetCount()
{
    for ( size_t n = 0; n < WXSIZEOF(gs_testData); n++ )
    {
        const TokenizerTestData& ttd = gs_testData[n];

        wxStringTokenizer tkz(ttd.str, ttd.delims, ttd.mode);
        CPPUNIT_ASSERT_EQUAL_MESSAGE( Nth(n), ttd.count, tkz.CountTokens() );

        size_t count = 0;
        while ( tkz.HasMoreTokens() )
        {
            tkz.GetNextToken();
            count++;
        }

        CPPUNIT_ASSERT_EQUAL_MESSAGE( Nth(n), ttd.count, count );
    }
}

// call this with the string to tokenize, delimeters to use and the expected
// positions (i.e. results of GetPosition()) after each GetNextToken() call,
// terminate positions with 0
static void
DoTestGetPosition(const wxChar *s, const wxChar *delims, int pos, ...)
{
    wxStringTokenizer tkz(s, delims);

    CPPUNIT_ASSERT_EQUAL( (size_t)0, tkz.GetPosition() );

    va_list ap;
    va_start(ap, pos);

    for ( ;; )
    {
        if ( !pos )
        {
            CPPUNIT_ASSERT( !tkz.HasMoreTokens() );
            break;
        }

        tkz.GetNextToken();

        CPPUNIT_ASSERT_EQUAL( (size_t)pos, tkz.GetPosition() );

        pos = va_arg(ap, int);
    }

    va_end(ap);
}

void TokenizerTestCase::GetPosition()
{
    DoTestGetPosition(wxT("foo"), wxT("_"), 3, 0);
    DoTestGetPosition(wxT("foo_bar"), wxT("_"), 4, 7, 0);
    DoTestGetPosition(wxT("foo_bar_"), wxT("_"), 4, 8, 0);
}

// helper for GetString(): the parameters are the same as for DoTestGetPosition
// but it checks GetString() return value instead of GetPosition()
static void
DoTestGetString(const wxChar *s, const wxChar *delims, int pos, ...)
{
    wxStringTokenizer tkz(s, delims);

    CPPUNIT_ASSERT_EQUAL( wxString(s), tkz.GetString() );

    va_list ap;
    va_start(ap, pos);

    for ( ;; )
    {
        if ( !pos )
        {
            CPPUNIT_ASSERT( tkz.GetString().empty() ) ;
            break;
        }

        tkz.GetNextToken();

        CPPUNIT_ASSERT_EQUAL( wxString(s + pos), tkz.GetString() );

        pos = va_arg(ap, int);
    }

    va_end(ap);
}

void TokenizerTestCase::GetString()
{
    DoTestGetString(wxT("foo"), wxT("_"), 3, 0);
    DoTestGetString(wxT("foo_bar"), wxT("_"), 4, 7, 0);
    DoTestGetString(wxT("foo_bar_"), wxT("_"), 4, 8, 0);
}

void TokenizerTestCase::LastDelimiter()
{
    wxStringTokenizer tkz(wxT("a+-b=c"), wxT("+-="));

    tkz.GetNextToken();
    CPPUNIT_ASSERT_EQUAL( wxT('+'), tkz.GetLastDelimiter() );

    tkz.GetNextToken();
    CPPUNIT_ASSERT_EQUAL( wxT('-'), tkz.GetLastDelimiter() );

    tkz.GetNextToken();
    CPPUNIT_ASSERT_EQUAL( wxT('='), tkz.GetLastDelimiter() );

    tkz.GetNextToken();
    CPPUNIT_ASSERT_EQUAL( wxT('\0'), tkz.GetLastDelimiter() );
}

void TokenizerTestCase::StrtokCompat()
{
    for ( size_t n = 0; n < WXSIZEOF(gs_testData); n++ )
    {
        const TokenizerTestData& ttd = gs_testData[n];
        if ( ttd.mode != wxTOKEN_STRTOK )
            continue;

#if wxUSE_UNICODE
        wxWCharBuffer
#else
        wxCharBuffer
#endif
            buf(ttd.str);
        wxChar *last;
        wxChar *s = wxStrtok(buf.data(), ttd.delims, &last);

        wxStringTokenizer tkz(ttd.str, ttd.delims, ttd.mode);
        while ( tkz.HasMoreTokens() )
        {
            CPPUNIT_ASSERT_EQUAL( wxString(s), tkz.GetNextToken() );
            s = wxStrtok(NULL, ttd.delims, &last);
        }
    }
}
Commit	Line	Data
a67f601b VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: tests/strings/strings.cpp
	3	// Purpose: wxStringTokenizer unit test
	4	// Author: Vadim Zeitlin
	5	// Created: 2005-12-20 (extacted from strings.cpp)
a67f601b VZ	6	// Copyright: (c) 2004-2005 Vadim Zeitlin
	7	///////////////////////////////////////////////////////////////////////////////
	8
	9	// ----------------------------------------------------------------------------
	10	// headers
	11	// ----------------------------------------------------------------------------
	12
	13	#include "testprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#ifndef WX_PRECOMP
	20	#include "wx/wx.h"
	21	#endif // WX_PRECOMP
	22
	23	#include "wx/tokenzr.h"
	24
	25	// ----------------------------------------------------------------------------
	26	// test class
	27	// ----------------------------------------------------------------------------
	28
	29	class TokenizerTestCase : public CppUnit::TestCase
	30	{
	31	public:
	32	TokenizerTestCase() { }
	33
	34	private:
	35	CPPUNIT_TEST_SUITE( TokenizerTestCase );
	36	CPPUNIT_TEST( GetCount );
	37	CPPUNIT_TEST( GetPosition );
06ef1511	38	CPPUNIT_TEST( GetString );
4626c57c	39	CPPUNIT_TEST( LastDelimiter );
a67f601b VZ	40	CPPUNIT_TEST( StrtokCompat );
	41	CPPUNIT_TEST_SUITE_END();
	42
	43	void GetCount();
	44	void GetPosition();
06ef1511	45	void GetString();
4626c57c	46	void LastDelimiter();
a67f601b VZ	47	void StrtokCompat();
	48
	49	DECLARE_NO_COPY_CLASS(TokenizerTestCase)
	50	};
	51
	52	// register in the unnamed registry so that these tests are run by default
	53	CPPUNIT_TEST_SUITE_REGISTRATION( TokenizerTestCase );
	54
e3778b4d	55	// also include in its own registry so that these tests can be run alone
a67f601b VZ	56	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TokenizerTestCase, "TokenizerTestCase" );
	57
	58	// ----------------------------------------------------------------------------
	59	// test data
	60	// ----------------------------------------------------------------------------
	61
	62	static const struct TokenizerTestData
	63	{
	64	// the string to tokenize
	65	const wxChar *str;
	66
	67	// the delimiters to use
	68	const wxChar *delims;
	69
	70	// the tokenizer mode
	71	wxStringTokenizerMode mode;
	72
	73	// expected number of tokens
	74	size_t count;
	75	}
	76	gs_testData[] =
	77	{
9a83f860 VZ	78	{ wxT(""), wxT(" "), wxTOKEN_DEFAULT, 0 },
	79	{ wxT(""), wxT(" "), wxTOKEN_RET_EMPTY, 0 },
	80	{ wxT(""), wxT(" "), wxTOKEN_RET_EMPTY_ALL, 0 },
	81	{ wxT(""), wxT(" "), wxTOKEN_RET_DELIMS, 0 },
	82	{ wxT(":"), wxT(":"), wxTOKEN_RET_EMPTY, 1 },
	83	{ wxT(":"), wxT(":"), wxTOKEN_RET_DELIMS, 1 },
	84	{ wxT(":"), wxT(":"), wxTOKEN_RET_EMPTY_ALL, 2 },
	85	{ wxT("::"), wxT(":"), wxTOKEN_RET_EMPTY, 1 },
	86	{ wxT("::"), wxT(":"), wxTOKEN_RET_DELIMS, 1 },
	87	{ wxT("::"), wxT(":"), wxTOKEN_RET_EMPTY_ALL, 3 },
	88
	89	{ wxT("Hello, world"), wxT(" "), wxTOKEN_DEFAULT, 2 },
	90	{ wxT("Hello, world "), wxT(" "), wxTOKEN_DEFAULT, 2 },
	91	{ wxT("Hello, world"), wxT(","), wxTOKEN_DEFAULT, 2 },
	92	{ wxT("Hello, world!"), wxT(",!"), wxTOKEN_DEFAULT, 2 },
	93	{ wxT("Hello,, world!"), wxT(",!"), wxTOKEN_DEFAULT, 3 },
	94	{ wxT("Hello,, world!"), wxT(",!"), wxTOKEN_STRTOK, 2 },
	95	{ wxT("Hello, world!"), wxT(",!"), wxTOKEN_RET_EMPTY_ALL, 3 },
	96
	97	{ wxT("username:password:uid:gid:gecos:home:shell"),
	98	wxT(":"), wxTOKEN_DEFAULT, 7 },
	99
	100	{ wxT("1:2::3:"), wxT(":"), wxTOKEN_DEFAULT, 4 },
	101	{ wxT("1:2::3:"), wxT(":"), wxTOKEN_RET_EMPTY, 4 },
	102	{ wxT("1:2::3:"), wxT(":"), wxTOKEN_RET_EMPTY_ALL, 5 },
	103	{ wxT("1:2::3:"), wxT(":"), wxTOKEN_RET_DELIMS, 4 },
	104	{ wxT("1:2::3:"), wxT(":"), wxTOKEN_STRTOK, 3 },
	105
	106	{ wxT("1:2::3::"), wxT(":"), wxTOKEN_DEFAULT, 4 },
	107	{ wxT("1:2::3::"), wxT(":"), wxTOKEN_RET_EMPTY, 4 },
	108	{ wxT("1:2::3::"), wxT(":"), wxTOKEN_RET_EMPTY_ALL, 6 },
	109	{ wxT("1:2::3::"), wxT(":"), wxTOKEN_RET_DELIMS, 4 },
	110	{ wxT("1:2::3::"), wxT(":"), wxTOKEN_STRTOK, 3 },
	111
	112	{ wxT("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, wxTOKEN_DEFAULT, 4 },
	113	{ wxT("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, wxTOKEN_STRTOK, 4 },
	114	{ wxT("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, wxTOKEN_RET_EMPTY, 6 },
	115	{ wxT("1 \t3\t4 6 "), wxDEFAULT_DELIMITERS, wxTOKEN_RET_EMPTY_ALL, 9 },
	116
	117	{ wxT("01/02/99"), wxT("/-"), wxTOKEN_DEFAULT, 3 },
	118	{ wxT("01-02/99"), wxT("/-"), wxTOKEN_RET_DELIMS, 3 },
a67f601b VZ	119	};
a67f601b VZ	120
822c2b9f VZ	121	// helper function returning the string showing the index for which the test
	122	// fails in the diagnostic message
	123	static std::string Nth(size_t n)
	124	{
9a83f860	125	return std::string(wxString::Format(wxT("for loop index %lu"),
5ad1f902	126	(unsigned long)n).mb_str());
822c2b9f VZ	127	}
822c2b9f VZ	128
a67f601b VZ	129	// ----------------------------------------------------------------------------
	130	// the tests
	131	// ----------------------------------------------------------------------------
	132
	133	void TokenizerTestCase::GetCount()
	134	{
	135	for ( size_t n = 0; n < WXSIZEOF(gs_testData); n++ )
	136	{
	137	const TokenizerTestData& ttd = gs_testData[n];
	138
	139	wxStringTokenizer tkz(ttd.str, ttd.delims, ttd.mode);
822c2b9f	140	CPPUNIT_ASSERT_EQUAL_MESSAGE( Nth(n), ttd.count, tkz.CountTokens() );
a67f601b VZ	141
	142	size_t count = 0;
	143	while ( tkz.HasMoreTokens() )
	144	{
	145	tkz.GetNextToken();
	146	count++;
	147	}
	148
822c2b9f	149	CPPUNIT_ASSERT_EQUAL_MESSAGE( Nth(n), ttd.count, count );
a67f601b VZ	150	}
	151	}
	152
	153	// call this with the string to tokenize, delimeters to use and the expected
	154	// positions (i.e. results of GetPosition()) after each GetNextToken() call,
	155	// terminate positions with 0
	156	static void
	157	DoTestGetPosition(const wxChar s, const wxChar delims, int pos, ...)
	158	{
	159	wxStringTokenizer tkz(s, delims);
	160
	161	CPPUNIT_ASSERT_EQUAL( (size_t)0, tkz.GetPosition() );
	162
	163	va_list ap;
	164	va_start(ap, pos);
	165
	166	for ( ;; )
	167	{
	168	if ( !pos )
	169	{
	170	CPPUNIT_ASSERT( !tkz.HasMoreTokens() );
	171	break;
	172	}
	173
	174	tkz.GetNextToken();
	175
	176	CPPUNIT_ASSERT_EQUAL( (size_t)pos, tkz.GetPosition() );
	177
	178	pos = va_arg(ap, int);
	179	}
	180
	181	va_end(ap);
	182	}
	183
	184	void TokenizerTestCase::GetPosition()
	185	{
9a83f860 VZ	186	DoTestGetPosition(wxT("foo"), wxT("_"), 3, 0);
	187	DoTestGetPosition(wxT("foo_bar"), wxT("_"), 4, 7, 0);
	188	DoTestGetPosition(wxT("foo_bar_"), wxT("_"), 4, 8, 0);
a67f601b VZ	189	}
a67f601b VZ	190
06ef1511 VZ	191	// helper for GetString(): the parameters are the same as for DoTestGetPosition
	192	// but it checks GetString() return value instead of GetPosition()
	193	static void
	194	DoTestGetString(const wxChar s, const wxChar delims, int pos, ...)
	195	{
	196	wxStringTokenizer tkz(s, delims);
	197
	198	CPPUNIT_ASSERT_EQUAL( wxString(s), tkz.GetString() );
	199
	200	va_list ap;
	201	va_start(ap, pos);
	202
	203	for ( ;; )
	204	{
	205	if ( !pos )
	206	{
f30057df	207	CPPUNIT_ASSERT( tkz.GetString().empty() ) ;
06ef1511 VZ	208	break;
	209	}
	210
	211	tkz.GetNextToken();
	212
	213	CPPUNIT_ASSERT_EQUAL( wxString(s + pos), tkz.GetString() );
	214
	215	pos = va_arg(ap, int);
	216	}
	217
	218	va_end(ap);
	219	}
	220
	221	void TokenizerTestCase::GetString()
	222	{
9a83f860 VZ	223	DoTestGetString(wxT("foo"), wxT("_"), 3, 0);
	224	DoTestGetString(wxT("foo_bar"), wxT("_"), 4, 7, 0);
	225	DoTestGetString(wxT("foo_bar_"), wxT("_"), 4, 8, 0);
06ef1511 VZ	226	}
06ef1511 VZ	227
4626c57c VZ	228	void TokenizerTestCase::LastDelimiter()
4626c57c VZ	229	{
9a83f860	230	wxStringTokenizer tkz(wxT("a+-b=c"), wxT("+-="));
4626c57c VZ	231
4626c57c VZ	232	tkz.GetNextToken();
9a83f860	233	CPPUNIT_ASSERT_EQUAL( wxT('+'), tkz.GetLastDelimiter() );
4626c57c VZ	234
4626c57c VZ	235	tkz.GetNextToken();
9a83f860	236	CPPUNIT_ASSERT_EQUAL( wxT('-'), tkz.GetLastDelimiter() );
4626c57c VZ	237
4626c57c VZ	238	tkz.GetNextToken();
9a83f860	239	CPPUNIT_ASSERT_EQUAL( wxT('='), tkz.GetLastDelimiter() );
4626c57c VZ	240
4626c57c VZ	241	tkz.GetNextToken();
9a83f860	242	CPPUNIT_ASSERT_EQUAL( wxT('\0'), tkz.GetLastDelimiter() );
4626c57c VZ	243	}
4626c57c VZ	244
a67f601b VZ	245	void TokenizerTestCase::StrtokCompat()
	246	{
	247	for ( size_t n = 0; n < WXSIZEOF(gs_testData); n++ )
	248	{
	249	const TokenizerTestData& ttd = gs_testData[n];
	250	if ( ttd.mode != wxTOKEN_STRTOK )
	251	continue;
	252
53599fbb VZ	253	#if wxUSE_UNICODE
	254	wxWCharBuffer
	255	#else
	256	wxCharBuffer
	257	#endif
	258	buf(ttd.str);
a67f601b VZ	259	wxChar *last;
	260	wxChar *s = wxStrtok(buf.data(), ttd.delims, &last);
	261
	262	wxStringTokenizer tkz(ttd.str, ttd.delims, ttd.mode);
	263	while ( tkz.HasMoreTokens() )
	264	{
	265	CPPUNIT_ASSERT_EQUAL( wxString(s), tkz.GetNextToken() );
	266	s = wxStrtok(NULL, ttd.delims, &last);
	267	}
	268	}
	269	}
	270
	271