From 2df5b9600ac08dae13b8b12e66fd2972ecdbe9e6 Mon Sep 17 00:00:00 2001 From: Norbert Podhorszki Date: Thu, 14 May 2020 14:23:28 -0400 Subject: [PATCH 1/3] Added backward compatibility tests for 2.5.0 attributes and multiblock arrays, and 2.6.0 attributes which now contains long double and complex attributes. Also fixed bpls to print long double values. --- source/utils/bpls/bpls.cpp | 1 + testing/CMakeLists.txt | 1 + .../2.5.0/CMakeLists.txt | 19 + .../2.5.0/SmallTestData250.h | 129 ++++ .../2.5.0/TestReadAttributes.cpp | 586 +++++++++++++++ .../2.5.0/TestReadMultiblocks.cpp | 532 ++++++++++++++ .../2.6.0/CMakeLists.txt | 18 + .../2.6.0/SmallTestData260.h | 129 ++++ .../2.6.0/TestReadAttributes.cpp | 690 ++++++++++++++++++ testing/backward-compatibility/CMakeLists.txt | 7 + 10 files changed, 2112 insertions(+) create mode 100644 testing/backward-compatibility/2.5.0/CMakeLists.txt create mode 100644 testing/backward-compatibility/2.5.0/SmallTestData250.h create mode 100644 testing/backward-compatibility/2.5.0/TestReadAttributes.cpp create mode 100644 testing/backward-compatibility/2.5.0/TestReadMultiblocks.cpp create mode 100644 testing/backward-compatibility/2.6.0/CMakeLists.txt create mode 100644 testing/backward-compatibility/2.6.0/SmallTestData260.h create mode 100644 testing/backward-compatibility/2.6.0/TestReadAttributes.cpp create mode 100644 testing/backward-compatibility/CMakeLists.txt diff --git a/source/utils/bpls/bpls.cpp b/source/utils/bpls/bpls.cpp index 097e386c49..3d20fd1ca3 100644 --- a/source/utils/bpls/bpls.cpp +++ b/source/utils/bpls/bpls.cpp @@ -2189,6 +2189,7 @@ const std::map adios_types_map = { {"int32_t", adios_integer}, {"float", adios_real}, {"double", adios_double}, + {"long double", adios_long_double}, {"float complex", adios_complex}, {"double complex", adios_double_complex}, {"int8_t", adios_byte}, diff --git a/testing/CMakeLists.txt b/testing/CMakeLists.txt index 675147ed4d..808f06de6f 100644 --- a/testing/CMakeLists.txt +++ b/testing/CMakeLists.txt @@ -96,6 +96,7 @@ endfunction() add_subdirectory(adios2) add_subdirectory(utils) +add_subdirectory(backward-compatibility) if(ADIOS2_RUN_INSTALL_TEST) add_subdirectory(install) endif() diff --git a/testing/backward-compatibility/2.5.0/CMakeLists.txt b/testing/backward-compatibility/2.5.0/CMakeLists.txt new file mode 100644 index 0000000000..ecb2d18481 --- /dev/null +++ b/testing/backward-compatibility/2.5.0/CMakeLists.txt @@ -0,0 +1,19 @@ +#------------------------------------------------------------------------------# +# Distributed under the OSI-approved Apache License, Version 2.0. See +# accompanying file Copyright.txt for details. +#------------------------------------------------------------------------------# + +macro(bp3_bp4_gtest_add_tests_helper testname mpi) + gtest_add_tests_helper(${testname} ${mpi} "" BackwardCompatibility.250. .BP3 + EXTRA_ARGS ${CMAKE_CURRENT_SOURCE_DIR}/data "BP3" + ) + gtest_add_tests_helper(${testname} ${mpi} "" BackwardCompatibility.250. .BP4 + EXTRA_ARGS ${CMAKE_CURRENT_SOURCE_DIR}/data "BP4" + ) +endmacro() + + +bp3_bp4_gtest_add_tests_helper(ReadAttributes MPI_NONE) +bp3_bp4_gtest_add_tests_helper(ReadMultiblocks MPI_NONE) + + diff --git a/testing/backward-compatibility/2.5.0/SmallTestData250.h b/testing/backward-compatibility/2.5.0/SmallTestData250.h new file mode 100644 index 0000000000..c38f8b2cbb --- /dev/null +++ b/testing/backward-compatibility/2.5.0/SmallTestData250.h @@ -0,0 +1,129 @@ +/* + * Distributed under the OSI-approved Apache License, Version 2.0. See + * accompanying file Copyright.txt for details. + */ +#ifndef TESTING_BACKWARD_250_SMALLTESTDATA_H_ +#define TESTING_BACKWARD_250_SMALLTESTDATA_H_ + +#include + +#include +#include +#include +#include + +#ifdef WIN32 +#define NOMINMAX +#endif + +// 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 +struct SmallTestData250 +{ + std::string S1 = "Testing ADIOS2 String type"; + + // These shoudl be able to use std::array like the rest of the pieces + // but the XL compiler seems to have some bad code generation surounding + // it that results in a double-free corruption. Switching to std::vector + // bypasses the problem + std::vector S1array = {"one"}; + std::vector S3 = {"one", "two", "three"}; + + std::array I8 = {{0, 1, -2, 3, -4, 5, -6, 7, -8, 9}}; + std::array I16 = { + {512, 513, -510, 515, -508, 517, -506, 519, -504, 521}}; + std::array I32 = {{131072, 131073, -131070, 131075, -131068, + 131077, -131066, 131079, -131064, 131081}}; + std::array I64 = { + {8589934592, 8589934593, -8589934590, 8589934595, -8589934588, + 8589934597, -8589934586, 8589934599, -8589934584, 8589934601}}; + std::array U8 = { + {128, 129, 130, 131, 132, 133, 134, 135, 136, 137}}; + std::array U16 = { + {32768, 32769, 32770, 32771, 32772, 32773, 32774, 32775, 32776, 32777}}; + std::array U32 = { + {2147483648, 2147483649, 2147483650, 2147483651, 2147483652, 2147483653, + 2147483654, 2147483655, 2147483656, 2147483657}}; + std::array U64 = { + {9223372036854775808UL, 9223372036854775809UL, 9223372036854775810UL, + 9223372036854775811UL, 9223372036854775812UL, 9223372036854775813UL, + 9223372036854775814UL, 9223372036854775815UL, 9223372036854775816UL, + 9223372036854775817UL}}; + std::array R32 = { + {0.1f, 1.1f, 2.1f, 3.1f, 4.1f, 5.1f, 6.1f, 7.1f, 8.1f, 9.1f}}; + std::array R64 = { + {10.2, 11.2, 12.2, 13.2, 14.2, 15.2, 16.2, 17.2, 18.2, 19.2}}; + std::array R128 = { + {410.2, 411.2, 412.2, 413.2, 414.2, 415.2, 416.2, 417.2, 418.2, 419.2}}; + + std::array, 10> CR32 = { + {std::complex(0.1f, 1.1f), std::complex(1.1f, 2.1f), + std::complex(2.1f, 3.1f), std::complex(3.1f, 4.1f), + std::complex(4.1f, 5.1f), std::complex(5.1f, 6.1f), + std::complex(6.1f, 7.1f), std::complex(7.1f, 8.1f), + std::complex(8.1f, 9.1f), std::complex(9.1f, 10.1f)}}; + + std::array, 10> CR64 = { + {std::complex(10.2, 11.2), std::complex(11.2, 12.2), + std::complex(12.2, 13.2), std::complex(13.2, 14.2), + std::complex(14.2, 15.2), std::complex(15.2, 16.2), + std::complex(16.2, 17.2), std::complex(17.2, 18.2), + std::complex(18.2, 19.2), std::complex(19.2, 20.2)}}; +}; + +SmallTestData250 generateNewSmallTestData(SmallTestData250 in, int step, + int rank, int size) +{ + int j = rank + 1 + step * size; + std::for_each(in.I8.begin(), in.I8.end(), [&](int8_t &v) { v += j; }); + std::for_each(in.I16.begin(), in.I16.end(), [&](int16_t &v) { v += j; }); + std::for_each(in.I32.begin(), in.I32.end(), [&](int32_t &v) { v += j; }); + std::for_each(in.I64.begin(), in.I64.end(), [&](int64_t &v) { v += j; }); + std::for_each(in.U8.begin(), in.U8.end(), [&](uint8_t &v) { v += j; }); + std::for_each(in.U16.begin(), in.U16.end(), [&](uint16_t &v) { v += j; }); + std::for_each(in.U32.begin(), in.U32.end(), [&](uint32_t &v) { v += j; }); + std::for_each(in.U64.begin(), in.U64.end(), [&](uint64_t &v) { v += j; }); + std::for_each(in.R32.begin(), in.R32.end(), [&](float &v) { v += j; }); + std::for_each(in.R64.begin(), in.R64.end(), [&](double &v) { v += j; }); + std::for_each(in.R128.begin(), in.R128.end(), + [&](long double &v) { v += j; }); + + std::for_each(in.CR32.begin(), in.CR32.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); + std::for_each(in.CR64.begin(), in.CR64.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); + + return in; +} + +void UpdateSmallTestData(SmallTestData250 &in, int step, int rank, int size) +{ + int j = rank + 1 + step * size; + std::for_each(in.I8.begin(), in.I8.end(), [&](int8_t &v) { v += j; }); + std::for_each(in.I16.begin(), in.I16.end(), [&](int16_t &v) { v += j; }); + std::for_each(in.I32.begin(), in.I32.end(), [&](int32_t &v) { v += j; }); + std::for_each(in.I64.begin(), in.I64.end(), [&](int64_t &v) { v += j; }); + std::for_each(in.U8.begin(), in.U8.end(), [&](uint8_t &v) { v += j; }); + std::for_each(in.U16.begin(), in.U16.end(), [&](uint16_t &v) { v += j; }); + std::for_each(in.U32.begin(), in.U32.end(), [&](uint32_t &v) { v += j; }); + std::for_each(in.U64.begin(), in.U64.end(), [&](uint64_t &v) { v += j; }); + std::for_each(in.R32.begin(), in.R32.end(), [&](float &v) { v += j; }); + std::for_each(in.R64.begin(), in.R64.end(), [&](double &v) { v += j; }); + std::for_each(in.R128.begin(), in.R128.end(), + [&](long double &v) { v += j; }); + + std::for_each(in.CR32.begin(), in.CR32.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); + std::for_each(in.CR64.begin(), in.CR64.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); +} + +#endif // TESTING_BACKWARD_250_SMALLTESTDATA_H_ diff --git a/testing/backward-compatibility/2.5.0/TestReadAttributes.cpp b/testing/backward-compatibility/2.5.0/TestReadAttributes.cpp new file mode 100644 index 0000000000..2597bc234f --- /dev/null +++ b/testing/backward-compatibility/2.5.0/TestReadAttributes.cpp @@ -0,0 +1,586 @@ +/* + * Distributed under the OSI-approved Apache License, Version 2.0. See + * accompanying file Copyright.txt for details. + */ +#include +#include +#include + +#include +#include + +#include + +#include + +#include "SmallTestData250.h" + +std::string dataPath; // comes from command line +std::string engineName; // comes from command line + +class ReadAttributes : public ::testing::Test +{ +public: + ReadAttributes() = default; + + SmallTestData250 m_TestData; +}; + +// ADIOS2 write, read for single value attributes +TEST_F(ReadAttributes, SingleTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesSingleTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Single = std::string("s1_Single_") + zero; + const std::string s1_Array = std::string("s1_Array_") + zero; + const std::string i8_Single = std::string("i8_Single_") + zero; + const std::string i16_Single = std::string("i16_Single_") + zero; + const std::string i32_Single = std::string("i32_Single_") + zero; + const std::string i64_Single = std::string("i64_Single_") + zero; + const std::string u8_Single = std::string("u8_Single_") + zero; + const std::string u16_Single = std::string("u16_Single_") + zero; + const std::string u32_Single = std::string("u32_Single_") + zero; + const std::string u64_Single = std::string("u64_Single_") + zero; + const std::string r32_Single = std::string("r32_Single_") + zero; + const std::string r64_Single = std::string("r64_Single_") + zero; + + // When collective meta generation has landed, use + // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); + // Generate current testing data + SmallTestData250 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto attr_s1 = ioRead.InquireAttribute(s1_Single); + auto attr_s1a = ioRead.InquireAttribute(s1_Array); + auto attr_i8 = ioRead.InquireAttribute(i8_Single); + auto attr_i16 = ioRead.InquireAttribute(i16_Single); + auto attr_i32 = ioRead.InquireAttribute(i32_Single); + auto attr_i64 = ioRead.InquireAttribute(i64_Single); + + auto attr_u8 = ioRead.InquireAttribute(u8_Single); + auto attr_u16 = ioRead.InquireAttribute(u16_Single); + auto attr_u32 = ioRead.InquireAttribute(u32_Single); + auto attr_u64 = ioRead.InquireAttribute(u64_Single); + + auto attr_r32 = ioRead.InquireAttribute(r32_Single); + auto attr_r64 = ioRead.InquireAttribute(r64_Single); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), s1_Single); + ASSERT_EQ(attr_s1.Data().size() == 1, true); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + ASSERT_EQ(attr_s1.Data().front(), currentTestData.S1); + + EXPECT_TRUE(attr_s1a); + ASSERT_EQ(attr_s1a.Name(), s1_Array); + ASSERT_EQ(attr_s1a.Data().size() == 1, true); + ASSERT_EQ(attr_s1a.Type(), adios2::GetType()); + ASSERT_EQ(attr_s1a.Data()[0], currentTestData.S1array[0]); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), i8_Single); + ASSERT_EQ(attr_i8.Data().size() == 1, true); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + ASSERT_EQ(attr_i8.Data().front(), currentTestData.I8.front()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), i16_Single); + ASSERT_EQ(attr_i16.Data().size() == 1, true); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + ASSERT_EQ(attr_i16.Data().front(), currentTestData.I16.front()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), i32_Single); + ASSERT_EQ(attr_i32.Data().size() == 1, true); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + ASSERT_EQ(attr_i32.Data().front(), currentTestData.I32.front()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), i64_Single); + ASSERT_EQ(attr_i64.Data().size() == 1, true); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + ASSERT_EQ(attr_i64.Data().front(), currentTestData.I64.front()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), u8_Single); + ASSERT_EQ(attr_u8.Data().size() == 1, true); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + ASSERT_EQ(attr_u8.Data().front(), currentTestData.U8.front()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), u16_Single); + ASSERT_EQ(attr_u16.Data().size() == 1, true); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + ASSERT_EQ(attr_u16.Data().front(), currentTestData.U16.front()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), u32_Single); + ASSERT_EQ(attr_u32.Data().size() == 1, true); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + ASSERT_EQ(attr_u32.Data().front(), currentTestData.U32.front()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), u64_Single); + ASSERT_EQ(attr_u64.Data().size() == 1, true); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + ASSERT_EQ(attr_u64.Data().front(), currentTestData.U64.front()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), r32_Single); + ASSERT_EQ(attr_r32.Data().size() == 1, true); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + ASSERT_EQ(attr_r32.Data().front(), currentTestData.R32.front()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), r64_Single); + ASSERT_EQ(attr_r64.Data().size() == 1, true); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + ASSERT_EQ(attr_r64.Data().front(), currentTestData.R64.front()); + + bpRead.Close(); + } +} + +// ADIOS2 write read for array attributes +TEST_F(ReadAttributes, ArrayTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesArrayTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Array = std::string("s1_Array_") + zero; + const std::string i8_Array = std::string("i8_Array_") + zero; + const std::string i16_Array = std::string("i16_Array_") + zero; + const std::string i32_Array = std::string("i32_Array_") + zero; + const std::string i64_Array = std::string("i64_Array_") + zero; + const std::string u8_Array = std::string("u8_Array_") + zero; + const std::string u16_Array = std::string("u16_Array_") + zero; + const std::string u32_Array = std::string("u32_Array_") + zero; + const std::string u64_Array = std::string("u64_Array_") + zero; + const std::string r32_Array = std::string("r32_Array_") + zero; + const std::string r64_Array = std::string("r64_Array_") + zero; + + // When collective meta generation has landed, use + // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); + // Generate current testing data + SmallTestData250 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto attr_s1 = ioRead.InquireAttribute(s1_Array); + + auto attr_i8 = ioRead.InquireAttribute(i8_Array); + auto attr_i16 = ioRead.InquireAttribute(i16_Array); + auto attr_i32 = ioRead.InquireAttribute(i32_Array); + auto attr_i64 = ioRead.InquireAttribute(i64_Array); + + auto attr_u8 = ioRead.InquireAttribute(u8_Array); + auto attr_u16 = ioRead.InquireAttribute(u16_Array); + auto attr_u32 = ioRead.InquireAttribute(u32_Array); + auto attr_u64 = ioRead.InquireAttribute(u64_Array); + + auto attr_r32 = ioRead.InquireAttribute(r32_Array); + auto attr_r64 = ioRead.InquireAttribute(r64_Array); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), s1_Array); + ASSERT_EQ(attr_s1.Data().size() == 1, false); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), i8_Array); + ASSERT_EQ(attr_i8.Data().size() == 1, false); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), i16_Array); + ASSERT_EQ(attr_i16.Data().size() == 1, false); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), i32_Array); + ASSERT_EQ(attr_i32.Data().size() == 1, false); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), i64_Array); + ASSERT_EQ(attr_i64.Data().size() == 1, false); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), u8_Array); + ASSERT_EQ(attr_u8.Data().size() == 1, false); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), u16_Array); + ASSERT_EQ(attr_u16.Data().size() == 1, false); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), u32_Array); + ASSERT_EQ(attr_u32.Data().size() == 1, false); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), u64_Array); + ASSERT_EQ(attr_u64.Data().size() == 1, false); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), r32_Array); + ASSERT_EQ(attr_r32.Data().size() == 1, false); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), r64_Array); + ASSERT_EQ(attr_r64.Data().size() == 1, false); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + + auto I8 = attr_i8.Data(); + auto I16 = attr_i16.Data(); + auto I32 = attr_i32.Data(); + auto I64 = attr_i64.Data(); + + auto U8 = attr_u8.Data(); + auto U16 = attr_u16.Data(); + auto U32 = attr_u32.Data(); + auto U64 = attr_u64.Data(); + + const size_t Nx = 10; + for (size_t i = 0; i < Nx; ++i) + { + EXPECT_EQ(I8[i], currentTestData.I8[i]); + EXPECT_EQ(I16[i], currentTestData.I16[i]); + EXPECT_EQ(I32[i], currentTestData.I32[i]); + EXPECT_EQ(I64[i], currentTestData.I64[i]); + + EXPECT_EQ(U8[i], currentTestData.U8[i]); + EXPECT_EQ(U16[i], currentTestData.U16[i]); + EXPECT_EQ(U32[i], currentTestData.U32[i]); + EXPECT_EQ(U64[i], currentTestData.U64[i]); + } + + bpRead.Close(); + } +} + +TEST_F(ReadAttributes, OfVariableSingleTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesOfVariableSingleTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Single = std::string("s1_Single_") + zero; + const std::string i8_Single = std::string("i8_Single_") + zero; + const std::string i16_Single = std::string("i16_Single_") + zero; + const std::string i32_Single = std::string("i32_Single_") + zero; + const std::string i64_Single = std::string("i64_Single_") + zero; + const std::string u8_Single = std::string("u8_Single_") + zero; + const std::string u16_Single = std::string("u16_Single_") + zero; + const std::string u32_Single = std::string("u32_Single_") + zero; + const std::string u64_Single = std::string("u64_Single_") + zero; + const std::string r32_Single = std::string("r32_Single_") + zero; + const std::string r64_Single = std::string("r64_Single_") + zero; + + // When collective meta generation has landed, use + // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); + // Generate current testing data + SmallTestData250 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + const std::string separator = "/"; + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto var = ioRead.InquireVariable("myVar"); + + auto attr_s1 = + ioRead.InquireAttribute(s1_Single, var.Name()); + auto attr_i8 = ioRead.InquireAttribute(i8_Single, var.Name()); + auto attr_i16 = + ioRead.InquireAttribute(i16_Single, var.Name()); + auto attr_i32 = + ioRead.InquireAttribute(i32_Single, var.Name()); + auto attr_i64 = + ioRead.InquireAttribute(i64_Single, var.Name()); + + auto attr_u8 = ioRead.InquireAttribute(u8_Single, var.Name()); + auto attr_u16 = + ioRead.InquireAttribute(u16_Single, var.Name()); + auto attr_u32 = + ioRead.InquireAttribute(u32_Single, var.Name()); + auto attr_u64 = + ioRead.InquireAttribute(u64_Single, var.Name()); + + auto attr_r32 = ioRead.InquireAttribute(r32_Single, var.Name()); + auto attr_r64 = ioRead.InquireAttribute(r64_Single, var.Name()); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), var.Name() + separator + s1_Single); + ASSERT_EQ(attr_s1.Data().size() == 1, true); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + ASSERT_EQ(attr_s1.Data().front(), currentTestData.S1); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), var.Name() + separator + i8_Single); + ASSERT_EQ(attr_i8.Data().size() == 1, true); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + ASSERT_EQ(attr_i8.Data().front(), currentTestData.I8.front()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), var.Name() + separator + i16_Single); + ASSERT_EQ(attr_i16.Data().size() == 1, true); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + ASSERT_EQ(attr_i16.Data().front(), currentTestData.I16.front()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), var.Name() + separator + i32_Single); + ASSERT_EQ(attr_i32.Data().size() == 1, true); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + ASSERT_EQ(attr_i32.Data().front(), currentTestData.I32.front()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), var.Name() + separator + i64_Single); + ASSERT_EQ(attr_i64.Data().size() == 1, true); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + ASSERT_EQ(attr_i64.Data().front(), currentTestData.I64.front()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), var.Name() + separator + u8_Single); + ASSERT_EQ(attr_u8.Data().size() == 1, true); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + ASSERT_EQ(attr_u8.Data().front(), currentTestData.U8.front()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), var.Name() + separator + u16_Single); + ASSERT_EQ(attr_u16.Data().size() == 1, true); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + ASSERT_EQ(attr_u16.Data().front(), currentTestData.U16.front()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), var.Name() + separator + u32_Single); + ASSERT_EQ(attr_u32.Data().size() == 1, true); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + ASSERT_EQ(attr_u32.Data().front(), currentTestData.U32.front()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), var.Name() + separator + u64_Single); + ASSERT_EQ(attr_u64.Data().size() == 1, true); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + ASSERT_EQ(attr_u64.Data().front(), currentTestData.U64.front()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), var.Name() + separator + r32_Single); + ASSERT_EQ(attr_r32.Data().size() == 1, true); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + ASSERT_EQ(attr_r32.Data().front(), currentTestData.R32.front()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), var.Name() + separator + r64_Single); + ASSERT_EQ(attr_r64.Data().size() == 1, true); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + ASSERT_EQ(attr_r64.Data().front(), currentTestData.R64.front()); + + bpRead.Close(); + } +} + +// ADIOS2 write read for array attributes +TEST_F(ReadAttributes, OfVariableArrayTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesOfVariableArrayTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Array = std::string("s1_Array_") + zero; + const std::string i8_Array = std::string("i8_Array_") + zero; + const std::string i16_Array = std::string("i16_Array_") + zero; + const std::string i32_Array = std::string("i32_Array_") + zero; + const std::string i64_Array = std::string("i64_Array_") + zero; + const std::string u8_Array = std::string("u8_Array_") + zero; + const std::string u16_Array = std::string("u16_Array_") + zero; + const std::string u32_Array = std::string("u32_Array_") + zero; + const std::string u64_Array = std::string("u64_Array_") + zero; + const std::string r32_Array = std::string("r32_Array_") + zero; + const std::string r64_Array = std::string("r64_Array_") + zero; + + const std::string separator = "/"; + + SmallTestData250 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto var = ioRead.InquireVariable("myVar"); + + auto attr_s1 = + ioRead.InquireAttribute(s1_Array, var.Name()); + + auto attr_i8 = ioRead.InquireAttribute(i8_Array, var.Name()); + auto attr_i16 = ioRead.InquireAttribute(i16_Array, var.Name()); + auto attr_i32 = ioRead.InquireAttribute(i32_Array, var.Name()); + auto attr_i64 = ioRead.InquireAttribute(i64_Array, var.Name()); + + auto attr_u8 = ioRead.InquireAttribute(u8_Array, var.Name()); + auto attr_u16 = + ioRead.InquireAttribute(u16_Array, var.Name()); + auto attr_u32 = + ioRead.InquireAttribute(u32_Array, var.Name()); + auto attr_u64 = + ioRead.InquireAttribute(u64_Array, var.Name()); + + auto attr_r32 = ioRead.InquireAttribute(r32_Array, var.Name()); + auto attr_r64 = ioRead.InquireAttribute(r64_Array, var.Name()); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), var.Name() + separator + s1_Array); + ASSERT_EQ(attr_s1.Data().size() == 1, false); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), var.Name() + separator + i8_Array); + ASSERT_EQ(attr_i8.Data().size() == 1, false); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), var.Name() + separator + i16_Array); + ASSERT_EQ(attr_i16.Data().size() == 1, false); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), var.Name() + separator + i32_Array); + ASSERT_EQ(attr_i32.Data().size() == 1, false); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), var.Name() + separator + i64_Array); + ASSERT_EQ(attr_i64.Data().size() == 1, false); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), var.Name() + separator + u8_Array); + ASSERT_EQ(attr_u8.Data().size() == 1, false); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), var.Name() + separator + u16_Array); + ASSERT_EQ(attr_u16.Data().size() == 1, false); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), var.Name() + separator + u32_Array); + ASSERT_EQ(attr_u32.Data().size() == 1, false); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), var.Name() + separator + u64_Array); + ASSERT_EQ(attr_u64.Data().size() == 1, false); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), var.Name() + separator + r32_Array); + ASSERT_EQ(attr_r32.Data().size() == 1, false); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), var.Name() + separator + r64_Array); + ASSERT_EQ(attr_r64.Data().size() == 1, false); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + + auto I8 = attr_i8.Data(); + auto I16 = attr_i16.Data(); + auto I32 = attr_i32.Data(); + auto I64 = attr_i64.Data(); + + auto U8 = attr_u8.Data(); + auto U16 = attr_u16.Data(); + auto U32 = attr_u32.Data(); + auto U64 = attr_u64.Data(); + + const size_t Nx = 10; + for (size_t i = 0; i < Nx; ++i) + { + EXPECT_EQ(I8[i], currentTestData.I8[i]); + EXPECT_EQ(I16[i], currentTestData.I16[i]); + EXPECT_EQ(I32[i], currentTestData.I32[i]); + EXPECT_EQ(I64[i], currentTestData.I64[i]); + + EXPECT_EQ(U8[i], currentTestData.U8[i]); + EXPECT_EQ(U16[i], currentTestData.U16[i]); + EXPECT_EQ(U32[i], currentTestData.U32[i]); + EXPECT_EQ(U64[i], currentTestData.U64[i]); + } + + bpRead.Close(); + } +} + +//****************************************************************************** +// main +//****************************************************************************** + +int main(int argc, char **argv) +{ + int result; + ::testing::InitGoogleTest(&argc, argv); + + if (argc < 3) + { + throw std::runtime_error( + "Test needs 2 arguments: path-to-data engineName"); + } + + dataPath = std::string(argv[1]); + engineName = std::string(argv[2]); + + result = RUN_ALL_TESTS(); + + return result; +} diff --git a/testing/backward-compatibility/2.5.0/TestReadMultiblocks.cpp b/testing/backward-compatibility/2.5.0/TestReadMultiblocks.cpp new file mode 100644 index 0000000000..386d1a014b --- /dev/null +++ b/testing/backward-compatibility/2.5.0/TestReadMultiblocks.cpp @@ -0,0 +1,532 @@ +/* + * Distributed under the OSI-approved Apache License, Version 2.0. See + * accompanying file Copyright.txt for details. + */ +#include +#include + +#include //std::min_element, std::max_element +#include +#include + +#include + +#include + +#include "SmallTestData250.h" + +std::string dataPath; // comes from command line +std::string engineName; // comes from command line + +class ReadMultiblock : public ::testing::Test +{ +public: + ReadMultiblock() = default; + + SmallTestData250 m_TestData; +}; + +//****************************************************************************** +// 2D 4x2 test data +//****************************************************************************** + +TEST_F(ReadMultiblock, 2D4x2) +{ + /* Data: Written by 4 processes + Each process did write a 4x2 array in two blocks of 2x2 + Writer process pattern in array + (rank 0 writes two blocks non-contiguously in global array) + 0 1 2 3 + 0 1 2 3 + Blocks position in array (rank 0 wrote block 0 and 1, etc) + 0 2 4 6 + 1 3 5 7 + */ + const std::string fname(dataPath + std::string(&adios2::PathSeparator, 1) + + engineName + "Multiblock2D4x2.bp"); + // std::cout << "Open file: " << fname << std::endl; + // Number of columns per block + const std::size_t Nx = 2; + // Number of rows per block + const std::size_t Ny = 2; + + // Number of blocks comprising each array in the file + const std::size_t NBlocksX = 4; + const std::size_t NBlocksY = 2; + const std::size_t NBlocksTotal = NBlocksY * NBlocksX; + + // Number of total columns of each array in file + const std::size_t Gnx = NBlocksX * Nx; + // Number of total rows of each array in file + const std::size_t Gny = NBlocksY * Ny; + + // Number of steps + const std::size_t NSteps = 3; + + adios2::ADIOS adios; + + adios2::IO io = adios.DeclareIO("ReadIO"); + + if (!engineName.empty()) + { + io.SetEngine(engineName); + } + + adios2::Engine bpReader = io.Open(fname, adios2::Mode::Read); + + auto var_i8 = io.InquireVariable("i8"); + EXPECT_TRUE(var_i8); + EXPECT_EQ(var_i8.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_i8.Steps(), NSteps); + EXPECT_EQ(var_i8.Shape()[0], Gny); + EXPECT_EQ(var_i8.Shape()[1], Gnx); + + auto var_i16 = io.InquireVariable("i16"); + EXPECT_TRUE(var_i16); + EXPECT_EQ(var_i16.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_i16.Steps(), NSteps); + EXPECT_EQ(var_i16.Shape()[0], Gny); + EXPECT_EQ(var_i16.Shape()[1], Gnx); + + auto var_i32 = io.InquireVariable("i32"); + EXPECT_TRUE(var_i32); + EXPECT_EQ(var_i32.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_i32.Steps(), NSteps); + EXPECT_EQ(var_i32.Shape()[0], Gny); + EXPECT_EQ(var_i32.Shape()[1], Gnx); + + auto var_i64 = io.InquireVariable("i64"); + EXPECT_TRUE(var_i64); + EXPECT_EQ(var_i64.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_i64.Steps(), NSteps); + EXPECT_EQ(var_i64.Shape()[0], Gny); + EXPECT_EQ(var_i64.Shape()[1], Gnx); + + auto var_u8 = io.InquireVariable("u8"); + EXPECT_TRUE(var_u8); + EXPECT_EQ(var_u8.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_u8.Steps(), NSteps); + EXPECT_EQ(var_u8.Shape()[0], Gny); + EXPECT_EQ(var_u8.Shape()[1], Gnx); + + auto var_u16 = io.InquireVariable("u16"); + EXPECT_TRUE(var_u16); + EXPECT_EQ(var_u16.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_u16.Steps(), NSteps); + EXPECT_EQ(var_u16.Shape()[0], Gny); + EXPECT_EQ(var_u16.Shape()[1], Gnx); + + auto var_u32 = io.InquireVariable("u32"); + EXPECT_TRUE(var_u32); + EXPECT_EQ(var_u32.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_u32.Steps(), NSteps); + EXPECT_EQ(var_u32.Shape()[0], Gny); + EXPECT_EQ(var_u32.Shape()[1], Gnx); + + auto var_u64 = io.InquireVariable("u64"); + EXPECT_TRUE(var_u64); + EXPECT_EQ(var_u64.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_u64.Steps(), NSteps); + EXPECT_EQ(var_u64.Shape()[0], Gny); + EXPECT_EQ(var_u64.Shape()[1], Gnx); + + auto var_r32 = io.InquireVariable("r32"); + EXPECT_TRUE(var_r32); + EXPECT_EQ(var_r32.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_r32.Steps(), NSteps); + EXPECT_EQ(var_r32.Shape()[0], Gny); + EXPECT_EQ(var_r32.Shape()[1], Gnx); + + auto var_r64 = io.InquireVariable("r64"); + EXPECT_TRUE(var_r64); + EXPECT_EQ(var_r64.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_r64.Steps(), NSteps); + EXPECT_EQ(var_r64.Shape()[0], Gny); + EXPECT_EQ(var_r64.Shape()[1], Gnx); + + auto var_cr32 = io.InquireVariable>("cr32"); + EXPECT_TRUE(var_cr32); + EXPECT_EQ(var_cr32.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_cr32.Steps(), NSteps); + EXPECT_EQ(var_cr32.Shape()[0], Gny); + EXPECT_EQ(var_cr32.Shape()[1], Gnx); + + auto var_cr64 = io.InquireVariable>("cr64"); + EXPECT_TRUE(var_cr64); + EXPECT_EQ(var_cr64.ShapeID(), adios2::ShapeID::GlobalArray); + EXPECT_EQ(var_cr64.Steps(), NSteps); + EXPECT_EQ(var_cr64.Shape()[0], Gny); + EXPECT_EQ(var_cr64.Shape()[1], Gnx); + + // create arrays to contain one block + std::array I8; + std::array I16; + std::array I32; + std::array I64; + std::array U8; + std::array U16; + std::array U32; + std::array U64; + std::array R32; + std::array R64; + std::array, Nx * Ny> CR32; + std::array, Nx * Ny> CR64; + + size_t t = 0; + + while (bpReader.BeginStep() == adios2::StepStatus::OK) + { + + std::cout << "Check step t = " << t << std::endl; + + const std::vector::Info> i8Info = + bpReader.BlocksInfo(var_i8, bpReader.CurrentStep()); + const std::vector::Info> i16Info = + bpReader.BlocksInfo(var_i16, bpReader.CurrentStep()); + const std::vector::Info> i32Info = + bpReader.BlocksInfo(var_i32, bpReader.CurrentStep()); + const std::vector::Info> i64Info = + bpReader.BlocksInfo(var_i64, bpReader.CurrentStep()); + const std::vector::Info> u8Info = + bpReader.BlocksInfo(var_u8, bpReader.CurrentStep()); + const std::vector::Info> u16Info = + bpReader.BlocksInfo(var_u16, bpReader.CurrentStep()); + const std::vector::Info> u32Info = + bpReader.BlocksInfo(var_u32, bpReader.CurrentStep()); + const std::vector::Info> u64Info = + bpReader.BlocksInfo(var_u64, bpReader.CurrentStep()); + const std::vector::Info> r32Info = + bpReader.BlocksInfo(var_r32, bpReader.CurrentStep()); + const std::vector::Info> r64Info = + bpReader.BlocksInfo(var_r64, bpReader.CurrentStep()); + + const std::vector>::Info> + cr32Info = bpReader.BlocksInfo(var_cr32, bpReader.CurrentStep()); + const std::vector>::Info> + cr64Info = bpReader.BlocksInfo(var_cr64, bpReader.CurrentStep()); + + EXPECT_EQ(i8Info.size(), NBlocksTotal); + EXPECT_EQ(i16Info.size(), NBlocksTotal); + EXPECT_EQ(i32Info.size(), NBlocksTotal); + EXPECT_EQ(i64Info.size(), NBlocksTotal); + EXPECT_EQ(u8Info.size(), NBlocksTotal); + EXPECT_EQ(u16Info.size(), NBlocksTotal); + EXPECT_EQ(u32Info.size(), NBlocksTotal); + EXPECT_EQ(u64Info.size(), NBlocksTotal); + EXPECT_EQ(r32Info.size(), NBlocksTotal); + EXPECT_EQ(r64Info.size(), NBlocksTotal); + EXPECT_EQ(cr32Info.size(), NBlocksTotal); + EXPECT_EQ(cr64Info.size(), NBlocksTotal); + + for (size_t b = 0; b < NBlocksTotal; ++b) + { + const size_t inRank = b / 2; + const size_t blockPosX = inRank; + // first or second block per process? + const size_t blockPosY = (b % 2); + + // Make a 2D selection to describe the local dimensions of the + // block we read and its offsets in the global spaces + const adios2::Box sel1( + {blockPosY * Ny, blockPosX * Nx}, {Ny, Nx}); + + std::cout << " Check block b = " << b << " start = {" + << sel1.first[0] << ", " << sel1.first[1] << "} count = {" + << sel1.second[0] << ", " << sel1.second[1] + << "} writer rank = " << inRank << " block pos = (" + << blockPosY << "," << blockPosX << ")" << std::endl; + + EXPECT_FALSE(i8Info[b].IsValue); + EXPECT_FALSE(i16Info[b].IsValue); + EXPECT_FALSE(i32Info[b].IsValue); + EXPECT_FALSE(i64Info[b].IsValue); + EXPECT_FALSE(u8Info[b].IsValue); + EXPECT_FALSE(u16Info[b].IsValue); + EXPECT_FALSE(u32Info[b].IsValue); + EXPECT_FALSE(u64Info[b].IsValue); + EXPECT_FALSE(r32Info[b].IsValue); + EXPECT_FALSE(r64Info[b].IsValue); + EXPECT_FALSE(cr32Info[b].IsValue); + EXPECT_FALSE(cr64Info[b].IsValue); + + // Generate data for one original writer's two blocks at once + SmallTestData250 currentTestData = + generateNewSmallTestData(m_TestData, static_cast(t), + static_cast(inRank), Nx * Ny); + + EXPECT_EQ(i8Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(i8Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(i8Info[b].Count[0], Ny); + EXPECT_EQ(i8Info[b].Count[1], Nx); + EXPECT_EQ(i8Info[b].WriterID, inRank); + + EXPECT_EQ(i16Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(i16Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(i16Info[b].Count[0], Ny); + EXPECT_EQ(i16Info[b].Count[1], Nx); + EXPECT_EQ(i16Info[b].WriterID, inRank); + + EXPECT_EQ(i32Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(i32Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(i32Info[b].Count[0], Ny); + EXPECT_EQ(i32Info[b].Count[1], Nx); + EXPECT_EQ(i32Info[b].WriterID, inRank); + + EXPECT_EQ(i64Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(i64Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(i64Info[b].Count[0], Ny); + EXPECT_EQ(i64Info[b].Count[1], Nx); + EXPECT_EQ(i64Info[b].WriterID, inRank); + + EXPECT_EQ(u8Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(u8Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(u8Info[b].Count[0], Ny); + EXPECT_EQ(u8Info[b].Count[1], Nx); + EXPECT_EQ(u8Info[b].WriterID, inRank); + + EXPECT_EQ(u16Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(u16Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(u16Info[b].Count[0], Ny); + EXPECT_EQ(u16Info[b].Count[1], Nx); + EXPECT_EQ(u16Info[b].WriterID, inRank); + + EXPECT_EQ(u32Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(u32Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(u32Info[b].Count[0], Ny); + EXPECT_EQ(u32Info[b].Count[1], Nx); + EXPECT_EQ(u32Info[b].WriterID, inRank); + + EXPECT_EQ(u64Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(u64Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(u64Info[b].Count[0], Ny); + EXPECT_EQ(u64Info[b].Count[1], Nx); + EXPECT_EQ(u64Info[b].WriterID, inRank); + + EXPECT_EQ(r32Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(r32Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(r32Info[b].Count[0], Ny); + EXPECT_EQ(r32Info[b].Count[1], Nx); + EXPECT_EQ(r32Info[b].WriterID, inRank); + + EXPECT_EQ(r64Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(r64Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(r64Info[b].Count[0], Ny); + EXPECT_EQ(r64Info[b].Count[1], Nx); + EXPECT_EQ(r64Info[b].WriterID, inRank); + + EXPECT_EQ(cr32Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(cr32Info[b].Start[1], blockPosX * Nx); + EXPECT_EQ(cr32Info[b].Count[0], Ny); + EXPECT_EQ(cr32Info[b].Count[1], Nx); + EXPECT_EQ(cr32Info[b].WriterID, inRank); + + EXPECT_EQ(cr64Info[b].Start[0], blockPosY * Ny); + EXPECT_EQ(cr64Info[b].Start[1], inRank * Nx); + EXPECT_EQ(cr64Info[b].Count[0], Ny); + EXPECT_EQ(cr64Info[b].Count[1], Nx); + EXPECT_EQ(cr64Info[b].WriterID, inRank); + + const size_t posFrom = blockPosY * Ny * Nx; + const size_t posTo = posFrom + Ny * Nx; + + int8_t i8Min, i8Max; + int16_t i16Min, i16Max; + int32_t i32Min, i32Max; + int64_t i64Min, i64Max; + uint8_t u8Min, u8Max; + uint16_t u16Min, u16Max; + uint32_t u32Min, u32Max; + uint64_t u64Min, u64Max; + float r32Min, r32Max; + double r64Min, r64Max; + std::complex cr32Min, cr32Max; + std::complex cr64Min, cr64Max; + + i8Min = *std::min_element(currentTestData.I8.begin() + posFrom, + currentTestData.I8.begin() + posTo); + i8Max = *std::max_element(currentTestData.I8.begin() + posFrom, + currentTestData.I8.begin() + posTo); + i16Min = *std::min_element(currentTestData.I16.begin() + posFrom, + currentTestData.I16.begin() + posTo); + i16Max = *std::max_element(currentTestData.I16.begin() + posFrom, + currentTestData.I16.begin() + posTo); + i32Min = *std::min_element(currentTestData.I32.begin() + posFrom, + currentTestData.I32.begin() + posTo); + i32Max = *std::max_element(currentTestData.I32.begin() + posFrom, + currentTestData.I32.begin() + posTo); + i64Min = *std::min_element(currentTestData.I64.begin() + posFrom, + currentTestData.I64.begin() + posTo); + i64Max = *std::max_element(currentTestData.I64.begin() + posFrom, + currentTestData.I64.begin() + posTo); + u8Min = *std::min_element(currentTestData.U8.begin() + posFrom, + currentTestData.U8.begin() + posTo); + u8Max = *std::max_element(currentTestData.U8.begin() + posFrom, + currentTestData.U8.begin() + posTo); + u16Min = *std::min_element(currentTestData.U16.begin() + posFrom, + currentTestData.U16.begin() + posTo); + u16Max = *std::max_element(currentTestData.U16.begin() + posFrom, + currentTestData.U16.begin() + posTo); + u32Min = *std::min_element(currentTestData.U32.begin() + posFrom, + currentTestData.U32.begin() + posTo); + u32Max = *std::max_element(currentTestData.U32.begin() + posFrom, + currentTestData.U32.begin() + posTo); + u64Min = *std::min_element(currentTestData.U64.begin() + posFrom, + currentTestData.U64.begin() + posTo); + u64Max = *std::max_element(currentTestData.U64.begin() + posFrom, + currentTestData.U64.begin() + posTo); + r32Min = *std::min_element(currentTestData.R32.begin() + posFrom, + currentTestData.R32.begin() + posTo); + r32Max = *std::max_element(currentTestData.R32.begin() + posFrom, + currentTestData.R32.begin() + posTo); + r64Min = *std::min_element(currentTestData.R64.begin() + posFrom, + currentTestData.R64.begin() + posTo); + r64Max = *std::max_element(currentTestData.R64.begin() + posFrom, + currentTestData.R64.begin() + posTo); + + cr32Min = currentTestData.CR32[posFrom]; + cr32Max = currentTestData.CR32[posFrom]; + for (auto it = currentTestData.CR32.begin() + posFrom; + it != currentTestData.CR32.begin() + posTo; ++it) + { + if (std::norm(*it) < std::norm(cr32Min)) + { + cr32Min = *it; + continue; + } + if (std::norm(*it) > std::norm(cr32Max)) + { + cr32Max = *it; + } + } + + cr64Min = currentTestData.CR64[posFrom]; + cr64Max = currentTestData.CR64[posFrom]; + for (auto it = currentTestData.CR64.begin() + posFrom; + it != currentTestData.CR64.begin() + posTo; ++it) + { + if (std::norm(*it) < std::norm(cr64Min)) + { + cr64Min = *it; + continue; + } + if (std::norm(*it) > std::norm(cr64Max)) + { + cr64Max = *it; + } + } + + EXPECT_EQ(i8Info[b].Min, i8Min); + EXPECT_EQ(i8Info[b].Max, i8Max); + EXPECT_EQ(i16Info[b].Min, i16Min); + EXPECT_EQ(i16Info[b].Max, i16Max); + EXPECT_EQ(i32Info[b].Min, i32Min); + EXPECT_EQ(i32Info[b].Max, i32Max); + EXPECT_EQ(i64Info[b].Min, i64Min); + EXPECT_EQ(i64Info[b].Max, i64Max); + + EXPECT_EQ(u8Info[b].Min, u8Min); + EXPECT_EQ(u8Info[b].Max, u8Max); + EXPECT_EQ(u16Info[b].Min, u16Min); + EXPECT_EQ(u16Info[b].Max, u16Max); + EXPECT_EQ(u32Info[b].Min, u32Min); + EXPECT_EQ(u32Info[b].Max, u32Max); + EXPECT_EQ(u64Info[b].Min, u64Min); + EXPECT_EQ(u64Info[b].Max, u64Max); + + EXPECT_EQ(r32Info[b].Min, r32Min); + EXPECT_EQ(r32Info[b].Max, r32Max); + EXPECT_EQ(r64Info[b].Min, r64Min); + EXPECT_EQ(r64Info[b].Max, r64Max); + + EXPECT_EQ(cr32Info[b].Min, cr32Min); + EXPECT_EQ(cr32Info[b].Max, cr32Max); + EXPECT_EQ(cr64Info[b].Min, cr64Min); + EXPECT_EQ(cr64Info[b].Max, cr64Max); + + var_i8.SetSelection(sel1); + bpReader.Get(var_i8, I8.data()); + + var_i16.SetSelection(sel1); + bpReader.Get(var_i16, I16.data()); + + var_i32.SetSelection(sel1); + bpReader.Get(var_i32, I32.data()); + + var_i64.SetSelection(sel1); + bpReader.Get(var_i64, I64.data()); + + var_u8.SetSelection(sel1); + bpReader.Get(var_u8, U8.data()); + + var_u16.SetSelection(sel1); + bpReader.Get(var_u16, U16.data()); + + var_u32.SetSelection(sel1); + bpReader.Get(var_u32, U32.data()); + + var_u64.SetSelection(sel1); + bpReader.Get(var_u64, U64.data()); + + var_r32.SetSelection(sel1); + bpReader.Get(var_r32, R32.data()); + + var_r64.SetSelection(sel1); + bpReader.Get(var_r64, R64.data()); + + var_cr32.SetSelection(sel1); + bpReader.Get(var_cr32, CR32.data()); + + var_cr64.SetSelection(sel1); + bpReader.Get(var_cr64, CR64.data()); + + bpReader.PerformGets(); + + for (size_t i = 0; i < Nx * Ny; ++i) + { + std::stringstream ss; + ss << "t=" << t << " i=" << i << " block=" << b; + std::string msg = ss.str(); + + EXPECT_EQ(I8[i], currentTestData.I8[i + posFrom]) << msg; + EXPECT_EQ(I16[i], currentTestData.I16[i + posFrom]) << msg; + EXPECT_EQ(I32[i], currentTestData.I32[i + posFrom]) << msg; + EXPECT_EQ(I64[i], currentTestData.I64[i + posFrom]) << msg; + EXPECT_EQ(U8[i], currentTestData.U8[i + posFrom]) << msg; + EXPECT_EQ(U16[i], currentTestData.U16[i + posFrom]) << msg; + EXPECT_EQ(U32[i], currentTestData.U32[i + posFrom]) << msg; + EXPECT_EQ(U64[i], currentTestData.U64[i + posFrom]) << msg; + EXPECT_EQ(R32[i], currentTestData.R32[i + posFrom]) << msg; + EXPECT_EQ(R64[i], currentTestData.R64[i + posFrom]) << msg; + EXPECT_EQ(CR32[i], currentTestData.CR32[i + posFrom]) << msg; + EXPECT_EQ(CR64[i], currentTestData.CR64[i + posFrom]) << msg; + } + } + + bpReader.EndStep(); + ++t; + } + EXPECT_EQ(t, NSteps); + bpReader.Close(); +} + +//****************************************************************************** +// main +//****************************************************************************** + +int main(int argc, char **argv) +{ + int result; + ::testing::InitGoogleTest(&argc, argv); + + if (argc < 3) + { + throw std::runtime_error( + "Test needs 2 arguments: path-to-data engineName"); + } + + dataPath = std::string(argv[1]); + engineName = std::string(argv[2]); + result = RUN_ALL_TESTS(); + + return result; +} diff --git a/testing/backward-compatibility/2.6.0/CMakeLists.txt b/testing/backward-compatibility/2.6.0/CMakeLists.txt new file mode 100644 index 0000000000..8226f6169b --- /dev/null +++ b/testing/backward-compatibility/2.6.0/CMakeLists.txt @@ -0,0 +1,18 @@ +#------------------------------------------------------------------------------# +# Distributed under the OSI-approved Apache License, Version 2.0. See +# accompanying file Copyright.txt for details. +#------------------------------------------------------------------------------# + +macro(bp3_bp4_gtest_add_tests_helper testname mpi) + gtest_add_tests_helper(${testname} ${mpi} "" BackwardCompatibility.260. .BP3 + EXTRA_ARGS ${CMAKE_CURRENT_SOURCE_DIR}/data "BP3" + ) + gtest_add_tests_helper(${testname} ${mpi} "" BackwardCompatibility.260. .BP4 + EXTRA_ARGS ${CMAKE_CURRENT_SOURCE_DIR}/data "BP4" + ) +endmacro() + + +bp3_bp4_gtest_add_tests_helper(ReadAttributes MPI_NONE) + + diff --git a/testing/backward-compatibility/2.6.0/SmallTestData260.h b/testing/backward-compatibility/2.6.0/SmallTestData260.h new file mode 100644 index 0000000000..94e2a4d648 --- /dev/null +++ b/testing/backward-compatibility/2.6.0/SmallTestData260.h @@ -0,0 +1,129 @@ +/* + * Distributed under the OSI-approved Apache License, Version 2.0. See + * accompanying file Copyright.txt for details. + */ +#ifndef TESTING_BACKWARD_260_SMALLTESTDATA_H_ +#define TESTING_BACKWARD_260_SMALLTESTDATA_H_ + +#include + +#include +#include +#include +#include + +#ifdef WIN32 +#define NOMINMAX +#endif + +// 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 +struct SmallTestData260 +{ + std::string S1 = "Testing ADIOS2 String type"; + + // These shoudl be able to use std::array like the rest of the pieces + // but the XL compiler seems to have some bad code generation surounding + // it that results in a double-free corruption. Switching to std::vector + // bypasses the problem + std::vector S1array = {"one"}; + std::vector S3 = {"one", "two", "three"}; + + std::array I8 = {{0, 1, -2, 3, -4, 5, -6, 7, -8, 9}}; + std::array I16 = { + {512, 513, -510, 515, -508, 517, -506, 519, -504, 521}}; + std::array I32 = {{131072, 131073, -131070, 131075, -131068, + 131077, -131066, 131079, -131064, 131081}}; + std::array I64 = { + {8589934592, 8589934593, -8589934590, 8589934595, -8589934588, + 8589934597, -8589934586, 8589934599, -8589934584, 8589934601}}; + std::array U8 = { + {128, 129, 130, 131, 132, 133, 134, 135, 136, 137}}; + std::array U16 = { + {32768, 32769, 32770, 32771, 32772, 32773, 32774, 32775, 32776, 32777}}; + std::array U32 = { + {2147483648, 2147483649, 2147483650, 2147483651, 2147483652, 2147483653, + 2147483654, 2147483655, 2147483656, 2147483657}}; + std::array U64 = { + {9223372036854775808UL, 9223372036854775809UL, 9223372036854775810UL, + 9223372036854775811UL, 9223372036854775812UL, 9223372036854775813UL, + 9223372036854775814UL, 9223372036854775815UL, 9223372036854775816UL, + 9223372036854775817UL}}; + std::array R32 = { + {0.1f, 1.1f, 2.1f, 3.1f, 4.1f, 5.1f, 6.1f, 7.1f, 8.1f, 9.1f}}; + std::array R64 = { + {10.2, 11.2, 12.2, 13.2, 14.2, 15.2, 16.2, 17.2, 18.2, 19.2}}; + std::array R128 = { + {410.2, 411.2, 412.2, 413.2, 414.2, 415.2, 416.2, 417.2, 418.2, 419.2}}; + + std::array, 10> CR32 = { + {std::complex(0.1f, 1.1f), std::complex(1.1f, 2.1f), + std::complex(2.1f, 3.1f), std::complex(3.1f, 4.1f), + std::complex(4.1f, 5.1f), std::complex(5.1f, 6.1f), + std::complex(6.1f, 7.1f), std::complex(7.1f, 8.1f), + std::complex(8.1f, 9.1f), std::complex(9.1f, 10.1f)}}; + + std::array, 10> CR64 = { + {std::complex(10.2, 11.2), std::complex(11.2, 12.2), + std::complex(12.2, 13.2), std::complex(13.2, 14.2), + std::complex(14.2, 15.2), std::complex(15.2, 16.2), + std::complex(16.2, 17.2), std::complex(17.2, 18.2), + std::complex(18.2, 19.2), std::complex(19.2, 20.2)}}; +}; + +SmallTestData260 generateNewSmallTestData(SmallTestData260 in, int step, + int rank, int size) +{ + int j = rank + 1 + step * size; + std::for_each(in.I8.begin(), in.I8.end(), [&](int8_t &v) { v += j; }); + std::for_each(in.I16.begin(), in.I16.end(), [&](int16_t &v) { v += j; }); + std::for_each(in.I32.begin(), in.I32.end(), [&](int32_t &v) { v += j; }); + std::for_each(in.I64.begin(), in.I64.end(), [&](int64_t &v) { v += j; }); + std::for_each(in.U8.begin(), in.U8.end(), [&](uint8_t &v) { v += j; }); + std::for_each(in.U16.begin(), in.U16.end(), [&](uint16_t &v) { v += j; }); + std::for_each(in.U32.begin(), in.U32.end(), [&](uint32_t &v) { v += j; }); + std::for_each(in.U64.begin(), in.U64.end(), [&](uint64_t &v) { v += j; }); + std::for_each(in.R32.begin(), in.R32.end(), [&](float &v) { v += j; }); + std::for_each(in.R64.begin(), in.R64.end(), [&](double &v) { v += j; }); + std::for_each(in.R128.begin(), in.R128.end(), + [&](long double &v) { v += j; }); + + std::for_each(in.CR32.begin(), in.CR32.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); + std::for_each(in.CR64.begin(), in.CR64.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); + + return in; +} + +void UpdateSmallTestData(SmallTestData260 &in, int step, int rank, int size) +{ + int j = rank + 1 + step * size; + std::for_each(in.I8.begin(), in.I8.end(), [&](int8_t &v) { v += j; }); + std::for_each(in.I16.begin(), in.I16.end(), [&](int16_t &v) { v += j; }); + std::for_each(in.I32.begin(), in.I32.end(), [&](int32_t &v) { v += j; }); + std::for_each(in.I64.begin(), in.I64.end(), [&](int64_t &v) { v += j; }); + std::for_each(in.U8.begin(), in.U8.end(), [&](uint8_t &v) { v += j; }); + std::for_each(in.U16.begin(), in.U16.end(), [&](uint16_t &v) { v += j; }); + std::for_each(in.U32.begin(), in.U32.end(), [&](uint32_t &v) { v += j; }); + std::for_each(in.U64.begin(), in.U64.end(), [&](uint64_t &v) { v += j; }); + std::for_each(in.R32.begin(), in.R32.end(), [&](float &v) { v += j; }); + std::for_each(in.R64.begin(), in.R64.end(), [&](double &v) { v += j; }); + std::for_each(in.R128.begin(), in.R128.end(), + [&](long double &v) { v += j; }); + + std::for_each(in.CR32.begin(), in.CR32.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); + std::for_each(in.CR64.begin(), in.CR64.end(), [&](std::complex &v) { + v.real(v.real() + static_cast(j)); + v.imag(v.imag() + static_cast(j)); + }); +} + +#endif // TESTING_BACKWARD_260_SMALLTESTDATA_H_ diff --git a/testing/backward-compatibility/2.6.0/TestReadAttributes.cpp b/testing/backward-compatibility/2.6.0/TestReadAttributes.cpp new file mode 100644 index 0000000000..6cefc1475a --- /dev/null +++ b/testing/backward-compatibility/2.6.0/TestReadAttributes.cpp @@ -0,0 +1,690 @@ +/* + * Distributed under the OSI-approved Apache License, Version 2.0. See + * accompanying file Copyright.txt for details. + */ +#include +#include +#include + +#include +#include + +#include + +#include + +#include "SmallTestData260.h" + +std::string dataPath; // comes from command line +std::string engineName; // comes from command line + +class ReadAttributes : public ::testing::Test +{ +public: + ReadAttributes() = default; + + SmallTestData260 m_TestData; +}; + +// ADIOS2 write, read for single value attributes +TEST_F(ReadAttributes, SingleTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesSingleTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Single = std::string("s1_Single_") + zero; + const std::string s1_Array = std::string("s1_Array_") + zero; + const std::string i8_Single = std::string("i8_Single_") + zero; + const std::string i16_Single = std::string("i16_Single_") + zero; + const std::string i32_Single = std::string("i32_Single_") + zero; + const std::string i64_Single = std::string("i64_Single_") + zero; + const std::string u8_Single = std::string("u8_Single_") + zero; + const std::string u16_Single = std::string("u16_Single_") + zero; + const std::string u32_Single = std::string("u32_Single_") + zero; + const std::string u64_Single = std::string("u64_Single_") + zero; + const std::string r32_Single = std::string("r32_Single_") + zero; + const std::string r64_Single = std::string("r64_Single_") + zero; + const std::string r128_Single = std::string("r128_Single_") + zero; + const std::string cr32_Single = std::string("cr32_Single_") + zero; + const std::string cr64_Single = std::string("cr64_Single_") + zero; + + // When collective meta generation has landed, use + // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); + // Generate current testing data + SmallTestData260 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto attr_s1 = ioRead.InquireAttribute(s1_Single); + auto attr_s1a = ioRead.InquireAttribute(s1_Array); + auto attr_i8 = ioRead.InquireAttribute(i8_Single); + auto attr_i16 = ioRead.InquireAttribute(i16_Single); + auto attr_i32 = ioRead.InquireAttribute(i32_Single); + auto attr_i64 = ioRead.InquireAttribute(i64_Single); + + auto attr_u8 = ioRead.InquireAttribute(u8_Single); + auto attr_u16 = ioRead.InquireAttribute(u16_Single); + auto attr_u32 = ioRead.InquireAttribute(u32_Single); + auto attr_u64 = ioRead.InquireAttribute(u64_Single); + + auto attr_r32 = ioRead.InquireAttribute(r32_Single); + auto attr_r64 = ioRead.InquireAttribute(r64_Single); + auto attr_r128 = ioRead.InquireAttribute(r128_Single); + + auto attr_cr32 = + ioRead.InquireAttribute>(cr32_Single); + auto attr_cr64 = + ioRead.InquireAttribute>(cr64_Single); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), s1_Single); + ASSERT_EQ(attr_s1.Data().size() == 1, true); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + ASSERT_EQ(attr_s1.Data().front(), currentTestData.S1); + + EXPECT_TRUE(attr_s1a); + ASSERT_EQ(attr_s1a.Name(), s1_Array); + ASSERT_EQ(attr_s1a.Data().size() == 1, true); + ASSERT_EQ(attr_s1a.Type(), adios2::GetType()); + ASSERT_EQ(attr_s1a.Data()[0], currentTestData.S1array[0]); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), i8_Single); + ASSERT_EQ(attr_i8.Data().size() == 1, true); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + ASSERT_EQ(attr_i8.Data().front(), currentTestData.I8.front()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), i16_Single); + ASSERT_EQ(attr_i16.Data().size() == 1, true); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + ASSERT_EQ(attr_i16.Data().front(), currentTestData.I16.front()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), i32_Single); + ASSERT_EQ(attr_i32.Data().size() == 1, true); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + ASSERT_EQ(attr_i32.Data().front(), currentTestData.I32.front()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), i64_Single); + ASSERT_EQ(attr_i64.Data().size() == 1, true); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + ASSERT_EQ(attr_i64.Data().front(), currentTestData.I64.front()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), u8_Single); + ASSERT_EQ(attr_u8.Data().size() == 1, true); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + ASSERT_EQ(attr_u8.Data().front(), currentTestData.U8.front()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), u16_Single); + ASSERT_EQ(attr_u16.Data().size() == 1, true); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + ASSERT_EQ(attr_u16.Data().front(), currentTestData.U16.front()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), u32_Single); + ASSERT_EQ(attr_u32.Data().size() == 1, true); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + ASSERT_EQ(attr_u32.Data().front(), currentTestData.U32.front()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), u64_Single); + ASSERT_EQ(attr_u64.Data().size() == 1, true); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + ASSERT_EQ(attr_u64.Data().front(), currentTestData.U64.front()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), r32_Single); + ASSERT_EQ(attr_r32.Data().size() == 1, true); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + ASSERT_EQ(attr_r32.Data().front(), currentTestData.R32.front()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), r64_Single); + ASSERT_EQ(attr_r64.Data().size() == 1, true); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + ASSERT_EQ(attr_r64.Data().front(), currentTestData.R64.front()); + + EXPECT_TRUE(attr_r128); + ASSERT_EQ(attr_r128.Name(), r128_Single); + ASSERT_EQ(attr_r128.Data().size() == 1, true); + ASSERT_EQ(attr_r128.Type(), adios2::GetType()); + ASSERT_EQ(attr_r128.Data().front(), currentTestData.R128.front()); + + EXPECT_TRUE(attr_cr32); + ASSERT_EQ(attr_cr32.Name(), cr32_Single); + ASSERT_EQ(attr_cr32.Data().size() == 1, true); + ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); + ASSERT_EQ(attr_cr32.Data().front(), currentTestData.CR32.front()); + + EXPECT_TRUE(attr_cr64); + ASSERT_EQ(attr_cr64.Name(), cr64_Single); + ASSERT_EQ(attr_cr64.Data().size() == 1, true); + ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); + ASSERT_EQ(attr_cr64.Data().front(), currentTestData.CR64.front()); + + bpRead.Close(); + } +} + +// ADIOS2 write read for array attributes +TEST_F(ReadAttributes, ArrayTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesArrayTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Array = std::string("s1_Array_") + zero; + const std::string i8_Array = std::string("i8_Array_") + zero; + const std::string i16_Array = std::string("i16_Array_") + zero; + const std::string i32_Array = std::string("i32_Array_") + zero; + const std::string i64_Array = std::string("i64_Array_") + zero; + const std::string u8_Array = std::string("u8_Array_") + zero; + const std::string u16_Array = std::string("u16_Array_") + zero; + const std::string u32_Array = std::string("u32_Array_") + zero; + const std::string u64_Array = std::string("u64_Array_") + zero; + const std::string r32_Array = std::string("r32_Array_") + zero; + const std::string r64_Array = std::string("r64_Array_") + zero; + const std::string r128_Array = std::string("r128_Array_") + zero; + const std::string cr32_Array = std::string("cr32_Array_") + zero; + const std::string cr64_Array = std::string("cr64_Array_") + zero; + + // When collective meta generation has landed, use + // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); + // Generate current testing data + SmallTestData260 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto attr_s1 = ioRead.InquireAttribute(s1_Array); + + auto attr_i8 = ioRead.InquireAttribute(i8_Array); + auto attr_i16 = ioRead.InquireAttribute(i16_Array); + auto attr_i32 = ioRead.InquireAttribute(i32_Array); + auto attr_i64 = ioRead.InquireAttribute(i64_Array); + + auto attr_u8 = ioRead.InquireAttribute(u8_Array); + auto attr_u16 = ioRead.InquireAttribute(u16_Array); + auto attr_u32 = ioRead.InquireAttribute(u32_Array); + auto attr_u64 = ioRead.InquireAttribute(u64_Array); + + auto attr_r32 = ioRead.InquireAttribute(r32_Array); + auto attr_r64 = ioRead.InquireAttribute(r64_Array); + auto attr_r128 = ioRead.InquireAttribute(r128_Array); + + auto attr_cr32 = + ioRead.InquireAttribute>(cr32_Array); + auto attr_cr64 = + ioRead.InquireAttribute>(cr64_Array); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), s1_Array); + ASSERT_EQ(attr_s1.Data().size() == 1, false); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), i8_Array); + ASSERT_EQ(attr_i8.Data().size() == 1, false); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), i16_Array); + ASSERT_EQ(attr_i16.Data().size() == 1, false); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), i32_Array); + ASSERT_EQ(attr_i32.Data().size() == 1, false); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), i64_Array); + ASSERT_EQ(attr_i64.Data().size() == 1, false); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), u8_Array); + ASSERT_EQ(attr_u8.Data().size() == 1, false); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), u16_Array); + ASSERT_EQ(attr_u16.Data().size() == 1, false); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), u32_Array); + ASSERT_EQ(attr_u32.Data().size() == 1, false); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), u64_Array); + ASSERT_EQ(attr_u64.Data().size() == 1, false); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), r32_Array); + ASSERT_EQ(attr_r32.Data().size() == 1, false); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), r64_Array); + ASSERT_EQ(attr_r64.Data().size() == 1, false); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r128); + ASSERT_EQ(attr_r128.Name(), r128_Array); + ASSERT_EQ(attr_r128.Data().size() == 1, false); + ASSERT_EQ(attr_r128.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_cr32); + ASSERT_EQ(attr_cr32.Name(), cr32_Array); + ASSERT_EQ(attr_cr32.Data().size() == 1, false); + ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); + + EXPECT_TRUE(attr_cr64); + ASSERT_EQ(attr_cr64.Name(), cr64_Array); + ASSERT_EQ(attr_cr64.Data().size() == 1, false); + ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); + + auto I8 = attr_i8.Data(); + auto I16 = attr_i16.Data(); + auto I32 = attr_i32.Data(); + auto I64 = attr_i64.Data(); + + auto U8 = attr_u8.Data(); + auto U16 = attr_u16.Data(); + auto U32 = attr_u32.Data(); + auto U64 = attr_u64.Data(); + + const size_t Nx = 10; + for (size_t i = 0; i < Nx; ++i) + { + EXPECT_EQ(I8[i], currentTestData.I8[i]); + EXPECT_EQ(I16[i], currentTestData.I16[i]); + EXPECT_EQ(I32[i], currentTestData.I32[i]); + EXPECT_EQ(I64[i], currentTestData.I64[i]); + + EXPECT_EQ(U8[i], currentTestData.U8[i]); + EXPECT_EQ(U16[i], currentTestData.U16[i]); + EXPECT_EQ(U32[i], currentTestData.U32[i]); + EXPECT_EQ(U64[i], currentTestData.U64[i]); + } + + bpRead.Close(); + } +} + +TEST_F(ReadAttributes, OfVariableSingleTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesOfVariableSingleTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Single = std::string("s1_Single_") + zero; + const std::string i8_Single = std::string("i8_Single_") + zero; + const std::string i16_Single = std::string("i16_Single_") + zero; + const std::string i32_Single = std::string("i32_Single_") + zero; + const std::string i64_Single = std::string("i64_Single_") + zero; + const std::string u8_Single = std::string("u8_Single_") + zero; + const std::string u16_Single = std::string("u16_Single_") + zero; + const std::string u32_Single = std::string("u32_Single_") + zero; + const std::string u64_Single = std::string("u64_Single_") + zero; + const std::string r32_Single = std::string("r32_Single_") + zero; + const std::string r64_Single = std::string("r64_Single_") + zero; + const std::string r128_Single = std::string("r128_Single_") + zero; + const std::string cr32_Single = std::string("cr32_Single_") + zero; + const std::string cr64_Single = std::string("cr64_Single_") + zero; + + // When collective meta generation has landed, use + // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); + // Generate current testing data + SmallTestData260 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + const std::string separator = "/"; + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto var = ioRead.InquireVariable("myVar"); + + auto attr_s1 = + ioRead.InquireAttribute(s1_Single, var.Name()); + auto attr_i8 = ioRead.InquireAttribute(i8_Single, var.Name()); + auto attr_i16 = + ioRead.InquireAttribute(i16_Single, var.Name()); + auto attr_i32 = + ioRead.InquireAttribute(i32_Single, var.Name()); + auto attr_i64 = + ioRead.InquireAttribute(i64_Single, var.Name()); + + auto attr_u8 = ioRead.InquireAttribute(u8_Single, var.Name()); + auto attr_u16 = + ioRead.InquireAttribute(u16_Single, var.Name()); + auto attr_u32 = + ioRead.InquireAttribute(u32_Single, var.Name()); + auto attr_u64 = + ioRead.InquireAttribute(u64_Single, var.Name()); + + auto attr_r32 = ioRead.InquireAttribute(r32_Single, var.Name()); + auto attr_r64 = ioRead.InquireAttribute(r64_Single, var.Name()); + auto attr_r128 = + ioRead.InquireAttribute(r128_Single, var.Name()); + + auto attr_cr32 = ioRead.InquireAttribute>( + cr32_Single, var.Name()); + auto attr_cr64 = ioRead.InquireAttribute>( + cr64_Single, var.Name()); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), var.Name() + separator + s1_Single); + ASSERT_EQ(attr_s1.Data().size() == 1, true); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + ASSERT_EQ(attr_s1.Data().front(), currentTestData.S1); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), var.Name() + separator + i8_Single); + ASSERT_EQ(attr_i8.Data().size() == 1, true); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + ASSERT_EQ(attr_i8.Data().front(), currentTestData.I8.front()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), var.Name() + separator + i16_Single); + ASSERT_EQ(attr_i16.Data().size() == 1, true); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + ASSERT_EQ(attr_i16.Data().front(), currentTestData.I16.front()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), var.Name() + separator + i32_Single); + ASSERT_EQ(attr_i32.Data().size() == 1, true); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + ASSERT_EQ(attr_i32.Data().front(), currentTestData.I32.front()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), var.Name() + separator + i64_Single); + ASSERT_EQ(attr_i64.Data().size() == 1, true); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + ASSERT_EQ(attr_i64.Data().front(), currentTestData.I64.front()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), var.Name() + separator + u8_Single); + ASSERT_EQ(attr_u8.Data().size() == 1, true); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + ASSERT_EQ(attr_u8.Data().front(), currentTestData.U8.front()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), var.Name() + separator + u16_Single); + ASSERT_EQ(attr_u16.Data().size() == 1, true); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + ASSERT_EQ(attr_u16.Data().front(), currentTestData.U16.front()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), var.Name() + separator + u32_Single); + ASSERT_EQ(attr_u32.Data().size() == 1, true); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + ASSERT_EQ(attr_u32.Data().front(), currentTestData.U32.front()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), var.Name() + separator + u64_Single); + ASSERT_EQ(attr_u64.Data().size() == 1, true); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + ASSERT_EQ(attr_u64.Data().front(), currentTestData.U64.front()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), var.Name() + separator + r32_Single); + ASSERT_EQ(attr_r32.Data().size() == 1, true); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + ASSERT_EQ(attr_r32.Data().front(), currentTestData.R32.front()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), var.Name() + separator + r64_Single); + ASSERT_EQ(attr_r64.Data().size() == 1, true); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + ASSERT_EQ(attr_r64.Data().front(), currentTestData.R64.front()); + + EXPECT_TRUE(attr_r128); + ASSERT_EQ(attr_r128.Name(), var.Name() + separator + r128_Single); + ASSERT_EQ(attr_r128.Data().size() == 1, true); + ASSERT_EQ(attr_r128.Type(), adios2::GetType()); + ASSERT_EQ(attr_r128.Data().front(), currentTestData.R128.front()); + + EXPECT_TRUE(attr_cr32); + ASSERT_EQ(attr_cr32.Name(), var.Name() + separator + cr32_Single); + ASSERT_EQ(attr_cr32.Data().size() == 1, true); + ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); + ASSERT_EQ(attr_cr32.Data().front(), currentTestData.CR32.front()); + + EXPECT_TRUE(attr_cr64); + ASSERT_EQ(attr_cr64.Name(), var.Name() + separator + cr64_Single); + ASSERT_EQ(attr_cr64.Data().size() == 1, true); + ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); + ASSERT_EQ(attr_cr64.Data().front(), currentTestData.CR64.front()); + + bpRead.Close(); + } +} + +// ADIOS2 write read for array attributes +TEST_F(ReadAttributes, OfVariableArrayTypes) +{ + const std::string fName = dataPath + + std::string(&adios2::PathSeparator, 1) + + engineName + "AttributesOfVariableArrayTypes.bp"; + + const std::string zero = std::to_string(0); + const std::string s1_Array = std::string("s1_Array_") + zero; + const std::string i8_Array = std::string("i8_Array_") + zero; + const std::string i16_Array = std::string("i16_Array_") + zero; + const std::string i32_Array = std::string("i32_Array_") + zero; + const std::string i64_Array = std::string("i64_Array_") + zero; + const std::string u8_Array = std::string("u8_Array_") + zero; + const std::string u16_Array = std::string("u16_Array_") + zero; + const std::string u32_Array = std::string("u32_Array_") + zero; + const std::string u64_Array = std::string("u64_Array_") + zero; + const std::string r32_Array = std::string("r32_Array_") + zero; + const std::string r64_Array = std::string("r64_Array_") + zero; + const std::string r128_Array = std::string("r128_Array_") + zero; + const std::string cr32_Array = std::string("cr32_Array_") + zero; + const std::string cr64_Array = std::string("cr64_Array_") + zero; + + const std::string separator = "/"; + + SmallTestData260 currentTestData = + generateNewSmallTestData(m_TestData, 0, 0, 0); + + adios2::ADIOS adios; + + { + adios2::IO ioRead = adios.DeclareIO("ioRead"); + if (!engineName.empty()) + { + ioRead.SetEngine(engineName); + } + + adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); + + auto var = ioRead.InquireVariable("myVar"); + + auto attr_s1 = + ioRead.InquireAttribute(s1_Array, var.Name()); + + auto attr_i8 = ioRead.InquireAttribute(i8_Array, var.Name()); + auto attr_i16 = ioRead.InquireAttribute(i16_Array, var.Name()); + auto attr_i32 = ioRead.InquireAttribute(i32_Array, var.Name()); + auto attr_i64 = ioRead.InquireAttribute(i64_Array, var.Name()); + + auto attr_u8 = ioRead.InquireAttribute(u8_Array, var.Name()); + auto attr_u16 = + ioRead.InquireAttribute(u16_Array, var.Name()); + auto attr_u32 = + ioRead.InquireAttribute(u32_Array, var.Name()); + auto attr_u64 = + ioRead.InquireAttribute(u64_Array, var.Name()); + + auto attr_r32 = ioRead.InquireAttribute(r32_Array, var.Name()); + auto attr_r64 = ioRead.InquireAttribute(r64_Array, var.Name()); + auto attr_r128 = + ioRead.InquireAttribute(r128_Array, var.Name()); + + auto attr_cr32 = ioRead.InquireAttribute>( + cr32_Array, var.Name()); + auto attr_cr64 = ioRead.InquireAttribute>( + cr64_Array, var.Name()); + + EXPECT_TRUE(attr_s1); + ASSERT_EQ(attr_s1.Name(), var.Name() + separator + s1_Array); + ASSERT_EQ(attr_s1.Data().size() == 1, false); + ASSERT_EQ(attr_s1.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i8); + ASSERT_EQ(attr_i8.Name(), var.Name() + separator + i8_Array); + ASSERT_EQ(attr_i8.Data().size() == 1, false); + ASSERT_EQ(attr_i8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i16); + ASSERT_EQ(attr_i16.Name(), var.Name() + separator + i16_Array); + ASSERT_EQ(attr_i16.Data().size() == 1, false); + ASSERT_EQ(attr_i16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i32); + ASSERT_EQ(attr_i32.Name(), var.Name() + separator + i32_Array); + ASSERT_EQ(attr_i32.Data().size() == 1, false); + ASSERT_EQ(attr_i32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_i64); + ASSERT_EQ(attr_i64.Name(), var.Name() + separator + i64_Array); + ASSERT_EQ(attr_i64.Data().size() == 1, false); + ASSERT_EQ(attr_i64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u8); + ASSERT_EQ(attr_u8.Name(), var.Name() + separator + u8_Array); + ASSERT_EQ(attr_u8.Data().size() == 1, false); + ASSERT_EQ(attr_u8.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u16); + ASSERT_EQ(attr_u16.Name(), var.Name() + separator + u16_Array); + ASSERT_EQ(attr_u16.Data().size() == 1, false); + ASSERT_EQ(attr_u16.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u32); + ASSERT_EQ(attr_u32.Name(), var.Name() + separator + u32_Array); + ASSERT_EQ(attr_u32.Data().size() == 1, false); + ASSERT_EQ(attr_u32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_u64); + ASSERT_EQ(attr_u64.Name(), var.Name() + separator + u64_Array); + ASSERT_EQ(attr_u64.Data().size() == 1, false); + ASSERT_EQ(attr_u64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r32); + ASSERT_EQ(attr_r32.Name(), var.Name() + separator + r32_Array); + ASSERT_EQ(attr_r32.Data().size() == 1, false); + ASSERT_EQ(attr_r32.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r64); + ASSERT_EQ(attr_r64.Name(), var.Name() + separator + r64_Array); + ASSERT_EQ(attr_r64.Data().size() == 1, false); + ASSERT_EQ(attr_r64.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_r128); + ASSERT_EQ(attr_r128.Name(), var.Name() + separator + r128_Array); + ASSERT_EQ(attr_r128.Data().size() == 1, false); + ASSERT_EQ(attr_r128.Type(), adios2::GetType()); + + EXPECT_TRUE(attr_cr32); + ASSERT_EQ(attr_cr32.Name(), var.Name() + separator + cr32_Array); + ASSERT_EQ(attr_cr32.Data().size() == 1, false); + ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); + + EXPECT_TRUE(attr_cr64); + ASSERT_EQ(attr_cr64.Name(), var.Name() + separator + cr64_Array); + ASSERT_EQ(attr_cr64.Data().size() == 1, false); + ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); + + auto I8 = attr_i8.Data(); + auto I16 = attr_i16.Data(); + auto I32 = attr_i32.Data(); + auto I64 = attr_i64.Data(); + + auto U8 = attr_u8.Data(); + auto U16 = attr_u16.Data(); + auto U32 = attr_u32.Data(); + auto U64 = attr_u64.Data(); + + const size_t Nx = 10; + for (size_t i = 0; i < Nx; ++i) + { + EXPECT_EQ(I8[i], currentTestData.I8[i]); + EXPECT_EQ(I16[i], currentTestData.I16[i]); + EXPECT_EQ(I32[i], currentTestData.I32[i]); + EXPECT_EQ(I64[i], currentTestData.I64[i]); + + EXPECT_EQ(U8[i], currentTestData.U8[i]); + EXPECT_EQ(U16[i], currentTestData.U16[i]); + EXPECT_EQ(U32[i], currentTestData.U32[i]); + EXPECT_EQ(U64[i], currentTestData.U64[i]); + } + + bpRead.Close(); + } +} + +//****************************************************************************** +// main +//****************************************************************************** + +int main(int argc, char **argv) +{ + int result; + ::testing::InitGoogleTest(&argc, argv); + + if (argc < 3) + { + throw std::runtime_error( + "Test needs 2 arguments: path-to-data engineName"); + } + + dataPath = std::string(argv[1]); + engineName = std::string(argv[2]); + + result = RUN_ALL_TESTS(); + + return result; +} diff --git a/testing/backward-compatibility/CMakeLists.txt b/testing/backward-compatibility/CMakeLists.txt new file mode 100644 index 0000000000..b4d2188df7 --- /dev/null +++ b/testing/backward-compatibility/CMakeLists.txt @@ -0,0 +1,7 @@ +#------------------------------------------------------------------------------# +# Distributed under the OSI-approved Apache License, Version 2.0. See +# accompanying file Copyright.txt for details. +#------------------------------------------------------------------------------# + +add_subdirectory(2.5.0) +add_subdirectory(2.6.0) From cdaab2cf7bc36b92fa16fc9247c8624c2d9eb5f8 Mon Sep 17 00:00:00 2001 From: Norbert Podhorszki Date: Thu, 14 May 2020 14:26:43 -0400 Subject: [PATCH 2/3] Added the data files for backward compatibility tests --- .../2.5.0/data/BP3AttributesArrayTypes.bp | Bin 0 -> 1616 bytes .../BP3AttributesArrayTypes.bp.0 | Bin 0 -> 2433 bytes .../profiling.json | 3 +++ .../data/BP3AttributesOfVariableArrayTypes.bp | Bin 0 -> 1752 bytes .../BP3AttributesOfVariableArrayTypes.bp.0 | Bin 0 -> 2681 bytes .../profiling.json | 3 +++ .../data/BP3AttributesOfVariableSingleTypes.bp | Bin 0 -> 1396 bytes .../BP3AttributesOfVariableSingleTypes.bp.0 | Bin 0 -> 1958 bytes .../profiling.json | 3 +++ .../2.5.0/data/BP3AttributesSingleTypes.bp | Bin 0 -> 1360 bytes .../BP3AttributesSingleTypes.bp.0 | Bin 0 -> 1846 bytes .../profiling.json | 3 +++ .../2.5.0/data/BP3Multiblock2D4x2.bp | Bin 0 -> 28992 bytes .../BP3Multiblock2D4x2.bp.0 | Bin 0 -> 19965 bytes .../BP3Multiblock2D4x2.bp.1 | Bin 0 -> 19965 bytes .../BP3Multiblock2D4x2.bp.2 | Bin 0 -> 19965 bytes .../BP3Multiblock2D4x2.bp.3 | Bin 0 -> 19965 bytes .../BP3Multiblock2D4x2.bp.dir/profiling.json | 6 ++++++ .../data/BP4AttributesArrayTypes.bp/data.0 | Bin 0 -> 980 bytes .../2.5.0/data/BP4AttributesArrayTypes.bp/md.0 | Bin 0 -> 1624 bytes .../data/BP4AttributesArrayTypes.bp/md.idx | Bin 0 -> 128 bytes .../BP4AttributesArrayTypes.bp/profiling.json | 3 +++ .../BP4AttributesOfVariableArrayTypes.bp/data.0 | Bin 0 -> 1090 bytes .../BP4AttributesOfVariableArrayTypes.bp/md.0 | Bin 0 -> 1760 bytes .../BP4AttributesOfVariableArrayTypes.bp/md.idx | Bin 0 -> 128 bytes .../profiling.json | 3 +++ .../data.0 | Bin 0 -> 723 bytes .../BP4AttributesOfVariableSingleTypes.bp/md.0 | Bin 0 -> 1404 bytes .../md.idx | Bin 0 -> 128 bytes .../profiling.json | 3 +++ .../data/BP4AttributesSingleTypes.bp/data.0 | Bin 0 -> 657 bytes .../2.5.0/data/BP4AttributesSingleTypes.bp/md.0 | Bin 0 -> 1368 bytes .../data/BP4AttributesSingleTypes.bp/md.idx | Bin 0 -> 128 bytes .../BP4AttributesSingleTypes.bp/profiling.json | 3 +++ .../2.5.0/data/BP4Multiblock2D4x2.bp/data.0 | Bin 0 -> 9475 bytes .../2.5.0/data/BP4Multiblock2D4x2.bp/data.1 | Bin 0 -> 9475 bytes .../2.5.0/data/BP4Multiblock2D4x2.bp/data.2 | Bin 0 -> 9475 bytes .../2.5.0/data/BP4Multiblock2D4x2.bp/data.3 | Bin 0 -> 9475 bytes .../2.5.0/data/BP4Multiblock2D4x2.bp/md.0 | Bin 0 -> 29992 bytes .../2.5.0/data/BP4Multiblock2D4x2.bp/md.idx | Bin 0 -> 256 bytes .../data/BP4Multiblock2D4x2.bp/profiling.json | 6 ++++++ .../2.6.0/data/BP3AttributesArrayTypes.bp | Bin 0 -> 2307 bytes .../BP3AttributesArrayTypes.bp.0 | Bin 0 -> 3617 bytes .../profiling.json | 3 +++ .../data/BP3AttributesOfVariableArrayTypes.bp | Bin 0 -> 2461 bytes .../BP3AttributesOfVariableArrayTypes.bp.0 | Bin 0 -> 3901 bytes .../profiling.json | 3 +++ .../data/BP3AttributesOfVariableSingleTypes.bp | Bin 0 -> 1748 bytes .../BP3AttributesOfVariableSingleTypes.bp.0 | Bin 0 -> 2464 bytes .../profiling.json | 3 +++ .../2.6.0/data/BP3AttributesSingleTypes.bp | Bin 0 -> 1694 bytes .../BP3AttributesSingleTypes.bp.0 | Bin 0 -> 2316 bytes .../profiling.json | 3 +++ .../data/BP4AttributesArrayTypes.bp/data.0 | Bin 0 -> 1494 bytes .../2.6.0/data/BP4AttributesArrayTypes.bp/md.0 | Bin 0 -> 2315 bytes .../data/BP4AttributesArrayTypes.bp/md.idx | Bin 0 -> 128 bytes .../BP4AttributesArrayTypes.bp/profiling.json | 3 +++ .../BP4AttributesOfVariableArrayTypes.bp/data.0 | Bin 0 -> 1622 bytes .../BP4AttributesOfVariableArrayTypes.bp/md.0 | Bin 0 -> 2469 bytes .../BP4AttributesOfVariableArrayTypes.bp/md.idx | Bin 0 -> 128 bytes .../profiling.json | 3 +++ .../data.0 | Bin 0 -> 898 bytes .../BP4AttributesOfVariableSingleTypes.bp/md.0 | Bin 0 -> 1756 bytes .../md.idx | Bin 0 -> 128 bytes .../profiling.json | 3 +++ .../WriteAttributeReadSingleTypes.bp/data.0 | Bin 0 -> 814 bytes .../WriteAttributeReadSingleTypes.bp/md.0 | Bin 0 -> 1702 bytes .../WriteAttributeReadSingleTypes.bp/md.idx | Bin 0 -> 128 bytes .../profiling.json | 3 +++ .../data/BP4AttributesSingleTypes.bp/data.0 | Bin 0 -> 814 bytes .../2.6.0/data/BP4AttributesSingleTypes.bp/md.0 | Bin 0 -> 1702 bytes .../data/BP4AttributesSingleTypes.bp/md.idx | Bin 0 -> 128 bytes .../BP4AttributesSingleTypes.bp/profiling.json | 3 +++ 73 files changed, 63 insertions(+) create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesArrayTypes.bp create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesArrayTypes.bp.dir/BP3AttributesArrayTypes.bp.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesArrayTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableArrayTypes.bp create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/BP3AttributesOfVariableArrayTypes.bp.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableSingleTypes.bp create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/BP3AttributesOfVariableSingleTypes.bp.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp create mode 100644 testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.1 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.2 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.3 create mode 100644 testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.1 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.2 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.3 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/md.0 create mode 100644 testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/md.idx create mode 100644 testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/BP3AttributesArrayTypes.bp.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/BP3AttributesOfVariableArrayTypes.bp.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableSingleTypes.bp create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/BP3AttributesOfVariableSingleTypes.bp.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/profiling.json create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/data.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.0 create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.idx create mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json diff --git a/testing/backward-compatibility/2.5.0/data/BP3AttributesArrayTypes.bp b/testing/backward-compatibility/2.5.0/data/BP3AttributesArrayTypes.bp new file mode 100644 index 0000000000000000000000000000000000000000..6af594a1b806ad0828ea15b1da731ecec0393cf1 GIT binary patch literal 1616 zcmb7EziSjx5T1Q+_ubyEjh%&vB1jNDa(kDH*m!G1h#(0lw&99B3}{X+7sYO3Vl?7E zkO($fS_)QHwz2VF(8ktI#64&B&Hg|wZr}0lo0+$7=9_u*o&$EA5edk6vCG4h`|TPBC|A zzM=Vv=GXq=ffFAd9H)6E)^BqjA4RxFXxl7+&31Ww#|j!Z{-Gi5Djq7JVYHEGm^>PJ zFu6NU68%Hmm_T}+^S13A!g@9DymP_S$lIYy$v+M0)Ft!?4Pk@OCu|Z1ygn!4O)LUG zBKA5FkLn}h6p7b)M3hoGb(NPI)kuBSOarCw=P~z0;2yPCmtt0X)GcDx=uzIoj`PW< zl1`^o2W#W&&pMwjf5TO0owH`0nXt}}2_!u#5&wZi zu+h>|u(Gm^jsJo+wsxXk{QYL$Zgw|AAk%PZ3}lya(; z^V9tP-1SreAIS1M^1Gt?t>#>(-=BXlS5>NKX7OXe(RkbAgy2cRQ-YK2hNG%rO|UN5 z5Nx(DK_~rzu|_>%tT2Jek2}xLEi4!)y^IZO7_TrsV0>QR3^^mbX*vO(! z84*(kC8>yVE}|d^^dKJ;1|}#DN2# zx=)!NP^MzaOb=zIk9??Blj*B-?%|`g^~W1eo^C#iF2)hek`5zD{^s;3rmqfXV&eVz zM5jPq4C>8Vt4He11^g>fatHt&UDje5#FCnok|gc|+dua7<>&bhaZJnO~hJ=5QtvA-ka z4SOsO1VA}obCDj#Y?U&v3VnyP^wrD+F!x0{MtI6t?VZHt!$uL#ZxR@;qC<^*ekb-{*Uv#t9Q z#_Wmmn2_%Va8g*W-N;E(2CbM|gcFhu)HwWOe#gHm`iH!4#-eP~F;RA;OVU=YmB(xN zc*|47LxmbcjL={SV=Q9@^$C?l0W&KKm&d9;ajS`ynJqJAmdudZF*77qNQ_Xw zb8J2p*jUxENs4SDaRbwvoXxkdZ*L9;hFW=%+H{xJds?4q9kmZfLFaHZL+gA;f49j3 z^HUUVU7JzYx?6?Tt$Q+4wC?j4yL&HRy?(QQpr1)m%}5mbg#cSP7jCnbSK_!2cbom# z%DC}(OIy&^KcZn{y{}>TbR&Y{qom*0A6(QgqHqJ)HgPFmE2cdE&6*EAaT*X7+4~;~V%SOf$YpDV>HYN{uR|u_~t(r59Y}hobQK zQd5%n$i?vuedH;}mydUgFPVgQY;zZ|&2?d$d9kglk|wh(N@rnd cU@>{1w`uexn7k$bPqx6zxF*!*_ho1OXX?9AJAl(5p&;$~xIb!HA) zAPRwd3>bA&k!J*?#QpW#^_CE_Nt!%DKOvrnB1gX%cr?Y%S7;6ybgM43D&>V*t5siL z7#E_c=jqj=m9tfcBaEYrV~qJ~$;vomfw9O~Vk}p$lTVP3LY9iLkf{-R_37h_D~pSo zTu;-o4H~a$yr;2S-RT6ioz5VQ;TqV>n5%YzeFf|}TLxw%hWBl3PDoGjbIq7$%rIsd zkvI|q_VD4^w-fBkU{4_t4xtQ%K?p?#vk3g2pk<{nDja9_&d4vKRi; zKQiBQ7s(D(qp*ca%(yf}uL2{DGNDNsZPF%VvL__LX6k|QiVM(HyajLA1qr!t9M(C zhCnir;D}x#nbIXw(h*C_dAAo5rU*4*nlM9{CCm|`6hJI;l_-VKmjcSb4{+=DdgRtU zLw=znVX#34pksH?!4x{eKuEa^Vv;f5t=^kHLoYMX zTqzgpv0xGTHMU2FH1sU7P&D8tl`Lf6bT5!vl$) z<;gZF$ZCvryaHszx=tp2v+l28)Gqc#q9wDTZ>Fu}KiBd=MCKaopxFaL3fTcY+9wKy zuLMxg+aiBEVXVspTgl^BCb>cP%BG$8H*yqUy zf4Drw7`=vzI0 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/profiling.json b/testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/profiling.json new file mode 100644 index 0000000000..b22cbb7c26 --- /dev/null +++ b/testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_07:33:59_2020", "threads": 1, "bytes": 2681, "aggregation_mus": 0, "meta_sort_merge_mus": 110, "mkdir_mus": 21, "minmax_mus": 0, "buffering_mus": 337, "memcpy_mus": 0, "transport_0": { "type": "File_POSIX", "close_mus": 1, "open_mus": 16, "write_mus": 7 },"transport_1": { "type": "File_POSIX", "close_mus": 1, "open_mus": 10, "write_mus": 5 } } +] diff --git a/testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableSingleTypes.bp b/testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableSingleTypes.bp new file mode 100644 index 0000000000000000000000000000000000000000..09cd0b72bfc648fba6f6ff146faacdd0e62fc4fe GIT binary patch literal 1396 zcmbVMy-EW?5T45>8>1j-B_fhWEhLG#{2+>Gf(WT1#MlOr7!EZ^k`q!Wv9Po80ek>E zeE@q4eFQ7P=Wu3k=5kjE7YFwC+uhmu=G)yl3p`uqehD-jwflowy-PC|D*>gXt}FiprzDIRh=nKzd?k zQuMeXJq1ZxPoig}-h}9j!8!K;Lewi41A??qR6);(g3gSs?kSQ%rtiHTh|Y^BbZ&^Q z{2w~rGg6PtqF)(wu-66)U9VsV)Fphn9rTK*?(^eeS2cO3b{PULxp=r zDk)TJ3~nh`qe|XjKOYd4@|mboB8plxrHl2FuI$(94LjW!^k_5~UbWS;Wbn>_uF)$` z5$lAmG47{OiJk)Op*OE?c(;CHKxdo6Hh!c|=xn8GKu>Uu7LutSq0(Np0o6DCascFP r-C%v&><^RF_nn&M=sLr|9CD_5n7+2Nr7ZrS*zD36XL)WUi=fmmsX%x$ literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/BP3AttributesOfVariableSingleTypes.bp.0 b/testing/backward-compatibility/2.5.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/BP3AttributesOfVariableSingleTypes.bp.0 new file mode 100644 index 0000000000000000000000000000000000000000..b2d57290765d815825ad6a9df930e4ea4b732e0a GIT binary patch literal 1958 zcmbVNL2DC16rS1Hoi+-Bo}?7Xp;oCjZ8m8TMKnc(o+8A0ts=23YLGM$dZ=s<-n{q& z`~lw7yLS(I^yo?Oclf@U_a-|?OX7pwd9(B8eeZko=IvUdoD8jcI5-&Z^f1$^sr_dR zYhG0i9x-I<<>8|zBc+ld&62b9O7T5aXXuRwpMJ8J>!d?2_+1;LPJ6Fk4EJ9Q_BNFo z+C^G>=4ACQY_UyjC$Vh@w(PcCB^~hx+h(Wgw}mxbuF%`ibDq(Q8&xCcOkbsS5D1=H zdDW6FSaA0>istUM>j{tQC3L}i(V5W2I6fIVPnj(E5IzzTAUyE4sf zd|NWMQ+AHr;&Pc?fts)aW?mI$adYVes4iK~m|Wgdn)l#9Vn6#)0nUrS#eL8I51h0~ zGhpBLEi3roi%8%mQFCeqxLag7E4$Ks6`)_N;L@R=PD?cEsNrVKbLq7C?L1QYML+{&6`QlN;k~0)ziD&@tdwRJMcxjZn7Nm+Ljo z=%kn;A*l%kv7osWsG6z2SVnimsxkhlV&NbEBGEvr?i5nc$=1v5w%eCiZ<`!eaYw}X z9FAKapVdi}NSwX0J(@0WR;o28UF){xtlK~F_?Bij zNXP>EeQrT7SU|_HM=0PWf5v!nh!5XF9c@x+8=Bc-AUl1TAWGrAp3!TFa35no@ z=!FnDlf)>90l!z#FpEbLF4`0!nxSTn8N>+9%WBhB`xQ^7j3~`8SB>WAgw2 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 b/testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 new file mode 100644 index 0000000000000000000000000000000000000000..2641d4c6835581bc15d70ae75e2f1a2591a31663 GIT binary patch literal 1846 zcmbVNJ#Q015S_cVmpHzX0tJLlfYK4gXU9Z|_%K33sRA;T$Z>HXOXxt34M`JSM9U9I z6FPnabkNX2LrIYaiC+;3=Izd&ycY@1jC9`FowxILW@pDI0U60OJxX^cTicig)RJY) zPJdg8SpOjF%P_D+H12i={ZaPpc{*4n%Jc%SJ~gs@2PkZaXzHW7K#8mT3hSXowUb$2 zotj1EF^|e3THRSh8~cL%GXDbGr0M#sIRV8XtaW1@c~*0P0PLDSj>KoL!{fKFZ*O1Y z@f?4PwA&i=#^d3>i8O+9U|wV?-QW>1HG!E)M`MW>kyy@9+`G56-B05FWQ^Hl|79Ap zwZUIRBR{af1Qz0Oi`MQRE(CGFX+w&e7U8G3=2C1tF#>{AKrV5}_PR4n{rkpBA-MGK zAY)1S1D83k$5xZOB;8}{0%ph<)q)G|nlbeSC>&0GmfiY?C_`RF*oMdpJQM`!n{2I2 z6q0)9NIr@(U^PsLx;16XHqy8Fry{jNk*lkYV^fqN+`!kF*Hah7T=#^>rd;y%MR9?uvue4GbPJLm zV=9Isdvf&z=VsBb?P$u|s^zYx|A)vmL51D`(GTrNs64bYq;2ZG`*uMzPvzz6z468r zpF}}$_SKepqG^c$=?(s=n6pFm1zTA3i5+RkBOb4b!F!^eB8Iu1DCO#n@y8^`q9BU8 x(VOJ;?xLy86GfnYI)YPCOh>+c_d)zBSy@}*|1XhbZIymW9OrGA6wAmE^#=?vyhH#1 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json b/testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json new file mode 100644 index 0000000000..f18a05f6ec --- /dev/null +++ b/testing/backward-compatibility/2.5.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_07:33:59_2020", "threads": 1, "bytes": 1846, "aggregation_mus": 0, "meta_sort_merge_mus": 383, "mkdir_mus": 52, "minmax_mus": 0, "buffering_mus": 1164, "memcpy_mus": 0, "transport_0": { "type": "File_POSIX", "close_mus": 3, "open_mus": 24, "write_mus": 14 },"transport_1": { "type": "File_POSIX", "close_mus": 2, "open_mus": 18, "write_mus": 8 } } +] diff --git a/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp b/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp new file mode 100644 index 0000000000000000000000000000000000000000..c57bd08be8082bf788324bce5dd2a617e3583165 GIT binary patch literal 28992 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 QO+%cH=WdrWO_!Vh11bWMDgXcg literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.0 b/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.0 new file mode 100644 index 0000000000000000000000000000000000000000..1c209974db8aa76a15ef48daa058aceee66a85bb GIT binary patch literal 19965 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 GF8>d|u22^M literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.1 b/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.1 new file mode 100644 index 0000000000000000000000000000000000000000..87de8a1a5e9fda16495f8b2c19661b68f0fe2fb4 GIT binary patch literal 19965 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 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.2 b/testing/backward-compatibility/2.5.0/data/BP3Multiblock2D4x2.bp.dir/BP3Multiblock2D4x2.bp.2 new file mode 100644 index 0000000000000000000000000000000000000000..ac6488e8b6cec307326202bd4d9eaa55f174ea73 GIT binary patch literal 19965 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 WF>~+UUw-)b>GPMb-*_8;$HV{S=DBzP literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/md.0 b/testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..e08835e0bc1c8675bc2c507cbd3713a790e31397 GIT binary patch literal 1624 zcmbVLPiqrV5TAW-_hqy3U~fH$){BVPkZjT*cyMDyXrWY4@FZoy4F;r@bgOug(Y9*E zFVK3^gBPz}z35Rd{R(~ry@p;CJbp7TZ|66EyVsUhZ_Z!6G50X6FVq`z zD@hvPjnf!J!i5Han_I`xk*m{!r@+9iWHVh_UFRDIn*1VS{fN}aKJ@J60|HA@gRN#~ ztveXRkJpH~mHRg<^u%YY!k@U#ECj6lOB__F(M1mpR?x>P2B?*?Pt6%oK9Fry;_S4? zoSlMmkDg4*X}zO3M=iFL4kb}EazDxf0DZBmf|3;KNTM)zL`mp{^%6k;(l}hIu@$pO zIBB?Q=>9Rk{a=B;oEPS{C_CiFhEIiQg=406!4yxyL`jlkE(lUFxDZ?fqyljANQomQ zjryZ_H;1BdgRInGP;QVZ;+UdAy^)-YES?vs#7L=ndFu`nbBx<4WsHr5jj>7xw~(tCp>(fyonR}{|Mx~8Qm=j|1Q sQ{?^a>+37Mo}uNqPJ_Qq=N+BTbiPLi`%d>@e}>N4uKppBnv+8F7c9N3rvLx| literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/md.idx b/testing/backward-compatibility/2.5.0/data/BP4AttributesArrayTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..646a964a9f9e7a24403f1dc6fd098b5541dfc99f GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFp$-S9-&$(wN$#8V=?CzuS_N%D9*Y0c&XRDd2tZ1*J zlv_#s_jNLUGRhi7a_Ot*^V8MnfT5$h4xynm1EqGE#hM)M4|j^M`KPB|o*&NAr%Eqv z*2R%&i0B&jSJQox><`b(iLIjMUOMO>C22Z4KZ44oKgQ3CeBF)<+%b5^;I6@T+{;(T zVAo(|uxGFzgLO)34#hD_>Rwc#_BhecA736W7CtB*qx=H<8}@hXU-8wYlU!YHVc$w@ zOHKoG%9iWeGy_gUMl9hmqVYn^jfiLRzQLx!z+lTD&BPK*&1u-nPP48})8{mxCM_ui zbfgl{2q*;Y1+4{b%a*tSMOin@-5lSq_@gMm(Hr-#|0nnzS{V$;-9Yjm*_v=Idq_=vEeL%TC2K%qm`26-QM3`pw1L zcke%Z{Pfw@#K_WITXWj22)<5B>A}fzp5yB5Bp0}Pk4WH+^Dn+@6*Io<0nT^PAb7o%+?q<=YqMZ%uEN@^ksZ z^is1E-U~aSU@6TNgh)B-Z}fQU4C85`#GU45XK{I*c05rej~eL^(i=t-VxCcmK-}NH z8%8&T@1m(0{FostO`gIUw_FFg&fdt-=IGbX1lubF#W(h8nW}|&AbxH?X>9o%1tj=lq z*qy_>1hc&X$J|abdxv87eP0ezelSpedXVw6gPbovIp!~{e57)XIOeEY8P%*}=3O{V zSaZwBxthiEj29SZ8S}NWkpg3pvBX$rtkmQOPEj4OLVbgKgt)BR$-Wsqf)FkfX6*^z z{7Eqwrl18t1xy1oz$`Ealn-pj3iXB+Izx06B+e#zhN;7xA$>zv^*2^%4v@DH?x}AUM;CuIPWn3ek!9xyo;nAhPsc@y zjrFD!orfEN=&VM~rkr)GH(8+pV*SZC{U zhNG)%tWcxa3|%(eWTRB$Z2sf1@i&?)r?E$(?G!iT&)7WRwLN?@3eCQKMrI@$TRw7G Hzh&hQPRh#9 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..04f50af03b46938e5afaa32a5a47d2fe592cf173 GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFoff Q`T-k+!J)P{4k`qu02H4L5&!@I literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json new file mode 100644 index 0000000000..092a51ac30 --- /dev/null +++ b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_07:05:44_2020", "threads": 1, "bytes": 1090, "aggregation_mus": 0, "meta_sort_merge_mus": 113, "mkdir_mus": 483, "minmax_mus": 0, "buffering_mus": 295, "memcpy_mus": 0, "transport_0": { "type": "File_POSIX", "close_mus": 1, "open_mus": 12, "write_mus": 6 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 10, "write_mus": 5 } } +] diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 new file mode 100644 index 0000000000000000000000000000000000000000..0715ca2c22ec88bccda8aa86d73c6e5c28ec4730 GIT binary patch literal 723 zcmZ8f!AiqG5Z$Cnw0hE`r<_E@)+TL(H;n`&NNFL`O9&;0C;<(Urb2J^F8E{mPtHp^ z%dP{P?9RM-Gy8VJD4r*S`-S`A52wSC8|6(d6!WJeAuPr5Z<{V2;%~EaR*rZo)=fOe z(GZ@2Ur$gJyDNCf(&a3==(g?G7H`{SUOx)6Vy{Jz?1)asv<7?jG@M1$OKYcH&UGD3 zR!LdCycR18Rn8$rpIbY>BY4I+sLweYJtsg8;$%C{xugTi${a6H>x>aIBpSEr(K^|8 zRoQF%XsK{px{eg z8;i9;70wB14?o{_?Wq^&pHT=?K(FG47%tyUni{8O`(7{!Wa!gk8A`oTvy;J;MIkW; Rf{Si6iG94^C%9=Evp)n!injm& literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..ed84c704f461694ff263078f714b2e86051ccd6e GIT binary patch literal 1404 zcmb7Eu}T9$5S_~=Yoe8@L?ooq&X`4R zU}YidC-@0|fR#IYGwYp#YV}iGv7mq+6~xLAuW1BOr4b+jC;i=KXB}c3O-`$iNt}(K zm*yW;Ky+}bOy2q8-zC zR!rQ{KKVr8NIChOOw=pd0itbs5U?AE|bxmMj1rR!?ajt10z-024ixHSag=zK) zpmZ@!V=4+sS0q1>QKTD)G!vBx9BUGMF;S;HA1Fu~B1icQc}9oYW-8)=qRV#zC?7Ts z0L#}4%4Zw42=ZNudtWM$&jhd`QksUVYK0o&r?De7L<~fiscr~dD4L|E;)=S3fPN`c z(GEJ|%)dha_4uT|vg)2>9sC{G*@oA_nb$vaMUFGrB7jGzW11sug^n<8QgDV(0ry~h z@kP63hUidRsh&W`gtSckFgi3jGGvwqdbQcmtqgZ2iBlW HayNVfY5;w0 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..ee6f3ad25006ab7ec51781d2805e09a5d9afd365 GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFoff Qx`q|P;85Ee2NeQS01GG!tpET3 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json new file mode 100644 index 0000000000..b422d0e01e --- /dev/null +++ b/testing/backward-compatibility/2.5.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_07:05:44_2020", "threads": 1, "bytes": 723, "aggregation_mus": 0, "meta_sort_merge_mus": 133, "mkdir_mus": 350, "minmax_mus": 0, "buffering_mus": 376, "memcpy_mus": 1, "transport_0": { "type": "File_POSIX", "close_mus": 1, "open_mus": 20, "write_mus": 8 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 15, "write_mus": 6 } } +] diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/data.0 b/testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/data.0 new file mode 100644 index 0000000000000000000000000000000000000000..911d14f87458d4f920d7cb7a1065cae1e152732c GIT binary patch literal 657 zcmZ9K!AiqG5Qb;dHrgh4!BY?^B3PQV4T6Un2}lm5g?K9^eu@k0MO3LzPW1_AS__tlJo}-1)1Pha1vTYSD z;R9h|T z8D8I#9u2QeR3 z*a&lVgX3+dE FZH|kIb7cSk literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/md.0 b/testing/backward-compatibility/2.5.0/data/BP4AttributesSingleTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..2392f7a81a9f28ea7b518b311a7597413b3cc831 GIT binary patch literal 1368 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 N`s%fW-~=X!e*n5wc3S`d literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.2 b/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.2 new file mode 100644 index 0000000000000000000000000000000000000000..38d64e96693c28b55e6ebcfcb4c6f3a4dd171a1e GIT binary patch literal 9475 zcmdT{OK%)S5bl|MKfEt49Aj~d!16w^NrHBf1+pxZAP|?x(preMag%rBnH^ReIn%uoBeiR~rq)%}Q}fkVqn+K`-+uDNoohdLHu@Wz z*LDsb9;n#W>2E5PjVThhckg_)d!uTVM|t(#j}IR1-o`di?ZB!(gkY1q-+#UH(yGnh ztoq@nZf8%GkHUdE3i-*AIE*y2N5!N~@BwM6ftpOd9Co|Mv@U4V-K9cj9&~<%?zmv(w zbOg9IS+?c8@GvsM4#rk)%;fx!qkrNte(SQ$@pf4DSoUrFi;cv%%f=$*$0GYf#DB== zkCMx%d+ouV3Q`<@!5)8Znh#A0WWsESjXzg~Y1z6eOp9TOHgNTTv&z`4@X>`SvZ`=a zYI>Php|Y9bhE|T1{@fPGLs{HnQ>0Cam2i8)*#b!D9pV$prpT5dCP)8mdU;71EAmHQ zCwbb(ftn4=q>;aHP+174ED<0aQ359sRw-eGaK@y=g-}CvZ);Bx_P#g%;=d6726=lN z*&y%D$J?^;aanv@h7YM}ypN1BjU<;M5w2<5GcE)WrK_NMTo{1x_RF3~1l;rNOvE1-5SMOIwl1X-HC8O{th zwCFQ7N`G$YOf_K@XGu47fSNKh%6Lfu&?s9}_#j2LT;Tv{x{#caGt`EXnI^I~55>q| zIH)YTkhGB|98sdA=)$QODMkoqY;_7RF;tHTwL2*ehf(|ZsqugO_{mdmKAycWKAt`Q zLy@Cv-s#Y{XMCAO6jNQ{jgQ?;CY((pT)_vORVB2??F1pL-DXB#dy>lgaa$qgTqAGBEjCr! ztg#Z=p76oCogk8IoU^u69pI1mm^AVi4q6E&h#Gt5)38dwGQwF)7$KZ7>2RToIGZ4H zmfaVMIm7P9a6p$+A3@FJn5hP}cul*VAl^ykrKa7wwXNYG*(cB=4m?f}^N4>1$}XQ6 z$d9{$#)cyRzO@Y1BNRt12$ZgX*86c)(KXAhE4r%JXcMn+fQq{bf?kkl&-5&c0b|JDVT78+H}oM!)%yL<5bLEjBq+* zt8+U+#Mr$zA1AL&p`E<^^%bXJ#5*R4E||(nCy0ogUy-qUn;`Cw{{BnTI;HiybOur4 z!E;_Puts=`|91xNHU4cL0zPATljW^=uSpt-@eMW>DL)o@%i{zACT}TT7}0v^MQ$gE z`m|+T)u)ZHNgGs^GzGU4gs^s-8PU-smG|SePRzMQ-i%vp8nkJ$64?s)yPY7CY@D;U zRDBs`_Y+Q?AQlruizF(DPs1u3tZXKX;(fv?yDwRGU#XT1yC0KZTuy!DS|-OrBiD-8 z^opsx)U<22Xbq>yK7k%_>V1NE56Uhz4T9!+f)D_|xeV1K6h|!xl)9ZD7Seh@uIjp_ z?H8;Yx=EXOg|C>(ONG02OL(OTt2j%#A&k<5PezGsrKH?W5EX+%W=_GKbuY?gl-*A_ wKy8Ep)P|g)Ha0+QNT4>P7~yorMy1?N5HWV|&ByCECdb#OzrEoUjKBo(FTRj^Z2$lO literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.3 b/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/data.3 new file mode 100644 index 0000000000000000000000000000000000000000..1fb6b8e620b431dd3dbe6f2ed1653c8dd5346910 GIT binary patch literal 9475 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 KT*DhuYX1*q`^CQi literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/md.idx b/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..2e196415f1ab684982bc8efdd182f991c9cb1939 GIT binary patch literal 256 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy`RfYLhZ z5QYVm-Vwex4k`tvn2=O+Q>6RJ}|oM1cmBM%NDjOAr;B literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/profiling.json b/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/profiling.json new file mode 100644 index 0000000000..ba0e8ac560 --- /dev/null +++ b/testing/backward-compatibility/2.5.0/data/BP4Multiblock2D4x2.bp/profiling.json @@ -0,0 +1,6 @@ +[ +{ "rank": 0, "start": "Thu_May_14_10:37:44_2020", "threads": 1, "bytes": 9475, "aggregation_mus": 0, "meta_sort_merge_mus": 1719, "mkdir_mus": 70, "minmax_mus": 588, "buffering_mus": 4107, "memcpy_mus": 12, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 12, "write_mus": 30 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 19, "write_mus": 42 } }, +{ "rank": 1, "start": "Thu_May_14_10:37:44_2020", "threads": 1, "bytes": 9475, "aggregation_mus": 0, "meta_sort_merge_mus": 1924, "mkdir_mus": 71, "minmax_mus": 498, "buffering_mus": 4144, "memcpy_mus": 12, "transport_0": { "type": "File_POSIX", "close_mus": 3, "open_mus": 18, "write_mus": 32 } }, +{ "rank": 2, "start": "Thu_May_14_10:37:44_2020", "threads": 1, "bytes": 9475, "aggregation_mus": 0, "meta_sort_merge_mus": 1419, "mkdir_mus": 70, "minmax_mus": 519, "buffering_mus": 3681, "memcpy_mus": 12, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 14, "write_mus": 29 } }, +{ "rank": 3, "start": "Thu_May_14_10:37:44_2020", "threads": 1, "bytes": 9475, "aggregation_mus": 0, "meta_sort_merge_mus": 2432, "mkdir_mus": 72, "minmax_mus": 455, "buffering_mus": 4355, "memcpy_mus": 12, "transport_0": { "type": "File_POSIX", "close_mus": 3, "open_mus": 10, "write_mus": 26 } } +] diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp b/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp new file mode 100644 index 0000000000000000000000000000000000000000..64e4ea9ee1c3cb17a204f6de9394c3ac30f282b8 GIT binary patch literal 2307 zcmb7G&1+LZ5TEz53{XGd8XcKH6G540EFha+{E<^d1=}hcqbtwHvWt4R_GZhgYZ*dKGR#t{i@UxKBUjm2LSII6Ian!; z#raljzBh5X&wM@QE1?3FQc|T=MrBo~#1|8DmyM5jp)fJWs&ULQ8*_j+;xmdbSNdj9 zK@6(eA$>R|l2Rc*yorhMbd?|jov`yr9|B1lsEgC!N8s8iFg>Sw7mg5(`JL`^L_~EQO ze&MIH?)ZgYW?fw2yyP?+1RVXPScoKWr2YN@fHN13vq&l$=UAU-eSvimNkwCXb%}ME zb%k}cCiYCeL!1r)N5c@wm23u8n{NZR^a&h1Lm(%BE4-C}O`s+~6PO9e3PG&I38sP^ zVWWvbH0(o|Pr!yB6Fb280BQK$;6UzY{)S@T1Uk;7yHD4kV7r6mQjE{M{oWh2gFM^( z_$VFf9Rd~?ngZGn7E{o^*J?J!Fz=O@*`Np3{LR69@_~IDuz_281OB($ddPD65zy%d zs8gsV>NM&M>MZJz*6)}+me`;!s;|X7l3moZc?{A;ecuow zxRyQGeUa^zqC$pC!b(QKEZ%|@lrD% z^a0#e~H_RdzH4 literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/BP3AttributesArrayTypes.bp.0 b/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/BP3AttributesArrayTypes.bp.0 new file mode 100644 index 0000000000000000000000000000000000000000..13ef60b95c3ff11190beea0a7536f634e0f556d7 GIT binary patch literal 3617 zcmd5;ON(4Z6t2G2eY@v&D~5Bk+E`cPelMqdd;*Ir77h#? zJ}CHA!LJEk9CR(T1h)lu1a}4Z21me?o`kS&Cnv0O5R03?esg$bB?i-Xao{q>_ZW9D z?hQ63rQyb87smb}HP)8NdO_npHKr*5Bll(aBWbxSQxQ5AToqgsydXFcOpSTAuGR}0 z_oy+1Q4oa~{6yvkj18C?Ff?Fhz{srPUkYxh(?z=zs+`&FY|rfXKJb2UzR3LHed7E= z-)v0U!!~%*JgD66=bYSq5sM`g8Ewj@Vq#M@HM3w6a{%k~L!!>)!xuFEkG9GW;|I0> zl0GPUDNz^OIj#+Qm>xR6IdsLeMt2zH zS+u+JVbq7wA7(+A4Ov#W?CBxU2}=V8cmo6G7L+gh0B3OfLHAEllz0VPW1Nv@1d!&% zlIGQs=4FtkKS}fQpTkJhdj9e|-2dXs%U7;myME*5SCUq0A65x3jADe=|VvKk4!FrV8m_9@ltC4 z``Db({?ZO5L4W6E{w$L#V90E+GV{eLN@Xr%b5@xMk6CJ&{?O}jK_+J@glfP8`O?}* z)p(D8kV>;cj`C0uH0!WdD8dzGE3n@0<-H*jW}#&SdHI6x-%d487H02*e!%M=((*g3hv*CKo!!q*_H{`x+h28efw zI;;i`!j`g{Dm+Iuc-A{m{iawOpOgs$$K74fC{|MYm+?z6C0zLs4tbRISC8*2^+>qK zpUZ@S<6;>BoPUb@sUC9#j+`+PmFyY`#-)hu9xct68(>_H+D_8au2$KO($e||ukRh1 zu!_3VLGRa1^_{1R?$9dgyFR(@$>b-ST*3)T*^~YY}OEMY0bM*KJ ghu%8z%B9ZY(qfCQw9r{6BDqwakmZZ2Q0)P?YQt~v~ZDMU##D+A92beS_y2z7;&-5|G9 z7Tf?47Q>qZM>;gN9S;G;|=V@n&e7O1X@yS|Em1?!|Qn9!K{WcWAYebmi>fT<_PD2KDNP_%oAo=Ak4BznB@>*mcu1EZ7vCN zYLyfWC3{kLDN!#d=Y=jp$(}y$h4`uCr;MK}JcaBh7V0c1uYonB3bgR@qOp|uAKGCo z*?0t(>Vh*o*7=d|-dnl<;NhdywRQQ1&25o_X>CgoM@Btgh!{*dgI%Pxc+$YO znJfWGYzAjPwc|z%XFtcrV>tUIHXg&-ud(qM&VJ)@xx;So?MF($2UheLs_gaod>ClG z&IxB=PJ5uyPG)V}LyEcCsuT;i<^r)WU9VQ<3o@qOlY$k#*DP{T7R}1=lV5>J?Pl$r zwHdU)gKq}@q-eGhAOnyJWD;ZwWEx}!$9I^G7uc0p+IAV$v5A(pgmXd{r483$GIK|7 zHCruUX5XP{#8{kg4rV)I%ss@I35fByh~)s0Rp&@4pPHDwI52wQ;8GzsoWuVzwiSj$ Mo&OnW9u!jk1+{)w+5i9m literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/BP3AttributesOfVariableArrayTypes.bp.0 b/testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/BP3AttributesOfVariableArrayTypes.bp.0 new file mode 100644 index 0000000000000000000000000000000000000000..2712c9358c6b67e9db6170977c2d52ae95a8a17d GIT binary patch literal 3901 zcmd5<&5ImG6tC{;uKCzijO5^eNIWPZY{s3L-AxXHGl>Lalmry~2CJ zV8!^61pk1{9&|wv&k7#B7(AKyK`yz*n`bW}IP3dWz1LmcOv3CY0Smfcy{W4Ae)X&O zUf0}6m21mJy}!7!diW@`NVOsetzsxj?ZL0qnqIhfs?J{gpg&M5UM4-BqE~`}MAhky z=UIBXZ2uZm^mr-1H@h9z zW=pcgy2v)`B0H>$oMT<&e0PN~f{h)#hvF8@v4?J<47m)k3@L|jgly6oxHR*GBai zY=CTGV=ZK(4f-#Ca^=&{KL6tCwd=?{{32`&TJ3OlWrN1ljUn2tN*4+>r#EgF^5bn@<0ZZEM`^sIH~y6I*9j5|jO=%%6_7iPFh!W1TV8Z>^};!K{;Q`3i;D_D zI89GRaUmFDAA~VwSxo6M+Du5MBn`<5$tuYj$vR1-&@-W_LJB34LP#HZfNiw7NoM_T zDeH(&%t6dx962AxwyX0K9;95FmKbmA{a0; zwrK>uRuuKAav`t36|XnBqscDL_+eF`lKH($bBccbI=8s=`kxmKeUB+KG1G8{Hh=`n z$qx%>J0syB&6tpcyw2($#oZn5oQD~B%WF?q-lNRlyO;>gW#gmsWz5$=e=MHA3OxJF zma4ZFdhTq?^O(<#y0m`H4FSC7%p}rf}0<$k1#d0eFq&XvJ+A z&2n9{{Bf~9^W5#(jq``w`l9D<((ZTtx1g@ENpR?`WvD|A=Q7lNnm8ecv<8TQ){=9XU($SEYmA0j#U6STU!s%Pd9m}!`;uY11kZ@!|c*8@AoINk>Zubcbb`tq(` z@u1@I8#@J9L&)^QlL1iaf6wtt7 zd*WoLI#e%^u zt(9s_ZraH`C00r~FT{7ePaQE>r|q_4hq!Lq@v3p9sGeld!4D$ymB9w>w%z0WB+@s- zJW$Uv=m3QHO{9J@(5dU8C#uMHB6XgV%96Sq{uZH22HI0^La3AQRB%EWJn53aE0G$o zEe*QM^tBW7l<2a&lM0BFwj7A6&&Lr~QF9DVXtkdn04a+7O04*Lo!T3sq*S|SZeqIr zO2Nzea>Fk*x*a|19`7~rg?zyp1D)Gj`UBjx(oW_5a0JU*))lNsveXgnuC_2Ha341MNFy)L7_sddMg@|8jL~GMCn0EkAfdS zK|ybR3PBJ=X+MZ~@a{$Dw{Lde+ek~^!0ygwXXiIFJM$)AeW9tZ#GUrWu(5)jCkh@G zDd-g38T?9=4;DQq#gomu4+cW`ecJn3ni4ojhz!jb2Wa$Ie}#C^k>J+()}UHmYj*qV zz4qFY5dG{d9d*C)qnsnBRnV+FGht^KoD=< zf_73hY=k&RL((|RW=&Y70AQ?wEIc%_BiDl}WMM7Qc%G&t4J%uyMr|p%(nx#n)(TXpT&C;wP?WJT`blH<5XRuDb$|uj%mYi^dD`>Plz{>`o_#UZ4kcQ0_a;W@JdtS zcvMGnY@j|c^O6+cnM049hfZ6hRT7yJX>O0qkk^a_51DyPijkBNXPvZ6SQF|bGo=Z* z1O4)-fxEyAVvAY{;oNFTTDTaoMRCdBd{Z4{s5XJ1q(UgSd_45h^F_@ZlK5sV7<5YkrUl^Eo%pi35(uScM zIbXgK%Lx@HbYpqX06k}>M-TyPI!w#Whm1w4ljxL>WV)Ap4;P5k=U^2>Uc-(y(KE9a zuR)?y;+bY8`L7`%} zIoaps5A6|!_ZKs86P-VF)9wAr!q!P9W_0CWt(o9XvKrm_7ME}5o)ze-Xw%qQ?F;mB9u%m*;cyq)*hH8I(p%l!AvzWHU|n>P+5wjllyD0mkgk2@P9UU8u5 zNaSDlfEIj}toF&FmL8le1-Y_?KoxMV@A6wg_iGsVA>S=A-MfELPnkxwtv z3{}f0P|W3@udfFK72>ra-HLcmK50M~PM)V~2`q2P7@QZ=`6tP2qs)khIxY=vRaeuLLTa&M^nphzwK;v1HU_t`D;A+5aE?!--zH>qs9 R>IAW1r%?wA%gLfCPgQ5Tc literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 b/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 new file mode 100644 index 0000000000000000000000000000000000000000..99c0c1014fb150ef60db1812b9c613c635ca90cb GIT binary patch literal 2316 zcmb7G&uddb5Z;$fHcgYN$5Ny`M4}gK^P{O~)kHklQ-vs=Bt}UjC{fZ>>@7tvg5Xub zn-|5ie}Pv^kNyjuJ&XE%`(_{6MC84J-JRW?H{a~c?Ck4jl%=6jw|cwd?H$enRS7s~ zCA+`=M06ahTe5bZlAtB^VAQC0+JoW4$Gy(FQp4g2EcY#yo6&f-S;iWbmeh>2S(uWh z6!n+Xp0Be(DSi){oIM)EYy7g?mD!*8#z_WPz8g3qBrQKd1h zs751#$trq-R#bZzrnjrKhfj9qBONB zk4K!1_n-Dc?3QdB_BNlBQcxYMrf@E6g7C2*oR5n<)UM4?Bl%jF^278dXFH9E`9@_$W z2hZ>$lDUj7F;GV7vIA)f(}4o|-hz1E4`Pr@*i8zO(Z)f9!aT?4%nJ5iUKC=4+t^Hq zu=1Zo(nq4v{1E0I6fGUH9@KP9F0sG;6LCK4VGTX@^X6ujMa)@_?;gO;{ zHB;bheZ!_obEE^k>Hs!{=|cr8#6Jr0qKKrrs;+M9?^Y@7`zZ`>5i2=Uz^~=C7%0sx zn&{tF8z7cN0n1Lr&c0zLhG;=1VFtJdQV$%^3t?<6wEW!LT8xoWB!WY7PqAj6k_>M> ziARfS#q7h|hyha^O}?4vHI2A;F!p^rckO2Q ath%c+YnN=bY#<3|}GqW=PDJ^3&I literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json b/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json new file mode 100644 index 0000000000..ca43f767ec --- /dev/null +++ b/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_13:53:51_2020", "threads": 1, "bytes": 2316, "aggregation_mus": 0, "meta_sort_merge_mus": 318, "mkdir_mus": 51, "minmax_mus": 0, "buffering_mus": 1042, "memcpy_mus": 0, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 19, "write_mus": 11 },"transport_1": { "type": "File_POSIX", "close_mus": 1, "open_mus": 17, "write_mus": 9 } } +] diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/data.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/data.0 new file mode 100644 index 0000000000000000000000000000000000000000..91b2732375e5d05805fc6bec0151045ff1f1d6d7 GIT binary patch literal 1494 zcmZux%Zd|06s=VHk#wRUxXEtZ$S`O~=Y_a2k)UKD6VTl_3_%jiW(G5f;;wXj03V{`ZDg;y}*c4}Yk+OJ@)gvH< zwH}EkYh8>sMxR8ZwN6H>L@#Q#T!d%3wGf-MK_P6XiqN=-#hj8VuN>tnPx-2#iYhp} z?iT#iDG-zNvxkjya^?K>{uF)(hTL_mQq4ddhN&!NR)Pv1?2lrcJvoT4GkZ84jf6Q( zomqpDm}GR8iOv$wNTT}D$^p7S59k96z#=dJnqXwiOCnf?aV};orOZc;bR$ptQ9%}? zK$?Rm@u8$ZnKxEChUfoXVt0$(HS6w4&f8sNcaz;!c6Y72Ea}E38iu3QF)Y|9<(SDN zL&7nQ!X`13<%w1+=$fqYebVNO;T}E!+AJ+?7Kt|XrEQY(v7EyU#6102>fHD2`O%A) PuU@}-`;NQuhrIg_cN0cp literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..d20b4310687a6549bc206b233ed4c7563cec173c GIT binary patch literal 2315 zcmb7G&1+LZ5Z~-3n>2}nHv=LSK}59XtHqNhS_&0Q1-*GFkD6jZT1iuj2(sGNTJh$k z6>sWI{{U}_7Z292gW$Q~{~*#A=l6Er%ggE^Z(%w!`|;-MHUh_^jwg6kN6SK_L+xLl;;qBX4+$-FYVW`G!~~ z5Q}2AU8~MC+ima844KY{2J|MK=b&YAF`YUn@(}*Fc0N5hH#esnmL`Z#G-|a~rWeFP zADDKD?>3%or<#@y5C6TZ{aiqT>PmO&MvFNt=w( zCTntL$mESWtAg(feT{|Jq+5|}j@5fM$0C~va>Q>82V~fY;aVG84qbQXpaQ|$HI_+ z9v=qv$X}1H30ldXRi;P&<=f!*sHk?eF02dOt zA-m~4{U`T3uU5F%^ivivO>7?(#C&|3q@sY6OcN=k^3yWoYnk&n1RkjHgdWr=E zw~q*xmt(NyZT;cKqs_;B5JHzKy{TP{+_;Dv(1I?-zXbdZJnCOc YEH1Q^=&USeMCV4k)l#oQd+%BJ3qd+IfdBvi literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..0785c1098c5a3a01e04d1defa32a31baa94874a0 GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFplB8AI;!ED@ixjD`ySX6v;6{QHq%@%PC4>?r!9JKmnppcbTJQJ+ zOr8q<0sn(9eX!pCg1eM_-ra6&L_fp7ws?HJ z+a2B$a=@n+ebOlqyGZ+!9UZsp+l@2*#aeXd`om$ZvR5AtyT^N!=3wcR?EP?E2_oDu z@T%sFo0>D0G%p3^aBUgrY0l_t&REu*v7$L+HJ~y&sO5-qg)XbQmUJmj>%XO#shg>q zsl};qXf%kr5{EAP2^DR0=lsk2Tm8O6YTTg;PH2Cm{h9W!U^>avr;}CMm+R~j)npSc z$En8DPz{Qur4Sj2&w+ZnlQqiXf zg)j)A$h{)hirg+-(l806v!Z*mehWx*@+d%pSk*|` zSY1|_RgRR7)n>&b)uH@!;w{v_NxmW1LISUrNVt57Oc^CrR$0ncj&fB_`*cYNoJPGMoS zhMu3i<(`sFe3)RJy8#HTkQcwE`NZJGZ-(9A#qWmQ;Kd(?-QdNaZ0A}6N^OZY*MI0G z#9zjkV>}NAy%0x72jQHI9u0dv!9Fm=%d{6QNDYsShFH?8mGsPJbBoX>bO>F-9ATcY zK*%ofBrhagrk=+hsbR8U>1V?E4htT;4eN=1v literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..64a176bff6f052839b9889fcc3f28343267e7903 GIT binary patch literal 2469 zcmbVNOKTKC5bl}Y>3t-M2_9S!iJ&5)>%Q^kY!U)dLIlNYnCPxXF@eb@l3Q!yBf%e# z-Kz(|qy7LvuO>b&lB?nm@TlUhRo&Gyv!jRI^wLxHP1kmPRozuno1C7#dT#v6*lICX z$>qmp>P_#a*Yp^TVkOU5!k~YpMX!#LJjw*SR$p#T&o1H{ixtqqMI8p}Q%YlOoFroo zySH}T^Di^o>?TgaVhT|bt(5-^DBMQ~L$tMI2SM(oG`I`GQR*SR}TSpk~{oi5P-NYa9JM}ZeN4d5TWm2{P>&%RhyOmNg^j8jo@xZWOe~d{R zCb*EWw}fz{fC*`k5T#7R1hSI90V^EhD=Du4Xkr1IYB^+64cKggVgGE<2QpHU0+)0j zkezxD43$)e1@?3v$X30l^h!QySl=QAbEs9r+K=YY30M!1!=3lfE;bs%Z8WCbQfVFL zbC~a7eskL`tJZFfz&u{#KWKMxnAmXRj*ZfZ-tePI95U--4|w;P#D*HDfDVq+F?oit zk!J}TnIoJ7`Z)42Ss-j=k+6{^!bX+}8(DGrOLa(am3B$NtE3|h4kele5oBS2tE8ik zXCWSSJj!@fVHA9oScn!Wc$J1#1cvoO^eTnD#RH>0&(4C&i9gOd-2_MnqyU)&nF5&x znZfl9Dh2U^6wKj)UN+GjCias<{14t#GqD^y-7YZG@6a`3EJw7#azu>fh#1QeF_t4@ z{>8BVMGCgpA()Jr4!T?jd&qD=`Vv_5rjS~L`ftyJv!%s4XU+Rd4r|`_>virLuk)l} z*&!zul$~EFMml#g@H;@+vF#R)ousRFW*TRAdvPmD z-lQ%nwn@Rym+qJ*`74nm6oVv8fL(9$b@C|AsCe*jedE#NCr>xGxNF?alkyr2b>j}3 zU9?~_fx`jHJnX%?|Asx-^kLJBbw3V!vgymZH)DTpw+b~rMHfrlA!QY4>+g&y^OZt1 zyrZRn^$ZyHnI=oxlFNj2q>xFOl4+Td{H^i)J>pq^*^K9fsAp?mo^9LaorLXlgq`f9 P>~tq%bITmn2~z$7rKVY` literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..50a34ff043cf4a8f4f8b9f73345210d8f46f63de GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFoff QdMPJ_5!t>s4k`qu02&(%i~s-t literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json new file mode 100644 index 0000000000..27649df8de --- /dev/null +++ b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_14:00:57_2020", "threads": 1, "bytes": 1622, "aggregation_mus": 0, "meta_sort_merge_mus": 456, "mkdir_mus": 33, "minmax_mus": 0, "buffering_mus": 1045, "memcpy_mus": 1, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 15, "write_mus": 8 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 11, "write_mus": 6 } } +] diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 new file mode 100644 index 0000000000000000000000000000000000000000..f6cffc0a64eecae0567364a44b5c67fd985d04aa GIT binary patch literal 898 zcmZ8gO;5r=5SQ4JpNho8J8a`k&+< z_+y;cvg#9GF9>@&EY?f1o1&;RFe;E%O`0e02 z9nx`%xqONmwNY;tKEF&x%rh(=aKbdP(`NcFH5oSq*yS}4`3F}$6=WU0}{Q z$gxX|+fX@Hu>nJ7Lwt+N!-$frxzQiEAON>)K?6Hs~TSK97s+Vz&!dl_r0}OSrUrha4Yo!E<_XgeYFk kC!z>s*kzZEb)se}gDIOr;yrfJbg4<~;ru>On;*~c4+2fLpa1{> literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..cc760ec7914bb8d1426df26f634b89111587ca5d GIT binary patch literal 1756 zcmbW1&1w`u5XWn_v%UFJOmYb^$P$QnF=i*pB1*_ikiZfoA*+I?u*BK0m@g)?fjuaj zyWUms0rZwf$lb*!@F*UA1*^KNIy1>-#)jSccW-t5wyL{2eAd`%K3w0fp7{$a3yam~ zQPO(TN?O3fUs(hglG#n`@zOoEv!LNcbec4_j%dY$8hHeyagg3H3SgZrKp75uuUhdY zlq8y-#~+7jRv|CLA4Q>Jn&Qx3tcBZX?`S)Di$)naX(K+0>&v^%&e8rsw2NtI7d}L< zRCsUN{4*Qn+IQQG`+<7RyY)L333`@{_mtpj{^Jy{;&=^o%gKXJpJ@y#fe8(2R=6Px zO4FW*q}k1+S$EhlKbH6O)kjwPf(4~%horfeE$bLNf-aDzl-1e?f%?u6{gcH3S{wO_ zyX2?JJL7;LsyNdcr0gn1Bm`QslfiSo510a}g8sock3SiFFj%_f|T^9QY7&jOxTPJf$ zS3SLoUO7+6!^To`g4$s59s`USlw@>TOC8XN%jji((u{en@QJ8~^b-2jW)jmZ>77LC z7nf4=vjWt5^bP^IWHYTd%?}+*)xB&~Q?Fi8vF3!}p>~IBYOC6wkg8G_5 qnYY%Vx*62+|DbSBU)>ed8VhQ);Y?PYOrv=YRix2MYEwYREdBvMt)uq< literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..95b490e62098b8d0eba73de70c9e92ca107f1e0e GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFoff Q`VJd}5!t>s4k`qu03QAfzyJUM literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json new file mode 100644 index 0000000000..530d8f60c4 --- /dev/null +++ b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_14:00:57_2020", "threads": 1, "bytes": 898, "aggregation_mus": 0, "meta_sort_merge_mus": 516, "mkdir_mus": 44, "minmax_mus": 0, "buffering_mus": 1122, "memcpy_mus": 1, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 18, "write_mus": 10 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 11, "write_mus": 6 } } +] diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/data.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/data.0 new file mode 100644 index 0000000000000000000000000000000000000000..fa7191ecb96959b612abf84417df798c8937bc40 GIT binary patch literal 814 zcmZ8f%}T>S5T5iWwN0v?Jq3|c6ibu-Ab7BmfaD-8)LSW~NGb)1lBPm$diMeJJ$wxN zB0h!lZMtE%3&ZZrelzp!x8n!laC~_?a^AdFuhn*fc{(R$dA&AKNeS#7C!@RYuaE^} zlOCc~8V=zaz^1({^FYZ`(dcQ@TJO;Z8g+QROLT*sA{(PSp30~TB^aF}FW5&6iQW%zkVr{|gMrFG^Po@v0YnR#P5=M^ literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..7531e77f10e7aae137c35357b8fe7d45e9d8ce89 GIT binary patch literal 1702 zcmb7^v2N5r5QfJ$m%Zfd15qHM2q9O9hLH0mCqx9X5zQ4SNCyoF9Txb|CDDN#2ayIH zT?#6yq{s`Tp+e#jD3T@=JOB>>4?w}pdUj=lknELw`|r;B|1`eYiS7+HhS%>t@ZSVW zt4quN{UnQD#90h7g4Jb!rdjj zX9M~sVnp+t*7Oa#{lYiwS`y$5ldR}n+^-9Iiwv4DcXGn{O*#G?1Q%KT7?FivR!s literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..3a1914abedbf644ef608871e71de91361534cfd1 GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFpS5T5iWwN0v?Jq3|c6ibu-Ab7BmfaD-8)LSW~NGb)1lBPm$diMeJJ$wxN zB0h!lZMtE%3&ZZrelzp!x8n!laC~_?a^AdFuhn*fc{(R$dA&AKNeS#7C!@RYuaE^} zlOCc~8V=zaz^1({^FYZ`(dcQ@TJO;Z8g+QROLT*sA{(PSp30~TB^aF}FW5&6iQW%zkVr{|gMrFG^Po@v0YnR#P5=M^ literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.0 new file mode 100644 index 0000000000000000000000000000000000000000..7531e77f10e7aae137c35357b8fe7d45e9d8ce89 GIT binary patch literal 1702 zcmb7^v2N5r5QfJ$m%Zfd15qHM2q9O9hLH0mCqx9X5zQ4SNCyoF9Txb|CDDN#2ayIH zT?#6yq{s`Tp+e#jD3T@=JOB>>4?w}pdUj=lknELw`|r;B|1`eYiS7+HhS%>t@ZSVW zt4quN{UnQD#90h7g4Jb!rdjj zX9M~sVnp+t*7Oa#{lYiwS`y$5ldR}n+^-9Iiwv4DcXGn{O*#G?1Q%KT7?FivR!s literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.idx new file mode 100644 index 0000000000000000000000000000000000000000..c139bfc50b3e632569bd27e0b19bdbb14aa0c838 GIT binary patch literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFpL;wH) literal 0 HcmV?d00001 diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json new file mode 100644 index 0000000000..7a148c839b --- /dev/null +++ b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json @@ -0,0 +1,3 @@ +[ +{ "rank": 0, "start": "Thu_May_14_14:00:57_2020", "threads": 1, "bytes": 814, "aggregation_mus": 0, "meta_sort_merge_mus": 532, "mkdir_mus": 72, "minmax_mus": 0, "buffering_mus": 1171, "memcpy_mus": 0, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 17, "write_mus": 11 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 10, "write_mus": 7 } } +] From 475a4e4f6379f80e9c5a20b0c156cbdb3f62db4b Mon Sep 17 00:00:00 2001 From: Norbert Podhorszki Date: Thu, 14 May 2020 15:54:09 -0400 Subject: [PATCH 3/3] Remove 2.6.0 tests because the long double data type is architecture dependent and fails anywhere which has a different long double representation than the x64 linux of the stored example files. --- .../2.6.0/CMakeLists.txt | 18 - .../2.6.0/SmallTestData260.h | 129 ---- .../2.6.0/TestReadAttributes.cpp | 690 ------------------ .../2.6.0/data/BP3AttributesArrayTypes.bp | Bin 2307 -> 0 bytes .../BP3AttributesArrayTypes.bp.0 | Bin 3617 -> 0 bytes .../profiling.json | 3 - .../data/BP3AttributesOfVariableArrayTypes.bp | Bin 2461 -> 0 bytes .../BP3AttributesOfVariableArrayTypes.bp.0 | Bin 3901 -> 0 bytes .../profiling.json | 3 - .../BP3AttributesOfVariableSingleTypes.bp | Bin 1748 -> 0 bytes .../BP3AttributesOfVariableSingleTypes.bp.0 | Bin 2464 -> 0 bytes .../profiling.json | 3 - .../2.6.0/data/BP3AttributesSingleTypes.bp | Bin 1694 -> 0 bytes .../BP3AttributesSingleTypes.bp.0 | Bin 2316 -> 0 bytes .../profiling.json | 3 - .../data/BP4AttributesArrayTypes.bp/data.0 | Bin 1494 -> 0 bytes .../data/BP4AttributesArrayTypes.bp/md.0 | Bin 2315 -> 0 bytes .../data/BP4AttributesArrayTypes.bp/md.idx | Bin 128 -> 0 bytes .../BP4AttributesArrayTypes.bp/profiling.json | 3 - .../data.0 | Bin 1622 -> 0 bytes .../BP4AttributesOfVariableArrayTypes.bp/md.0 | Bin 2469 -> 0 bytes .../md.idx | Bin 128 -> 0 bytes .../profiling.json | 3 - .../data.0 | Bin 898 -> 0 bytes .../md.0 | Bin 1756 -> 0 bytes .../md.idx | Bin 128 -> 0 bytes .../profiling.json | 3 - .../WriteAttributeReadSingleTypes.bp/data.0 | Bin 814 -> 0 bytes .../WriteAttributeReadSingleTypes.bp/md.0 | Bin 1702 -> 0 bytes .../WriteAttributeReadSingleTypes.bp/md.idx | Bin 128 -> 0 bytes .../profiling.json | 3 - .../data/BP4AttributesSingleTypes.bp/data.0 | Bin 814 -> 0 bytes .../data/BP4AttributesSingleTypes.bp/md.0 | Bin 1702 -> 0 bytes .../data/BP4AttributesSingleTypes.bp/md.idx | Bin 128 -> 0 bytes .../profiling.json | 3 - testing/backward-compatibility/CMakeLists.txt | 1 - 36 files changed, 865 deletions(-) delete mode 100644 testing/backward-compatibility/2.6.0/CMakeLists.txt delete mode 100644 testing/backward-compatibility/2.6.0/SmallTestData260.h delete mode 100644 testing/backward-compatibility/2.6.0/TestReadAttributes.cpp delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/BP3AttributesArrayTypes.bp.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/BP3AttributesOfVariableArrayTypes.bp.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableSingleTypes.bp delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/BP3AttributesOfVariableSingleTypes.bp.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableSingleTypes.bp.dir/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/data.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.idx delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/data.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/data.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.idx delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/profiling.json delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/data.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.0 delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.idx delete mode 100644 testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json diff --git a/testing/backward-compatibility/2.6.0/CMakeLists.txt b/testing/backward-compatibility/2.6.0/CMakeLists.txt deleted file mode 100644 index 8226f6169b..0000000000 --- a/testing/backward-compatibility/2.6.0/CMakeLists.txt +++ /dev/null @@ -1,18 +0,0 @@ -#------------------------------------------------------------------------------# -# Distributed under the OSI-approved Apache License, Version 2.0. See -# accompanying file Copyright.txt for details. -#------------------------------------------------------------------------------# - -macro(bp3_bp4_gtest_add_tests_helper testname mpi) - gtest_add_tests_helper(${testname} ${mpi} "" BackwardCompatibility.260. .BP3 - EXTRA_ARGS ${CMAKE_CURRENT_SOURCE_DIR}/data "BP3" - ) - gtest_add_tests_helper(${testname} ${mpi} "" BackwardCompatibility.260. .BP4 - EXTRA_ARGS ${CMAKE_CURRENT_SOURCE_DIR}/data "BP4" - ) -endmacro() - - -bp3_bp4_gtest_add_tests_helper(ReadAttributes MPI_NONE) - - diff --git a/testing/backward-compatibility/2.6.0/SmallTestData260.h b/testing/backward-compatibility/2.6.0/SmallTestData260.h deleted file mode 100644 index 94e2a4d648..0000000000 --- a/testing/backward-compatibility/2.6.0/SmallTestData260.h +++ /dev/null @@ -1,129 +0,0 @@ -/* - * Distributed under the OSI-approved Apache License, Version 2.0. See - * accompanying file Copyright.txt for details. - */ -#ifndef TESTING_BACKWARD_260_SMALLTESTDATA_H_ -#define TESTING_BACKWARD_260_SMALLTESTDATA_H_ - -#include - -#include -#include -#include -#include - -#ifdef WIN32 -#define NOMINMAX -#endif - -// 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 -struct SmallTestData260 -{ - std::string S1 = "Testing ADIOS2 String type"; - - // These shoudl be able to use std::array like the rest of the pieces - // but the XL compiler seems to have some bad code generation surounding - // it that results in a double-free corruption. Switching to std::vector - // bypasses the problem - std::vector S1array = {"one"}; - std::vector S3 = {"one", "two", "three"}; - - std::array I8 = {{0, 1, -2, 3, -4, 5, -6, 7, -8, 9}}; - std::array I16 = { - {512, 513, -510, 515, -508, 517, -506, 519, -504, 521}}; - std::array I32 = {{131072, 131073, -131070, 131075, -131068, - 131077, -131066, 131079, -131064, 131081}}; - std::array I64 = { - {8589934592, 8589934593, -8589934590, 8589934595, -8589934588, - 8589934597, -8589934586, 8589934599, -8589934584, 8589934601}}; - std::array U8 = { - {128, 129, 130, 131, 132, 133, 134, 135, 136, 137}}; - std::array U16 = { - {32768, 32769, 32770, 32771, 32772, 32773, 32774, 32775, 32776, 32777}}; - std::array U32 = { - {2147483648, 2147483649, 2147483650, 2147483651, 2147483652, 2147483653, - 2147483654, 2147483655, 2147483656, 2147483657}}; - std::array U64 = { - {9223372036854775808UL, 9223372036854775809UL, 9223372036854775810UL, - 9223372036854775811UL, 9223372036854775812UL, 9223372036854775813UL, - 9223372036854775814UL, 9223372036854775815UL, 9223372036854775816UL, - 9223372036854775817UL}}; - std::array R32 = { - {0.1f, 1.1f, 2.1f, 3.1f, 4.1f, 5.1f, 6.1f, 7.1f, 8.1f, 9.1f}}; - std::array R64 = { - {10.2, 11.2, 12.2, 13.2, 14.2, 15.2, 16.2, 17.2, 18.2, 19.2}}; - std::array R128 = { - {410.2, 411.2, 412.2, 413.2, 414.2, 415.2, 416.2, 417.2, 418.2, 419.2}}; - - std::array, 10> CR32 = { - {std::complex(0.1f, 1.1f), std::complex(1.1f, 2.1f), - std::complex(2.1f, 3.1f), std::complex(3.1f, 4.1f), - std::complex(4.1f, 5.1f), std::complex(5.1f, 6.1f), - std::complex(6.1f, 7.1f), std::complex(7.1f, 8.1f), - std::complex(8.1f, 9.1f), std::complex(9.1f, 10.1f)}}; - - std::array, 10> CR64 = { - {std::complex(10.2, 11.2), std::complex(11.2, 12.2), - std::complex(12.2, 13.2), std::complex(13.2, 14.2), - std::complex(14.2, 15.2), std::complex(15.2, 16.2), - std::complex(16.2, 17.2), std::complex(17.2, 18.2), - std::complex(18.2, 19.2), std::complex(19.2, 20.2)}}; -}; - -SmallTestData260 generateNewSmallTestData(SmallTestData260 in, int step, - int rank, int size) -{ - int j = rank + 1 + step * size; - std::for_each(in.I8.begin(), in.I8.end(), [&](int8_t &v) { v += j; }); - std::for_each(in.I16.begin(), in.I16.end(), [&](int16_t &v) { v += j; }); - std::for_each(in.I32.begin(), in.I32.end(), [&](int32_t &v) { v += j; }); - std::for_each(in.I64.begin(), in.I64.end(), [&](int64_t &v) { v += j; }); - std::for_each(in.U8.begin(), in.U8.end(), [&](uint8_t &v) { v += j; }); - std::for_each(in.U16.begin(), in.U16.end(), [&](uint16_t &v) { v += j; }); - std::for_each(in.U32.begin(), in.U32.end(), [&](uint32_t &v) { v += j; }); - std::for_each(in.U64.begin(), in.U64.end(), [&](uint64_t &v) { v += j; }); - std::for_each(in.R32.begin(), in.R32.end(), [&](float &v) { v += j; }); - std::for_each(in.R64.begin(), in.R64.end(), [&](double &v) { v += j; }); - std::for_each(in.R128.begin(), in.R128.end(), - [&](long double &v) { v += j; }); - - std::for_each(in.CR32.begin(), in.CR32.end(), [&](std::complex &v) { - v.real(v.real() + static_cast(j)); - v.imag(v.imag() + static_cast(j)); - }); - std::for_each(in.CR64.begin(), in.CR64.end(), [&](std::complex &v) { - v.real(v.real() + static_cast(j)); - v.imag(v.imag() + static_cast(j)); - }); - - return in; -} - -void UpdateSmallTestData(SmallTestData260 &in, int step, int rank, int size) -{ - int j = rank + 1 + step * size; - std::for_each(in.I8.begin(), in.I8.end(), [&](int8_t &v) { v += j; }); - std::for_each(in.I16.begin(), in.I16.end(), [&](int16_t &v) { v += j; }); - std::for_each(in.I32.begin(), in.I32.end(), [&](int32_t &v) { v += j; }); - std::for_each(in.I64.begin(), in.I64.end(), [&](int64_t &v) { v += j; }); - std::for_each(in.U8.begin(), in.U8.end(), [&](uint8_t &v) { v += j; }); - std::for_each(in.U16.begin(), in.U16.end(), [&](uint16_t &v) { v += j; }); - std::for_each(in.U32.begin(), in.U32.end(), [&](uint32_t &v) { v += j; }); - std::for_each(in.U64.begin(), in.U64.end(), [&](uint64_t &v) { v += j; }); - std::for_each(in.R32.begin(), in.R32.end(), [&](float &v) { v += j; }); - std::for_each(in.R64.begin(), in.R64.end(), [&](double &v) { v += j; }); - std::for_each(in.R128.begin(), in.R128.end(), - [&](long double &v) { v += j; }); - - std::for_each(in.CR32.begin(), in.CR32.end(), [&](std::complex &v) { - v.real(v.real() + static_cast(j)); - v.imag(v.imag() + static_cast(j)); - }); - std::for_each(in.CR64.begin(), in.CR64.end(), [&](std::complex &v) { - v.real(v.real() + static_cast(j)); - v.imag(v.imag() + static_cast(j)); - }); -} - -#endif // TESTING_BACKWARD_260_SMALLTESTDATA_H_ diff --git a/testing/backward-compatibility/2.6.0/TestReadAttributes.cpp b/testing/backward-compatibility/2.6.0/TestReadAttributes.cpp deleted file mode 100644 index 6cefc1475a..0000000000 --- a/testing/backward-compatibility/2.6.0/TestReadAttributes.cpp +++ /dev/null @@ -1,690 +0,0 @@ -/* - * Distributed under the OSI-approved Apache License, Version 2.0. See - * accompanying file Copyright.txt for details. - */ -#include -#include -#include - -#include -#include - -#include - -#include - -#include "SmallTestData260.h" - -std::string dataPath; // comes from command line -std::string engineName; // comes from command line - -class ReadAttributes : public ::testing::Test -{ -public: - ReadAttributes() = default; - - SmallTestData260 m_TestData; -}; - -// ADIOS2 write, read for single value attributes -TEST_F(ReadAttributes, SingleTypes) -{ - const std::string fName = dataPath + - std::string(&adios2::PathSeparator, 1) + - engineName + "AttributesSingleTypes.bp"; - - const std::string zero = std::to_string(0); - const std::string s1_Single = std::string("s1_Single_") + zero; - const std::string s1_Array = std::string("s1_Array_") + zero; - const std::string i8_Single = std::string("i8_Single_") + zero; - const std::string i16_Single = std::string("i16_Single_") + zero; - const std::string i32_Single = std::string("i32_Single_") + zero; - const std::string i64_Single = std::string("i64_Single_") + zero; - const std::string u8_Single = std::string("u8_Single_") + zero; - const std::string u16_Single = std::string("u16_Single_") + zero; - const std::string u32_Single = std::string("u32_Single_") + zero; - const std::string u64_Single = std::string("u64_Single_") + zero; - const std::string r32_Single = std::string("r32_Single_") + zero; - const std::string r64_Single = std::string("r64_Single_") + zero; - const std::string r128_Single = std::string("r128_Single_") + zero; - const std::string cr32_Single = std::string("cr32_Single_") + zero; - const std::string cr64_Single = std::string("cr64_Single_") + zero; - - // When collective meta generation has landed, use - // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); - // Generate current testing data - SmallTestData260 currentTestData = - generateNewSmallTestData(m_TestData, 0, 0, 0); - - adios2::ADIOS adios; - - { - adios2::IO ioRead = adios.DeclareIO("ioRead"); - if (!engineName.empty()) - { - ioRead.SetEngine(engineName); - } - - adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); - - auto attr_s1 = ioRead.InquireAttribute(s1_Single); - auto attr_s1a = ioRead.InquireAttribute(s1_Array); - auto attr_i8 = ioRead.InquireAttribute(i8_Single); - auto attr_i16 = ioRead.InquireAttribute(i16_Single); - auto attr_i32 = ioRead.InquireAttribute(i32_Single); - auto attr_i64 = ioRead.InquireAttribute(i64_Single); - - auto attr_u8 = ioRead.InquireAttribute(u8_Single); - auto attr_u16 = ioRead.InquireAttribute(u16_Single); - auto attr_u32 = ioRead.InquireAttribute(u32_Single); - auto attr_u64 = ioRead.InquireAttribute(u64_Single); - - auto attr_r32 = ioRead.InquireAttribute(r32_Single); - auto attr_r64 = ioRead.InquireAttribute(r64_Single); - auto attr_r128 = ioRead.InquireAttribute(r128_Single); - - auto attr_cr32 = - ioRead.InquireAttribute>(cr32_Single); - auto attr_cr64 = - ioRead.InquireAttribute>(cr64_Single); - - EXPECT_TRUE(attr_s1); - ASSERT_EQ(attr_s1.Name(), s1_Single); - ASSERT_EQ(attr_s1.Data().size() == 1, true); - ASSERT_EQ(attr_s1.Type(), adios2::GetType()); - ASSERT_EQ(attr_s1.Data().front(), currentTestData.S1); - - EXPECT_TRUE(attr_s1a); - ASSERT_EQ(attr_s1a.Name(), s1_Array); - ASSERT_EQ(attr_s1a.Data().size() == 1, true); - ASSERT_EQ(attr_s1a.Type(), adios2::GetType()); - ASSERT_EQ(attr_s1a.Data()[0], currentTestData.S1array[0]); - - EXPECT_TRUE(attr_i8); - ASSERT_EQ(attr_i8.Name(), i8_Single); - ASSERT_EQ(attr_i8.Data().size() == 1, true); - ASSERT_EQ(attr_i8.Type(), adios2::GetType()); - ASSERT_EQ(attr_i8.Data().front(), currentTestData.I8.front()); - - EXPECT_TRUE(attr_i16); - ASSERT_EQ(attr_i16.Name(), i16_Single); - ASSERT_EQ(attr_i16.Data().size() == 1, true); - ASSERT_EQ(attr_i16.Type(), adios2::GetType()); - ASSERT_EQ(attr_i16.Data().front(), currentTestData.I16.front()); - - EXPECT_TRUE(attr_i32); - ASSERT_EQ(attr_i32.Name(), i32_Single); - ASSERT_EQ(attr_i32.Data().size() == 1, true); - ASSERT_EQ(attr_i32.Type(), adios2::GetType()); - ASSERT_EQ(attr_i32.Data().front(), currentTestData.I32.front()); - - EXPECT_TRUE(attr_i64); - ASSERT_EQ(attr_i64.Name(), i64_Single); - ASSERT_EQ(attr_i64.Data().size() == 1, true); - ASSERT_EQ(attr_i64.Type(), adios2::GetType()); - ASSERT_EQ(attr_i64.Data().front(), currentTestData.I64.front()); - - EXPECT_TRUE(attr_u8); - ASSERT_EQ(attr_u8.Name(), u8_Single); - ASSERT_EQ(attr_u8.Data().size() == 1, true); - ASSERT_EQ(attr_u8.Type(), adios2::GetType()); - ASSERT_EQ(attr_u8.Data().front(), currentTestData.U8.front()); - - EXPECT_TRUE(attr_u16); - ASSERT_EQ(attr_u16.Name(), u16_Single); - ASSERT_EQ(attr_u16.Data().size() == 1, true); - ASSERT_EQ(attr_u16.Type(), adios2::GetType()); - ASSERT_EQ(attr_u16.Data().front(), currentTestData.U16.front()); - - EXPECT_TRUE(attr_u32); - ASSERT_EQ(attr_u32.Name(), u32_Single); - ASSERT_EQ(attr_u32.Data().size() == 1, true); - ASSERT_EQ(attr_u32.Type(), adios2::GetType()); - ASSERT_EQ(attr_u32.Data().front(), currentTestData.U32.front()); - - EXPECT_TRUE(attr_u64); - ASSERT_EQ(attr_u64.Name(), u64_Single); - ASSERT_EQ(attr_u64.Data().size() == 1, true); - ASSERT_EQ(attr_u64.Type(), adios2::GetType()); - ASSERT_EQ(attr_u64.Data().front(), currentTestData.U64.front()); - - EXPECT_TRUE(attr_r32); - ASSERT_EQ(attr_r32.Name(), r32_Single); - ASSERT_EQ(attr_r32.Data().size() == 1, true); - ASSERT_EQ(attr_r32.Type(), adios2::GetType()); - ASSERT_EQ(attr_r32.Data().front(), currentTestData.R32.front()); - - EXPECT_TRUE(attr_r64); - ASSERT_EQ(attr_r64.Name(), r64_Single); - ASSERT_EQ(attr_r64.Data().size() == 1, true); - ASSERT_EQ(attr_r64.Type(), adios2::GetType()); - ASSERT_EQ(attr_r64.Data().front(), currentTestData.R64.front()); - - EXPECT_TRUE(attr_r128); - ASSERT_EQ(attr_r128.Name(), r128_Single); - ASSERT_EQ(attr_r128.Data().size() == 1, true); - ASSERT_EQ(attr_r128.Type(), adios2::GetType()); - ASSERT_EQ(attr_r128.Data().front(), currentTestData.R128.front()); - - EXPECT_TRUE(attr_cr32); - ASSERT_EQ(attr_cr32.Name(), cr32_Single); - ASSERT_EQ(attr_cr32.Data().size() == 1, true); - ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); - ASSERT_EQ(attr_cr32.Data().front(), currentTestData.CR32.front()); - - EXPECT_TRUE(attr_cr64); - ASSERT_EQ(attr_cr64.Name(), cr64_Single); - ASSERT_EQ(attr_cr64.Data().size() == 1, true); - ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); - ASSERT_EQ(attr_cr64.Data().front(), currentTestData.CR64.front()); - - bpRead.Close(); - } -} - -// ADIOS2 write read for array attributes -TEST_F(ReadAttributes, ArrayTypes) -{ - const std::string fName = dataPath + - std::string(&adios2::PathSeparator, 1) + - engineName + "AttributesArrayTypes.bp"; - - const std::string zero = std::to_string(0); - const std::string s1_Array = std::string("s1_Array_") + zero; - const std::string i8_Array = std::string("i8_Array_") + zero; - const std::string i16_Array = std::string("i16_Array_") + zero; - const std::string i32_Array = std::string("i32_Array_") + zero; - const std::string i64_Array = std::string("i64_Array_") + zero; - const std::string u8_Array = std::string("u8_Array_") + zero; - const std::string u16_Array = std::string("u16_Array_") + zero; - const std::string u32_Array = std::string("u32_Array_") + zero; - const std::string u64_Array = std::string("u64_Array_") + zero; - const std::string r32_Array = std::string("r32_Array_") + zero; - const std::string r64_Array = std::string("r64_Array_") + zero; - const std::string r128_Array = std::string("r128_Array_") + zero; - const std::string cr32_Array = std::string("cr32_Array_") + zero; - const std::string cr64_Array = std::string("cr64_Array_") + zero; - - // When collective meta generation has landed, use - // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); - // Generate current testing data - SmallTestData260 currentTestData = - generateNewSmallTestData(m_TestData, 0, 0, 0); - - adios2::ADIOS adios; - - { - adios2::IO ioRead = adios.DeclareIO("ioRead"); - - if (!engineName.empty()) - { - ioRead.SetEngine(engineName); - } - - adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); - - auto attr_s1 = ioRead.InquireAttribute(s1_Array); - - auto attr_i8 = ioRead.InquireAttribute(i8_Array); - auto attr_i16 = ioRead.InquireAttribute(i16_Array); - auto attr_i32 = ioRead.InquireAttribute(i32_Array); - auto attr_i64 = ioRead.InquireAttribute(i64_Array); - - auto attr_u8 = ioRead.InquireAttribute(u8_Array); - auto attr_u16 = ioRead.InquireAttribute(u16_Array); - auto attr_u32 = ioRead.InquireAttribute(u32_Array); - auto attr_u64 = ioRead.InquireAttribute(u64_Array); - - auto attr_r32 = ioRead.InquireAttribute(r32_Array); - auto attr_r64 = ioRead.InquireAttribute(r64_Array); - auto attr_r128 = ioRead.InquireAttribute(r128_Array); - - auto attr_cr32 = - ioRead.InquireAttribute>(cr32_Array); - auto attr_cr64 = - ioRead.InquireAttribute>(cr64_Array); - - EXPECT_TRUE(attr_s1); - ASSERT_EQ(attr_s1.Name(), s1_Array); - ASSERT_EQ(attr_s1.Data().size() == 1, false); - ASSERT_EQ(attr_s1.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i8); - ASSERT_EQ(attr_i8.Name(), i8_Array); - ASSERT_EQ(attr_i8.Data().size() == 1, false); - ASSERT_EQ(attr_i8.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i16); - ASSERT_EQ(attr_i16.Name(), i16_Array); - ASSERT_EQ(attr_i16.Data().size() == 1, false); - ASSERT_EQ(attr_i16.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i32); - ASSERT_EQ(attr_i32.Name(), i32_Array); - ASSERT_EQ(attr_i32.Data().size() == 1, false); - ASSERT_EQ(attr_i32.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i64); - ASSERT_EQ(attr_i64.Name(), i64_Array); - ASSERT_EQ(attr_i64.Data().size() == 1, false); - ASSERT_EQ(attr_i64.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u8); - ASSERT_EQ(attr_u8.Name(), u8_Array); - ASSERT_EQ(attr_u8.Data().size() == 1, false); - ASSERT_EQ(attr_u8.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u16); - ASSERT_EQ(attr_u16.Name(), u16_Array); - ASSERT_EQ(attr_u16.Data().size() == 1, false); - ASSERT_EQ(attr_u16.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u32); - ASSERT_EQ(attr_u32.Name(), u32_Array); - ASSERT_EQ(attr_u32.Data().size() == 1, false); - ASSERT_EQ(attr_u32.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u64); - ASSERT_EQ(attr_u64.Name(), u64_Array); - ASSERT_EQ(attr_u64.Data().size() == 1, false); - ASSERT_EQ(attr_u64.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_r32); - ASSERT_EQ(attr_r32.Name(), r32_Array); - ASSERT_EQ(attr_r32.Data().size() == 1, false); - ASSERT_EQ(attr_r32.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_r64); - ASSERT_EQ(attr_r64.Name(), r64_Array); - ASSERT_EQ(attr_r64.Data().size() == 1, false); - ASSERT_EQ(attr_r64.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_r128); - ASSERT_EQ(attr_r128.Name(), r128_Array); - ASSERT_EQ(attr_r128.Data().size() == 1, false); - ASSERT_EQ(attr_r128.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_cr32); - ASSERT_EQ(attr_cr32.Name(), cr32_Array); - ASSERT_EQ(attr_cr32.Data().size() == 1, false); - ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); - - EXPECT_TRUE(attr_cr64); - ASSERT_EQ(attr_cr64.Name(), cr64_Array); - ASSERT_EQ(attr_cr64.Data().size() == 1, false); - ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); - - auto I8 = attr_i8.Data(); - auto I16 = attr_i16.Data(); - auto I32 = attr_i32.Data(); - auto I64 = attr_i64.Data(); - - auto U8 = attr_u8.Data(); - auto U16 = attr_u16.Data(); - auto U32 = attr_u32.Data(); - auto U64 = attr_u64.Data(); - - const size_t Nx = 10; - for (size_t i = 0; i < Nx; ++i) - { - EXPECT_EQ(I8[i], currentTestData.I8[i]); - EXPECT_EQ(I16[i], currentTestData.I16[i]); - EXPECT_EQ(I32[i], currentTestData.I32[i]); - EXPECT_EQ(I64[i], currentTestData.I64[i]); - - EXPECT_EQ(U8[i], currentTestData.U8[i]); - EXPECT_EQ(U16[i], currentTestData.U16[i]); - EXPECT_EQ(U32[i], currentTestData.U32[i]); - EXPECT_EQ(U64[i], currentTestData.U64[i]); - } - - bpRead.Close(); - } -} - -TEST_F(ReadAttributes, OfVariableSingleTypes) -{ - const std::string fName = dataPath + - std::string(&adios2::PathSeparator, 1) + - engineName + "AttributesOfVariableSingleTypes.bp"; - - const std::string zero = std::to_string(0); - const std::string s1_Single = std::string("s1_Single_") + zero; - const std::string i8_Single = std::string("i8_Single_") + zero; - const std::string i16_Single = std::string("i16_Single_") + zero; - const std::string i32_Single = std::string("i32_Single_") + zero; - const std::string i64_Single = std::string("i64_Single_") + zero; - const std::string u8_Single = std::string("u8_Single_") + zero; - const std::string u16_Single = std::string("u16_Single_") + zero; - const std::string u32_Single = std::string("u32_Single_") + zero; - const std::string u64_Single = std::string("u64_Single_") + zero; - const std::string r32_Single = std::string("r32_Single_") + zero; - const std::string r64_Single = std::string("r64_Single_") + zero; - const std::string r128_Single = std::string("r128_Single_") + zero; - const std::string cr32_Single = std::string("cr32_Single_") + zero; - const std::string cr64_Single = std::string("cr64_Single_") + zero; - - // When collective meta generation has landed, use - // generateNewSmallTestData(m_TestData, 0, mpiRank, mpiSize); - // Generate current testing data - SmallTestData260 currentTestData = - generateNewSmallTestData(m_TestData, 0, 0, 0); - - const std::string separator = "/"; - - adios2::ADIOS adios; - - { - adios2::IO ioRead = adios.DeclareIO("ioRead"); - if (!engineName.empty()) - { - ioRead.SetEngine(engineName); - } - - adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); - - auto var = ioRead.InquireVariable("myVar"); - - auto attr_s1 = - ioRead.InquireAttribute(s1_Single, var.Name()); - auto attr_i8 = ioRead.InquireAttribute(i8_Single, var.Name()); - auto attr_i16 = - ioRead.InquireAttribute(i16_Single, var.Name()); - auto attr_i32 = - ioRead.InquireAttribute(i32_Single, var.Name()); - auto attr_i64 = - ioRead.InquireAttribute(i64_Single, var.Name()); - - auto attr_u8 = ioRead.InquireAttribute(u8_Single, var.Name()); - auto attr_u16 = - ioRead.InquireAttribute(u16_Single, var.Name()); - auto attr_u32 = - ioRead.InquireAttribute(u32_Single, var.Name()); - auto attr_u64 = - ioRead.InquireAttribute(u64_Single, var.Name()); - - auto attr_r32 = ioRead.InquireAttribute(r32_Single, var.Name()); - auto attr_r64 = ioRead.InquireAttribute(r64_Single, var.Name()); - auto attr_r128 = - ioRead.InquireAttribute(r128_Single, var.Name()); - - auto attr_cr32 = ioRead.InquireAttribute>( - cr32_Single, var.Name()); - auto attr_cr64 = ioRead.InquireAttribute>( - cr64_Single, var.Name()); - - EXPECT_TRUE(attr_s1); - ASSERT_EQ(attr_s1.Name(), var.Name() + separator + s1_Single); - ASSERT_EQ(attr_s1.Data().size() == 1, true); - ASSERT_EQ(attr_s1.Type(), adios2::GetType()); - ASSERT_EQ(attr_s1.Data().front(), currentTestData.S1); - - EXPECT_TRUE(attr_i8); - ASSERT_EQ(attr_i8.Name(), var.Name() + separator + i8_Single); - ASSERT_EQ(attr_i8.Data().size() == 1, true); - ASSERT_EQ(attr_i8.Type(), adios2::GetType()); - ASSERT_EQ(attr_i8.Data().front(), currentTestData.I8.front()); - - EXPECT_TRUE(attr_i16); - ASSERT_EQ(attr_i16.Name(), var.Name() + separator + i16_Single); - ASSERT_EQ(attr_i16.Data().size() == 1, true); - ASSERT_EQ(attr_i16.Type(), adios2::GetType()); - ASSERT_EQ(attr_i16.Data().front(), currentTestData.I16.front()); - - EXPECT_TRUE(attr_i32); - ASSERT_EQ(attr_i32.Name(), var.Name() + separator + i32_Single); - ASSERT_EQ(attr_i32.Data().size() == 1, true); - ASSERT_EQ(attr_i32.Type(), adios2::GetType()); - ASSERT_EQ(attr_i32.Data().front(), currentTestData.I32.front()); - - EXPECT_TRUE(attr_i64); - ASSERT_EQ(attr_i64.Name(), var.Name() + separator + i64_Single); - ASSERT_EQ(attr_i64.Data().size() == 1, true); - ASSERT_EQ(attr_i64.Type(), adios2::GetType()); - ASSERT_EQ(attr_i64.Data().front(), currentTestData.I64.front()); - - EXPECT_TRUE(attr_u8); - ASSERT_EQ(attr_u8.Name(), var.Name() + separator + u8_Single); - ASSERT_EQ(attr_u8.Data().size() == 1, true); - ASSERT_EQ(attr_u8.Type(), adios2::GetType()); - ASSERT_EQ(attr_u8.Data().front(), currentTestData.U8.front()); - - EXPECT_TRUE(attr_u16); - ASSERT_EQ(attr_u16.Name(), var.Name() + separator + u16_Single); - ASSERT_EQ(attr_u16.Data().size() == 1, true); - ASSERT_EQ(attr_u16.Type(), adios2::GetType()); - ASSERT_EQ(attr_u16.Data().front(), currentTestData.U16.front()); - - EXPECT_TRUE(attr_u32); - ASSERT_EQ(attr_u32.Name(), var.Name() + separator + u32_Single); - ASSERT_EQ(attr_u32.Data().size() == 1, true); - ASSERT_EQ(attr_u32.Type(), adios2::GetType()); - ASSERT_EQ(attr_u32.Data().front(), currentTestData.U32.front()); - - EXPECT_TRUE(attr_u64); - ASSERT_EQ(attr_u64.Name(), var.Name() + separator + u64_Single); - ASSERT_EQ(attr_u64.Data().size() == 1, true); - ASSERT_EQ(attr_u64.Type(), adios2::GetType()); - ASSERT_EQ(attr_u64.Data().front(), currentTestData.U64.front()); - - EXPECT_TRUE(attr_r32); - ASSERT_EQ(attr_r32.Name(), var.Name() + separator + r32_Single); - ASSERT_EQ(attr_r32.Data().size() == 1, true); - ASSERT_EQ(attr_r32.Type(), adios2::GetType()); - ASSERT_EQ(attr_r32.Data().front(), currentTestData.R32.front()); - - EXPECT_TRUE(attr_r64); - ASSERT_EQ(attr_r64.Name(), var.Name() + separator + r64_Single); - ASSERT_EQ(attr_r64.Data().size() == 1, true); - ASSERT_EQ(attr_r64.Type(), adios2::GetType()); - ASSERT_EQ(attr_r64.Data().front(), currentTestData.R64.front()); - - EXPECT_TRUE(attr_r128); - ASSERT_EQ(attr_r128.Name(), var.Name() + separator + r128_Single); - ASSERT_EQ(attr_r128.Data().size() == 1, true); - ASSERT_EQ(attr_r128.Type(), adios2::GetType()); - ASSERT_EQ(attr_r128.Data().front(), currentTestData.R128.front()); - - EXPECT_TRUE(attr_cr32); - ASSERT_EQ(attr_cr32.Name(), var.Name() + separator + cr32_Single); - ASSERT_EQ(attr_cr32.Data().size() == 1, true); - ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); - ASSERT_EQ(attr_cr32.Data().front(), currentTestData.CR32.front()); - - EXPECT_TRUE(attr_cr64); - ASSERT_EQ(attr_cr64.Name(), var.Name() + separator + cr64_Single); - ASSERT_EQ(attr_cr64.Data().size() == 1, true); - ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); - ASSERT_EQ(attr_cr64.Data().front(), currentTestData.CR64.front()); - - bpRead.Close(); - } -} - -// ADIOS2 write read for array attributes -TEST_F(ReadAttributes, OfVariableArrayTypes) -{ - const std::string fName = dataPath + - std::string(&adios2::PathSeparator, 1) + - engineName + "AttributesOfVariableArrayTypes.bp"; - - const std::string zero = std::to_string(0); - const std::string s1_Array = std::string("s1_Array_") + zero; - const std::string i8_Array = std::string("i8_Array_") + zero; - const std::string i16_Array = std::string("i16_Array_") + zero; - const std::string i32_Array = std::string("i32_Array_") + zero; - const std::string i64_Array = std::string("i64_Array_") + zero; - const std::string u8_Array = std::string("u8_Array_") + zero; - const std::string u16_Array = std::string("u16_Array_") + zero; - const std::string u32_Array = std::string("u32_Array_") + zero; - const std::string u64_Array = std::string("u64_Array_") + zero; - const std::string r32_Array = std::string("r32_Array_") + zero; - const std::string r64_Array = std::string("r64_Array_") + zero; - const std::string r128_Array = std::string("r128_Array_") + zero; - const std::string cr32_Array = std::string("cr32_Array_") + zero; - const std::string cr64_Array = std::string("cr64_Array_") + zero; - - const std::string separator = "/"; - - SmallTestData260 currentTestData = - generateNewSmallTestData(m_TestData, 0, 0, 0); - - adios2::ADIOS adios; - - { - adios2::IO ioRead = adios.DeclareIO("ioRead"); - if (!engineName.empty()) - { - ioRead.SetEngine(engineName); - } - - adios2::Engine bpRead = ioRead.Open(fName, adios2::Mode::Read); - - auto var = ioRead.InquireVariable("myVar"); - - auto attr_s1 = - ioRead.InquireAttribute(s1_Array, var.Name()); - - auto attr_i8 = ioRead.InquireAttribute(i8_Array, var.Name()); - auto attr_i16 = ioRead.InquireAttribute(i16_Array, var.Name()); - auto attr_i32 = ioRead.InquireAttribute(i32_Array, var.Name()); - auto attr_i64 = ioRead.InquireAttribute(i64_Array, var.Name()); - - auto attr_u8 = ioRead.InquireAttribute(u8_Array, var.Name()); - auto attr_u16 = - ioRead.InquireAttribute(u16_Array, var.Name()); - auto attr_u32 = - ioRead.InquireAttribute(u32_Array, var.Name()); - auto attr_u64 = - ioRead.InquireAttribute(u64_Array, var.Name()); - - auto attr_r32 = ioRead.InquireAttribute(r32_Array, var.Name()); - auto attr_r64 = ioRead.InquireAttribute(r64_Array, var.Name()); - auto attr_r128 = - ioRead.InquireAttribute(r128_Array, var.Name()); - - auto attr_cr32 = ioRead.InquireAttribute>( - cr32_Array, var.Name()); - auto attr_cr64 = ioRead.InquireAttribute>( - cr64_Array, var.Name()); - - EXPECT_TRUE(attr_s1); - ASSERT_EQ(attr_s1.Name(), var.Name() + separator + s1_Array); - ASSERT_EQ(attr_s1.Data().size() == 1, false); - ASSERT_EQ(attr_s1.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i8); - ASSERT_EQ(attr_i8.Name(), var.Name() + separator + i8_Array); - ASSERT_EQ(attr_i8.Data().size() == 1, false); - ASSERT_EQ(attr_i8.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i16); - ASSERT_EQ(attr_i16.Name(), var.Name() + separator + i16_Array); - ASSERT_EQ(attr_i16.Data().size() == 1, false); - ASSERT_EQ(attr_i16.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i32); - ASSERT_EQ(attr_i32.Name(), var.Name() + separator + i32_Array); - ASSERT_EQ(attr_i32.Data().size() == 1, false); - ASSERT_EQ(attr_i32.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_i64); - ASSERT_EQ(attr_i64.Name(), var.Name() + separator + i64_Array); - ASSERT_EQ(attr_i64.Data().size() == 1, false); - ASSERT_EQ(attr_i64.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u8); - ASSERT_EQ(attr_u8.Name(), var.Name() + separator + u8_Array); - ASSERT_EQ(attr_u8.Data().size() == 1, false); - ASSERT_EQ(attr_u8.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u16); - ASSERT_EQ(attr_u16.Name(), var.Name() + separator + u16_Array); - ASSERT_EQ(attr_u16.Data().size() == 1, false); - ASSERT_EQ(attr_u16.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u32); - ASSERT_EQ(attr_u32.Name(), var.Name() + separator + u32_Array); - ASSERT_EQ(attr_u32.Data().size() == 1, false); - ASSERT_EQ(attr_u32.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_u64); - ASSERT_EQ(attr_u64.Name(), var.Name() + separator + u64_Array); - ASSERT_EQ(attr_u64.Data().size() == 1, false); - ASSERT_EQ(attr_u64.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_r32); - ASSERT_EQ(attr_r32.Name(), var.Name() + separator + r32_Array); - ASSERT_EQ(attr_r32.Data().size() == 1, false); - ASSERT_EQ(attr_r32.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_r64); - ASSERT_EQ(attr_r64.Name(), var.Name() + separator + r64_Array); - ASSERT_EQ(attr_r64.Data().size() == 1, false); - ASSERT_EQ(attr_r64.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_r128); - ASSERT_EQ(attr_r128.Name(), var.Name() + separator + r128_Array); - ASSERT_EQ(attr_r128.Data().size() == 1, false); - ASSERT_EQ(attr_r128.Type(), adios2::GetType()); - - EXPECT_TRUE(attr_cr32); - ASSERT_EQ(attr_cr32.Name(), var.Name() + separator + cr32_Array); - ASSERT_EQ(attr_cr32.Data().size() == 1, false); - ASSERT_EQ(attr_cr32.Type(), adios2::GetType>()); - - EXPECT_TRUE(attr_cr64); - ASSERT_EQ(attr_cr64.Name(), var.Name() + separator + cr64_Array); - ASSERT_EQ(attr_cr64.Data().size() == 1, false); - ASSERT_EQ(attr_cr64.Type(), adios2::GetType>()); - - auto I8 = attr_i8.Data(); - auto I16 = attr_i16.Data(); - auto I32 = attr_i32.Data(); - auto I64 = attr_i64.Data(); - - auto U8 = attr_u8.Data(); - auto U16 = attr_u16.Data(); - auto U32 = attr_u32.Data(); - auto U64 = attr_u64.Data(); - - const size_t Nx = 10; - for (size_t i = 0; i < Nx; ++i) - { - EXPECT_EQ(I8[i], currentTestData.I8[i]); - EXPECT_EQ(I16[i], currentTestData.I16[i]); - EXPECT_EQ(I32[i], currentTestData.I32[i]); - EXPECT_EQ(I64[i], currentTestData.I64[i]); - - EXPECT_EQ(U8[i], currentTestData.U8[i]); - EXPECT_EQ(U16[i], currentTestData.U16[i]); - EXPECT_EQ(U32[i], currentTestData.U32[i]); - EXPECT_EQ(U64[i], currentTestData.U64[i]); - } - - bpRead.Close(); - } -} - -//****************************************************************************** -// main -//****************************************************************************** - -int main(int argc, char **argv) -{ - int result; - ::testing::InitGoogleTest(&argc, argv); - - if (argc < 3) - { - throw std::runtime_error( - "Test needs 2 arguments: path-to-data engineName"); - } - - dataPath = std::string(argv[1]); - engineName = std::string(argv[2]); - - result = RUN_ALL_TESTS(); - - return result; -} diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp b/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp deleted file mode 100644 index 64e4ea9ee1c3cb17a204f6de9394c3ac30f282b8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2307 zcmb7G&1+LZ5TEz53{XGd8XcKH6G540EFha+{E<^d1=}hcqbtwHvWt4R_GZhgYZ*dKGR#t{i@UxKBUjm2LSII6Ian!; z#raljzBh5X&wM@QE1?3FQc|T=MrBo~#1|8DmyM5jp)fJWs&ULQ8*_j+;xmdbSNdj9 zK@6(eA$>R|l2Rc*yorhMbd?|jov`yr9|B1lsEgC!N8s8iFg>Sw7mg5(`JL`^L_~EQO ze&MIH?)ZgYW?fw2yyP?+1RVXPScoKWr2YN@fHN13vq&l$=UAU-eSvimNkwCXb%}ME zb%k}cCiYCeL!1r)N5c@wm23u8n{NZR^a&h1Lm(%BE4-C}O`s+~6PO9e3PG&I38sP^ zVWWvbH0(o|Pr!yB6Fb280BQK$;6UzY{)S@T1Uk;7yHD4kV7r6mQjE{M{oWh2gFM^( z_$VFf9Rd~?ngZGn7E{o^*J?J!Fz=O@*`Np3{LR69@_~IDuz_281OB($ddPD65zy%d zs8gsV>NM&M>MZJz*6)}+me`;!s;|X7l3moZc?{A;ecuow zxRyQGeUa^zqC$pC!b(QKEZ%|@lrD% z^a0#e~H_RdzH4 diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/BP3AttributesArrayTypes.bp.0 b/testing/backward-compatibility/2.6.0/data/BP3AttributesArrayTypes.bp.dir/BP3AttributesArrayTypes.bp.0 deleted file mode 100644 index 13ef60b95c3ff11190beea0a7536f634e0f556d7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3617 zcmd5;ON(4Z6t2G2eY@v&D~5Bk+E`cPelMqdd;*Ir77h#? zJ}CHA!LJEk9CR(T1h)lu1a}4Z21me?o`kS&Cnv0O5R03?esg$bB?i-Xao{q>_ZW9D z?hQ63rQyb87smb}HP)8NdO_npHKr*5Bll(aBWbxSQxQ5AToqgsydXFcOpSTAuGR}0 z_oy+1Q4oa~{6yvkj18C?Ff?Fhz{srPUkYxh(?z=zs+`&FY|rfXKJb2UzR3LHed7E= z-)v0U!!~%*JgD66=bYSq5sM`g8Ewj@Vq#M@HM3w6a{%k~L!!>)!xuFEkG9GW;|I0> zl0GPUDNz^OIj#+Qm>xR6IdsLeMt2zH zS+u+JVbq7wA7(+A4Ov#W?CBxU2}=V8cmo6G7L+gh0B3OfLHAEllz0VPW1Nv@1d!&% zlIGQs=4FtkKS}fQpTkJhdj9e|-2dXs%U7;myME*5SCUq0A65x3jADe=|VvKk4!FrV8m_9@ltC4 z``Db({?ZO5L4W6E{w$L#V90E+GV{eLN@Xr%b5@xMk6CJ&{?O}jK_+J@glfP8`O?}* z)p(D8kV>;cj`C0uH0!WdD8dzGE3n@0<-H*jW}#&SdHI6x-%d487H02*e!%M=((*g3hv*CKo!!q*_H{`x+h28efw zI;;i`!j`g{Dm+Iuc-A{m{iawOpOgs$$K74fC{|MYm+?z6C0zLs4tbRISC8*2^+>qK zpUZ@S<6;>BoPUb@sUC9#j+`+PmFyY`#-)hu9xct68(>_H+D_8au2$KO($e||ukRh1 zu!_3VLGRa1^_{1R?$9dgyFR(@$>b-ST*3)T*^~YY}OEMY0bM*KJ ghu%8z%B9ZY(qfCQw9r{6BDqwakmZZ2Q0)P?YQt~v~ZDMU##D+A92beS_y2z7;&-5|G9 z7Tf?47Q>qZM>;gN9S;G;|=V@n&e7O1X@yS|Em1?!|Qn9!K{WcWAYebmi>fT<_PD2KDNP_%oAo=Ak4BznB@>*mcu1EZ7vCN zYLyfWC3{kLDN!#d=Y=jp$(}y$h4`uCr;MK}JcaBh7V0c1uYonB3bgR@qOp|uAKGCo z*?0t(>Vh*o*7=d|-dnl<;NhdywRQQ1&25o_X>CgoM@Btgh!{*dgI%Pxc+$YO znJfWGYzAjPwc|z%XFtcrV>tUIHXg&-ud(qM&VJ)@xx;So?MF($2UheLs_gaod>ClG z&IxB=PJ5uyPG)V}LyEcCsuT;i<^r)WU9VQ<3o@qOlY$k#*DP{T7R}1=lV5>J?Pl$r zwHdU)gKq}@q-eGhAOnyJWD;ZwWEx}!$9I^G7uc0p+IAV$v5A(pgmXd{r483$GIK|7 zHCruUX5XP{#8{kg4rV)I%ss@I35fByh~)s0Rp&@4pPHDwI52wQ;8GzsoWuVzwiSj$ Mo&OnW9u!jk1+{)w+5i9m diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/BP3AttributesOfVariableArrayTypes.bp.0 b/testing/backward-compatibility/2.6.0/data/BP3AttributesOfVariableArrayTypes.bp.dir/BP3AttributesOfVariableArrayTypes.bp.0 deleted file mode 100644 index 2712c9358c6b67e9db6170977c2d52ae95a8a17d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3901 zcmd5<&5ImG6tC{;uKCzijO5^eNIWPZY{s3L-AxXHGl>Lalmry~2CJ zV8!^61pk1{9&|wv&k7#B7(AKyK`yz*n`bW}IP3dWz1LmcOv3CY0Smfcy{W4Ae)X&O zUf0}6m21mJy}!7!diW@`NVOsetzsxj?ZL0qnqIhfs?J{gpg&M5UM4-BqE~`}MAhky z=UIBXZ2uZm^mr-1H@h9z zW=pcgy2v)`B0H>$oMT<&e0PN~f{h)#hvF8@v4?J<47m)k3@L|jgly6oxHR*GBai zY=CTGV=ZK(4f-#Ca^=&{KL6tCwd=?{{32`&TJ3OlWrN1ljUn2tN*4+>r#EgF^5bn@<0ZZEM`^sIH~y6I*9j5|jO=%%6_7iPFh!W1TV8Z>^};!K{;Q`3i;D_D zI89GRaUmFDAA~VwSxo6M+Du5MBn`<5$tuYj$vR1-&@-W_LJB34LP#HZfNiw7NoM_T zDeH(&%t6dx962AxwyX0K9;95FmKbmA{a0; zwrK>uRuuKAav`t36|XnBqscDL_+eF`lKH($bBccbI=8s=`kxmKeUB+KG1G8{Hh=`n z$qx%>J0syB&6tpcyw2($#oZn5oQD~B%WF?q-lNRlyO;>gW#gmsWz5$=e=MHA3OxJF zma4ZFdhTq?^O(<#y0m`H4FSC7%p}rf}0<$k1#d0eFq&XvJ+A z&2n9{{Bf~9^W5#(jq``w`l9D<((ZTtx1g@ENpR?`WvD|A=Q7lNnm8ecv<8TQ){=9XU($SEYmA0j#U6STU!s%Pd9m}!`;uY11kZ@!|c*8@AoINk>Zubcbb`tq(` z@u1@I8#@J9L&)^QlL1iaf6wtt7 zd*WoLI#e%^u zt(9s_ZraH`C00r~FT{7ePaQE>r|q_4hq!Lq@v3p9sGeld!4D$ymB9w>w%z0WB+@s- zJW$Uv=m3QHO{9J@(5dU8C#uMHB6XgV%96Sq{uZH22HI0^La3AQRB%EWJn53aE0G$o zEe*QM^tBW7l<2a&lM0BFwj7A6&&Lr~QF9DVXtkdn04a+7O04*Lo!T3sq*S|SZeqIr zO2Nzea>Fk*x*a|19`7~rg?zyp1D)Gj`UBjx(oW_5a0JU*))lNsveXgnuC_2Ha341MNFy)L7_sddMg@|8jL~GMCn0EkAfdS zK|ybR3PBJ=X+MZ~@a{$Dw{Lde+ek~^!0ygwXXiIFJM$)AeW9tZ#GUrWu(5)jCkh@G zDd-g38T?9=4;DQq#gomu4+cW`ecJn3ni4ojhz!jb2Wa$Ie}#C^k>J+()}UHmYj*qV zz4qFY5dG{d9d*C)qnsnBRnV+FGht^KoD=< zf_73hY=k&RL((|RW=&Y70AQ?wEIc%_BiDl}WMM7Qc%G&t4J%uyMr|p%(nx#n)(TXpT&C;wP?WJT`blH<5XRuDb$|uj%mYi^dD`>Plz{>`o_#UZ4kcQ0_a;W@JdtS zcvMGnY@j|c^O6+cnM049hfZ6hRT7yJX>O0qkk^a_51DyPijkBNXPvZ6SQF|bGo=Z* z1O4)-fxEyAVvAY{;oNFTTDTaoMRCdBd{Z4{s5XJ1q(UgSd_45h^F_@ZlK5sV7<5YkrUl^Eo%pi35(uScM zIbXgK%Lx@HbYpqX06k}>M-TyPI!w#Whm1w4ljxL>WV)Ap4;P5k=U^2>Uc-(y(KE9a zuR)?y;+bY8`L7`%} zIoaps5A6|!_ZKs86P-VF)9wAr!q!P9W_0CWt(o9XvKrm_7ME}5o)ze-Xw%qQ?F;mB9u%m*;cyq)*hH8I(p%l!AvzWHU|n>P+5wjllyD0mkgk2@P9UU8u5 zNaSDlfEIj}toF&FmL8le1-Y_?KoxMV@A6wg_iGsVA>S=A-MfELPnkxwtv z3{}f0P|W3@udfFK72>ra-HLcmK50M~PM)V~2`q2P7@QZ=`6tP2qs)khIxY=vRaeuLLTa&M^nphzwK;v1HU_t`D;A+5aE?!--zH>qs9 R>IAW1r%?wA%gLfCPgQ5Tc diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 b/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/BP3AttributesSingleTypes.bp.0 deleted file mode 100644 index 99c0c1014fb150ef60db1812b9c613c635ca90cb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2316 zcmb7G&uddb5Z;$fHcgYN$5Ny`M4}gK^P{O~)kHklQ-vs=Bt}UjC{fZ>>@7tvg5Xub zn-|5ie}Pv^kNyjuJ&XE%`(_{6MC84J-JRW?H{a~c?Ck4jl%=6jw|cwd?H$enRS7s~ zCA+`=M06ahTe5bZlAtB^VAQC0+JoW4$Gy(FQp4g2EcY#yo6&f-S;iWbmeh>2S(uWh z6!n+Xp0Be(DSi){oIM)EYy7g?mD!*8#z_WPz8g3qBrQKd1h zs751#$trq-R#bZzrnjrKhfj9qBONB zk4K!1_n-Dc?3QdB_BNlBQcxYMrf@E6g7C2*oR5n<)UM4?Bl%jF^278dXFH9E`9@_$W z2hZ>$lDUj7F;GV7vIA)f(}4o|-hz1E4`Pr@*i8zO(Z)f9!aT?4%nJ5iUKC=4+t^Hq zu=1Zo(nq4v{1E0I6fGUH9@KP9F0sG;6LCK4VGTX@^X6ujMa)@_?;gO;{ zHB;bheZ!_obEE^k>Hs!{=|cr8#6Jr0qKKrrs;+M9?^Y@7`zZ`>5i2=Uz^~=C7%0sx zn&{tF8z7cN0n1Lr&c0zLhG;=1VFtJdQV$%^3t?<6wEW!LT8xoWB!WY7PqAj6k_>M> ziARfS#q7h|hyha^O}?4vHI2A;F!p^rckO2Q ath%c+YnN=bY#<3|}GqW=PDJ^3&I diff --git a/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json b/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json deleted file mode 100644 index ca43f767ec..0000000000 --- a/testing/backward-compatibility/2.6.0/data/BP3AttributesSingleTypes.bp.dir/profiling.json +++ /dev/null @@ -1,3 +0,0 @@ -[ -{ "rank": 0, "start": "Thu_May_14_13:53:51_2020", "threads": 1, "bytes": 2316, "aggregation_mus": 0, "meta_sort_merge_mus": 318, "mkdir_mus": 51, "minmax_mus": 0, "buffering_mus": 1042, "memcpy_mus": 0, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 19, "write_mus": 11 },"transport_1": { "type": "File_POSIX", "close_mus": 1, "open_mus": 17, "write_mus": 9 } } -] diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/data.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/data.0 deleted file mode 100644 index 91b2732375e5d05805fc6bec0151045ff1f1d6d7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1494 zcmZux%Zd|06s=VHk#wRUxXEtZ$S`O~=Y_a2k)UKD6VTl_3_%jiW(G5f;;wXj03V{`ZDg;y}*c4}Yk+OJ@)gvH< zwH}EkYh8>sMxR8ZwN6H>L@#Q#T!d%3wGf-MK_P6XiqN=-#hj8VuN>tnPx-2#iYhp} z?iT#iDG-zNvxkjya^?K>{uF)(hTL_mQq4ddhN&!NR)Pv1?2lrcJvoT4GkZ84jf6Q( zomqpDm}GR8iOv$wNTT}D$^p7S59k96z#=dJnqXwiOCnf?aV};orOZc;bR$ptQ9%}? zK$?Rm@u8$ZnKxEChUfoXVt0$(HS6w4&f8sNcaz;!c6Y72Ea}E38iu3QF)Y|9<(SDN zL&7nQ!X`13<%w1+=$fqYebVNO;T}E!+AJ+?7Kt|XrEQY(v7EyU#6102>fHD2`O%A) PuU@}-`;NQuhrIg_cN0cp diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.0 deleted file mode 100644 index d20b4310687a6549bc206b233ed4c7563cec173c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2315 zcmb7G&1+LZ5Z~-3n>2}nHv=LSK}59XtHqNhS_&0Q1-*GFkD6jZT1iuj2(sGNTJh$k z6>sWI{{U}_7Z292gW$Q~{~*#A=l6Er%ggE^Z(%w!`|;-MHUh_^jwg6kN6SK_L+xLl;;qBX4+$-FYVW`G!~~ z5Q}2AU8~MC+ima844KY{2J|MK=b&YAF`YUn@(}*Fc0N5hH#esnmL`Z#G-|a~rWeFP zADDKD?>3%or<#@y5C6TZ{aiqT>PmO&MvFNt=w( zCTntL$mESWtAg(feT{|Jq+5|}j@5fM$0C~va>Q>82V~fY;aVG84qbQXpaQ|$HI_+ z9v=qv$X}1H30ldXRi;P&<=f!*sHk?eF02dOt zA-m~4{U`T3uU5F%^ivivO>7?(#C&|3q@sY6OcN=k^3yWoYnk&n1RkjHgdWr=E zw~q*xmt(NyZT;cKqs_;B5JHzKy{TP{+_;Dv(1I?-zXbdZJnCOc YEH1Q^=&USeMCV4k)l#oQd+%BJ3qd+IfdBvi diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesArrayTypes.bp/md.idx deleted file mode 100644 index 0785c1098c5a3a01e04d1defa32a31baa94874a0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFplB8AI;!ED@ixjD`ySX6v;6{QHq%@%PC4>?r!9JKmnppcbTJQJ+ zOr8q<0sn(9eX!pCg1eM_-ra6&L_fp7ws?HJ z+a2B$a=@n+ebOlqyGZ+!9UZsp+l@2*#aeXd`om$ZvR5AtyT^N!=3wcR?EP?E2_oDu z@T%sFo0>D0G%p3^aBUgrY0l_t&REu*v7$L+HJ~y&sO5-qg)XbQmUJmj>%XO#shg>q zsl};qXf%kr5{EAP2^DR0=lsk2Tm8O6YTTg;PH2Cm{h9W!U^>avr;}CMm+R~j)npSc z$En8DPz{Qur4Sj2&w+ZnlQqiXf zg)j)A$h{)hirg+-(l806v!Z*mehWx*@+d%pSk*|` zSY1|_RgRR7)n>&b)uH@!;w{v_NxmW1LISUrNVt57Oc^CrR$0ncj&fB_`*cYNoJPGMoS zhMu3i<(`sFe3)RJy8#HTkQcwE`NZJGZ-(9A#qWmQ;Kd(?-QdNaZ0A}6N^OZY*MI0G z#9zjkV>}NAy%0x72jQHI9u0dv!9Fm=%d{6QNDYsShFH?8mGsPJbBoX>bO>F-9ATcY zK*%ofBrhagrk=+hsbR8U>1V?E4htT;4eN=1v diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.0 deleted file mode 100644 index 64a176bff6f052839b9889fcc3f28343267e7903..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2469 zcmbVNOKTKC5bl}Y>3t-M2_9S!iJ&5)>%Q^kY!U)dLIlNYnCPxXF@eb@l3Q!yBf%e# z-Kz(|qy7LvuO>b&lB?nm@TlUhRo&Gyv!jRI^wLxHP1kmPRozuno1C7#dT#v6*lICX z$>qmp>P_#a*Yp^TVkOU5!k~YpMX!#LJjw*SR$p#T&o1H{ixtqqMI8p}Q%YlOoFroo zySH}T^Di^o>?TgaVhT|bt(5-^DBMQ~L$tMI2SM(oG`I`GQR*SR}TSpk~{oi5P-NYa9JM}ZeN4d5TWm2{P>&%RhyOmNg^j8jo@xZWOe~d{R zCb*EWw}fz{fC*`k5T#7R1hSI90V^EhD=Du4Xkr1IYB^+64cKggVgGE<2QpHU0+)0j zkezxD43$)e1@?3v$X30l^h!QySl=QAbEs9r+K=YY30M!1!=3lfE;bs%Z8WCbQfVFL zbC~a7eskL`tJZFfz&u{#KWKMxnAmXRj*ZfZ-tePI95U--4|w;P#D*HDfDVq+F?oit zk!J}TnIoJ7`Z)42Ss-j=k+6{^!bX+}8(DGrOLa(am3B$NtE3|h4kele5oBS2tE8ik zXCWSSJj!@fVHA9oScn!Wc$J1#1cvoO^eTnD#RH>0&(4C&i9gOd-2_MnqyU)&nF5&x znZfl9Dh2U^6wKj)UN+GjCias<{14t#GqD^y-7YZG@6a`3EJw7#azu>fh#1QeF_t4@ z{>8BVMGCgpA()Jr4!T?jd&qD=`Vv_5rjS~L`ftyJv!%s4XU+Rd4r|`_>virLuk)l} z*&!zul$~EFMml#g@H;@+vF#R)ousRFW*TRAdvPmD z-lQ%nwn@Rym+qJ*`74nm6oVv8fL(9$b@C|AsCe*jedE#NCr>xGxNF?alkyr2b>j}3 zU9?~_fx`jHJnX%?|Asx-^kLJBbw3V!vgymZH)DTpw+b~rMHfrlA!QY4>+g&y^OZt1 zyrZRn^$ZyHnI=oxlFNj2q>xFOl4+Td{H^i)J>pq^*^K9fsAp?mo^9LaorLXlgq`f9 P>~tq%bITmn2~z$7rKVY` diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/md.idx deleted file mode 100644 index 50a34ff043cf4a8f4f8b9f73345210d8f46f63de..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFoff QdMPJ_5!t>s4k`qu02&(%i~s-t diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json deleted file mode 100644 index 27649df8de..0000000000 --- a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableArrayTypes.bp/profiling.json +++ /dev/null @@ -1,3 +0,0 @@ -[ -{ "rank": 0, "start": "Thu_May_14_14:00:57_2020", "threads": 1, "bytes": 1622, "aggregation_mus": 0, "meta_sort_merge_mus": 456, "mkdir_mus": 33, "minmax_mus": 0, "buffering_mus": 1045, "memcpy_mus": 1, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 15, "write_mus": 8 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 11, "write_mus": 6 } } -] diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/data.0 deleted file mode 100644 index f6cffc0a64eecae0567364a44b5c67fd985d04aa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 898 zcmZ8gO;5r=5SQ4JpNho8J8a`k&+< z_+y;cvg#9GF9>@&EY?f1o1&;RFe;E%O`0e02 z9nx`%xqONmwNY;tKEF&x%rh(=aKbdP(`NcFH5oSq*yS}4`3F}$6=WU0}{Q z$gxX|+fX@Hu>nJ7Lwt+N!-$frxzQiEAON>)K?6Hs~TSK97s+Vz&!dl_r0}OSrUrha4Yo!E<_XgeYFk kC!z>s*kzZEb)se}gDIOr;yrfJbg4<~;ru>On;*~c4+2fLpa1{> diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.0 deleted file mode 100644 index cc760ec7914bb8d1426df26f634b89111587ca5d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1756 zcmbW1&1w`u5XWn_v%UFJOmYb^$P$QnF=i*pB1*_ikiZfoA*+I?u*BK0m@g)?fjuaj zyWUms0rZwf$lb*!@F*UA1*^KNIy1>-#)jSccW-t5wyL{2eAd`%K3w0fp7{$a3yam~ zQPO(TN?O3fUs(hglG#n`@zOoEv!LNcbec4_j%dY$8hHeyagg3H3SgZrKp75uuUhdY zlq8y-#~+7jRv|CLA4Q>Jn&Qx3tcBZX?`S)Di$)naX(K+0>&v^%&e8rsw2NtI7d}L< zRCsUN{4*Qn+IQQG`+<7RyY)L333`@{_mtpj{^Jy{;&=^o%gKXJpJ@y#fe8(2R=6Px zO4FW*q}k1+S$EhlKbH6O)kjwPf(4~%horfeE$bLNf-aDzl-1e?f%?u6{gcH3S{wO_ zyX2?JJL7;LsyNdcr0gn1Bm`QslfiSo510a}g8sock3SiFFj%_f|T^9QY7&jOxTPJf$ zS3SLoUO7+6!^To`g4$s59s`USlw@>TOC8XN%jji((u{en@QJ8~^b-2jW)jmZ>77LC z7nf4=vjWt5^bP^IWHYTd%?}+*)xB&~Q?Fi8vF3!}p>~IBYOC6wkg8G_5 qnYY%Vx*62+|DbSBU)>ed8VhQ);Y?PYOrv=YRix2MYEwYREdBvMt)uq< diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/md.idx deleted file mode 100644 index 95b490e62098b8d0eba73de70c9e92ca107f1e0e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFoff Q`VJd}5!t>s4k`qu03QAfzyJUM diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json b/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json deleted file mode 100644 index 530d8f60c4..0000000000 --- a/testing/backward-compatibility/2.6.0/data/BP4AttributesOfVariableSingleTypes.bp/profiling.json +++ /dev/null @@ -1,3 +0,0 @@ -[ -{ "rank": 0, "start": "Thu_May_14_14:00:57_2020", "threads": 1, "bytes": 898, "aggregation_mus": 0, "meta_sort_merge_mus": 516, "mkdir_mus": 44, "minmax_mus": 0, "buffering_mus": 1122, "memcpy_mus": 1, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 18, "write_mus": 10 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 11, "write_mus": 6 } } -] diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/data.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/data.0 deleted file mode 100644 index fa7191ecb96959b612abf84417df798c8937bc40..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 814 zcmZ8f%}T>S5T5iWwN0v?Jq3|c6ibu-Ab7BmfaD-8)LSW~NGb)1lBPm$diMeJJ$wxN zB0h!lZMtE%3&ZZrelzp!x8n!laC~_?a^AdFuhn*fc{(R$dA&AKNeS#7C!@RYuaE^} zlOCc~8V=zaz^1({^FYZ`(dcQ@TJO;Z8g+QROLT*sA{(PSp30~TB^aF}FW5&6iQW%zkVr{|gMrFG^Po@v0YnR#P5=M^ diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.0 deleted file mode 100644 index 7531e77f10e7aae137c35357b8fe7d45e9d8ce89..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1702 zcmb7^v2N5r5QfJ$m%Zfd15qHM2q9O9hLH0mCqx9X5zQ4SNCyoF9Txb|CDDN#2ayIH zT?#6yq{s`Tp+e#jD3T@=JOB>>4?w}pdUj=lknELw`|r;B|1`eYiS7+HhS%>t@ZSVW zt4quN{UnQD#90h7g4Jb!rdjj zX9M~sVnp+t*7Oa#{lYiwS`y$5ldR}n+^-9Iiwv4DcXGn{O*#G?1Q%KT7?FivR!s diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/WriteAttributeReadSingleTypes.bp/md.idx deleted file mode 100644 index 3a1914abedbf644ef608871e71de91361534cfd1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFpS5T5iWwN0v?Jq3|c6ibu-Ab7BmfaD-8)LSW~NGb)1lBPm$diMeJJ$wxN zB0h!lZMtE%3&ZZrelzp!x8n!laC~_?a^AdFuhn*fc{(R$dA&AKNeS#7C!@RYuaE^} zlOCc~8V=zaz^1({^FYZ`(dcQ@TJO;Z8g+QROLT*sA{(PSp30~TB^aF}FW5&6iQW%zkVr{|gMrFG^Po@v0YnR#P5=M^ diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.0 b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.0 deleted file mode 100644 index 7531e77f10e7aae137c35357b8fe7d45e9d8ce89..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1702 zcmb7^v2N5r5QfJ$m%Zfd15qHM2q9O9hLH0mCqx9X5zQ4SNCyoF9Txb|CDDN#2ayIH zT?#6yq{s`Tp+e#jD3T@=JOB>>4?w}pdUj=lknELw`|r;B|1`eYiS7+HhS%>t@ZSVW zt4quN{UnQD#90h7g4Jb!rdjj zX9M~sVnp+t*7Oa#{lYiwS`y$5ldR}n+^-9Iiwv4DcXGn{O*#G?1Q%KT7?FivR!s diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.idx b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/md.idx deleted file mode 100644 index c139bfc50b3e632569bd27e0b19bdbb14aa0c838..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 128 zcmZ>C@$?VYbqY`@Gtx8FGf?o%OG&Lz2uV!JNo4>5BU1wg1{N?AE5V2+>Hy{ELFpL;wH) diff --git a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json b/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json deleted file mode 100644 index 7a148c839b..0000000000 --- a/testing/backward-compatibility/2.6.0/data/BP4AttributesSingleTypes.bp/profiling.json +++ /dev/null @@ -1,3 +0,0 @@ -[ -{ "rank": 0, "start": "Thu_May_14_14:00:57_2020", "threads": 1, "bytes": 814, "aggregation_mus": 0, "meta_sort_merge_mus": 532, "mkdir_mus": 72, "minmax_mus": 0, "buffering_mus": 1171, "memcpy_mus": 0, "transport_0": { "type": "File_POSIX", "close_mus": 2, "open_mus": 17, "write_mus": 11 },"transport_1": { "type": "File_POSIX", "close_mus": 0, "open_mus": 10, "write_mus": 7 } } -] diff --git a/testing/backward-compatibility/CMakeLists.txt b/testing/backward-compatibility/CMakeLists.txt index b4d2188df7..8af7ab4619 100644 --- a/testing/backward-compatibility/CMakeLists.txt +++ b/testing/backward-compatibility/CMakeLists.txt @@ -4,4 +4,3 @@ #------------------------------------------------------------------------------# add_subdirectory(2.5.0) -add_subdirectory(2.6.0)