TAO/tests/OctetSeq/client.cpp

   1 // -*- C++ -*-
   2 #include "ace/Get_Opt.h"
   3 #include "ace/ACE.h"
   4 #include "testC.h"
   5 #include "ace/OS_NS_time.h"
   6 #include "ace/OS_NS_string.h"
   7 #include "ace/OS_NS_unistd.h"
   8
   9 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  10 int niterations = 5;
  11 unsigned int seed = 0;
  12 int verbose = 0;
  13
  14 int
  15 parse_args (int argc, ACE_TCHAR *argv[])
  16 {
  17   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("vk:i:s:"));
  18   int c;
  19
  20   while ((c = get_opts ()) != -1)
  21     switch (c)
  22       {
  23       case 'k':
  24         ior = get_opts.opt_arg ();
  25         break;
  26
  27       case 'i':
  28         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  29         break;
  30
  31       case 's':
  32         seed = ACE_OS::atoi (get_opts.opt_arg ());
  33         break;
  34
  35       case 'v':
  36         verbose = 1;
  37         break;
  38
  39      case '?':
  40       default:
  41         ACE_ERROR_RETURN ((LM_ERROR,
  42                            "usage:  %s "
  43                            "-k <ior> "
  44                            "-i <niterations> "
  45                            "-s <seed> "
  46                            "-v "
  47                            "\n",
  48                            argv [0]),
  49                           -1);
  50       }
  51   // Indicates successful parsing of the command line
  52   return 0;
  53 }
  54
  55 int
  56 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  57 {
  58   try
  59     {
  60       CORBA::ORB_var orb =
  61         CORBA::ORB_init (argc, argv);
  62
  63       if (parse_args (argc, argv) != 0)
  64         return 1;
  65
  66       CORBA::Object_var object =
  67         orb->string_to_object (ior);
  68
  69       Test::Database_var server =
  70         Test::Database::_narrow (object.in ());
  71
  72       if (CORBA::is_nil (server.in ()))
  73         {
  74           ACE_ERROR_RETURN ((LM_ERROR,
  75                              "Object reference <%s> is nil.\n",
  76                              ior),
  77                             1);
  78         }
  79
  80 #if (TAO_HAS_MINIMUM_CORBA == 0)
  81       CORBA::String_var repository_id =
  82         server->_repository_id ();
  83
  84       if (ACE_OS::strcmp (repository_id.in (), "IDL:Test/Database:1.0") != 0)
  85         {
  86           ACE_ERROR_RETURN ((LM_ERROR,
  87                              "Repository id is wrong <%C>\n",
  88                              repository_id.in ()),
  89                             1);
  90         }
  91 #endif /* TAO_HAS_MINIMUM_CORBA == 0 */
  92
  93       if (seed == 0)
  94         {
  95           seed = static_cast<unsigned int> (ACE_OS::time (0));
  96           ACE_DEBUG ((LM_DEBUG, "Seed value is %d\n", seed));
  97         }
  98
  99       const int nelements = 64; // @@ TODO
 100       const int maxsize = 1024;
 101       Test::OctetSeq elements[nelements];
 102
 103       for (int i = 0; i != niterations; ++i)
 104         {
 105           CORBA::ULong r = ACE_OS::rand_r (&seed);
 106           Test::Index idx = (r % nelements);
 107
 108           if (i % 100 == 0)
 109             {
 110               for (int j = 0; j != nelements; ++j)
 111                 {
 112                   CORBA::ULong r = ACE_OS::rand_r (&seed);
 113                   CORBA::ULong l = r % maxsize;
 114                   elements[j].length (l);
 115                   CORBA::Double token = 0;
 116                   for (CORBA::ULong k = 0; k != l; ++k)
 117                     {
 118                       r = ACE_OS::rand_r (&seed);
 119                       elements[j][k] = (r % 128);
 120                       token += r;
 121                     }
 122                   CORBA::Double returned_token;
 123                   server->set (Test::Index (j),
 124                                elements[j],
 125                                token,
 126                                returned_token);
 127
 128                   if (!ACE::is_equal (token, returned_token))
 129                     {
 130                       ACE_ERROR ((LM_ERROR,
 131                                   "ERROR - invalid token <%f> returned,"
 132                                   " expecting %f in (%d,%d)\n",
 133                                   returned_token, token, i, j));
 134                     }
 135                 }
 136             }
 137
 138           CORBA::ULong crc_remote =
 139             server->get_crc (idx);
 140
 141           CORBA::ULong crc_local =
 142             ACE::crc32 (elements[idx].get_buffer (),
 143                         elements[idx].length ());
 144
 145           if (crc_local != crc_remote)
 146             {
 147               ACE_DEBUG ((LM_DEBUG,
 148                           "CRC mismatch for element %d\n", idx));
 149             }
 150           else if (verbose == 1)
 151             {
 152               ACE_DEBUG ((LM_DEBUG,
 153                           "CRC <%u> matched for element %d\n",
 154                           crc_remote, idx));
 155             }
 156
 157         }
 158
 159       server->shutdown ();
 160       ACE_OS::sleep(1);
 161       orb->destroy ();
 162     }
 163   catch (const CORBA::Exception& ex)
 164     {
 165       ex._tao_print_exception ("Caught exception:");
 166       return 1;
 167     }
 168
 169   return 0;
 170 }