testosapi.c

这是DVD中伺服部分的核心代码

void MemoryPoolTests( void )
{
    DbgPrint(("\n\nOSAPI MEMORY POOL TESTS\n"));

    DbgPrint( ("\n***** Random Allocations Test -- Going to randomly allocate\n") );
    DbgPrint( ("***** and deallocate memory from the memory pool.\n") );
    MemoryPoolTest_RandomAllocs();

    /*
     * Test managing several memory pools concurrently.
     */
    DbgPrint( ("\n***** Several Pools Test -- Going to create and manage\n") );
    DbgPrint( ("***** three different memory pools concurrently.\n") );
    MemoryPoolTest_SeveralPools();
     
    /*
     * Test freeing an invalid memory address.
     */
    DbgPrint( ("\n***** Invalid Free Test -- Going to attempt to free a\n") );
    DbgPrint( ("***** memory address that is not in the specified memory pool.\n") );
    MemoryPoolTest_InvalidFree();

    DbgPrint(("\n\nOSAPI MEMORY POOL TESTS FINISHED\n"));
}

#define STACK_SIZE  8*1024
#define QUEUE_DEPTH 5

static OS_MSG_Q_ID messageQueue = 0;

static volatile BOOLEAN receiveMessagesThreadFinished = FALSE;
static volatile BOOLEAN sendMessagesThreadFinished = FALSE;
static volatile BOOLEAN messageQueueFull = FALSE;
static volatile BOOLEAN messageQueueEmpty = FALSE;

ULONG ReceiveMessagesThreadEntryPoint( void )
{
    OS_STATUS   status;
    ULONG       ulMessage;
    int         i;
    int         removeCount;
    int         receiveCount;

    removeCount = 0;
    receiveCount = 0;

    DbgPrint(("\n\nReceiving/Removing messages from message queue...\n"));
    for ( i=0; i < QUEUE_DEPTH+1; i++ )
    {
        if ( (i % 2) == 0)
        {
            DbgPrint(("[running] Test: receive message:"));  
            status = OS_MsgQReceive(messageQueue, (char *)&ulMessage, sizeof(ULONG), OS_NO_WAIT);
            DbgPrint(("received[%08x]", ulMessage));
            PassFail( ( (status==OS_OK) && ( ulMessage == (0xdead0000 | (receiveCount+1))) )  );
            receiveCount++;
            if ( i == 0 ) 
            {
                OS_TaskDelay(1000);     // Give queue chance to fill from blocked send
            }
        }
        else
        {
            DbgPrint(("[running] Test: remove message:"));  
            status = OS_MsgQRemove(messageQueue, (char *)&ulMessage, sizeof(ULONG) );
            DbgPrint(("removed[%08x]", ulMessage));
            PassFail( ( (status==OS_OK) && ( ulMessage == (0xdead0000 | (QUEUE_DEPTH+1-removeCount))) )  );
            removeCount++;
        }
    }



    DbgPrint(("[running] Test: receiving message from empty queue (no timeout)"));  
    status = OS_MsgQReceive(messageQueue, (char *)&ulMessage, sizeof(ULONG), OS_NO_WAIT);
    PassFail( (status==OS_TIMEOUT) );

    DbgPrint(("[running] Test: receiving message from empty queue (timeout=100ms)"));  
    status = OS_MsgQReceive(messageQueue, (char *)&ulMessage, sizeof(ULONG), 100);
    PassFail( (status==OS_TIMEOUT) );

    messageQueueEmpty = TRUE;

    DbgPrint(("[running] Test: receiving message from empty queue (timeout 10 seconds)"));  
    status = OS_MsgQReceive(messageQueue, (char *)&ulMessage, sizeof(ULONG), 10000);

    OS_TaskDelay(1000); // give send a chance to finish up debug printing

    DbgPrint(("[running] Test: receiving message from empty queue (timeout 10 seconds)"));  
    PassFail( ( (status==OS_OK) && ( ulMessage == (0xdead0000 | (QUEUE_DEPTH+2))) )  );

    DbgPrint(("ReceiveMessagesThread exiting\n"));
    receiveMessagesThreadFinished = TRUE;

    return (0);
}



