19750e409Sopenharmony_ci/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
29750e409Sopenharmony_ci * ==========================================
39750e409Sopenharmony_ci *  Unity Project - A Test Framework for C
49750e409Sopenharmony_ci *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
59750e409Sopenharmony_ci *  [Released under MIT License. Please refer to license.txt for details]
69750e409Sopenharmony_ci * ========================================== */
79750e409Sopenharmony_ci
89750e409Sopenharmony_ci#include "unity_fixture.h"
99750e409Sopenharmony_ci#include "unity_internals.h"
109750e409Sopenharmony_ci#include <string.h>
119750e409Sopenharmony_ci
129750e409Sopenharmony_cistruct UNITY_FIXTURE_T UnityFixture;
139750e409Sopenharmony_ci
149750e409Sopenharmony_ci/* If you decide to use the function pointer approach.
159750e409Sopenharmony_ci * Build with -D UNITY_OUTPUT_CHAR=outputChar and include <stdio.h>
169750e409Sopenharmony_ci * int (*outputChar)(int) = putchar; */
179750e409Sopenharmony_ci
189750e409Sopenharmony_ci#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
199750e409Sopenharmony_civoid setUp(void)    { /*does nothing*/ }
209750e409Sopenharmony_civoid tearDown(void) { /*does nothing*/ }
219750e409Sopenharmony_ci#endif
229750e409Sopenharmony_ci
239750e409Sopenharmony_cistatic void announceTestRun(unsigned int runNumber)
249750e409Sopenharmony_ci{
259750e409Sopenharmony_ci    UnityPrint("Unity test run ");
269750e409Sopenharmony_ci    UnityPrintNumberUnsigned(runNumber+1);
279750e409Sopenharmony_ci    UnityPrint(" of ");
289750e409Sopenharmony_ci    UnityPrintNumberUnsigned(UnityFixture.RepeatCount);
299750e409Sopenharmony_ci    UNITY_PRINT_EOL();
309750e409Sopenharmony_ci}
319750e409Sopenharmony_ci
329750e409Sopenharmony_ciint UnityMain(int argc, const char* argv[], void (*runAllTests)(void))
339750e409Sopenharmony_ci{
349750e409Sopenharmony_ci    int result = UnityGetCommandLineOptions(argc, argv);
359750e409Sopenharmony_ci    unsigned int r;
369750e409Sopenharmony_ci    if (result != 0)
379750e409Sopenharmony_ci        return result;
389750e409Sopenharmony_ci
399750e409Sopenharmony_ci    for (r = 0; r < UnityFixture.RepeatCount; r++)
409750e409Sopenharmony_ci    {
419750e409Sopenharmony_ci        UnityBegin(argv[0]);
429750e409Sopenharmony_ci        announceTestRun(r);
439750e409Sopenharmony_ci        runAllTests();
449750e409Sopenharmony_ci        if (!UnityFixture.Verbose) UNITY_PRINT_EOL();
459750e409Sopenharmony_ci        UnityEnd();
469750e409Sopenharmony_ci    }
479750e409Sopenharmony_ci
489750e409Sopenharmony_ci    return (int)Unity.TestFailures;
499750e409Sopenharmony_ci}
509750e409Sopenharmony_ci
519750e409Sopenharmony_cistatic int selected(const char* filter, const char* name)
529750e409Sopenharmony_ci{
539750e409Sopenharmony_ci    if (filter == 0)
549750e409Sopenharmony_ci        return 1;
559750e409Sopenharmony_ci    return strstr(name, filter) ? 1 : 0;
569750e409Sopenharmony_ci}
579750e409Sopenharmony_ci
589750e409Sopenharmony_cistatic int testSelected(const char* test)
599750e409Sopenharmony_ci{
609750e409Sopenharmony_ci    return selected(UnityFixture.NameFilter, test);
619750e409Sopenharmony_ci}
629750e409Sopenharmony_ci
639750e409Sopenharmony_cistatic int groupSelected(const char* group)
649750e409Sopenharmony_ci{
659750e409Sopenharmony_ci    return selected(UnityFixture.GroupFilter, group);
669750e409Sopenharmony_ci}
679750e409Sopenharmony_ci
689750e409Sopenharmony_civoid UnityTestRunner(unityfunction* setup,
699750e409Sopenharmony_ci                     unityfunction* testBody,
709750e409Sopenharmony_ci                     unityfunction* teardown,
719750e409Sopenharmony_ci                     const char* printableName,
729750e409Sopenharmony_ci                     const char* group,
739750e409Sopenharmony_ci                     const char* name,
749750e409Sopenharmony_ci                     const char* file,
759750e409Sopenharmony_ci                     unsigned int line)
769750e409Sopenharmony_ci{
779750e409Sopenharmony_ci    if (testSelected(name) && groupSelected(group))
789750e409Sopenharmony_ci    {
799750e409Sopenharmony_ci        Unity.TestFile = file;
809750e409Sopenharmony_ci        Unity.CurrentTestName = printableName;
819750e409Sopenharmony_ci        Unity.CurrentTestLineNumber = line;
829750e409Sopenharmony_ci        if (!UnityFixture.Verbose)
839750e409Sopenharmony_ci            UNITY_OUTPUT_CHAR('.');
849750e409Sopenharmony_ci        else
859750e409Sopenharmony_ci        {
869750e409Sopenharmony_ci            UnityPrint(printableName);
879750e409Sopenharmony_ci        #ifndef UNITY_REPEAT_TEST_NAME
889750e409Sopenharmony_ci            Unity.CurrentTestName = NULL;
899750e409Sopenharmony_ci        #endif
909750e409Sopenharmony_ci        }
919750e409Sopenharmony_ci
929750e409Sopenharmony_ci        Unity.NumberOfTests++;
939750e409Sopenharmony_ci        UnityMalloc_StartTest();
949750e409Sopenharmony_ci        UnityPointer_Init();
959750e409Sopenharmony_ci
969750e409Sopenharmony_ci        if (TEST_PROTECT())
979750e409Sopenharmony_ci        {
989750e409Sopenharmony_ci            setup();
999750e409Sopenharmony_ci            testBody();
1009750e409Sopenharmony_ci        }
1019750e409Sopenharmony_ci        if (TEST_PROTECT())
1029750e409Sopenharmony_ci        {
1039750e409Sopenharmony_ci            teardown();
1049750e409Sopenharmony_ci        }
1059750e409Sopenharmony_ci        if (TEST_PROTECT())
1069750e409Sopenharmony_ci        {
1079750e409Sopenharmony_ci            UnityPointer_UndoAllSets();
1089750e409Sopenharmony_ci            if (!Unity.CurrentTestFailed)
1099750e409Sopenharmony_ci                UnityMalloc_EndTest();
1109750e409Sopenharmony_ci        }
1119750e409Sopenharmony_ci        UnityConcludeFixtureTest();
1129750e409Sopenharmony_ci    }
1139750e409Sopenharmony_ci}
1149750e409Sopenharmony_ci
1159750e409Sopenharmony_civoid UnityIgnoreTest(const char* printableName, const char* group, const char* name)
1169750e409Sopenharmony_ci{
1179750e409Sopenharmony_ci    if (testSelected(name) && groupSelected(group))
1189750e409Sopenharmony_ci    {
1199750e409Sopenharmony_ci        Unity.NumberOfTests++;
1209750e409Sopenharmony_ci        Unity.TestIgnores++;
1219750e409Sopenharmony_ci        if (!UnityFixture.Verbose)
1229750e409Sopenharmony_ci            UNITY_OUTPUT_CHAR('!');
1239750e409Sopenharmony_ci        else
1249750e409Sopenharmony_ci        {
1259750e409Sopenharmony_ci            UnityPrint(printableName);
1269750e409Sopenharmony_ci            UNITY_PRINT_EOL();
1279750e409Sopenharmony_ci        }
1289750e409Sopenharmony_ci    }
1299750e409Sopenharmony_ci}
1309750e409Sopenharmony_ci
1319750e409Sopenharmony_ci
1329750e409Sopenharmony_ci/*------------------------------------------------- */
1339750e409Sopenharmony_ci/* Malloc and free stuff */
1349750e409Sopenharmony_ci#define MALLOC_DONT_FAIL -1
1359750e409Sopenharmony_cistatic int malloc_count;
1369750e409Sopenharmony_cistatic int malloc_fail_countdown = MALLOC_DONT_FAIL;
1379750e409Sopenharmony_ci
1389750e409Sopenharmony_civoid UnityMalloc_StartTest(void)
1399750e409Sopenharmony_ci{
1409750e409Sopenharmony_ci    malloc_count = 0;
1419750e409Sopenharmony_ci    malloc_fail_countdown = MALLOC_DONT_FAIL;
1429750e409Sopenharmony_ci}
1439750e409Sopenharmony_ci
1449750e409Sopenharmony_civoid UnityMalloc_EndTest(void)
1459750e409Sopenharmony_ci{
1469750e409Sopenharmony_ci    malloc_fail_countdown = MALLOC_DONT_FAIL;
1479750e409Sopenharmony_ci    if (malloc_count != 0)
1489750e409Sopenharmony_ci    {
1499750e409Sopenharmony_ci        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "This test leaks!");
1509750e409Sopenharmony_ci    }
1519750e409Sopenharmony_ci}
1529750e409Sopenharmony_ci
1539750e409Sopenharmony_civoid UnityMalloc_MakeMallocFailAfterCount(int countdown)
1549750e409Sopenharmony_ci{
1559750e409Sopenharmony_ci    malloc_fail_countdown = countdown;
1569750e409Sopenharmony_ci}
1579750e409Sopenharmony_ci
1589750e409Sopenharmony_ci/* These definitions are always included from unity_fixture_malloc_overrides.h */
1599750e409Sopenharmony_ci/* We undef to use them or avoid conflict with <stdlib.h> per the C standard */
1609750e409Sopenharmony_ci#undef malloc
1619750e409Sopenharmony_ci#undef free
1629750e409Sopenharmony_ci#undef calloc
1639750e409Sopenharmony_ci#undef realloc
1649750e409Sopenharmony_ci
1659750e409Sopenharmony_ci#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
1669750e409Sopenharmony_cistatic unsigned char unity_heap[UNITY_INTERNAL_HEAP_SIZE_BYTES];
1679750e409Sopenharmony_cistatic size_t heap_index;
1689750e409Sopenharmony_ci#else
1699750e409Sopenharmony_ci#include <stdlib.h>
1709750e409Sopenharmony_ci#endif
1719750e409Sopenharmony_ci
1729750e409Sopenharmony_citypedef struct GuardBytes
1739750e409Sopenharmony_ci{
1749750e409Sopenharmony_ci    size_t size;
1759750e409Sopenharmony_ci    size_t guard_space;
1769750e409Sopenharmony_ci} Guard;
1779750e409Sopenharmony_ci
1789750e409Sopenharmony_ci
1799750e409Sopenharmony_cistatic const char end[] = "END";
1809750e409Sopenharmony_ci
1819750e409Sopenharmony_civoid* unity_malloc(size_t size)
1829750e409Sopenharmony_ci{
1839750e409Sopenharmony_ci    char* mem;
1849750e409Sopenharmony_ci    Guard* guard;
1859750e409Sopenharmony_ci    size_t total_size = size + sizeof(Guard) + sizeof(end);
1869750e409Sopenharmony_ci
1879750e409Sopenharmony_ci    if (malloc_fail_countdown != MALLOC_DONT_FAIL)
1889750e409Sopenharmony_ci    {
1899750e409Sopenharmony_ci        if (malloc_fail_countdown == 0)
1909750e409Sopenharmony_ci            return NULL;
1919750e409Sopenharmony_ci        malloc_fail_countdown--;
1929750e409Sopenharmony_ci    }
1939750e409Sopenharmony_ci
1949750e409Sopenharmony_ci    if (size == 0) return NULL;
1959750e409Sopenharmony_ci#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
1969750e409Sopenharmony_ci    if (heap_index + total_size > UNITY_INTERNAL_HEAP_SIZE_BYTES)
1979750e409Sopenharmony_ci    {
1989750e409Sopenharmony_ci        guard = NULL;
1999750e409Sopenharmony_ci    }
2009750e409Sopenharmony_ci    else
2019750e409Sopenharmony_ci    {
2029750e409Sopenharmony_ci        guard = (Guard*)&unity_heap[heap_index];
2039750e409Sopenharmony_ci        heap_index += total_size;
2049750e409Sopenharmony_ci    }
2059750e409Sopenharmony_ci#else
2069750e409Sopenharmony_ci    guard = (Guard*)UNITY_FIXTURE_MALLOC(total_size);
2079750e409Sopenharmony_ci#endif
2089750e409Sopenharmony_ci    if (guard == NULL) return NULL;
2099750e409Sopenharmony_ci    malloc_count++;
2109750e409Sopenharmony_ci    guard->size = size;
2119750e409Sopenharmony_ci    guard->guard_space = 0;
2129750e409Sopenharmony_ci    mem = (char*)&(guard[1]);
2139750e409Sopenharmony_ci    memcpy(&mem[size], end, sizeof(end));
2149750e409Sopenharmony_ci
2159750e409Sopenharmony_ci    return (void*)mem;
2169750e409Sopenharmony_ci}
2179750e409Sopenharmony_ci
2189750e409Sopenharmony_cistatic int isOverrun(void* mem)
2199750e409Sopenharmony_ci{
2209750e409Sopenharmony_ci    Guard* guard = (Guard*)mem;
2219750e409Sopenharmony_ci    char* memAsChar = (char*)mem;
2229750e409Sopenharmony_ci    guard--;
2239750e409Sopenharmony_ci
2249750e409Sopenharmony_ci    return guard->guard_space != 0 || strcmp(&memAsChar[guard->size], end) != 0;
2259750e409Sopenharmony_ci}
2269750e409Sopenharmony_ci
2279750e409Sopenharmony_cistatic void release_memory(void* mem)
2289750e409Sopenharmony_ci{
2299750e409Sopenharmony_ci    Guard* guard = (Guard*)mem;
2309750e409Sopenharmony_ci    guard--;
2319750e409Sopenharmony_ci
2329750e409Sopenharmony_ci    malloc_count--;
2339750e409Sopenharmony_ci#ifdef UNITY_EXCLUDE_STDLIB_MALLOC
2349750e409Sopenharmony_ci    if (mem == unity_heap + heap_index - guard->size - sizeof(end))
2359750e409Sopenharmony_ci    {
2369750e409Sopenharmony_ci        heap_index -= (guard->size + sizeof(Guard) + sizeof(end));
2379750e409Sopenharmony_ci    }
2389750e409Sopenharmony_ci#else
2399750e409Sopenharmony_ci    UNITY_FIXTURE_FREE(guard);
2409750e409Sopenharmony_ci#endif
2419750e409Sopenharmony_ci}
2429750e409Sopenharmony_ci
2439750e409Sopenharmony_civoid unity_free(void* mem)
2449750e409Sopenharmony_ci{
2459750e409Sopenharmony_ci    int overrun;
2469750e409Sopenharmony_ci
2479750e409Sopenharmony_ci    if (mem == NULL)
2489750e409Sopenharmony_ci    {
2499750e409Sopenharmony_ci        return;
2509750e409Sopenharmony_ci    }
2519750e409Sopenharmony_ci
2529750e409Sopenharmony_ci    overrun = isOverrun(mem);
2539750e409Sopenharmony_ci    release_memory(mem);
2549750e409Sopenharmony_ci    if (overrun)
2559750e409Sopenharmony_ci    {
2569750e409Sopenharmony_ci        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during free()");
2579750e409Sopenharmony_ci    }
2589750e409Sopenharmony_ci}
2599750e409Sopenharmony_ci
2609750e409Sopenharmony_civoid* unity_calloc(size_t num, size_t size)
2619750e409Sopenharmony_ci{
2629750e409Sopenharmony_ci    void* mem = unity_malloc(num * size);
2639750e409Sopenharmony_ci    if (mem == NULL) return NULL;
2649750e409Sopenharmony_ci    memset(mem, 0, num * size);
2659750e409Sopenharmony_ci    return mem;
2669750e409Sopenharmony_ci}
2679750e409Sopenharmony_ci
2689750e409Sopenharmony_civoid* unity_realloc(void* oldMem, size_t size)
2699750e409Sopenharmony_ci{
2709750e409Sopenharmony_ci    Guard* guard = (Guard*)oldMem;
2719750e409Sopenharmony_ci    void* newMem;
2729750e409Sopenharmony_ci
2739750e409Sopenharmony_ci    if (oldMem == NULL) return unity_malloc(size);
2749750e409Sopenharmony_ci
2759750e409Sopenharmony_ci    guard--;
2769750e409Sopenharmony_ci    if (isOverrun(oldMem))
2779750e409Sopenharmony_ci    {
2789750e409Sopenharmony_ci        release_memory(oldMem);
2799750e409Sopenharmony_ci        UNITY_TEST_FAIL(Unity.CurrentTestLineNumber, "Buffer overrun detected during realloc()");
2809750e409Sopenharmony_ci    }
2819750e409Sopenharmony_ci
2829750e409Sopenharmony_ci    if (size == 0)
2839750e409Sopenharmony_ci    {
2849750e409Sopenharmony_ci        release_memory(oldMem);
2859750e409Sopenharmony_ci        return NULL;
2869750e409Sopenharmony_ci    }
2879750e409Sopenharmony_ci
2889750e409Sopenharmony_ci    if (guard->size >= size) return oldMem;
2899750e409Sopenharmony_ci
2909750e409Sopenharmony_ci#ifdef UNITY_EXCLUDE_STDLIB_MALLOC /* Optimization if memory is expandable */
2919750e409Sopenharmony_ci    if (oldMem == unity_heap + heap_index - guard->size - sizeof(end) &&
2929750e409Sopenharmony_ci        heap_index + size - guard->size <= UNITY_INTERNAL_HEAP_SIZE_BYTES)
2939750e409Sopenharmony_ci    {
2949750e409Sopenharmony_ci        release_memory(oldMem);    /* Not thread-safe, like unity_heap generally */
2959750e409Sopenharmony_ci        return unity_malloc(size); /* No memcpy since data is in place */
2969750e409Sopenharmony_ci    }
2979750e409Sopenharmony_ci#endif
2989750e409Sopenharmony_ci    newMem = unity_malloc(size);
2999750e409Sopenharmony_ci    if (newMem == NULL) return NULL; /* Do not release old memory */
3009750e409Sopenharmony_ci    memcpy(newMem, oldMem, guard->size);
3019750e409Sopenharmony_ci    release_memory(oldMem);
3029750e409Sopenharmony_ci    return newMem;
3039750e409Sopenharmony_ci}
3049750e409Sopenharmony_ci
3059750e409Sopenharmony_ci
3069750e409Sopenharmony_ci/*-------------------------------------------------------- */
3079750e409Sopenharmony_ci/*Automatic pointer restoration functions */
3089750e409Sopenharmony_cistruct PointerPair
3099750e409Sopenharmony_ci{
3109750e409Sopenharmony_ci    void** pointer;
3119750e409Sopenharmony_ci    void* old_value;
3129750e409Sopenharmony_ci};
3139750e409Sopenharmony_ci
3149750e409Sopenharmony_cistatic struct PointerPair pointer_store[UNITY_MAX_POINTERS];
3159750e409Sopenharmony_cistatic int pointer_index = 0;
3169750e409Sopenharmony_ci
3179750e409Sopenharmony_civoid UnityPointer_Init(void)
3189750e409Sopenharmony_ci{
3199750e409Sopenharmony_ci    pointer_index = 0;
3209750e409Sopenharmony_ci}
3219750e409Sopenharmony_ci
3229750e409Sopenharmony_civoid UnityPointer_Set(void** pointer, void* newValue, UNITY_LINE_TYPE line)
3239750e409Sopenharmony_ci{
3249750e409Sopenharmony_ci    if (pointer_index >= UNITY_MAX_POINTERS)
3259750e409Sopenharmony_ci    {
3269750e409Sopenharmony_ci        UNITY_TEST_FAIL(line, "Too many pointers set");
3279750e409Sopenharmony_ci    }
3289750e409Sopenharmony_ci    else
3299750e409Sopenharmony_ci    {
3309750e409Sopenharmony_ci        pointer_store[pointer_index].pointer = pointer;
3319750e409Sopenharmony_ci        pointer_store[pointer_index].old_value = *pointer;
3329750e409Sopenharmony_ci        *pointer = newValue;
3339750e409Sopenharmony_ci        pointer_index++;
3349750e409Sopenharmony_ci    }
3359750e409Sopenharmony_ci}
3369750e409Sopenharmony_ci
3379750e409Sopenharmony_civoid UnityPointer_UndoAllSets(void)
3389750e409Sopenharmony_ci{
3399750e409Sopenharmony_ci    while (pointer_index > 0)
3409750e409Sopenharmony_ci    {
3419750e409Sopenharmony_ci        pointer_index--;
3429750e409Sopenharmony_ci        *(pointer_store[pointer_index].pointer) =
3439750e409Sopenharmony_ci            pointer_store[pointer_index].old_value;
3449750e409Sopenharmony_ci    }
3459750e409Sopenharmony_ci}
3469750e409Sopenharmony_ci
3479750e409Sopenharmony_ciint UnityGetCommandLineOptions(int argc, const char* argv[])
3489750e409Sopenharmony_ci{
3499750e409Sopenharmony_ci    int i;
3509750e409Sopenharmony_ci    UnityFixture.Verbose = 0;
3519750e409Sopenharmony_ci    UnityFixture.GroupFilter = 0;
3529750e409Sopenharmony_ci    UnityFixture.NameFilter = 0;
3539750e409Sopenharmony_ci    UnityFixture.RepeatCount = 1;
3549750e409Sopenharmony_ci
3559750e409Sopenharmony_ci    if (argc == 1)
3569750e409Sopenharmony_ci        return 0;
3579750e409Sopenharmony_ci
3589750e409Sopenharmony_ci    for (i = 1; i < argc; )
3599750e409Sopenharmony_ci    {
3609750e409Sopenharmony_ci        if (strcmp(argv[i], "-v") == 0)
3619750e409Sopenharmony_ci        {
3629750e409Sopenharmony_ci            UnityFixture.Verbose = 1;
3639750e409Sopenharmony_ci            i++;
3649750e409Sopenharmony_ci        }
3659750e409Sopenharmony_ci        else if (strcmp(argv[i], "-g") == 0)
3669750e409Sopenharmony_ci        {
3679750e409Sopenharmony_ci            i++;
3689750e409Sopenharmony_ci            if (i >= argc)
3699750e409Sopenharmony_ci                return 1;
3709750e409Sopenharmony_ci            UnityFixture.GroupFilter = argv[i];
3719750e409Sopenharmony_ci            i++;
3729750e409Sopenharmony_ci        }
3739750e409Sopenharmony_ci        else if (strcmp(argv[i], "-n") == 0)
3749750e409Sopenharmony_ci        {
3759750e409Sopenharmony_ci            i++;
3769750e409Sopenharmony_ci            if (i >= argc)
3779750e409Sopenharmony_ci                return 1;
3789750e409Sopenharmony_ci            UnityFixture.NameFilter = argv[i];
3799750e409Sopenharmony_ci            i++;
3809750e409Sopenharmony_ci        }
3819750e409Sopenharmony_ci        else if (strcmp(argv[i], "-r") == 0)
3829750e409Sopenharmony_ci        {
3839750e409Sopenharmony_ci            UnityFixture.RepeatCount = 2;
3849750e409Sopenharmony_ci            i++;
3859750e409Sopenharmony_ci            if (i < argc)
3869750e409Sopenharmony_ci            {
3879750e409Sopenharmony_ci                if (*(argv[i]) >= '0' && *(argv[i]) <= '9')
3889750e409Sopenharmony_ci                {
3899750e409Sopenharmony_ci                    unsigned int digit = 0;
3909750e409Sopenharmony_ci                    UnityFixture.RepeatCount = 0;
3919750e409Sopenharmony_ci                    while (argv[i][digit] >= '0' && argv[i][digit] <= '9')
3929750e409Sopenharmony_ci                    {
3939750e409Sopenharmony_ci                        UnityFixture.RepeatCount *= 10;
3949750e409Sopenharmony_ci                        UnityFixture.RepeatCount += (unsigned int)argv[i][digit++] - '0';
3959750e409Sopenharmony_ci                    }
3969750e409Sopenharmony_ci                    i++;
3979750e409Sopenharmony_ci                }
3989750e409Sopenharmony_ci            }
3999750e409Sopenharmony_ci        }
4009750e409Sopenharmony_ci        else
4019750e409Sopenharmony_ci        {
4029750e409Sopenharmony_ci            /* ignore unknown parameter */
4039750e409Sopenharmony_ci            i++;
4049750e409Sopenharmony_ci        }
4059750e409Sopenharmony_ci    }
4069750e409Sopenharmony_ci    return 0;
4079750e409Sopenharmony_ci}
4089750e409Sopenharmony_ci
4099750e409Sopenharmony_civoid UnityConcludeFixtureTest(void)
4109750e409Sopenharmony_ci{
4119750e409Sopenharmony_ci    if (Unity.CurrentTestIgnored)
4129750e409Sopenharmony_ci    {
4139750e409Sopenharmony_ci        Unity.TestIgnores++;
4149750e409Sopenharmony_ci        UNITY_PRINT_EOL();
4159750e409Sopenharmony_ci    }
4169750e409Sopenharmony_ci    else if (!Unity.CurrentTestFailed)
4179750e409Sopenharmony_ci    {
4189750e409Sopenharmony_ci        if (UnityFixture.Verbose)
4199750e409Sopenharmony_ci        {
4209750e409Sopenharmony_ci            UnityPrint(" PASS");
4219750e409Sopenharmony_ci            UNITY_PRINT_EOL();
4229750e409Sopenharmony_ci        }
4239750e409Sopenharmony_ci    }
4249750e409Sopenharmony_ci    else /* Unity.CurrentTestFailed */
4259750e409Sopenharmony_ci    {
4269750e409Sopenharmony_ci        Unity.TestFailures++;
4279750e409Sopenharmony_ci        UNITY_PRINT_EOL();
4289750e409Sopenharmony_ci    }
4299750e409Sopenharmony_ci
4309750e409Sopenharmony_ci    Unity.CurrentTestFailed = 0;
4319750e409Sopenharmony_ci    Unity.CurrentTestIgnored = 0;
4329750e409Sopenharmony_ci}
433