Commit b2f675d3 authored by Lukas Cejka's avatar Lukas Cejka
Browse files

Added provisional tests for AdEllpack and BiEllpack.

parent c966edf6

src/UnitTests/Matrices/SparseMatrixTest.h

+256 −34
Original line number Diff line number Diff line
@@ -844,16 +844,238 @@ void test_Print() 
    EXPECT_EQ( printed.str(), couted.str() );

}



//// test fixture for typed tests

//template< typename Matrix >

//class AdEllpackMatrixTest : public ::testing::Test

//{

//protected:

//   using AdEllpackMatrixType = Matrix;

//};

//

//// types for which MatrixTest is instantiated

//using AdEllpackMatrixTypes = ::testing::Types

//<

//    TNL::Matrices::AdEllpack< int,    TNL::Devices::Host, short >,

//    TNL::Matrices::AdEllpack< long,   TNL::Devices::Host, short >,

//    TNL::Matrices::AdEllpack< float,  TNL::Devices::Host, short >,

//    TNL::Matrices::AdEllpack< double, TNL::Devices::Host, short >,

//    TNL::Matrices::AdEllpack< int,    TNL::Devices::Host, int >,

//    TNL::Matrices::AdEllpack< long,   TNL::Devices::Host, int >,

//    TNL::Matrices::AdEllpack< float,  TNL::Devices::Host, int >,

//    TNL::Matrices::AdEllpack< double, TNL::Devices::Host, int >,

//    TNL::Matrices::AdEllpack< int,    TNL::Devices::Host, long >,

//    TNL::Matrices::AdEllpack< long,   TNL::Devices::Host, long >,

//    TNL::Matrices::AdEllpack< float,  TNL::Devices::Host, long >,

//    TNL::Matrices::AdEllpack< double, TNL::Devices::Host, long >,

//#ifdef HAVE_CUDA

//    TNL::Matrices::AdEllpack< int,    TNL::Devices::Cuda, short >,

//    TNL::Matrices::AdEllpack< long,   TNL::Devices::Cuda, short >,

//    TNL::Matrices::AdEllpack< float,  TNL::Devices::Cuda, short >,

//    TNL::Matrices::AdEllpack< double, TNL::Devices::Cuda, short >,

//    TNL::Matrices::AdEllpack< int,    TNL::Devices::Cuda, int >,

//    TNL::Matrices::AdEllpack< long,   TNL::Devices::Cuda, int >,

//    TNL::Matrices::AdEllpack< float,  TNL::Devices::Cuda, int >,

//    TNL::Matrices::AdEllpack< double, TNL::Devices::Cuda, int >,

//    TNL::Matrices::AdEllpack< int,    TNL::Devices::Cuda, long >,

//    TNL::Matrices::AdEllpack< long,   TNL::Devices::Cuda, long >,

//    TNL::Matrices::AdEllpack< float,  TNL::Devices::Cuda, long >,

//    TNL::Matrices::AdEllpack< double, TNL::Devices::Cuda, long >

//#endif

//>;

//

//TYPED_TEST_CASE( AdEllpackMatrixTest, AdEllpackMatrixTypes);

//

//TYPED_TEST( AdEllpackMatrixTest, setDimensionsTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_SetDimensions< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, setCompressedRowLengthsTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_SetCompressedRowLengths< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, setLikeTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_SetLike< AdEllpackMatrixType, AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, resetTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_Reset< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, setElementTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_SetElement< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, addElementTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_AddElement< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, setRowTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_SetRow< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, vectorProductTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_VectorProduct< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, saveAndLoadTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_SaveAndLoad< AdEllpackMatrixType >();

//}

//

//TYPED_TEST( AdEllpackMatrixTest, printTest )

//{

//    using AdEllpackMatrixType = typename TestFixture::AdEllpackMatrixType;

//    

//    test_Print< AdEllpackMatrixType >();

//}

//

//// test fixture for typed tests

//template< typename Matrix >

//class BiEllpackMatrixTest : public ::testing::Test

//{

//protected:

//   using BiEllpackMatrixType = Matrix;

//};

//

//// types for which MatrixTest is instantiated

//using BiEllpackMatrixTypes = ::testing::Types

//<

//    TNL::Matrices::BiEllpack< int,    TNL::Devices::Host, short >,

//    TNL::Matrices::BiEllpack< long,   TNL::Devices::Host, short >,

//    TNL::Matrices::BiEllpack< float,  TNL::Devices::Host, short >,

//    TNL::Matrices::BiEllpack< double, TNL::Devices::Host, short >,

//    TNL::Matrices::BiEllpack< int,    TNL::Devices::Host, int >,

//    TNL::Matrices::BiEllpack< long,   TNL::Devices::Host, int >,

//    TNL::Matrices::BiEllpack< float,  TNL::Devices::Host, int >,

//    TNL::Matrices::BiEllpack< double, TNL::Devices::Host, int >,

//    TNL::Matrices::BiEllpack< int,    TNL::Devices::Host, long >,

//    TNL::Matrices::BiEllpack< long,   TNL::Devices::Host, long >,

//    TNL::Matrices::BiEllpack< float,  TNL::Devices::Host, long >,

//    TNL::Matrices::BiEllpack< double, TNL::Devices::Host, long >//,

////#ifdef HAVE_CUDA

////    TNL::Matrices::BiEllpack< int,    TNL::Devices::Cuda, short >,

////    TNL::Matrices::BiEllpack< long,   TNL::Devices::Cuda, short >,

////    TNL::Matrices::BiEllpack< float,  TNL::Devices::Cuda, short >,

////    TNL::Matrices::BiEllpack< double, TNL::Devices::Cuda, short >,

////    TNL::Matrices::BiEllpack< int,    TNL::Devices::Cuda, int >,

////    TNL::Matrices::BiEllpack< long,   TNL::Devices::Cuda, int >,

////    TNL::Matrices::BiEllpack< float,  TNL::Devices::Cuda, int >,

////    TNL::Matrices::BiEllpack< double, TNL::Devices::Cuda, int >,

////    TNL::Matrices::BiEllpack< int,    TNL::Devices::Cuda, long >,

////    TNL::Matrices::BiEllpack< long,   TNL::Devices::Cuda, long >,

////    TNL::Matrices::BiEllpack< float,  TNL::Devices::Cuda, long >,

////    TNL::Matrices::BiEllpack< double, TNL::Devices::Cuda, long >

////#endif

//>;

//

//TYPED_TEST_CASE( BiEllpackMatrixTest, BiEllpackMatrixTypes);

//

//TYPED_TEST( BiEllpackMatrixTest, setDimensionsTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_SetDimensions< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, setCompressedRowLengthsTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_SetCompressedRowLengths< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, setLikeTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_SetLike< BiEllpackMatrixType, BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, resetTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_Reset< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, setElementTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_SetElement< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, addElementTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_AddElement< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, setRowTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_SetRow< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, vectorProductTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_VectorProduct< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, saveAndLoadTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_SaveAndLoad< BiEllpackMatrixType >();

//}

//

//TYPED_TEST( BiEllpackMatrixTest, printTest )

//{

//    using BiEllpackMatrixType = typename TestFixture::BiEllpackMatrixType;

//    

//    test_Print< BiEllpackMatrixType >();

//}



// test fixture for typed tests

template< typename Matrix >

class CHEllpackMatrixTest : public ::testing::Test

class ChEllpackMatrixTest : public ::testing::Test

{

protected:

   using CHEllpackMatrixType = Matrix;

   using ChEllpackMatrixType = Matrix;

};



// types for which MatrixTest is instantiated

using CHEllpackMatrixTypes = ::testing::Types

using ChEllpackMatrixTypes = ::testing::Types

<

    TNL::Matrices::ChunkedEllpack< int,    TNL::Devices::Host, short >,

    TNL::Matrices::ChunkedEllpack< long,   TNL::Devices::Host, short >,
@@ -883,76 +1105,76 @@ using CHEllpackMatrixTypes = ::testing::Types 
#endif

>;



TYPED_TEST_CASE( CHEllpackMatrixTest, CHEllpackMatrixTypes);

TYPED_TEST_CASE( ChEllpackMatrixTest, ChEllpackMatrixTypes);



TYPED_TEST( CHEllpackMatrixTest, setDimensionsTest )

TYPED_TEST( ChEllpackMatrixTest, setDimensionsTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_SetDimensions< CHEllpackMatrixType >();

    test_SetDimensions< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, setCompressedRowLengthsTest )

TYPED_TEST( ChEllpackMatrixTest, setCompressedRowLengthsTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_SetCompressedRowLengths< CHEllpackMatrixType >();

    test_SetCompressedRowLengths< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, setLikeTest )

TYPED_TEST( ChEllpackMatrixTest, setLikeTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_SetLike< CHEllpackMatrixType, CHEllpackMatrixType >();

    test_SetLike< ChEllpackMatrixType, ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, resetTest )

TYPED_TEST( ChEllpackMatrixTest, resetTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_Reset< CHEllpackMatrixType >();

    test_Reset< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, setElementTest )

TYPED_TEST( ChEllpackMatrixTest, setElementTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_SetElement< CHEllpackMatrixType >();

    test_SetElement< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, addElementTest )

TYPED_TEST( ChEllpackMatrixTest, addElementTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_AddElement< CHEllpackMatrixType >();

    test_AddElement< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, setRowTest )

TYPED_TEST( ChEllpackMatrixTest, setRowTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_SetRow< CHEllpackMatrixType >();

    test_SetRow< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, vectorProductTest )

TYPED_TEST( ChEllpackMatrixTest, vectorProductTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_VectorProduct< CHEllpackMatrixType >();

    test_VectorProduct< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, saveAndLoadTest )

TYPED_TEST( ChEllpackMatrixTest, saveAndLoadTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_SaveAndLoad< CHEllpackMatrixType >();

    test_SaveAndLoad< ChEllpackMatrixType >();

}



TYPED_TEST( CHEllpackMatrixTest, printTest )

TYPED_TEST( ChEllpackMatrixTest, printTest )

{

    using CHEllpackMatrixType = typename TestFixture::CHEllpackMatrixType;

    using ChEllpackMatrixType = typename TestFixture::ChEllpackMatrixType;

    

    test_Print< CHEllpackMatrixType >();

    test_Print< ChEllpackMatrixType >();

}



// test fixture for typed tests