test_param.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>
#include <stdint.h>
 
#include "parameter/param.h"
#include "parameter/param_int.h"
#include "parameter/param_bool.h"
#include "parameter/param_dble.h"
#include "parameter/param_angle.h"
#include "parameter/param_distance.h"
#include "parameter/param_oneof.h"
#include "parameter/param_list.h"
#include "parameter/param_str.h"
#include "parameter/param_struct.h"
#include "parameter/param_enum.h"
#include "parameter/param_internal.h"
#include "tests.h"
 
static void utest_null_param_interfaces(void);
static void utest_get_last_error(void);
static void utest_deg_rad_conversion(void);
static void utest_int_param_interfaces(void);
static void utest_bool_param_interfaces(void);
static void utest_dble_param_interfaces(void);
static void utest_angle_param_interfaces(void);
static void utest_distance_param_interfaces(void);
static void utest_str_param_interfaces(void);
static void utest_enum_param_interfaces(void);
static void utest_struct_param_interfaces(void);
static void utest_oneof_param_interfaces(void);
static void utest_list_param_interfaces(void);
static void utest_usage_demo(void);
 
static double const tol = 1e-12;
 
int main(void) {
 
  utest_null_param_interfaces();
  utest_get_last_error();
  utest_deg_rad_conversion();
  utest_int_param_interfaces();
  utest_bool_param_interfaces();
  utest_dble_param_interfaces();
  utest_angle_param_interfaces();
  utest_distance_param_interfaces();
  utest_str_param_interfaces();
  utest_enum_param_interfaces();
  utest_struct_param_interfaces();
  utest_oneof_param_interfaces();
  utest_list_param_interfaces();
  utest_usage_demo();
 
  return TEST_EXIT_CODE;
}
 
static char const *oneof_int_param_name = "int_sub";
static int oneof_int_val = 7;
static int oneof_int_default = 42;
static int oneof_int_min = 0;
static int oneof_int_max = 100;
static int oneof_has_default = 1;
static int oneof_is_defined = 1;
 
static char const *oneof_bool_param_name = "bool_sub";
static int oneof_bool_val = 1;
static int oneof_bool_default = 0;
static int oneof_bool_has_default = 1;
static int oneof_bool_is_defined = 1;
 
static char const * oneof_default_param_name = "int_sub";
 
// Factory for oneof subparam (int_sub)
static int utest_oneof_factory(
  const char *name, void **obj,
  struct yac_param **param, int *is_default) {
  UNUSED(name);
 
  enum {
    INT_PARAM,
    BOOL_PARAM
  };
 
  struct yac_name_type_pair subparam_types[] = {
    {oneof_int_param_name, INT_PARAM},
    {oneof_bool_param_name, BOOL_PARAM}
  };
  enum {
    NUM_SUBPARAM_TYPES = sizeof(subparam_types) / sizeof(subparam_types[0])};
 
  if (name == NULL) {
    // No name provided, use default subparam
    name = oneof_default_param_name;
  }
 
  int type =
    yac_name_type_pair_get_type(subparam_types, NUM_SUBPARAM_TYPES, name);
 
  if (type == INT_MAX) {
    // Unsupported subparam name
    YAC_PARAM_ASSERT(0, "unsupported subparam name");
    return 1;
  }
 
  switch (type) {
    default: {__attribute__((fallthrough));}
    case (INT_PARAM): {
 
      int *val = xmalloc(sizeof(int));
      *val = oneof_int_val;
      *obj = val;
      *param = yac_param_int_new(
        oneof_int_param_name, val, oneof_int_default,
        oneof_int_min, oneof_int_max, oneof_has_default, oneof_is_defined);
      *is_default = 1;
      break;
    }
    case (BOOL_PARAM): {
 
      int *val = xmalloc(sizeof(int));
      *val = oneof_bool_val;
      *obj = val;
      *param = yac_param_bool_new(
        oneof_bool_param_name, val, oneof_bool_default,
        oneof_bool_has_default, oneof_bool_is_defined);
      *is_default = 0;
      break;
    }
  }
 
  return 0;
}
 
// Factory that always fails (for testing error handling in oneof)
static int utest_oneof_failing_factory(
  const char *name, void **obj,
  struct yac_param **param, int *is_default) {
  UNUSED(name);
  UNUSED(obj);
  UNUSED(param);
  UNUSED(is_default);
  return 1;
}
 
