TAO/tests/Param_Test/bd_str_seq.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    bd_str_seq.cpp
   5  *
   6  *  tests bounded string sequences
   7  *
   8  *  @author   Aniruddha Gokhale
   9  */
  10 //=============================================================================
  11
  12
  13 #include "helper.h"
  14 #include "bd_str_seq.h"
  15
  16 // ************************************************************************
  17 //               Test_Bounded_String_Sequence
  18 // ************************************************************************
  19
  20 Test_Bounded_String_Sequence::Test_Bounded_String_Sequence ()
  21   : opname_ (CORBA::string_dup ("test_bounded_strseq")),
  22     in_ (new Param_Test::Bounded_StrSeq),
  23     inout_ (new Param_Test::Bounded_StrSeq),
  24     out_ (new Param_Test::Bounded_StrSeq),
  25     ret_ (new Param_Test::Bounded_StrSeq)
  26 {
  27 }
  28
  29 Test_Bounded_String_Sequence::~Test_Bounded_String_Sequence ()
  30 {
  31   CORBA::string_free (this->opname_);
  32   this->opname_ = 0;
  33 }
  34
  35 const char *
  36 Test_Bounded_String_Sequence::opname () const
  37 {
  38   return this->opname_;
  39 }
  40
  41 void
  42 Test_Bounded_String_Sequence::dii_req_invoke (CORBA::Request *req)
  43 {
  44   req->add_in_arg ("s1") <<= this->in_.in ();
  45   req->add_inout_arg ("s2") <<= this->inout_.in ();
  46   req->add_out_arg ("s3") <<= this->out_.in ();
  47
  48   req->set_return_type (Param_Test::_tc_Bounded_StrSeq);
  49
  50   req->invoke ();
  51
  52   const Param_Test::Bounded_StrSeq *tmp;
  53   req->return_value () >>= tmp;
  54   this->ret_ = new Param_Test::Bounded_StrSeq (*tmp);
  55
  56   CORBA::NamedValue_ptr arg2 =
  57     req->arguments ()->item (1);
  58   *arg2->value () >>= tmp;
  59   this->inout_ = new Param_Test::Bounded_StrSeq (*tmp);
  60
  61   CORBA::NamedValue_ptr arg3 =
  62     req->arguments ()->item (2);
  63   *arg3->value () >>= tmp;
  64   this->out_ = new Param_Test::Bounded_StrSeq (*tmp);
  65 }
  66
  67 int
  68 Test_Bounded_String_Sequence::init_parameters (Param_Test_ptr)
  69 {
  70   const char *choiceList[] =
  71   {
  72     "one",
  73     "two",
  74     "three"
  75   };
  76
  77   CORBA::ULong len = this->in_->maximum ();
  78
  79   // set the length of the sequence
  80   this->in_->length (len);
  81   this->inout_->length (len);
  82   // now set each individual element
  83   for (CORBA::ULong i=0; i < this->in_->length (); i++)
  84     {
  85       this->in_[i] = choiceList[i%3];
  86       this->inout_[i] = choiceList[(i+1)%3]; // different from in_
  87     }
  88   return 0;
  89 }
  90
  91 int
  92 Test_Bounded_String_Sequence::reset_parameters ()
  93 {
  94   this->inout_ = new Param_Test::Bounded_StrSeq; // delete the previous ones
  95   this->out_ = new Param_Test::Bounded_StrSeq;
  96   this->ret_ = new Param_Test::Bounded_StrSeq;
  97   return 0;
  98 }
  99
 100 int
 101 Test_Bounded_String_Sequence::run_sii_test (Param_Test_ptr objref)
 102 {
 103   try
 104     {
 105       Param_Test::Bounded_StrSeq_out out (this->out_.out ());
 106
 107       this->ret_ = objref->test_bounded_strseq (this->in_.in (),
 108                                                 this->inout_.inout (),
 109                                                 out);
 110
 111       return 0;
 112     }
 113   catch (const CORBA::Exception& ex)
 114     {
 115       ex._tao_print_exception ("Test_Bounded_String_Sequence::run_sii_test\n");
 116     }
 117   return -1;
 118 }
 119
 120 CORBA::Boolean
 121 Test_Bounded_String_Sequence::check_validity ()
 122 {
 123   CORBA::Boolean flag = 0;
 124   if ((this->in_->length () == this->inout_->length ()) &&
 125       (this->in_->length () == this->out_->length ()) &&
 126       (this->in_->length () == this->ret_->length ()))
 127     {
 128       flag = 1; // assume all are equal
 129       // lengths are same. Now compare the contents
 130       for (CORBA::ULong i=0; i < this->in_->length () && flag; i++)
 131         {
 132           if (ACE_OS::strcmp(this->in_[i], this->inout_[i]) ||
 133               ACE_OS::strcmp(this->in_[i], this->out_[i]) ||
 134               ACE_OS::strcmp(this->in_[i], this->ret_[i]))
 135             // not equal
 136             flag = 0;
 137         }
 138     }
 139   return flag;
 140 }
 141
 142 CORBA::Boolean
 143 Test_Bounded_String_Sequence::check_validity (CORBA::Request_ptr /*req*/)
 144 {
 145   //ACE_UNUSED_ARG (req);
 146   return this->check_validity ();
 147 }
 148
 149 void
 150 Test_Bounded_String_Sequence::print_values ()
 151 {
 152   CORBA::ULong i;
 153   ACE_DEBUG ((LM_DEBUG, "\n*=*=*=*=*=*=*=*=*=*=\n"));
 154   for (i=0; this->in_.ptr () && (i < this->in_->length ()); i++)
 155     {
 156       ACE_DEBUG ((LM_DEBUG,
 157                   "Element #%d\n"
 158                   "in : %C\n",
 159                   i,
 160                   this->in_[i]? (const char *)this->in_[i]:"<nul>"));
 161     }
 162   if (!this->in_.ptr ())
 163     ACE_DEBUG ((LM_DEBUG, "\nin sequence is NUL\n"));
 164   ACE_DEBUG ((LM_DEBUG, "\n*=*=*=*=*=*=*=*=*=*=\n"));
 165   for (i=0; this->inout_.ptr () && (i < this->inout_->length ()); i++)
 166     {
 167       ACE_DEBUG ((LM_DEBUG,
 168                   "Element #%d\n"
 169                   "in : %C\n",
 170                   i,
 171                   (this->inout_[i]? (const char *)this->inout_[i]:"<nul>")));
 172     }
 173   if (!this->inout_.ptr ())
 174     ACE_DEBUG ((LM_DEBUG, "\ninout sequence is NUL\n"));
 175   ACE_DEBUG ((LM_DEBUG, "\n*=*=*=*=*=*=*=*=*=*=\n"));
 176   for (i=0; this->out_.ptr () && (i < this->out_->length ()); i++)
 177     {
 178       ACE_DEBUG ((LM_DEBUG,
 179                   "Element #%d\n"
 180                   "in : %C\n",
 181                   i,
 182                   (this->out_[i]? (const char *)this->out_[i]:"<nul>")));
 183     }
 184   if (!this->out_.ptr ())
 185     ACE_DEBUG ((LM_DEBUG, "\nout sequence is NUL\n"));
 186   ACE_DEBUG ((LM_DEBUG, "\n*=*=*=*=*=*=*=*=*=*=\n"));
 187   for (i=0; this->ret_.ptr () && (i < this->ret_->length ()); i++)
 188     {
 189       ACE_DEBUG ((LM_DEBUG,
 190                   "Element #%d\n"
 191                   "in : %C\n",
 192                   i,
 193                   (this->ret_[i]? (const char *)this->ret_[i]:"<nul>")));
 194     }
 195   if (!this->ret_.ptr ())
 196     ACE_DEBUG ((LM_DEBUG, "\nin sequence is NUL\n"));
 197   ACE_DEBUG ((LM_DEBUG, "\n*=*=*=*=*=*=*=*=*=*=\n"));
 198 }