testing_interface.cpp

Go to the documentation of this file.

/** \file testing_interface.cpp
 * \brief Collective comparisons and accepted-step numerical testing.
 */
#include <MoFEM.hpp>
#include <memory>
#include <sstream>
#include <type_traits>
using namespace MoFEM;
 
static_assert(std::is_abstract_v<TestingInterface>);
 
namespace {
 
template <typename Check>
MoFEMErrorCode
expectFailure(Check check, const std::vector<std::string> &details = {},
              MoFEMErrorCode expected_error = MOFEM_ATOM_TEST_INVALID) {
  MoFEMFunctionBegin;
  std::string diagnostic;
  CHKERR PetscPushErrorHandler(
      [](MPI_Comm, int, const char *, const char *, PetscErrorCode code,
         PetscErrorType, const char *message, void *ctx) -> PetscErrorCode {
        if (message)
          *static_cast<std::string *>(ctx) += message;
        return code;
      },
      &diagnostic);
  const auto error = check();
  CHKERR PetscPopErrorHandler();
  if (error != expected_error)
    SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
            "Expected error %d, got %d", static_cast<int>(expected_error),
            static_cast<int>(error));
  for (const auto &detail : details)
    if (diagnostic.find(detail) == std::string::npos)
      SETERRQ(PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
              "Missing diagnostic '%s' in '%s'", detail.c_str(),
              diagnostic.c_str());
  MoFEMFunctionReturn(0);
}
 
SmartPetscObj<TS> createTimeSolver(MPI_Comm comm, Vec solution) {
  auto ts = createTS(comm);
  CHK_THROW_MESSAGE(TSSetType(ts, TSEULER), "Set Euler solver");
  CHK_THROW_MESSAGE(
      TSSetRHSFunction(
          ts, nullptr,
          [](TS, PetscReal, Vec, Vec rhs, void *) -> PetscErrorCode {
            return VecSet(rhs, 1.);
          },
          nullptr),
      "Set unit rate");
  CHK_THROW_MESSAGE(TSSetSolution(ts, solution), "Set solution");
  CHK_THROW_MESSAGE(TSSetTimeStep(ts, 0.125), "Set time step");
  CHK_THROW_MESSAGE(TSSetMaxTime(ts, 0.375), "Set final time");
  CHK_THROW_MESSAGE(TSSetExactFinalTime(ts, TS_EXACTFINALTIME_MATCHSTEP),
                    "Set final-time policy");
  return ts;
}
 