// Test oneof struct parameter interfaces
static void utest_oneof_param_interfaces(void) {
 
  { // main test (active subparam is set to default by factory)
 
    // Factory for oneof default subparam (int_sub)
    void *created_obj = NULL;
 
    char const * param_name = "oneof_param";
    struct yac_param * subparam = NULL;
    int subparam_is_default = 0;
    struct yac_param *param =
      yac_param_oneof_new(
        param_name, utest_oneof_factory, &created_obj, subparam, subparam_is_default);
 
    // get_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_STRUCT)
      PUT_ERR("oneof param get_type should return TYPE_STRUCT");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INT;
    int scalar_kind_ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((scalar_kind_ret == 0) ||
        (scalar_kind != YAC_PARAM_SCALAR_KIND_INVALID))
      PUT_ERR("oneof param get_scalar_kind should fail");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("oneof param get_name should return 'oneof_param'");
 
    // is_default (undefined oneof counts as default)
    int ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("oneof param is_default should be 1 (default)");
 
    // get_sub_count (should always be 1)
    size_t count = 0;
    ret = yac_param_get_sub_count(param, &count);
    if (ret != 0 || count != 1)
      PUT_ERR("oneof param get_sub_count should return 1");
 
    // get_sub_by_name  (should fail for any unsupported name)
    struct yac_param *sub = NULL;
    char const * unsupported_name = "unsupported_sub";
    ret = yac_param_get_sub_by_name(
      param, unsupported_name, &sub);
    if (ret == 0)
      PUT_ERR("oneof param get_sub_by_name should fail for non-default");
 
    // get_sub_by_index (only 0 allowed, should return the default subparam)
    sub = NULL;
    ret = yac_param_get_sub_by_index(param, 0, &sub);
    if (ret != 0 || !sub)
      PUT_ERR("oneof param get_sub_by_index failed for index 0");
    char const *sub_name = yac_param_get_name(sub);
    if (!sub_name || strcmp(sub_name, oneof_int_param_name) != 0)
      PUT_ERR(
        "oneof param get_sub_by_index should return subparam "
        "with name 'int_sub' for index 0");
 
    // get_sub_by_index should have selected the default subparam (int_sub)
    // and created it with the initial value
    if (!created_obj)
      PUT_ERR("oneof factory should have allocated an object for the subparam");
    if (*(int *)created_obj != oneof_int_val)
      PUT_ERR(
        "oneof factory should have set the created object to the initial value");
 
    // get_sub_by_index (out of bounds)
    ret = yac_param_get_sub_by_index(param, 1, &sub);
    if (ret == 0)
      PUT_ERR("oneof param get_sub_by_index should fail for idx != 0");
 
    // get_sub_by_name
    // (should fail for any name different from the one currently set)
    sub = NULL;
    ret =
      yac_param_get_sub_by_name(
        param, oneof_bool_param_name, &sub);
    if (ret == 0)
      PUT_ERR(
        "oneof param get_sub_by_name should fail for valid but "
        "non-active subparam name");
 
    // get_sub_by_name (should succeed for int_sub)
    sub = NULL;
    ret = yac_param_get_sub_by_name(
      param, oneof_int_param_name, &sub);
    if (ret != 0 || !sub)
      PUT_ERR("oneof param get_sub_by_name failed for 'int_sub'");
    sub_name = yac_param_get_name(sub);
    if (!sub_name || strcmp(sub_name, oneof_int_param_name) != 0)
      PUT_ERR(
        "oneof param get_sub_by_name should return "
        "subparam with name 'int_sub'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("oneof param is_default should be 0 (not default)");
 
    // Set active subparam to default value
    struct yac_param *int_sub = NULL;
    ret =
      yac_param_get_sub_by_name(
        param, oneof_int_param_name, &int_sub);
    if (ret != 0 || !int_sub)
      PUT_ERR("oneof param get_sub_by_name failed for 'int_sub'");
    yac_param_set_scalar_int(
      int_sub, oneof_int_default);
 
    // is_default (should be true now)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("oneof param is_default should be 1 (default)");
 
    // destroy
    yac_param_delete(param);
    free(created_obj);
  }
 
  { // Test which sets param to non-default value in factory
 
    // Factory for oneof default subparam (int_sub)
    void *created_obj = NULL;
 
    char const * param_name = "oneof_param_non_default";
    struct yac_param * subparam = NULL;
    int subparam_is_default = 0;
    struct yac_param *param =
      yac_param_oneof_new(
        param_name, utest_oneof_factory, &created_obj, subparam, subparam_is_default);
 
    // is_default (undefined oneof counts as default)
    int ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("oneof param is_default should be 1 (default)");
 
    // Set active subparam to non-default value
    struct yac_param *bool_sub = NULL;
    ret =
      yac_param_get_sub_by_name(
        param, oneof_bool_param_name, &bool_sub);
    if (ret != 0 || !bool_sub)
      PUT_ERR("oneof param get_sub_by_name failed for 'bool_sub'");
    if (!created_obj)
      PUT_ERR("oneof factory should have allocated an object for the subparam");
    if (*(int *)created_obj != oneof_bool_val)
      PUT_ERR(
        "oneof factory should have set the created object to the initial value");
    char const * bool_sub_name =
      yac_param_get_name(bool_sub);
    if (!bool_sub_name || strcmp(bool_sub_name, oneof_bool_param_name) != 0)
      PUT_ERR(
        "oneof param get_sub_by_name should return subparam with name 'bool_sub'");
 
    // is_default (should be false because bool_sub has non-default value)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("oneof param is_default should be 0 (not default)");
 
    // set active subparam to default value
    yac_param_set_scalar_int(
      bool_sub, oneof_bool_default);
 
    // is_default (should still be false because active subparam is not "
    // the default type)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("oneof param is_default should be 0 (not default)");
 
    // destroy
    yac_param_delete(param);
    free(created_obj);
  }
 
  { // Test with preinitialised parameter (default type)
      int predef_int_val = oneof_int_val;
      void * predef_val = &predef_int_val;
      struct yac_param *predef_subparam =
        yac_param_int_new(
          oneof_int_param_name, &predef_int_val, oneof_int_default,
          oneof_int_min, oneof_int_max, oneof_has_default, oneof_is_defined);
      int subparam_is_default = 1;
      char const * param_name = "oneof_param_predefined";
      struct yac_param *param =
        yac_param_oneof_new(
          param_name, utest_oneof_factory, &predef_val, predef_subparam,
          subparam_is_default);
 
      // get_sub_by_index should return the pre-defined subparam unchanged
      struct yac_param *sub = NULL;
      int ret = yac_param_get_sub_by_index(param, 0, &sub);
      if (ret != 0 || (sub != predef_subparam))
        PUT_ERR("oneof predefined subparam should be returned unchanged");
 
      // is_default should be false because the pre-defined subparam has a
      // non-default value
      ret = yac_param_is_default(param);
      if (ret != 0)
        PUT_ERR("oneof param is_default should be 0 (not default)");
 
      // set integer value to the default value
      predef_int_val = oneof_int_default;
 
      // is_default should now be true because the active subparam has
      // the default value
      ret = yac_param_is_default(param);
      if (ret != 1)
        PUT_ERR("oneof param is_default should be 1 (default)");
 
      // destroy
      yac_param_delete(param);
  }
 
  { // Test with preinitialised parameter (non-default type)
      int predef_bool_val = oneof_bool_val;
      void * predef_val = &predef_bool_val;
      struct yac_param *predef_subparam =
        yac_param_bool_new(
          oneof_bool_param_name, &predef_bool_val, oneof_bool_default,
          oneof_has_default, oneof_is_defined);
      int subparam_is_default = 0;
      char const * param_name = "oneof_param_predefined";
      struct yac_param *param =
        yac_param_oneof_new(
          param_name, utest_oneof_factory, &predef_val, predef_subparam,
          subparam_is_default);
 
      // get_sub_by_index should return the pre-defined subparam unchanged
      struct yac_param *sub = NULL;
      int ret = yac_param_get_sub_by_index(param, 0, &sub);
      if (ret != 0 || (sub != predef_subparam))
        PUT_ERR("oneof predefined subparam should be returned unchanged");
 
      // is_default should be false because the pre-defined subparam has a
      // non-default value
      ret = yac_param_is_default(param);
      if (ret != 0)
        PUT_ERR("oneof param is_default should be 0 (not default)");
 
      // set boolean value to the default value
      predef_bool_val = oneof_bool_default;
 
      // is_default should still be false because the active subparam is
      // not the default type
      ret = yac_param_is_default(param);
      if (ret != 0)
        PUT_ERR("oneof param is_default should be 0 (not default)");
 
      // destroy
      yac_param_delete(param);
  }
 
  {// Test error handling in factory
 
    // failing factory path in get_sub_by_index
    void * created_obj = NULL;
    int subparam_is_default = 0;
    struct yac_param *param =
      yac_param_oneof_new(
        "oneof_param_fail_idx", utest_oneof_failing_factory, &created_obj, NULL,
        subparam_is_default);
    struct yac_param *sub = NULL;
    int ret = yac_param_get_sub_by_index(param, 0, &sub);
    if (ret == 0)
      PUT_ERR("oneof get_sub_by_index should fail if factory fails");
    yac_param_delete(param);
  }
 
  {// Test error handling in factory
 
    // failing factory path in get_sub_by_name
    void * created_obj = NULL;
    int subparam_is_default = 0;
    struct yac_param *param =
      yac_param_oneof_new(
        "oneof_param_fail_name", utest_oneof_failing_factory, &created_obj, NULL,
        subparam_is_default);
    struct yac_param *sub = NULL;
    int ret =
      yac_param_get_sub_by_name(param, "int_sub", &sub);
    if (ret == 0)
      PUT_ERR("oneof get_sub_by_name should fail if factory fails");
    yac_param_delete(param);
  }
}
 
static struct yac_param * utest_get_sub_by_name(
  struct yac_param *param, char const *name) {
  struct yac_param *sub = NULL;
  int ret = yac_param_get_sub_by_name(param, name, &sub);
  if (ret != 0)
    return NULL;
  return sub;
}
 
// Test struct parameter interfaces
static void utest_struct_param_interfaces(void) {
 
  char const * int_param_name = "int_sub";
  int int_val = 5;
  int int_default = 42;
  int int_has_default = 1;
  int int_is_defined = 1;
  int int_min_value = 0;
  int int_max_value = 100;
 
  char const * bool_param_name = "bool_sub";
  int bool_val = 1;
  int bool_default = 0;
  int bool_has_default = 1;
  int bool_is_defined = 1;
 
  char const * str_param_name = "str_sub";
  char *str_val = strdup("foo");
  const char *str_default = "bar";
  int str_allow_null = 0;
  int str_allow_empty = 0;
  int str_has_default = 1;
  int str_is_defined = 1;
  size_t max_str_len = 8;
  int ret;
 
  struct yac_param *subparams[] = {
    yac_param_int_new(
      int_param_name, &int_val, int_default, int_min_value, int_max_value,
      int_has_default, int_is_defined),
    yac_param_bool_new(
      bool_param_name, &bool_val, bool_default,
      bool_has_default, bool_is_defined),
    yac_param_str_new(
      str_param_name, &str_val, str_default, str_allow_null, str_allow_empty,
      max_str_len, str_has_default, str_is_defined)
  };
  enum {NUM_SUBPARAMS = sizeof(subparams) / sizeof(subparams[0])};
 
  char const * param_name = "struct_param";
  struct yac_param *param =
    yac_param_struct_new(
      param_name, subparams, NUM_SUBPARAMS);
 
  // get_type
  enum yac_param_type type =
    yac_param_get_type(param);
  if (type != YAC_PARAM_TYPE_STRUCT)
    PUT_ERR("struct param get_type should return TYPE_STRUCT");
 
  enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INT;
  ret = yac_param_get_scalar_kind(param, &scalar_kind);
  if ((ret == 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_INVALID))
    PUT_ERR("struct param get_scalar_kind should fail");
 
  // get_name
  const char *name = yac_param_get_name(param);
  if (!name || strcmp(name, param_name) != 0)
    PUT_ERR("struct param get_name should return 'struct_param'");
 
  // get_sub_count
  size_t count = 0;
  ret = yac_param_get_sub_count(param, &count);
  if (ret != 0 || count != NUM_SUBPARAMS)
    PUT_ERR("struct param get_sub_count should return 3");
 
  // get_sub_by_name (existing)
  struct yac_param *sub = NULL;
  ret =
    yac_param_get_sub_by_name(param, int_param_name, &sub);
  if (ret != 0 || !sub)
    PUT_ERR("struct param get_sub_by_name failed for 'int_sub'");
  if (sub != subparams[0])
    PUT_ERR("struct param get_sub_by_name did not return "
            "the actual subparam pointer");
 
  // get_sub_by_name (nonexistent)
  char const * nonexistent_param_name = "nope";
  ret =
    yac_param_get_sub_by_name(
      param, nonexistent_param_name, &sub);
  if (ret == 0)
    PUT_ERR(
      "struct param get_sub_by_name should fail for nonexistent subparam");
 
  // get_sub_by_index (in bounds)
  sub = NULL;
  ret = yac_param_get_sub_by_index(param, 1, &sub);
  if (ret != 0 || !sub)
    PUT_ERR("struct param get_sub_by_index failed for index 1");
  if (sub != subparams[1])
    PUT_ERR("struct param get_sub_by_index did not return "
            "the actual subparam pointer");
 
  // get_sub_by_index (out of bounds)
  ret =
  yac_param_get_sub_by_index(param, NUM_SUBPARAMS, &sub);
  if (ret == 0)
    PUT_ERR("struct param get_sub_by_index should fail for out-of-bounds");
 
  // is_default (should be false initially)
  ret = yac_param_is_default(param);
  if (ret != 0)
    PUT_ERR("struct param is_default should be 0 (not default)");
 
  // Set subset of subparams to default
  yac_param_set_scalar_int(
    utest_get_sub_by_name(param, int_param_name), int_default);
  yac_param_set_scalar_int(
    utest_get_sub_by_name(param, bool_param_name), bool_default);
 
  // is_default (should still be false since str_sub is not default)
  ret = yac_param_is_default(param);
  if (ret != 0)
    PUT_ERR("struct param is_default should be 0 (not default)");
 
  // Set remaining subparam to default
  yac_param_set_scalar(
    utest_get_sub_by_name(param, str_param_name), str_default);
 
  // is_default (should be true now)
  ret = yac_param_is_default(param);
  if (ret != 1)
    PUT_ERR("struct param is_default should be 1 (default)");
 
  // destroy
  yac_param_delete(param);
  free(str_val);
}
 
// Test enum parameter interfaces
static void utest_enum_param_interfaces(void) {
 
  enum {RED, GREEN, BLUE, COLOR_TABLE_SIZE};
  static const struct yac_name_type_pair color_table[COLOR_TABLE_SIZE] = {
    {"red", RED}, {"green", GREEN}, {"blue", BLUE}
  };
 
  { // Test enum param with default (has_default = 1)
    char const * param_name = "color_param";
    int value = GREEN;
    int default_value = RED;
    int has_default = 1;
    int is_defined = 1;
    char buf[32];
    int ret;
    struct yac_param *param =
      yac_param_enum_new(
        param_name, &value, default_value, color_table, COLOR_TABLE_SIZE,
        has_default, is_defined);
 
    // get_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_SCALAR)
      PUT_ERR("enum param get_type should return TYPE_SCALAR");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INVALID;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret != 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_INT))
      PUT_ERR("enum param get_scalar_kind should return INT");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("enum param get_name should return 'color_param'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("enum param is_default should be 0 (not default)");
 
    // set_scalar_int to default value
    ret = yac_param_set_scalar_int(
      param, default_value);
    if ((ret != 0) || (value != default_value))
      PUT_ERR("enum param set_scalar_int failed");
 
    // is_default (should be true now)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("enum param is_default should be 1 (default)");
 
    // set_scalar
    ret = yac_param_set_scalar(
      param, "blue");
    if (ret != 0 || value != BLUE)
      PUT_ERR("enum param set_scalar string failed");
 
    // get_scalar
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "blue") != 0)
      PUT_ERR("enum param get_scalar string failed");
 
    // set_scalar_int
    ret = yac_param_set_scalar_int(
      param, GREEN);
    if (ret != 0 || value != GREEN)
      PUT_ERR("enum param set_scalar_int failed (again)");
 
    // get_scalar_int
    int out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret != 0 || out_val != GREEN)
      PUT_ERR("enum param get_scalar_int failed");
 
    // set_scalar to invalid string (should fail)
    ret = yac_param_set_scalar(
      param, "yellow");
    if (ret == 0)
      PUT_ERR("enum param set_scalar should fail for invalid string");
 
    // set_scalar to NULL (should fail)
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret == 0)
      PUT_ERR("enum param set_scalar should fail for NULL value");
 
    // set_scalar_int to invalid value (should fail)
    ret = yac_param_set_scalar_int(
      param, 999);
    if (ret == 0)
      PUT_ERR("enum param set_scalar_int should fail for invalid value");
 
    // get_scalar with too small buffer (should fail)
    int const small_buf_len = 2;
    ret = yac_param_get_scalar(
      param, buf, small_buf_len);
    if (ret == 0)
      PUT_ERR("enum param get_scalar should fail for small buffer");
 
    // destroy
    yac_param_delete(param);
  }
 
  { // Test enum param without default (has_default = 0)
    char const * param_name = "color_param";
    int value = GREEN;
    int default_value = RED;
    int has_default = 0;
    int is_defined = 0;
    char buf[32];
    int ret;
    struct yac_param *param =
      yac_param_enum_new(
        param_name, &value, default_value, color_table,
        COLOR_TABLE_SIZE, has_default, is_defined);
 
    // is_default should always be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("enum param (no default) is_default should be 0");
 
    // get_scalar_int should fail (undefined)
    int out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret == 0)
      PUT_ERR("enum param (no default) get_scalar_int should fail if undefined");
 
    // get_scalar should fail (undefined)
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("enum param (no default) get_scalar should fail if undefined");
 
    // set_scalar_int should define value
    ret = yac_param_set_scalar_int(
      param, GREEN);
    if (ret != 0 || value != GREEN)
      PUT_ERR("enum param (no default) set_scalar_int failed");
 
    // Now get_scalar_int should succeed
    out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret != 0 || out_val != GREEN)
      PUT_ERR("enum param (no default) get_scalar_int should succeed after set");
 
    // get_scalar should succeed
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "green") != 0)
      PUT_ERR("enum param (no default) get_scalar should succeed after set");
 
    // Set default value
    ret = yac_param_set_scalar_int(
      param, default_value);
    if (ret != 0 || value != default_value)
      PUT_ERR("enum param (no default) set_scalar_int failed");
 
    // is_default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("enum param (no default) is_default should still be 0");
 
    yac_param_delete(param);
  }
}
 
