C Language
Testa ramar

Introduktion

Anmärkningar

CppUTest

CppUTest är en xUnit- stilram för enhetstest C och C ++. Den är skriven i C ++ och syftar till portabilitet och enkelhet i design. Den har stöd för att upptäcka minnesläckage, bygga håravfall och köra sina tester tillsammans med Google Test. Levereras med hjälpskript och provprojekt för Visual Studio och 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);
}

En testgrupp kan ha en metod för setup() och en teardown() . setup kallas före varje test och metoden för teardown() kallas efter. Båda är valfria och antingen kan utelämnas oberoende. Andra metoder och variabler kan också deklareras i en grupp och kommer att vara tillgängliga för alla tester i den gruppen.

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 är ett testram för xUnit- stil för enhetstestning C. Det är skrivet helt i C och är portabelt, snabbt, enkelt, uttrycksfullt och utdragbart. Den är utformad för att särskilt vara också användbar för enhetstestning för inbäddade system.

Ett enkelt testfall som kontrollerar returfunktionen för en funktion kan se ut som följer

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

En fullständig testfil kan se ut:

#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 kommer med några exempelprojekt, makefiler och några Ruby rake-skript som hjälper till att skapa längre testfiler lite enklare.

CMocka

CMocka är en elegant enhetstestram för C med stöd för håliga föremål. Det kräver bara C-biblioteket, fungerar på en rad datorplattformar (inklusive inbäddade) och med olika kompilatorer. Den har en tutorial om testning med håna, API-dokumentation och en mängd exempel .

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