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