test_param_utils.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
 
 
#include <mpi.h>
#include <stdlib.h>
#include <string.h>
 
#include "parameter/param.h"
#include "parameter/param_bool.h"
#include "parameter/param_dble.h"
#include "parameter/param_int.h"
#include "parameter/param_list.h"
#include "parameter/param_str.h"
#include "parameter/param_struct.h"
#include "parameter/param_utils.h"
#include "tests.h"
 
static void utest_scalar_int_roundtrip(MPI_Comm comm);
static void utest_scalar_dble_roundtrip(MPI_Comm comm);
static void utest_scalar_str_roundtrip(MPI_Comm comm);
static void utest_struct_roundtrip(MPI_Comm comm);
static void utest_list_roundtrip(MPI_Comm comm);
static void utest_empty_list_roundtrip(MPI_Comm comm);
 
static int utest_list_default_factory(
  void ** element_ptr, struct yac_param ** param_ptr) {
 
  int * value = malloc(sizeof(*value));
  if (value == NULL) return 1;
  *value = 0;
 
  *element_ptr = value;
  *param_ptr = yac_param_int_new("list_elem", value, 0, -1000, 1000, 1, 1);
 
  return (*param_ptr == NULL);
}
 
static void utest_free_int_list(void ** list) {
 
  if (list == NULL) return;
  for (size_t i = 0; list[i] != NULL; ++i) free(list[i]);
  free(list);
}
 
int main(void) {
 
  // Run all checks with a single local rank.
  MPI_Init(NULL, NULL);
 
  utest_scalar_int_roundtrip(MPI_COMM_SELF);
  utest_scalar_dble_roundtrip(MPI_COMM_SELF);
  utest_scalar_str_roundtrip(MPI_COMM_SELF);
  utest_struct_roundtrip(MPI_COMM_SELF);
  utest_list_roundtrip(MPI_COMM_SELF);
  utest_empty_list_roundtrip(MPI_COMM_SELF);
 
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}
 
static void utest_scalar_int_roundtrip(MPI_Comm comm) {
 
  { // Test pack/unpack of a single int parameter with default value in defined
    // state
    char const * param_name = "ival";
    int const default_value = 42;
    int const value_min = -1000;
    int const value_max = 1000;
    int const has_default = 1;
    int const is_defined = 1;
 
    int value = default_value;
 
    // Create new int parameter
    struct yac_param * param =
      yac_param_int_new(
        param_name, &value, default_value, value_min, value_max,
        has_default, is_defined);
 
    // Get pack size for the parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("int pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new parameter for unpacking with default value
    int unpacked_value = default_value;
    struct yac_param * unpacked_param =
      yac_param_int_new(
        param_name, &unpacked_value, default_value, value_min, value_max,
        has_default, is_defined);
 
    // Unpack the parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked value matches the original value
    if (unpacked_value != value)
      PUT_ERR("int unpack should update destination value to source value");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(buffer);
  }
 
  { // Test pack/unpack of a single int parameter with non-default value in
    // defined state
    char const * param_name = "ival";
    int const default_value = 42;
    int const value_min = -1000;
    int const value_max = 1000;
    int const has_default = 1;
    int const is_defined = 1;
 
    int value = default_value + 1;
 
    // Create new int parameter
    struct yac_param * param =
      yac_param_int_new(
        param_name, &value, default_value, value_min, value_max,
        has_default, is_defined);
 
    // Get pack size for the parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("int pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new parameter for unpacking with default value
    int unpacked_value = default_value;
    struct yac_param * unpacked_param =
      yac_param_int_new(
        param_name, &unpacked_value, default_value, value_min, value_max,
        has_default, is_defined);
 
    // Unpack the parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked value matches the original value
    if (unpacked_value != value)
      PUT_ERR("int unpack should update destination value to source value");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(buffer);
  }
}
 
