test_utils_common.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <limits.h>
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "tests.h"
#include "utils_common.h"
 
static void utest_remove_duplicates_int(void);
static void utest_name_type_pairs(void);
static void utest_qsort_index(void);
static void utest_getenv_bool(MPI_Comm comm);
static void utest_getenv_int(MPI_Comm comm);
static void utest_getenv_str(MPI_Comm comm);
 
int main(void) {
 
  MPI_Init(NULL, NULL);
 
  int comm_size;
  MPI_Comm_size(MPI_COMM_WORLD, &comm_size);
 
  if (comm_size != 4) {
    PUT_ERR("ERROR: test_utils_common requires exactly 4 MPI processes");
    MPI_Finalize();
    return TEST_EXIT_CODE;
  }
 
  utest_remove_duplicates_int();
  utest_name_type_pairs();
  utest_qsort_index();
  utest_getenv_bool(MPI_COMM_WORLD);
  utest_getenv_int(MPI_COMM_WORLD);
  utest_getenv_str(MPI_COMM_WORLD);
 
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}
 
static int utest_compare_int(void const * a, void const * b) {
 
  int aa = *(int const *)a;
  int bb = *(int const *)b;
 
  return (aa > bb) - (aa < bb);
}
 
static void utest_unsetenv_all(MPI_Comm comm, char const * name) {
 
  unsetenv(name);
 
  // synchronize all ranks to ensure that the environment variable is unset
  MPI_Barrier(comm);
}
 
static void utest_setenv_all(
  MPI_Comm comm, char const * name, char const * root_value,
  char const * other_value) {
 
  int rank;
  MPI_Comm_rank(comm, &rank);
 
  char const * value = (rank == 0)?root_value:other_value;
 
  if (value != NULL) setenv(name, value, 1);
  else unsetenv(name);
 
  // synchronize all ranks to ensure that the environment variable is set
  // before proceeding
  MPI_Barrier(comm);
}
 
static void utest_remove_duplicates_int(void) {
 
  { // test that empty input is handled correctly
    int value = 42;
    size_t n = 0;
    yac_remove_duplicates_int(&value, &n);
    if (n != 0) PUT_ERR("yac_remove_duplicates_int failed for empty input");
  }
 
  { // test that duplicates are removed
    int values[] = {1, 1, 2, 2, 2, 4, 4, 7};
    int ref[] = {1, 2, 4, 7};
    size_t n = sizeof(values) / sizeof(values[0]);
 
    yac_remove_duplicates_int(values, &n);
 
    if (n != sizeof(ref) / sizeof(ref[0]))
      PUT_ERR("yac_remove_duplicates_int produced wrong output length");
    for (size_t i = 0; i < n; ++i)
      if (values[i] != ref[i])
        PUT_ERR("yac_remove_duplicates_int produced wrong output values");
  }
 
  { // test that unique input is unchanged
    int values[] = {-2, -1, 0, 3};
    int ref[] = {-2, -1, 0, 3};
    size_t n = sizeof(values) / sizeof(values[0]);
 
    yac_remove_duplicates_int(values, &n);
 
    if (n != sizeof(ref) / sizeof(ref[0]))
      PUT_ERR("yac_remove_duplicates_int changed unique input length");
    for (size_t i = 0; i < n; ++i)
      if (values[i] != ref[i])
        PUT_ERR("yac_remove_duplicates_int changed unique input values");
  }
}
 
static void utest_name_type_pairs(void) {
 
  enum { alpha = -3, beta = 2, gamma = 2, invalid = 42 };
 
  DEF_NAME_TYPE_PAIRS(
    utest_name_type_table,
    DEF_NAME_TYPE_PAIR(alpha, alpha),
    DEF_NAME_TYPE_PAIR(beta, beta),
    DEF_NAME_TYPE_PAIR(BETA, beta),
    DEF_NAME_TYPE_PAIR(gamma, gamma));
 
  // test valid input for yac_name_type_pair_get_name
  // (should return the first matching name for a given type)
  char const * name =
    yac_name_type_pair_get_name(
      utest_name_type_table, utest_name_type_table_size, beta);
  if ((name == NULL) || strcmp(name, "beta"))
    PUT_ERR("yac_name_type_pair_get_name returned wrong result");
 
  // test invalid input for yac_name_type_pair_get_name
  if (yac_name_type_pair_get_name(
        utest_name_type_table, utest_name_type_table_size, invalid) != NULL)
    PUT_ERR("yac_name_type_pair_get_name should return NULL for unknown type");
 
  // test valid input for yac_name_type_pair_get_type
  if (yac_name_type_pair_get_type(
        utest_name_type_table, utest_name_type_table_size, "alpha") != alpha)
    PUT_ERR("yac_name_type_pair_get_type returned wrong result for alpha");
 
  // test alternate name for beta
  if (yac_name_type_pair_get_type(
        utest_name_type_table, utest_name_type_table_size, "BETA") != beta)
    PUT_ERR("yac_name_type_pair_get_type returned wrong result for BETA");
 
  // test invalid input for yac_name_type_pair_get_type
  if (yac_name_type_pair_get_type(
        utest_name_type_table, utest_name_type_table_size, "invalid") !=
      INT_MAX)
    PUT_ERR("yac_name_type_pair_get_type should return INT_MAX for unknown names");
 
  // test NULL input for yac_name_type_pair_get_type
  if (yac_name_type_pair_get_type(
        utest_name_type_table, utest_name_type_table_size, NULL) != INT_MAX)
    PUT_ERR("yac_name_type_pair_get_type should return INT_MAX for NULL input");
}
 
