Cppcheck - HTML report

/**   \file  suite_modmgr-searchpath.c
 *   \brief  Check ModMgr search path management
 *  \author  François Cerbelle (Fanfan), francois@cerbelle.net
 *
 *  \internal
 *       Created:  29/01/2024
 *      Revision:  none
 * Last modified:  2024-07-21 12:50
 *      Compiler:  gcc
 *  Organization:  Cerbelle.net
 *     Copyright:  Copyright (c) 2024, François Cerbelle
 *
 *  This source code is released for free distribution under the terms of the
 *  GNU General Public License as published by the Free Software Foundation.
 */

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

#include "modmgr.h"
#include "debug/oom.h"                                /* OOM simulation */
#include <check.h>
#include <unistd.h>                             /* pid_t getpid() */
#include <sys/stat.h>                           /* mkdir(), chdir(), mode_t */
#include <stdio.h>                              /* fprintf */
#include <stdlib.h>                             /* abort() */
#include <string.h>                             /* strdup (with XOPEN_SOURCE >=500 */
#include <linux/limits.h>                       /* PATH_MAX */
#include "checktools.inc"

/*
 * Module management :
 * - from = uninitialized, empty, 1 module (mkmod1), 1 module (mkmod1:2),
 * 3 modules (mkmod1, mkmod2, mkmod3)
 * 3 modules (mkmod1:2, mkmod2, mkmod3)
 * 3 modules (mkmod1, mkmod2:2, mkmod3)
 * 3 modules (mkmod1, mkmod2, mkmod3:2)
 * 3 modules (mkmod1:2, mkmod2:2, mkmod3)
 * 3 modules (mkmod1:2, mkmod2, mkmod3:2)
 * 3 modules (mkmod1:2, mkmod2:2, mkmod3:2)
 *
 * load (normal, OOM, overflow)
 * - modfile = NULL, empty, missing, normal, subfolder, PATH_MAX+1, noOnLoad, noOnUnload, noGetSymbol, badInfos, badAPI
 *
 * getsymbol (normal, OOM, overflow)
 * - module = NULL, normal, noOnLoad, noOnUnload, noGetSymbol, badInfos, badAPI
 * - szSymbol = NULL, empty, missing, normal,
 *
 * unload (normal, OOM, overflow)
 * - module = NULL, normal, noOnLoad, noOnUnload, noGetSymbol, badInfos, badAPI
 *
 * */

/**************************************************************************/
/* Helper functions */

/** Simulate what we want the real addpath function to achieve
 */
char* simul_insertpath(const char* currentpath, const char* before, const char* value)
{
    uint16_t pos;
    char* retval;

    /* Prepare return value strlen current+value+colon+terminator */
    retval=malloc(
               strlen(NULL!=currentpath?currentpath:"")
               +strlen(NULL!=value?value:"")
               +2);
    pos=0;
    retval[pos] = 0;

    /* If there is an existing currentpath, copy from currentpath to
     * currentpath+before */
    if (NULL!=currentpath) {
        while ((0!=(currentpath+pos)[0])&&((currentpath+pos)!=before)) {
            retval[pos]=currentpath[pos];
            pos++;
        }
    }
    retval[pos]=0;

    /* Add the value to insert */
    if ((NULL!=value)&&(0!=value[0])) {
        /* if nothing was copied before, no need for a colon, if something was copied,
         * colon was already copied, except if adding at the very end of an existing
         * string with before==NULL */
        if ((NULL!=currentpath)&&(NULL==before))
            strcat(retval,":");
        strcat(retval,value);
        /* Insert a separator before the remaining of the string if needed */
        /* If insertion was not at the very end (before==NULL), there is something
         * to add after with a colon separator */
        if ((NULL!=currentpath)&&(NULL!=before))
            strcat(retval,":");
    }

    /* Copy the remaining path */
    if (NULL!=currentpath)
        strcat(retval,currentpath+pos);

    /* lt_dlgetpath does not store empty strings and returns NULL */
    if (0==retval[0]) {
        free(retval);
        retval=NULL;
    }

    return retval;
}

/**************************************************************************/
/* set/getpath tests */
START_TEST(set_null)
{
    int result = 0;                             /* Return code */
    char* oldVal;                               /* Value before*/
    char* newVal;                               /* Value after */
    char* expVal;                               /* Expected value */

    /* Stringify potential NULL and get rid of const qualifier */
    oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");<--- Variable 'oldVal' is allocated memory that is never used.

    oomtest_fill(_i,2);
    result = modmgr_setpath(NULL);
    oomtest_free();

    ck_assert((0==result)||(oomtest_enabled()));

    /* Stringify potential NULL and get rid of const qualifier */
    newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
    expVal = strdup("");

    if (0==result)
        ck_assert_msg(0 == strcmp(newVal,expVal),"modmgr_setpath(NULL)");
    else
        ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(NULL)");

    free(oldVal);
    free(newVal);
    free(expVal);
}
END_TEST

START_TEST(set_empty)
{
    int result = 0;                             /* Return code */
    char* oldVal;                               /* Value before*/
    char* newVal;                               /* Value after */
    char* expVal;                               /* Expected value */

    /* Stringify potential NULL and get rid of const qualifier */
    oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");<--- Variable 'oldVal' is allocated memory that is never used.

    oomtest_fill(_i,2);
    result=modmgr_setpath("");
    oomtest_free();

    ck_assert((0==result)||(oomtest_enabled()));

    /* Stringify potential NULL and get rid of const qualifier */
    newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
    expVal = strdup("");

    if (0==result)
        ck_assert_msg(0 == strcmp(newVal,expVal),"modmgr_setpath(\"\")");
    else
        ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(\"\")");

    free(oldVal);
    free(newVal);
    free(expVal);
}
END_TEST

START_TEST(set_value)
{
    int result = 0;                             /* Return code */
    char* oldVal;                               /* Value before*/
    char* newVal;                               /* Value after */
    char* expVal;                               /* Expected value */

    /* Stringify potential NULL and get rid of const qualifier */
    oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");<--- Variable 'oldVal' is allocated memory that is never used.

    oomtest_fill(_i,2);
    result=modmgr_setpath("abc:def:ghi");
    oomtest_free();

    ck_assert((0==result)||(oomtest_enabled()));

    /* Stringify potential NULL and get rid of const qualifier */
    newVal = strdup(modmgr_getpath()?modmgr_getpath():"");
    expVal = strdup("abc:def:ghi");

    if (0==result)
        ck_assert_msg(0 == strcmp(newVal,expVal),"modmgr_setpath(\"abc:def:ghi\")");
    else
        ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(\"abc:def:ghi\")");

    free(oldVal);
    free(newVal);
    free(expVal);
}
END_TEST

START_TEST(set_bigvalue)
{
    int result = 0;                             /* Return code */
    char* oldVal;                               /* Value before*/
    char* newVal;                               /* Value after */
    char tmpVal[PATH_MAX];                      /* Temporary value */

    /* Stringify potential NULL and get rid of const qualifier */
    oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");<--- Variable 'oldVal' is allocated memory that is never used.

    memset(tmpVal, 65, PATH_MAX-1);
    tmpVal[PATH_MAX-1]=0;

    oomtest_fill(_i,2);
    result = modmgr_setpath(tmpVal);
    oomtest_free();

    ck_assert((0==result)||(oomtest_enabled()));

    /* Stringify potential NULL and get rid of const qualifier */
    newVal = strdup(modmgr_getpath()?modmgr_getpath():"");

    if (0==result)
        ck_assert_msg(0 == strcmp(newVal,tmpVal),"modmgr_setpath(bigvalue)");
    else
        ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(bigvalue)");

    free(oldVal);
    free(newVal);
}
END_TEST

