diff --git a/examples/hello/datamanReader/helloDataManReader_nompi.cpp b/examples/hello/datamanReader/helloDataManReader_nompi.cpp
index 09940479f1558949f6a512441cfa4c5c61620306..965e47c364dd527ed287bf45f11d0e62a6cacfeb 100644
--- a/examples/hello/datamanReader/helloDataManReader_nompi.cpp
+++ b/examples/hello/datamanReader/helloDataManReader_nompi.cpp
@@ -37,7 +37,7 @@ int main(int argc, char *argv[])
         adios::ADIOS adios(adios::DebugON);
 
         adios::IO &dataManIO = adios.DeclareIO("WAN");
-        dataManIO.SetEngine("DataMan");
+        dataManIO.SetEngine("DataManReader");
         dataManIO.SetParameters("real_time=yes", "method_type=stream",
                                 "method=dump");
         auto dataManReader =
diff --git a/source/adios2/core/IO.tcc b/source/adios2/core/IO.tcc
index 52b9290b0348ded3813896183c34e60c25e9ddc0..335e257ae50ae73f6e1275412ae456cfb5b37081 100644
--- a/source/adios2/core/IO.tcc
+++ b/source/adios2/core/IO.tcc
@@ -33,9 +33,9 @@ Variable<T> &IO::DefineVariable(const std::string &name, const Dims shape,
     {
         if (VariableExists(name))
         {
-            std::invalid_argument("ERROR: variable " + name +
-                                  " exists in IO object " + m_Name +
-                                  ", in call to DefineVariable\n");
+            throw std::invalid_argument("ERROR: variable " + name +
+                                        " exists in IO object " + m_Name +
+                                        ", in call to DefineVariable\n");
         }
     }
 
diff --git a/source/adios2/toolkit/transportman/TransportMan.cpp b/source/adios2/toolkit/transportman/TransportMan.cpp
index 524e9e3bb2217645fd50824b6b18112a2758d2ce..49a45a71e37d8f5892152986289241eeccf1d8ca 100644
--- a/source/adios2/toolkit/transportman/TransportMan.cpp
+++ b/source/adios2/toolkit/transportman/TransportMan.cpp
@@ -42,22 +42,11 @@ void TransportMan::OpenFiles(const std::vector<std::string> &baseNames,
         const Params &parameters = parametersVector[i];
         const std::string type(parameters.at("transport"));
 
-        if (type == "File") // need to create directory
+        if (type == "File" || type == "file") // need to create directory
         {
             CreateDirectory(baseNames[i]);
+            OpenFileTransport(names[i], openMode, parameters, profile);
         }
-        OpenSingleFile(type, names[i], openMode, parameters, profile);
-    }
-}
-
-void TransportMan::OpenSingleFile(const std::string type,
-                                  const std::string &name,
-                                  const OpenMode openMode,
-                                  const Params &parameters, const bool profile)
-{
-    if (type == "File")
-    {
-        OpenFileTransport(name, openMode, parameters, profile);
     }
 }
 
diff --git a/source/adios2/toolkit/transportman/TransportMan.h b/source/adios2/toolkit/transportman/TransportMan.h
index 4e4913814184c5a922af779ca53d4a1ef48e47c1..23c728b14513420afb6dfbd4076871d3a34b5d23 100644
--- a/source/adios2/toolkit/transportman/TransportMan.h
+++ b/source/adios2/toolkit/transportman/TransportMan.h
@@ -61,16 +61,6 @@ public:
                    const std::vector<Params> &parametersVector,
                    const bool profile);
 