MoFEMErrorCode checkSelection(MoFEM::Core &core) {
  MoFEMFunctionBegin;
  MoFEM::Interface &m_field = core;
  const auto comm = m_field.get_comm();
  std::unique_ptr<TestingInterface> testing(
      createInterface<TestingInterface>(core));
  auto solution = createGhostVector(comm, 1, PETSC_DECIDE, 0, nullptr);
  CHKERR VecZeroEntries(solution);
  auto ts = createTimeSolver(comm, solution);
  PetscInt monitor_calls = 0;
  auto monitor = [&](TS, PetscInt, PetscReal, Vec) -> MoFEMErrorCode {
    ++monitor_calls;
    return 0;
  };
  CHKERR PetscOptionsSetValue(nullptr, "-selection_test_name", "monitor,missing");
  CHKERR testing->addTSMonitor("selection_", 1, "monitor", ts, monitor);
  if (!testing->checkTest(1) || !testing->checkTest("monitor"))
    SETERRQ(comm, MOFEM_ATOM_TEST_INVALID,
            "Selected monitor is missing from the test registry");
 
  auto messages = boost::make_shared<std::ostringstream>();
  auto sink = LogManager::createSink(messages, "TEST_INTERFACE");
  auto log = logging::core::get();
  log->add_sink(sink);
  const auto selection_error = testing->runTests();
  log->remove_sink(sink);
  CHKERR selection_error;
  if (messages->str().find("-selection_test_name missing") == std::string::npos ||
      messages->str().find("-selection_test_name monitor") != std::string::npos)
    SETERRQ(comm, MOFEM_ATOM_TEST_INVALID,
            "Selection diagnostics must identify only the unmatched test");
  if (monitor_calls)
    SETERRQ(comm, MOFEM_ATOM_TEST_INVALID,
            "runTests invoked a TS monitor callback");
 
  CHKERR PetscOptionsClearValue(nullptr, "-selection_test_name");
  CHKERR testing->getOptions("selection_");
  messages->str("");
  log->add_sink(sink);
  const auto refresh_error = testing->runTests();
  log->remove_sink(sink);
  CHKERR refresh_error;
  if (!messages->str().empty())
    SETERRQ(comm, MOFEM_ATOM_TEST_INVALID,
            "Refreshed empty selectors still produce a warning");
 
  CHKERR TSSolve(ts, solution);
  CHKERR testing->checkValue<TestType::SCALAR>(
      "selected monitor execution", monitor_calls, 3., {0., 0.});
  int hook_calls = 0;
  CHKERR testing->addTest(1, "monitor", [&]() -> MoFEMErrorCode {
    ++hook_calls;
    return 0;
  });
  CHKERR PetscOptionsSetValue(nullptr, "-selection_test_nb", "1");
  CHKERR testing->getOptions("selection_");
  CHKERR testing->addTSMonitor("selection_", 1, "monitor", ts, monitor);
  CHKERR testing->runTestCommandLine("selection_");
  CHKERR testing->checkValue<TestType::SCALAR>(
      "monitor registration retains post-solve hook", hook_calls, 1., {0., 0.});
  CHKERR PetscOptionsClearValue(nullptr, "-selection_test_nb");
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode checkSelectedExecution(MoFEM::Core &core) {
  MoFEMFunctionBegin;
  MoFEM::Interface &m_field = core;
  std::unique_ptr<TestingInterface> testing(
      createInterface<TestingInterface>(core));
  std::vector<int> calls;
  for (int number : {3, 1, 2})
    CHKERR testing->addTest(
        number, "test_" + std::to_string(number), [&, number]() {
          calls.push_back(number);
          return MoFEMErrorCode(0);
        });
  CHKERR PetscOptionsSetValue(nullptr, "-execution_test_nb", "3,1,3,9,9");
  auto messages = boost::make_shared<std::ostringstream>();
  auto sink = LogManager::createSink(messages, "TEST_INTERFACE");
  auto log = logging::core::get();
  log->add_sink(sink);
  const auto run_error = testing->runTestCommandLine("execution_");
  log->remove_sink(sink);
  CHKERR run_error;
  const std::string missing = "-execution_test_nb 9";
  const auto warning = messages->str().find(missing);
  if (calls != std::vector<int>({1, 3}) || warning == std::string::npos ||
      messages->str().find(missing, warning + missing.size()) !=
          std::string::npos)
    SETERRQ(m_field.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Selected tests must run once in number order and warn once per "
            "unknown selector");
 
  CHKERR PetscOptionsSetValue(nullptr, "-execution_test_name", "test_3,test_1,test_3");
  CHKERR expectFailure([&] { return testing->getOptions("execution_"); },
                       {"Both -execution_test_nb and -execution_test_name"},
                       MOFEM_INVALID_DATA);
  CHKERR PetscOptionsClearValue(nullptr, "-execution_test_nb");
  CHKERR testing->getOptions("execution_");
  calls.clear();
  CHKERR testing->runTestCommandLine("execution_");
  if (calls != std::vector<int>({1, 3}))
    SETERRQ(m_field.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Name selection differs from number selection");
 
  CHKERR PetscOptionsClearValue(nullptr, "-execution_test_name");
  CHKERR testing->getOptions("execution_");
  calls.clear();
  CHKERR testing->runTestCommandLine("execution_");
  if (!calls.empty())
    SETERRQ(m_field.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Empty refreshed selectors executed a test");
  CHKERR testing->runTests();
  if (calls != std::vector<int>({1, 2, 3}))
    SETERRQ(m_field.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Refreshing selectors changed existing test registrations");
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode checkSolverCompletion(MoFEM::Interface &m_field) {
  MoFEMFunctionBegin;
  const auto comm = m_field.get_comm();
  auto testing = m_field.getInterface<TestingInterface>();
  auto solution = createGhostVector(comm, 1, PETSC_DECIDE, 0, nullptr);
  auto rhs = vectorDuplicate(solution);
  auto residual = vectorDuplicate(solution);
  Mat matrix_raw;
  CHKERR MatCreateAIJ(comm, 1, 1, PETSC_DECIDE, PETSC_DECIDE, 1, nullptr, 0,
                      nullptr, &matrix_raw);
  SmartPetscObj<Mat> matrix(matrix_raw);
  CHKERR MatAssemblyBegin(matrix, MAT_FINAL_ASSEMBLY);
  CHKERR MatAssemblyEnd(matrix, MAT_FINAL_ASSEMBLY);
  CHKERR MatShift(matrix, 1.);
 
  auto ksp = createKSP(comm);
  CHKERR expectFailure(
      [&] { return testing->checkSolver(ksp, "unsolved KSP"); });
  CHKERR KSPSetOperators(ksp, matrix, matrix);
  CHKERR KSPSetType(ksp, KSPCG);
  PC pc;
  CHKERR KSPGetPC(ksp, &pc);
  CHKERR PCSetType(pc, PCNONE);
  CHKERR VecSet(rhs, 1.);
  CHKERR KSPSolve(ksp, rhs, solution);
  CHKERR testing->checkSolver(ksp, "converged KSP");
  CHKERR VecZeroEntries(rhs);
  CHKERR KSPSolve(ksp, rhs, solution);
  CHKERR testing->checkSolver(ksp, "KSP converged without iterations");
  CHKERR VecSet(rhs, 1.);
  CHKERR KSPSetTolerances(ksp, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, 0);
  CHKERR KSPSolve(ksp, rhs, solution);
  CHKERR expectFailure(
      [&] { return testing->checkSolver(ksp, "KSP iteration limit"); });
 
  auto snes = createSNES(comm);
  CHKERR expectFailure(
      [&] { return testing->checkSolver(snes, "unsolved SNES"); });
  CHKERR SNESSetType(snes, SNESNEWTONLS);
  CHKERR SNESSetFunction(
      snes, residual,
      [](SNES, Vec x, Vec f, void *) -> PetscErrorCode {
        MoFEMFunctionBegin;
        CHKERR VecCopy(x, f);
        CHKERR VecShift(f, -1.);
        MoFEMFunctionReturn(0);
      },
      nullptr);
  CHKERR SNESSetJacobian(
      snes, matrix, matrix,
      [](SNES, Vec, Mat, Mat, void *) -> PetscErrorCode {
        return PETSC_SUCCESS;
      },
      nullptr);
  KSP inner_ksp;
  CHKERR SNESGetKSP(snes, &inner_ksp);
  CHKERR KSPSetType(inner_ksp, KSPCG);
  CHKERR KSPGetPC(inner_ksp, &pc);
  CHKERR PCSetType(pc, PCNONE);
  CHKERR VecSet(solution, 1.);
  CHKERR SNESSolve(snes, nullptr, solution);
  CHKERR testing->checkSolver(snes, "SNES converged without KSP");
  CHKERR VecZeroEntries(solution);
  CHKERR SNESSolve(snes, nullptr, solution);
  CHKERR testing->checkSolver(snes, "converged SNES and KSP");
 
  // A positive outer reason must not conceal a failed inner solve.
  CHKERR KSPSetTolerances(inner_ksp, PETSC_DEFAULT, PETSC_DEFAULT,
                          PETSC_DEFAULT, 0);
  CHKERR KSPSolve(inner_ksp, rhs, solution);
  CHKERR expectFailure(
      [&] { return testing->checkSolver(snes, "SNES with failed KSP"); });
  CHKERR SNESSetTolerances(snes, PETSC_DEFAULT, PETSC_DEFAULT, PETSC_DEFAULT, 0,
                           PETSC_DEFAULT);
  CHKERR VecZeroEntries(solution);
  CHKERR SNESSolve(snes, nullptr, solution);
  CHKERR expectFailure(
      [&] { return testing->checkSolver(snes, "SNES iteration limit"); });
 
  auto ts = createTimeSolver(comm, solution);
  CHKERR TSSetType(ts, TSBEULER);
  CHKERR TSSetRHSJacobian(
      ts, matrix, matrix,
      [](TS, PetscReal, Vec, Mat a, Mat, void *) -> PetscErrorCode {
        return MatZeroEntries(a);
      },
      nullptr);
  SNES inner_snes;
  CHKERR TSGetSNES(ts, &inner_snes);
  CHKERR SNESGetKSP(inner_snes, &inner_ksp);
  CHKERR KSPSetType(inner_ksp, KSPCG);
  CHKERR KSPGetPC(inner_ksp, &pc);
  CHKERR PCSetType(pc, PCNONE);
  CHKERR TSSolve(ts, solution);
  CHKERR testing->checkSolver(ts, 0.375, {1e-12, 0.},
                              "implicit trajectory with SNES and KSP");
  CHKERR KSPSetTolerances(inner_ksp, PETSC_DEFAULT, PETSC_DEFAULT,
                          PETSC_DEFAULT, 0);
  CHKERR KSPSolve(inner_ksp, rhs, solution);
  CHKERR expectFailure([&] {
    return testing->checkSolver(ts, 0.375, {1e-12, 0.}, "TS with failed KSP");
  });
  CHKERR SNESSetConvergedReason(inner_snes, SNES_DIVERGED_MAX_IT);
  CHKERR expectFailure([&] {
    return testing->checkSolver(ts, 0.375, {1e-12, 0.}, "TS with failed SNES");
  });
 
  // Fail through the actual TS -> SNES -> KSP solve chain.
  CHKERR VecZeroEntries(solution);
  CHKERR TSSetTime(ts, 0.);
  CHKERR TSSetStepNumber(ts, 0);
  CHKERR TSSetMaxSNESFailures(ts, 1);
  CHKERR TSSetErrorIfStepFails(ts, PETSC_FALSE);
  CHKERR SNESSetErrorIfNotConverged(inner_snes, PETSC_FALSE);
  CHKERR KSPSetErrorIfNotConverged(inner_ksp, PETSC_FALSE);
  CHKERR TSSolve(ts, solution);
  TSConvergedReason ts_reason;
  SNESConvergedReason snes_reason;
  KSPConvergedReason ksp_reason;
  CHKERR TSGetConvergedReason(ts, &ts_reason);
  CHKERR SNESGetConvergedReason(inner_snes, &snes_reason);
  CHKERR KSPGetConvergedReason(inner_ksp, &ksp_reason);
  if (ts_reason >= 0 || snes_reason >= 0 || ksp_reason >= 0)
    SETERRQ(comm, MOFEM_ATOM_TEST_INVALID,
            "Expected genuine TS/SNES/KSP divergence");
  CHKERR expectFailure(
      [&] {
        return testing->checkSolver(ts, 0.375, {1e-12, 0.}, "real TS failure");
      },
      {TSConvergedReasons[ts_reason], "final time (actual=0, expected=0.375)",
       "real TS failure: SNES: termination", SNESConvergedReasons[snes_reason],
       "real TS failure: SNES: KSP: termination",
       KSPConvergedReasons[ksp_reason]});
  CHKERR expectFailure(
      [&] { return testing->checkSolver(inner_snes, "real SNES failure"); },
      {SNESConvergedReasons[snes_reason], "real SNES failure: KSP: termination",
       KSPConvergedReasons[ksp_reason]});
 
  CHKERR KSPSetTolerances(inner_ksp, PETSC_DEFAULT, PETSC_DEFAULT,
                          PETSC_DEFAULT, 100);
  CHKERR TSSetTime(ts, 0.);
  CHKERR TSSetStepNumber(ts, 0);
  CHKERR VecZeroEntries(solution);
  CHKERR TSSolve(ts, solution);
  CHKERR testing->checkSolver(ts, 0.375, {1e-12, 0.}, "recovered trajectory");
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode checkTaoCompletion(MoFEM::Interface &m_field) {
  MoFEMFunctionBegin;
  auto testing = m_field.getInterface<TestingInterface>();
  auto tao = createTao(m_field.get_comm());
  CHKERR expectFailure(
      [&] { return testing->checkSolver(tao, "unsolved TAO"); });
  auto solution =
      createGhostVector(m_field.get_comm(), 1, PETSC_DECIDE, 0, nullptr);
  CHKERR VecSet(solution, 2.);
  CHKERR TaoSetType(tao, TAOLMVM);
  CHKERR TaoSetSolution(tao, solution);
  CHKERR TaoSetTolerances(tao, 1e-10, 0., 0.);
  CHKERR TaoSetObjectiveAndGradient(
      tao, nullptr,
      [](Tao, Vec x, PetscReal *f, Vec gradient, void *) -> PetscErrorCode {
        MoFEMFunctionBegin;
        // Strictly convex quartic: f = sum(x^4/4 + x^2/2).
        CHKERR VecPointwiseMult(gradient, x, x);
        CHKERR VecPointwiseMult(gradient, gradient, x);
        CHKERR VecAXPY(gradient, 1., x);
        PetscScalar xg, xx;
        CHKERR VecDot(x, gradient, &xg);
        CHKERR VecDot(x, x, &xx);
        *f = 0.25 * PetscRealPart(xg + xx);
        MoFEMFunctionReturn(0);
      },
      nullptr);
  CHKERR TaoSetMaximumIterations(tao, 1);
  CHKERR TaoSolve(tao);
  TaoConvergedReason reason;
  CHKERR TaoGetConvergedReason(tao, &reason);
  if (reason >= 0)
    SETERRQ(m_field.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Expected TAO iteration limit");
  CHKERR expectFailure(
      [&] { return testing->checkSolver(tao, "TAO iteration limit"); },
      {TaoConvergedReasons[reason]});
  CHKERR TaoSetMaximumIterations(tao, 20);
  CHKERR TaoSolve(tao);
  CHKERR testing->checkSolver(tao, "converged TAO");
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode checkCommunicators(MoFEM::Interface &m_field) {
  MoFEMFunctionBegin;
  auto testing = m_field.getInterface<TestingInterface>();
  auto comm = m_field.get_comm();
  MPI_Comm duplicate;
  CHKERR MPI_Comm_dup(comm, &duplicate);
  {
    auto solution = createGhostVector(duplicate, 1, PETSC_DECIDE, 0, nullptr);
    CHKERR VecZeroEntries(solution);
    auto ts = createTimeSolver(duplicate, solution);
    CHKERR testing->addTSMonitor(
        ts, [](TS, PetscInt, PetscReal, Vec) { return MoFEMErrorCode(0); });
    CHKERR TSSolve(ts, solution);
    CHKERR testing->checkSolver(ts, 0.375, {1e-12, 0.}, "congruent TS");
    auto snes = createSNES(duplicate);
    auto ksp = createKSP(duplicate);
    auto tao = createTao(duplicate);
    // Unsolved reasons fail, but the duplicated communicator is accepted.
    CHKERR expectFailure(
        [&] { return testing->checkSolver(snes, "congruent SNES"); },
        {"termination"});
    CHKERR expectFailure(
        [&] { return testing->checkSolver(ksp, "congruent KSP"); },
        {"termination"});
    CHKERR expectFailure(
        [&] { return testing->checkSolver(tao, "congruent TAO"); },
        {"termination"});
  }
  CHKERR MPI_Comm_free(&duplicate);
  if (m_field.get_comm_size() > 1) {
    // Only one Core rank calls: rejection must precede any Core collective.
    if (m_field.get_comm_rank() == 0) {
      auto ts = createTS(PETSC_COMM_SELF);
      auto snes = createSNES(PETSC_COMM_SELF);
      auto ksp = createKSP(PETSC_COMM_SELF);
      auto tao = createTao(PETSC_COMM_SELF);
      CHKERR expectFailure(
          [&] {
            return testing->addTSMonitor(
                ts, [](TS, PetscInt, PetscReal, Vec) {
                  return MoFEMErrorCode(0);
                });
          },
          {"communicator"}, MOFEM_INVALID_DATA);
      CHKERR expectFailure(
          [&] {
            return testing->checkSolver(ts, 1., {0., 0.}, "subcommunicator TS");
          },
          {"communicator"}, MOFEM_INVALID_DATA);
      CHKERR expectFailure(
          [&] { return testing->checkSolver(snes, "subcommunicator SNES"); },
          {"communicator"}, MOFEM_INVALID_DATA);
      CHKERR expectFailure(
          [&] { return testing->checkSolver(ksp, "subcommunicator KSP"); },
          {"communicator"}, MOFEM_INVALID_DATA);
      CHKERR expectFailure(
          [&] { return testing->checkSolver(tao, "subcommunicator TAO"); },
          {"communicator"}, MOFEM_INVALID_DATA);
    }
    CHKERR MPI_Barrier(comm);
    MPI_Comm reordered;
    CHKERR MPI_Comm_split(comm, 0, -m_field.get_comm_rank(), &reordered);
    {
      auto ksp = createKSP(reordered);
      CHKERR expectFailure(
          [&] { return testing->checkSolver(ksp, "reordered KSP"); },
          {"communicator"}, MOFEM_INVALID_DATA);
    }
    CHKERR MPI_Comm_free(&reordered);
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode runTests(MoFEM::Interface &m_field) {
  MoFEMFunctionBegin;
  auto testing = m_field.getInterface<TestingInterface>();
  auto operators = m_field.getInterface<OperatorsTester>();
  const auto comm = m_field.get_comm();
  const bool last_rank = m_field.get_comm_rank() == m_field.get_comm_size() - 1;
  CHKERR testing->checkValue<TestType::SCALAR>("relative tolerance", 100.001,
                                               100., {0., 1e-4});
  CHKERR testing->checkValue<TestType::SCALAR>(
      "custom success severity", 0., 0., {0., 0.}, Sev::error, Sev::warning);
  CHKERR expectFailure([&] {
    return testing->checkValue<TestType::POINTWISE>(
        "rank-local mismatch", last_rank ? 2. : 1., 1., {1e-8, 0.},
        Sev::warning, Sev::inform);
  });
  CHKERR expectFailure([&] {
    return testing->checkValue<TestType::SCALAR>(
        "non-finite value",
        last_rank ? std::numeric_limits<PetscReal>::quiet_NaN() : 1., 1.,
        {1e-8, 0.});
  });
  CHKERR expectFailure([&] {
    return testing->checkError<TestType::DERIVATIVE>("invalid tolerance", 0.,
                                                     1., {-1., 1.});
  });
 
  CHKERR expectFailure(
      [&] {
        return testing->checkError<TestType::SCALAR>(
            "rank-dependent bounds", last_rank ? 2. : 100., 0.,
            {last_rank ? 1. : 200., 0.});
      },
      {"max_error=" + std::to_string(m_field.get_comm_size() > 1 ? 100 : 2),
       "failing_ranks=1",
       "failing_rank=" + std::to_string(m_field.get_comm_size() - 1),
       ", error=2, bound=1,", "inputs=valid"});
  CHKERR expectFailure(
      [&] {
        return testing->checkError<TestType::SCALAR>(
            "invalid input diagnostic",
            std::numeric_limits<PetscReal>::infinity(), 0., {1., 0.});
      },
      {"max_error=inf", "bound=1", "inputs=invalid/non-finite"});
 
  auto solution = createGhostVector(comm, 1, PETSC_DECIDE, 0, nullptr);
  CHKERR VecZeroEntries(solution);
  auto ts = createTimeSolver(comm, solution);
  PetscInt existing_calls = 0;
  CHKERR TSMonitorSet(
      ts,
      [](TS, PetscInt, PetscReal, Vec, void *ctx) -> PetscErrorCode {
        ++*static_cast<PetscInt *>(ctx);
        return PETSC_SUCCESS;
      },
      &existing_calls, nullptr);
  auto checked_steps = boost::make_shared<PetscInt>(0);
  boost::weak_ptr<PetscInt> monitor_lifetime = checked_steps;
  CHKERR testing->addTSMonitor(
      ts, [testing, operators, checked_steps](TS, PetscInt step, PetscReal time,
                                              Vec state) {
        MoFEMFunctionBegin;
        auto difference = vectorDuplicate(state);
        auto before = vectorDuplicate(state);
        CHKERR VecCopy(state, before);
        CHKERR VecCopy(state, difference);
        CHKERR VecShift(difference, -time);
        PetscReal error;
        CHKERR VecNorm(difference, NORM_INFINITY, &error);
        CHKERR testing->checkError<TestType::POINTWISE>(
            "u(t)=t", error, std::abs(time), {1e-12, 1e-12});
 
        auto direction = vectorDuplicate(state);
        auto gradient = vectorDuplicate(state);
        CHKERR VecSet(direction, 1.);
        CHKERR VecCopy(state, gradient);
        CHKERR VecScale(gradient, 2.);
        PetscReal finite_difference, derivative;
        CHKERR operators->checkScalarCentralFiniteDifference(
            state, direction, gradient, 1e-5,
            [](Vec x, PetscReal &value) {
              MoFEMFunctionBegin;
              PetscScalar dot;
              CHKERR VecDot(x, x, &dot);
              value = PetscRealPart(dot);
              MoFEMFunctionReturn(0);
            },
            finite_difference, derivative);
        CHKERR testing->checkValue<TestType::DERIVATIVE>(
            "per-step energy derivative", finite_difference, derivative,
            {1e-9, 1e-9});
        PetscBool unchanged;
        CHKERR VecEqual(state, before, &unchanged);
        if (!unchanged || step != ++*checked_steps)
          SETERRQ(PetscObjectComm(reinterpret_cast<PetscObject>(state)),
                  MOFEM_ATOM_TEST_INVALID,
                  "Monitor changed the solution or skipped/repeated a step");
        MoFEMFunctionReturn(0);
      });
  CHKERR TSSolve(ts, solution);
  CHKERR testing->checkSolver(ts, "complete configured trajectory");
  CHKERR testing->checkValue<TestType::SCALAR>("accepted steps", *checked_steps,
                                               3., {0., 0.});
  CHKERR testing->checkValue<TestType::SCALAR>("existing monitor retained",
                                               existing_calls, 4., {0., 0.});
  checked_steps.reset();
  if (monitor_lifetime.expired())
    SETERRQ(comm, MOFEM_ATOM_TEST_INVALID,
            "TS did not retain its test callback");
  CHKERR TSMonitorCancel(ts);
  if (!monitor_lifetime.expired())
    SETERRQ(comm, MOFEM_ATOM_TEST_INVALID, "TS leaked its test callback");
 
  CHKERR VecZeroEntries(solution);
  ts = createTimeSolver(comm, solution);
  CHKERR TSSetMaxSteps(ts, 1);
  CHKERR TSSolve(ts, solution);
  CHKERR expectFailure([&] {
    return testing->checkSolver(ts, "incomplete configured trajectory");
  });
 
  for (auto policy : {TS_EXACTFINALTIME_STEPOVER,
                      TS_EXACTFINALTIME_INTERPOLATE,
                      TS_EXACTFINALTIME_MATCHSTEP}) {
    CHKERR VecZeroEntries(solution);
    ts = createTimeSolver(comm, solution);
    CHKERR TSSetMaxTime(ts, 0.3);
    CHKERR TSSetExactFinalTime(ts, policy);
    CHKERR TSSolve(ts, solution);
    CHKERR testing->checkSolver(ts, "configured final-time policy");
  }
 
  CHKERR VecZeroEntries(solution);
  ts = createTimeSolver(comm, solution);
  CHKERR testing->addTSMonitor(
      ts, [testing, last_rank](TS, PetscInt, PetscReal, Vec) {
        return testing->checkValue<TestType::SCALAR>(
            "monitor failure propagation", last_rank ? 1. : 0., 0., {0., 0.});
      });
  CHKERR expectFailure([&] { return TSSolve(ts, solution); });
  CHKERR checkSolverCompletion(m_field);
  CHKERR checkTaoCompletion(m_field);
  CHKERR checkCommunicators(m_field);
  MoFEMFunctionReturn(0);
}
 
} // namespace
 
int main(int argc, char *argv[]) {
  MoFEM::Core::Initialize(&argc, &argv, nullptr,
                          "Numerical testing interface\n");
  try {
    moab::Core moab_core;
    MoFEM::Core mofem_core(moab_core);
    std::unique_ptr<TestingInterface> owned_testing(
        createInterface<TestingInterface>(mofem_core));
    if (owned_testing->getInterface<TestingInterface>() != owned_testing.get())
      SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
              "Factory-created testing interface cannot be queried");
    CHKERR owned_testing->checkValue<TestType::SCALAR>(
        "factory-created interface", 1., 1., {0., 0.});
    auto calls = std::make_shared<int>(0);
    auto hook = [calls]() -> MoFEMErrorCode { ++*calls; return 0; };
    CHKERR PetscOptionsSetValue(nullptr, "-registry_test_nb", "2");
    CHKERR owned_testing->getOptions("registry_");
    CHKERR owned_testing->addTestCommandLine("registry_", 1, "first", hook);
    CHKERR owned_testing->addTestCommandLine("registry_", 2, "second", hook);
    CHKERR owned_testing->runTests();
    CHKERR owned_testing->checkValue<TestType::SCALAR>(
        "number selection", *calls, 1., {0., 0.});
    CHKERR PetscOptionsClearValue(nullptr, "-registry_test_nb");
    CHKERR PetscOptionsSetValue(nullptr, "-registry_test_name", "second");
    // Cached selection remains valid until explicitly refreshed.
    CHKERR owned_testing->runTestCommandLine("registry_");
    CHKERR owned_testing->getOptions("registry_");
    CHKERR owned_testing->runTestCommandLine("registry_");
    CHKERR owned_testing->checkValue<TestType::SCALAR>(
        "cached and named selection", *calls, 3., {0., 0.});
    CHKERR PetscOptionsClearValue(nullptr, "-registry_test_name");
    CHKERR checkSelection(mofem_core);
    CHKERR checkSelectedExecution(mofem_core);
    CHKERR runTests(mofem_core);
  }
  CATCH_ERRORS;
  CHKERR MoFEM::Core::Finalize();
  return 0;
}