// Test string parameter interfaces
static void utest_str_param_interfaces(void) {
 
  { // Test str param with default (has_default = 1)
    char const * param_name = "str_param";
    char *value = strdup("init");
    const char *default_value = "default";
    int allow_null = 0;
    int allow_empty = 1;
    size_t max_str_len = 16;
    int has_default = 1;
    int is_defined = 1;
    char buf[32];
    int ret;
    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_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_SCALAR)
      PUT_ERR("str param get_type should return TYPE_SCALAR");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INVALID;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret != 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_STR))
      PUT_ERR("str param get_scalar_kind should return STR");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("str param get_name should return 'str_param'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("str param is_default should be 0 (not default)");
 
    // set_scalar to default value
    ret = yac_param_set_scalar(
      param, default_value);
    if (ret != 0)
      PUT_ERR("str param set_scalar to default failed");
    if (strcmp(value, default_value) != 0)
      PUT_ERR("str param value not set to default");
 
    // is_default (should be true now)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("str param is_default should be 1 (default)");
 
    // set_scalar (string)
    ret = yac_param_set_scalar(
      param, "foo");
    if (ret != 0 || strcmp(value, "foo") != 0)
      PUT_ERR("str param set_scalar string failed");
 
    // get_scalar (string)
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "foo") != 0)
      PUT_ERR("str param get_scalar string failed");
 
    // set_scalar to empty string (allowed)
    ret = yac_param_set_scalar(
      param, "");
    if (ret != 0 || strcmp(value, "") != 0)
      PUT_ERR("str param set_scalar empty string failed");
 
    // get_scalar (empty string)
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "") != 0)
      PUT_ERR("str param get_scalar empty string failed");
 
    // set_scalar to too long string (should fail)
    char longstr[32];
    memset(longstr, 'x', max_str_len+1); longstr[max_str_len+1] = '\0';
    ret = yac_param_set_scalar(
      param, longstr);
    if (ret == 0)
      PUT_ERR("str param set_scalar should fail for too long string");
 
    // set_scalar to NULL (should fail, allow_NULL=0)
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret == 0)
      PUT_ERR("str param set_scalar should fail for NULL value");
 
    // set_scalar to non empty string
    ret = yac_param_set_scalar(
      param, "foo");
    if (ret != 0 || strcmp(value, "foo") != 0)
      PUT_ERR("str param set_scalar non empty string failed");
 
    // get_scalar with too small buffer (should fail)
    ret = yac_param_get_scalar(
      param, buf, 1);
    if (ret == 0)
      PUT_ERR("str param get_scalar should fail for too small buffer");
 
    yac_param_delete(param);
    free(value);
  }
 
  { // Test str param with no default (has_default = 0)
    char const * param_name = "str_param";
    char *value = NULL;
    const char *default_value = "default";
    int allow_null = 1;
    int allow_empty = 1;
    int has_default = 0;
    int is_defined = 0;
    size_t max_str_len = 16;
    char buf[32];
    int ret;
    struct yac_param *param =
      yac_param_str_new(
        param_name, &value, default_value, allow_null, allow_empty,
        max_str_len, has_default, is_defined);
 
    // is_default should always be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("str param (no default) is_default should be 0");
 
    // get_scalar should fail (undefined)
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("str param (no default) get_scalar should fail if undefined");
 
    // set_scalar should define value
    ret = yac_param_set_scalar(
      param, "abc");
    if (ret != 0 || !value || strcmp(value, "abc") != 0)
      PUT_ERR("str param (no default) set_scalar failed");
 
    // Now get_scalar should succeed
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "abc") != 0)
      PUT_ERR("str param (no default) get_scalar should succeed after set");
 
    // Set to default
    ret = yac_param_set_scalar(
      param, default_value);
    if (ret != 0 || !value || strcmp(value, default_value) != 0)
      PUT_ERR("str param (no default) set_scalar failed");
 
    // is_default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("str param (no default) is_default should still be 0");
 
    // allow_NULL branch in set_scalar
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret != 0 || value != NULL)
      PUT_ERR("str param (allow_NULL) set_scalar(NULL) should succeed");
 
    // allow_NULL branch in is_default
    ret = yac_param_is_default(param);
    if (ret != 0)
 
    // get_scalar should return empty string for NULL value if allow_NULL=1
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "") != 0)
      PUT_ERR(
        "str param (allow_NULL) get_scalar should return empty string for NULL");
 
    yac_param_delete(param);
    free(value);
  }
 
  { // empty-string disallowed in get/set paths
    char const * param_name = "str_no_empty";
    char *value = strdup("non-empty");
    char const *default_value = "x";
    int allow_null = 1;
    int allow_empty = 0;
    size_t max_str_len = 16;
    int has_default = 1;
    int is_defined = 1;
    int ret;
    struct yac_param *param =
      yac_param_str_new(
        param_name, &value, default_value, allow_null, allow_empty,
        max_str_len, has_default, is_defined);
 
    // set_scalar to empty string should fail
    ret = yac_param_set_scalar(
      param, "");
    if (ret == 0)
      PUT_ERR("str param set_scalar should fail for empty value if disallowed");
 
    // force value to empty string and test get_scalar
    free(value);
    value = strdup("");
 
    // get_scalar should fail if value is empty string and allow_empty=0
    char buf[32];
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("str param get_scalar should fail for empty value if disallowed");
 
    yac_param_delete(param);
    free(value);
  }
 
  { // NULL value disallowed in get path
    char const * param_name = "str_no_null";
    char *value = strdup("non-NULL");;
    int ret;
    int allow_null = 0;
    int allow_empty = 1;
    char const *default_value = "x";
    size_t max_str_len = 16;
    int has_default = 1;
    int is_defined = 1;
    struct yac_param *param =
      yac_param_str_new(
        param_name, &value, default_value, allow_null, allow_empty,
        max_str_len, has_default, is_defined);
 
    // set_scalar to NULL should fail
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret == 0)
      PUT_ERR("str param set_scalar should fail for NULL value if disallowed");
 
    // force value to NULL and test get_scalar
    free(value);
    value = NULL;
 
    // get_scalar should fail if value is NULL and allow_NULL=0
    char buf[32];
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("str param get_scalar should fail for NULL value if disallowed");
 
    yac_param_delete(param);
    free(value);
  }
 
  { // Test with NULL default value and allow_NULL=1
    char const * param_name = "str_null_default";
    char *value = NULL;
    char const *default_value = NULL;
    int allow_null = 1;
    int allow_empty = 1;
    size_t max_str_len = 16;
    int has_default = 1;
    int is_defined = 1;
    int ret;
    struct yac_param *param =
      yac_param_str_new(
        param_name, &value, default_value, allow_null, allow_empty,
        max_str_len, has_default, is_defined);
 
    // is_default should be true initially since value equals default (both NULL)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("str param with NULL default should be default initially");
 
    // set_scalar to non-empty string
    ret = yac_param_set_scalar(
      param, "hello");
    if (ret != 0 || strcmp(value, "hello") != 0)
      PUT_ERR("str param set_scalar failed for non-empty string");
 
    // is_default should now be false
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("str param with NULL default should not be default after set");
 
    // set_scalar to NULL
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret != 0 || value != NULL)
      PUT_ERR("str param set_scalar failed for NULL value");
 
    // is_default should be true again
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("str param with NULL default should be default after setting back to NULL");
 
    yac_param_delete(param);
  }
 
  { // Test with empty default value and allow_empty=1
    char const * param_name = "str_empty_default";
    char *value = strdup("");
    char const *default_value = "";
    int allow_null = 1;
    int allow_empty = 1;
    size_t max_str_len = 16;
    int has_default = 1;
    int is_defined = 1;
    int ret;
    struct yac_param *param =
      yac_param_str_new(
        param_name, &value, default_value, allow_null, allow_empty,
        max_str_len, has_default, is_defined);
 
    // is_default should be true initially since value equals default
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("str param with empty default should be default initially");
 
    // set_scalar to non-empty string
    ret = yac_param_set_scalar(
      param, "hello");
    if (ret != 0 || strcmp(value, "hello") != 0)
      PUT_ERR("str param set_scalar failed for non-empty string");
 
    // is_default should now be false
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("str param with empty default should not be default after set");
 
    // set_scalar to empty string
    ret = yac_param_set_scalar(
      param, "");
    if (ret != 0 || strcmp(value, "") != 0)
      PUT_ERR("str param set_scalar failed for empty string");
 
    // is_default should be true again
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR(
        "str param with empty default should be default after "
        "setting back to empty");
 
    yac_param_delete(param);
    free(value);
  }
}
 
