VirtualBox

Changeset 32946 in vbox for trunk/src/VBox/Runtime


Ignore:
Timestamp:
Oct 6, 2010 2:21:29 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
66441
Message:

iprt/semaphore.h: Started adding RTSem*<Wait|Request>Ex[Debug].

Location:
trunk/src/VBox/Runtime
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/Makefile.kmk

    r32656 r32946  
    545545        r3/linux/semeventmulti-linux.cpp \
    546546        r3/linux/semmutex-linux.cpp
     547#       generic/RTSemEventMultiWait-2-ex-generic.cpp \
     548#       generic/RTSemEventMultiWaitNoResume-2-ex-generic.cpp
    547549else
    548550 RuntimeR3_SOURCES.linux.x86 += \
    … …  
    553555        r3/linux/semevent-linux.cpp \
    554556        r3/linux/semeventmulti-linux.cpp
     557#       generic/RTSemEventMultiWait-2-ex-generic.cpp \
     558#       generic/RTSemEventMultiWaitNoResume-2-ex-generic.cpp
    555559 ifdef RT_NEW_LINUX_MUTEX_CODE
    556560  RuntimeR3_SOURCES.linux.amd64 += \

  • trunk/src/VBox/Runtime/r3/linux/semeventmulti-linux.cpp

    r28800 r32946  
    55
    66/*
    7  * Copyright (C) 2006-2007 Oracle Corporation
     7 * Copyright (C) 2006-2010 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    248248
    249249
    250 static int rtSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, RTMSINTERVAL cMillies, bool fAutoResume)
    251 {
    252     PCRTLOCKVALSRCPOS pSrcPos = NULL;
    253 
     250
     251DECLINLINE(int) rtSemEventLnxMultiWait(struct RTSEMEVENTMULTIINTERNAL *pThis, uint32_t fFlags, uint64_t uTimeout,
     252                                       PCRTLOCKVALSRCPOS pSrcPos)
     253{
    254254    /*
    255255     * Validate input.
    256256     */
    257     struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
    258     AssertReturn(VALID_PTR(pThis) && pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
    259                  VERR_INVALID_HANDLE);
     257    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     258    AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
     259    AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
    260260
    261261    /*
    … …  
    268268
    269269    /*
    270      * Convert the timeout value.
     270     * Check and convert the timeout value.
    271271     */
    272272    struct timespec ts;
    273273    struct timespec *pTimeout = NULL;
    274     uint64_t u64End = 0; /* shut up gcc */
    275     if (cMillies != RT_INDEFINITE_WAIT)
     274    uint64_t u64Deadline = 0; /* shut up gcc */
     275    if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
    276276    {
    277277        /* If the timeout is zero, then we're done. */
    278         if (!cMillies)
     278        if (!uTimeout)
    279279            return VERR_TIMEOUT;
    280         ts.tv_sec  = cMillies / 1000;
    281         ts.tv_nsec = (cMillies % 1000) * UINT32_C(1000000);
    282         u64End = RTTimeSystemNanoTS() + cMillies * UINT64_C(1000000);
    283         pTimeout = &ts;
     280
     281        /* Convert it to a deadline + interval timespec. */
     282        if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
     283            uTimeout = uTimeout < UINT64_MAX / UINT32_C(1000000) * UINT32_C(1000000)
     284                     ? uTimeout * UINT32_C(1000000)
     285                     : UINT64_MAX;
     286        if (uTimeout != UINT64_MAX) /* unofficial way of indicating an indefinite wait */
     287        {
     288            if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
     289                u64Deadline = RTTimeSystemNanoTS();
     290            else
     291            {
     292                uint64_t u64Now = RTTimeSystemNanoTS();
     293                if (uTimeout <= u64Now)
     294                    return VERR_TIMEOUT;
     295                u64Deadline = uTimeout;
     296                uTimeout   -= u64Now;
     297            }
     298            if (   sizeof(ts.tv_sec) >= sizeof(uint64_t)
     299                || uTimeout <= UINT64_C(1000000000) * UINT32_MAX)
     300            {
     301                ts.tv_nsec = uTimeout % UINT32_C(1000000000);
     302                ts.tv_sec  = uTimeout / UINT32_C(1000000000);
     303                pTimeout = &ts;
     304            }
     305        }
    284306    }
    285307
    … …  
    306328            if (pTimeout)
    307329            {
    308                 int64_t i64Diff = u64End - RTTimeSystemNanoTS();
     330                int64_t i64Diff = u64Deadline - RTTimeSystemNanoTS();
    309331                if (i64Diff < 1000)
    310332                    return VERR_TIMEOUT;
    … …  
    316338            {
    317339                int rc9 = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false,
    318                                                                 cMillies, RTTHREADSTATE_EVENT_MULTI, true);
     340                                                                uTimeout / UINT32_C(1000000), RTTHREADSTATE_EVENT_MULTI, true);
    319341                if (RT_FAILURE(rc9))
    320342                    return rc9;
    … …  
    344366            else if (rc == -EINTR)
    345367            {
    346                 if (!fAutoResume)
     368                if (fFlags & RTSEMWAIT_FLAGS_NORESUME)
    347369                    return VERR_INTERRUPTED;
    348370            }
    … …  
    360382
    361383
    362 RTDECL(int)  RTSemEventMultiWait(RTSEMEVENTMULTI hEventMultiSem, RTMSINTERVAL cMillies)
    363 {
    364     int rc = rtSemEventMultiWait(hEventMultiSem, cMillies, true);
    365     Assert(rc != VERR_INTERRUPTED);
    366     return rc;
    367 }
    368 
    369 
    370 RTDECL(int)  RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI hEventMultiSem, RTMSINTERVAL cMillies)
    371 {
    372     return rtSemEventMultiWait(hEventMultiSem, cMillies, false);
     384#undef RTSemEventMultiWaitEx
     385RTDECL(int)  RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout)
     386{
     387#ifndef RTSEMEVENT_STRICT
     388    return rtSemEventLnxMultiWait(hEventMultiSem, fFlags, uTimeout, NULL);
     389#else
     390    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
     391    return rtSemEventLnxMultiWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
     392#endif
     393}
     394
     395
     396RTDECL(int)  RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout,
     397                                        RTHCUINTPTR uId, RT_SRC_POS_DECL)
     398{
     399    RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
     400    return rtSemEventLnxMultiWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
    373401}
    374402
    … …  
    411439}
    412440
     441#include "../../generic/RTSemEventMultiWait-2-ex-generic.cpp"
     442#include "../../generic/RTSemEventMultiWaitNoResume-2-ex-generic.cpp"
     443
    413444#endif /* glibc < 2.6 || IPRT_WITH_FUTEX_BASED_SEMS */
    414445

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

    r28800 r32946  
    2525 */
    2626
     27
    2728/*******************************************************************************
    2829*   Header Files                                                               *
    2930*******************************************************************************/
    3031#include <iprt/semaphore.h>
    31 #include <iprt/string.h>
    32 #include <iprt/thread.h>
    33 #include <iprt/stream.h>
    34 #include <iprt/time.h>
    35 #include <iprt/initterm.h>
    36 #include <iprt/rand.h>
     32
    3733#include <iprt/asm.h>
    3834#include <iprt/assert.h>
     35#include <iprt/rand.h>
     36#include <iprt/stream.h>
     37#include <iprt/string.h>
     38#include <iprt/test.h>
     39#include <iprt/thread.h>
     40#include <iprt/time.h>
    3941
    4042
    … …  
    4244*   Global Variables                                                           *
    4345*******************************************************************************/
    44 static RTSEMEVENTMULTI      g_hSemEM = NIL_RTSEMEVENTMULTI;
    45 static uint32_t volatile    g_cErrors;
    46 
    47 
    48 int PrintError(const char *pszFormat, ...)
    49 {
    50     ASMAtomicIncU32(&g_cErrors);
    51 
    52     RTPrintf("tstSemEvent: FAILURE - ");
    53     va_list va;
    54     va_start(va, pszFormat);
    55     RTPrintfV(pszFormat, va);
    56     va_end(va);
    57 
    58     return 1;
    59 }
    60 
    61 
    62 int ThreadTest1(RTTHREAD ThreadSelf, void *pvUser)
    63 {
    64     int rc;
    65     rc = RTSemEventMultiWait(g_hSemEM, 1000);
    66     if (rc != VERR_TIMEOUT)
    67     {
    68         PrintError("Thread 1: unexpected result of first RTSemEventMultiWait %Rrc\n", rc);
    69         return VINF_SUCCESS;
    70     }
    71 
    72     rc = RTSemEventMultiWait(g_hSemEM, 1000);
    73     if (RT_FAILURE(rc))
    74     {
    75         PrintError("Thread 1: unexpected result of second RTSemEventMultiWait %Rrc\n", rc);
    76         return VINF_SUCCESS;
    77     }
    78 
    79     RTPrintf("tstSemEvent: Thread 1 normal exit...\n");
     46/** The test handle. */
     47static RTTEST  g_hTest;
     48
     49
     50static DECLCALLBACK(int) test1Thread1(RTTHREAD ThreadSelf, void *pvUser)
     51{
     52    RTSEMEVENTMULTI hSem = *(PRTSEMEVENTMULTI)pvUser;
     53
     54    uint64_t u64 = RTTimeSystemMilliTS();
     55    RTTEST_CHECK_RC_RET(g_hTest, RTSemEventMultiWait(hSem, 1000), VERR_TIMEOUT, rcCheck);
     56    u64 = RTTimeSystemMilliTS() - u64;
     57    RTTEST_CHECK_MSG(g_hTest, u64 < 1500 && u64 > 950, (g_hTest, "u64=%llu\n", u64));
     58
     59    RTTEST_CHECK_RC_RET(g_hTest, RTSemEventMultiWait(hSem, 2000), VINF_SUCCESS, rcCheck);
    8060    return VINF_SUCCESS;
    8161}
    8262
    8363
    84 int ThreadTest2(RTTHREAD ThreadSelf, void *pvUser)
    85 {
    86     int rc;
    87     rc = RTSemEventMultiWait(g_hSemEM, RT_INDEFINITE_WAIT);
    88     if (RT_FAILURE(rc))
    89     {
    90         PrintError("Thread 2: unexpected result of RTSemEventMultiWait %Rrc\n", rc);
    91         return VINF_SUCCESS;
    92     }
    93 
    94     RTPrintf("tstSemEvent: Thread 2 normal exit...\n");
     64static DECLCALLBACK(int) test1Thread2(RTTHREAD ThreadSelf, void *pvUser)
     65{
     66    RTSEMEVENTMULTI hSem = *(PRTSEMEVENTMULTI)pvUser;
     67    RTTEST_CHECK_RC_RET(g_hTest, RTSemEventMultiWait(hSem, RT_INDEFINITE_WAIT), VINF_SUCCESS, rcCheck);
    9568    return VINF_SUCCESS;
    9669}
    9770
    9871
    99 static int Test1()
    100 {
    101     int rc;
    102     RTTHREAD Thread1, Thread2;
    103 
    104     rc = RTSemEventMultiCreate(&g_hSemEM);
    105     if (RT_FAILURE(rc))
    106         return PrintError("RTSemEventMultiCreate failed (rc=%Rrc)\n", rc);
     72static void test1(void)
     73{
     74    RTTestISub("Three threads");
    10775
    10876    /*
    10977     * Create the threads and let them block on the event multi semaphore.
    11078     */
    111     rc = RTSemEventMultiReset(g_hSemEM);
    112     if (RT_FAILURE(rc))
    113         return PrintError("RTSemEventMultiReset failed (rc=%Rrc)\n", rc);
    114 
    115     rc = RTThreadCreate(&Thread2, ThreadTest2, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test2");
    116     if (RT_FAILURE(rc))
    117         return PrintError("RTThreadCreate failed for thread 2 (rc=%Rrc)\n", rc);
     79    RTSEMEVENTMULTI hSem;
     80    RTTESTI_CHECK_RC_RETV(RTSemEventMultiCreate(&hSem), VINF_SUCCESS);
     81
     82    RTTHREAD hThread2;
     83    RTTESTI_CHECK_RC_RETV(RTThreadCreate(&hThread2, test1Thread2, &hSem, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test2"), VINF_SUCCESS);
    11884    RTThreadSleep(100);
    11985
    120     rc = RTThreadCreate(&Thread1, ThreadTest1, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test1");
    121     if (RT_FAILURE(rc))
    122         return PrintError("RTThreadCreate failed for thread 1 (rc=%Rrc)\n", rc);
     86    RTTHREAD hThread1;
     87    RTTESTI_CHECK_RC_RETV(RTThreadCreate(&hThread1, test1Thread1, &hSem, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test1"), VINF_SUCCESS);
    12388
    12489    /* Force first thread (which has a timeout of 1 second) to timeout in the
    12590     * first wait, and the second wait will succeed. */
    126     RTThreadSleep(1500);
    127     rc = RTSemEventMultiSignal(g_hSemEM);
    128     if (RT_FAILURE(rc))
    129         PrintError("RTSemEventMultiSignal failed (rc=%Rrc)\n", rc);
    130 
    131     rc = RTThreadWait(Thread1, 5000, NULL);
    132     if (RT_FAILURE(rc))
    133         PrintError("RTThreadWait failed for thread 1 (rc=%Rrc)\n", rc);
    134 
    135     rc = RTThreadWait(Thread2, 5000, NULL);
    136     if (RT_FAILURE(rc))
    137         PrintError("RTThreadWait failed for thread 2 (rc=%Rrc)\n", rc);
    138 
    139     rc = RTSemEventMultiDestroy(g_hSemEM);
    140     if (RT_FAILURE(rc))
    141         PrintError("RTSemEventMultiDestroy failed - %Rrc\n", rc);
    142     g_hSemEM = NIL_RTSEMEVENTMULTI;
    143     if (g_cErrors)
    144         RTThreadSleep(100);
    145     return 0;
     91    RTTESTI_CHECK_RC(RTThreadSleep(1500), VINF_SUCCESS);
     92    RTTESTI_CHECK_RC(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     93    RTTESTI_CHECK_RC(RTThreadWait(hThread1, 5000, NULL), VINF_SUCCESS);
     94    RTTESTI_CHECK_RC(RTThreadWait(hThread2, 5000, NULL), VINF_SUCCESS);
     95    RTTESTI_CHECK_RC(RTSemEventMultiDestroy(hSem), VINF_SUCCESS);
     96}
     97
     98
     99static void testBasicsWaitTimeout(RTSEMEVENTMULTI hSem, unsigned i)
     100{
     101    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWait(hSem, 0), VERR_TIMEOUT);
     102#if 1
     103    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitNoResume(hSem, 0), VERR_TIMEOUT);
     104#else
     105    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     106                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_RELATIVE,
     107                                                0),
     108                          VERR_TIMEOUT);
     109    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     110                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     111                                                RTTimeSystemNanoTS() + 1000*i),
     112                          VERR_TIMEOUT);
     113    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     114                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     115                                                RTTimeNanoTS() + 1000*i),
     116                          VERR_TIMEOUT);
     117
     118    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     119                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_MILLISECS | RTSEMWAIT_FLAGS_RELATIVE,
     120                                                0),
     121                          VERR_TIMEOUT);
     122#endif
     123}
     124
     125
     126static void testBasicsWaitSuccess(RTSEMEVENTMULTI hSem, unsigned i)
     127{
     128    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWait(hSem, 0), VINF_SUCCESS);
     129    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWait(hSem, RT_INDEFINITE_WAIT), VINF_SUCCESS);
     130#if 1
     131    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitNoResume(hSem, 0), VINF_SUCCESS);
     132    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitNoResume(hSem, RT_INDEFINITE_WAIT), VINF_SUCCESS);
     133#else
     134    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     135                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_RELATIVE,
     136                                                0),
     137                          VINF_SUCCESS);
     138    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem, RTSEMWAIT_FLAGS_RESUME   | RTSEMWAIT_FLAGS_INDEFINITE, 0), VINF_SUCCESS);
     139    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem, RTSEMWAIT_FLAGS_NORESUME | RTSEMWAIT_FLAGS_INDEFINITE, 0), VINF_SUCCESS);
     140    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     141                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     142                                                RTTimeSystemNanoTS() + 1000*i),
     143                          VINF_SUCCESS);
     144    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     145                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     146                                                RTTimeNanoTS() + 1000*i),
     147                          VINF_SUCCESS);
     148    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     149                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     150                                                0),
     151                          VINF_SUCCESS);
     152    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     153                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     154                                                _1G),
     155                          VINF_SUCCESS);
     156    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     157                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     158                                                UINT64_MAX),
     159                          VINF_SUCCESS);
     160
     161
     162    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     163                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_MILLISECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     164                                                RTTimeSystemMilliTS() + 1000*i),
     165                          VINF_SUCCESS);
     166    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     167                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_MILLISECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     168                                                RTTimeMilliTS() + 1000*i),
     169                          VINF_SUCCESS);
     170    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     171                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_MILLISECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     172                                                0),
     173                          VINF_SUCCESS);
     174    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     175                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_MILLISECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     176                                                _1M),
     177                          VINF_SUCCESS);
     178    RTTESTI_CHECK_RC_RETV(RTSemEventMultiWaitEx(hSem,
     179                                                RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_MILLISECS | RTSEMWAIT_FLAGS_ABSOLUTE,
     180                                                UINT64_MAX),
     181                          VINF_SUCCESS);
     182#endif
     183}
     184
     185
     186static void testBasics(void)
     187{
     188    RTTestISub("Basics");
     189
     190    RTSEMEVENTMULTI hSem;
     191    RTTESTI_CHECK_RC_RETV(RTSemEventMultiCreate(&hSem), VINF_SUCCESS);
     192
     193    /* The semaphore is created in a reset state, calling reset explicitly
     194       shouldn't make any difference. */
     195    testBasicsWaitTimeout(hSem, 0);
     196    RTTESTI_CHECK_RC_RETV(RTSemEventMultiReset(hSem), VINF_SUCCESS);
     197    testBasicsWaitTimeout(hSem, 1);
     198    if (RTTestIErrorCount())
     199        return;
     200
     201    /* When signalling the semaphore all successive wait calls shall
     202       succeed, signalling it again should make no difference. */
     203    RTTESTI_CHECK_RC_RETV(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     204    testBasicsWaitSuccess(hSem, 2);
     205    if (RTTestIErrorCount())
     206        return;
     207
     208    /* After resetting it we should time out again. */
     209    RTTESTI_CHECK_RC_RETV(RTSemEventMultiReset(hSem), VINF_SUCCESS);
     210    testBasicsWaitTimeout(hSem, 3);
     211    if (RTTestIErrorCount())
     212        return;
     213
     214    /* The number of resets or signal calls shouldn't matter. */
     215    RTTESTI_CHECK_RC_RETV(RTSemEventMultiReset(hSem), VINF_SUCCESS);
     216    RTTESTI_CHECK_RC_RETV(RTSemEventMultiReset(hSem), VINF_SUCCESS);
     217    RTTESTI_CHECK_RC_RETV(RTSemEventMultiReset(hSem), VINF_SUCCESS);
     218    testBasicsWaitTimeout(hSem, 4);
     219
     220    RTTESTI_CHECK_RC_RETV(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     221    RTTESTI_CHECK_RC_RETV(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     222    RTTESTI_CHECK_RC_RETV(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     223    RTTESTI_CHECK_RC_RETV(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     224    RTTESTI_CHECK_RC_RETV(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     225    testBasicsWaitSuccess(hSem, 5);
     226
     227    RTTESTI_CHECK_RC_RETV(RTSemEventMultiReset(hSem), VINF_SUCCESS);
     228    testBasicsWaitTimeout(hSem, 6);
     229
     230    /* Destroy it. */
     231    RTTESTI_CHECK_RC_RETV(RTSemEventMultiDestroy(hSem), VINF_SUCCESS);
     232    RTTESTI_CHECK_RC_RETV(RTSemEventMultiDestroy(NIL_RTSEMEVENTMULTI), VINF_SUCCESS);
     233
     234    /* Whether it is reset (above), signalled or not used shouldn't matter.  */
     235    RTTESTI_CHECK_RC_RETV(RTSemEventMultiCreate(&hSem), VINF_SUCCESS);
     236    RTTESTI_CHECK_RC_RETV(RTSemEventMultiSignal(hSem), VINF_SUCCESS);
     237    RTTESTI_CHECK_RC_RETV(RTSemEventMultiDestroy(hSem), VINF_SUCCESS);
     238
     239    RTTESTI_CHECK_RC_RETV(RTSemEventMultiCreate(&hSem), VINF_SUCCESS);
     240    RTTESTI_CHECK_RC_RETV(RTSemEventMultiDestroy(hSem), VINF_SUCCESS);
     241
     242    RTTestISubDone();
    146243}
    147244
    … …  
    149246int main(int argc, char **argv)
    150247{
    151     int rc = RTR3Init();
    152     if (RT_FAILURE(rc))
     248    RTEXITCODE rcExit = RTTestInitAndCreate("tstSemEventMulti", &g_hTest);
     249    if (rcExit != RTEXITCODE_SUCCESS)
     250        return rcExit;
     251
     252    testBasics();
     253    if (!RTTestErrorCount(g_hTest))
    153254    {
    154         RTPrintf("tstSemEvent: RTR3Init failed (rc=%Rrc)\n", rc);
    155         return 1;
     255        test1();
    156256    }
    157     RTPrintf("tstSemEvent: TESTING...\n");
    158     Test1();
    159 
    160     if (!g_cErrors)
    161         RTPrintf("tstSemEvent: SUCCESS\n");
    162     else
    163         RTPrintf("tstSemEvent: FAILURE - %u errors\n", g_cErrors);
    164     return g_cErrors != 0;
    165 }
    166 
     257
     258    return RTTestSummaryAndDestroy(g_hTest);
     259}
     260
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