1 : //==============================================================================
2 : // File <$/test/cpp/unit/cdr/write/TestCdrWrite.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //==============================================================================
21 :
22 : #include "yaorb/CORBA.h"
23 : #include "yaorb/YAORB.h"
24 : #include "src/cpp/prod/tool/String.h"
25 : #include "src/cpp/prod/protocol/cdr/cdr_file.h"
26 :
27 : void
28 2 : TestBool(YAORB::CDR *cdr)
29 : {
30 : CORBA::Boolean b ;
31 : CORBA::Boolean bArray[8] ;
32 : int size = 8 ;
33 : int middle = 3 ;
34 : int i ;
35 :
36 : // Expecting to write :
37 : // T, F, T (*3), F (*5)
38 : // --> 0x01 0x00 0x01 0x01 0x01 0x00 0x00 0x00
39 : // 0x00 0x00
40 : // 10 bytes total.
41 :
42 2 : b = true ;
43 2 : cdr->cdr_Boolean(& b) ;
44 :
45 2 : b = false ;
46 2 : cdr->cdr_Boolean(& b) ;
47 :
48 : #ifdef LATER
49 : // Expecting to write True = 1 or throw marshall ?
50 : char *hackPrt = (char*) & b ;
51 : *hackPrt = 12 ;
52 : cdr->cdr_Boolean(& b) ;
53 : #endif
54 :
55 6 : for (i = 0 ; i < middle ; i++)
56 : {
57 6 : bArray[i] = true ;
58 : }
59 :
60 10 : for (i = middle ; i < size ; i++)
61 : {
62 10 : bArray[i] = false ;
63 : }
64 :
65 2 : cdr->cdr_BooleanArray(& bArray[0], size) ;
66 :
67 : return ;
68 : }
69 :
70 : void
71 2 : TestOctet(YAORB::CDR *cdr)
72 : {
73 : CORBA::Octet o ;
74 : CORBA::Octet oArray[5] ;
75 :
76 : // Expecting to write :
77 : // 0x10 0x20 0xAA 0xBB 0xCC 0x0F 0xF0
78 : // 7 bytes total.
79 :
80 2 : o = 0x10 ;
81 2 : cdr->cdr_Octet(& o) ;
82 :
83 2 : o = 0x20 ;
84 2 : cdr->cdr_Octet(& o) ;
85 :
86 2 : oArray[0] = 0xAA ;
87 2 : oArray[1] = 0xBB ;
88 2 : oArray[2] = 0xCC ;
89 2 : oArray[3] = 0x0F ;
90 2 : oArray[4] = 0xF0 ;
91 :
92 2 : cdr->cdr_OctetArray(& oArray[0], 5) ;
93 : }
94 :
95 : void
96 2 : TestChar(YAORB::CDR *cdr)
97 : {
98 : CORBA::Char c ;
99 : CORBA::Char cArray[4] ;
100 :
101 : // Expecting to write :
102 : // 'a' 'b' 'A' 'B' 'C' 'D'
103 : // --> 0x61 0x62 0x41 0x42 0x43 0x44
104 : // 6 bytes total.
105 :
106 2 : c = 'a' ;
107 2 : cdr->cdr_Char(& c) ;
108 :
109 2 : c = 'b' ;
110 2 : cdr->cdr_Char(& c) ;
111 :
112 2 : cArray[0] = 'A' ;
113 2 : cArray[1] = 'B' ;
114 2 : cArray[2] = 'C' ;
115 2 : cArray[3] = 'D' ;
116 :
117 2 : cdr->cdr_CharArray(& cArray[0], 4) ;
118 : }
119 :
120 : void
121 0 : TestWChar(YAORB::CDR *cdr)
122 : {
123 : CORBA::WChar wc ;
124 : CORBA::WChar wcArray[4] ;
125 :
126 : // Expecting to write :
127 : // L'a' L'b' L'A' L'B' L'C' L'D'
128 : // --> 0x??61 0x??62 0x??41 0x??42 0x??43 0x??44
129 : // FIXME : depend on character transmission set
130 : // ?? bytes total.
131 :
132 0 : wc = L'a' ;
133 0 : cdr->cdr_WChar(& wc) ;
134 :
135 0 : wc = L'b' ;
136 0 : cdr->cdr_WChar(& wc) ;
137 :
138 0 : wcArray[0] = L'A' ;
139 0 : wcArray[1] = L'B' ;
140 0 : wcArray[2] = L'C' ;
141 0 : wcArray[3] = L'D' ;
142 :
143 0 : cdr->cdr_WCharArray(& wcArray[0], 4) ;
144 : }
145 :
146 : void
147 2 : TestShort(YAORB::CDR *cdr)
148 : {
149 : CORBA::Short s ;
150 : CORBA::Short sArray[3] ;
151 :
152 : // Expecting to write :
153 : // 0x0102 0xFCFC 0x51A2 0x9E4E 0x71C2
154 : // be --> 0x01 0x02 0xFC 0xFC 0x51 0xA2 0x9E 0x4E
155 : // 0x71 0xC2
156 : // le --> 0x02 0x01 0xFC 0xFC 0xA2 0x51 0x4E 0x9E
157 : // 0xC2 0x71
158 : // 10 bytes total.
159 :
160 2 : s = 0x0102 ;
161 2 : cdr->cdr_Short(& s) ;
162 :
163 2 : s = - 0x0304 ; // --> 0xFCFC
164 2 : cdr->cdr_Short(& s) ;
165 :
166 2 : sArray[0] = 0x51A2 ;
167 2 : sArray[1] = - 0x61B2 ; // --> 0x9E4E
168 2 : sArray[2] = 0x71C2 ;
169 :
170 2 : cdr->cdr_ShortArray(& sArray[0], 3) ;
171 : }
172 :
173 : void
174 2 : TestUShort(YAORB::CDR *cdr)
175 : {
176 : CORBA::UShort us ;
177 : CORBA::UShort usArray[3] ;
178 :
179 : // Expecting to write :
180 : // 0x0102 0x0304 0xA1A2 0xB1B2 0xC1C2
181 : // be --> 0x01 0x02 0x03 0x04 0xA1 0xA2 0xB1 0xB2
182 : // 0xC1 0xC2
183 : // le --> 0x02 0x01 0x04 0x03 0xA2 0xA1 0xB2 0xB1
184 : // 0xC2 0xC1
185 : // 10 bytes total.
186 :
187 2 : us = 0x0102 ;
188 2 : cdr->cdr_UShort(& us) ;
189 :
190 2 : us = 0x0304 ;
191 2 : cdr->cdr_UShort(& us) ;
192 :
193 2 : usArray[0] = 0xA1A2 ;
194 2 : usArray[1] = 0xB1B2 ;
195 2 : usArray[2] = 0xC1C2 ;
196 :
197 2 : cdr->cdr_UShortArray(& usArray[0], 3) ;
198 : }
199 :
200 : void
201 2 : TestLong(YAORB::CDR *cdr)
202 : {
203 : CORBA::Long l ;
204 : CORBA::Long lArray[3] ;
205 :
206 : // Expecting to write :
207 : // 0x01020304 0xFAF9F8F8 0x51A2A3A4 0x9E4D4C4C 0x71C2C3C4
208 : // be --> 0x01 0x02 0x03 0x04 0xFA 0xF9 0xF8 0xF8
209 : // 0x51 0xA2 0xA3 0xA4 0x9E 0x4D 0x4C 0x4C
210 : // 0x71 0xC2 0xC3 0xC4
211 : // le --> 0x04 0x03 0x02 0x01 0xF8 0xF8 0xF9 0xFA
212 : // 0xA4 0xA3 0xA2 0x51 0x4C 0x4C 0x4D 0x9E
213 : // 0xC4 0xC3 0xC2 0x71
214 : // 20 bytes total.
215 :
216 2 : l = 0x01020304 ;
217 2 : cdr->cdr_Long(& l) ;
218 :
219 2 : l = - 0x05060708 ; // --> 0xFAF9F8F8
220 2 : cdr->cdr_Long(& l) ;
221 :
222 2 : lArray[0] = 0x51A2A3A4 ;
223 2 : lArray[1] = - 0x61B2B3B4 ; // --> 0x9E4D4C4C
224 2 : lArray[2] = 0x71C2C3C4 ;
225 :
226 2 : cdr->cdr_LongArray(& lArray[0], 3) ;
227 : }
228 :
229 : void
230 2 : TestULong(YAORB::CDR *cdr)
231 : {
232 : CORBA::ULong ul ;
233 : CORBA::ULong ulArray[3] ;
234 :
235 : // Expecting to write :
236 : // 0x01020304 0x05060708 0xA1A2A3A4 0xB1B2B3B4 0xC1C2C3C4
237 : // be --> 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08
238 : // 0xA1 0xA2 0xA3 0xA4 0xB1 0xB2 0xB3 0xB4
239 : // 0xC1 0xC2 0xC3 0xC4
240 : // le --> 0x04 0x03 0x02 0x01 0x08 0x07 0x06 0x05
241 : // 0xA4 0xA3 0xA2 0xA1 0x4C 0x4C 0x4D 0x9E
242 : // 0xC4 0xC3 0xC2 0xC1
243 : // 20 bytes total.
244 :
245 : // FIXME : Expecting to write :
246 : // 20 bytes total.
247 :
248 2 : ul = 0x01020304 ;
249 2 : cdr->cdr_ULong(& ul) ;
250 :
251 2 : ul = 0x05060708 ;
252 2 : cdr->cdr_ULong(& ul) ;
253 :
254 2 : ulArray[0] = 0xA1A2A3A4 ;
255 2 : ulArray[1] = 0xB1B2B3B4 ;
256 2 : ulArray[2] = 0xC1C2C3C4 ;
257 :
258 2 : cdr->cdr_ULongArray(& ulArray[0], 3) ;
259 : }
260 :
261 : void
262 2 : TestLongLong(YAORB::CDR *cdr)
263 : {
264 : CORBA::LongLong ll ;
265 : CORBA::LongLong llArray[3] ;
266 :
267 : // Expecting to write :
268 : // 0x0102030405060708
269 : // 0xF6F5F4F3F2F1F0AB
270 : // 0x21A2A3A4A5A6A7A8
271 : // 0xCE4D4C4B4A494848
272 : // 0x41C2C3C4C5C6C7C8
273 : // be --> 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08
274 : // 0xF6 0xF5 0xF4 0xF3 0xF2 0xF1 0xF0 0xAB
275 : // 0x21 0xA2 0xA3 0xA4 0xA5 0xA5 0xA7 0xA8
276 : // 0xCE 0x4D 0x4C 0x4B 0x4A 0x49 0x48 0x48
277 : // 0x41 0xC2 0xC3 0xC4 0xC5 0xC5 0xC7 0xC8
278 : // le --> 0x08 0x07 0x06 0x05 0x04 0x03 0x02 0x01
279 : // 0xAB 0xF0 0xF1 0xF2 0xF3 0xF4 0xF5 0xF6
280 : // 0xA8 0xA7 0xA6 0xA5 0xA4 0xA3 0xA2 0x21
281 : // 0x48 0x48 0x49 0x4A 0x4B 0x4C 0x4D 0xCE
282 : // 0xC8 0xC7 0xC6 0xC5 0xC4 0xC3 0xC2 0x41
283 : // 40 bytes total.
284 :
285 : ll = 0x01020304 ;
286 : ll <<= 32 ;
287 2 : ll += 0x05060708 ;
288 2 : cdr->cdr_LongLong(& ll) ;
289 :
290 : ll = - 0x090A0B0C ;
291 : ll <<= 32 ;
292 2 : ll -= 0x0D0E0F55 ; // --> 0xF6F5F4F3F2F1F0AB
293 2 : cdr->cdr_LongLong(& ll) ;
294 :
295 : llArray[0] = 0x21A2A3A4 ;
296 : llArray[0] <<= 32 ;
297 2 : llArray[0] += 0xA5A6A7A8 ;
298 :
299 : llArray[1] = - 0x31B2B3B4 ;
300 : llArray[1] <<= 32 ;
301 2 : llArray[1] -= 0xB5B6B7B8 ; // --> 0xCE4D4C4B4A494848
302 :
303 : llArray[2] = 0x41C2C3C4 ;
304 : llArray[2] <<= 32 ;
305 2 : llArray[2] += 0xC5C6C7C8 ;
306 :
307 2 : cdr->cdr_LongLongArray(& llArray[0], 3) ;
308 : }
309 :
310 : void
311 2 : TestULongLong(YAORB::CDR *cdr)
312 : {
313 : CORBA::ULongLong ull ;
314 : CORBA::ULongLong ullArray[3] ;
315 :
316 : // Expecting to write :
317 : // 0x0102030405060708
318 : // 0x090A0B0C0D0E0F55
319 : // 0xA1A2A3A4A5A6A7A8
320 : // 0xB1B2B3B4B5B6B7B8
321 : // 0xC1C2C3C4C5C6C7C8
322 : // be --> 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08
323 : // 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x55
324 : // 0xA1 0xA2 0xA3 0xA4 0xA5 0xA5 0xA7 0xA8
325 : // 0xB1 0xB2 0xB3 0xB4 0xB5 0xB5 0xB7 0xB8
326 : // 0xC1 0xC2 0xC3 0xC4 0xC5 0xC5 0xC7 0xC8
327 : // le --> 0x08 0x07 0x06 0x05 0x04 0x03 0x02 0x01
328 : // 0x55 0x0F 0x0E 0x0D 0x0C 0x0B 0x0A 0x09
329 : // 0xA8 0xA7 0xA6 0xA5 0xA4 0xA3 0xA2 0xA1
330 : // 0xB8 0xB7 0xB6 0xB5 0xB4 0xB3 0xB2 0xB1
331 : // 0xC8 0xC7 0xC6 0xC5 0xC4 0xC3 0xC2 0xC1
332 : // 40 bytes total.
333 :
334 : ull = 0x01020304 ;
335 : ull <<= 32 ;
336 2 : ull += 0x05060708 ;
337 2 : cdr->cdr_ULongLong(& ull) ;
338 :
339 : ull = 0x090A0B0C ;
340 : ull <<= 32 ;
341 2 : ull += 0x0D0E0F55 ;
342 2 : cdr->cdr_ULongLong(& ull) ;
343 :
344 : ullArray[0] = 0xA1A2A3A4 ;
345 : ullArray[0] <<= 32 ;
346 2 : ullArray[0] += 0xA5A6A7A8 ;
347 :
348 : ullArray[1] = 0xB1B2B3B4 ;
349 : ullArray[1] <<= 32 ;
350 2 : ullArray[1] += 0xB5B6B7B8 ;
351 :
352 : ullArray[2] = 0xC1C2C3C4 ;
353 : ullArray[2] <<= 32 ;
354 2 : ullArray[2] += 0xC5C6C7C8 ;
355 :
356 2 : cdr->cdr_ULongLongArray(& ullArray[0], 3) ;
357 : }
358 :
359 : void
360 2 : TestFloat(YAORB::CDR *cdr)
361 : {
362 : CORBA::Float f ;
363 : CORBA::Float fArray[3] ;
364 :
365 : // FIXME : Expecting to write :
366 :
367 2 : f = 1.234e5 ;
368 2 : cdr->cdr_Float(& f) ;
369 :
370 2 : f = - 9.876e-5 ;
371 2 : cdr->cdr_Float(& f) ;
372 :
373 2 : fArray[0] = 11.22 ;
374 2 : fArray[1] = - 33.44 ;
375 2 : fArray[2] = 55.66 ;
376 :
377 2 : cdr->cdr_FloatArray(& fArray[0], 3) ;
378 : }
379 :
380 : void
381 2 : TestDouble(YAORB::CDR *cdr)
382 : {
383 : CORBA::Double d ;
384 : CORBA::Double dArray[3] ;
385 :
386 : // FIXME : Expecting to write :
387 :
388 2 : d = 1.234e5 ;
389 2 : cdr->cdr_Double(& d) ;
390 :
391 2 : d = - 9.876e-5 ;
392 2 : cdr->cdr_Double(& d) ;
393 :
394 2 : dArray[0] = 11.22 ;
395 2 : dArray[1] = - 33.44 ;
396 2 : dArray[2] = 55.66 ;
397 :
398 2 : cdr->cdr_DoubleArray(& dArray[0], 3) ;
399 : }
400 :
401 : void
402 2 : TestLongDouble(YAORB::CDR *cdr)
403 : {
404 : CORBA::LongDouble ld ;
405 : CORBA::LongDouble ldArray[3] ;
406 :
407 : // FIXME : Expecting to write :
408 :
409 2 : ld = 1.234e5 ;
410 2 : cdr->cdr_LongDouble(& ld) ;
411 :
412 2 : ld = - 9.876e-5 ;
413 2 : cdr->cdr_LongDouble(& ld) ;
414 :
415 2 : ldArray[0] = 11.22 ;
416 2 : ldArray[1] = - 33.44 ;
417 2 : ldArray[2] = 55.66 ;
418 :
419 2 : cdr->cdr_LongDoubleArray(& ldArray[0], 3) ;
420 : }
421 :
422 24 : int main(int argc, char* argv[])
423 : {
424 24 : if (argc < 3)
425 : {
426 0 : fprintf(stderr, "TestCdrWrite failed : bad arguments\n") ;
427 0 : return (-1) ;
428 : }
429 :
430 : const char* inputFileName = argv[1] ;
431 24 : const char* outputFileName = argv[2] ;
432 :
433 24 : FILE *input = fopen(inputFileName, "r") ;
434 :
435 24 : if (input == NULL)
436 : {
437 0 : fprintf(stderr, "TestCdrWrite failed : bad input\n") ;
438 0 : return (-2) ;
439 : }
440 :
441 : try
442 : {
443 24 : CDRFile cdr(outputFileName, YAORB::CDR_WRITE) ;
444 :
445 : char str[255] ;
446 24 : String menu ;
447 :
448 24 : fscanf(input, "%s", str) ;
449 24 : menu = str ;
450 :
451 24 : if (menu == "LITTLE-ENDIAN")
452 : {
453 12 : cdr.SetLittleEndian() ;
454 : }
455 12 : else if (menu == "BIG-ENDIAN")
456 : {
457 12 : cdr.SetBigEndian() ;
458 : }
459 : else
460 : {
461 0 : fprintf(stderr, "TestCdrWrite failed : bad byte order\n") ;
462 : return (-3) ;
463 : }
464 :
465 24 : fscanf(input, "%s", str) ;
466 24 : menu = str ;
467 :
468 24 : if (menu == "TestBool")
469 : {
470 2 : TestBool(& cdr) ;
471 : }
472 22 : else if (menu == "TestOctet")
473 : {
474 2 : TestOctet(& cdr) ;
475 : }
476 20 : else if (menu == "TestChar")
477 : {
478 2 : TestChar(& cdr) ;
479 : }
480 18 : else if (menu == "TestShort")
481 : {
482 2 : TestShort(& cdr) ;
483 : }
484 16 : else if (menu == "TestUShort")
485 : {
486 2 : TestUShort(& cdr) ;
487 : }
488 14 : else if (menu == "TestLong")
489 : {
490 2 : TestLong(& cdr) ;
491 : }
492 12 : else if (menu == "TestULong")
493 : {
494 2 : TestULong(& cdr) ;
495 : }
496 10 : else if (menu == "TestLongLong")
497 : {
498 2 : TestLongLong(& cdr) ;
499 : }
500 8 : else if (menu == "TestULongLong")
501 : {
502 2 : TestULongLong(& cdr) ;
503 : }
504 6 : else if (menu == "TestFloat")
505 : {
506 2 : TestFloat(& cdr) ;
507 : }
508 4 : else if (menu == "TestDouble")
509 : {
510 2 : TestDouble(& cdr) ;
511 : }
512 2 : else if (menu == "TestLongDouble")
513 : {
514 2 : TestLongDouble(& cdr) ;
515 : }
516 0 : else if (menu == "yyy")
517 : {
518 0 : }
519 :
520 : }
521 24 : catch (...)
522 : {
523 0 : fprintf(stderr, "TestCdrWrite failed : exception\n") ;
524 0 : return (-4) ;
525 : }
526 :
527 24 : fclose (input) ;
528 : return 0;
529 : }
530 :
|
