← Back to branch summary

~ubuntu-branches/ubuntu/raring/zeroc-icee-java/raring

« back to all changes in this revision

Viewing changes to test/IceE/proxy/AllTests.java

  • Committer: Bazaar Package Importer
  • Author(s): Francisco Moya
  • Date: 2008-08-07 23:05:39 UTC
  • mfrom: (3.1.2 gutsy)
  • Revision ID: james.westby@ubuntu.com-20080807230539-iiuezo41bclg5yxy
Tags: 1.2.0-3
http://bugs.debian.org/487027
* Upgraded packaging standards.
* Removed unsatisfiable build dependency (Closes: #487027).

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/IceE/proxy/AllTests.java
 
1
// **********************************************************************
 
2
//
 
3
// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
 
4
//
 
5
// This copy of Ice is licensed to you under the terms described in the
 
6
// ICE_LICENSE file included in this distribution.
 
7
//
 
8
// **********************************************************************
 
9
 
 
10
public class AllTests
 
11
{
 
12
    private static void
 
13
    test(boolean b)
 
14
    {
 
15
        if(!b)
 
16
        {
 
17
            throw new RuntimeException();
 
18
        }
 
19
    }
 
20
 
 
21
    public static Test.MyClassPrx
 
22
    allTests(Ice.Communicator communicator, java.io.PrintStream out)
 
23
    {
 
24
        out.print("testing stringToProxy... ");
 
25
        out.flush();
 
26
        String ref = communicator.getProperties().getPropertyWithDefault("Test.Proxy", 
 
27
                "test:default -p 12010 -t 10000");
 
28
        Ice.ObjectPrx base = communicator.stringToProxy(ref);
 
29
        test(base != null);
 
30
 
 
31
        Ice.ObjectPrx b1 = communicator.stringToProxy("test");
 
32
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
33
             b1.ice_getAdapterId().length() == 0 && b1.ice_getFacet().length() == 0);
 
34
        b1 = communicator.stringToProxy("test ");
 
35
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
36
             b1.ice_getFacet().length() == 0);
 
37
        b1 = communicator.stringToProxy(" test ");
 
38
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
39
             b1.ice_getFacet().length() == 0);
 
40
        b1 = communicator.stringToProxy(" test");
 
41
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
42
             b1.ice_getFacet().length() == 0);
 
43
        b1 = communicator.stringToProxy("'test -f facet'");
 
44
        test(b1.ice_getIdentity().name.equals("test -f facet") && b1.ice_getIdentity().category.length() == 0 &&
 
45
             b1.ice_getFacet().length() == 0);
 
46
        try
 
47
        {
 
48
            b1 = communicator.stringToProxy("\"test -f facet'");
 
49
            test(false);
 
50
        }
 
51
        catch(Ice.ProxyParseException ex)
 
52
        {
 
53
        }
 
54
        b1 = communicator.stringToProxy("\"test -f facet\"");
 
55
        test(b1.ice_getIdentity().name.equals("test -f facet") && b1.ice_getIdentity().category.length() == 0 &&
 
56
             b1.ice_getFacet().length() == 0);
 
57
        b1 = communicator.stringToProxy("\"test -f facet@test\"");
 
58
        test(b1.ice_getIdentity().name.equals("test -f facet@test") && b1.ice_getIdentity().category.length() == 0 &&
 
59
             b1.ice_getFacet().length() == 0);
 
60
        b1 = communicator.stringToProxy("\"test -f facet@test @test\"");
 
61
        test(b1.ice_getIdentity().name.equals("test -f facet@test @test") && b1.ice_getIdentity().category.length() == 0 &&
 
62
             b1.ice_getFacet().length() == 0);
 
63
        try
 
64
        {
 
65
            b1 = communicator.stringToProxy("test test");
 
66
            test(false);
 
67
        }
 
68
        catch(Ice.ProxyParseException ex)
 
69
        {
 
70
        }
 
