I'm having trouble making sense of parameterized strings.

[saladuit]

Ideally I would like to make something that looks almost like this:

typedef struct s_envp_load {
    char *input[2];
    char *key;
    char *value;
} t_envp_load;

ParameterizedTestParameters(envp_load, paramiterized) {
    static t_envp_load params[] = {
      { { "HELLO=Hello"}, "HELLO", "Hello" },
    // Add more test cases here
    };
    size_t nb_params;

    nb_params = sizeof(params) / sizeof(params[0]);
    return cr_make_param_array(t_envp_load, params, nb_params);
}

ParameterizedTest(t_envp_load *param, envp_load, paramiterized) {
   cr_log_info("key:%s", param->key);
  cr_log_info("input[0]:%s", param->input[0]);
  cr_log_info("input[1]:%s", param->input[1]);
  cr_log_info("value:%s", param->value);
  // assert_envp_load(param->input, param->key, param->value);
}

It only appears that I'm not correctly initializing my parameters or that I'm not properly sending them to my parameterized test.
cr_log_info("key:%s", param->key); immediately segfaults.

[saladuit]

I've simplified my code. But it still doesn't seem to work.

typedef struct s_envp_load {
    // char *input[2];
    char *key;
    char *value;
} t_envp_load;

ParameterizedTestParameters(envp_load, hoi) {
    static t_envp_load params[] = {
      { /*{ "HELLO=Hello"},*/ "HELLO", "Hello" },
    // Add more test cases here
    };
    size_t nb_params;

    nb_params = sizeof(params) / sizeof(params[0]);
    cr_log_error("nb_params:%zu", nb_params);
    cr_log_error("key:%s", params[0].key);
    cr_log_error("value:%s", params[0].value);
    return cr_make_param_array(t_envp_load, params, nb_params);
}

ParameterizedTest(t_envp_load *param, envp_load, hoi) {
  // cr_log_info("input[0]:%s", param->input[0]);
  // cr_log_info("input[1]:%s", param->input[1]);
  cr_log_info("key:%s", param->key);
  // cr_log_info("value:%s", param->value);
  // assert_envp_load(param->input, param->key, param->value);
}

[ERR ] nb_params:1
[ERR ] key:HELLO
[ERR ] value:Hello
AddressSanitizer:DEADLYSIGNAL
=================================================================
==75584==ERROR: AddressSanitizer: SEGV on unknown address 0x55c55d97a560 (pc 0x7efd8b8d9bf6 bp 0x7ffccd152280 sp 0x7ffccd1519b8 T0)
==75584==The signal is caused by a READ memory access.
    #0 0x7efd8b8d9bf6 in __sanitizer::internal_strlen(char const*) /usr/src/debug/gcc/gcc/libsanitizer/sanitizer_common/sanitizer_libc.cpp:167
    #1 0x7efd8b875978 in printf_common /usr/src/debug/gcc/gcc/libsanitizer/sanitizer_common/sanitizer_common_interceptors_format.inc:551
    #2 0x7efd8b877705 in __interceptor___vsnprintf_chk /usr/src/debug/gcc/gcc/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:1670
    #3 0x7efd8c00f946 in cri_fmt_vbprintf (/usr/lib/libcriterion.so.3+0x15946)
    #4 0x7efd8c00fae5 in cr_vasprintf (/usr/lib/libcriterion.so.3+0x15ae5)
    #5 0x7efd8c00c3ef in cr_log (/usr/lib/libcriterion.so.3+0x123ef)
    #6 0x55b2cbd22692 in envp_load_hoi_impl src/env_cases.c:51
    #7 0x7efd8c007f8f in criterion_internal_test_main (/usr/lib/libcriterion.so.3+0xdf8f)
    #8 0x55b2cbd22605 in envp_load_hoi_jmp src/env_cases.c:48
    #9 0x7efd8c007364  (/usr/lib/libcriterion.so.3+0xd364)
    #10 0x7efd8c01416c  (/usr/lib/libcriterion.so.3+0x1a16c)
    #11 0x7efd8b63c78f  (/usr/lib/libc.so.6+0x2378f)
    #12 0x7efd8b63c849 in __libc_start_main (/usr/lib/libc.so.6+0x23849)
    #13 0x55b2cbd1a4d4 in _start (/home/safoh/repos/minishell/test.out+0x284d4)

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV /usr/src/debug/gcc/gcc/libsanitizer/sanitizer_common/sanitizer_libc.cpp:167 in __sanitizer::internal_strlen(char const*)
==75584==ABORTING
[FAIL] envp_load::hoi: (0.00s)
[====] Synthesis: Tested: 2 | Passing: 1 | Failing: 1 | Crashing: 0 

[Snaipe]

Unfortunately, this is a result of the addresses space changing between the parent (where ParameterizedTestParameters runs) and the child (where the test runs). Any pointer value defined there, including strings, end up messed up, likely because of the ASLR.

The canonical way of passing pointer values is to use cr_malloc to ensure the strings get moved from the parent to the child's virtual address space. See

Criterion/samples/parameterized.c

Line 82 in 6c1be20

/* Using strings in parameterized tests */

for an actual example.

[saladuit]

thank you for your quick response!
In any case, the documentation doesn't word it correctly.
https://criterion.readthedocs.io/en/master/parameterized.html states the following.
"Any dynamic memory allocation done from a ParameterizedTestParameter function must be done with cr_malloc, cr_calloc, or cr_realloc."
So I figured that I should use those cr_* functions when I'm actually dynamically allocating space.
Would it perhaps be a suggestion to make a wrapper that takes care of this?
Worst case scenario, would be that I actually want to dynamically allocate space. What should one do in such a scenario?
edited: It could very well be that I don't correctly understand the exact meaning of dynamic memory allocation, but I thought a string literal was stored in the data segment of a program and therefore statically allocated.

[saladuit]

This is besides the fact that I need a lot more code to achieve exactly the same goal.
Without all the Parameterized test setup my code looks like this.

void assert_envp_load(char **input,char *key, char *expected)
{
  t_dictionary env[HASH_TABLE_SIZE];

  envp_load(env, input);
  cr_expect_str_eq(dict_get(env, key), expected);
  dict_destroy(env);
}

TestSuite(envp_load);

Test(envp_load, basic)
{
  char *input[] = {"HELLO=Hello", NULL};
  assert_envp_load(input , "HELLO", "Hello");
}

Test(envp_load, empty)
{
  char *input[] = {"HELLO=", NULL};
  assert_envp_load(input , "HELLO", "");
}

Test(envp_load, dollar)
{
  char *input[] = {"DOLLAR=$", NULL};
  assert_envp_load(input , "DOLLAR", "$");
}