test_expect_abort.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <mpi.h>
 
#include "tests.h"
#include "test_expect_abort.h"
#include "ppm/core.h"
 
static char const * expected_msg = "ERROR(dummy): the expected message";
static char const * unexpected_msg = "ERROR(dummy): some other message";
static char const * expected_substr = "the expected message";
 
static void utest_maybe_abort(int do_abort, char const * msg) {
 
  if (do_abort) yac_abort(MPI_COMM_WORLD, msg, __FILE__, __LINE__);
}
 
static void utest_check(int test_failed, char const * test_name) {
 
  if (test_failed) PUT_ERR_F("ERROR in %s", test_name);
}
 
int main(void) {
 
  MPI_Init(NULL, NULL);
 
  int comm_rank, comm_size;
  MPI_Comm_rank(MPI_COMM_WORLD, &comm_rank);
  MPI_Comm_size(MPI_COMM_WORLD, &comm_size);
 
  if (comm_size != 2) {
    PUT_ERR("ERROR: wrong number of processes (has to be 2)");
    MPI_Finalize();
    return TEST_EXIT_CODE;
  }
 
  yac_abort_func initial_handler = yac_get_abort_handler();
 
  int test_failed;
 
  { // serial: statement does not abort
 
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_NO_CALL, expected_substr,
      utest_maybe_abort(0, expected_msg));
    utest_check(test_failed, "SERIAL without abort");
  }
 
  { // serial: statement aborts with the expected message
 
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_EXPECTED, expected_substr,
      utest_maybe_abort(1, expected_msg));
    utest_check(test_failed, "SERIAL with abort");
  }
 
  { // serial: statement aborts with an unexpected message
 
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_UNEXPECTED, expected_substr,
      utest_maybe_abort(1, unexpected_msg));
    utest_check(test_failed, "SERIAL with unexpected message");
  }
 
  { // serial: any message is accepted if no substring is provided
 
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_EXPECTED, NULL,
      utest_maybe_abort(1, unexpected_msg));
    utest_check(test_failed, "SERIAL without substring");
  }
 
  { // serial: the statement may contain commas at bracket level zero
 
    // volatile because the value is modified between setjmp and longjmp
    // and read afterwards (C11 7.13.2.1)
    int volatile statement_was_executed = 0;
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_EXPECTED, expected_substr,
      statement_was_executed = 1, utest_maybe_abort(1, expected_msg));
    utest_check(test_failed, "SERIAL with comma");
#if YAC_TEST_ABORT_UNHAPPY_PATH_ENABLED
    if (!statement_was_executed)
      PUT_ERR("ERROR in SERIAL with comma: statement was not executed");
#else
    if (statement_was_executed)
      PUT_ERR("ERROR in SERIAL with comma: statement was executed");
