CI: Enable unit tests in GitLab

.gitlab/build_and_test.sh

@@ -175,6 +175,8 @@ then
         $cmake_exe \
             -C "${hostconfig_path}" \
             -DCMAKE_INSTALL_PREFIX=${install_dir} \
+            -DSUNDIALS_TEST_ENABLE_DIFF_OUTPUT=OFF \
+            -DSUNDIALS_TEST_ENABLE_UNIT_TESTS=ON \
             -DMPIEXEC_EXECUTABLE=$(which $MPIEXEC_EXECUTABLE) \
             -DMPIEXEC_PREFLAGS=${MPIEXEC_PREFLAGS} \
             -DMPIEXEC_POSTFLAGS=${MPIEXEC_POSTFLAGS} \
@@ -186,6 +188,8 @@ then
         $cmake_exe \
             -C "${hostconfig_path}" \
             -DCMAKE_INSTALL_PREFIX=${install_dir} \
+            -DSUNDIALS_TEST_ENABLE_DIFF_OUTPUT=OFF \
+            -DSUNDIALS_TEST_ENABLE_UNIT_TESTS=ON \
             -DMPIEXEC_EXECUTABLE=$(which $MPIEXEC_EXECUTABLE) \
             -DMPIEXEC_PREFLAGS=${MPIEXEC_PREFLAGS} \
             -DMPIEXEC_POSTFLAGS=${MPIEXEC_POSTFLAGS} \

scripts/spack/packages/sundials/package.py

@@ -75,10 +75,10 @@ class Sundials(CachedCMakePackage, CudaPackage, ROCmPackage):
 
     variant("cxxstd", default="14", description="C++ language standard", values=("14", "17"))
 
-    # Logging
+    # Logging (default=0 when "@6.2.0:6.7.0", default=2 when "@7.0.0:")
     variant(
         "logging-level",
-        default="0",
+        default="2",
         description="logging level\n 0 = no logging,\n 1 = errors,\n "
         "2 = errors + warnings,\n 3 = errors + "
         "warnings + info,\n 4 = errors + warnings + info + debugging, "
@@ -88,12 +88,12 @@ class Sundials(CachedCMakePackage, CudaPackage, ROCmPackage):
         when="@6.2.0:",
     )
 
-    # MPI logging
+    # MPI logging (option removed in 7.0)
     variant(
         "logging-mpi",
         default="OFF",
         description="enable MPI support in the logger",
-        when="@6.2.0:",
+        when="@6.2.0:6.7.0",
     )
 
     # Real type

test/unit_tests/arkode/gtest/test_arkode_error_handling.cpp

@@ -20,8 +20,6 @@
 #include "arkode/arkode_impl.h"
 #include "nvector/nvector_serial.h"
 #include "sundials/sundials_context.hpp"
-#include "sundials/sundials_logger.h"
-#include "sundials/sundials_nvector.h"
 
 static const std::string errfile{"test_arkode_error_handling.err"};
 
@@ -56,23 +54,36 @@ class ARKodeErrConditionTest : public testing::Test
 
 TEST_F(ARKodeErrConditionTest, WarningIsPrinted)
 {
-  SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   ARKodeMemRec* ark_mem = (ARKodeMemRec*)arkode_mem;
   arkProcessError(ark_mem, ARK_WARNING, __LINE__, __func__, __FILE__, "test");
-  SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  err = SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  ASSERT_EQ(err, SUN_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_WARNING
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[WARNING]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr("test")));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }
 
 TEST_F(ARKodeErrConditionTest, ErrorIsPrinted)
 {
-  SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   // negative reltol is illegal
-  ARKodeSStolerances(arkode_mem, /* reltol= */ -1e-4, /* abstol= */ 1e-4);
+  int ierr = ARKodeSStolerances(arkode_mem, /* reltol= */ -1e-4,
+                                /* abstol= */ 1e-4);
+  ASSERT_NE(ierr, ARK_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_ERROR
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[ERROR]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr(MSG_ARK_BAD_RELTOL)));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }

test/unit_tests/cvode/gtest/test_cvode_error_handling.cpp

@@ -10,7 +10,6 @@
  * SUNDIALS Copyright End
  * -----------------------------------------------------------------*/
 
-#include "gmock/gmock.h"
 #include <cvode/cvode.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -42,23 +41,35 @@ class CVodeErrConditionTest : public testing::Test
 
 TEST_F(CVodeErrConditionTest, WarningIsPrinted)
 {
-  SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   CVodeMemRec* ark_mem = (CVodeMemRec*)cvode_mem;
   cvProcessError(ark_mem, CV_WARNING, __LINE__, __func__, __FILE__, "test");
-  SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  err = SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  ASSERT_EQ(err, SUN_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_WARNING
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[WARNING]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr("test")));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }
 
 TEST_F(CVodeErrConditionTest, ErrorIsPrinted)
 {
-  SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   // attempting to call CVodeSStolerances before CVodeInit is illegal
-  CVodeSStolerances(cvode_mem, 1e-4, 1e-4);
+  int ierr = CVodeSStolerances(cvode_mem, 1e-4, 1e-4);
+  ASSERT_NE(ierr, CV_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_ERROR
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[ERROR]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr(MSGCV_NO_MALLOC)));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }

test/unit_tests/cvodes/gtest/test_cvodes_error_handling.cpp

@@ -10,7 +10,6 @@
  * SUNDIALS Copyright End
  * -----------------------------------------------------------------*/
 
-#include "gmock/gmock.h"
 #include <cvodes/cvodes.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -42,23 +41,35 @@ class CVodeErrConditionTest : public testing::Test
 
 TEST_F(CVodeErrConditionTest, WarningIsPrinted)
 {
-  SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   CVodeMemRec* ark_mem = (CVodeMemRec*)cvode_mem;
   cvProcessError(ark_mem, CV_WARNING, __LINE__, __func__, __FILE__, "test");
-  SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  err = SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  ASSERT_EQ(err, SUN_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_WARNING
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[WARNING]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr("test")));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }
 
 TEST_F(CVodeErrConditionTest, ErrorIsPrinted)
 {
-  SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   // attempting to call CVodeSStolerances before CVodeInit is illegal
-  CVodeSStolerances(cvode_mem, 1e-4, 1e-4);
+  int ierr = CVodeSStolerances(cvode_mem, 1e-4, 1e-4);
+  ASSERT_NE(ierr, CV_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_ERROR
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[ERROR]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr(MSGCV_NO_MALLOC)));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }

test/unit_tests/ida/gtest/test_ida_error_handling.cpp

@@ -41,23 +41,35 @@ class IDAErrConditionTest : public testing::Test
 
 TEST_F(IDAErrConditionTest, WarningIsPrinted)
 {
-  SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   IDAMemRec* ark_mem = (IDAMemRec*)IDA_mem;
   IDAProcessError(ark_mem, IDA_WARNING, __LINE__, __func__, __FILE__, "test");
-  SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  err = SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  ASSERT_EQ(err, SUN_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_WARNING
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[WARNING]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr("test")));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }
 
 TEST_F(IDAErrConditionTest, ErrorIsPrinted)
 {
-  SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   // attempting to call IDASStolerances before IDAInit is illegal
-  IDASStolerances(IDA_mem, 1e-4, 1e-4);
+  int ierr = IDASStolerances(IDA_mem, 1e-4, 1e-4);
+  ASSERT_NE(ierr, IDA_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_ERROR
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[ERROR]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr(MSG_NO_MALLOC)));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }

test/unit_tests/idas/gtest/test_idas_error_handling.cpp

@@ -41,23 +41,35 @@ class IDAErrConditionTest : public testing::Test
 
 TEST_F(IDAErrConditionTest, WarningIsPrinted)
 {
-  SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   IDAMemRec* ark_mem = (IDAMemRec*)IDA_mem;
   IDAProcessError(ark_mem, IDA_WARNING, __LINE__, __func__, __FILE__, "test");
-  SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  err = SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  ASSERT_EQ(err, SUN_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_WARNING
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[WARNING]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr("test")));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }
 
 TEST_F(IDAErrConditionTest, ErrorIsPrinted)
 {
-  SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   // attempting to call IDASStolerances before IDAInit is illegal
-  IDASStolerances(IDA_mem, 1e-4, 1e-4);
+  int ierr = IDASStolerances(IDA_mem, 1e-4, 1e-4);
+  ASSERT_NE(ierr, IDA_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_ERROR
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[ERROR]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr(MSG_NO_MALLOC)));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }

test/unit_tests/kinsol/gtest/test_kinsol_error_handling.cpp

@@ -41,23 +41,35 @@ class KINErrConditionTest : public testing::Test
 
 TEST_F(KINErrConditionTest, WarningIsPrinted)
 {
-  SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetWarningFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   KINMemRec* kin_mem = (KINMemRec*)kinmem;
   KINProcessError(kin_mem, KIN_WARNING, __LINE__, __func__, __FILE__, "test");
-  SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  err = SUNLogger_Flush(logger, SUN_LOGLEVEL_WARNING);
+  ASSERT_EQ(err, SUN_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_WARNING
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[WARNING]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr("test")));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }
 
 TEST_F(KINErrConditionTest, ErrorIsPrinted)
 {
-  SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  SUNErrCode err = SUNLogger_SetErrorFilename(logger, errfile.c_str());
+  ASSERT_EQ(err, SUN_SUCCESS);
   // -1 is an illegal value
-  KINSetNumMaxIters(kinmem, -1);
+  int ierr = KINSetNumMaxIters(kinmem, -1);
+  ASSERT_NE(ierr, KIN_SUCCESS);
   std::string output = dumpstderr(sunctx, errfile);
+#if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_ERROR
   EXPECT_THAT(output, testing::AllOf(testing::StartsWith("[ERROR]"),
                                      testing::HasSubstr("[rank 0]"),
                                      testing::HasSubstr(MSG_BAD_MXITER)));
+#else
+  EXPECT_EQ(output, "");
+#endif
 }