xref: /aoo4110/main/sal/qa/osl/pipe/osl_Pipe.cxx (revision b1cdbd2c)
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