1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sal.hxx"
26
27 //------------------------------------------------------------------------
28 // include files
29 //------------------------------------------------------------------------
30
31 #include "cppunit/TestAssert.h"
32 #include "cppunit/TestFixture.h"
33 #include "cppunit/extensions/HelperMacros.h"
34 #include "cppunit/plugin/TestPlugIn.h"
35 #include "test/uniquepipename.hxx"
36 #include <sal/types.h>
37 #include <rtl/ustring.hxx>
38
39 #ifndef _OSL_THREAD_HXX
40 #include <osl/thread.hxx>
41 #endif
42
43 #ifndef _OSL_MUTEX_HXX
44 #include <osl/mutex.hxx>
45 #endif
46
47 #ifndef _OSL_MUTEX_HXX
48 #include <osl/pipe.hxx>
49 #endif
50 #include <osl/time.h>
51
52 #ifdef UNX
53 #include <unistd.h>
54 #endif
55 #include <string.h>
56
57 using namespace osl;
58 using namespace rtl;
59
60 //------------------------------------------------------------------------
61 // helper functions
62 //------------------------------------------------------------------------
63
64 /** print Boolean value.
65 */
printBool(sal_Bool bOk)66 inline void printBool( sal_Bool bOk )
67 {
68 printf("#printBool# " );
69 ( sal_True == bOk ) ? printf("YES!\n" ): printf("NO!\n" );
70 }
71
72 /** print a UNI_CODE String.
73 */
printUString(const::rtl::OUString & str)74 inline void printUString( const ::rtl::OUString & str )
75 {
76 rtl::OString aString;
77
78 printf("#printUString_u# " );
79 aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
80 printf("%s\n", aString.getStr( ) );
81 }
82
83 /** print last error of pipe system.
84 */
printPipeError(::osl::Pipe aPipe)85 inline void printPipeError( ::osl::Pipe aPipe )
86 {
87 oslPipeError nError = aPipe.getError( );
88 printf("#printPipeError# " );
89 switch ( nError ) {
90 case osl_Pipe_E_None:
91 printf("Success!\n" );
92 break;
93 case osl_Pipe_E_NotFound:
94 printf("The returned error is: Not found!\n" );
95 break;
96 case osl_Pipe_E_AlreadyExists:
97 printf("The returned error is: Already exist!\n" );
98 break;
99 case osl_Pipe_E_NoProtocol:
100 printf("The returned error is: No protocol!\n" );
101 break;
102 case osl_Pipe_E_NetworkReset:
103 printf("The returned error is: Network reset!\n" );
104 break;
105 case osl_Pipe_E_ConnectionAbort:
106 printf("The returned error is: Connection aborted!\n" );
107 break;
108 case osl_Pipe_E_ConnectionReset:
109 printf("The returned error is: Connection reset!\n" );
110 break;
111 case osl_Pipe_E_NoBufferSpace:
112 printf("The returned error is: No buffer space!\n" );
113 break;
114 case osl_Pipe_E_TimedOut:
115 printf("The returned error is: Timeout!\n" );
116 break;
117 case osl_Pipe_E_ConnectionRefused:
118 printf("The returned error is: Connection refused!\n" );
119 break;
120 case osl_Pipe_E_invalidError:
121 printf("The returned error is: Invalid error!\n" );
122 break;
123 default:
124 printf("The returned error is: Number %d, Unknown Error\n", nError );
125 break;
126 }
127 }
128
129
130
131 //------------------------------------------------------------------------
132 // pipe name and transfer contents
133 //------------------------------------------------------------------------
134 const rtl::OUString aTestPipeName = rtl::OUString::createFromAscii( "testpipe2" );
135 const rtl::OUString aTestPipe1 = rtl::OUString::createFromAscii( "testpipe1" );
136 const rtl::OUString aTestString = rtl::OUString::createFromAscii( "Sun Microsystems" );
137
138 const OString m_pTestString1("Sun Microsystems");
139 const OString m_pTestString2("test pipe PASS/OK");
140
141 //------------------------------------------------------------------------
142 // test code start here
143 //------------------------------------------------------------------------
144
145 namespace osl_Pipe
146 {
147
148 //------------------------------------------------------------------------
149 // most return value -1 denote a fail of operation.
150 //------------------------------------------------------------------------
151 #define OSL_PIPE_FAIL -1
152
153 /** testing the methods:
154 inline Pipe();
155 inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options);
156 inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options,const Security & rSecurity);
157 inline Pipe(const Pipe& pipe);
158 inline Pipe(oslPipe pipe, __sal_NoAcquire noacquire );
159 inline Pipe(oslPipe Pipe);
160 */
161 class ctors : public CppUnit::TestFixture
162 {
163 public:
164 sal_Bool bRes, bRes1;
165
setUp()166 void setUp( )
167 {
168 }
169
tearDown()170 void tearDown( )
171 {
172 }
173
ctors_none()174 void ctors_none( )
175 {
176 ::osl::Pipe aPipe;
177 bRes = aPipe.is( );
178
179 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with no parameter, yet no case to test.",
180 sal_False == bRes );
181 }
182
ctors_name_option()183 void ctors_name_option( )
184 {
185 /// create a named pipe.
186 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
187 ::osl::Pipe aAssignPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
188
189 bRes = aPipe.is( ) && aAssignPipe.is( );
190
191 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with name and option.",
192 sal_True == bRes );
193 }
194
ctors_name_option_security()195 void ctors_name_option_security( )
196 {
197 /// create a security pipe.
198 const ::osl::Security rSecurity;
199 ::osl::Pipe aSecurityPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSecurity );
200
201 bRes = aSecurityPipe.is( );
202
203 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with name, option and security, the test of security is not implemented yet.",
204 sal_True == bRes );
205 }
206
ctors_copy()207 void ctors_copy( )
208 {
209 /// create a pipe.
210 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
211 /// create a pipe using copy constructor.
212 ::osl::Pipe aCopyPipe( aPipe );
213
214 bRes = aCopyPipe.is( ) && aCopyPipe == aPipe;
215
216 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test copy constructor.",
217 sal_True == bRes );
218 }
219
220 /** tester comment:
221
222 When test the following two constructors, don't know how to test the
223 acquire and no acquire action. possible plans:
224 1.release one handle and check the other( did not success since the
225 other still exist and valid. )
226 2. release one handle twice to see getLastError( )(the getLastError
227 always returns invalidError(LINUX)).
228 */
229
ctors_no_acquire()230 void ctors_no_acquire( )
231 {
232 /// create a pipe.
233 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
234 /// constructs a pipe reference without acquiring the handle.
235 ::osl::Pipe aNoAcquirePipe( aPipe.getHandle( ), SAL_NO_ACQUIRE );
236
237 bRes = aNoAcquirePipe.is( );
238 ///aPipe.clear( );
239 ///bRes1 = aNoAcquirePipe.is( );
240
241
242 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with no aquire of handle, only validation test, do not know how to test no acquire.",
243 sal_True == bRes );
244 }
245
ctors_acquire()246 void ctors_acquire( )
247 {
248 /// create a base pipe.
249 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
250 /// constructs two pipes without acquiring the handle on the base pipe.
251 ::osl::Pipe aAcquirePipe( aPipe.getHandle( ) );
252 ::osl::Pipe aAcquirePipe1( NULL );
253
254 bRes = aAcquirePipe.is( );
255 bRes1 = aAcquirePipe1.is( );
256
257 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with no aquire of handle.only validation test, do not know how to test no acquire.",
258 sal_True == bRes && sal_False == bRes1 );
259 }
260
261 CPPUNIT_TEST_SUITE( ctors );
262 CPPUNIT_TEST( ctors_none );
263 CPPUNIT_TEST( ctors_name_option );
264 CPPUNIT_TEST( ctors_name_option_security );
265 CPPUNIT_TEST( ctors_copy );
266 CPPUNIT_TEST( ctors_no_acquire );
267 CPPUNIT_TEST( ctors_acquire );
268 CPPUNIT_TEST_SUITE_END( );
269 }; // class ctors
270
271
272 /** testing the method:
273 inline sal_Bool SAL_CALL is() const;
274 */
275 class is : public CppUnit::TestFixture
276 {
277 public:
is_001()278 void is_001( )
279 {
280 ::osl::Pipe aPipe;
281
282 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test is(), check if the pipe is a valid one.", sal_False == aPipe.is( ) );
283 }
284
is_002()285 void is_002( )
286 {
287 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
288
289 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test is(), a normal pipe creation.", sal_True == aPipe.is( ) );
290 }
291
is_003()292 void is_003( )
293 {
294 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
295 aPipe.clear( );
296
297 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test is(), an invalid case.", sal_False == aPipe.is( ) );
298 }
299
is_004()300 void is_004( )
301 {
302 ::osl::Pipe aPipe( NULL );
303
304 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test is(), an invalid constructor.", sal_False == aPipe.is( ) );
305 }
306
307 CPPUNIT_TEST_SUITE( is );
308 CPPUNIT_TEST( is_001 );
309 CPPUNIT_TEST( is_002 );
310 CPPUNIT_TEST( is_003 );
311 CPPUNIT_TEST( is_004 );
312 CPPUNIT_TEST_SUITE_END( );
313 }; // class is
314
315
316 /** testing the methods:
317 inline sal_Bool create( const ::rtl::OUString & strName,
318 oslPipeOptions Options, const Security &rSec );
319 nline sal_Bool create( const ::rtl::OUString & strName,
320 oslPipeOptions Options = osl_Pipe_OPEN );
321 */
322 class create : public CppUnit::TestFixture
323 {
324 public:
325 sal_Bool bRes, bRes1;
326
327 /** tester comment:
328
329 security create only be tested creation, security section is
330 untested yet.
331 */
332
create_named_security_001()333 void create_named_security_001( )
334 {
335 const Security rSec;
336 ::osl::Pipe aPipe;
337 bRes = aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec );
338 bRes1 = aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec );
339 aPipe.clear( );
340
341 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test creation.",
342 sal_True == bRes && sal_False == bRes1);
343 }
344
create_named_security_002()345 void create_named_security_002( )
346 {
347 const Security rSec;
348 ::osl::Pipe aPipe, aPipe1;
349 bRes = aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec );
350 bRes1 = aPipe1.create( test::uniquePipeName(aTestPipeName), osl_Pipe_OPEN, rSec );
351 aPipe.clear( );
352
353 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test creation and open.",
354 sal_True == bRes && sal_True == bRes1);
355 }
356
create_named_001()357 void create_named_001( )
358 {
359 ::osl::Pipe aPipe;
360 bRes = aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
361 bRes1 = aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
362 aPipe.clear( );
363
364 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test creation.",
365 sal_True == bRes && sal_False == bRes1);
366 }
367
create_named_002()368 void create_named_002( )
369 {
370 ::osl::Pipe aPipe, aPipe1;
371 bRes = aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
372 bRes1 = aPipe1.create( test::uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
373 aPipe.clear( );
374
375 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test creation and open.",
376 sal_True == bRes && sal_True == bRes1);
377 }
378
create_named_003()379 void create_named_003( )
380 {
381 ::osl::Pipe aPipe;
382 bRes = aPipe.create( test::uniquePipeName(aTestPipeName) );
383 aPipe.clear( );
384
385 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test default option is open.",
386 sal_False == bRes );
387 }
388
389 CPPUNIT_TEST_SUITE( create );
390 CPPUNIT_TEST( create_named_security_001 );
391 CPPUNIT_TEST( create_named_security_002 );
392 CPPUNIT_TEST( create_named_001 );
393 CPPUNIT_TEST( create_named_002 );
394 CPPUNIT_TEST( create_named_003 );
395 CPPUNIT_TEST_SUITE_END( );
396 }; // class create
397
398
399 /** testing the method:
400 inline void SAL_CALL clear();
401 */
402 class clear : public CppUnit::TestFixture
403 {
404 public:
405 sal_Bool bRes, bRes1;
406
clear_001()407 void clear_001( )
408 {
409 ::osl::Pipe aPipe;
410 aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
411 aPipe.clear( );
412 bRes = aPipe.is( );
413
414 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test clear.",
415 sal_False == bRes );
416 }
417
418 CPPUNIT_TEST_SUITE( clear );
419 CPPUNIT_TEST( clear_001 );
420 CPPUNIT_TEST_SUITE_END( );
421 }; // class clear
422
423
424 /** testing the methods:
425 inline Pipe& SAL_CALL operator= (const Pipe& pipe);
426 inline Pipe& SAL_CALL operator= (const oslPipe pipe );
427 */
428 class assign : public CppUnit::TestFixture
429 {
430 public:
431 sal_Bool bRes, bRes1;
432
assign_ref()433 void assign_ref( )
434 {
435 ::osl::Pipe aPipe, aPipe1;
436 aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
437 aPipe1 = aPipe;
438 bRes = aPipe1.is( );
439 bRes1 = aPipe == aPipe1;
440 aPipe.close( );
441 aPipe1.close( );
442
443 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test assign with reference.",
444 sal_True == bRes && sal_True == bRes1 );
445 }
446
assign_handle()447 void assign_handle( )
448 {
449 ::osl::Pipe aPipe, aPipe1;
450 aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
451 aPipe1 = aPipe.getHandle( );
452 bRes = aPipe1.is( );
453 bRes1 = aPipe == aPipe1;
454 aPipe.close( );
455 aPipe1.close( );
456
457 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test assign with handle.",
458 sal_True == bRes && sal_True == bRes1 );
459 }
460
461 CPPUNIT_TEST_SUITE( assign );
462 CPPUNIT_TEST( assign_ref );
463 CPPUNIT_TEST( assign_handle );
464 CPPUNIT_TEST_SUITE_END( );
465 }; // class assign
466
467
468 /** testing the method:
469 inline sal_Bool SAL_CALL isValid() const;
470 isValid( ) has not been implemented under the following platforms, please refer to osl/pipe.hxx
471 */
472 /*class isValid : public CppUnit::TestFixture
473 {
474 public:
475 sal_Bool bRes, bRes1;
476
477 void isValid_001( )
478 {
479 CPPUNIT_ASSERT_MESSAGE( "#test comment#: isValid() has not been implemented on all platforms.",
480 sal_False );
481 }
482
483 CPPUNIT_TEST_SUITE( isValid );
484 CPPUNIT_TEST( isValid_001 );
485 CPPUNIT_TEST_SUITE_END( );
486 };*/ // class isValid
487
488
489 /** testing the method:
490 inline sal_Bool SAL_CALL operator==( const Pipe& rPipe ) const;
491 */
492 class isEqual : public CppUnit::TestFixture
493 {
494 public:
495 sal_Bool bRes, bRes1;
496
isEqual_001()497 void isEqual_001( )
498 {
499 ::osl::Pipe aPipe;
500 aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
501 bRes = aPipe == aPipe;
502 aPipe.close( );
503
504 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test isEqual(), compare its self.",
505 sal_True == bRes );
506 }
507
isEqual_002()508 void isEqual_002( )
509 {
510 ::osl::Pipe aPipe, aPipe1, aPipe2;
511 aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
512
513 aPipe1 = aPipe;
514 aPipe2.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
515
516 bRes = aPipe == aPipe1;
517 bRes1 = aPipe == aPipe2;
518 aPipe.close( );
519 aPipe1.close( );
520 aPipe2.close( );
521
522 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test isEqual(),create one copy instance, and compare.",
523 sal_True == bRes && sal_False == bRes1 );
524 }
525
526 CPPUNIT_TEST_SUITE( isEqual );
527 CPPUNIT_TEST( isEqual_001 );
528 CPPUNIT_TEST( isEqual_002 );
529 CPPUNIT_TEST_SUITE_END( );
530 }; // class isEqual
531
532
533 /** testing the method:
534 inline void SAL_CALL close();
535 */
536 class close : public CppUnit::TestFixture
537 {
538 public:
539 sal_Bool bRes, bRes1;
540
close_001()541 void close_001( )
542 {
543 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipe1), osl_Pipe_CREATE );
544 aPipe.close( );
545 bRes = aPipe.is( );
546
547 aPipe.clear( );
548 bRes1 = aPipe.is( );
549
550 CPPUNIT_ASSERT_MESSAGE( "#test comment#: difference between close and clear.",
551 sal_True == bRes && sal_False == bRes1);
552 }
553
close_002()554 void close_002( )
555 {
556 ::osl::StreamPipe aPipe( test::uniquePipeName(aTestPipe1), osl_Pipe_CREATE );
557 aPipe.close( );
558 int nRet = aPipe.send( m_pTestString1.getStr(), 3 );
559
560 CPPUNIT_ASSERT_MESSAGE( "#test comment#: use after close.",
561 OSL_PIPE_FAIL == nRet );
562 }
563
564 CPPUNIT_TEST_SUITE( close );
565 CPPUNIT_TEST( close_001 );
566 CPPUNIT_TEST( close_002 );
567 CPPUNIT_TEST_SUITE_END( );
568 }; // class close
569
570
571 /** testing the method:
572 inline oslPipeError SAL_CALL accept(StreamPipe& Connection);
573 please refer to StreamPipe::recv
574 */
575 /* class accept : public CppUnit::TestFixture
576 {
577 public:
578 sal_Bool bRes, bRes1;
579
580 void accept_001( )
581 {
582
583 // CPPUNIT_ASSERT_MESSAGE( "#test comment#: accept, untested.", 1 == 1 );
584 //CPPUNIT_ASSERT_STUB();
585 }
586
587 CPPUNIT_TEST_SUITE( accept );
588 CPPUNIT_TEST( accept_001 );
589 CPPUNIT_TEST_SUITE_END( );
590 };*/ // class accept
591
592
593 /** testing the method:
594 inline oslPipeError SAL_CALL getError() const;
595 */
596 class getError : public CppUnit::TestFixture
597 {
598 public:
599 sal_Bool bRes, bRes1;
600 /*
601 PipeError[]= {
602 { 0, osl_Pipe_E_None }, // no error
603 { EPROTOTYPE, osl_Pipe_E_NoProtocol }, // Protocol wrong type for socket
604 { ENOPROTOOPT, osl_Pipe_E_NoProtocol }, // Protocol not available
605 { EPROTONOSUPPORT, osl_Pipe_E_NoProtocol }, // Protocol not supported
606 { ESOCKTNOSUPPORT, osl_Pipe_E_NoProtocol }, // Socket type not supported
607 { EPFNOSUPPORT, osl_Pipe_E_NoProtocol }, // Protocol family not supported
608 { EAFNOSUPPORT, osl_Pipe_E_NoProtocol }, // Address family not supported by
609 // protocol family
610 { ENETRESET, osl_Pipe_E_NetworkReset }, // Network dropped connection because
611 // of reset
612 { ECONNABORTED, osl_Pipe_E_ConnectionAbort }, // Software caused connection abort
613 { ECONNRESET, osl_Pipe_E_ConnectionReset }, // Connection reset by peer
614 { ENOBUFS, osl_Pipe_E_NoBufferSpace }, // No buffer space available
615 { ETIMEDOUT, osl_Pipe_E_TimedOut }, // Connection timed out
616 { ECONNREFUSED, osl_Pipe_E_ConnectionRefused }, // Connection refused
617 { -1, osl_Pipe_E_invalidError }
618 };
619 did not define osl_Pipe_E_NotFound, osl_Pipe_E_AlreadyExists
620 */
621
getError_001()622 void getError_001( )
623 {
624 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
625 oslPipeError nError = aPipe.getError( );
626 printPipeError( aPipe );
627 aPipe.clear( );
628
629 CPPUNIT_ASSERT_MESSAGE( "#test comment#: open a non-exist pipe.",
630 nError != osl_Pipe_E_None );
631 }
632
getError_002()633 void getError_002( )
634 {
635 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
636 ::osl::Pipe aPipe1( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
637 oslPipeError nError = aPipe.getError( );
638 printPipeError( aPipe );
639 aPipe.clear( );
640 aPipe1.clear( );
641
642 CPPUNIT_ASSERT_MESSAGE( "#test comment#: create an already exist pipe.",
643 nError != osl_Pipe_E_None );
644 }
645
646 CPPUNIT_TEST_SUITE( getError );
647 CPPUNIT_TEST( getError_001 );
648 CPPUNIT_TEST( getError_002 );
649 CPPUNIT_TEST_SUITE_END( );
650 }; // class getError
651
652
653 /** testing the method:
654 inline oslPipe SAL_CALL getHandle() const;
655 */
656 class getHandle : public CppUnit::TestFixture
657 {
658 public:
659 sal_Bool bRes, bRes1;
660
getHandle_001()661 void getHandle_001( )
662 {
663 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
664 bRes = aPipe == aPipe.getHandle( );
665 aPipe.clear( );
666
667 CPPUNIT_ASSERT_MESSAGE( "#test comment#: one pipe should equal to its handle.",
668 sal_True == bRes );
669 }
670
getHandle_002()671 void getHandle_002( )
672 {
673 ::osl::Pipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
674 ::osl::Pipe aPipe1( aPipe.getHandle( ) );
675 bRes = aPipe == aPipe1;
676 aPipe.clear( );
677 aPipe1.clear( );
678
679 CPPUNIT_ASSERT_MESSAGE( "#test comment#: one pipe derived from another pipe's handle.",
680 sal_True == bRes );
681 }
682
683 CPPUNIT_TEST_SUITE( getHandle );
684 CPPUNIT_TEST( getHandle_001 );
685 CPPUNIT_TEST( getHandle_002 );
686 CPPUNIT_TEST_SUITE_END( );
687 }; // class getHandle
688
689
690 // -----------------------------------------------------------------------------
691 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::ctors);
692 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::is);
693 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::create);
694 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::clear);
695 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::assign);
696 //CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::isValid);
697 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::isEqual);
698 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::close);
699 //CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::accept);
700 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::getError);
701 CPPUNIT_TEST_SUITE_REGISTRATION(osl_Pipe::getHandle);
702 // -----------------------------------------------------------------------------
703
704 } // namespace osl_Pipe
705
706
707 namespace osl_StreamPipe
708 {
709
710 /** testing the methods:
711 inline StreamPipe();
712 inline StreamPipe(oslPipe Pipe);;
713 inline StreamPipe(const StreamPipe& Pipe);
714 inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options = osl_Pipe_OPEN);
715 inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options, const Security &rSec );
716 inline StreamPipe( oslPipe pipe, __sal_NoAcquire noacquire );
717 */
718 class ctors : public CppUnit::TestFixture
719 {
720 public:
721 sal_Bool bRes, bRes1;
722
ctors_none()723 void ctors_none( )
724 {
725 // create a pipe.
726 ::osl::StreamPipe aStreamPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
727 // create an unattached pipe.
728 ::osl::StreamPipe aStreamPipe1;
729 bRes = aStreamPipe1.is( );
730
731 // assign it and check.
732 aStreamPipe1 = aStreamPipe;
733 bRes1 = aStreamPipe1.is( );
734 aStreamPipe.clear( );
735 aStreamPipe1.clear( );
736
737 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with no parameter, before and after assign.",
738 sal_False == bRes && sal_True == bRes1 );
739 }
740
ctors_handle()741 void ctors_handle( )
742 {
743 // create a pipe.
744 ::osl::StreamPipe aStreamPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
745 // create a pipe with last handle.
746 ::osl::StreamPipe aStreamPipe1( aStreamPipe.getHandle( ) );
747 bRes = aStreamPipe1.is( ) && aStreamPipe == aStreamPipe1;
748 aStreamPipe.clear( );
749 aStreamPipe1.clear( );
750
751 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with other's handle.",
752 sal_True == bRes );
753 }
754
ctors_copy()755 void ctors_copy( )
756 {
757 // create a pipe.
758 ::osl::StreamPipe aStreamPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
759 // create an unattached pipe.
760 ::osl::StreamPipe aStreamPipe1( aStreamPipe );
761 bRes = aStreamPipe1.is( ) && aStreamPipe == aStreamPipe1;
762 aStreamPipe.clear( );
763 aStreamPipe1.clear( );
764
765 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test copy constructor.",
766 sal_True == bRes );
767 }
768
ctors_name_option()769 void ctors_name_option( )
770 {
771 // create a pipe.
772 ::osl::StreamPipe aStreamPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
773 // create an unattached pipe.
774 ::osl::StreamPipe aStreamPipe1( test::uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
775 bRes = aStreamPipe1.is( ) && aStreamPipe.is( );
776 aStreamPipe.clear( );
777 aStreamPipe1.clear( );
778
779 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with name and option.",
780 sal_True == bRes );
781 }
782
ctors_name_option_security()783 void ctors_name_option_security( )
784 {
785 /// create a security pipe.
786 const ::osl::Security rSecurity;
787 ::osl::StreamPipe aSecurityPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSecurity );
788
789 bRes = aSecurityPipe.is( );
790 aSecurityPipe.clear( );
791
792 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with name, option and security, the test of security is not implemented yet.",
793 sal_True == bRes );
794 }
795
796 /** tester comment:
797
798 When test the following constructor, don't know how to test the
799 acquire and no acquire action. possible plans:
800 1.release one handle and check the other( did not success since the
801 other still exist and valid. )
802 2. release one handle twice to see getLastError( )(the getLastError
803 always returns invalidError(LINUX)).
804 */
805
ctors_no_acquire()806 void ctors_no_acquire( )
807 {
808 // create a pipe.
809 ::osl::StreamPipe aPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
810 // constructs a pipe reference without acquiring the handle.
811 ::osl::StreamPipe aNoAcquirePipe( aPipe.getHandle( ), SAL_NO_ACQUIRE );
812
813 bRes = aNoAcquirePipe.is( );
814 aPipe.clear( );
815 // bRes1 = aNoAcquirePipe.is( );
816
817 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test constructor with no aquire of handle, only validation test, do not know how to test no acquire.",
818 sal_True == bRes );
819 }
820
821 CPPUNIT_TEST_SUITE( ctors );
822 CPPUNIT_TEST( ctors_none );
823 CPPUNIT_TEST( ctors_handle );
824 CPPUNIT_TEST( ctors_copy );
825 CPPUNIT_TEST( ctors_name_option );
826 CPPUNIT_TEST( ctors_name_option_security );
827 CPPUNIT_TEST( ctors_no_acquire );
828 CPPUNIT_TEST_SUITE_END( );
829 }; // class ctors
830
831
832 /** testing the methods:
833 inline StreamPipe & SAL_CALL operator=(oslPipe Pipe);
834 inline StreamPipe& SAL_CALL operator=(const Pipe& pipe);
835 mindy: not implementated in osl/pipe.hxx, so remove the cases
836 */
837 /*
838 class assign : public CppUnit::TestFixture
839 {
840 public:
841 sal_Bool bRes, bRes1;
842
843 void assign_ref( )
844 {
845 ::osl::StreamPipe aPipe, aPipe1;
846 aPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
847 aPipe1 = aPipe;
848 bRes = aPipe1.is( );
849 bRes1 = aPipe == aPipe1;
850 aPipe.close( );
851 aPipe1.close( );
852
853 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test assign with reference.",
854 sal_True == bRes && sal_True == bRes1 );
855 }
856
857 void assign_handle( )
858 {
859 ::osl::StreamPipe * pPipe = new ::osl::StreamPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
860 ::osl::StreamPipe * pAssignPipe = new ::osl::StreamPipe;
861 *pAssignPipe = pPipe->getHandle( );
862
863 bRes = pAssignPipe->is( );
864 bRes1 = ( *pPipe == *pAssignPipe );
865 pPipe->close( );
866
867 delete pAssignPipe;
868
869 CPPUNIT_ASSERT_MESSAGE( "#test comment#: test assign with handle., seems not implemented under (LINUX)(W32)",
870 sal_True == bRes && sal_True == bRes1 );
871 }
872
873 CPPUNIT_TEST_SUITE( assign );
874 CPPUNIT_TEST( assign_ref );
875 CPPUNIT_TEST( assign_handle );
876 CPPUNIT_TEST_SUITE_END( );
877 };*/ // class assign
878
879
880 /** wait _nSec seconds.
881 */
thread_sleep(sal_Int32 _nSec)882 void thread_sleep( sal_Int32 _nSec )
883 {
884 /// print statement in thread process must use fflush() to force display.
885 // printf("wait %d seconds. ", _nSec );
886 fflush(stdout);
887
888 #ifdef WNT //Windows
889 Sleep( _nSec * 1000 );
890 #endif
891 #if ( defined UNX ) || ( defined OS2 ) //Unix
892 sleep( _nSec );
893 #endif
894 // printf("done\n" );
895 }
896 // test read/write & send/recv data to pipe
897 // -----------------------------------------------------------------------------
898
899 class Pipe_DataSink_Thread : public Thread
900 {
901 public:
902 sal_Char buf[256];
Pipe_DataSink_Thread()903 Pipe_DataSink_Thread( ) { }
904
~Pipe_DataSink_Thread()905 ~Pipe_DataSink_Thread( )
906 {
907 }
908 protected:
run()909 void SAL_CALL run( )
910 {
911 sal_Int32 nChars = 0;
912
913 printf("open pipe\n");
914 ::osl::StreamPipe aSenderPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_OPEN ); // test::uniquePipeName(aTestPipeName) is a string = "TestPipe"
915 if ( aSenderPipe.is() == sal_False )
916 {
917 printf("pipe open failed! \n");
918 }
919 else
920 {
921 printf("read\n");
922 nChars = aSenderPipe.read( buf, m_pTestString1.getLength() + 1 );
923 if ( nChars < 0 )
924 {
925 printf("read failed! \n");
926 return;
927 }
928 printf("buffer is %s \n", buf);
929 printf("send\n");
930 nChars = aSenderPipe.send( m_pTestString2.getStr(), m_pTestString2.getLength() + 1 );
931 if ( nChars < 0 )
932 {
933 printf("client send failed! \n");
934 return;
935 }
936 }
937 }
938
939 };
940
941 // -----------------------------------------------------------------------------
942
943 class Pipe_DataSource_Thread : public Thread
944 {
945 public:
946 sal_Char buf[256];
947 //::osl::StreamPipe aListenPipe; //( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
948 ::osl::Pipe aListenPipe;
949 ::osl::StreamPipe aConnectionPipe;
Pipe_DataSource_Thread()950 Pipe_DataSource_Thread( )
951 {
952 printf("create pipe\n");
953 aListenPipe.create( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
954 }
~Pipe_DataSource_Thread()955 ~Pipe_DataSource_Thread( )
956 {
957 aListenPipe.close();
958 }
959 protected:
run()960 void SAL_CALL run( )
961 {
962 //create pipe.
963 sal_Int32 nChars;
964 //::osl::StreamPipe aListenPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
965 printf("listen\n");
966 if ( aListenPipe.is() == sal_False )
967 {
968 printf("pipe create failed! \n");
969 }
970 else
971 {
972 //::osl::StreamPipe aConnectionPipe;
973
974 //start server and wait for connection.
975 printf("accept\n");
976 if ( osl_Pipe_E_None != aListenPipe.accept( aConnectionPipe ) )
977 {
978 printf("pipe accept failed!");
979 return;
980 }
981 printf("write\n");
982 // write to pipe
983 nChars = aConnectionPipe.write( m_pTestString1.getStr(), m_pTestString1.getLength() + 1 );
984 if ( nChars < 0)
985 {
986 printf("server write failed! \n");
987 return;
988 }
989 printf("recv\n");
990 nChars = aConnectionPipe.recv( buf, 256 );
991
992 if ( nChars < 0)
993 {
994 printf("server receive failed! \n");
995 return;
996 }
997 //thread_sleep( 2 );
998 printf("received message is: %s\n", buf );
999 //aConnectionPipe.close();
1000 }
1001 }
1002 };
1003
1004 /** testing the method: read/write/send/recv and Pipe::accept
1005 */
1006 class recv : public CppUnit::TestFixture
1007 {
1008 public:
1009 sal_Bool bRes, bRes1;
1010
recv_001()1011 void recv_001( )
1012 {
1013 //launch threads.
1014 Pipe_DataSource_Thread myDataSourceThread;
1015 Pipe_DataSink_Thread myDataSinkThread;
1016 myDataSourceThread.create( );
1017 thread_sleep( 1 );
1018 myDataSinkThread.create( );
1019
1020 //wait until the thread terminate
1021 myDataSinkThread.join( );
1022 myDataSourceThread.join( );
1023
1024 int nCompare1 = strcmp( myDataSinkThread.buf, m_pTestString1.getStr() );
1025 int nCompare2 = strcmp( myDataSourceThread.buf, m_pTestString2.getStr() );
1026 CPPUNIT_ASSERT_MESSAGE( "test send/recv/write/read.", nCompare1 == 0 && nCompare2 == 0 );
1027 }
1028 //close pipe when accept
recv_002()1029 void recv_002()
1030 {
1031 thread_sleep( 1 );
1032
1033 Pipe_DataSource_Thread myDataSourceThread;
1034 Pipe_DataSink_Thread myDataSinkThread;
1035 myDataSourceThread.create( );
1036 thread_sleep( 1 );
1037 myDataSourceThread.aListenPipe.close();
1038 myDataSourceThread.join( );
1039 //no condition judgement here, if the case could finish excuting within 1 or 2 seconds, it passes.
1040 }
1041
1042 CPPUNIT_TEST_SUITE( recv );
1043 CPPUNIT_TEST( recv_001 );
1044 CPPUNIT_TEST( recv_002 );
1045 CPPUNIT_TEST_SUITE_END( );
1046 }; // class recv
1047
1048 // -----------------------------------------------------------------------------
1049 CPPUNIT_TEST_SUITE_REGISTRATION(osl_StreamPipe::ctors);
1050 //CPPUNIT_TEST_SUITE_REGISTRATION(osl_StreamPipe::assign);
1051 CPPUNIT_TEST_SUITE_REGISTRATION(osl_StreamPipe::recv);
1052 // -----------------------------------------------------------------------------
1053
1054 } // namespace osl_StreamPipe
1055
1056 CPPUNIT_PLUGIN_IMPLEMENT();
1057