Cppcheck report - GATE C/C++ Framework: gate/tests.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/tests.h"
#include "gate/streams.h"
#include "gate/strings.h"
#include "gate/console.h"
#include "gate/arrays.h"

typedef struct gate_test_session_class
{
    gate_stream_t* stream;
    gate_test_report_t	reports[256];
    unsigned			reports_used;
    gate_bool_t			save_checks;
    gate_linkedlist_t	checks;
} gate_test_session_t;

typedef struct gate_test_history_class
{
    char const* test_name;
    char		message[128];
    gate_bool_t	failed;
    char const* origin;
    unsigned	line;

} gate_test_history_t;

static gate_test_session_t test_session = GATE_INIT_EMPTY;


static gate_test_report_t* gate_test_register(char const* unit_name)
{
    gate_test_report_t* ptr = NULL;
    gate_size_t unit_name_len = gate_str_length(unit_name);
    gate_size_t const max_reports = sizeof(test_session.reports) / sizeof(test_session.reports[0]);
    if (test_session.reports_used < max_reports)
    {
        ptr = &test_session.reports[test_session.reports_used];
        ++test_session.reports_used;
        gate_mem_clear(ptr, sizeof(gate_test_report_t));
        gate_str_print_text(ptr->name, sizeof(ptr->name), unit_name, unit_name_len);
        ptr->test_counter = 0;
        ptr->error_counter = 0;
    }
    else
    {
        ptr = &test_session.reports[max_reports - 1];
    }
    return ptr;
}

static gate_test_report_t* gate_test_current_unit()
{
    if (test_session.reports_used == 0)
    {
        return gate_test_register("unnamed_unit_test");
    }
    return &test_session.reports[test_session.reports_used - 1];
}

static gate_stream_t* gate_test_current_stream()
{
    return test_session.stream;
}

static void gate_test_print_source(gate_stream_t* stream, char const* filepath, unsigned codeline)
{
    if (filepath)
    {
        gate_stream_print(stream,
            GATE_PRINT_CSTR, filepath,
            GATE_PRINT_CSTR, "(",
            GATE_PRINT_UI32, (gate_uint32_t)codeline,
            GATE_PRINT_CSTR, "): ",
            GATE_PRINT_END
        );
    }
}

static void gate_test_print_message(char const* msg_type, char const* message, char const* filepath, unsigned codeline)
{
    gate_stream_t* stream = gate_test_current_stream();

    gate_test_print_source(stream, filepath, codeline);
    gate_stream_print(stream,
        GATE_PRINT_CSTR, msg_type,
        GATE_PRINT_CSTR, message,
        GATE_PRINT_NEWLINE,
        GATE_PRINT_END);
}

void gate_test_init(gate_stream_t* stream)
{
    gate_console_t* con;
<--- The scope of the variable 'con' can be reduced. [+]
The scope of the variable 'con' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_mem_clear(&test_session, sizeof(test_session));
    test_session.reports_used = 0;
    if (stream == NULL)
    {
        con = gate_console();
        if (con)
        {
            test_session.stream = (gate_stream_t*)con;
        }
        else
        {
            test_session.stream = gate_nullstream();
        }
    }
    else
    {
        test_session.stream = stream;
    }
    gate_linkedlist_create(&test_session.checks, sizeof(gate_test_history_t), NULL, NULL);
}

void gate_test_uninit()
{
    gate_linkedlist_destroy(&test_session.checks);
    gate_mem_clear(&test_session, sizeof(test_session));
}


void gate_test_unit_begin(char const* unit_name, char const* filepath, unsigned codeline)
{
    gate_test_register(unit_name);
    gate_test_print_message("TEST-BEGIN: ", unit_name, filepath, codeline);
}

static gate_bool_t volatile global_trace_on;
static gate_bool_t volatile global_history_on;

void gate_test_trace_enable(gate_bool_t on)
{
    global_trace_on = on;
}

void gate_test_history_enable(gate_bool_t on)
{
    global_history_on = on;
}


void gate_test_trace_message(char const* message, char const* filepath, unsigned codeline)
{
    if (global_trace_on)
    {
        gate_test_print_message("TRACE: ", message, filepath, codeline);
    }
}

void gate_test_trace_value(gate_int64_t value, char const* filepath, unsigned codeline)
{
    char buffer[128] = GATE_INIT_EMPTY;
    gate_str_print_int64(buffer, sizeof(buffer), value);
    gate_test_trace_message(buffer, filepath, codeline);
}