ULONG SendMessagesThreadEntryPoint( void )
{
    OS_STATUS   status;
    ULONG       ulMessage;
    int         i;
    
    DbgPrint(("\n\nSending %d messages to message queue...\n", QUEUE_DEPTH));
    for (i = 0; i < QUEUE_DEPTH; i++)
    {
        ulMessage = i + 1 | 0xDEAD0000;
        DbgPrint(("[running] Test: sending message %d:[%08x]", i + 1, ulMessage));  
        status = OS_MsgQSend(messageQueue, (char *)&ulMessage, sizeof(ULONG), OS_WAIT_FOREVER, OS_MSG_PRI_NORMAL);
        PassFail( (status==OS_OK) );
    }
    
    messageQueueFull = TRUE;

    ulMessage = i + 1 | 0xDEAD0000;
    DbgPrint(("[running] Test: sending message to full queue (timeout=no timeout) %d:[%08x]", i + 1, ulMessage));  
    status = OS_MsgQSend(messageQueue, (char *)&ulMessage, sizeof(ULONG), OS_NO_WAIT, OS_MSG_PRI_NORMAL);
    PassFail( (status==OS_TIMEOUT) );

    DbgPrint(("[running] Test: sending message to full queue (timeout=100ms) %d:[%08x]", i + 1, ulMessage));  
    status = OS_MsgQSend(messageQueue, (char *)&ulMessage, sizeof(ULONG), 100, OS_MSG_PRI_NORMAL);
    PassFail( (status==OS_TIMEOUT) );

    DbgPrint(("[running] Test: sending message to full queue (timeout=10s) %d:[%08x]", i + 1, ulMessage));  
    status = OS_MsgQSend(messageQueue, (char *)&ulMessage, sizeof(ULONG), 10000, OS_MSG_PRI_NORMAL);
    DbgPrint(("[running] Test: sending message to full queue (timeout=10s) %d:[%08x]", i + 1, ulMessage));  
    PassFail( (status==OS_OK) );

    while ( messageQueueEmpty == FALSE )
    {
        OS_TaskDelay(100);
    }

    ulMessage = i + 2 | 0xDEAD0000;
    DbgPrint(("\n[running] Test: sending message to empty queue %d:[%08x]", i + 2, ulMessage));  
    status = OS_MsgQSend(messageQueue, (char *)&ulMessage, sizeof(ULONG), OS_WAIT_FOREVER, OS_MSG_PRI_NORMAL);
    PassFail( (status==OS_OK) );

    DbgPrint(("SendMessagesThread exiting\n"));
    sendMessagesThreadFinished = TRUE;

    return 0;
}