START_TEST(set_hugevalue)
{
    int result = 0;                             /* Return code */
    char* oldVal;                               /* Value before*/
    char* newVal;                               /* Value after */
    char tmpVal[PATH_MAX+5];                    /* Temporary value */

    /* Stringify potential NULL and get rid of const qualifier */
    oldVal = strdup(modmgr_getpath()?modmgr_getpath():"");<--- Variable 'oldVal' is allocated memory that is never used.

    memset(tmpVal, 65, PATH_MAX+5-1);
    tmpVal[PATH_MAX+5-1]=0;

    oomtest_fill(_i,2);
    result = modmgr_setpath(tmpVal);
    oomtest_free();

    ck_assert((0==result)||(oomtest_enabled()));

    /* Stringify potential NULL and get rid of const qualifier */
    newVal = strdup(modmgr_getpath()?modmgr_getpath():"");

    if (0==result)
        ck_assert_msg(0 == strcmp(newVal,tmpVal),"modmgr_setpath(hugevalue)");
    else
        ck_assert_msg(0 == strcmp(newVal,""),"modmgr_setpath(hugevalue)");

    free(oldVal);
    free(newVal);
}
END_TEST

/**************************************************************************/
/** Generic insertpath function, same for all tests
 */
void test_insertpath(const unsigned int minHeap, const char* pos, const char* tmpVal)
{
    int result = 0;                             /* Return code */
    char* oldVal;                               /* Value before*/
    const char* newVal;                         /* Value after */
    char* expVal;                               /* Expected value */

    /* Preserve the current value */
    oldVal = (modmgr_getpath()?strdup(modmgr_getpath()):NULL);

    /* Run the test */
    oomtest_fill(minHeap,2);
    result = modmgr_insertpath(pos,tmpVal);
    oomtest_free();

    /* Test should succeed, except potentially if RAM was filled */
    ck_assert((0==result)||(oomtest_enabled()));

    /* Fetch the resulting value */
    newVal = modmgr_getpath();

    /* Evaluate what should be the resulting value */
    expVal = simul_insertpath(oldVal, pos, tmpVal);

    /* Validate function results against simulation results */
    if (0==result) {
        /* Test succeeded either with oom or without oom enabled */
        if (NULL==expVal)
            ck_assert_msg(NULL==newVal, "modmgr_addpath(null,null)");
        else {
            ck_assert_msg(NULL!=newVal, "modmgr_addpath(null,null)");
            ck_assert_msg((0==strcmp(newVal,expVal)), "modmgr_addpath(null,null)");
        }
    } else {
        /* Test failed only if oom was enabled */
        ck_assert_msg(
            ((NULL==newVal)&&(NULL==oldVal))
            ||((NULL!=newVal)&&(NULL!=oldVal)&&(0==strcmp(oldVal,newVal)))
            ,"modmgr_addpath(null,null)");
    }

    free(oldVal);
    free(expVal);
}

START_TEST(add_null)
{
    test_insertpath(_i,NULL,NULL);
}
END_TEST

START_TEST(add_empty)
{
    test_insertpath(_i,NULL,"");
}
END_TEST

START_TEST(add_value)
{
    test_insertpath(_i,NULL,"abc:def:ghi");
}
END_TEST

START_TEST(add_bigvalue)
{
    char tmpVal[PATH_MAX];                      /* Temporary value */

    memset(tmpVal, 65, PATH_MAX-1);
    tmpVal[PATH_MAX-1]=0;

    test_insertpath(_i,NULL,tmpVal);
}
END_TEST

START_TEST(add_hugevalue)
{
    char tmpVal[PATH_MAX+5];                    /* Temporary value */

    memset(tmpVal, 65, PATH_MAX+5-1);
    tmpVal[PATH_MAX+5-1]=0;

    test_insertpath(_i,NULL,tmpVal);
}
END_TEST

START_TEST(insert_null_at_null)
{
    test_insertpath(_i,NULL,NULL);
}
END_TEST

START_TEST(insert_null_at_first)
{
    test_insertpath(_i,modmgr_getpath(),NULL);
}
END_TEST