static void add_test_history_entry(gate_bool_t failed, char const* message, char const* filepath, unsigned codeline)
{
    gate_test_report_t* ptr = gate_test_current_unit();
    gate_test_history_t entry;
    entry.test_name = ptr->name;
    gate_str_print_text(entry.message, sizeof(entry.message), message, gate_str_length(message));
    entry.failed = failed;
    entry.origin = filepath;
    entry.line = codeline;
    gate_linkedlist_add(&test_session.checks, &entry);
}

void gate_test_success_message(char const* message, char const* filepath, unsigned codeline)
{
    if (global_trace_on || global_history_on)
    {
        gate_test_print_message("SUCCESS: ", message, filepath, codeline);
    }
    if (global_history_on)
    {
        add_test_history_entry(false, message, filepath, codeline);
    }
}

void gate_test_error_message(char const* message, char const* filepath, unsigned codeline)
{
    gate_test_print_message("ERROR: ", message, filepath, codeline);
    if (global_history_on)
    {
        add_test_history_entry(true, message, filepath, codeline);
    }
}


void gate_test_count_test()
{
    gate_test_report_t* ptr = gate_test_current_unit();
    if (ptr)
    {
        ++ptr->test_counter;
    }
}

void gate_test_count_error()
{
    gate_test_report_t* ptr = gate_test_current_unit();
    if (ptr)
    {
        ++ptr->error_counter;
    }
}

unsigned gate_test_get_reports(gate_test_report_t* target_report_array, unsigned max_reports)
{
    unsigned count = (max_reports < test_session.reports_used) ? max_reports : test_session.reports_used;
    gate_mem_copy(target_report_array, &test_session.reports[0], count * sizeof(gate_test_report_t));
    return count;
}

static void print_history_junit(gate_stream_t* stream, gate_linkedlist_t* checks)
{

}

gate_bool_t gate_test_print_history(gate_stream_t* stream, gate_enumint_t flags)
{
    if (GATE_FLAG_ENABLED(flags, GATE_TEST_HISTORY_FORMAT_JUNIT))
    {
        print_history_junit(stream, &test_session.checks);
        return true;
    }
    return false;
}


void gate_test_print_reports()
{
    gate_test_report_t* ptr;
<--- The scope of the variable 'ptr' can be reduced. [+]
The scope of the variable 'ptr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_stream_t* stream = gate_test_current_stream();
    unsigned ndx;
    gate_uint16_t total_tests = 0;
    gate_uint16_t total_errors = 0;

    gate_stream_print(stream,
        GATE_PRINT_CSTR, "----------------------------------------",
        GATE_PRINT_NEWLINE,
        GATE_PRINT_END);

    for (ndx = 0; ndx != test_session.reports_used; ++ndx)
    {
        ptr = &test_session.reports[ndx];
        total_tests += ptr->test_counter;
        total_errors += ptr->error_counter;

        if (ptr->error_counter == 0)
        {
            gate_stream_print_cstr(stream, "UNIT OK: ");
        }
        else
        {
            gate_stream_print_cstr(stream, "UNIT FAILED: ");
        }

        gate_stream_print(stream,
            GATE_PRINT_CSTR, ptr->name,
            GATE_PRINT_CSTR, ", ",
            GATE_PRINT_UI16, ptr->test_counter,
            GATE_PRINT_CSTR, " tests",
            GATE_PRINT_END);

        if (ptr->error_counter != 0)
        {
            gate_stream_print(stream,
                GATE_PRINT_CSTR, ", ",
                GATE_PRINT_UI16, ptr->error_counter,
                GATE_PRINT_CSTR, " failures",
                GATE_PRINT_END);
        }

        gate_stream_print(stream,
            GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }

    gate_stream_print(stream,
        GATE_PRINT_CSTR, "----------------------------------------",
        GATE_PRINT_NEWLINE,
        GATE_PRINT_CSTR, "TOTAL: ",
        GATE_PRINT_UI16, total_tests,
        GATE_PRINT_CSTR, " tests, ",
        GATE_PRINT_END);
    if (total_errors == 0)
    {
        gate_stream_print(stream,
            GATE_PRINT_CSTR, "No errors detected",
            GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }
    else
    {
        gate_stream_print(stream,
            GATE_PRINT_UI16, total_errors,
            GATE_PRINT_CSTR, " errors detected",
            GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }

}

gate_bool_t gate_test_failed()
{
    gate_test_report_t* ptr;
<--- The scope of the variable 'ptr' can be reduced. [+]
The scope of the variable 'ptr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    unsigned ndx;
    for (ndx = 0; ndx != test_session.reports_used; ++ndx)
    {
        ptr = &test_session.reports[ndx];
        if (ptr->error_counter != 0)
        {
            return true;
        }
    }
    return false;
}


gate_bool_t gate_test_cases_run(gate_test_case_t const* test_cases, gate_size_t test_cases_count)
{
    gate_size_t ndx;
    gate_bool_t succeeded = true;
    gate_test_case_t const* ptr_case = NULL;

    GATE_TEST_INIT_DEFAULT();

    for (ndx = 0; ndx != test_cases_count; ++ndx)
    {
        ptr_case = &test_cases[ndx];<--- Variable 'ptr_case' is assigned a value that is never used.
        succeeded = test_cases[ndx].test_function();
    }

    return !gate_test_failed();
}

static gate_bool_t is_test_case_selected(char const* tc_name, char const* const* patterns, gate_size_t patterns_count)
{
    if (patterns_count == 0)
    {
        /* no pattern defined -> all TCs are selected */
        return true;
    }
    else
    {
        gate_size_t const tc_name_len = gate_str_length(tc_name);
        gate_size_t ndx;

        for (ndx = 0; ndx != patterns_count; ++ndx)
        {
            char const* const pattern = patterns[ndx];
            size_t const pattern_len = gate_str_length(pattern);
            if (gate_str_like(tc_name, tc_name_len, pattern, pattern_len))
            {
                /* matching pattern found */
                return true;
            }
        }
        return false;
    }

}

int gate_test_main(gate_test_case_t const* test_cases, gate_size_t test_cases_count,
    char const* const* arguments, gate_size_t argcount)
{
    gate_test_case_t selected_test_cases[256];
    gate_size_t selected_test_cases_count = 0;
    const gate_size_t selected_test_cases_max = sizeof(selected_test_cases) / sizeof(selected_test_cases[0]);
    char const* test_patterns[256];
    gate_size_t test_patterns_count = 0;
    const gate_size_t test_pattern_max = sizeof(test_patterns) / sizeof(test_patterns[0]);
    gate_bool_t succeeded;
    gate_size_t ndx;
    gate_bool_t show_help = false;
    gate_bool_t enable_trace = false;
    gate_bool_t list_tests = false;
    gate_stream_t* con = (gate_stream_t*)gate_console();

    GATE_TEST_INIT_DEFAULT();

    for (ndx = 0; ndx != argcount; ++ndx)
    {
        char const* const arg = arguments[ndx];
        if (gate_str_comp_ic(arg, "--help") == 0)
        {
            show_help = true;
        }
        else if (gate_str_comp_ic(arg, "--list") == 0)
        {
            list_tests = true;
        }
        else if (gate_str_comp_ic(arg, "--trace") == 0)
        {
            enable_trace = true;
        }
        else
        {
            if (test_patterns_count < test_pattern_max)
            {
                test_patterns[test_patterns_count] = arg;
                ++test_patterns_count;
            }
        }
    }

    if (show_help)
    {
        gate_stream_print(con,
            GATE_PRINT_CSTR, "Usage:", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "testapp --help", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "\tPrint test program usage description", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "testapp --list", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "\tLists all registered test cases by their anmes", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "testapp", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "\tExecutes all registered test cases", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "testapp test_case_name1 test_case_name2", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "\tExecutes only test cases named by arguments", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "testapp --trace test_case_name1 test_case_name2", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "\tExecutes given test cases with trace-mode enabled", GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
        return 0;
    }

    if (list_tests)
    {
        for (ndx = 0; ndx != test_cases_count; ++ndx)
        {
            gate_test_case_t const* tc = &test_cases[ndx];
            gate_stream_print(con,
                GATE_PRINT_CSTR, tc->name, GATE_PRINT_NEWLINE,
                GATE_PRINT_END);
        }
        return 0;
    }


    for (ndx = 0; (ndx != test_cases_count) && (selected_test_cases_count < selected_test_cases_max); ++ndx)
    {
        gate_test_case_t const* tc = &test_cases[ndx];
        if (is_test_case_selected(tc->name, test_patterns, test_patterns_count))
        {
            selected_test_cases[selected_test_cases_count] = test_cases[ndx];
            ++selected_test_cases_count;
        }
    }

    if (enable_trace)
    {
        gate_test_trace_on();
    }

    succeeded = gate_test_cases_run(selected_test_cases, selected_test_cases_count);
    gate_test_print_reports();

    gate_test_uninit();
    return succeeded ? 0 : 1;
}