C Language
Test des frameworks

Introduction

Remarques

CppUTest

CppUTest est un framework de type xUnit pour les tests unitaires C et C ++. Il est écrit en C ++ et vise la portabilité et la simplicité dans la conception. Il prend en charge la détection des fuites de mémoire, la création de simulacres et l'exécution de ses tests avec le test Google. Livré avec des scripts d'aide et des exemples de projets pour Visual Studio et Eclipse CDT.

#include <CppUTest/CommandLineTestRunner.h>
#include <CppUTest/TestHarness.h>


TEST_GROUP(Foo_Group) {}

TEST(Foo_Group, Foo_TestOne) {}

/* Test runner may be provided options, such
   as to enable colored output, to run only a
   specific test or a group of tests, etc. This
   will return the number of failed tests. */

int main(int argc, char ** argv)
{
    RUN_ALL_TESTS(argc, argv);
}

Un groupe de test peut avoir une méthode setup() et une méthode teardown() . La méthode d' setup est appelée avant chaque test et la méthode teardown() est appelée après. Les deux sont facultatifs et l'un ou l'autre peut être omis indépendamment. D'autres méthodes et variables peuvent également être déclarées à l'intérieur d'un groupe et seront disponibles pour tous les tests de ce groupe.

TEST_GROUP(Foo_Group)
{
    size_t data_bytes = 128;
    void * data;

    void setup()
    {
        data = malloc(data_bytes);
    }

    void teardown()
    {
        free(data);
    }

    void clear()
    {
        memset(data, 0, data_bytes);
    }
}

Cadre de test d'unité

Unity est un framework de test de style xUnit pour les tests unitaires C. Il est entièrement écrit en C et est portable, rapide, simple, expressif et extensible. Il est spécialement conçu pour les tests unitaires des systèmes embarqués.

Un scénario de test simple qui vérifie la valeur de retour d'une fonction peut se présenter comme suit

void test_FunctionUnderTest_should_ReturnFive(void)
{
    TEST_ASSERT_EQUAL_INT( 5, FunctionUnderTest() );
}

Un fichier de test complet peut ressembler à ceci:

#include "unity.h"
#include "UnitUnderTest.h" /* The unit to be tested. */

void setUp (void) {} /* Is run before every test, put unit init calls here. */
void tearDown (void) {} /* Is run after every test, put unit clean-up calls here. */

void test_TheFirst(void)
{
    TEST_IGNORE_MESSAGE("Hello world!"); /* Ignore this test but print a message. */
}

int main (void)
{
    UNITY_BEGIN();
    RUN_TEST(test_TheFirst); /* Run the test. */
    return UNITY_END();
}  

Unity est fourni avec des exemples de projets, des fichiers makefiles et des scripts rake Ruby qui facilitent la création de fichiers de test plus longs.

CMocka

CMocka est un framework de test unitaire élégant pour C avec prise en charge des objets fictifs . Il ne nécessite que la bibliothèque standard C, fonctionne sur une gamme de plates-formes informatiques (y compris embarquées) et avec différents compilateurs. Il comprend un didacticiel sur les tests avec des simulacres, la documentation de l’API et divers exemples .

#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>

void null_test_success (void ** state) {}

void null_test_fail (void ** state)
{
    assert_true (0);
}

/* These functions will be used to initialize
   and clean resources up after each test run */
int setup (void ** state)
{
    return 0;
}

int teardown (void ** state)
{
    return 0;
}


int main (void)
{
    const struct CMUnitTest tests [] =
    {
        cmocka_unit_test (null_test_success),
        cmocka_unit_test (null_test_fail),
    };

    /* If setup and teardown functions are not
       needed, then NULL may be passed instead */

    int count_fail_tests =
        cmocka_run_group_tests (tests, setup, teardown);

    return count_fail_tests;
}