TAO/tests/README

   1
   2
   3 This directory contains a number of tests to validate that TAO is
   4 functioning correctly.  The individual directories contain READMEs on
   5 how to run the following tests:
   6
   7         . AMI
   8
   9           This is a simple test for AMI callback model.
  10
  11         . AMI_Buffering
  12
  13           Test the buffering constraint policy when applied to AMI
  14           requests.
  15
  16         . AMI_Timeouts
  17
  18           This is a simple test for AMI callback model in combination with
  19           timeouts (relative roundtrip timeout policy).
  20
  21         . Big_Oneways
  22
  23           Stress test non-blocking I/O features in the ORB.
  24
  25         . Big_Twoways
  26
  27           More stress testing for the non-blocking I/O features in the
  28           ORB, this time also test receiving big blocks of data.
  29
  30         . Big_Requests_Muxing
  31
  32           More stress testing for the non-blocking I/O features in the
  33           ORB, this time we send reliable and unreliable oneways
  34           through the same connection.
  35
  36         . Bidirectional
  37
  38           This is a test that exercises the birectional GIOP connection
  39           implementation in TAO.
  40
  41         . Bidirectional_NestedUpcall
  42
  43           This test is similar to the $TAO_ROOT/tests/BiDirectional
  44           test. The only difference is that, this test uses the
  45           select_mt reactor, which helps the server to make calls to
  46           client during the upcall.
  47
  48         . Blocking_Sync_None
  49
  50           A regression test for [BUGID:858], verifies that SYNC_NONE
  51           requests never block.
  52
  53         . CDR
  54
  55           This directory contains several tests for the CDR stream
  56           class.
  57
  58         . Client_Leaks
  59
  60           TAO-1.1.12 leaked handles, this test tries to verify that
  61           the problem does not happen any longer by connecting a
  62           client to 1000 servers.
  63
  64         . Codec
  65
  66           This test verifies that CodecFactory and CDR encapsulation
  67           Codec support is working properly.
  68
  69         . Collocation
  70
  71           This program performs a series of sanity check on the
  72           collocation support in TAO.
  73
  74         . Collocation_Opportunities
  75
  76           A test for making sure the ORB avails all collocation
  77           opportunities it is presented with.
  78
  79         . Connection_Purging
  80
  81           This is a test which stress tests the connection management
  82           and checks whether cached handlers are purged effectively
  83           when the process runs out of descriptors.
  84
  85         . Connection_Failure
  86
  87           A simple test for connection failures. The client tries to
  88           connect to an non-existent server.
  89
  90         . Crashed_Callback
  91
  92           A regression test for callbacks, sent as a reliable oneway,
  93           to a server that crashes.  The client used to hang on
  94           TAO-1.1.12.
  95
  96         . Crash_On_Write
  97
  98           A regression test for bug number 678.  The ORB used to crash
  99           if an error was detected during a write() call.  Between
 100           betas 1.1.14 and 1.1.15 the ORB would not crash but would
 101           dead-lock.
 102
 103         . DLL_ORB
 104
 105           Test that dynamically loads and unloads objects that
 106           implement client-side and server-side CORBA application
 107           code.  The primary client and server binaries are completely
 108           decoupled from the ORB.  If the test fails then it is likely
 109           that ORB resources were not reclaimed prior to dynamic
 110           unloading (i.e. finalization).
 111
 112         . DSI_Gateway
 113
 114           A simple test for the DSI/DII gateway support. TAO can
 115           optimize some demarshaling/marshaling and data copying in
 116           the implementation of DSI/DII based gateways.
 117
 118         . DynAny_Test
 119
 120           Tests TAO's DynAny feature, which allows composition and
 121           decomposition of arbitrarily complex CORBA::Any values at
 122           runtime, without requiring any compile-time knowledge of the
 123           IDL.
 124
 125         . Endpoint_Per_Priority
 126
 127           A simple test that verifies of TAO's endpoint-per-priority
 128           model works.
 129
 130         . Explicit_Event_Loop
 131
 132           This tests the methods work_pending() and perform_work()
 133           methods of the orb.
 134
 135         . Exposed_Policies
 136
 137           This directory contains a test case used to verify that the
 138           client exposed policies get embedded correctly in the IOR
 139           and exposed to the client in the object reference.
 140
 141         . FL_Cube
 142
 143           Test the integration of the FL toolkit and TAO.
 144
 145         . Faults
 146
 147           A little test to check the the ORB can handle server and
 148           client crashes.
 149
 150         . Forwarding
 151
 152           Regression test for LOCATION_FORWARD messages in the
 153           follower thread.
 154
 155         . Hello
 156
 157           Extremely simple test to establish base line and serve as
 158           code base for other tests.
 159
 160         . IDL_Test
 161
 162           A collection of the IDL examples that have caused problems
 163           in the past for the IDL compiler. Most files need only to
 164           build cleanly, except pragma.idl, which generates pragma
 165           prefixes. These prefixes are checked for correctness in
 166           main.cpp.
 167
 168         . ior_corbaloc
 169
 170           This is test to exercise the corbaname: style URL.
 171
 172         . IORManipulation
 173
 174           This program test the basic operation of TAO's
 175           IORManipulation interface.
 176
 177         . InterOp-Naming
 178
 179           This service allows the ORB to be administratively
 180           configured to return object references from
 181           CORBA::ORB::resolve_initial_references () for non-locality
 182           constrained objects.
 183
 184         . Leader_Followers
 185
 186           This is a test for server applications that have client
 187           threads (threads making remote calls) starting before event
 188           loop threads (threads running the event loop).
 189
 190         . LongUpcalls
 191
 192           Regression test for bugs #175 and #575
 193
 194         . MProfile
 195
 196           This program tests fundamentals of TAO's ORB fault tolerance
 197           by merging multiple profiles in a single object reference.
 198
 199         . MProfile_Forwarding
 200
 201           This test evalutes ORB fault tolerance support.
 202
 203         . MT_Client
 204
 205           This is a simple test for multi-threaded clients; it just
 206           creates a simple server process and runs a client with
 207           multiple thread sharing the same object reference.
 208
 209         . MT_Server
 210
 211           This is a simple test for a thread-pool server.  It creates
 212           a server process with a variable number of threads, multiple
 213           clients can send requests to it, the requests are handled in
 214           different threads.
 215
 216         . MT_Timeout
 217
 218           Test the ORB timeouts in multithreaded configurations.
 219
 220         . Multiple
 221
 222           This test make sure that the collocation scheme works fine
 223           in case of diamond shaped multiple inheritance.
 224
 225         . Multiple_Inheritance
 226
 227           This test exercises IDL interfaces that inherit from
 228           multiple interfaces.
 229
 230         . Muxing
 231
 232           Simple test for connection muxing.
 233
 234         . Native_Exceptions
 235
 236           Simple test to show (and verify) that TAO can generate code
 237           for platforms with native exception support, including
 238           passing the exception around.
 239
 240         . NestedUpcall
 241
 242           Tests TAO's nested upcall feature, which allows
 243           single-threaded clients and servers to perform callbacks on
 244           each other without deadlocking.
 245
 246         . Nested_Event_Loop
 247
 248           This is a test of invoking nested event loop calls from user
 249           code, i.e., a call to perform_work() or run() from the
 250           implementation of the servant.
 251
 252         . Oneway_Buffering
 253
 254           A regression test for the oneway buffering features in TAO.
 255           It verifies that flushing based on message count, message
 256           sizes and timeouts work correctly.
 257
 258         . ORB_destroy
 259
 260           A simple ORB destruction test.
 261
 262         . ORB_init
 263
 264           The ORB_init test simply verifies that the CORBA::ORB_init()
 265           call behaves as defined in the OMG CORBA specification.
 266
 267         . Object_Loader
 268
 269           Regression test for the DLL-style IORs.
 270
 271         . OctetSeq
 272
 273           Measures the cost of marshaling and demarshaling of
 274           sequences of octets of different sizes. NOTE: TAO optimizes
 275           this so the cost should be constant!
 276
 277         . POA
 278
 279           Tests and illustates various Portable Object Adapter (POA)
 280           interfaces and their usage scenarios.
 281
 282         . Param_Test
 283
 284           Tests all the features of TAO's protocol engine.
 285
 286         . Policies
 287
 288           This is a stress test for the ORB's Policy interfaces.
 289
 290         . Portable_Interceptors
 291
 292           A series of tests for the Portable Interceptors feature.
 293
 294         . QtTests
 295
 296           This example illustrates the usage of the QtReactor from TAO.
 297
 298         . Reliable_Oneways
 299
 300           A regression test for reliable oneways.  It is based on the
 301           fact that different SyncScope policies can detect different
 302           errors in a request.
 303
 304         . RTCORBA
 305
 306           A collection of tests exercising features from RTCORBA 1.0
 307           specification. Tests exercising TAO-specific RT features
 308           can be found in $TAO_ROOT/performance-tests/RTCorba.
 309
 310         . Single_Read
 311
 312           This is a stress test for TAO's "single read" feature.
 313
 314         . Server_Leaks
 315
 316           Try to make the server-side leak resources by connecting and
 317           disconnecting multiple clients.
 318
 319         . Smart Proxies
 320
 321           Tests the smart proxy feature which allows the user to
 322           specify a proxy in plaec of the default proxy (stub).
 323
 324         . Strategies
 325
 326           This test helps show the various ways in which the default
 327           and advanced TAO strategies can be dynamically loaded.
 328
 329         . Timed_Buffered_Oneways
 330
 331           This is a test for oneways with buffering and timing
 332           constraints.
 333
 334         . Timeout
 335
 336           A simple test for timeouts.
 337
 338         . Xt_Stopwatch
 339
 340           This example illustrates the usage of the XtReactor from
 341           TAO.
 342
 343         . UNKNOWN_Exception
 344
 345           Test of handling UNKNOWN exceptions.