static void utest_scalar_dble_roundtrip(MPI_Comm comm) {
 
  { // Test pack/unpack of a single double parameter with default value in
    // defined state
    char const * param_name = "dval";
    double const default_value = 0.0;
    double const value_min = -1000.0;
    double const value_max = 1000.0;
    int const allow_nan = 0;
    int const allow_inf = 0;
    int const has_default = 1;
    int const is_defined = 1;
 
    double value = default_value;
 
    // Create new double parameter
    struct yac_param * param =
      yac_param_dble_new(
        param_name, &value, default_value, value_min, value_max,
        allow_nan, allow_inf, has_default, is_defined);
 
    // Get pack size for the parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("double pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new parameter for unpacking with default value
    double unpacked_value = default_value;
    struct yac_param * unpacked_param =
      yac_param_dble_new(
        param_name, &unpacked_value, default_value, value_min, value_max,
        allow_nan, allow_inf, has_default, is_defined);
 
    // Unpack the parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked value matches the original value
    if (unpacked_value != value)
      PUT_ERR("double unpack should update destination value to source value");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(buffer);
  }
 
  { // Test pack/unpack of a single double parameter with non-default value
    char const * param_name = "dval";
    double const default_value = 0.0;
    double const value_min = -1000.0;
    double const value_max = 1000.0;
    int const allow_nan = 0;
    int const allow_inf = 0;
    int const has_default = 1;
    int const is_defined = 1;
 
    double value = 2.75;
 
    // Create new double parameter
    struct yac_param * param =
      yac_param_dble_new(
        param_name, &value, default_value, value_min, value_max,
        allow_nan, allow_inf, has_default, is_defined);
 
    // Get pack size for the parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("double pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new parameter for unpacking with default value
    double unpacked_value = default_value;
    struct yac_param * unpacked_param =
      yac_param_dble_new(
        param_name, &unpacked_value, default_value, value_min, value_max,
        allow_nan, allow_inf, has_default, is_defined);
 
    // Unpack the parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked value matches the original value
    if (unpacked_value != value)
      PUT_ERR("double unpack should update destination value to source value");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(buffer);
  }
}
 
static void utest_scalar_str_roundtrip(MPI_Comm comm) {
 
  { // Test pack/unpack of a single string parameter with default value in
    // defined state
    char const * param_name = "sval";
    char const * default_value = "default";
    int const allow_null = 0;
    int const allow_empty = 0;
    size_t const max_str_len = 128;
    int const has_default = 1;
    int const is_defined = 1;
 
    char * value = strdup(default_value);
 
    // Create new string parameter
    struct yac_param * param = yac_param_str_new(
      param_name, &value, default_value, allow_null, allow_empty,
      max_str_len, has_default, is_defined);
 
    // Get pack size for the parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("string pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new parameter for unpacking with default value
    char * unpacked_value = strdup(default_value);
    struct yac_param * unpacked_param = yac_param_str_new(
      param_name, &unpacked_value, default_value, allow_null, allow_empty,
      max_str_len, has_default, is_defined);
 
    // Unpack the parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked value matches the original value
    if (strcmp(unpacked_value, value) != 0)
      PUT_ERR("string unpack should update destination value to source value");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(value);
    free(unpacked_value);
    free(buffer);
  }
 
  { // Test pack/unpack of a single string parameter with non-default value
    char const * param_name = "sval";
    char const * default_value = "default";
    int const allow_null = 0;
    int const allow_empty = 0;
    size_t const max_str_len = 128;
    int const has_default = 1;
    int const is_defined = 1;
 
    // Long value ensures internal string-buffer growth logic is exercised.
    char * value = strdup(
      "this-is-a-long-string-value-that-forces-buffer-growth-in-pack-size");
 
    // Create new string parameter
    struct yac_param * param = yac_param_str_new(
      param_name, &value, default_value, allow_null, allow_empty,
      max_str_len, has_default, is_defined);
 
    // Get pack size for the parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("string pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new parameter for unpacking with default value
    char * unpacked_value = strdup(default_value);
    struct yac_param * unpacked_param = yac_param_str_new(
      param_name, &unpacked_value, default_value, allow_null, allow_empty,
      max_str_len, has_default, is_defined);
 
    // Unpack the parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked value matches the original value
    if (strcmp(unpacked_value, value) != 0)
      PUT_ERR("string unpack should update destination value to source value");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(value);
    free(unpacked_value);
    free(buffer);
  }
}
 