void MessageQueueTests( void )
{
    OS_STATUS   status;
    int         receiveMessagesThread;
    int         sendMessageThread;
    
    DbgPrint(("\n\nOSAPI MESSAGE QUEUE TESTS\n"));

    DbgPrint(("[running] Test 1: create message queue"));
    messageQueue = OS_MsgQCreate(QUEUE_DEPTH, sizeof(ULONG), 0);
    PassFail( (messageQueue!=0) );
    
    DbgPrint(("[running] Test 2: create send messages thread"));
    sendMessageThread = OS_TaskSpawn("SendMessagesThread", 4, STACK_SIZE, SendMessagesThreadEntryPoint);
    PassFail( (sendMessageThread!=OS_FAILURE) );

    while ( messageQueueFull == FALSE ) 
    {
        OS_TaskDelay(100); // Give send thread a chance to block on full queue
    }
    OS_TaskDelay(1000); // give debug prints a chance to finish

    DbgPrint(("\n[running] Test 3: create receive messages thread"));
    receiveMessagesThread = OS_TaskSpawn("ReceiveMessagesThread", 4, STACK_SIZE, ReceiveMessagesThreadEntryPoint);
    PassFail( (receiveMessagesThread!=OS_FAILURE) );

    while ( (receiveMessagesThreadFinished==FALSE) && ( sendMessagesThreadFinished==FALSE ))
    {
        OS_TaskDelay(100);
    }

    OS_TaskDelay(1000);     // give debug prints a chance to finish

    DbgPrint(("[running] Test 4: join receive messages thread"));
    status = OS_TaskJoin(receiveMessagesThread);
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 5: join send messages thread"));
    status = OS_TaskJoin(sendMessageThread);
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 6: delete receive messages thread"));
    OS_TaskDelete(receiveMessagesThread);
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 7: delete send messages thread"));
    OS_TaskDelete(sendMessageThread);
    PassFail( (status==OS_OK) );
    
    DbgPrint(("[running] Test 8: delete message queue"));
    status = OS_MsgQDelete(messageQueue);
    PassFail( (status==OS_OK) );

    DbgPrint(("\nOSAPI MESSAGE QUEUE TEST FINISHED\n"));
}

#define COUNTING_SEMAPHORE_TEST_COUNT 13
static volatile OS_SEM_ID   testSemaphoreHandle = 0;

ULONG SemaphoreTestThreadEntryPoint( void )
{
    OS_STATUS   status;

    DbgPrint(("[running] Test 10: wait for semaphore to be released by another thread\n"));
    status = OS_SemTake( testSemaphoreHandle, 5*OS_WAIT_1S ); // Wait for 5 seconds...

    DbgPrint(("\n[running] Test 10: wait for semaphore to be released by another thread"));
    PassFail( (status==OS_OK) );

    DbgPrint(("SemaphoreTestThread exiting\n"));

    return (0);
}