71
        b1 = communicator.stringToProxy("test\\040test");
 
72
        test(b1.ice_getIdentity().name.equals("test test") && b1.ice_getIdentity().category.length() == 0);
 
73
        try
 
74
        {
 
75
            b1 = communicator.stringToProxy("test\\777");
 
76
            test(false);
 
77
        }
 
78
        catch(Ice.IdentityParseException ex)
 
79
        {
 
80
        }
 
81
        b1 = communicator.stringToProxy("test\\40test");
 
82
        test(b1.ice_getIdentity().name.equals("test test"));
 
83
 
 
84
        // Test some octal and hex corner cases.
 
85
        b1 = communicator.stringToProxy("test\\4test");
 
86
        test(b1.ice_getIdentity().name.equals("test\4test"));
 
87
        b1 = communicator.stringToProxy("test\\04test");
 
88
        test(b1.ice_getIdentity().name.equals("test\4test"));
 
89
        b1 = communicator.stringToProxy("test\\004test");
 
90
        test(b1.ice_getIdentity().name.equals("test\4test"));
 
91
        b1 = communicator.stringToProxy("test\\1114test");
 
92
        test(b1.ice_getIdentity().name.equals("test\1114test"));
 
93
 
 
94
        b1 = communicator.stringToProxy("test\\b\\f\\n\\r\\t\\'\\\"\\\\test");
 
95
        test(b1.ice_getIdentity().name.equals("test\b\f\n\r\t\'\"\\test") && b1.ice_getIdentity().category.length() == 0);
 
96
 
 
97
        b1 = communicator.stringToProxy("category/test");
 
98
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.equals("category") &&
 
99
             b1.ice_getAdapterId().length() == 0);
 
100
             
 
101
        b1 = communicator.stringToProxy("test@adapter");
 
102
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
103
             b1.ice_getAdapterId().equals("adapter"));
 
104
        try
 
105
        {
 
106
            b1 = communicator.stringToProxy("id@adapter test");
 
107
            test(false);
 
108
        }
 
109
        catch(Ice.ProxyParseException ex)
 
110
        {
 
111
        }
 
112
        b1 = communicator.stringToProxy("category/test@adapter");
 
113
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.equals("category") &&
 
114
             b1.ice_getAdapterId().equals("adapter"));
 
115
        b1 = communicator.stringToProxy("category/test@adapter:tcp");
 
116
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.equals("category") &&
 
117
             b1.ice_getAdapterId().equals("adapter:tcp"));
 
118
        b1 = communicator.stringToProxy("'category 1/test'@adapter");
 
119
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.equals("category 1") &&
 
120
             b1.ice_getAdapterId().equals("adapter"));
 
121
        b1 = communicator.stringToProxy("'category/test 1'@adapter");
 
122
        test(b1.ice_getIdentity().name.equals("test 1") && b1.ice_getIdentity().category.equals("category") &&
 
123
             b1.ice_getAdapterId().equals("adapter"));
 
124
        b1 = communicator.stringToProxy("'category/test'@'adapter 1'");
 
125
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.equals("category") &&
 
126
             b1.ice_getAdapterId().equals("adapter 1"));
 
127
        b1 = communicator.stringToProxy("\"category \\/test@foo/test\"@adapter");
 
128
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.equals("category /test@foo") &&
 
129
             b1.ice_getAdapterId().equals("adapter"));
 
130
        b1 = communicator.stringToProxy("\"category \\/test@foo/test\"@\"adapter:tcp\"");
 
131
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.equals("category /test@foo") &&
 
132
             b1.ice_getAdapterId().equals("adapter:tcp"));
 
133
 
 
134
        b1 = communicator.stringToProxy("id -f facet");
 
135
        test(b1.ice_getIdentity().name.equals("id") && b1.ice_getIdentity().category.length() == 0 &&
 
136
             b1.ice_getFacet().equals("facet"));
 
137
        b1 = communicator.stringToProxy("id -f 'facet x'");
 
138
        test(b1.ice_getIdentity().name.equals("id") && b1.ice_getIdentity().category.length() == 0 &&
 
139
             b1.ice_getFacet().equals("facet x"));
 
140
        b1 = communicator.stringToProxy("id -f \"facet x\"");
 
141
        test(b1.ice_getIdentity().name.equals("id") && b1.ice_getIdentity().category.length() == 0 &&
 
142
             b1.ice_getFacet().equals("facet x"));
 
143
        try
 
144
        {
 
145
            b1 = communicator.stringToProxy("id -f \"facet x");
 
146
            test(false);
 
147
        }
 
148
        catch(Ice.ProxyParseException ex)
 
149
        {
 
150
        }
 
151
        try
 
152
        {
 
153
            b1 = communicator.stringToProxy("id -f \'facet x");
 
154
            test(false);
 
155
        }
 
156
        catch(Ice.ProxyParseException ex)
 
157
        {
 
158
        }
 
159
        b1 = communicator.stringToProxy("test -f facet:tcp");
 
160
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
161
             b1.ice_getFacet().equals("facet") && b1.ice_getAdapterId().length() == 0);
 
162
        b1 = communicator.stringToProxy("test -f \"facet:tcp\"");
 
163
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
164
             b1.ice_getFacet().equals("facet:tcp") && b1.ice_getAdapterId().length() == 0);
 
165
        b1 = communicator.stringToProxy("test -f facet@test");
 
166
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
167
             b1.ice_getFacet().equals("facet") && b1.ice_getAdapterId().equals("test"));
 
168
        b1 = communicator.stringToProxy("test -f 'facet@test'");
 
169
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
170
             b1.ice_getFacet().equals("facet@test") && b1.ice_getAdapterId().length() == 0);
 
171
        b1 = communicator.stringToProxy("test -f 'facet@test'@test");
 
172
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
173
             b1.ice_getFacet().equals("facet@test") && b1.ice_getAdapterId().equals("test"));
 
174
        try
 
175
        {
 
176
            b1 = communicator.stringToProxy("test -f facet@test @test");
 
177
            test(false);
 
178
        }
 
179
        catch(Ice.ProxyParseException ex)
 
180
        {
 
181
        }
 
182
        b1 = communicator.stringToProxy("test");
 
183
        test(b1.ice_isTwoway());
 
184
        b1 = communicator.stringToProxy("test -t");
 
185
        test(b1.ice_isTwoway());
 
186
        b1 = communicator.stringToProxy("test -o");
 
187
        test(b1.ice_isOneway());
 
188
        b1 = communicator.stringToProxy("test -O");
 
189
        test(b1.ice_isBatchOneway());
 
190
        b1 = communicator.stringToProxy("test -d");
 
191
        test(b1.ice_isDatagram());
 
192
        b1 = communicator.stringToProxy("test -D");
 
193
        test(b1.ice_isBatchDatagram());
 
194
        b1 = communicator.stringToProxy("test");
 
195
        test(!b1.ice_isSecure());
 
196
        b1 = communicator.stringToProxy("test -s");
 
197
        test(b1.ice_isSecure());
 
198
 
 
199
        try
 
200
        {
 
201
            b1 = communicator.stringToProxy("test:tcp@adapterId");
 
202
            test(false);
 
203
        }
 
204
        catch(Ice.EndpointParseException ex)
 
205
        {
 
206
        }
 
207
        // This is an unknown endpoint warning, not a parse exception.
 
208
        //
 
209
        //try
 
210
        //{
 
211
        //   b1 = communicator.stringToProxy("test -f the:facet:tcp");
 
212
        //   test(false);
 
213
        //}
 
214
        //catch(Ice.EndpointParseException ex)
 
215
        //{
 
216
        //}
 
217
        try
 