-    /**
-     * Adds a transport to m_Transports
-     * @param type
-     * @param name
-     * @param parameters
-     */
-    void OpenSingleFile(const std::string type, const std::string &name,
-                        const OpenMode openMode, const Params &parameters,
-                        const bool profile);
-
     /**
      * Gets each transport base name from either baseName at Open or name key in
      * parameters
diff --git a/testing/adios2/engine/adios1/TestADIOS1WriteRead.cpp b/testing/adios2/engine/adios1/TestADIOS1WriteRead.cpp
index 41b0e8ae73e67563c7883d97b167bcb55750018c..ae7e964f16636dc51ad6321d2d23e8fac8db30ae 100644
--- a/testing/adios2/engine/adios1/TestADIOS1WriteRead.cpp
+++ b/testing/adios2/engine/adios1/TestADIOS1WriteRead.cpp
@@ -42,25 +42,31 @@ TEST_F(ADIOS1WriteReadTest, ADIOS2ADIOS1WriteADIOS1Read1D8)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{8});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{8});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{8});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{8});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{8});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{8});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{8});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{8});
             auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{8});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{8});
+                io.DefineVariable<unsigned char>("u8", {}, {}, adios::Dims{8});
+            auto &var_u16 = io.DefineVariable<unsigned short>("u16", {}, {},
+                                                              adios::Dims{8});
             auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{8});
+                io.DefineVariable<unsigned int>("u32", {}, {}, adios::Dims{8});
             auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{8});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{8});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{8});
+                io.DefineVariable<unsigned long>("u64", {}, {}, adios::Dims{8});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{8});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{8});
         }
 
         // Create the ADIOS 1 Engine
         io.SetEngine("ADIOS1Writer");
-        io.AddTransport("file");
+        io.AddTransport("File");
 
         auto engine = io.Open(fname, adios::OpenMode::Write);
         ASSERT_NE(engine.get(), nullptr);
@@ -265,20 +271,26 @@ TEST_F(ADIOS1WriteReadTest, ADIOS2ADIOS1WriteADIOS1Read2D2x4)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{2, 4});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{2, 4});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{2, 4});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{2, 4});
-            auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{2, 4});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{2, 4});
-            auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{2, 4});
-            auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{2, 4});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{2, 4});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{2, 4});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{2, 4});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{2, 4});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{2, 4});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{2, 4});
+            auto &var_u8 = io.DefineVariable<unsigned char>("u8", {}, {},
+                                                            adios::Dims{2, 4});
+            auto &var_u16 = io.DefineVariable<unsigned short>(
+                "u16", {}, {}, adios::Dims{2, 4});
+            auto &var_u32 = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                            adios::Dims{2, 4});
+            auto &var_u64 = io.DefineVariable<unsigned long>("u64", {}, {},
+                                                             adios::Dims{2, 4});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{2, 4});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{2, 4});
         }
 
         // Create the ADIOS 1 Engine
@@ -498,20 +510,26 @@ TEST_F(ADIOS1WriteReadTest, ADIOS2ADIOS1WriteADIOS1Read2D4x2)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{4, 2});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{4, 2});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{4, 2});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{4, 2});
-            auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{4, 2});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{4, 2});
-            auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{4, 2});
-            auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{4, 2});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{4, 2});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{4, 2});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{4, 2});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{4, 2});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{4, 2});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{4, 2});
+            auto &var_u8 = io.DefineVariable<unsigned char>("u8", {}, {},
+                                                            adios::Dims{4, 2});
+            auto &var_u16 = io.DefineVariable<unsigned short>(
+                "u16", {}, {}, adios::Dims{4, 2});
+            auto &var_u32 = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                            adios::Dims{4, 2});
+            auto &var_u64 = io.DefineVariable<unsigned long>("u64", {}, {},
+                                                             adios::Dims{4, 2});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{4, 2});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{4, 2});
         }
 
         // Create the ADIOS 1 Engine
diff --git a/testing/adios2/engine/bp/TestBPWriteRead.cpp b/testing/adios2/engine/bp/TestBPWriteRead.cpp
index bee83a5c0cfb047d8eb9fbefdc732adc9c1528f7..ab6f328ced033d1c79a672356743de735cb704cf 100644
--- a/testing/adios2/engine/bp/TestBPWriteRead.cpp
+++ b/testing/adios2/engine/bp/TestBPWriteRead.cpp
@@ -39,25 +39,31 @@ TEST_F(BPWriteReadTest, ADIOS2BPWriteADIOS1Read1D8)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{8});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{8});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{8});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{8});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{8});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{8});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{8});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{8});
             auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{8});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{8});
+                io.DefineVariable<unsigned char>("u8", {}, {}, adios::Dims{8});
+            auto &var_u16 = io.DefineVariable<unsigned short>("u16", {}, {},
+                                                              adios::Dims{8});
             auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{8});
+                io.DefineVariable<unsigned int>("u32", {}, {}, adios::Dims{8});
             auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{8});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{8});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{8});
+                io.DefineVariable<unsigned long>("u64", {}, {}, adios::Dims{8});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{8});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{8});
         }
 
         // Create the BP Engine
         io.SetEngine("BPFileWriter");
-        io.AddTransport("file");
+        io.AddTransport("File");
 
         auto engine = io.Open(fname, adios::OpenMode::Write);
         ASSERT_NE(engine.get(), nullptr);
@@ -249,20 +255,26 @@ TEST_F(BPWriteReadTest, ADIOS2BPWriteADIOS1Read2D2x4)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{2, 4});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{2, 4});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{2, 4});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{2, 4});
-            auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{2, 4});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{2, 4});
-            auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{2, 4});
-            auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{2, 4});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{2, 4});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{2, 4});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{2, 4});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{2, 4});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{2, 4});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{2, 4});
+            auto &var_u8 = io.DefineVariable<unsigned char>("u8", {}, {},
+                                                            adios::Dims{2, 4});
+            auto &var_u16 = io.DefineVariable<unsigned short>(
+                "u16", {}, {}, adios::Dims{2, 4});
+            auto &var_u32 = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                            adios::Dims{2, 4});
+            auto &var_u64 = io.DefineVariable<unsigned long>("u64", {}, {},
+                                                             adios::Dims{2, 4});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{2, 4});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{2, 4});
         }
 
         // Create the BP Engine
@@ -469,20 +481,26 @@ TEST_F(BPWriteReadTest, ADIOS2BPWriteADIOS1Read2D4x2)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{4, 2});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{4, 2});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{4, 2});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{4, 2});
-            auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{4, 2});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{4, 2});
-            auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{4, 2});
-            auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{4, 2});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{4, 2});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{4, 2});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{4, 2});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{4, 2});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{4, 2});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{4, 2});
+            auto &var_u8 = io.DefineVariable<unsigned char>("u8", {}, {},
+                                                            adios::Dims{4, 2});
+            auto &var_u16 = io.DefineVariable<unsigned short>(
+                "u16", {}, {}, adios::Dims{4, 2});
+            auto &var_u32 = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                            adios::Dims{4, 2});
+            auto &var_u64 = io.DefineVariable<unsigned long>("u64", {}, {},
+                                                             adios::Dims{4, 2});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{4, 2});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{4, 2});
         }
 
         // Create the BP Engine
diff --git a/testing/adios2/engine/hdf5/TestHDF5WriteRead.cpp b/testing/adios2/engine/hdf5/TestHDF5WriteRead.cpp
index 0d447444bb586233e60c75c6823866ed22072ea8..8789a0829a109935b18da3cd8227d4034aa7afae 100644
--- a/testing/adios2/engine/hdf5/TestHDF5WriteRead.cpp
+++ b/testing/adios2/engine/hdf5/TestHDF5WriteRead.cpp
@@ -195,20 +195,26 @@ TEST_F(HDF5WriteReadTest, ADIOS2HDF5WriteHDF5Read1D8)
         adios::IO &io = adios.DeclareIO("TestIO");
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{8});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{8});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{8});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{8});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{8});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{8});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{8});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{8});
             auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{8});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{8});
+                io.DefineVariable<unsigned char>("u8", {}, {}, adios::Dims{8});
+            auto &var_u16 = io.DefineVariable<unsigned short>("u16", {}, {},
+                                                              adios::Dims{8});
             auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{8});
+                io.DefineVariable<unsigned int>("u32", {}, {}, adios::Dims{8});
             auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{8});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{8});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{8});
+                io.DefineVariable<unsigned long>("u64", {}, {}, adios::Dims{8});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{8});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{8});
         }
 
         // Create the HDF5 Engine
@@ -395,20 +401,26 @@ TEST_F(HDF5WriteReadTest, ADIOS2HDF5WriteHDF5Read2D2x4)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{2, 4});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{2, 4});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{2, 4});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{2, 4});
-            auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{2, 4});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{2, 4});
-            auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{2, 4});
-            auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{2, 4});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{2, 4});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{2, 4});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{2, 4});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{2, 4});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{2, 4});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{2, 4});
+            auto &var_u8 = io.DefineVariable<unsigned char>("u8", {}, {},
+                                                            adios::Dims{2, 4});
+            auto &var_u16 = io.DefineVariable<unsigned short>(
+                "u16", {}, {}, adios::Dims{2, 4});
+            auto &var_u32 = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                            adios::Dims{2, 4});
+            auto &var_u64 = io.DefineVariable<unsigned long>("u64", {}, {},
+                                                             adios::Dims{2, 4});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{2, 4});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{2, 4});
         }
 
         io.SetEngine("HDF5Writer");
@@ -604,20 +616,26 @@ TEST_F(HDF5WriteReadTest, ADIOS2HDF5WriteHDF5Read2D4x2)
 
         // Declare 1D variables
         {
-            auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{4, 2});
-            auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{4, 2});
-            auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{4, 2});
-            auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{4, 2});
-            auto &var_u8 =
-                io.DefineVariable<unsigned char>("u8", adios::Dims{4, 2});
-            auto &var_u16 =
-                io.DefineVariable<unsigned short>("u16", adios::Dims{4, 2});
-            auto &var_u32 =
-                io.DefineVariable<unsigned int>("u32", adios::Dims{4, 2});
-            auto &var_u64 =
-                io.DefineVariable<unsigned long>("u64", adios::Dims{4, 2});
-            auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{4, 2});
-            auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{4, 2});
+            auto &var_i8 =
+                io.DefineVariable<char>("i8", {}, {}, adios::Dims{4, 2});
+            auto &var_i16 =
+                io.DefineVariable<short>("i16", {}, {}, adios::Dims{4, 2});
+            auto &var_i32 =
+                io.DefineVariable<int>("i32", {}, {}, adios::Dims{4, 2});
+            auto &var_i64 =
+                io.DefineVariable<long>("i64", {}, {}, adios::Dims{4, 2});
+            auto &var_u8 = io.DefineVariable<unsigned char>("u8", {}, {},
+                                                            adios::Dims{4, 2});
+            auto &var_u16 = io.DefineVariable<unsigned short>(
+                "u16", {}, {}, adios::Dims{4, 2});
+            auto &var_u32 = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                            adios::Dims{4, 2});
+            auto &var_u64 = io.DefineVariable<unsigned long>("u64", {}, {},
+                                                             adios::Dims{4, 2});
+            auto &var_r32 =
+                io.DefineVariable<float>("r32", {}, {}, adios::Dims{4, 2});
+            auto &var_r64 =
+                io.DefineVariable<double>("r64", {}, {}, adios::Dims{4, 2});
         }
 
         // Create the HDF5 Engine
diff --git a/testing/adios2/interface/TestADIOSInterfaceWrite.cpp b/testing/adios2/interface/TestADIOSInterfaceWrite.cpp
index 7b7420df9e0faca4e35781390b2dae940d0af2b4..c315a166db76cc0633b3d92003b60d700ac546d5 100644
--- a/testing/adios2/interface/TestADIOSInterfaceWrite.cpp
+++ b/testing/adios2/interface/TestADIOSInterfaceWrite.cpp
@@ -24,20 +24,21 @@ protected:
 TEST_F(ADIOSInterfaceWriteTest, DefineVarChar1x10)
 {
     // Define ADIOS variables for each type
-    auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{10});
+    auto &var_i8 = io.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 = io.DefineVariable<char>("i8", adios::Dims{10}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<char>("i8", {}, {}, adios::Dims{10}),
                  std::invalid_argument);
 
     // Verify the dimensions, name, and type are correct
-    ASSERT_EQ(var_i8.m_Shape.size(), 1);
-    EXPECT_EQ(var_i8.m_Shape[0], 10);
-    EXPECT_EQ(var_i8.m_Count.size(), 0);
+    ASSERT_EQ(var_i8.m_Shape.size(), 0);
     EXPECT_EQ(var_i8.m_Start.size(), 0);
+    EXPECT_EQ(var_i8.m_Count.size(), 1);
+    EXPECT_EQ(var_i8.m_Count[0], 10);
     EXPECT_EQ(var_i8.m_Name, "i8");
     EXPECT_EQ(var_i8.m_Type, "char");
 }
@@ -45,299 +46,317 @@ TEST_F(ADIOSInterfaceWriteTest, DefineVarChar1x10)
 // Rinse  and repeat for remaining types
 TEST_F(ADIOSInterfaceWriteTest, DefineVarShort1x10)
 {
-    auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{10});
+    auto &var_i16 = io.DefineVariable<short>("i16", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_i16),
                                   adios::Variable<short> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<short>("i16", adios::Dims{10}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<short>("i16", {}, {}, adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_i16.m_Shape.size(), 1);
-    EXPECT_EQ(var_i16.m_Shape[0], 10);
-    EXPECT_EQ(var_i16.m_Count.size(), 0);
+    ASSERT_EQ(var_i16.m_Shape.size(), 0);
     EXPECT_EQ(var_i16.m_Start.size(), 0);
+    EXPECT_EQ(var_i16.m_Count.size(), 1);
+    EXPECT_EQ(var_i16.m_Count[0], 10);
     EXPECT_EQ(var_i16.m_Name, "i16");
     EXPECT_EQ(var_i16.m_Type, "short");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarInt1x10)
 {
-    auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{10});
+    auto &var_i32 = io.DefineVariable<int>("i32", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_i32), adios::Variable<int> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<int>("i32", adios::Dims{10}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<int>("i32", {}, {}, adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_i32.m_Shape.size(), 1);
-    EXPECT_EQ(var_i32.m_Shape[0], 10);
-    EXPECT_EQ(var_i32.m_Count.size(), 0);
+    ASSERT_EQ(var_i32.m_Shape.size(), 0);
     EXPECT_EQ(var_i32.m_Start.size(), 0);
+    EXPECT_EQ(var_i32.m_Count.size(), 1);
+    EXPECT_EQ(var_i32.m_Count[0], 10);
     EXPECT_EQ(var_i32.m_Name, "i32");
     EXPECT_EQ(var_i32.m_Type, "int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarLong1x10)
 {
-    auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{10});
-    ::testing::StaticAssertTypeEq<decltype(var_i64), adios::Variable<long> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<long>("i64", adios::Dims{10}),
+    auto &var_u16 = io.DefineVariable<long>("u16", {}, {}, adios::Dims{10});
+    ::testing::StaticAssertTypeEq<decltype(var_u16), adios::Variable<long> &>();
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<long>("u16", {}, {}, adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_i64.m_Shape.size(), 1);
-    EXPECT_EQ(var_i64.m_Shape[0], 10);
-    EXPECT_EQ(var_i64.m_Count.size(), 0);
-    EXPECT_EQ(var_i64.m_Start.size(), 0);
-    EXPECT_EQ(var_i64.m_Name, "i64");
-    EXPECT_EQ(var_i64.m_Type, "long int");
+    ASSERT_EQ(var_u16.m_Shape.size(), 0);
+    EXPECT_EQ(var_u16.m_Start.size(), 0);
+    EXPECT_EQ(var_u16.m_Count.size(), 1);
+    EXPECT_EQ(var_u16.m_Count[0], 10);
+    EXPECT_EQ(var_u16.m_Name, "u16");
+    EXPECT_EQ(var_u16.m_Type, "long int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarUChar1x10)
 {
-    auto &var_u8 = io.DefineVariable<unsigned char>("u8", adios::Dims{10});
+    auto &var_u8 =
+        io.DefineVariable<unsigned char>("u8", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_u8),
                                   adios::Variable<unsigned char> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<unsigned char>("u8", adios::Dims{10}),
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned char>("u8", {}, {},
+                                                              adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_u8.m_Shape.size(), 1);
-    EXPECT_EQ(var_u8.m_Shape[0], 10);
-    EXPECT_EQ(var_u8.m_Count.size(), 0);
+    ASSERT_EQ(var_u8.m_Shape.size(), 0);
     EXPECT_EQ(var_u8.m_Start.size(), 0);
+    EXPECT_EQ(var_u8.m_Count.size(), 1);
+    EXPECT_EQ(var_u8.m_Count[0], 10);
     EXPECT_EQ(var_u8.m_Name, "u8");
     EXPECT_EQ(var_u8.m_Type, "unsigned char");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarUShort1x10)
 {
-    auto &var_u16 = io.DefineVariable<unsigned short>("u16", adios::Dims{10});
+    auto &var_u16 =
+        io.DefineVariable<unsigned short>("u16", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_u16),
                                   adios::Variable<unsigned short> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<unsigned short>("u16", adios::Dims{10}),
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned short>("u16", {}, {},
+                                                               adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_u16.m_Shape.size(), 1);
-    EXPECT_EQ(var_u16.m_Shape[0], 10);
-    EXPECT_EQ(var_u16.m_Count.size(), 0);
+    ASSERT_EQ(var_u16.m_Shape.size(), 0);
     EXPECT_EQ(var_u16.m_Start.size(), 0);
+    EXPECT_EQ(var_u16.m_Count.size(), 1);
+    EXPECT_EQ(var_u16.m_Count[0], 10);
     EXPECT_EQ(var_u16.m_Name, "u16");
     EXPECT_EQ(var_u16.m_Type, "unsigned short");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarUInt1x10)
 {
-    auto &var_u32 = io.DefineVariable<unsigned int>("u32", adios::Dims{10});
+    auto &var_u32 =
+        io.DefineVariable<unsigned int>("u32", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_u32),
                                   adios::Variable<unsigned int> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<unsigned int>("u32", adios::Dims{10}),
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                             adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_u32.m_Shape.size(), 1);
-    EXPECT_EQ(var_u32.m_Shape[0], 10);
-    EXPECT_EQ(var_u32.m_Count.size(), 0);
+    ASSERT_EQ(var_u32.m_Shape.size(), 0);
     EXPECT_EQ(var_u32.m_Start.size(), 0);
+    EXPECT_EQ(var_u32.m_Count.size(), 1);
+    EXPECT_EQ(var_u32.m_Count[0], 10);
     EXPECT_EQ(var_u32.m_Name, "u32");
     EXPECT_EQ(var_u32.m_Type, "unsigned int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarULong1x10)
 {
-    auto &var_u64 = io.DefineVariable<unsigned long>("u64", adios::Dims{10});
+    auto &var_u64 =
+        io.DefineVariable<unsigned long>("u64", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_u64),
                                   adios::Variable<unsigned long> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<unsigned long>("u64", adios::Dims{10}),
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned long>("u64", {}, {},
+                                                              adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_u64.m_Shape.size(), 1);
-    EXPECT_EQ(var_u64.m_Shape[0], 10);
-    EXPECT_EQ(var_u64.m_Count.size(), 0);
+    ASSERT_EQ(var_u64.m_Shape.size(), 0);
     EXPECT_EQ(var_u64.m_Start.size(), 0);
+    EXPECT_EQ(var_u64.m_Count.size(), 1);
+    EXPECT_EQ(var_u64.m_Count[0], 10);
     EXPECT_EQ(var_u64.m_Name, "u64");
     EXPECT_EQ(var_u64.m_Type, "unsigned long int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarFloat1x10)
 {
-    auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{10});
+    auto &var_r32 = io.DefineVariable<float>("r32", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_r32),
                                   adios::Variable<float> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<float>("r32", adios::Dims{10}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<float>("r32", {}, {}, adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_r32.m_Shape.size(), 1);
-    EXPECT_EQ(var_r32.m_Shape[0], 10);
-    EXPECT_EQ(var_r32.m_Count.size(), 0);
+    ASSERT_EQ(var_r32.m_Shape.size(), 0);
     EXPECT_EQ(var_r32.m_Start.size(), 0);
+    EXPECT_EQ(var_r32.m_Count.size(), 1);
+    EXPECT_EQ(var_r32.m_Count[0], 10);
     EXPECT_EQ(var_r32.m_Name, "r32");
     EXPECT_EQ(var_r32.m_Type, "float");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarDouble1x10)
 {
-    auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{10});
+    auto &var_r64 = io.DefineVariable<double>("r64", {}, {}, adios::Dims{10});
     ::testing::StaticAssertTypeEq<decltype(var_r64),
                                   adios::Variable<double> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<double>("r64", adios::Dims{10}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<double>("r64", {}, {}, adios::Dims{10}),
                  std::invalid_argument);
-    ASSERT_EQ(var_r64.m_Shape.size(), 1);
-    EXPECT_EQ(var_r64.m_Shape[0], 10);
-    EXPECT_EQ(var_r64.m_Count.size(), 0);
+    ASSERT_EQ(var_r64.m_Shape.size(), 0);
     EXPECT_EQ(var_r64.m_Start.size(), 0);
+    EXPECT_EQ(var_r64.m_Count.size(), 1);
+    EXPECT_EQ(var_r64.m_Count[0], 10);
     EXPECT_EQ(var_r64.m_Name, "r64");
     EXPECT_EQ(var_r64.m_Type, "double");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarChar2x5)
 {
-    auto &var_i8 = io.DefineVariable<char>("i8", adios::Dims{2, 5});
+    auto &var_i8 = io.DefineVariable<char>("i8", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_i8), adios::Variable<char> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<char>("i8", adios::Dims{2, 5}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<char>("i8", {}, {}, adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_i8.m_Shape.size(), 2);
-    EXPECT_EQ(var_i8.m_Shape[0], 2);
-    EXPECT_EQ(var_i8.m_Shape[1], 5);
-    EXPECT_EQ(var_i8.m_Count.size(), 0);
+    ASSERT_EQ(var_i8.m_Shape.size(), 0);
     EXPECT_EQ(var_i8.m_Start.size(), 0);
+    EXPECT_EQ(var_i8.m_Count.size(), 2);
+    EXPECT_EQ(var_i8.m_Count[0], 2);
+    EXPECT_EQ(var_i8.m_Count[1], 5);
     EXPECT_EQ(var_i8.m_Name, "i8");
     EXPECT_EQ(var_i8.m_Type, "char");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarShort2x5)
 {
-    auto &var_i16 = io.DefineVariable<short>("i16", adios::Dims{2, 5});
+    auto &var_i16 = io.DefineVariable<short>("i16", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_i16),
                                   adios::Variable<short> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<short>("i16", adios::Dims{2, 5}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<short>("i16", {}, {}, adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_i16.m_Shape.size(), 2);
-    EXPECT_EQ(var_i16.m_Shape[0], 2);
-    EXPECT_EQ(var_i16.m_Shape[1], 5);
-    EXPECT_EQ(var_i16.m_Count.size(), 0);
+    ASSERT_EQ(var_i16.m_Shape.size(), 0);
     EXPECT_EQ(var_i16.m_Start.size(), 0);
+    EXPECT_EQ(var_i16.m_Count.size(), 2);
+    EXPECT_EQ(var_i16.m_Count[0], 2);
+    EXPECT_EQ(var_i16.m_Count[1], 5);
     EXPECT_EQ(var_i16.m_Name, "i16");
     EXPECT_EQ(var_i16.m_Type, "short");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarInt2x5)
 {
-    auto &var_i32 = io.DefineVariable<int>("i32", adios::Dims{2, 5});
+    auto &var_i32 = io.DefineVariable<int>("i32", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_i32), adios::Variable<int> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<int>("i32", adios::Dims{2, 5}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<int>("i32", {}, {}, adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_i32.m_Shape.size(), 2);
-    EXPECT_EQ(var_i32.m_Shape[0], 2);
-    EXPECT_EQ(var_i32.m_Shape[1], 5);
-    EXPECT_EQ(var_i32.m_Count.size(), 0);
+    ASSERT_EQ(var_i32.m_Shape.size(), 0);
     EXPECT_EQ(var_i32.m_Start.size(), 0);
+    EXPECT_EQ(var_i32.m_Count.size(), 2);
+    EXPECT_EQ(var_i32.m_Count[0], 2);
+    EXPECT_EQ(var_i32.m_Count[1], 5);
     EXPECT_EQ(var_i32.m_Name, "i32");
     EXPECT_EQ(var_i32.m_Type, "int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarLong2x5)
 {
-    auto &var_i64 = io.DefineVariable<long>("i64", adios::Dims{2, 5});
-    ::testing::StaticAssertTypeEq<decltype(var_i64), adios::Variable<long> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<long>("i64", adios::Dims{2, 5}),
+    auto &var_u16 = io.DefineVariable<long>("u16", {}, {}, adios::Dims{2, 5});
+    ::testing::StaticAssertTypeEq<decltype(var_u16), adios::Variable<long> &>();
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<long>("u16", {}, {}, adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_i64.m_Shape.size(), 2);
-    EXPECT_EQ(var_i64.m_Shape[0], 2);
-    EXPECT_EQ(var_i64.m_Shape[1], 5);
-    EXPECT_EQ(var_i64.m_Count.size(), 0);
-    EXPECT_EQ(var_i64.m_Start.size(), 0);
-    EXPECT_EQ(var_i64.m_Name, "i64");
-    EXPECT_EQ(var_i64.m_Type, "long int");
+    ASSERT_EQ(var_u16.m_Shape.size(), 0);
+    EXPECT_EQ(var_u16.m_Start.size(), 0);
+    EXPECT_EQ(var_u16.m_Count.size(), 2);
+    EXPECT_EQ(var_u16.m_Count[0], 2);
+    EXPECT_EQ(var_u16.m_Count[1], 5);
+    EXPECT_EQ(var_u16.m_Name, "u16");
+    EXPECT_EQ(var_u16.m_Type, "long int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarUChar2x5)
 {
-    auto &var_u8 = io.DefineVariable<unsigned char>("u8", adios::Dims{2, 5});
+    auto &var_u8 =
+        io.DefineVariable<unsigned char>("u8", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_u8),
                                   adios::Variable<unsigned char> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<unsigned char>("u8", adios::Dims{2, 5}),
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned char>(
+                     "u8", {}, {}, adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_u8.m_Shape.size(), 2);
-    EXPECT_EQ(var_u8.m_Shape[0], 2);
-    EXPECT_EQ(var_u8.m_Shape[1], 5);
-    EXPECT_EQ(var_u8.m_Count.size(), 0);
+    ASSERT_EQ(var_u8.m_Shape.size(), 0);
     EXPECT_EQ(var_u8.m_Start.size(), 0);
+    EXPECT_EQ(var_u8.m_Count.size(), 2);
+    EXPECT_EQ(var_u8.m_Count[0], 2);
+    EXPECT_EQ(var_u8.m_Count[1], 5);
     EXPECT_EQ(var_u8.m_Name, "u8");
     EXPECT_EQ(var_u8.m_Type, "unsigned char");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarUShort2x5)
 {
-    auto &var_u16 = io.DefineVariable<unsigned short>("u16", adios::Dims{2, 5});
+    auto &var_u16 =
+        io.DefineVariable<unsigned short>("u16", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_u16),
                                   adios::Variable<unsigned short> &>();
-    EXPECT_THROW(
-        auto &foo = io.DefineVariable<unsigned short>("u16", adios::Dims{2, 5}),
-        std::invalid_argument);
-    ASSERT_EQ(var_u16.m_Shape.size(), 2);
-    EXPECT_EQ(var_u16.m_Shape[0], 2);
-    EXPECT_EQ(var_u16.m_Shape[1], 5);
-    EXPECT_EQ(var_u16.m_Count.size(), 0);
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned short>(
+                     "u16", {}, {}, adios::Dims{2, 5}),
+                 std::invalid_argument);
+    ASSERT_EQ(var_u16.m_Shape.size(), 0);
     EXPECT_EQ(var_u16.m_Start.size(), 0);
+    EXPECT_EQ(var_u16.m_Count.size(), 2);
+    EXPECT_EQ(var_u16.m_Count[0], 2);
+    EXPECT_EQ(var_u16.m_Count[1], 5);
     EXPECT_EQ(var_u16.m_Name, "u16");
     EXPECT_EQ(var_u16.m_Type, "unsigned short");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarUInt2x5)
 {
-    auto &var_u32 = io.DefineVariable<unsigned int>("u32", adios::Dims{2, 5});
+    auto &var_u32 =
+        io.DefineVariable<unsigned int>("u32", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_u32),
                                   adios::Variable<unsigned int> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<unsigned int>("u32", adios::Dims{2, 5}),
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned int>("u32", {}, {},
+                                                             adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_u32.m_Shape.size(), 2);
-    EXPECT_EQ(var_u32.m_Shape[0], 2);
-    EXPECT_EQ(var_u32.m_Shape[1], 5);
-    EXPECT_EQ(var_u32.m_Count.size(), 0);
+    ASSERT_EQ(var_u32.m_Shape.size(), 0);
     EXPECT_EQ(var_u32.m_Start.size(), 0);
+    EXPECT_EQ(var_u32.m_Count.size(), 2);
+    EXPECT_EQ(var_u32.m_Count[0], 2);
+    EXPECT_EQ(var_u32.m_Count[1], 5);
     EXPECT_EQ(var_u32.m_Name, "u32");
     EXPECT_EQ(var_u32.m_Type, "unsigned int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarULong2x5)
 {
-    auto &var_u64 = io.DefineVariable<unsigned long>("u64", adios::Dims{2, 5});
+    auto &var_u64 =
+        io.DefineVariable<unsigned long>("u64", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_u64),
                                   adios::Variable<unsigned long> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<unsigned long>("u64", adios::Dims{2, 5}),
+    EXPECT_THROW(auto &foo = io.DefineVariable<unsigned long>(
+                     "u64", {}, {}, adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_u64.m_Shape.size(), 2);
-    EXPECT_EQ(var_u64.m_Shape[0], 2);
-    EXPECT_EQ(var_u64.m_Shape[1], 5);
-    EXPECT_EQ(var_u64.m_Count.size(), 0);
+    ASSERT_EQ(var_u64.m_Shape.size(), 0);
     EXPECT_EQ(var_u64.m_Start.size(), 0);
+    EXPECT_EQ(var_u64.m_Count.size(), 2);
+    EXPECT_EQ(var_u64.m_Count[0], 2);
+    EXPECT_EQ(var_u64.m_Count[1], 5);
     EXPECT_EQ(var_u64.m_Name, "u64");
     EXPECT_EQ(var_u64.m_Type, "unsigned long int");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarFloat2x5)
 {
-    auto &var_r32 = io.DefineVariable<float>("r32", adios::Dims{2, 5});
+    auto &var_r32 = io.DefineVariable<float>("r32", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_r32),
                                   adios::Variable<float> &>();
-    EXPECT_THROW(auto &foo = io.DefineVariable<float>("r32", adios::Dims{2, 5}),
+    EXPECT_THROW(auto &foo =
+                     io.DefineVariable<float>("r32", {}, {}, adios::Dims{2, 5}),
                  std::invalid_argument);
-    ASSERT_EQ(var_r32.m_Shape.size(), 2);
-    EXPECT_EQ(var_r32.m_Shape[0], 2);
-    EXPECT_EQ(var_r32.m_Shape[1], 5);
-    EXPECT_EQ(var_r32.m_Count.size(), 0);
+    ASSERT_EQ(var_r32.m_Shape.size(), 0);
     EXPECT_EQ(var_r32.m_Start.size(), 0);
+    EXPECT_EQ(var_r32.m_Count.size(), 2);
+    EXPECT_EQ(var_r32.m_Count[0], 2);
+    EXPECT_EQ(var_r32.m_Count[1], 5);
     EXPECT_EQ(var_r32.m_Name, "r32");
     EXPECT_EQ(var_r32.m_Type, "float");
 }
 
 TEST_F(ADIOSInterfaceWriteTest, DefineVarDouble2x5)
 {
-    auto &var_r64 = io.DefineVariable<double>("r64", adios::Dims{2, 5});
+    auto &var_r64 = io.DefineVariable<double>("r64", {}, {}, adios::Dims{2, 5});
     ::testing::StaticAssertTypeEq<decltype(var_r64),
                                   adios::Variable<double> &>();
-    EXPECT_THROW(auto &foo =
-                     io.DefineVariable<double>("r64", adios::Dims{2, 5}),
-                 std::invalid_argument);
-    ASSERT_EQ(var_r64.m_Shape.size(), 2);
-    EXPECT_EQ(var_r64.m_Shape[0], 2);
-    EXPECT_EQ(var_r64.m_Shape[1], 5);
-    EXPECT_EQ(var_r64.m_Count.size(), 0);
+    EXPECT_THROW(
+        auto &foo = io.DefineVariable<double>("r64", {}, {}, adios::Dims{2, 5}),
+        std::invalid_argument);
+    ASSERT_EQ(var_r64.m_Shape.size(), 0);
     EXPECT_EQ(var_r64.m_Start.size(), 0);
+    EXPECT_EQ(var_r64.m_Count.size(), 2);
+    EXPECT_EQ(var_r64.m_Count[0], 2);
+    EXPECT_EQ(var_r64.m_Count[1], 5);
     EXPECT_EQ(var_r64.m_Name, "r64");
     EXPECT_EQ(var_r64.m_Type, "double");
 }