Commit e99daed4 authored by Jakub Klinkovský's avatar Jakub Klinkovský
Browse files

Added tests for mesh readers and sample data

parent 00676af3

src/UnitTests/Meshes/CMakeLists.txt

+25 −0
Original line number Diff line number Diff line
@@ -35,3 +35,28 @@ ADD_TEST( EntityTagsTest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/EntityTagsTest${CMAKE 
ADD_TEST( MeshTest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/MeshTest${CMAKE_EXECUTABLE_SUFFIX} )

ADD_TEST( MeshTraverserTest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/MeshTraverserTest${CMAKE_EXECUTABLE_SUFFIX} )

ADD_TEST( MeshOrderingTest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/MeshOrderingTest${CMAKE_EXECUTABLE_SUFFIX} )





# special tests needing external libraries

find_package( ZLIB )

find_package( tinyxml2 QUIET )



if( ZLIB_FOUND AND tinyxml2_FOUND )

   foreach( target IN ITEMS NetgenReaderTest VTKReaderTest VTUReaderTest )

      add_executable(${target} ${target}.cpp)

      target_compile_options(${target} PRIVATE ${CXX_TESTS_FLAGS} )

      target_link_libraries(${target} ${GTEST_BOTH_LIBRARIES})



      target_compile_definitions(${target} PUBLIC "-DHAVE_ZLIB")

      target_include_directories(${target} PUBLIC ${ZLIB_INCLUDE_DIRS})

      target_link_libraries(${target} ${ZLIB_LIBRARIES})



      target_compile_definitions(${target} PUBLIC "-DHAVE_TINYXML2")

      target_link_libraries(${target} tinyxml2::tinyxml2)



      # configure path to the data directory

      target_compile_definitions(${target} PUBLIC "-DTNL_MESH_TESTS_DATA_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/data\"")



      add_test(${target} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${target}${CMAKE_EXECUTABLE_SUFFIX})

   endforeach()

endif()

src/UnitTests/Meshes/MeshReaderTest.h

0 → 100644
+130 −0
Original line number Diff line number Diff line 
#pragma once



#include <gtest/gtest.h>



#include <string>

#include <fstream>



#include <TNL/Meshes/TypeResolver/resolveMeshType.h>



template< typename ReaderType, template<typename> class WriterType, typename MeshType >

void test_reader( const MeshType& mesh, std::string outputFileName )

{

   // write the mesh into the file (new scope is needed to properly close the file)

   {

      std::ofstream file( outputFileName );

      WriterType< MeshType > writer( file );

      writer.writeEntities( mesh );

   }



   MeshType mesh_in;

   ReaderType reader( outputFileName );

   reader.loadMesh( mesh_in );



   EXPECT_EQ( mesh_in, mesh );



   EXPECT_EQ( std::remove( outputFileName.c_str() ), 0 );

}



// Test that:

// 1. resolveMeshType resolves the mesh type correctly

// 2. resolveAndLoadMesh loads the mesh

template< template<typename> class WriterType, typename ConfigTag, typename MeshType >

void test_resolveAndLoadMesh( const MeshType& mesh, std::string outputFileName )

{

   // write the mesh into the file (new scope is needed to properly close the file)

   {

      std::ofstream file( outputFileName );

      WriterType< MeshType > writer( file );

      writer.writeEntities( mesh );

   }



   auto wrapper = [&] ( TNL::Meshes::Readers::MeshReader& reader, auto&& mesh2 )

   {

      using MeshType2 = std::decay_t< decltype(mesh2) >;



      // static_assert does not work, the wrapper is actually instantiated for all resolved types

//      static_assert( std::is_same< MeshType2, MeshType >::value, "mesh type was not resolved as expected" );

      EXPECT_EQ( std::string( TNL::getType< MeshType2 >() ), std::string( TNL::getType< MeshType >() ) );



      // operator== does not work for instantiations of the wrapper with MeshType2 != MeshType

//      EXPECT_EQ( mesh2, mesh );

      std::stringstream str1, str2;

      str1 << mesh;

      str2 << mesh2;

      EXPECT_EQ( str2.str(), str1.str() );



      return true;

   };



   const bool status = TNL::Meshes::resolveAndLoadMesh< ConfigTag, TNL::Devices::Host >( wrapper, outputFileName );

   EXPECT_TRUE( status );



   EXPECT_EQ( std::remove( outputFileName.c_str() ), 0 );

}



template< typename ReaderType, template<typename> class WriterType, typename MeshType >

void test_meshfunction( const MeshType& mesh, std::string outputFileName, std::string type = "PointData" )

{

   using ArrayType = TNL::Containers::Array< std::int32_t >;

   ArrayType array_scalars, array_vectors;

   if( type == "PointData" ) {

      array_scalars.setSize( 1 * mesh.template getEntitiesCount< 0 >() );

      array_vectors.setSize( 3 * mesh.template getEntitiesCount< 0 >() );

   }

   else {

      array_scalars.setSize( 1 * mesh.template getEntitiesCount< MeshType::getMeshDimension() >() );

      array_vectors.setSize( 3 * mesh.template getEntitiesCount< MeshType::getMeshDimension() >() );

   }

   for( int i = 0; i < array_scalars.getSize(); i++ )

      array_scalars[i] = i;

   for( int i = 0; i < array_vectors.getSize(); i++ )

      array_vectors[i] = i;



   // write the mesh into the file (new scope is needed to properly close the file)

   {

      std::ofstream file( outputFileName );

      WriterType< MeshType > writer( file );

      writer.writeMetadata( 42, 3.14 );  // cycle, time

      writer.writeEntities( mesh );

      if( type == "PointData" ) {

         writer.writePointData( array_scalars, "foo" );

         writer.writePointData( array_vectors, "bar", 3 );

      }

      else {

         writer.writeCellData( array_scalars, "foo" );

         writer.writeCellData( array_vectors, "bar", 3 );

      }

   }



   MeshType mesh_in;

   ReaderType reader( outputFileName );

   reader.loadMesh( mesh_in );

   EXPECT_EQ( mesh_in, mesh );



   ArrayType array_scalars_in, array_vectors_in;

   typename ReaderType::VariantVector variant_scalars, variant_vectors;

   if( type == "PointData" ) {

      variant_scalars = reader.readPointData( "foo" );

      variant_vectors = reader.readPointData( "bar" );

   }

   else {

      variant_scalars = reader.readCellData( "foo" );

      variant_vectors = reader.readCellData( "bar" );

   }

   using mpark::visit;

   visit( [&array_scalars_in](auto&& vector) {

            array_scalars_in = vector;

         },

         variant_scalars

      );

   visit( [&array_vectors_in](auto&& vector) {

            array_vectors_in = vector;

         },

         variant_vectors

      );

   EXPECT_EQ( array_scalars_in, array_scalars );

   EXPECT_EQ( array_vectors_in, array_vectors );



   EXPECT_EQ( std::remove( outputFileName.c_str() ), 0 );

}

src/UnitTests/Meshes/NetgenReaderTest.cpp

0 → 100644
+122 −0
Original line number Diff line number Diff line 
#ifdef HAVE_GTEST

#include <gtest/gtest.h>



#include <TNL/Meshes/Readers/NetgenReader.h>

#include <TNL/Meshes/Writers/NetgenWriter.h>

#include <TNL/Meshes/TypeResolver/resolveMeshType.h>



#include "data/loader.h"



using namespace TNL::Meshes;



static const char* TEST_FILE_NAME = "test_NetgenReaderTest.ng";



struct MyConfigTag {};



namespace TNL {

namespace Meshes {

namespace BuildConfigTags {



// disable all grids

template< int Dimension, typename Real, typename Device, typename Index >

struct GridTag< MyConfigTag, Grid< Dimension, Real, Device, Index > >{ enum { enabled = false }; };



// enable meshes used in the tests

//template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Edge > { enum { enabled = true }; };

template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Triangle > { enum { enabled = true }; };

template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Tetrahedron > { enum { enabled = true }; };



} // namespace BuildConfigTags

} // namespace Meshes

} // namespace TNL



template< typename MeshType >

void test_NetgenReader( const MeshType& mesh )

{

   // write the mesh into the file (new scope is needed to properly close the file)

   {

      std::ofstream file( TEST_FILE_NAME );

      Writers::NetgenWriter< MeshType > writer;

      writer.writeMesh( mesh, file );

   }



   MeshType mesh_in;

   Readers::NetgenReader reader( TEST_FILE_NAME );

   reader.loadMesh( mesh_in );



   EXPECT_EQ( mesh_in, mesh );



   EXPECT_EQ( std::remove( TEST_FILE_NAME ), 0 );

}



// Test that:

// 1. resolveMeshType resolves the mesh type correctly

// 2. resolveAndLoadMesh loads the mesh

template< typename ConfigTag, typename MeshType >

void test_resolveAndLoadMesh( const MeshType& mesh )

{

   // write the mesh into the file (new scope is needed to properly close the file)

   {

      std::ofstream file( TEST_FILE_NAME );

      Writers::NetgenWriter< MeshType > writer;

      writer.writeMesh( mesh, file );

   }



   auto wrapper = [&] ( Readers::MeshReader& reader, auto&& mesh2 )

   {

      using MeshType2 = std::decay_t< decltype(mesh2) >;



      // static_assert does not work, the wrapper is actually instantiated for all resolved types

//      static_assert( std::is_same< MeshType2, MeshType >::value, "mesh type was not resolved as expected" );

      EXPECT_EQ( std::string( TNL::getType< MeshType2 >() ), std::string( TNL::getType< MeshType >() ) );



      // operator== does not work for instantiations of the wrapper with MeshType2 != MeshType

//      EXPECT_EQ( mesh2, mesh );

      std::stringstream str1, str2;

      str1 << mesh;

      str2 << mesh2;

      EXPECT_EQ( str2.str(), str1.str() );



      return true;

   };



   const bool status = resolveAndLoadMesh< ConfigTag, TNL::Devices::Host >( wrapper, TEST_FILE_NAME );

   EXPECT_TRUE( status );



   EXPECT_EQ( std::remove( TEST_FILE_NAME ), 0 );

}



// TODO: test case for 1D mesh of edges



TEST( NetgenReaderTest, triangles )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::NetgenReader >( "triangles/netgen_square.ng" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 289 );

   EXPECT_EQ( cells, 512 );



   test_NetgenReader( mesh );

   test_resolveAndLoadMesh< MyConfigTag >( mesh );

}



TEST( NetgenReaderTest, tetrahedrons )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Tetrahedron > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::NetgenReader >( "tetrahedrons/netgen_cube.ng" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 4913 );

   EXPECT_EQ( cells, 24576 );



   test_NetgenReader( mesh );

   test_resolveAndLoadMesh< MyConfigTag >( mesh );

}

