LXR 6.1/​testsuites/​psxtests/​psxmsgq01/​init.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:40

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /*
  *  COPYRIGHT (c) 1989-2012.
  *  On-Line Applications Research Corporation (OAR).
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #define CONFIGURE_INIT
 #include "system.h"
 #include <sched.h>
 #include <fcntl.h>
 #include <time.h>
 #include <tmacros.h>
 #include <signal.h>   /* signal facilities */
 #include "test_support.h"
 
 const char rtems_test_name[] = "PSXMSGQ 1";
 
 /* forward declarations to avoid warnings */
 void Start_Test(char *description);
 void Validate_attributes(mqd_t mq, int oflag, int msg_count);
 char *Build_Queue_Name(int i);
 void open_test_queues(void);
 void validate_mq_open_error_codes(void);
 void validate_mq_unlink_error_codes(void);
 void validate_mq_close_error_codes(void);
 void validate_mq_getattr_error_codes(void);
 void Send_msg_to_que(int que, int msg);
 void Show_send_msg_to_que(char *task_name, int que, int msg);
 void verify_queues_full(char *task_name);
 void verify_queues_empty(char *task_name);
 int empty_message_queues(char *task_name);
 int fill_message_queues(char *task_name);
 void Read_msg_from_que(int que, int msg);
 int validate_mq_send_error_codes(void);
 void validate_mq_receive_error_codes(void);
 void verify_open_functionality(void);
 void verify_unlink_functionality(void);
 void verify_close_functionality(void);
 void verify_timed_send_queue(int que, int is_blocking);
 void verify_timed_send(void);
 void verify_timed_receive_queue(char *task_name, int que, int is_blocking);
 void verify_timed_receive(void);
 void wait_for_signal(sigset_t *waitset, int sec, int expect_signal);
 void verify_notify(void);
 void verify_with_threads(void);
 void verify_timedout_mq_timedreceive(char *task_name, int que, int is_blocking);
 void verify_timedout_mq_timedsend(int que, int is_blocking);
 void verify_timed_receive(void);
 void validate_mq_setattr(void);
 void verify_timedout_mq_timedreceive(
   char *task_name, int que, int is_blocking);
 void verify_mq_receive(void);
 void verify_timedout_mq_timedsend(int que, int is_blocking);
 void verify_mq_send(void);
 void verify_timed_receive(void);
 
 typedef struct {
   char         msg[ 50 ];
   int          size;
   unsigned int priority;
 } Test_Message_t;
 
 Test_Message_t Predefined_Msgs[MAXMSG+1];
 Test_Message_t Predefined_Msgs[MAXMSG+1] = {
   { "12345678",   9, MQ_PRIO_MAX-1 },  /* Max Length Message med  */
   { "",           1, 1             },  /* NULL  Message      low  */
   { "Last",       5, MQ_PRIO_MAX   },  /* Queue Full Message hi   */
   { "No Message", 0, MQ_PRIO_MAX-1 },  /* 0 length Message   med  */
   { "1",          2, 0             },  /* Cause Overflow Behavior */
 };
 int Priority_Order[MAXMSG+1] = { 2, 0, 3, 1, MAXMSG };
 
 
 typedef struct {
   mqd_t              mq;
   Test_Queue_Types   index;
   char              *name;
   int                oflag;
   int                maxmsg;
   int                msgsize;
   int                count;
 } Test_queue_type;
 
 Test_queue_type Test_q[ NUMBER_OF_TEST_QUEUES + 1 ] =
 {
   { 0, 0, "Qread",    ( O_CREAT | O_RDONLY | O_NONBLOCK ), MAXMSG, MSGSIZE, 0 },
   { 0, 1, "Qwrite",   ( O_CREAT | O_WRONLY | O_NONBLOCK ), MAXMSG, MSGSIZE, 0 },
   { 0, 2, "Qnoblock", ( O_CREAT | O_RDWR   | O_NONBLOCK ), MAXMSG, MSGSIZE, 0 },
   { 0, 3, "Qblock",   ( O_CREAT | O_RDWR )               , MAXMSG, MSGSIZE, 0 },
   { 0, 4, "Qdefault", ( O_CREAT | O_RDWR )               , 10,     16,      0 },
   { 0, 5, "mq6",      ( O_CREAT | O_WRONLY | O_NONBLOCK ), MAXMSG, MSGSIZE, 0 },
   { 0, 6, "Qblock",   (           O_RDWR )               , MAXMSG, MSGSIZE, 0 },
 };
 
 #define RW_NAME             Test_q[ RW_QUEUE ].name
 #define DEFAULT_NAME        Test_q[ DEFAULT_RW ].name
 #define RD_NAME             Test_q[ RD_QUEUE ].name
 #define WR_NAME             Test_q[ WR_QUEUE ].name
 #define BLOCKING_NAME       Test_q[ BLOCKING ].name
 #define CLOSED_NAME         Test_q[ CLOSED ].name
 
 #define RW_ATTR         Test_q[ RW_QUEUE ].oflag
 #define DEFAULT_ATTR    Test_q[ DEFAULT_RW ].oflag
 #define RD_ATTR         Test_q[ RD_QUEUE ].oflag
 #define WR_ATTR         Test_q[ WR_QUEUE ].oflag
 #define BLOCK_ATTR      Test_q[ BLOCKING ].oflag
 #define CLOSED_ATTR     Test_q[ CLOSED ].oflag
 
 /*
  * Outputs a header at each test section.
  */
 void Start_Test(
   char *description
 )
 {
   printf( "_______________%s\n", description );
 }
 
 
 void Validate_attributes(
   mqd_t  mq,
   int    oflag,
   int    msg_count
 )
 {
   int             status;
   struct mq_attr  attr;
 
   status = mq_getattr( mq, &attr );
   fatal_posix_service_status( status, 0, "mq_getattr valid return status");
 
   if ( mq != Test_q[ DEFAULT_RW ].mq ){
     fatal_int_service_status((int)attr.mq_maxmsg, MAXMSG, "maxmsg attribute" );
     fatal_int_service_status((int)attr.mq_msgsize,MSGSIZE,"msgsize attribute");
   }
 
   fatal_int_service_status((int)attr.mq_curmsgs, msg_count, "count attribute" );
   fatal_int_service_status((int)attr.mq_flags, oflag, "flag attribute" );
 }
 
 #define Get_Queue_Name( i )  Test_q[i].name
 char *Build_Queue_Name(int i)
 {
   static char Queue_Name[PATH_MAX + 2];
 
   sprintf(Queue_Name,"mq%d", i+1 );
   return Queue_Name;
 }
 
 void open_test_queues(void)
 {
   struct mq_attr   attr;
   int              status;
   Test_queue_type *tq;
   int              que;
 
   attr.mq_maxmsg  = MAXMSG;
   attr.mq_msgsize = MSGSIZE;
 
   puts( "Init: Open Test Queues" );
 
   for( que = 0; que < NUMBER_OF_TEST_QUEUES+1; que++ ) {
 
     tq = &Test_q[ que ];
     if ( que == DEFAULT_RW)
       Test_q[que].mq = mq_open( tq->name, tq->oflag, 0x777, NULL );
     else
       Test_q[que].mq = mq_open( tq->name, tq->oflag, 0x777, &attr );
 
     rtems_test_assert( Test_q[que].mq != (-1) );
   }
 
   status = mq_close( Test_q[NUMBER_OF_TEST_QUEUES].mq );
   fatal_posix_service_status( status, 0, "mq_close duplicate message queue");
   status = mq_close( Test_q[CLOSED].mq );
   fatal_posix_service_status( status, 0, "mq_close message queue");
   status = mq_unlink( CLOSED_NAME );
   fatal_posix_service_status( status, 0, "mq_unlink message queue");
 }
 
 /*
  * Opens CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES then leaves size queues
  * opened but closes the rest.
  */
 
 void validate_mq_open_error_codes(void)
 {
   int             i;
   mqd_t           n_mq2;
   struct mq_attr  attr;
   int             status;
   mqd_t           open_mq[CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES + 1];
 
   attr.mq_maxmsg  = MAXMSG;
   attr.mq_msgsize = MSGSIZE;
 
   Start_Test( "mq_open errors" );
 
   /*
    * XXX EINVAL - inappropriate name was given for the message queue
    */
 
   /*
    * EINVAL - Create with negative maxmsg.
    */
 
   attr.mq_maxmsg = -1;
   puts( "Init: mq_open - Create with maxmsg (-1) (EINVAL)" );
   n_mq2 = mq_open( "mq2", O_CREAT | O_RDONLY, 0x777, &attr);
   fatal_posix_mqd( n_mq2, "mq_open error return status" );
   fatal_posix_service_status( errno, EINVAL,  "mq_open errno EINVAL");
   attr.mq_maxmsg  = MAXMSG;
 
   /*
    * EINVAL - Create withnegative msgsize.
    */
 
   attr.mq_msgsize = -1;
   puts( "Init: mq_open - Create with msgsize (-1) (EINVAL)" );
   n_mq2 = mq_open( "mq2", O_CREAT | O_RDONLY, 0x777, &attr);
   fatal_posix_mqd( n_mq2, "mq_open error return status" );
   fatal_posix_service_status( errno, EINVAL,  "mq_open errno EINVAL");
   attr.mq_msgsize = MSGSIZE;
 
   /*
    * ENOENT - Open a non-created file.
    */
 
   puts( "Init: mq_open - Open new mq without create flag (ENOENT)" );
   n_mq2 = mq_open( "mq3", O_EXCL | O_RDONLY, 0x777, NULL);
   fatal_posix_mqd( n_mq2, "mq_open error return status" );
   fatal_posix_service_status( errno, ENOENT,  "mq_open errno ENOENT");
 
   /*
    * XXX EINTR  - call was interrupted by a signal
    */
 
   /*
    * ENAMETOOLONG - Give a name greater than PATH_MAX.
    */
 
   puts( "Init: mq_open - Open with too long of a name (ENAMETOOLONG)" );
   n_mq2 = mq_open( Get_Too_Long_Name(), O_CREAT | O_RDONLY, 0x777, NULL );
   fatal_posix_mqd( n_mq2, "mq_open error return status" );
   fatal_posix_service_status( errno, ENAMETOOLONG, "mq_open errno ENAMETOOLONG");
 
   /*
    * XXX - ENAMETOOLONG - Give a name greater than NAME_MAX
    *       Per implementation not possible.
    */
 
   /*
    * EEXIST - Create an existing queue.
    */
 
   puts( "Init: mq_open - Create an Existing mq (EEXIST)" );
   open_mq[0] = mq_open(
     Build_Queue_Name(0), O_CREAT | O_RDWR | O_NONBLOCK, 0x777, NULL );
   rtems_test_assert( open_mq[0] != (-1) );
 
   n_mq2 = mq_open(
     Build_Queue_Name(0), O_CREAT | O_EXCL | O_RDONLY, 0x777, NULL);
   fatal_posix_mqd( n_mq2, "mq_open error return status" );
   fatal_posix_service_status( errno, EEXIST,  "mq_open errno EEXIST");
 
   status = mq_unlink( Build_Queue_Name(0) );
   fatal_posix_service_status( status, 0, "mq_unlink message queue");
 
   status = mq_close( open_mq[0]);
   fatal_posix_service_status( status, 0, "mq_close message queue");
 
   /*
    * Open maximum number of message queues
    */
 
   puts( "Init: mq_open - SUCCESSFUL" );
   for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES; i++) {
     open_mq[i] = mq_open(
       Build_Queue_Name(i), O_CREAT | O_RDWR | O_NONBLOCK, 0x777, NULL );
     rtems_test_assert( open_mq[i] != (-1) );
     rtems_test_assert( open_mq[i] );
     /*XXX - Isn't there a more general check */
 /* JRS     printf( "mq_open 0x%x %s\n", open_mq[i], Build_Queue_Name(i) ); */
   }
 
   /*
    * XXX EACCES - permission to create is denied.
    */
 
   /*
    * XXX EACCES - queue exists permissions specified by o_flag are denied.
    */
 
   /*
    * XXX EMFILE  - Too many message queues in use by the process
    */
 
   /*
    * ENFILE -  Too many message queues open in the system
    */
 
   puts( "Init: mq_open - system is out of resources (ENFILE)" );
   n_mq2 = mq_open( Build_Queue_Name(i), O_CREAT | O_RDONLY, 0x777, NULL );
   fatal_posix_mqd( n_mq2, "mq_open error return status" );
   fatal_posix_service_status( errno, ENFILE,  "mq_open errno ENFILE");
 
   /*
    * Unlink and Close all queues.
    */
 
   puts( "Init: mq_close and mq_unlink (mq3...mqn) - SUCCESSFUL" );
   for (i = 0; i < CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES; i++) {
 
     status = mq_close( open_mq[i]);
     fatal_posix_service_status( status, 0, "mq_close message queue");
 
     status = mq_unlink( Build_Queue_Name(i) );
     if ( status == -1 )
       perror( "mq_unlink" );
     fatal_posix_service_status( status, 0, "mq_unlink message queue");
     /* JRS printf( "mq_close/mq_unlink 0x%x %s\n", open_mq[i], Build_Queue_Name(i) ); */
   }
 }
 
 void validate_mq_unlink_error_codes(void)
 {
   int             status;
 
   Start_Test( "mq_unlink errors" );
 
   /*
    * XXX - EACCES Permission Denied
    */
 
   /*
    * ENAMETOOLONG - Give a name greater than PATH_MAX.
    */
 
   puts( "Init: mq_unlink - mq_unlink with too long of a name (ENAMETOOLONG)" );
   status = mq_unlink( Get_Too_Long_Name() );
   fatal_posix_service_status( status, -1, "mq_unlink error return status");
   fatal_posix_service_status( errno, ENAMETOOLONG, "mq_unlink errno ENAMETOOLONG");
 
   /*
    * XXX - ENAMETOOLONG - Give a name greater than NAME_MAX
    *       Per implementation not possible.
    */
 
   /*
    *  ENOENT - Unlink an unopened queue
    */
 
   puts( "Init: mq_unlink - A Queue not opened  (ENOENT)" );
   status = mq_unlink( CLOSED_NAME );
   fatal_posix_service_status( status, -1, "mq_unlink error return status");
   fatal_posix_service_status( errno, ENOENT, "mq_unlink errno ENOENT");
 
   /*
    * XXX - The following were not listed in the POSIX document as
    *       possible errors.  Under other commands the EINVAL is
    *       given for these conditions.
    */
 
   /*
    *  EINVAL - Unlink a queue with no name
    */
 
   puts( "Init: mq_unlink (NULL) - EINVAL" );
   status = mq_unlink( NULL );
   fatal_posix_service_status( status, -1, "mq_unlink error return status");
   fatal_posix_service_status( errno, EINVAL, "mq_unlink errno value");
 
   /*
    *  ENOENT - Unlink a queue with a zero length name
    */
 
   puts( "Init: mq_unlink (\"\") - ENOENT" );
   status = mq_unlink( "" );
   fatal_posix_service_status( status, -1, "mq_unlink error return status");
   fatal_posix_service_status( errno, ENOENT, "mq_unlink errno value");
 }
 
 void validate_mq_close_error_codes(void)
 {
   int             status;
 
   Start_Test( "mq_close errors" );
 
   /*
    * EBADF - Close a queue that is not open.
    */
 
   puts( "Init: mq_close - unopened queue (EBADF)" );
   status = mq_close( Test_q[CLOSED].mq );
   fatal_posix_service_status( status, -1, "mq_close error return status");
   fatal_posix_service_status( errno, EBADF, "mq_close errno EBADF");
 }
 
 
 void validate_mq_getattr_error_codes(void)
 {
   struct mq_attr  attr;
   int             status;
 
   Start_Test( "mq_getattr errors" );
 
   /*
    * EBADF - Get the attributes from a closed queue.
    */
 
   puts( "Init: mq_getattr - unopened queue (EBADF)" );
   status = mq_getattr( Test_q[CLOSED].mq, &attr );
   fatal_posix_service_status( status, -1, "mq_close error return status");
   fatal_posix_service_status( errno, EBADF, "mq_close errno EBADF");
 
   /*
    * XXX - The following are not listed in the POSIX manual but
    *       may occur.
    */
 
   /*
    * EINVAL - NULL attributes
    */
 
   puts( "Init: mq_getattr - NULL attributes (EINVAL)" );
   status = mq_getattr( Test_q[RW_QUEUE].mq, NULL );
   fatal_posix_service_status( status, -1, "mq_close error return status");
   fatal_posix_service_status( errno, EINVAL, "mq_close errno EINVAL");
 
 }
 
 
 void Send_msg_to_que(
   int que,
   int msg
 )
 {
   Test_Message_t *ptr = &Predefined_Msgs[msg];
   int             status;
 
   status = mq_send( Test_q[que].mq, ptr->msg, ptr->size , ptr->priority );
   fatal_posix_service_status( status, 0, "mq_send valid return status");
   Test_q[que].count++;
 }
 
 void Show_send_msg_to_que(
   char *task_name,
   int   que,
   int   msg
 )
 {
   Test_Message_t *ptr = &Predefined_Msgs[msg];
   printf( "%s mq_send -  to %s msg: %s priority %d\n",
     task_name, Test_q[que].name, ptr->msg, ptr->priority);
   Send_msg_to_que( que, msg );
 }
 
 void verify_queues_full(
   char *task_name
 )
 {
   int          que;
 
   /*
    * Validate that the queues are full.
    */
 
   printf( "%s Verify Queues are full\n", task_name );
   for( que = RW_QUEUE; que < CLOSED; que++ )
     Validate_attributes( Test_q[que].mq, Test_q[que].oflag, Test_q[que].count );
 
 }
 void verify_queues_empty(
   char *task_name
 )
 {
   int             que;
 
   printf( "%s Verify Queues are empty\n", task_name );
   for( que = RW_QUEUE; que < CLOSED; que++ )
     Validate_attributes( Test_q[que].mq, Test_q[que].oflag, 0 );
 }
 
 int fill_message_queues(
   char *task_name
 )
 {
   int             msg;
   int             que;
 
 
   verify_queues_empty( task_name );
 
   /*
    * Fill Queue with predefined messages.
    */
 
   printf( "%s Fill Queues with messages\n", task_name );
   for(msg=0; msg<MAXMSG; msg++){
     for( que = RW_QUEUE; que < CLOSED; que++ ) {
       Send_msg_to_que( que, msg );
     }
   }
 
   verify_queues_full( "Init:" );
   return msg;
 }
 
 
 void Read_msg_from_que(
   int que,
   int msg
 )
 {
   unsigned int    priority;
   Test_Message_t *ptr;
   int             status;
   char            message[100];
   char            err_msg[100];
 
   ptr = &Predefined_Msgs[msg];
   status = mq_receive(Test_q[ que ].mq, message, 100, &priority );
   Test_q[que].count--;
 
   sprintf( err_msg, "%s msg %s size failure", Test_q[ que ].name, ptr->msg );
   fatal_int_service_status( status, ptr->size, err_msg );
 
   rtems_test_assert( !strcmp( message, ptr->msg ) );
   strcpy( message, "No Message" );
 
   sprintf( err_msg,"%s msg %s size failure", Test_q[ que ].name, ptr->msg );
   fatal_int_service_status(priority, ptr->priority, err_msg );
 }
 
 int empty_message_queues(
   char *task_name
 )
 {
   int que;
   int i;
 
   printf( "%s Empty all Queues\n", task_name );
   for( que = RW_QUEUE; que < CLOSED; que++ ) {
     for(i=0; Test_q[que].count != 0; i++ )
       Read_msg_from_que( que,  Priority_Order[i] );
 
     Validate_attributes( Test_q[ que].mq, Test_q[ que ].oflag, 0 );
   }
   return 0;
 }
 
 /*
  * Returns the number of messages queued after the test on the
  * first queue.
  */
 int validate_mq_send_error_codes(void)
 {
   int             status;
   int             i;
   char           *str;
 
   Start_Test( "mq_send errors" );
 
   /*
    * EBADF - Write to a closed queue.
    */
 
   puts( "Init: mq_send - Closed message queue (EBADF)" );
   status = mq_send( Test_q[CLOSED].mq, "", 1, 0 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EBADF, "mq_send errno EBADF");
 
   /*
    * EBADF - Write to a read only  queue.
    */
 
   puts( "Init: mq_send - Read only message queue (EBADF)" );
   status = mq_send( Test_q[ RD_QUEUE ].mq, "", 1, 0 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EBADF, "mq_send errno EBADF");
 
   /*
    * XXX - EINTR      Signal interrupted the call.
    *
   puts( "Init: mq_send - UNSUCCESSFUL (EINTR)" );
   status = mq_send( Test_q, "", 0xffff, 0 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, E, "mq_send errno E");
    */
 
   /*
    * EINVAL priority is out of range.
    */
 
   puts( "Init: mq_send - Priority out of range (EINVAL)" );
   status = mq_send( Test_q[ RW_QUEUE ].mq, "", 1, MQ_PRIO_MAX + 1 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EINVAL, "mq_send errno EINVAL");
 
   /*
    *  EMSGSIZE - Message size larger than msg_len
    *             Validates that msgsize is stored correctly.
    */
 
   puts( "Init: mq_send - Message longer than msg_len (EMSGSIZE)" );
   status = mq_send( Test_q[ RW_QUEUE ].mq, "", MSGSIZE+1, 0 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EMSGSIZE, "mq_send errno EMSGSIZE");
 
   i = fill_message_queues( "Init:" );
 
   /*
    * ENOSYS - send not supported
   puts( "Init: mq_send - Blocking Queue overflow (ENOSYS)" );
   status = mq_send( n_mq1, Predefined_Msgs[i], 0, 0 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EBADF, "mq_send errno EBADF");
 
   status = mq_close( n_mq1 );
   fatal_posix_service_status( status, 0, "mq_close message queue");
 
   status = mq_unlink( "read_only" );
   fatal_posix_service_status( status, 0, "mq_unlink message queue");
    */
 
   /*
    * EAGAIN - O_NONBLOCK and message queue is full.
    */
 
   puts( "Init: mq_send - on a FULL non-blocking queue with (EAGAIN)" );
   str = Predefined_Msgs[i].msg;
   status = mq_send(Test_q[RW_QUEUE].mq, str, 0, 0 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EAGAIN, "mq_send errno EAGAIN");
 
   return i-1;
 }
 
 void validate_mq_receive_error_codes(void)
 {
   int            status;
   char           message[100];
   unsigned int   priority;
 
   Start_Test( "mq_receive errors"  );
 
   /*
    * EBADF - Not A Valid Message Queue
    */
 
   puts( "Init: mq_receive - Unopened message queue (EBADF)" );
   status = mq_receive( Test_q[CLOSED].mq, message, 100, &priority );
   fatal_posix_service_status( status, -1, "mq_ error return status");
   fatal_posix_service_status( errno, EBADF, "mq_receive errno EBADF");
 
   /*
    * EBADF - Queue not opened to read
    */
 
   puts( "Init: mq_receive - Write only queue (EBADF)" );
   status = mq_receive( Test_q[WR_QUEUE].mq, message, 100, &priority  );
   fatal_posix_service_status( status, -1, "mq_ error return status");
   fatal_posix_service_status( errno, EBADF, "mq_receive errno EBADF");
 
   /*
    * EMSGSIZE - Size is less than the message size attribute
    */
 
   puts( "Init: mq_receive - Size is less than the message (EMSGSIZE)" );
   status = mq_receive(
     Test_q[RW_QUEUE].mq, message, Predefined_Msgs[0].size-1, &priority );
   fatal_posix_service_status( status, -1, "mq_ error return status");
   fatal_posix_service_status( errno, EMSGSIZE, "mq_receive errno EMSGSIZE");
 
 
   /*
    * EAGAIN - O_NONBLOCK and Queue is empty
    */
   verify_queues_full( "Init:" );
   empty_message_queues( "Init:" );
 
   puts( "Init: mq_receive - Queue is empty (EAGAIN)" );
   status = mq_receive( Test_q[RW_QUEUE].mq, message, 100, &priority );
   fatal_posix_service_status( status, -1, "mq_ error return status");
   fatal_posix_service_status( errno, EAGAIN, "mq_receive errno EAGAIN");
 
   /*
    * XXX - EINTR - Interrupted by a signal
    */
 
   /*
    * XXX - EBADMSG - a data corruption problem.
    */
 
   /*
    * XXX - ENOSYS - mq_receive not supported
    */
 }
 
 void verify_open_functionality(void)
 {
   mqd_t           n_mq;
   int             status;
 
   Start_Test( "mq_open functionality" );
 
   /*
    * Validate a second open returns the same message queue.
    */
 
   puts( "Init: mq_open - Open an existing mq ( same id )" );
   n_mq = mq_open( RD_NAME, 0 );
   rtems_test_assert( n_mq == Test_q[RD_QUEUE].mq );
   status = mq_close( n_mq );
   fatal_posix_service_status( status, 0, "mq_close");
 }
 
 void verify_unlink_functionality(void)
 {
   mqd_t           n_mq;
   int             status;
 
   Start_Test( "mq_unlink functionality" );
 
   /*
    * Unlink the message queue, then verify an open of the same name produces a
    * different message queue.
    */
 
   puts( "Init: Unlink and Open without closing SUCCESSFUL" );
   status = mq_unlink( DEFAULT_NAME );
   fatal_posix_service_status( status, 0, "mq_unlink locked message queue");
 
   n_mq = mq_open( DEFAULT_NAME, DEFAULT_ATTR, 0x777, NULL );
   rtems_test_assert( n_mq != (-1) );
   rtems_test_assert( n_mq != Test_q[ DEFAULT_RW ].mq );
 
 
   status = mq_unlink( DEFAULT_NAME );
   fatal_posix_service_status( status, 0, "mq_unlink locked message queue");
   status = mq_close( Test_q[ DEFAULT_RW ].mq );
   fatal_posix_service_status( status, 0, "mq_close message queue");
 
   Test_q[ DEFAULT_RW ].mq = n_mq;
 }
 
 void verify_close_functionality(void)
 {
   int i;
   int status;
   Start_Test( "Unlink and Close All Files"  );
   for (i=0; i<DEFAULT_RW; i++) {
 
     status = mq_unlink( Get_Queue_Name(i) );
     fatal_posix_service_status( status, 0, "mq_unlink message queue");
 
     status = mq_close( Test_q[i].mq );
     fatal_posix_service_status( status, 0, "mq_close message queue");
   }
 }
 
 
 void verify_timed_send_queue(
   int  que,
   int  is_blocking
 )
 {
   struct timespec timeout;
   struct timeval  tv1, tv2, tv3;
   struct timezone tz1, tz2;
   int              len;
   int              status;
   char            *msg;
 
   printf( "Init: mq_timedsend - on queue %s ", Test_q[que].name);
   len = Predefined_Msgs[MAXMSG].size;
   msg = Predefined_Msgs[MAXMSG].msg;
 
   gettimeofday( &tv1, &tz1 );
   timeout.tv_sec  = tv1.tv_sec + 1;
   timeout.tv_nsec = tv1.tv_usec * 1000;
 
   status = mq_timedsend( Test_q[que].mq, msg, len , 0, &timeout );
 
   gettimeofday( &tv2, &tz2 );
   tv3.tv_sec  = tv2.tv_sec - tv1.tv_sec;
   tv3.tv_usec = tv2.tv_usec - tv1.tv_usec;
 
   if ( is_blocking ) { /* Don't verify the non-blocking queue */
     fatal_int_service_status( status, -1, "mq_timedsend status" );
     fatal_posix_service_status( errno, ETIMEDOUT,  "errno ETIMEDOUT" );
   }
 
   printf( "Init: %ld sec %ld us\n", (long)tv3.tv_sec, (long)tv3.tv_usec );
 
   if ( que == DEFAULT_RW )
     Test_q[que].count++;
 }
 
 void verify_timed_send(void)
 {
   int              que;
 
   Start_Test( "mq_timedsend"  );
 
   for( que = RW_QUEUE; que < CLOSED; que++ ) {
     if ( que == BLOCKING )
       verify_timed_send_queue( que, 1 );
     else
       verify_timed_send_queue( que, 0 );
   }
 }
 
 void verify_timed_receive_queue(
   char *task_name,
   int   que,
   int   is_blocking
 )
 {
   char message[ 100 ];
   unsigned int priority;
   struct timespec tm;
   struct timeval  tv1, tv2, tv3;
   struct timezone tz1, tz2;
   int              status;
 
   printf(
     "Init: %s mq_timedreceive - on queue %s ",
     task_name,
     Test_q[que].name
   );
 
   gettimeofday( &tv1, &tz1 );
   tm.tv_sec  = tv1.tv_sec + 1;
   tm.tv_nsec = tv1.tv_usec * 1000;
 
   status = mq_timedreceive( Test_q[ que ].mq, message, 100, &priority, &tm );
 
   gettimeofday( &tv2, &tz2 );
   tv3.tv_sec  = tv2.tv_sec - tv1.tv_sec;
   tv3.tv_usec = tv2.tv_usec - tv1.tv_usec;
 
   fatal_int_service_status( status, -1, "mq_timedreceive status");
   if ( is_blocking )
     fatal_posix_service_status( errno, ETIMEDOUT,  "errno ETIMEDOUT");
   printf( "Init: %ld sec %ld us\n", (long)tv3.tv_sec, (long)tv3.tv_usec );
 
 }
 
 void verify_timed_receive(void)
 {
   int  que;
 
   Start_Test( "mq_timedreceive"  );
 
   for( que = RW_QUEUE; que < CLOSED; que++ ) {
     if (( que == BLOCKING ) || ( que == DEFAULT_RW ))
       verify_timed_receive_queue( "Init:", que, 1 );
     else
       verify_timed_receive_queue( "Init:", que, 0 );
   }
 }
 
 #if (0)
 void verify_set_attr(void)
 {
   struct mq_attr save_attr[ NUMBER_OF_TEST_QUEUES ];
   struct mq_attr attr;
   int            i;
   int            status;
 
   attr.mq_maxmsg  = 0;
   attr.mq_msgsize = 0;
 
   Start_Test( "mq_setattr"  );
 
   puts( "Init: set_attr all queues to blocking" );
   for(i=0; i<CLOSED; i++) {
     attr.mq_flags =  Test_q[i].oflag & (~O_NONBLOCK );
     status = mq_setattr( Test_q[i].mq, &attr, &save_attr[i] );
     fatal_int_service_status( status, 0, "mq_setattr valid return status");
 
     Validate_attributes( Test_q[i].mq, attr.mq_flags, 0 );
   }
 
   for( i = RW_QUEUE; i < CLOSED; i++ ) {
     verify_timed_receive_queue( "Init:", i, 1 );
   }
 
   for(i=0; i<CLOSED; i++) {
     attr.mq_flags =  Test_q[i].oflag & (~O_NONBLOCK );
     status = mq_setattr( Test_q[i].mq, &save_attr[i], NULL );
     fatal_int_service_status( status, 0, "mq_setattr valid return status");
 
     Validate_attributes( Test_q[i].mq, Test_q[i].oflag, 0 );
   }
 }
 #endif
 
 void wait_for_signal(
   sigset_t     *waitset,
   int           sec,
   int           expect_signal
 )
 {
 #if defined(RTEMS_POSIX_API)
   siginfo_t         siginfo;
   int               status;
   struct timespec   timeout;
   int               signo;
 
   siginfo.si_code = -1;
   siginfo.si_signo = -1;
   siginfo.si_value.sival_int = -1;
 
   timeout.tv_sec = sec;
   timeout.tv_nsec = 0;
 
   status = sigemptyset( waitset );
   rtems_test_assert( !status );
 
   status = sigaddset( waitset, SIGUSR1 );
   rtems_test_assert( !status );
 
   printf( "waiting on any signal for %d seconds.\n", sec );
   signo = sigtimedwait( waitset, &siginfo, &timeout );
   if (expect_signal) {
     fatal_int_service_status( signo, SIGUSR1, "got SISUSR1" );
   } else {
     fatal_int_service_status( signo, -1, "error return status");
     fatal_posix_service_status( errno, EAGAIN, "errno EAGAIN");
   }
 #endif
 }
 
 void verify_notify(void)
 {
 #if defined(RTEMS_POSIX_API)
   struct sigevent event;
   int             status;
   timer_t         timer_id;
   sigset_t        set;
 
   Start_Test( "mq_notify"  );
 
   /* timer create */
   event.sigev_notify = SIGEV_SIGNAL;
   event.sigev_signo  = SIGUSR1;
   if (timer_create (CLOCK_REALTIME, &event, &timer_id) == -1)
     fatal_posix_service_status( errno, 0,  "errno ETIMEDOUT");
 
   /* block the timer signal */
   sigemptyset( &set );
   sigaddset( &set, SIGUSR1 );
   pthread_sigmask( SIG_BLOCK, &set, NULL );
 
   /*
    * EBADF - Not A Valid Message Queue
    */
 
   puts( "Init: mq_notify - Unopened message queue (EBADF)" );
   status = mq_notify( Test_q[CLOSED].mq, NULL );
   fatal_posix_service_status( status, -1, "mq_ error return status");
   fatal_posix_service_status( errno, EBADF, "mq_receive errno EBADF");
 
   /*
    * Create ...
    */
 
   /*
    * XXX setup notification
    */
   printf( "_____mq_notify - notify when %s gets a message\n",RW_NAME);
   status = mq_notify( Test_q[RW_QUEUE].mq, &event );
   fatal_posix_service_status( status, 0, "mq_notify valid status");
   wait_for_signal( &set, 3, 0 );
 
   /*
    * Send and verify signal occurs and registration is removed.
    */
 
   puts( "Init: Verify Signal when send" );
   Show_send_msg_to_que( "Init:", RW_QUEUE, 0 );
   wait_for_signal( &set, 3, 1 );
   Read_msg_from_que( RW_QUEUE, 0 );
 
   puts( "Init: Verify No Signal when send" );
   Show_send_msg_to_que( "Init:", RW_QUEUE, 0 );
   wait_for_signal( &set, 3, 0 );
   Read_msg_from_que( RW_QUEUE, 0 );
 
   /*
    * EBUSY - Already Registered
    */
 
   printf( "____mq_notify - notify when %s gets a message\n",RD_NAME);
   status = mq_notify( Test_q[RW_QUEUE].mq, &event );
   fatal_posix_service_status( status, 0, "mq_notify valid status");
   wait_for_signal( &set, 3, 0 );
 
   puts( "Init: mq_notify -  (EBUSY)" );
   status = mq_notify( Test_q[RW_QUEUE].mq, &event );
   fatal_posix_service_status( status, -1, "mq_notify error return status");
   fatal_posix_service_status( errno, EBUSY, "mq_notify errno EBUSY");
 
   /*
    * Verify NULL removes registration.
    */
 
   puts( "Init: mq_notify - Remove notification with null" );
   status = mq_notify( Test_q[RW_QUEUE].mq, NULL );
   fatal_posix_service_status( status, 0, "mq_notify valid status");
 
   puts( "Init: Verify No Signal when send" );
   Show_send_msg_to_que( "Init:", RW_QUEUE, 0 );
   wait_for_signal( &set, 3, 0 );
   Read_msg_from_que( RW_QUEUE, 0 );
 #endif
 }
 
 void verify_with_threads(void)
 {
   int               status;
   pthread_t         id;
   Test_Message_t   *ptr;
 #if 0
   unsigned int      priority;
   char              message[100];
 #endif
 
 
 #if 0
   /*
    * Create a task then block until the task sends the message.
    * Task tests set attributes so one queue will have a thread
    * blocked while attributes are changed.
    */
 
   Start_Test( "multi-thread Task 4 Receive Test"  );
   status = pthread_create( &id, NULL, Task_4, NULL );
   rtems_test_assert( !status );
   puts( "Init: mq_receive - Empty queue changes to non-blocking (EAGAIN)" );
   status = mq_receive( Test_q[BLOCKING].mq, message, 100, &priority );
   fatal_int_service_status( status, -1, "mq_receive error return status");
   fatal_posix_service_status( errno, EAGAIN, "mq_receive errno EAGAIN");
   print_current_time( "Init: ", "" );
 #endif
   /*
    * Create a task then block until the task sends the message.
    * Task tests set attributes so one queue will have a thread
    * blocked while attributes are changed.
    */
 
   Start_Test( "multi-thread Task 1 Test"  );
   status = pthread_create( &id, NULL, Task_1, NULL );
   rtems_test_assert( !status );
   Read_msg_from_que(  BLOCKING, 0 ); /* Block until init writes */
   print_current_time( "Init: ", "" );
 
 #if 0
   /*
    * Fill the queue then create a task then block until the task receives a message.
    * Task tests set attributes so one queue will have a thread
    * blocked while attributes are changed.
    */
 
   Start_Test( "multi-thread Task 4 Send Test"  );
   fill_message_queues( "Init:" );
   status = pthread_create( &id, NULL, Task_4, NULL );
   rtems_test_assert( !status );
   puts( "Init: mq_send - Full queue changes to non-blocking (EAGAIN)" );
   status = mq_send(Test_q[BLOCKING].mq, message, 0, 0 );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EAGAIN, "mq_send errno EAGAIN");
   verify_queues_full( "Init:" );
   empty_message_queues( "Init:" );
 #endif
   /*
    * Create a task then block until the task reads a message.
    */
 
   Start_Test( "multi-thread Task 2 Test"  );
   fill_message_queues( "Init:" );
   status = pthread_create( &id, NULL, Task_2, NULL );
   rtems_test_assert( !status );
   Show_send_msg_to_que( "Init:", BLOCKING, Priority_Order[0] );
   print_current_time( "Init: ", "" );
   verify_queues_full( "Init:" );
   empty_message_queues( "Init:" );
 
   /*
    * Create a task then block until it deletes and closes all queues.
    *     EBADF - Queue unlinked and closed while blocked
    */
 
   Start_Test( "multi-thread Task 3 Test"  );
   fill_message_queues( "Init:" );
   status = pthread_create( &id, NULL, Task_3, NULL );
   rtems_test_assert( !status );
   puts( "Init: mq_send - Block while thread deletes queue (EBADF)" );
   ptr = &Predefined_Msgs[0];
   status = mq_send( Test_q[BLOCKING].mq, ptr->msg, ptr->size , ptr->priority );
   fatal_posix_service_status( status, -1, "mq_send error return status");
   fatal_posix_service_status( errno, EBADF, "mq_send errno EBADF");
 
 }
 
 void validate_mq_setattr(void)
 {
   struct mq_attr  attr = { 0 };
   struct mq_attr  save_attr[ NUMBER_OF_TEST_QUEUES ];
   int             status;
   int            i;
 
   /*
    * EBADF - Get the attributes from a closed queue.
    */
 
   puts( "Task1:mq_setattr - unopened queue (EBADF)" );
   status = mq_setattr( Test_q[CLOSED].mq, &attr, NULL );
   fatal_posix_service_status( status, -1, "mq_setattr error return status");
   fatal_posix_service_status( errno, EBADF, "mq_setattr errno EBADF");
 
   /*
    * XXX - The following are not listed in the POSIX manual but
    *       may occur.
    */
 
   /*
    * EINVAL - NULL attributes
    */
 
   puts( "Task1:mq_setattr - NULL attributes (EINVAL)" );
   status = mq_setattr( Test_q[RW_QUEUE].mq, NULL, NULL );
   fatal_posix_service_status( status, -1, "mq_setattr error return status");
   fatal_posix_service_status( errno, EINVAL, "mq_setattr errno EINVAL");
 
   /*
    * Verify change queues to blocking, by verifying all queues block
    * for a timed receive.
    */
 
   puts( "Init: set_attr all queues to blocking" );
   for(i=0; i<CLOSED; i++) {
     attr.mq_flags =  Test_q[i].oflag & (~O_NONBLOCK );
     status = mq_setattr( Test_q[i].mq, &attr, &save_attr[i] );
     fatal_int_service_status( status, 0, "mq_setattr valid return status");
     Validate_attributes( Test_q[i].mq, attr.mq_flags, 0 );
   }
   for( i = RW_QUEUE; i < CLOSED; i++ ) {
     verify_timed_receive_queue( "Init:", i, 1 );
   }
 
   /*
    * Restore restore all queues to their old attribute.
    */
 
   for(i=0; i<CLOSED; i++) {
     status = mq_setattr( Test_q[i].mq, &save_attr[i], NULL );
     fatal_int_service_status( status, 0, "mq_setattr valid return status");
     Validate_attributes( Test_q[i].mq, Test_q[i].oflag, 0 );
   }
 }
 
 void verify_timedout_mq_timedreceive(
   char *task_name,
   int   que,
   int   is_blocking
 )
 {
   char             message[ 100 ];
   struct timespec  tm;
   struct timeval   tv1, tv2, tv3;
   struct timezone  tz1, tz2;
   int              status;
 
   printf(
     "Init: %s verify_timedout_mq_timedreceive - on queue %s ",
     task_name,
     Test_q[que].name
   );
 
   gettimeofday( &tv1, &tz1 );
   tm.tv_sec  = tv1.tv_sec - 1;
   tm.tv_nsec = tv1.tv_usec * 1000;
 
   status = mq_timedreceive( Test_q[ que ].mq, message, 100, NULL, &tm );
 
   gettimeofday( &tv2, &tz2 );
   tv3.tv_sec  = tv2.tv_sec - tv1.tv_sec;
   tv3.tv_usec = tv2.tv_usec - tv1.tv_usec;
 
   fatal_int_service_status( status, -1, "mq_timedreceive status");
 
 /* FIXME: This is wrong. */
   printf( "Init: %ld sec %ld us\n", (long)tv3.tv_sec, (long)tv3.tv_usec );
 }
 
 void verify_mq_receive(void)
 {
   int  que;
 
   Start_Test( "mq_timedout_receive"  );
 
   for( que = RW_QUEUE; que < CLOSED; que++ ) {
     if (( que == BLOCKING ) || ( que == DEFAULT_RW ))
       break;
     else
       verify_timedout_mq_timedreceive( "Init:", que, 0 );
   }
 }
 
 void verify_timedout_mq_timedsend(
   int  que,
   int  is_blocking
 )
 {
   struct timespec timeout;
   struct timeval  tv1, tv2, tv3;
   struct timezone tz1, tz2;
   int              len;
   char            *msg;
 
   printf( "Init: verify_timedout_mq_timedsend - on queue %s ", Test_q[que].name);
   len = Predefined_Msgs[MAXMSG].size;
   msg = Predefined_Msgs[MAXMSG].msg;
 
   gettimeofday( &tv1, &tz1 );
   timeout.tv_sec  = tv1.tv_sec - 1;
   timeout.tv_nsec = tv1.tv_usec * 1000;
 
   (void) mq_timedsend( Test_q[que].mq, msg, len , 0, &timeout );
 
   gettimeofday( &tv2, &tz2 );
   tv3.tv_sec  = tv2.tv_sec - tv1.tv_sec;
   tv3.tv_usec = tv2.tv_usec - tv1.tv_usec;
 
   printf( "Init: %ld sec %ld us\n", (long)tv3.tv_sec, (long)tv3.tv_usec );
 
   if ( que == DEFAULT_RW )
     Test_q[que].count++;
 }
 
 void verify_mq_send(void)
 {
   int              que;
 
   Start_Test( "verify_timedout_mq_timedsend"  );
 
   for( que = RW_QUEUE; que < CLOSED; que++ ) {
     if ( que == BLOCKING )
       verify_timedout_mq_timedsend( que, 1 );
     else
       verify_timedout_mq_timedsend( que, 0 );
   }
 }
 
 static void *receive_maxmsg_plus_one( void *arg )
 {
   mqd_t                 mq;
   const Test_Message_t *m;
   int                   i;
 
   mq = Test_q[ BLOCKING ].mq;
   m = &Predefined_Msgs[ 0 ];
 
   for ( i = 0; i < MAXMSG + 1; ++i ) {
     Test_Message_t a;
     unsigned       prio;
     ssize_t        n;
 
     n = mq_receive( mq, &a.msg[0], sizeof(a.msg), &prio);
     rtems_test_assert( n == m->size );
     rtems_test_assert( prio == m->priority );
     rtems_test_assert( memcmp( &a.msg[0], &m->msg[0], (size_t) n ) == 0 );
   }
 
   return arg;
 }
 
 static void verify_blocking_mq_timedsend( void )
 {
   mqd_t                 mq;
   const Test_Message_t *m;
   int                   status;
   struct timespec       timeout;
   pthread_t             thread;
   void                 *exit_value;
   rtems_status_code     sc;
 
   Start_Test( "verify_blocking_mq_timedsend"  );
 
   mq = Test_q[ BLOCKING ].mq;
   m = &Predefined_Msgs[ 0 ];
 
   /*
    * Create and suspend the receive thread early so that we don't overwrite the
    * ETIMEDOUT in executing->Wait.return_code.  This verifies the succesful
    * mq_timedreceive() later.
    */
 
   status = pthread_create( &thread, NULL, receive_maxmsg_plus_one, &thread );
   fatal_posix_service_status( status, 0, "pthread_create" );
 
   sc = rtems_task_suspend( thread );
   fatal_directive_status( sc, RTEMS_SUCCESSFUL, "rtems_task_suspend" );
 
   do {
     status = clock_gettime( CLOCK_REALTIME, &timeout );
     fatal_posix_service_status( status, 0, "clock_gettime" );
     ++timeout.tv_sec;
 
     status = mq_timedsend( mq, m->msg, m->size , m->priority, &timeout );
   } while ( status == 0 );
 
   fatal_posix_service_status_errno( status, ETIMEDOUT, "mq_timedsend");
 
   sc = rtems_task_resume( thread );
   fatal_directive_status( sc, RTEMS_SUCCESSFUL, "rtems_task_resume" );
 
   status = clock_gettime( CLOCK_REALTIME, &timeout );
   fatal_posix_service_status( status, 0, "clock_gettime" );
   ++timeout.tv_sec;
 
   status = mq_timedsend( mq, m->msg, m->size , m->priority, &timeout );
   fatal_posix_service_status( status, 0, "mq_timedsend" );
 
   exit_value = NULL;
   status = pthread_join( thread, &exit_value );
   fatal_posix_service_status( status, 0, "pthread_join" );
   rtems_test_assert( exit_value == &thread );
 }
 
 void *POSIX_Init(
   void *argument
 )
 {
   TEST_BEGIN();
 
   validate_mq_open_error_codes( );
   open_test_queues();
   verify_blocking_mq_timedsend();
   validate_mq_unlink_error_codes();
   validate_mq_close_error_codes();
   verify_unlink_functionality();
   validate_mq_setattr( );
   validate_mq_send_error_codes();
   validate_mq_getattr_error_codes();
   verify_timed_send();
   validate_mq_receive_error_codes();
   verify_timed_receive();
   verify_open_functionality();
   verify_notify();
   verify_with_threads();
   verify_mq_receive();
   verify_mq_send();
 
   TEST_END();
   rtems_test_exit( 0 );
 
   return NULL; /* just so the compiler thinks we returned something */
 }
 
 
 void *Task_1 (
   void *argument
 )
 {
   /* Block Waiting for a message */
 
   print_current_time( "Task_1: ", "" );
 
   Show_send_msg_to_que( "Task_1:", BLOCKING, 0 );
 
   puts( "Task_1: pthread_exit" );
   pthread_exit( NULL );
 
   /* switch to Init */
 
   rtems_test_assert( 0 );
   return NULL; /* just so the compiler thinks we returned something */
 }
 
 void *Task_2(
   void *argument
 )
 {
   print_current_time( "Task_2: ", "" );
 
 
   /* Block waiting to send a message */
 
   verify_queues_full( "Task_2:" );
   Read_msg_from_que( BLOCKING, Priority_Order[0] ); /* Cause context switch */
 
   puts( "Task_2: pthread_exit" );
   pthread_exit( NULL );
 
      /* switch to Init */
 
   return NULL; /* just so the compiler thinks we returned something */
 }
 
 void *Task_3 (
   void *argument
 )
 {
 
   print_current_time( "Task_3: ", "" );
 
   /*
    * close and unlink all queues.
    */
 
   verify_close_functionality();
   puts( "Task_3: pthread_exit" );
   pthread_exit( NULL );
 
      /* switch to Init */
 
   return NULL; /* just so the compiler thinks we returned something */
 
 }
 
 void *Task_4 (
   void *argument
 )
 {
   struct mq_attr  attr;
   int             status;
   int             count;
 
   print_current_time( "Task_4: ", "" );
 
   /*
    * Set the count to the number of messages in the queue.
    */
 
   status = mq_getattr( Test_q[BLOCKING].mq, &attr );
   fatal_posix_service_status( status, 0, "mq_getattr valid return status");
   count = attr.mq_curmsgs;
 
   puts("Task_4: Set queue to non-blocking");
   attr.mq_flags =  Test_q[BLOCKING].oflag | O_NONBLOCK;
   status = mq_setattr( Test_q[BLOCKING].mq, &attr, NULL );
   fatal_int_service_status( status, 0, "mq_setattr valid return status");
   Validate_attributes( Test_q[BLOCKING].mq, attr.mq_flags, count );
 
   puts("Task_4: Return queue to blocking");
   attr.mq_flags =  Test_q[BLOCKING].oflag;
   status = mq_setattr( Test_q[BLOCKING].mq, &attr, NULL );
   fatal_int_service_status( status, 0, "mq_setattr valid return status");
   Validate_attributes( Test_q[BLOCKING].mq, attr.mq_flags, count );
 
   puts( "Task_4: pthread_exit" );
   pthread_exit( NULL );
 
      /* switch to Init */
 
   return NULL; /* just so the compiler thinks we returned something */
 
 }
 
 void *Task_5 (
   void *argument
 )
 {
 
   print_current_time( "Task_5: ", "" );
 
   puts( "Task_5: pthread_exit" );
   pthread_exit( NULL );
 
      /* switch to Init */
 
   return NULL; /* just so the compiler thinks we returned something */
 
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team