ACE/tests/ARGV_Test.cpp

   1 // ============================================================================
   2 //
   3 // = LIBRARY
   4 //    tests
   5 //
   6 // = DESCRIPTION
   7 //    This simple test illustrates how to use advanced features of
   8 //    <ACE_ARGV>.
   9 //
  10 // = AUTHOR
  11 //    Suresh Kannan <kannan@uav.ae.gatech.edu> and
  12 //    Duane Binder <duane.binder@veritas.com>
  13
  14 // ============================================================================
  15
  16 #include "ace/ARGV.h"
  17 #include "ace/Arg_Shifter.h"
  18 #include "ace/OS_NS_string.h"
  19 #include "ace/Argv_Type_Converter.h"
  20 #include "test_config.h"
  21
  22
  23
  24 static void
  25 consume_arg (int argc, ACE_TCHAR *argv[])
  26 {
  27   ACE_Arg_Shifter arg_shifter (argc, argv);
  28
  29   if (arg_shifter.is_anything_left ())
  30     arg_shifter.consume_arg (1);
  31   // Once we initialize an arg_shifter, we must iterate through it all!
  32   while ((arg_shifter.is_anything_left ()))
  33     arg_shifter.ignore_arg (1);
  34 }
  35
  36 static int
  37 test_simple_argv (ACE_TCHAR *argv[])
  38 {
  39   // From command line.
  40   ACE_ARGV cl (argv);
  41
  42   // My own stuff.
  43   ACE_ARGV my;
  44
  45   // Add to my stuff.
  46   my.add (ACE_TEXT ("-ORBEndpoint iiop://localhost:12345"));
  47
  48   // Combine the two (see the ace/ARGV.h constructors documentation).
  49   ACE_ARGV a (cl.argv (),
  50               my.argv ());
  51
  52   ACE_DEBUG ((LM_DEBUG,
  53               ACE_TEXT ("argc = %d\n"),
  54               a.argc ()));
  55
  56   // Print the contents of the combined <ACE_ARGV>.
  57   for (int i = 0; i < a.argc (); i++)
  58     ACE_DEBUG ((LM_DEBUG,
  59                 ACE_TEXT (" (%d) %s\n"),
  60                 i,
  61                 a.argv ()[i]));
  62
  63   return 0;
  64 }
  65
  66 static int
  67 test_argv_type_converter (void)
  68 {
  69   char *argv[20];
  70   argv[0] = ACE_OS::strdup ("one");
  71   argv[1] = ACE_OS::strdup ("two");
  72   argv[2] = ACE_OS::strdup ("three");
  73   argv[3] = ACE_OS::strdup ("four");
  74   argv[4] = 0;
  75
  76   char *save_argv[20];
  77   ACE_OS::memcpy (save_argv, argv, sizeof (argv));
  78
  79   int argc = 4;
  80
  81   {
  82     ACE_Argv_Type_Converter ct2 (argc, argv);
  83   }
  84
  85   {
  86     ACE_Argv_Type_Converter ct (argc, argv);
  87     ct.get_argc (); ct.get_TCHAR_argv ();
  88     consume_arg ( ct.get_argc (), ct.get_TCHAR_argv ());
  89   }
  90   {
  91     ACE_Argv_Type_Converter ct3 (argc, argv);
  92     ct3.get_argc (); ct3.get_ASCII_argv ();
  93     consume_arg ( ct3.get_argc (), ct3.get_TCHAR_argv ());
  94   }
  95
  96   {
  97     for (size_t i = 0; i < 4; i++)
  98       ACE_DEBUG ((LM_DEBUG,
  99                   ACE_TEXT (" (%d) %C\n"),
 100                   i,
 101                   argv[i]));
 102   }
 103
 104   for (size_t i = 0; save_argv[i]; ++i)
 105     ACE_OS::free (save_argv[i]);
 106
 107   return 0;
 108 }
 109
 110 static int
 111 test_argv_type_converter2 (void)
 112 {
 113   ACE_TCHAR *argv[20];
 114   argv[0] = ACE_OS::strdup (ACE_TEXT ("one"));
 115   argv[1] = ACE_OS::strdup (ACE_TEXT ("two"));
 116   argv[2] = ACE_OS::strdup (ACE_TEXT ("three"));
 117   argv[3] = ACE_OS::strdup (ACE_TEXT ("four"));
 118   argv[4] = 0;
 119
 120   ACE_TCHAR *save_argv[20];
 121   ACE_OS::memcpy (save_argv, argv, sizeof (argv));
 122
 123   int argc = 4;
 124
 125   {
 126     ACE_Argv_Type_Converter ct (argc, argv);
 127     ct.get_argc (); ct.get_TCHAR_argv ();
 128     consume_arg ( ct.get_argc (), ct.get_TCHAR_argv ());
 129   }
 130
 131   consume_arg (argc, argv);
 132
 133   {
 134     for (size_t i = 0; i < 4; i++)
 135       ACE_DEBUG ((LM_DEBUG,
 136                   ACE_TEXT (" (%d) %s\n"),
 137                   i,
 138                   argv[i]));
 139   }
 140
 141   for (size_t i = 0; save_argv[i]; ++i)
 142     ACE_OS::free (save_argv[i]);
 143
 144   return 0;
 145 }
 146
 147 static int
 148 test_argv_buf (void)
 149 {
 150   pid_t parent_pid = ACE_OS::getpid ();
 151
 152   ACE_TCHAR *l_argv[3];
 153   ACE_TCHAR pid_str[100];
 154   // Store the parent's process id so we can pass it to the child
 155   // portably.  Also, pass the test number, as well.
 156   ACE_OS::snprintf (pid_str, 100,
 157                     ACE_TEXT ("-p %ld -t %d"),
 158                     static_cast <long> (parent_pid),
 159                     1);
 160
 161   // We're going to create a new process that runs this program again,
 162   // so we need to indicate that it's the child.
 163   const ACE_TCHAR *t = ACE_TEXT (".")
 164                        ACE_DIRECTORY_SEPARATOR_STR
 165                        ACE_TEXT ("Signal_Test")
 166                        ACE_PLATFORM_EXE_SUFFIX
 167                        ACE_TEXT (" -c");
 168   l_argv[0] = const_cast <ACE_TCHAR *> (t);
 169   l_argv[1] = pid_str;
 170   l_argv[2] = 0;
 171
 172   ACE_ARGV my_argv (l_argv);
 173
 174   // This shouldn't have any quotes in it.
 175   ACE_DEBUG ((LM_DEBUG, "%s\n", my_argv.buf ()));
 176   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("argc: %d\n"), my_argv.argc ()));
 177   return 0;
 178 }
 179
 180 static int
 181 test_argv_quotes (void)
 182 {
 183   const ACE_TCHAR *argv_const[] = { ACE_TEXT ("first without quotes"),
 184                                     ACE_TEXT ("'second in single quotes'"),
 185                                     ACE_TEXT ("\"third in double quotes\""),
 186                                     0
 187                                   };
 188   ACE_TCHAR **argv = const_cast<ACE_TCHAR **> (argv_const);
 189   // The convoluted argv definition is to silence warnings from gcc 4.3, which
 190   // warns if the string-literals are not assigned to const char* and also
 191   // warns if the const char*[] is passed to the ACE_ARGV constructor as in
 192   // "args3" below.
 193
 194   int argc = 3;
 195
 196   // (argc, argv)
 197   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n*** argv ***\n")));
 198   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("argc: %d\n"), argc));
 199
 200   for (int i = 0; i < argc; ++i)
 201     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("argv[%02d] = %s\n"), i, argv[i]));
 202
 203   // args
 204   ACE_ARGV args;
 205   for (int i = 0; i < argc; ++i)
 206     args.add (argv[i]);
 207   args.add (ACE_TEXT ("'fourth in single quotes'"));
 208   args.add (ACE_TEXT ("\"fifth in double quotes\""));
 209   args.add (ACE_TEXT ("sixth without any quotes"));
 210
 211   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n*** args-1 ***\n")));
 212   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args.argc ()));
 213
 214   for (int i = 0; i < args.argc (); ++i)
 215     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args[%02d]: %s\n"), i, args[i]));
 216
 217   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args.argc ()));
 218
 219   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n*** args-2 ***\n")));
 220   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args.argc ()));
 221
 222   for (int i = 0; i < args.argc (); ++i)
 223     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argv ()[%02d]: %s\n"),
 224                 i, args.argv ()[i]));
 225
 226   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args.argc ()));
 227
 228   // args2
 229   ACE_ARGV args2;
 230   for (int i = 0; i < argc; ++i)
 231     args2.add (argv[i], true);
 232   args2.add (ACE_TEXT ("'fourth in single quotes'"), true);
 233   args2.add (ACE_TEXT ("\"fifth in double quotes\""), true);
 234   args2.add (ACE_TEXT ("sixth without any quotes"), true);
 235
 236   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n*** args-3 ***\n")));
 237   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args2.argc ()));
 238
 239   for (int i = 0; i < args2.argc (); ++i)
 240     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args[%02d]: %s\n"), i, args2[i]));
 241
 242   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args2.argc ()));
 243
 244   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n*** args-4 ***\n")));
 245   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args2.argc ()));
 246
 247   for (int i = 0; i < args2.argc (); ++i)
 248     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argv ()[%02d]: %s\n"),
 249                 i, args2.argv ()[i]));
 250
 251   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args2.argc ()));
 252
 253   // args3
 254   ACE_ARGV args3 (argv);
 255
 256   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n*** args-5 ***\n")));
 257   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args3.argc ()));
 258
 259   for (int i = 0; i < args3.argc (); ++i)
 260     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args[%02d]: %s\n"), i, args3[i]));
 261
 262   ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("args.argc (): %d\n"), args3.argc ()));
 263
 264   return 0;
 265 }
 266
 267 int
 268 run_main (int, ACE_TCHAR *argv[])
 269 {
 270   ACE_START_TEST (ACE_TEXT ("ARGV_Test"));
 271
 272   test_simple_argv (argv);
 273   test_argv_type_converter2 ();
 274   test_argv_type_converter ();
 275   test_argv_quotes ();
 276   test_argv_buf ();
 277
 278   ACE_END_TEST;
 279   return 0;
 280 }
 281