TAO/tests/Param_Test/bd_array_seq.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    bd_array_seq.cpp
   5  *
   6  *  tests bounded array sequences
   7  *
   8  *  @author Jeff Parsons <parsons@cs.wustl.edu>
   9  */
  10 //=============================================================================
  11
  12
  13 #include "helper.h"
  14 #include "bd_array_seq.h"
  15
  16 const CORBA::ULong MAX_ARRAYSEQ_LEN = 1;
  17
  18 // ************************************************************************
  19 //               Test_Bounded_Array_Sequence
  20 // ************************************************************************
  21
  22 Test_Bounded_Array_Sequence::Test_Bounded_Array_Sequence ()
  23   : opname_ (CORBA::string_dup ("test_bounded_array_sequence")),
  24     inout_ (new Param_Test::Bounded_ArraySeq),
  25     out_ (new Param_Test::Bounded_ArraySeq),
  26     ret_ (new Param_Test::Bounded_ArraySeq)
  27 {
  28 }
  29
  30 Test_Bounded_Array_Sequence::~Test_Bounded_Array_Sequence ()
  31 {
  32   CORBA::string_free (this->opname_);
  33   this->opname_ = 0;
  34   // the other data members will be freed as they are "_var"s and objects
  35   // (rather than pointers to objects)
  36 }
  37
  38 const char *
  39 Test_Bounded_Array_Sequence::opname () const
  40 {
  41   return this->opname_;
  42 }
  43
  44 void
  45 Test_Bounded_Array_Sequence::dii_req_invoke (CORBA::Request *req)
  46 {
  47   req->add_in_arg ("s1") <<= this->in_;
  48   req->add_inout_arg ("s2") <<= this->inout_.in ();
  49   req->add_out_arg ("s3") <<= this->out_.in ();
  50   req->set_return_type (Param_Test::_tc_Bounded_ArraySeq);
  51
  52   req->invoke ();
  53
  54   const Param_Test::Bounded_ArraySeq *tmp = 0;
  55   req->return_value () >>= tmp;
  56   this->ret_ = new Param_Test::Bounded_ArraySeq (*tmp);
  57
  58   CORBA::NamedValue_ptr arg2 =
  59     req->arguments ()->item (1);
  60   *arg2->value () >>= tmp;
  61   this->inout_ = new Param_Test::Bounded_ArraySeq (*tmp);
  62
  63   CORBA::NamedValue_ptr arg3 =
  64     req->arguments ()->item (2);
  65   *arg3->value () >>= tmp;
  66   this->out_ = new Param_Test::Bounded_ArraySeq (*tmp);
  67 }
  68
  69 int
  70 Test_Bounded_Array_Sequence::init_parameters (Param_Test_ptr)
  71 {
  72   Generator *gen = GENERATOR::instance (); // value generator
  73
  74   // set the length of the sequence
  75   this->in_.length (MAX_ARRAYSEQ_LEN);
  76   // different from in_.
  77   this->inout_->length (1);
  78
  79   // now set each individual element
  80   Param_Test::Fixed_Array tmp;
  81
  82   for (CORBA::ULong j = 0; j < Param_Test::DIM1; j++)
  83     {
  84       tmp[j] = gen->gen_long ();
  85     }
  86
  87   Param_Test::Fixed_Array_copy (this->inout_[0], tmp);
  88
  89   for (CORBA::ULong i = 0; i < this->in_.length (); i++)
  90     {
  91       // Generate some arbitrary array to be filled into the ith
  92       // location in the sequence.
  93       for (CORBA::ULong j = 0; j < Param_Test::DIM1; j++)
  94         {
  95           tmp[j] = gen->gen_long ();
  96         }
  97
  98       Param_Test::Fixed_Array_copy (this->in_[i], tmp);
  99     }
 100
 101   return 0;
 102 }
 103
 104 int
 105 Test_Bounded_Array_Sequence::reset_parameters ()
 106 {
 107   // Delete the previous ones.
 108   this->inout_ = new Param_Test::Bounded_ArraySeq;
 109   this->out_ = new Param_Test::Bounded_ArraySeq;
 110   this->ret_ = new Param_Test::Bounded_ArraySeq;
 111   return 0;
 112 }
 113
 114 int
 115 Test_Bounded_Array_Sequence::run_sii_test (Param_Test_ptr objref)
 116 {
 117   try
 118     {
 119       Param_Test::Bounded_ArraySeq_out out (this->out_.out ());
 120
 121       this->ret_ =
 122         objref->test_bounded_array_sequence (this->in_,
 123                                              this->inout_.inout (),
 124                                              out);
 125
 126       return 0;
 127     }
 128   catch (const CORBA::Exception& ex)
 129     {
 130       ex._tao_print_exception ("Test_Bounded_Array_Sequence::run_sii_test\n");
 131     }
 132   return -1;
 133 }
 134
 135 CORBA::Boolean
 136 Test_Bounded_Array_Sequence::check_validity ()
 137 {
 138   if (this->compare (this->in_, this->inout_.in ()) &&
 139       this->compare (this->in_, this->out_.in ()) &&
 140       this->compare (this->in_, this->ret_.in ()))
 141     return 1;
 142   else
 143     return 0;
 144 }
 145
 146 CORBA::Boolean
 147 Test_Bounded_Array_Sequence::check_validity (CORBA::Request_ptr)
 148 {
 149   return this->check_validity ();
 150 }
 151
 152 void
 153 Test_Bounded_Array_Sequence::print_values ()
 154 {
 155   ACE_DEBUG ((LM_DEBUG,
 156               "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
 157               "IN sequence\n"));
 158   this->print_sequence (this->in_);
 159   ACE_DEBUG ((LM_DEBUG,
 160               "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
 161               "INOUT sequence\n"));
 162   this->print_sequence (this->inout_.in ());
 163   ACE_DEBUG ((LM_DEBUG,
 164               "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
 165               "OUT sequence\n"));
 166   this->print_sequence (this->out_.in ());
 167   ACE_DEBUG ((LM_DEBUG,
 168               "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n"
 169               "RET sequence\n"));
 170   this->print_sequence (this->ret_.in ());
 171 }
 172
 173 CORBA::Boolean
 174 Test_Bounded_Array_Sequence::compare (const Param_Test::Bounded_ArraySeq &s1,
 175                                       const Param_Test::Bounded_ArraySeq &s2)
 176 {
 177   if (s1.maximum () != s2.maximum ())
 178     {
 179       return 0;
 180     }
 181
 182   if (s1.length () != s2.length ())
 183     {
 184       return 0;
 185     }
 186
 187   for (CORBA::ULong i = 0; i < s1.length (); i++)
 188     {
 189       const Param_Test::Fixed_Array& vs1 = s1[i];
 190       const Param_Test::Fixed_Array& vs2 = s2[i];
 191
 192       for (CORBA::ULong j = 0; j < Param_Test::DIM1; j++)
 193         {
 194           if (vs1[j] != vs2[j])
 195             {
 196               return 0;
 197             }
 198         }
 199     }
 200
 201   return 1; // success
 202 }
 203
 204 void
 205 Test_Bounded_Array_Sequence::print_sequence (const Param_Test::Bounded_ArraySeq &s)
 206 {
 207   ACE_DEBUG ((LM_DEBUG,
 208               "maximum = %d\n"
 209               "length = %d\n",
 210               s.maximum (),
 211               s.length ()));
 212   ACE_DEBUG ((LM_DEBUG, "Elements -\n"));
 213
 214   for (CORBA::ULong i=0; i < s.length (); i++)
 215     {
 216       ACE_DEBUG ((LM_DEBUG,
 217                   "Element #%d --\n",
 218                   i));
 219
 220       const Param_Test::Fixed_Array& vs = s[i];
 221
 222       for (CORBA::ULong j = 0; j < Param_Test::DIM1; j++)
 223         {
 224           ACE_DEBUG ((LM_DEBUG,
 225                       "Element%d[%d] = %d\n",
 226                       i,
 227                       j,
 228                       vs[j]));
 229         }
 230     }
 231 }