test_osapi_messagequeue.c

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

/*****************************************************************************
******************************************************************************
**                                                                          **
**  Copyright (c) 2006 Videon Central, Inc.                                 **
**  All rights reserved.                                                    **
**                                                                          **
**  The computer program contained herein contains proprietary information  **
**  which is the property of Videon Central, Inc.  The program may be used  **
**  and/or copied only with the written permission of Videon Central, Inc.  **
**  or in accordance with the terms and conditions stipulated in the        **
**  agreement/contract under which the programs have been supplied.         **
**                                                                          **
******************************************************************************
*****************************************************************************/
/**
 * @file test_osapi_messagequeue.c
 *
 * $Revision: 1.3 $ 
 *
 * Operating System API (OSAPI) test file. 
 *
 */

#include "vdvd_types.h"
#include "osapi.h"
#include "dbgprint.h"
#include "test_osapi.h"

#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 OSAPIMessageQueueTests( 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"));
}