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).
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
m_nCount; // current number of elements

3
include/wx/dynarray.h
View File

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

77
src/common/arrstr.cpp
View File

@@ -198,15 +198,16 @@ int wxSortedArrayString::Index(const wxString& str,
wxASSERT_MSG( bCase && !bFromEnd,
"search parameters ignored for sorted array" );
SCMPFUNC function = GetCompareFunction();
wxSortedArrayString::const_iterator
it = std::lower_bound(begin(), end(), str,
#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
wxStringCompare(wxStringCmp())
wxStringCompare(function)
#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)
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
wxASSERT_MSG( bCase && !bFromEnd,
wxT("search parameters ignored for auto sorted array") );
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;
return BinarySearch(str, false /* not lower bound */);
}
else {
// use linear search in unsorted array
@@ -432,30 +438,9 @@ size_t wxArrayString::Add(const wxString& str, size_t nInsert)
{
if ( m_autoSort ) {
// insert the string at the correct position to keep the array sorted
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 {
lo = hi = i;
break;
}
}
wxASSERT_MSG( lo == hi, wxT("binary search broken") );
Insert(str, lo, nInsert);
return (size_t)lo;
size_t nIndex = BinarySearch(str, true /* return lower bound */);
Insert(str, nIndex, nInsert);
return nIndex;
}
else {
// 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);
// ----------------------------------------------------------------------------
// test class
// the tests
// ----------------------------------------------------------------------------
class ArraysTestCase : public CppUnit::TestCase
{
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()
TEST_CASE("wxArrayString", "[dynarray]")
{
wxArrayString a1;
a1.Add(wxT("thermit"));
@@ -219,7 +169,7 @@ void ArraysTestCase::wxStringArrayTest()
a1.Add(wxT("human"));
a1.Add(wxT("alligator"));
CPPUNIT_ASSERT((COMPARE_8_VALUES( a1 , wxT("thermit") ,
CHECK((COMPARE_8_VALUES( a1 , wxT("thermit") ,
wxT("condor") ,
wxT("lion") ,
wxT("lion") ,
@@ -227,11 +177,11 @@ void ArraysTestCase::wxStringArrayTest()
wxT("dog") ,
wxT("human") ,
wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 8 ) );
CHECK( COMPARE_COUNT( a1 , 8 ) );
wxArrayString a2(a1);
CPPUNIT_ASSERT((COMPARE_8_VALUES( a2 , wxT("thermit") ,
CHECK((COMPARE_8_VALUES( a2 , wxT("thermit") ,
wxT("condor") ,
wxT("lion") ,
wxT("lion") ,
@@ -239,11 +189,11 @@ void ArraysTestCase::wxStringArrayTest()
wxT("dog") ,
wxT("human") ,
wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a2 , 8 ) );
CHECK( COMPARE_COUNT( a2 , 8 ) );
wxSortedArrayString a3(a1);
CPPUNIT_ASSERT((COMPARE_8_VALUES( a3 , wxT("alligator") ,
CHECK((COMPARE_8_VALUES( a3 , wxT("alligator") ,
wxT("condor") ,
wxT("dog") ,
wxT("human") ,
@@ -251,13 +201,13 @@ void ArraysTestCase::wxStringArrayTest()
wxT("lion") ,
wxT("lion") ,
wxT("thermit") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a3 , 8 ) );
CHECK( COMPARE_COUNT( a3 , 8 ) );
wxSortedArrayString a4;
for (wxArrayString::iterator it = a1.begin(), en = a1.end(); it != en; ++it)
a4.Add(*it);
CPPUNIT_ASSERT((COMPARE_8_VALUES( a4 , wxT("alligator") ,
CHECK((COMPARE_8_VALUES( a4 , wxT("alligator") ,
wxT("condor") ,
wxT("dog") ,
wxT("human") ,
@@ -265,97 +215,97 @@ void ArraysTestCase::wxStringArrayTest()
wxT("lion") ,
wxT("lion") ,
wxT("thermit") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a4 , 8 ) );
CHECK( COMPARE_COUNT( a4 , 8 ) );
a1.RemoveAt(2,3);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("thermit") ,
CHECK((COMPARE_5_VALUES( a1 , wxT("thermit") ,
wxT("condor") ,
wxT("dog") ,
wxT("human") ,
wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) );
CHECK( COMPARE_COUNT( a1 , 5 ) );
a2 = a1;
CPPUNIT_ASSERT((COMPARE_5_VALUES( a2 , wxT("thermit") ,
CHECK((COMPARE_5_VALUES( a2 , wxT("thermit") ,
wxT("condor") ,
wxT("dog") ,
wxT("human") ,
wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a2 , 5 ) );
CHECK( COMPARE_COUNT( a2 , 5 ) );
a1.Sort(false);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("alligator") ,
CHECK((COMPARE_5_VALUES( a1 , wxT("alligator") ,
wxT("condor") ,
wxT("dog") ,
wxT("human") ,
wxT("thermit") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) );
CHECK( COMPARE_COUNT( a1 , 5 ) );
a1.Sort(true);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("thermit") ,
CHECK((COMPARE_5_VALUES( a1 , wxT("thermit") ,
wxT("human") ,
wxT("dog") ,
wxT("condor") ,
wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) );
CHECK( COMPARE_COUNT( a1 , 5 ) );
a1.Sort(&StringLenCompare);
CPPUNIT_ASSERT((COMPARE_5_VALUES( a1 , wxT("dog") ,
CHECK((COMPARE_5_VALUES( a1 , wxT("dog") ,
wxT("human") ,
wxT("condor") ,
wxT("thermit") ,
wxT("alligator") )));
CPPUNIT_ASSERT( COMPARE_COUNT( a1 , 5 ) );
CPPUNIT_ASSERT( a1.Index( wxT("dog") ) == 0 );
CPPUNIT_ASSERT( a1.Index( wxT("human") ) == 1 );
CPPUNIT_ASSERT( a1.Index( wxT("humann") ) == wxNOT_FOUND );
CPPUNIT_ASSERT( a1.Index( wxT("condor") ) == 2 );
CPPUNIT_ASSERT( a1.Index( wxT("thermit") ) == 3 );
CPPUNIT_ASSERT( a1.Index( wxT("alligator") ) == 4 );
CHECK( COMPARE_COUNT( a1 , 5 ) );
CHECK( a1.Index( wxT("dog") ) == 0 );
CHECK( a1.Index( wxT("human") ) == 1 );
CHECK( a1.Index( wxT("humann") ) == wxNOT_FOUND );
CHECK( a1.Index( wxT("condor") ) == 2 );
CHECK( a1.Index( wxT("thermit") ) == 3 );
CHECK( a1.Index( wxT("alligator") ) == 4 );
CPPUNIT_ASSERT( a1.Index( wxT("dog"), /*bCase=*/true, /*fromEnd=*/true ) == 0 );
CPPUNIT_ASSERT( a1.Index( wxT("human"), /*bCase=*/true, /*fromEnd=*/true ) == 1 );
CPPUNIT_ASSERT( a1.Index( wxT("humann"), /*bCase=*/true, /*fromEnd=*/true ) == wxNOT_FOUND );
CPPUNIT_ASSERT( a1.Index( wxT("condor"), /*bCase=*/true, /*fromEnd=*/true ) == 2 );
CPPUNIT_ASSERT( a1.Index( wxT("thermit"), /*bCase=*/true, /*fromEnd=*/true ) == 3 );
CPPUNIT_ASSERT( a1.Index( wxT("alligator"), /*bCase=*/true, /*fromEnd=*/true ) == 4 );
CHECK( a1.Index( wxT("dog"), /*bCase=*/true, /*fromEnd=*/true ) == 0 );
CHECK( a1.Index( wxT("human"), /*bCase=*/true, /*fromEnd=*/true ) == 1 );
CHECK( a1.Index( wxT("humann"), /*bCase=*/true, /*fromEnd=*/true ) == wxNOT_FOUND );
CHECK( a1.Index( wxT("condor"), /*bCase=*/true, /*fromEnd=*/true ) == 2 );
CHECK( a1.Index( wxT("thermit"), /*bCase=*/true, /*fromEnd=*/true ) == 3 );
CHECK( a1.Index( wxT("alligator"), /*bCase=*/true, /*fromEnd=*/true ) == 4 );
wxArrayString a5;
CPPUNIT_ASSERT( a5.Add( wxT("x"), 1 ) == 0 );
CPPUNIT_ASSERT( a5.Add( wxT("a"), 3 ) == 1 );
CHECK( a5.Add( wxT("x"), 1 ) == 0 );
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") )));
a5.assign(a1.end(), a1.end());
CPPUNIT_ASSERT( a5.empty() );
CHECK( a5.empty() );
a5.assign(a1.begin(), a1.end());
CPPUNIT_ASSERT( a5 == a1 );
CHECK( a5 == a1 );
const wxString months[] = { "Jan", "Feb", "Mar" };
a5.assign(months, months + WXSIZEOF(months));
CPPUNIT_ASSERT_EQUAL( WXSIZEOF(months), a5.size() );
CPPUNIT_ASSERT((COMPARE_3_VALUES(a5, "Jan", "Feb", "Mar")));
CHECK( a5.size() == WXSIZEOF(months) );
CHECK((COMPARE_3_VALUES(a5, "Jan", "Feb", "Mar")));
a5.clear();
CPPUNIT_ASSERT_EQUAL( 0, a5.size() );
CHECK( a5.size() == 0 );
a5.resize(7, "Foo");
CPPUNIT_ASSERT_EQUAL( 7, a5.size() );
CPPUNIT_ASSERT_EQUAL( "Foo", a5[3] );
CHECK( a5.size() == 7 );
CHECK( a5[3] == "Foo" );
a5.resize(3);
CPPUNIT_ASSERT_EQUAL( 3, a5.size() );
CPPUNIT_ASSERT_EQUAL( "Foo", a5[2] );
CHECK( a5.size() == 3 );
CHECK( a5[2] == "Foo" );
wxArrayString a6;
a6.Add("Foo");
@@ -367,41 +317,46 @@ void ArraysTestCase::wxStringArrayTest()
wxArrayString a7;
a7 = a7;
CPPUNIT_ASSERT_EQUAL( 0, a7.size() );
CHECK( a7.size() == 0 );
a7.Add("Bar");
a7 = a7;
CPPUNIT_ASSERT_EQUAL( 1, a7.size() );
CHECK( a7.size() == 1 );
wxCLANG_WARNING_RESTORE(self-assign-overloaded)
}
void ArraysTestCase::SortedArray()
TEST_CASE("wxSortedArrayString", "[dynarray]")
{
wxSortedArrayString a;
a.Add("d");
a.Add("c");
CPPUNIT_ASSERT_EQUAL( 0, a.Index("c") );
CHECK( a.Index("c") == 0 );
a.push_back("b");
a.push_back("a");
CPPUNIT_ASSERT_EQUAL( 0, a.Index("a") );
CHECK( a.Index("a") == 0 );
wxSortedArrayString ar(wxStringSortDescending);
ar.Add("a");
ar.Add("b");
CPPUNIT_ASSERT_EQUAL( "b", ar[0] );
CPPUNIT_ASSERT_EQUAL( "a", ar[1] );
CHECK( ar[0] == "b" );
CHECK( ar[1] == "a" );
wxSortedArrayString ad(wxDictionaryStringSortAscending);
ad.Add("AB");
ad.Add("a");
ad.Add("Aa");
CPPUNIT_ASSERT_EQUAL( "a", ad[0] );
CPPUNIT_ASSERT_EQUAL( "Aa", ad[1] );
CHECK( ad[0] == "a" );
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:
@@ -413,7 +368,7 @@ void ArraysTestCase::wxStringArraySplitTest()
wxArrayString exparr(WXSIZEOF(expected), expected);
wxArrayString realarr(wxSplit(str, wxT(',')));
CPPUNIT_ASSERT( exparr == realarr );
CHECK( exparr == realarr );
}
{
@@ -426,12 +381,12 @@ void ArraysTestCase::wxStringArraySplitTest()
// escaping on:
wxArrayString exparr(WXSIZEOF(expected), expected);
wxArrayString realarr(wxSplit(str, wxT(','), wxT('\\')));
CPPUNIT_ASSERT( exparr == realarr );
CHECK( exparr == realarr );
// escaping turned off:
wxArrayString exparr2(WXSIZEOF(expected2), expected2);
wxArrayString realarr2(wxSplit(str, wxT(','), wxT('\0')));
CPPUNIT_ASSERT( exparr2 == realarr2 );
CHECK( exparr2 == realarr2 );
}
{
@@ -447,16 +402,16 @@ void ArraysTestCase::wxStringArraySplitTest()
// escaping on:
wxArrayString exparr(WXSIZEOF(expected), expected);
wxArrayString realarr(wxSplit(str, wxT(','), wxT('\\')));
CPPUNIT_ASSERT( exparr == realarr );
CHECK( exparr == realarr );
// escaping turned off:
wxArrayString exparr2(WXSIZEOF(expected2), expected2);
wxArrayString realarr2(wxSplit(str, wxT(','), wxT('\0')));
CPPUNIT_ASSERT( exparr2 == realarr2 );
CHECK( exparr2 == realarr2 );
}
}
void ArraysTestCase::wxStringArrayJoinTest()
TEST_CASE("Arrays::Join", "[dynarray]")
{
// test wxJoin:
@@ -466,7 +421,7 @@ void ArraysTestCase::wxStringArrayJoinTest()
wxArrayString arrstr(WXSIZEOF(arr), arr);
wxString result = wxJoin(arrstr, wxT(','));
CPPUNIT_ASSERT( expected == result );
CHECK( expected == result );
}
{
@@ -477,11 +432,11 @@ void ArraysTestCase::wxStringArrayJoinTest()
// escaping on:
wxArrayString arrstr(WXSIZEOF(arr), arr);
wxString result = wxJoin(arrstr, wxT(','), wxT('\\'));
CPPUNIT_ASSERT( expected == result );
CHECK( expected == result );
// escaping turned off:
wxString result2 = wxJoin(arrstr, wxT(','), wxT('\0'));
CPPUNIT_ASSERT( expected2 == result2 );
CHECK( expected2 == result2 );
}
{
@@ -493,15 +448,15 @@ void ArraysTestCase::wxStringArrayJoinTest()
// escaping on:
wxArrayString arrstr(WXSIZEOF(arr), arr);
wxString result = wxJoin(arrstr, wxT(','), wxT('\\'));
CPPUNIT_ASSERT( expected == result );
CHECK( expected == result );
// escaping turned off:
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('\\'),
wxT('&'), wxT('{'), wxT('A'), wxT('<'), wxT('>'),
@@ -526,7 +481,7 @@ void ArraysTestCase::wxStringArraySplitJoinTest()
for (i = 0; i < WXSIZEOF(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++)
{
wxString string = wxJoin(theArr, separators[i]);
CPPUNIT_ASSERT( theArr == wxSplit(string, separators[i]) );
CHECK( theArr == wxSplit(string, separators[i]) );
}
wxArrayString emptyArray;
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;
Bar bar(wxT("first bar in general, second bar in array (two copies!)"));
CPPUNIT_ASSERT_EQUAL( 0, bars.GetCount() );
CPPUNIT_ASSERT_EQUAL( 1, Bar::GetNumber() );
CHECK( bars.GetCount() == 0 );
CHECK( Bar::GetNumber() == 1 );
bars.Add(new Bar(wxT("first bar in array")));
bars.Add(bar, 2);
CPPUNIT_ASSERT_EQUAL( 3, bars.GetCount() );
CPPUNIT_ASSERT_EQUAL( 4, Bar::GetNumber() );
CHECK( bars.GetCount() == 3 );
CHECK( Bar::GetNumber() == 4 );
bars.RemoveAt(1, bars.GetCount() - 1);
CPPUNIT_ASSERT_EQUAL( 1, bars.GetCount() );
CPPUNIT_ASSERT_EQUAL( 2, Bar::GetNumber() );
CHECK( bars.GetCount() == 1 );
CHECK( Bar::GetNumber() == 2 );
bars.Empty();
CPPUNIT_ASSERT_EQUAL( 0, bars.GetCount() );
CPPUNIT_ASSERT_EQUAL( 1, Bar::GetNumber() );
CHECK( bars.GetCount() == 0 );
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.
ArrayBarPtrs barptrs;
CPPUNIT_ASSERT_EQUAL( 0, barptrs.size() );
CHECK( barptrs.size() == 0 );
}
#define TestArrayOf(name) \
\
void ArraysTestCase::wxArray ## name ## Test() \
TEST_CASE("wxDynArray::" #name, "[dynarray]") \
{ \
wxArray##name a; \
a.Add(1); \
@@ -600,18 +555,18 @@ void ArraysTestCase::wxArray ## name ## Test() \
a.Add(5,3); \
a.Add(3,4); \
\
CPPUNIT_ASSERT((COMPARE_10_VALUES(a,1,17,17,5,5,5,3,3,3,3))); \
CPPUNIT_ASSERT( COMPARE_COUNT( a , 10 ) ); \
CHECK((COMPARE_10_VALUES(a,1,17,17,5,5,5,3,3,3,3))); \
CHECK( COMPARE_COUNT( a , 10 ) ); \
\
a.Sort(name ## Compare); \
\
CPPUNIT_ASSERT((COMPARE_10_VALUES(a,1,3,3,3,3,5,5,5,17,17))); \
CPPUNIT_ASSERT( COMPARE_COUNT( a , 10 ) ); \
CHECK((COMPARE_10_VALUES(a,1,3,3,3,3,5,5,5,17,17))); \
CHECK( COMPARE_COUNT( a , 10 ) ); \
\
a.Sort(name ## RevCompare); \
\
CPPUNIT_ASSERT((COMPARE_10_VALUES(a,17,17,5,5,5,3,3,3,3,1))); \
CPPUNIT_ASSERT( COMPARE_COUNT( a , 10 ) ); \
CHECK((COMPARE_10_VALUES(a,17,17,5,5,5,3,3,3,3,1))); \
CHECK( COMPARE_COUNT( a , 10 ) ); \
\
wxSortedArray##name b; \
\
@@ -620,15 +575,15 @@ void ArraysTestCase::wxArray ## name ## Test() \
b.Add(5); \
b.Add(3); \
\
CPPUNIT_ASSERT((COMPARE_4_VALUES(b,1,3,5,17))); \
CPPUNIT_ASSERT( COMPARE_COUNT( b , 4 ) ); \
CPPUNIT_ASSERT( b.Index( 0 ) == wxNOT_FOUND ); \
CPPUNIT_ASSERT( b.Index( 1 ) == 0 ); \
CPPUNIT_ASSERT( b.Index( 3 ) == 1 ); \
CPPUNIT_ASSERT( b.Index( 4 ) == wxNOT_FOUND ); \
CPPUNIT_ASSERT( b.Index( 5 ) == 2 ); \
CPPUNIT_ASSERT( b.Index( 6 ) == wxNOT_FOUND ); \
CPPUNIT_ASSERT( b.Index( 17 ) == 3 ); \
CHECK((COMPARE_4_VALUES(b,1,3,5,17))); \
CHECK( COMPARE_COUNT( b , 4 ) ); \
CHECK( b.Index( 0 ) == wxNOT_FOUND ); \
CHECK( b.Index( 1 ) == 0 ); \
CHECK( b.Index( 3 ) == 1 ); \
CHECK( b.Index( 4 ) == wxNOT_FOUND ); \
CHECK( b.Index( 5 ) == 2 ); \
CHECK( b.Index( 6 ) == wxNOT_FOUND ); \
CHECK( b.Index( 17 ) == 3 ); \
}
TestArrayOf(UShort)
@@ -637,33 +592,33 @@ TestArrayOf(Char)
TestArrayOf(Int)
void ArraysTestCase::Alloc()
TEST_CASE("wxDynArray::Alloc", "[dynarray]")
{
wxArrayInt a;
a.Add(17);
a.Add(9);
CPPUNIT_ASSERT_EQUAL( 2, a.GetCount() );
CHECK( a.GetCount() == 2 );
a.Alloc(1000);
CPPUNIT_ASSERT_EQUAL( 2, a.GetCount() );
CPPUNIT_ASSERT_EQUAL( 17, a[0] );
CPPUNIT_ASSERT_EQUAL( 9, a[1] );
CHECK( a.GetCount() == 2 );
CHECK( a[0] == 17 );
CHECK( a[1] == 9 );
}
void ArraysTestCase::Clear()
TEST_CASE("wxDynArray::Clear", "[dynarray]")
{
ItemPtrArray 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(71));
CPPUNIT_ASSERT_EQUAL( 2, items.size() );
CHECK( items.size() == 2 );
WX_CLEAR_ARRAY(items);
CPPUNIT_ASSERT_EQUAL( 0, items.size() );
CHECK( items.size() == 0 );
}
namespace
@@ -674,30 +629,30 @@ void DoTestSwap(T v1, T v2, T v3)
{
A a1, a2;
a1.swap(a2);
CPPUNIT_ASSERT( a1.empty() );
CPPUNIT_ASSERT( a2.empty() );
CHECK( a1.empty() );
CHECK( a2.empty() );
a1.push_back(v1);
a1.swap(a2);
CPPUNIT_ASSERT( a1.empty() );
CPPUNIT_ASSERT_EQUAL( 1, a2.size() );
CHECK( a1.empty() );
CHECK( a2.size() == 1 );
a1.push_back(v2);
a1.push_back(v3);
a2.swap(a1);
CPPUNIT_ASSERT_EQUAL( 1, a1.size() );
CPPUNIT_ASSERT_EQUAL( 2, a2.size() );
CPPUNIT_ASSERT_EQUAL( v1, a1[0] );
CPPUNIT_ASSERT_EQUAL( v3, a2[1] );
CHECK( a1.size() == 1 );
CHECK( a2.size() == 2 );
CHECK( a1[0] == v1 );
CHECK( a2[1] == v3 );
a1.swap(a2);
CPPUNIT_ASSERT_EQUAL( 2, a1.size() );
CPPUNIT_ASSERT_EQUAL( 1, a2.size() );
CHECK( a1.size() == 2 );
CHECK( a2.size() == 1 );
}
} // anonymous namespace
void ArraysTestCase::Swap()
TEST_CASE("wxDynArray::Swap", "[dynarray]")
{
DoTestSwap<wxArrayString>("Foo", "Bar", "Baz");
@@ -705,7 +660,7 @@ void ArraysTestCase::Swap()
DoTestSwap<wxArrayLong>(6, 28, 496);
}
void ArraysTestCase::TestSTL()
TEST_CASE("wxDynArray::TestSTL", "[dynarray]")
{
wxArrayInt list1;
wxArrayInt::iterator it, en;
@@ -716,35 +671,35 @@ void ArraysTestCase::TestSTL()
for ( i = 0; i < COUNT; ++i )
list1.push_back(i);
CPPUNIT_ASSERT( list1.capacity() >= (size_t)COUNT );
CPPUNIT_ASSERT_EQUAL( COUNT, list1.size() );
CHECK( list1.capacity() >= (size_t)COUNT );
CHECK( list1.size() == COUNT );
for ( it = list1.begin(), en = list1.end(), i = 0;
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;
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) );
CPPUNIT_ASSERT( *list1.begin() == *(list1.rend()-1) );
CHECK( *list1.rbegin() == *(list1.end()-1) );
CHECK( *list1.begin() == *(list1.rend()-1) );
it = list1.begin()+1;
rit = list1.rbegin()+1;
CPPUNIT_ASSERT( *list1.begin() == *(it-1) );
CPPUNIT_ASSERT( *list1.rbegin() == *(rit-1) );
CHECK( *list1.begin() == *(it-1) );
CHECK( *list1.rbegin() == *(rit-1) );
CPPUNIT_ASSERT( list1.front() == 0 );
CPPUNIT_ASSERT( list1.back() == COUNT - 1 );
CHECK( list1.front() == 0 );
CHECK( list1.back() == COUNT - 1 );
list1.erase(list1.begin());
list1.erase(list1.end()-1);
@@ -752,30 +707,30 @@ void ArraysTestCase::TestSTL()
for ( it = list1.begin(), en = list1.end(), i = 1;
it != en; ++it, ++i )
{
CPPUNIT_ASSERT( *it == i );
CHECK( *it == i );
}
ItemPtrArray items;
items.push_back(new Item(17));
CPPUNIT_ASSERT_EQUAL( 17, (*(items.rbegin()))->n );
CPPUNIT_ASSERT_EQUAL( 17, (**items.begin()).n );
CHECK( (*(items.rbegin()))->n == 17 );
CHECK( (**items.begin()).n == 17 );
WX_CLEAR_ARRAY(items);
}
void ArraysTestCase::IndexFromEnd()
TEST_CASE("wxDynArray::IndexFromEnd", "[dynarray]")
{
wxArrayInt a;
a.push_back(10);
a.push_back(1);
a.push_back(42);
CPPUNIT_ASSERT_EQUAL( 0, a.Index(10) );
CPPUNIT_ASSERT_EQUAL( 1, a.Index(1) );
CPPUNIT_ASSERT_EQUAL( 2, a.Index(42) );
CPPUNIT_ASSERT_EQUAL( 0, a.Index(10, /*bFromEnd=*/true) );
CPPUNIT_ASSERT_EQUAL( 1, a.Index(1, /*bFromEnd=*/true) );
CPPUNIT_ASSERT_EQUAL( 2, a.Index(42, /*bFromEnd=*/true) );
CHECK( a.Index(10) == 0 );
CHECK( a.Index(1) == 1 );
CHECK( a.Index(42) == 2 );
CHECK( a.Index(10, /*bFromEnd=*/true) == 0 );
CHECK( a.Index( 1, /*bFromEnd=*/true) == 1 );
CHECK( a.Index(42, /*bFromEnd=*/true) == 2 );
}