diff --git a/testing/adios2/CMakeLists.txt b/testing/adios2/CMakeLists.txt
index 3f65197ad11b7d77174058eaff58cbd760a084cf..ef043c0c9c5223cb95f2dca238b0cf0687c6594e 100644
--- a/testing/adios2/CMakeLists.txt
+++ b/testing/adios2/CMakeLists.txt
@@ -3,4 +3,5 @@
# accompanying file Copyright.txt for details.
#------------------------------------------------------------------------------#
+add_subdirectory(interface)
add_subdirectory(engine)
diff --git a/testing/adios2/engine/bp/TestBPWrite.cpp b/testing/adios2/engine/bp/TestBPWriteRead.cpp
similarity index 100%
rename from testing/adios2/engine/bp/TestBPWrite.cpp
rename to testing/adios2/engine/bp/TestBPWriteRead.cpp
diff --git a/testing/adios2/interface/CMakeLists.txt b/testing/adios2/interface/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7924344f3098f0dd61e0a4d3b91b76143c70b314
--- /dev/null
+++ b/testing/adios2/interface/CMakeLists.txt
@@ -0,0 +1,8 @@
+#------------------------------------------------------------------------------#
+# Distributed under the OSI-approved Apache License, Version 2.0. See
+# accompanying file Copyright.txt for details.
+#------------------------------------------------------------------------------#
+
+add_executable(TestADIOSInterfaceWrite TestADIOSInterfaceWrite.cpp)
+target_link_libraries(TestADIOSInterfaceWrite adios2 gtest gtest_main)
+add_test(NAME adios2::interface::write COMMAND TestADIOSInterfaceWrite)
diff --git a/testing/adios2/interface/TestADIOSInterfaceWrite.cpp b/testing/adios2/interface/TestADIOSInterfaceWrite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3816e04be1ee3126afc69357f24fdcb5341cd7bc
--- /dev/null
+++ b/testing/adios2/interface/TestADIOSInterfaceWrite.cpp
@@ -0,0 +1,354 @@
+#include <cstdint>
+
+#include <iostream>
+#include <stdexcept>
+
+#include <adios2.h>
+
+#include <gtest/gtest.h>
+
+class ADIOSInterfaceWriteTest : public ::testing::Test
+{
+public:
+ ADIOSInterfaceWriteTest() : adios(adios::Verbose::WARN, true) {}
+
+protected:
+ // virtual void SetUp() { }
+
+ // virtual void TearDown() { }
+
+ adios::ADIOS adios;
+};
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarChar1x10)
+{
+ // Define ADIOS variables for each type
+ auto &var_i8 = adios.DefineVariable<char>("i8", adios::Dims{10});
+
+ // Verify the return type is as expected
+ ::testing::StaticAssertTypeEq<decltype(var_i8), adios::Variable<char> &>();
+
+ // Verify exceptions are thrown upon duplicate variable names
+ EXPECT_THROW(auto &foo = adios.DefineVariable<char>("i8", adios::Dims{10}),
+ std::invalid_argument);
+
+ // Verify the dimensions, name, and type are correct
+ ASSERT_EQ(var_i8.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_i8.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_i8.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i8.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i8.m_Name, "i8");
+ EXPECT_EQ(var_i8.m_Type, "char");
+}
+
+// Rinse and repeat for remaining types
+TEST_F(ADIOSInterfaceWriteTest, DefineVarShort1x10)
+{
+ auto &var_i16 = adios.DefineVariable<short>("i16", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_i16),
+ adios::Variable<short> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<short>("i16", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_i16.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_i16.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_i16.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i16.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i16.m_Name, "i16");
+ EXPECT_EQ(var_i16.m_Type, "short");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarInt1x10)
+{
+ auto &var_i32 = adios.DefineVariable<int>("i32", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_i32), adios::Variable<int> &>();
+ EXPECT_THROW(auto &foo = adios.DefineVariable<int>("i32", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_i32.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_i32.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_i32.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i32.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i32.m_Name, "i32");
+ EXPECT_EQ(var_i32.m_Type, "int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarLong1x10)
+{
+ auto &var_i64 = adios.DefineVariable<long>("i64", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_i64), adios::Variable<long> &>();
+ EXPECT_THROW(auto &foo = adios.DefineVariable<long>("i64", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_i64.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_i64.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_i64.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i64.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i64.m_Name, "i64");
+ EXPECT_EQ(var_i64.m_Type, "long int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarUChar1x10)
+{
+ auto &var_u8 = adios.DefineVariable<unsigned char>("u8", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_u8),
+ adios::Variable<unsigned char> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<unsigned char>("u8", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u8.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_u8.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_u8.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u8.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u8.m_Name, "u8");
+ EXPECT_EQ(var_u8.m_Type, "unsigned char");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarUShort1x10)
+{
+ auto &var_u16 =
+ adios.DefineVariable<unsigned short>("u16", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_u16),
+ adios::Variable<unsigned short> &>();
+ EXPECT_THROW(auto &foo = adios.DefineVariable<unsigned short>(
+ "u16", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u16.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_u16.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_u16.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u16.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u16.m_Name, "u16");
+ EXPECT_EQ(var_u16.m_Type, "unsigned short");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarUInt1x10)
+{
+ auto &var_u32 = adios.DefineVariable<unsigned int>("u32", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_u32),
+ adios::Variable<unsigned int> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<unsigned int>("u32", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u32.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_u32.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_u32.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u32.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u32.m_Name, "u32");
+ EXPECT_EQ(var_u32.m_Type, "unsigned int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarULong1x10)
+{
+ auto &var_u64 = adios.DefineVariable<unsigned long>("u64", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_u64),
+ adios::Variable<unsigned long> &>();
+ EXPECT_THROW(
+ auto &foo = adios.DefineVariable<unsigned long>("u64", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u64.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_u64.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_u64.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u64.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u64.m_Name, "u64");
+ EXPECT_EQ(var_u64.m_Type, "unsigned long int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarFloat1x10)
+{
+ auto &var_r32 = adios.DefineVariable<float>("r32", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_r32),
+ adios::Variable<float> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<float>("r32", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_r32.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_r32.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_r32.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_r32.m_Offsets.size(), 0);
+ EXPECT_EQ(var_r32.m_Name, "r32");
+ EXPECT_EQ(var_r32.m_Type, "float");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarDouble1x10)
+{
+ auto &var_r64 = adios.DefineVariable<double>("r64", adios::Dims{10});
+ ::testing::StaticAssertTypeEq<decltype(var_r64),
+ adios::Variable<double> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<double>("r64", adios::Dims{10}),
+ std::invalid_argument);
+ ASSERT_EQ(var_r64.m_LocalDimensions.size(), 1);
+ EXPECT_EQ(var_r64.m_LocalDimensions[0], 10);
+ EXPECT_EQ(var_r64.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_r64.m_Offsets.size(), 0);
+ EXPECT_EQ(var_r64.m_Name, "r64");
+ EXPECT_EQ(var_r64.m_Type, "double");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarChar2x5)
+{
+ auto &var_i8 = adios.DefineVariable<char>("i8", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_i8), adios::Variable<char> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<char>("i8", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_i8.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_i8.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_i8.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_i8.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i8.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i8.m_Name, "i8");
+ EXPECT_EQ(var_i8.m_Type, "char");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarShort2x5)
+{
+ auto &var_i16 = adios.DefineVariable<short>("i16", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_i16),
+ adios::Variable<short> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<short>("i16", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_i16.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_i16.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_i16.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_i16.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i16.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i16.m_Name, "i16");
+ EXPECT_EQ(var_i16.m_Type, "short");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarInt2x5)
+{
+ auto &var_i32 = adios.DefineVariable<int>("i32", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_i32), adios::Variable<int> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<int>("i32", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_i32.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_i32.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_i32.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_i32.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i32.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i32.m_Name, "i32");
+ EXPECT_EQ(var_i32.m_Type, "int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarLong2x5)
+{
+ auto &var_i64 = adios.DefineVariable<long>("i64", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_i64), adios::Variable<long> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<long>("i64", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_i64.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_i64.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_i64.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_i64.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_i64.m_Offsets.size(), 0);
+ EXPECT_EQ(var_i64.m_Name, "i64");
+ EXPECT_EQ(var_i64.m_Type, "long int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarUChar2x5)
+{
+ auto &var_u8 = adios.DefineVariable<unsigned char>("u8", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_u8),
+ adios::Variable<unsigned char> &>();
+ EXPECT_THROW(auto &foo = adios.DefineVariable<unsigned char>(
+ "u8", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u8.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_u8.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_u8.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_u8.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u8.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u8.m_Name, "u8");
+ EXPECT_EQ(var_u8.m_Type, "unsigned char");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarUShort2x5)
+{
+ auto &var_u16 =
+ adios.DefineVariable<unsigned short>("u16", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_u16),
+ adios::Variable<unsigned short> &>();
+ EXPECT_THROW(auto &foo = adios.DefineVariable<unsigned short>(
+ "u16", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u16.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_u16.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_u16.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_u16.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u16.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u16.m_Name, "u16");
+ EXPECT_EQ(var_u16.m_Type, "unsigned short");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarUInt2x5)
+{
+ auto &var_u32 =
+ adios.DefineVariable<unsigned int>("u32", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_u32),
+ adios::Variable<unsigned int> &>();
+ EXPECT_THROW(auto &foo = adios.DefineVariable<unsigned int>(
+ "u32", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u32.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_u32.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_u32.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_u32.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u32.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u32.m_Name, "u32");
+ EXPECT_EQ(var_u32.m_Type, "unsigned int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarULong2x5)
+{
+ auto &var_u64 =
+ adios.DefineVariable<unsigned long>("u64", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_u64),
+ adios::Variable<unsigned long> &>();
+ EXPECT_THROW(auto &foo = adios.DefineVariable<unsigned long>(
+ "u64", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_u64.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_u64.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_u64.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_u64.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_u64.m_Offsets.size(), 0);
+ EXPECT_EQ(var_u64.m_Name, "u64");
+ EXPECT_EQ(var_u64.m_Type, "unsigned long int");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarFloat2x5)
+{
+ auto &var_r32 = adios.DefineVariable<float>("r32", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_r32),
+ adios::Variable<float> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<float>("r32", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_r32.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_r32.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_r32.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_r32.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_r32.m_Offsets.size(), 0);
+ EXPECT_EQ(var_r32.m_Name, "r32");
+ EXPECT_EQ(var_r32.m_Type, "float");
+}
+
+TEST_F(ADIOSInterfaceWriteTest, DefineVarDouble2x5)
+{
+ auto &var_r64 = adios.DefineVariable<double>("r64", adios::Dims{2, 5});
+ ::testing::StaticAssertTypeEq<decltype(var_r64),
+ adios::Variable<double> &>();
+ EXPECT_THROW(auto &foo =
+ adios.DefineVariable<double>("r64", adios::Dims{2, 5}),
+ std::invalid_argument);
+ ASSERT_EQ(var_r64.m_LocalDimensions.size(), 2);
+ EXPECT_EQ(var_r64.m_LocalDimensions[0], 2);
+ EXPECT_EQ(var_r64.m_LocalDimensions[1], 5);
+ EXPECT_EQ(var_r64.m_GlobalDimensions.size(), 0);
+ EXPECT_EQ(var_r64.m_Offsets.size(), 0);
+ EXPECT_EQ(var_r64.m_Name, "r64");
+ EXPECT_EQ(var_r64.m_Type, "double");
+}