218
        {
 
219
            b1 = communicator.stringToProxy("test::tcp");
 
220
            test(false);
 
221
        }
 
222
        catch(Ice.EndpointParseException ex)
 
223
        {
 
224
        }
 
225
        out.println("ok");
 
226
 
 
227
        out.print("testing propertyToProxy... ");
 
228
        out.flush();
 
229
        Ice.Properties prop = communicator.getProperties();
 
230
        String propertyPrefix = "Foo.Proxy";
 
231
        prop.setProperty(propertyPrefix, "test:default -p 12010 -t 10000");
 
232
        b1 = communicator.propertyToProxy(propertyPrefix);
 
233
        test(b1.ice_getIdentity().name.equals("test") && b1.ice_getIdentity().category.length() == 0 &&
 
234
             b1.ice_getAdapterId().length() == 0 && b1.ice_getFacet().length() == 0);
 
235
 
 
236
        // These two properties don't do anything to direct proxies so
 
237
        // first we test that.
 
238
        String property = propertyPrefix + ".Locator";
 
239
        test(b1.ice_getLocator() == null);
 
240
        prop.setProperty(property, "locator:default -p 10000");
 
241
        b1 = communicator.propertyToProxy(propertyPrefix);
 
242
        test(b1.ice_getLocator() == null);
 
243
        prop.setProperty(property, "");
 
244
 
 
245
/*
 
246
        property = propertyPrefix + ".LocatorCacheTimeout";
 
247
        test(b1.ice_getLocatorCacheTimeout() == 0);
 
248
        prop.setProperty(property, "1");
 
249
        b1 = communicator.propertyToProxy(propertyPrefix);
 
250
        test(b1.ice_getLocatorCacheTimeout() == 0);
 
251
        prop.setProperty(property, "");
 
252
*/
 
253
 
 
254
        // Now retest with an indirect proxy.
 
255
        prop.setProperty(propertyPrefix, "test");
 
256
        property = propertyPrefix + ".Locator";
 
257
        prop.setProperty(property, "locator:default -p 10000");
 
258
        b1 = communicator.propertyToProxy(propertyPrefix);
 
259
        test(b1.ice_getLocator() != null && b1.ice_getLocator().ice_getIdentity().name.equals("locator"));
 
260
        prop.setProperty(property, "");
 
261
 
 
262
/*
 
263
        property = propertyPrefix + ".LocatorCacheTimeout";
 
264
        test(b1.ice_getLocatorCacheTimeout() == -1);
 
265
        prop.setProperty(property, "1");
 
266
        b1 = communicator.propertyToProxy(propertyPrefix);
 
267
        test(b1.ice_getLocatorCacheTimeout() == 1);
 
268
        prop.setProperty(property, "");
 
269
 
 
270
        // This cannot be tested so easily because the property is cached
 
271
        // on communicator initialization.
 
272
        //
 
273
        //prop.setProperty("Ice.Default.LocatorCacheTimeout", "60");
 
274
        //b1 = communicator.propertyToProxy(propertyPrefix);
 
275
        //test(b1.ice_getLocatorCacheTimeout() == 60);
 
276
        //prop.setProperty("Ice.Default.LocatorCacheTimeout", "");
 
277
 
 
278
        prop.setProperty(propertyPrefix, "test:default -p 12010 -t 10000");
 
279
*/
 
280
 
 
281
        property = propertyPrefix + ".Router";
 
282
        test(b1.ice_getRouter() == null);
 
283
        prop.setProperty(property, "router:default -p 10000");
 
284
        b1 = communicator.propertyToProxy(propertyPrefix);
 
285
        test(b1.ice_getRouter() != null && b1.ice_getRouter().ice_getIdentity().name.equals("router"));
 
286
        prop.setProperty(property, "");
 
