From 1e7c207f214f2f15e59414915fe1aaf55f7b63c2 Mon Sep 17 00:00:00 2001 From: Reece Boston <52183986+rboston628@users.noreply.github.com> Date: Thu, 13 Mar 2025 16:34:58 -0400 Subject: [PATCH] Create more tests of `NeXus::File` using based on old `napi` tests (#39027) * save progress * more output to see source of error * change leak test 3 on windows * error macro in napi_test for better readability * link test working * slab tests * try fixing the windows test failure * fix windows test issue for real * fix test that windows is incapable of running * last time * maybe the problem is file names? * address comments remove test data dependency * maybe it was napi_test.cpp all along * try using correct macro * try again * the problem was literally the first thing I tried --- Framework/Nexus/test/NeXusFileTest.h | 399 ++++++++++++++++++-- Framework/Nexus/test/napi_test.cpp | 541 +++++++++------------------ 2 files changed, 549 insertions(+), 391 deletions(-) diff --git a/Framework/Nexus/test/NeXusFileTest.h b/Framework/Nexus/test/NeXusFileTest.h index 5da724aec6ed..89900b2eb0bd 100644 --- a/Framework/Nexus/test/NeXusFileTest.h +++ b/Framework/Nexus/test/NeXusFileTest.h @@ -77,7 +77,7 @@ void removeFile(const std::string &filename) { class NeXusFileTest : public CxxTest::TestSuite { public: void do_test_write(const string &filename, NXaccess create_code) { - std::cout << "writeTest(" << filename << ") started\n"; + cout << "writeTest(" << filename << ") started\n"; NeXus::File file(filename, create_code); // create group file.makeGroup("entry", "NXentry", true); @@ -145,11 +145,11 @@ class NeXusFileTest : public CxxTest::TestSuite { file.putSlab(&(r8_array[0]), slab_start, slab_size); // add some attributes - std::cout << "writing attributes to r8_data" << std::endl; + cout << "writing attributes to r8_data" << std::endl; file.putAttr("ch_attribute", "NeXus"); file.putAttr("i4_attribute", 42); file.putAttr("r4_attribute", 3.14159265); - std::cout << "... done" << std::endl; + cout << "... done" << std::endl; // set up for creating a link NXlink link = file.getDataID(); @@ -241,13 +241,13 @@ class NeXusFileTest : public CxxTest::TestSuite { file.openPath("/"); file.makeGroup("link", "NXentry", true); file.makeLink(glink); - std::cout << "writeTest(" << filename << ") successful\n"; + cout << "writeTest(" << filename << ") successful\n"; TS_ASSERT_EQUALS(std::filesystem::exists(filename), true); } void do_test_read(const string &filename) { - std::cout << "readTest(" << filename << ") started\n"; + cout << "readTest(" << filename << ") started\n"; const string SDS("SDS"); // top level file information NeXus::File file(filename); @@ -308,12 +308,12 @@ class NeXusFileTest : public CxxTest::TestSuite { cout << "NXopenpath checks OK\n"; // everything went fine - std::cout << "readTest(" << filename << ") successful\n"; + cout << "readTest(" << filename << ") successful\n"; } void do_test_loadPath(const string &filename) { if (getenv("NX_LOAD_PATH") != NULL) { - TS_ASSERT_THROWS_NOTHING(NeXus::File file(filename)); + TS_ASSERT_THROWS_NOTHING(NeXus::File file(filename, NXACC_RDWR)); cout << "Success loading NeXus file from path" << endl; } else { cout << "NX_LOAD_PATH variable not defined. Skipping testLoadPath\n"; @@ -321,9 +321,10 @@ class NeXusFileTest : public CxxTest::TestSuite { } void test_readwrite_hdf5() { + cout << " Nexus File Tests\n"; NXaccess const nx_creation_code = NXACC_CREATE5; string const fileext = ".h5"; - string const filename("napi_test_cpp" + fileext); + string const filename("nexus_file_napi_test_cpp" + fileext); removeFile(filename); // in case last round failed @@ -342,25 +343,18 @@ class NeXusFileTest : public CxxTest::TestSuite { removeFile(DMC01 + fileext); removeFile(DMC02 + fileext); } -}; - -/** - * These correspond to former napi tests - * - leak_test1 - * - leak_test2 - * - leak_test3 - */ -class NeXusFileLeakTest : public CxxTest::TestSuite { -public: - static NeXusFileLeakTest *createSuite() { return new NeXusFileLeakTest(); } - static void destroySuite(NeXusFileLeakTest *suite) { delete suite; } - NeXusFileLeakTest() : CxxTest::TestSuite() { Mantid::API::FrameworkManager::Instance(); } + /** + * These correspond to former napi tests + * - leak_test1 + * - leak_test2 + * - leak_test3 + */ void test_leak1() { int const nReOpen = 1000; - cout << "Running for " << nReOpen << " iterations\n"; - std::string const szFile("leak_test1.nxs"); + cout << "Running Leak Test 1: " << nReOpen << " iterations\n"; + string const szFile("nexus_leak_test1.nxs"); removeFile(szFile); // in case it was left over from previous run @@ -377,6 +371,7 @@ class NeXusFileLeakTest : public CxxTest::TestSuite { } removeFile(szFile); // cleanup + cout << "Leak Test 1 Success!\n"; } void test_leak2() { @@ -385,12 +380,13 @@ class NeXusFileLeakTest : public CxxTest::TestSuite { int const nData = 10; vector const i2_array{1000, 2000, 3000, 4000}; - cout << strmakef("Running for %d iterations", nFiles); + cout << "Running Leak Test 2: " << nFiles << " iterations\n"; + NXaccess access_mode = NXACC_CREATE5; std::string strFile; for (int iFile = 0; iFile < nFiles; iFile++) { - strFile = strmakef("leak_test2_%03d.nxs", iFile); + strFile = strmakef("nexus_leak_test2_%03d.nxs", iFile); removeFile(strFile); cout << "file " << strFile << "\n"; @@ -419,20 +415,34 @@ class NeXusFileLeakTest : public CxxTest::TestSuite { fileid.close(); removeFile(strFile); } + cout << "Leak Test 2 Success!\n"; } void test_leak3() { + cout << "Running Leak Test 3\n"; + fflush(stdout); const int nFiles = 10; const int nEntry = 2; const int nData = 2; - DimVector array_dims({512, 512}); - std::string const szFile("leak_test.nxs"); - const int iBinarySize = 512 * 512; +#ifdef WIN32 + // NOTE the Windows runners do not have enough stack space for the full test (max 1MB stack) + // Rather than skip the entire test, we can use a smaller array size + // It is no longer testing the same behavior on Windows with this choice. + std::size_t const TEST_SIZE(8); +#else + std::size_t const TEST_SIZE(512); +#endif // WIN32 + DimVector array_dims({TEST_SIZE, TEST_SIZE}); + std::string const szFile("nexus_leak_test3.nxs"); + int const iBinarySize = TEST_SIZE * TEST_SIZE; + cout << "Creating array of " << iBinarySize << " integers\n"; + fflush(stdout); int aiBinaryData[iBinarySize]; for (int i = 0; i < iBinarySize; i++) { aiBinaryData[i] = rand(); } + cout << "Created " << iBinarySize << " random integers\n"; for (int iFile = 0; iFile < nFiles; iFile++) { cout << "file " << iFile << "\n"; @@ -466,5 +476,338 @@ class NeXusFileLeakTest : public CxxTest::TestSuite { // Delete file removeFile(szFile); } + cout << "Leak Test 3 Success!\n"; + } + + /** + * These tests correspond to tests inside napi_test.cpp + * Refactored to work as unit tests with asserts and comparisons + * as opposed to a single long print-out test + */ + +private: + File do_prep_files(std::string const nxFile) { + removeFile(nxFile); // in case previous run didn't clean up + + cout << "Creating \"" << nxFile << "\"" << endl; + // create file + File fileid(nxFile, NXACC_CREATE5); + + fileid.makeGroup("entry", "NXentry"); + fileid.openGroup("entry", "NXentry"); + fileid.putAttr("hugo", "namenlos"); + fileid.putAttr("cucumber", "passion"); + return fileid; + } + + template void do_rw_test(File &fileid, std::string const &dataname, T const &data) { + cout << "Testing data " << dataname << "\n"; + // write + fileid.writeData(dataname, data); + + // read + T output; + fileid.readData(dataname, output); + + // compare + TS_ASSERT_EQUALS(data, output); + } + + template + void do_rw2darray_test(File &fileid, std::string const &dataname, T const (&data)[N][M]) { + cout << "Testing attribute " << dataname << "\n"; + // write + fileid.makeData(dataname, getType(), DimVector({N, M})); + fileid.openData(dataname); + fileid.putData(data); + fileid.closeData(); + + // read + T output[N][M]; + fileid.openData(dataname); + fileid.getData(&(output[0][0])); + fileid.closeData(); + + // compare + for (size_t i = 0; i < N; i++) { + for (size_t j = 0; j < M; j++) { + TS_ASSERT_EQUALS(data[i][j], output[i][j]); + } + } + } + + template void do_rwslabvec_test(File &fileid, std::string const dataname, vector const &data) { + cout << "Testing slab " << dataname << "\n"; + + // write + dimsize_t dimsize = data.size(); + DimSizeVector const start({0}), size({dimsize}); + fileid.makeData(dataname, getType(), dimsize); + fileid.openData(dataname); + fileid.putSlab(data, start, size); + fileid.closeData(); + + // read + int const Ncheck(5); // can't use variable-length arrays, just check this many + T output[Ncheck]; + fileid.openData(dataname); + fileid.getSlab(&output, start, size); + + // compare + for (int i = 0; i < Ncheck; i++) { + TS_ASSERT_EQUALS(data[i], output[i]) + } + } + + template + void do_rwslab_test(File &fileid, std::string const dataname, T const (&data)[N][M]) { + cout << "Testing slab " << dataname << "\n"; + + // write + DimSizeVector start({0, 0}), size({N, M}); + DimVector const dims({N, M}); + fileid.makeData(dataname, getType(), dims); + fileid.openData(dataname); + fileid.putSlab(&(data[0][0]), start, size); + fileid.closeData(); + + // prepare to read/compare + T output[N][M]; + fileid.openData(dataname); + + // read, compare, row-by-row + for (size_t i = 1; i <= N; i++) { + size = {(dimsize_t)i, (dimsize_t)M}; + fileid.getSlab(&output, start, size); + for (size_t j = 0; j < M; j++) { + TS_ASSERT_EQUALS(data[0][j], output[0][j]); + } + } + } + +public: + void test_napi_char() { + cout << "Starting NAPI CHAR Test\n"; + std::string const nxFile("NexusFile_test_char.h5"); + File fileid = do_prep_files(nxFile); + + // tests of string/char read/write + string const ch_test_data = "NeXus ><}&{'\\&\" Data"; + char const c1_array[5][4] = { + {'a', 'b', 'c', 'd'}, {'e', 'f', 'g', 'h'}, {'i', 'j', 'k', 'l'}, {'m', 'n', 'o', 'p'}, {'q', 'r', 's', 't'}}; + char const c2_array[3][2] = {{'z', 'y'}, {'x', 'w'}, {'v', 'u'}}; + char const c3_array[6][1] = {{'z'}, {'y'}, {'x'}, {'w'}, {'v'}, {'u'}}; + char const c4_array[1][7] = {{'a', 'b', 'c', 'd', 'e', 'f', 'g'}}; + do_rw_test(fileid, "ch_data", ch_test_data); + do_rw2darray_test(fileid, "c1_data", c1_array); + do_rw2darray_test(fileid, "c2_data", c2_array); + do_rw2darray_test(fileid, "c3_data", c3_array); + do_rw2darray_test(fileid, "c4_data", c4_array); + + // check all attributes + auto attrs = fileid.getAttrInfos(); + vector exp_attr_names({"hugo", "cucumber"}); + vector attr_names; + for (auto x : attrs) { + attr_names.push_back(x.name); + } + TS_ASSERT_EQUALS(attr_names, exp_attr_names); + + // check all entries + vector entry_names({"c1_data", "c2_data", "c3_data", "c4_data", "ch_data"}); + Entries exp_entries; + for (string x : entry_names) { + exp_entries[x] = "SDS"; + } + Entries entries = fileid.getEntries(); + TS_ASSERT_EQUALS(entries, exp_entries); + + // cleanup and return + fileid.close(); + cout << "napi slab test done\n"; + removeFile(nxFile); + } + + void test_napi_vec() { + cout << "Starting NAPI VEC Test\n"; + std::string const nxFile("NexusFile_test_vec.h5"); + File fileid = do_prep_files(nxFile); + + // tests of integer read/write + vector const i1_array{1, 2, 3, 4}; + vector const i2_array{1000, 2000, 3000, 4000}; + vector const i4_array{1000000, 2000000, 3000000, 4000000}; + do_rw_test(fileid, "i1_data", i1_array); + do_rw_test(fileid, "i2_data", i2_array); + do_rw_test(fileid, "i4_data", i4_array); + + // tests of float read/write + vector const r4_vec{12.f, 13.f, 14.f, 15.f, 16.f}; + vector const r8_vec{12.l, 13.l, 14.l, 15.l, 16.l}; + float const r4_array[5][4] = { + {1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 11., 12.}, {13., 14., 15., 16.}, {17., 18., 19., 20.}}; + double const r8_array[5][4] = { + {1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 11., 12.}, {13., 14., 15., 16.}, {17., 18., 19., 20.}}; + do_rw_test(fileid, "r4_vec_data", r4_vec); + do_rw_test(fileid, "r8_vec_data", r8_vec); + do_rw2darray_test(fileid, "r4_data", r4_array); + do_rw2darray_test(fileid, "r8_data", r8_array); + + // check all entries + vector entry_names({"i1_data", "i2_data", "i4_data", "r4_data", "r4_vec_data", "r8_data", "r8_vec_data"}); + Entries exp_entries; + for (string x : entry_names) { + exp_entries[x] = "SDS"; + } + Entries entries = fileid.getEntries(); + TS_ASSERT_EQUALS(entries, exp_entries); + + // cleanup and return + fileid.close(); + cout << "napi slab test done\n"; + removeFile(nxFile); + } + + void test_napi_slab() { + cout << "Starting NAPI SLAB Test\n"; + std::string const nxFile("NExusFile_test_vec.h5"); + File fileid = do_prep_files(nxFile); + + // test of slab read/write + vector const r4_vec{12.f, 13.f, 14.f, 15.f, 16.f}; + vector const r8_vec{12.l, 13.l, 14.l, 15.l, 16.l}; + float const r4_array[5][4] = { + {1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 11., 12.}, {13., 14., 15., 16.}, {17., 18., 19., 20.}}; + double const r8_array[5][4] = { + {1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 11., 12.}, {13., 14., 15., 16.}, {17., 18., 19., 20.}}; + do_rwslabvec_test(fileid, "r4_slab", r4_vec); + do_rwslabvec_test(fileid, "r8_slab", r8_vec); + do_rwslab_test(fileid, "r4_slab2d", r4_array); + do_rwslab_test(fileid, "r8_slab2d", r8_array); + + // check all entries + vector entry_names({"r4_slab", "r4_slab2d", "r8_slab", "r8_slab2d"}); + Entries exp_entries; + for (string x : entry_names) { + exp_entries[x] = "SDS"; + } + Entries entries = fileid.getEntries(); + TS_ASSERT_EQUALS(entries, exp_entries); + + // cleanup and return + fileid.close(); + cout << "napi slab test done\n"; + removeFile(nxFile); + } + + void test_openPath() { + cout << "tests for openPath\n"; + + // make file with path /entry + string const filename("NexusFile_openpathtest.nxs"); + File fileid = do_prep_files(filename); + + // make path /entry/data1 + fileid.writeData("data1", '1'); + + // make path /entry/data2 + fileid.writeData("data2", '2'); + + // make path /entry/data1/more_data + fileid.makeGroup("data", "NXdata"); + fileid.openGroup("data", "NXdata"); + fileid.writeData("more_data", '3'); + + // make path /link + fileid.closeGroup(); // close /entry/data + fileid.closeGroup(); // close /entry + fileid.makeGroup("link", "NXentry"); + fileid.openGroup("link", "NXentry"); // open /link + fileid.writeData("data4", '4'); + + // compare + char output; + fileid.closeGroup(); + + fileid.openPath("/entry/data1"); + fileid.getData(&output); + TS_ASSERT_EQUALS('1', output); + + fileid.openPath("/link/data4"); + fileid.getData(&output); + TS_ASSERT_EQUALS('4', output); + + fileid.openPath("/entry/data/more_data"); + fileid.getData(&output); + TS_ASSERT_EQUALS('3', output); + + fileid.openData("/entry/data2"); + fileid.getData(&output); + TS_ASSERT_EQUALS('2', output); + + // cleanup + fileid.close(); + removeFile(filename); + cout << "NXopenpath checks OK\n"; + } + + void test_links() { + cout << "tests of linkature\n"; + + string const filename("NexusFIle_linktest.nxs"); + removeFile(filename); + File fileid = do_prep_files(filename); + + // Create some data with a link + cout << "create entry at /entry/some_data\n"; + string const somedata("this is some data"); + fileid.makeData("some_data", NXnumtype::CHAR, DimVector({(dimsize_t)somedata.size()})); + fileid.openData("some_data"); + fileid.putData(&somedata); + NXlink datalink = fileid.getDataID(); + fileid.closeData(); + fileid.flush(); + // Create a group, and link it to that data + cout << "create group at /entry/data to link to the data\n"; + fileid.makeGroup("data", "NXdata"); + fileid.openGroup("data", "NXdata"); + fileid.makeLink(datalink); + fileid.closeGroup(); + fileid.flush(); + + // check data link + fileid.openPath("/entry/data/some_data"); + // TODO why can't we get the data through the link? + // string output1; + // fileid.getData(&output1); + // TS_ASSERT_EQUALS(somedata, output1); + NXlink res1 = fileid.getDataID(); + TS_ASSERT_EQUALS(datalink.linkType, res1.linkType); + TS_ASSERT_EQUALS(string(datalink.targetPath), string(res1.targetPath)); + printf("data link works\n"); + fileid.closeGroup(); + + // Create two groups, group1 and group2 + // Make a link inside group2 to group1 + // make group1 + cout << "create group /entry/group1\n"; + std::string const strdata("NeXus sample data"); + fileid.makeGroup("group1", "NXentry"); + fileid.openGroup("group1", "NXentry"); + NXlink grouplink = fileid.getGroupID(); + fileid.closeGroup(); + // make group 2 + cout << "create group /entry/group2/group1\n"; + fileid.makeGroup("group2", "NXentry"); + fileid.openGroup("group2", "NXentry"); + fileid.makeLink(grouplink); + fileid.closeGroup(); + + // check group link + fileid.openPath("/entry/group2/group1"); + NXlink res2 = fileid.getGroupID(); + TS_ASSERT_EQUALS(grouplink.linkType, res2.linkType); + TS_ASSERT_EQUALS(string(grouplink.targetPath), string(res2.targetPath)); + printf("group link works\n"); } }; diff --git a/Framework/Nexus/test/napi_test.cpp b/Framework/Nexus/test/napi_test.cpp index e55c2b17c1ef..2b689733623d 100644 --- a/Framework/Nexus/test/napi_test.cpp +++ b/Framework/Nexus/test/napi_test.cpp @@ -42,6 +42,10 @@ using NexusNapiTest::removeFile; using NexusNapiTest::write_dmc01; using NexusNapiTest::write_dmc02; +#define ASSERT_NO_ERROR(status, msg) \ + if ((status) != NXstatus::NX_OK) \ + ON_ERROR(msg); + namespace { // anonymous namespace std::string relativePathOf(const std::string &filename) { return std::filesystem::path(filename).filename().string(); } } // anonymous namespace @@ -53,9 +57,6 @@ int main(int argc, char *argv[]) { if (strstr(argv[0], "napi_test_hdf5") != NULL) { nx_creation_code = NXACC_CREATE5; nxFile = "NXtest.h5"; - } else if (strstr(argv[0], "napi_test_hdf4") != NULL) { - nx_creation_code = NXACC_CREATE4; - nxFile = "NXtest.hdf"; } else { ON_ERROR(std::string(argv[0]) + " is not supported"); } @@ -64,7 +65,7 @@ int main(int argc, char *argv[]) { #ifdef WIN32 // these have issues on windows UNUSED_ARG(nx_creation_code); UNUSED_ARG(argc); -#else // WIN32 +#else // WIN32 // ------------------------------------------> TODO fine up to here "nexuscpptest-c-hdf5-test" int i, j, NXlen; float r; @@ -88,127 +89,74 @@ int main(int argc, char *argv[]) { std::cout << "Creating \"" << nxFile << "\"" << std::endl; // create file - if (NXopen(nxFile.c_str(), nx_creation_code, &fileid) != NXstatus::NX_OK) { - std::cerr << "Failed to NXopen(" << nxFile << ", " << nx_creation_code << ", fileid)\n"; - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopen(nxFile.c_str(), nx_creation_code, &fileid), "Failure in NXopen for " + nxFile); if (nx_creation_code == NXACC_CREATE5) { std::cout << "Trying to reopen the file handle" << std::endl; NXhandle clone_fileid; - if (NXreopen(fileid, &clone_fileid) != NXstatus::NX_OK) { - std::cerr << "Failed to NXreopen " << nxFile << "\n"; - return TEST_FAILED; - } - } - if (NXmakegroup(fileid, "entry", "NXentry") != NXstatus::NX_OK) - ON_ERROR("NXmakegroup(fileid, \"entry\", \"NXentry\")"); - if (NXopengroup(fileid, "entry", "NXentry") != NXstatus::NX_OK) - ON_ERROR("NXopengroup(fileid, \"entry\", \"NXentry\")"); - if (NXputattr(fileid, "hugo", "namenlos", static_cast(strlen("namenlos")), NXnumtype::CHAR) != NXstatus::NX_OK) - ON_ERROR("NXputattr(fileid, \"hugo\", \"namenlos\", strlen, NXnumtype::CHAR)"); - if (NXputattr(fileid, "cucumber", "passion", static_cast(strlen("passion")), NXnumtype::CHAR) != NXstatus::NX_OK) - ON_ERROR("NXputattr(fileid, \"cucumber\", \"passion\", strlen, NXnumtype::CHAR)"); + ASSERT_NO_ERROR(NXreopen(fileid, &clone_fileid), "Failed to NXreopen " + nxFile); + } + // open group entry + ASSERT_NO_ERROR(NXmakegroup(fileid, "entry", "NXentry"), "NXmakegroup(fileid, \"entry\", \"NXentry\")"); + ASSERT_NO_ERROR(NXopengroup(fileid, "entry", "NXentry"), "NXopengroup(fileid, \"entry\", \"NXentry\")"); + ASSERT_NO_ERROR(NXputattr(fileid, "hugo", "namenlos", static_cast(strlen("namenlos")), NXnumtype::CHAR), + "NXputattr(fileid, \"hugo\", \"namenlos\", strlen, NXnumtype::CHAR)"); + ASSERT_NO_ERROR(NXputattr(fileid, "cucumber", "passion", static_cast(strlen("passion")), NXnumtype::CHAR), + "NXputattr(fileid, \"cucumber\", \"passion\", strlen, NXnumtype::CHAR)"); NXlen = static_cast(strlen(ch_test_data)); - if (NXmakedata(fileid, "ch_data", NXnumtype::CHAR, 1, &NXlen) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "ch_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, ch_test_data) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakedata(fileid, "c1_data", NXnumtype::CHAR, 2, array_dims) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "c1_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, c1_array) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakedata(fileid, "i1_data", NXnumtype::INT8, 1, &array_dims[1]) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "i1_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, i1_array) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakedata(fileid, "i2_data", NXnumtype::INT16, 1, &array_dims[1]) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "i2_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, i2_array) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakedata(fileid, "i4_data", NXnumtype::INT32, 1, &array_dims[1]) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "i4_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, i4_array) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXcompmakedata(fileid, "r4_data", NXnumtype::FLOAT32, 2, array_dims, NX_COMP_LZW, chunk_size) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "r4_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, r4_array) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakedata(fileid, "r8_data", NXnumtype::FLOAT64, 2, array_dims) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "r8_data") != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXmakedata(fileid, "ch_data", NXnumtype::CHAR, 1, &NXlen), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "ch_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, ch_test_data), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXmakedata(fileid, "c1_data", NXnumtype::CHAR, 2, array_dims), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "c1_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, c1_array), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXmakedata(fileid, "i1_data", NXnumtype::INT8, 1, &array_dims[1]), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "i1_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, i1_array), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXmakedata(fileid, "i2_data", NXnumtype::INT16, 1, &array_dims[1]), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "i2_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, i2_array), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXmakedata(fileid, "i4_data", NXnumtype::INT32, 1, &array_dims[1]), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "i4_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, i4_array), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXcompmakedata(fileid, "r4_data", NXnumtype::FLOAT32, 2, array_dims, NX_COMP_LZW, chunk_size), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "r4_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, r4_array), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + + // BEGIN DOUBLE SLAB + ASSERT_NO_ERROR(NXmakedata(fileid, "r8_data", NXnumtype::FLOAT64, 2, array_dims), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "r8_data"), ""); slab_start[0] = 4; slab_start[1] = 0; slab_size[0] = 1; slab_size[1] = 4; // cppcheck-suppress cstyleCast - if (NXputslab(fileid, (double *)r8_array + 16, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXputslab(fileid, (double *)r8_array + 16, slab_start, slab_size), ""); slab_start[0] = 0; slab_start[1] = 0; slab_size[0] = 4; slab_size[1] = 4; - if (NXputslab(fileid, r8_array, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputattr(fileid, "ch_attribute", ch_test_data, static_cast(strlen(ch_test_data)), NXnumtype::CHAR) != - NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXputslab(fileid, r8_array, slab_start, slab_size), ""); + ASSERT_NO_ERROR( + NXputattr(fileid, "ch_attribute", ch_test_data, static_cast(strlen(ch_test_data)), NXnumtype::CHAR), ""); i = 42; - if (NXputattr(fileid, "i4_attribute", &i, 1, NXnumtype::INT32) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXputattr(fileid, "i4_attribute", &i, 1, NXnumtype::INT32), ""); r = static_cast(3.14159265); - if (NXputattr(fileid, "r4_attribute", &r, 1, NXnumtype::FLOAT32) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetdataID(fileid, &dlink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (nx_creation_code != NXACC_CREATE4) { -#if HAVE_LONG_LONG_INT - const int64_t grossezahl[4] = {12, 555555555555LL, 23, 777777777777LL}; -#else - const int64_t grossezahl[4] = {12, 555555, 23, 77777}; -#endif /* HAVE_LONG_LONG_INT */ - int dims[1] = {4}; - if (NXmakedata(fileid, "grosse_zahl", NXnumtype::INT64, 1, dims) == NXstatus::NX_OK) { - if (NXopendata(fileid, "grosse_zahl") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, grossezahl) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - } - } - if (NXmakegroup(fileid, "data", "NXdata") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopengroup(fileid, "data", "NXdata") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakelink(fileid, &dlink) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXputattr(fileid, "r4_attribute", &r, 1, NXnumtype::FLOAT32), ""); + ASSERT_NO_ERROR(NXgetdataID(fileid, &dlink), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + // END DOUBLE SLAB + + // BEGIN LINK TEST + // open group entry/data + ASSERT_NO_ERROR(NXmakegroup(fileid, "data", "NXdata"), ""); + ASSERT_NO_ERROR(NXopengroup(fileid, "data", "NXdata"), ""); + ASSERT_NO_ERROR(NXmakelink(fileid, &dlink), ""); int dims[2] = {100, 20}; for (i = 0; i < 100; i++) { for (j = 0; j < 20; j++) { @@ -216,63 +164,45 @@ int main(int argc, char *argv[]) { } } int cdims[2] = {20, 20}; - if (NXcompmakedata(fileid, "comp_data", NXnumtype::INT32, 2, dims, NX_COMP_LZW, cdims) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "comp_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, comp_array) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXflush(&fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakedata(fileid, "flush_data", NXnumtype::INT32, 1, unlimited_dims) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXcompmakedata(fileid, "comp_data", NXnumtype::INT32, 2, dims, NX_COMP_LZW, cdims), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "comp_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, comp_array), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXflush(&fileid), ""); + ASSERT_NO_ERROR(NXmakedata(fileid, "flush_data", NXnumtype::INT32, 1, unlimited_dims), ""); slab_size[0] = 1; for (i = 0; i < 7; i++) { slab_start[0] = i; - if (NXopendata(fileid, "flush_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputslab(fileid, &i, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXflush(&fileid) != NXstatus::NX_OK) - return TEST_FAILED; - } - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakegroup(fileid, "sample", "NXsample") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopengroup(fileid, "sample", "NXsample") != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopendata(fileid, "flush_data"), ""); + ASSERT_NO_ERROR(NXputslab(fileid, &i, slab_start, slab_size), ""); + ASSERT_NO_ERROR(NXflush(&fileid), ""); + } + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); + // close group entry/data + // open group entry/sample + ASSERT_NO_ERROR(NXmakegroup(fileid, "sample", "NXsample"), ""); + ASSERT_NO_ERROR(NXopengroup(fileid, "sample", "NXsample"), ""); NXlen = 12; - if (NXmakedata(fileid, "ch_data", NXnumtype::CHAR, 1, &NXlen) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "ch_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(fileid, "NeXus sample") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetgroupID(fileid, &glink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakegroup(fileid, "link", "NXentry") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopengroup(fileid, "link", "NXentry") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakelink(fileid, &glink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakenamedlink(fileid, "renLinkGroup", &glink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXmakenamedlink(fileid, "renLinkData", &dlink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclose(&fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXmakedata(fileid, "ch_data", NXnumtype::CHAR, 1, &NXlen), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "ch_data"), ""); + ASSERT_NO_ERROR(NXputdata(fileid, "NeXus sample"), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXgetgroupID(fileid, &glink), ""); + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); + // close group entry/sample + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); + // close group entry + // open group link + ASSERT_NO_ERROR(NXmakegroup(fileid, "link", "NXentry"), ""); + ASSERT_NO_ERROR(NXopengroup(fileid, "link", "NXentry"), ""); + ASSERT_NO_ERROR(NXmakelink(fileid, &glink), ""); + ASSERT_NO_ERROR(NXmakenamedlink(fileid, "renLinkGroup", &glink), ""); + ASSERT_NO_ERROR(NXmakenamedlink(fileid, "renLinkData", &dlink), ""); + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); + // close group link + ASSERT_NO_ERROR(NXclose(&fileid), ""); + // close file + // END LINK TEST if ((argc >= 2) && !strcmp(argv[1], "-q")) { return TEST_SUCCEED; /* create only */ @@ -284,14 +214,9 @@ int main(int argc, char *argv[]) { // read test std::cout << "Read/Write to read \"" << nxFile << "\"" << std::endl; - if (NXopen(nxFile.c_str(), NXACC_RDWR, &fileid) != NXstatus::NX_OK) { - std::cerr << "Failed to open \"" << nxFile << "\" for read/write" << std::endl; - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopen(nxFile.c_str(), NXACC_RDWR, &fileid), "Failed to open \"" << nxFile << "\" for read/write"); char filename[256]; - if (NXinquirefile(fileid, filename, 256) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXinquirefile(fileid, filename, 256), ""); std::cout << "NXinquirefile found: " << relativePathOf(filename) << std::endl; NXgetattrinfo(fileid, &i); if (i > 0) { @@ -309,8 +234,7 @@ int main(int argc, char *argv[]) { switch (NXtype) { case NXnumtype::CHAR: NXlen = sizeof(char_buffer); - if (NXgetattr(fileid, name, char_buffer, &NXlen, &NXtype) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetattr(fileid, name, char_buffer, &NXlen, &NXtype), ""); if (strcmp(name, "file_time") && strcmp(name, "HDF_version") && strcmp(name, "HDF5_Version") && strcmp(name, "XML_version")) { printf(" %s = %s\n", name, char_buffer); @@ -321,12 +245,10 @@ int main(int argc, char *argv[]) { } } } while (attr_status == NXstatus::NX_OK); - if (NXopengroup(fileid, "entry", "NXentry") != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopengroup(fileid, "entry", "NXentry"), ""); NXgetattrinfo(fileid, &i); std::cout << "Number of group attributes: " << i << std::endl; - if (NXgetpath(fileid, path, 512) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetpath(fileid, path, 512), ""); std::cout << "NXentry path " << path << std::endl; do { // cppcheck-suppress argumentSize @@ -336,15 +258,13 @@ int main(int argc, char *argv[]) { if (attr_status == NXstatus::NX_OK) { if (NXtype == NXnumtype::CHAR) { NXlen = sizeof(char_buffer); - if (NXgetattr(fileid, name, char_buffer, &NXlen, &NXtype) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetattr(fileid, name, char_buffer, &NXlen, &NXtype), ""); printf(" %s = %s\n", name, char_buffer); } } } while (attr_status == NXstatus::NX_OK); // cppcheck-suppress argumentSize - if (NXgetgroupinfo(fileid, &i, group_name, class_name) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetgroupinfo(fileid, &i, group_name, class_name), ""); std::cout << "Group: " << group_name << "(" << class_name << ") contains " << i << " items\n"; do { // cppcheck-suppress argumentSize @@ -359,55 +279,43 @@ int main(int argc, char *argv[]) { } else { void *data_buffer; if (entry_status == NXstatus::NX_OK) { - if (NXopendata(fileid, name) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetpath(fileid, path, 512) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopendata(fileid, name), ""); + ASSERT_NO_ERROR(NXgetpath(fileid, path, 512), ""); printf("Data path %s\n", path); - if (NXgetinfo(fileid, &NXrank, NXdims, &NXtype) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetinfo(fileid, &NXrank, NXdims, &NXtype), ""); printf(" %s(%d)", name, (int)NXtype); // cppcheck-suppress cstyleCast - if (NXmalloc((void **)&data_buffer, NXrank, NXdims, NXtype) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXmalloc((void **)&data_buffer, NXrank, NXdims, NXtype), ""); int n = 1; for (int k = 0; k < NXrank; k++) { n *= NXdims[k]; } if (NXtype == NXnumtype::CHAR) { - if (NXgetdata(fileid, data_buffer) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetdata(fileid, data_buffer), ""); print_data(" = ", std::cout, data_buffer, NXtype, n); } else if (NXtype != NXnumtype::FLOAT32 && NXtype != NXnumtype::FLOAT64) { - if (NXgetdata(fileid, data_buffer) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetdata(fileid, data_buffer), ""); print_data(" = ", std::cout, data_buffer, NXtype, n); } else { slab_start[0] = 0; slab_start[1] = 0; slab_size[0] = 1; slab_size[1] = 4; - if (NXgetslab(fileid, data_buffer, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetslab(fileid, data_buffer, slab_start, slab_size), ""); print_data("\n ", std::cout, data_buffer, NXtype, 4); slab_start[0] = TEST_FAILED; - if (NXgetslab(fileid, data_buffer, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetslab(fileid, data_buffer, slab_start, slab_size), ""); print_data(" ", std::cout, data_buffer, NXtype, 4); slab_start[0] = 2; - if (NXgetslab(fileid, data_buffer, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetslab(fileid, data_buffer, slab_start, slab_size), ""); print_data(" ", std::cout, data_buffer, NXtype, 4); slab_start[0] = 3; - if (NXgetslab(fileid, data_buffer, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetslab(fileid, data_buffer, slab_start, slab_size), ""); print_data(" ", std::cout, data_buffer, NXtype, 4); slab_start[0] = 4; - if (NXgetslab(fileid, data_buffer, slab_start, slab_size) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetslab(fileid, data_buffer, slab_start, slab_size), ""); print_data(" ", std::cout, data_buffer, NXtype, 4); - if (NXgetattrinfo(fileid, &i) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetattrinfo(fileid, &i), ""); if (i > 0) { printf(" Number of attributes : %d\n", i); } @@ -420,20 +328,17 @@ int main(int argc, char *argv[]) { switch (NXtype) { case NXnumtype::INT32: NXlen = TEST_FAILED; - if (NXgetattr(fileid, name, &i, &NXlen, &NXtype) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetattr(fileid, name, &i, &NXlen, &NXtype), ""); printf(" %s : %d\n", name, i); break; case NXnumtype::FLOAT32: NXlen = TEST_FAILED; - if (NXgetattr(fileid, name, &r, &NXlen, &NXtype) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetattr(fileid, name, &r, &NXlen, &NXtype), ""); printf(" %s : %f\n", name, r); break; case NXnumtype::CHAR: NXlen = sizeof(char_buffer); - if (NXgetattr(fileid, name, char_buffer, &NXlen, &NXtype) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetattr(fileid, name, char_buffer, &NXlen, &NXtype), ""); printf(" %s : %s\n", name, char_buffer); break; default: @@ -442,43 +347,28 @@ int main(int argc, char *argv[]) { } } while (attr_status == NXstatus::NX_OK); } - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXclosedata(fileid), ""); // cppcheck-suppress cstyleCast - if (NXfree((void **)&data_buffer) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXfree((void **)&data_buffer), ""); } } } while (entry_status == NXstatus::NX_OK); - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); // check links std::cout << "check links\n"; NXlink blink; - if (NXopengroup(fileid, "entry", "NXentry") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopengroup(fileid, "sample", "NXsample") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetgroupID(fileid, &glink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopengroup(fileid, "data", "NXdata") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "r8_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetdataID(fileid, &dlink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(fileid, "r8_data") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetdataID(fileid, &blink) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopengroup(fileid, "entry", "NXentry"), ""); + ASSERT_NO_ERROR(NXopengroup(fileid, "sample", "NXsample"), ""); + ASSERT_NO_ERROR(NXgetgroupID(fileid, &glink), ""); + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); + ASSERT_NO_ERROR(NXopengroup(fileid, "data", "NXdata"), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "r8_data"), ""); + ASSERT_NO_ERROR(NXgetdataID(fileid, &dlink), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); + ASSERT_NO_ERROR(NXopendata(fileid, "r8_data"), ""); + ASSERT_NO_ERROR(NXgetdataID(fileid, &blink), ""); + ASSERT_NO_ERROR(NXclosedata(fileid), ""); if (NXsameID(fileid, &dlink, &blink) != NXstatus::NX_OK) { std::cout << "Link check FAILED (r8_data)\n" << "original data\n"; @@ -487,18 +377,13 @@ int main(int argc, char *argv[]) { NXIprintlink(fileid, &blink); return TEST_FAILED; } - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); - if (NXopengroup(fileid, "link", "NXentry") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopengroup(fileid, "sample", "NXsample") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetpath(fileid, path, 512) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopengroup(fileid, "link", "NXentry"), ""); + ASSERT_NO_ERROR(NXopengroup(fileid, "sample", "NXsample"), ""); + ASSERT_NO_ERROR(NXgetpath(fileid, path, 512), ""); std::cout << "Group path " << path << "\n"; - if (NXgetgroupID(fileid, &blink) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXgetgroupID(fileid, &blink), ""); if (NXsameID(fileid, &glink, &blink) != NXstatus::NX_OK) { std::cout << "Link check FAILED (sample)\n" << "original group\n"; @@ -507,12 +392,10 @@ int main(int argc, char *argv[]) { NXIprintlink(fileid, &blink); return TEST_FAILED; } - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); std::cout << "renLinkGroup NXsample test\n"; - if (NXopengroup(fileid, "renLinkGroup", "NXsample") != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopengroup(fileid, "renLinkGroup", "NXsample"), ""); if (NXgetgroupID(fileid, &blink) != NXstatus::NX_OK) return TEST_FAILED; if (NXsameID(fileid, &glink, &blink) != NXstatus::NX_OK) { @@ -523,14 +406,11 @@ int main(int argc, char *argv[]) { NXIprintlink(fileid, &blink); return TEST_FAILED; } - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); std::cout << "renLinkData test\n"; - if (NXopendata(fileid, "renLinkData") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXgetdataID(fileid, &blink) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopendata(fileid, "renLinkData"), ""); + ASSERT_NO_ERROR(NXgetdataID(fileid, &blink), ""); if (NXsameID(fileid, &dlink, &blink) != NXstatus::NX_OK) { std::cout << "Link check FAILED (renLinkData)\n" << "original group\n"; @@ -539,33 +419,20 @@ int main(int argc, char *argv[]) { NXIprintlink(fileid, &blink); return TEST_FAILED; } - if (NXclosedata(fileid) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXclosegroup(fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXclosedata(fileid), ""); + ASSERT_NO_ERROR(NXclosegroup(fileid), ""); std::cout << "Link check OK\n"; // tests for NXopenpath std::cout << "tests for NXopenpath\n"; - if (NXopenpath(fileid, "/entry/data/comp_data") != NXstatus::NX_OK) { - ON_ERROR("Failure on NXopenpath\n"); - } - if (NXopenpath(fileid, "/entry/data/comp_data") != NXstatus::NX_OK) { - ON_ERROR("Failure on NXopenpath\n"); - } - if (NXopenpath(fileid, "../r8_data") != NXstatus::NX_OK) { - ON_ERROR("Failure on NXopenpath\n"); - } - if (NXopengrouppath(fileid, "/entry/data/comp_data") != NXstatus::NX_OK) { - ON_ERROR("Failure on NXopengrouppath\n"); - } - if (NXopenpath(fileid, "/entry/data/r8_data") != NXstatus::NX_OK) { - ON_ERROR("Failure on NXopenpath\n"); - } + ASSERT_NO_ERROR(NXopenpath(fileid, "/entry/data/comp_data"), "Failure on NXopenpath\n"); + ASSERT_NO_ERROR(NXopenpath(fileid, "/entry/data/comp_data"), "Failure on NXopenpath\n"); + ASSERT_NO_ERROR(NXopenpath(fileid, "../r8_data"), "Failure on NXopenpath\n"); + ASSERT_NO_ERROR(NXopengrouppath(fileid, "/entry/data/comp_data"), "Failure on NXopengrouppath\n"); + ASSERT_NO_ERROR(NXopenpath(fileid, "/entry/data/r8_data"), "Failure on NXopenpath\n"); std::cout << "NXopenpath checks OK\n"; - if (NXclose(&fileid) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXclose(&fileid), ""); #endif // WIN32 std::cout << "before load path tests\n"; @@ -573,10 +440,8 @@ int main(int argc, char *argv[]) { return TEST_FAILED; std::cout << "before external link tests\n"; - if (testExternal(argv[0]) != TEST_SUCCEED) { + if (testExternal(argv[0]) != TEST_SUCCEED) return TEST_FAILED; - } - // cleanup and return std::cout << "all ok - done\n"; removeFile(nxFile); @@ -652,39 +517,25 @@ static int testExternal(const std::string &progName) { // create the test file NXhandle hfil; - if (NXopen(testFile.c_str(), create, &hfil) != NXstatus::NX_OK) { - std::cerr << "Failed to open \"" << testFile << "\" for writing\n"; - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopen(testFile.c_str(), create, &hfil), "Failed to open \"" + testFile + "\" for writing"); /*if(NXmakegroup(hfil,"entry1","NXentry") != NXstatus::NX_OK){ return TEST_FAILED; }*/ const std::string extFile1EntryPath = PROTOCOL + extFile1 + "#/entry1"; - if (NXlinkexternal(hfil, "entry1", "NXentry", extFile1EntryPath.c_str()) != NXstatus::NX_OK) { - std::cerr << "Failed to NXlinkexternal(hfil, \"entry1\", \"NXentry\", \"" << extFile1EntryPath << "\")\n"; - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXlinkexternal(hfil, "entry1", "NXentry", extFile1EntryPath.c_str()), + "Failed to NXlinkexternal(hfil, \"entry1\", \"NXentry\", \"" + extFile1EntryPath + "\")"); /*if(NXmakegroup(hfil,"entry2","NXentry") != NXstatus::NX_OK){ return TEST_FAILED; }*/ const std::string extFile2EntryPath = PROTOCOL + extFile2 + "#/entry1"; - if (NXlinkexternal(hfil, "entry2", "NXentry", extFile2EntryPath.c_str()) != NXstatus::NX_OK) { - std::cerr << "Failed to NXlinkexternal(hfil, \"entry2\", \"NXentry\", \"" << extFile2EntryPath << "\")\n"; - return TEST_FAILED; - } - if (NXmakegroup(hfil, "entry3", "NXentry") != NXstatus::NX_OK) { - return TEST_FAILED; - } - if (NXopengroup(hfil, "entry3", "NXentry") != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXlinkexternal(hfil, "entry2", "NXentry", extFile2EntryPath.c_str()), + "Failed to NXlinkexternal(hfil, \"entry2\", \"NXentry\", \"" + extFile2EntryPath + "\")"); + ASSERT_NO_ERROR(NXmakegroup(hfil, "entry3", "NXentry"), ""); + ASSERT_NO_ERROR(NXopengroup(hfil, "entry3", "NXentry"), ""); /* force create old style external link */ - if (NXmakedata(hfil, "extlinkdata", NXnumtype::FLOAT32, 1, &dummylen) != NXstatus::NX_OK) - return TEST_FAILED; - if (NXopendata(hfil, "extlinkdata") != NXstatus::NX_OK) - return TEST_FAILED; - if (NXputdata(hfil, &dummyfloat) != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXmakedata(hfil, "extlinkdata", NXnumtype::FLOAT32, 1, &dummylen), ""); + ASSERT_NO_ERROR(NXopendata(hfil, "extlinkdata"), ""); + ASSERT_NO_ERROR(NXputdata(hfil, &dummyfloat), ""); std::string temperaturePath(PROTOCOL + extFile1 + "#/entry1/sample/temperature_mean"); if (NXputattr(hfil, "napimount", temperaturePath.c_str(), static_cast(strlen(temperaturePath.c_str())), NXnumtype::CHAR) != NXstatus::NX_OK) @@ -694,61 +545,35 @@ static int testExternal(const std::string &progName) { return TEST_FAILED; } */ - if (NXopenpath(hfil, "/entry3") != NXstatus::NX_OK) { - std::cerr << "Failed to NXopenpath(hfil, \"/entry3\") during write\n"; - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopenpath(hfil, "/entry3"), "Failed to NXopenpath(hfil, \"/entry3\") during write"); /* create new style external link on hdf5 , equivalent to the above on other backends */ - if (NXlinkexternaldataset(hfil, "extlinknative", temperaturePath.c_str()) != NXstatus::NX_OK) { - std::cerr << "Failed to NXlinkexternaldataset(hfil, \"extlinknative\", \"" << temperaturePath << "\")\n"; - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXlinkexternaldataset(hfil, "extlinknative", temperaturePath.c_str()), + "Failed to NXlinkexternaldataset(hfil, \"extlinknative\", \"" + temperaturePath + "\")"); - if (NXclose(&hfil) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXclose(&hfil), ""); // actually test linking - if (NXopen(testFile.c_str(), NXACC_RDWR, &hfil) != NXstatus::NX_OK) { - std::cerr << "Failed to open \"" << testFile << "\" for read/write\n"; - return TEST_FAILED; - } - if (NXopenpath(hfil, "/entry1/start_time") != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopen(testFile.c_str(), NXACC_RDWR, &hfil), "Failed to open \"" + testFile + "\" for read/write"); + ASSERT_NO_ERROR(NXopenpath(hfil, "/entry1/start_time"), ""); char time[132]; memset(time, 0, 132); - if (NXgetdata(hfil, time) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXgetdata(hfil, time), ""); printf("First file time: %s\n", time); char filename[256]; - if (NXinquirefile(hfil, filename, 256) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXinquirefile(hfil, filename, 256), ""); std::cout << "NXinquirefile found: " << relativePathOf(filename) << "\n"; - if (NXopenpath(hfil, "/entry2/sample/sample_name") != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopenpath(hfil, "/entry2/sample/sample_name"), ""); memset(time, 0, 132); - if (NXgetdata(hfil, time) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXgetdata(hfil, time), ""); printf("Second file sample: %s\n", time); - if (NXinquirefile(hfil, filename, 256) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXinquirefile(hfil, filename, 256), ""); std::cout << "NXinquirefile found: " << relativePathOf(filename) << "\n"; - if (NXopenpath(hfil, "/entry2/start_time") != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopenpath(hfil, "/entry2/start_time"), ""); memset(time, 0, 132); - if (NXgetdata(hfil, time) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXgetdata(hfil, time), ""); printf("Second file time: %s\n", time); NXopenpath(hfil, "/"); if (NXisexternalgroup(hfil, "entry1", "NXentry", filename, 255) != NXstatus::NX_OK) { @@ -767,31 +592,21 @@ static int testExternal(const std::string &progName) { } else { printf("extlinkdata external URL = %s\n", filename); } - if (NXopendata(hfil, "extlinkdata") != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopendata(hfil, "extlinkdata"), ""); memset(&temperature, 0, 4); - if (NXgetdata(hfil, &temperature) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXgetdata(hfil, &temperature), ""); printf("value retrieved: %4.2f\n", temperature); - if (NXopenpath(hfil, "/entry3") != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXopenpath(hfil, "/entry3"), ""); if (NXisexternaldataset(hfil, "extlinknative", filename, 255) != NXstatus::NX_OK) { - printf("extlinknative should be external link\n"); - return TEST_FAILED; + ON_ERROR("extlinknative should be external link"); } else { printf("extlinknative external URL = %s\n", filename); } - if (NXopendata(hfil, "extlinknative") != NXstatus::NX_OK) - return TEST_FAILED; + ASSERT_NO_ERROR(NXopendata(hfil, "extlinknative"), ""); memset(&temperature, 0, 4); - if (NXgetdata(hfil, &temperature) != NXstatus::NX_OK) { - return TEST_FAILED; - } + ASSERT_NO_ERROR(NXgetdata(hfil, &temperature), ""); printf("value retrieved: %4.2f\n", temperature); - NXclose(&hfil); printf("External File Linking tested OK\n");