C Language
Marcos de prueba

Introducción

Observaciones

CppUTest

CppUTest es un marco de estilo xUnit para pruebas de unidad C y C ++. Está escrito en C ++ y tiene como objetivo la portabilidad y la simplicidad en el diseño. Es compatible con la detección de fugas de memoria, la creación de simulacros y la ejecución de sus pruebas junto con Google Test. Viene con scripts de ayuda y proyectos de muestra para Visual Studio y 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 grupo de prueba puede tener un método setup() y un método teardown() . El método de setup se llama antes de cada prueba y el método teardown() se llama después. Ambos son opcionales y pueden omitirse independientemente. Otros métodos y variables también pueden declararse dentro de un grupo y estarán disponibles para todas las pruebas de ese grupo.

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 es un marco de prueba de estilo xUnit para pruebas de unidad C. Está escrito completamente en C y es portátil, rápido, simple, expresivo y extensible. Está diseñado para ser especialmente útil también para pruebas unitarias de sistemas integrados.

Un caso de prueba simple que verifica el valor de retorno de una función, podría tener el siguiente aspecto

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

Un archivo de prueba completo podría verse como:

#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 con algunos proyectos de ejemplo, archivos make y algunos scripts de rake de Ruby que ayudan a que la creación de archivos de prueba más largos sea un poco más fácil.

CMocka

CMocka es un marco de prueba de unidad elegante para C con soporte para objetos simulados. Solo requiere la biblioteca C estándar, funciona en una variedad de plataformas informáticas (incluidas las integradas) y con diferentes compiladores. Tiene un tutorial sobre pruebas con simulacros, documentación de API y una variedad de ejemplos .

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