C Language
Strutture di prova

introduzione

Osservazioni

CppUTest

CppUTest è un framework xUnit per unità di test C e C ++. È scritto in C ++ e mira alla portabilità e alla semplicità del design. Supporta il rilevamento delle perdite di memoria, crea mock e esegue i test insieme a Google Test. Viene fornito con script di supporto e progetti di esempio per Visual Studio ed 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 gruppo di prova può avere un metodo setup() e teardown() . Il metodo di setup viene chiamato prima di ogni test e viene chiamato il metodo teardown() . Entrambi sono opzionali e possono essere omessi indipendentemente. Altri metodi e variabili possono anche essere dichiarati all'interno di un gruppo e saranno disponibili per tutti i test di quel gruppo.

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);
    }
}

Unity Test Framework

Unity è un framework di test in stile xUnit per il test dell'unità C. È scritto completamente in C ed è portatile, rapido, semplice, espressivo ed estensibile. È progettato per essere particolarmente utile anche per il test dell'unità per sistemi embedded.

Un semplice caso di test che controlla il valore restituito da una funzione potrebbe apparire come segue

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

Un file di test completo potrebbe essere simile a:

#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 viene fornito con alcuni progetti di esempio, makefile e alcuni script di Ruby Rake che aiutano a rendere un po 'più semplice la creazione di file di test più lunghi.

CMocka

CMocka è un elegante framework di test unitario per C con supporto per oggetti finti. Richiede solo la libreria C standard, funziona su una gamma di piattaforme di elaborazione (incluso embedded) e con diversi compilatori. Ha un tutorial su test con mock, documentazione API e una varietà di esempi .

#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;
}