VirtualBox

Changeset 19953 in vbox for trunk/src/VBox/Runtime/testcase


Ignore:
Timestamp:
May 23, 2009 11:59:06 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
47655
Message:

tstCritSect: Converted to RTTest and disable the distribution test by default (as it's busted for ages).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/testcase/tstCritSect.cpp

    r14831 r19953  
    55
    66/*
    7  * Copyright (C) 2006-2007 Sun Microsystems, Inc.
     7 * Copyright (C) 2006-2009 Sun Microsystems, Inc.
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2929 */
    3030
    31 
    3231/*******************************************************************************
    3332*   Header Files                                                               *
    … …  
    3736#endif
    3837#include <iprt/critsect.h>
     38
     39#include <iprt/asm.h>
     40#include <iprt/assert.h>
     41#include <iprt/ctype.h>
     42#include <iprt/err.h>
     43#include <iprt/initterm.h>
     44#include <iprt/getopt.h>
    3945#include <iprt/lock.h>
     46#include <iprt/log.h>
     47#include <iprt/mem.h>
     48#include <iprt/semaphore.h>
     49#include <iprt/string.h>
     50#include <iprt/test.h>
     51#include <iprt/time.h>
    4052#include <iprt/thread.h>
    41 #include <iprt/log.h>
    42 #include <iprt/semaphore.h>
    43 #include <iprt/asm.h>
    44 #include <iprt/initterm.h>
    45 #include <iprt/time.h>
    46 #include <iprt/assert.h>
    47 #include <iprt/string.h>
    48 #include <iprt/err.h>
    49 
    50 #include <stdio.h>
    51 #include <stdlib.h>
     53
    5254
    5355#ifndef TRY_WIN32_CRIT
    54 #define LOCKERS(sect)   ((sect).cLockers)
    55 #else
     56# define LOCKERS(sect)   ((sect).cLockers)
     57#else /* TRY_WIN32_CRIT */
     58
    5659/* This is for comparing with the "real thing". */
    5760#define RTCRITSECT      CRITICAL_SECTION
    … …  
    5962#define LOCKERS(sect)   (*(LONG volatile *)&(sect).LockCount)
    6063
    61 inline int RTCritSectInit(PCRITICAL_SECTION pCritSect)
     64DECLINLINE(int) RTCritSectInit(PCRITICAL_SECTION pCritSect)
    6265{
    6366    InitializeCriticalSection(pCritSect);
    … …  
    6669
    6770#undef RTCritSectEnter
    68 inline int RTCritSectEnter(PCRITICAL_SECTION pCritSect)
     71DECLINLINE(int) RTCritSectEnter(PCRITICAL_SECTION pCritSect)
    6972{
    7073    EnterCriticalSection(pCritSect);
    … …  
    7275}
    7376
    74 inline int RTCritSectLeave(PCRITICAL_SECTION pCritSect)
     77DECLINLINE(int) RTCritSectLeave(PCRITICAL_SECTION pCritSect)
    7578{
    7679    LeaveCriticalSection(pCritSect);
    … …  
    7881}
    7982
    80 inline int RTCritSectDelete(PCRITICAL_SECTION pCritSect)
     83DECLINLINE(int) RTCritSectDelete(PCRITICAL_SECTION pCritSect)
    8184{
    8285    DeleteCriticalSection(pCritSect);
    8386    return VINF_SUCCESS;
    8487}
    85 #endif
     88
     89#endif /* TRY_WIN32_CRIT */
     90
    8691
    8792/*******************************************************************************
    … …  
    139144*   Global Variables                                                           *
    140145*******************************************************************************/
    141 /** Error counter. */
    142 static volatile uint32_t g_cErrors = 0;
     146/** The test handle. */
     147static RTTEST g_hTest;
     148
     149
    143150
    144151/**
    145152 * Thread which goes to sleep on the critsect and checks that it's released in the right order.
    146153 */
    147 static DECLCALLBACK(int) ThreadTest1(RTTHREAD ThreadSelf, void *pvArg)
    148 {
    149     PTHREADTEST1ARGS pArgs = (PTHREADTEST1ARGS)pvArg;
    150     Log2(("ThreadTest1: Start - iThread=%d ThreadSelf=%p\n", pArgs->iThread, ThreadSelf));
     154static DECLCALLBACK(int) ThreadTest1(RTTHREAD ThreadSelf, void *pvArgs)
     155{
     156    THREADTEST1ARGS Args = *(PTHREADTEST1ARGS)pvArgs;
     157    Log2(("ThreadTest1: Start - iThread=%d ThreadSelf=%p\n", Args.iThread, ThreadSelf));
     158    RTMemFree(pvArgs);
    151159
    152160    /*
    153161     * Enter it.
    154162     */
    155     int rc = RTCritSectEnter(pArgs->pCritSect);
     163    int rc = RTCritSectEnter(Args.pCritSect);
    156164    if (RT_FAILURE(rc))
    157165    {
    158         printf("tstCritSect: FATAL FAILURE - thread %d: RTCritSectEnter -> %d\n", pArgs->iThread, rc);
    159         ASMAtomicIncU32(&g_cErrors);
    160         exit(g_cErrors);
     166        RTTestFailed(g_hTest, "thread %d: RTCritSectEnter -> %Rrc", Args.iThread, rc);
    161167        return 1;
    162168    }
    … …  
    165171     * Check release order.
    166172     */
    167     if (*pArgs->pu32Release != pArgs->iThread)
    168     {
    169         printf("tstCritSect: FAILURE - thread %d: released as number %d\n", pArgs->iThread, *pArgs->pu32Release);
    170         ASMAtomicIncU32(&g_cErrors);
    171     }
    172     ASMAtomicIncU32(pArgs->pu32Release);
     173    if (*Args.pu32Release != Args.iThread)
     174        RTTestFailed(g_hTest, "thread %d: released as number %d", Args.iThread, *Args.pu32Release);
     175    ASMAtomicIncU32(Args.pu32Release);
    173176
    174177    /*
    175178     * Leave it.
    176179     */
    177     rc = RTCritSectLeave(pArgs->pCritSect);
     180    rc = RTCritSectLeave(Args.pCritSect);
    178181    if (RT_FAILURE(rc))
    179182    {
    180         printf("tstCritSect: FATAL FAILURE - thread %d: RTCritSectEnter -> %d\n", pArgs->iThread, rc);
    181         ASMAtomicIncU32(&g_cErrors);
    182         exit(g_cErrors);
     183        RTTestFailed(g_hTest, "thread %d: RTCritSectEnter -> %Rrc", Args.iThread, rc);
    183184        return 1;
    184185    }
    185186
    186     Log2(("ThreadTest1: End - iThread=%d ThreadSelf=%p\n", pArgs->iThread, ThreadSelf));
     187    Log2(("ThreadTest1: End - iThread=%d ThreadSelf=%p\n", Args.iThread, ThreadSelf));
    187188    return 0;
    188189}
    189190
    190191
    191 int Test1(unsigned cThreads)
    192 {
     192static int Test1(unsigned cThreads)
     193{
     194    RTTestSubF(g_hTest, "Test #1 with %u thread", cThreads);
     195
    193196    /*
    194197     * Create a critical section.
    195198     */
    196199    RTCRITSECT CritSect;
    197     int rc = RTCritSectInit(&CritSect);
    198     if (RT_FAILURE(rc))
    199     {
    200         printf("tstCritSect: FATAL FAILURE - RTCritSectInit -> %d\n", rc);
    201         return 1;
    202     }
     200    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectInit(&CritSect), VINF_SUCCESS, 1);
    203201
    204202    /*
    205203     * Enter, leave and enter again.
    206204     */
    207     rc = RTCritSectEnter(&CritSect);
    208     if (RT_FAILURE(rc))
    209     {
    210         printf("tstCritSect: FATAL FAILURE - RTCritSectEnter -> %d\n", rc);
    211         return 1;
    212     }
    213     rc = RTCritSectLeave(&CritSect);
    214     if (RT_FAILURE(rc))
    215     {
    216         printf("tstCritSect: FATAL FAILURE - RTCritSectLeave -> %d\n", rc);
    217         return 1;
    218     }
    219     rc = RTCritSectEnter(&CritSect);
    220     if (RT_FAILURE(rc))
    221     {
    222         printf("tstCritSect: FATAL FAILURE - RTCritSectEnter -> %d (2nd)\n", rc);
    223         return 1;
    224     }
     205    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
     206    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
     207    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
    225208
    226209    /*
    … …  
    230213    for (uint32_t iThread = 0; iThread < cThreads; iThread++)
    231214    {
    232         PTHREADTEST1ARGS pArgs = (PTHREADTEST1ARGS)calloc(sizeof(*pArgs), 1);
     215        PTHREADTEST1ARGS pArgs = (PTHREADTEST1ARGS)RTMemAllocZ(sizeof(*pArgs));
    233216        pArgs->iThread = iThread;
    234217        pArgs->pCritSect = &CritSect;
    235218        pArgs->pu32Release = &u32Release;
    236219        int32_t     iLock = LOCKERS(CritSect);
    237         char szThread[17];
    238         RTStrPrintf(szThread, sizeof(szThread), "T%d", iThread);
    239         RTTHREAD  Thread;
    240         rc = RTThreadCreate(&Thread, ThreadTest1, pArgs, 0, RTTHREADTYPE_DEFAULT, 0, szThread);
    241         if (RT_FAILURE(rc))
    242         {
    243             printf("tstCritSect: FATAL FAILURE - RTThreadCreate -> %d\n", rc);
    244             exit(1);
    245         }
     220        RTTHREAD    Thread;
     221        RTTEST_CHECK_RC_RET(g_hTest, RTThreadCreateF(&Thread, ThreadTest1, pArgs, 0, RTTHREADTYPE_DEFAULT, 0, "T%d", iThread), VINF_SUCCESS, 1);
     222
    246223        /* wait for it to get into waiting. */
    247224        while (LOCKERS(CritSect) == iLock)
    … …  
    254231     */
    255232    u32Release = 0;
    256     rc = RTCritSectLeave(&CritSect);
    257     if (RT_FAILURE(rc))
    258     {
    259         printf("tstCritSect: FATAL FAILURE - RTCritSectLeave -> %d (2nd)\n", rc);
    260         return 1;
    261     }
     233    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
    262234    while (u32Release < cThreads)
    263235        RTThreadSleep(10);
    264236
    265     rc = RTCritSectDelete(&CritSect);
    266     if (RT_FAILURE(rc))
    267     {
    268         printf("tstCritSect: FAILURE - RTCritSectDelete -> %d\n", rc);
    269         ASMAtomicIncU32(&g_cErrors);
    270     }
    271 
     237    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectDelete(&CritSect), VINF_SUCCESS, 1);
    272238    return 0;
    273239}
    … …  
    295261        if (RT_FAILURE(rc))
    296262        {
    297             printf("tstCritSect: FATAL FAILURE - Test 2 - thread %d, iteration %d: RTCritSectEnter -> %d\n", pArgs->iThread, i, rc);
    298             ASMAtomicIncU32(&g_cErrors);
    299             exit(g_cErrors);
     263            RTTestFailed(g_hTest, "thread %d, iteration %d: RTCritSectEnter -> %d", pArgs->iThread, i, rc);
    300264            return 1;
    301265        }
    … …  
    303267            u64TSStart = RTTimeNanoTS();
    304268
    305         #if 0 /* We just check for sequences. */
     269#if 0 /* We just check for sequences. */
    306270        /*
    307271         * Check release order.
    308272         */
    309273        if ((*pArgs->pu32Release % pArgs->cThreads) != pArgs->iThread)
    310         {
    311             printf("tstCritSect: FAILURE - Test 2 - thread %d, iteration %d: released as number %d (%d)\n",
    312                    pArgs->iThread, i, *pArgs->pu32Release % pArgs->cThreads, *pArgs->pu32Release);
    313             ASMAtomicIncU32(&g_cErrors);
    314         }
     274            RTTestFailed(g_hTest, "thread %d, iteration %d: released as number %d (%d)",
     275                         pArgs->iThread, i, *pArgs->pu32Release % pArgs->cThreads, *pArgs->pu32Release);
    315276        else
    316             printf("tstCritSect: SUCCESS - Test 2 - thread %d, iteration %d: released as number %d (%d)\n",
    317                    pArgs->iThread, i, *pArgs->pu32Release % pArgs->cThreads, *pArgs->pu32Release);
    318         #endif
     277            RTTestPrintf(g_hTest, RTTESTLVL_INFO, "iteration %d: released as number %d (%d)\n",
     278                         pArgs->iThread, i, *pArgs->pu32Release % pArgs->cThreads, *pArgs->pu32Release);
     279#endif
    319280        pArgs->cTimes++;
    320281        ASMAtomicIncU32(pArgs->pu32Release);
    … …  
    348309            if (*pArgs->pu32Alone != ~0U)
    349310            {
    350                 printf("tstCritSect: FATAL FAILURE - Test 2 - thread %d, iteration %d: not alone!!!\n", pArgs->iThread, i);
    351                 AssertReleaseMsgFailed(("Not alone!\n"));
    352                 ASMAtomicIncU32(&g_cErrors);
    353                 exit(g_cErrors);
     311                RTTestFailed(g_hTest, "thread %d, iteration %d: not alone!!!", pArgs->iThread, i);
     312                //AssertReleaseMsgFailed(("Not alone!\n"));
    354313                return 1;
    355314            }
    … …  
    360319            if (*pArgs->pu32Alone != pArgs->iThread)
    361320            {
    362                 printf("tstCritSect: FATAL FAILURE - Test 2 - thread %d, iteration %d: not alone!!!\n", pArgs->iThread, i);
    363                 AssertReleaseMsgFailed(("Not alone!\n"));
    364                 ASMAtomicIncU32(&g_cErrors);
    365                 exit(g_cErrors);
     321                RTTestFailed(g_hTest, "thread %d, iteration %d: not alone!!!", pArgs->iThread, i);
     322                //AssertReleaseMsgFailed(("Not alone!\n"));
    366323                return 1;
    367324            }
    … …  
    384341        if (RT_FAILURE(rc))
    385342        {
    386             printf("tstCritSect: FATAL FAILURE - Test 2 - thread %d, iteration %d: RTCritSectEnter -> %d\n", pArgs->iThread, i, rc);
    387             ASMAtomicIncU32(&g_cErrors);
    388             exit(g_cErrors);
     343            RTTestFailed(g_hTest, "thread %d, iteration %d: RTCritSectEnter -> %d", pArgs->iThread, i, rc);
    389344            return 1;
    390345        }
    … …  
    398353}
    399354
    400 int Test2(unsigned cThreads, unsigned cIterations, unsigned cCheckLoops)
    401 {
    402     printf("tstCritSect: Test2 - cThread=%d cIterations=%d cCheckLoops=%d...\n", cThreads, cIterations, cCheckLoops);
     355static int Test2(unsigned cThreads, unsigned cIterations, unsigned cCheckLoops)
     356{
     357    RTTestSubF(g_hTest, "Test #2 - cThreads=%u cIterations=%u cCheckLoops=%u", cThreads, cIterations, cCheckLoops);
    403358
    404359    /*
    … …  
    406361     */
    407362    RTCRITSECT CritSect;
    408     int rc = RTCritSectInit(&CritSect);
    409     if (RT_FAILURE(rc))
    410     {
    411         printf("tstCritSect: FATAL FAILURE - Test 2 - RTCritSectInit -> %d\n", rc);
    412         return 1;
    413     }
     363    int rc;
     364    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectInit(&CritSect), VINF_SUCCESS, 1);
    414365
    415366    /*
    416367     * Enter, leave and enter again.
    417368     */
    418     rc = RTCritSectEnter(&CritSect);
    419     if (RT_FAILURE(rc))
    420     {
    421         printf("tstCritSect: FATAL FAILURE - Test 2 - RTCritSectEnter -> %d\n", rc);
    422         return 1;
    423     }
    424     rc = RTCritSectLeave(&CritSect);
    425     if (RT_FAILURE(rc))
    426     {
    427         printf("tstCritSect: FATAL FAILURE - Test 2 - RTCritSectLeave -> %d\n", rc);
    428         return 1;
    429     }
    430     rc = RTCritSectEnter(&CritSect);
    431     if (RT_FAILURE(rc))
    432     {
    433         printf("tstCritSect: FATAL FAILURE - Test 2 - RTCritSectEnter -> %d (2nd)\n", rc);
    434         return 1;
    435     }
     369    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
     370    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
     371    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(&CritSect), VINF_SUCCESS, 1);
    436372
    437373    /*
    438374     * Now spawn threads which will go to sleep entering the critsect.
    439375     */
    440     PTHREADTEST2ARGS paArgs = (PTHREADTEST2ARGS)calloc(sizeof(THREADTEST2ARGS), cThreads);
    441     RTSEMEVENT    EventDone;
    442     rc = RTSemEventCreate(&EventDone);
     376    PTHREADTEST2ARGS paArgs = (PTHREADTEST2ARGS)RTMemAllocZ(sizeof(THREADTEST2ARGS) * cThreads);
     377    RTSEMEVENT       EventDone;
     378    RTTEST_CHECK_RC_RET(g_hTest, RTSemEventCreate(&EventDone), VINF_SUCCESS, 1);
    443379    uint32_t volatile   u32Release = 0;
    444380    uint32_t volatile   u32Alone = ~0;
    … …  
    470406        if (RT_FAILURE(rc))
    471407        {
    472             printf("tstCritSect: FATAL FAILURE - Test 2 - RTThreadCreate -> %d\n", rc);
    473             exit(1);
     408            RTTestFailed(g_hTest, "RTThreadCreate -> %d", rc);
     409            return 1;
    474410        }
    475411        /* wait for it to get into waiting. */
    … …  
    478414        RTThreadSleep(20);
    479415    }
    480     printf("tstCritSect: Test2 - threads created...\n");
     416    RTTestPrintf(g_hTest, RTTESTLVL_INFO, "threads created...\n");
    481417
    482418    /*
    … …  
    485421    u32Release = 0;
    486422    uint64_t u64TSStart = RTTimeNanoTS();
    487     rc = RTCritSectLeave(&CritSect);
    488     if (RT_FAILURE(rc))
    489     {
    490         printf("tstCritSect: FATAL FAILURE - RTCritSectLeave -> %d (2nd)\n", rc);
    491         return 1;
    492     }
     423    RTTEST_CHECK_RC_RET(g_hTest, RTCritSectLeave(&CritSect), VINF_SUCCESS, 1);
    493424
    494425    while (cThreadRunning > 0)
    … …  
    499430     * Clean up and report results.
    500431     */
    501     rc = RTCritSectDelete(&CritSect);
    502     if (RT_FAILURE(rc))
    503     {
    504         printf("tstCritSect: FAILURE - RTCritSectDelete -> %d\n", rc);
    505         ASMAtomicIncU32(&g_cErrors);
    506     }
     432    RTTEST_CHECK_RC(g_hTest, RTCritSectDelete(&CritSect), VINF_SUCCESS);
    507433
    508434    /* sequences */
    509435    if (cSeq > RT_MAX(u32Release / 10000, 1))
    510     {
    511         printf("tstCritSect: FAILURE - too many same thread sequences! cSeq=%d\n", cSeq);
    512         ASMAtomicIncU32(&g_cErrors);
    513     }
     436        RTTestFailed(g_hTest, "too many same thread sequences! cSeq=%d\n", cSeq);
    514437
    515438    /* distribution caused by sequences / reordering. */
    … …  
    520443        int cDiff = paArgs[iThread].cTimes - u32Perfect;
    521444        if ((unsigned)RT_ABS(cDiff) > RT_MAX(u32Perfect / 10000, 2))
    522         {
    523             printf("tstCritSect: FAILURE - bad distribution thread %d u32Perfect=%d cTimes=%d cDiff=%d\n",
    524                    iThread, u32Perfect, paArgs[iThread].cTimes, cDiff);
    525             ASMAtomicIncU32(&g_cErrors);
    526         }
     445            RTTestFailed(g_hTest, "bad distribution thread %d u32Perfect=%d cTimes=%d cDiff=%d\n",
     446                         iThread, u32Perfect, paArgs[iThread].cTimes, cDiff);
    527447        cDiffTotal += RT_ABS(cDiff);
    528448    }
    529449
    530450    uint32_t cMillies = (uint32_t)((u64TSEnd - u64TSStart) / 1000000);
    531     printf("tstCritSect: Test2 - DONE. %d enter+leave in %dms cSeq=%d cReordered=%d cDiffTotal=%d\n",
    532            u32Release, cMillies, cSeq, cReordered, cDiffTotal);
     451    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
     452                 "%d enter+leave in %dms cSeq=%d cReordered=%d cDiffTotal=%d\n",
     453                 u32Release, cMillies, cSeq, cReordered, cDiffTotal);
    533454    return 0;
    534455}
    535456
    536457
    537 int main(int argc, char *argv[])
    538 {
    539     printf("tstCritSect: TESTING\n");
    540 
     458int main(int argc, char **argv)
     459{
    541460    int rc = RTR3Init();
    542461    if (RT_FAILURE(rc))
    543     {
    544         printf("tstCritSect: FATAL FAILURE - RTR3Init -> %d\n", rc);
    545462        return 1;
    546     }
    547 
    548     printf("tstCritSect: Test1...\n");
    549     if (Test1(1))
     463    RTTEST hTest;
     464#ifndef TRY_WIN32_CRT
     465    rc = RTTestCreate("tstRTCritSect", &hTest);
     466#else
     467    rc = RTTestCreate("tstRTCritSectW32", &hTest);
     468#endif
     469    if (RT_FAILURE(rc))
    550470        return 1;
    551     if (Test1(3))
    552         return 1;
    553     if (Test1(10))
    554         return 1;
    555     if (Test1(63))
    556         return 1;
    557     if (Test2(1, 200000, 1000))
    558         return 1;
    559     if (Test2(2, 200000, 1000))
    560         return 1;
    561     if (Test2(3, 200000, 1000))
    562         return 1;
    563     if (Test2(4, 200000, 1000))
    564         return 1;
    565     if (Test2(5, 200000, 1000))
    566         return 1;
    567     if (Test2(7, 200000, 1000))
    568         return 1;
    569     if (Test2(67, 200000, 1000))
    570         return 1;
     471    g_hTest = hTest;
     472    RTTestBanner(hTest);
     473
     474    /* parse args. */
     475    static const RTGETOPTDEF s_aOptions[] =
     476    {
     477        { "--distribution", 'd', RTGETOPT_REQ_NOTHING },
     478        { "--help",         'h', RTGETOPT_REQ_NOTHING }
     479    };
     480
     481    bool fTestDistribution = false;
     482
     483    int ch;
     484    RTGETOPTUNION ValueUnion;
     485    RTGETOPTSTATE GetState;
     486    RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
     487    while ((ch = RTGetOpt(&GetState, &ValueUnion)))
     488    {
     489        switch (ch)
     490        {
     491            case 'd':
     492                fTestDistribution = true;
     493                break;
     494
     495            case 'h':
     496                RTTestIPrintf(RTTESTLVL_ALWAYS, "%s [--help|-h] [--distribution|-d]\n", argv[0]);
     497                return 1;
     498
     499            case VINF_GETOPT_NOT_OPTION:
     500                RTTestIFailed("%Rrs\n", ch);
     501                return RTTestSummaryAndDestroy(hTest);
     502
     503            default:
     504                if (ch > 0)
     505                {
     506                    if (RT_C_IS_GRAPH(ch))
     507                        RTTestIFailed("unhandled option: -%c\n", ch);
     508                    else
     509                        RTTestIFailed("unhandled option: %i\n", ch);
     510                }
     511                else if (ch == VERR_GETOPT_UNKNOWN_OPTION)
     512                    RTTestIFailed("unknown option: %s\n", ValueUnion.psz);
     513                else if (ValueUnion.pDef)
     514                    RTTestIFailed("%s: %Rrs\n", ValueUnion.pDef->pszLong, ch);
     515                else
     516                    RTTestIFailed("%Rrs\n", ch);
     517                return RTTestSummaryAndDestroy(hTest);
     518        }
     519    }
     520
     521
     522    /*
     523     * Perform the testing.
     524     */
     525    if (    !Test1(1)
     526        &&  !Test1(3)
     527        &&  !Test1(10)
     528        &&  !Test1(63))
     529    {
     530
     531        if (    fTestDistribution
     532            &&  !Test2(1, 200000, 1000)
     533            &&  !Test2(2, 200000, 1000)
     534            &&  !Test2(3, 200000, 1000)
     535            &&  !Test2(4, 200000, 1000)
     536            &&  !Test2(5, 200000, 1000)
     537            &&  !Test2(7, 200000, 1000)
     538            &&  !Test2(67, 200000, 1000))
     539        {
     540            /*nothing*/;
     541        }
     542    }
    571543
    572544    /*
    573545     * Summary.
    574546     */
    575     if (!g_cErrors)
    576         printf("tstCritSect: SUCCESS\n");
    577     else
    578         printf("tstCritSect: FAILURE - %d errors\n", g_cErrors);
    579 
    580     return !!g_cErrors;
    581 }
     547    return RTTestSummaryAndDestroy(hTest);
     548}
     549
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette