summaryrefslogtreecommitdiff
path: root/TAO/interop-tests/wchar/Client.java
blob: 821582b167eaa0de3d7c36111ac2cd8a668a5ef9 (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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
package interop.wchar;

import org.omg.CORBA.*;
import java.io.*;
import interop.*;

/**
 * Client.java
 *
 * Java implemention of the interoperability tests for wchars.
 *
 * @author Phil Mesnier
 * @version $Id$
 */

public class Client
{

    private static WCharReference ref = new WCharReference();
    private static org.omg.CORBA.ORB orb;

    private static int WCHAR_TO_SERVER = 0x0001;
    private static int WSTRING_TO_SERVER = 0x0002;
    private static int WARRAY_TO_SERVER = 0x0004;
    private static int ANY_WCHAR_TO_SERVER = 0x0008;
    private static int WSTRING_EXCEPTION = 0x0010;
    private static int WCHAR_FROM_SERVER = 0x0020;
    private static int WSTRING_FROM_SERVER = 0x0040;
    private static int WARRAY_FROM_SERVER = 0x0080;
    private static int ANY_WCHAR_FROM_SERVER = 0x0100;
    private static int TBD_6 = 0x0200;
    private static int TBD_5 = 0x0400;
    private static int TBD_4 = 0x0800;
    private static int TBD_3 = 0x1000;
    private static int TBD_2 = 0x2000;
    private static int TBD_1 = 0x4000;
    private static int TBD_0 = 0x8000;
    private static int ALL_TESTS = 0xFFFF;

    private static String test_name[] =
    {
        "wchar_to_server", "wstring_to_server", "warray_to_server",
        "any(wchar)_to_server", "wstring_exception", "wchar_from_server",
        "wstring_from_server", "warray_from_server", "any(wchar)_from_server"
    };

    private static int tests_to_run = 0;
    private static short data_set = 0;
    private static boolean verbose = false;

    private static boolean runOneTest (WChar_Passer server, int test_num)
    {
        switch (test_num)
            {
            case 0x0001: //WCHAR_TO_SERVER:
                return server.wchar_to_server (Client.
                                               ref.get_wchar(data_set),
                                               data_set);
            case 0x0002: //WSTRING_TO_SERVER:
                return server.wstring_to_server (Client.
                                                 ref.get_wstring(data_set),
                                                 data_set);
            case 0x0004: //WARRAY_TO_SERVER:
                return server.warray_to_server (Client.
                                                ref.get_warray(data_set),
                                                data_set);
            case 0x0008: //ANY_WCHAR_TO_SERVER:
                {
                    Any a = orb.create_any();
                    a.insert_wchar (ref.get_wchar(data_set));
                    return server.any_to_server (a,data_set);
                }
            case 0x0010: //WSTRING_EXCEPTION:
                {
                    try {
                        server.exception_test(data_set);
                    } catch (interop.WChar_PasserPackage.WStringException ex) {
                        return Client.ref.match_except (data_set,ex.why);
                    }
                    break;
                }
            case 0x0020: // WCHAR_FROM_SERVER:
                {
                    char wc = server.wchar_from_server (data_set);
                    return Client.ref.match_wchar (data_set,wc);
                }
            case 0x0040: //WSTRING_FROM_SERVER:
                {
                    String ws = server.wstring_from_server (data_set);
                    return Client.ref.match_wstring (data_set,ws);
                }
            case 0x0080: //WARRAY_FROM_SERVER:
                {
                    char wa[] = server.warray_from_server (data_set);
                    return Client.ref.match_warray (data_set,wa);
                }
            case 0x0100: // ANY_WCHAR_FROM_SERVER:
                {
                    if (verbose)
                        System.out.println ("test any(wchar) from server not yet implemented");
                    return true;
                }
            default:
                break;
            }
        return false;
    }

    public static boolean runTests (WChar_Passer server)
    {
        int successes = 0;
        int numtests = 0;
        ref.set_verbose (verbose);
        int t = 1;
        for (int i = 0; i < test_name.length; i++, t <<= 1)
            if ((tests_to_run & t) == t)
                {
                    boolean result = runOneTest (server,t);
                    ++numtests;
                    if (result) ++successes;
                    if (verbose)
                        System.out.println (test_name[i] +
                                            "[" + data_set + "] " +
                                            (result ? "passed" : "failed"));
                }
        if (verbose)
            System.out.println ("Total of " + successes +
                                "successes out of " + numtests + " tests");
        return successes == numtests;
    }

    public static void main( String[] args )
        throws Exception
    {
        String iorfile = "IOR";
        boolean kill_server = false;

        for (int i = 0; i < args.length; i++)
        {
            if (args[i].equals ("-i"))
                iorfile = args[++i];
            else if (args[i].equals ("-v"))
                verbose = true;
            else if (args[i].equals ("-x"))
                kill_server = true;
            else if (args[i].equals ("-t"))
            {
                int tnum = Integer.decode(args[++i]).intValue();
                if (tnum >= 0 && tnum < test_name.length)
                    tests_to_run |= (1 << tnum);
            }
            else
            {
                System.out.println( "Usage: jaco interop.wchar.Client " +
                                    "-i <ior_file> " +
                                    "-t <0 <= num < " + test_name.length + "> " +
                                    "-v " +
                                    "-x ");
                System.out.println ("Available tests:");
                for (int j = 0; i < test_name.length; i++)
                    System.out.println (j + " - " + test_name[i]);
                System.exit( 1 );
            }
        }
        if (tests_to_run == 0)
            tests_to_run = ALL_TESTS;

        File f = new File(iorfile);

        //check if file exists
        if( ! f.exists() )
        {
            System.out.println("File " + iorfile +
                               " does not exist.");
            System.exit( -1 );
        }

        //check if args[0] points to a directory
        if( f.isDirectory() )
        {
            System.out.println("File " + iorfile +
                               " is a directory.");
            System.exit( -1 );
        }

        // initialize the ORB.
        orb = org.omg.CORBA.ORB.init( args, null );

        BufferedReader br =
            new BufferedReader( new FileReader( f ));

        // get object reference from command-line argument file
        org.omg.CORBA.Object obj =
            orb.string_to_object( br.readLine() );

        br.close();

        WChar_Passer wp = WChar_PasserHelper.narrow( obj );

        boolean result = Client.runTests (wp);
        System.out.println ("wchar_interop test (Jacorb client, " +
                            wp.orb_name() + " server) " +
                            (result ? "passed" : "failed"));
        if (kill_server)
            wp.shutdown();
    }
}// Client