void SemaphoreTests ( void )
{
    OS_SEM_ID   handle;
    OS_STATUS   status;
    int         iSemaphoreTestThread1ID;
    int         index;

    DbgPrint(("\n\nOSAPI SEMAPHORE TESTS\n"));

    DbgPrint(("[running] Test 1: create full binary semaphore"));
    handle = OS_SemBCreate(OS_SEM_Q_FIFO, OS_SEM_FULL);
    PassFail( (handle!=0) );

    DbgPrint(("[running] Test 2: obtain full binary semaphore"));
    status = OS_SemTake( handle, OS_WAIT_FOREVER );
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 3: obtain empty binary semaphore with timeout"));
    status = OS_SemTake( handle, 10 );
    PassFail( (status==OS_TIMEOUT) );

    DbgPrint(("[running] Test 4: obtain empty binary semaphore with 0 timeout"));
    status = OS_SemTake( handle, OS_NO_WAIT );
    PassFail( (status==OS_TIMEOUT) );

    DbgPrint(("[running] Test 5: release empty binary semaphore"));
    status = OS_SemGive( handle );
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 6: release full binary semaphore"));
    status = OS_SemGive( handle );
    PassFail( (status==OS_FAILURE) );

    DbgPrint(("[running] Test 7: obtain full binary semaphore with timeout"));
    status = OS_SemTake( handle, 10 );
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 8: release empty binary semaphore"));
    status = OS_SemGive( handle );
    PassFail( (status==OS_OK) );


    // Obtain full binary semaphore (the semaphore is now not available)

    DbgPrint(("[running] Test 9: obtain full binary semaphore"));
    status = OS_SemTake( handle, OS_WAIT_FOREVER );
    PassFail( (status==OS_OK) );

    
    // Create a thread that will wait to obtain the semaphore

    testSemaphoreHandle = handle;
    iSemaphoreTestThread1ID = OS_TaskSpawn("Task1", 4, STACK_SIZE, SemaphoreTestThreadEntryPoint);
    PassFail( (iSemaphoreTestThread1ID!=OS_FAILURE) );

    // Let thread run and block on semaphore
    OS_TaskDelay( 2*OS_WAIT_1S );

    DbgPrint(("[running] Test 11: release empty binary semaphore"));
    status = OS_SemGive( handle );
    PassFail( (status==OS_OK) );

    // Let thread get semaphore and exit
    OS_TaskDelay( 5*OS_WAIT_1S );


    DbgPrint(("[running] Test 12: delete binary semaphore"));
    status = OS_SemDelete(handle);
    PassFail( (status==OS_OK) );


    DbgPrint(("[running] Test 1: create empty counting semaphore"));
    handle = OS_SemCCreate(OS_SEM_Q_FIFO, 0);
    PassFail( (handle!=0) );

    DbgPrint(("[running] Test 2: obtain empty counting semaphore (timeout=NO_WAIT)"));
    status = OS_SemTake( handle, OS_NO_WAIT );
    PassFail( (status==OS_TIMEOUT) );

    DbgPrint(("[running] Test 3: obtain empty counting semaphore (timeout=100ms)"));
    status = OS_SemTake( handle, 100 );
    PassFail( (status==OS_TIMEOUT) );

    status = 0;
    DbgPrint(("[running] Test 4: release counting semaphore %d times", COUNTING_SEMAPHORE_TEST_COUNT));
    for ( index = 0; index < COUNTING_SEMAPHORE_TEST_COUNT; index++ )
    {
        status |= OS_SemGive( handle );
    }
    PassFail( (status==OS_OK) );

    status = 0;
    DbgPrint(("[running] Test 5: obtain counting semaphore %d times", COUNTING_SEMAPHORE_TEST_COUNT));
    for ( index = 0; index < COUNTING_SEMAPHORE_TEST_COUNT; index++ )
    {
        status |= OS_SemTake( handle, 100 );
    }
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 6: obtain empty counting semaphore with (timeout=10ms)"));
    status = OS_SemTake( handle, 10 );
    PassFail( (status==OS_TIMEOUT) );

    DbgPrint(("[running] Test 9: delete counting semaphore"));
    status = OS_SemDelete(handle);
    PassFail( (status==OS_OK) );

    DbgPrint(("\nOSAPI SEMAPHORE TEST FINISHED\n"));
}





ULONG Thread1EntryPoint( void )
{
    int done = FALSE;

    OS_TaskDelay( 1000 );
    DbgPrint(("\nThread1 running\n"));

    while ( !done ) 
        ;

    DbgPrint(("Thread1 exiting\n"));

    return (0);
}


void ThreadTests( void )
{
    OS_STATUS   status;
    int         iThread1ID;

    DbgPrint(("\n\nOSAPI THREAD TESTS\n"));

    DbgPrint(("[running] Test 1: create thread"));
    iThread1ID = OS_TaskSpawn("Task1", 4, STACK_SIZE, Thread1EntryPoint);
    PassFail( (iThread1ID!=OS_FAILURE) );

    // Let thread run and exit
    OS_TaskDelay( 2000 );

    DbgPrint(("[running] Test 2:  join thread"));
    status = OS_TaskJoin(iThread1ID);
    PassFail( (status==OS_OK) );

    DbgPrint(("[running] Test 3:  delete thread"));
    OS_TaskDelete(iThread1ID);
    PassFail( (status==OS_OK) );

    DbgPrint(("\nOSAPI THREAD TEST FINISHED\n"));
}


void main ( void )
{
    DbgPrint(("OSAPI TEST\n"));
    DbgPrint(("----------\n"));

    MemoryTests();
    getchar();

    MemoryPoolTests();
    getchar();

    ThreadTests();
    getchar();

    SemaphoreTests();
    getchar();

    MessageQueueTests();
    getchar();

    DbgPrint(("OSAPI TEST FINISHED\n"));
    getchar();
}