static void utest_qsort_index(void) {
 
  { // test that values are sorted and index mapping is correct
    int values[] = {5, 1, 3, 1, 4};
    int ref[] = {5, 1, 3, 1, 4};
    size_t idx[] = {0, 1, 2, 3, 4};
    int const sorted_ref[] = {1, 1, 3, 4, 5};
 
    yac_qsort_index(
      values, sizeof(values) / sizeof(values[0]), sizeof(values[0]),
      utest_compare_int, idx);
 
    for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
      if (values[i] != sorted_ref[i])
        PUT_ERR("yac_qsort_index failed to sort values");
 
    int seen[] = {0, 0, 0, 0, 0};
    for (size_t i = 0; i < sizeof(idx) / sizeof(idx[0]); ++i) {
      if (idx[i] >= sizeof(ref) / sizeof(ref[0])) {
        PUT_ERR("yac_qsort_index returned out-of-range index");
        continue;
      }
      if (seen[idx[i]]) PUT_ERR("yac_qsort_index returned duplicate index");
      seen[idx[i]] = 1;
      if (ref[idx[i]] != values[i])
        PUT_ERR("yac_qsort_index index mapping does not match sorted values");
    }
  }
 
  { // test that idx == NULL is handled correctly
    int values[] = {3, 2, 1};
    int const sorted_ref[] = {1, 2, 3};
 
    yac_qsort_index(
      values, sizeof(values) / sizeof(values[0]), sizeof(values[0]),
      utest_compare_int, NULL);
 
    for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
      if (values[i] != sorted_ref[i])
        PUT_ERR("yac_qsort_index failed for idx == NULL");
  }
}
 
static void utest_getenv_bool(MPI_Comm comm) {
 
  int rank;
  MPI_Comm_rank(comm, &rank);
 
  char const * env_name = "YAC_UTEST_BOOL";
 
  { // test behaviour when environment variable is not set
    utest_unsetenv_all(comm, env_name);
    int value = yac_getenv_bool(env_name, 1, comm);
    if (value != 1) PUT_ERR("yac_getenv_bool returned wrong default value");
  }
 
  { // test behaviour when environment variable is only set on non-root ranks
    utest_setenv_all(comm, env_name, NULL, "on");
    int value = yac_getenv_bool(env_name, 0, comm);
    if (value != 0)
      PUT_ERR("yac_getenv_bool returned wrong value for unset on root");
  }
 
  { // test behaviour when environment variable is only set on root rank
    utest_setenv_all(comm, env_name, "on", NULL);
    int value = yac_getenv_bool(env_name, 0, comm);
    if (value != 1)
      PUT_ERR("yac_getenv_bool returned wrong value for unset on non-root");
 
  }
 
  { // test behaviour when environment variable is set to "on" on root and
    // "off" on non-root ranks
    utest_setenv_all(comm, env_name, "on", "off");
    int value = yac_getenv_bool(env_name, 0, comm);
    if (value != 1) PUT_ERR("yac_getenv_bool returned wrong value for 'on'");
  }
 
  { // test behaviour when environment variable is set to "off" on root and
    // "on" on non-root ranks
    utest_setenv_all(comm, env_name, "off", "on");
    int value = yac_getenv_bool(env_name, 1, comm);
    if (value != 0) PUT_ERR("yac_getenv_bool returned wrong value for 'off'");
  }
 
  // TODO: enable once support for testing of unhappy path is supported
  // { // test behaviour when environment variable is set to an invalid value
  //   utest_setenv_all(comm, env_name, "invalid", "on");
  //   int value = yac_getenv_bool(env_name, 0, comm);
  //   if (value != 0)
  //     PUT_ERR("yac_getenv_bool returned wrong value for invalid input");
  // }
 
  utest_unsetenv_all(comm, env_name);
}
 