static void utest_struct_roundtrip(MPI_Comm comm) {
 
  { // Struct path packs only non-default children by name
 
    char const * param_name = "struct";
 
    struct test_type {
      int i, b;
      double d;
      char * s;
    } data = {42, 1, 3.14, strdup("custom")};
 
    struct yac_param * sub_params[] = {
      yac_param_int_new("i", &data.i, 0, -1000, 1000, 1, 1),
      yac_param_bool_new("b", &data.b, 0, 1, 1),
      yac_param_dble_new("d", &data.d, 0.0, -1000.0, 1000.0, 0, 0, 1, 1),
      yac_param_str_new("s", &data.s, "default", 0, 0, 128, 1, 1),
    };
    enum {NUM_SUB_PARAMS = sizeof(sub_params) / sizeof(sub_params[0])};
 
    // Create a struct parameter with the sub-parameters
    struct yac_param * param =
      yac_param_struct_new(param_name, sub_params, NUM_SUB_PARAMS);
 
    // Get pack size for the struct parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("struct pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the struct parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new struct parameter for unpacking with default values
    struct test_type unpacked_data = {0, 0, 0.0, strdup("default")};
    struct yac_param * unpacked_param =
      yac_param_struct_new(
        param_name,
        (struct yac_param*[]) {
          yac_param_int_new("i", &unpacked_data.i, 0, -1000, 1000, 1, 1),
          yac_param_bool_new("b", &unpacked_data.b, 0, 1, 1),
          yac_param_dble_new(
            "d", &unpacked_data.d, 0.0, -1000.0, 1000.0, 0, 0, 1, 1),
          yac_param_str_new("s", &unpacked_data.s, "default", 0, 0, 128, 1, 1),
        }, NUM_SUB_PARAMS);
 
    // Unpack the struct parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked values match the original values
    if (unpacked_data.i != data.i)
      PUT_ERR("non-default struct child should remain default after roundtrip");
    if (unpacked_data.b != data.b)
      PUT_ERR("non-default bool struct child should be unpacked");
    if (unpacked_data.d != data.d)
      PUT_ERR("non-default double struct child should remain default after roundtrip");
    if (strcmp(unpacked_data.s, data.s) != 0)
      PUT_ERR("non-default string struct child should be unpacked");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(data.s);
    free(unpacked_data.s);
    free(buffer);
  }
 
  { // Struct path with only default children packs nothing,
    // and unpacking leaves defaults unchanged
 
    char const * param_name = "struct";
 
    struct test_type {
      int i, b;
      double d;
      char * s;
    } data = {0, 0, 0.0, strdup("default")};
 
    struct yac_param * sub_params[] = {
      yac_param_int_new("i", &data.i, 0, -1000, 1000, 1, 1),
      yac_param_bool_new("b", &data.b, 0, 1, 1),
      yac_param_dble_new("d", &data.d, 0.0, -1000.0, 1000.0, 0, 0, 1, 1),
      yac_param_str_new("s", &data.s, "default", 0, 0, 128, 1, 1),
    };
    enum {NUM_SUB_PARAMS = sizeof(sub_params) / sizeof(sub_params[0])};
 
    // Create a struct parameter with the sub-parameters
    struct yac_param * param =
      yac_param_struct_new(param_name, sub_params, NUM_SUB_PARAMS);
 
    // Get pack size for the struct parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("struct pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the struct parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new struct parameter for unpacking with default values
    struct test_type unpacked_data = {0, 0, 0.0, strdup("default")};
    struct yac_param * unpacked_param =
      yac_param_struct_new(
        param_name,
        (struct yac_param*[]) {
          yac_param_int_new("i", &unpacked_data.i, 0, -1000, 1000, 1, 1),
          yac_param_bool_new("b", &unpacked_data.b, 0, 1, 1),
          yac_param_dble_new(
            "d", &unpacked_data.d, 0.0, -1000.0, 1000.0, 0, 0, 1, 1),
          yac_param_str_new("s", &unpacked_data.s, "default", 0, 0, 128, 1, 1),
        }, NUM_SUB_PARAMS);
 
    // Unpack the struct parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked values match the original values
    if (unpacked_data.i != data.i)
      PUT_ERR("default struct child should remain default after roundtrip");
    if (unpacked_data.b != data.b)
      PUT_ERR("default bool struct child should remain default after roundtrip");
    if (unpacked_data.d != data.d)
      PUT_ERR("default double struct child should remain default after roundtrip");
    if (strcmp(unpacked_data.s, data.s) != 0)
      PUT_ERR("default string struct child should remain default after roundtrip");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(data.s);
    free(unpacked_data.s);
    free(buffer);
  }
 
  { // Struct path with partial default children
    char const * param_name = "struct";
 
    struct test_type {
      int i, b;
      double d;
      char * s;
    } data = {42, 0, 3.14, strdup("default")};
 
    struct yac_param * sub_params[] = {
      yac_param_int_new("i", &data.i, 0, -1000, 1000, 1, 1),
      yac_param_bool_new("b", &data.b, 0, 1, 1),
      yac_param_dble_new("d", &data.d, 0.0, -1000.0, 1000.0, 0, 0, 1, 1),
      yac_param_str_new("s", &data.s, "default", 0, 0, 128, 1, 1),
    };
    enum {NUM_SUB_PARAMS = sizeof(sub_params) / sizeof(sub_params[0])};
 
    // Create a struct parameter with the sub-parameters
    struct yac_param * param =
      yac_param_struct_new(param_name, sub_params, NUM_SUB_PARAMS);
 
    // Get pack size for the struct parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("struct pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the struct parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new struct parameter for unpacking with default values
    struct test_type unpacked_data = {0, 0, 0.0, strdup("default")};
    struct yac_param * unpacked_param =
      yac_param_struct_new(
        param_name,
        (struct yac_param*[]) {
          yac_param_int_new("i", &unpacked_data.i, 0, -1000, 1000, 1, 1),
          yac_param_bool_new("b", &unpacked_data.b, 0, 1, 1),
          yac_param_dble_new(
            "d", &unpacked_data.d, 0.0, -1000.0, 1000.0, 0, 0, 1, 1),
          yac_param_str_new("s", &unpacked_data.s, "default", 0, 0, 128, 1, 1),
        }, NUM_SUB_PARAMS);
 
    // Unpack the struct parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked values match the original values
    if (unpacked_data.i != data.i)
      PUT_ERR("default struct child should remain default after roundtrip");
    if (unpacked_data.b != data.b)
      PUT_ERR("default bool struct child should remain default after roundtrip");
    if (unpacked_data.d != data.d)
      PUT_ERR("default double struct child should remain default after roundtrip");
    if (strcmp(unpacked_data.s, data.s) != 0)
      PUT_ERR("default string struct child should remain default after roundtrip");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    free(data.s);
    free(unpacked_data.s);
    free(buffer);
  }
}
 