// Test double parameter interfaces
static void utest_dble_param_interfaces(void) {
 
  { // Test dble param with default (has_default = 1)
    char const * param_name = "dble_param";
    double value = 1.5;
    double default_value = 3.14;
    double min_value = -10.0;
    double max_value = 10.0;
    int allow_nan = 0;
    int allow_inf = 0;
    int has_default = 1;
    int is_defined = 1;
    char buf[64];
    int ret;
    double out_val = -999.0;
    struct yac_param *param =
      yac_param_dble_new(
        param_name, &value, default_value, min_value, max_value,
        allow_nan, allow_inf, has_default, is_defined);
 
    // get_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_SCALAR)
      PUT_ERR("dble param get_type should return TYPE_SCALAR");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INVALID;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret != 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_DBLE))
      PUT_ERR("dble param get_scalar_kind should return DBLE");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("dble param get_name should return 'dble_param'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("dble param is_default should be 0 (not default)");
 
    // set_scalar_dble to default value
    ret = yac_param_set_scalar_dble(
      param, default_value);
    if (ret != 0)
      PUT_ERR("dble param set_scalar_dble failed");
    if (value != default_value)
      PUT_ERR("dble param value not set to default");
 
    // is_default (should be true now)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("dble param is_default should be 1 (default)");
 
    // set_scalar (string)
    ret = yac_param_set_scalar(
      param, "2.5");
    if (ret != 0 || value != 2.5)
      PUT_ERR("dble param set_scalar string failed");
 
    // set_scalar with NULL/invalid string (should fail)
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret == 0)
      PUT_ERR("dble param set_scalar should fail for NULL string");
    ret = yac_param_set_scalar(
      param, "2.0x");
    if (ret == 0)
      PUT_ERR("dble param set_scalar should fail for invalid string");
 
    // get_scalar (string)
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || atof(buf) != 2.5)
      PUT_ERR("dble param get_scalar string failed");
 
    // get_scalar with too small buffer (should fail)
    int const small_buf_size = 2; // needs to hold at least "2.5\0"
    ret = yac_param_get_scalar(
      param, buf, small_buf_size);
    if (ret == 0)
      PUT_ERR("dble param get_scalar should fail for too small buffer");
 
    // set_scalar_dble (again)
    ret = yac_param_set_scalar_dble(
      param, -5.5);
    if (ret != 0 || value != -5.5)
      PUT_ERR("dble param set_scalar_dble failed (again)");
 
    // get_scalar_dble
    out_val = -999.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret != 0 || out_val != -5.5)
      PUT_ERR("dble param get_scalar_dble failed");
 
    // set_scalar_int (should succeed for integer-valued double)
    ret = yac_param_set_scalar_int(
      param, 5);
    if (ret != 0 || value != 5.0)
      PUT_ERR("dble param set_scalar_int should succeed for integer value");
 
    // get_scalar_int (should succeed when value is integer)
    int ival = 0;
    ret = yac_param_get_scalar_int(
      param, &ival);
    if (ret != 0 || ival != 5)
      PUT_ERR("dble param get_scalar_int should succeed for integer value");
 
    // get_scalar_int should fail for non-integer value
    ret = yac_param_set_scalar_dble(param, 2.5);
    if (ret != 0) PUT_ERR("dble param set_scalar_dble failed");
    ret = yac_param_get_scalar_int(param, &ival);
    if (ret == 0)
      PUT_ERR("dble param get_scalar_int should fail for non-integer value");
 
    // test out-of-range
    ret = yac_param_set_scalar_dble(
      param, min_value - 1.0);
    if (ret == 0)
      PUT_ERR("dble param set_scalar_dble should fail for out-of-range");
    ret = yac_param_set_scalar_dble(
      param, max_value + 1.0);
    if (ret == 0)
      PUT_ERR("dble param set_scalar_dble should fail for out-of-range");
 
    // test NaN (should fail)
    ret = yac_param_set_scalar_dble(
      param, NAN);
    if (ret == 0)
      PUT_ERR("dble param set_scalar_dble should fail for NaN");
 
    // test Inf (should fail)
    ret = yac_param_set_scalar_dble(
      param, INFINITY);
    if (ret == 0)
      PUT_ERR("dble param set_scalar_dble should fail for Inf");
 
    // destroy
    yac_param_delete(param);
  }
 
  { // Additional test: dble param with no default (has_default = 0)
    double value = 0.0;
    double default_value = 3.14;
    double min_value = -10.0, max_value = 10.0;
    int allow_nan = 0;
    int allow_inf = 0;
    int has_default = 0;
    int is_defined = 0;
    int ret;
    char buf[64];
    double out_val = -999.0;
    struct yac_param *param =
      yac_param_dble_new(
        "dble_param_nodef", &value, default_value,
        min_value, max_value, allow_nan, allow_inf, has_default, is_defined);
 
    // is_default should always be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("dble param (no default) is_default should be 0");
 
    // get_scalar/get_scalar_dble should fail before set
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("dble param (no default) get_scalar should fail if not set");
    out_val = -999.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret == 0)
      PUT_ERR("dble param (no default) get_scalar_dble should fail if not set");
 
    // set_scalar_dble, then get_scalar/get_scalar_dble should succeed
    ret = yac_param_set_scalar_dble(
      param, 5.5);
    if (ret != 0 || value != 5.5)
      PUT_ERR("dble param (no default) set_scalar_dble failed");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || atof(buf) != 5.5)
      PUT_ERR("dble param (no default) get_scalar after set failed");
    out_val = -999.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret != 0 || out_val != 5.5)
      PUT_ERR("dble param (no default) get_scalar_dble after set failed");
 
    // Set to default
    ret = yac_param_set_scalar_dble(
      param, default_value);
    if (ret != 0 || value != default_value)
      PUT_ERR("dble param (no default) set_scalar_dble failed");
 
    // is_default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("dble param (no default) is_default should be 0");
 
    yac_param_delete(param);
  }
 
  { // Additional test: dble param with allowed nan and inf values
    double value = 0.0;
    double default_value = INFINITY;
    double min_value = -1.0;
    double max_value = 1.0;
    int allow_nan = 1;
    int allow_inf = 1;
    int has_default = 1;
    int is_defined = 1;
    int ret;
    char buf[64];
    double out_val = 0.0;
    struct yac_param *param =
      yac_param_dble_new(
        "dble_param_nan_inf", &value, default_value,
        min_value, max_value, allow_nan, allow_inf, has_default, is_defined);
 
    // set/get NaN should succeed when allow_nan=1
    ret = yac_param_set_scalar_dble(
      param, NAN);
    if (ret != 0 || !isnan(value))
      PUT_ERR("dble param set_scalar_dble should accept NaN if allowed");
    out_val = 0.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret != 0 || !isnan(out_val))
      PUT_ERR("dble param get_scalar_dble should return NaN if set");
 
    // set/get +Inf should succeed when allow_inf=1
    ret = yac_param_set_scalar_dble(
      param, INFINITY);
    if (ret != 0 || !isinf(value) || (value < 0.0))
      PUT_ERR("dble param set_scalar_dble should accept +Inf if allowed");
    out_val = 0.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret != 0 || !isinf(out_val) || (out_val < 0.0))
      PUT_ERR("dble param get_scalar_dble should return +Inf if set");
 
    // string-based set/get for non-finite values
    ret = yac_param_set_scalar(
      param, "nan");
    if (ret != 0 || !isnan(value))
      PUT_ERR("dble param set_scalar should accept 'nan' if allowed");
    ret = yac_param_set_scalar(
      param, "inf");
    if (ret != 0 || !isinf(value) || (value < 0.0))
      PUT_ERR("dble param set_scalar should accept 'inf' if allowed");
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || !isinf(atof(buf)) || (atof(buf) < 0.0))
      PUT_ERR("dble param get_scalar should serialize +Inf");
 
    // finite values still obey range constraints
    ret = yac_param_set_scalar_dble(
      param, 2.0);
    if (ret == 0)
      PUT_ERR("dble param finite out-of-range should still fail");
 
    // test out-of-range
    ret = yac_param_set_scalar_dble(
      param, min_value - 1.0);
    if (ret == 0)
      PUT_ERR("dble param set_scalar_dble should fail for out-of-range");
    ret = yac_param_set_scalar_dble(
      param, max_value + 1.0);
    if (ret == 0)
      PUT_ERR("dble param set_scalar_dble should fail for out-of-range");
 
    // default is +Inf, so setting +Inf should report default state
    ret = yac_param_set_scalar_dble(
      param, default_value);
    if (ret != 0)
      PUT_ERR("dble param set to default +Inf failed");
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("dble param is_default should be 1 for +Inf default value");
 
    yac_param_delete(param);
  }
}
 
// Test yac_param_get_last_error
static void utest_get_last_error(void) {
 
  // Cause a known error: set_scalar_int(NULL, ...)
  int ret = yac_param_set_scalar_int(
    NULL, 123);
  if (ret == 0)
    PUT_ERR("set_scalar_int(NULL) should fail");
  const char *err = yac_param_get_last_error();
  if (!err) PUT_ERR("get_last_error did not report expected error message");
}
 
// Test bool parameter interfaces
static void utest_bool_param_interfaces(void) {
 
  { // Test bool param with default (has_default = 1)
    char const * param_name = "bool_param";
    int value = 0;
    int default_value = 1;
    int has_default = 1;
    int is_defined = 1;
    char buf[32];
    int ret;
    int out_val = -1;
    struct yac_param *param =
      yac_param_bool_new(
        param_name, &value, default_value, has_default, is_defined);
 
    // get_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_SCALAR)
      PUT_ERR("bool param get_type should return TYPE_SCALAR");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INVALID;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret != 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_INT))
      PUT_ERR("bool param get_scalar_kind should return INT");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("bool param get_name should return 'bool_param'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("bool param is_default should be 0 (not default)");
 
    // set_scalar_int to default value (1)
    ret = yac_param_set_scalar_int(
      param, default_value);
    if (ret != 0)
      PUT_ERR("bool param set_scalar_int failed");
    if (value != default_value)
      PUT_ERR("bool param value not set to default");
 
    // is_default (should be true now)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("bool param is_default should be 1 (default)");
 
    // set_scalar (string)
    ret = yac_param_set_scalar(
      param, "0");
    if (ret != 0 || value != 0)
      PUT_ERR("bool param set_scalar string failed");
 
    // invalid/NULL parser input
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret == 0)
      PUT_ERR("bool param set_scalar should fail for NULL value");
    ret = yac_param_set_scalar(
      param, "maybe");
    if (ret == 0)
      PUT_ERR("bool param set_scalar should fail for invalid value");
 
    // get_scalar (string)
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "false") != 0)
      PUT_ERR("bool param get_scalar string failed");
 
    // get_scalar with too small buffer (should fail)
    int const small_buf_size = 2; // "true"/"false" + null terminator is 5 chars
    ret = yac_param_get_scalar(
      param, buf, small_buf_size);
    if (ret == 0)
      PUT_ERR("bool param get_scalar should fail for too small buffer");
 
    // set_scalar_int (again)
    ret = yac_param_set_scalar_int(
      param, 1);
    if (ret != 0 || value != 1)
      PUT_ERR("bool param set_scalar_int failed (again)");
 
    // get_scalar_int
    out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret != 0 || out_val != 1)
      PUT_ERR("bool param get_scalar_int failed");
 
    // set_scalar_dble (should fail)
    ret = yac_param_set_scalar_dble(
      param, 0.0);
    if (ret == 0)
      PUT_ERR("bool param set_scalar_dble should fail");
 
    // get_scalar_dble (should fail)
    double dval = 0.0;
    ret = yac_param_get_scalar_dble(
      param, &dval);
    if (ret == 0)
      PUT_ERR("bool param get_scalar_dble should fail");
 
    // destroy
    yac_param_delete(param);
  }
 
  { // Test bool param with no default (has_default = 0)
    int value = 0;
    int default_value = 1;
    int has_default = 0;
    int is_defined = 0;
    char buf[32];
    int ret;
    int out_val = -1;
    struct yac_param *param =
      yac_param_bool_new(
        "bool_param_nodef", &value, default_value, has_default, is_defined);
 
    // is_default should always be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("bool param (no default) is_default should be 0");
 
    // get_scalar/get_scalar_int should fail before set
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("bool param (no default) get_scalar should fail if not set");
    out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret == 0)
      PUT_ERR("bool param (no default) get_scalar_int should fail if not set");
 
    // Set to default value
    ret = yac_param_set_scalar_int(
      param, default_value);
    if (ret != 0 || value != default_value)
      PUT_ERR("bool param (no default) set_scalar_int to default failed");
 
    // get_scalar/get_scalar_int should succeed after set
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "true") != 0)
      PUT_ERR("bool param (no default) get_scalar after set failed");
    out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret != 0 || out_val != 1)
      PUT_ERR("bool param (no default) get_scalar_int after set failed");
 
    // is_default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("bool param (no default) is_default should still be 0");
 
    yac_param_delete(param);
  }
}
 