START_TEST(insert_null_at_second)
{
    const char* currentpath;                    /* Pointer to current path string */
    char* insertposition;                       /* Pointer to insert position */

    /* Get the current path string */
    currentpath = modmgr_getpath();

    /* Check if current path allow this test */
    if (NULL==currentpath)
        return;

    /* Find the first separator */
    insertposition = strchr(currentpath,':');

    /* Discard test if not enough paths in the string */
    if (NULL==insertposition)
        return;

    /* Go to the first char of the next path */
    insertposition++;

    /* Check if next path exists (colon was not the last char) */
    if (0==insertposition[0])
        return;

    /* Try the insertion */
    test_insertpath(_i,insertposition,NULL);
}
END_TEST

START_TEST(insert_null_at_colon)
{
    const char* currentpath;                    /* Pointer to current path string */
    char* insertposition;                       /* Pointer to insert position */

    /* Get the current path string */
    currentpath = modmgr_getpath();

    /* Check if current path allow this test */
    if (NULL==currentpath)
        return;

    /* Find the first separator */
    insertposition = strchr(currentpath,':');

    /* Discard test if not enough paths in the string */
    if (NULL==insertposition)
        return;

    /* Check if next path exists (colon was not the last char) */
    if (0==insertposition[0])
        return;
    /* Try the insertion */
    test_insertpath(_i,insertposition,NULL);
}
END_TEST

START_TEST(insert_null_at_middle)
{
    const char* currentpath;                    /* Pointer to current path string */
    char* insertposition;                       /* Pointer to insert position */

    /* Get the current path string */
    currentpath = modmgr_getpath();

    /* Check if current path allow this test */
    if (NULL==currentpath)
        return;

    /* Find the first separator */
    insertposition = strchr(currentpath,':');

    /* Discard test if not enough paths in the string */
    if (NULL==insertposition)
        return;

    /* Go to the first char of the next path */
    insertposition++;

    /* Check if next path exists (colon was not the last char) */
    if (0==insertposition[0])
        return;

    /* Go to the second char of the next path */
    insertposition++;

    /* Check if next path exists and is not a separator */
    if ((0==insertposition[0])||(':'==insertposition[0]))
        return;
    /* Try the insertion */
    test_insertpath(_i,insertposition,NULL);
}
END_TEST

START_TEST(insert_null_at_end)
{
    const char* currentpath;                    /* Pointer to current path string */
    char* insertposition;                       /* Pointer to insert position */

    /* Get the current path string */
    currentpath = modmgr_getpath();

    /* Check if current path allow this test */
    if (NULL==currentpath)
        return;

    /* Find the end */
    insertposition = strchr(currentpath,0);

    /* Try the insertion */
    test_insertpath(_i,insertposition,NULL);
}
END_TEST

START_TEST(insert_null_at_outside)
{
    const char* currentpath;                    /* Pointer to current path string */
    char* insertposition;                       /* Pointer to insert position */

    /* Get the current path string */
    currentpath = modmgr_getpath();

    /* Check if current path allow this test */
    if (NULL==currentpath)
        return;

    /* Find the end */
    insertposition = strchr(currentpath,0);
    insertposition++;

    /* Try the insertion */
    test_insertpath(_i,insertposition,NULL);
}
END_TEST



/************************************************************************/
void setpath_uninitialized_unchecked_setup()
{
    forktest_init();
}
void setpath_uninitialized_checked_setup()
{
    signals_catch();
    forktest_gprofdir();
}
void setpath_uninitialized_checked_teardown()
{
    signals_release();
}
void setpath_uninitialized_unchecked_teardown() { }

/************************************************************************/
void setpath_empty_unchecked_setup()
{
    forktest_init();
}
void setpath_empty_checked_setup()
{
    signals_catch();
    forktest_gprofdir();
    modmgr_setpath(NULL);
    ck_assert_msg(NULL == modmgr_getpath(),"modmgr_getpath!=NULL");
}
void setpath_empty_checked_teardown()
{
    signals_release();
}
void setpath_empty_unchecked_teardown() { }

