Commit b73d7a84 authored by Podhorszki, Norbert's avatar Podhorszki, Norbert
Browse files

fix hdf5 engine tests

parent 70e54994

testing/adios2/bindings/python/CMakeLists.txt

+5 −2
Original line number Diff line number Diff line
@@ -15,8 +15,11 @@ if(ADIOS2_HAVE_MPI) 
    				SCRIPT TestBPWriteReadTypes.py)

    python_add_test(NAME PythonBPWriteReadHighLevelAPI ${test_parameters} 

    				SCRIPT TestBPWriteTypesHighLevelAPI.py)

    python_add_test(NAME PythonBPWriteReadHighLevelAPI_HDF5 ${test_parameters} 

    				SCRIPT TestBPWriteTypesHighLevelAPI_HDF5.py)

    python_add_test(NAME PythonBPReadMultisteps ${test_parameters} 

    				SCRIPT TestBPReadMultisteps.py)

endif()



if (ADIOS2_HAVE_HDF5)

    python_add_test(NAME PythonBPWriteReadHighLevelAPI_HDF5 

    				SCRIPT TestBPWriteTypesHighLevelAPI_HDF5.py)

endif()

testing/adios2/engine/hdf5/TestHDF5WriteReadAsStream.cpp

+35 −39
Original line number Diff line number Diff line
@@ -215,21 +215,21 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8) 
                EXPECT_FALSE(var_u64);



                ASSERT_EQ(var_i8.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_i8.Steps(), NSteps / 2 + NSteps % 2);

                ASSERT_EQ(var_i8.Steps(), 1);

                ASSERT_EQ(var_i8.Shape()[0], static_cast<size_t>(mpiSize * Nx));



                ASSERT_EQ(var_i16.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_i16.Steps(), NSteps / 2 + NSteps % 2);

                ASSERT_EQ(var_i16.Steps(), 1);

                ASSERT_EQ(var_i16.Shape()[0],

                          static_cast<size_t>(mpiSize * Nx));



                ASSERT_EQ(var_i32.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_i32.Steps(), NSteps / 2 + NSteps % 2);

                ASSERT_EQ(var_i32.Steps(), 1);

                ASSERT_EQ(var_i32.Shape()[0],

                          static_cast<size_t>(mpiSize * Nx));



                ASSERT_EQ(var_i64.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_i64.Steps(), NSteps / 2 + NSteps % 2);

                ASSERT_EQ(var_i64.Steps(), 1);

                ASSERT_EQ(var_i64.Shape()[0],

                          static_cast<size_t>(mpiSize * Nx));
@@ -256,19 +256,19 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8) 
                EXPECT_TRUE(var_u64);



                ASSERT_EQ(var_u8.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_u8.Steps(), NSteps / 2);

                ASSERT_EQ(var_u8.Steps(), 1);

                ASSERT_EQ(var_u8.Shape()[0], mpiSize * Nx);



                ASSERT_EQ(var_u16.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_u16.Steps(), NSteps / 2);

                ASSERT_EQ(var_u16.Steps(), 1);

                ASSERT_EQ(var_u16.Shape()[0], mpiSize * Nx);



                ASSERT_EQ(var_u32.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_u32.Steps(), NSteps / 2);

                ASSERT_EQ(var_u32.Steps(), 1);

                ASSERT_EQ(var_u32.Shape()[0], mpiSize * Nx);



                ASSERT_EQ(var_u64.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_u64.Steps(), NSteps / 2);

                ASSERT_EQ(var_u64.Steps(), 1);

                ASSERT_EQ(var_u64.Shape()[0], mpiSize * Nx);



                var_u8.SetSelection(sel);
@@ -293,11 +293,11 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8) 
                EXPECT_TRUE(var_r64);



                ASSERT_EQ(var_r32.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_r32.Steps(), NSteps - 1);

                ASSERT_EQ(var_r32.Steps(), 1);

                ASSERT_EQ(var_r32.Shape()[0], mpiSize * Nx);



                ASSERT_EQ(var_r64.ShapeID(), adios2::ShapeID::GlobalArray);

                ASSERT_EQ(var_r64.Steps(), NSteps - 1);

                ASSERT_EQ(var_r64.Steps(), 1);

                ASSERT_EQ(var_r64.Shape()[0], mpiSize * Nx);



                var_r32.SetSelection(sel);
