os/kernelhwsrv/kerneltest/e32test/pipe/t_pipe4.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib.
     1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
     2 // All rights reserved.
     3 // This component and the accompanying materials are made available
     4 // under the terms of the License "Eclipse Public License v1.0"
     5 // which accompanies this distribution, and is available
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
     7 //
     8 // Initial Contributors:
     9 // Nokia Corporation - initial contribution.
    10 //
    11 // Contributors:
    12 //
    13 // Description:
    14 // e32test\pipe\t_pipe4.cpp
    15 // This is very similar to User::WaitForRequest() but allows the User
    16 // to specify multiple TRequestStatus objects to wait on. The function
    17 // will return when the first TRequestStatus object completes.
    18 // / Header Files////////
    19 // 
    20 //
    21 
    22 /**
    23  @STMTestCaseID			KBASE-T_PIPE4-0218
    24  @SYMPREQ				PREQ1460
    25  @SYMREQ					REQ6142
    26  @SYMCR					CR0923
    27  @SYMTestCaseDesc		User::WaitForNRequests functional test
    28  @SYMTestPriority		High
    29  @SYMTestActions			Tests the operation of the API User::WaitForNRequests().
    30  @SYMTestExpectedResults	Test should pass
    31 */
    32 
    33 #define __E32TEST_EXTENSION__
    34 
    35 #include <e32test.h>
    36 #include <e32svr.h>
    37 #include <e32des8.h>
    38 #include <e32des8_private.h>
    39 #include <e32cmn.h>
    40 #include <e32cmn_private.h>
    41 #include <e32std.h>
    42 #include <e32std_private.h>
    43 
    44 #include "rpipe.h"
    45 
    46 //// Test Objects for All threads////
    47 
    48 LOCAL_D RTest test(_L("t_pipe4"));
    49 LOCAL_D RTest test2(_L("t_pipe_t2"));
    50 LOCAL_D RTest test3(_L("t_pipe_t3"));
    51 LOCAL_D RTest test4(_L("t_pipe_t4"));
    52 LOCAL_D RTest test5(_L("t_pipe_t5"));
    53 
    54 //// Thread Name Constants //////
    55 _LIT(KThread2Name, "WaitThread");
    56 _LIT(KThread3Name, "NotifyDataThread");
    57 _LIT(KThread4Name, "NotifySpaceThread");
    58 _LIT(KThread5Name, "CancelNotifyThread");
    59 
    60 _LIT(KPipe1Name,"TestPipeP");
    61 _LIT(KPipe2Name,"TestPipeQ");
    62 _LIT(KPipe3Name,"TestPipeR");
    63 _LIT(KPipe4Name,"TestPipeS");
    64 _LIT(KPipe5Name,"TestPipeT");
    65 
    66 
    67 _LIT8(KTestDataNum,"1234567890");
    68 
    69 
    70 
    71 const TInt KHeapSize=0x2000;
    72 
    73 
    74 // Following class is used to pass thread handle information to different threads.
    75 class TData
    76 	{
    77 public:
    78 	TData(RPipe* aPipe, RPipe *bPipe, TInt aSize);
    79 	RPipe* rPipe;								// Pipe Read handle
    80 	RPipe* wPipe;								// Pipe Write handle
    81 	TInt iSize;
    82 
    83 
    84 	};
    85 
    86 TData::TData(RPipe * aPipe , RPipe *bPipe, TInt aSize) {
    87 	rPipe = aPipe;
    88 	wPipe = bPipe;
    89 	iSize = aSize;
    90 
    91 }
    92 
    93 ////////////////////////////////////////////////////
    94 //// WaitThread : Function opens the Read handle
    95 ////			for the pipe passed to it.
    96 ////
    97 ////			CPipeName --> Pipe Name
    98 ////			aData 	  --> Read Write Handle
    99 ////
   100 ////////////////////////////////////////////////////
   101 TBufC<100> 		cPipeName;
   102 
   103 TInt WaitThread(TAny* aData) {
   104 
   105 	test2.Start(_L("PIPE TEST:WaitThread Entry"));
   106 	TInt 		ret;
   107 
   108 	TData& data = *(TData *)aData; 					// aData will have pipe handles and size.
   109 
   110 	ret = data.rPipe->Open(cPipeName,RPipe::EOpenToRead);
   111 	test2 (ret == KErrNone);
   112 
   113 	test2.Printf(_L("PIPE TEST:WaitThread Exit\n"));
   114 	test2.End();
   115 	test2.Close();
   116 	return KErrNone;
   117 }
   118 
   119 ////////////////////////////////////////////////////
   120 //// NotifyDataThread :
   121 ////			Function writes data into the pipe.
   122 ////
   123 ////			aData 	  --> Read Write Handle
   124 ////
   125 ////////////////////////////////////////////////////
   126 
   127 TInt NotifyDataThread(TAny* aData) {
   128 
   129 	TBufC8<50> 			cTestData(KTestDataNum); 	// Test Data
   130 	TInt 				ret;
   131 
   132 	test3.Start(_L("PIPE TEST:NotifyDataThread Entry"));
   133 
   134 	TData& data = *(TData *)aData; 					// aData will have pipe handles and size.
   135 
   136 	User::After(10000);
   137 
   138 	ret = data.wPipe->Write(cTestData,cTestData.Length());
   139 	test3(ret == cTestData.Length());
   140 
   141 	test3.Printf(_L("PIPE TEST:NotifyDataThread Exit\n"));
   142 	test3.End();
   143 	test3.Close();
   144 	return KErrNone;
   145 }
   146 
   147 ////////////////////////////////////////////////////
   148 //// NotifySpaceThread :
   149 ////			Function flush the pipe and makes
   150 ////			it free.
   151 ////
   152 ////			aData 	  --> Read Write Handle
   153 ////
   154 ////////////////////////////////////////////////////
   155 
   156 TInt NotifySpaceThread(TAny* aData) {
   157 
   158 
   159 	test4.Start(_L("PIPE TEST:NotifySpaceThread Entry"));
   160 
   161 	TData& data = *(TData *)aData; 					// aData will have pipe handles and size.
   162 
   163 //	User::After(10000000);
   164 
   165 	data.rPipe->Flush();
   166 
   167 	test4.Printf(_L("PIPE TEST:NotifySpaceThread Exit\n"));
   168 	test4.End();
   169 	test4.Close();
   170 	return KErrNone;
   171 }
   172 
   173 
   174 ////////////////////////////////////////////////////
   175 //// CancelNotifyThread :
   176 ////			Function cancels Space available request
   177 ////			or Cancels Data available request.
   178 ////
   179 ////			CancelFlag  --> 1 CancelSpaceAvailable
   180 ////							0 for CancelDataAvailable
   181 ////
   182 ////			aData 	  --> Read Write Handle
   183 ////
   184 ////////////////////////////////////////////////////
   185 
   186 TInt		CancelFlag; // 1 CancelSpaceAvailable ; 0 for CancelDataAvailable
   187 TInt CancelNotifyThread(TAny* aData) {
   188 
   189 	test5.Start(_L("PIPE TEST:CancelNotifyThread Entry"));
   190 
   191 	TData& data = *(TData *)aData; 					// aData will have pipe handles and size.
   192 
   193 	if ( CancelFlag == 1)
   194 		data.wPipe->CancelSpaceAvailable();
   195 	else if ( CancelFlag == 0)
   196 		data.rPipe->CancelDataAvailable();
   197 	else
   198 		test5.Printf(_L("PIPE TEST: *** Illegal Cancel\n"));
   199 
   200 	test5.Printf(_L("PIPE TEST:CancelNotifyThread Exit\n"));
   201 	test5.End();
   202 	test5.Close();
   203 	return KErrNone;
   204 }
   205 
   206 ////////////////////////////////////////////////////
   207 //// Main Thread
   208 ////
   209 ////
   210 ////////////////////////////////////////////////////
   211 /*
   212 
   213 
   214 1. Create 5 (UN)Pipes.
   215 2. Register NotifyData AVailable on 5 pipes.
   216 3. Create Thread 1
   217 4. Wait for n request.
   218 5. In thread 1 write data into any one pipe. Exit
   219 6. Main should show 1 stat variable updated.
   220 
   221 7. Again call Wait for n request.
   222 8. It shall come out as one stat is Available.
   223 
   224 9. Close all the pipes. Repeat same for NotifySpace available.
   225 
   226 10. Define 5 N-Pipes
   227 11. Open write end and call wait till read end open.
   228 12. Create thread 2
   229 12. Wait for n request
   230 13. In thread 2 , open read end of one of the pipe.
   231 14. Main should show 1 stat variable updated.
   232 
   233 15. Again call Wait for n request.
   234 16. It shall come out as one stat is Available.
   235 
   236 17. Close all the pipes. Destroy pipes.
   237 
   238 18. Create 3 N pipe and 2 UN pipes.
   239 19. Register 2 NDA , 2 NSA , 2 Read end wait.
   240 20. Create thread 3 make any request successful.
   241 
   242 
   243 */
   244 
   245 LOCAL_C void test_MainThread()
   246 {
   247 
   248 		RPipe			aReader1,aWriter1;			// Used to pass to thread.
   249 		RPipe			aReader2,aWriter2;			// Used to pass to thread.
   250 		RPipe			aReader3,aWriter3;			// Used to pass to thread.
   251 		RPipe			aReader4,aWriter4;			// Used to pass to thread.
   252 		RPipe			aReader5,aWriter5;			// Used to pass to thread.
   253 
   254 		TInt			ret,aSize;
   255 		RThread			thread2;
   256 		RThread			thread3;
   257 		RThread			thread4;
   258 		RThread			thread5;
   259 
   260 		TRequestStatus	stat1;
   261 		TRequestStatus	stat2;
   262 		TRequestStatus	stat3;
   263 		TRequestStatus	stat4;
   264 		TRequestStatus	stat5;
   265 
   266 		TRequestStatus	s;
   267 
   268 		TRequestStatus	*ReqArray[] =
   269 		{
   270 			&stat1,&stat2,&stat3,&stat4,&stat5
   271 		};
   272 		const TBufC<100> 		cPipeName1(KPipe1Name);
   273 		TBufC8<50> 				cTestData(KTestDataNum); 	// Test Data
   274 
   275 
   276 
   277 		test.Printf(_L("PIPE TEST:Main Thread Entry\n"));
   278 
   279 //Test	1:
   280 
   281 		aSize = 10;
   282 		// Create 5 Pipes.
   283 		ret = RPipe::Create( aSize,	aReader1,aWriter1,EOwnerProcess, EOwnerProcess);
   284 		test_KErrNone(ret);
   285 		ret = RPipe::Create( aSize,	aReader2,aWriter2,EOwnerProcess, EOwnerProcess);
   286 		test_KErrNone(ret);
   287 		ret = RPipe::Create( aSize,	aReader3,aWriter3,EOwnerProcess, EOwnerProcess);
   288 		test_KErrNone(ret);
   289 		ret = RPipe::Create( aSize,	aReader4,aWriter4,EOwnerProcess, EOwnerProcess);
   290 		test_KErrNone(ret);
   291 		ret = RPipe::Create( aSize,	aReader5,aWriter5,EOwnerProcess, EOwnerProcess);
   292 		test_KErrNone(ret);
   293 		// Register Notification for Data Available for all 5 pipes.
   294 		aReader1.NotifyDataAvailable(stat1);
   295 		aReader2.NotifyDataAvailable(stat2);
   296 		aReader3.NotifyDataAvailable(stat3);
   297 		aReader4.NotifyDataAvailable(stat4);
   298 		aReader5.NotifyDataAvailable(stat5);
   299 
   300 
   301 		// Pass handles for Pipe# 3
   302 		TData data1(&aReader3,&aWriter3,aSize);
   303 
   304 		// Create thread for Writing data into pipe.
   305 		// This will make status variable of respective pipe as AVAILABLE
   306 		ret = thread3.Create(
   307 								KThread3Name, 		// Thread name
   308 								NotifyDataThread,			// Function to be called
   309 								KDefaultStackSize,
   310 								KHeapSize,
   311 								KHeapSize,
   312 								(TAny *)&data1		// Data object containing Pipe information.
   313 							);
   314 		test_KErrNone(ret);
   315 		thread3.Logon(s);
   316 		test_Equal(KRequestPending, s.Int());
   317 
   318 		// Start the Thread
   319 		thread3.Resume();
   320 
   321 		// Wait till any of the request status is Avaialble
   322 		User::WaitForNRequest(ReqArray,5);
   323 
   324 		// As WaitForNRequest returned. This proves test pass.
   325 		test.Printf(_L("PIPE TEST:Test 1: Pass\n"));
   326 
   327 		// Cancel all pending requests for other tests.
   328 		aReader1.CancelDataAvailable();
   329 		aReader2.CancelDataAvailable();
   330 		aReader3.CancelDataAvailable();
   331 		aReader4.CancelDataAvailable();
   332 		aReader5.CancelDataAvailable();
   333 
   334 		// Close thread.
   335 		User::WaitForRequest(s);
   336 		CLOSE_AND_WAIT(thread3);
   337 
   338 
   339 //Test	2:
   340 
   341 		// Pipes created in Test 1.
   342 		// Write data into all the pipes and Fill it.
   343 		aWriter1.Write(cTestData,cTestData.Length());
   344 		aWriter2.Write(cTestData,cTestData.Length());
   345 		aWriter3.Write(cTestData,cTestData.Length());
   346 		aWriter4.Write(cTestData,cTestData.Length());
   347 		aWriter5.Write(cTestData,cTestData.Length());
   348 
   349 		// Register notification for Space availability for all pipes.
   350 			
   351 		aWriter1.NotifySpaceAvailable(aSize,stat1);
   352 		aWriter2.NotifySpaceAvailable(aSize,stat2);
   353 		aWriter3.NotifySpaceAvailable(aSize,stat3);
   354 		aWriter4.NotifySpaceAvailable(aSize,stat4);
   355 		aWriter5.NotifySpaceAvailable(aSize,stat5);
   356 
   357 
   358 		// Create data object for Pipe# 5.
   359 		TData data2(&aReader5,&aWriter5,aSize);
   360 
   361 		// Create thread which will make space available in Pipe.
   362 		//
   363 		ret = thread4.Create(
   364 								KThread4Name, 		// Thread name
   365 								NotifySpaceThread,			// Function to be called
   366 								KDefaultStackSize,
   367 								KHeapSize,
   368 								KHeapSize,
   369 								(TAny *)&data2		// Data object containing Pipe information.
   370 							);
   371 		test_KErrNone(ret);
   372 		thread4.Logon(s);
   373 		test_Equal(KRequestPending, s.Int());
   374 
   375 		// Start the thread.
   376 		thread4.Resume();
   377 
   378 		// Wait till any of the status variable status change to Avaialble
   379 		User::WaitForNRequest(ReqArray,5);
   380 
   381 		test.Printf(_L("PIPE TEST:Test 2: Pass\n"));
   382 
   383 		// Cancel all pending requests.
   384 		aWriter1.CancelSpaceAvailable();
   385 		aWriter2.CancelSpaceAvailable();
   386 		aWriter3.CancelSpaceAvailable();
   387 		aWriter4.CancelSpaceAvailable();
   388 		aWriter5.CancelSpaceAvailable();
   389 
   390 		// Close the thread.
   391 		User::WaitForRequest(s);
   392 		CLOSE_AND_WAIT(thread4);
   393 
   394 //Test	3:
   395 		// Flush all the Pipes.
   396 		// This is needed for NotifyDataAvailable request.
   397 		aReader1.Flush();
   398 		aReader2.Flush();
   399 		aReader3.Flush();
   400 		aReader4.Flush();
   401 		aReader5.Flush();
   402 
   403 		// Register NotifyDataAvailable request for all the pipes.
   404 		
   405 		CancelFlag = 0;	// 0 = CanceldataAvailable()
   406 		aReader1.NotifyDataAvailable(stat1);
   407 		aReader2.NotifyDataAvailable(stat2);
   408 		aReader3.NotifyDataAvailable(stat3);
   409 		aReader4.NotifyDataAvailable(stat4);
   410 		aReader5.NotifyDataAvailable(stat5);
   411 
   412 		TData data3(&aReader2,&aWriter2,aSize);
   413 
   414 		ret = thread5.Create(
   415 								KThread5Name, 		// Thread name
   416 								CancelNotifyThread,			// Function to be called
   417 								KDefaultStackSize,
   418 								KHeapSize,
   419 								KHeapSize,
   420 								(TAny *)&data3		// Data object containing Pipe information.
   421 							);
   422 		test_KErrNone(ret);
   423 		thread5.Logon(s);
   424 		test_Equal(KRequestPending, s.Int());
   425 		thread5.Resume();
   426 
   427 		User::WaitForNRequest(ReqArray,5);
   428 
   429 		test.Printf(_L("PIPE TEST:Test 3: Pass\n"));
   430 		aReader1.CancelDataAvailable();
   431 		aReader2.CancelDataAvailable();
   432 		aReader3.CancelDataAvailable();
   433 		aReader4.CancelDataAvailable();
   434 		aReader5.CancelDataAvailable();
   435 		User::WaitForRequest(s);
   436 		CLOSE_AND_WAIT(thread5);
   437 
   438 
   439 //Test	4:
   440 		aReader1.Close();
   441 		aWriter1.Close();
   442 		aReader2.Close();
   443 		aWriter2.Close();
   444 		aReader3.Close();
   445 		aWriter3.Close();
   446 		aReader4.Close();
   447 		aWriter4.Close();
   448 		aReader5.Close();
   449 		aWriter5.Close();
   450 
   451 		ret = RPipe::Define(KPipe1Name,aSize);
   452 		test_KErrNone(ret);
   453 		ret = RPipe::Define(KPipe2Name,aSize);
   454 		test_KErrNone(ret);
   455 		ret = RPipe::Define(KPipe3Name,aSize);
   456 		test_KErrNone(ret);
   457 		ret = RPipe::Define(KPipe4Name,aSize);
   458 		test_KErrNone(ret);
   459 		ret = RPipe::Define(KPipe5Name,aSize);
   460 		test_KErrNone(ret);
   461 
   462 		aWriter1.Open(KPipe1Name,RPipe::EOpenToWrite);
   463 		aWriter2.Open(KPipe2Name,RPipe::EOpenToWrite);
   464 		aWriter3.Open(KPipe3Name,RPipe::EOpenToWrite);
   465 		aWriter4.Open(KPipe4Name,RPipe::EOpenToWrite);
   466 		aWriter5.Open(KPipe5Name,RPipe::EOpenToWrite);
   467 
   468 		aWriter1.Wait(KPipe1Name,stat1);
   469 		aWriter2.Wait(KPipe2Name,stat2);
   470 		aWriter3.Wait(KPipe3Name,stat3);
   471 		aWriter4.Wait(KPipe4Name,stat4);
   472 		aWriter5.Wait(KPipe5Name,stat5);
   473 
   474 		const TBufC<100> 		cPipeName2(KPipe2Name);
   475 
   476 		TData data4(&aReader2,&aWriter2,aSize);
   477 		cPipeName = cPipeName2;
   478 
   479 		ret = thread2.Create(
   480 								KThread2Name, 		// Thread name
   481 								WaitThread,			// Function to be called
   482 								KDefaultStackSize,
   483 								KHeapSize,
   484 								KHeapSize,
   485 								(TAny *)&data4		// Data object containing Pipe information.
   486 							);
   487 		test_KErrNone(ret);
   488 		thread2.Logon(s);
   489 		test_Equal(KRequestPending, s.Int());
   490 		thread2.Resume();
   491 		User::WaitForNRequest(ReqArray,5);
   492 		test.Printf(_L("PIPE TEST:Test 4: Pass\n"));
   493 		aWriter1.CancelWait();
   494 		aWriter2.CancelWait();
   495 		aWriter3.CancelWait();
   496 		aWriter4.CancelWait();
   497 		aWriter5.CancelWait();
   498 
   499 		aReader1.Close();		aWriter1.Close();
   500 		aReader2.Close();		aWriter2.Close();
   501 		aReader3.Close();		aWriter3.Close();
   502 		aReader4.Close();		aWriter4.Close();
   503 		aReader5.Close();		aWriter5.Close();
   504 
   505 		User::WaitForRequest(s);
   506 		CLOSE_AND_WAIT(thread2);
   507 
   508 //Test	5:
   509 
   510 		ret =aWriter1.Open(KPipe1Name,RPipe::EOpenToWrite);
   511 		test_KErrNone(ret);
   512 		aReader1.Close();
   513 		//ret =aWriter1.Wait(KPipe1Name,stat1);
   514 		aWriter1.Wait(KPipe1Name,stat1);
   515 
   516 		ret =aWriter2.Open(KPipe2Name,RPipe::EOpenToWrite);
   517 		test_KErrNone(ret);
   518 		ret =aReader2.Open(KPipe2Name,RPipe::EOpenToRead);
   519 		test_KErrNone(ret);
   520 		ret =aWriter2.Write(cTestData,cTestData.Length());
   521 		//ret =aWriter2.NotifySpaceAvailable(aSize,stat2);
   522 		aWriter2.NotifySpaceAvailable(aSize,stat2);
   523 
   524 		ret = RPipe::Create( aSize,	aReader3,aWriter3,EOwnerProcess, EOwnerProcess);
   525 		test_KErrNone(ret);
   526 		aReader3.Flush();
   527 		//ret =aReader3.NotifyDataAvailable(stat3);
   528 		aReader3.NotifyDataAvailable(stat3);
   529 
   530 		ret = RPipe::Create( aSize,	aReader4,aWriter4,EOwnerProcess, EOwnerProcess);
   531 		test_KErrNone(ret);
   532 		ret =aWriter4.Write(cTestData,cTestData.Length());
   533 		//ret =aWriter4.NotifySpaceAvailable(aSize,stat4);
   534 		aWriter4.NotifySpaceAvailable(aSize,stat4);
   535 
   536 		ret = RPipe::Create( aSize,	aReader5,aWriter5,EOwnerProcess, EOwnerProcess);
   537 		test_KErrNone(ret);
   538 		aReader5.Flush();
   539 		//ret =aReader5.NotifyDataAvailable(stat5);
   540 		aReader5.NotifyDataAvailable(stat5);
   541 
   542 		TData data5(&aReader3,&aWriter3,aSize);
   543 		cPipeName = cPipeName2;
   544 
   545 		RThread thread6;
   546 
   547 		ret = thread6.Create(
   548 								KThread3Name, 		// Thread name
   549 								NotifyDataThread,			// Function to be called
   550 								KDefaultStackSize,
   551 								KHeapSize,
   552 								KHeapSize,
   553 								(TAny *)&data5		// Data object containing Pipe information.
   554 							);
   555 		test_KErrNone(ret);
   556 		thread6.Logon(s);
   557 		test_Equal(KRequestPending, s.Int());
   558 		thread6.Resume();
   559 		User::WaitForNRequest(ReqArray,5);
   560 		test.Printf(_L("PIPE TEST:Test 5: Pass\n"));
   561 
   562 		User::WaitForRequest(s);
   563 		CLOSE_AND_WAIT(thread6);
   564 //Test	6:
   565 
   566 		TData data6(&aReader2,&aWriter2,aSize);
   567 		cPipeName = cPipeName2;
   568 
   569 		RThread thread7;
   570 
   571 		ret = thread7.Create(
   572 								KThread3Name, 		// Thread name
   573 								NotifySpaceThread,			// Function to be called
   574 								KDefaultStackSize,
   575 								KHeapSize,
   576 								KHeapSize,
   577 								(TAny *)&data6		// Data object containing Pipe information.
   578 							);
   579 		test_KErrNone(ret);
   580 		thread7.Logon(s);
   581 		test_Equal(KRequestPending, s.Int());
   582 		thread7.Resume();
   583 
   584 		User::WaitForNRequest(ReqArray,5);
   585 		test.Printf(_L("PIPE TEST:Test 6: Pass\n"));
   586 
   587 
   588 		User::WaitForRequest(s);
   589 		CLOSE_AND_WAIT(thread7);
   590 
   591 //Test	7:
   592 		TData data7(&aReader1,&aWriter1,aSize);
   593 		cPipeName = cPipeName1;
   594 
   595 		RThread thread8;
   596 
   597 		ret = thread8.Create(
   598 								KThread2Name, 		// Thread name
   599 								WaitThread,			// Function to be called
   600 								KDefaultStackSize,
   601 								KHeapSize,
   602 								KHeapSize,
   603 								(TAny *)&data7		// Data object containing Pipe information.
   604 							);
   605 		test_KErrNone(ret);
   606 		thread8.Logon(s);
   607 		test_Equal(KRequestPending, s.Int());
   608 		thread8.Resume();
   609 
   610 		User::WaitForNRequest(ReqArray,5);
   611 		test.Printf(_L("PIPE TEST:Test 7: Pass\n"));
   612 
   613 
   614 		User::WaitForRequest(s);
   615 //		CLOSE_AND_WAIT(thread8);	DOESN'T WORK SINCE PIPE DRIVER KEEPS THE THREAD OPEN
   616 		thread8.Close();
   617 
   618 //Test	8:
   619 		TData data8(&aReader4,&aWriter4,aSize);
   620 
   621 		RThread thread9;
   622 		
   623 		CancelFlag = 1;	// 1 = CancelSpaceAvailable()
   624 
   625 		ret = thread9.Create(
   626 								KThread4Name, 		// Thread name
   627 								CancelNotifyThread,			// Function to be called
   628 								KDefaultStackSize,
   629 								KHeapSize,
   630 								KHeapSize,
   631 								(TAny *)&data8		// Data object containing Pipe information.
   632 							);
   633 		test_KErrNone(ret);
   634 		thread9.Logon(s);
   635 		test_Equal(KRequestPending, s.Int());
   636 		thread9.Resume();
   637 
   638 		User::WaitForNRequest(ReqArray,5);
   639 		test.Printf(_L("PIPE TEST:Test 8: Pass\n"));
   640 
   641 		User::WaitForRequest(s);
   642 		CLOSE_AND_WAIT(thread9);
   643 
   644 //Test	9:
   645 		TData data9(&aReader5,&aWriter5,aSize);
   646 
   647 		RThread thread10;
   648 
   649 		CancelFlag = 0;	// 0 = CancelDataAvailable()
   650 
   651 		ret = thread10.Create(
   652 								KThread5Name, 		// Thread name
   653 								CancelNotifyThread,			// Function to be called
   654 								KDefaultStackSize,
   655 								KHeapSize,
   656 								KHeapSize,
   657 								(TAny *)&data9		// Data object containing Pipe information.
   658 							);
   659 		test_KErrNone(ret);
   660 		thread10.Logon(s);
   661 		test_Equal(KRequestPending, s.Int());
   662 		thread10.Resume();
   663 
   664 		
   665 		User::WaitForNRequest(ReqArray,5);
   666 		test.Printf(_L("PIPE TEST:Test 9: Pass\n"));
   667 
   668 		User::WaitForRequest(s);
   669 		CLOSE_AND_WAIT(thread10);
   670 
   671 
   672 		aReader1.Close();		aWriter1.Close();
   673 		aReader2.Close();		aWriter2.Close();
   674 		aReader3.Close();		aWriter3.Close();
   675 		aReader4.Close();		aWriter4.Close();
   676 		aReader5.Close();		aWriter5.Close();
   677 		ret = RPipe::Destroy(KPipe1Name);
   678 		test_KErrNone(ret);
   679 		ret = RPipe::Destroy(KPipe2Name);
   680 		test_KErrNone(ret);
   681 		ret = RPipe::Destroy(KPipe3Name);
   682 		test_KErrNone(ret);
   683 		ret = RPipe::Destroy(KPipe4Name);
   684 		test_KErrNone(ret);
   685 		ret = RPipe::Destroy(KPipe5Name);
   686 		test_KErrNone(ret);
   687 		
   688 		
   689 		test.Printf(_L("PIPE TEST:Main Thread Exit\n"));
   690 		return;
   691 
   692 
   693 
   694 }
   695 
   696 ////////////////////////////////////////////////////
   697 //// RunTests:
   698 ////
   699 ////
   700 ////////////////////////////////////////////////////
   701 LOCAL_C void RunTests(void)
   702 {
   703 
   704 	test.Start(_L("PIPE TEST: Testing WaitForNRequest"));
   705 
   706 	test_MainThread();
   707 
   708 	test.Printf(_L("PIPE TEST: Ending test.\n"));
   709 
   710 	test.End();
   711 	test.Close();
   712 	return;
   713 }
   714 
   715 
   716 ////////////////////////////////////////////////////
   717 //// E32Main : Main entry point to test.
   718 ////
   719 ////
   720 ////////////////////////////////////////////////////
   721 
   722 
   723 GLDEF_C TInt E32Main()
   724 
   725 {
   726 	TInt		ret = 0;
   727 
   728 	ret = RPipe::Init();
   729 	
   730 	if (ret != KErrNone && ret != KErrAlreadyExists)
   731 	{
   732 	test.Printf(_L(" t_pipe4.exe PIPE TEST: Error loading driver %d\n"),ret);
   733 	test.Printf(_L(" Exiting t_pipe4.exe\n"));
   734 
   735 	return KErrNone;
   736 
   737 	}
   738 	RunTests();
   739 
   740 	TName pddName1(RPipe::Name());
   741 	
   742 	ret= User::FreeLogicalDevice(pddName1);
   743 	
   744 	return KErrNone;
   745 	
   746 }