/************************************************************************/
void setpath_withdata_unchecked_setup()
{
    forktest_init();
}
void setpath_withdata_checked_setup()
{
    signals_catch();
    forktest_gprofdir();
    modmgr_setpath("abc:def");
    ck_assert_msg(0 == strcmp("abc:def",modmgr_getpath()),"modmgr_getpath!=withdata");
}
void setpath_withdata_checked_teardown()
{
    signals_release();
}
void setpath_withdata_unchecked_teardown() { }

/************************************************************************/
void setpath_pathmax_unchecked_setup()
{
    forktest_init();
}
void setpath_pathmax_checked_setup()
{
    char modulePath[PATH_MAX];
    signals_catch();
    forktest_gprofdir();
    memset(modulePath, 65, PATH_MAX-1);
    modulePath[PATH_MAX-1]=0;
    modmgr_setpath(modulePath);
    ck_assert_msg(0 == strcmp(modulePath,modmgr_getpath()),"modmgr_getpath!=bigval");
}
void setpath_pathmax_checked_teardown()
{
    signals_release();
}
void setpath_pathmax_unchecked_teardown() { }

/************************************************************************/
void setpath_uninitialized_oom_unchecked_setup()
{
    forktest_init();
}
void setpath_uninitialized_oom_checked_setup()
{
    signals_catch();
    forktest_gprofdir();
    oomtest_enable(RAMLIMIT_SOFT);
}
void setpath_uninitialized_oom_checked_teardown()
{
    signals_release();
}
void setpath_uninitialized_oom_unchecked_teardown() { }

/************************************************************************/
void setpath_empty_oom_unchecked_setup()
{
    forktest_init();
}
void setpath_empty_oom_checked_setup()
{
    signals_catch();
    forktest_gprofdir();
    modmgr_setpath(NULL);
    ck_assert_msg(NULL == modmgr_getpath(),"modmgr_getpath!=NULL");
    oomtest_enable(RAMLIMIT_SOFT);
}
void setpath_empty_oom_checked_teardown()
{
    signals_release();
}
void setpath_empty_oom_unchecked_teardown() { }

/************************************************************************/
void setpath_withdata_oom_unchecked_setup()
{
    forktest_init();
}
void setpath_withdata_oom_checked_setup()
{
    signals_catch();
    forktest_gprofdir();
    modmgr_setpath("abc:def");
    ck_assert_msg(0 == strcmp("abc:def",modmgr_getpath()),"modmgr_getpath!=withdata");
    oomtest_enable(RAMLIMIT_SOFT);
}
void setpath_withdata_oom_checked_teardown()
{
    signals_release();
}
void setpath_withdata_oom_unchecked_teardown() { }

/************************************************************************/
void setpath_pathmax_oom_unchecked_setup()
{
    forktest_init();
}
void setpath_pathmax_oom_checked_setup()
{
    char modulePath[PATH_MAX];
    signals_catch();
    forktest_gprofdir();
    memset(modulePath, 65, PATH_MAX-1);
    modulePath[PATH_MAX-1]=0;
    modmgr_setpath(modulePath);
    ck_assert_msg(0 == strcmp(modulePath,modmgr_getpath()),"modmgr_getpath!=bigval");
    oomtest_enable(RAMLIMIT_SOFT);
}
void setpath_pathmax_oom_checked_teardown()
{
    signals_release();
}
void setpath_pathmax_oom_unchecked_teardown() { }