// Test int parameter interfaces
static void utest_int_param_interfaces(void) {
 
  { // Test int param with with default (has_default = 1)
    char const * param_name = "int_param";
    int value = 7;
    int default_value = 42;
    int min_value = 0;
    int max_value = 100;
    char buf[32];
    int ret;
    int out_val = -1;
    int has_default = 1;
    int is_defined = 1;
    struct yac_param *param =
      yac_param_int_new(
        param_name, &value, default_value, min_value, max_value,
        has_default, is_defined);
 
    // get_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_SCALAR)
      PUT_ERR("int param get_type should return TYPE_SCALAR");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INVALID;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret != 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_INT))
      PUT_ERR("int param get_scalar_kind should return INT");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("int param get_name should return 'int_param'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("int param is_default should be 0 (not default)");
 
    // set_scalar_int to default value
    ret = yac_param_set_scalar_int(
      param, default_value);
    if (ret != 0)
      PUT_ERR("int param set_scalar_int failed");
    if (value != default_value)
      PUT_ERR("int param value not set to default");
 
    // is_default (should be true now)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("int param is_default should be 1 (default)");
 
    // set_scalar (string)
    ret = yac_param_set_scalar(
      param, "13");
    if (ret != 0 || value != 13)
      PUT_ERR("int param set_scalar string failed");
 
    // is_default (should be false again)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("int param is_default should be 0 (not default)");
 
    // set_scalar with NULL string (should fail)
    ret = yac_param_set_scalar(
      param, NULL);
    if (ret == 0)
      PUT_ERR("int param set_scalar should fail for NULL value");
 
    // set_scalar with invalid string (should fail)
    ret = yac_param_set_scalar(
      param, "13x");
    if (ret == 0)
      PUT_ERR("int param set_scalar should fail for invalid string");
 
    // get_scalar (string)
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "13") != 0)
      PUT_ERR("int param get_scalar string failed");
 
    // get_scalar with too small buffer (should fail)
    size_t const small_buf_size = 2; // "13" + null terminator = 3 bytes needed
    ret = yac_param_get_scalar(
      param, buf, small_buf_size);
    if (ret == 0)
      PUT_ERR("int param get_scalar should fail for too small buffer");
 
    // set_scalar_int (again)
    ret = yac_param_set_scalar_int(
      param, 77);
    if (ret != 0 || value != 77)
      PUT_ERR("int param set_scalar_int failed (again)");
 
    // out-of-range integer
    ret = yac_param_set_scalar_int(
      param, min_value - 1);
    if (ret == 0 || value != 77)
      PUT_ERR("int param set_scalar_int should fail for out-of-range value");
    ret = yac_param_set_scalar_int(
      param, max_value + 1);
    if (ret == 0 || value != 77)
      PUT_ERR("int param set_scalar_int should fail for out-of-range value");
 
    // get_scalar_int
    out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret != 0 || out_val != 77)
      PUT_ERR("int param get_scalar_int failed");
 
    // set_scalar_dble (should succeed for integer-valued double)
    ret = yac_param_set_scalar_dble(
      param, 50.0);
    if (ret != 0 || value != 50)
      PUT_ERR("int param set_scalar_dble should succeed for integer value");
 
    // set_scalar_dble should fail for non-integer value
    ret = yac_param_set_scalar_dble(
      param, 3.14);
    if (ret == 0)
      PUT_ERR("int param set_scalar_dble should fail for non-integer value");
    if (value != 50)
      PUT_ERR("int param value should not change after failed set_scalar_dble");
 
    // get_scalar_dble (should succeed)
    double dval = 0.0;
    ret = yac_param_get_scalar_dble(
      param, &dval);
    if (ret != 0 || dval != 50.0)
      PUT_ERR("int param get_scalar_dble should succeed");
 
    // destroy
    yac_param_delete(param);
  }
 
  { // Test int param with no default (has_default = 0)
    int value = 0;
    int default_value = 42;
    int min_value = 0, max_value = 100;
    int has_default = 0;
    int is_defined = 0;
    int ret;
    char buf[32];
    struct yac_param *param =
      yac_param_int_new(
        "int_param_nodef", &value, default_value, min_value, max_value,
        has_default, is_defined);
 
    // is_default should always be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("int param (no default) is_default should be 0");
 
    // get_scalar/get_scalar_int should fail before set
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("int param (no default) get_scalar should fail if not set");
    int out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret == 0)
      PUT_ERR("int param (no default) get_scalar_int should fail if not set");
 
    // set_scalar_int, then get_scalar/get_scalar_int should succeed
    ret = yac_param_set_scalar_int(
      param, default_value);
 
    // is_default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("int param (no default) is_default should be 0");
 
    // get_scalar/get_scalar_int should be successful
    if (ret != 0)
      PUT_ERR("int param (no default) set_scalar_int failed");
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || strcmp(buf, "42") != 0)
      PUT_ERR("int param (no default) get_scalar after set failed");
    out_val = -1;
    ret = yac_param_get_scalar_int(
      param, &out_val);
    if (ret != 0 || out_val != 42)
      PUT_ERR("int param (no default) get_scalar_int after set failed");
    yac_param_delete(param);
  }
}
 
// Test all basic interfaces with NULL param
static void utest_null_param_interfaces(void) {
 
  struct yac_param *null_param = NULL;
  size_t count = 1234;
  int i_val = 42;
  double d_val = 3.14;
  char buf[32] = "garbage";
  const char *name;
  int ret;
 
  // get_type
  enum yac_param_type type =
    yac_param_get_type(null_param);
  if (type != YAC_PARAM_TYPE_EMPTY)
    PUT_ERR("get_type(NULL) should return TYPE_EMPTY");
 
  enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INT;
  ret = yac_param_get_scalar_kind(null_param, &scalar_kind);
  if ((ret != 1) || (scalar_kind != YAC_PARAM_SCALAR_KIND_INVALID))
    PUT_ERR("get_scalar_kind(NULL) should return error and INVALID");
 
  // is_default
  ret = yac_param_is_default(null_param);
  if (!ret) PUT_ERR("is_default(NULL) should return 1");
 
  // get_name
  name = yac_param_get_name(null_param);
  if (name != NULL) PUT_ERR("get_name(NULL) should return NULL");
 
  // get_sub_count
  count = 1234;
  ret = yac_param_get_sub_count(null_param, &count);
  if (ret != 0 || count != 0)
    PUT_ERR("get_sub_count(NULL) should return 0, count=0");
 
  // get_sub_by_name
  struct yac_param *sub_param = (void*)0x1;
  ret = yac_param_get_sub_by_name(
    null_param, "foo", &sub_param);
  if (ret != 1)
    PUT_ERR("get_sub_by_name(NULL) should return 1");
 
  // get_sub_by_index
  sub_param = (void*)0x1;
  ret = yac_param_get_sub_by_index(
    null_param, 0, &sub_param);
  if (ret != 1)
    PUT_ERR("get_sub_by_index(NULL) should return 1");
 
  // append
  sub_param = NULL;
  ret = yac_param_append(null_param, &sub_param);
  if (ret != 1)
    PUT_ERR("append(NULL) should return 1");
 
  // set_scalar
  ret =
    yac_param_set_scalar(
      null_param, "42");
  if (ret != 1)
    PUT_ERR("set_scalar(NULL) should return 1");
 
  // get_scalar
  strcpy(buf, "garbage");
  ret = yac_param_get_scalar(
    null_param, buf, sizeof(buf));
  if (ret != 1 || buf[0] != '\0')
    PUT_ERR("get_scalar(NULL) should return 1, buf=\0");
 
  // set_scalar_int
  ret = yac_param_set_scalar_int(
    null_param, 42);
  if (ret != 1)
    PUT_ERR("set_scalar_int(NULL) should return 1");
 
  // set_scalar_dble
  ret = yac_param_set_scalar_dble(
    null_param, 3.14);
  if (ret != 1)
    PUT_ERR("set_scalar_dble(NULL) should return 1");
 
  // get_scalar_int
  i_val = 42;
  ret = yac_param_get_scalar_int(
    null_param, &i_val);
  if (ret != 1)
    PUT_ERR("get_scalar_int(NULL) should return 1");
 
  // get_scalar_dble
  d_val = 3.14;
  ret = yac_param_get_scalar_dble(
    null_param, &d_val);
  if (ret != 1)
    PUT_ERR("get_scalar_dble(NULL) should return 1");
 
  // destroy (should not crash)
  yac_param_delete(null_param);
}
 
