$Id$

This directory contains a number of tests to validate that TAO is
functioning correctly.  The individual directories contain READMEs on
how to run the following tests:

        . CDR

          This directory contains several tests for the CDR stream
          class.

        . Collocation

          This program performs a series of sanity check on the
          collocation support in TAO.

        . Connection_Purging

          This is a test which stress tests the connection management
          and checks whether cached handlers are purged effectively
          when the process runs out of descriptors.

        . DynAny_Test
        
          Tests TAO's DynAny feature, which allows composition and
          decomposition of arbitrarily complex CORBA::Any values at
          runtime, without requiring any compile-time knowledge of the
          IDL.

        . Endpoint_Per_Priority

          A simple test that verifies of TAO's endpoint-per-priority
          model works.

        . Explicit_Event_Loop

          This tests the methods work_pending() and perform_work()
          methods of the orb.

        . FL_Cube

          Test the integration of the FL toolkit and TAO.

        . Faults

          A little test to check the the ORB can handle server and
          client crashes.

        . IDL_Test

          A collection of the IDL examples that have caused problems
          in the past for the IDL compiler. Most files need only to
          build cleanly, except pragma.idl, which generates pragma
          prefixes. These prefixes are checked for correctness in
          main.cpp.

        . IORManipulation

          This program test the basic operation of TAO's
          IORManipulation interface.

        . InterOp-Naming

          This service allows the ORB to be administratively
          configured to return object references from
          CORBA::ORB::resolve_initial_references () for non-locality
          constrained objects.

        . Interceptors

          This test allows you to visually check the correct
          invocation of TAO's pseudo-portable interceptors.

        . Leader_Followers

          This is a test for server applications that have client
          threads (threads making remote calls) starting before event
          loop threads (threads running the event loop).

        . MProfile

          This program tests fundamentals of TAO's ORB fault tolerance
          by merging multiple profiles in a single object reference.

        . MProfile_Forwarding

          This test evalutes ORB fault tolerance support.

        . MT_Client

          This is a simple test for multi-threaded clients; it just
          creates a simple server process and runs a client with
          multiple thread sharing the same object reference.

        . MT_Server

          This is a simple test for a thread-pool server.  It creates
          a server process with a variable number of threads, multiple
          clients can send requests to it, the requests are handled in
          different threads.

        . Multiple_Inheritance

          This test exercises IDL interfaces that inherit from
          multiple interfaces.

        . Native_Exceptions

          Simple test to show (and verify) that TAO can generate code
          for platforms with native exception support, including
          passing the exception around.

        . NestedUpcall

          Tests TAO's nested upcall feature, which allows
          single-threaded clients and servers to perform callbacks on
          each other without deadlocking.

        . Nested_Event_Loop

          This is a test of invoking nested event loop calls from user
          code, i.e., a call to perform_work() or run() from the
          implementation of the servant.

        . ORB_init

          The ORB_init test simply verifies that the CORBA::ORB_init()
          call behaves as defined in the OMG CORBA specification.

        . OctetSeq

          Measures the cost of marshaling and demarshaling of
          sequences of octets of different sizes. NOTE: TAO optimizes
          this so the cost should be constant!

        . POA

          Tests and illustates various Portable Object Adapter (POA)
          interfaces and their usage scenarios.

        . Param_Test
 
          Tests all the features of TAO's protocol engine.

        . QtTests

          This example illustrates the usage of the QtReactor from TAO.

        . Smart Proxies
        
          Tests the smart proxy feature which allows the user to
          specify a proxy in plaec of the default proxy (stub).

        . Timed_Buffered_Oneways

          This is a test for oneways with buffering and timing
          constraints.

        . Timeout

          A simple test for timeouts.

        . Xt_Stopwatch

          This example illustrates the usage of the XtReactor from
          TAO.