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 #ifdef WNT 32 #include <Windows.h> 33 #endif 34 35 #include <sal/types.h> 36 #include <rtl/ustring.hxx> 37 38 #ifndef _OSL_THREAD_HXX 39 #include <osl/thread.hxx> 40 #endif 41 42 #ifndef _OSL_MUTEX_HXX 43 #include <osl/mutex.hxx> 44 #endif 45 46 #ifndef _OSL_MUTEX_HXX 47 #include <osl/pipe.hxx> 48 #endif 49 #include <osl/time.h> 50 #include <osl/process.h> 51 52 #ifdef UNX 53 #include <unistd.h> 54 #endif 55 #include <string.h> 56 57 #include "gtest/gtest.h" 58 59 using namespace osl; 60 using namespace rtl; 61 62 //------------------------------------------------------------------------ 63 // helper functions 64 //------------------------------------------------------------------------ 65 66 67 /** helper function for unique pipe names 68 */ 69 OUString uniquePipeName(OUString const & name) { 70 oslProcessInfo info; 71 info.Size = sizeof info; 72 EXPECT_TRUE( osl_Process_E_None == osl_getProcessInfo(0, osl_Process_IDENTIFIER, &info) ); 73 return name + OUString::valueOf((sal_Int32)info.Ident); 74 } 75 76 /** print Boolean value. 77 */ 78 inline void printBool( sal_Bool bOk ) 79 { 80 printf("#printBool# " ); 81 ( sal_True == bOk ) ? printf("YES!\n" ): printf("NO!\n" ); 82 } 83 84 /** print a UNI_CODE String. 85 */ 86 inline void printUString( const ::rtl::OUString & str ) 87 { 88 rtl::OString aString; 89 90 printf("#printUString_u# " ); 91 aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US ); 92 printf("%s\n", aString.getStr( ) ); 93 } 94 95 /** print last error of pipe system. 96 */ 97 inline void printPipeError( ::osl::Pipe aPipe ) 98 { 99 oslPipeError nError = aPipe.getError( ); 100 printf("#printPipeError# " ); 101 switch ( nError ) { 102 case osl_Pipe_E_None: 103 printf("Success!\n" ); 104 break; 105 case osl_Pipe_E_NotFound: 106 printf("The returned error is: Not found!\n" ); 107 break; 108 case osl_Pipe_E_AlreadyExists: 109 printf("The returned error is: Already exist!\n" ); 110 break; 111 case osl_Pipe_E_NoProtocol: 112 printf("The returned error is: No protocol!\n" ); 113 break; 114 case osl_Pipe_E_NetworkReset: 115 printf("The returned error is: Network reset!\n" ); 116 break; 117 case osl_Pipe_E_ConnectionAbort: 118 printf("The returned error is: Connection aborted!\n" ); 119 break; 120 case osl_Pipe_E_ConnectionReset: 121 printf("The returned error is: Connection reset!\n" ); 122 break; 123 case osl_Pipe_E_NoBufferSpace: 124 printf("The returned error is: No buffer space!\n" ); 125 break; 126 case osl_Pipe_E_TimedOut: 127 printf("The returned error is: Timeout!\n" ); 128 break; 129 case osl_Pipe_E_ConnectionRefused: 130 printf("The returned error is: Connection refused!\n" ); 131 break; 132 case osl_Pipe_E_invalidError: 133 printf("The returned error is: Invalid error!\n" ); 134 break; 135 default: 136 printf("The returned error is: Number %d, Unknown Error\n", nError ); 137 break; 138 } 139 } 140 141 142 143 //------------------------------------------------------------------------ 144 // pipe name and transfer contents 145 //------------------------------------------------------------------------ 146 const rtl::OUString aTestPipeName = rtl::OUString::createFromAscii( "testpipe2" ); 147 const rtl::OUString aTestPipe1 = rtl::OUString::createFromAscii( "testpipe1" ); 148 const rtl::OUString aTestString = rtl::OUString::createFromAscii( "Apache Software Foundation" ); 149 150 const OString m_pTestString1("Apache Software Foundation"); 151 const OString m_pTestString2("test pipe PASS/OK"); 152 153 //------------------------------------------------------------------------ 154 // test code start here 155 //------------------------------------------------------------------------ 156 157 namespace osl_Pipe 158 { 159 160 //------------------------------------------------------------------------ 161 // most return value -1 denote a fail of operation. 162 //------------------------------------------------------------------------ 163 #define OSL_PIPE_FAIL -1 164 165 /** testing the methods: 166 inline Pipe(); 167 inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options); 168 inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options,const Security & rSecurity); 169 inline Pipe(const Pipe& pipe); 170 inline Pipe(oslPipe pipe, __sal_NoAcquire noacquire ); 171 inline Pipe(oslPipe Pipe); 172 */ 173 TEST(Sal_Test_Pipe, ctors_none) { 174 ::osl::Pipe aPipe; 175 sal_Bool bRes = aPipe.is( ); 176 177 // #test comment#: test constructor with no parameter, yet no case to test. 178 ASSERT_TRUE( !bRes ); 179 } 180 181 TEST(Sal_Test_Pipe, ctors_name_option) { 182 /// create a named pipe. 183 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 184 ::osl::Pipe aAssignPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN ); 185 186 sal_Bool bRes = aPipe.is( ) && aAssignPipe.is( ); 187 188 // #test comment#: test constructor with name and option. 189 ASSERT_TRUE( bRes ); 190 } 191 192 TEST(Sal_Test_Pipe, ctors_name_option_security) { 193 /// create a security pipe. 194 const ::osl::Security rSecurity; 195 ::osl::Pipe aSecurityPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSecurity ); 196 197 sal_Bool bRes = aSecurityPipe.is( ); 198 199 // #test comment#: test constructor with name, option and security, the test of security is not implemented yet. 200 ASSERT_TRUE( bRes ); 201 } 202 203 TEST(Sal_Test_Pipe, ctors_copy) { 204 /// create a pipe. 205 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 206 /// create a pipe using copy constructor. 207 ::osl::Pipe aCopyPipe( aPipe ); 208 209 sal_Bool bRes = aCopyPipe.is( ) && aCopyPipe == aPipe; 210 211 // #test comment#: test copy constructor. 212 ASSERT_TRUE( bRes ); 213 } 214 215 216 /** tester comment: 217 218 When test the following two constructors, don't know how to test the 219 acquire and no acquire action. possible plans: 220 1.release one handle and check the other( did not success since the 221 other still exist and valid. ) 222 2. release one handle twice to see getLastError( )(the getLastError 223 always returns invalidError(LINUX)). 224 */ 225 TEST(Sal_Test_Pipe, ctors_no_acquire) { 226 /// create a pipe. 227 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 228 /// constructs a pipe reference without acquiring the handle. 229 ::osl::Pipe aNoAcquirePipe( aPipe.getHandle( ), SAL_NO_ACQUIRE ); 230 231 sal_Bool bRes = aNoAcquirePipe.is( ); 232 ///aPipe.clear( ); 233 ///bRes1 = aNoAcquirePipe.is( ); 234 235 236 // #test comment#: test constructor with no acquire of handle, only validation test, do not know how to test no acquire. 237 ASSERT_TRUE( bRes ); 238 } 239 240 TEST(Sal_Test_Pipe, ctors_acquire) { 241 /// create a base pipe. 242 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 243 /// constructs two pipes without acquiring the handle on the base pipe. 244 ::osl::Pipe aAcquirePipe( aPipe.getHandle( ) ); 245 ::osl::Pipe aAcquirePipe1( NULL ); 246 247 sal_Bool bRes = aAcquirePipe.is( ); 248 sal_Bool bRes1 = aAcquirePipe1.is( ); 249 250 // #test comment#: test constructor with no acquire of handle.only validation test, do not know how to test no acquire. 251 ASSERT_TRUE( bRes && !bRes1 ); 252 } 253 254 255 /** testing the method: 256 inline sal_Bool SAL_CALL is() const; 257 */ 258 TEST(Sal_Test_Pipe, is_001) { 259 ::osl::Pipe aPipe; 260 261 // #test comment#: test is(), check if the pipe is a valid one. 262 ASSERT_TRUE( !aPipe.is( ) ); 263 } 264 265 TEST(Sal_Test_Pipe, is_002) { 266 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 267 268 // #test comment#: test is(), a normal pipe creation. 269 ASSERT_TRUE( aPipe.is( ) ); 270 } 271 272 TEST(Sal_Test_Pipe, is_003) { 273 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 274 aPipe.clear( ); 275 276 // #test comment#: test is(), an invalid case 277 ASSERT_TRUE( !aPipe.is( ) ); 278 } 279 280 TEST(Sal_Test_Pipe, is_004) { 281 ::osl::Pipe aPipe( NULL ); 282 283 // #test comment#: test is(), an invalid constructor. 284 ASSERT_TRUE( !aPipe.is( ) ); 285 } 286 287 288 /** testing the methods: 289 inline sal_Bool create( const ::rtl::OUString & strName, 290 oslPipeOptions Options, const Security &rSec ); 291 nline sal_Bool create( const ::rtl::OUString & strName, 292 oslPipeOptions Options = osl_Pipe_OPEN ); 293 */ 294 TEST(Sal_Test_Pipe, create_named_security_001) { 295 const Security rSec; 296 ::osl::Pipe aPipe; 297 sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec ); 298 sal_Bool bRes1 = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec ); 299 aPipe.clear( ); 300 301 // #test comment#: test creation. 302 ASSERT_TRUE( bRes && !bRes1 ); 303 } 304 305 TEST(Sal_Test_Pipe, create_named_security_002) { 306 const Security rSec; 307 ::osl::Pipe aPipe, aPipe1; 308 sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSec ); 309 sal_Bool bRes1 = aPipe1.create( uniquePipeName(aTestPipeName), osl_Pipe_OPEN, rSec ); 310 aPipe.clear( ); 311 312 // #test comment#: test creation and open. 313 ASSERT_TRUE( bRes && bRes1 ); 314 } 315 316 TEST(Sal_Test_Pipe, create_named_001) { 317 ::osl::Pipe aPipe; 318 sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 319 sal_Bool bRes1 = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 320 aPipe.clear( ); 321 322 // #test comment#: test creation. 323 ASSERT_TRUE( bRes && !bRes1); 324 } 325 326 TEST(Sal_Test_Pipe, create_named_002) { 327 ::osl::Pipe aPipe, aPipe1; 328 sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 329 sal_Bool bRes1 = aPipe1.create( uniquePipeName(aTestPipeName), osl_Pipe_OPEN ); 330 aPipe.clear( ); 331 332 // #test comment#: test creation and open. 333 ASSERT_TRUE( bRes && bRes1); 334 } 335 336 TEST(Sal_Test_Pipe, create_named_003) { 337 ::osl::Pipe aPipe; 338 sal_Bool bRes = aPipe.create( uniquePipeName(aTestPipeName) ); 339 aPipe.clear( ); 340 341 // #test comment#: test default option is open. 342 ASSERT_TRUE( !bRes ); 343 } 344 345 346 /** testing the method: 347 inline void SAL_CALL clear(); 348 */ 349 TEST(Sal_Test_Pipe, clear_001) { 350 ::osl::Pipe aPipe; 351 aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 352 aPipe.clear( ); 353 sal_Bool bRes = aPipe.is( ); 354 355 // #test comment#: test clear. 356 ASSERT_TRUE( !bRes ); 357 } 358 359 360 /** testing the methods: 361 inline Pipe& SAL_CALL operator= (const Pipe& pipe); 362 inline Pipe& SAL_CALL operator= (const oslPipe pipe ); 363 */ 364 TEST(Sal_Test_Pipe, assign_ref) { 365 ::osl::Pipe aPipe, aPipe1; 366 aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 367 aPipe1 = aPipe; 368 sal_Bool bRes = aPipe1.is( ); 369 sal_Bool bRes1 = aPipe == aPipe1; 370 aPipe.close( ); 371 aPipe1.close( ); 372 373 // #test comment#: test assign with reference. 374 ASSERT_TRUE( bRes && bRes1 ); 375 } 376 377 TEST(Sal_Test_Pipe, assign_handle) { 378 ::osl::Pipe aPipe, aPipe1; 379 aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 380 aPipe1 = aPipe.getHandle( ); 381 sal_Bool bRes = aPipe1.is( ); 382 sal_Bool bRes1 = aPipe == aPipe1; 383 aPipe.close( ); 384 aPipe1.close( ); 385 386 // #test comment#: test assign with handle. 387 ASSERT_TRUE( bRes && bRes1 ); 388 } 389 390 391 /** testing the method: 392 inline sal_Bool SAL_CALL isValid() const; 393 isValid( ) has not been implemented under the following platforms, please refer to osl/pipe.hxx 394 */ 395 // TEST(Sal_Test_Pipe, isValid_001) { 396 // ... 397 // // #test comment#: isValid() has not been implemented on all platforms. 398 // ASSERT_TRUE( ... ); 399 // } 400 401 402 /** testing the method: 403 inline sal_Bool SAL_CALL operator==( const Pipe& rPipe ) const; 404 */ 405 TEST(Sal_Test_Pipe, isEqual_001) { 406 ::osl::Pipe aPipe; 407 aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 408 sal_Bool bRes = aPipe == aPipe; 409 aPipe.close( ); 410 411 // #test comment#: test isEqual(), compare its self. 412 ASSERT_TRUE( bRes ); 413 } 414 415 TEST(Sal_Test_Pipe, isEqual_002) { 416 ::osl::Pipe aPipe, aPipe1, aPipe2; 417 aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 418 aPipe1 = aPipe; 419 aPipe2.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 420 421 sal_Bool bRes = aPipe == aPipe1; 422 sal_Bool bRes1 = aPipe == aPipe2; 423 aPipe.close( ); 424 aPipe1.close( ); 425 aPipe2.close( ); 426 427 // #test comment#: test isEqual(),create one copy instance, and compare. 428 ASSERT_TRUE( bRes && !bRes1 ); 429 } 430 431 432 /** testing the method: 433 inline void SAL_CALL close(); 434 */ 435 TEST(Sal_Test_Pipe, close_001) { 436 ::osl::Pipe aPipe( uniquePipeName(aTestPipe1), osl_Pipe_CREATE ); 437 aPipe.close( ); 438 sal_Bool bRes = aPipe.is( ); 439 440 aPipe.clear( ); 441 sal_Bool bRes1 = aPipe.is( ); 442 443 // #test comment#: difference between close and clear. 444 ASSERT_TRUE( bRes && !bRes1); 445 } 446 447 TEST(Sal_Test_Pipe, close_002) { 448 ::osl::StreamPipe aPipe( uniquePipeName(aTestPipe1), osl_Pipe_CREATE ); 449 aPipe.close( ); 450 int nRet = aPipe.send( m_pTestString1.getStr(), 3 ); 451 452 // #test comment#: use after close. 453 ASSERT_EQ( nRet, OSL_PIPE_FAIL ); 454 } 455 456 457 /** testing the method: 458 inline oslPipeError SAL_CALL accept(StreamPipe& Connection); 459 please refer to StreamPipe::recv 460 */ 461 462 463 /** testing the method: 464 inline oslPipeError SAL_CALL getError() const; 465 */ 466 /* 467 PipeError[]= { 468 { 0, osl_Pipe_E_None }, // no error 469 { EPROTOTYPE, osl_Pipe_E_NoProtocol }, // Protocol wrong type for socket 470 { ENOPROTOOPT, osl_Pipe_E_NoProtocol }, // Protocol not available 471 { EPROTONOSUPPORT, osl_Pipe_E_NoProtocol }, // Protocol not supported 472 { ESOCKTNOSUPPORT, osl_Pipe_E_NoProtocol }, // Socket type not supported 473 { EPFNOSUPPORT, osl_Pipe_E_NoProtocol }, // Protocol family not supported 474 { EAFNOSUPPORT, osl_Pipe_E_NoProtocol }, // Address family not supported by 475 // protocol family 476 { ENETRESET, osl_Pipe_E_NetworkReset }, // Network dropped connection because 477 // of reset 478 { ECONNABORTED, osl_Pipe_E_ConnectionAbort }, // Software caused connection abort 479 { ECONNRESET, osl_Pipe_E_ConnectionReset }, // Connection reset by peer 480 { ENOBUFS, osl_Pipe_E_NoBufferSpace }, // No buffer space available 481 { ETIMEDOUT, osl_Pipe_E_TimedOut }, // Connection timed out 482 { ECONNREFUSED, osl_Pipe_E_ConnectionRefused }, // Connection refused 483 { -1, osl_Pipe_E_invalidError } 484 }; 485 did not define osl_Pipe_E_NotFound, osl_Pipe_E_AlreadyExists 486 */ 487 TEST(Sal_Test_Pipe, getError_001) { 488 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN ); 489 oslPipeError nError = aPipe.getError( ); 490 printPipeError( aPipe ); 491 aPipe.clear( ); 492 493 // #test comment#: open a non-exist pipe. 494 ASSERT_NE( nError, osl_Pipe_E_None ); 495 } 496 497 TEST(Sal_Test_Pipe, getError_002) { 498 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 499 ::osl::Pipe aPipe1( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 500 oslPipeError nError = aPipe.getError( ); 501 printPipeError( aPipe ); 502 aPipe.clear( ); 503 aPipe1.clear( ); 504 505 // #test comment#: create an already exist pipe. 506 ASSERT_NE( nError, osl_Pipe_E_None ); 507 } 508 509 510 /** testing the method: 511 inline oslPipe SAL_CALL getHandle() const; 512 */ 513 TEST(Sal_Test_Pipe, getHandle_001) { 514 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN ); 515 sal_Bool bRes = aPipe == aPipe.getHandle( ); 516 aPipe.clear( ); 517 518 // #test comment#: one pipe should equal to its handle. 519 ASSERT_TRUE( bRes ); 520 } 521 522 TEST(Sal_Test_Pipe, getHandle_002) { 523 ::osl::Pipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 524 ::osl::Pipe aPipe1( aPipe.getHandle( ) ); 525 sal_Bool bRes = aPipe == aPipe1; 526 aPipe.clear( ); 527 aPipe1.clear( ); 528 529 // #test comment#: one pipe derived from another pipe's handle. 530 ASSERT_TRUE( bRes ); 531 } 532 533 } // namespace osl_Pipe 534 535 536 namespace osl_StreamPipe 537 { 538 539 /** testing the methods: 540 inline StreamPipe(); 541 inline StreamPipe(oslPipe Pipe); 542 inline StreamPipe(const StreamPipe& Pipe); 543 inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options = osl_Pipe_OPEN); 544 inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options, const Security &rSec ); 545 inline StreamPipe( oslPipe pipe, __sal_NoAcquire noacquire ); 546 */ 547 548 TEST(Sal_Test_StreamPipe, ctors_none) { 549 // create a pipe. 550 ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 551 // create an unattached pipe. 552 ::osl::StreamPipe aStreamPipe1; 553 sal_Bool bRes = aStreamPipe1.is( ); 554 555 // assign it and check. 556 aStreamPipe1 = aStreamPipe; 557 sal_Bool bRes1 = aStreamPipe1.is( ); 558 aStreamPipe.clear( ); 559 aStreamPipe1.clear( ); 560 561 // #test comment#: test constructor with no parameter, before and after assign. 562 ASSERT_TRUE( !bRes && bRes1 ); 563 } 564 565 TEST(Sal_Test_StreamPipe, ctors_handle) { 566 // create a pipe. 567 ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 568 // create a pipe with last handle. 569 ::osl::StreamPipe aStreamPipe1( aStreamPipe.getHandle( ) ); 570 sal_Bool bRes = aStreamPipe1.is( ) && aStreamPipe == aStreamPipe1; 571 aStreamPipe.clear( ); 572 aStreamPipe1.clear( ); 573 574 // #test comment#: test constructor with other's handle. 575 ASSERT_TRUE( bRes ); 576 } 577 578 TEST(Sal_Test_StreamPipe, ctors_copy) { 579 // create a pipe. 580 ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 581 // create an unattached pipe. 582 ::osl::StreamPipe aStreamPipe1( aStreamPipe ); 583 sal_Bool bRes = aStreamPipe1.is( ) && aStreamPipe == aStreamPipe1; 584 aStreamPipe.clear( ); 585 aStreamPipe1.clear( ); 586 587 // #test comment#: test copy constructor. 588 ASSERT_TRUE( bRes ); 589 } 590 591 TEST(Sal_Test_StreamPipe, ctors_name_option) { 592 // create a pipe. 593 ::osl::StreamPipe aStreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 594 // create an unattached pipe. 595 ::osl::StreamPipe aStreamPipe1( uniquePipeName(aTestPipeName), osl_Pipe_OPEN ); 596 sal_Bool bRes = aStreamPipe1.is( ) && aStreamPipe.is( ); 597 aStreamPipe.clear( ); 598 aStreamPipe1.clear( ); 599 600 // #test comment#: test constructor with name and option. 601 ASSERT_TRUE( bRes ); 602 } 603 604 TEST(Sal_Test_StreamPipe, ctors_name_option_security) { 605 // create a security pipe. 606 const ::osl::Security rSecurity; 607 ::osl::StreamPipe aSecurityPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE, rSecurity ); 608 609 sal_Bool bRes = aSecurityPipe.is( ); 610 aSecurityPipe.clear( ); 611 612 // #test comment#: test constructor with name, option and security, the test of security is not implemented yet. 613 ASSERT_TRUE( bRes ); 614 } 615 616 /** tester comment: 617 618 When test the following constructor, don't know how to test the 619 acquire and no acquire action. possible plans: 620 1.release one handle and check the other( did not success since the 621 other still exist and valid. ) 622 2. release one handle twice to see getLastError( )(the getLastError 623 always returns invalidError(LINUX)). 624 */ 625 TEST(Sal_Test_StreamPipe, ctors_no_acquire) { 626 // create a pipe. 627 ::osl::StreamPipe aPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 628 // constructs a pipe reference without acquiring the handle. 629 ::osl::StreamPipe aNoAcquirePipe( aPipe.getHandle( ), SAL_NO_ACQUIRE ); 630 631 sal_Bool bRes = aNoAcquirePipe.is( ); 632 aPipe.clear( ); 633 // bRes1 = aNoAcquirePipe.is( ); 634 635 // #test comment#: test constructor with no acquire of handle, only validation test, do not know how to test no acquire. 636 ASSERT_TRUE( bRes ); 637 } 638 639 /** testing the methods: 640 inline StreamPipe & SAL_CALL operator=(oslPipe Pipe); 641 inline StreamPipe& SAL_CALL operator=(const Pipe& pipe); 642 mindy: not implemented in osl/pipe.hxx, so remove the cases 643 */ 644 // TEST(Sal_Test_StreamPipe, assign_ref) { 645 // ::osl::StreamPipe aPipe, aPipe1; 646 // aPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 647 // aPipe1 = aPipe; 648 // sal_Bool bRes = aPipe1.is( ); 649 // sal_Bool bRes1 = aPipe == aPipe1; 650 // aPipe.close( ); 651 // aPipe1.close( ); 652 653 // // #test comment#: test assign with reference. 654 // ASSERT_TRUE( bRes && bRes1 ); 655 // } 656 657 // TEST(Sal_Test_StreamPipe, assign_ref) { 658 // ::osl::StreamPipe * pPipe = new ::osl::StreamPipe( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 659 // ::osl::StreamPipe * pAssignPipe = new ::osl::StreamPipe; 660 // *pAssignPipe = pPipe->getHandle( ); 661 662 // bRes = pAssignPipe->is( ); 663 // bRes1 = ( *pPipe == *pAssignPipe ); 664 // pPipe->close( ); 665 666 // delete pAssignPipe; 667 668 // // #test comment#: test assign with handle., seems not implemented under (LINUX)(W32) 669 // ASSERT_TRUE( bRes && bRes1 ); 670 // } 671 672 673 /** wait _nSec seconds. 674 */ 675 void thread_sleep( sal_Int32 _nSec ) 676 { 677 /// print statement in thread process must use fflush() to force display. 678 // printf("wait %d seconds. ", _nSec ); 679 fflush(stdout); 680 681 #ifdef WNT //Windows 682 Sleep( _nSec * 1000 ); 683 #endif 684 #if ( defined UNX ) || ( defined OS2 ) //Unix 685 sleep( _nSec ); 686 #endif 687 // printf("done\n" ); 688 } 689 690 // test read/write & send/recv data to pipe 691 // ----------------------------------------------------------------------------- 692 693 class Pipe_DataSink_Thread : public Thread 694 { 695 public: 696 sal_Char buf[256]; 697 Pipe_DataSink_Thread( ) { } 698 699 ~Pipe_DataSink_Thread( ) 700 { 701 } 702 protected: 703 void SAL_CALL run( ) 704 { 705 sal_Int32 nChars = 0; 706 707 printf("open pipe\n"); 708 // uniquePipeName(aTestPipeName) is a string = "TestPipe" 709 ::osl::StreamPipe aSenderPipe( uniquePipeName(aTestPipeName), osl_Pipe_OPEN ); 710 if ( aSenderPipe.is() == sal_False ) 711 { 712 printf("pipe open failed! \n"); 713 } 714 else 715 { 716 printf("read\n"); 717 nChars = aSenderPipe.read( buf, m_pTestString1.getLength() + 1 ); 718 if ( nChars < 0 ) 719 { 720 printf("read failed! \n"); 721 return; 722 } 723 printf("buffer is %s \n", buf); 724 printf("send\n"); 725 nChars = aSenderPipe.send( m_pTestString2.getStr(), m_pTestString2.getLength() + 1 ); 726 if ( nChars < 0 ) 727 { 728 printf("client send failed! \n"); 729 return; 730 } 731 } 732 } 733 }; 734 735 // ----------------------------------------------------------------------------- 736 737 class Pipe_DataSource_Thread : public Thread 738 { 739 public: 740 sal_Char buf[256]; 741 //::osl::StreamPipe aListenPipe; //( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 742 ::osl::Pipe aListenPipe; 743 ::osl::StreamPipe aConnectionPipe; 744 Pipe_DataSource_Thread( ) 745 { 746 printf("create pipe\n"); 747 aListenPipe.create( uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 748 } 749 ~Pipe_DataSource_Thread( ) 750 { 751 aListenPipe.close(); 752 } 753 protected: 754 void SAL_CALL run( ) 755 { 756 //create pipe. 757 sal_Int32 nChars; 758 //::osl::StreamPipe aListenPipe( test::uniquePipeName(aTestPipeName), osl_Pipe_CREATE ); 759 printf("listen\n"); 760 if ( aListenPipe.is() == sal_False ) 761 { 762 printf("pipe create failed! \n"); 763 } 764 else 765 { 766 //::osl::StreamPipe aConnectionPipe; 767 768 //start server and wait for connection. 769 printf("accept\n"); 770 if ( osl_Pipe_E_None != aListenPipe.accept( aConnectionPipe ) ) 771 { 772 printf("pipe accept failed!"); 773 return; 774 } 775 printf("write\n"); 776 // write to pipe 777 nChars = aConnectionPipe.write( m_pTestString1.getStr(), m_pTestString1.getLength() + 1 ); 778 if ( nChars < 0) 779 { 780 printf("server write failed! \n"); 781 return; 782 } 783 printf("recv\n"); 784 nChars = aConnectionPipe.recv( buf, 256 ); 785 786 if ( nChars < 0) 787 { 788 printf("server receive failed! \n"); 789 return; 790 } 791 //thread_sleep( 2 ); 792 printf("received message is: %s\n", buf ); 793 //aConnectionPipe.close(); 794 } 795 } 796 }; 797 798 799 /** testing the method: read/write/send/recv and Pipe::accept 800 */ 801 TEST(Sal_Test_StreamPipe, recv_001) { 802 //launch threads. 803 Pipe_DataSource_Thread myDataSourceThread; 804 Pipe_DataSink_Thread myDataSinkThread; 805 myDataSourceThread.create( ); 806 thread_sleep( 1 ); 807 myDataSinkThread.create( ); 808 809 //wait until the thread terminate 810 myDataSinkThread.join( ); 811 myDataSourceThread.join( ); 812 813 int nCompare1 = strcmp( myDataSinkThread.buf, m_pTestString1.getStr() ); 814 int nCompare2 = strcmp( myDataSourceThread.buf, m_pTestString2.getStr() ); 815 816 // test send/recv/write/read. 817 ASSERT_TRUE( nCompare1 == 0 && nCompare2 == 0 ); 818 } 819 820 } // namespace osl_StreamPipe 821 822 int main(int argc, char **argv) 823 { 824 ::testing::InitGoogleTest(&argc, argv); 825 return RUN_ALL_TESTS(); 826 } 827