287
 
 
288
/*
 
289
        property = propertyPrefix + ".PreferSecure";
 
290
        test(!b1.ice_isPreferSecure());
 
291
        prop.setProperty(property, "1");
 
292
        b1 = communicator.propertyToProxy(propertyPrefix);
 
293
        test(b1.ice_isPreferSecure());
 
294
        prop.setProperty(property, "");
 
295
 
 
296
        property = propertyPrefix + ".ConnectionCached";
 
297
        test(b1.ice_isConnectionCached());
 
298
        prop.setProperty(property, "0");
 
299
        b1 = communicator.propertyToProxy(propertyPrefix);
 
300
        test(!b1.ice_isConnectionCached());
 
301
        prop.setProperty(property, "");
 
302
 
 
303
        property = propertyPrefix + ".EndpointSelection";
 
304
        test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random);
 
305
        prop.setProperty(property, "Random");
 
306
        b1 = communicator.propertyToProxy(propertyPrefix);
 
307
        test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random);
 
308
        prop.setProperty(property, "Ordered");
 
309
        b1 = communicator.propertyToProxy(propertyPrefix);
 
310
        test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Ordered);
 
311
        prop.setProperty(property, "");
 
312
 
 
313
        property = propertyPrefix + ".CollocationOptimization";
 
314
        test(b1.ice_isCollocationOptimized());
 
315
        prop.setProperty(property, "0");
 
316
        b1 = communicator.propertyToProxy(propertyPrefix);
 
317
        test(!b1.ice_isCollocationOptimized());
 
318
        prop.setProperty(property, "");
 
319
 
 
320
        property = propertyPrefix + ".ThreadPerConnection";
 
321
        test(!b1.ice_isThreadPerConnection());
 
322
        prop.setProperty(property, "1");
 
323
        b1 = communicator.propertyToProxy(propertyPrefix);
 
324
        test(b1.ice_isThreadPerConnection());
 
325
        prop.setProperty(property, "");
 
326
*/
 
327
 
 
328
        out.println("ok");
 
329
 
 
330
        out.print("testing ice_getCommunicator... ");
 
331
        out.flush();
 
332
        test(base.ice_getCommunicator() == communicator);
 
333
        out.println("ok");
 
334
 
 
335
        out.print("testing proxy methods... ");
 
336
        out.flush();
 
337
        test(communicator.identityToString(
 
338
                 base.ice_identity(communicator.stringToIdentity("other")).ice_getIdentity()).equals("other"));
 
339
        test(base.ice_facet("facet").ice_getFacet().equals("facet"));
 
340
        test(base.ice_adapterId("id").ice_getAdapterId().equals("id"));
 
341
        test(base.ice_twoway().ice_isTwoway());
 
342
        test(base.ice_oneway().ice_isOneway());
 
343
        test(base.ice_batchOneway().ice_isBatchOneway());
 
344
        test(base.ice_datagram().ice_isDatagram());
 
345
        test(base.ice_batchDatagram().ice_isBatchDatagram());
 
346
        test(base.ice_secure(true).ice_isSecure());
 
347
        test(!base.ice_secure(false).ice_isSecure());
 
348
        //test(base.ice_collocationOptimized(true).ice_isCollocationOptimized());
 
349
        //test(!base.ice_collocationOptimized(false).ice_isCollocationOptimized());
 
350
        out.println("ok");
 
351
 
 
352
        out.print("testing proxy comparison... ");
 
353
        out.flush();
 
354
 
 
355
        test(communicator.stringToProxy("foo").equals(communicator.stringToProxy("foo")));
 
356
        test(!communicator.stringToProxy("foo").equals(communicator.stringToProxy("foo2")));
 
357
 
 
358
        Ice.ObjectPrx compObj = communicator.stringToProxy("foo");
 
359
 
 
360
        test(compObj.ice_facet("facet").equals(compObj.ice_facet("facet")));
 
361
        test(!compObj.ice_facet("facet").equals(compObj.ice_facet("facet1")));
 
362
 
 
363
        test(compObj.ice_oneway().equals(compObj.ice_oneway()));
 
