test_interp_method_config.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <string.h>
 
#include "interpolation/methods/interp_method_config.h"
#include "interpolation/methods/interp_method_dnn.h"
#include "interpolation/methods/interp_method_nnn.h"
#include "tests.h"
#include "test_expect_abort.h"
#include "parameter/param.h"
#include "geometry.h"
 
static struct yac_param * utest_get_subparam(
  struct yac_param * param, char const * subparam_name);
 
int main(void) {
 
  MPI_Init(NULL, NULL);
 
  { // Basic test with average interpolation method configuration
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("average");
    if (!config) PUT_ERR("avg_create failed");
 
    // Test copy
    struct yac_interp_method_config *copy =
      yac_interp_method_config_copy(config);
    if (!copy) PUT_ERR("copy failed");
 
    // Test compare (identical)
    if (yac_interp_method_config_compare(config, copy) != 0)
      PUT_ERR("compare failed");
 
    // Test compare (different partial_coverage)
    struct yac_interp_method_config *config2 =
      yac_interp_method_config_default_from_name_new("average");
    if (!config2) PUT_ERR("avg_create failed (config2)");
    struct yac_param * config2_param =
      yac_interp_method_config_get_param(config2);
    struct yac_param * partial_coverage_param = NULL;
    if (yac_param_get_sub_by_name(
          config2_param, "partial_coverage", &partial_coverage_param) != 0)
      PUT_ERR("failed to get avg.partial_coverage parameter");
    if (yac_param_set_scalar_int(partial_coverage_param, 1) != 0)
      PUT_ERR("failed to set avg.partial_coverage parameter");
    if (yac_interp_method_config_compare(config, config2) == 0)
      PUT_ERR("compare should detect difference");
    yac_interp_method_config_delete(config2);
 
 
    struct interp_method * interp_stack[2] =
      {yac_interp_method_config_generate(config), NULL};
    if (interp_stack[0] == NULL) PUT_ERR("generate should not return NULL");
 
    yac_interp_method_delete(interp_stack);
    yac_interp_method_config_delete(copy);
    yac_interp_method_config_delete(config);
  }
 
  { // get_param cache and ownership behavior
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("average");
    if (!config) PUT_ERR("avg_create failed");
 
    struct yac_param *param_a =
      yac_interp_method_config_get_param(config);
    struct yac_param *param_b =
      yac_interp_method_config_get_param(config);
    if (param_a != param_b)
      PUT_ERR("get_param should return cached handle");
 
    struct yac_param *partial_coverage_a = NULL;
    if (yac_param_get_sub_by_name(
          param_a, "partial_coverage", &partial_coverage_a) != 0)
      PUT_ERR("failed to get avg.partial_coverage parameter");
    if (yac_param_set_scalar_int(partial_coverage_a, 1) != 0)
      PUT_ERR("failed to set avg.partial_coverage parameter");
 
    struct yac_param *partial_coverage_b = NULL;
    if (yac_param_get_sub_by_name(
          param_b, "partial_coverage", &partial_coverage_b) != 0)
      PUT_ERR("failed to re-get avg.partial_coverage parameter");
    int partial_coverage = 0;
    if (yac_param_get_scalar_int(partial_coverage_b, &partial_coverage) != 0)
      PUT_ERR("failed to read avg.partial_coverage parameter");
    if (partial_coverage != 1)
      PUT_ERR("cached parameter handle did not expose latest value");
 
    struct yac_interp_method_config *copy =
      yac_interp_method_config_copy(config);
    if (!copy) PUT_ERR("copy failed");
    struct yac_param *copy_param =
      yac_interp_method_config_get_param(copy);
    if (copy_param == param_a)
      PUT_ERR("copied config must not share cached parameter handle");
 
    size_t pack_size =
      yac_interp_method_config_get_pack_size(config, MPI_COMM_SELF);
    int mpi_pack_size = (int)pack_size;
    void *sendbuf = malloc(mpi_pack_size);
    void *recvbuf = malloc(mpi_pack_size);
    int pos = 0;
    yac_interp_method_config_pack(
      config, sendbuf, mpi_pack_size, &pos, MPI_COMM_SELF);
    MPI_Sendrecv(
      sendbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      recvbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      MPI_COMM_SELF, MPI_STATUS_IGNORE);
    int rpos = 0;
    struct yac_interp_method_config *unpacked =
      yac_interp_method_config_unpack(
        recvbuf, mpi_pack_size, &rpos, MPI_COMM_SELF);
    if (!unpacked) PUT_ERR("avg_unpack failed");
    struct yac_param *unpacked_param =
      yac_interp_method_config_get_param(unpacked);
    if (unpacked_param == param_a)
      PUT_ERR("unpacked config must not share cached parameter handle");
 
    free(sendbuf);
    free(recvbuf);
    yac_interp_method_config_delete(unpacked);
    yac_interp_method_config_delete(copy);
    yac_interp_method_config_delete(config);
  }
 
  { // Basic test for pack/unpack with average config
    struct yac_interp_method_config *send_config =
      yac_interp_method_config_default_from_name_new("average");
    if (!send_config) PUT_ERR("avg_create failed");
    size_t pack_size =
      yac_interp_method_config_get_pack_size(send_config, MPI_COMM_SELF);
    int mpi_pack_size = (int)pack_size;
    void *sendbuf = malloc(mpi_pack_size);
    void *recvbuf = malloc(mpi_pack_size);
    int pos = 0;
    yac_interp_method_config_pack(
      send_config, sendbuf, mpi_pack_size, &pos, MPI_COMM_SELF);
    MPI_Sendrecv(
      sendbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      recvbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      MPI_COMM_SELF, MPI_STATUS_IGNORE);
    int rpos = 0;
    struct yac_interp_method_config *recv_config =
      yac_interp_method_config_unpack(recvbuf, mpi_pack_size, &rpos, MPI_COMM_SELF);
    if (!recv_config) PUT_ERR("avg_unpack failed");
    if (yac_interp_method_config_compare(send_config, recv_config) != 0)
      PUT_ERR("compare failed");
    free(sendbuf);
    free(recvbuf);
    yac_interp_method_config_delete(send_config);
    yac_interp_method_config_delete(recv_config);
  }
 
  { // Check NULL config handling
    // yac_interp_method_config_delete(NULL) should not crash
    yac_interp_method_config_delete(NULL);
 
    // yac_interp_method_config_copy(NULL) should return NULL
    if (yac_interp_method_config_copy(NULL) != NULL)
      PUT_ERR("copy(NULL) should return NULL");
 
    // yac_interp_method_config_compare(NULL, NULL) should return 0
    if (yac_interp_method_config_compare(NULL, NULL) != 0)
      PUT_ERR("compare(NULL, NULL) should return 0");
 
    // yac_interp_method_config_compare(NULL, valid) should return -1
    struct yac_interp_method_config *valid_config =
      yac_interp_method_config_default_from_name_new("average");
    if (yac_interp_method_config_compare(NULL, valid_config) != -1)
      PUT_ERR("compare(NULL, valid) should return -1");
    if (yac_interp_method_config_compare(valid_config, NULL) != 1)
      PUT_ERR("compare(valid, NULL) should return 1");
    yac_interp_method_config_delete(valid_config);
 
    // packing/unpacking
    struct yac_interp_method_config *send_config = NULL;
    size_t pack_size =
      yac_interp_method_config_get_pack_size(send_config, MPI_COMM_SELF);
    int mpi_pack_size = (int)pack_size;
    void *sendbuf = malloc(mpi_pack_size);
    void *recvbuf = malloc(mpi_pack_size);
    int pos = 0;
    yac_interp_method_config_pack(
      NULL, sendbuf, mpi_pack_size, &pos, MPI_COMM_SELF);
    MPI_Sendrecv(
      sendbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      recvbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      MPI_COMM_SELF, MPI_STATUS_IGNORE);
    int rpos = 0;
    struct yac_interp_method_config *recv_config =
      yac_interp_method_config_unpack(
        recvbuf, mpi_pack_size, &rpos, MPI_COMM_SELF);
 
    free(recvbuf);
    free(sendbuf);
 
    if (recv_config) PUT_ERR("undefined_unpack failed");
    if (yac_interp_method_config_compare(send_config, recv_config) != 0)
      PUT_ERR("compare failed");
 
    // yac_interp_method_config_get_type(NULL) should return -1 (invalid)
    if (yac_interp_method_config_get_type(NULL) != YAC_UNDEFINED)
      PUT_ERR("get_type(NULL) should return YAC_UNDEFINED");
 
    // yac_interp_method_config_get_param(NULL) should return NULL
    if (yac_interp_method_config_get_param(NULL) != NULL)
      PUT_ERR("get_param(NULL) should return NULL");
 
    // yac_interp_method_config_generate(NULL) should return NULL
    if (yac_interp_method_config_generate(NULL) != NULL)
      PUT_ERR("generate(NULL) should return NULL");
  }
 
  { // Short interface test for all default method configurations
    struct {
      char const *name;
      enum yac_interpolation_list type;
    } test_cases[] = {
      {"average", YAC_AVERAGE},
      {"ncc", YAC_NEAREST_CORNER_CELLS},
      {"nnn", YAC_N_NEAREST_NEIGHBOR},
      {"rbf", YAC_RADIAL_BASIS_FUNCTION},
      {"dnn", YAC_DISTANCE_NEAREST_NEIGHBOR},
      {"conservative", YAC_CONSERVATIVE},
      {"fixed", YAC_FIXED_VALUE},
      {"user_file", YAC_USER_FILE},
      {"file", YAC_USER_FILE},
      {"check", YAC_CHECK},
      {"bernstein_bezier", YAC_BERNSTEIN_BEZIER},
      {"creep", YAC_CREEP},
      {"user_callback", YAC_USER_CALLBACK},
      {"callback", YAC_USER_CALLBACK},
      {"source_to_target_map", YAC_SOURCE_TO_TARGET_MAP},
      {"spmap", YAC_SOURCE_TO_TARGET_MAP},
    };
 
    for (size_t i = 0; i < sizeof(test_cases) / sizeof(test_cases[0]); ++i) {
 
      // generate default config by name and check type
      struct yac_interp_method_config *config =
        yac_interp_method_config_default_from_name_new(test_cases[i].name);
      if (!config)
        PUT_ERR("yac_interp_method_config_default_from_name_new returned NULL");
 
      // check that the type matches the expected type for this method
      if (yac_interp_method_config_get_type(config) != test_cases[i].type)
        PUT_ERR(
          "yac_interp_method_config_default_from_name_new returned wrong type");
 
      // check that get_param returns a valid parameter tree handle
      struct yac_param *param =
        yac_interp_method_config_get_param(config);
      if (!param)
        PUT_ERR("yac_interp_method_config_get_param returned NULL");
 
      // check that default parameters report is_default == 1
      // (YAC_USER_FILE and YAC_USER_CALLBACK contain parameters that
      //  have no default)
      if (test_cases[i].type == YAC_USER_FILE ||
          test_cases[i].type == YAC_USER_CALLBACK) {
        if (yac_param_is_default(param) != 0)
          PUT_ERR_F(
            "%s config parameters should not be default", test_cases[i].name);
      } else {
        if (yac_param_is_default(param) != 1)
          PUT_ERR_F(
            "default config parameters of %s should be in default state",
            test_cases[i].name);
      }
 
      // check that copying the config produces an identical config
      struct yac_interp_method_config *copy =
        yac_interp_method_config_copy(config);
      if (!copy)
        PUT_ERR("yac_interp_method_config_copy returned NULL");
      if (yac_interp_method_config_compare(config, copy) != 0)
        PUT_ERR("yac_interp_method_config_compare failed for copied config");
 
      // user_file method requires a filename to be set
      if (test_cases[i].type == YAC_USER_FILE) {
        yac_interp_method_config_set_param_str(config, "filename", "test.txt");
      }
 
      // user_callback method requires a callback function to be set
      if (test_cases[i].type == YAC_USER_CALLBACK) {
        yac_interp_method_config_set_param_str(
          config, "func_compute_weights", "test_callback");
      }
 
      // check packing and unpacking of the config
      size_t pack_size =
        yac_interp_method_config_get_pack_size(config, MPI_COMM_SELF);
      int mpi_pack_size = (int)pack_size;
      void *sendbuf = malloc(mpi_pack_size);
      void *recvbuf = malloc(mpi_pack_size);
      int pos = 0;
      yac_interp_method_config_pack(
        config, sendbuf, mpi_pack_size, &pos, MPI_COMM_SELF);
      MPI_Sendrecv(
        sendbuf, mpi_pack_size, MPI_PACKED, 0, 0,
        recvbuf, mpi_pack_size, MPI_PACKED, 0, 0,
        MPI_COMM_SELF, MPI_STATUS_IGNORE);
      int rpos = 0;
      struct yac_interp_method_config *unpacked =
        yac_interp_method_config_unpack(
          recvbuf, mpi_pack_size, &rpos, MPI_COMM_SELF);
      if (!unpacked)
        PUT_ERR("yac_interp_method_config_unpack returned NULL");
      if (yac_interp_method_config_compare(config, unpacked) != 0)
        PUT_ERR("pack/unpack roundtrip compare failed");
      free(sendbuf);
      free(recvbuf);
 
      // check that generate produces a non-NULL method for all methods
      // that do not require mandatory parameters
      // (user_file needs a filename and user_callback needs a callback
      //  function, so these are excluded)
      if ((test_cases[i].type != YAC_USER_FILE) &&
          (test_cases[i].type != YAC_USER_CALLBACK)) {
        struct interp_method *stack[2] =
          {yac_interp_method_config_generate(config), NULL};
        if (stack[0] == NULL)
          PUT_ERR("yac_interp_method_config_generate returned NULL");
        yac_interp_method_delete(stack);
      }
 
      // cleanup
      yac_interp_method_config_delete(unpacked);
      yac_interp_method_config_delete(copy);
      yac_interp_method_config_delete(config);
    }
  }
 
  { // Test get_param for RBF interpolation method configuration
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("rbf");
    if (!config) PUT_ERR("rbf_create failed");
 
    struct yac_param *param =
      yac_interp_method_config_get_param(config);
    if (!param) PUT_ERR("rbf get_param returned NULL");
 
    // root should be a struct named "rbf"
    if (yac_param_get_type(param) !=
        YAC_PARAM_TYPE_STRUCT)
      PUT_ERR("rbf get_param root type should be STRUCT");
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, "rbf") != 0)
      PUT_ERR("rbf get_param root name should be 'rbf'");
 
    // should have 5 subparams: n, n_min, max_search_distance, rbf_scale,
    // rbf_kernel
    enum {REF_NUM_SUBPARAMS = 5};
    size_t count = 0;
    if (yac_param_get_sub_count(param, &count) != 0)
      PUT_ERR("rbf get_param get_sub_count failed");
    if (count != REF_NUM_SUBPARAMS)
      PUT_ERR("rbf get_param should have 5 subparams");
 
    struct yac_param *sub = NULL;
    if (yac_param_get_sub_by_name(param, "n", &sub) != 0
        || !sub)
      PUT_ERR("rbf get_param missing 'n' subparam");
    if (yac_param_get_sub_by_name(param, "n_min", &sub) != 0
        || !sub)
      PUT_ERR("rbf get_param missing 'n_min' subparam");
    if (yac_param_get_sub_by_name(
            param, "max_search_distance", &sub) != 0 || !sub)
      PUT_ERR("rbf get_param missing 'max_search_distance' subparam");
    if (yac_param_get_sub_by_name(
            param, "rbf_scale", &sub) != 0 || !sub)
      PUT_ERR("rbf get_param missing 'rbf_scale' subparam");
    if (yac_param_get_sub_by_name(
            param, "rbf_kernel", &sub) != 0 || !sub)
      PUT_ERR("rbf get_param missing 'rbf_kernel' subparam");
 
    // all at defaults → is_default should be true
    if (yac_param_is_default(param) != 1)
      PUT_ERR("rbf get_param should report all-default");
    yac_interp_method_config_delete(config);
  }
 
  { // NNN n_min handling
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("nnn");
    if (!config) PUT_ERR("nnn_create failed");
 
    // n_min defaults to 0, which is interpreted as "use n"
    if (yac_interp_method_config_get_param_int(config, "n_min") !=
        YAC_INTERP_NNN_N_MIN_DEFAULT)
      PUT_ERR("nnn default 'n_min' value is wrong");
 
    yac_interp_method_config_set_param_int(config, "n", 4);
    yac_interp_method_config_set_param_int(config, "n_min", 2);
    if (yac_interp_method_config_get_param_int(config, "n_min") != 2)
      PUT_ERR("failed to set nnn 'n_min' parameter");
 
    // n_min == 0 and n_min == n are equivalent
    struct yac_interp_method_config *config_default_n_min =
      yac_interp_method_config_default_from_name_new("nnn");
    struct yac_interp_method_config *config_explicit_n_min =
      yac_interp_method_config_default_from_name_new("nnn");
    yac_interp_method_config_set_param_int(config_default_n_min, "n", 4);
    yac_interp_method_config_set_param_int(config_explicit_n_min, "n", 4);
    yac_interp_method_config_set_param_int(config_explicit_n_min, "n_min", 4);
    if (yac_interp_method_config_compare(
          config_default_n_min, config_explicit_n_min) != 0)
      PUT_ERR("n_min == 0 and n_min == n should compare as equal");
    if (yac_interp_method_config_compare(config, config_explicit_n_min) == 0)
      PUT_ERR("compare should detect different n_min");
    yac_interp_method_config_delete(config_explicit_n_min);
    yac_interp_method_config_delete(config_default_n_min);
 
    // n_min > n is invalid
    yac_interp_method_config_set_param_int(config, "n_min", 5);
    int test_failed;
    YAC_TEST_EXPECT_ABORT_SERIAL(
      test_failed, YAC_TEST_ABORT_EXPECTED, "unsupported value for n_min",
      yac_interp_method_config_generate(config));
    if (test_failed) PUT_ERR("n_min > n should abort");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Doxygen example: NNN config and method generation
// The following code snippet is included in the Doxygen documentation
// for yac_interp_method_config.
// (Since this is to be display on the documentation website, we can make
// an exception in respect to the 80-characters-per-line rule)
// Create the default NNN interpolation method configuration object.
struct yac_interp_method_config *config =
  yac_interp_method_config_default_from_name_new("nnn");
 
// Get the root parameter of the configuration.
struct yac_param *root = yac_interp_method_config_get_param(config);
 
// Set custom values to configure Gaussian-weighted NNN.
yac_param_set_scalar(utest_get_subparam(root, "weighted"), "gauss_weighted");
yac_param_set_scalar_int(utest_get_subparam(root, "n"), 8);
yac_param_set_scalar_dble(utest_get_subparam(root, "max_search_distance"), 0.2);
yac_param_set_scalar_dble(utest_get_subparam(root, "gauss_scale"), 0.75);
 
// The parameter tree handle is cached and owned by the config.
 
// Generate an executable interpolation method from the config.
struct interp_method * method = yac_interp_method_config_generate(config);
 
// The config object is no longer needed after generation.
yac_interp_method_config_delete(config);
 
// The generated method can now be used in an interpolation stack.
// The stack is NULL-terminated to allow for variable-length stacks.
struct interp_method *stack[] = {method, NULL};
 
// Use the method stack for interpolation (not shown here)...
 
// Clean up the method stack after use.
yac_interp_method_delete(stack);
  }
 
  { // Test DNN search_distance oneof parameter handling
    struct yac_interp_method_config * config =
      yac_interp_method_config_default_from_name_new("dnn");
    if (!config) PUT_ERR("dnn_create failed");
 
    struct yac_param * root_param =
      yac_interp_method_config_get_param(config);
    if (!root_param) PUT_ERR("dnn get_param returned NULL");
 
    struct yac_param * search_distance_param = NULL;
    if (yac_param_get_sub_by_name(
          root_param, "search_distance", &search_distance_param) != 0)
      PUT_ERR("dnn get_param missing 'search_distance' subparam");
 
    struct yac_param * fixed_param = NULL;
    if (yac_param_get_sub_by_name(
          search_distance_param, "fixed", &fixed_param) != 0)
      PUT_ERR("dnn get_param failed to select search_distance.fixed");
    if (yac_param_set_scalar_dble(fixed_param, 1.0 * YAC_RAD) != 0)
      PUT_ERR("dnn failed to set search_distance.fixed");
 
    struct yac_param * cell_area_param = NULL;
    if (yac_param_get_sub_by_name(
          search_distance_param, "cell_area", &cell_area_param) == 0)
      PUT_ERR("dnn oneof allowed selecting fixed and cell_area together");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test DNN search_distance cell_area branch inference
    struct yac_interp_method_config * config =
      yac_interp_method_config_default_from_name_new("dnn");
    if (!config) PUT_ERR("dnn_create failed");
 
    struct yac_param * root_param =
      yac_interp_method_config_get_param(config);
    if (!root_param) PUT_ERR("dnn get_param returned NULL");
 
    struct yac_param * search_distance_param = NULL;
    if (yac_param_get_sub_by_name(
          root_param, "search_distance", &search_distance_param) != 0)
      PUT_ERR("dnn get_param missing 'search_distance' subparam");
 
    struct yac_param * cell_area_param = NULL;
    if (yac_param_get_sub_by_name(
          search_distance_param, "cell_area", &cell_area_param) != 0)
      PUT_ERR("dnn get_param failed to select search_distance.cell_area");
    if (yac_param_set_scalar_dble(cell_area_param, 2.0 * YAC_RAD) != 0)
      PUT_ERR("dnn failed to set search_distance.cell_area");
 
    struct yac_param * fixed_param = NULL;
    if (yac_param_get_sub_by_name(
          search_distance_param, "fixed", &fixed_param) == 0)
      PUT_ERR("dnn oneof allowed selecting cell_area and fixed together");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Query default DNN configuration contents
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("dnn");
    if (!config) PUT_ERR("dnn default_create failed");
 
    // type must be YAC_DISTANCE_NEAREST_NEIGHBOR
    if (yac_interp_method_config_get_type(config) !=
        YAC_DISTANCE_NEAREST_NEIGHBOR)
      PUT_ERR("dnn default config has wrong type");
 
    struct yac_param *root = yac_interp_method_config_get_param(config);
    if (!root) PUT_ERR("dnn get_param returned NULL");
 
    // root must be a struct named "dnn"
    if (yac_param_get_type(root) != YAC_PARAM_TYPE_STRUCT)
      PUT_ERR("dnn root param type should be STRUCT");
    if (strcmp(yac_param_get_name(root), "dnn") != 0)
      PUT_ERR("dnn root param name should be 'dnn'");
 
    // must have 5 subparams: weighted, n_min, gauss_scale, rbf_scale,
    // search_distance
    enum {REF_NUM_SUBPARAMS = 5};
    size_t count = 0;
    if (yac_param_get_sub_count(root, &count) != 0)
      PUT_ERR("dnn get_sub_count failed");
    if (count != REF_NUM_SUBPARAMS)
      PUT_ERR("dnn root should have 5 subparams");
 
    // n_min defaults to YAC_INTERP_DNN_N_MIN_DEFAULT
    struct yac_param *n_min_param = NULL;
    if (yac_param_get_sub_by_name(root, "n_min", &n_min_param) != 0
        || !n_min_param)
      PUT_ERR("dnn missing 'n_min' subparam");
    int n_min_val = -1;
    if (yac_param_get_scalar_int(n_min_param, &n_min_val) != 0)
      PUT_ERR("dnn failed to read 'n_min' value");
    if (n_min_val != YAC_INTERP_DNN_N_MIN_DEFAULT)
      PUT_ERR("dnn default 'n_min' value is wrong");
    if (yac_param_is_default(n_min_param) != 1)
      PUT_ERR("dnn 'n_min' should be at default");
 
    // weighted defaults to YAC_INTERP_DNN_WEIGHT_DEFAULT (DIST)
    struct yac_param *weighted_param = NULL;
    if (yac_param_get_sub_by_name(root, "weighted", &weighted_param) != 0
        || !weighted_param)
      PUT_ERR("dnn missing 'weighted' subparam");
    int weighted_val = -1;
    if (yac_param_get_scalar_int(weighted_param, &weighted_val) != 0)
      PUT_ERR("dnn failed to read 'weighted' value");
    if (weighted_val != YAC_INTERP_DNN_WEIGHT_DEFAULT)
      PUT_ERR("dnn default 'weighted' value is wrong");
    if (yac_param_is_default(weighted_param) != 1)
      PUT_ERR("dnn 'weighted' should be at default");
 
    // search_distance oneof defaults to cell_area
    struct yac_param *sd_param = NULL;
    if (yac_param_get_sub_by_name(root, "search_distance", &sd_param) != 0
        || !sd_param)
      PUT_ERR("dnn missing 'search_distance' subparam");
 
    // the active branch must be cell_area
    struct yac_param *cell_area_param = NULL;
    if (yac_param_get_sub_by_name(sd_param, "cell_area", &cell_area_param) != 0
        || !cell_area_param)
      PUT_ERR("dnn default search_distance branch should be 'cell_area'");
 
    // cell_area must hold YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA_DEFAULT
    double cell_area_val = -1.0;
    if (yac_param_get_scalar_dble(cell_area_param, &cell_area_val) != 0)
      PUT_ERR("dnn failed to read 'cell_area' value");
    if (cell_area_val != YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA_DEFAULT)
      PUT_ERR("dnn default 'cell_area' scale value is wrong");
    if (yac_param_is_default(cell_area_param) != 1)
      PUT_ERR("dnn 'cell_area' should be at default");
 
    // fixed branch must not be accessible (oneof exclusivity)
    struct yac_param *fixed_param = NULL;
    if (yac_param_get_sub_by_name(sd_param, "fixed", &fixed_param) == 0)
      PUT_ERR("dnn default: 'fixed' branch should not be accessible "
              "when 'cell_area' is active");
 
    // entire default config must report is_default == 1
    if (yac_param_is_default(root) != 1)
      PUT_ERR("dnn root should report all-default");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test invalid search distance type name for DNN
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("dnn");
    if (!config) PUT_ERR("dnn_create failed");
 
    struct yac_param *root_param =
      yac_interp_method_config_get_param(config);
    if (!root_param) PUT_ERR("dnn get_param returned NULL");
 
    struct yac_param *search_distance_param = NULL;
    if (yac_param_get_sub_by_name(
          root_param, "search_distance", &search_distance_param) != 0)
      PUT_ERR("dnn get_param missing 'search_distance' subparam");
 
    // An invalid search distance type name should trigger the default branch
    // of the switch in config_dnn_search_distance_factory and return an error.
    struct yac_param *invalid_param = NULL;
    if (yac_param_get_sub_by_name(
          search_distance_param, "invalid_search_distance_type",
          &invalid_param) == 0)
      PUT_ERR(
        "config_dnn_search_distance_factory accepted invalid search "
        "distance type name");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test default branch in spmap_cell_area_config_factory with invalid name
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("spmap");
    if (!config) PUT_ERR("spmap_create failed");
 
    struct yac_param *root_param =
      yac_interp_method_config_get_param(config);
    if (!root_param) PUT_ERR("spmap get_param returned NULL");
 
    struct yac_param *src_cell_area_param = NULL;
    if (yac_param_get_sub_by_name(
          root_param, "src_cell_area", &src_cell_area_param) != 0)
      PUT_ERR("spmap get_param missing 'src_cell_area' subparam");
 
    // An invalid cell area type name should trigger the default branch of
    // the switch in spmap_cell_area_config_factory and return an error.
    struct yac_param *invalid_param = NULL;
    if (yac_param_get_sub_by_name(
          src_cell_area_param, "invalid_area_type", &invalid_param) == 0)
      PUT_ERR(
        "spmap_cell_area_config_factory accepted invalid cell area type");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test convenience set/get int for nnn.n
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("nnn");
    if (!config) PUT_ERR("nnn_create failed");
 
    yac_interp_method_config_set_param_int(config, "n", 7);
 
    int n = yac_interp_method_config_get_param_int(config, "n");
    if (n != 7)
      PUT_ERR("convenience set/get int: expected n==7");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test convenience set/get dble for nnn.max_search_distance
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("nnn");
    if (!config) PUT_ERR("nnn_create failed");
 
    yac_interp_method_config_set_param_dble(config, "max_search_distance", 0.5);
 
    double d = yac_interp_method_config_get_param_dble(config, "max_search_distance");
    if (d != 0.5)
      PUT_ERR("convenience set/get dble: expected max_search_distance==0.5");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test convenience set/get str for nnn.weighted
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("nnn");
    if (!config) PUT_ERR("nnn_create failed");
 
    yac_interp_method_config_set_param_str(config, "weighted", "gauss_weighted");
 
    char *val = yac_interp_method_config_get_param_str(config, "weighted");
    if (!val || strcmp(val, "gauss_weighted") != 0)
      PUT_ERR("convenience set/get str: expected 'gauss_weighted'");
    free(val);
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test convenience with dot-separated path: dnn search_distance.fixed
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("dnn");
    if (!config) PUT_ERR("dnn_create failed");
 
    yac_interp_method_config_set_param_dble(
      config, "search_distance.fixed", 1.0 * YAC_RAD);
 
    double d =
      yac_interp_method_config_get_param_dble(config, "search_distance.fixed");
    if (d != 1.0 * YAC_RAD)
      PUT_ERR("dot-path set/get dble: wrong value");
 
    yac_interp_method_config_delete(config);
  }
 
  { // Test that modified config generates a valid method
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("nnn");
    if (!config) PUT_ERR("nnn_create failed");
 
    yac_interp_method_config_set_param_int(config, "n", 4);
    yac_interp_method_config_set_param_str(config, "weighted", "arithmetic_average");
 
    struct interp_method *stack[2] =
      {yac_interp_method_config_generate(config), NULL};
    if (stack[0] == NULL)
      PUT_ERR("generate after convenience set should not return NULL");
 
    yac_interp_method_delete(stack);
    yac_interp_method_config_delete(config);
  }
 
  { // Test that two configs modified to the same values compare equal
    struct yac_interp_method_config *a =
      yac_interp_method_config_default_from_name_new("nnn");
    struct yac_interp_method_config *b =
      yac_interp_method_config_default_from_name_new("nnn");
    if (!a || !b) PUT_ERR("nnn_create failed");
 
    yac_interp_method_config_set_param_int(a, "n", 5);
    yac_interp_method_config_set_param_int(b, "n", 5);
 
    if (yac_interp_method_config_compare(a, b) != 0)
      PUT_ERR("two configs set to same value should compare equal");
 
    yac_interp_method_config_set_param_int(b, "n", 6);
 
    if (yac_interp_method_config_compare(a, b) == 0)
      PUT_ERR("configs with different n should not compare equal");
 
    yac_interp_method_config_delete(a);
    yac_interp_method_config_delete(b);
  }
 
  { // Test convenience API round-trip via pack/unpack
    struct yac_interp_method_config *config =
      yac_interp_method_config_default_from_name_new("nnn");
    if (!config) PUT_ERR("nnn_create failed");
 
    yac_interp_method_config_set_param_int(config, "n", 9);
 
    size_t pack_size =
      yac_interp_method_config_get_pack_size(config, MPI_COMM_SELF);
    int mpi_pack_size = (int)pack_size;
    void *sendbuf = malloc(mpi_pack_size);
    void *recvbuf = malloc(mpi_pack_size);
    int pos = 0;
    yac_interp_method_config_pack(
      config, sendbuf, mpi_pack_size, &pos, MPI_COMM_SELF);
    MPI_Sendrecv(
      sendbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      recvbuf, mpi_pack_size, MPI_PACKED, 0, 0,
      MPI_COMM_SELF, MPI_STATUS_IGNORE);
    int rpos = 0;
    struct yac_interp_method_config *unpacked =
      yac_interp_method_config_unpack(recvbuf, mpi_pack_size, &rpos, MPI_COMM_SELF);
    if (!unpacked)
      PUT_ERR("unpack after convenience set returned NULL");
    if (yac_interp_method_config_compare(config, unpacked) != 0)
      PUT_ERR("pack/unpack roundtrip failed after convenience set");
 
    int n = yac_interp_method_config_get_param_int(unpacked, "n");
    if (n != 9)
      PUT_ERR("convenience get after unpack: expected n==9");
 
    free(sendbuf);
    free(recvbuf);
    yac_interp_method_config_delete(config);
    yac_interp_method_config_delete(unpacked);
  }
 
  // -- Test: list parameter support (spmap overwrite) --
  {
    struct yac_interp_method_config * config =
      yac_interp_method_config_default_from_name_new("spmap");
    if (!config)
      PUT_ERR("spmap config creation failed");
 
    // Default overwrite list should be empty.
    size_t initial_size =
      yac_interp_method_config_get_list_size(config, "overwrite");
    if (initial_size != 0)
      PUT_ERR("expected empty overwrite list initially");
 
    // Append a first overwrite element.
    size_t idx0 =
      yac_interp_method_config_append_list_element(config, "overwrite");
    if (idx0 != 0)
      PUT_ERR("expected index 0 for first appended element");
 
    size_t size_after_1 =
      yac_interp_method_config_get_list_size(config, "overwrite");
    if (size_after_1 != 1)
      PUT_ERR("expected list size 1 after one append");
 
    // Set a sub-parameter of the newly appended element via index path.
    yac_interp_method_config_set_param_dble(
      config, "overwrite.0.spread_distance", 0.05);
    double sd =
      yac_interp_method_config_get_param_dble(
        config, "overwrite.0.spread_distance");
    if (sd != 0.05)
      PUT_ERR("overwrite.0.spread_distance round-trip failed");
 
    // Append a second overwrite element and verify independent indexing.
    size_t idx1 =
      yac_interp_method_config_append_list_element(config, "overwrite");
    if (idx1 != 1)
      PUT_ERR("expected index 1 for second appended element");
 
    yac_interp_method_config_set_param_dble(
      config, "overwrite.1.spread_distance", 0.10);
    double sd1 =
      yac_interp_method_config_get_param_dble(
        config, "overwrite.1.spread_distance");
    if (sd1 != 0.10)
      PUT_ERR("overwrite.1.spread_distance round-trip failed");
 
    // First element must remain unchanged.
    double sd0 =
      yac_interp_method_config_get_param_dble(
        config, "overwrite.0.spread_distance");
    if (sd0 != 0.05)
      PUT_ERR("overwrite.0 was modified when setting overwrite.1");
 
    yac_interp_method_config_delete(config);
  }
 
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}
 
// The following code snippet is included in the Doxygen documentation
// for yac_interp_method_config.
 
static struct yac_param * utest_get_subparam(
  struct yac_param * param, char const * subparam_name) {
 
  struct yac_param *subparam = NULL;
  int status = yac_param_get_sub_by_name(param, subparam_name, &subparam);
  if (status != 0) {
    fputs("failed to retrieve sub-parameter", stderr);
    // add appropriate error handling
  }
  return subparam;
}