#endif



#include "../main.h"

src/UnitTests/Meshes/VTKReaderTest.cpp

0 → 100644
+129 −0
Original line number Diff line number Diff line 
#ifdef HAVE_GTEST

#include <gtest/gtest.h>



#include <TNL/Meshes/Readers/VTKReader.h>

#include <TNL/Meshes/Writers/VTKWriter.h>

#include <TNL/Meshes/TypeResolver/resolveMeshType.h>



#include "data/loader.h"

#include "MeshReaderTest.h"



using namespace TNL::Meshes;



static const char* TEST_FILE_NAME = "test_VTKReaderTest.vtk";



struct MyConfigTag {};



namespace TNL {

namespace Meshes {

namespace BuildConfigTags {



// disable all grids

template< int Dimension, typename Real, typename Device, typename Index >

struct GridTag< MyConfigTag, Grid< Dimension, Real, Device, Index > >{ enum { enabled = false }; };



// enable meshes used in the tests

//template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Edge > { enum { enabled = true }; };

template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Triangle > { enum { enabled = true }; };

template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Tetrahedron > { enum { enabled = true }; };



} // namespace BuildConfigTags

} // namespace Meshes

} // namespace TNL



// TODO: test case for 1D mesh of edges



// ASCII data, produced by Gmsh

