Skip to content
Snippets Groups Projects
Commit 4de0fc8a authored by Atkins, Charles Vernon's avatar Atkins, Charles Vernon
Browse files

Refactoring of engine tests

parent 5b8a8d56
No related branches found
No related tags found
1 merge request!89Refactoring of engine tests
Hide whitespace changes
Inline Side-by-side
Showing
with 365 additions and 252 deletions
testing/adios2/engine/EngineWriteReadTest.cpp 0 → 100644
+ 162
− 0
View file @ 4de0fc8a
#include "EngineWriteReadTest.h"
#include <cstdint>
#include <array>
#include <iostream>
#include <stdexcept>
#include <adios2.h>
#include <gtest/gtest.h>
EngineWriteReadTestBase::EngineWriteReadTestBase(std::string engineName,
std::string fileName)
: m_EngineName(engineName), m_FileName(fileName), m_Method(nullptr)
{
}
void EngineWriteReadTestBase::SetUpTestCase()
{
#ifdef ADIOS2_HAVE_MPI
MPI_Init(nullptr, nullptr);
#endif
}
void EngineWriteReadTestBase::TearDownTestCase()
{
#ifdef ADIOS2_HAVE_MPI
MPI_Finalize();
#endif
}
void EngineWriteReadTestBase::SetUp()
{
m_adios = std::unique_ptr<adios::ADIOS>(
new adios::ADIOS(adios::Verbose::WARN, true));
}
void EngineWriteReadTestBase::TearDown() { m_adios.reset(); }
void EngineWriteReadTestBase::SetUpWrite()
{
m_Method = &m_adios->DeclareMethod("TestMethod");
m_Method->SetEngine(m_EngineName);
m_Method->AddTransport("File");
m_Engine = m_adios->Open(m_FileName, "w", *m_Method);
ASSERT_NE(m_Engine, nullptr);
}
void EngineWriteReadTestBase::TearDownWrite()
{
m_Method = nullptr;
m_Engine->Close();
m_Engine.reset();
}
void EngineWriteReadTestBase::WriteStep(size_t step)
{
auto &var_i8 = m_adios->GetVariable<char>("i8");
auto &var_i16 = m_adios->GetVariable<short>("i16");
auto &var_i32 = m_adios->GetVariable<int>("i32");
auto &var_i64 = m_adios->GetVariable<long>("i64");
auto &var_u8 = m_adios->GetVariable<unsigned char>("u8");
auto &var_u16 = m_adios->GetVariable<unsigned short>("u16");
auto &var_u32 = m_adios->GetVariable<unsigned int>("u32");
auto &var_u64 = m_adios->GetVariable<unsigned long>("u64");
auto &var_r32 = m_adios->GetVariable<float>("r32");
auto &var_r64 = m_adios->GetVariable<double>("r64");
m_Engine->Write(var_i8, m_DataI8.cbegin() + step);
m_Engine->Write(var_i16, m_DataI16.cbegin() + step);
m_Engine->Write(var_i32, m_DataI32.cbegin() + step);
m_Engine->Write(var_i64, m_DataI64.cbegin() + step);
m_Engine->Write(var_u8, m_DataU8.cbegin() + step);
m_Engine->Write(var_u16, m_DataU16.cbegin() + step);
m_Engine->Write(var_u32, m_DataU32.cbegin() + step);
m_Engine->Write(var_u64, m_DataU64.cbegin() + step);
m_Engine->Write(var_r32, m_DataR32.cbegin() + step);
m_Engine->Write(var_r64, m_DataR64.cbegin() + step);
}
void EngineWriteReadTestBase::Write3Steps()
{
for (size_t t = 0; t < 3; ++t)
{
WriteStep(t);
m_Engine->Advance();
}
}
void EngineWriteReadTestBase::WriteRead()
{
Declare();
SetUpWrite();
Write3Steps();
TearDownWrite();
}
//******************************************************************************
// 1D test data
//******************************************************************************
void EngineWriteRead1DTest::Declare()
{
auto &var_i8 = m_adios->DefineVariable<char>("i8", adios::Dims{8});
auto &var_i16 = m_adios->DefineVariable<short>("i16", adios::Dims{8});
auto &var_i32 = m_adios->DefineVariable<int>("i32", adios::Dims{8});
auto &var_i64 = m_adios->DefineVariable<long>("i64", adios::Dims{8});
auto &var_u8 = m_adios->DefineVariable<unsigned char>("u8", adios::Dims{8});
auto &var_u16 =
m_adios->DefineVariable<unsigned short>("u16", adios::Dims{8});
auto &var_u32 =
m_adios->DefineVariable<unsigned int>("u32", adios::Dims{8});
auto &var_u64 =
m_adios->DefineVariable<unsigned long>("u64", adios::Dims{8});
auto &var_r32 = m_adios->DefineVariable<float>("r32", adios::Dims{8});
auto &var_r64 = m_adios->DefineVariable<double>("r64", adios::Dims{8});
}
//******************************************************************************
// 2D 2x4 test data
//******************************************************************************
void EngineWriteRead2D2x4Test::Declare()
{
auto &var_i8 = m_adios->DefineVariable<char>("i8", adios::Dims{2, 4});
auto &var_i16 = m_adios->DefineVariable<short>("i16", adios::Dims{2, 4});
auto &var_i32 = m_adios->DefineVariable<int>("i32", adios::Dims{2, 4});
auto &var_i64 = m_adios->DefineVariable<long>("i64", adios::Dims{2, 4});
auto &var_u8 =
m_adios->DefineVariable<unsigned char>("u8", adios::Dims{2, 4});
auto &var_u16 =
m_adios->DefineVariable<unsigned short>("u16", adios::Dims{2, 4});
auto &var_u32 =
m_adios->DefineVariable<unsigned int>("u32", adios::Dims{2, 4});
auto &var_u64 =
m_adios->DefineVariable<unsigned long>("u64", adios::Dims{2, 4});
auto &var_r32 = m_adios->DefineVariable<float>("r32", adios::Dims{2, 4});
auto &var_r64 = m_adios->DefineVariable<double>("r64", adios::Dims{2, 4});
}
//******************************************************************************
// 2D 4x2 test data
//******************************************************************************
void EngineWriteRead2D4x2Test::Declare()
{
auto &var_i8 = m_adios->DefineVariable<char>("i8", adios::Dims{4, 2});
auto &var_i16 = m_adios->DefineVariable<short>("i16", adios::Dims{4, 2});
auto &var_i32 = m_adios->DefineVariable<int>("i32", adios::Dims{4, 2});
auto &var_i64 = m_adios->DefineVariable<long>("i64", adios::Dims{4, 2});
auto &var_u8 =
m_adios->DefineVariable<unsigned char>("u8", adios::Dims{4, 2});
auto &var_u16 =
m_adios->DefineVariable<unsigned short>("u16", adios::Dims{4, 2});
auto &var_u32 =
m_adios->DefineVariable<unsigned int>("u32", adios::Dims{4, 2});
auto &var_u64 =
m_adios->DefineVariable<unsigned long>("u64", adios::Dims{4, 2});
auto &var_r32 = m_adios->DefineVariable<float>("r32", adios::Dims{4, 2});
auto &var_r64 = m_adios->DefineVariable<double>("r64", adios::Dims{4, 2});
}
testing/adios2/engine/EngineWriteReadTest.h 0 → 100644
+ 107
− 0
View file @ 4de0fc8a
#include <cstdint>
#include <array>
#include <iostream>
#include <stdexcept>
#include <adios2.h>
#include <gtest/gtest.h>
class EngineWriteReadTestBase : public ::testing::Test
{
public:
EngineWriteReadTestBase(std::string engineName, std::string fileName);
protected:
std::unique_ptr<adios::ADIOS> m_adios;
std::string m_EngineName;
std::string m_FileName;
// To be created by child class SetUp()
adios::Method *m_Method;
std::shared_ptr<adios::Engine> m_Engine;
// Handle MPI things if necessary
static void SetUpTestCase();
static void TearDownTestCase();
// Create and destroy the manager class
virtual void SetUp();
virtual void TearDown();
virtual void SetUpWrite();
virtual void TearDownWrite();
// Shared test functions
virtual void Declare() = 0;
void WriteStep(size_t step);
void Write3Steps();
void WriteRead();
//*************************************************************************
// Test Data
//*************************************************************************
// Test data for each type. Make sure our values exceed the range of the
// previous size to make sure we all bytes for each element
std::array<char, 10> m_DataI8 = {{0, 1, -2, 3, -4, 5, -6, 7, -8, 9}};
std::array<int16_t, 10> m_DataI16 = {
{512, 513, -510, 515, -508, 517, -506, 519, -504, 521}};
std::array<int32_t, 10> m_DataI32 = {{131072, 131073, -131070, 131075,
-131068, 131077, -131066, 131079,
-131064, 131081}};
std::array<int64_t, 10> m_DataI64 = {
{8589934592, 8589934593, -8589934590, 8589934595, -8589934588,
8589934597, -8589934586, 8589934599, -8589934584, 8589934601}};
std::array<unsigned char, 10> m_DataU8 = {
{128, 129, 130, 131, 132, 133, 134, 135, 136, 137}};
std::array<uint16_t, 10> m_DataU16 = {
{32768, 32769, 32770, 32771, 32772, 32773, 32774, 32775, 32776, 32777}};
std::array<uint32_t, 10> m_DataU32 = {
{2147483648, 2147483649, 2147483650, 2147483651, 2147483652, 2147483653,
2147483654, 2147483655, 2147483656, 2147483657}};
std::array<uint64_t, 10> m_DataU64 = {
{9223372036854775808UL, 9223372036854775809UL, 9223372036854775810UL,
9223372036854775811UL, 9223372036854775812UL, 9223372036854775813UL,
9223372036854775814UL, 9223372036854775815UL, 9223372036854775816UL,
9223372036854775817UL}};
std::array<float, 10> m_DataR32 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
std::array<double, 10> m_DataR64 = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
};
class EngineWriteRead1DTest : public EngineWriteReadTestBase
{
public:
EngineWriteRead1DTest(std::string engineName, std::string fileName)
: EngineWriteReadTestBase(engineName, fileName)
{
}
protected:
virtual void Declare();
};
class EngineWriteRead2D2x4Test : public EngineWriteReadTestBase
{
public:
EngineWriteRead2D2x4Test(std::string engineName, std::string fileName)
: EngineWriteReadTestBase(engineName, fileName)
{
}
protected:
virtual void Declare();
};
class EngineWriteRead2D4x2Test : public EngineWriteReadTestBase
{
public:
EngineWriteRead2D4x2Test(std::string engineName, std::string fileName)
: EngineWriteReadTestBase(engineName, fileName)
{
}
protected:
virtual void Declare();
};
testing/adios2/engine/EngineWriteReadTestBase.cpp deleted 100644 → 0
+ 0
− 106
View file @ 5b8a8d56
#include "EngineWriteReadTestBase.h"
#include <cstdint>
#include <array>
#include <iostream>
#include <stdexcept>
#include <adios2.h>
#include <gtest/gtest.h>
EngineWriteReadTestBase::EngineWriteReadTestBase()
: m_adios(adios::Verbose::WARN, true)
{
}
void EngineWriteReadTestBase::Declare1D_8()
{
auto &var_i8 = m_adios.DefineVariable<char>("i8", adios::Dims{8});
auto &var_i16 = m_adios.DefineVariable<short>("i16", adios::Dims{8});
auto &var_i32 = m_adios.DefineVariable<int>("i32", adios::Dims{8});
auto &var_i64 = m_adios.DefineVariable<long>("i64", adios::Dims{8});
auto &var_u8 = m_adios.DefineVariable<unsigned char>("u8", adios::Dims{8});
auto &var_u16 =
m_adios.DefineVariable<unsigned short>("u16", adios::Dims{8});
auto &var_u32 = m_adios.DefineVariable<unsigned int>("u32", adios::Dims{8});
auto &var_u64 =
m_adios.DefineVariable<unsigned long>("u64", adios::Dims{8});
auto &var_r32 = m_adios.DefineVariable<float>("r32", adios::Dims{8});
auto &var_r64 = m_adios.DefineVariable<double>("r64", adios::Dims{8});
}
void EngineWriteReadTestBase::Declare2D_2x4()
{
auto &var_i8 = m_adios.DefineVariable<char>("i8", adios::Dims{2, 4});
auto &var_i16 = m_adios.DefineVariable<short>("i16", adios::Dims{2, 4});
auto &var_i32 = m_adios.DefineVariable<int>("i32", adios::Dims{2, 4});
auto &var_i64 = m_adios.DefineVariable<long>("i64", adios::Dims{2, 4});
auto &var_u8 =
m_adios.DefineVariable<unsigned char>("u8", adios::Dims{2, 4});
auto &var_u16 =
m_adios.DefineVariable<unsigned short>("u16", adios::Dims{2, 4});
auto &var_u32 =
m_adios.DefineVariable<unsigned int>("u32", adios::Dims{2, 4});
auto &var_u64 =
m_adios.DefineVariable<unsigned long>("u64", adios::Dims{2, 4});
auto &var_r32 = m_adios.DefineVariable<float>("r32", adios::Dims{2, 4});
auto &var_r64 = m_adios.DefineVariable<double>("r64", adios::Dims{2, 4});
}
void EngineWriteReadTestBase::Declare2D_4x2()
{
auto &var_i8 = m_adios.DefineVariable<char>("i8", adios::Dims{4, 2});
auto &var_i16 = m_adios.DefineVariable<short>("i16", adios::Dims{4, 2});
auto &var_i32 = m_adios.DefineVariable<int>("i32", adios::Dims{4, 2});
auto &var_i64 = m_adios.DefineVariable<long>("i64", adios::Dims{4, 2});
auto &var_u8 =
m_adios.DefineVariable<unsigned char>("u8", adios::Dims{4, 2});
auto &var_u16 =
m_adios.DefineVariable<unsigned short>("u16", adios::Dims{4, 2});
auto &var_u32 =
m_adios.DefineVariable<unsigned int>("u32", adios::Dims{4, 2});
auto &var_u64 =
m_adios.DefineVariable<unsigned long>("u64", adios::Dims{4, 2});
auto &var_r32 = m_adios.DefineVariable<float>("r32", adios::Dims{4, 2});
auto &var_r64 = m_adios.DefineVariable<double>("r64", adios::Dims{4, 2});
}
void EngineWriteReadTestBase::WriteStep(size_t step)
{
auto &var_i8 = m_adios.GetVariable<char>("i8");
auto &var_i16 = m_adios.GetVariable<short>("i16");
auto &var_i32 = m_adios.GetVariable<int>("i32");
auto &var_i64 = m_adios.GetVariable<long>("i64");
auto &var_u8 = m_adios.GetVariable<unsigned char>("u8");
auto &var_u16 = m_adios.GetVariable<unsigned short>("u16");
auto &var_u32 = m_adios.GetVariable<unsigned int>("u32");
auto &var_u64 = m_adios.GetVariable<unsigned long>("u64");
auto &var_r32 = m_adios.GetVariable<float>("r32");
auto &var_r64 = m_adios.GetVariable<double>("r64");
m_Engine->Write(var_i8, m_DataI8.cbegin() + step);
m_Engine->Write(var_i16, m_DataI16.cbegin() + step);
m_Engine->Write(var_i32, m_DataI32.cbegin() + step);
m_Engine->Write(var_i64, m_DataI64.cbegin() + step);
m_Engine->Write(var_u8, m_DataU8.cbegin() + step);
m_Engine->Write(var_u16, m_DataU16.cbegin() + step);
m_Engine->Write(var_u32, m_DataU32.cbegin() + step);
m_Engine->Write(var_u64, m_DataU64.cbegin() + step);
m_Engine->Write(var_r32, m_DataR32.cbegin() + step);
m_Engine->Write(var_r64, m_DataR64.cbegin() + step);
}
void EngineWriteReadTestBase::OpenWriteClose(std::string fname)
{
OpenWrite(fname);
for (size_t t = 0; t < 3; ++t)
{
EngineWriteReadTestBase::WriteStep(t);
m_Engine->Advance();
}
m_Engine->Close();
}
testing/adios2/engine/EngineWriteReadTestBase.h deleted 100644 → 0
+ 0
− 62
View file @ 5b8a8d56
#include <cstdint>
#include <array>
#include <iostream>
#include <stdexcept>
#include <adios2.h>
#include <gtest/gtest.h>
class EngineWriteReadTestBase : public ::testing::Test
{
public:
EngineWriteReadTestBase();
protected:
adios::ADIOS m_adios;
// To be created by child class SetUp()
std::shared_ptr<adios::Engine> m_Engine;
// Shared test functions
void Declare1D_8();
void Declare2D_2x4();
void Declare2D_4x2();
virtual void OpenWrite(std::string fname) = 0;
void WriteStep(size_t step);
void OpenWriteClose(std::string fname);
//*************************************************************************
// Test Data
//*************************************************************************
// Test data for each type. Make sure our values exceed the range of the
// previous size to make sure we all bytes for each element
std::array<char, 10> m_DataI8 = {0, 1, -2, 3, -4, 5, -6, 7, -8, 9};
std::array<int16_t, 10> m_DataI16 = {512, 513, -510, 515, -508,
517, -506, 519, -504, 521};
std::array<int32_t, 10> m_DataI32 = {131072, 131073, -131070, 131075,
-131068, 131077, -131066, 131079,
-131064, 131081};
std::array<int64_t, 10> m_DataI64 = {
8589934592, 8589934593, -8589934590, 8589934595, -8589934588,
8589934597, -8589934586, 8589934599, -8589934584, 8589934601};
std::array<unsigned char, 10> m_DataU8 = {128, 129, 130, 131, 132,
133, 134, 135, 136, 137};
std::array<uint16_t, 10> m_DataU16 = {32768, 32769, 32770, 32771, 32772,
32773, 32774, 32775, 32776, 32777};
std::array<uint32_t, 10> m_DataU32 = {
2147483648, 2147483649, 2147483650, 2147483651, 2147483652,
2147483653, 2147483654, 2147483655, 2147483656, 2147483657};
std::array<uint64_t, 10> m_DataU64 = {
9223372036854775808UL, 9223372036854775809UL, 9223372036854775810UL,
9223372036854775811UL, 9223372036854775812UL, 9223372036854775813UL,
9223372036854775814UL, 9223372036854775815UL, 9223372036854775816UL,
9223372036854775817UL};
std::array<float, 10> m_DataR32 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::array<double, 10> m_DataR64 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
};
testing/adios2/engine/adios1/CMakeLists.txt
+ 1
− 1
View file @ 4de0fc8a
......@@ -5,7 +5,7 @@
add_executable(TestADIOS1WriteRead
TestADIOS1WriteRead.cpp
../EngineWriteReadTestBase.cpp
../EngineWriteReadTest.cpp
)
target_link_libraries(TestADIOS1WriteRead adios2 gtest gtest_main)
add_test(NAME adios2::engine::adios1::write_read COMMAND TestADIOS1WriteRead)
testing/adios2/engine/adios1/TestADIOS1WriteRead.cpp
+ 31
− 27
View file @ 4de0fc8a
......@@ -7,41 +7,45 @@
#include <gtest/gtest.h>
#include "../EngineWriteReadTestBase.h"
#include "../EngineWriteReadTest.h"
class ADIOS1WriteReadTest : public EngineWriteReadTestBase
class ADIOS1WriteRead1DTest : public EngineWriteRead1DTest
{
public:
ADIOS1WriteReadTest() : EngineWriteReadTestBase() {}
protected:
void OpenWrite(std::string fname)
ADIOS1WriteRead1DTest()
: EngineWriteRead1DTest("ADIOS1Writer", "ADIOS1WriteRead1DTest.bp")
{
auto &m_EngineSettings = m_adios.DeclareMethod("TestMethod");
m_EngineSettings.SetEngine("ADIOS1Writer");
m_EngineSettings.SetParameters("profile_units=mus");
m_EngineSettings.AddTransport("File", "profile_units=mus",
"have_metadata_file=no");
m_Engine = m_adios.Open(fname, "w", m_EngineSettings);
ASSERT_NE(m_Engine, nullptr);
}
};
TEST_F(ADIOS1WriteReadTest, WriteRead_1D_8)
{
EngineWriteReadTestBase::Declare1D_8();
EngineWriteReadTestBase::OpenWriteClose("ADIOS1WriteReadTest_1D_8.bp");
}
TEST_F(ADIOS1WriteRead1DTest, WriteReadTest) { WriteRead(); }
TEST_F(ADIOS1WriteReadTest, WriteRead_2D_2x4)
//******************************************************************************
// 2D 2x4 test data
//******************************************************************************
class ADIOS1WriteRead2D2x4Test : public EngineWriteRead2D2x4Test
{
EngineWriteReadTestBase::Declare2D_2x4();
EngineWriteReadTestBase::OpenWriteClose("ADIOS1WriteReadTest_2D_2x4.bp");
}
public:
ADIOS1WriteRead2D2x4Test()
: EngineWriteRead2D2x4Test("ADIOS1Writer", "ADIOS1WriteRead2D2x4Test.bp")
{
}
};
TEST_F(ADIOS1WriteReadTest, WriteRead_2D_4x2)
TEST_F(ADIOS1WriteRead2D2x4Test, WriteReadTest) { WriteRead(); }
//******************************************************************************
// 2D 4x2 test data
//******************************************************************************
class ADIOS1WriteRead2D4x2Test : public EngineWriteRead2D4x2Test
{
EngineWriteReadTestBase::Declare2D_4x2();
EngineWriteReadTestBase::OpenWriteClose("ADIOS1WriteReadTest_2D_4x2.bp");
}
public:
ADIOS1WriteRead2D4x2Test()
: EngineWriteRead2D4x2Test("ADIOS1Writer", "ADIOS1WriteRead2D4x2Test.bp")
{
}
};
TEST_F(ADIOS1WriteRead2D4x2Test, WriteReadTest) { WriteRead(); }
testing/adios2/engine/bp/CMakeLists.txt
+ 1
− 1
View file @ 4de0fc8a
......@@ -5,7 +5,7 @@
add_executable(TestBPWriteRead
TestBPWriteRead.cpp
../EngineWriteReadTestBase.cpp
../EngineWriteReadTest.cpp
)
target_link_libraries(TestBPWriteRead adios2 gtest gtest_main)
add_test(NAME adios2::engine::bp::write_read COMMAND TestBPWriteRead)
testing/adios2/engine/bp/TestBPWriteRead.cpp
+ 31
− 27
View file @ 4de0fc8a
......@@ -7,41 +7,45 @@
#include <gtest/gtest.h>
#include "../EngineWriteReadTestBase.h"
#include "../EngineWriteReadTest.h"
class BPWriteReadTest : public EngineWriteReadTestBase
class BPWriteRead1DTest : public EngineWriteRead1DTest
{
public:
BPWriteReadTest() : EngineWriteReadTestBase() {}
protected:
virtual void OpenWrite(std::string fname)
BPWriteRead1DTest()
: EngineWriteRead1DTest("BPFileWriter", "BPWriteRead1DTest.bp")
{
auto &m_EngineSettings = m_adios.DeclareMethod("TestMethod");
m_EngineSettings.SetEngine("BPFileWriter");
m_EngineSettings.SetParameters("profile_units=mus");
m_EngineSettings.AddTransport("File", "profile_units=mus",
"have_metadata_file=no");
m_Engine = m_adios.Open(fname, "w", m_EngineSettings);
ASSERT_NE(m_Engine, nullptr);
}
};
TEST_F(BPWriteReadTest, WriteRead_1D_8)
{
EngineWriteReadTestBase::Declare1D_8();
EngineWriteReadTestBase::OpenWriteClose("BPWriteReadTest_1D_8.bp");
}
TEST_F(BPWriteRead1DTest, WriteReadTest) { WriteRead(); }
TEST_F(BPWriteReadTest, WriteRead_2D_2x4)
//******************************************************************************
// 2D 2x4 test data
//******************************************************************************
class BPWriteRead2D2x4Test : public EngineWriteRead2D2x4Test
{
EngineWriteReadTestBase::Declare2D_2x4();
EngineWriteReadTestBase::OpenWriteClose("BPWriteReadTest_2D_2x4.bp");
}
public:
BPWriteRead2D2x4Test()
: EngineWriteRead2D2x4Test("BPFileWriter", "BPWriteRead2D2x4Test.bp")
{
}
};
TEST_F(BPWriteReadTest, WriteRead_2D_4x2)
TEST_F(BPWriteRead2D2x4Test, WriteReadTest) { WriteRead(); }
//******************************************************************************
// 2D 4x2 test data
//******************************************************************************
class BPWriteRead2D4x2Test : public EngineWriteRead2D4x2Test
{
EngineWriteReadTestBase::Declare2D_4x2();
EngineWriteReadTestBase::OpenWriteClose("BPWriteReadTest_2D_4x2.bp");
}
public:
BPWriteRead2D4x2Test()
: EngineWriteRead2D4x2Test("BPFileWriter", "BPWriteRead2D4x2Test.bp")
{
}
};
TEST_F(BPWriteRead2D4x2Test, WriteReadTest) { WriteRead(); }
testing/adios2/engine/hdf5/CMakeLists.txt
+ 1
− 1
View file @ 4de0fc8a
......@@ -5,7 +5,7 @@
add_executable(TestHDF5WriteRead
TestHDF5WriteRead.cpp
../EngineWriteReadTestBase.cpp
../EngineWriteReadTest.cpp
)
target_link_libraries(TestHDF5WriteRead adios2 gtest gtest_main)
add_test(NAME adios2::engine::hdf5::write_read COMMAND TestHDF5WriteRead)
testing/adios2/engine/hdf5/TestHDF5WriteRead.cpp
+ 31
− 27
View file @ 4de0fc8a
......@@ -7,41 +7,45 @@
#include <gtest/gtest.h>
#include "../EngineWriteReadTestBase.h"
#include "../EngineWriteReadTest.h"
class HDF5WriteReadTest : public EngineWriteReadTestBase
class HDF5WriteRead1DTest : public EngineWriteRead1DTest
{
public:
HDF5WriteReadTest() : EngineWriteReadTestBase() {}
protected:
void OpenWrite(std::string fname)
HDF5WriteRead1DTest()
: EngineWriteRead1DTest("HDF5Writer", "HDF5WriteRead1DTest.h5")
{
auto &m_EngineSettings = m_adios.DeclareMethod("TestMethod");
m_EngineSettings.SetEngine("HDF5Writer");
m_EngineSettings.SetParameters("profile_units=mus");
m_EngineSettings.AddTransport("File", "profile_units=mus",
"have_metadata_file=no");
m_Engine = m_adios.Open(fname, "w", m_EngineSettings);
ASSERT_NE(m_Engine, nullptr);
}
};
TEST_F(HDF5WriteReadTest, WriteRead_1D_8)
{
EngineWriteReadTestBase::Declare1D_8();
EngineWriteReadTestBase::OpenWriteClose("HDF5WriteReadTest_1D_8.h5");
}
TEST_F(HDF5WriteRead1DTest, WriteReadTest) { WriteRead(); }
TEST_F(HDF5WriteReadTest, WriteRead_2D_2x4)
//******************************************************************************
// 2D 2x4 test data
//******************************************************************************
class HDF5WriteRead2D2x4Test : public EngineWriteRead2D2x4Test
{
EngineWriteReadTestBase::Declare2D_2x4();
EngineWriteReadTestBase::OpenWriteClose("HDF5WriteReadTest_2D_2x4.h5");
}
public:
HDF5WriteRead2D2x4Test()
: EngineWriteRead2D2x4Test("HDF5Writer", "HDF5WriteRead2D2x4Test.h5")
{
}
};
TEST_F(HDF5WriteReadTest, WriteRead_2D_4x2)
TEST_F(HDF5WriteRead2D2x4Test, WriteReadTest) { WriteRead(); }
//******************************************************************************
// 2D 4x2 test data
//******************************************************************************
class HDF5WriteRead2D4x2Test : public EngineWriteRead2D4x2Test
{
EngineWriteReadTestBase::Declare2D_4x2();
EngineWriteReadTestBase::OpenWriteClose("HDF5WriteReadTest_2D_4x2.h5");
}
public:
HDF5WriteRead2D4x2Test()
: EngineWriteRead2D4x2Test("HDF5Writer", "HDF5WriteRead2D4x2Test.h5")
{
}
};
TEST_F(HDF5WriteRead2D4x2Test, WriteReadTest) { WriteRead(); }
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment