wibble 0.1.28
range.test.h
Go to the documentation of this file.
00001 // -*- C++ -*- (c) 2005, 2006, 2007 Petr Rockai <me@mornfall.net>
00002 
00003 #include <wibble/range.h>
00004 #include <wibble/operators.h>
00005 #include <list>
00006 #include <functional>
00007 
00008 namespace {
00009 
00010 using namespace wibble;
00011 using namespace operators;
00012 
00013 struct TestRange {
00014 
00015     Test iteratorRange() {
00016         std::list<int> a;
00017         a.push_back( 10 );
00018         a.push_back( 20 );
00019         Range< int > r = range( a.begin(), a.end() );
00020         Range< int >::iterator i = r.begin();
00021         assert_eq( *i, 10 );
00022         assert_eq( *(i + 1), 20 );
00023         assert( i + 2 == r.end() );
00024     }
00025 
00026     Test copy() {
00027         std::list<int> a;
00028         a.push_back( 10 );
00029         a.push_back( 20 );
00030         Range< int > r = range( a.begin(), a.end() );
00031         std::list<int> b;
00032         assert( a != b );
00033         std::copy( r.begin(), r.end(), back_inserter( b ) );
00034         assert( a == b );
00035     }
00036 
00037     Test copyToConsumer() {
00038         // std::vector< int > &vec = *new (GC) std::vector< int >;
00039         std::vector< int > vec;
00040         std::list< int > a;
00041         a.push_back( 10 );
00042         a.push_back( 20 );
00043         Range< int > r = range( a.begin(), a.end() );
00044         std::copy( r.begin(), r.end(), consumer( vec ) );
00045         Range< int > r1 = range( vec );
00046         assert_eq( *r1.begin(), 10 );
00047         assert_eq( *(r1.begin() + 1), 20 );
00048         assert( r1.begin() + 2 == r1.end() );
00049         while ( !r.empty() ) {
00050             assert_eq( r.head(), r1.head() );
00051             r = r.tail();
00052             r1 = r1.tail();
00053         }
00054         assert( r1.empty() );
00055     }
00056 
00057     Test _filteredRange() {
00058         std::vector< int > v;
00059         std::list<int> a;
00060         a.push_back( 10 );
00061         a.push_back( 20 );
00062         Range< int > r = range( a.begin(), a.end() );
00063         r.output( consumer( v ) );
00064         
00065         Range<int> fr =
00066             filteredRange( range( v ),
00067                            std::bind1st( std::equal_to< int >(), 10 ) );
00068         assert_eq( fr.head(), 10 );
00069         fr = fr.tail();
00070         assert( fr.empty() );
00071     }
00072 
00073     Test sort() {
00074         std::vector< int > v;
00075         std::list<int> a;
00076         a.push_back( 20 );
00077         a.push_back( 10 );
00078         a.push_back( 30 );
00079         Range< int > r = range( a.begin(), a.end() );
00080         r.output( consumer( v ) );
00081         std::sort( v.begin(), v.end() );
00082         assert_eq( *(v.begin()), 10 );
00083         assert_eq( *(v.begin() + 1), 20 );
00084         assert_eq( *(v.begin() + 2), 30 );
00085         assert( v.begin() + 3 == v.end() );
00086     }
00087 
00088     Test assignment() {
00089         std::vector< int > vec;
00090         Range< int > a;
00091         a = range( vec );
00092         assert( a.empty() );
00093         vec.push_back( 4 );
00094         Range< int > b = range( vec );
00095         assert_eq( b.head(), 4 );
00096         a = b;
00097         assert( !a.empty() );
00098         assert_eq( a.head(), 4 );
00099     }
00100     
00101     Test _transformedRange() {
00102         Range< int > a;
00103         std::vector< int > xv;
00104         Consumer< int > x = consumer( xv );
00105         x.consume( 4 );
00106         x.consume( 8 );
00107         a = transformedRange( range( xv ),
00108                               std::bind1st( std::plus< int >(), 2 ) );
00109         assert_eq( a.head(), 6 );
00110         a.removeFirst();
00111         assert_eq( a.head(), 10 );
00112         a.removeFirst();
00113         assert( a.empty() );
00114     }
00115 
00116     Test _transformedRange2() {
00117         Range< int > a;
00118         std::vector< unsigned > xv;
00119         Consumer< unsigned > x = consumer( xv );
00120         x.consume( 4 );
00121         x.consume( 8 );
00122         a = transformedRange(
00123             range( xv ), std::bind1st( std::plus< int >(), 2 ) );
00124         assert_eq( a.head(), 6 );
00125         a.removeFirst();
00126         assert_eq( a.head(), 10 );
00127         a.removeFirst();
00128         assert( a.empty() );
00129     }
00130 
00131     Test tailOfIteratorRange() {
00132         std::vector<int> a;
00133         a.insert( a.begin(), 30 );
00134         a.insert( a.begin(), 10 );
00135         a.insert( a.begin(), 20 );
00136         Range< int > r = range( a.begin(), a.end() );
00137         assert_eq( r.head(), 20 );
00138         r = r.tail();
00139         assert_eq( r.head(), 10 );
00140         r = r.tail();
00141         assert_eq( r.head(), 30 );
00142         r = r.tail();
00143         assert( r.empty() );
00144     }
00145 
00146     Test _castedRange()
00147     {
00148         std::vector<int> a;
00149         a.insert( a.begin(), 30 );
00150         a.insert( a.begin(), 10 );
00151         a.insert( a.begin(), 20 );
00152         Range< unsigned > r = castedRange< unsigned >(
00153             range( a.begin(), a.end() ) );
00154         assert_eq( r.head(), 20u );
00155         r = r.tail();
00156         assert_eq( r.head(), 10u );
00157         r = r.tail();
00158         assert_eq( r.head(), 30u );
00159         r = r.tail();
00160         assert( r.empty() );
00161     }
00162 
00163     static void removeFirst( int &i ) {
00164         ++i;
00165     }
00166 
00167     static bool isEnd( const int &i ) {
00168         return i >= 5;
00169     }
00170 
00171     Test _generatedRange() {
00172         Range< int > r = generatedRange( 0, removeFirst, isEnd );
00173         assert( !r.empty() );
00174         assert_eq( *(r.begin() + 0), 0 );
00175         assert_eq( *(r.begin() + 1), 1 );
00176         assert_eq( *(r.begin() + 2), 2 );
00177         assert_eq( *(r.begin() + 3), 3 );
00178         assert_eq( *(r.begin() + 4), 4 );
00179         assert( (r.begin() + 5) == r.end() );
00180     }
00181 
00182 };
00183 
00184 }