925 lines
23 KiB
C++
925 lines
23 KiB
C++
#include <ebcl/Arrays.hh>
|
|
#include <cppunit/extensions/HelperMacros.h>
|
|
using namespace ebcl;
|
|
|
|
|
|
class ArraysObjectsTest : public CppUnit::TestFixture
|
|
{
|
|
CPPUNIT_TEST_SUITE( ArraysObjectsTest );
|
|
CPPUNIT_TEST( testDefaults );
|
|
|
|
CPPUNIT_TEST( testAppendCopy );
|
|
CPPUNIT_TEST( testAppendMove );
|
|
CPPUNIT_TEST( testAppendNew );
|
|
CPPUNIT_TEST( testAppendTwo );
|
|
CPPUNIT_TEST( testExpand );
|
|
|
|
CPPUNIT_TEST( testClear );
|
|
CPPUNIT_TEST( testFree );
|
|
|
|
CPPUNIT_TEST( testEnsureFactor );
|
|
CPPUNIT_TEST( testEnsureOther );
|
|
CPPUNIT_TEST( testEnsureMoves );
|
|
|
|
CPPUNIT_TEST( testRemoveEnd );
|
|
CPPUNIT_TEST( testRemoveMiddle );
|
|
CPPUNIT_TEST( testRemoveSwapEnd );
|
|
CPPUNIT_TEST( testRemoveSwapMiddle );
|
|
|
|
CPPUNIT_TEST( testCopyCons );
|
|
CPPUNIT_TEST( testCopyAss );
|
|
|
|
CPPUNIT_TEST( testMoveCons );
|
|
CPPUNIT_TEST( testMoveAss );
|
|
|
|
CPPUNIT_TEST( testSwap );
|
|
|
|
CPPUNIT_TEST( testIndexOf );
|
|
CPPUNIT_TEST( testIndexOfMissing );
|
|
CPPUNIT_TEST( testContains );
|
|
CPPUNIT_TEST( testContainsMissing );
|
|
|
|
CPPUNIT_TEST( testIndexOfPred );
|
|
CPPUNIT_TEST( testIndexOfPredMissing );
|
|
CPPUNIT_TEST( testContainsPred );
|
|
CPPUNIT_TEST( testContainsPredMissing );
|
|
|
|
CPPUNIT_TEST( testInsertCopyEmpty );
|
|
CPPUNIT_TEST( testInsertCopyBefore );
|
|
CPPUNIT_TEST( testInsertCopyAfter );
|
|
CPPUNIT_TEST( testInsertMoveEmpty );
|
|
CPPUNIT_TEST( testInsertMoveBefore );
|
|
CPPUNIT_TEST( testInsertMoveAfter );
|
|
CPPUNIT_TEST( testInsertNewEmpty );
|
|
CPPUNIT_TEST( testInsertNewBefore );
|
|
CPPUNIT_TEST( testInsertNewAfter );
|
|
|
|
CPPUNIT_TEST( testSort );
|
|
CPPUNIT_TEST( testSortComparator );
|
|
CPPUNIT_TEST( testSortPartial );
|
|
|
|
CPPUNIT_TEST( testRangeOutside );
|
|
CPPUNIT_TEST( testRangeLarger );
|
|
CPPUNIT_TEST( testRangeSub );
|
|
|
|
CPPUNIT_TEST( testMoveRangeOutside );
|
|
CPPUNIT_TEST( testMoveRangeLarger );
|
|
CPPUNIT_TEST( testMoveRangeSub );
|
|
CPPUNIT_TEST_SUITE_END( );
|
|
|
|
public:
|
|
void tearDown( ) override;
|
|
|
|
void testDefaults( );
|
|
|
|
void testAppendCopy( );
|
|
void testAppendMove( );
|
|
void testAppendNew( );
|
|
void testAppendTwo( );
|
|
void testExpand( );
|
|
|
|
void testClear( );
|
|
void testFree( );
|
|
|
|
void testEnsureFactor( );
|
|
void testEnsureOther( );
|
|
void testEnsureMoves( );
|
|
|
|
void testRemoveEnd( );
|
|
void testRemoveMiddle( );
|
|
void testRemoveSwapEnd( );
|
|
void testRemoveSwapMiddle( );
|
|
|
|
void testCopyCons( );
|
|
void testCopyAss( );
|
|
|
|
void testMoveCons( );
|
|
void testMoveAss( );
|
|
|
|
void testSwap( );
|
|
|
|
void testIndexOf( );
|
|
void testIndexOfMissing( );
|
|
void testContains( );
|
|
void testContainsMissing( );
|
|
|
|
void testIndexOfPred( );
|
|
void testIndexOfPredMissing( );
|
|
void testContainsPred( );
|
|
void testContainsPredMissing( );
|
|
|
|
void testInsertCopyEmpty( );
|
|
void testInsertCopyBefore( );
|
|
void testInsertCopyAfter( );
|
|
void testInsertMoveEmpty( );
|
|
void testInsertMoveBefore( );
|
|
void testInsertMoveAfter( );
|
|
void testInsertNewEmpty( );
|
|
void testInsertNewBefore( );
|
|
void testInsertNewAfter( );
|
|
|
|
void testSort( );
|
|
void testSortComparator( );
|
|
void testSortPartial( );
|
|
|
|
void testRangeOutside( );
|
|
void testRangeLarger( );
|
|
void testRangeSub( );
|
|
|
|
void testMoveRangeOutside( );
|
|
void testMoveRangeLarger( );
|
|
void testMoveRangeSub( );
|
|
};
|
|
CPPUNIT_TEST_SUITE_REGISTRATION( ArraysObjectsTest );
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
namespace {
|
|
|
|
struct T_Test
|
|
{
|
|
static uint32_t nConsDefault;
|
|
static uint32_t nConsCopy;
|
|
static uint32_t nConsMove;
|
|
static uint32_t nDestr;
|
|
|
|
static void reset( )
|
|
{
|
|
nConsDefault = 0;
|
|
nConsCopy = 0;
|
|
nConsMove = 0;
|
|
nDestr = 0;
|
|
}
|
|
|
|
bool ignoreMe;
|
|
uint32_t serial;
|
|
|
|
T_Test( ) : ignoreMe( false )
|
|
{ nConsDefault ++; }
|
|
|
|
T_Test( uint32_t serial )
|
|
: ignoreMe( true ) , serial( serial )
|
|
{ }
|
|
|
|
T_Test( T_Test const& o )
|
|
: ignoreMe( false ) , serial( o.serial )
|
|
{ nConsCopy ++; }
|
|
|
|
T_Test( T_Test && o )
|
|
: ignoreMe( false ) , serial( o.serial )
|
|
{ nConsMove ++; }
|
|
|
|
~T_Test( )
|
|
{ if ( !ignoreMe ) { nDestr ++; } }
|
|
|
|
T_Test& operator =( T_Test const& source )
|
|
{
|
|
serial = source.serial;
|
|
ignoreMe = false;
|
|
return *this;
|
|
}
|
|
|
|
T_Test& operator =( T_Test&& source )
|
|
{
|
|
std::swap( source.serial , serial );
|
|
ignoreMe = false;
|
|
return *this;
|
|
}
|
|
|
|
bool operator ==( T_Test const& other )
|
|
{
|
|
return other.serial == serial;
|
|
}
|
|
|
|
bool operator !=( T_Test const& other )
|
|
{
|
|
return other.serial != serial;
|
|
}
|
|
};
|
|
|
|
uint32_t T_Test::nConsDefault = 0;
|
|
uint32_t T_Test::nConsCopy = 0;
|
|
uint32_t T_Test::nConsMove = 0;
|
|
uint32_t T_Test::nDestr = 0;
|
|
|
|
void swap( T_Test& lhs , T_Test& rhs )
|
|
{
|
|
using std::swap;
|
|
swap( lhs.serial , rhs.serial );
|
|
swap( lhs.ignoreMe , rhs.ignoreMe );
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace ebcl { M_DECLARE_COMPARATOR( T_Test ); }
|
|
|
|
M_DEFINE_COMPARATOR( T_Test )
|
|
{
|
|
return T_Comparator< uint32_t >::compare( a.serial , b.serial );
|
|
}
|
|
|
|
void ArraysObjectsTest::tearDown( )
|
|
{
|
|
T_Test::reset( );
|
|
}
|
|
|
|
#define M_CHECK_(ncd,ncc,ncm,nd) \
|
|
do { \
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( ncd ) , \
|
|
T_Test::nConsDefault ); \
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( ncc ) , T_Test::nConsCopy ); \
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( ncm ) , T_Test::nConsMove ); \
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( nd ) , T_Test::nDestr ); \
|
|
} while ( 0 )
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testDefaults( )
|
|
{
|
|
T_Array< T_Test > array;
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 4096 / sizeof( T_Test ) ) ,
|
|
array.growth( ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testAppendCopy( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
T_Test obj( 0 );
|
|
array.add( obj );
|
|
M_CHECK_( 0 , 1 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 1 , 0 , 1 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testAppendMove( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.add( T_Test( 0 ) );
|
|
M_CHECK_( 0 , 0 , 1 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 1 , 1 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testAppendNew( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.addNew( 0 );
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testAppendTwo( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
T_Test obj1( 0 ) , obj2( 1 );
|
|
array << obj1 << obj2;
|
|
M_CHECK_( 0 , 2 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array[ 1 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 2 , 0 , 2 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testExpand( )
|
|
{
|
|
uint32_t g , n;
|
|
{
|
|
T_Array< T_Test > array;
|
|
g = array.growth( );
|
|
n = g * 3 / 2;
|
|
for ( uint32_t i = 0 ; i < n ; i ++ ) {
|
|
T_Test obj( i );
|
|
array.add( obj );
|
|
}
|
|
M_CHECK_( 0 , n , g , g );
|
|
|
|
CPPUNIT_ASSERT_EQUAL( n , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( 2 * g , array.capacity( ) );
|
|
for ( uint32_t i = 0 ; i < n ; i ++ ) {
|
|
CPPUNIT_ASSERT_EQUAL( i , array[ i ].serial );
|
|
}
|
|
|
|
}
|
|
M_CHECK_( 0 , n , g , g + n );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testClear( )
|
|
{
|
|
uint32_t n;
|
|
{
|
|
T_Array< T_Test > array;
|
|
n = array.growth( );
|
|
for ( uint32_t i = 0 ; i < n ; i ++ ) {
|
|
T_Test obj( i );
|
|
array.add( obj );
|
|
}
|
|
array.clear( );
|
|
M_CHECK_( 0 , n , 0 , n );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
}
|
|
M_CHECK_( 0 , n , 0 , n );
|
|
}
|
|
|
|
void ArraysObjectsTest::testFree( )
|
|
{
|
|
uint32_t n;
|
|
{
|
|
T_Array< T_Test > array;
|
|
n = array.growth( );
|
|
for ( uint32_t i = 0 ; i < n ; i ++ ) {
|
|
T_Test obj( i );
|
|
array.add( obj );
|
|
}
|
|
array.free( );
|
|
M_CHECK_( 0 , n , 0 , n );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array.capacity( ) );
|
|
}
|
|
M_CHECK_( 0 , n , 0 , n );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testEnsureFactor( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.ensureCapacity( array.growth( ) * 2 );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) * 2 , array.capacity( ) );
|
|
}
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testEnsureOther( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.ensureCapacity( array.growth( ) * 3 / 2 );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) * 2 , array.capacity( ) );
|
|
}
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testEnsureMoves( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.add( T_Test( 0 ) );
|
|
array.ensureCapacity( array.growth( ) * 2 );
|
|
M_CHECK_( 0 , 0 , 2 , 1 );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) * 2 , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 2 , 2 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testRemoveEnd( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array << T_Test( 0 ) << T_Test( 1 ) << T_Test( 2 );
|
|
M_CHECK_( 0 , 0 , 3 , 0 );
|
|
|
|
array.remove( 2 );
|
|
M_CHECK_( 0 , 0 , 3 , 1 );
|
|
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array[ 1 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 3 , 3 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testRemoveMiddle( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array << T_Test( 0 ) << T_Test( 1 ) << T_Test( 2 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , array.size( ) );
|
|
M_CHECK_( 0 , 0 , 3 , 0 );
|
|
|
|
array.remove( 1 );
|
|
M_CHECK_( 0 , 0 , 3 , 1 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , array[ 1 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 3 , 3 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testRemoveSwapEnd( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array << T_Test( 0 ) << T_Test( 1 ) << T_Test( 2 );
|
|
M_CHECK_( 0 , 0 , 3 , 0 );
|
|
|
|
array.removeSwap( 2 );
|
|
M_CHECK_( 0 , 0 , 3 , 1 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array[ 1 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 3 , 3 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testRemoveSwapMiddle( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array << T_Test( 0 ) << T_Test( 1 ) << T_Test( 2 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , array.size( ) );
|
|
M_CHECK_( 0 , 0 , 3 , 0 );
|
|
|
|
array.removeSwap( 0 );
|
|
M_CHECK_( 0 , 0 , 3 , 1 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 2 ) , array[ 0 ].serial );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array[ 1 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 3 , 3 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testCopyCons( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.ensureCapacity( array.growth( ) * 2 );
|
|
array.add( T_Test( 0 ) );
|
|
|
|
T_Array< T_Test > copy( array );
|
|
M_CHECK_( 0 , 1 , 1 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , copy.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , copy.growth( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.capacity( ) , copy.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , copy[ 0 ].serial );
|
|
|
|
copy.add( T_Test( 1 ) );
|
|
M_CHECK_( 0 , 1 , 2 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
}
|
|
M_CHECK_( 0 , 1 , 2 , 3 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testCopyAss( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.ensureCapacity( array.growth( ) * 2 );
|
|
array.add( T_Test( 0 ) );
|
|
|
|
T_Array< T_Test > copy;
|
|
copy.add( T_Test( 1 ) );
|
|
M_CHECK_( 0 , 0 , 2 , 0 );
|
|
|
|
copy = array;
|
|
M_CHECK_( 0 , 1 , 2 , 1 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , copy.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , copy.growth( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.capacity( ) , copy.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , copy[ 0 ].serial );
|
|
|
|
copy.add( T_Test( 1 ) );
|
|
M_CHECK_( 0 , 1 , 3 , 1 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
}
|
|
M_CHECK_( 0 , 1 , 3 , 4 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testMoveCons( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array( std::move(
|
|
T_Array< T_Test >( 128 ).ensureCapacity( 256 )
|
|
<< T_Test( 0 ) ) );
|
|
M_CHECK_( 0 , 0 , 1 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 128 ) , array.growth( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 256 ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 1 , 1 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testMoveAss( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array << T_Test( 1 );
|
|
array = std::move( T_Array< T_Test >( 128 ).ensureCapacity( 256 ) << T_Test( 0 ) );
|
|
M_CHECK_( 0 , 0 , 2 , 1 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 128 ) , array.growth( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 256 ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 2 , 2 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testSwap( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
T_Array< T_Test > a2;
|
|
a1 << 1 << 2 << 3;
|
|
a2 << 2 << 4 << 6 << 8;
|
|
swap( a1 , a2 );
|
|
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 4 ) , a1.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 3 ) , a2.size( ) );
|
|
for ( uint32_t i = 0 ; i < 3 ; i ++ ) {
|
|
CPPUNIT_ASSERT( a1[ i ].serial == a2[ i ].serial * 2 );
|
|
}
|
|
CPPUNIT_ASSERT( a1[ 3 ].serial == 8 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testIndexOf( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT_EQUAL( int32_t( 1 ) , a1.indexOf( T_Test( 2 ) ) );
|
|
}
|
|
|
|
void ArraysObjectsTest::testIndexOfMissing( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT_EQUAL( int32_t( -1 ) , a1.indexOf( T_Test( 8 ) ) );
|
|
}
|
|
|
|
void ArraysObjectsTest::testContains( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT( a1.contains( T_Test( 2 ) ) );
|
|
}
|
|
|
|
void ArraysObjectsTest::testContainsMissing( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT( !a1.contains( T_Test( 4 ) ) );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testIndexOfPred( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT_EQUAL( 1 , a1.indexOf( []( auto const& i ) {
|
|
return i.serial > 1;
|
|
} ) );
|
|
}
|
|
|
|
void ArraysObjectsTest::testIndexOfPredMissing( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT_EQUAL( -1 , a1.indexOf( []( auto const& i ) {
|
|
return i.serial > 4;
|
|
} ) );
|
|
|
|
}
|
|
|
|
void ArraysObjectsTest::testContainsPred( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT( a1.contains( []( auto const& i ) {
|
|
return i.serial > 1;
|
|
} ) );
|
|
|
|
}
|
|
|
|
void ArraysObjectsTest::testContainsPredMissing( )
|
|
{
|
|
T_Array< T_Test > a1;
|
|
a1 << 1 << 2 << 3;
|
|
CPPUNIT_ASSERT( !a1.contains( []( auto const& i ) {
|
|
return i.serial > 4;
|
|
} ) );
|
|
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testInsertCopyEmpty( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
T_Test obj( 0 );
|
|
array.insert( 0 , obj );
|
|
M_CHECK_( 0 , 1 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 1 , 0 , 1 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testInsertCopyBefore( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 10 ; i ++ ) {
|
|
array << i;
|
|
}
|
|
T_Test::reset( );
|
|
|
|
T_Test obj( 15 );
|
|
array.insert( 0 , obj );
|
|
M_CHECK_( 0 , 1 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 11 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 1 , 0 , 11 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testInsertCopyAfter( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 10 ; i ++ ) {
|
|
array << i;
|
|
}
|
|
T_Test::reset( );
|
|
|
|
T_Test obj( 15 );
|
|
array.insert( 10 , obj );
|
|
M_CHECK_( 0 , 1 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 11 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 10 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 1 , 0 , 11 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testInsertMoveEmpty( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
T_Test obj( 15 );
|
|
array.insert( 0 , std::move( obj ) );
|
|
M_CHECK_( 0 , 0 , 1 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 1 , 1 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testInsertMoveBefore( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 10 ; i ++ ) {
|
|
array << i;
|
|
}
|
|
T_Test::reset( );
|
|
|
|
T_Test obj( 15 );
|
|
array.insert( 0 , std::move( obj ) );
|
|
M_CHECK_( 0 , 0 , 1 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 11 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 1 , 11 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testInsertMoveAfter( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 10 ; i ++ ) {
|
|
array << i;
|
|
}
|
|
T_Test::reset( );
|
|
|
|
T_Test obj( 15 );
|
|
array.insert( 10 , std::move( obj ) );
|
|
M_CHECK_( 0 , 0 , 1 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 11 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 10 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 1 , 11 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testInsertNewEmpty( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
array.insertNew( 0 , 15 );
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testInsertNewBefore( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 10 ; i ++ ) {
|
|
array << ( i + 2 );
|
|
}
|
|
|
|
array.insertNew( 0 , 15 );
|
|
M_CHECK_( 0 , 0 , 10 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 11 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 0 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 10 , 10 );
|
|
}
|
|
|
|
void ArraysObjectsTest::testInsertNewAfter( )
|
|
{
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 10 ; i ++ ) {
|
|
array << ( i + 2 );
|
|
}
|
|
|
|
array.insertNew( 10 , 15 );
|
|
M_CHECK_( 0 , 0 , 10 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 11 ) , array.size( ) );
|
|
CPPUNIT_ASSERT_EQUAL( array.growth( ) , array.capacity( ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 15 ) , array[ 10 ].serial );
|
|
}
|
|
M_CHECK_( 0 , 0 , 10 , 10 );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testSort( )
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array << T_Test( std::rand( ) );
|
|
}
|
|
array.sort( );
|
|
|
|
for ( uint32_t i = 1 ; i < 5000 ; i ++ ) {
|
|
CPPUNIT_ASSERT( array[ i ].serial >= array[ i - 1 ].serial );
|
|
}
|
|
}
|
|
|
|
void ArraysObjectsTest::testSortComparator( )
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array << T_Test( std::rand( ) );
|
|
}
|
|
array.sort( []( T_Test const& a , T_Test const& b ){
|
|
return T_Comparator< T_Test >::compare( b , a );
|
|
} );
|
|
|
|
for ( uint32_t i = 1 ; i < 5000 ; i ++ ) {
|
|
CPPUNIT_ASSERT( array[ i ].serial <= array[ i - 1 ].serial );
|
|
}
|
|
}
|
|
|
|
void ArraysObjectsTest::testSortPartial( )
|
|
{
|
|
T_Array< T_Test > array;
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array << std::rand( );
|
|
}
|
|
T_Array< T_Test > copy( array );
|
|
array.sort( 1000 , 1000 );
|
|
|
|
for ( uint32_t i = 0 ; i < 1000 ; i ++ ) {
|
|
CPPUNIT_ASSERT_EQUAL( copy[ i ].serial , array[ i ].serial );
|
|
}
|
|
for ( uint32_t i = 1001 ; i < 2000 ; i ++ ) {
|
|
CPPUNIT_ASSERT( array[ i ].serial >= array[ i - 1 ].serial );
|
|
}
|
|
for ( uint32_t i = 2000 ; i < 5000 ; i ++ ) {
|
|
CPPUNIT_ASSERT_EQUAL( copy[ i ].serial , array[ i ].serial );
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testRangeOutside( )
|
|
{
|
|
T_Array< T_Test > array( 5000 );
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array.addNew( std::rand( ) );
|
|
}
|
|
T_Array< T_Test > range( array.copyRange( 7000 , 1000 ) );
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , range.size( ) );
|
|
}
|
|
|
|
void ArraysObjectsTest::testRangeLarger( )
|
|
{
|
|
T_Array< T_Test > array( 5000 );
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array.addNew( std::rand( ) );
|
|
}
|
|
T_Array< T_Test > range( array.copyRange( 1000 ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 4000 ) , range.size( ) );
|
|
M_CHECK_( 0 , 4000 , 0 , 0 );
|
|
for ( uint32_t i = 0 ; i < 4000 ; i ++ ) {
|
|
CPPUNIT_ASSERT_EQUAL( array[ i + 1000 ].serial , range[ i ].serial );
|
|
}
|
|
}
|
|
|
|
void ArraysObjectsTest::testRangeSub( )
|
|
{
|
|
T_Array< T_Test > array( 5000 );
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array.addNew( std::rand( ) );
|
|
}
|
|
T_Array< T_Test > range( array.copyRange( 1000 , 1999 ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1000 ) , range.size( ) );
|
|
M_CHECK_( 0 , 1000 , 0 , 0 );
|
|
for ( uint32_t i = 0 ; i < 1000 ; i ++ ) {
|
|
CPPUNIT_ASSERT_EQUAL( array[ i + 1000 ].serial , range[ i ].serial );
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
void ArraysObjectsTest::testMoveRangeOutside( )
|
|
{
|
|
T_Array< T_Test > array( 5000 );
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array.addNew( std::rand( ) );
|
|
}
|
|
T_Array< T_Test > range( array.moveRange( 7000 , 1000 ) );
|
|
M_CHECK_( 0 , 0 , 0 , 0 );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 0 ) , range.size( ) );
|
|
}
|
|
|
|
void ArraysObjectsTest::testMoveRangeLarger( )
|
|
{
|
|
T_Array< T_Test > array( 5000 );
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array.addNew( std::rand( ) );
|
|
}
|
|
T_Array< T_Test > range( array.moveRange( 1000 ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 4000 ) , range.size( ) );
|
|
M_CHECK_( 0 , 0 , 4000 , 0 );
|
|
for ( uint32_t i = 0 ; i < 4000 ; i ++ ) {
|
|
CPPUNIT_ASSERT_EQUAL( array[ i + 1000 ].serial , range[ i ].serial );
|
|
}
|
|
}
|
|
|
|
void ArraysObjectsTest::testMoveRangeSub( )
|
|
{
|
|
T_Array< T_Test > array( 5000 );
|
|
for ( uint32_t i = 0 ; i < 5000 ; i ++ ) {
|
|
array.addNew( std::rand( ) );
|
|
}
|
|
T_Array< T_Test > range( array.moveRange( 1000 , 1999 ) );
|
|
CPPUNIT_ASSERT_EQUAL( uint32_t( 1000 ) , range.size( ) );
|
|
M_CHECK_( 0 , 0 , 1000 , 0 );
|
|
for ( uint32_t i = 0 ; i < 1000 ; i ++ ) {
|
|
CPPUNIT_ASSERT_EQUAL( array[ i + 1000 ].serial , range[ i ].serial );
|
|
}
|
|
}
|