rvtimer.c

基于h323协议的软phone

    RvPrintf("RvTimerQueueNumEvents = %u.\n", RvTimerQueueNumEvents(&tqueue));
    RvPrintf("RvTimerQueueNextEvent = ");
    result = RvTimerQueueNextEvent(&tqueue, &eventtime);
    if(result == RV_OK) {
        Rv64toA(timestr, eventtime);
        RvPrintf("%s\n", timestr);
    } else {
        if(RvErrorGetCode(result) == RV_TIMER_WARNING_QUEUEEMPTY) {
            RvPrintf("Empty\n");
        } else RvTimerPrintError(result);
    }
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueSetSize(200): ");
    resultsize = RvTimerQueueSetSize(&tqueue, 200);
    RvPrintf("%u ", resultsize);
    if(resultsize < 200) {
        RvPrintf("ERROR!\n");
    } else RvPrintf("OK.\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueAddSize(50): ");
    resultsize = RvTimerQueueAddSize(&tqueue, 50);
    RvPrintf("%u ", resultsize);
    if(resultsize < 50) {
        RvPrintf("ERROR!\n");
    } else RvPrintf("OK.\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("Waiting...\n");
    RvThreadNanosleep( (RvInt64)Rv64Multiply(delay, RvInt64Const(2)) );

    RvPrintf("RvTimerQueueNumEvents = %u.\n", RvTimerQueueNumEvents(&tqueue));
    RvPrintf("RvTimerQueueNextEvent = ");
    result = RvTimerQueueNextEvent(&tqueue, &eventtime);
    if(result == RV_OK) {
        Rv64toA(timestr, eventtime);
        RvPrintf("%s\n", timestr);
    } else {
        if(RvErrorGetCode(result) == RV_TIMER_WARNING_QUEUEEMPTY) {
            RvPrintf("Empty\n");
        } else RvTimerPrintError(result);
    }

    RvPrintf("RvTimerQueueService(0)...\n");
    result = RvTimerQueueService(&tqueue, 0, &numevents);
    RvPrintf("  RvTimerQueueService: ");
    if(result == RV_OK) {
        RvPrintf("OK, numevents = %u\n", numevents);
    } else RvTimerPrintError(result);

    RvPrintf("RvTimerCancel Timer1 (blocking): ");
    result = RvTimerCancel(&timer1, RV_TIMER_CANCEL_BLOCKING);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");

    RvPrintf("RvTimerQueueStop: ");
    result = RvTimerQueueStop(&tqueue);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");

    RvPrintf("RvTimerQueueService(0): ");
    result = RvTimerQueueService(&tqueue, 0, &numevents);
    if(result != RV_OK) {
        if(RvErrorGetCode(result) == RV_TIMER_ERROR_QUEUESTOPPED) {
            RvPrintf("Correct, reported QUEUESTOPPED.\n");
        } else RvTimerPrintError(result);
    } else RvPrintf("ERROR, queue stopped, should not return OK.\n");

    RvPrintf("RvTimerQueueDestruct: ");
    result = RvTimerQueueDestruct(&tqueue);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");

    /* Tests with seperate service tasks */

    RvPrintf("RvTimerQueueConstruct(EXPANDING, 10, 20, 5, 0, 4): ");
    result = RvTimerQueueConstruct(&tqueue, RV_TIMER_QTYPE_EXPANDING, 10, 20, 5, 0, 4, NULL);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    exitthread = RV_FALSE;
    RvThreadConstruct(&th1, RvTimerTestServiceThread, &tqueue);
    RvThreadConstruct(&th2, RvTimerTestServiceThread, &tqueue);
    RvThreadCreate(&th1);
    RvThreadCreate(&th2);
    RvThreadStart(&th1);
    RvThreadStart(&th2);

    /* Test cancels while in callbacks. */

    delay = RV_TIME64_NSECPERSEC;
    Rv64toA(timestr, delay);
    RvPrintf("RvTimerStart(PERIODIC, %s): ", timestr);
    result = RvTimerStart(&timer1, &tqueue, RV_TIMER_TYPE_PERIODIC, delay, RvTimerTestCallback2, (void *)&timer1);
    if(result == RV_OK) {
        RvPrintf("OK\n");
        Rv64toA(timestr, timer1.starttime);
        RvPrintf("  Timer1(%p): id = %u, starttime  = %s\n", &timer1, timer1.id, timestr);
    } else RvTimerPrintError(result);
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueChangeMaxtimers(2, INCREASE): ");
    bresult = RvTimerQueueChangeMaxtimers(&tqueue, 2, RV_TIMER_VALUE_INCREASE);
    if(bresult == RV_TRUE) {
        RvPrintf("OK.\n");
    } else RvPrintf("ERROR!\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueChangeMaxtimers(5, DECREASE): ");
    bresult = RvTimerQueueChangeMaxtimers(&tqueue, 5, RV_TIMER_VALUE_DECREASE);
    if(bresult == RV_TRUE) {
        RvPrintf("OK.\n");
    } else RvPrintf("ERROR!\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueSetMaxtimers(30): ");
    bresult = RvTimerQueueSetMaxtimers(&tqueue, 30);
    if(bresult == RV_TRUE) {
        RvPrintf("OK.\n");
    } else RvPrintf("ERROR!\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("Waiting for 2 seconds...\n");
    RvThreadNanosleep( (RvInt64)Rv64Multiply(delay, RvInt64Const(2)) );

    RvPrintf("RvTimerCancel Timer1 (non-blocking): ");
    result = RvTimerCancel(&timer1, RV_TIMER_CANCEL_NONBLOCKING);
    if(result != RV_OK) {
        if(RvErrorGetCode(result) == RV_TIMER_WARNING_BUSY) {
            RvPrintf("OK, reported BUSY.\n");
        } else RvTimerPrintError(result);
    } else RvPrintf("ERROR, not BUSY.\n");

    RvPrintf("Waiting for 20 seconds (only current callback should complete)...\n");
    RvThreadNanosleep( (RvInt64)Rv64Multiply(delay, RvInt64Const(20)) );

    RvPrintf("RvTimerStart(ONESHOT, %s): ", timestr);
    result = RvTimerStart(&timer1, &tqueue, RV_TIMER_TYPE_ONESHOT, delay, RvTimerTestCallback2, (void *)&timer1);
    if(result == RV_OK) {
        RvPrintf("OK\n");
        Rv64toA(timestr, timer1.starttime);
        RvPrintf("  Timer1(%p): id = %u, starttime  = %s\n", &timer1, timer1.id, timestr);
    } else RvTimerPrintError(result);

    RvPrintf("Waiting for 2 seconds...\n");
    RvThreadNanosleep( (RvInt64)Rv64Multiply(delay, RvInt64Const(2)) );

    RvPrintf("RvTimerCancel Timer1 (blocking): Should wait until callback completes...\n");
    result = RvTimerCancel(&timer1, RV_TIMER_CANCEL_BLOCKING);
    if(result != RV_OK) {
        RvPrintf("  RvTimerCancel: ");
        RvTimerPrintError(result);
    } else RvPrintf("  RvTimerCancel: OK\n");

    /* Test periodic timers */

    delay = RV_TIME64_NSECPERSEC;
    Rv64toA(timestr, delay);
    RvPrintf("RvTimerStart(PERIODIC, %s): ", timestr);
    result = RvTimerStart(&timer1, &tqueue, RV_TIMER_TYPE_PERIODIC, delay, RvTimerTestCallback, (void *)&timer1);
    if(result == RV_OK) {
        RvPrintf("OK\n");
        Rv64toA(timestr, timer1.starttime);
        RvPrintf("  Timer1(%p): id = %u, starttime  = %s\n", &timer1, timer1.id, timestr);
    } else RvTimerPrintError(result);

    delay *= RvInt64Const(2);
    Rv64toA(timestr, delay);
    RvPrintf("RvTimerStart(PERIODIC, %s): ", timestr);
    result = RvTimerStart(&timer2, &tqueue, RV_TIMER_TYPE_PERIODIC, delay, RvTimerTestCallback, (void *)&timer2);
    if(result == RV_OK) {
        RvPrintf("OK\n");
        Rv64toA(timestr, timer2.starttime);
        RvPrintf("  Timer2(%p): id = %u, starttime  = %s\n", &timer2, timer2.id, timestr);
    } else RvTimerPrintError(result);
    RvPrintf("RvTimerQueueNumEvents = %u.\n", RvTimerQueueNumEvents(&tqueue));
    RvPrintf("RvTimerQueueNextEvent = ");
    result = RvTimerQueueNextEvent(&tqueue, &eventtime);
    if(result == RV_OK) {
        Rv64toA(timestr, eventtime);
        RvPrintf("%s\n", timestr);
    } else {
        if(RvErrorGetCode(result) == RV_TIMER_WARNING_QUEUEEMPTY) {
            RvPrintf("Empty\n");
        } else RvTimerPrintError(result);
    }

    RvPrintf("Waiting...\n");
    RvThreadNanosleep( (RvInt64)Rv64Multiply(delay, RvInt64Const(2)) );

    /* Mix in some random timers. */

    timerarray = NULL;
    RvMemoryAlloc(NULL, (void **)&timerarray, (RvSize_t)((RvInt8 *)&timerarray[RV_TIMER_TEST_NUMTIMERS] - (RvInt8 *)&timerarray[0]));
    for(i = 0; i < RV_TIMER_TEST_NUMTIMERS; i++)
    {
        delay = Rv64Multiply((RvInt64)rand(), RvInt64Const(100000)); /* 0 to 3.2 seconds */
        RvPrintf("  Timer #%d: ", i);
        result = RvTimerStart(&timerarray[i], &tqueue, RV_TIMER_TYPE_ONESHOT, delay, RvTimerTestCallback, (void *)&timerarray[i]);
        if(result == RV_OK) {
            Rv64toA(timestr, timerarray[i].starttime);
            RvPrintf("  id = %u, starttime  = %s, ", timerarray[i].id, timestr);
            Rv64toA(timestr, delay);
            RvPrintf("delay = %s\n", timestr);
        } else RvTimerPrintError(result);
    }

    RvPrintf("Waiting...\n");
    RvThreadNanosleep( (RvInt64)Rv64Multiply(RV_TIME64_NSECPERSEC, RvInt64Const(5)) );

    exitthread = RV_TRUE;
    RvPrintf("RvTimerQueueStop: ");
    result = RvTimerQueueStop(&tqueue);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");

    RvThreadDestruct(&th1);
    RvThreadDestruct(&th2);

    RvMemoryFree(timerarray);

    RvPrintf("RvTimerQueueDestruct: ");
    result = RvTimerQueueDestruct(&tqueue);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");


    /* Test stopping while in a callbacks */

    RvPrintf("RvTimerQueueConstruct(DYNAMIC, 5, 0, 0, 60, 4): ");
    result = RvTimerQueueConstruct(&tqueue, RV_TIMER_QTYPE_DYNAMIC, 5, 0, 0, 60, 4, NULL);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueChangeMintimers(10, INCREASE): ");
    bresult = RvTimerQueueChangeMintimers(&tqueue, 10, RV_TIMER_VALUE_INCREASE);
    if(bresult == RV_TRUE) {
        RvPrintf("OK.\n");
    } else RvPrintf("ERROR!\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueChangeMintimers(7, DECREASE): ");
    bresult = RvTimerQueueChangeMintimers(&tqueue, 7, RV_TIMER_VALUE_DECREASE);
    if(bresult == RV_TRUE) {
        RvPrintf("OK.\n");
    } else RvPrintf("ERROR!\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueSetMintimers(0): ");
    bresult = RvTimerQueueSetMintimers(&tqueue, 0);
    if(bresult == RV_TRUE) {
        RvPrintf("OK.\n");
    } else RvPrintf("ERROR!\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    RvPrintf("RvTimerQueueSetFreelevel(50): ");
    bresult = RvTimerQueueSetFreelevel(&tqueue, 0);
    if(bresult == RV_TRUE) {
        RvPrintf("OK.\n");
    } else RvPrintf("ERROR!\n");
    RvPrintf("size=%u, max=%u, min=%u, freelevel=%u\n", RvTimerQueueGetSize(&tqueue), RvTimerQueueGetMaxtimers(&tqueue), RvTimerQueueGetMintimers(&tqueue), RvTimerQueueGetFreelevel(&tqueue));

    exitthread = RV_FALSE;
    RvThreadConstruct(&th1, RvTimerTestServiceThread, &tqueue);
    RvThreadConstruct(&th2, RvTimerTestServiceThread, &tqueue);
    RvThreadCreate(&th1);
    RvThreadCreate(&th2);
    RvThreadStart(&th1);
    RvThreadStart(&th2);

    delay = RV_TIME64_NSECPERSEC;
    Rv64toA(timestr, delay);
    RvPrintf("RvTimerStart(PERIODIC, %s): ", timestr);
    result = RvTimerStart(&timer1, &tqueue, RV_TIMER_TYPE_PERIODIC, delay, RvTimerTestCallback2, (void *)&timer1);
    if(result == RV_OK) {
        RvPrintf("OK\n");
        Rv64toA(timestr, timer1.starttime);
        RvPrintf("  Timer1(%p): id = %u, starttime  = %s\n", &timer1, timer1.id, timestr);
    } else RvTimerPrintError(result);

    RvThreadNanosleep((RvInt64)Rv64Divide(delay, RvInt64Const(2)));

    RvPrintf("RvTimerStart(ONESHOT, %s): ", timestr);
    result = RvTimerStart(&timer2, &tqueue, RV_TIMER_TYPE_ONESHOT, delay, RvTimerTestCallback2, (void *)&timer2);
    if(result == RV_OK) {
        RvPrintf("OK\n");
        Rv64toA(timestr, timer2.starttime);
        RvPrintf("  Timer2(%p): id = %u, starttime  = %s\n", &timer2, timer2.id, timestr);
    } else RvTimerPrintError(result);

    RvPrintf("Waiting for 3 seconds...\n");
    RvThreadNanosleep( (RvInt64)Rv64Multiply(delay, RvInt64Const(3)) );

    exitthread = RV_TRUE;
    RvPrintf("RvTimerQueueStop: Should wait until callbacks complete...\n");
    result = RvTimerQueueStop(&tqueue);
    if(result != RV_OK) {
        RvPrintf("  RvTimerQueueStop: ");
        RvTimerPrintError(result);
    } else RvPrintf("  RvTimerQueueStop completed OK.\n");

    RvThreadDestruct(&th1);
    RvThreadDestruct(&th2);

    RvPrintf("RvTimerQueueDestruct: ");
    result = RvTimerQueueDestruct(&tqueue);
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");

    RvPrintf("RvTimerEnd: ");
    result = RvTimerEnd();
    if(result != RV_OK) {
        RvTimerPrintError(result);
    } else RvPrintf("OK\n");

    RvCCoreEnd();
}
#endif /* RV_TEST_CODE */