Suite* modmgr_searchpath_suite()
{
    Suite *s;
    TCase *tc;

    s = suite_create("ModMgr-SearchPath");

    tc = tcase_create("Uninitialized");
    tcase_add_checked_fixture(tc, setpath_uninitialized_checked_setup, setpath_uninitialized_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_uninitialized_unchecked_setup, setpath_uninitialized_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_test(tc, set_null);
    tcase_add_test(tc, set_empty);
    tcase_add_test(tc, set_value);
    tcase_add_test(tc, set_bigvalue);
    tcase_add_test(tc, set_hugevalue);
    tcase_add_test(tc, add_null);
    tcase_add_test(tc, add_empty);
    tcase_add_test(tc, add_value);
    tcase_add_test(tc, add_bigvalue);
    tcase_add_test(tc, add_hugevalue);
    tcase_add_test(tc, insert_null_at_null);
    tcase_add_test(tc, insert_null_at_first);
    tcase_add_test(tc, insert_null_at_second);
    tcase_add_test(tc, insert_null_at_colon);
    tcase_add_test(tc, insert_null_at_middle);
    tcase_add_test(tc, insert_null_at_end);
    tcase_add_test(tc, insert_null_at_outside);

    tc = tcase_create("Empty");
    tcase_add_checked_fixture(tc, setpath_empty_checked_setup, setpath_empty_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_empty_unchecked_setup, setpath_empty_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_test(tc, set_null);
    tcase_add_test(tc, set_empty);
    tcase_add_test(tc, set_value);
    tcase_add_test(tc, set_bigvalue);
    tcase_add_test(tc, set_hugevalue);
    tcase_add_test(tc, add_null);
    tcase_add_test(tc, add_empty);
    tcase_add_test(tc, add_value);
    tcase_add_test(tc, add_bigvalue);
    tcase_add_test(tc, add_hugevalue);
    tcase_add_test(tc, insert_null_at_null);
    tcase_add_test(tc, insert_null_at_first);
    tcase_add_test(tc, insert_null_at_second);
    tcase_add_test(tc, insert_null_at_colon);
    tcase_add_test(tc, insert_null_at_middle);
    tcase_add_test(tc, insert_null_at_end);
    tcase_add_test(tc, insert_null_at_outside);

    tc = tcase_create("WithData");
    tcase_add_checked_fixture(tc, setpath_withdata_checked_setup, setpath_withdata_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_withdata_unchecked_setup, setpath_withdata_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_test(tc, set_null);
    tcase_add_test(tc, set_empty);
    tcase_add_test(tc, set_value);
    tcase_add_test(tc, set_bigvalue);
    tcase_add_test(tc, set_hugevalue);
    tcase_add_test(tc, add_null);
    tcase_add_test(tc, add_empty);
    tcase_add_test(tc, add_value);
    tcase_add_test(tc, add_bigvalue);
    tcase_add_test(tc, add_hugevalue);
    tcase_add_test(tc, insert_null_at_null);
    tcase_add_test(tc, insert_null_at_first);
    tcase_add_test(tc, insert_null_at_second);
    tcase_add_test(tc, insert_null_at_colon);
    tcase_add_test(tc, insert_null_at_middle);
    tcase_add_test(tc, insert_null_at_end);
    tcase_add_test(tc, insert_null_at_outside);

    tc = tcase_create("PathMax");
    tcase_add_checked_fixture(tc, setpath_pathmax_checked_setup, setpath_pathmax_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_pathmax_unchecked_setup, setpath_pathmax_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_test(tc, set_null);
    tcase_add_test(tc, set_empty);
    tcase_add_test(tc, set_value);
    tcase_add_test(tc, set_bigvalue);
    tcase_add_test(tc, set_hugevalue);
    tcase_add_test(tc, add_null);
    tcase_add_test(tc, add_empty);
    tcase_add_test(tc, add_value);
    tcase_add_test(tc, add_bigvalue);
    tcase_add_test(tc, add_hugevalue);
    tcase_add_test(tc, insert_null_at_null);
    tcase_add_test(tc, insert_null_at_first);
    tcase_add_test(tc, insert_null_at_second);
    tcase_add_test(tc, insert_null_at_colon);
    tcase_add_test(tc, insert_null_at_middle);
    tcase_add_test(tc, insert_null_at_end);
    tcase_add_test(tc, insert_null_at_outside);


    tc = tcase_create("Uninitialized-OOM");
    tcase_set_tags(tc,"oom");
    tcase_add_checked_fixture(tc, setpath_uninitialized_oom_checked_setup, setpath_uninitialized_oom_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_uninitialized_oom_unchecked_setup, setpath_uninitialized_oom_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_loop_test(tc, set_null, 0, 15);
    tcase_add_loop_test(tc, set_empty, 0, 15);
    tcase_add_loop_test(tc, set_value, 0, 15);
    tcase_add_loop_test(tc, set_bigvalue, 0, 15);
    tcase_add_loop_test(tc, set_hugevalue, 0, 15);
    tcase_add_loop_test(tc, add_null, 0, 15);
    tcase_add_loop_test(tc, add_empty, 0, 15);
    tcase_add_loop_test(tc, add_value, 0, 15);
    tcase_add_loop_test(tc, add_bigvalue, 0, 15);
    /*     tcase_add_loop_test(tc, add_hugevalue, 0, 15);
     */
    tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);

    tc = tcase_create("Empty-OOM");
    tcase_set_tags(tc,"oom");
    tcase_add_checked_fixture(tc, setpath_empty_oom_checked_setup, setpath_empty_oom_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_empty_oom_unchecked_setup, setpath_empty_oom_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_loop_test(tc, set_null, 0, 15);
    tcase_add_loop_test(tc, set_empty, 0, 15);
    tcase_add_loop_test(tc, set_value, 0, 15);
    tcase_add_loop_test(tc, set_bigvalue, 0, 15);
    tcase_add_loop_test(tc, set_hugevalue, 0, 15);
    tcase_add_loop_test(tc, add_null, 0, 15);
    tcase_add_loop_test(tc, add_empty, 0, 15);
    tcase_add_loop_test(tc, add_value, 0, 15);
    tcase_add_loop_test(tc, add_bigvalue, 0, 15);
    tcase_add_loop_test(tc, add_hugevalue, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);

    tc = tcase_create("WithData-OOM");
    tcase_set_tags(tc,"oom");
    tcase_add_checked_fixture(tc, setpath_withdata_oom_checked_setup, setpath_withdata_oom_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_withdata_oom_unchecked_setup, setpath_withdata_oom_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_loop_test(tc, set_null, 0, 15);
    tcase_add_loop_test(tc, set_empty, 0, 15);
    tcase_add_loop_test(tc, set_value, 0, 15);
    tcase_add_loop_test(tc, set_bigvalue, 0, 15);
    tcase_add_loop_test(tc, set_hugevalue, 0, 15);
    tcase_add_loop_test(tc, add_null, 0, 15);
    tcase_add_loop_test(tc, add_empty, 0, 15);
    tcase_add_loop_test(tc, add_value, 0, 15);
    tcase_add_loop_test(tc, add_bigvalue, 0, 15);
    tcase_add_loop_test(tc, add_hugevalue, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);

    tc = tcase_create("PathMax-OOM");
    tcase_set_tags(tc,"oom");
    tcase_add_checked_fixture(tc, setpath_pathmax_oom_checked_setup, setpath_pathmax_oom_checked_teardown);
    tcase_add_unchecked_fixture(tc, setpath_pathmax_oom_unchecked_setup, setpath_pathmax_oom_unchecked_teardown);
    suite_add_tcase(s, tc);
    tcase_add_loop_test(tc, set_null, 0, 15);
    tcase_add_loop_test(tc, set_empty, 0, 15);
    tcase_add_loop_test(tc, set_value, 0, 15);
    tcase_add_loop_test(tc, set_bigvalue, 0, 15);
    tcase_add_loop_test(tc, set_hugevalue, 0, 15);
    tcase_add_loop_test(tc, add_null, 0, 15);
    tcase_add_loop_test(tc, add_empty, 0, 15);
    tcase_add_loop_test(tc, add_value, 0, 15);
    tcase_add_loop_test(tc, add_bigvalue, 0, 15);
    tcase_add_loop_test(tc, add_hugevalue, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_null, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_first, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_second, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_colon, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_middle, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_end, 0, 15);
    tcase_add_loop_test(tc, insert_null_at_outside, 0, 15);

    return s;
}
Cppcheck report - MKernel: test/suite_modmgr-searchpath.c