364
        test(!compObj.ice_oneway().equals(compObj.ice_twoway()));
 
365
 
 
366
        test(compObj.ice_secure(true).equals(compObj.ice_secure(true)));
 
367
        test(!compObj.ice_secure(false).equals(compObj.ice_secure(true)));
 
368
 
 
369
        //test(compObj.ice_collocationOptimized(true).equals(compObj.ice_collocationOptimized(true)));
 
370
        //test(!compObj.ice_collocationOptimized(false).equals(compObj.ice_collocationOptimized(true)));
 
371
 
 
372
        //test(compObj.ice_connectionCached(true).equals(compObj.ice_connectionCached(true)));
 
373
        //test(!compObj.ice_connectionCached(false).equals(compObj.ice_connectionCached(true)));
 
374
 
 
375
        //test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random).equals(
 
376
                 //compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random)));
 
377
        //test(!compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random).equals(
 
378
                 //compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered)));
 
379
 
 
380
        //test(compObj.ice_connectionId("id2").equals(compObj.ice_connectionId("id2")));
 
381
        //test(!compObj.ice_connectionId("id1").equals(compObj.ice_connectionId("id2")));
 
382
 
 
383
        //test(compObj.ice_compress(true).equals(compObj.ice_compress(true)));
 
384
        //test(!compObj.ice_compress(false).equals(compObj.ice_compress(true)));
 
385
 
 
386
        test(compObj.ice_timeout(20).equals(compObj.ice_timeout(20)));
 
387
        test(!compObj.ice_timeout(10).equals(compObj.ice_timeout(20)));
 
388
 
 
389
        Ice.ObjectPrx compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10000");
 
390
        Ice.ObjectPrx compObj2 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10001");
 
391
        test(!compObj1.equals(compObj2));
 
392
 
 
393
        compObj1 = communicator.stringToProxy("foo@MyAdapter1");
 
394
        compObj2 = communicator.stringToProxy("foo@MyAdapter2");
 
395
        test(!compObj1.equals(compObj2));
 
396
 
 
397
        //test(compObj1.ice_locatorCacheTimeout(20).equals(compObj1.ice_locatorCacheTimeout(20)));
 
398
        //test(!compObj1.ice_locatorCacheTimeout(10).equals(compObj1.ice_locatorCacheTimeout(20)));
 
399
 
 
400
        compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 1000");
 
401
        compObj2 = communicator.stringToProxy("foo@MyAdapter1");
 
402
        test(!compObj1.equals(compObj2));
 
403
 
 
404
        //
 
405
        // TODO: Ideally we should also test comparison of fixed proxies.
 
406
        //
 
407
        out.println("ok");
 
408
 
 
409
        out.print("testing checked cast... ");
 
410
        out.flush();
 
411
        Test.MyClassPrx cl = Test.MyClassPrxHelper.checkedCast(base);
 
412
        test(cl != null);
 
413
        Test.MyDerivedClassPrx derived = Test.MyDerivedClassPrxHelper.checkedCast(cl);
 
414
        test(derived != null);
 
415
        test(cl.equals(base));
 
416
        test(derived.equals(base));
 
417
        test(cl.equals(derived));
 
418
        out.println("ok");
 
419
 
 
420
        out.print("testing checked cast with context... ");
 
421
        out.flush();
 
422
 
 
423
        java.util.Hashtable c = cl.getContext();
 
424
        test(c == null || c.size() == 0);
 
425
 
 
426
        c = new java.util.Hashtable();
 
427
        c.put("one", "hello");
 
428
        c.put("two", "world");
 
429
        cl = Test.MyClassPrxHelper.checkedCast(base, c);
 
430
        java.util.Hashtable c2 = cl.getContext();
 
431
        test(IceUtil.Hashtable.equals(c, c2));
 
432
        out.println("ok");
 
433
 
 
434
        return cl;
 
435
    }
 
436
}