TAO/tests/Queued_Message_Test/Queued_Message_Test.cpp

   1 // ============================================================================
   2 /**
   3  * @brief Unit test for the TAO_Queued_Message class
   4  *
   5  * @author Carlos O'Ryan <coryan@uci.edu>
   6  */
   7 // ============================================================================
   8
   9 #include "tao/Asynch_Queued_Message.h"
  10 #include "tao/ORB_Core.h"
  11 #include "ace/Log_Msg.h"
  12 #include "ace/Message_Block.h"
  13 #include "ace/ACE.h"
  14 #include "ace/OS_NS_stdio.h"
  15 #include "ace/OS_NS_time.h"
  16 #include "ace/OS_NS_stdlib.h"
  17
  18 /// Max number of bytes on each message block
  19 const size_t max_block_length = 256;
  20
  21 static TAO_Queued_Message *
  22 create_new_message ()
  23 {
  24   // First create a message block
  25   size_t block_size =
  26     64 + ACE_OS::rand () % (max_block_length - 64);
  27   ACE_Message_Block mb (block_size);
  28   mb.wr_ptr (block_size);
  29
  30   return new TAO_Asynch_Queued_Message (&mb, TAO_ORB_Core_instance (), 0, 0, 1);
  31 }
  32
  33 /// Add a new message at the tail of the queue.
  34 static void push_back_message (TAO_Queued_Message *&head,
  35                                TAO_Queued_Message *&tail)
  36 {
  37   TAO_Queued_Message *msg = create_new_message ();
  38   msg->push_back (head, tail);
  39 }
  40
  41 /// Add a new message at the head of the queue.
  42 static void push_front_message (TAO_Queued_Message *&head,
  43                                 TAO_Queued_Message *&tail)
  44 {
  45   TAO_Queued_Message *msg = create_new_message ();
  46   msg->push_front (head, tail);
  47 }
  48
  49 /// Remove the message at the head of the queue, and simulate the
  50 /// behavior of the I/O subsystem when processing such messages.
  51 static void del_message (TAO_Queued_Message *&head,
  52                          TAO_Queued_Message *&tail)
  53 {
  54   // ACE_DEBUG ((LM_DEBUG, "Removing message\n"));
  55   TAO_Queued_Message *current = head;
  56   current->remove_from_list (head, tail);
  57
  58   // Simulate message writing: each message is 'sent' using
  59   // multiple write() calls, in this simulation, we call the
  60   // bytes_transferred() method until all messages are removed.
  61
  62   size_t total_length = current->message_length ();
  63   while (total_length > 0)
  64     {
  65       // select how many bytes we want to 'send' in this iteration.
  66       size_t t = ACE_OS::rand () % 256 + 1;
  67
  68       if (t > total_length)
  69         t = total_length;
  70
  71       current->bytes_transferred (t);
  72       total_length -= t;
  73     }
  74   if (!current->all_data_sent ())
  75     {
  76       ACE_ERROR ((LM_DEBUG,
  77                   "ERROR: inconsistent state in Queued_Message\n"));
  78       ACE_OS::exit (1);
  79     }
  80   current->destroy ();
  81 }
  82
  83 int
  84 ACE_TMAIN(int, ACE_TCHAR *[])
  85 {
  86   // Initialize a random seed to get better coverage.
  87   // @@ The random seed and default values should be configurable
  88   // using command line options.
  89
  90   ACE_hrtime_t current_hrtime = ACE_OS::gethrtime ();
  91   ACE_UINT32 seed =
  92     ACE_CU64_TO_CU32(current_hrtime);
  93   ACE_OS::srand (seed);
  94
  95   ACE_DEBUG ((LM_DEBUG, "Running test SEED = %d\n", seed));
  96
  97   TAO_Queued_Message *head = 0;
  98   TAO_Queued_Message *tail = 0;
  99
 100   int add_count = 0;
 101   int del_count = 0;
 102
 103   const int iterations = 100;
 104   int i;
 105
 106   for (i = 0; i != iterations; ++i)
 107     {
 108       push_back_message (head, tail);
 109       add_count++;
 110
 111       if (ACE_OS::rand () % 100 > 90)
 112         {
 113           // every so often remove a message also.
 114           if (head != 0)
 115             {
 116               del_message (head, tail);
 117               del_count++;
 118             }
 119         }
 120     }
 121
 122   // second phase, change the probabilities of removing a message.
 123   for (i = 0; i != iterations; ++i)
 124     {
 125       if (ACE_OS::rand () % 100 > 90)
 126         {
 127           push_back_message (head, tail); add_count++;
 128         }
 129       if (ACE_OS::rand () % 100 > 90)
 130         {
 131           push_front_message (head, tail); add_count++;
 132         }
 133       if (head != 0)
 134         {
 135           del_message (head, tail);
 136           del_count++;
 137         }
 138     }
 139
 140   // Go through a phase where all messages are removed.
 141   while (head != 0)
 142     {
 143       del_message (head, tail);
 144       del_count++;
 145     }
 146
 147   if (tail != 0)
 148     {
 149       ACE_ERROR_RETURN ((LM_ERROR,
 150                          "ERROR: inconsistent state in message queue\n"),
 151                         1);
 152     }
 153
 154   if (add_count != del_count)
 155     {
 156       ACE_ERROR_RETURN ((LM_ERROR,
 157                          "ERROR: mismatched (%d != %d) add and del counts\n",
 158                          add_count, del_count),
 159                         1);
 160     }
 161
 162
 163   return 0;
 164 }