TAO/orbsvcs/tests/Concurrency/CC_tests.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    CC_tests.cpp
   5  *
   6  *    This class implements a number of test objects to test the
   7  *    concurrency service.
   8  *
   9  *  @author Torben Worm <tworm@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "CC_tests.h"
  15 #include "ace/Log_Msg.h"
  16
  17 CC_Test::CC_Test (CC_naming_service *ns)
  18   : result (CC_FAIL),
  19     naming_service_ (ns)
  20 {
  21 }
  22
  23 CC_Test::~CC_Test ()
  24 {
  25 }
  26
  27 CosConcurrencyControl::LockSet_ptr
  28 CC_Test::create_lock_set ()
  29 {
  30   // Create the lock set and return an obj ref corresponding to the
  31   // key.
  32   CosConcurrencyControl::LockSet_ptr lock_set(0);
  33   try
  34     {
  35       lock_set =
  36         this->naming_service_->get_lock_set_factory ()->create ();
  37
  38       if (CORBA::is_nil (lock_set))
  39         ACE_ERROR_RETURN ((LM_ERROR,
  40                            "null lock set objref returned by factory\n"),
  41                           0);
  42     }
  43   catch (const CORBA::Exception& ex)
  44     {
  45       ex._tao_print_exception ("CC_Client::create_lock_set");
  46       return 0;
  47     }
  48   return lock_set;
  49 }
  50
  51 char *
  52 CC_Test::get_lock_mode_name (CosConcurrencyControl::lock_mode mode)
  53 {
  54   if (mode==CosConcurrencyControl::read)
  55     return const_cast<char *> ("read");
  56
  57   if (mode==CosConcurrencyControl::write)
  58     return const_cast<char *> ("write");
  59
  60   if (mode==CosConcurrencyControl::upgrade)
  61     return const_cast<char *> ("upgrade");
  62
  63   if (mode==CosConcurrencyControl::intention_read)
  64     return const_cast<char *> ("intension_read");
  65
  66   if (mode==CosConcurrencyControl::intention_write)
  67     return const_cast<char *> ("intension_write");
  68
  69   return const_cast<char *> ("unknown lock mode");
  70 }
  71
  72 // ================================
  73 // Here the tests start.
  74
  75 Test_Single_Lock_With_Mode::Test_Single_Lock_With_Mode (CC_naming_service *naming_service,
  76                                                         CosConcurrencyControl::lock_mode mode)
  77   : CC_Test (naming_service),
  78     mode_ (mode)
  79 {
  80 }
  81
  82 Test_Single_Lock_With_Mode::~Test_Single_Lock_With_Mode ()
  83 {
  84 }
  85
  86 int
  87 Test_Single_Lock_With_Mode::run (int /* times_to_run */)
  88 {
  89   CORBA::Boolean lock_not_held;
  90
  91   CosConcurrencyControl::LockSet_ptr cc_lock_set_ = create_lock_set ();
  92
  93   try
  94     {
  95       cc_lock_set_->lock (mode_);
  96
  97       ACE_DEBUG ((LM_DEBUG,
  98                   "%s lock set\n",
  99                   get_lock_mode_name (mode_)));
 100
 101       lock_not_held = cc_lock_set_->try_lock (mode_);
 102
 103       if (lock_not_held)
 104         {
 105           ACE_DEBUG ((LM_DEBUG,
 106                       "%s lock not held\n",
 107                       get_lock_mode_name (mode_)));
 108           return CC_FAIL;
 109         }
 110       else
 111         ACE_DEBUG ((LM_DEBUG,
 112                     "%s lock held\n",
 113                     get_lock_mode_name (mode_)));
 114
 115       cc_lock_set_->unlock (mode_);
 116       ACE_DEBUG ((LM_DEBUG,
 117                   "%s lock released\n",
 118                   get_lock_mode_name (mode_)));
 119
 120       lock_not_held = cc_lock_set_->try_lock (mode_);
 121
 122       if (lock_not_held)
 123         ACE_DEBUG ((LM_DEBUG,
 124                     "%s lock not held\n",
 125                     get_lock_mode_name (mode_)));
 126       else
 127         {
 128           ACE_DEBUG ((LM_DEBUG,
 129                       "%s lock held\n",
 130                       get_lock_mode_name (mode_)));
 131           return CC_FAIL;
 132         }
 133
 134     }
 135   catch (const CORBA::Exception& ex)
 136     {
 137       ex._tao_print_exception ("Test_Single_Lock_With_Mode::run");
 138       return CC_FAIL;
 139     }
 140
 141   CORBA::release (cc_lock_set_);
 142
 143   return CC_SUCCESS;
 144 }
 145
 146 // ================================
 147
 148 Test_Setup_LockSet::Test_Setup_LockSet (CC_naming_service *naming_service,
 149                                         char *name)
 150   : CC_Test (naming_service),
 151     my_name_ (name)
 152 {
 153 }
 154
 155 Test_Setup_LockSet::~Test_Setup_LockSet ()
 156 {
 157 }
 158
 159 int
 160 Test_Setup_LockSet::run (int /* times_to_run */)
 161 {
 162   try
 163     {
 164       CosConcurrencyControl::LockSet_ptr cc_lock_set_ =
 165         create_lock_set ();
 166       this->naming_service_->bind_name (my_name_, cc_lock_set_);
 167
 168       ACE_DEBUG ((LM_DEBUG,
 169                   "Name bound\n"));
 170
 171       cc_lock_set_->lock (CosConcurrencyControl::read);
 172
 173       ACE_DEBUG ((LM_DEBUG,
 174                   "Read lock set\n"));
 175     }
 176   catch (const CORBA::Exception& ex)
 177     {
 178       ex._tao_print_exception ("Test_Against_Other_LockSet::run");
 179       return CC_FAIL;
 180     }
 181
 182   return CC_SUCCESS;
 183 }
 184
 185 // ================================
 186
 187 Test_Use_Already_Created_LockSet::
 188 Test_Use_Already_Created_LockSet (CC_naming_service *naming_service,
 189                                   char *name)
 190   : CC_Test (naming_service),
 191     my_name_ (name)
 192 {
 193 }
 194
 195 Test_Use_Already_Created_LockSet::~Test_Use_Already_Created_LockSet ()
 196 {
 197 }
 198
 199 int
 200 Test_Use_Already_Created_LockSet::run (int /* times_to_run */)
 201 {
 202   try
 203     {
 204       CORBA::Object_var ccls_obj =
 205         this->naming_service_->get_obj_from_name (const_cast<char *> (""),
 206                                                   my_name_);
 207
 208       CosConcurrencyControl::LockSet_var ccls =
 209         CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ());
 210
 211       ccls->lock (CosConcurrencyControl::read);
 212     }
 213   catch (const CORBA::Exception& ex)
 214     {
 215       ex._tao_print_exception ("Test_Against_Other_LockSet::run");
 216       return CC_FAIL;
 217     }
 218
 219   return CC_SUCCESS;
 220 }
 221
 222 // ================================
 223
 224 Test_Unlock_Already_Created_LockSet::
 225 Test_Unlock_Already_Created_LockSet (CC_naming_service *naming_service,
 226                                      char *name)
 227   : CC_Test (naming_service),
 228     my_name_ (name)
 229 {
 230 }
 231
 232 Test_Unlock_Already_Created_LockSet::~Test_Unlock_Already_Created_LockSet ()
 233 {
 234 }
 235
 236 int
 237 Test_Unlock_Already_Created_LockSet::run (int /* times_to_run */)
 238 {
 239   try
 240     {
 241       CORBA::Object_var ccls_obj =
 242         this->naming_service_->get_obj_from_name (const_cast<char *> (""), my_name_);
 243
 244       CosConcurrencyControl::LockSet_var ccls =
 245         CosConcurrencyControl::LockSet::_narrow (ccls_obj.in ());
 246
 247       ccls->unlock (CosConcurrencyControl::read);
 248     }
 249   catch (const CORBA::Exception& ex)
 250     {
 251       ex._tao_print_exception ("Test_Unlock_Already_Created_LockSet::run");
 252       return CC_FAIL;
 253     }
 254
 255   return CC_SUCCESS;
 256 }
 257
 258 // ================================
 259
 260 Test_Release_Not_Held_Lock::Test_Release_Not_Held_Lock (CC_naming_service *naming_service,
 261                                                         CosConcurrencyControl::lock_mode mode)
 262   : CC_Test (naming_service),
 263     mode_ (mode)
 264 {
 265 }
 266
 267 Test_Release_Not_Held_Lock::~Test_Release_Not_Held_Lock ()
 268 {
 269 }
 270
 271 int
 272 Test_Release_Not_Held_Lock::run (int /* times_to_run */)
 273 {
 274   CORBA::Boolean lock_not_held;
 275
 276   // Create the lock set
 277   CosConcurrencyControl::LockSet_ptr cc_lock_set_ = create_lock_set ();
 278   try
 279     {
 280       // lock the lock
 281       cc_lock_set_->lock (mode_);
 282
 283       ACE_DEBUG ((LM_DEBUG,
 284                   "%s lock set\n",
 285                   get_lock_mode_name (mode_)));
 286
 287       // check to see if the lock is held
 288       lock_not_held = cc_lock_set_->try_lock (mode_);
 289
 290       if (lock_not_held)
 291         {
 292           ACE_DEBUG ((LM_DEBUG,
 293                       "%s lock not held\n",
 294                       get_lock_mode_name (mode_)));
 295           return CC_FAIL;
 296         }
 297       else
 298         ACE_DEBUG ((LM_DEBUG,
 299                     "%s lock held\n",
 300                     get_lock_mode_name (mode_)));
 301
 302       // release the lock
 303       cc_lock_set_->unlock (mode_);
 304       ACE_DEBUG ((LM_DEBUG,
 305                   "%s lock released\n",
 306                   get_lock_mode_name (mode_)));
 307
 308       // release the lock again. this should raise an exception
 309       cc_lock_set_->unlock (mode_);
 310
 311       ACE_DEBUG ((LM_DEBUG,
 312                   "attemptet to release %s lock\n",
 313                   get_lock_mode_name (mode_)));
 314     }
 315   catch (const CosConcurrencyControl::LockNotHeld& userex)
 316     {
 317       // We should end here
 318       ACE_UNUSED_ARG (userex);
 319       ACE_DEBUG((LM_DEBUG, "CosConcurrencyControl::LockNotHeld\n"));
 320       return CC_SUCCESS;
 321     }
 322
 323   catch (const CORBA::Exception& ex)
 324     {
 325       ex._tao_print_exception ("Test_Release_Not_Held_Lock::run");
 326       return CC_FAIL;
 327     }
 328
 329   CORBA::release (cc_lock_set_);
 330
 331   return CC_FAIL;
 332 }