1%
2% Copyright (c) ZeroC, Inc. All rights reserved.
3%
4
5classdef AllTests
6    methods(Static)
7        function r = allTests(helper)
8            import Test.*;
9
10            communicator = helper.communicator();
11
12            ref = ['test:', helper.getTestEndpoint()];
13            obj = communicator.stringToProxy(ref);
14            assert(~isempty(obj));
15            proxy = TestIntfPrx.checkedCast(obj);
16            assert(~isempty(proxy));
17
18            fprintf('testing enum values... ');
19
20            assert(int32(ByteEnum.benum1) == 0);
21            assert(int32(ByteEnum.benum2) == 1);
22            assert(int32(ByteEnum.benum3) == ByteConst1.value);
23            assert(int32(ByteEnum.benum4) == ByteConst1.value + 1);
24            assert(int32(ByteEnum.benum5) == ShortConst1.value);
25            assert(int32(ByteEnum.benum6) == ShortConst1.value + 1);
26            assert(int32(ByteEnum.benum7) == IntConst1.value);
27            assert(int32(ByteEnum.benum8) == IntConst1.value + 1);
28            assert(int32(ByteEnum.benum9) == LongConst1.value);
29            assert(int32(ByteEnum.benum10) == LongConst1.value + 1);
30            assert(int32(ByteEnum.benum11) == ByteConst2.value);
31
32            assert(ByteEnum.ice_getValue(0) == ByteEnum.benum1);
33            assert(ByteEnum.ice_getValue(1) == ByteEnum.benum2);
34            assert(ByteEnum.ice_getValue(ByteConst1.value) == ByteEnum.benum3);
35            assert(ByteEnum.ice_getValue(ByteConst1.value + 1) == ByteEnum.benum4);
36            assert(ByteEnum.ice_getValue(ShortConst1.value) == ByteEnum.benum5);
37            assert(ByteEnum.ice_getValue(ShortConst1.value + 1) == ByteEnum.benum6);
38            assert(ByteEnum.ice_getValue(IntConst1.value) == ByteEnum.benum7);
39            assert(ByteEnum.ice_getValue(IntConst1.value + 1) == ByteEnum.benum8);
40            assert(ByteEnum.ice_getValue(LongConst1.value) == ByteEnum.benum9);
41            assert(ByteEnum.ice_getValue(LongConst1.value + 1) == ByteEnum.benum10);
42            assert(ByteEnum.ice_getValue(ByteConst2.value) == ByteEnum.benum11);
43
44            assert(int32(ShortEnum.senum1) == 3);
45            assert(int32(ShortEnum.senum2) == 4);
46            assert(int32(ShortEnum.senum3) == ByteConst1.value);
47            assert(int32(ShortEnum.senum4) == ByteConst1.value + 1);
48            assert(int32(ShortEnum.senum5) == ShortConst1.value);
49            assert(int32(ShortEnum.senum6) == ShortConst1.value + 1);
50            assert(int32(ShortEnum.senum7) == IntConst1.value);
51            assert(int32(ShortEnum.senum8) == IntConst1.value + 1);
52            assert(int32(ShortEnum.senum9) == LongConst1.value);
53            assert(int32(ShortEnum.senum10) == LongConst1.value + 1);
54            assert(int32(ShortEnum.senum11) == ShortConst2.value);
55
56            assert(ShortEnum.ice_getValue(3) == ShortEnum.senum1);
57            assert(ShortEnum.ice_getValue(4) == ShortEnum.senum2);
58            assert(ShortEnum.ice_getValue(ByteConst1.value) == ShortEnum.senum3);
59            assert(ShortEnum.ice_getValue(ByteConst1.value + 1) == ShortEnum.senum4);
60            assert(ShortEnum.ice_getValue(ShortConst1.value) == ShortEnum.senum5);
61            assert(ShortEnum.ice_getValue(ShortConst1.value + 1) == ShortEnum.senum6);
62            assert(ShortEnum.ice_getValue(IntConst1.value) == ShortEnum.senum7);
63            assert(ShortEnum.ice_getValue(IntConst1.value + 1) == ShortEnum.senum8);
64            assert(ShortEnum.ice_getValue(LongConst1.value) == ShortEnum.senum9);
65            assert(ShortEnum.ice_getValue(LongConst1.value + 1) == ShortEnum.senum10);
66            assert(ShortEnum.ice_getValue(ShortConst2.value) == ShortEnum.senum11);
67
68            assert(int32(IntEnum.ienum1) == 0);
69            assert(int32(IntEnum.ienum2) == 1);
70            assert(int32(IntEnum.ienum3) == ByteConst1.value);
71            assert(int32(IntEnum.ienum4) == ByteConst1.value + 1);
72            assert(int32(IntEnum.ienum5) == ShortConst1.value);
73            assert(int32(IntEnum.ienum6) == ShortConst1.value + 1);
74            assert(int32(IntEnum.ienum7) == IntConst1.value);
75            assert(int32(IntEnum.ienum8) == IntConst1.value + 1);
76            assert(int32(IntEnum.ienum9) == LongConst1.value);
77            assert(int32(IntEnum.ienum10) == LongConst1.value + 1);
78            assert(int32(IntEnum.ienum11) == IntConst2.value);
79            assert(int32(IntEnum.ienum12) == LongConst2.value);
80
81            assert(IntEnum.ice_getValue(0) == IntEnum.ienum1);
82            assert(IntEnum.ice_getValue(1) == IntEnum.ienum2);
83            assert(IntEnum.ice_getValue(ByteConst1.value) == IntEnum.ienum3);
84            assert(IntEnum.ice_getValue(ByteConst1.value + 1) == IntEnum.ienum4);
85            assert(IntEnum.ice_getValue(ShortConst1.value) == IntEnum.ienum5);
86            assert(IntEnum.ice_getValue(ShortConst1.value + 1) == IntEnum.ienum6);
87            assert(IntEnum.ice_getValue(IntConst1.value) == IntEnum.ienum7);
88            assert(IntEnum.ice_getValue(IntConst1.value + 1) == IntEnum.ienum8);
89            assert(IntEnum.ice_getValue(LongConst1.value) == IntEnum.ienum9);
90            assert(IntEnum.ice_getValue(LongConst1.value + 1) == IntEnum.ienum10);
91            assert(IntEnum.ice_getValue(IntConst2.value) == IntEnum.ienum11);
92            assert(IntEnum.ice_getValue(LongConst2.value) == IntEnum.ienum12);
93
94            assert(int32(SimpleEnum.red) == 0);
95            assert(int32(SimpleEnum.green) == 1);
96            assert(int32(SimpleEnum.blue) == 2);
97
98            assert(SimpleEnum.ice_getValue(0) == SimpleEnum.red);
99            assert(SimpleEnum.ice_getValue(1) == SimpleEnum.green);
100            assert(SimpleEnum.ice_getValue(2) == SimpleEnum.blue);
101
102            fprintf('ok\n');
103
104            fprintf('testing enum streaming... ');
105
106            encoding_1_0 = strcmp(communicator.getProperties().getProperty('Ice.Default.EncodingVersion'), '1.0');
107
108            os = communicator.createOutputStream();
109            ByteEnum.ice_write(os, ByteEnum.benum11);
110            bytes = os.finished();
111            assert(length(bytes) == 1); % ByteEnum should require one byte
112
113            os = communicator.createOutputStream();
114            ShortEnum.ice_write(os, ShortEnum.senum11);
115            bytes = os.finished();
116            if encoding_1_0
117                assert(length(bytes) == 2);
118            else
119                assert(length(bytes) == 5);
120            end
121
122            os = communicator.createOutputStream();
123            IntEnum.ice_write(os, IntEnum.ienum11);
124            bytes = os.finished();
125            if encoding_1_0
126                assert(length(bytes) == 4);
127            else
128                assert(length(bytes) == 5);
129            end
130
131            os = communicator.createOutputStream();
132            SimpleEnum.ice_write(os, SimpleEnum.blue);
133            bytes = os.finished();
134            assert(length(bytes) == 1); % SimpleEnum should require one byte
135
136            fprintf('ok\n');
137
138            fprintf('testing enum operations... ');
139
140            [r, b2] = proxy.opByte(ByteEnum.benum1);
141            assert(r == ByteEnum.benum1 && b2 == ByteEnum.benum1);
142            [r, b2] = proxy.opByte(ByteEnum.benum11);
143            assert(r == ByteEnum.benum11 && b2 == ByteEnum.benum11);
144
145            [r, s2] = proxy.opShort(ShortEnum.senum1);
146            assert(r == ShortEnum.senum1 && r == ShortEnum.senum1);
147            [r, s2] = proxy.opShort(ShortEnum.senum11);
148            assert(r == ShortEnum.senum11 && r == ShortEnum.senum11);
149
150            [r, i2] = proxy.opInt(IntEnum.ienum1);
151            assert(r == IntEnum.ienum1 && i2 == IntEnum.ienum1);
152            [r, i2] = proxy.opInt(IntEnum.ienum11);
153            assert(r == IntEnum.ienum11 && i2 == IntEnum.ienum11);
154            [r, i2] = proxy.opInt(IntEnum.ienum12);
155            assert(r == IntEnum.ienum12 && i2 == IntEnum.ienum12);
156
157            [r, s2] = proxy.opSimple(SimpleEnum.green);
158            assert(r == SimpleEnum.green && s2 == SimpleEnum.green);
159
160            fprintf('ok\n');
161
162            fprintf('testing enum sequences operations... ');
163
164            b1 = [ ByteEnum.benum1, ByteEnum.benum2, ByteEnum.benum3, ByteEnum.benum4, ByteEnum.benum5, ...
165                   ByteEnum.benum6, ByteEnum.benum7, ByteEnum.benum8, ByteEnum.benum9, ByteEnum.benum10, ...
166                   ByteEnum.benum11 ];
167
168            [r, b2] = proxy.opByteSeq(b1);
169
170            for i = 1:length(b1)
171                assert(b1(i) == b2(i));
172                assert(b1(i) == r(i));
173            end
174
175            s1 = [ ShortEnum.senum1, ShortEnum.senum2, ShortEnum.senum3, ShortEnum.senum4, ShortEnum.senum5, ...
176                   ShortEnum.senum6, ShortEnum.senum7, ShortEnum.senum8, ShortEnum.senum9, ShortEnum.senum10, ...
177                   ShortEnum.senum11 ];
178
179            [r, s2] = proxy.opShortSeq(s1);
180
181            for i = 1:length(s1)
182                assert(s1(i) == s2(i));
183                assert(s1(i) == r(i));
184            end
185
186            i1 = [ IntEnum.ienum1, IntEnum.ienum2, IntEnum.ienum3, IntEnum.ienum4, IntEnum.ienum5, ...
187                   IntEnum.ienum6, IntEnum.ienum7, IntEnum.ienum8, IntEnum.ienum9, IntEnum.ienum10, ...
188                   IntEnum.ienum11 ];
189
190            [r, i2] = proxy.opIntSeq(i1);
191
192            for i = 1:length(i1)
193                assert(i1(i) == i2(i));
194                assert(i1(i) == r(i));
195            end
196
197            s1 = [ SimpleEnum.red, SimpleEnum.green, SimpleEnum.blue ];
198
199            [r, s2] = proxy.opSimpleSeq(s1);
200
201            for i = 1:length(s1)
202                assert(s1(i) == s2(i));
203                assert(s1(i) == r(i));
204            end
205
206            fprintf('ok\n');
207
208            fprintf('testing enum exceptions... ');
209
210            try
211                os = communicator.createOutputStream();
212                os.writeByte(2); % Invalid enumerator
213                in = os.createInputStream();
214                ByteEnum.ice_read(in);
215                assert(false);
216            catch ex
217                assert(isa(ex, 'Ice.MarshalException'));
218            end
219
220            try
221                os = communicator.createOutputStream();
222                os.writeByte(128); % Invalid enumerator
223                in = os.createInputStream();
224                ByteEnum.ice_read(in);
225                assert(false);
226            catch ex
227                assert(isa(ex, 'Ice.MarshalException'));
228            end
229
230            try
231                os = communicator.createOutputStream();
232                os.writeShort(-1); % Negative enumerators are not supported
233                in = os.createInputStream();
234                ShortEnum.ice_read(in);
235                assert(false);
236            catch ex
237                assert(isa(ex, 'Ice.MarshalException'));
238            end
239
240            try
241                os = communicator.createOutputStream();
242                os.writeShort(0); % Invalid enumerator
243                in = os.createInputStream();
244                ShortEnum.ice_read(in);
245                assert(false);
246            catch ex
247                assert(isa(ex, 'Ice.MarshalException'));
248            end
249
250            try
251                os = communicator.createOutputStream();
252                os.writeShort(32767); % Invalid enumerator
253                in = os.createInputStream();
254                ShortEnum.ice_read(in);
255                assert(false);
256            catch ex
257                assert(isa(ex, 'Ice.MarshalException'));
258            end
259
260            try
261                os = communicator.createOutputStream();
262                os.writeInt(-1); % Negative enumerators are not supported
263                in = os.createInputStream();
264                IntEnum.ice_read(in);
265                assert(false);
266            catch ex
267                assert(isa(ex, 'Ice.MarshalException'));
268            end
269
270            try
271                os = communicator.createOutputStream();
272                os.writeInt(2); % Invalid enumerator
273                in = os.createInputStream();
274                IntEnum.ice_read(in);
275                assert(false);
276            catch ex
277                assert(isa(ex, 'Ice.MarshalException'));
278            end
279
280            fprintf('ok\n');
281
282            r = proxy;
283        end
284    end
285end
286