TAO/tests/OBV/Collocated/Forward/Client_Task.cpp

   1
   2 #include "Client_Task.h"
   3
   4 Client_Task::Client_Task (const ACE_TCHAR *ior,
   5                           CORBA::ORB_ptr corb,
   6                           ACE_Thread_Manager *thr_mgr)
   7   : ACE_Task_Base (thr_mgr)
   8     , input_ (ior)
   9     , corb_ (CORBA::ORB::_duplicate (corb))
  10
  11 {
  12 }
  13
  14 int
  15 Client_Task::svc ()
  16 {
  17   int result = 0;
  18   try
  19     {
  20       // All factories are kindly provided by
  21       // compiler so we just to put everything in a right order.
  22
  23       // Create and register factory for BaseNode.
  24       BaseNode_init *bn_factory = 0;
  25       ACE_NEW_RETURN (bn_factory,
  26                       BaseNode_init,
  27                       1);
  28
  29       this->corb_->register_value_factory (bn_factory->tao_repository_id (),
  30                                    bn_factory);
  31       bn_factory->_remove_ref (); // release ownership
  32
  33       // Create and register factory for TreeController.
  34       TreeController_init *tc_factory = 0;
  35       ACE_NEW_RETURN (tc_factory,
  36                       TreeController_init,
  37                       1);
  38
  39       this->corb_->register_value_factory (tc_factory->tao_repository_id (),
  40                                    tc_factory);
  41       tc_factory->_remove_ref (); // release ownership
  42
  43       // Create and register factory for StringNode.
  44       StringNode_init *sn_factory = 0;
  45       ACE_NEW_RETURN (sn_factory,
  46                       StringNode_init,
  47                       1);
  48
  49       this->corb_->register_value_factory (sn_factory->tao_repository_id (),
  50                                    sn_factory);
  51       sn_factory->_remove_ref (); // release ownership
  52
  53       //Well, done with factories.
  54
  55       // Obtain reference to the object.
  56       CORBA::Object_var tmp =
  57         this->corb_->string_to_object(this->input_);
  58
  59       Test_var test = Test::_narrow(tmp.in ());
  60
  61       if (CORBA::is_nil (test.in ()))
  62       {
  63         ACE_ERROR_RETURN ((LM_DEBUG,
  64                            "Nil Test reference <%s>\n",
  65                            this->input_),
  66                           1);
  67       }
  68
  69       // Now build simple graph (tree in our case).
  70
  71       TreeController_var tc;
  72       ACE_NEW_RETURN (tc.inout (),
  73                       OBV_TreeController,
  74                       1);
  75
  76       // Create the root node.
  77       {
  78         StringNode_var sn;
  79         ACE_NEW_RETURN (sn.inout (),
  80                         OBV_StringNode,
  81                         1);
  82         sn->name ((const char*)("RootNode"));
  83         tc->root (sn);
  84
  85         // Create the left leaf.
  86         {
  87           StringNode_var dummy;
  88           ACE_NEW_RETURN (dummy.inout (),
  89                           OBV_StringNode,
  90                           1);
  91           dummy->name ((const char*)("LeftNode"));
  92           sn->left (dummy);
  93         }
  94
  95         // Create the right leaf.
  96         {
  97           StringNode_var dummy;
  98           ACE_NEW_RETURN (dummy.inout (),
  99                           OBV_StringNode,
 100                           1);
 101           dummy->name ((const char*)("RightNode"));
 102           sn->right (dummy);
 103
 104           // dummy->right (sn); // ;-)
 105         }
 106       }
 107
 108       // Make copy
 109
 110       TreeController_var tc_copy;
 111       ACE_NEW_RETURN (tc_copy.inout (),
 112                       OBV_TreeController,
 113                       1);
 114
 115       // Create the root node.
 116       {
 117         StringNode_var sn;
 118         ACE_NEW_RETURN (sn.inout (),
 119                         OBV_StringNode,
 120                         1);
 121         sn->name ((const char*)("RootNode"));
 122         tc_copy->root (sn);
 123
 124         // Create the left leaf.
 125         {
 126           StringNode_var dummy;
 127           ACE_NEW_RETURN (dummy.inout (),
 128                           OBV_StringNode,
 129                           1);
 130           dummy->name ((const char*)("LeftNode"));
 131           sn->left (dummy);
 132         }
 133
 134         // Create the right leaf.
 135         {
 136           StringNode_var dummy;
 137           ACE_NEW_RETURN (dummy.inout (),
 138                           OBV_StringNode,
 139                           1);
 140           dummy->name ((const char*)("RightNode"));
 141           sn->right (dummy);
 142
 143           // dummy->right (sn); // ;-)
 144         }
 145       }
 146
 147       if (!is_equal_tree (tc.in (), tc_copy.in ()))
 148         {
 149           ACE_ERROR ((LM_ERROR,
 150                       "ERROR: tc != tc_copy\n"));
 151           result = 1;
 152         }
 153
 154       TreeController_var tc_result =
 155         test->reflect (tc.in ());
 156
 157       // The following two ifs will fail until bug 1390 is fixed.
 158       if (is_equal_tree (tc.in (), tc_result.in ()))
 159         {
 160           ACE_ERROR ((LM_ERROR,
 161                       "ERROR: tc == tc_result\n"));
 162           result = 1;
 163         }
 164       if (result == 0 && !is_equal_tree (tc.in (), tc_copy.in ()))
 165         {
 166           ACE_ERROR ((LM_ERROR,
 167                       "ERROR: tc != tc_copy\n"));
 168           result = 1;
 169         }
 170
 171       test->shutdown ();
 172
 173       ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - test finished\n"));
 174     }
 175   catch (const CORBA::Exception& ex)
 176     {
 177       ex._tao_print_exception ("Exception caught:");
 178       return 1;
 179     }
 180
 181   return result;
 182 }
 183
 184 int
 185 Client_Task::is_equal_tree (TreeController * tree1, TreeController * tree2)
 186 {
 187   return is_equal_node (tree1->root (), tree2->root ());
 188 }
 189
 190
 191 int
 192 Client_Task::is_equal_node (BaseNode * node1, BaseNode * node2)
 193 {
 194   int ret_val = 0;
 195   if (!(node1 || node2))
 196     return 1;
 197   if (node1 && node2)
 198     {
 199       StringNode * sn1 = StringNode::_downcast (node1);
 200       StringNode * sn2 = StringNode::_downcast (node2);
 201       if (sn1 && sn2)
 202         if (!ACE_OS::strcmp (sn1->name (), sn2->name ()))
 203           ret_val = 1;
 204       if (!(sn1 || sn2))
 205         ret_val = 1;
 206       return (ret_val &&
 207               is_equal_node (node1->left (), node2->left ()) &&
 208               is_equal_node (node1->right (), node2->right ()));
 209     }
 210
 211   return 0;
 212 }
 213
 214 void
 215 Client_Task::dump_node (BaseNode *bn, int indent)
 216 {
 217   if (bn == 0) return;
 218
 219   // This is ugly I know
 220   int i = indent;
 221   for (; i != 0; i--) ACE_DEBUG ((LM_DEBUG, "  "));
 222
 223   StringNode *sn = StringNode::_downcast (bn);
 224   if (sn != 0)
 225   {
 226     ACE_DEBUG ((LM_DEBUG, "%x <StringNode> %s\n",
 227                bn,
 228                sn->name ()));
 229   }
 230   else
 231   {
 232     ACE_DEBUG ((LM_DEBUG,
 233                 "%x <BaseNode>\n",
 234                 bn));
 235   }
 236
 237   dump_node (bn->left (), indent + 1);
 238   dump_node (bn->right (), indent + 1);
 239 }
 240
 241 void
 242 Client_Task::dump_tree (TreeController *tc)
 243 {
 244   ACE_DEBUG ((LM_DEBUG,
 245               "(%P|%t) start tree dump <%x>\n",
 246               tc));
 247
 248   dump_node (tc->root (), 1);
 249
 250   ACE_DEBUG ((LM_DEBUG,
 251               "(%P|%t) end tree dump <%x>\n",
 252               tc));
 253 }