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

Added more tests for engines

parent 2913f388
No related branches found
No related tags found
1 merge request!86Add initial tests
Hide whitespace changes
Inline Side-by-side
Showing
with 304 additions and 148 deletions
testing/adios2/engine/EngineWriteReadTestBase.cpp 0 → 100644
+ 106
− 0
View file @ 770faa9b
#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 0 → 100644
+ 62
− 0
View file @ 770faa9b
#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
+ 7
− 0
View file @ 770faa9b
...@@ -2,3 +2,10 @@ ...@@ -2,3 +2,10 @@
# Distributed under the OSI-approved Apache License, Version 2.0. See # Distributed under the OSI-approved Apache License, Version 2.0. See
# accompanying file Copyright.txt for details. # accompanying file Copyright.txt for details.
#------------------------------------------------------------------------------# #------------------------------------------------------------------------------#
add_executable(TestADIOS1WriteRead
TestADIOS1WriteRead.cpp
../EngineWriteReadTestBase.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 0 → 100644
+ 47
− 0
View file @ 770faa9b
#include <cstdint>
#include <iostream>
#include <stdexcept>
#include <adios2.h>
#include <gtest/gtest.h>
#include "../EngineWriteReadTestBase.h"
class ADIOS1WriteReadTest : public EngineWriteReadTestBase
{
public:
ADIOS1WriteReadTest() : EngineWriteReadTestBase() {}
protected:
void OpenWrite(std::string fname)
{
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(ADIOS1WriteReadTest, WriteRead_2D_2x4)
{
EngineWriteReadTestBase::Declare2D_2x4();
EngineWriteReadTestBase::OpenWriteClose("ADIOS1WriteReadTest_2D_2x4.bp");
}
TEST_F(ADIOS1WriteReadTest, WriteRead_2D_4x2)
{
EngineWriteReadTestBase::Declare2D_4x2();
EngineWriteReadTestBase::OpenWriteClose("ADIOS1WriteReadTest_2D_4x2.bp");
}
testing/adios2/engine/bp/CMakeLists.txt
+ 4
− 1
View file @ 770faa9b
...@@ -3,6 +3,9 @@ ...@@ -3,6 +3,9 @@
# accompanying file Copyright.txt for details. # accompanying file Copyright.txt for details.
#------------------------------------------------------------------------------# #------------------------------------------------------------------------------#
add_executable(TestBPWriteRead TestBPWriteRead.cpp) add_executable(TestBPWriteRead
TestBPWriteRead.cpp
../EngineWriteReadTestBase.cpp
)
target_link_libraries(TestBPWriteRead adios2 gtest gtest_main) target_link_libraries(TestBPWriteRead adios2 gtest gtest_main)
add_test(NAME adios2::engine::bp::write_read COMMAND TestBPWriteRead) add_test(NAME adios2::engine::bp::write_read COMMAND TestBPWriteRead)
testing/adios2/engine/bp/TestBPWriteRead.cpp
+ 24
− 147
View file @ 770faa9b
...@@ -7,164 +7,41 @@ ...@@ -7,164 +7,41 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
class BPWriteReadTest : public ::testing::Test #include "../EngineWriteReadTestBase.h"
class BPWriteReadTest : public EngineWriteReadTestBase
{ {
public: public:
BPWriteReadTest() : adios(adios::Verbose::WARN, true) {} BPWriteReadTest() : EngineWriteReadTestBase() {}
protected: protected:
virtual void SetUp() {} virtual void OpenWrite(std::string fname)
virtual void TearDown() {}
adios::ADIOS adios;
// 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::vector<char> m_DataI8 = {0, 1, -2, 3, -4, 5, -6, 7, -8, 9};
std::vector<int16_t> m_DataI16 = {512, 513, -510, 515, -508,
517, -506, 519, -504, 521};
std::vector<int32_t> m_DataI32 = {131072, 131073, -131070, 131075,
-131068, 131077, -131066, 131079,
-131064, 131081};
std::vector<int64_t> m_DataI64 = {
8589934592, 8589934593, -8589934590, 8589934595, -8589934588,
8589934597, -8589934586, 8589934599, -8589934584, 8589934601};
std::vector<unsigned char> m_DataU8 = {128, 129, 130, 131, 132,
133, 134, 135, 136, 137};
std::vector<uint16_t> m_DataU16 = {32768, 32769, 32770, 32771, 32772,
32773, 32774, 32775, 32776, 32777};
std::vector<uint32_t> m_DataU32 = {
2147483648, 2147483649, 2147483650, 2147483651, 2147483652,
2147483653, 2147483654, 2147483655, 2147483656, 2147483657};
std::vector<uint64_t> m_DataU64 = {
9223372036854775808UL, 9223372036854775809UL, 9223372036854775810UL,
9223372036854775811UL, 9223372036854775812UL, 9223372036854775813UL,
9223372036854775814UL, 9223372036854775815UL, 9223372036854775816UL,
9223372036854775817UL};
std::vector<float> m_DataR32 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<double> m_DataR64 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
};
TEST_F(BPWriteReadTest, Write1D)
{
auto &var_i8 = adios.DefineVariable<char>("i8", adios::Dims{8});
auto &var_i16 = adios.DefineVariable<short>("i16", adios::Dims{8});
auto &var_i32 = adios.DefineVariable<int>("i32", adios::Dims{8});
auto &var_i64 = adios.DefineVariable<long>("i64", adios::Dims{8});
auto &var_u8 = adios.DefineVariable<unsigned char>("u8", adios::Dims{8});
auto &var_u16 = adios.DefineVariable<unsigned short>("u16", adios::Dims{8});
auto &var_u32 = adios.DefineVariable<unsigned int>("u32", adios::Dims{8});
auto &var_u64 = adios.DefineVariable<unsigned long>("u64", adios::Dims{8});
auto &var_r32 = adios.DefineVariable<float>("r32", adios::Dims{8});
auto &var_r64 = adios.DefineVariable<double>("r64", adios::Dims{8});
auto &bpWriterSettings = adios.DeclareMethod("SingleFile");
bpWriterSettings.SetParameters("profile_units=mus");
bpWriterSettings.AddTransport("File", "profile_units=mus",
"have_metadata_file=no");
auto bpWriter = adios.Open("BPWriteReadTest1D.bp", "w", bpWriterSettings);
ASSERT_NE(bpWriter, nullptr);
for (size_t t = 0; t < 3; ++t)
{ {
bpWriter->Write(var_i8, m_DataI8.data() + t); auto &m_EngineSettings = m_adios.DeclareMethod("TestMethod");
bpWriter->Write(var_i16, m_DataI16.data() + t); m_EngineSettings.SetEngine("BPFileWriter");
bpWriter->Write(var_i32, m_DataI32.data() + t); m_EngineSettings.SetParameters("profile_units=mus");
bpWriter->Write(var_i64, m_DataI64.data() + t); m_EngineSettings.AddTransport("File", "profile_units=mus",
bpWriter->Write(var_u8, m_DataU8.data() + t); "have_metadata_file=no");
bpWriter->Write(var_u16, m_DataU16.data() + t);
bpWriter->Write(var_u32, m_DataU32.data() + t); m_Engine = m_adios.Open(fname, "w", m_EngineSettings);
bpWriter->Write(var_u64, m_DataU64.data() + t); ASSERT_NE(m_Engine, nullptr);
bpWriter->Write(var_r32, m_DataR32.data() + t);
bpWriter->Write(var_r64, m_DataR64.data() + t);
bpWriter->Advance();
} }
};
bpWriter->Close(); TEST_F(BPWriteReadTest, WriteRead_1D_8)
{
EngineWriteReadTestBase::Declare1D_8();
EngineWriteReadTestBase::OpenWriteClose("BPWriteReadTest_1D_8.bp");
} }
TEST_F(BPWriteReadTest, Write2D_2x4) TEST_F(BPWriteReadTest, WriteRead_2D_2x4)
{ {
auto &var_i8 = adios.DefineVariable<char>("i8", adios::Dims{2, 4}); EngineWriteReadTestBase::Declare2D_2x4();
auto &var_i16 = adios.DefineVariable<short>("i16", adios::Dims{2, 4}); EngineWriteReadTestBase::OpenWriteClose("BPWriteReadTest_2D_2x4.bp");
auto &var_i32 = adios.DefineVariable<int>("i32", adios::Dims{2, 4});
auto &var_i64 = adios.DefineVariable<long>("i64", adios::Dims{2, 4});
auto &var_u8 = adios.DefineVariable<unsigned char>("u8", adios::Dims{2, 4});
auto &var_u16 =
adios.DefineVariable<unsigned short>("u16", adios::Dims{2, 4});
auto &var_u32 =
adios.DefineVariable<unsigned int>("u32", adios::Dims{2, 4});
auto &var_u64 =
adios.DefineVariable<unsigned long>("u64", adios::Dims{2, 4});
auto &var_r32 = adios.DefineVariable<float>("r32", adios::Dims{2, 4});
auto &var_r64 = adios.DefineVariable<double>("r64", adios::Dims{2, 4});
auto &bpWriterSettings = adios.DeclareMethod("SingleFile");
bpWriterSettings.SetParameters("profile_units=mus");
bpWriterSettings.AddTransport("File", "profile_units=mus",
"have_metadata_file=no");
auto bpWriter = adios.Open("BPWriteReadTest1D.bp", "w", bpWriterSettings);
ASSERT_NE(bpWriter, nullptr);
for (size_t t = 0; t < 3; ++t)
{
bpWriter->Write(var_i8, m_DataI8.data() + t);
bpWriter->Write(var_i16, m_DataI16.data() + t);
bpWriter->Write(var_i32, m_DataI32.data() + t);
bpWriter->Write(var_i64, m_DataI64.data() + t);
bpWriter->Write(var_u8, m_DataU8.data() + t);
bpWriter->Write(var_u16, m_DataU16.data() + t);
bpWriter->Write(var_u32, m_DataU32.data() + t);
bpWriter->Write(var_u64, m_DataU64.data() + t);
bpWriter->Write(var_r32, m_DataR32.data() + t);
bpWriter->Write(var_r64, m_DataR64.data() + t);
bpWriter->Advance();
}
bpWriter->Close();
} }
TEST_F(BPWriteReadTest, Write2D_4x2) TEST_F(BPWriteReadTest, WriteRead_2D_4x2)
{ {
auto &var_i8 = adios.DefineVariable<char>("i8", adios::Dims{4, 2}); EngineWriteReadTestBase::Declare2D_4x2();
auto &var_i16 = adios.DefineVariable<short>("i16", adios::Dims{4, 2}); EngineWriteReadTestBase::OpenWriteClose("BPWriteReadTest_2D_4x2.bp");
auto &var_i32 = adios.DefineVariable<int>("i32", adios::Dims{4, 2});
auto &var_i64 = adios.DefineVariable<long>("i64", adios::Dims{4, 2});
auto &var_u8 = adios.DefineVariable<unsigned char>("u8", adios::Dims{4, 2});
auto &var_u16 =
adios.DefineVariable<unsigned short>("u16", adios::Dims{4, 2});
auto &var_u32 =
adios.DefineVariable<unsigned int>("u32", adios::Dims{4, 2});
auto &var_u64 =
adios.DefineVariable<unsigned long>("u64", adios::Dims{4, 2});
auto &var_r32 = adios.DefineVariable<float>("r32", adios::Dims{4, 2});
auto &var_r64 = adios.DefineVariable<double>("r64", adios::Dims{4, 2});
auto &bpWriterSettings = adios.DeclareMethod("SingleFile");
bpWriterSettings.SetParameters("profile_units=mus");
bpWriterSettings.AddTransport("File", "profile_units=mus",
"have_metadata_file=no");
auto bpWriter = adios.Open("BPWriteReadTest1D.bp", "w", bpWriterSettings);
ASSERT_NE(bpWriter, nullptr);
for (size_t t = 0; t < 3; ++t)
{
bpWriter->Write(var_i8, m_DataI8.data() + t);
bpWriter->Write(var_i16, m_DataI16.data() + t);
bpWriter->Write(var_i32, m_DataI32.data() + t);
bpWriter->Write(var_i64, m_DataI64.data() + t);
bpWriter->Write(var_u8, m_DataU8.data() + t);
bpWriter->Write(var_u16, m_DataU16.data() + t);
bpWriter->Write(var_u32, m_DataU32.data() + t);
bpWriter->Write(var_u64, m_DataU64.data() + t);
bpWriter->Write(var_r32, m_DataR32.data() + t);
bpWriter->Write(var_r64, m_DataR64.data() + t);
bpWriter->Advance();
}
bpWriter->Close();
} }
testing/adios2/engine/hdf5/CMakeLists.txt
+ 7
− 0
View file @ 770faa9b
...@@ -2,3 +2,10 @@ ...@@ -2,3 +2,10 @@
# Distributed under the OSI-approved Apache License, Version 2.0. See # Distributed under the OSI-approved Apache License, Version 2.0. See
# accompanying file Copyright.txt for details. # accompanying file Copyright.txt for details.
#------------------------------------------------------------------------------# #------------------------------------------------------------------------------#
add_executable(TestHDF5WriteRead
TestHDF5WriteRead.cpp
../EngineWriteReadTestBase.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 0 → 100644
+ 47
− 0
View file @ 770faa9b
#include <cstdint>
#include <iostream>
#include <stdexcept>
#include <adios2.h>
#include <gtest/gtest.h>
#include "../EngineWriteReadTestBase.h"
class HDF5WriteReadTest : public EngineWriteReadTestBase
{
public:
HDF5WriteReadTest() : EngineWriteReadTestBase() {}
protected:
void OpenWrite(std::string fname)
{
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(HDF5WriteReadTest, WriteRead_2D_2x4)
{
EngineWriteReadTestBase::Declare2D_2x4();
EngineWriteReadTestBase::OpenWriteClose("HDF5WriteReadTest_2D_2x4.h5");
}
TEST_F(HDF5WriteReadTest, WriteRead_2D_4x2)
{
EngineWriteReadTestBase::Declare2D_4x2();
EngineWriteReadTestBase::OpenWriteClose("HDF5WriteReadTest_2D_4x2.h5");
}
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