Added tests for assert macros in TNL (246f74a1) · Commits · TNL / tnl-dev

src/UnitTests/AssertCudaTest.cu

0 → 100644

+110 −0

Original line number	Diff line number	Diff line
		/***************************************************************************
		AssertCudaTest.h - description
		-------------------
		begin : Sep 7, 2018
		copyright : (C) 2018 by Tomas Oberhuber et al.
		email : tomas.oberhuber@fjfi.cvut.cz
		***************************************************************************/

		/* See Copyright Notice in tnl/Copyright */

		#include <TNL/Assert.h>
		#include <TNL/Devices/Cuda.h>
		#include <TNL/Exceptions/CudaRuntimeError.h>

		#ifdef HAVE_GTEST
		#include <gtest/gtest.h>

		using namespace TNL;

		#ifdef HAVE_CUDA

		#define WRAP_ASSERT( suffix, statement, not_failing ) \
		__global__ \
		void kernel_##suffix( int* output ) \
		{ \
		const bool tr = true; \
		const bool fa = false; \
		const int two = 2; \
		const int ten = 10; \
		/* pointers */ \
		const double* data_null = nullptr; \
		const double** data_full = &data_null; \
		\
		statement \
		\
		/* actually do something to test if the execution control gets here */ \
		output[0] = 1; \
		} \
		\
		TEST( AssertCudaTest, suffix ) \
		{ \
		int* output_cuda; \
		int output_host = 0; \
		\
		cudaMalloc( (void**)&output_cuda, sizeof(int) ); \
		cudaMemcpy( output_cuda, &output_host, sizeof(int), cudaMemcpyHostToDevice ); \
		\
		kernel_##suffix<<<1, 1>>>(output_cuda); \
		cudaDeviceSynchronize(); \
		if( not_failing ) { \
		EXPECT_NO_THROW( TNL_CHECK_CUDA_DEVICE; ); \
		cudaMemcpy( &output_host, output_cuda, sizeof(int), cudaMemcpyDeviceToHost ); \
		cudaFree( output_cuda ); \
		EXPECT_EQ( output_host, 1 ); \
		} \
		else \
		EXPECT_THROW( TNL_CHECK_CUDA_DEVICE;, \
		TNL::Exceptions::CudaRuntimeError ); \
		} \


		// not failing statements:
		WRAP_ASSERT( test1, TNL_ASSERT_TRUE( true, "true is true" );, true );
		WRAP_ASSERT( test2, TNL_ASSERT_TRUE( tr, "true is true" );, true );
		WRAP_ASSERT( test3, TNL_ASSERT_FALSE( false, "false is false" );, true );
		WRAP_ASSERT( test4, TNL_ASSERT_FALSE( fa, "false is false" );, true );

		WRAP_ASSERT( test5, TNL_ASSERT_EQ( two, 2, "two is 2" );, true );
		WRAP_ASSERT( test6, TNL_ASSERT_NE( ten, 2, "ten is not 2" );, true );
		WRAP_ASSERT( test7, TNL_ASSERT_LT( two, 10, "two < 10" );, true );
		WRAP_ASSERT( test8, TNL_ASSERT_LE( two, 10, "two <= 10" );, true );
		WRAP_ASSERT( test9, TNL_ASSERT_LE( two, 2, "two <= 2" );, true );
		WRAP_ASSERT( test10, TNL_ASSERT_GT( ten, 2, "ten > 2" );, true );
		WRAP_ASSERT( test11, TNL_ASSERT_GE( ten, 10, "ten >= 10" );, true );
		WRAP_ASSERT( test12, TNL_ASSERT_GE( ten, 2, "ten >= 2" );, true );

		WRAP_ASSERT( test13, TNL_ASSERT_FALSE( data_null, "nullptr is false" );, true );
		WRAP_ASSERT( test14, TNL_ASSERT_TRUE( data_full, "non-nullptr is true" );, true );

		// errors:
		WRAP_ASSERT( test15, TNL_ASSERT_TRUE( false, "false is true" );, false );
		WRAP_ASSERT( test16, TNL_ASSERT_TRUE( fa, "false is true" );, false );
		WRAP_ASSERT( test17, TNL_ASSERT_FALSE( true, "true is false" );, false );
		WRAP_ASSERT( test18, TNL_ASSERT_FALSE( tr, "true is false" );, false );

		WRAP_ASSERT( test19, TNL_ASSERT_NE( two, 2, "two != 2" );, false );
		WRAP_ASSERT( test20, TNL_ASSERT_EQ( ten, 2, "ten == 2" );, false );
		WRAP_ASSERT( test21, TNL_ASSERT_GE( two, 10, "two >= 10" );, false );
		WRAP_ASSERT( test22, TNL_ASSERT_GT( two, 10, "two > 10" );, false );
		WRAP_ASSERT( test23, TNL_ASSERT_GT( two, 2, "two > 2" );, false );
		WRAP_ASSERT( test24, TNL_ASSERT_LE( ten, 2, "ten <= 2" );, false );
		WRAP_ASSERT( test25, TNL_ASSERT_LT( ten, 10, "ten < 10" );, false );
		WRAP_ASSERT( test26, TNL_ASSERT_LT( ten, 2, "ten < 2" );, false );

		WRAP_ASSERT( test27, TNL_ASSERT_TRUE( data_null, "nullptr is true" );, false );
		WRAP_ASSERT( test28, TNL_ASSERT_FALSE( data_full, "non-nullptr is false" );, false );

		#endif
		#endif

		#include "GtestMissingError.h"
		int main( int argc, char* argv[] )
		{
		#ifdef HAVE_GTEST
		::testing::InitGoogleTest( &argc, argv );
		return RUN_ALL_TESTS();
		#else
		throw GtestMissingError();
		#endif
		}

