1#!/usr/bin/env python
2#
3# Copyright (c) ZeroC, Inc. All rights reserved.
4#
5
6import Ice, threading, sys
7
8Ice.loadSlice('-I. --all ClientPrivate.ice')
9import Test
10
11def test(b):
12    if not b:
13        raise RuntimeError('test assertion failed')
14
15class CallbackBase:
16    def __init__(self):
17        self._called = False
18        self._cond = threading.Condition()
19
20    def check(self):
21        with self._cond:
22            while not self._called:
23                self._cond.wait()
24            self._called = False
25
26    def called(self):
27        with self._cond:
28            self._called = True
29            self._cond.notify()
30
31class Callback(CallbackBase):
32    def exception_baseAsBase(self, f):
33        try:
34            f.result()
35            test(False)
36        except Test.Base as b:
37            test(b.b == "Base.b")
38            test(b.ice_id() == "::Test::Base")
39        except:
40            test(False)
41        self.called()
42
43    def exception_unknownDerivedAsBase(self, f):
44        try:
45            f.result()
46            test(False)
47        except Test.Base as b:
48            test(b.b == "UnknownDerived.b")
49            test(b.ice_id() == "::Test::Base")
50        except:
51            test(False)
52        self.called()
53
54    def exception_knownDerivedAsBase(self, f):
55        try:
56            f.result()
57            test(False)
58        except Test.KnownDerived as k:
59            test(k.b == "KnownDerived.b")
60            test(k.kd == "KnownDerived.kd")
61            test(k.ice_id() == "::Test::KnownDerived")
62        except:
63            test(False)
64        self.called()
65
66    def exception_knownDerivedAsKnownDerived(self, f):
67        try:
68            f.result()
69            test(False)
70        except Test.KnownDerived as k:
71            test(k.b == "KnownDerived.b")
72            test(k.kd == "KnownDerived.kd")
73            test(k.ice_id() == "::Test::KnownDerived")
74        except:
75            test(False)
76        self.called()
77
78    def exception_unknownIntermediateAsBase(self, f):
79        try:
80            f.result()
81            test(False)
82        except Test.Base as b:
83            test(b.b == "UnknownIntermediate.b")
84            test(b.ice_id() == "::Test::Base")
85        except:
86            test(False)
87        self.called()
88
89    def exception_knownIntermediateAsBase(self, f):
90        try:
91            f.result()
92            test(False)
93        except Test.KnownIntermediate as ki:
94            test(ki.b == "KnownIntermediate.b")
95            test(ki.ki == "KnownIntermediate.ki")
96            test(ki.ice_id() == "::Test::KnownIntermediate")
97        except:
98            test(False)
99        self.called()
100
101    def exception_knownMostDerivedAsBase(self, f):
102        try:
103            f.result()
104            test(False)
105        except Test.KnownMostDerived as kmd:
106            test(kmd.b == "KnownMostDerived.b")
107            test(kmd.ki == "KnownMostDerived.ki")
108            test(kmd.kmd == "KnownMostDerived.kmd")
109            test(kmd.ice_id() == "::Test::KnownMostDerived")
110        except:
111            test(False)
112        self.called()
113
114    def exception_knownIntermediateAsKnownIntermediate(self, f):
115        try:
116            f.result()
117            test(False)
118        except Test.KnownIntermediate as ki:
119            test(ki.b == "KnownIntermediate.b")
120            test(ki.ki == "KnownIntermediate.ki")
121            test(ki.ice_id() == "::Test::KnownIntermediate")
122        except:
123            test(False)
124        self.called()
125
126    def exception_knownMostDerivedAsKnownMostDerived(self, f):
127        try:
128            f.result()
129            test(False)
130        except Test.KnownMostDerived as kmd:
131            test(kmd.b == "KnownMostDerived.b")
132            test(kmd.ki == "KnownMostDerived.ki")
133            test(kmd.kmd == "KnownMostDerived.kmd")
134            test(kmd.ice_id() == "::Test::KnownMostDerived")
135        except:
136            test(False)
137        self.called()
138
139    def exception_knownMostDerivedAsKnownIntermediate(self, f):
140        try:
141            f.result()
142            test(False)
143        except Test.KnownMostDerived as kmd:
144            test(kmd.b == "KnownMostDerived.b")
145            test(kmd.ki == "KnownMostDerived.ki")
146            test(kmd.kmd == "KnownMostDerived.kmd")
147            test(kmd.ice_id() == "::Test::KnownMostDerived")
148        except:
149            test(False)
150        self.called()
151
152    def exception_unknownMostDerived1AsBase(self, f):
153        try:
154            f.result()
155            test(False)
156        except Test.KnownIntermediate as ki:
157            test(ki.b == "UnknownMostDerived1.b")
158            test(ki.ki == "UnknownMostDerived1.ki")
159            test(ki.ice_id() == "::Test::KnownIntermediate")
160        except:
161            test(False)
162        self.called()
163
164    def exception_unknownMostDerived1AsKnownIntermediate(self, f):
165        try:
166            f.result()
167            test(False)
168        except Test.KnownIntermediate as ki:
169            test(ki.b == "UnknownMostDerived1.b")
170            test(ki.ki == "UnknownMostDerived1.ki")
171            test(ki.ice_id() == "::Test::KnownIntermediate")
172        except:
173            test(False)
174        self.called()
175
176    def exception_unknownMostDerived2AsBase(self, f):
177        try:
178            f.result()
179            test(False)
180        except Test.Base as b:
181            test(b.b == "UnknownMostDerived2.b")
182            test(b.ice_id() == "::Test::Base")
183        except:
184            test(False)
185        self.called()
186
187class RelayI(Test.Relay):
188    def knownPreservedAsBase(self, current=None):
189        ex = Test.KnownPreservedDerived()
190        ex.b = "base"
191        ex.kp = "preserved"
192        ex.kpd = "derived"
193        raise ex
194
195    def knownPreservedAsKnownPreserved(self, current=None):
196        ex = Test.KnownPreservedDerived()
197        ex.b = "base"
198        ex.kp = "preserved"
199        ex.kpd = "derived"
200        raise ex
201
202    def unknownPreservedAsBase(self, current=None):
203        ex = Test.Preserved2()
204        ex.b = "base"
205        ex.kp = "preserved"
206        ex.kpd = "derived"
207        ex.p1 = Test.PreservedClass("bc", "pc")
208        ex.p2 = ex.p1
209        raise ex
210
211    def unknownPreservedAsKnownPreserved(self, current=None):
212        ex = Test.Preserved2()
213        ex.b = "base"
214        ex.kp = "preserved"
215        ex.kpd = "derived"
216        ex.p1 = Test.PreservedClass("bc", "pc")
217        ex.p2 = ex.p1
218        raise ex
219
220def allTests(helper, communicator):
221    obj = communicator.stringToProxy("Test:{0}".format(helper.getTestEndpoint()))
222    t = Test.TestIntfPrx.checkedCast(obj)
223
224    sys.stdout.write("base... ")
225    sys.stdout.flush()
226    try:
227        t.baseAsBase()
228        test(False)
229    except Test.Base as b:
230        test(b.b == "Base.b")
231        test(b.ice_id() == "::Test::Base")
232    except:
233        test(False)
234    print("ok")
235
236    sys.stdout.write("base (AMI)... ")
237    sys.stdout.flush()
238    cb = Callback()
239    t.baseAsBaseAsync().add_done_callback(cb.exception_baseAsBase)
240    cb.check()
241    print("ok")
242
243    sys.stdout.write("slicing of unknown derived... ")
244    sys.stdout.flush()
245    try:
246        t.unknownDerivedAsBase()
247        test(False)
248    except Test.Base as b:
249        test(b.b == "UnknownDerived.b")
250        test(b.ice_id() == "::Test::Base")
251    except:
252        test(False)
253    print("ok")
254
255    sys.stdout.write("slicing of unknown derived (AMI)... ")
256    sys.stdout.flush()
257    cb = Callback()
258    t.unknownDerivedAsBaseAsync().add_done_callback(cb.exception_unknownDerivedAsBase)
259    cb.check()
260    print("ok")
261
262    sys.stdout.write("non-slicing of known derived as base... ")
263    sys.stdout.flush()
264    try:
265        t.knownDerivedAsBase()
266        test(False)
267    except Test.KnownDerived as k:
268        test(k.b == "KnownDerived.b")
269        test(k.kd == "KnownDerived.kd")
270        test(k.ice_id() == "::Test::KnownDerived")
271    except:
272        test(False)
273    print("ok")
274
275    sys.stdout.write("non-slicing of known derived as base (AMI)... ")
276    sys.stdout.flush()
277    cb = Callback()
278    t.knownDerivedAsBaseAsync().add_done_callback(cb.exception_knownDerivedAsBase)
279    cb.check()
280    print("ok")
281
282    sys.stdout.write("non-slicing of known derived as derived... ")
283    sys.stdout.flush()
284    try:
285        t.knownDerivedAsKnownDerived()
286        test(False)
287    except Test.KnownDerived as k:
288        test(k.b == "KnownDerived.b")
289        test(k.kd == "KnownDerived.kd")
290        test(k.ice_id() == "::Test::KnownDerived")
291    except:
292        test(False)
293    print("ok")
294
295    sys.stdout.write("non-slicing of known derived as derived (AMI)... ")
296    sys.stdout.flush()
297    cb = Callback()
298    t.knownDerivedAsKnownDerivedAsync().add_done_callback(cb.exception_knownDerivedAsKnownDerived)
299    cb.check()
300    print("ok")
301
302    sys.stdout.write("slicing of unknown intermediate as base... ")
303    sys.stdout.flush()
304    try:
305        t.unknownIntermediateAsBase()
306        test(False)
307    except Test.Base as b:
308        test(b.b == "UnknownIntermediate.b")
309        test(b.ice_id() == "::Test::Base")
310    except:
311        test(False)
312    print("ok")
313
314    sys.stdout.write("slicing of unknown intermediate as base (AMI)... ")
315    sys.stdout.flush()
316    cb = Callback()
317    t.unknownIntermediateAsBaseAsync().add_done_callback(cb.exception_unknownIntermediateAsBase)
318    cb.check()
319    print("ok")
320
321    sys.stdout.write("slicing of known intermediate as base... ")
322    sys.stdout.flush()
323    try:
324        t.knownIntermediateAsBase()
325        test(False)
326    except Test.KnownIntermediate as ki:
327        test(ki.b == "KnownIntermediate.b")
328        test(ki.ki == "KnownIntermediate.ki")
329        test(ki.ice_id() == "::Test::KnownIntermediate")
330    except:
331        test(False)
332    print("ok")
333
334    sys.stdout.write("slicing of known intermediate as base (AMI)... ")
335    sys.stdout.flush()
336    cb = Callback()
337    t.knownIntermediateAsBaseAsync().add_done_callback(cb.exception_knownIntermediateAsBase)
338    cb.check()
339    print("ok")
340
341    sys.stdout.write("slicing of known most derived as base... ")
342    sys.stdout.flush()
343    try:
344        t.knownMostDerivedAsBase()
345        test(False)
346    except Test.KnownMostDerived as kmd:
347        test(kmd.b == "KnownMostDerived.b")
348        test(kmd.ki == "KnownMostDerived.ki")
349        test(kmd.kmd == "KnownMostDerived.kmd")
350        test(kmd.ice_id() == "::Test::KnownMostDerived")
351    except:
352        test(False)
353    print("ok")
354
355    sys.stdout.write("slicing of known most derived as base (AMI)... ")
356    sys.stdout.flush()
357    cb = Callback()
358    t.knownMostDerivedAsBaseAsync().add_done_callback(cb.exception_knownMostDerivedAsBase)
359    cb.check()
360    print("ok")
361
362    sys.stdout.write("non-slicing of known intermediate as intermediate... ")
363    sys.stdout.flush()
364    try:
365        t.knownIntermediateAsKnownIntermediate()
366        test(False)
367    except Test.KnownIntermediate as ki:
368        test(ki.b == "KnownIntermediate.b")
369        test(ki.ki == "KnownIntermediate.ki")
370        test(ki.ice_id() == "::Test::KnownIntermediate")
371    except:
372        test(False)
373    print("ok")
374
375    sys.stdout.write("non-slicing of known intermediate as intermediate (AMI)... ")
376    sys.stdout.flush()
377    cb = Callback()
378    t.knownIntermediateAsKnownIntermediateAsync().add_done_callback(cb.exception_knownIntermediateAsKnownIntermediate)
379    cb.check()
380    print("ok")
381
382    sys.stdout.write("non-slicing of known most derived exception as intermediate... ")
383    sys.stdout.flush()
384    try:
385        t.knownMostDerivedAsKnownIntermediate()
386        test(False)
387    except Test.KnownMostDerived as kmd:
388        test(kmd.b == "KnownMostDerived.b")
389        test(kmd.ki == "KnownMostDerived.ki")
390        test(kmd.kmd == "KnownMostDerived.kmd")
391        test(kmd.ice_id() == "::Test::KnownMostDerived")
392    except:
393        test(False)
394    print("ok")
395
396    sys.stdout.write("non-slicing of known most derived as intermediate (AMI)... ")
397    sys.stdout.flush()
398    cb = Callback()
399    t.knownMostDerivedAsKnownIntermediateAsync().add_done_callback(cb.exception_knownMostDerivedAsKnownIntermediate)
400    cb.check()
401    print("ok")
402
403    sys.stdout.write("non-slicing of known most derived as most derived... ")
404    sys.stdout.flush()
405    try:
406        t.knownMostDerivedAsKnownMostDerived()
407        test(False)
408    except Test.KnownMostDerived as kmd:
409        test(kmd.b == "KnownMostDerived.b")
410        test(kmd.ki == "KnownMostDerived.ki")
411        test(kmd.kmd == "KnownMostDerived.kmd")
412        test(kmd.ice_id() == "::Test::KnownMostDerived")
413    except:
414        test(False)
415    print("ok")
416
417    sys.stdout.write("non-slicing of known most derived as most derived (AMI)... ")
418    sys.stdout.flush()
419    cb = Callback()
420    t.knownMostDerivedAsKnownMostDerivedAsync().add_done_callback(cb.exception_knownMostDerivedAsKnownMostDerived)
421    cb.check()
422    print("ok")
423
424    sys.stdout.write("slicing of unknown most derived, known intermediate as base... ")
425    sys.stdout.flush()
426    try:
427        t.unknownMostDerived1AsBase()
428        test(False)
429    except Test.KnownIntermediate as ki:
430        test(ki.b == "UnknownMostDerived1.b")
431        test(ki.ki == "UnknownMostDerived1.ki")
432        test(ki.ice_id() == "::Test::KnownIntermediate")
433    except:
434        test(False)
435    print("ok")
436
437    sys.stdout.write("slicing of unknown most derived, known intermediate as base (AMI)... ")
438    sys.stdout.flush()
439    cb = Callback()
440    t.unknownMostDerived1AsBaseAsync().add_done_callback(cb.exception_unknownMostDerived1AsBase)
441    cb.check()
442    print("ok")
443
444    sys.stdout.write("slicing of unknown most derived, known intermediate as intermediate... ")
445    sys.stdout.flush()
446    try:
447        t.unknownMostDerived1AsKnownIntermediate()
448        test(False)
449    except Test.KnownIntermediate as ki:
450        test(ki.b == "UnknownMostDerived1.b")
451        test(ki.ki == "UnknownMostDerived1.ki")
452        test(ki.ice_id() == "::Test::KnownIntermediate")
453    except:
454        test(False)
455    print("ok")
456
457    sys.stdout.write("slicing of unknown most derived, known intermediate as intermediate (AMI)... ")
458    sys.stdout.flush()
459    cb = Callback()
460    t.unknownMostDerived1AsKnownIntermediateAsync().add_done_callback(
461        cb.exception_unknownMostDerived1AsKnownIntermediate)
462    cb.check()
463    print("ok")
464
465    sys.stdout.write("slicing of unknown most derived, unknown intermediate as base... ")
466    sys.stdout.flush()
467    try:
468        t.unknownMostDerived2AsBase()
469        test(False)
470    except Test.Base as b:
471        test(b.b == "UnknownMostDerived2.b")
472        test(b.ice_id() == "::Test::Base")
473    except:
474        test(False)
475    print("ok")
476
477    sys.stdout.write("slicing of unknown most derived, unknown intermediate as base (AMI)... ")
478    sys.stdout.flush()
479    cb = Callback()
480    t.unknownMostDerived2AsBaseAsync().add_done_callback(cb.exception_unknownMostDerived2AsBase)
481    cb.check()
482    print("ok")
483
484    sys.stdout.write("unknown most derived in compact format... ")
485    sys.stdout.flush()
486    try:
487        t.unknownMostDerived2AsBaseCompact()
488        test(False)
489    except Test.Base:
490        #
491        # For the 1.0 encoding, the unknown exception is sliced to Base.
492        #
493        test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
494    except Ice.UnknownUserException:
495        #
496        # An UnkownUserException is raised for the compact format because the
497        # most-derived type is unknown and the exception cannot be sliced.
498        #
499        test(t.ice_getEncodingVersion() != Ice.Encoding_1_0)
500    except Ice.OperationNotExistException:
501        pass
502    except:
503        test(False)
504    print("ok")
505
506    sys.stdout.write("preserved exceptions... ")
507    sys.stdout.flush()
508
509    try:
510        t.unknownPreservedAsBase();
511        test(False);
512    except Test.Base as ex:
513        if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
514            test(ex.ice_getSlicedData() is None)
515        else:
516            slicedData = ex.ice_getSlicedData();
517            test(slicedData);
518            test(len(slicedData.slices) == 2);
519            test(slicedData.slices[1].typeId == "::Test::SPreserved1");
520            test(slicedData.slices[0].typeId == "::Test::SPreserved2");
521
522    try:
523        t.unknownPreservedAsKnownPreserved();
524        test(False);
525    except Test.KnownPreserved as ex:
526        test(ex.kp == "preserved")
527        if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
528            test(ex.ice_getSlicedData() is None)
529        else:
530            slicedData = ex.ice_getSlicedData();
531            test(slicedData);
532            test(len(slicedData.slices) == 2);
533            test(slicedData.slices[1].typeId == "::Test::SPreserved1");
534            test(slicedData.slices[0].typeId == "::Test::SPreserved2");
535
536    adapter = communicator.createObjectAdapter("")
537    relay = Test.RelayPrx.uncheckedCast(adapter.addWithUUID(RelayI()))
538    adapter.activate()
539    t.ice_getConnection().setAdapter(adapter)
540
541    try:
542        t.relayKnownPreservedAsBase(relay)
543        test(False)
544    except Test.KnownPreservedDerived as ex:
545        test(ex.b == "base")
546        test(ex.kp == "preserved")
547        test(ex.kpd == "derived")
548    except Ice.OperationNotExistException:
549        pass
550    except:
551        test(False)
552
553    try:
554        t.relayKnownPreservedAsKnownPreserved(relay)
555        test(False)
556    except Test.KnownPreservedDerived as ex:
557        test(ex.b == "base")
558        test(ex.kp == "preserved")
559        test(ex.kpd == "derived")
560    except Ice.OperationNotExistException:
561        pass
562    except:
563        test(False)
564
565    try:
566        t.relayUnknownPreservedAsBase(relay)
567        test(False)
568    except Test.Preserved2 as ex:
569        test(ex.b == "base")
570        test(ex.kp == "preserved")
571        test(ex.kpd == "derived")
572        test(ex.p1.ice_id() == Test.PreservedClass.ice_staticId())
573        pc = ex.p1
574        test(isinstance(pc, Test.PreservedClass))
575        test(pc.bc == "bc")
576        test(pc.pc == "pc")
577        test(ex.p2 == ex.p1)
578    except Test.KnownPreservedDerived as ex:
579        #
580        # For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
581        #
582        test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
583        test(ex.b == "base")
584        test(ex.kp == "preserved")
585        test(ex.kpd == "derived")
586    except Ice.OperationNotExistException:
587        pass
588    except:
589        test(False)
590
591    try:
592        t.relayUnknownPreservedAsKnownPreserved(relay)
593        test(False)
594    except Test.Preserved2 as ex:
595        test(ex.b == "base")
596        test(ex.kp == "preserved")
597        test(ex.kpd == "derived")
598        test(ex.p1.ice_id() == Test.PreservedClass.ice_staticId())
599        pc = ex.p1
600        test(isinstance(pc, Test.PreservedClass))
601        test(pc.bc == "bc")
602        test(pc.pc == "pc")
603        test(ex.p2 == ex.p1)
604    except Test.KnownPreservedDerived as ex:
605        #
606        # For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
607        #
608        test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
609        test(ex.b == "base")
610        test(ex.kp == "preserved")
611        test(ex.kpd == "derived")
612    except Ice.OperationNotExistException:
613        pass
614    except:
615        test(False)
616
617    adapter.destroy()
618    print("ok")
619
620    return t
621