@@ -311,11 +311,11 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead1D8) 
            EXPECT_TRUE(var_cr64);



            ASSERT_EQ(var_cr32.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_cr32.Steps(), NSteps);

            ASSERT_EQ(var_cr32.Steps(), 1);

            ASSERT_EQ(var_cr32.Shape()[0], mpiSize * Nx);



            ASSERT_EQ(var_cr64.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_cr64.Steps(), NSteps);

            ASSERT_EQ(var_cr64.Steps(), 1);

            ASSERT_EQ(var_cr64.Shape()[0], mpiSize * Nx);



            var_cr32.SetSelection(sel);
@@ -474,70 +474,70 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead2D2x4) 
            auto var_i8 = io.InquireVariable<int8_t>("i8");

            EXPECT_TRUE(var_i8);

            ASSERT_EQ(var_i8.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i8.Steps(), NSteps);

            ASSERT_EQ(var_i8.Steps(), 1);

            ASSERT_EQ(var_i8.Shape()[0], Ny);

            ASSERT_EQ(var_i8.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_i16 = io.InquireVariable<int16_t>("i16");

            EXPECT_TRUE(var_i16);

            ASSERT_EQ(var_i16.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i16.Steps(), NSteps);

            ASSERT_EQ(var_i16.Steps(), 1);

            ASSERT_EQ(var_i16.Shape()[0], Ny);

            ASSERT_EQ(var_i16.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_i32 = io.InquireVariable<int32_t>("i32");

            EXPECT_TRUE(var_i32);

            ASSERT_EQ(var_i32.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i32.Steps(), NSteps);

            ASSERT_EQ(var_i32.Steps(), 1);

            ASSERT_EQ(var_i32.Shape()[0], Ny);

            ASSERT_EQ(var_i32.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_i64 = io.InquireVariable<int64_t>("i64");

            EXPECT_TRUE(var_i64);

            ASSERT_EQ(var_i64.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i64.Steps(), NSteps);

            ASSERT_EQ(var_i64.Steps(), 1);

            ASSERT_EQ(var_i64.Shape()[0], Ny);

            ASSERT_EQ(var_i64.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u8 = io.InquireVariable<uint8_t>("u8");

            EXPECT_TRUE(var_u8);

            ASSERT_EQ(var_u8.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u8.Steps(), NSteps);

            ASSERT_EQ(var_u8.Steps(), 1);

            ASSERT_EQ(var_u8.Shape()[0], Ny);

            ASSERT_EQ(var_u8.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u16 = io.InquireVariable<uint16_t>("u16");

            EXPECT_TRUE(var_u16);

            ASSERT_EQ(var_u16.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u16.Steps(), NSteps);

            ASSERT_EQ(var_u16.Steps(), 1);

            ASSERT_EQ(var_u16.Shape()[0], Ny);

            ASSERT_EQ(var_u16.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u32 = io.InquireVariable<uint32_t>("u32");

            EXPECT_TRUE(var_u32);

            ASSERT_EQ(var_u32.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u32.Steps(), NSteps);

            ASSERT_EQ(var_u32.Steps(), 1);

            ASSERT_EQ(var_u32.Shape()[0], Ny);

            ASSERT_EQ(var_u32.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u64 = io.InquireVariable<uint64_t>("u64");

            EXPECT_TRUE(var_u64);

            ASSERT_EQ(var_u64.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u64.Steps(), NSteps);

            ASSERT_EQ(var_u64.Steps(), 1);

            ASSERT_EQ(var_u64.Shape()[0], Ny);

            ASSERT_EQ(var_u64.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_r32 = io.InquireVariable<float>("r32");

            EXPECT_TRUE(var_r32);

            ASSERT_EQ(var_r32.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_r32.Steps(), NSteps);

            ASSERT_EQ(var_r32.Steps(), 1);

            ASSERT_EQ(var_r32.Shape()[0], Ny);

            ASSERT_EQ(var_r32.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_r64 = io.InquireVariable<double>("r64");

            EXPECT_TRUE(var_r64);

            ASSERT_EQ(var_r64.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_r64.Steps(), NSteps);

            ASSERT_EQ(var_r64.Steps(), 1);

            ASSERT_EQ(var_r64.Shape()[0], Ny);

            ASSERT_EQ(var_r64.Shape()[1], static_cast<size_t>(mpiSize * Nx));
@@ -724,70 +724,70 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ADIOS2HDF5WriteRead2D4x2) 
            auto var_i8 = io.InquireVariable<int8_t>("i8");

            EXPECT_TRUE(var_i8);

            ASSERT_EQ(var_i8.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i8.Steps(), NSteps);

            ASSERT_EQ(var_i8.Steps(), 1);

            ASSERT_EQ(var_i8.Shape()[0], Ny);

            ASSERT_EQ(var_i8.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_i16 = io.InquireVariable<int16_t>("i16");

            EXPECT_TRUE(var_i16);

            ASSERT_EQ(var_i16.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i16.Steps(), NSteps);

            ASSERT_EQ(var_i16.Steps(), 1);

            ASSERT_EQ(var_i16.Shape()[0], Ny);

            ASSERT_EQ(var_i16.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_i32 = io.InquireVariable<int32_t>("i32");

            EXPECT_TRUE(var_i32);

            ASSERT_EQ(var_i32.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i32.Steps(), NSteps);

            ASSERT_EQ(var_i32.Steps(), 1);

            ASSERT_EQ(var_i32.Shape()[0], Ny);

            ASSERT_EQ(var_i32.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_i64 = io.InquireVariable<int64_t>("i64");

            EXPECT_TRUE(var_i64);

            ASSERT_EQ(var_i64.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_i64.Steps(), NSteps);

            ASSERT_EQ(var_i64.Steps(), 1);

            ASSERT_EQ(var_i64.Shape()[0], Ny);

            ASSERT_EQ(var_i64.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u8 = io.InquireVariable<uint8_t>("u8");

            EXPECT_TRUE(var_u8);

            ASSERT_EQ(var_u8.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u8.Steps(), NSteps);

            ASSERT_EQ(var_u8.Steps(), 1);

            ASSERT_EQ(var_u8.Shape()[0], Ny);

            ASSERT_EQ(var_u8.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u16 = io.InquireVariable<uint16_t>("u16");

            EXPECT_TRUE(var_u16);

            ASSERT_EQ(var_u16.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u16.Steps(), NSteps);

            ASSERT_EQ(var_u16.Steps(), 1);

            ASSERT_EQ(var_u16.Shape()[0], Ny);

            ASSERT_EQ(var_u16.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u32 = io.InquireVariable<uint32_t>("u32");

            EXPECT_TRUE(var_u32);

            ASSERT_EQ(var_u32.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u32.Steps(), NSteps);

            ASSERT_EQ(var_u32.Steps(), 1);

            ASSERT_EQ(var_u32.Shape()[0], Ny);

            ASSERT_EQ(var_u32.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_u64 = io.InquireVariable<uint64_t>("u64");

            EXPECT_TRUE(var_u64);

            ASSERT_EQ(var_u64.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_u64.Steps(), NSteps);

            ASSERT_EQ(var_u64.Steps(), 1);

            ASSERT_EQ(var_u64.Shape()[0], Ny);

            ASSERT_EQ(var_u64.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_r32 = io.InquireVariable<float>("r32");

            EXPECT_TRUE(var_r32);

            ASSERT_EQ(var_r32.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_r32.Steps(), NSteps);

            ASSERT_EQ(var_r32.Steps(), 1);

            ASSERT_EQ(var_r32.Shape()[0], Ny);

            ASSERT_EQ(var_r32.Shape()[1], static_cast<size_t>(mpiSize * Nx));



            auto var_r64 = io.InquireVariable<double>("r64");

            EXPECT_TRUE(var_r64);

            ASSERT_EQ(var_r64.ShapeID(), adios2::ShapeID::GlobalArray);

            ASSERT_EQ(var_r64.Steps(), NSteps);

            ASSERT_EQ(var_r64.Steps(), 1);

            ASSERT_EQ(var_r64.Shape()[0], Ny);

            ASSERT_EQ(var_r64.Shape()[1], static_cast<size_t>(mpiSize * Nx));
@@ -937,13 +937,9 @@ TEST_F(HDF5WriteReadAsStreamTestADIOS2, ReaderWriterDefineVariable) 
            EXPECT_TRUE(varR32);

            reader.EndStep();



            if (step == 0)

            {

            adios2::Variable<double> varR64 = io.DefineVariable<double>(

                "r64", shape, start, count, adios2::ConstantDims);

            EXPECT_TRUE(varR64);

            }



            SmallTestData currentTestData = generateNewSmallTestData(

                m_TestData, static_cast<int>(step), mpiRank, mpiSize);

            writer.BeginStep();

testing/adios2/engine/hdf5/TestNativeHDF5WriteRead.cpp

+4 −10
Original line number Diff line number Diff line
@@ -964,7 +964,6 @@ TEST_F(HDF5WriteReadTest, ADIOS2HDF5WriteADIOS2HDF5Read1D8) 
            SmallTestData currentTestData = generateNewSmallTestData(

                m_TestData, static_cast<int>(t), mpiRank, mpiSize);



            hdf5Reader.BeginStep();

            hdf5Reader.Get(var_iString, IString);



            hdf5Reader.Get(var_i8, I8.data());
@@ -979,8 +978,7 @@ TEST_F(HDF5WriteReadTest, ADIOS2HDF5WriteADIOS2HDF5Read1D8) 


            hdf5Reader.Get(var_r32, R32.data());

            hdf5Reader.Get(var_r64, R64.data());



            hdf5Reader.EndStep();

            hdf5Reader.PerformGets();



            EXPECT_EQ(IString, currentTestData.S1);
@@ -1207,7 +1205,6 @@ TEST_F(HDF5WriteReadTest, HDF5WriteADIOS2HDF5Read1D8) 
            SmallTestData currentTestData = generateNewSmallTestData(

                m_TestData, static_cast<int>(t), mpiRank, mpiSize);



            hdf5Reader.BeginStep();

            hdf5Reader.Get(var_iString, IString);



            hdf5Reader.Get(var_i8, I8.data());
@@ -1223,7 +1220,7 @@ TEST_F(HDF5WriteReadTest, HDF5WriteADIOS2HDF5Read1D8) 
            hdf5Reader.Get(var_r32, R32.data());

            hdf5Reader.Get(var_r64, R64.data());



            hdf5Reader.EndStep();

            hdf5Reader.PerformGets();



            EXPECT_EQ(IString, currentTestData.S1);
@@ -2588,7 +2585,6 @@ TEST_F(HDF5WriteReadTest, ADIOS2HDF5WriteADIOS2HDF5Read2D4x2) 
            var_r32.SetStepSelection({t, 1});

            var_r64.SetStepSelection({t, 1});



            hdf5Reader.BeginStep();

            hdf5Reader.Get(var_iString, IString);



            hdf5Reader.Get(var_i8, I8.data());
@@ -2603,8 +2599,7 @@ TEST_F(HDF5WriteReadTest, ADIOS2HDF5WriteADIOS2HDF5Read2D4x2) 


            hdf5Reader.Get(var_r32, R32.data());

            hdf5Reader.Get(var_r64, R64.data());



            hdf5Reader.EndStep();

            hdf5Reader.PerformGets();



            // Generate test data for each rank uniquely

            SmallTestData currentTestData = generateNewSmallTestData(
@@ -2840,7 +2835,6 @@ TEST_F(HDF5WriteReadTest, HDF5WriteADIOS2HDF5Read2D4x2) 
            var_r32.SetStepSelection({t, 1});

            var_r64.SetStepSelection({t, 1});



            hdf5Reader.BeginStep();

            hdf5Reader.Get(var_iString, IString);



            hdf5Reader.Get(var_i8, I8.data());
@@ -2855,7 +2849,7 @@ TEST_F(HDF5WriteReadTest, HDF5WriteADIOS2HDF5Read2D4x2) 


            hdf5Reader.Get(var_r32, R32.data());

            hdf5Reader.Get(var_r64, R64.data());

            hdf5Reader.EndStep();

            hdf5Reader.PerformGets();



            // Generate test data for each rank uniquely

            SmallTestData currentTestData = generateNewSmallTestData(