TEST( VTKReaderTest, mrizka_1 )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTKReader >( "triangles/mrizka_1.vtk" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 142 );

   EXPECT_EQ( cells, 242 );



   test_reader< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTKWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// ASCII data, produced by Gmsh

TEST( VTKReaderTest, tetrahedrons )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Tetrahedron > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTKReader >( "tetrahedrons/cube1m_1.vtk" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 395 );

   EXPECT_EQ( cells, 1312 );



   test_reader< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTKWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// binary data, produced by RF writer

TEST( VTKReaderTest, triangles_2x2x2_original_with_metadata_and_cell_data )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTKReader >( "triangles_2x2x2/original_with_metadata_and_cell_data.vtk" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTKWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// ASCII data, produced by TNL writer

TEST( VTKReaderTest, triangles_2x2x2_minimized_ascii )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTKReader >( "triangles_2x2x2/minimized_ascii.vtk" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTKWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// binary data, produced by TNL writer

TEST( VTKReaderTest, triangles_2x2x2_minimized_binary )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTKReader >( "triangles_2x2x2/minimized_binary.vtk" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTKWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTKReader, Writers::VTKWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// TODO: test case for DataFile version 5.1: triangles_2x2x2/DataFile_version_5.1_exported_from_paraview.vtk

#endif



#include "../main.h"

src/UnitTests/Meshes/VTUReaderTest.cpp

0 → 100644
+163 −0
Original line number Diff line number Diff line 
#ifdef HAVE_GTEST

#include <gtest/gtest.h>



#include <TNL/Meshes/Readers/VTUReader.h>

#include <TNL/Meshes/Writers/VTUWriter.h>

#include <TNL/Meshes/TypeResolver/resolveMeshType.h>



#include "data/loader.h"

#include "MeshReaderTest.h"



using namespace TNL::Meshes;



static const char* TEST_FILE_NAME = "test_VTUReaderTest.vtu";



struct MyConfigTag {};



namespace TNL {

namespace Meshes {

namespace BuildConfigTags {



// disable all grids

template< int Dimension, typename Real, typename Device, typename Index >

struct GridTag< MyConfigTag, Grid< Dimension, Real, Device, Index > >{ enum { enabled = false }; };



// enable meshes used in the tests

//template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Edge > { enum { enabled = true }; };

template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Triangle > { enum { enabled = true }; };

template<> struct MeshCellTopologyTag< MyConfigTag, Topologies::Tetrahedron > { enum { enabled = true }; };



} // namespace BuildConfigTags

} // namespace Meshes

} // namespace TNL



// TODO: test case for 1D mesh of edges



TEST( VTUReaderTest, mrizka_1 )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTUReader >( "triangles/mrizka_1.vtu" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 142 );

   EXPECT_EQ( cells, 242 );



   test_reader< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTUWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



TEST( VTUReaderTest, tetrahedrons )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Tetrahedron > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTUReader >( "tetrahedrons/cube1m_1.vtu" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 395 );

   EXPECT_EQ( cells, 1312 );



   test_reader< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTUWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// ASCII data, produced by TNL writer

TEST( VTUReaderTest, triangles_2x2x2_minimized_ascii )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTUReader >( "triangles_2x2x2/minimized_ascii.vtu" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTUWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// encoded data, produced by TNL writer

TEST( VTUReaderTest, triangles_2x2x2_minimized_encoded_tnl )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTUReader >( "triangles_2x2x2/minimized_encoded_tnl.vtu" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTUWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// encoded data, produced by Paraview

TEST( VTUReaderTest, triangles_2x2x2_minimized_encoded_paraview )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTUReader >( "triangles_2x2x2/minimized_encoded_paraview.vtu" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTUWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// compressed data, produced by TNL

TEST( VTUReaderTest, triangles_2x2x2_minimized_compressed_tnl )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTUReader >( "triangles_2x2x2/minimized_compressed_tnl.vtu" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTUWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// compressed data, produced by Paraview

TEST( VTUReaderTest, triangles_2x2x2_minimized_compressed_paraview )

{

   using MeshType = Mesh< DefaultConfig< Topologies::Triangle > >;

   const MeshType mesh = loadMeshFromFile< MeshType, Readers::VTUReader >( "triangles_2x2x2/minimized_compressed_paraview.vtu" );



   // test that the mesh was actually loaded

   const auto vertices = mesh.template getEntitiesCount< 0 >();

   const auto cells = mesh.template getEntitiesCount< MeshType::getMeshDimension() >();

   EXPECT_EQ( vertices, 9 );

   EXPECT_EQ( cells, 8 );



   test_reader< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME );

   test_resolveAndLoadMesh< Writers::VTUWriter, MyConfigTag >( mesh, TEST_FILE_NAME );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "PointData" );

   test_meshfunction< Readers::VTUReader, Writers::VTUWriter >( mesh, TEST_FILE_NAME, "CellData" );

}



// TODO: test cases for the appended data block: minimized_appended_binary_compressed.vtu, minimized_appended_binary.vtu, minimized_appended_encoded_compressed.vtu, minimized_appended_encoded.vtu

#endif



#include "../main.h"