static void utest_list_roundtrip(MPI_Comm comm) {
 
  { // List path serializes element count and element records in order
    char const * param_name = "list";
 
    // Create a list parameter with a default factory for elements
    void ** list = NULL;
    struct yac_param * param =
      yac_param_list_new(param_name, &list, utest_list_default_factory, NULL);
 
    // Add two elements to the list
    struct yac_param * elem0 = NULL;
    struct yac_param * elem1 = NULL;
    if (yac_param_append(param, &elem0) != 0)
      PUT_ERR("list append for first source element failed");
    if (yac_param_append(param, &elem1) != 0)
      PUT_ERR("list append for second source element failed");
 
    // First element stays at default value, second element is set to a
    // non-default value
    yac_param_set_scalar_int(elem1, 22);
 
    // Get pack size for the list parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("list pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the list parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new list parameter for unpacking with default factory
    void ** unpacked_list = NULL;
    struct yac_param * unpacked_param =
      yac_param_list_new(
        param_name, &unpacked_list, utest_list_default_factory, NULL);
 
    // Unpack the list parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked list is identical to the original list in terms
    // of count and element values
    size_t count = 0;
    if (yac_param_get_sub_count(unpacked_param, &count) != 0 || count != 2)
      PUT_ERR("list unpack should create two destination elements");
    for (size_t i = 0; i < count; ++i) {
      if (*(int*)list[i] != *(int*)unpacked_list[i])
        PUT_ERR("list unpack should preserve elements");
    }
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    utest_free_int_list(list);
    utest_free_int_list(unpacked_list);
    free(buffer);
  }
}
 
static void utest_empty_list_roundtrip(MPI_Comm comm) {
 
  { // Explicitly cover list unpack with sub_count = 0
    char const * param_name = "list";
 
    // Create a list parameter with a default factory for elements
    void ** list = NULL;
    struct yac_param * param =
      yac_param_list_new(param_name, &list, utest_list_default_factory, NULL);
 
    // Get pack size for the list parameter
    size_t pack_size = yac_param_get_pack_size(param, comm, __func__);
    if (pack_size == 0) PUT_ERR("empty-list pack size should be > 0");
 
    // Allocate buffer for packing
    void * buffer = malloc(pack_size);
    int pos = 0;
 
    // Pack the list parameter into the buffer
    yac_param_pack(param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Create new list parameter for unpacking with default factory
    void ** unpacked_list = NULL;
    struct yac_param * unpacked_param =
      yac_param_list_new(
        param_name, &unpacked_list, utest_list_default_factory, NULL);
 
    // Unpack the list parameter from the buffer
    pos = 0;
    yac_param_unpack(
      unpacked_param, buffer, (int)pack_size, &pos, comm, __func__);
 
    // Check that the unpacked list is empty, as expected
    size_t count = 99;
    if (yac_param_get_sub_count(unpacked_param, &count) != 0 || count != 0)
      PUT_ERR("empty list roundtrip should keep destination list empty");
 
    // Clean up
    yac_param_delete(param);
    yac_param_delete(unpacked_param);
    utest_free_int_list(list);
    utest_free_int_list(unpacked_list);
    free(buffer);
  }
}