static void utest_distance_param_interfaces(void) {
 
  { // Test distance param with default (has_default = 1)
    char const * param_name = "distance_param";
    double value = M_PI_4; // radians
    double default_value = M_PI_2; // radians
    double min_value = 0.0;
    double max_value = M_PI;
    int has_default = 1;
    int is_defined = 1;
    char buf[64];
    int ret;
    double out_val = -999.0;
    struct yac_param *param =
      yac_param_distance_new(
        param_name, &value, default_value, min_value, max_value,
        has_default, is_defined);
 
    // get_type
    enum yac_param_type type = yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_SCALAR)
      PUT_ERR("distance param get_type should return TYPE_SCALAR");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INVALID;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret != 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_DBLE))
      PUT_ERR("distance param get_scalar_kind should return DBLE");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("distance param get_name should return 'distance_param'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("distance param is_default should be 0 (not default)");
 
    // set_scalar_dble to default value (radians)
    ret = yac_param_set_scalar_dble(param, default_value);
    if (ret != 0)
      PUT_ERR("distance param set_scalar_dble failed");
    if (value != default_value)
      PUT_ERR("distance param value not set to default");
 
    // is_default (should be true now)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("distance param is_default should be 1 (default)");
 
    // set_scalar defaults to degrees
    ret = yac_param_set_scalar(param, "90.0");
    if (ret != 0 || (value != M_PI_2))
      PUT_ERR("distance param set_scalar string default-degree failed");
 
    // set_scalar with explicit rad suffix
    ret = yac_param_set_scalar(param, "0.5 rad");
    if (ret != 0 || (value != 0.5))
      PUT_ERR("distance param set_scalar explicit rad suffix failed");
 
    // set_scalar with case-insensitive short suffix
    ret = yac_param_set_scalar(param, "45 D");
    if (ret != 0 || (value != M_PI_4))
      PUT_ERR("distance param set_scalar short degree suffix failed");
 
    // numeric setter/getter use radians
    ret = yac_param_set_scalar_dble(param, M_PI_2);
    if (ret != 0 || (value != M_PI_2))
      PUT_ERR("distance param set_scalar_dble (radians) failed");
 
    out_val = -999.0;
    ret = yac_param_get_scalar_dble(param, &out_val);
    if (ret != 0 || (out_val != M_PI_2))
      PUT_ERR("distance param get_scalar_dble (radians) failed");
 
    // string getter always returns degrees
    strcpy(buf, "garbage");
    ret = yac_param_get_scalar(param, buf, sizeof(buf));
    if (ret != 0 || fabs(atof(buf) - 90.0) > tol)
      PUT_ERR("distance param get_scalar should return degrees");
 
    // invalid/NULL parser input
    ret = yac_param_set_scalar(param, NULL);
    if (ret == 0)
      PUT_ERR("distance param set_scalar should fail for NULL string");
    ret = yac_param_set_scalar(param, "90x");
    if (ret == 0)
      PUT_ERR("distance param set_scalar should fail for invalid string");
    ret = yac_param_set_scalar(param, "90  deg");
    if (ret == 0)
      PUT_ERR("distance param set_scalar should reject double space before unit");
    ret = yac_param_set_scalar(param, "90 deg ");
    if (ret == 0)
      PUT_ERR("distance param set_scalar should reject trailing whitespace");
 
    // get_scalar with too small buffer (should fail)
    int const small_buf_size = 2;
    ret = yac_param_get_scalar(
      param, buf, small_buf_size);
    if (ret == 0)
      PUT_ERR("distance param get_scalar should fail for too small buffer");
 
    // set_scalar_int (should succeed for integer degree values)
    ret = yac_param_set_scalar_int(
      param, 1);
    if (ret != 0 || (value !=  1.0))
      PUT_ERR("distance param set_scalar_int should succeed for 1 deg");
 
    // get_scalar_int (should succeed when value is integer degrees)
    int ival = 0;
    ret = yac_param_get_scalar_int(
      param, &ival);
    if (ret != 0 || ival != 1)
      PUT_ERR("distance param get_scalar_int should succeed for 1 deg");
 
    // get_scalar_int should fail for non-integer degree value
    ret = yac_param_set_scalar_dble(param, 0.5);
    if (ret != 0) PUT_ERR("distance param set_scalar_dble failed");
    ret = yac_param_get_scalar_int(param, &ival);
    if (ret == 0)
      PUT_ERR("distance param get_scalar_int should fail for non-integer deg");
 
    // test out-of-range (should fail)
    ret = yac_param_set_scalar_dble(
      param, min_value - 0.01);
    if (ret == 0)
      PUT_ERR("distance param set_scalar_dble should fail for out-of-range");
    ret = yac_param_set_scalar_dble(
      param, max_value + 0.01);
    if (ret == 0)
      PUT_ERR("distance param set_scalar_dble should fail for out-of-range");
 
    // test NaN (should fail)
    ret = yac_param_set_scalar_dble(
      param, NAN);
    if (ret == 0)
      PUT_ERR("distance param set_scalar_dble should fail for NaN");
 
    // test Inf (should fail)
    ret = yac_param_set_scalar_dble(
      param, INFINITY);
    if (ret == 0)
      PUT_ERR("distance param set_scalar_dble should fail for Inf");
 
    // destroy
    yac_param_delete(param);
  }
 
  { // Test distance param with no default (has_default = 0)
    char const * param_name = "distance_param_nodef";
    double value = 0.0;
    double default_value = 1.0;
    double min_value = 0.0, max_value = M_PI;
    int has_default = 0;
    int is_defined = 0;
    int ret;
    char buf[64];
    double out_val = -999.0;
    struct yac_param *param =
      yac_param_distance_new(
        param_name, &value, default_value, min_value, max_value,
        has_default, is_defined);
 
    // is_default should always be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("distance param (no default) is_default should be 0");
 
    // get_scalar/get_scalar_dble should fail before set
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("distance param (no default) get_scalar should fail if not set");
    out_val = -999.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret == 0)
      PUT_ERR(
        "distance param (no default) get_scalar_dble should fail if not set");
 
    // set_scalar_dble, then get_scalar/get_scalar_dble should succeed
    ret = yac_param_set_scalar_dble(
      param, 0.7);
    if (ret != 0 || value != 0.7)
      PUT_ERR("distance param (no default) set_scalar_dble failed");
    ret = yac_param_get_scalar(param, buf, sizeof(buf));
    if (ret != 0 || fabs(atof(buf) - yac_rad_to_deg(0.7, param_name)) > tol)
      PUT_ERR("distance param (no default) get_scalar after set failed");
    out_val = -999.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret != 0 || out_val != 0.7)
      PUT_ERR("distance param (no default) get_scalar_dble after set failed");
 
    // Set to default
    ret = yac_param_set_scalar_dble(
      param, default_value);
    if (ret != 0 || value != default_value)
      PUT_ERR("distance param (no default) set_scalar_dble failed");
 
    // is_default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("distance param (no default) is_default should be 0");
 
    yac_param_delete(param);
  }
}
 
static void utest_angle_param_interfaces(void) {
 
  { // Angle parameter with mandatory wrapping to [-pi, pi)
    char const * param_name = "angle_param";
    double value = 0.5;
    double default_value = 0.0;
    double value_min = -M_PI_2;
    double value_max = M_PI_2;
    int has_default = 1;
    int is_defined = 1;
    char buf[64];
    double out_val = -999.0;
    int ret;
 
    struct yac_param *param =
      yac_param_angle_new(
        param_name, &value, default_value, value_min, value_max,
        has_default, is_defined);
 
    // get_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_SCALAR)
      PUT_ERR("angle param get_type should return TYPE_SCALAR");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INVALID;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret != 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_DBLE))
      PUT_ERR("angle param get_scalar_kind should return DBLE");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("angle param get_name should return 'angle_param'");
 
    // is_default (should be false initially)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("angle param is_default should be 0 (not default)");
 
    // set_scalar defaults to degrees
    ret = yac_param_set_scalar(param, "90.0");
    if (ret != 0 || (value != M_PI_2))
      PUT_ERR("angle param default degree string conversion failed");
 
    // explicit rad suffix overrides degree default
    ret = yac_param_set_scalar(param, "0.5rad");
    if (ret != 0 || (value != 0.5))
      PUT_ERR("angle param explicit rad suffix conversion failed");
 
    // numeric set/get are radians
    ret = yac_param_set_scalar_dble(param, -M_PI_2);
    if (ret != 0 || (value != -M_PI_2))
      PUT_ERR("angle param numeric radian assignment failed");
 
    ret = yac_param_get_scalar_dble(param, &out_val);
    if (ret != 0 || (out_val != -M_PI_2))
      PUT_ERR("angle param numeric radian retrieval failed");
 
    // string getter is in degrees
    ret = yac_param_get_scalar(param, buf, sizeof(buf));
    if (ret != 0 || fabs(atof(buf) - (-90.0)) > tol)
      PUT_ERR("angle param string getter should return degrees");
 
    // invalid/NULL input
    ret = yac_param_set_scalar(param, NULL);
    if (ret == 0)
      PUT_ERR("angle param set_scalar should fail for NULL string");
    ret = yac_param_set_scalar(param, "180x");
    if (ret == 0)
      PUT_ERR("angle param set_scalar should fail for invalid string");
 
    // numeric setter expects radians; degree-like values are out of range
    ret = yac_param_set_scalar_dble(param, 91.0);
    if (ret == 0)
      PUT_ERR("angle param set_scalar_dble should fail for out-of-range value");
    ret = yac_param_set_scalar_dble(param, -91.0);
    if (ret == 0)
      PUT_ERR("angle param set_scalar_dble should fail for out-of-range value");
 
 
    // get_scalar with too small buffer (should fail)
    int const small_buf_size = 2; // "45.0" + null terminator is 5 chars
    ret = yac_param_get_scalar(
      param, buf, small_buf_size);
    if (ret == 0)
      PUT_ERR("angle param get_scalar should fail for too small buffer");
 
    // set_scalar with out-of-range value (should fail)
    ret = yac_param_set_scalar_dble(
      param, value_min - 0.1);
    if (ret == 0)
      PUT_ERR("angle param should fail if wrapped value is out of range");
    ret = yac_param_set_scalar_dble(
      param, value_max + 0.1);
    if (ret == 0)
      PUT_ERR("angle param should fail if wrapped value is out of range");
 
    // set_scalar_int (integer degrees, should succeed)
    ret = yac_param_set_scalar_int(param, 1);
    if (ret != 0 || (value !=  1.0))
      PUT_ERR("angle param set_scalar_int should succeed for 1 deg");
 
    // get_scalar_int (should succeed when angle is integer degrees)
    int ival = 0;
    ret = yac_param_get_scalar_int(param, &ival);
    if (ret != 0 || ival != 1)
      PUT_ERR("angle param get_scalar_int should succeed for 1 deg");
 
    // get_scalar_int should fail for non-integer degree value
    ret = yac_param_set_scalar_dble(param, 0.5);
    if (ret != 0) PUT_ERR("angle param set_scalar_dble failed");
    ret = yac_param_get_scalar_int(param, &ival);
    if (ret == 0)
      PUT_ERR("angle param get_scalar_int should fail for non-integer deg");
 
    yac_param_delete(param);
  }
 
  { // Angle parameter wrapping for string-degree and numeric-radian input
    char const * param_name = "angle_wrap_param";
    double value = 2.0 * M_PI; // 360 degrees, should wrap to 0
    double default_value = 0.0;
    double value_min = -M_PI_2; // -90 degrees
    double value_max = M_PI_2;  // +90 degrees
    int has_default = 1;
    int is_defined = 1;
    char buf[64];
    int ret;
 
    struct yac_param *param =
      yac_param_angle_new(
        param_name, &value, default_value + 2.0 * M_PI,
        value_min, value_max, has_default, is_defined);
 
    // set_scalar with degree value that wraps
    ret = yac_param_set_scalar(param, "270.0");
    if (ret != 0 || (value != -M_PI_2))
      PUT_ERR("angle param wrapping from degree string input failed");
 
    // get_scalar should reflect wrapped value in degrees
    ret = yac_param_get_scalar(param, buf, sizeof(buf));
    if (ret != 0 || (fabs(atof(buf) - (-90.0)) > tol))
      PUT_ERR("angle param wrapped degree retrieval failed");
 
    // set_scalar_dble with radian value that wraps
    ret = yac_param_set_scalar_dble(param, M_PI_2 + 2.0 * M_PI);
    if (ret != 0 || (value != M_PI_2))
      PUT_ERR("angle param wrapping from numeric radian input failed");
 
    // get_scalar_dble should reflect wrapped value in radians
    double out_val = -999.0;
    ret = yac_param_get_scalar_dble(param, &out_val);
    if (ret != 0 || (fabs(out_val - M_PI_2) > tol))
      PUT_ERR("angle param wrapped radian retrieval failed");
 
    // set_scalar_dble with radian value that wraps negatively
    ret = yac_param_set_scalar_dble(param, -M_PI_2 - 2.0 * M_PI);
    if (ret != 0 || (value != -M_PI_2))
      PUT_ERR("angle param wrapping from numeric radian input failed");
 
    // set_scalar with out-of-range value with wrapping (should fail)
    ret = yac_param_set_scalar_dble(
      param, value_min - 0.1 - 2.0 * M_PI);
    if (ret == 0)
      PUT_ERR("angle param should fail if wrapped value is out of range");
    ret = yac_param_set_scalar_dble(
      param, value_max + 0.1 + 2.0 * M_PI);
    if (ret == 0)
      PUT_ERR("angle param should fail if wrapped value is out of range");
 
    yac_param_delete(param);
  }
 
  { // Wrapping is also applied during constructor initialization
    char const * param_name = "angle_init_wrap_param";
    double value = 3.0 * M_PI;
    double default_value = value;
    double value_min = -M_PI; // -180 degrees
    double value_max = M_PI;  // +180 degrees
    int has_default = 1;
    int is_defined = 1;
    struct yac_param *param =
      yac_param_angle_new(
        param_name, &value, default_value,
        value_min, value_max, has_default, is_defined);
    if (!param)
      PUT_ERR("angle param constructor with wrap should succeed");
    if (value != -M_PI)
      PUT_ERR("angle param constructor did not wrap initial value");
    if (yac_param_is_default(param) != 1)
      PUT_ERR("angle param wrapped initial/default should match");
    yac_param_delete(param);
  }
 
  { // Angle parameter without default
    char const * param_name = "angle_param_nodef";
    double value = 0.0;
    double default_value = 1.0;
    double value_min = -M_PI_2;
    double value_max = M_PI_2;
    int has_default = 0;
    int is_defined = 0;
    int ret;
    char buf[64];
    double out_val = -999.0;
    struct yac_param *param =
      yac_param_angle_new(
        param_name, &value, default_value, value_min, value_max,
        has_default, is_defined);
 
    // is_default should always be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("angle param (no default) is_default should be 0");
 
    // get_scalar/get_scalar_dble should fail before set
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret == 0)
      PUT_ERR("angle param (no default) get_scalar should fail if not set");
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret == 0)
      PUT_ERR("angle param (no default) get_scalar_dble should fail if not set");
 
    // set_scalar_dble
    ret = yac_param_set_scalar_dble(
      param, M_PI_4);
    if (ret != 0 || value != M_PI_4)
      PUT_ERR("angle param (no default) set_scalar_dble failed");
 
    // get_scalar/get_scalar_dble should be successful
    ret = yac_param_get_scalar(
      param, buf, sizeof(buf));
    if (ret != 0 || fabs(atof(buf) - 45.0) > tol)
      PUT_ERR("angle param (no default) get_scalar after set failed");
    out_val = -999.0;
    ret = yac_param_get_scalar_dble(
      param, &out_val);
    if (ret != 0 || out_val != M_PI_4)
      PUT_ERR("angle param (no default) get_scalar_dble after set failed");
 
    // is default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("angle param (no default) is_default should be 0");
 
    // set to default
    ret = yac_param_set_scalar_dble(
      param, default_value);
    if (ret != 0 || value != default_value)
      PUT_ERR("angle param (no default) set_scalar_dble failed");
 
    // is default should still be 0
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("angle param (no default) is_default should be 0");
 
    yac_param_delete(param);
  }
}
 
