1 : //==============================================================================
2 : // File <$/test/cpp/unit/sequences/TestSeq.cpp>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003, 2006, 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 <iostream>
23 : #include <yaorb/CORBA.h>
24 :
25 : #include <src/cpp/prod/tool/String.h>
26 :
27 : using namespace std ;
28 :
29 : volatile int* main_stack = NULL ;
30 :
31 : const char*
32 195 : BufferType(const void* buffer)
33 : {
34 : // Can't print the hexadecimal value of get_buffer()
35 : // as a result of a unit test,
36 : // because we need reproductibility
37 : // 1) across platforms.
38 : // 2) across builds (compiler options, ...)
39 : // for REGRESSION testing.
40 : //
41 : // For this unit test to be meaningful,
42 : // we need to display something about get_buffer(),
43 : // so that the test also verify the allocation/de-allocation behavior.
44 :
45 : const char* where = NULL ;
46 :
47 195 : if (buffer == NULL)
48 : {
49 : where = "nil" ;
50 : }
51 : else
52 : {
53 : volatile int here ;
54 :
55 143 : if ( ((main_stack < buffer) && (buffer < & here))
56 : || ((& here < buffer) && (buffer < main_stack)) )
57 : {
58 : where = "stack" ;
59 : }
60 : else
61 : {
62 : where = "heap or text" ;
63 : }
64 : }
65 :
66 : return where ;
67 : }
68 :
69 : //=============================================================================
70 : // sequence<CORBA::Boolean>
71 : //=============================================================================
72 :
73 15 : void DumpBoolSeq(CORBABooleanSeq& s, const char* title)
74 : {
75 : CORBA::ULong i ;
76 15 : CORBA::ULong len = s.length() ;
77 15 : CORBA::ULong max = s.maximum() ;
78 15 : CORBA::Boolean rel = s.release() ;
79 : const CORBABooleanSeq& const_s = s ;
80 15 : const void *buffer = const_s.get_buffer() ;
81 15 : void *buffer2 = s.get_buffer(false) ;
82 :
83 15 : cout << title << endl << endl ;
84 :
85 15 : cout << "Length = " << len << endl ;
86 15 : cout << "Max = " << max << endl ;
87 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
88 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
89 :
90 15 : if (buffer != buffer2)
91 : {
92 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
93 : }
94 :
95 81 : for (i = 0 ; i < len ; i++)
96 : {
97 132 : cout << " - [" << i << "]=" << (s[i] ? "true" : "false") << endl ;
98 : }
99 :
100 : cout << endl ;
101 : }
102 :
103 1 : void TestBoolSeq(void)
104 : {
105 1 : cout << "========== Testing CORBABooleanSeq ==========" << endl << endl ;
106 :
107 1 : CORBABooleanSeq s1 ;
108 1 : DumpBoolSeq(s1, "Sequence s1()") ;
109 :
110 1 : CORBABooleanSeq s2(12) ;
111 1 : s2[0] = false ;
112 1 : s2[1] = false ;
113 1 : s2[2] = false ;
114 1 : s2[3] = false ;
115 1 : s2[4] = false ;
116 1 : s2[5] = false ;
117 1 : s2[6] = false ;
118 1 : s2[7] = false ;
119 1 : s2[8] = false ;
120 1 : s2[9] = false ;
121 1 : s2[10] = false ;
122 1 : s2[11] = false ;
123 1 : DumpBoolSeq(s2, "Sequence s2(12)") ;
124 :
125 : CORBA::Boolean data_s3[] =
126 : {
127 : true,
128 : false,
129 : true,
130 : false
131 1 : } ;
132 :
133 1 : CORBABooleanSeq s3(4UL, 4UL, & data_s3 [0], false) ;
134 1 : DumpBoolSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
135 :
136 1 : CORBA::Boolean *data_s4 = new CORBA::Boolean[4] ;
137 1 : data_s4[0] = false ;
138 1 : data_s4[1] = true ;
139 1 : data_s4[2] = false ;
140 1 : data_s4[3] = true ;
141 :
142 1 : CORBABooleanSeq s4(4UL, 4UL, data_s4, false) ;
143 1 : DumpBoolSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
144 :
145 1 : CORBABooleanSeq s5(s1) ;
146 1 : DumpBoolSeq(s5, "Sequence s5(s1)") ;
147 :
148 1 : CORBABooleanSeq s6(s2) ;
149 1 : DumpBoolSeq(s6, "Sequence s6(s2)") ;
150 :
151 1 : s1 = s3 ;
152 1 : DumpBoolSeq(s1, "s1 = s3") ;
153 :
154 1 : s2 = s4 ;
155 1 : DumpBoolSeq(s2, "s2 = s4") ;
156 :
157 1 : s1.length(8) ;
158 1 : s1[4] = true ;
159 1 : s1[5] = true ;
160 1 : s1[6] = true ;
161 1 : s1[7] = true ;
162 1 : DumpBoolSeq(s1, "s1.length(8)") ;
163 :
164 1 : s2.length(8) ;
165 1 : DumpBoolSeq(s2, "s2.length(8)") ;
166 :
167 1 : CORBA::Boolean& b = s3[1] ;
168 1 : b = true ;
169 1 : DumpBoolSeq(s3, "hacking s3[1]=true, still in stack") ;
170 :
171 1 : CORBA::Boolean *buf = s3.get_buffer(true) ;
172 1 : DumpBoolSeq(s3, "orphaned s3") ;
173 :
174 1 : if (buf != data_s3)
175 : {
176 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
177 : }
178 :
179 1 : s3.replace(4UL, 4UL, data_s4, false) ;
180 1 : DumpBoolSeq(s3, "s3 replaced with not owned data") ;
181 :
182 1 : s3.replace(2UL, 2UL, data_s4, false) ;
183 1 : DumpBoolSeq(s3, "s3 replaced with not owned data, again") ;
184 :
185 1 : s4.replace(0UL, 0UL, NULL, false) ;
186 1 : DumpBoolSeq(s4, "s4 orphaned the hard way") ;
187 :
188 1 : delete [] data_s4 ;
189 : }
190 :
191 : //=============================================================================
192 : // sequence<CORBA::Char>
193 : //=============================================================================
194 :
195 15 : void DumpCharSeq(CORBACharSeq& s, const char* title)
196 : {
197 : CORBA::ULong i ;
198 15 : CORBA::ULong len = s.length() ;
199 15 : CORBA::ULong max = s.maximum() ;
200 15 : CORBA::Boolean rel = s.release() ;
201 : const CORBACharSeq& const_s = s ;
202 15 : const void *buffer = const_s.get_buffer() ;
203 15 : void *buffer2 = s.get_buffer(false) ;
204 :
205 15 : cout << title << endl << endl ;
206 :
207 15 : cout << "Length = " << len << endl ;
208 15 : cout << "Max = " << max << endl ;
209 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
210 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
211 :
212 15 : if (buffer != buffer2)
213 : {
214 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
215 : }
216 :
217 81 : for (i = 0 ; i < len ; i++)
218 : {
219 132 : cout << " - [" << i << "]=" << s[i] << endl ;
220 : }
221 :
222 : cout << endl ;
223 : }
224 :
225 1 : void TestCharSeq(void)
226 : {
227 1 : cout << "========== Testing CORBACharSeq ==========" << endl << endl ;
228 :
229 1 : CORBACharSeq s1 ;
230 1 : DumpCharSeq(s1, "Sequence s1()") ;
231 :
232 1 : CORBACharSeq s2(12) ;
233 1 : s2[0] = 'a' ;
234 1 : s2[1] = 'b' ;
235 1 : s2[2] = 'c' ;
236 1 : s2[3] = 'd' ;
237 1 : s2[4] = 'e' ;
238 1 : s2[5] = 'f' ;
239 1 : s2[6] = 'g' ;
240 1 : s2[7] = 'h' ;
241 1 : s2[8] = 'i' ;
242 1 : s2[9] = 'j' ;
243 1 : s2[10] = 'k' ;
244 1 : s2[11] = 'l' ;
245 1 : DumpCharSeq(s2, "Sequence s2(12)") ;
246 :
247 : CORBA::Char data_s3[] =
248 : {
249 : 'A',
250 : 'B',
251 : 'C',
252 : 'D'
253 1 : } ;
254 :
255 1 : CORBACharSeq s3(4UL, 4UL, & data_s3 [0], false) ;
256 1 : DumpCharSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
257 :
258 1 : CORBA::Char *data_s4 = new CORBA::Char[4] ;
259 1 : data_s4[0] = 'X' ;
260 1 : data_s4[1] = 'Y' ;
261 1 : data_s4[2] = 'Z' ;
262 1 : data_s4[3] = 'T' ;
263 :
264 1 : CORBACharSeq s4(4UL, 4UL, data_s4, false) ;
265 1 : DumpCharSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
266 :
267 1 : CORBACharSeq s5(s1) ;
268 1 : DumpCharSeq(s5, "Sequence s5(s1)") ;
269 :
270 1 : CORBACharSeq s6(s2) ;
271 1 : DumpCharSeq(s6, "Sequence s6(s2)") ;
272 :
273 1 : s1 = s3 ;
274 1 : DumpCharSeq(s1, "s1 = s3") ;
275 :
276 1 : s2 = s4 ;
277 1 : DumpCharSeq(s2, "s2 = s4") ;
278 :
279 1 : s1.length(8) ;
280 1 : s1[4] = '#' ;
281 1 : s1[5] = '#' ;
282 1 : s1[6] = '#' ;
283 1 : s1[7] = '#' ;
284 1 : DumpCharSeq(s1, "s1.length(8)") ;
285 :
286 1 : s2.length(8) ;
287 1 : DumpCharSeq(s2, "s2.length(8)") ;
288 :
289 1 : CORBA::Char& c = s3[1] ;
290 1 : c = '?' ;
291 1 : DumpCharSeq(s3, "hacking s3[1]='?', still in stack") ;
292 :
293 1 : CORBA::Char *buf = s3.get_buffer(true) ;
294 1 : DumpCharSeq(s3, "orphaned s3") ;
295 :
296 1 : if (buf != data_s3)
297 : {
298 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
299 : }
300 :
301 1 : s3.replace(4UL, 4UL, data_s4, false) ;
302 1 : DumpCharSeq(s3, "s3 replaced with not owned data") ;
303 :
304 1 : s3.replace(2UL, 2UL, data_s4, false) ;
305 1 : DumpCharSeq(s3, "s3 replaced with not owned data, again") ;
306 :
307 1 : s4.replace(0UL, 0UL, NULL, false) ;
308 1 : DumpCharSeq(s4, "s4 orphaned the hard way") ;
309 :
310 1 : delete [] data_s4 ;
311 : }
312 :
313 : //=============================================================================
314 : // sequence<CORBA::WChar>
315 : //=============================================================================
316 :
317 15 : void DumpWCharSeq(CORBAWCharSeq& s, const char* title)
318 : {
319 : CORBA::ULong i ;
320 15 : CORBA::ULong len = s.length() ;
321 15 : CORBA::ULong max = s.maximum() ;
322 15 : CORBA::Boolean rel = s.release() ;
323 : const CORBAWCharSeq& const_s = s ;
324 15 : const void *buffer = const_s.get_buffer() ;
325 15 : void *buffer2 = s.get_buffer(false) ;
326 :
327 15 : cout << title << endl << endl ;
328 :
329 15 : cout << "Length = " << len << endl ;
330 15 : cout << "Max = " << max << endl ;
331 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
332 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
333 :
334 15 : if (buffer != buffer2)
335 : {
336 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
337 : }
338 :
339 81 : for (i = 0 ; i < len ; i++)
340 : {
341 132 : cout << " - [" << i << "]=" << s[i] << endl ;
342 : }
343 :
344 : cout << endl ;
345 : }
346 :
347 1 : void TestWCharSeq(void)
348 : {
349 1 : cout << "========== Testing CORBAWCharSeq ==========" << endl << endl ;
350 :
351 1 : CORBAWCharSeq s1 ;
352 1 : DumpWCharSeq(s1, "Sequence s1()") ;
353 :
354 1 : CORBAWCharSeq s2(12) ;
355 1 : s2[0] = 'a' ;
356 1 : s2[1] = 'b' ;
357 1 : s2[2] = 'c' ;
358 1 : s2[3] = 'd' ;
359 1 : s2[4] = 'e' ;
360 1 : s2[5] = 'f' ;
361 1 : s2[6] = 'g' ;
362 1 : s2[7] = 'h' ;
363 1 : s2[8] = 'i' ;
364 1 : s2[9] = 'j' ;
365 1 : s2[10] = 'k' ;
366 1 : s2[11] = 'l' ;
367 1 : DumpWCharSeq(s2, "Sequence s2(12)") ;
368 :
369 : CORBA::WChar data_s3[] =
370 : {
371 : 'A',
372 : 'B',
373 : 'C',
374 : 'D'
375 1 : } ;
376 :
377 1 : CORBAWCharSeq s3(4UL, 4UL, & data_s3 [0], false) ;
378 1 : DumpWCharSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
379 :
380 1 : CORBA::WChar *data_s4 = new CORBA::WChar[4] ;
381 1 : data_s4[0] = 'X' ;
382 1 : data_s4[1] = 'Y' ;
383 1 : data_s4[2] = 'Z' ;
384 1 : data_s4[3] = 'T' ;
385 :
386 1 : CORBAWCharSeq s4(4UL, 4UL, data_s4, false) ;
387 1 : DumpWCharSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
388 :
389 1 : CORBAWCharSeq s5(s1) ;
390 1 : DumpWCharSeq(s5, "Sequence s5(s1)") ;
391 :
392 1 : CORBAWCharSeq s6(s2) ;
393 1 : DumpWCharSeq(s6, "Sequence s6(s2)") ;
394 :
395 1 : s1 = s3 ;
396 1 : DumpWCharSeq(s1, "s1 = s3") ;
397 :
398 1 : s2 = s4 ;
399 1 : DumpWCharSeq(s2, "s2 = s4") ;
400 :
401 1 : s1.length(8) ;
402 1 : s1[4] = '#' ;
403 1 : s1[5] = '#' ;
404 1 : s1[6] = '#' ;
405 1 : s1[7] = '#' ;
406 1 : DumpWCharSeq(s1, "s1.length(8)") ;
407 :
408 1 : s2.length(8) ;
409 1 : DumpWCharSeq(s2, "s2.length(8)") ;
410 :
411 1 : CORBA::WChar& c = s3[1] ;
412 1 : c = '?' ;
413 1 : DumpWCharSeq(s3, "hacking s3[1]='?', still in stack") ;
414 :
415 1 : CORBA::WChar *buf = s3.get_buffer(true) ;
416 1 : DumpWCharSeq(s3, "orphaned s3") ;
417 :
418 1 : if (buf != data_s3)
419 : {
420 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
421 : }
422 :
423 1 : s3.replace(4UL, 4UL, data_s4, false) ;
424 1 : DumpWCharSeq(s3, "s3 replaced with not owned data") ;
425 :
426 1 : s3.replace(2UL, 2UL, data_s4, false) ;
427 1 : DumpWCharSeq(s3, "s3 replaced with not owned data, again") ;
428 :
429 1 : s4.replace(0UL, 0UL, NULL, false) ;
430 1 : DumpWCharSeq(s4, "s4 orphaned the hard way") ;
431 :
432 1 : delete [] data_s4 ;
433 : }
434 :
435 : //=============================================================================
436 : // sequence<CORBA::Octet>
437 : //=============================================================================
438 :
439 15 : void DumpOctetSeq(CORBAOctetSeq& s, const char* title)
440 : {
441 : CORBA::ULong i ;
442 15 : CORBA::ULong len = s.length() ;
443 15 : CORBA::ULong max = s.maximum() ;
444 15 : CORBA::Boolean rel = s.release() ;
445 : const CORBAOctetSeq& const_s = s ;
446 15 : const void *buffer = const_s.get_buffer() ;
447 15 : void *buffer2 = s.get_buffer(false) ;
448 :
449 15 : cout << title << endl << endl ;
450 :
451 15 : cout << "Length = " << len << endl ;
452 15 : cout << "Max = " << max << endl ;
453 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
454 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
455 :
456 15 : if (buffer != buffer2)
457 : {
458 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
459 : }
460 :
461 81 : for (i = 0 ; i < len ; i++)
462 : {
463 132 : cout << " - [" << i << "]=" << (int)(s[i]) << endl ;
464 : }
465 :
466 : cout << endl ;
467 : }
468 :
469 1 : void TestOctetSeq(void)
470 : {
471 1 : cout << "========== Testing CORBAOctetSeq ==========" << endl << endl ;
472 :
473 1 : CORBAOctetSeq s1 ;
474 1 : DumpOctetSeq(s1, "Sequence s1()") ;
475 :
476 1 : CORBAOctetSeq s2(12) ;
477 1 : s2[0] = 100 ;
478 1 : s2[1] = 101 ;
479 1 : s2[2] = 102 ;
480 1 : s2[3] = 103 ;
481 1 : s2[4] = 104 ;
482 1 : s2[5] = 105 ;
483 1 : s2[6] = 106 ;
484 1 : s2[7] = 107 ;
485 1 : s2[8] = 108 ;
486 1 : s2[9] = 109 ;
487 1 : s2[10] = 110;
488 1 : s2[11] = 111 ;
489 1 : DumpOctetSeq(s2, "Sequence s2(12)") ;
490 :
491 : CORBA::Octet data_s3[] =
492 : {
493 : 201,
494 : 202,
495 : 203,
496 : 204
497 1 : } ;
498 :
499 1 : CORBAOctetSeq s3(4UL, 4UL, & data_s3 [0], false) ;
500 1 : DumpOctetSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
501 :
502 1 : CORBA::Octet *data_s4 = new CORBA::Octet[4] ;
503 1 : data_s4[0] = 11 ;
504 1 : data_s4[1] = 22 ;
505 1 : data_s4[2] = 33 ;
506 1 : data_s4[3] = 44 ;
507 :
508 1 : CORBAOctetSeq s4(4UL, 4UL, data_s4, false) ;
509 1 : DumpOctetSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
510 :
511 1 : CORBAOctetSeq s5(s1) ;
512 1 : DumpOctetSeq(s5, "Sequence s5(s1)") ;
513 :
514 1 : CORBAOctetSeq s6(s2) ;
515 1 : DumpOctetSeq(s6, "Sequence s6(s2)") ;
516 :
517 1 : s1 = s3 ;
518 1 : DumpOctetSeq(s1, "s1 = s3") ;
519 :
520 1 : s2 = s4 ;
521 1 : DumpOctetSeq(s2, "s2 = s4") ;
522 :
523 1 : s1.length(8) ;
524 1 : s1[4] = 255 ;
525 1 : s1[5] = 255 ;
526 1 : s1[6] = 255 ;
527 1 : s1[7] = 255 ;
528 1 : DumpOctetSeq(s1, "s1.length(8)") ;
529 :
530 1 : s2.length(8) ;
531 1 : DumpOctetSeq(s2, "s2.length(8)") ;
532 :
533 1 : CORBA::Octet& c = s3[1] ;
534 1 : c = 128 ;
535 1 : DumpOctetSeq(s3, "hacking s3[1]=128, still in stack") ;
536 :
537 1 : CORBA::Octet *buf = s3.get_buffer(true) ;
538 1 : DumpOctetSeq(s3, "orphaned s3") ;
539 :
540 1 : if (buf != data_s3)
541 : {
542 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
543 : }
544 :
545 1 : s3.replace(4UL, 4UL, data_s4, false) ;
546 1 : DumpOctetSeq(s3, "s3 replaced with not owned data") ;
547 :
548 1 : s3.replace(2UL, 2UL, data_s4, false) ;
549 1 : DumpOctetSeq(s3, "s3 replaced with not owned data, again") ;
550 :
551 1 : s4.replace(0UL, 0UL, NULL, false) ;
552 1 : DumpOctetSeq(s4, "s4 orphaned the hard way") ;
553 :
554 1 : delete [] data_s4 ;
555 : }
556 :
557 : //=============================================================================
558 : // sequence<CORBA::Short>
559 : //=============================================================================
560 :
561 15 : void DumpShortSeq(CORBAShortSeq& s, const char* title)
562 : {
563 : CORBA::ULong i ;
564 15 : CORBA::ULong len = s.length() ;
565 15 : CORBA::ULong max = s.maximum() ;
566 15 : CORBA::Boolean rel = s.release() ;
567 : const CORBAShortSeq& const_s = s ;
568 15 : const void *buffer = const_s.get_buffer() ;
569 15 : void *buffer2 = s.get_buffer(false) ;
570 :
571 15 : cout << title << endl << endl ;
572 :
573 15 : cout << "Length = " << len << endl ;
574 15 : cout << "Max = " << max << endl ;
575 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
576 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
577 :
578 15 : if (buffer != buffer2)
579 : {
580 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
581 : }
582 :
583 81 : for (i = 0 ; i < len ; i++)
584 : {
585 132 : cout << " - [" << i << "]=" << (s[i]) << endl ;
586 : }
587 :
588 : cout << endl ;
589 : }
590 :
591 1 : void TestShortSeq(void)
592 : {
593 1 : cout << "========== Testing CORBAShortSeq ==========" << endl << endl ;
594 :
595 1 : CORBAShortSeq s1 ;
596 1 : DumpShortSeq(s1, "Sequence s1()") ;
597 :
598 1 : CORBAShortSeq s2(12) ;
599 1 : s2[0] = 100 ;
600 1 : s2[1] = 101 ;
601 1 : s2[2] = 102 ;
602 1 : s2[3] = 103 ;
603 1 : s2[4] = 104 ;
604 1 : s2[5] = 105 ;
605 1 : s2[6] = 106 ;
606 1 : s2[7] = 107 ;
607 1 : s2[8] = 108 ;
608 1 : s2[9] = 109 ;
609 1 : s2[10] = 110;
610 1 : s2[11] = 111 ;
611 1 : DumpShortSeq(s2, "Sequence s2(12)") ;
612 :
613 : CORBA::Short data_s3[] =
614 : {
615 : 201,
616 : 202,
617 : 203,
618 : 204
619 1 : } ;
620 :
621 1 : CORBAShortSeq s3(4UL, 4UL, & data_s3 [0], false) ;
622 1 : DumpShortSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
623 :
624 1 : CORBA::Short *data_s4 = new CORBA::Short[4] ;
625 1 : data_s4[0] = -11 ;
626 1 : data_s4[1] = -22 ;
627 1 : data_s4[2] = -33 ;
628 1 : data_s4[3] = -44 ;
629 :
630 1 : CORBAShortSeq s4(4UL, 4UL, data_s4, false) ;
631 1 : DumpShortSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
632 :
633 1 : CORBAShortSeq s5(s1) ;
634 1 : DumpShortSeq(s5, "Sequence s5(s1)") ;
635 :
636 1 : CORBAShortSeq s6(s2) ;
637 1 : DumpShortSeq(s6, "Sequence s6(s2)") ;
638 :
639 1 : s1 = s3 ;
640 1 : DumpShortSeq(s1, "s1 = s3") ;
641 :
642 1 : s2 = s4 ;
643 1 : DumpShortSeq(s2, "s2 = s4") ;
644 :
645 1 : s1.length(8) ;
646 1 : s1[4] = 32767 ;
647 1 : s1[5] = 32767 ;
648 1 : s1[6] = 32767 ;
649 1 : s1[7] = 32767 ;
650 1 : DumpShortSeq(s1, "s1.length(8)") ;
651 :
652 1 : s2.length(8) ;
653 1 : DumpShortSeq(s2, "s2.length(8)") ;
654 :
655 1 : CORBA::Short& c = s3[1] ;
656 1 : c = -32768 ;
657 1 : DumpShortSeq(s3, "hacking s3[1]=-32768, still in stack") ;
658 :
659 1 : CORBA::Short *buf = s3.get_buffer(true) ;
660 1 : DumpShortSeq(s3, "orphaned s3") ;
661 :
662 1 : if (buf != data_s3)
663 : {
664 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
665 : }
666 :
667 1 : s3.replace(4UL, 4UL, data_s4, false) ;
668 1 : DumpShortSeq(s3, "s3 replaced with not owned data") ;
669 :
670 1 : s3.replace(2UL, 2UL, data_s4, false) ;
671 1 : DumpShortSeq(s3, "s3 replaced with not owned data, again") ;
672 :
673 1 : s4.replace(0UL, 0UL, NULL, false) ;
674 1 : DumpShortSeq(s4, "s4 orphaned the hard way") ;
675 :
676 1 : delete [] data_s4 ;
677 : }
678 :
679 : //=============================================================================
680 : // sequence<CORBA::UShort>
681 : //=============================================================================
682 :
683 15 : void DumpUShortSeq(CORBAUShortSeq& s, const char* title)
684 : {
685 : CORBA::ULong i ;
686 15 : CORBA::ULong len = s.length() ;
687 15 : CORBA::ULong max = s.maximum() ;
688 15 : CORBA::Boolean rel = s.release() ;
689 : const CORBAUShortSeq& const_s = s ;
690 15 : const void *buffer = const_s.get_buffer() ;
691 15 : void *buffer2 = s.get_buffer(false) ;
692 :
693 15 : cout << title << endl << endl ;
694 :
695 15 : cout << "Length = " << len << endl ;
696 15 : cout << "Max = " << max << endl ;
697 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
698 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
699 :
700 15 : if (buffer != buffer2)
701 : {
702 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
703 : }
704 :
705 81 : for (i = 0 ; i < len ; i++)
706 : {
707 132 : cout << " - [" << i << "]=" << (s[i]) << endl ;
708 : }
709 :
710 : cout << endl ;
711 : }
712 :
713 1 : void TestUShortSeq(void)
714 : {
715 1 : cout << "========== Testing CORBAUShortSeq ==========" << endl << endl ;
716 :
717 1 : CORBAUShortSeq s1 ;
718 1 : DumpUShortSeq(s1, "Sequence s1()") ;
719 :
720 1 : CORBAUShortSeq s2(12) ;
721 1 : s2[0] = 100 ;
722 1 : s2[1] = 101 ;
723 1 : s2[2] = 102 ;
724 1 : s2[3] = 103 ;
725 1 : s2[4] = 104 ;
726 1 : s2[5] = 105 ;
727 1 : s2[6] = 106 ;
728 1 : s2[7] = 107 ;
729 1 : s2[8] = 108 ;
730 1 : s2[9] = 109 ;
731 1 : s2[10] = 110;
732 1 : s2[11] = 111 ;
733 1 : DumpUShortSeq(s2, "Sequence s2(12)") ;
734 :
735 : CORBA::UShort data_s3[] =
736 : {
737 : 201,
738 : 202,
739 : 203,
740 : 204
741 1 : } ;
742 :
743 1 : CORBAUShortSeq s3(4UL, 4UL, & data_s3 [0], false) ;
744 1 : DumpUShortSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
745 :
746 1 : CORBA::UShort *data_s4 = new CORBA::UShort[4] ;
747 1 : data_s4[0] = 65000 ;
748 1 : data_s4[1] = 65001 ;
749 1 : data_s4[2] = 65002 ;
750 1 : data_s4[3] = 65003 ;
751 :
752 1 : CORBAUShortSeq s4(4UL, 4UL, data_s4, false) ;
753 1 : DumpUShortSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
754 :
755 1 : CORBAUShortSeq s5(s1) ;
756 1 : DumpUShortSeq(s5, "Sequence s5(s1)") ;
757 :
758 1 : CORBAUShortSeq s6(s2) ;
759 1 : DumpUShortSeq(s6, "Sequence s6(s2)") ;
760 :
761 1 : s1 = s3 ;
762 1 : DumpUShortSeq(s1, "s1 = s3") ;
763 :
764 1 : s2 = s4 ;
765 1 : DumpUShortSeq(s2, "s2 = s4") ;
766 :
767 1 : s1.length(8) ;
768 1 : s1[4] = 65535 ;
769 1 : s1[5] = 65535 ;
770 1 : s1[6] = 65535 ;
771 1 : s1[7] = 65535 ;
772 1 : DumpUShortSeq(s1, "s1.length(8)") ;
773 :
774 1 : s2.length(8) ;
775 1 : DumpUShortSeq(s2, "s2.length(8)") ;
776 :
777 1 : CORBA::UShort& c = s3[1] ;
778 1 : c = 0 ;
779 1 : DumpUShortSeq(s3, "hacking s3[1]=0, still in stack") ;
780 :
781 1 : CORBA::UShort *buf = s3.get_buffer(true) ;
782 1 : DumpUShortSeq(s3, "orphaned s3") ;
783 :
784 1 : if (buf != data_s3)
785 : {
786 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
787 : }
788 :
789 1 : s3.replace(4UL, 4UL, data_s4, false) ;
790 1 : DumpUShortSeq(s3, "s3 replaced with not owned data") ;
791 :
792 1 : s3.replace(2UL, 2UL, data_s4, false) ;
793 1 : DumpUShortSeq(s3, "s3 replaced with not owned data, again") ;
794 :
795 1 : s4.replace(0UL, 0UL, NULL, false) ;
796 1 : DumpUShortSeq(s4, "s4 orphaned the hard way") ;
797 :
798 1 : delete [] data_s4 ;
799 : }
800 :
801 : //=============================================================================
802 : // sequence<CORBA::Long>
803 : //=============================================================================
804 :
805 15 : void DumpLongSeq(CORBALongSeq& s, const char* title)
806 : {
807 : CORBA::ULong i ;
808 15 : CORBA::ULong len = s.length() ;
809 15 : CORBA::ULong max = s.maximum() ;
810 15 : CORBA::Boolean rel = s.release() ;
811 : const CORBALongSeq& const_s = s ;
812 15 : const void *buffer = const_s.get_buffer() ;
813 15 : void *buffer2 = s.get_buffer(false) ;
814 :
815 15 : cout << title << endl << endl ;
816 :
817 15 : cout << "Length = " << len << endl ;
818 15 : cout << "Max = " << max << endl ;
819 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
820 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
821 :
822 15 : if (buffer != buffer2)
823 : {
824 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
825 : }
826 :
827 81 : for (i = 0 ; i < len ; i++)
828 : {
829 132 : cout << " - [" << i << "]=" << s[i] << endl ;
830 : }
831 :
832 : cout << endl ;
833 : }
834 :
835 1 : void TestLongSeq(void)
836 : {
837 1 : cout << "========== Testing CORBALongSeq ==========" << endl << endl ;
838 :
839 1 : CORBALongSeq s1 ;
840 1 : DumpLongSeq(s1, "Sequence s1()") ;
841 :
842 1 : CORBALongSeq s2(12) ;
843 1 : s2[0] = 100 ;
844 1 : s2[1] = 101 ;
845 1 : s2[2] = 102 ;
846 1 : s2[3] = 103 ;
847 1 : s2[4] = 104 ;
848 1 : s2[5] = 105 ;
849 1 : s2[6] = 106 ;
850 1 : s2[7] = 107 ;
851 1 : s2[8] = 108 ;
852 1 : s2[9] = 109 ;
853 1 : s2[10] = 110;
854 1 : s2[11] = 111 ;
855 1 : DumpLongSeq(s2, "Sequence s2(12)") ;
856 :
857 : CORBA::Long data_s3[] =
858 : {
859 : 201,
860 : 202,
861 : 203,
862 : 204
863 1 : } ;
864 :
865 1 : CORBALongSeq s3(4UL, 4UL, & data_s3 [0], false) ;
866 1 : DumpLongSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
867 :
868 1 : CORBA::Long *data_s4 = new CORBA::Long[4] ;
869 1 : data_s4[0] = -11 ;
870 1 : data_s4[1] = -22 ;
871 1 : data_s4[2] = -33 ;
872 1 : data_s4[3] = -44 ;
873 :
874 1 : CORBALongSeq s4(4UL, 4UL, data_s4, false) ;
875 1 : DumpLongSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
876 :
877 1 : CORBALongSeq s5(s1) ;
878 1 : DumpLongSeq(s5, "Sequence s5(s1)") ;
879 :
880 1 : CORBALongSeq s6(s2) ;
881 1 : DumpLongSeq(s6, "Sequence s6(s2)") ;
882 :
883 1 : s1 = s3 ;
884 1 : DumpLongSeq(s1, "s1 = s3") ;
885 :
886 1 : s2 = s4 ;
887 1 : DumpLongSeq(s2, "s2 = s4") ;
888 :
889 1 : s1.length(8) ;
890 1 : s1[4] = 2147483647 ;
891 1 : s1[5] = 2147483647 ;
892 1 : s1[6] = 2147483647 ;
893 1 : s1[7] = 2147483647 ;
894 1 : DumpLongSeq(s1, "s1.length(8)") ;
895 :
896 1 : s2.length(8) ;
897 1 : DumpLongSeq(s2, "s2.length(8)") ;
898 :
899 1 : CORBA::Long& c = s3[1] ;
900 1 : c = -2147483647L -1L ;
901 1 : DumpLongSeq(s3, "hacking s3[1]=-2147483648, still in stack") ;
902 :
903 1 : CORBA::Long *buf = s3.get_buffer(true) ;
904 1 : DumpLongSeq(s3, "orphaned s3") ;
905 :
906 1 : if (buf != data_s3)
907 : {
908 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
909 : }
910 :
911 1 : s3.replace(4UL, 4UL, data_s4, false) ;
912 1 : DumpLongSeq(s3, "s3 replaced with not owned data") ;
913 :
914 1 : s3.replace(2UL, 2UL, data_s4, false) ;
915 1 : DumpLongSeq(s3, "s3 replaced with not owned data, again") ;
916 :
917 1 : s4.replace(0UL, 0UL, NULL, false) ;
918 1 : DumpLongSeq(s4, "s4 orphaned the hard way") ;
919 :
920 1 : delete [] data_s4 ;
921 : }
922 :
923 : //=============================================================================
924 : // sequence<CORBA::ULong>
925 : //=============================================================================
926 :
927 15 : void DumpULongSeq(CORBAULongSeq& s, const char* title)
928 : {
929 : CORBA::ULong i ;
930 15 : CORBA::ULong len = s.length() ;
931 15 : CORBA::ULong max = s.maximum() ;
932 15 : CORBA::Boolean rel = s.release() ;
933 : const CORBAULongSeq& const_s = s ;
934 15 : const void *buffer = const_s.get_buffer() ;
935 15 : void *buffer2 = s.get_buffer(false) ;
936 :
937 15 : cout << title << endl << endl ;
938 :
939 15 : cout << "Length = " << len << endl ;
940 15 : cout << "Max = " << max << endl ;
941 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
942 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
943 :
944 15 : if (buffer != buffer2)
945 : {
946 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
947 : }
948 :
949 81 : for (i = 0 ; i < len ; i++)
950 : {
951 132 : cout << " - [" << i << "]=" << (s[i]) << endl ;
952 : }
953 :
954 : cout << endl ;
955 : }
956 :
957 1 : void TestULongSeq(void)
958 : {
959 1 : cout << "========== Testing CORBAULongSeq ==========" << endl << endl ;
960 :
961 1 : CORBAULongSeq s1 ;
962 1 : DumpULongSeq(s1, "Sequence s1()") ;
963 :
964 1 : CORBAULongSeq s2(12) ;
965 1 : s2[0] = 100 ;
966 1 : s2[1] = 101 ;
967 1 : s2[2] = 102 ;
968 1 : s2[3] = 103 ;
969 1 : s2[4] = 104 ;
970 1 : s2[5] = 105 ;
971 1 : s2[6] = 106 ;
972 1 : s2[7] = 107 ;
973 1 : s2[8] = 108 ;
974 1 : s2[9] = 109 ;
975 1 : s2[10] = 110;
976 1 : s2[11] = 111 ;
977 1 : DumpULongSeq(s2, "Sequence s2(12)") ;
978 :
979 : CORBA::ULong data_s3[] =
980 : {
981 : 201,
982 : 202,
983 : 203,
984 : 204
985 1 : } ;
986 :
987 1 : CORBAULongSeq s3(4UL, 4UL, & data_s3 [0], false) ;
988 1 : DumpULongSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
989 :
990 1 : CORBA::ULong *data_s4 = new CORBA::ULong[4] ;
991 1 : data_s4[0] = 65000 ;
992 1 : data_s4[1] = 65001 ;
993 1 : data_s4[2] = 65002 ;
994 1 : data_s4[3] = 65003 ;
995 :
996 1 : CORBAULongSeq s4(4UL, 4UL, data_s4, false) ;
997 1 : DumpULongSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
998 :
999 1 : CORBAULongSeq s5(s1) ;
1000 1 : DumpULongSeq(s5, "Sequence s5(s1)") ;
1001 :
1002 1 : CORBAULongSeq s6(s2) ;
1003 1 : DumpULongSeq(s6, "Sequence s6(s2)") ;
1004 :
1005 1 : s1 = s3 ;
1006 1 : DumpULongSeq(s1, "s1 = s3") ;
1007 :
1008 1 : s2 = s4 ;
1009 1 : DumpULongSeq(s2, "s2 = s4") ;
1010 :
1011 1 : s1.length(8) ;
1012 1 : s1[4] = 4294967295UL ;
1013 1 : s1[5] = 4294967295UL ;
1014 1 : s1[6] = 4294967295UL ;
1015 1 : s1[7] = 4294967295UL ;
1016 1 : DumpULongSeq(s1, "s1.length(8)") ;
1017 :
1018 1 : s2.length(8) ;
1019 1 : DumpULongSeq(s2, "s2.length(8)") ;
1020 :
1021 1 : CORBA::ULong& c = s3[1] ;
1022 1 : c = 0 ;
1023 1 : DumpULongSeq(s3, "hacking s3[1]=0, still in stack") ;
1024 :
1025 1 : CORBA::ULong *buf = s3.get_buffer(true) ;
1026 1 : DumpULongSeq(s3, "orphaned s3") ;
1027 :
1028 1 : if (buf != data_s3)
1029 : {
1030 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
1031 : }
1032 :
1033 1 : s3.replace(4UL, 4UL, data_s4, false) ;
1034 1 : DumpULongSeq(s3, "s3 replaced with not owned data") ;
1035 :
1036 1 : s3.replace(2UL, 2UL, data_s4, false) ;
1037 1 : DumpULongSeq(s3, "s3 replaced with not owned data, again") ;
1038 :
1039 1 : s4.replace(0UL, 0UL, NULL, false) ;
1040 1 : DumpULongSeq(s4, "s4 orphaned the hard way") ;
1041 :
1042 1 : delete [] data_s4 ;
1043 : }
1044 :
1045 : //=============================================================================
1046 : // sequence<CORBA::LongLong>
1047 : //=============================================================================
1048 :
1049 15 : void DumpLongLongSeq(CORBALongLongSeq& s, const char* title)
1050 : {
1051 : CORBA::ULong i ;
1052 15 : CORBA::ULong len = s.length() ;
1053 15 : CORBA::ULong max = s.maximum() ;
1054 15 : CORBA::Boolean rel = s.release() ;
1055 : const CORBALongLongSeq& const_s = s ;
1056 15 : const void *buffer = const_s.get_buffer() ;
1057 15 : void *buffer2 = s.get_buffer(false) ;
1058 :
1059 15 : cout << title << endl << endl ;
1060 :
1061 15 : cout << "Length = " << len << endl ;
1062 15 : cout << "Max = " << max << endl ;
1063 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
1064 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
1065 :
1066 15 : if (buffer != buffer2)
1067 : {
1068 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
1069 : }
1070 :
1071 : CORBA::LongLong v ;
1072 : CORBA::Long vh, vl ;
1073 : char buf[255] ;
1074 :
1075 81 : for (i = 0 ; i < len ; i++)
1076 : {
1077 66 : v = s[i] ;
1078 : vh = v >> 32 ;
1079 : vl = v & 0xFFFFFFFFL ;
1080 66 : sprintf(buf, "0x%08x%08x", vh, vl) ;
1081 132 : cout << " - [" << i << "]=" << buf << endl ;
1082 : }
1083 :
1084 : cout << endl ;
1085 : }
1086 :
1087 1 : void TestLongLongSeq(void)
1088 : {
1089 1 : cout << "========== Testing CORBALongLongSeq ==========" << endl << endl ;
1090 :
1091 1 : CORBALongLongSeq s1 ;
1092 1 : DumpLongLongSeq(s1, "Sequence s1()") ;
1093 :
1094 1 : CORBALongLongSeq s2(12) ;
1095 1 : s2[0] = 0x100 ;
1096 1 : s2[1] = 0x101 ;
1097 1 : s2[2] = 0x102 ;
1098 1 : s2[3] = 0x103 ;
1099 1 : s2[4] = 0x104 ;
1100 1 : s2[5] = 0x105 ;
1101 1 : s2[6] = 0x106 ;
1102 1 : s2[7] = 0x107 ;
1103 1 : s2[8] = 0x108 ;
1104 1 : s2[9] = 0x109 ;
1105 1 : s2[10] = 0x110;
1106 1 : s2[11] = 0x111 ;
1107 1 : DumpLongLongSeq(s2, "Sequence s2(12)") ;
1108 :
1109 : CORBA::LongLong data_s3[] =
1110 : {
1111 : 0x201,
1112 : 0x202,
1113 : 0x203,
1114 : 0x204
1115 1 : } ;
1116 :
1117 1 : CORBALongLongSeq s3(4UL, 4UL, & data_s3 [0], false) ;
1118 1 : DumpLongLongSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
1119 :
1120 1 : CORBA::LongLong *data_s4 = new CORBA::LongLong[4] ;
1121 1 : data_s4[0] = -0x11 ;
1122 1 : data_s4[1] = -0x22 ;
1123 1 : data_s4[2] = -0x33 ;
1124 1 : data_s4[3] = -0x44 ;
1125 :
1126 1 : CORBALongLongSeq s4(4UL, 4UL, data_s4, false) ;
1127 1 : DumpLongLongSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
1128 :
1129 1 : CORBALongLongSeq s5(s1) ;
1130 1 : DumpLongLongSeq(s5, "Sequence s5(s1)") ;
1131 :
1132 1 : CORBALongLongSeq s6(s2) ;
1133 1 : DumpLongLongSeq(s6, "Sequence s6(s2)") ;
1134 :
1135 1 : s1 = s3 ;
1136 1 : DumpLongLongSeq(s1, "s1 = s3") ;
1137 :
1138 1 : s2 = s4 ;
1139 1 : DumpLongLongSeq(s2, "s2 = s4") ;
1140 :
1141 1 : s1.length(8) ;
1142 : // long long may not be supported natively, can not express s64 constants
1143 1 : s1[4] = 0x7FFFFFFFL ;
1144 1 : s1[4] <<= 32 ;
1145 1 : s1[4] += 0xFFFFFFFFL ;
1146 :
1147 1 : s1[5] = 0x7FFFFFFFL ;
1148 1 : s1[5] <<= 32 ;
1149 1 : s1[5] += 0xFFFFFFFFL ;
1150 :
1151 1 : s1[6] = 0x7FFFFFFFL ;
1152 1 : s1[6] <<= 32 ;
1153 1 : s1[6] += 0xFFFFFFFFL ;
1154 :
1155 1 : s1[7] = 0x7FFFFFFFL ;
1156 1 : s1[7] <<= 32 ;
1157 1 : s1[7] += 0xFFFFFFFFL ;
1158 :
1159 1 : DumpLongLongSeq(s1, "s1.length(8)") ;
1160 :
1161 1 : s2.length(8) ;
1162 1 : DumpLongLongSeq(s2, "s2.length(8)") ;
1163 :
1164 1 : CORBA::LongLong& c = s3[1] ;
1165 1 : c = ( - 0x80000000L ) ;
1166 1 : c <<= 32 ;
1167 1 : DumpLongLongSeq(s3, "hacking s3[1]=-8000000000000000, still in stack") ;
1168 :
1169 1 : CORBA::LongLong *buf = s3.get_buffer(true) ;
1170 1 : DumpLongLongSeq(s3, "orphaned s3") ;
1171 :
1172 1 : if (buf != data_s3)
1173 : {
1174 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
1175 : }
1176 :
1177 1 : s3.replace(4UL, 4UL, data_s4, false) ;
1178 1 : DumpLongLongSeq(s3, "s3 replaced with not owned data") ;
1179 :
1180 1 : s3.replace(2UL, 2UL, data_s4, false) ;
1181 1 : DumpLongLongSeq(s3, "s3 replaced with not owned data, again") ;
1182 :
1183 1 : s4.replace(0UL, 0UL, NULL, false) ;
1184 1 : DumpLongLongSeq(s4, "s4 orphaned the hard way") ;
1185 :
1186 1 : delete [] data_s4 ;
1187 : }
1188 :
1189 : //=============================================================================
1190 : // sequence<CORBA::ULongLong>
1191 : //=============================================================================
1192 :
1193 15 : void DumpULongLongSeq(CORBAULongLongSeq& s, const char* title)
1194 : {
1195 : CORBA::ULong i ;
1196 15 : CORBA::ULong len = s.length() ;
1197 15 : CORBA::ULong max = s.maximum() ;
1198 15 : CORBA::Boolean rel = s.release() ;
1199 : const CORBAULongLongSeq& const_s = s ;
1200 15 : const void *buffer = const_s.get_buffer() ;
1201 15 : void *buffer2 = s.get_buffer(false) ;
1202 :
1203 15 : cout << title << endl << endl ;
1204 :
1205 15 : cout << "Length = " << len << endl ;
1206 15 : cout << "Max = " << max << endl ;
1207 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
1208 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
1209 :
1210 15 : if (buffer != buffer2)
1211 : {
1212 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
1213 : }
1214 :
1215 : CORBA::ULongLong v ;
1216 : CORBA::ULong vh, vl ;
1217 : char buf[255] ;
1218 :
1219 81 : for (i = 0 ; i < len ; i++)
1220 : {
1221 66 : v = s[i] ;
1222 : vh = v >> 32 ;
1223 : vl = v & 0xFFFFFFFFL ;
1224 66 : sprintf(buf, "0x%08x%08x", vh, vl) ;
1225 132 : cout << " - [" << i << "]=" << buf << endl ;
1226 : }
1227 :
1228 : cout << endl ;
1229 : }
1230 :
1231 1 : void TestULongLongSeq(void)
1232 : {
1233 1 : cout << "========== Testing CORBAULongLongSeq ==========" << endl << endl ;
1234 :
1235 1 : CORBAULongLongSeq s1 ;
1236 1 : DumpULongLongSeq(s1, "Sequence s1()") ;
1237 :
1238 1 : CORBAULongLongSeq s2(12) ;
1239 1 : s2[0] = 0x100 ;
1240 1 : s2[1] = 0x101 ;
1241 1 : s2[2] = 0x102 ;
1242 1 : s2[3] = 0x103 ;
1243 1 : s2[4] = 0x104 ;
1244 1 : s2[5] = 0x105 ;
1245 1 : s2[6] = 0x106 ;
1246 1 : s2[7] = 0x107 ;
1247 1 : s2[8] = 0x108 ;
1248 1 : s2[9] = 0x109 ;
1249 1 : s2[10] = 0x110;
1250 1 : s2[11] = 0x111 ;
1251 1 : DumpULongLongSeq(s2, "Sequence s2(12)") ;
1252 :
1253 : CORBA::ULongLong data_s3[] =
1254 : {
1255 : 0x201,
1256 : 0x202,
1257 : 0x203,
1258 : 0x204
1259 1 : } ;
1260 :
1261 1 : CORBAULongLongSeq s3(4UL, 4UL, & data_s3 [0], false) ;
1262 1 : DumpULongLongSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
1263 :
1264 1 : CORBA::ULongLong *data_s4 = new CORBA::ULongLong[4] ;
1265 1 : data_s4[0] = 0x65000 ;
1266 1 : data_s4[1] = 0x65001 ;
1267 1 : data_s4[2] = 0x65002 ;
1268 1 : data_s4[3] = 0x65003 ;
1269 :
1270 1 : CORBAULongLongSeq s4(4UL, 4UL, data_s4, false) ;
1271 1 : DumpULongLongSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
1272 :
1273 1 : CORBAULongLongSeq s5(s1) ;
1274 1 : DumpULongLongSeq(s5, "Sequence s5(s1)") ;
1275 :
1276 1 : CORBAULongLongSeq s6(s2) ;
1277 1 : DumpULongLongSeq(s6, "Sequence s6(s2)") ;
1278 :
1279 1 : s1 = s3 ;
1280 1 : DumpULongLongSeq(s1, "s1 = s3") ;
1281 :
1282 1 : s2 = s4 ;
1283 1 : DumpULongLongSeq(s2, "s2 = s4") ;
1284 :
1285 1 : s1.length(8) ;
1286 : // long long may not be supported natively, can not express u64 constants
1287 1 : s1[4] = 0xFFFFFFFFUL ;
1288 1 : s1[4] <<= 32 ;
1289 1 : s1[4] += 0xFFFFFFFFUL ;
1290 :
1291 1 : s1[5] = 0xFFFFFFFFUL ;
1292 1 : s1[5] <<= 32 ;
1293 1 : s1[5] += 0xFFFFFFFFUL ;
1294 :
1295 1 : s1[6] = 0xFFFFFFFFUL ;
1296 1 : s1[6] <<= 32 ;
1297 1 : s1[6] += 0xFFFFFFFFUL ;
1298 :
1299 1 : s1[7] = 0xFFFFFFFFUL ;
1300 1 : s1[7] <<= 32 ;
1301 1 : s1[7] += 0xFFFFFFFFUL ;
1302 :
1303 1 : DumpULongLongSeq(s1, "s1.length(8)") ;
1304 :
1305 1 : s2.length(8) ;
1306 1 : DumpULongLongSeq(s2, "s2.length(8)") ;
1307 :
1308 1 : CORBA::ULongLong& c = s3[1] ;
1309 1 : c = 0 ;
1310 1 : DumpULongLongSeq(s3, "hacking s3[1]=0, still in stack") ;
1311 :
1312 1 : CORBA::ULongLong *buf = s3.get_buffer(true) ;
1313 1 : DumpULongLongSeq(s3, "orphaned s3") ;
1314 :
1315 1 : if (buf != data_s3)
1316 : {
1317 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
1318 : }
1319 :
1320 1 : s3.replace(4UL, 4UL, data_s4, false) ;
1321 1 : DumpULongLongSeq(s3, "s3 replaced with not owned data") ;
1322 :
1323 1 : s3.replace(2UL, 2UL, data_s4, false) ;
1324 1 : DumpULongLongSeq(s3, "s3 replaced with not owned data, again") ;
1325 :
1326 1 : s4.replace(0UL, 0UL, NULL, false) ;
1327 1 : DumpULongLongSeq(s4, "s4 orphaned the hard way") ;
1328 :
1329 1 : delete [] data_s4 ;
1330 : }
1331 :
1332 : //=============================================================================
1333 : // sequence<CORBA::Float>
1334 : //=============================================================================
1335 :
1336 15 : void DumpFloatSeq(CORBAFloatSeq& s, const char* title)
1337 : {
1338 : CORBA::ULong i ;
1339 15 : CORBA::ULong len = s.length() ;
1340 15 : CORBA::ULong max = s.maximum() ;
1341 15 : CORBA::Boolean rel = s.release() ;
1342 : const CORBAFloatSeq& const_s = s ;
1343 15 : const void *buffer = const_s.get_buffer() ;
1344 15 : void *buffer2 = s.get_buffer(false) ;
1345 :
1346 15 : cout << title << endl << endl ;
1347 :
1348 15 : cout << "Length = " << len << endl ;
1349 15 : cout << "Max = " << max << endl ;
1350 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
1351 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
1352 :
1353 15 : if (buffer != buffer2)
1354 : {
1355 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
1356 : }
1357 :
1358 81 : for (i = 0 ; i < len ; i++)
1359 : {
1360 132 : cout << " - [" << i << "]=" << s[i] << endl ;
1361 : }
1362 :
1363 : cout << endl ;
1364 : }
1365 :
1366 1 : void TestFloatSeq(void)
1367 : {
1368 1 : cout << "========== Testing CORBAFloatSeq ==========" << endl << endl ;
1369 :
1370 1 : CORBAFloatSeq s1 ;
1371 1 : DumpFloatSeq(s1, "Sequence s1()") ;
1372 :
1373 1 : CORBAFloatSeq s2(12) ;
1374 1 : s2[0] = 1.1E1 ;
1375 1 : s2[1] = 2.2E2 ;
1376 1 : s2[2] = 3.3E3 ;
1377 1 : s2[3] = 4.4E4 ;
1378 1 : s2[4] = 5.5E5 ;
1379 1 : s2[5] = 6.6E6 ;
1380 1 : s2[6] = 7.7E7 ;
1381 1 : s2[7] = 8.8E8 ;
1382 1 : s2[8] = 9.9E9 ;
1383 1 : s2[9] = 12.12 ;
1384 1 : s2[10] = 3.1415 ;
1385 1 : s2[11] = 1.0E-15 ;
1386 1 : DumpFloatSeq(s2, "Sequence s2(12)") ;
1387 :
1388 : CORBA::Float data_s3[] =
1389 : {
1390 : 9.0E-12,
1391 : 8.0E-13,
1392 : 7.0E-14,
1393 : 6.0E-15
1394 1 : } ;
1395 :
1396 1 : CORBAFloatSeq s3(4UL, 4UL, & data_s3 [0], false) ;
1397 1 : DumpFloatSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
1398 :
1399 1 : CORBA::Float *data_s4 = new CORBA::Float[4] ;
1400 1 : data_s4[0] = 9.99999E34 ;
1401 1 : data_s4[1] = 9.99999E34 ;
1402 1 : data_s4[2] = 9.99999E34 ;
1403 1 : data_s4[3] = 9.99999E34 ;
1404 :
1405 1 : CORBAFloatSeq s4(4UL, 4UL, data_s4, false) ;
1406 1 : DumpFloatSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
1407 :
1408 1 : CORBAFloatSeq s5(s1) ;
1409 1 : DumpFloatSeq(s5, "Sequence s5(s1)") ;
1410 :
1411 1 : CORBAFloatSeq s6(s2) ;
1412 1 : DumpFloatSeq(s6, "Sequence s6(s2)") ;
1413 :
1414 1 : s1 = s3 ;
1415 1 : DumpFloatSeq(s1, "s1 = s3") ;
1416 :
1417 1 : s2 = s4 ;
1418 1 : DumpFloatSeq(s2, "s2 = s4") ;
1419 :
1420 1 : s1.length(8) ;
1421 1 : s1[4] = 0.0 ;
1422 1 : s1[5] = 0.0 ;
1423 1 : s1[6] = 0.0 ;
1424 1 : s1[7] = 0.0 ;
1425 1 : DumpFloatSeq(s1, "s1.length(8)") ;
1426 :
1427 1 : s2.length(8) ;
1428 1 : DumpFloatSeq(s2, "s2.length(8)") ;
1429 :
1430 1 : CORBA::Float& c = s3[1] ;
1431 1 : c = 0.0 ;
1432 1 : DumpFloatSeq(s3, "hacking s3[1]=0, still in stack") ;
1433 :
1434 1 : CORBA::Float *buf = s3.get_buffer(true) ;
1435 1 : DumpFloatSeq(s3, "orphaned s3") ;
1436 :
1437 1 : if (buf != data_s3)
1438 : {
1439 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
1440 : }
1441 :
1442 1 : s3.replace(4UL, 4UL, data_s4, false) ;
1443 1 : DumpFloatSeq(s3, "s3 replaced with not owned data") ;
1444 :
1445 1 : s3.replace(2UL, 2UL, data_s4, false) ;
1446 1 : DumpFloatSeq(s3, "s3 replaced with not owned data, again") ;
1447 :
1448 1 : s4.replace(0UL, 0UL, NULL, false) ;
1449 1 : DumpFloatSeq(s4, "s4 orphaned the hard way") ;
1450 :
1451 1 : delete [] data_s4 ;
1452 : }
1453 :
1454 : //=============================================================================
1455 : // sequence<CORBA::Double>
1456 : //=============================================================================
1457 :
1458 15 : void DumpDoubleSeq(CORBADoubleSeq& s, const char* title)
1459 : {
1460 : CORBA::ULong i ;
1461 15 : CORBA::ULong len = s.length() ;
1462 15 : CORBA::ULong max = s.maximum() ;
1463 15 : CORBA::Boolean rel = s.release() ;
1464 : const CORBADoubleSeq& const_s = s ;
1465 15 : const void *buffer = const_s.get_buffer() ;
1466 15 : void *buffer2 = s.get_buffer(false) ;
1467 :
1468 15 : cout << title << endl << endl ;
1469 :
1470 15 : cout << "Length = " << len << endl ;
1471 15 : cout << "Max = " << max << endl ;
1472 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
1473 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
1474 :
1475 15 : if (buffer != buffer2)
1476 : {
1477 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
1478 : }
1479 :
1480 81 : for (i = 0 ; i < len ; i++)
1481 : {
1482 132 : cout << " - [" << i << "]=" << s[i] << endl ;
1483 : }
1484 :
1485 : cout << endl ;
1486 : }
1487 :
1488 1 : void TestDoubleSeq(void)
1489 : {
1490 1 : cout << "========== Testing CORBADoubleSeq ==========" << endl << endl ;
1491 :
1492 1 : CORBADoubleSeq s1 ;
1493 1 : DumpDoubleSeq(s1, "Sequence s1()") ;
1494 :
1495 1 : CORBADoubleSeq s2(12) ;
1496 1 : s2[0] = 1.1E1 ;
1497 1 : s2[1] = 2.2E2 ;
1498 1 : s2[2] = 3.3E3 ;
1499 1 : s2[3] = 4.4E4 ;
1500 1 : s2[4] = 5.5E5 ;
1501 1 : s2[5] = 6.6E6 ;
1502 1 : s2[6] = 7.7E7 ;
1503 1 : s2[7] = 8.8E8 ;
1504 1 : s2[8] = 9.9E9 ;
1505 1 : s2[9] = 12.12 ;
1506 1 : s2[10] = 3.1415 ;
1507 1 : s2[11] = 1.0E-15 ;
1508 1 : DumpDoubleSeq(s2, "Sequence s2(12)") ;
1509 :
1510 : CORBA::Double data_s3[] =
1511 : {
1512 : 9.0E-12,
1513 : 8.0E-13,
1514 : 7.0E-14,
1515 : 6.0E-15
1516 1 : } ;
1517 :
1518 1 : CORBADoubleSeq s3(4UL, 4UL, & data_s3 [0], false) ;
1519 1 : DumpDoubleSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
1520 :
1521 1 : CORBA::Double *data_s4 = new CORBA::Double[4] ;
1522 1 : data_s4[0] = 9.99999E34 ;
1523 1 : data_s4[1] = 9.99999E34 ;
1524 1 : data_s4[2] = 9.99999E34 ;
1525 1 : data_s4[3] = 9.99999E34 ;
1526 :
1527 1 : CORBADoubleSeq s4(4UL, 4UL, data_s4, false) ;
1528 1 : DumpDoubleSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
1529 :
1530 1 : CORBADoubleSeq s5(s1) ;
1531 1 : DumpDoubleSeq(s5, "Sequence s5(s1)") ;
1532 :
1533 1 : CORBADoubleSeq s6(s2) ;
1534 1 : DumpDoubleSeq(s6, "Sequence s6(s2)") ;
1535 :
1536 1 : s1 = s3 ;
1537 1 : DumpDoubleSeq(s1, "s1 = s3") ;
1538 :
1539 1 : s2 = s4 ;
1540 1 : DumpDoubleSeq(s2, "s2 = s4") ;
1541 :
1542 1 : s1.length(8) ;
1543 1 : s1[4] = 0.0 ;
1544 1 : s1[5] = 0.0 ;
1545 1 : s1[6] = 0.0 ;
1546 1 : s1[7] = 0.0 ;
1547 1 : DumpDoubleSeq(s1, "s1.length(8)") ;
1548 :
1549 1 : s2.length(8) ;
1550 1 : DumpDoubleSeq(s2, "s2.length(8)") ;
1551 :
1552 1 : CORBA::Double& c = s3[1] ;
1553 1 : c = 0.0 ;
1554 1 : DumpDoubleSeq(s3, "hacking s3[1]=0, still in stack") ;
1555 :
1556 1 : CORBA::Double *buf = s3.get_buffer(true) ;
1557 1 : DumpDoubleSeq(s3, "orphaned s3") ;
1558 :
1559 1 : if (buf != data_s3)
1560 : {
1561 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
1562 : }
1563 :
1564 1 : s3.replace(4UL, 4UL, data_s4, false) ;
1565 1 : DumpDoubleSeq(s3, "s3 replaced with not owned data") ;
1566 :
1567 1 : s3.replace(2UL, 2UL, data_s4, false) ;
1568 1 : DumpDoubleSeq(s3, "s3 replaced with not owned data, again") ;
1569 :
1570 1 : s4.replace(0UL, 0UL, NULL, false) ;
1571 1 : DumpDoubleSeq(s4, "s4 orphaned the hard way") ;
1572 :
1573 1 : delete [] data_s4 ;
1574 : }
1575 :
1576 : //=============================================================================
1577 : // sequence<CORBA::LongDouble>
1578 : //=============================================================================
1579 :
1580 15 : void DumpLongDoubleSeq(CORBALongDoubleSeq& s, const char* title)
1581 : {
1582 : CORBA::ULong i ;
1583 15 : CORBA::ULong len = s.length() ;
1584 15 : CORBA::ULong max = s.maximum() ;
1585 15 : CORBA::Boolean rel = s.release() ;
1586 : const CORBALongDoubleSeq& const_s = s ;
1587 15 : const void *buffer = const_s.get_buffer() ;
1588 15 : void *buffer2 = s.get_buffer(false) ;
1589 :
1590 15 : cout << title << endl << endl ;
1591 :
1592 15 : cout << "Length = " << len << endl ;
1593 15 : cout << "Max = " << max << endl ;
1594 15 : cout << "Release = " << (rel ? "true" : "false") << endl ;
1595 15 : cout << "Buffer = " << BufferType(buffer) << endl ;
1596 :
1597 15 : if (buffer != buffer2)
1598 : {
1599 0 : cout << "ERROR : get_buffer(void) != get_buffer(orphan = false) !!!" ;
1600 : }
1601 :
1602 81 : for (i = 0 ; i < len ; i++)
1603 : {
1604 66 : long double v = s[i] ;
1605 66 : double v2 = v ;
1606 132 : cout << " - [" << i << "]=" << v2 << endl ;
1607 : }
1608 :
1609 : cout << endl ;
1610 : }
1611 :
1612 1 : void TestLongDoubleSeq(void)
1613 : {
1614 1 : cout << "========== Testing CORBALongDoubleSeq ==========" << endl << endl ;
1615 :
1616 1 : CORBALongDoubleSeq s1 ;
1617 1 : DumpLongDoubleSeq(s1, "Sequence s1()") ;
1618 :
1619 1 : CORBALongDoubleSeq s2(12) ;
1620 1 : s2[0] = 1.1E1 ;
1621 1 : s2[1] = 2.2E2 ;
1622 1 : s2[2] = 3.3E3 ;
1623 1 : s2[3] = 4.4E4 ;
1624 1 : s2[4] = 5.5E5 ;
1625 1 : s2[5] = 6.6E6 ;
1626 1 : s2[6] = 7.7E7 ;
1627 1 : s2[7] = 8.8E8 ;
1628 1 : s2[8] = 9.9E9 ;
1629 1 : s2[9] = 12.12 ;
1630 1 : s2[10] = 3.1415 ;
1631 1 : s2[11] = 1.0E-15 ;
1632 1 : DumpLongDoubleSeq(s2, "Sequence s2(12)") ;
1633 :
1634 : CORBA::LongDouble data_s3[4] ;
1635 1 : data_s3[0] = 9.0E-12 ;
1636 1 : data_s3[1] = 8.0E-13 ;
1637 1 : data_s3[2] = 7.0E-14 ;
1638 1 : data_s3[3] = 6.0E-15 ;
1639 :
1640 1 : CORBALongDoubleSeq s3(4UL, 4UL, & data_s3 [0], false) ;
1641 1 : DumpLongDoubleSeq(s3, "Sequence s3(4, 4, stack data, false)") ;
1642 :
1643 1 : CORBA::LongDouble *data_s4 = new CORBA::LongDouble[4] ;
1644 1 : data_s4[0] = 9.99999E34 ;
1645 1 : data_s4[1] = 9.99999E34 ;
1646 1 : data_s4[2] = 9.99999E34 ;
1647 1 : data_s4[3] = 9.99999E34 ;
1648 :
1649 1 : CORBALongDoubleSeq s4(4UL, 4UL, data_s4, false) ;
1650 1 : DumpLongDoubleSeq(s4, "Sequence s4(4, 4, heap data, false)") ;
1651 :
1652 1 : CORBALongDoubleSeq s5(s1) ;
1653 1 : DumpLongDoubleSeq(s5, "Sequence s5(s1)") ;
1654 :
1655 1 : CORBALongDoubleSeq s6(s2) ;
1656 1 : DumpLongDoubleSeq(s6, "Sequence s6(s2)") ;
1657 :
1658 1 : s1 = s3 ;
1659 1 : DumpLongDoubleSeq(s1, "s1 = s3") ;
1660 :
1661 1 : s2 = s4 ;
1662 1 : DumpLongDoubleSeq(s2, "s2 = s4") ;
1663 :
1664 1 : s1.length(8) ;
1665 1 : s1[4] = 0.0 ;
1666 1 : s1[5] = 0.0 ;
1667 1 : s1[6] = 0.0 ;
1668 1 : s1[7] = 0.0 ;
1669 1 : DumpLongDoubleSeq(s1, "s1.length(8)") ;
1670 :
1671 1 : s2.length(8) ;
1672 1 : DumpLongDoubleSeq(s2, "s2.length(8)") ;
1673 :
1674 1 : CORBA::LongDouble& c = s3[1] ;
1675 1 : c = 0.0 ;
1676 1 : DumpLongDoubleSeq(s3, "hacking s3[1]=0, still in stack") ;
1677 :
1678 1 : CORBA::LongDouble *buf = s3.get_buffer(true) ;
1679 1 : DumpLongDoubleSeq(s3, "orphaned s3") ;
1680 :
1681 1 : if (buf != data_s3)
1682 : {
1683 0 : cout << "ERROR : wrong orphaned buffer for s3 !" << endl ;
1684 : }
1685 :
1686 1 : s3.replace(4UL, 4UL, data_s4, false) ;
1687 1 : DumpLongDoubleSeq(s3, "s3 replaced with not owned data") ;
1688 :
1689 1 : s3.replace(2UL, 2UL, data_s4, false) ;
1690 1 : DumpLongDoubleSeq(s3, "s3 replaced with not owned data, again") ;
1691 :
1692 1 : s4.replace(0UL, 0UL, NULL, false) ;
1693 1 : DumpLongDoubleSeq(s4, "s4 orphaned the hard way") ;
1694 :
1695 1 : delete [] data_s4 ;
1696 : }
1697 :
1698 13 : int main(int argc, char *argv[])
1699 : {
1700 : volatile int here ;
1701 13 : main_stack = & here ;
1702 13 : String menu ;
1703 : char str[256] ;
1704 :
1705 13 : FILE *input = fopen(argv[1], "r") ;
1706 13 : fscanf(input, "%s", str) ;
1707 13 : menu = str ;
1708 :
1709 13 : if (menu == "CORBA::Boolean")
1710 : {
1711 1 : TestBoolSeq() ;
1712 : }
1713 :
1714 13 : if (menu == "CORBA::Char")
1715 : {
1716 1 : TestCharSeq() ;
1717 : }
1718 :
1719 13 : if (menu == "CORBA::WChar")
1720 : {
1721 1 : TestWCharSeq() ;
1722 : }
1723 :
1724 13 : if (menu == "CORBA::Octet")
1725 : {
1726 1 : TestOctetSeq() ;
1727 : }
1728 :
1729 13 : if (menu == "CORBA::Short")
1730 : {
1731 1 : TestShortSeq() ;
1732 : }
1733 :
1734 13 : if (menu == "CORBA::UShort")
1735 : {
1736 1 : TestUShortSeq() ;
1737 : }
1738 :
1739 13 : if (menu == "CORBA::Long")
1740 : {
1741 1 : TestLongSeq() ;
1742 : }
1743 :
1744 13 : if (menu == "CORBA::ULong")
1745 : {
1746 1 : TestULongSeq() ;
1747 : }
1748 :
1749 13 : if (menu == "CORBA::LongLong")
1750 : {
1751 1 : TestLongLongSeq() ;
1752 : }
1753 :
1754 13 : if (menu == "CORBA::ULongLong")
1755 : {
1756 1 : TestULongLongSeq() ;
1757 : }
1758 :
1759 13 : if (menu == "CORBA::Float")
1760 : {
1761 1 : TestFloatSeq() ;
1762 : }
1763 :
1764 13 : if (menu == "CORBA::Double")
1765 : {
1766 1 : TestDoubleSeq() ;
1767 : }
1768 :
1769 13 : if (menu == "CORBA::LongDouble")
1770 : {
1771 1 : TestLongDoubleSeq() ;
1772 : }
1773 :
1774 :
1775 13 : fclose (input) ;
1776 13 : return 0L ;
1777 13 : }
1778 13 :
|
