Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'sorted-array-str-search'

Browse Source 
Fix searching in wxSortedArrayString with custom compare function.

Also improve array unit tests.

See https://github.com/wxWidgets/wxWidgets/pull/2251/
This commit is contained in:
Vadim Zeitlin
2021-02-26 16:51:11 +01:00
parent 063dd3e852 b113635111
commit 94812c9e06
4 changed files with 186 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
include/wx/arrstr.h
View File

@@ -398,6 +398,11 @@ private:
// (if the old buffer is big enough, just return NULL). // (if the old buffer is big enough, just return NULL).
wxString *Grow(size_t nIncrement); wxString *Grow(size_t nIncrement);
// Binary search in the sorted array: return the index of the string if it's
// present, otherwise, if lowerBound is true, return the position at which
// the string should be inserted and if it's false return wxNOT_FOUND.
size_t BinarySearch(const wxString& str, bool lowerBound) const;
size_t m_nSize, // current size of the array size_t m_nSize, // current size of the array
m_nCount; // current number of elements m_nCount; // current number of elements

3
include/wx/dynarray.h
View File

@@ -255,6 +255,9 @@ public:
Add(item); Add(item);
} }
protected:
SCMPFUNC GetCompareFunction() const wxNOEXCEPT { return m_fnCompare; }
private: private:
SCMPFUNC m_fnCompare; SCMPFUNC m_fnCompare;
}; };

77
src/common/arrstr.cpp
View File