static void utest_deg_rad_conversion(void) {
 
  double const deg_to_rad = M_PI / 180.0;
 
  for (int deg = -720; deg <= 720; ++deg) {
 
    double wrapped_deg = (double)deg;
    while (wrapped_deg < -180.0) wrapped_deg += 360.0;
    while (wrapped_deg >= 180.0) wrapped_deg -= 360.0;
 
    double expected_rad = wrapped_deg * deg_to_rad;
    double converted_rad = yac_deg_to_rad((double)deg, "deg_to_rad_test");
 
    if (fabs(converted_rad - expected_rad) > tol)
      PUT_ERR("yac_deg_to_rad conversion failed in [-720,720] degree loop");
 
    double expected_deg = wrapped_deg;
    double converted_deg =
      yac_rad_to_deg((double)deg * deg_to_rad, "rad_to_deg_test");
 
    if (fabs(converted_deg - expected_deg) > tol)
      PUT_ERR("yac_rad_to_deg conversion failed in [-720,720] degree loop");
  }
}
 
static struct yac_param * utest_get_sub_by_index(
  struct yac_param *param, size_t idx) {
  struct yac_param *sub = NULL;
  int ret = yac_param_get_sub_by_index(param, idx, &sub);
  if (ret != 0)
    return NULL;
  return sub;
}
 
static char const * list_param_name = "int_sub";
static int list_param_init_value = 4;
static int list_param_default_value = 0;
static int list_param_min = 0;
static int list_param_max = 100;
static int list_param_has_default = 1;
static int list_param_is_defined = 1;
 
// Factory for unnamed int param (for append)
static int utest_default_factory(
  void **element_ptr, struct yac_param **param_ptr) {
  int *elem = xmalloc(sizeof(int));
  *elem = list_param_init_value;
  *element_ptr = elem;
  *param_ptr = yac_param_int_new(
    list_param_name, elem,
    list_param_default_value, list_param_min, list_param_max,
    list_param_has_default, list_param_is_defined);
  return 0;
}
 
static int utest_failing_default_factory(
  void **element_ptr, struct yac_param **param_ptr) {
  UNUSED(element_ptr);
  UNUSED(param_ptr);
  return 1;
}
 
static int utest_list_existing_element_get_param(
  void *element, struct yac_param **param_ptr) {
  *param_ptr = yac_param_int_new(
    list_param_name, (int *)element,
    list_param_default_value, list_param_min, list_param_max,
    list_param_has_default, list_param_is_defined);
  return 0;
}
 
// Test list parameter interfaces
static void utest_list_param_interfaces(void) {
 
  int ret;
 
  { // Main test of list param interfaces
 
    // Start with no backing array; append allocates and grows the array.
    char const * param_name = "list_param";
    void **list = NULL;
    struct yac_param *param =
      yac_param_list_new(
        param_name, &list, utest_default_factory, NULL);
 
    // get_type
    enum yac_param_type type =
      yac_param_get_type(param);
    if (type != YAC_PARAM_TYPE_LIST)
      PUT_ERR("list param get_type should return TYPE_LIST");
 
    enum yac_param_scalar_kind scalar_kind = YAC_PARAM_SCALAR_KIND_INT;
    ret = yac_param_get_scalar_kind(param, &scalar_kind);
    if ((ret == 0) || (scalar_kind != YAC_PARAM_SCALAR_KIND_INVALID))
      PUT_ERR("list param get_scalar_kind should fail");
 
    // get_name
    const char *name = yac_param_get_name(param);
    if (!name || strcmp(name, param_name) != 0)
      PUT_ERR("list param get_name should return 'list_param'");
 
    // get_sub_count
    size_t count = SIZE_MAX;
    ret = yac_param_get_sub_count(param, &count);
    if (ret != 0 || count != 0)
      PUT_ERR("list param get_sub_count should return 0");
 
    // is_default (should be true initially)
    ret = yac_param_is_default(param);
    if (ret != 1)
      PUT_ERR("list param is_default should be 1 (default)");
 
    // Append three elements and set their values to 1, 2, 3
    for (int i = 0; i < 3; ++i) {
      struct yac_param *added = NULL;
      ret = yac_param_append(param, &added);
      if (ret != 0 || !added)
        PUT_ERR("list param append failed (bulk append)");
      ret = yac_param_set_scalar_int(
        added, i + 1);
      if (ret != 0)
        PUT_ERR("list param set_scalar_int failed after append");
      if (*(int*)list[i] != i + 1)
        PUT_ERR("list param appended element value not set correctly");
    }
 
    // is_default (should be false now)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("list param is_default should be 0 (not default)");
 
    // get_sub_count
    ret = yac_param_get_sub_count(param, &count);
    if (ret != 0 || count != 3)
      PUT_ERR("list param get_sub_count should return 3");
 
    // get_sub_by_index (in bounds)
    for (size_t i = 0; i < count; ++i) {
      struct yac_param *sub = NULL;
      ret = yac_param_get_sub_by_index(param, i, &sub);
      if (ret != 0 || !sub)
        PUT_ERR("list param get_sub_by_index failed for valid index");
      int sub_val = -1;
      ret = yac_param_get_scalar_int(
        sub, &sub_val);
      if (ret != 0 || sub_val != (int)(i + 1))
        PUT_ERR(
          "list param get_sub_by_index returned subparam with wrong value");
    }
 
    // get_sub_by_index (out of bounds)
    struct yac_param *sub = NULL;
    ret = yac_param_get_sub_by_index(param, count, &sub);
    if (ret == 0)
      PUT_ERR("list param get_sub_by_index should fail for out-of-bounds");
 
    // Set all subparams to default
    for (size_t i = 0; i < count; ++i) {
      struct yac_param *sub = NULL;
      ret = yac_param_get_sub_by_index(param, i, &sub);
      if (ret != 0 || !sub)
        PUT_ERR(
          "list param get_sub_by_index failed for valid index (set default)");
      yac_param_set_scalar_int(
        utest_get_sub_by_index(param, i), list_param_default_value);
    }
 
    // is_default (should still be false, since the list is not empty)
    ret = yac_param_is_default(param);
    if (ret != 0)
      PUT_ERR("list param is_default should be 0 (not default)");
 
    // destroy
    yac_param_delete(param);
    for (size_t i = 0; i < count; ++i) free(list[i]);
    free(list);
  }
 
  { // append error path
    char const * param_name = "list_param_append_error";
    void **err_list = NULL;
    void **err_list_ptr = err_list;
    void ***err_list_handle = &err_list_ptr;
    struct yac_param *err_param =
      yac_param_list_new(
        param_name, err_list_handle, utest_failing_default_factory, NULL);
    struct yac_param *added = NULL;
    ret = yac_param_append(err_param, &added);
    if (ret == 0)
      PUT_ERR("list param append should fail if factory fails");
    yac_param_delete(err_param);
  }
 
  { // constructor path with existing elements and element_get_param callback
    char const * param_name = "list_param_existing";
    int existing_values[3] = {10, 20, 30};
    void ** existing_list = xmalloc(4 * sizeof(void*));
    existing_list[0] = &existing_values[0];
    existing_list[1] = &existing_values[1];
    existing_list[2] = &existing_values[2];
    existing_list[3] = NULL;
    struct yac_param *existing_param =
      yac_param_list_new(
        param_name, &existing_list, utest_default_factory,
        utest_list_existing_element_get_param);
 
    // is_default should be false since the list is not empty
    ret = yac_param_is_default(existing_param);
    if (ret != 0)
      PUT_ERR("list param with existing elements should not be default");
 
    // get_sub_count should reflect the existing elements
    size_t existing_count = 0;
    ret = yac_param_get_sub_count(
      existing_param, &existing_count);
    if (ret != 0 || existing_count != 3)
      PUT_ERR("list param with existing elements should have size 3");
 
    // get_sub_by_index should return subparams reflecting the existing elements
    for (size_t i = 0; i < existing_count; ++i) {
      struct yac_param *sub = NULL;
      ret = yac_param_get_sub_by_index(
        existing_param, i, &sub);
      if (ret != 0 || !sub)
        PUT_ERR("list param get_sub_by_index failed for existing element");
      int sub_val = -1;
      ret = yac_param_get_scalar_int(
        sub, &sub_val);
      if (ret != 0 || sub_val != existing_values[i])
        PUT_ERR(
          "list param get_sub_by_index returned subparam with wrong "
          "value for existing element");
    }
 
    // get_sub_by_index should fail for out-of-bounds index
    struct yac_param *sub = NULL;
    ret = yac_param_get_sub_by_index(
      existing_param, existing_count, &sub);
    if (ret == 0)
      PUT_ERR("list param get_sub_by_index should fail for out-of-bounds on "
              "existing list");
 
    // append should still work and add new elements after the existing ones
    struct yac_param *added = NULL;
    ret = yac_param_append(existing_param, &added);
    if (ret != 0 || !added)
      PUT_ERR("list param append failed when existing elements are present");
    ret = yac_param_set_scalar_int(
      added, 40);
    if (ret != 0)
      PUT_ERR("list param set_scalar_int failed after append with existing "
              "elements");
    if (*(int*)existing_list[3] != 40)
      PUT_ERR(
        "list param appended element value not set correctly with existing "
        "elements");
 
    yac_param_delete(existing_param);
    free(existing_list[3]);
    free(existing_list);
  }
}
 
