summaryrefslogtreecommitdiff
path: root/TAO/tests/POA/README
blob: 9d4a03425d23d47b5ce80b08dcda994d17a9e648 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
// $Id$

The following TAO applications test and illustate various Portable
Object Adapter (POA) interfaces and their usage scenarios.

        . Identity

                The example shows the identity between servants, ids,
                and references.

        . POA_Destruction

                The program tests the destruction of a POA during an
                upcall.

        . Default_Servant

                This program tests the behavior of
                POA::id_to_servant() and POA::reference_to_servant()
                with the use of default servants.

        . Object_Reactivation

                This program tests the reactivation of a servant that
                has been deactivated but not removed from the Active
                Object Map yet.

        . Excessive_Object_Deactivations

                This program tests for excessive deactivations of a
                servant.  The test checks excessive deactivations in a
                POA with SYSTEM_ID and other POA with USER_ID.  The
                test also check for excessive deactivations during
                upcalls.

        . Non_Servant_Upcalls

                This program check the users ability to make calls on
                a POA during non-servant upcalls.  In this example, a
                servant which is being destroyed during because of a
                deactivate_object() call, tries to deactivate another
                object in its destructor.

        . wait_for_completion

                This program tests the <wait_for_completion> feature
                of the POA.

        . Single_Threaded_POA 

                This program tests to make sure that two threads
                cannot call servants in a single threaded POA
                simultaneously.  At the same time, it makes sure that
                a servant can call itself or other servants in the
                same POA while in an upcall.

        . Etherealization

                This program tests for deactivation and
                etherealization of reference counted and non reference
                counted servants.

        . Persistent_ID 

                This test checks the combination of PERSISTENT &
                SYSTEM_ID POA policies.

        . Policies

                This program tests the construction of POA policies,
                both through the generic ORB::create_policy interface
                and the PortableServer specific interfaces.

        . MT_Servant_Locator

                This program tests that multiple calls to the Servant
                Locator can take place simultaneously.

        . Nested_Non_Servant_Upcalls

                This program tests that nested non-servant upcalls are
                handled correctly.

        . POAManagerFactory
   
                The program tests the POAManagerFactory interface. Test may
                be run by hand using "POAManagerFactory -v" to get a verbose 
                report of individual tests being run.

        . EndpointPolicy 

                Tests for the endpoint policy, the server listens on two
                endpoints, one with an alias rendering it unreachable. The 
                server uses the endpoint policy to create two IORs, one with
                the only the good endpoint and another with only the bad. The
                client expects to reach the good ior and expects to fail with
                the bad ior.