TAO/tests/README

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