#endif
  }
 
  // the abort handler has to be restored by every macro
  if (yac_get_abort_handler() != initial_handler)
    PUT_ERR("ERROR: abort handler was not restored");
 
  { // parallel: no process aborts
 
    YAC_TEST_EXPECT_ABORT_PAR_ANY(
      test_failed, YAC_TEST_ABORT_NO_CALL, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(0, expected_msg));
    utest_check(test_failed, "PAR_ANY without abort");
 
    YAC_TEST_EXPECT_ABORT_PAR_ALL(
      test_failed, YAC_TEST_ABORT_NO_CALL, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(0, expected_msg));
    utest_check(test_failed, "PAR_ALL without abort");
  }
 
  { // parallel: all processes abort with the expected message
 
    YAC_TEST_EXPECT_ABORT_PAR_ANY(
      test_failed, YAC_TEST_ABORT_EXPECTED, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(1, expected_msg));
    utest_check(test_failed, "PAR_ANY with all aborting");
 
    YAC_TEST_EXPECT_ABORT_PAR_ALL(
      test_failed, YAC_TEST_ABORT_EXPECTED, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(1, expected_msg));
    utest_check(test_failed, "PAR_ALL with all aborting");
  }
 
  { // parallel: only one process aborts with the expected message
 
    YAC_TEST_EXPECT_ABORT_PAR_ANY(
      test_failed, YAC_TEST_ABORT_EXPECTED, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(comm_rank == 0, expected_msg));
    utest_check(test_failed, "PAR_ANY with one aborting");
 
    // PAR_ALL requires all processes to abort
    YAC_TEST_EXPECT_ABORT_PAR_ALL(
      test_failed, YAC_TEST_ABORT_UNEXPECTED, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(comm_rank == 0, expected_msg));
    utest_check(test_failed, "PAR_ALL with one aborting");
  }
 
  { // parallel: all processes abort, but one with an unexpected message
    // (an unexpected message must not be masked by the other processes)
 
    YAC_TEST_EXPECT_ABORT_PAR_ANY(
      test_failed, YAC_TEST_ABORT_UNEXPECTED, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(1, (comm_rank == 0)?expected_msg:unexpected_msg));
    utest_check(test_failed, "PAR_ANY with mixed messages");
 
    YAC_TEST_EXPECT_ABORT_PAR_ALL(
      test_failed, YAC_TEST_ABORT_UNEXPECTED, expected_substr, MPI_COMM_WORLD,
      utest_maybe_abort(1, (comm_rank == 0)?expected_msg:unexpected_msg));
    utest_check(test_failed, "PAR_ALL with mixed messages");
  }
 
  { // statements that are expected to abort are not executed if the internal
    // asserts are compiled out, statements that are expected to complete
    // normally always are
 
    // volatile because the value is modified between setjmp and longjmp
    // and read afterwards (C11 7.13.2.1)
    int volatile statement_was_executed = 0;
    YAC_TEST_EXPECT_ABORT_PAR_ALL(
      test_failed, YAC_TEST_ABORT_EXPECTED, expected_substr, MPI_COMM_WORLD,
      statement_was_executed = 1, utest_maybe_abort(1, expected_msg));
    utest_check(test_failed, "PAR_ALL unhappy path");
#if YAC_TEST_ABORT_UNHAPPY_PATH_ENABLED
    if (!statement_was_executed)
      PUT_ERR("ERROR in PAR_ALL unhappy path: statement was not executed");
#else
    if (statement_was_executed)
      PUT_ERR("ERROR in PAR_ALL unhappy path: statement was executed");
#endif
 
    statement_was_executed = 0;
    YAC_TEST_EXPECT_ABORT_PAR_ALL(
      test_failed, YAC_TEST_ABORT_NO_CALL, expected_substr, MPI_COMM_WORLD,
      statement_was_executed = 1, utest_maybe_abort(0, expected_msg));
    utest_check(test_failed, "PAR_ALL happy path");
    if (!statement_was_executed)
      PUT_ERR("ERROR in PAR_ALL happy path: statement was not executed");
  }
 
  { // a mismatch has to be detected and reported
 
    fputs(
      "NOTE: the following two ERROR lines are part of the test\n", stderr);
 
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_EXPECTED, expected_substr,
      utest_maybe_abort(0, expected_msg));
#if YAC_TEST_ABORT_UNHAPPY_PATH_ENABLED
    if (!test_failed)
      PUT_ERR("ERROR: undetected mismatch (expected abort, got none)");
#else
    // the statement is not executed at all, hence there is nothing to detect
    if (test_failed)
      PUT_ERR("ERROR: mismatch reported for a skipped statement");
#endif
 
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_NO_CALL, expected_substr,
      utest_maybe_abort(1, expected_msg));
    if (!test_failed)
      PUT_ERR("ERROR: undetected mismatch (expected no abort, got one)");
  }
 
  if (yac_get_abort_handler() != initial_handler)
    PUT_ERR("ERROR: abort handler was not restored");
 
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}