OpenWalnut
1.4.0
|
00001 //--------------------------------------------------------------------------- 00002 // 00003 // Project: OpenWalnut ( http://www.openwalnut.org ) 00004 // 00005 // Copyright 2009 OpenWalnut Community, BSV@Uni-Leipzig and CNCF@MPI-CBS 00006 // For more information see http://www.openwalnut.org/copying 00007 // 00008 // This file is part of OpenWalnut. 00009 // 00010 // OpenWalnut is free software: you can redistribute it and/or modify 00011 // it under the terms of the GNU Lesser General Public License as published by 00012 // the Free Software Foundation, either version 3 of the License, or 00013 // (at your option) any later version. 00014 // 00015 // OpenWalnut is distributed in the hope that it will be useful, 00016 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00017 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00018 // GNU Lesser General Public License for more details. 00019 // 00020 // You should have received a copy of the GNU Lesser General Public License 00021 // along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>. 00022 // 00023 //--------------------------------------------------------------------------- 00024 00025 #ifndef WVALUESET_TEST_H 00026 #define WVALUESET_TEST_H 00027 00028 #include <stdint.h> 00029 #include <vector> 00030 00031 #include <cxxtest/TestSuite.h> 00032 00033 #include "../WValueSet.h" 00034 #include "../WDataHandlerEnums.h" 00035 00036 /** 00037 * UnitTests the WValueSet class 00038 */ 00039 class WValueSetTest : public CxxTest::TestSuite 00040 { 00041 public: 00042 /** 00043 * An instantiation should never throw an exception 00044 */ 00045 void testInstantiation( void ) 00046 { 00047 double a[2] = { 0.0, 3.1415 }; 00048 const boost::shared_ptr< std::vector< double > > v = 00049 boost::shared_ptr< std::vector< double > >( 00050 new std::vector< double >( a, a + sizeof( a ) / sizeof( double ) ) ); 00051 TS_ASSERT_THROWS_NOTHING( WValueSet< double > valueSet( 0, 1, v, W_DT_DOUBLE ) ); 00052 } 00053 00054 /** 00055 * The number of values retrieved is correct 00056 */ 00057 void testGetNumberOfValues( void ) 00058 { 00059 int a[4] = { 0, -5, 1, 2 }; 00060 const boost::shared_ptr< std::vector< int8_t > > v = 00061 boost::shared_ptr< std::vector< int8_t > >( 00062 new std::vector< int8_t >( a, a + sizeof( a ) / sizeof( int ) ) ); 00063 WValueSet< int8_t > first( 0, 1, v, W_DT_INT8 ); 00064 TS_ASSERT_EQUALS( first.size(), 4 ); 00065 WValueSet< int8_t > second( 1, 2, v, W_DT_INT8 ); 00066 TS_ASSERT_EQUALS( second.size(), 2 ); 00067 WValueSet< int8_t > third( 2, 2, v, W_DT_INT8 ); 00068 TS_ASSERT_EQUALS( third.size(), 1 ); 00069 } 00070 00071 /** 00072 * The raw size is the size of the number of integral elements inside 00073 * this ValueSet. 00074 */ 00075 void testRawSize( void ) 00076 { 00077 int8_t a[4] = { 0, -5, 1, 2 }; 00078 const boost::shared_ptr< std::vector< int8_t > > v = 00079 boost::shared_ptr< std::vector< int8_t > >( 00080 new std::vector< int8_t >( a, a + sizeof( a ) / sizeof( int8_t ) ) ); 00081 WValueSet< int8_t > first( 0, 1, v, W_DT_INT8 ); 00082 TS_ASSERT_EQUALS( first.rawSize(), 4 ); 00083 WValueSet< int8_t > second( 2, 2, v, W_DT_INT8 ); 00084 TS_ASSERT_EQUALS( first.rawSize(), 4 ); 00085 } 00086 00087 /** 00088 * This function should return the i-th value if the value set is scalar. 00089 */ 00090 void testGetScalar( void ) 00091 { 00092 int8_t a[4] = { 0, -5, 1, 2 }; 00093 const boost::shared_ptr< std::vector< int8_t > > v = 00094 boost::shared_ptr< std::vector< int8_t > >( 00095 new std::vector< int8_t >( a, a + sizeof( a ) / sizeof( int8_t ) ) ); 00096 WValueSet< int8_t > set( 0, 1, v, W_DT_INT8 ); 00097 TS_ASSERT_EQUALS( set.getScalar( 0 ), a[0] ); 00098 TS_ASSERT_EQUALS( set.getScalar( 1 ), a[1] ); 00099 TS_ASSERT_EQUALS( set.getScalar( 2 ), a[2] ); 00100 TS_ASSERT_EQUALS( set.getScalar( 3 ), a[3] ); 00101 } 00102 00103 /** 00104 * Raw Access should provide data access to the underlying array. 00105 */ 00106 void testReadOnlyRawAccess( void ) 00107 { 00108 double a[2] = { 0.0, 3.1415 }; 00109 const boost::shared_ptr< std::vector< double > > v = 00110 boost::shared_ptr< std::vector< double > >( 00111 new std::vector< double >( a, a + sizeof( a ) / sizeof( double ) ) ); 00112 WValueSet< double > valueSet( 0, 1, v, W_DT_DOUBLE ); 00113 const double * const b = valueSet.rawData(); 00114 TS_ASSERT_EQUALS( b[0], 0.0 ); 00115 TS_ASSERT_EQUALS( b[1], 3.1415 ); 00116 } 00117 00118 /** 00119 * This function should return the i-th WValue with of the used dimension (prerequisite the ValueSet has order 1) 00120 */ 00121 void testGetWValue( void ) 00122 { 00123 int8_t a[6] = { 1, 2, 3, 4, 5, 6 }; 00124 std::size_t dim = 2; 00125 00126 const boost::shared_ptr< std::vector< int8_t > > v = 00127 boost::shared_ptr< std::vector< int8_t > >( 00128 new std::vector< int8_t >( a, a + sizeof( a ) / sizeof( int8_t ) ) ); 00129 WValueSet< int8_t > set( 1, dim, v, W_DT_INT8 ); 00130 00131 // testing for valid dimension and values of the returned WValue 00132 for( std::size_t idx = 0; idx < v->size()/dim; idx++ ) 00133 { 00134 WValue< int8_t > currentWValue( dim ); 00135 for( std::size_t i = 0; i < dim; i++ ) currentWValue[ i ] = ( *v )[ idx*dim + i ]; 00136 TS_ASSERT_EQUALS( set.getWValue( idx ), currentWValue ); 00137 TS_ASSERT_EQUALS( set.getWValue( idx ).size(), dim ); 00138 } 00139 00140 // catch wrong indices? 00141 TS_ASSERT_THROWS_ANYTHING( set.getWValue( v->size() ) ); 00142 TS_ASSERT_THROWS_ANYTHING( set.getWValue( v->size()*2 ) ); 00143 00144 // catch wrong order? 00145 WValueSet< int8_t > set2( 2, dim, v, W_DT_INT8 ); 00146 TS_ASSERT_THROWS_ANYTHING( set2.getWValue( 0 ) ); 00147 } 00148 00149 /** 00150 * A subarray should never exceed the valuesets boundaries and should not have a length of 0. 00151 */ 00152 void testSubArrayInstantiation() 00153 { 00154 int8_t a[4] = { 0, -5, 1, 2 }; 00155 const boost::shared_ptr< std::vector< int8_t > > v = 00156 boost::shared_ptr< std::vector< int8_t > >( 00157 new std::vector< int8_t >( a, a + sizeof( a ) / sizeof( int8_t ) ) ); 00158 WValueSet< int8_t > set( 1, 2, v, W_DT_INT8 ); 00159 TS_ASSERT_THROWS_NOTHING( set.getSubArray( 0, 2 ) ); 00160 TS_ASSERT_THROWS_NOTHING( set.getSubArray( 3, 1 ) ); 00161 TS_ASSERT_THROWS( set.getSubArray( 4, 1 ), WException ); 00162 TS_ASSERT_THROWS( set.getSubArray( 3, 2 ), WException ); 00163 TS_ASSERT_THROWS( set.getSubArray( 2, 0 ), WException ); 00164 } 00165 00166 /** 00167 * A subarray should return the correct elements. 00168 */ 00169 void testSubArrayAccess() 00170 { 00171 int8_t a[ 8 ] = { 0, -5, 1, 2, -27, 6, 29, 8 }; 00172 const boost::shared_ptr< std::vector< int8_t > > v = 00173 boost::shared_ptr< std::vector< int8_t > >( 00174 new std::vector< int8_t >( a, a + sizeof( a ) / sizeof( int8_t ) ) ); 00175 WValueSet< int8_t > set( 1, 2, v, W_DT_INT8 ); 00176 00177 { 00178 WValueSet< int8_t >::SubArray const s = set.getSubArray( 0, 2 ); 00179 00180 TS_ASSERT_THROWS_NOTHING( s[ 0 ] ); 00181 TS_ASSERT_THROWS_NOTHING( s[ 1 ] ); 00182 TS_ASSERT_THROWS_NOTHING( s[ 2 ] ); 00183 TS_ASSERT_THROWS_NOTHING( s[ 100 ] ); 00184 00185 TS_ASSERT_EQUALS( s[ 0 ], 0 ); 00186 TS_ASSERT_EQUALS( s[ 1 ], -5 ); 00187 TS_ASSERT_EQUALS( s[ 2 ], 0 ); 00188 TS_ASSERT_EQUALS( s[ 100 ], 0 ); 00189 } 00190 { 00191 WValueSet< int8_t >::SubArray const s = set.getSubArray( 1, 3 ); 00192 00193 TS_ASSERT_THROWS_NOTHING( s[ 0 ] ); 00194 TS_ASSERT_THROWS_NOTHING( s[ 1 ] ); 00195 TS_ASSERT_THROWS_NOTHING( s[ 2 ] ); 00196 TS_ASSERT_THROWS_NOTHING( s[ 100 ] ); 00197 00198 TS_ASSERT_EQUALS( s[ 0 ], -5 ); 00199 TS_ASSERT_EQUALS( s[ 1 ], 1 ); 00200 TS_ASSERT_EQUALS( s[ 2 ], 2 ); 00201 TS_ASSERT_EQUALS( s[ 100 ], -5 ); 00202 } 00203 { 00204 WValueSet< int8_t >::SubArray const s = set.getSubArray( 5, 3 ); 00205 00206 TS_ASSERT_THROWS_NOTHING( s[ 0 ] ); 00207 TS_ASSERT_THROWS_NOTHING( s[ 1 ] ); 00208 TS_ASSERT_THROWS_NOTHING( s[ 2 ] ); 00209 TS_ASSERT_THROWS_NOTHING( s[ 100 ] ); 00210 00211 TS_ASSERT_EQUALS( s[ 0 ], 6 ); 00212 TS_ASSERT_EQUALS( s[ 1 ], 29 ); 00213 TS_ASSERT_EQUALS( s[ 2 ], 8 ); 00214 TS_ASSERT_EQUALS( s[ 100 ], 6 ); 00215 } 00216 } 00217 }; 00218 00219 #endif // WVALUESET_TEST_H