TAO/tests/POA/README

   1 The following TAO applications test and illustrate various Portable
   2 Object Adapter (POA) interfaces and their usage scenarios.
   3
   4 . Identity
   5
   6         The example shows the identity between servants, ids,
   7         and references.
   8
   9 . POA_Destruction
  10
  11         The program tests the destruction of a POA during an
  12         upcall.
  13
  14 . Default_Servant
  15
  16         This program tests the behavior of
  17         POA::id_to_servant() and POA::reference_to_servant()
  18         with the use of default servants.
  19
  20 . Object_Reactivation
  21
  22         This program tests the reactivation of a servant that
  23         has been deactivated but not removed from the Active
  24         Object Map yet.
  25
  26 . Excessive_Object_Deactivations
  27
  28         This program tests for excessive deactivations of a
  29         servant.  The test checks excessive deactivations in a
  30         POA with SYSTEM_ID and other POA with USER_ID.  The
  31         test also check for excessive deactivations during
  32         upcalls.
  33
  34 . Non_Servant_Upcalls
  35
  36         This program check the users ability to make calls on
  37         a POA during non-servant upcalls.  In this example, a
  38         servant which is being destroyed during because of a
  39         deactivate_object() call, tries to deactivate another
  40         object in its destructor.
  41
  42 . wait_for_completion
  43
  44         This program tests the <wait_for_completion> feature
  45         of the POA.
  46
  47 . Single_Threaded_POA
  48
  49         This program tests to make sure that two threads
  50         cannot call servants in a single threaded POA
  51         simultaneously.  At the same time, it makes sure that
  52         a servant can call itself or other servants in the
  53         same POA while in an upcall.
  54
  55 . Etherealization
  56
  57         This program tests for deactivation and
  58         etherealization of reference counted and non reference
  59         counted servants.
  60
  61 . Persistent_ID
  62
  63         This test checks the combination of PERSISTENT &
  64         SYSTEM_ID POA policies.
  65
  66 . Policies
  67
  68         This program tests the construction of POA policies,
  69         both through the generic ORB::create_policy interface
  70         and the PortableServer specific interfaces.
  71
  72 . MT_Servant_Locator
  73
  74         This program tests that multiple calls to the Servant
  75         Locator can take place simultaneously.
  76
  77 . Nested_Non_Servant_Upcalls
  78
  79         This program tests that nested non-servant upcalls are
  80         handled correctly.
  81
  82 . POAManagerFactory
  83
  84         The program tests the POAManagerFactory interface. Test may
  85         be run by hand using "POAManagerFactory -v" to get a verbose
  86         report of individual tests being run.
  87
  88 . EndpointPolicy
  89
  90         Tests for the endpoint policy, the server listens on two
  91         endpoints, one with an alias rendering it unreachable. The
  92         server uses the endpoint policy to create two IORs, one with
  93         the only the good endpoint and another with only the bad. The
  94         client expects to reach the good ior and expects to fail with
  95         the bad ior.
  96
  97 . RootPOA
  98
  99         This example explains how to obtain the name of the
 100         RootPOA.
 101
 102 . NewPOA
 103
 104         This example explains the operations involved in
 105         creation of new POAs.
 106
 107 . FindPOA
 108
 109         This example explains registering an adapter activator
 110         for a POA and also the find_POA operation.
 111
 112 . Generic_Servant
 113
 114         A simple test interface is defined here and its
 115         implementations, server and client programs are
 116         available, which can be used for testing POA
 117         applications.  Several servers for that interface are
 118         implemented using different POA policies; a common
 119         client for all the servers is also provided.
 120
 121 . On_Demand_Activation
 122
 123         Contains programs that test the POA's 2 types of
 124         activation of objects on demand, namely , Servant
 125         Activator approach and Servant Locator , which depend
 126         on the RETAIN/NON-RETAIN policy of a POA.
 127
 128 . Default_Servant
 129
 130         Contains a File IDL module and its implementation and
 131         a server,client to test the File Module interfaces.
 132         The System interface uses the USE_DEFAULT_MANAGER policy
 133         to create a POA and registers a single File Descriptor
 134         object as the default servant. The default servant serves
 135         requests for many Descriptor objects.
 136
 137 . Explicit_Activation
 138
 139         This application explains various operations involved
 140         in the explicit activation of objects; including the
 141         creation of objects without servants (the servant is
 142         created on demand).
 143
 144 . DSI
 145
 146         The client/server couple tests the DSI features of the
 147         POA.
 148
 149 . Forwarding
 150
 151         The example is used to test the support for forwarding
 152         in TAO.  Three ways are shown: (a) Forwarding using
 153         Servant Activators, (b) Forwarding using Servant
 154         Locators, and (c) Forwarding using POA (this feature
 155         is TAO specific).
 156
 157 . TIE
 158
 159         Shows off the standard TIE features of the new CORBA
 160         2.2 specification.
 161
 162 . On_Demand_Loading
 163
 164         This example illustrates how to dynamically link and
 165         load servants into a POA in a platform-independent
 166         manner using the ACE_DLL feature and standard CORBA
 167         Servant Manager features.  In the example, the POA is
 168         configured with the USE_SERVANT_MANAGER policy value,
 169         which relies on an application supplied Servant
 170         Manager object to supply object/server associations.
 171
 172         This example illustrates both Servant Activator and
 173         Servant_Locator interfaces.  The servant object is
 174         created by a factory function that resides in a DLL
 175         that is linked and loaded into the server's address
 176         space on-demand when client requests arrive.  The
 177         ObjectID in each client request indicates which DLL
 178         name and which factory function to use to create the
 179         servant.
 180
 181   . Loader
 182
 183         This example is similar to the above except the id is
 184         not hijacked to store the DLL and factory function
 185         name.  This information is provided to the Servant
 186         Managers on creation.
 187
 188 . Explicit_Activation
 189
 190         This example is very similar to the
 191         Explicit_Activation example except that the POAs are
 192         deleted once the object references have been
 193         created. After this, an adapter activator is install
 194         in the RootPOA to reactivate the POAs on demand.
 195
 196 . Reference_Counted_Servant
 197
 198         This example shows how to use reference counted
 199         servants to automatically manage dynamic memory for
 200         servants.