// ---------------------------------------------------------------------------
// Usage demo: a dummy interpolation configuration combining int (count),
// distance, and oneof (sub variant) parameter types backed by:
struct dummy_config {
  int count;
  double distance; // stored in radians
  struct dummy_sub  {
    enum {
      DUMMY_OPTION_A,
      DUMMY_OPTION_B
    } sub_type;
    union {
      struct { double scale; } A;
      struct { char  *name;  } B;
    } sub_data;
  } *sub;
};
// ---------------------------------------------------------------------------
 
// Remark:
//  using DEF_NAME_TYPE_PAIRS macro outside of function scope caused problems
//  for doxygen, so defining the name-type pairs manually instead
static struct yac_name_type_pair const dummy_option_types[] = {
  DEF_NAME_TYPE_PAIR(option_a, DUMMY_OPTION_A),
  DEF_NAME_TYPE_PAIR(option_b, DUMMY_OPTION_B),
  DEF_NAME_TYPE_PAIR(a, DUMMY_OPTION_A), // alias for option_a
  DEF_NAME_TYPE_PAIR(b, DUMMY_OPTION_B)  // alias for option_b
};
enum {
  dummy_option_types_size =
    sizeof(dummy_option_types) / sizeof(dummy_option_types[0])
};
 
// default options
int const DUMMY_COUNT_DEFAULT = 3; // default count value
double const DUMMY_DISTANCE_DEFAULT = 1.0 * M_PI / 180.0; // default distance value (1 degree)
static int const DUMMY_SUB_DEFAULT = (int)DUMMY_OPTION_A; // default sub variant
double const DUMMY_SCALE_DEFAULT = 0.5; // default scale value for DUMMY_OPTION_A
char const * const DUMMY_NAME_DEFAULT = "default_name"; // default name value for DUMMY_OPTION_B
 
static struct yac_param * dummy_sub_build_param(struct dummy_sub *dummy_sub) {
 
  if (!dummy_sub) return NULL;
 
  enum {
    DUMMY_SCALE_HAS_DEFAULT = 1,
    DUMMY_SCALE_IS_DEFINE   = 1,
    DUMMY_NAME_ALLOW_NULL = 0,
    DUMMY_NAME_ALLOW_EMPTY = 0,
    DUMMY_NAME_MAX_STR_LEN = 64,
    DUMMY_NAME_HAS_DEFAULT  = 1,
    DUMMY_NAME_IS_DEFINE    = 1
  };
  double const DUMMY_SCALE_MIN     = 0.00001;
  double const DUMMY_SCALE_MAX     = 90.0 * M_PI / 180.0; // 90 degree
 
  switch (dummy_sub->sub_type) {
 
    YAC_UNREACHABLE_DEFAULT(
      "ERROR(dummy_sub_build_param): unknown option type in dummy_sub");
 
    case (DUMMY_OPTION_A): {
 
      struct yac_param * scale_subparam =
        yac_param_distance_new(
          "scale", &dummy_sub->sub_data.A.scale, DUMMY_SCALE_DEFAULT,
          DUMMY_SCALE_MIN, DUMMY_SCALE_MAX, DUMMY_SCALE_HAS_DEFAULT,
          DUMMY_SCALE_IS_DEFINE);
      struct yac_param *sub_params[] = {
        scale_subparam
      };
      return
        yac_param_struct_new(
          yac_name_type_pair_get_name(
            dummy_option_types, dummy_option_types_size, dummy_sub->sub_type),
          sub_params, sizeof(sub_params)/sizeof(sub_params[0]));
    }
 
    case (DUMMY_OPTION_B): {
 
      struct yac_param * name_subparam =
        yac_param_str_new(
          "name", &dummy_sub->sub_data.B.name, DUMMY_NAME_DEFAULT,
          DUMMY_NAME_ALLOW_NULL, DUMMY_NAME_ALLOW_EMPTY, DUMMY_NAME_MAX_STR_LEN,
          DUMMY_NAME_HAS_DEFAULT, DUMMY_NAME_IS_DEFINE);
      struct yac_param *sub_params[] = {
        name_subparam
      };
      return
        yac_param_struct_new(
          yac_name_type_pair_get_name(
            dummy_option_types, dummy_option_types_size, dummy_sub->sub_type),
          sub_params, sizeof(sub_params)/sizeof(sub_params[0]));
    }
  }
}
 
static int dummy_sub_factory(
  const char *name, void **obj,
  struct yac_param **param, int *is_default) {
 
  YAC_ASSERT(obj, "missing dummy sub config object");
  YAC_ASSERT(param, "param is NULL");
  YAC_ASSERT(is_default, "is_default is NULL");
 
  struct dummy_sub **dummy_sub_ptr = (struct dummy_sub **)obj;
 
  YAC_ASSERT(
    *dummy_sub_ptr == NULL, "dummy sub config object is already defined");
 
  struct dummy_sub * dummy_sub = xmalloc(1 * sizeof(*dummy_sub));
 
  int type =
    (name == NULL)?
      (int)DUMMY_OPTION_A:
      yac_name_type_pair_get_type(
        dummy_option_types, dummy_option_types_size, name);
 
  int ret = 1;
 
  switch (type) {
    case DUMMY_OPTION_A:
      dummy_sub->sub_type = DUMMY_OPTION_A;
      dummy_sub->sub_data.A.scale = DUMMY_SCALE_DEFAULT;
      ret = 0;
      break;
 
    case DUMMY_OPTION_B:
      dummy_sub->sub_type = DUMMY_OPTION_B;
      dummy_sub->sub_data.B.name = strdup(DUMMY_NAME_DEFAULT);
      ret = 0;
      break;
 
    default:
      free(dummy_sub);
      dummy_sub = NULL;
      YAC_PARAM_ASSERT(
        0, "ERROR(dummy_sub_factory): unknown option type");
      break;
  }
 
  *dummy_sub_ptr = dummy_sub;
  *param = dummy_sub_build_param(dummy_sub);
  *is_default = (ret == 0) && ((int)dummy_sub->sub_type == DUMMY_SUB_DEFAULT);
 
  return ret;
}
 
static struct yac_param * dummy_config_get_param(
  struct dummy_config *cfg) {
 
  enum {
    DUMMY_COUNT_MIN = 1,
    DUMMY_COUNT_MAX = 100,
    DUMMY_COUNT_HAS_DEFAULT = 1,
    DUMMY_COUNT_IS_DEFAULT = 1
  };
 
  // count param
  struct yac_param *count_param =
    yac_param_int_new(
      "count", &cfg->count,
      DUMMY_COUNT_DEFAULT, DUMMY_COUNT_MIN, DUMMY_COUNT_MAX,
      DUMMY_COUNT_HAS_DEFAULT, DUMMY_COUNT_IS_DEFAULT);
 
  double const DUMMY_DISTANCE_MIN = 0.0;
  double const DUMMY_DISTANCE_MAX = M_PI; // 180 degrees
  enum {
    DUMMY_DISTANCE_HAS_DEFAULT = 1,
    DUMMY_DISTANCE_IS_DEFAULT = 1
  };
 
  // distance param (stores radians; PARSER source converts from degrees)
  struct yac_param *dist_param =
    yac_param_distance_new(
      "distance", &cfg->distance,
      DUMMY_DISTANCE_DEFAULT, DUMMY_DISTANCE_MIN, DUMMY_DISTANCE_MAX,
      DUMMY_DISTANCE_HAS_DEFAULT, DUMMY_DISTANCE_IS_DEFAULT);
 
  // create subparam for cfg.sub
  struct yac_param *dummy_sub_param =
    dummy_sub_build_param(cfg->sub);
 
  int const DUMMY_SUB_IS_DEFAULT =
    (cfg->sub == NULL) || ((int)cfg->sub->sub_type == DUMMY_SUB_DEFAULT);
 
  // oneof param for sub — factory populates cfg.sub on first access
  struct yac_param *sub_param =
    yac_param_oneof_new(
      "sub", dummy_sub_factory, (void **)&cfg->sub,
      dummy_sub_param, DUMMY_SUB_IS_DEFAULT);
 
  // Outer struct param bundles all three
  struct yac_param *root_subs[] = {
    count_param, dist_param, sub_param
  };
  struct yac_param *root =
    yac_param_struct_new(
      "config", root_subs, sizeof(root_subs)/sizeof(root_subs[0]));
 
  return root;
}
 
// Demonstrate application of config param interfaces in a realistic usage
// scenario with a dummy interpolation config.
static void utest_usage_demo(void) {
 
  // Default configuration struct for usage demo
  struct dummy_config cfg = {
    .count    = DUMMY_COUNT_DEFAULT,
    .distance = DUMMY_DISTANCE_DEFAULT,
    .sub      = NULL
  };
 
  // Create the config param tree for dummy_config, which is backed by cfg.
  struct yac_param *config_param =
    dummy_config_get_param(&cfg);
 
  // Set distance in config to 10 degree through the string interface.
  struct yac_param *dist_param;
  yac_param_get_sub_by_name(
    config_param, "distance", &dist_param);
  yac_param_set_scalar(dist_param, "10");
 
  // Set the dummy sub variant to option_b and set its name field to "test_name"
  struct yac_param *sub_param;
  yac_param_get_sub_by_name(config_param, "sub", &sub_param);
  struct yac_param *option_b_param;
  yac_param_get_sub_by_name(sub_param, "option_b", &option_b_param);
  struct yac_param *option_b_name_param;
  yac_param_get_sub_by_name(option_b_param, "name", &option_b_name_param);
  yac_param_set_scalar(option_b_name_param, "test_name");
 
  // Getting the count param
  int count_value;
  struct yac_param *count_param;
  yac_param_get_sub_by_name(config_param, "count", &count_param);
  yac_param_get_scalar_int(count_param, &count_value);
  printf("count value = %d\n", count_value);
 
  // Delete the config param tree
  // (does not free cfg since config params do not own their backing data)
  yac_param_delete(config_param);
 
  // Print contents of cfg to verify that the config params correctly updated it
  printf("cfg.count = %d\n", cfg.count);
  printf("cfg.distance (radians) = %f\n", cfg.distance);
  if (cfg.sub) {
    printf("cfg.sub->sub_type = %d\n", cfg.sub->sub_type);
    if (cfg.sub->sub_type == DUMMY_OPTION_A) {
      printf("cfg.sub->sub_data.A.scale (radians) = %f\n", cfg.sub->sub_data.A.scale);
    } else if (cfg.sub->sub_type == DUMMY_OPTION_B) {
      printf("cfg.sub->sub_data.B.name = %s\n", cfg.sub->sub_data.B.name);
    }
  } else {
    printf("cfg.sub = NULL\n");
  }
 
  // Cleanup
  if (cfg.sub) {
    if (cfg.sub->sub_type == DUMMY_OPTION_B) {
      free(cfg.sub->sub_data.B.name);
    }
    free(cfg.sub);
  }
}