libkernaux/tests/cmdline_gen.jinja

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <kernaux/cmdline.h>
#include <kernaux/memory_file.h>

#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#define ARGV_COUNT_MAX 100
#define BUFFER_SIZE 4096

static void test(
    const char *cmdline,
    size_t argv_count_max,
    size_t buffer_size,

    bool expected_result,
    const char *expected_error_msg,
    size_t expected_argc,
    const char *const *const expected_argv
);

void test_main()
{
    {% for case in cases %}
    {
        {% if not case.error and len(case.result) %}
            const char *const expected_argv[] = {
                {% for item in case.result %}
                    {{ escape_str(item) }},
                {% endfor %}
            };
        {% endif %}

        test(
            {{ escape_str(case.cmdline) }},
            {{ escape_int(case.argv_count_max or 0) }},
            {{ escape_int(case.buffer_size or 0) }},
            {% if not case.error %}
                true,
                "",
                {{ escape_int(len(case.result)) }},
                {% if len(case.result) %}
                    expected_argv
                {% else %}
                    NULL
                {% endif %}
            {% else %}
                false,
                {{ escape_str(case.error) }},
                0,
                NULL
            {% endif %}
        );
    }
    {% endfor %}
}

void test(
    const char *const cmdline,
    size_t argv_count_max,
    size_t buffer_size,

    const bool expected_result,
    const char *const expected_error_msg,
    size_t expected_argc,
    const char *const *const expected_argv
) {
    if (argv_count_max == 0) argv_count_max = ARGV_COUNT_MAX;
    if (buffer_size    == 0) buffer_size    = BUFFER_SIZE;

    char *error_msg = malloc(KERNAUX_CMDLINE_ERROR_MSG_SIZE_MAX);
    size_t argc = 1234;
    char **const argv = malloc(sizeof(char*) * argv_count_max);
    char *const buffer = malloc(buffer_size);

    assert(error_msg);
    assert(argv);
    assert(buffer);

    {
        memset(error_msg, 'x', KERNAUX_CMDLINE_ERROR_MSG_SIZE_MAX);
        memset(argv,      'x', sizeof(char*) * argv_count_max);
        memset(buffer,    'x', buffer_size);

        assert(
            kernaux_cmdline(
                cmdline,
                error_msg,
                &argc,
                argv,
                buffer,
                argv_count_max,
                buffer_size
            ) == !!expected_result
        );

        assert(strcmp(error_msg, expected_error_msg) == 0);
        assert(argc == expected_argc);

        if (expected_argv) {
            for (size_t index = 0; index < argc; ++index) {
                assert(strcmp(argv[index], expected_argv[index]) == 0);
            }
        }

        for (size_t index = argc; index < argv_count_max; ++index) {
            assert(argv[index] == NULL);
        }
    }

    if (strcmp(expected_error_msg, "too many args") != 0) {
        memset(error_msg, 'x', KERNAUX_CMDLINE_ERROR_MSG_SIZE_MAX);
        memset(argv,      'x', sizeof(char*) * argv_count_max);
        memset(buffer,    'x', buffer_size);

        struct KernAux_MemoryFile memory_file =
            KernAux_MemoryFile_create(buffer, buffer_size, NULL);

        assert(
            kernaux_cmdline_file(
                cmdline,
                error_msg,
                &argc,
                &memory_file.file
            ) == !!expected_result
        );

        assert(strcmp(error_msg, expected_error_msg) == 0);
        assert(argc == expected_argc);

        if (expected_argv) {
            const char *arg = buffer;
            for (size_t index = 0; index < argc; ++index) {
                assert(strcmp(expected_argv[index], arg) == 0);
                arg += strlen(arg) + 1;
            }
        }
    }

    free(error_msg);
    free(argv);
    free(buffer);
}