src/UnitTests/AssertTest.cpp

0 → 100644

+76 −0

Original line number	Diff line number	Diff line
		/***************************************************************************
		AssertTest.h - description
		-------------------
		begin : Sep 7, 2018
		copyright : (C) 2018 by Tomas Oberhuber et al.
		email : tomas.oberhuber@fjfi.cvut.cz
		***************************************************************************/

		/* See Copyright Notice in tnl/Copyright */

		#include <TNL/Assert.h>

		#ifdef HAVE_GTEST
		#include <gtest/gtest.h>

		using namespace TNL;

		TEST( AssertTest, basicTest )
		{
		const bool tr = true;
		const bool fa = false;
		const int two = 2;
		const int ten = 10;

		// true statements:
		EXPECT_NO_THROW( TNL_ASSERT_TRUE( true, "true is true" ); );
		EXPECT_NO_THROW( TNL_ASSERT_TRUE( tr, "true is true" ); );
		EXPECT_NO_THROW( TNL_ASSERT_FALSE( false, "false is false" ); );
		EXPECT_NO_THROW( TNL_ASSERT_FALSE( fa, "false is false" ); );
		EXPECT_NO_THROW( TNL_ASSERT_EQ( two, 2, "two is 2" ); );
		EXPECT_NO_THROW( TNL_ASSERT_NE( ten, 2, "ten is not 2" ); );
		EXPECT_NO_THROW( TNL_ASSERT_LT( two, 10, "two < 10" ); );
		EXPECT_NO_THROW( TNL_ASSERT_LE( two, 10, "two <= 10" ); );
		EXPECT_NO_THROW( TNL_ASSERT_LE( two, 2, "two <= 2" ); );
		EXPECT_NO_THROW( TNL_ASSERT_GT( ten, 2, "ten > 2" ); );
		EXPECT_NO_THROW( TNL_ASSERT_GE( ten, 10, "ten >= 10" ); );
		EXPECT_NO_THROW( TNL_ASSERT_GE( ten, 2, "ten >= 2" ); );

		// errors:
		EXPECT_ANY_THROW( TNL_ASSERT_TRUE( false, "false is true" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_TRUE( fa, "false is true" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_FALSE( true, "true is false" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_FALSE( tr, "true is false" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_NE( two, 2, "two != 2" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_EQ( ten, 2, "ten == 2" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_GE( two, 10, "two >= 10" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_GT( two, 10, "two > 10" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_GT( two, 2, "two > 2" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_LE( ten, 2, "ten <= 2" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_LT( ten, 10, "ten < 10" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_LT( ten, 2, "ten < 2" ); );

		// pointers
		const double* data_null = nullptr;
		const double** data_full = &data_null;

		// true statements:
		EXPECT_NO_THROW( TNL_ASSERT_FALSE( data_null, "nullptr is false" ); );
		EXPECT_NO_THROW( TNL_ASSERT_TRUE( data_full, "non-nullptr is true" ); );

		// errors
		EXPECT_ANY_THROW( TNL_ASSERT_TRUE( data_null, "nullptr is true" ); );
		EXPECT_ANY_THROW( TNL_ASSERT_FALSE( data_full, "non-nullptr is false" ); );
		}
		#endif

		#include "GtestMissingError.h"
		int main( int argc, char* argv[] )
		{
		#ifdef HAVE_GTEST
		::testing::InitGoogleTest( &argc, argv );
		return RUN_ALL_TESTS();
		#else
		throw GtestMissingError();
		#endif
		}

src/UnitTests/CMakeLists.txt

+20 −3

Original line number	Diff line number	Diff line
		@@ -5,24 +5,37 @@ ADD_SUBDIRECTORY( Functions )
		ADD_SUBDIRECTORY( Matrices )
		ADD_SUBDIRECTORY( Meshes )

		ADD_EXECUTABLE( AssertTest AssertTest.cpp )
		TARGET_COMPILE_OPTIONS( AssertTest PRIVATE ${CXX_TESTS_FLAGS} )
		TARGET_LINK_LIBRARIES( AssertTest
		${GTEST_BOTH_LIBRARIES}
		tnl )

		if( BUILD_CUDA )
		CUDA_ADD_EXECUTABLE( AssertCudaTest AssertCudaTest.cu OPTIONS ${CXX_TESTS_FLAGS} )
		TARGET_LINK_LIBRARIES( AssertCudaTest
		${GTEST_BOTH_LIBRARIES}
		tnl )
		endif()

		ADD_EXECUTABLE( UniquePointerTest UniquePointerTest.cpp )
		TARGET_COMPILE_OPTIONS( UniquePointerTest PRIVATE ${CXX_TESTS_FLAGS} )
		TARGET_LINK_LIBRARIES( UniquePointerTest
		${GTEST_BOTH_LIBRARIES}
		tnl )

		IF( BUILD_CUDA )
		if( BUILD_CUDA )
		CUDA_ADD_EXECUTABLE( FileTest FileTest.cu OPTIONS ${CXX_TESTS_FLAGS} )
		TARGET_LINK_LIBRARIES( FileTest
		${GTEST_BOTH_LIBRARIES}
		tnl )
		ELSE( BUILD_CUDA )
		else()
		ADD_EXECUTABLE( FileTest FileTest.cpp )
		TARGET_COMPILE_OPTIONS( FileTest PRIVATE ${CXX_TESTS_FLAGS} )
		TARGET_LINK_LIBRARIES( FileTest
		${GTEST_BOTH_LIBRARIES}
		tnl )
		ENDIF( BUILD_CUDA )
		endif()

		ADD_EXECUTABLE( StringTest StringTest.cpp )
		TARGET_COMPILE_OPTIONS( StringTest PRIVATE ${CXX_TESTS_FLAGS} )
		@@ -42,6 +55,10 @@ TARGET_LINK_LIBRARIES( SaveAndLoadMeshfunctionTest
		${GTEST_BOTH_LIBRARIES}
		tnl )

		ADD_TEST( AssertTest ${EXECUTABLE_OUTPUT_PATH}/AssertTest${CMAKE_EXECUTABLE_SUFFIX} )
		if( BUILD_CUDA )
		ADD_TEST( AssertCudaTest ${EXECUTABLE_OUTPUT_PATH}/AssertCudaTest${CMAKE_EXECUTABLE_SUFFIX} )
		endif()
		ADD_TEST( FileTest ${EXECUTABLE_OUTPUT_PATH}/FileTest${CMAKE_EXECUTABLE_SUFFIX} )
		ADD_TEST( StringTest ${EXECUTABLE_OUTPUT_PATH}/StringTest${CMAKE_EXECUTABLE_SUFFIX} )
		ADD_TEST( ObjectTest ${EXECUTABLE_OUTPUT_PATH}/ObjectTest${CMAKE_EXECUTABLE_SUFFIX} )