VirtualBox

Changeset 25514 in vbox for trunk


Ignore:
Timestamp:
Dec 20, 2009 2:43:55 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
56187
Message:

tstSemRW: Converted to RTTest and added basic API tests.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r20597 r25514  
    3333*******************************************************************************/
    3434#include <iprt/semaphore.h>
    35 #include <iprt/string.h>
    36 #include <iprt/thread.h>
    37 #include <iprt/stream.h>
    38 #include <iprt/time.h>
     35
     36#include <iprt/asm.h>
     37#include <iprt/assert.h>
     38#include <iprt/err.h>
    3939#include <iprt/initterm.h>
    4040#include <iprt/rand.h>
    41 #include <iprt/asm.h>
    42 #include <iprt/assert.h>
     41#include <iprt/string.h>
     42#include <iprt/stream.h>
     43#include <iprt/test.h>
     44#include <iprt/time.h>
     45#include <iprt/thread.h>
    4346
    4447
    … …  
    4649*   Global Variables                                                           *
    4750*******************************************************************************/
     51static RTTEST               g_hTest;
    4852static RTSEMRW              g_hSemRW = NIL_RTSEMRW;
    4953static bool volatile        g_fTerminate;
    … …  
    5155static bool                 g_fQuiet;
    5256static unsigned             g_uWritePercent;
    53 static uint32_t volatile    g_cbConcurrentWrite;
    54 static uint32_t volatile    g_cbConcurrentRead;
     57static uint32_t volatile    g_cConcurrentWriters;
     58static uint32_t volatile    g_cConcurrentReaders;
    5559static uint32_t volatile    g_cErrors;
    56 
    57 
    58 int PrintError(const char *pszFormat, ...)
    59 {
    60     ASMAtomicIncU32(&g_cErrors);
    61 
    62     RTPrintf("tstSemRW: FAILURE - ");
    63     va_list va;
    64     va_start(va, pszFormat);
    65     RTPrintfV(pszFormat, va);
    66     va_end(va);
    67 
    68     return 1;
    69 }
    7060
    7161
    … …  
    9585                if (RT_FAILURE(rc))
    9686                {
    97                     PrintError("%x: RTSemRWRequestWriteNoResume failed with %Rrc\n", rc);
     87                    RTTestFailed(g_hTest, "Write recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
    9888                    break;
    9989                }
    … …  
    10191            if (RT_FAILURE(rc))
    10292                break;
    103             if (ASMAtomicIncU32(&g_cbConcurrentWrite) != 1)
    104             {
    105                 PrintError("g_cbConcurrentWrite=%d after request!\n", g_cbConcurrentWrite);
    106                 break;
    107             }
    108             if (g_cbConcurrentRead != 0)
    109             {
    110                 PrintError("g_cbConcurrentRead=%d after request!\n", g_cbConcurrentRead);
     93            if (ASMAtomicIncU32(&g_cConcurrentWriters) != 1)
     94            {
     95                RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after write locking it",
     96                             g_cConcurrentWriters, RTThreadSelfName());
     97                break;
     98            }
     99            if (g_cConcurrentReaders != 0)
     100            {
     101                RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s after write locking it",
     102                             g_cConcurrentReaders, RTThreadSelfName());
    111103                break;
    112104            }
    … …  
    117109            if (RT_FAILURE(rc))
    118110            {
    119                 PrintError("%x: RTSemRWRequestReadNoResume failed with %Rrc\n", rc);
    120                 break;
    121             }
    122             ASMAtomicIncU32(&g_cbConcurrentRead);
    123             if (g_cbConcurrentWrite != 0)
    124             {
    125                 PrintError("g_cbConcurrentWrite=%d after request!\n", g_cbConcurrentWrite);
     111                RTTestFailed(g_hTest, "Read locking on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
     112                break;
     113            }
     114            ASMAtomicIncU32(&g_cConcurrentReaders);
     115            if (g_cConcurrentWriters != 0)
     116            {
     117                RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s after read locking it",
     118                             g_cConcurrentWriters, RTThreadSelfName());
    126119                break;
    127120            }
    … …  
    132125            if (RT_FAILURE(rc))
    133126            {
    134                 PrintError("%x: RTSemRWRequestReadNoResume failed with %Rrc\n", rc);
     127                RTTestFailed(g_hTest, "Read recursion %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
    135128                break;
    136129            }
    … …  
    156149            if (RT_FAILURE(rc))
    157150            {
    158                 PrintError("%x: RTSemRWReleaseRead failed with %Rrc\n", rc);
     151                RTTestFailed(g_hTest, "Read release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
    159152                break;
    160153            }
    … …  
    165158        if (fWrite)
    166159        {
    167             if (ASMAtomicDecU32(&g_cbConcurrentWrite) != 0)
    168             {
    169                 PrintError("g_cbConcurrentWrite=%d before release!\n", g_cbConcurrentWrite);
    170                 break;
    171             }
    172             if (g_cbConcurrentRead != 0)
    173             {
    174                 PrintError("g_cbConcurrentRead=%d before release!\n", g_cbConcurrentRead);
     160            if (ASMAtomicDecU32(&g_cConcurrentWriters) != 0)
     161            {
     162                RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before write release",
     163                             g_cConcurrentWriters, RTThreadSelfName());
     164                break;
     165            }
     166            if (g_cConcurrentReaders != 0)
     167            {
     168                RTTestFailed(g_hTest, "g_cConcurrentReaders=%u on %s before write release",
     169                             g_cConcurrentReaders, RTThreadSelfName());
    175170                break;
    176171            }
    … …  
    180175                if (RT_FAILURE(rc))
    181176                {
    182                     PrintError("%x: RTSemRWReleaseWrite failed with %Rrc\n", rc);
     177                    RTTestFailed(g_hTest, "Write release %u on %s failed with rc=%Rrc", i, RTThreadSelfName(), rc);
    183178                    break;
    184179                }
    … …  
    187182        else
    188183        {
    189             if (g_cbConcurrentWrite != 0)
    190             {
    191                 PrintError("g_cbConcurrentWrite=%d before release!\n", g_cbConcurrentWrite);
    192                 break;
    193             }
    194             ASMAtomicDecU32(&g_cbConcurrentRead);
     184            if (g_cConcurrentWriters != 0)
     185            {
     186                RTTestFailed(g_hTest, "g_cConcurrentWriters=%u on %s before read release",
     187                             g_cConcurrentWriters, RTThreadSelfName());
     188                break;
     189            }
     190            ASMAtomicDecU32(&g_cConcurrentReaders);
    195191            rc = RTSemRWReleaseRead(g_hSemRW);
    196192            if (RT_FAILURE(rc))
    197193            {
    198                 PrintError("%x: RTSemRWReleaseRead failed with %Rrc\n", rc);
     194                RTTestFailed(g_hTest, "Read release on %s failed with rc=%Rrc", RTThreadSelfName(), rc);
    199195                break;
    200196            }
    … …  
    208204    }
    209205    if (!g_fQuiet)
    210         RTPrintf("tstSemRW: Thread %08x exited with %lld\n", ThreadSelf, *pu64);
     206        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Thread %s exited with %lld\n", RTThreadSelfName(), *pu64);
    211207    return VINF_SUCCESS;
    212208}
    213209
    214210
    215 static int Test1(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
     211static void Test3(unsigned cThreads, unsigned cSeconds, unsigned uWritePercent, bool fYield, bool fQuiet)
    216212{
    217213    int rc;
    218214    unsigned i;
    219     uint64_t g_au64[32];
    220     RTTHREAD aThreads[RT_ELEMENTS(g_au64)];
    221     AssertRelease(cThreads <= RT_ELEMENTS(g_au64));
     215    uint64_t au64[32];
     216    RTTHREAD aThreads[RT_ELEMENTS(au64)];
     217    AssertRelease(cThreads <= RT_ELEMENTS(au64));
     218
     219    RTTestSubF(g_hTest, "Test3 - %u threads, %u sec, %u%% writes, %syielding",
     220               cThreads, cSeconds, uWritePercent, fYield ? "" : "non-");
    222221
    223222    /*
    … …  
    228227    g_fTerminate = false;
    229228    g_uWritePercent = uWritePercent;
    230     g_cbConcurrentWrite = 0;
    231     g_cbConcurrentRead = 0;
    232 
    233     rc = RTSemRWCreate(&g_hSemRW);
    234     if (RT_FAILURE(rc))
    235         return PrintError("RTSemRWCreate failed (rc=%Rrc)\n", rc);
     229    g_cConcurrentWriters = 0;
     230    g_cConcurrentReaders = 0;
     231
     232    RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWCreate(&g_hSemRW), VINF_SUCCESS);
    236233
    237234    /*
    238235     * Create the threads and let them block on the semrw.
    239236     */
    240     rc = RTSemRWRequestWrite(g_hSemRW, RT_INDEFINITE_WAIT);
    241     if (RT_FAILURE(rc))
    242         return PrintError("RTSemRWRequestWrite failed (rc=%Rrc)\n", rc);
     237    RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWRequestWrite(g_hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS);
    243238
    244239    for (i = 0; i < cThreads; i++)
    245240    {
    246         g_au64[i] = 0;
    247         rc = RTThreadCreate(&aThreads[i], ThreadTest1, &g_au64[i], 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test");
    248         if (RT_FAILURE(rc))
    249             return PrintError("RTThreadCreate failed for thread %u (rc=%Rrc)\n", i, rc);
    250     }
    251 
    252     if (!fQuiet)
    253         RTPrintf("tstSemRW: %zu Threads created. Racing them for %u seconds (%s) ...\n",
    254                  cThreads, cSeconds, g_fYield ? "yielding" : "no yielding");
    255 
     241        au64[i] = 0;
     242        RTTEST_CHECK_RC_RETV(g_hTest, RTThreadCreateF(&aThreads[i], ThreadTest1, &au64[i], 0,
     243                                                      RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
     244                                                      "test-%u", i), VINF_SUCCESS);
     245    }
     246
     247    /*
     248     * Do the test run.
     249     */
    256250    uint64_t u64StartTS = RTTimeNanoTS();
    257     rc = RTSemRWReleaseWrite(g_hSemRW);
    258     if (RT_FAILURE(rc))
    259         PrintError("RTSemRWReleaseWrite failed (rc=%Rrc)\n", rc);
     251    RTTEST_CHECK_RC(g_hTest, RTSemRWReleaseWrite(g_hSemRW), VINF_SUCCESS);
    260252    RTThreadSleep(cSeconds * 1000);
    261     ASMAtomicXchgBool(&g_fTerminate, true);
     253    ASMAtomicWriteBool(&g_fTerminate, true);
    262254    uint64_t ElapsedNS = RTTimeNanoTS() - u64StartTS;
    263255
     256    /*
     257     * Clean up the threads and semaphore.
     258     */
    264259    for (i = 0; i < cThreads; i++)
    265     {
    266         rc = RTThreadWait(aThreads[i], 5000, NULL);
    267         if (RT_FAILURE(rc))
    268             PrintError("RTThreadWait failed for thread %u (rc=%Rrc)\n", i, rc);
    269     }
    270 
    271     if (g_cbConcurrentWrite != 0)
    272         PrintError("g_cbConcurrentWrite=%d at end of test!\n", g_cbConcurrentWrite);
    273     if (g_cbConcurrentRead != 0)
    274         PrintError("g_cbConcurrentRead=%d at end of test!\n", g_cbConcurrentRead);
    275 
    276     rc = RTSemRWDestroy(g_hSemRW);
    277     if (RT_FAILURE(rc))
    278         PrintError("RTSemRWDestroy failed - %Rrc\n", rc);
     260        RTTEST_CHECK_RC(g_hTest, RTThreadWait(aThreads[i], 5000, NULL), VINF_SUCCESS);
     261
     262    RTTEST_CHECK_MSG(g_hTest, g_cConcurrentWriters == 0, (g_hTest, "g_cConcurrentWriters=%u at end of test\n", g_cConcurrentWriters));
     263    RTTEST_CHECK_MSG(g_hTest, g_cConcurrentReaders == 0, (g_hTest, "g_cConcurrentReaders=%u at end of test\n", g_cConcurrentReaders));
     264
     265    RTTEST_CHECK_RC(g_hTest, RTSemRWDestroy(g_hSemRW), VINF_SUCCESS);
    279266    g_hSemRW = NIL_RTSEMRW;
    280     if (g_cErrors)
    281         RTThreadSleep(100);
     267
     268//    if (g_cErrors)
     269//        RTThreadSleep(100);
    282270
    283271    /*
    284272     * Collect and display the results.
    285273     */
    286     uint64_t Total = g_au64[0];
     274    uint64_t Total = au64[0];
    287275    for (i = 1; i < cThreads; i++)
    288         Total += g_au64[i];
     276        Total += au64[i];
    289277
    290278    uint64_t Normal = Total / cThreads;
    … …  
    292280    for (i = 0; i < cThreads; i++)
    293281    {
    294         uint64_t Delta = RT_ABS((int64_t)(g_au64[i] - Normal));
     282        uint64_t Delta = RT_ABS((int64_t)(au64[i] - Normal));
    295283        if (Delta > Normal / 2)
    296             RTPrintf("tstSemRW: Warning! Thread %d deviates by more than 50%% - %llu (it) vs. %llu (avg)\n",
    297                      i, g_au64[i], Normal);
     284            RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
     285                         "Warning! Thread %u deviates by more than 50%% - %llu (it) vs. %llu (avg) - %llu%%\n",
     286                         i, au64[i], Normal, Delta * 100 / Normal);
    298287        if (Delta > MaxDeviation)
    299288            MaxDeviation = Delta;
    … …  
    301290    }
    302291
    303     RTPrintf("tstSemRW: Threads: %u  Total: %llu  Per Sec: %llu  Avg: %llu ns  Max dev: %llu%%\n",
    304              cThreads,
    305              Total,
    306              Total / cSeconds,
    307              ElapsedNS / Total,
    308              MaxDeviation * 100 / Normal
    309              );
    310     return 0;
    311 }
    312 
     292    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS,
     293                 "Threads: %u  Total: %llu  Per Sec: %llu  Avg: %llu ns  Max dev: %llu%%\n",
     294                 cThreads,
     295                 Total,
     296                 Total / cSeconds,
     297                 ElapsedNS / Total,
     298                 MaxDeviation * 100 / Normal
     299                 );
     300}
     301
     302
     303static DECLCALLBACK(int) Test2Thread(RTTHREAD hThreadSelf, void *pvUser)
     304{
     305    RTSEMRW hSemRW = (RTSEMRW)pvUser;
     306
     307    RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead(hSemRW, 0), VERR_TIMEOUT);
     308    RTTEST_CHECK_RC(g_hTest, RTSemRWRequestWrite(hSemRW, 0), VERR_TIMEOUT);
     309
     310    RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead(hSemRW, 1), VERR_TIMEOUT);
     311    RTTEST_CHECK_RC(g_hTest, RTSemRWRequestWrite(hSemRW, 1), VERR_TIMEOUT);
     312
     313    RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead(hSemRW, 50), VERR_TIMEOUT);
     314    RTTEST_CHECK_RC(g_hTest, RTSemRWRequestWrite(hSemRW, 50), VERR_TIMEOUT);
     315
     316    return VINF_SUCCESS;
     317}
     318
     319
     320static void Test2(void)
     321{
     322    RTTestSub(g_hTest, "Timeout");
     323
     324    RTSEMRW hSemRW = NIL_RTSEMRW;
     325    RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWCreate(&hSemRW), VINF_SUCCESS);
     326
     327    /* Lock it for writing and let the thread do the remainder of the test. */
     328    RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWRequestWrite(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS);
     329
     330    RTTHREAD hThread;
     331    RTTEST_CHECK_RC_RETV(g_hTest, RTThreadCreate(&hThread, Test2Thread, hSemRW, 0,
     332                                                 RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test2"),
     333                         VINF_SUCCESS);
     334    RTTEST_CHECK_RC(g_hTest, RTThreadWait(hThread, 15000, NULL), VINF_SUCCESS);
     335    RTTEST_CHECK_RC(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS);
     336
     337    RTTEST_CHECK_RC(g_hTest, RTSemRWDestroy(hSemRW), VINF_SUCCESS);
     338}
     339
     340
     341static bool Test1(void)
     342{
     343    RTTestSub(g_hTest, "Basics");
     344
     345    RTSEMRW hSemRW = NIL_RTSEMRW;
     346    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWCreate(&hSemRW), VINF_SUCCESS, false);
     347    RTTEST_CHECK_RET(g_hTest, hSemRW != NIL_RTSEMRW, false);
     348
     349    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
     350    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
     351
     352    for (unsigned cMs = 0; cMs < 50; cMs++)
     353    {
     354        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, cMs), VINF_SUCCESS, false);
     355        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, cMs), VINF_SUCCESS, false);
     356        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
     357        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
     358    }
     359
     360    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
     361    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
     362
     363    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
     364    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS, false);
     365    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
     366    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
     367
     368    for (unsigned cMs = 0; cMs < 50; cMs++)
     369    {
     370        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, cMs), VINF_SUCCESS, false);
     371        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 1, false);
     372        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
     373        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
     374
     375        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, cMs), VINF_SUCCESS, false);
     376        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
     377        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
     378        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
     379
     380        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestRead(hSemRW, cMs), VINF_SUCCESS, false);
     381        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
     382        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 1, false);
     383        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
     384
     385        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hSemRW, cMs), VINF_SUCCESS, false);
     386        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 3, false);
     387        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 1, false);
     388        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
     389
     390        /*  midway  */
     391
     392        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
     393        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
     394        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 1, false);
     395        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
     396
     397        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseRead(hSemRW), VINF_SUCCESS, false);
     398        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 2, false);
     399        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
     400        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
     401
     402        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
     403        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 1, false);
     404        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
     405        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == true, false);
     406
     407        RTTEST_CHECK_RC_RET(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS, false);
     408        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriteRecursion(hSemRW) == 0, false);
     409        RTTEST_CHECK_RET(g_hTest, RTSemRWGetWriterReadRecursion(hSemRW) == 0, false);
     410        RTTEST_CHECK_RET(g_hTest, RTSemRWIsWriteOwner(hSemRW) == false, false);
     411    }
     412
     413    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWDestroy(hSemRW), VINF_SUCCESS, false);
     414    RTTEST_CHECK_RC_RET(g_hTest, RTSemRWDestroy(NIL_RTSEMRW), VINF_SUCCESS, false);
     415    return true;
     416}
    313417
    314418int main(int argc, char **argv)
    315419{
    316     int rc = RTR3Init();
    317     if (RT_FAILURE(rc))
    318     {
    319         RTPrintf("tstSemRW: RTR3Init failed (rc=%Rrc)\n", rc);
     420    int rc = RTTestInitAndCreate("tstRTSemRW", &g_hTest);
     421    if (rc)
    320422        return 1;
    321     }
    322     RTPrintf("tstSemRW: TESTING...\n");
    323 
    324     if (argc == 1)
    325     {
    326         /*    threads, seconds, writePercent,  yield,  quiet */
    327         Test1(      1,       1,            0,   true,  false);
    328         Test1(      1,       1,            1,   true,  false);
    329         Test1(      1,       1,            5,   true,  false);
    330         Test1(      2,       1,            3,   true,  false);
    331         Test1(     10,       1,            5,   true,  false);
    332         Test1(     10,      10,           10,  false,  false);
    333 
    334         RTPrintf("tstSemRW: benchmarking...\n");
    335         for (unsigned cThreads = 1; cThreads < 32; cThreads++)
    336             Test1(cThreads,  2,            1,  false,   true);
    337 
    338         /** @todo add a testcase where some stuff times out. */
    339     }
    340     else
    341     {
    342         /*    threads, seconds, writePercent,  yield,  quiet */
    343         RTPrintf("tstSemRW: benchmarking...\n");
    344         Test1(      1,       3,            1,  false,   true);
    345         Test1(      1,       3,            1,  false,   true);
    346         Test1(      1,       3,            1,  false,   true);
    347         Test1(      2,       3,            1,  false,   true);
    348         Test1(      2,       3,            1,  false,   true);
    349         Test1(      2,       3,            1,  false,   true);
    350         Test1(      3,       3,            1,  false,   true);
    351         Test1(      3,       3,            1,  false,   true);
    352         Test1(      3,       3,            1,  false,   true);
    353     }
    354 
    355     if (!g_cErrors)
    356         RTPrintf("tstSemRW: SUCCESS\n");
    357     else
    358         RTPrintf("tstSemRW: FAILURE - %u errors\n", g_cErrors);
    359     return g_cErrors != 0;
    360 }
    361 
     423    RTTestBanner(g_hTest);
     424
     425    if (Test1())
     426    {
     427        if (argc == 1)
     428        {
     429            Test2();
     430
     431            /*    threads, seconds, writePercent,  yield,  quiet */
     432            Test3(      1,       1,            0,   true,  false);
     433            Test3(      1,       1,            1,   true,  false);
     434            Test3(      1,       1,            5,   true,  false);
     435            Test3(      2,       1,            3,   true,  false);
     436            Test3(     10,       1,            5,   true,  false);
     437            Test3(     10,      10,           10,  false,  false);
     438
     439            RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
     440            for (unsigned cThreads = 1; cThreads < 32; cThreads++)
     441                Test3(cThreads,  2,            1,  false,   true);
     442
     443            /** @todo add a testcase where some stuff times out. */
     444        }
     445        else
     446        {
     447            /*    threads, seconds, writePercent,  yield,  quiet */
     448            RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "benchmarking...\n");
     449            Test3(      1,       3,            1,  false,   true);
     450            Test3(      1,       3,            1,  false,   true);
     451            Test3(      1,       3,            1,  false,   true);
     452            Test3(      2,       3,            1,  false,   true);
     453            Test3(      2,       3,            1,  false,   true);
     454            Test3(      2,       3,            1,  false,   true);
     455            Test3(      3,       3,            1,  false,   true);
     456            Test3(      3,       3,            1,  false,   true);
     457            Test3(      3,       3,            1,  false,   true);
     458        }
     459    }
     460
     461    return RTTestSummaryAndDestroy(g_hTest);
     462}
     463
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