187d2adbcSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
387d2adbcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
487d2adbcSAndrew Rist * or more contributor license agreements. See the NOTICE file
587d2adbcSAndrew Rist * distributed with this work for additional information
687d2adbcSAndrew Rist * regarding copyright ownership. The ASF licenses this file
787d2adbcSAndrew Rist * to you under the Apache License, Version 2.0 (the
887d2adbcSAndrew Rist * "License"); you may not use this file except in compliance
987d2adbcSAndrew Rist * with the License. You may obtain a copy of the License at
1087d2adbcSAndrew Rist *
1187d2adbcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
1287d2adbcSAndrew Rist *
1387d2adbcSAndrew Rist * Unless required by applicable law or agreed to in writing,
1487d2adbcSAndrew Rist * software distributed under the License is distributed on an
1587d2adbcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
1687d2adbcSAndrew Rist * KIND, either express or implied. See the License for the
1787d2adbcSAndrew Rist * specific language governing permissions and limitations
1887d2adbcSAndrew Rist * under the License.
1987d2adbcSAndrew Rist *
2087d2adbcSAndrew Rist *************************************************************/
2187d2adbcSAndrew Rist
2287d2adbcSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sal.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir //------------------------------------------------------------------------
28cdf0e10cSrcweir // include files
29cdf0e10cSrcweir //------------------------------------------------------------------------
30cdf0e10cSrcweir
3137e87705SJuergen Schmidt #ifdef WNT
3237e87705SJuergen Schmidt #include <Windows.h>
3337e87705SJuergen Schmidt #endif
3437e87705SJuergen Schmidt
35cdf0e10cSrcweir #include <sal/types.h>
36cdf0e10cSrcweir #include <rtl/ustring.hxx>
37cdf0e10cSrcweir
38cdf0e10cSrcweir #ifndef _OSL_THREAD_HXX
39cdf0e10cSrcweir #include <osl/thread.hxx>
40cdf0e10cSrcweir #endif
41cdf0e10cSrcweir
42cdf0e10cSrcweir #ifndef _OSL_MUTEX_HXX
43cdf0e10cSrcweir #include <osl/mutex.hxx>
44cdf0e10cSrcweir #endif
45cdf0e10cSrcweir
46cdf0e10cSrcweir #ifndef _OSL_MUTEX_HXX
47cdf0e10cSrcweir #include <osl/pipe.hxx>
48cdf0e10cSrcweir #endif
49cdf0e10cSrcweir #include <osl/time.h>
5064293329SJuergen Schmidt #include <osl/process.h>
51cdf0e10cSrcweir
52cdf0e10cSrcweir #ifdef UNX
53cdf0e10cSrcweir #include <unistd.h>
54cdf0e10cSrcweir #endif
55cdf0e10cSrcweir #include <string.h>
56cdf0e10cSrcweir
5764293329SJuergen Schmidt #include "gtest/gtest.h"
5864293329SJuergen Schmidt
59cdf0e10cSrcweir using namespace osl;
60cdf0e10cSrcweir using namespace rtl;
61cdf0e10cSrcweir
62cdf0e10cSrcweir //------------------------------------------------------------------------
63cdf0e10cSrcweir // helper functions
64cdf0e10cSrcweir //------------------------------------------------------------------------
65cdf0e10cSrcweir
6664293329SJuergen Schmidt
6764293329SJuergen Schmidt /** helper function for unique pipe names
6864293329SJuergen Schmidt */
uniquePipeName(OUString const & name)6964293329SJuergen Schmidt OUString uniquePipeName(OUString const & name) {
7064293329SJuergen Schmidt oslProcessInfo info;
7164293329SJuergen Schmidt info.Size = sizeof info;
7264293329SJuergen Schmidt EXPECT_TRUE( osl_Process_E_None == osl_getProcessInfo(0, osl_Process_IDENTIFIER, &info) );
7364293329SJuergen Schmidt return name + OUString::valueOf((sal_Int32)info.Ident);
7464293329SJuergen Schmidt }
7564293329SJuergen Schmidt
76cdf0e10cSrcweir /** print Boolean value.
77cdf0e10cSrcweir */
printBool(sal_Bool bOk)78cdf0e10cSrcweir inline void printBool( sal_Bool bOk )
79cdf0e10cSrcweir {
80cdf0e10cSrcweir printf("#printBool# " );
81cdf0e10cSrcweir ( sal_True == bOk ) ? printf("YES!\n" ): printf("NO!\n" );
82cdf0e10cSrcweir }
83cdf0e10cSrcweir
84cdf0e10cSrcweir /** print a UNI_CODE String.
85cdf0e10cSrcweir */
printUString(const::rtl::OUString & str)86cdf0e10cSrcweir inline void printUString( const ::rtl::OUString & str )
87cdf0e10cSrcweir {
88cdf0e10cSrcweir rtl::OString aString;
89cdf0e10cSrcweir
90cdf0e10cSrcweir printf("#printUString_u# " );
91cdf0e10cSrcweir aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
92cdf0e10cSrcweir printf("%s\n", aString.getStr( ) );
93cdf0e10cSrcweir }
94cdf0e10cSrcweir
95cdf0e10cSrcweir /** print last error of pipe system.
96cdf0e10cSrcweir */
printPipeError(::osl::Pipe aPipe)97cdf0e10cSrcweir inline void printPipeError( ::osl::Pipe aPipe )
98cdf0e10cSrcweir {
99cdf0e10cSrcweir oslPipeError nError = aPipe.getError( );
100cdf0e10cSrcweir printf("#printPipeError# " );
101cdf0e10cSrcweir switch ( nError ) {
102cdf0e10cSrcweir case osl_Pipe_E_None:
103cdf0e10cSrcweir printf("Success!\n" );
104cdf0e10cSrcweir break;
105cdf0e10cSrcweir case osl_Pipe_E_NotFound:
106cdf0e10cSrcweir printf("The returned error is: Not found!\n" );
107cdf0e10cSrcweir break;
108cdf0e10cSrcweir case osl_Pipe_E_AlreadyExists:
109cdf0e10cSrcweir printf("The returned error is: Already exist!\n" );
110cdf0e10cSrcweir break;
111cdf0e10cSrcweir case osl_Pipe_E_NoProtocol:
112cdf0e10cSrcweir printf("The returned error is: No protocol!\n" );
113cdf0e10cSrcweir break;
114cdf0e10cSrcweir case osl_Pipe_E_NetworkReset:
115cdf0e10cSrcweir printf("The returned error is: Network reset!\n" );
116cdf0e10cSrcweir break;
117cdf0e10cSrcweir case osl_Pipe_E_ConnectionAbort:
118cdf0e10cSrcweir printf("The returned error is: Connection aborted!\n" );
119cdf0e10cSrcweir break;
120cdf0e10cSrcweir case osl_Pipe_E_ConnectionReset:
121cdf0e10cSrcweir printf("The returned error is: Connection reset!\n" );
122cdf0e10cSrcweir break;
123cdf0e10cSrcweir case osl_Pipe_E_NoBufferSpace:
124cdf0e10cSrcweir printf("The returned error is: No buffer space!\n" );
125cdf0e10cSrcweir break;
126cdf0e10cSrcweir case osl_Pipe_E_TimedOut:
127cdf0e10cSrcweir printf("The returned error is: Timeout!\n" );
128cdf0e10cSrcweir break;
129cdf0e10cSrcweir case osl_Pipe_E_ConnectionRefused:
130cdf0e10cSrcweir printf("The returned error is: Connection refused!\n" );
131cdf0e10cSrcweir break;
132cdf0e10cSrcweir case osl_Pipe_E_invalidError:
133cdf0e10cSrcweir printf("The returned error is: Invalid error!\n" );
134cdf0e10cSrcweir break;
135cdf0e10cSrcweir default:
136cdf0e10cSrcweir printf("The returned error is: Number %d, Unknown Error\n", nError );
137cdf0e10cSrcweir break;
138cdf0e10cSrcweir }
139cdf0e10cSrcweir }
140cdf0e10cSrcweir
141cdf0e10cSrcweir
142cdf0e10cSrcweir
143cdf0e10cSrcweir //------------------------------------------------------------------------
144cdf0e10cSrcweir // pipe name and transfer contents
145cdf0e10cSrcweir //------------------------------------------------------------------------
146cdf0e10cSrcweir const rtl::OUString aTestPipeName = rtl::OUString::createFromAscii( "testpipe2" );
147cdf0e10cSrcweir const rtl::OUString aTestPipe1 = rtl::OUString::createFromAscii( "testpipe1" );
14864293329SJuergen Schmidt const rtl::OUString aTestString = rtl::OUString::createFromAscii( "Apache Software Foundation" );
149cdf0e10cSrcweir
15064293329SJuergen Schmidt const OString m_pTestString1("Apache Software Foundation");
151cdf0e10cSrcweir const OString m_pTestString2("test pipe PASS/OK");
152cdf0e10cSrcweir
153cdf0e10cSrcweir //------------------------------------------------------------------------
154cdf0e10cSrcweir // test code start here
155cdf0e10cSrcweir //------------------------------------------------------------------------
156cdf0e10cSrcweir
157cdf0e10cSrcweir namespace osl_Pipe
158cdf0e10cSrcweir {
159cdf0e10cSrcweir
160cdf0e10cSrcweir //------------------------------------------------------------------------
161cdf0e10cSrcweir // most return value -1 denote a fail of operation.
162cdf0e10cSrcweir //------------------------------------------------------------------------
163cdf0e10cSrcweir #define OSL_PIPE_FAIL -1
164cdf0e10cSrcweir
165cdf0e10cSrcweir /** testing the methods:
166cdf0e10cSrcweir inline Pipe();
167cdf0e10cSrcweir inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options);
168cdf0e10cSrcweir inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options,const Security & rSecurity);
169cdf0e10cSrcweir inline Pipe(const Pipe& pipe);
170cdf0e10cSrcweir inline Pipe(oslPipe pipe, __sal_NoAcquire noacquire );
171cdf0e10cSrcweir inline Pipe(oslPipe Pipe);
172cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,ctors_none)17364293329SJuergen Schmidt TEST(Sal_Test_Pipe, ctors_none) {
17464293329SJuergen Schmidt ::osl::Pipe aPipe;
17564293329SJuergen Schmidt sal_Bool bRes = aPipe.is( );
176cdf0e10cSrcweir
17764293329SJuergen Schmidt // #test comment#: test constructor with no parameter, yet no case to test.
17864293329SJuergen Schmidt ASSERT_TRUE( !bRes );
17964293329SJuergen Schmidt }
180cdf0e10cSrcweir
TEST(Sal_Test_Pipe,ctors_name_option)18164293329SJuergen Schmidt TEST(Sal_Test_Pipe, ctors_name_option) {
18264293329SJuergen Schmidt /// create a named pipe.
18364293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
18464293329SJuergen Schmidt ::osl::Pipe aAssignPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
185cdf0e10cSrcweir
18664293329SJuergen Schmidt sal_Bool bRes = aPipe.is( ) && aAssignPipe.is( );
187cdf0e10cSrcweir
18864293329SJuergen Schmidt // #test comment#: test constructor with name and option.
18964293329SJuergen Schmidt ASSERT_TRUE( bRes );
19064293329SJuergen Schmidt }
191cdf0e10cSrcweir
TEST(Sal_Test_Pipe,ctors_name_option_security)19264293329SJuergen Schmidt TEST(Sal_Test_Pipe, ctors_name_option_security) {
19364293329SJuergen Schmidt /// create a security pipe.
19464293329SJuergen Schmidt const ::osl::Security rSecurity;
19564293329SJuergen Schmidt ::osl::Pipe aSecurityPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSecurity );
196cdf0e10cSrcweir
19764293329SJuergen Schmidt sal_Bool bRes = aSecurityPipe.is( );
198cdf0e10cSrcweir
19964293329SJuergen Schmidt // #test comment#: test constructor with name, option and security, the test of security is not implemented yet.
20064293329SJuergen Schmidt ASSERT_TRUE( bRes );
20164293329SJuergen Schmidt }
202cdf0e10cSrcweir
TEST(Sal_Test_Pipe,ctors_copy)20364293329SJuergen Schmidt TEST(Sal_Test_Pipe, ctors_copy) {
20464293329SJuergen Schmidt /// create a pipe.
20564293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
20664293329SJuergen Schmidt /// create a pipe using copy constructor.
20764293329SJuergen Schmidt ::osl::Pipe aCopyPipe( aPipe );
208cdf0e10cSrcweir
20964293329SJuergen Schmidt sal_Bool bRes = aCopyPipe.is( ) && aCopyPipe == aPipe;
210cdf0e10cSrcweir
21164293329SJuergen Schmidt // #test comment#: test copy constructor.
21264293329SJuergen Schmidt ASSERT_TRUE( bRes );
21364293329SJuergen Schmidt }
214cdf0e10cSrcweir
215cdf0e10cSrcweir
21664293329SJuergen Schmidt /** tester comment:
217cdf0e10cSrcweir
21864293329SJuergen Schmidt When test the following two constructors, don't know how to test the
21964293329SJuergen Schmidt acquire and no acquire action. possible plans:
22064293329SJuergen Schmidt 1.release one handle and check the other( did not success since the
22164293329SJuergen Schmidt other still exist and valid. )
22264293329SJuergen Schmidt 2. release one handle twice to see getLastError( )(the getLastError
22364293329SJuergen Schmidt always returns invalidError(LINUX)).
22464293329SJuergen Schmidt */
TEST(Sal_Test_Pipe,ctors_no_acquire)22564293329SJuergen Schmidt TEST(Sal_Test_Pipe, ctors_no_acquire) {
22664293329SJuergen Schmidt /// create a pipe.
22764293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
22864293329SJuergen Schmidt /// constructs a pipe reference without acquiring the handle.
22964293329SJuergen Schmidt ::osl::Pipe aNoAcquirePipe( aPipe.getHandle( ), SAL_NO_ACQUIRE );
23064293329SJuergen Schmidt
23164293329SJuergen Schmidt sal_Bool bRes = aNoAcquirePipe.is( );
23264293329SJuergen Schmidt ///aPipe.clear( );
23364293329SJuergen Schmidt ///bRes1 = aNoAcquirePipe.is( );
23464293329SJuergen Schmidt
23564293329SJuergen Schmidt
23664293329SJuergen Schmidt // #test comment#: test constructor with no acquire of handle, only validation test, do not know how to test no acquire.
23764293329SJuergen Schmidt ASSERT_TRUE( bRes );
23864293329SJuergen Schmidt }
239cdf0e10cSrcweir
TEST(Sal_Test_Pipe,ctors_acquire)24064293329SJuergen Schmidt TEST(Sal_Test_Pipe, ctors_acquire) {
24164293329SJuergen Schmidt /// create a base pipe.
24264293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
24364293329SJuergen Schmidt /// constructs two pipes without acquiring the handle on the base pipe.
24464293329SJuergen Schmidt ::osl::Pipe aAcquirePipe( aPipe.getHandle( ) );
24564293329SJuergen Schmidt ::osl::Pipe aAcquirePipe1( NULL );
24664293329SJuergen Schmidt
24764293329SJuergen Schmidt sal_Bool bRes = aAcquirePipe.is( );
24864293329SJuergen Schmidt sal_Bool bRes1 = aAcquirePipe1.is( );
24964293329SJuergen Schmidt
25064293329SJuergen Schmidt // #test comment#: test constructor with no acquire of handle.only validation test, do not know how to test no acquire.
25164293329SJuergen Schmidt ASSERT_TRUE( bRes && !bRes1 );
25264293329SJuergen Schmidt }
253cdf0e10cSrcweir
254cdf0e10cSrcweir
255cdf0e10cSrcweir /** testing the method:
256cdf0e10cSrcweir inline sal_Bool SAL_CALL is() const;
257cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,is_001)25864293329SJuergen Schmidt TEST(Sal_Test_Pipe, is_001) {
25964293329SJuergen Schmidt ::osl::Pipe aPipe;
260cdf0e10cSrcweir
26164293329SJuergen Schmidt // #test comment#: test is(), check if the pipe is a valid one.
26264293329SJuergen Schmidt ASSERT_TRUE( !aPipe.is( ) );
26364293329SJuergen Schmidt }
264cdf0e10cSrcweir
TEST(Sal_Test_Pipe,is_002)26564293329SJuergen Schmidt TEST(Sal_Test_Pipe, is_002) {
26664293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
267cdf0e10cSrcweir
26864293329SJuergen Schmidt // #test comment#: test is(), a normal pipe creation.
26964293329SJuergen Schmidt ASSERT_TRUE( aPipe.is( ) );
27064293329SJuergen Schmidt }
271cdf0e10cSrcweir
TEST(Sal_Test_Pipe,is_003)27264293329SJuergen Schmidt TEST(Sal_Test_Pipe, is_003) {
27364293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
27464293329SJuergen Schmidt aPipe.clear( );
275cdf0e10cSrcweir
27664293329SJuergen Schmidt // #test comment#: test is(), an invalid case
27764293329SJuergen Schmidt ASSERT_TRUE( !aPipe.is( ) );
27864293329SJuergen Schmidt }
279cdf0e10cSrcweir
TEST(Sal_Test_Pipe,is_004)28064293329SJuergen Schmidt TEST(Sal_Test_Pipe, is_004) {
28164293329SJuergen Schmidt ::osl::Pipe aPipe( NULL );
282cdf0e10cSrcweir
28364293329SJuergen Schmidt // #test comment#: test is(), an invalid constructor.
28464293329SJuergen Schmidt ASSERT_TRUE( !aPipe.is( ) );
28564293329SJuergen Schmidt }
286cdf0e10cSrcweir
287cdf0e10cSrcweir
288cdf0e10cSrcweir /** testing the methods:
289cdf0e10cSrcweir inline sal_Bool create( const ::rtl::OUString & strName,
290cdf0e10cSrcweir oslPipeOptions Options, const Security &rSec );
291cdf0e10cSrcweir nline sal_Bool create( const ::rtl::OUString & strName,
292cdf0e10cSrcweir oslPipeOptions Options = osl_Pipe_OPEN );
293cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,create_named_security_001)29464293329SJuergen Schmidt TEST(Sal_Test_Pipe, create_named_security_001) {
29564293329SJuergen Schmidt const Security rSec;
29664293329SJuergen Schmidt ::osl::Pipe aPipe;
29764293329SJuergen Schmidt sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec );
29864293329SJuergen Schmidt sal_Bool bRes1 = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec );
29964293329SJuergen Schmidt aPipe.clear( );
30064293329SJuergen Schmidt
30164293329SJuergen Schmidt // #test comment#: test creation.
30264293329SJuergen Schmidt ASSERT_TRUE( bRes && !bRes1 );
30364293329SJuergen Schmidt }
304cdf0e10cSrcweir
TEST(Sal_Test_Pipe,create_named_security_002)30564293329SJuergen Schmidt TEST(Sal_Test_Pipe, create_named_security_002) {
30664293329SJuergen Schmidt const Security rSec;
30764293329SJuergen Schmidt ::osl::Pipe aPipe, aPipe1;
30864293329SJuergen Schmidt sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec );
30964293329SJuergen Schmidt sal_Bool bRes1 = aPipe1.create( uniquePipeName(aTestPipeName), osl_Pipe_OPEN, rSec );
31064293329SJuergen Schmidt aPipe.clear( );
311cdf0e10cSrcweir
31264293329SJuergen Schmidt // #test comment#: test creation and open.
31364293329SJuergen Schmidt ASSERT_TRUE( bRes && bRes1 );
31464293329SJuergen Schmidt }
315cdf0e10cSrcweir
TEST(Sal_Test_Pipe,create_named_001)31664293329SJuergen Schmidt TEST(Sal_Test_Pipe, create_named_001) {
31764293329SJuergen Schmidt ::osl::Pipe aPipe;
31864293329SJuergen Schmidt sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
31964293329SJuergen Schmidt sal_Bool bRes1 = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
32064293329SJuergen Schmidt aPipe.clear( );
321cdf0e10cSrcweir
32264293329SJuergen Schmidt // #test comment#: test creation.
32364293329SJuergen Schmidt ASSERT_TRUE( bRes && !bRes1);
32464293329SJuergen Schmidt }
325cdf0e10cSrcweir
TEST(Sal_Test_Pipe,create_named_002)32664293329SJuergen Schmidt TEST(Sal_Test_Pipe, create_named_002) {
32764293329SJuergen Schmidt ::osl::Pipe aPipe, aPipe1;
32864293329SJuergen Schmidt sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
32964293329SJuergen Schmidt sal_Bool bRes1 = aPipe1.create( uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
33064293329SJuergen Schmidt aPipe.clear( );
33164293329SJuergen Schmidt
33264293329SJuergen Schmidt // #test comment#: test creation and open.
33364293329SJuergen Schmidt ASSERT_TRUE( bRes && bRes1);
33464293329SJuergen Schmidt }
335cdf0e10cSrcweir
TEST(Sal_Test_Pipe,create_named_003)33664293329SJuergen Schmidt TEST(Sal_Test_Pipe, create_named_003) {
33764293329SJuergen Schmidt ::osl::Pipe aPipe;
33864293329SJuergen Schmidt sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName) );
33964293329SJuergen Schmidt aPipe.clear( );
340cdf0e10cSrcweir
34164293329SJuergen Schmidt // #test comment#: test default option is open.
34264293329SJuergen Schmidt ASSERT_TRUE( !bRes );
34364293329SJuergen Schmidt }
344cdf0e10cSrcweir
345cdf0e10cSrcweir
346cdf0e10cSrcweir /** testing the method:
347cdf0e10cSrcweir inline void SAL_CALL clear();
348cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,clear_001)34964293329SJuergen Schmidt TEST(Sal_Test_Pipe, clear_001) {
35064293329SJuergen Schmidt ::osl::Pipe aPipe;
35164293329SJuergen Schmidt aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
35264293329SJuergen Schmidt aPipe.clear( );
35364293329SJuergen Schmidt sal_Bool bRes = aPipe.is( );
35464293329SJuergen Schmidt
35564293329SJuergen Schmidt // #test comment#: test clear.
35664293329SJuergen Schmidt ASSERT_TRUE( !bRes );
35764293329SJuergen Schmidt }
358cdf0e10cSrcweir
359cdf0e10cSrcweir
360cdf0e10cSrcweir /** testing the methods:
361cdf0e10cSrcweir inline Pipe& SAL_CALL operator= (const Pipe& pipe);
362cdf0e10cSrcweir inline Pipe& SAL_CALL operator= (const oslPipe pipe );
363cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,assign_ref)36464293329SJuergen Schmidt TEST(Sal_Test_Pipe, assign_ref) {
36564293329SJuergen Schmidt ::osl::Pipe aPipe, aPipe1;
36664293329SJuergen Schmidt aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
36764293329SJuergen Schmidt aPipe1 = aPipe;
36864293329SJuergen Schmidt sal_Bool bRes = aPipe1.is( );
36964293329SJuergen Schmidt sal_Bool bRes1 = aPipe == aPipe1;
37064293329SJuergen Schmidt aPipe.close( );
37164293329SJuergen Schmidt aPipe1.close( );
37264293329SJuergen Schmidt
37364293329SJuergen Schmidt // #test comment#: test assign with reference.
37464293329SJuergen Schmidt ASSERT_TRUE( bRes && bRes1 );
37564293329SJuergen Schmidt }
376cdf0e10cSrcweir
TEST(Sal_Test_Pipe,assign_handle)37764293329SJuergen Schmidt TEST(Sal_Test_Pipe, assign_handle) {
37864293329SJuergen Schmidt ::osl::Pipe aPipe, aPipe1;
37964293329SJuergen Schmidt aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
38064293329SJuergen Schmidt aPipe1 = aPipe.getHandle( );
38164293329SJuergen Schmidt sal_Bool bRes = aPipe1.is( );
38264293329SJuergen Schmidt sal_Bool bRes1 = aPipe == aPipe1;
38364293329SJuergen Schmidt aPipe.close( );
38464293329SJuergen Schmidt aPipe1.close( );
38564293329SJuergen Schmidt
38664293329SJuergen Schmidt // #test comment#: test assign with handle.
38764293329SJuergen Schmidt ASSERT_TRUE( bRes && bRes1 );
38864293329SJuergen Schmidt }
389cdf0e10cSrcweir
390cdf0e10cSrcweir
391cdf0e10cSrcweir /** testing the method:
392cdf0e10cSrcweir inline sal_Bool SAL_CALL isValid() const;
393cdf0e10cSrcweir isValid( ) has not been implemented under the following platforms, please refer to osl/pipe.hxx
394cdf0e10cSrcweir */
39564293329SJuergen Schmidt // TEST(Sal_Test_Pipe, isValid_001) {
39664293329SJuergen Schmidt // ...
39764293329SJuergen Schmidt // // #test comment#: isValid() has not been implemented on all platforms.
39864293329SJuergen Schmidt // ASSERT_TRUE( ... );
39964293329SJuergen Schmidt // }
400cdf0e10cSrcweir
401cdf0e10cSrcweir
402cdf0e10cSrcweir /** testing the method:
403cdf0e10cSrcweir inline sal_Bool SAL_CALL operator==( const Pipe& rPipe ) const;
404cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,isEqual_001)40564293329SJuergen Schmidt TEST(Sal_Test_Pipe, isEqual_001) {
40664293329SJuergen Schmidt ::osl::Pipe aPipe;
40764293329SJuergen Schmidt aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
40864293329SJuergen Schmidt sal_Bool bRes = aPipe == aPipe;
40964293329SJuergen Schmidt aPipe.close( );
41064293329SJuergen Schmidt
41164293329SJuergen Schmidt // #test comment#: test isEqual(), compare its self.
41264293329SJuergen Schmidt ASSERT_TRUE( bRes );
41364293329SJuergen Schmidt }
414cdf0e10cSrcweir
TEST(Sal_Test_Pipe,isEqual_002)41564293329SJuergen Schmidt TEST(Sal_Test_Pipe, isEqual_002) {
41664293329SJuergen Schmidt ::osl::Pipe aPipe, aPipe1, aPipe2;
41764293329SJuergen Schmidt aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
41864293329SJuergen Schmidt aPipe1 = aPipe;
41964293329SJuergen Schmidt aPipe2.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
420cdf0e10cSrcweir
42164293329SJuergen Schmidt sal_Bool bRes = aPipe == aPipe1;
42264293329SJuergen Schmidt sal_Bool bRes1 = aPipe == aPipe2;
42364293329SJuergen Schmidt aPipe.close( );
42464293329SJuergen Schmidt aPipe1.close( );
42564293329SJuergen Schmidt aPipe2.close( );
426cdf0e10cSrcweir
42764293329SJuergen Schmidt // #test comment#: test isEqual(),create one copy instance, and compare.
42864293329SJuergen Schmidt ASSERT_TRUE( bRes && !bRes1 );
42964293329SJuergen Schmidt }
430cdf0e10cSrcweir
431cdf0e10cSrcweir
432cdf0e10cSrcweir /** testing the method:
433cdf0e10cSrcweir inline void SAL_CALL close();
434cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,close_001)43564293329SJuergen Schmidt TEST(Sal_Test_Pipe, close_001) {
43664293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipe1), osl_Pipe_CREATE );
43764293329SJuergen Schmidt aPipe.close( );
43864293329SJuergen Schmidt sal_Bool bRes = aPipe.is( );
43964293329SJuergen Schmidt
44064293329SJuergen Schmidt aPipe.clear( );
44164293329SJuergen Schmidt sal_Bool bRes1 = aPipe.is( );
44264293329SJuergen Schmidt
44364293329SJuergen Schmidt // #test comment#: difference between close and clear.
44464293329SJuergen Schmidt ASSERT_TRUE( bRes && !bRes1);
44564293329SJuergen Schmidt }
446cdf0e10cSrcweir
TEST(Sal_Test_Pipe,close_002)44764293329SJuergen Schmidt TEST(Sal_Test_Pipe, close_002) {
44864293329SJuergen Schmidt ::osl::StreamPipe aPipe( uniquePipeName(aTestPipe1), osl_Pipe_CREATE );
44964293329SJuergen Schmidt aPipe.close( );
45064293329SJuergen Schmidt int nRet = aPipe.send( m_pTestString1.getStr(), 3 );
451cdf0e10cSrcweir
45264293329SJuergen Schmidt // #test comment#: use after close.
45364293329SJuergen Schmidt ASSERT_EQ( nRet, OSL_PIPE_FAIL );
45464293329SJuergen Schmidt }
455cdf0e10cSrcweir
456cdf0e10cSrcweir
457cdf0e10cSrcweir /** testing the method:
458cdf0e10cSrcweir inline oslPipeError SAL_CALL accept(StreamPipe& Connection);
459cdf0e10cSrcweir please refer to StreamPipe::recv
460cdf0e10cSrcweir */
461cdf0e10cSrcweir
462cdf0e10cSrcweir
463cdf0e10cSrcweir /** testing the method:
464cdf0e10cSrcweir inline oslPipeError SAL_CALL getError() const;
465cdf0e10cSrcweir */
46664293329SJuergen Schmidt /*
46764293329SJuergen Schmidt PipeError[]= {
46864293329SJuergen Schmidt { 0, osl_Pipe_E_None }, // no error
46964293329SJuergen Schmidt { EPROTOTYPE, osl_Pipe_E_NoProtocol }, // Protocol wrong type for socket
47064293329SJuergen Schmidt { ENOPROTOOPT, osl_Pipe_E_NoProtocol }, // Protocol not available
47164293329SJuergen Schmidt { EPROTONOSUPPORT, osl_Pipe_E_NoProtocol }, // Protocol not supported
47264293329SJuergen Schmidt { ESOCKTNOSUPPORT, osl_Pipe_E_NoProtocol }, // Socket type not supported
47364293329SJuergen Schmidt { EPFNOSUPPORT, osl_Pipe_E_NoProtocol }, // Protocol family not supported
47464293329SJuergen Schmidt { EAFNOSUPPORT, osl_Pipe_E_NoProtocol }, // Address family not supported by
47564293329SJuergen Schmidt // protocol family
47664293329SJuergen Schmidt { ENETRESET, osl_Pipe_E_NetworkReset }, // Network dropped connection because
47764293329SJuergen Schmidt // of reset
47864293329SJuergen Schmidt { ECONNABORTED, osl_Pipe_E_ConnectionAbort }, // Software caused connection abort
47964293329SJuergen Schmidt { ECONNRESET, osl_Pipe_E_ConnectionReset }, // Connection reset by peer
48064293329SJuergen Schmidt { ENOBUFS, osl_Pipe_E_NoBufferSpace }, // No buffer space available
48164293329SJuergen Schmidt { ETIMEDOUT, osl_Pipe_E_TimedOut }, // Connection timed out
48264293329SJuergen Schmidt { ECONNREFUSED, osl_Pipe_E_ConnectionRefused }, // Connection refused
48364293329SJuergen Schmidt { -1, osl_Pipe_E_invalidError }
48464293329SJuergen Schmidt };
48564293329SJuergen Schmidt did not define osl_Pipe_E_NotFound, osl_Pipe_E_AlreadyExists
48664293329SJuergen Schmidt */
TEST(Sal_Test_Pipe,getError_001)48764293329SJuergen Schmidt TEST(Sal_Test_Pipe, getError_001) {
48864293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
48964293329SJuergen Schmidt oslPipeError nError = aPipe.getError( );
49064293329SJuergen Schmidt printPipeError( aPipe );
49164293329SJuergen Schmidt aPipe.clear( );
49264293329SJuergen Schmidt
49364293329SJuergen Schmidt // #test comment#: open a non-exist pipe.
49464293329SJuergen Schmidt ASSERT_NE( nError, osl_Pipe_E_None );
49564293329SJuergen Schmidt }
496cdf0e10cSrcweir
TEST(Sal_Test_Pipe,getError_002)49764293329SJuergen Schmidt TEST(Sal_Test_Pipe, getError_002) {
49864293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
49964293329SJuergen Schmidt ::osl::Pipe aPipe1( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
50064293329SJuergen Schmidt oslPipeError nError = aPipe.getError( );
50164293329SJuergen Schmidt printPipeError( aPipe );
50264293329SJuergen Schmidt aPipe.clear( );
50364293329SJuergen Schmidt aPipe1.clear( );
50464293329SJuergen Schmidt
50564293329SJuergen Schmidt // #test comment#: create an already exist pipe.
50664293329SJuergen Schmidt ASSERT_NE( nError, osl_Pipe_E_None );
50764293329SJuergen Schmidt }
508cdf0e10cSrcweir
509cdf0e10cSrcweir
510cdf0e10cSrcweir /** testing the method:
511cdf0e10cSrcweir inline oslPipe SAL_CALL getHandle() const;
512cdf0e10cSrcweir */
TEST(Sal_Test_Pipe,getHandle_001)51364293329SJuergen Schmidt TEST(Sal_Test_Pipe, getHandle_001) {
51464293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
51564293329SJuergen Schmidt sal_Bool bRes = aPipe == aPipe.getHandle( );
51664293329SJuergen Schmidt aPipe.clear( );
517cdf0e10cSrcweir
51864293329SJuergen Schmidt // #test comment#: one pipe should equal to its handle.
51964293329SJuergen Schmidt ASSERT_TRUE( bRes );
52064293329SJuergen Schmidt }
521cdf0e10cSrcweir
TEST(Sal_Test_Pipe,getHandle_002)52264293329SJuergen Schmidt TEST(Sal_Test_Pipe, getHandle_002) {
52364293329SJuergen Schmidt ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
52464293329SJuergen Schmidt ::osl::Pipe aPipe1( aPipe.getHandle( ) );
52564293329SJuergen Schmidt sal_Bool bRes = aPipe == aPipe1;
52664293329SJuergen Schmidt aPipe.clear( );
52764293329SJuergen Schmidt aPipe1.clear( );
52864293329SJuergen Schmidt
52964293329SJuergen Schmidt // #test comment#: one pipe derived from another pipe's handle.
53064293329SJuergen Schmidt ASSERT_TRUE( bRes );
53164293329SJuergen Schmidt }
532cdf0e10cSrcweir
533cdf0e10cSrcweir } // namespace osl_Pipe
534cdf0e10cSrcweir
535cdf0e10cSrcweir
536cdf0e10cSrcweir namespace osl_StreamPipe
537cdf0e10cSrcweir {
538cdf0e10cSrcweir
539cdf0e10cSrcweir /** testing the methods:
540cdf0e10cSrcweir inline StreamPipe();
541cdf0e10cSrcweir inline StreamPipe(oslPipe Pipe);;
542cdf0e10cSrcweir inline StreamPipe(const StreamPipe& Pipe);
543cdf0e10cSrcweir inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options = osl_Pipe_OPEN);
544cdf0e10cSrcweir inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options, const Security &rSec );
545cdf0e10cSrcweir inline StreamPipe( oslPipe pipe, __sal_NoAcquire noacquire );
546cdf0e10cSrcweir */
547cdf0e10cSrcweir
TEST(Sal_Test_StreamPipe,ctors_none)54864293329SJuergen Schmidt TEST(Sal_Test_StreamPipe, ctors_none) {
54964293329SJuergen Schmidt // create a pipe.
55064293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
55164293329SJuergen Schmidt // create an unattached pipe.
55264293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe1;
55364293329SJuergen Schmidt sal_Bool bRes = aStreamPipe1.is( );
55464293329SJuergen Schmidt
55564293329SJuergen Schmidt // assign it and check.
55664293329SJuergen Schmidt aStreamPipe1 = aStreamPipe;
55764293329SJuergen Schmidt sal_Bool bRes1 = aStreamPipe1.is( );
55864293329SJuergen Schmidt aStreamPipe.clear( );
55964293329SJuergen Schmidt aStreamPipe1.clear( );
56064293329SJuergen Schmidt
56164293329SJuergen Schmidt // #test comment#: test constructor with no parameter, before and after assign.
56264293329SJuergen Schmidt ASSERT_TRUE( !bRes && bRes1 );
56364293329SJuergen Schmidt }
564cdf0e10cSrcweir
TEST(Sal_Test_StreamPipe,ctors_handle)56564293329SJuergen Schmidt TEST(Sal_Test_StreamPipe, ctors_handle) {
56664293329SJuergen Schmidt // create a pipe.
56764293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
56864293329SJuergen Schmidt // create a pipe with last handle.
56964293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe1( aStreamPipe.getHandle( ) );
57064293329SJuergen Schmidt sal_Bool bRes = aStreamPipe1.is( ) && aStreamPipe == aStreamPipe1;
57164293329SJuergen Schmidt aStreamPipe.clear( );
57264293329SJuergen Schmidt aStreamPipe1.clear( );
57364293329SJuergen Schmidt
57464293329SJuergen Schmidt // #test comment#: test constructor with other's handle.
57564293329SJuergen Schmidt ASSERT_TRUE( bRes );
57664293329SJuergen Schmidt }
577cdf0e10cSrcweir
TEST(Sal_Test_StreamPipe,ctors_copy)57864293329SJuergen Schmidt TEST(Sal_Test_StreamPipe, ctors_copy) {
57964293329SJuergen Schmidt // create a pipe.
58064293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
58164293329SJuergen Schmidt // create an unattached pipe.
58264293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe1( aStreamPipe );
58364293329SJuergen Schmidt sal_Bool bRes = aStreamPipe1.is( ) && aStreamPipe == aStreamPipe1;
58464293329SJuergen Schmidt aStreamPipe.clear( );
58564293329SJuergen Schmidt aStreamPipe1.clear( );
58664293329SJuergen Schmidt
58764293329SJuergen Schmidt // #test comment#: test copy constructor.
58864293329SJuergen Schmidt ASSERT_TRUE( bRes );
58964293329SJuergen Schmidt }
590cdf0e10cSrcweir
TEST(Sal_Test_StreamPipe,ctors_name_option)59164293329SJuergen Schmidt TEST(Sal_Test_StreamPipe, ctors_name_option) {
59264293329SJuergen Schmidt // create a pipe.
59364293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
59464293329SJuergen Schmidt // create an unattached pipe.
59564293329SJuergen Schmidt ::osl::StreamPipe aStreamPipe1( uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
59664293329SJuergen Schmidt sal_Bool bRes = aStreamPipe1.is( ) && aStreamPipe.is( );
59764293329SJuergen Schmidt aStreamPipe.clear( );
59864293329SJuergen Schmidt aStreamPipe1.clear( );
59964293329SJuergen Schmidt
60064293329SJuergen Schmidt // #test comment#: test constructor with name and option.
60164293329SJuergen Schmidt ASSERT_TRUE( bRes );
60264293329SJuergen Schmidt }
603cdf0e10cSrcweir
TEST(Sal_Test_StreamPipe,ctors_name_option_security)60464293329SJuergen Schmidt TEST(Sal_Test_StreamPipe, ctors_name_option_security) {
60564293329SJuergen Schmidt // create a security pipe.
60664293329SJuergen Schmidt const ::osl::Security rSecurity;
60764293329SJuergen Schmidt ::osl::StreamPipe aSecurityPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSecurity );
60864293329SJuergen Schmidt
60964293329SJuergen Schmidt sal_Bool bRes = aSecurityPipe.is( );
61064293329SJuergen Schmidt aSecurityPipe.clear( );
611cdf0e10cSrcweir
61264293329SJuergen Schmidt // #test comment#: test constructor with name, option and security, the test of security is not implemented yet.
61364293329SJuergen Schmidt ASSERT_TRUE( bRes );
61464293329SJuergen Schmidt }
615cdf0e10cSrcweir
61664293329SJuergen Schmidt /** tester comment:
617cdf0e10cSrcweir
61864293329SJuergen Schmidt When test the following constructor, don't know how to test the
61964293329SJuergen Schmidt acquire and no acquire action. possible plans:
62064293329SJuergen Schmidt 1.release one handle and check the other( did not success since the
62164293329SJuergen Schmidt other still exist and valid. )
62264293329SJuergen Schmidt 2. release one handle twice to see getLastError( )(the getLastError
62364293329SJuergen Schmidt always returns invalidError(LINUX)).
62464293329SJuergen Schmidt */
TEST(Sal_Test_StreamPipe,ctors_no_acquire)62564293329SJuergen Schmidt TEST(Sal_Test_StreamPipe, ctors_no_acquire) {
62664293329SJuergen Schmidt // create a pipe.
62764293329SJuergen Schmidt ::osl::StreamPipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
62864293329SJuergen Schmidt // constructs a pipe reference without acquiring the handle.
62964293329SJuergen Schmidt ::osl::StreamPipe aNoAcquirePipe( aPipe.getHandle( ), SAL_NO_ACQUIRE );
63064293329SJuergen Schmidt
63164293329SJuergen Schmidt sal_Bool bRes = aNoAcquirePipe.is( );
63264293329SJuergen Schmidt aPipe.clear( );
63364293329SJuergen Schmidt // bRes1 = aNoAcquirePipe.is( );
63464293329SJuergen Schmidt
63564293329SJuergen Schmidt // #test comment#: test constructor with no acquire of handle, only validation test, do not know how to test no acquire.
63664293329SJuergen Schmidt ASSERT_TRUE( bRes );
63764293329SJuergen Schmidt }
638cdf0e10cSrcweir
639cdf0e10cSrcweir /** testing the methods:
640cdf0e10cSrcweir inline StreamPipe & SAL_CALL operator=(oslPipe Pipe);
641cdf0e10cSrcweir inline StreamPipe& SAL_CALL operator=(const Pipe& pipe);
642*5b21bb1fSmseidel mindy: not implemented in osl/pipe.hxx, so remove the cases
643cdf0e10cSrcweir */
64464293329SJuergen Schmidt // TEST(Sal_Test_StreamPipe, assign_ref) {
64564293329SJuergen Schmidt // ::osl::StreamPipe aPipe, aPipe1;
64664293329SJuergen Schmidt // aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
64764293329SJuergen Schmidt // aPipe1 = aPipe;
64864293329SJuergen Schmidt // sal_Bool bRes = aPipe1.is( );
64964293329SJuergen Schmidt // sal_Bool bRes1 = aPipe == aPipe1;
65064293329SJuergen Schmidt // aPipe.close( );
65164293329SJuergen Schmidt // aPipe1.close( );
65264293329SJuergen Schmidt
65364293329SJuergen Schmidt // // #test comment#: test assign with reference.
65464293329SJuergen Schmidt // ASSERT_TRUE( bRes && bRes1 );
65564293329SJuergen Schmidt // }
65664293329SJuergen Schmidt
65764293329SJuergen Schmidt // TEST(Sal_Test_StreamPipe, assign_ref) {
65864293329SJuergen Schmidt // ::osl::StreamPipe * pPipe = new ::osl::StreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
65964293329SJuergen Schmidt // ::osl::StreamPipe * pAssignPipe = new ::osl::StreamPipe;
66064293329SJuergen Schmidt // *pAssignPipe = pPipe->getHandle( );
66164293329SJuergen Schmidt
66264293329SJuergen Schmidt // bRes = pAssignPipe->is( );
66364293329SJuergen Schmidt // bRes1 = ( *pPipe == *pAssignPipe );
66464293329SJuergen Schmidt // pPipe->close( );
66564293329SJuergen Schmidt
66664293329SJuergen Schmidt // delete pAssignPipe;
66764293329SJuergen Schmidt
66864293329SJuergen Schmidt // // #test comment#: test assign with handle., seems not implemented under (LINUX)(W32)
66964293329SJuergen Schmidt // ASSERT_TRUE( bRes && bRes1 );
67064293329SJuergen Schmidt // }
671cdf0e10cSrcweir
672cdf0e10cSrcweir
673cdf0e10cSrcweir /** wait _nSec seconds.
674cdf0e10cSrcweir */
thread_sleep(sal_Int32 _nSec)675cdf0e10cSrcweir void thread_sleep( sal_Int32 _nSec )
676cdf0e10cSrcweir {
677cdf0e10cSrcweir /// print statement in thread process must use fflush() to force display.
678cdf0e10cSrcweir // printf("wait %d seconds. ", _nSec );
679cdf0e10cSrcweir fflush(stdout);
680cdf0e10cSrcweir
681cdf0e10cSrcweir #ifdef WNT //Windows
682cdf0e10cSrcweir Sleep( _nSec * 1000 );
683cdf0e10cSrcweir #endif
684cdf0e10cSrcweir #if ( defined UNX ) || ( defined OS2 ) //Unix
685cdf0e10cSrcweir sleep( _nSec );
686cdf0e10cSrcweir #endif
687cdf0e10cSrcweir // printf("done\n" );
688cdf0e10cSrcweir }
68964293329SJuergen Schmidt
69064293329SJuergen Schmidt // test read/write & send/recv data to pipe
691cdf0e10cSrcweir // -----------------------------------------------------------------------------
692cdf0e10cSrcweir
693cdf0e10cSrcweir class Pipe_DataSink_Thread : public Thread
694cdf0e10cSrcweir {
695cdf0e10cSrcweir public:
696cdf0e10cSrcweir sal_Char buf[256];
Pipe_DataSink_Thread()697cdf0e10cSrcweir Pipe_DataSink_Thread( ) { }
698cdf0e10cSrcweir
~Pipe_DataSink_Thread()699cdf0e10cSrcweir ~Pipe_DataSink_Thread( )
70064293329SJuergen Schmidt {
70164293329SJuergen Schmidt }
702cdf0e10cSrcweir protected:
run()703cdf0e10cSrcweir void SAL_CALL run( )
70464293329SJuergen Schmidt {
70564293329SJuergen Schmidt sal_Int32 nChars = 0;
70664293329SJuergen Schmidt
70764293329SJuergen Schmidt printf("open pipe\n");
70864293329SJuergen Schmidt // uniquePipeName(aTestPipeName) is a string = "TestPipe"
70964293329SJuergen Schmidt ::osl::StreamPipe aSenderPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN );
71064293329SJuergen Schmidt if ( aSenderPipe.is() == sal_False )
711cdf0e10cSrcweir {
71264293329SJuergen Schmidt printf("pipe open failed! \n");
71364293329SJuergen Schmidt }
71464293329SJuergen Schmidt else
71564293329SJuergen Schmidt {
71664293329SJuergen Schmidt printf("read\n");
71764293329SJuergen Schmidt nChars = aSenderPipe.read( buf, m_pTestString1.getLength() + 1 );
71864293329SJuergen Schmidt if ( nChars < 0 )
719cdf0e10cSrcweir {
72064293329SJuergen Schmidt printf("read failed! \n");
72164293329SJuergen Schmidt return;
722cdf0e10cSrcweir }
72364293329SJuergen Schmidt printf("buffer is %s \n", buf);
72464293329SJuergen Schmidt printf("send\n");
72564293329SJuergen Schmidt nChars = aSenderPipe.send( m_pTestString2.getStr(), m_pTestString2.getLength() + 1 );
72664293329SJuergen Schmidt if ( nChars < 0 )
727cdf0e10cSrcweir {
72864293329SJuergen Schmidt printf("client send failed! \n");
72964293329SJuergen Schmidt return;
730cdf0e10cSrcweir }
731cdf0e10cSrcweir }
73264293329SJuergen Schmidt }
733cdf0e10cSrcweir };
734cdf0e10cSrcweir
735cdf0e10cSrcweir // -----------------------------------------------------------------------------
736cdf0e10cSrcweir
737cdf0e10cSrcweir class Pipe_DataSource_Thread : public Thread
738cdf0e10cSrcweir {
739cdf0e10cSrcweir public:
740cdf0e10cSrcweir sal_Char buf[256];
74164293329SJuergen Schmidt //::osl::StreamPipe aListenPipe; //( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
742cdf0e10cSrcweir ::osl::Pipe aListenPipe;
743cdf0e10cSrcweir ::osl::StreamPipe aConnectionPipe;
Pipe_DataSource_Thread()744cdf0e10cSrcweir Pipe_DataSource_Thread( )
74564293329SJuergen Schmidt {
74664293329SJuergen Schmidt printf("create pipe\n");
74764293329SJuergen Schmidt aListenPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
74864293329SJuergen Schmidt }
~Pipe_DataSource_Thread()749cdf0e10cSrcweir ~Pipe_DataSource_Thread( )
75064293329SJuergen Schmidt {
75164293329SJuergen Schmidt aListenPipe.close();
75264293329SJuergen Schmidt }
753cdf0e10cSrcweir protected:
run()754cdf0e10cSrcweir void SAL_CALL run( )
75564293329SJuergen Schmidt {
75664293329SJuergen Schmidt //create pipe.
75764293329SJuergen Schmidt sal_Int32 nChars;
75864293329SJuergen Schmidt //::osl::StreamPipe aListenPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE );
75964293329SJuergen Schmidt printf("listen\n");
76064293329SJuergen Schmidt if ( aListenPipe.is() == sal_False )
76164293329SJuergen Schmidt {
76264293329SJuergen Schmidt printf("pipe create failed! \n");
76364293329SJuergen Schmidt }
76464293329SJuergen Schmidt else
76564293329SJuergen Schmidt {
76664293329SJuergen Schmidt //::osl::StreamPipe aConnectionPipe;
76764293329SJuergen Schmidt
76864293329SJuergen Schmidt //start server and wait for connection.
76964293329SJuergen Schmidt printf("accept\n");
77064293329SJuergen Schmidt if ( osl_Pipe_E_None != aListenPipe.accept( aConnectionPipe ) )
77164293329SJuergen Schmidt {
77264293329SJuergen Schmidt printf("pipe accept failed!");
77364293329SJuergen Schmidt return;
77464293329SJuergen Schmidt }
77564293329SJuergen Schmidt printf("write\n");
77664293329SJuergen Schmidt // write to pipe
77764293329SJuergen Schmidt nChars = aConnectionPipe.write( m_pTestString1.getStr(), m_pTestString1.getLength() + 1 );
77864293329SJuergen Schmidt if ( nChars < 0)
779cdf0e10cSrcweir {
78064293329SJuergen Schmidt printf("server write failed! \n");
78164293329SJuergen Schmidt return;
782cdf0e10cSrcweir }
78364293329SJuergen Schmidt printf("recv\n");
78464293329SJuergen Schmidt nChars = aConnectionPipe.recv( buf, 256 );
78564293329SJuergen Schmidt
78664293329SJuergen Schmidt if ( nChars < 0)
787cdf0e10cSrcweir {
78864293329SJuergen Schmidt printf("server receive failed! \n");
78964293329SJuergen Schmidt return;
790cdf0e10cSrcweir }
79164293329SJuergen Schmidt //thread_sleep( 2 );
79264293329SJuergen Schmidt printf("received message is: %s\n", buf );
79364293329SJuergen Schmidt //aConnectionPipe.close();
794cdf0e10cSrcweir }
79564293329SJuergen Schmidt }
796cdf0e10cSrcweir };
797cdf0e10cSrcweir
79864293329SJuergen Schmidt
799cdf0e10cSrcweir /** testing the method: read/write/send/recv and Pipe::accept
800cdf0e10cSrcweir */
TEST(Sal_Test_StreamPipe,recv_001)80164293329SJuergen Schmidt TEST(Sal_Test_StreamPipe, recv_001) {
80264293329SJuergen Schmidt //launch threads.
80364293329SJuergen Schmidt Pipe_DataSource_Thread myDataSourceThread;
80464293329SJuergen Schmidt Pipe_DataSink_Thread myDataSinkThread;
80564293329SJuergen Schmidt myDataSourceThread.create( );
80664293329SJuergen Schmidt thread_sleep( 1 );
80764293329SJuergen Schmidt myDataSinkThread.create( );
808cdf0e10cSrcweir
80964293329SJuergen Schmidt //wait until the thread terminate
81064293329SJuergen Schmidt myDataSinkThread.join( );
81164293329SJuergen Schmidt myDataSourceThread.join( );
812cdf0e10cSrcweir
81364293329SJuergen Schmidt int nCompare1 = strcmp( myDataSinkThread.buf, m_pTestString1.getStr() );
81464293329SJuergen Schmidt int nCompare2 = strcmp( myDataSourceThread.buf, m_pTestString2.getStr() );
815cdf0e10cSrcweir
81664293329SJuergen Schmidt // test send/recv/write/read.
81764293329SJuergen Schmidt ASSERT_TRUE( nCompare1 == 0 && nCompare2 == 0 );
81864293329SJuergen Schmidt }
819cdf0e10cSrcweir
820cdf0e10cSrcweir } // namespace osl_StreamPipe
821cdf0e10cSrcweir
main(int argc,char ** argv)82264293329SJuergen Schmidt int main(int argc, char **argv)
82364293329SJuergen Schmidt {
82464293329SJuergen Schmidt ::testing::InitGoogleTest(&argc, argv);
82564293329SJuergen Schmidt return RUN_ALL_TESTS();
82664293329SJuergen Schmidt }
827