static void utest_getenv_int(MPI_Comm comm) {
 
  int rank;
  MPI_Comm_rank(comm, &rank);
 
  char const * env_name = "YAC_UTEST_INT";
 
  { // test behaviour when environment variable is not set
    utest_unsetenv_all(comm, env_name);
    int value = yac_getenv_int(env_name, 7, 0, comm);
    if (value != 7) PUT_ERR("yac_getenv_int returned wrong default value");
  }
 
  { // test behaviour when environment variable is only set on non-root ranks
    utest_setenv_all(comm, env_name, NULL, "12");
    int value = yac_getenv_int(env_name, 7, 0, comm);
    if (value != 7)
      PUT_ERR("yac_getenv_int returned wrong value for unset on root");
  }
 
  { // test behaviour when environment variable is only set on root rank
    utest_setenv_all(comm, env_name, "12", NULL);
    int value = yac_getenv_int(env_name, 7, 0, comm);
    if (value != 12)
      PUT_ERR("yac_getenv_int returned wrong value for unset on non-root");
  }
 
  { // test behaviour when environment variable is set to a value below the
    // threshold
    utest_setenv_all(comm, env_name, "2", "2");
    int value = yac_getenv_int(env_name, 7, 3, comm);
    if (value != 7)
      PUT_ERR("yac_getenv_int returned wrong value for below threshold");
  }
 
  { // test behavioud when environment variable is set to different values on
    // all ranks (to local rank)
    char str_rank[16];
    snprintf(str_rank, sizeof(str_rank), "%d", rank);
    utest_setenv_all(comm, env_name, str_rank, str_rank);
    int value = yac_getenv_int(env_name, 7, 0, comm);
    if (value != 0)
      PUT_ERR("yac_getenv_int returned wrong value for rank-dependent input");
  }
 
  // TODO: enable once support for testing of unhappy path is supported
  // { // test behaviour when environment variable is set to an invalid value
  //   utest_setenv_all(comm, env_name, "invalid", "12");
  //   int value = yac_getenv_int(env_name, 7, 0, comm);
  //   if (value != 7)
  //     PUT_ERR("yac_getenv_int returned wrong value for invalid input");
  // }
 
  utest_unsetenv_all(comm, env_name);
}
 
static void utest_getenv_str(MPI_Comm comm) {
 
  int rank;
  MPI_Comm_rank(comm, &rank);
 
  char const * env_name = "YAC_UTEST_STR";
 
  { // test behaviour when environment variable is not set
    utest_unsetenv_all(comm, env_name);
    char * str_value = yac_getenv_str(env_name, "fallback", comm);
    if ((str_value == NULL) || strcmp(str_value, "fallback"))
      PUT_ERR("yac_getenv_str returned wrong default value");
    free(str_value);
  }
 
  { // test behaviour when environment variable is set to an empty string
    utest_setenv_all(comm, env_name, "", "");
    char * str_value = yac_getenv_str(env_name, "fallback", comm);
    if ((str_value == NULL) || strcmp(str_value, "fallback"))
      PUT_ERR("yac_getenv_str returned wrong value for empty string");
    free(str_value);
  }
 
  { // test behaviour when environment variable is set to a non-empty string
    utest_setenv_all(comm, env_name, "root_value", "other_value");
    char * str_value = yac_getenv_str(env_name, "fallback", comm);
    if ((str_value == NULL) || strcmp(str_value, "root_value"))
      PUT_ERR("yac_getenv_str returned wrong value for non-empty string");
    free(str_value);
  }
 
  { // test behaviour when environment variable is set to an empty string on
    // root and a non-empty string on non-root ranks
    utest_setenv_all(comm, env_name, "", "other_value");
    char * str_value = yac_getenv_str(env_name, "fallback", comm);
    if ((str_value == NULL) || strcmp(str_value, "fallback"))
      PUT_ERR(
        "yac_getenv_str returned wrong value for empty string on root");
    free(str_value);
  }
 
  { // test behaviour when environment variable is set to a non-empty string on
    // root and an empty string on non-root ranks
    utest_setenv_all(comm, env_name, "root_value", "");
    char * str_value = yac_getenv_str(env_name, "fallback", comm);
    if ((str_value == NULL) || strcmp(str_value, "root_value"))
      PUT_ERR(
        "yac_getenv_str returned wrong value for empty string on non-root");
    free(str_value);
 
  }
 
  { // test behaviour when environment variable is only set on non-root ranks
    utest_setenv_all(comm, env_name, NULL, "other_value");
    char * str_value = yac_getenv_str(env_name, "fallback", comm);
    if ((str_value == NULL) || strcmp(str_value, "fallback"))
      PUT_ERR("yac_getenv_str returned wrong value for unset on root");
    free(str_value);
  }
 
  { // test behaviour when environment variable is only set on root rank
    utest_setenv_all(comm, env_name, "root_value", NULL);
    char * str_value = yac_getenv_str(env_name, "fallback", comm);
    if ((str_value == NULL) || strcmp(str_value, "root_value"))
      PUT_ERR("yac_getenv_str returned wrong value for unset on non-root");
    free(str_value);
 
  }
 
  utest_unsetenv_all(comm, env_name);
}