@@ -198,15 +198,16 @@ int wxSortedArrayString::Index(const wxString& str,
wxASSERT_MSG( bCase && !bFromEnd, wxASSERT_MSG( bCase && !bFromEnd,
"search parameters ignored for sorted array" ); "search parameters ignored for sorted array" );
SCMPFUNC function = GetCompareFunction();
wxSortedArrayString::const_iterator wxSortedArrayString::const_iterator
it = std::lower_bound(begin(), end(), str, it = std::lower_bound(begin(), end(), str,
#if __cplusplus >= 201103L || wxCHECK_VISUALC_VERSION(14) #if __cplusplus >= 201103L || wxCHECK_VISUALC_VERSION(14)
[](const wxString& s1, const wxString& s2) [function](const wxString& s1, const wxString& s2)
{ {
return s1 < s2; return function(s1, s2) < 0;
} }
#else // C++98 version #else // C++98 version
wxStringCompare(wxStringCmp()) wxStringCompare(function)
#endif // C++11/C++98 #endif // C++11/C++98
); );
@@ -377,6 +378,29 @@ void wxArrayString::Shrink()
} }
} }
// Binary search in the sorted array
size_t wxArrayString::BinarySearch(const wxString& str, bool lowerBound) const
{
size_t
lo = 0,
hi = m_nCount;
while (lo < hi) {
size_t i;
i = (lo + hi) / 2;
int res;
res = m_compareFunction ? m_compareFunction(str, m_pItems[i]) : str.Cmp(m_pItems[i]);
if (res < 0)
hi = i;
else if (res > 0)
lo = i + 1;
else
return i;
}
wxASSERT_MSG(lo == hi, wxT("binary search broken"));
return lowerBound ? lo : wxNOT_FOUND;
}
// searches the array for an item (forward or backwards) // searches the array for an item (forward or backwards)
int wxArrayString::Index(const wxString& str, bool bCase, bool bFromEnd) const int wxArrayString::Index(const wxString& str, bool bCase, bool bFromEnd) const
{ {
@@ -384,25 +408,7 @@ int wxArrayString::Index(const wxString& str, bool bCase, bool bFromEnd) const
// use binary search in the sorted array // use binary search in the sorted array
wxASSERT_MSG( bCase && !bFromEnd, wxASSERT_MSG( bCase && !bFromEnd,
wxT("search parameters ignored for auto sorted array") ); wxT("search parameters ignored for auto sorted array") );
return BinarySearch(str, false /* not lower bound */);
size_t
lo = 0,
hi = m_nCount;
while ( lo < hi ) {
size_t i;
i = (lo + hi)/2;
int res;
res = str.compare(m_pItems[i]);
if ( res < 0 )
hi = i;
else if ( res > 0 )
lo = i + 1;
else
return i;
}
return wxNOT_FOUND;
} }
else { else {
// use linear search in unsorted array // use linear search in unsorted array
@@ -432,30 +438,9 @@ size_t wxArrayString::Add(const wxString& str, size_t nInsert)
{ {
if ( m_autoSort ) { if ( m_autoSort ) {
// insert the string at the correct position to keep the array sorted // insert the string at the correct position to keep the array sorted
size_t size_t nIndex = BinarySearch(str, true /* return lower bound */);
lo = 0, Insert(str, nIndex, nInsert);
hi = m_nCount; return nIndex;
while ( lo < hi ) {
size_t i;
i = (lo + hi)/2;
int res;
res = m_compareFunction ? m_compareFunction(str, m_pItems[i]) : str.Cmp(m_pItems[i]);
if ( res < 0 )
hi = i;
else if ( res > 0 )
lo = i + 1;
else {
lo = hi = i;
break;
}
}
wxASSERT_MSG( lo == hi, wxT("binary search broken") );
Insert(str, lo, nInsert);
return (size_t)lo;
} }
else { else {
// Now that we must postpone freeing the old memory until we don't need it // Now that we must postpone freeing the old memory until we don't need it

339
tests/arrays/arrays.cpp
View File

@@ -156,60 +156,10 @@ struct Item
WX_DEFINE_ARRAY_PTR(Item *, ItemPtrArray); WX_DEFINE_ARRAY_PTR(Item *, ItemPtrArray);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// test class // the tests
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class ArraysTestCase : public CppUnit::TestCase TEST_CASE("wxArrayString", "[dynarray]")
{
public:
ArraysTestCase() { }
private:
CPPUNIT_TEST_SUITE( ArraysTestCase );
CPPUNIT_TEST( wxStringArrayTest );
CPPUNIT_TEST( SortedArray );
CPPUNIT_TEST( wxStringArraySplitTest );
CPPUNIT_TEST( wxStringArrayJoinTest );
CPPUNIT_TEST( wxStringArraySplitJoinTest );
CPPUNIT_TEST( wxObjArrayTest );
CPPUNIT_TEST( wxObjArrayPtrTest );
CPPUNIT_TEST( wxArrayUShortTest );
CPPUNIT_TEST( wxArrayIntTest );
CPPUNIT_TEST( wxArrayCharTest );
CPPUNIT_TEST( TestSTL );
CPPUNIT_TEST( Alloc );
CPPUNIT_TEST( Clear );
CPPUNIT_TEST( Swap );
CPPUNIT_TEST( IndexFromEnd );
CPPUNIT_TEST_SUITE_END();
void wxStringArrayTest();
void SortedArray();
void wxStringArraySplitTest();
void wxStringArrayJoinTest();
void wxStringArraySplitJoinTest();
void wxObjArrayTest();
void wxObjArrayPtrTest();
void wxArrayUShortTest();
void wxArrayIntTest();
void wxArrayCharTest();
void TestSTL();
void Alloc();
void Clear();
void Swap();
void IndexFromEnd();
wxDECLARE_NO_COPY_CLASS(ArraysTestCase);
};
// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( ArraysTestCase );
// also include in its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ArraysTestCase, "ArraysTestCase" );
void ArraysTestCase::wxStringArrayTest()
{ {
wxArrayString a1; wxArrayString a1;
a1.Add(wxT("thermit")); a1.Add(wxT("thermit"));
@@ -219,7 +169,7 @@ void ArraysTestCase::wxStringArrayTest()
a1.Add(wxT("human")); a1.Add(wxT("human"));
a1.Add(wxT("alligator")); a1.Add(wxT("alligator"));
CPPUNIT_ASSERT((COMPARE_8_VALUES( a1 , wxT("thermit") , CHECK((COMPARE_8_VALUES( a1 , wxT("thermit") ,
wxT("condor") , wxT("condor") ,
wxT("lion") , wxT("lion") ,
wxT("lion") , wxT("lion") ,
@@ -227,11 +177,11 @@ void ArraysTestCase::wxStringArrayTest()
wxT("dog") , wxT("dog") ,
wxT("human") , wxT("human") ,
wxT("alligator") ))); wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 8 ) ); CHECK( COMPARE_COUNT( a1 , 8 ) );
wxArrayString a2(a1); wxArrayString a2(a1);
CPPUNIT_ASSERT((COMPARE_8_VALUES( a2 , wxT("thermit") , CHECK((COMPARE_8_VALUES( a2 , wxT("thermit") ,
wxT("condor") , wxT("condor") ,
wxT("lion") , wxT("lion") ,
wxT("lion") , wxT("lion") ,
@@ -239,11 +189,11 @@ void ArraysTestCase::wxStringArrayTest()
wxT("dog") , wxT("dog") ,
wxT("human") , wxT("human") ,
wxT("alligator") ))); wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a2 , 8 ) ); CHECK( COMPARE_COUNT( a2 , 8 ) );
wxSortedArrayString a3(a1); wxSortedArrayString a3(a1);
CPPUNIT_ASSERT((COMPARE_8_VALUES( a3 , wxT("alligator") , CHECK((COMPARE_8_VALUES( a3 , wxT("alligator") ,
wxT("condor") , wxT("condor") ,
wxT("dog") , wxT("dog") ,
wxT("human") , wxT("human") ,
@@ -251,13 +201,13 @@ void ArraysTestCase::wxStringArrayTest()
wxT("lion") , wxT("lion") ,
wxT("lion") , wxT("lion") ,
wxT("thermit") ))); wxT("thermit") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a3 , 8 ) ); CHECK( COMPARE_COUNT( a3 , 8 ) );
wxSortedArrayString a4; wxSortedArrayString a4;
for (wxArrayString::iterator it = a1.begin(), en = a1.end(); it != en; ++it) for (wxArrayString::iterator it = a1.begin(), en = a1.end(); it != en; ++it)
a4.Add(*it); a4.Add(*it);
CPPUNIT_ASSERT((COMPARE_8_VALUES( a4 , wxT("alligator") , CHECK((COMPARE_8_VALUES( a4 , wxT("alligator") ,
wxT("condor") , wxT("condor") ,
wxT("dog") , wxT("dog") ,
wxT("human") , wxT("human") ,
@@ -265,97 +215,97 @@ void ArraysTestCase::wxStringArrayTest()
wxT("lion") , wxT("lion") ,
wxT("lion") , wxT("lion") ,
wxT("thermit") ))); wxT("thermit") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a4 , 8 ) ); CHECK( COMPARE_COUNT( a4 , 8 ) );
a1.RemoveAt(2,3); a1.RemoveAt(2,3);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("thermit") , CHECK((COMPARE_5_VALUES( a1 , wxT("thermit") ,
wxT("condor") , wxT("condor") ,
wxT("dog") , wxT("dog") ,
wxT("human") , wxT("human") ,
wxT("alligator") ))); wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) ); CHECK( COMPARE_COUNT( a1 , 5 ) );
a2 = a1; a2 = a1;
CPPUNIT_ASSERT((COMPARE_5_VALUES( a2 , wxT("thermit") , CHECK((COMPARE_5_VALUES( a2 , wxT("thermit") ,
wxT("condor") , wxT("condor") ,
wxT("dog") , wxT("dog") ,
wxT("human") , wxT("human") ,
wxT("alligator") ))); wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a2 , 5 ) ); CHECK( COMPARE_COUNT( a2 , 5 ) );
a1.Sort(false); a1.Sort(false);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("alligator") , CHECK((COMPARE_5_VALUES( a1 , wxT("alligator") ,
wxT("condor") , wxT("condor") ,
wxT("dog") , wxT("dog") ,
wxT("human") , wxT("human") ,
wxT("thermit") ))); wxT("thermit") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) ); CHECK( COMPARE_COUNT( a1 , 5 ) );
a1.Sort(true); a1.Sort(true);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("thermit") , CHECK((COMPARE_5_VALUES( a1 , wxT("thermit") ,
wxT("human") , wxT("human") ,
wxT("dog") , wxT("dog") ,
wxT("condor") , wxT("condor") ,
wxT("alligator") ))); wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) ); CHECK( COMPARE_COUNT( a1 , 5 ) );
a1.Sort(&StringLenCompare); a1.Sort(&StringLenCompare);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("dog") , CHECK((COMPARE_5_VALUES( a1 , wxT("dog") ,
wxT("human") , wxT("human") ,
wxT("condor") , wxT("condor") ,
wxT("thermit") , wxT("thermit") ,
wxT("alligator") ))); wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) ); CHECK( COMPARE_COUNT( a1 , 5 ) );
CPPUNIT_ASSERT( a1.Index( wxT("dog") ) == 0 ); CHECK( a1.Index( wxT("dog") ) == 0 );
CPPUNIT_ASSERT( a1.Index( wxT("human") ) == 1 ); CHECK( a1.Index( wxT("human") ) == 1 );
CPPUNIT_ASSERT( a1.Index( wxT("humann") ) == wxNOT_FOUND ); CHECK( a1.Index( wxT("humann") ) == wxNOT_FOUND );
CPPUNIT_ASSERT( a1.Index( wxT("condor") ) == 2 ); CHECK( a1.Index( wxT("condor") ) == 2 );
CPPUNIT_ASSERT( a1.Index( wxT("thermit") ) == 3 ); CHECK( a1.Index( wxT("thermit") ) == 3 );
CPPUNIT_ASSERT( a1.Index( wxT("alligator") ) == 4 ); CHECK( a1.Index( wxT("alligator") ) == 4 );
CPPUNIT_ASSERT( a1.Index( wxT("dog"), /*bCase=*/true, /*fromEnd=*/true ) == 0 ); CHECK( a1.Index( wxT("dog"), /*bCase=*/true, /*fromEnd=*/true ) == 0 );
CPPUNIT_ASSERT( a1.Index( wxT("human"), /*bCase=*/true, /*fromEnd=*/true ) == 1 ); CHECK( a1.Index( wxT("human"), /*bCase=*/true, /*fromEnd=*/true ) == 1 );
CPPUNIT_ASSERT( a1.Index( wxT("humann"), /*bCase=*/true, /*fromEnd=*/true ) == wxNOT_FOUND ); CHECK( a1.Index( wxT("humann"), /*bCase=*/true, /*fromEnd=*/true ) == wxNOT_FOUND );
CPPUNIT_ASSERT( a1.Index( wxT("condor"), /*bCase=*/true, /*fromEnd=*/true ) == 2 ); CHECK( a1.Index( wxT("condor"), /*bCase=*/true, /*fromEnd=*/true ) == 2 );
CPPUNIT_ASSERT( a1.Index( wxT("thermit"), /*bCase=*/true, /*fromEnd=*/true ) == 3 ); CHECK( a1.Index( wxT("thermit"), /*bCase=*/true, /*fromEnd=*/true ) == 3 );
CPPUNIT_ASSERT( a1.Index( wxT("alligator"), /*bCase=*/true, /*fromEnd=*/true ) == 4 ); CHECK( a1.Index( wxT("alligator"), /*bCase=*/true, /*fromEnd=*/true ) == 4 );
wxArrayString a5; wxArrayString a5;
CPPUNIT_ASSERT( a5.Add( wxT("x"), 1 ) == 0 ); CHECK( a5.Add( wxT("x"), 1 ) == 0 );
CPPUNIT_ASSERT( a5.Add( wxT("a"), 3 ) == 1 ); CHECK( a5.Add( wxT("a"), 3 ) == 1 );
CPPUNIT_ASSERT((COMPARE_4_VALUES( a5, wxT("x") , CHECK((COMPARE_4_VALUES( a5, wxT("x") ,
wxT("a") , wxT("a") ,
wxT("a") , wxT("a") ,
wxT("a") ))); wxT("a") )));
a5.assign(a1.end(), a1.end()); a5.assign(a1.end(), a1.end());
CPPUNIT_ASSERT( a5.empty() ); CHECK( a5.empty() );
a5.assign(a1.begin(), a1.end()); a5.assign(a1.begin(), a1.end());
CPPUNIT_ASSERT( a5 == a1 ); CHECK( a5 == a1 );
const wxString months[] = { "Jan", "Feb", "Mar" }; const wxString months[] = { "Jan", "Feb", "Mar" };
a5.assign(months, months + WXSIZEOF(months)); a5.assign(months, months + WXSIZEOF(months));
CPPUNIT_ASSERT_EQUAL( WXSIZEOF(months), a5.size() ); CHECK( a5.size() == WXSIZEOF(months) );
CPPUNIT_ASSERT((COMPARE_3_VALUES(a5, "Jan", "Feb", "Mar"))); CHECK((COMPARE_3_VALUES(a5, "Jan", "Feb", "Mar")));
a5.clear(); a5.clear();
CPPUNIT_ASSERT_EQUAL( 0, a5.size() ); CHECK( a5.size() == 0 );
a5.resize(7, "Foo"); a5.resize(7, "Foo");
CPPUNIT_ASSERT_EQUAL( 7, a5.size() ); CHECK( a5.size() == 7 );
CPPUNIT_ASSERT_EQUAL( "Foo", a5[3] ); CHECK( a5[3] == "Foo" );
a5.resize(3); a5.resize(3);
CPPUNIT_ASSERT_EQUAL( 3, a5.size() ); CHECK( a5.size() == 3 );
CPPUNIT_ASSERT_EQUAL( "Foo", a5[2] ); CHECK( a5[2] == "Foo" );
wxArrayString a6; wxArrayString a6;
a6.Add("Foo"); a6.Add("Foo");
@@ -367,41 +317,46 @@ void ArraysTestCase::wxStringArrayTest()
wxArrayString a7; wxArrayString a7;
a7 = a7; a7 = a7;
CPPUNIT_ASSERT_EQUAL( 0, a7.size() ); CHECK( a7.size() == 0 );
a7.Add("Bar"); a7.Add("Bar");
a7 = a7; a7 = a7;
CPPUNIT_ASSERT_EQUAL( 1, a7.size() ); CHECK( a7.size() == 1 );
wxCLANG_WARNING_RESTORE(self-assign-overloaded) wxCLANG_WARNING_RESTORE(self-assign-overloaded)
} }
void ArraysTestCase::SortedArray() TEST_CASE("wxSortedArrayString", "[dynarray]")
{ {
wxSortedArrayString a; wxSortedArrayString a;
a.Add("d"); a.Add("d");
a.Add("c"); a.Add("c");
CPPUNIT_ASSERT_EQUAL( 0, a.Index("c") ); CHECK( a.Index("c") == 0 );
a.push_back("b"); a.push_back("b");
a.push_back("a"); a.push_back("a");
CPPUNIT_ASSERT_EQUAL( 0, a.Index("a") ); CHECK( a.Index("a") == 0 );
wxSortedArrayString ar(wxStringSortDescending); wxSortedArrayString ar(wxStringSortDescending);
ar.Add("a"); ar.Add("a");
ar.Add("b"); ar.Add("b");
CPPUNIT_ASSERT_EQUAL( "b", ar[0] ); CHECK( ar[0] == "b" );
CPPUNIT_ASSERT_EQUAL( "a", ar[1] ); CHECK( ar[1] == "a" );
wxSortedArrayString ad(wxDictionaryStringSortAscending); wxSortedArrayString ad(wxDictionaryStringSortAscending);
ad.Add("AB"); ad.Add("AB");
ad.Add("a"); ad.Add("a");
ad.Add("Aa"); ad.Add("Aa");
CPPUNIT_ASSERT_EQUAL( "a", ad[0] ); CHECK( ad[0] == "a" );
CPPUNIT_ASSERT_EQUAL( "Aa", ad[1] ); CHECK( ad[1] == "Aa" );
CHECK( ad.Index("a") == 0 );
CHECK( ad.Index("Aa") == 1 );
CHECK( ad.Index("AB") == 2 );
CHECK( ad.Index("A") == wxNOT_FOUND );
CHECK( ad.Index("z") == wxNOT_FOUND );
} }
void ArraysTestCase::wxStringArraySplitTest() TEST_CASE("Arrays::Split", "[dynarray]")
{ {
// test wxSplit: // test wxSplit:
@@ -413,7 +368,7 @@ void ArraysTestCase::wxStringArraySplitTest()
wxArrayString exparr(WXSIZEOF(expected), expected); wxArrayString exparr(WXSIZEOF(expected), expected);
wxArrayString realarr(wxSplit(str, wxT(','))); wxArrayString realarr(wxSplit(str, wxT(',')));
CPPUNIT_ASSERT( exparr == realarr ); CHECK( exparr == realarr );
} }
{ {
@@ -426,12 +381,12 @@ void ArraysTestCase::wxStringArraySplitTest()
// escaping on: // escaping on:
wxArrayString exparr(WXSIZEOF(expected), expected); wxArrayString exparr(WXSIZEOF(expected), expected);
wxArrayString realarr(wxSplit(str, wxT(','), wxT('\\'))); wxArrayString realarr(wxSplit(str, wxT(','), wxT('\\')));
CPPUNIT_ASSERT( exparr == realarr ); CHECK( exparr == realarr );
// escaping turned off: // escaping turned off:
wxArrayString exparr2(WXSIZEOF(expected2), expected2); wxArrayString exparr2(WXSIZEOF(expected2), expected2);
wxArrayString realarr2(wxSplit(str, wxT(','), wxT('\0'))); wxArrayString realarr2(wxSplit(str, wxT(','), wxT('\0')));
CPPUNIT_ASSERT( exparr2 == realarr2 ); CHECK( exparr2 == realarr2 );
} }
{ {
@@ -447,16 +402,16 @@ void ArraysTestCase::wxStringArraySplitTest()
// escaping on: // escaping on:
wxArrayString exparr(WXSIZEOF(expected), expected); wxArrayString exparr(WXSIZEOF(expected), expected);
wxArrayString realarr(wxSplit(str, wxT(','), wxT('\\'))); wxArrayString realarr(wxSplit(str, wxT(','), wxT('\\')));
CPPUNIT_ASSERT( exparr == realarr ); CHECK( exparr == realarr );
// escaping turned off: // escaping turned off:
wxArrayString exparr2(WXSIZEOF(expected2), expected2); wxArrayString exparr2(WXSIZEOF(expected2), expected2);
wxArrayString realarr2(wxSplit(str, wxT(','), wxT('\0'))); wxArrayString realarr2(wxSplit(str, wxT(','), wxT('\0')));
CPPUNIT_ASSERT( exparr2 == realarr2 ); CHECK( exparr2 == realarr2 );
} }
} }
void ArraysTestCase::wxStringArrayJoinTest() TEST_CASE("Arrays::Join", "[dynarray]")
{ {
// test wxJoin: // test wxJoin:
@@ -466,7 +421,7 @@ void ArraysTestCase::wxStringArrayJoinTest()
wxArrayString arrstr(WXSIZEOF(arr), arr); wxArrayString arrstr(WXSIZEOF(arr), arr);
wxString result = wxJoin(arrstr, wxT(',')); wxString result = wxJoin(arrstr, wxT(','));
CPPUNIT_ASSERT( expected == result ); CHECK( expected == result );
} }
{ {
@@ -477,11 +432,11 @@ void ArraysTestCase::wxStringArrayJoinTest()
// escaping on: // escaping on:
wxArrayString arrstr(WXSIZEOF(arr), arr); wxArrayString arrstr(WXSIZEOF(arr), arr);
wxString result = wxJoin(arrstr, wxT(','), wxT('\\')); wxString result = wxJoin(arrstr, wxT(','), wxT('\\'));
CPPUNIT_ASSERT( expected == result ); CHECK( expected == result );
// escaping turned off: // escaping turned off:
wxString result2 = wxJoin(arrstr, wxT(','), wxT('\0')); wxString result2 = wxJoin(arrstr, wxT(','), wxT('\0'));
CPPUNIT_ASSERT( expected2 == result2 ); CHECK( expected2 == result2 );
} }
{ {
@@ -493,15 +448,15 @@ void ArraysTestCase::wxStringArrayJoinTest()
// escaping on: // escaping on:
wxArrayString arrstr(WXSIZEOF(arr), arr); wxArrayString arrstr(WXSIZEOF(arr), arr);
wxString result = wxJoin(arrstr, wxT(','), wxT('\\')); wxString result = wxJoin(arrstr, wxT(','), wxT('\\'));
CPPUNIT_ASSERT( expected == result ); CHECK( expected == result );
// escaping turned off: // escaping turned off:
wxString result2 = wxJoin(arrstr, wxT(','), wxT('\0')); wxString result2 = wxJoin(arrstr, wxT(','), wxT('\0'));
CPPUNIT_ASSERT( expected2 == result2 ); CHECK( expected2 == result2 );
} }
} }
void ArraysTestCase::wxStringArraySplitJoinTest() TEST_CASE("Arrays::SplitJoin", "[dynarray]")
{ {
wxChar separators[] = { wxT('a'), wxT(','), wxT('_'), wxT(' '), wxT('\\'), wxChar separators[] = { wxT('a'), wxT(','), wxT('_'), wxT(' '), wxT('\\'),
wxT('&'), wxT('{'), wxT('A'), wxT('<'), wxT('>'), wxT('&'), wxT('{'), wxT('A'), wxT('<'), wxT('>'),
@@ -526,7 +481,7 @@ void ArraysTestCase::wxStringArraySplitJoinTest()
for (i = 0; i < WXSIZEOF(separators); i++) for (i = 0; i < WXSIZEOF(separators); i++)
{ {
wxArrayString arr = wxSplit(str, separators[i]); wxArrayString arr = wxSplit(str, separators[i]);
CPPUNIT_ASSERT( str == wxJoin(arr, separators[i]) ); CHECK( str == wxJoin(arr, separators[i]) );
} }
@@ -543,56 +498,56 @@ void ArraysTestCase::wxStringArraySplitJoinTest()
for (i = 0; i < WXSIZEOF(separators); i++) for (i = 0; i < WXSIZEOF(separators); i++)
{ {
wxString string = wxJoin(theArr, separators[i]); wxString string = wxJoin(theArr, separators[i]);
CPPUNIT_ASSERT( theArr == wxSplit(string, separators[i]) ); CHECK( theArr == wxSplit(string, separators[i]) );
} }
wxArrayString emptyArray; wxArrayString emptyArray;
wxString string = wxJoin(emptyArray, wxT(';')); wxString string = wxJoin(emptyArray, wxT(';'));
CPPUNIT_ASSERT( string.empty() ); CHECK( string.empty() );
CPPUNIT_ASSERT( wxSplit(string, wxT(';')).empty() ); CHECK( wxSplit(string, wxT(';')).empty() );
CPPUNIT_ASSERT_EQUAL( 2, wxSplit(wxT(";"), wxT(';')).size() ); CHECK( wxSplit(wxT(";"), wxT(';')).size() == 2 );
} }
void ArraysTestCase::wxObjArrayTest() TEST_CASE("wxObjArray", "[dynarray]")
{ {
{ {
ArrayBars bars; ArrayBars bars;
Bar bar(wxT("first bar in general, second bar in array (two copies!)")); Bar bar(wxT("first bar in general, second bar in array (two copies!)"));
CPPUNIT_ASSERT_EQUAL( 0, bars.GetCount() ); CHECK( bars.GetCount() == 0 );
CPPUNIT_ASSERT_EQUAL( 1, Bar::GetNumber() ); CHECK( Bar::GetNumber() == 1 );
bars.Add(new Bar(wxT("first bar in array"))); bars.Add(new Bar(wxT("first bar in array")));
bars.Add(bar, 2); bars.Add(bar, 2);
CPPUNIT_ASSERT_EQUAL( 3, bars.GetCount() ); CHECK( bars.GetCount() == 3 );
CPPUNIT_ASSERT_EQUAL( 4, Bar::GetNumber() ); CHECK( Bar::GetNumber() == 4 );
bars.RemoveAt(1, bars.GetCount() - 1); bars.RemoveAt(1, bars.GetCount() - 1);
CPPUNIT_ASSERT_EQUAL( 1, bars.GetCount() ); CHECK( bars.GetCount() == 1 );
CPPUNIT_ASSERT_EQUAL( 2, Bar::GetNumber() ); CHECK( Bar::GetNumber() == 2 );
bars.Empty(); bars.Empty();
CPPUNIT_ASSERT_EQUAL( 0, bars.GetCount() ); CHECK( bars.GetCount() == 0 );
CPPUNIT_ASSERT_EQUAL( 1, Bar::GetNumber() ); CHECK( Bar::GetNumber() == 1 );
} }
CPPUNIT_ASSERT_EQUAL( 0, Bar::GetNumber() ); CHECK( Bar::GetNumber() == 0 );
} }
void ArraysTestCase::wxObjArrayPtrTest() TEST_CASE("wxObjArrayPtr", "[dynarray]")
{ {
// Just check that instantiating this class compiles. // Just check that instantiating this class compiles.
ArrayBarPtrs barptrs; ArrayBarPtrs barptrs;
CPPUNIT_ASSERT_EQUAL( 0, barptrs.size() ); CHECK( barptrs.size() == 0 );
} }
#define TestArrayOf(name) \ #define TestArrayOf(name) \
\ \
void ArraysTestCase::wxArray ## name ## Test() \ TEST_CASE("wxDynArray::" #name, "[dynarray]") \
{ \ { \
wxArray##name a; \ wxArray##name a; \
a.Add(1); \ a.Add(1); \
@@ -600,18 +555,18 @@ void ArraysTestCase::wxArray ## name ## Test() \
a.Add(5,3); \ a.Add(5,3); \
a.Add(3,4); \ a.Add(3,4); \
\ \
CPPUNIT_ASSERT((COMPARE_10_VALUES(a,1,17,17,5,5,5,3,3,3,3))); \ CHECK((COMPARE_10_VALUES(a,1,17,17,5,5,5,3,3,3,3))); \
CPPUNIT_ASSERT( COMPARE_COUNT( a , 10 ) ); \ CHECK( COMPARE_COUNT( a , 10 ) ); \
\ \
a.Sort(name ## Compare); \ a.Sort(name ## Compare); \
\ \
CPPUNIT_ASSERT((COMPARE_10_VALUES(a,1,3,3,3,3,5,5,5,17,17))); \ CHECK((COMPARE_10_VALUES(a,1,3,3,3,3,5,5,5,17,17))); \
CPPUNIT_ASSERT( COMPARE_COUNT( a , 10 ) ); \ CHECK( COMPARE_COUNT( a , 10 ) ); \
\ \
a.Sort(name ## RevCompare); \ a.Sort(name ## RevCompare); \
\ \
CPPUNIT_ASSERT((COMPARE_10_VALUES(a,17,17,5,5,5,3,3,3,3,1))); \ CHECK((COMPARE_10_VALUES(a,17,17,5,5,5,3,3,3,3,1))); \
CPPUNIT_ASSERT( COMPARE_COUNT( a , 10 ) ); \ CHECK( COMPARE_COUNT( a , 10 ) ); \
\ \
wxSortedArray##name b; \ wxSortedArray##name b; \
\ \
@@ -620,15 +575,15 @@ void ArraysTestCase::wxArray ## name ## Test() \
b.Add(5); \ b.Add(5); \
b.Add(3); \ b.Add(3); \
\ \
CPPUNIT_ASSERT((COMPARE_4_VALUES(b,1,3,5,17))); \ CHECK((COMPARE_4_VALUES(b,1,3,5,17))); \
CPPUNIT_ASSERT( COMPARE_COUNT( b , 4 ) ); \ CHECK( COMPARE_COUNT( b , 4 ) ); \
CPPUNIT_ASSERT( b.Index( 0 ) == wxNOT_FOUND ); \ CHECK( b.Index( 0 ) == wxNOT_FOUND ); \
CPPUNIT_ASSERT( b.Index( 1 ) == 0 ); \ CHECK( b.Index( 1 ) == 0 ); \
CPPUNIT_ASSERT( b.Index( 3 ) == 1 ); \ CHECK( b.Index( 3 ) == 1 ); \
CPPUNIT_ASSERT( b.Index( 4 ) == wxNOT_FOUND ); \ CHECK( b.Index( 4 ) == wxNOT_FOUND ); \
CPPUNIT_ASSERT( b.Index( 5 ) == 2 ); \ CHECK( b.Index( 5 ) == 2 ); \
CPPUNIT_ASSERT( b.Index( 6 ) == wxNOT_FOUND ); \ CHECK( b.Index( 6 ) == wxNOT_FOUND ); \
CPPUNIT_ASSERT( b.Index( 17 ) == 3 ); \ CHECK( b.Index( 17 ) == 3 ); \
} }
TestArrayOf(UShort) TestArrayOf(UShort)
@@ -637,33 +592,33 @@ TestArrayOf(Char)
TestArrayOf(Int) TestArrayOf(Int)
void ArraysTestCase::Alloc() TEST_CASE("wxDynArray::Alloc", "[dynarray]")
{ {
wxArrayInt a; wxArrayInt a;
a.Add(17); a.Add(17);
a.Add(9); a.Add(9);
CPPUNIT_ASSERT_EQUAL( 2, a.GetCount() ); CHECK( a.GetCount() == 2 );
a.Alloc(1000); a.Alloc(1000);
CPPUNIT_ASSERT_EQUAL( 2, a.GetCount() ); CHECK( a.GetCount() == 2 );
CPPUNIT_ASSERT_EQUAL( 17, a[0] ); CHECK( a[0] == 17 );
CPPUNIT_ASSERT_EQUAL( 9, a[1] ); CHECK( a[1] == 9 );
} }
void ArraysTestCase::Clear() TEST_CASE("wxDynArray::Clear", "[dynarray]")
{ {
ItemPtrArray items; ItemPtrArray items;
WX_CLEAR_ARRAY(items); WX_CLEAR_ARRAY(items);
CPPUNIT_ASSERT_EQUAL( 0, items.size() ); CHECK( items.size() == 0 );
items.push_back(new Item(17)); items.push_back(new Item(17));
items.push_back(new Item(71)); items.push_back(new Item(71));
CPPUNIT_ASSERT_EQUAL( 2, items.size() ); CHECK( items.size() == 2 );
WX_CLEAR_ARRAY(items); WX_CLEAR_ARRAY(items);
CPPUNIT_ASSERT_EQUAL( 0, items.size() ); CHECK( items.size() == 0 );
} }
namespace namespace
@@ -674,30 +629,30 @@ void DoTestSwap(T v1, T v2, T v3)
{ {
A a1, a2; A a1, a2;
a1.swap(a2); a1.swap(a2);
CPPUNIT_ASSERT( a1.empty() ); CHECK( a1.empty() );
CPPUNIT_ASSERT( a2.empty() ); CHECK( a2.empty() );
a1.push_back(v1); a1.push_back(v1);
a1.swap(a2); a1.swap(a2);
CPPUNIT_ASSERT( a1.empty() ); CHECK( a1.empty() );
CPPUNIT_ASSERT_EQUAL( 1, a2.size() ); CHECK( a2.size() == 1 );
a1.push_back(v2); a1.push_back(v2);
a1.push_back(v3); a1.push_back(v3);
a2.swap(a1); a2.swap(a1);
CPPUNIT_ASSERT_EQUAL( 1, a1.size() ); CHECK( a1.size() == 1 );
CPPUNIT_ASSERT_EQUAL( 2, a2.size() ); CHECK( a2.size() == 2 );
CPPUNIT_ASSERT_EQUAL( v1, a1[0] ); CHECK( a1[0] == v1 );
CPPUNIT_ASSERT_EQUAL( v3, a2[1] ); CHECK( a2[1] == v3 );
a1.swap(a2); a1.swap(a2);
CPPUNIT_ASSERT_EQUAL( 2, a1.size() ); CHECK( a1.size() == 2 );
CPPUNIT_ASSERT_EQUAL( 1, a2.size() ); CHECK( a2.size() == 1 );
} }
} // anonymous namespace } // anonymous namespace
void ArraysTestCase::Swap() TEST_CASE("wxDynArray::Swap", "[dynarray]")
{ {
DoTestSwap<wxArrayString>("Foo", "Bar", "Baz"); DoTestSwap<wxArrayString>("Foo", "Bar", "Baz");
@@ -705,7 +660,7 @@ void ArraysTestCase::Swap()
DoTestSwap<wxArrayLong>(6, 28, 496); DoTestSwap<wxArrayLong>(6, 28, 496);
} }
void ArraysTestCase::TestSTL() TEST_CASE("wxDynArray::TestSTL", "[dynarray]")
{ {
wxArrayInt list1; wxArrayInt list1;
wxArrayInt::iterator it, en; wxArrayInt::iterator it, en;
@@ -716,35 +671,35 @@ void ArraysTestCase::TestSTL()
for ( i = 0; i < COUNT; ++i ) for ( i = 0; i < COUNT; ++i )
list1.push_back(i); list1.push_back(i);
CPPUNIT_ASSERT( list1.capacity() >= (size_t)COUNT ); CHECK( list1.capacity() >= (size_t)COUNT );
CPPUNIT_ASSERT_EQUAL( COUNT, list1.size() ); CHECK( list1.size() == COUNT );
for ( it = list1.begin(), en = list1.end(), i = 0; for ( it = list1.begin(), en = list1.end(), i = 0;
it != en; ++it, ++i ) it != en; ++it, ++i )
{ {
CPPUNIT_ASSERT( *it == i ); CHECK( *it == i );
} }
CPPUNIT_ASSERT_EQUAL( COUNT, i ); CHECK( i == COUNT );
for ( rit = list1.rbegin(), ren = list1.rend(), i = COUNT; for ( rit = list1.rbegin(), ren = list1.rend(), i = COUNT;
rit != ren; ++rit, --i ) rit != ren; ++rit, --i )
{ {
CPPUNIT_ASSERT( *rit == i-1 ); CHECK( *rit == i-1 );
} }
CPPUNIT_ASSERT_EQUAL( 0, i ); CHECK( i == 0 );
CPPUNIT_ASSERT( *list1.rbegin() == *(list1.end()-1) ); CHECK( *list1.rbegin() == *(list1.end()-1) );
CPPUNIT_ASSERT( *list1.begin() == *(list1.rend()-1) ); CHECK( *list1.begin() == *(list1.rend()-1) );
it = list1.begin()+1; it = list1.begin()+1;
rit = list1.rbegin()+1; rit = list1.rbegin()+1;
CPPUNIT_ASSERT( *list1.begin() == *(it-1) ); CHECK( *list1.begin() == *(it-1) );
CPPUNIT_ASSERT( *list1.rbegin() == *(rit-1) ); CHECK( *list1.rbegin() == *(rit-1) );
CPPUNIT_ASSERT( list1.front() == 0 ); CHECK( list1.front() == 0 );
CPPUNIT_ASSERT( list1.back() == COUNT - 1 ); CHECK( list1.back() == COUNT - 1 );
list1.erase(list1.begin()); list1.erase(list1.begin());
list1.erase(list1.end()-1); list1.erase(list1.end()-1);
@@ -752,30 +707,30 @@ void ArraysTestCase::TestSTL()
for ( it = list1.begin(), en = list1.end(), i = 1; for ( it = list1.begin(), en = list1.end(), i = 1;
it != en; ++it, ++i ) it != en; ++it, ++i )
{ {
CPPUNIT_ASSERT( *it == i ); CHECK( *it == i );
} }
ItemPtrArray items; ItemPtrArray items;
items.push_back(new Item(17)); items.push_back(new Item(17));
CPPUNIT_ASSERT_EQUAL( 17, (*(items.rbegin()))->n ); CHECK( (*(items.rbegin()))->n == 17 );
CPPUNIT_ASSERT_EQUAL( 17, (**items.begin()).n ); CHECK( (**items.begin()).n == 17 );
WX_CLEAR_ARRAY(items); WX_CLEAR_ARRAY(items);
} }
void ArraysTestCase::IndexFromEnd() TEST_CASE("wxDynArray::IndexFromEnd", "[dynarray]")
{ {
wxArrayInt a; wxArrayInt a;
a.push_back(10); a.push_back(10);
a.push_back(1); a.push_back(1);
a.push_back(42); a.push_back(42);
CPPUNIT_ASSERT_EQUAL( 0, a.Index(10) ); CHECK( a.Index(10) == 0 );
CPPUNIT_ASSERT_EQUAL( 1, a.Index(1) ); CHECK( a.Index(1) == 1 );
CPPUNIT_ASSERT_EQUAL( 2, a.Index(42) ); CHECK( a.Index(42) == 2 );
CPPUNIT_ASSERT_EQUAL( 0, a.Index(10, /*bFromEnd=*/true) ); CHECK( a.Index(10, /*bFromEnd=*/true) == 0 );
CPPUNIT_ASSERT_EQUAL( 1, a.Index(1, /*bFromEnd=*/true) ); CHECK( a.Index( 1, /*bFromEnd=*/true) == 1 );
CPPUNIT_ASSERT_EQUAL( 2, a.Index(42, /*bFromEnd=*/true) ); CHECK( a.Index(42, /*bFromEnd=*/true) == 2 );
} }