Mercurial Mercurial > oss > FCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
kerneltest/e32test/demandpaging/t_svrpinning.cpp
branchRCL_3
changeset 294 039a3e647356
parent 249 a179b74831c9
equal deleted inserted replaced
268:345b1ca54e88 294:039a3e647356 
    70 	{
 
    70 	{
 
    71 public:
 
    71 public:
 
    72 	enum TTestMode
 
    72 	enum TTestMode
 
    73 		{
 
    73 		{
 
    74 		EStop,
 
    74 		EStop,
 
    75 		ETestRdPinAll,
 
    75 		ETestPinAll,
 
    76 		ETestRdUnpin3,
 
    76 		ETestPinEven,
 
    77 		ETestRdUnpin2,
 
    77 		ETestPinOdd,
 
    78 		ETestRdUnpin1,
 
    78 		ETestPin3,
 
    79 		ETestRdUnpin0,
 
    79 		ETestPin2,
 
    80 		ETestWrPinAll,
 
    80 		ETestPin1,
 
    81 		ETestWrPinNone,
 
    81 		ETestPin0,
 
       
    82 		ETestPinWritable,
 
       
    83 		ETestUnpinWritable,
 
    82 		ETestPinOOM,
 
    84 		ETestPinOOM,
 
    83 		ETestPinDefault,
 
    85 		ETestPinDefault,
 
    84 		ETestDeadServer,
 
    86 		ETestDeadServer,
 
    85 		};
 
    87 		};
 
    86 //Override pure virtual
 
    88 //Override pure virtual
 
   152 RSemaphore gSem;
 
   154 RSemaphore gSem;
 
   153 RSemaphore gSem1;
 
   155 RSemaphore gSem1;
 
   154 
   156 
   155 TInt CTestSession::CheckDesPresent(const RMessage2& aMessage, TUint aArgIndex, TBool aExpected, TBool aWrite)
 
   157 TInt CTestSession::CheckDesPresent(const RMessage2& aMessage, TUint aArgIndex, TBool aExpected, TBool aWrite)
 
   156 	{
 
   158 	{
 
   157 	TRequestStatus clientStat;
 
       
   158 	
       
   159 	if (aExpected)
 
   159 	if (aExpected)
 
   160 		{
 
       
   161 		RDebug::Printf("  Checking message argument at %d is present", aArgIndex);
 
   160 		RDebug::Printf("  Checking message argument at %d is present", aArgIndex);
 
   162 		}
 
       
   163 	else
 
   161 	else
 
   164 		{
 
       
   165 		RDebug::Printf("  Checking message argument at %d is not present", aArgIndex);
 
   162 		RDebug::Printf("  Checking message argument at %d is not present", aArgIndex);
 
   166 		// Start watching for client thread death
 
   163 
   167 		RThread clientThread;
 
       
   168 		aMessage.Client(clientThread);
 
       
   169 		clientThread.Logon(clientStat);
 
       
   170 		clientThread.Close();
 
       
   171 		}
 
       
   172 		
       
   173 	// Get the length of the descriptor and verify it is as expected.
 
   164 	// Get the length of the descriptor and verify it is as expected.
 
   174 	TInt length = aMessage.GetDesLength(aArgIndex);
 
   165 	TInt length = aMessage.GetDesLength(aArgIndex);
 
   175 	if (length < KErrNone)
 
   166 	if (length < KErrNone)
 
   176 		{
 
   167 		{
 
   177 		RDebug::Printf("  Error getting descriptor length %d", length);
 
   168 		RDebug::Printf("  Error getting descriptor length %d", length);
 
   184 		}
 
   175 		}
 
   185 	if (!aWrite)
 
   176 	if (!aWrite)
 
   186 		{// Now read the descriptor and verify that it is present or not.
 
   177 		{// Now read the descriptor and verify that it is present or not.
 
   187 		TBuf8<5> des;
 
   178 		TBuf8<5> des;
 
   188 		TInt r = aMessage.Read(aArgIndex, des);
 
   179 		TInt r = aMessage.Read(aArgIndex, des);
 
   189 		if (r != (aExpected ? KErrNone : KErrBadDescriptor))
 
   180 		TBool pass;
 
       
   181 		if (iClientDied)
 
       
   182 			pass = r == KErrDied || r == KErrBadDescriptor;
 
       
   183 		else
 
       
   184 			pass = r == (aExpected ? KErrNone : KErrBadDescriptor);
 
       
   185 		if (!pass)
 
   190 			{
 
   186 			{
 
   191 			RDebug::Printf("  Unexpected value returned from aMessage.Read:%d", r);
 
   187 			RDebug::Printf("  Error reading descriptor data r %d", r);
 
   192 			return KErrGeneral;
 
   188 			return KErrGeneral;
 
   193 			}
 
   189 			}
 
   194 		if (r==KErrNone && (des[0] != 'a' || des[1] != 'r' || des[2] != 'g'))
 
   190 		if (r==KErrNone && (des[0] != 'a' || des[1] != 'r' || des[2] != 'g'))
 
   195 			{// The incorrect descriptor data has been passed.
 
   191 			{// The incorrect descriptor data has been passed.
 
   196 			RDebug::Printf("  Error in descriptor data is corrupt r %d", r);
 
   192 			RDebug::Printf("  Error in descriptor data is corrupt r %d", r);
 
   209 		TPtr8 argPtr = argTmp->Des();
 
   205 		TPtr8 argPtr = argTmp->Des();
 
   210 		argPtr.SetLength(max);
 
   206 		argPtr.SetLength(max);
 
   211 		for (TInt i = 0; i < max; i++)
 
   207 		for (TInt i = 0; i < max; i++)
 
   212 			argPtr[i] = (TUint8)aArgIndex;
 
   208 			argPtr[i] = (TUint8)aArgIndex;
 
   213 		TInt r = aMessage.Write(aArgIndex, argPtr);
 
   209 		TInt r = aMessage.Write(aArgIndex, argPtr);
 
   214 		if (r != (aExpected ? KErrNone : KErrBadDescriptor))
 
   210 		TBool pass;
 
       
   211 		if (iClientDied)
 
       
   212 			pass = r == KErrDied || r == KErrBadDescriptor;
 
       
   213 		else
 
       
   214 			pass = r == (aExpected ? KErrNone : KErrBadDescriptor);
 
       
   215 		if (!pass)
 
   215 			{
 
   216 			{
 
   216 			RDebug::Printf("  Unexpected value returned from aMessage.Write:%d", r);
 
   217 			RDebug::Printf("  Error writing to the descriptor data r %d", r);
 
   217 			return KErrGeneral;
 
   218 			return KErrGeneral;
 
   218 			}
 
   219 			}
 
   219 		}
 
   220 		}
 
   220 
   221 
   221 	if (!aExpected)
 
   222 	if (!aExpected)
 
   222 		{// The client should have been killed as the data wasn't present.
 
   223 		{// The client should have been killed as the data wasn't present.
 
   223 		RDebug::Printf("  CheckDesPresent: Waiting for client to die");
 
   224 		if(!iClientDied)
 
   224 		User::WaitForRequest(clientStat);
 
   225 			User::After(500000); // allow time for client to die before next test
 
   225 		iClientDied = ETrue;
 
   226 		iClientDied = ETrue;
 
   226 		RDebug::Printf("  CheckDesPresent: Client dead");
 
       
   227 		}
 
   227 		}
 
   228 	return KErrNone;
 
   228 	return KErrNone;
 
   229 	}
 
   229 	}
 
   230 
   230 
   231 TInt CTestSession::CheckArgsPresent(const RMessage2& aMessage, TBool arg0Present, TBool arg1Present, TBool arg2Present, TBool arg3Present, TBool aWrite=EFalse)
 
   231 TInt CTestSession::CheckArgsPresent(const RMessage2& aMessage, TBool arg0Present, TBool arg1Present, TBool arg2Present, TBool arg3Present, TBool aWrite=EFalse)
 
   241 	DPTest::FlushCache();
 
   241 	DPTest::FlushCache();
 
   242 
   242 
   243 	TInt r = User::SetRealtimeState(User::ERealtimeStateOn);
 
   243 	TInt r = User::SetRealtimeState(User::ERealtimeStateOn);
 
   244 	if (r != KErrNone)
 
   244 	if (r != KErrNone)
 
   245 		{
 
   245 		{
 
   246 		RDebug::Printf("CheckArgsPresent: Error setting realtime state r = %d", r);
 
   246 		RDebug::Printf("Error setting realtime state r = %d", r);
 
   247 		return r;
 
   247 		return r;
 
   248 		}
 
   248 		}
 
   249 
   249 
   250 	r = CheckDesPresent(aMessage, 0, arg0Present, aWrite);
 
   250 	r = CheckDesPresent(aMessage, 0, arg0Present, aWrite);
 
   251 	if ((r == KErrNone) && !iClientDied)
 
   251 	if (r == KErrNone)
 
   252 		r = CheckDesPresent(aMessage, 1, arg1Present, aWrite);
 
   252 		r = CheckDesPresent(aMessage, 1, arg1Present, aWrite);
 
   253 	if ((r == KErrNone) && !iClientDied)
 
   253 	if (r == KErrNone)
 
   254 		r = CheckDesPresent(aMessage, 2, arg2Present, aWrite);
 
   254 		r = CheckDesPresent(aMessage, 2, arg2Present, aWrite);
 
   255 	if ((r == KErrNone) && !iClientDied)
 
   255 	if (r == KErrNone)
 
   256 		r = CheckDesPresent(aMessage, 3, arg3Present, aWrite);
 
   256 		r = CheckDesPresent(aMessage, 3, arg3Present, aWrite);
 
   257 
   257 
   258 	User::SetRealtimeState(User::ERealtimeStateOff);
 
   258 	User::SetRealtimeState(User::ERealtimeStateOff);
 
   259 
   259 
   260 	return r;
 
   260 	return r;
 
   261 	}
 
   261 	}
 
   262 
   262 
   263 EXPORT_C void CTestSession::ServiceL(const RMessage2& aMessage)
 
   263 void CTestSession::ServiceL(const RMessage2& aMessage)
 
   264 //
 
   264 //
 
   265 // Virtual message-handler
 
   265 // Virtual message-handler
 
   266 //
 
   266 //
 
   267 	{
 
   267 	{
 
   268 	TInt r = KErrNone;
 
   268 	TInt r = KErrNone;
 
   270 	switch (aMessage.Function())
 
   270 	switch (aMessage.Function())
 
   271 		{
 
   271 		{
 
   272 		case EStop:
 
   272 		case EStop:
 
   273 			CActiveScheduler::Stop();
 
   273 			CActiveScheduler::Stop();
 
   274 			break;
 
   274 			break;
 
   275 		case ETestRdPinAll:
 
   275 		case ETestPinAll:
 
   276 			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, ETrue);
 
   276 			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, ETrue);
 
   277 			break;
 
   277 			break;
 
   278 		case ETestRdUnpin3:
 
   278 		case ETestPinOdd:
 
       
   279 			r = CheckArgsPresent(aMessage, EFalse, ETrue, EFalse, ETrue);
 
       
   280 			break;
 
       
   281 		case ETestPinEven:
 
       
   282 			r = CheckArgsPresent(aMessage, ETrue, EFalse, ETrue, EFalse);
 
       
   283 			break;
 
       
   284 		case ETestPin3:
 
   279 			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, EFalse);
 
   285 			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, EFalse);
 
   280 			break;
 
   286 			break;
 
   281 		case ETestRdUnpin2:
 
   287 		case ETestPin2:
 
   282 			r = CheckArgsPresent(aMessage, ETrue, ETrue, EFalse, ETrue);
 
   288 			r = CheckArgsPresent(aMessage, ETrue, ETrue, EFalse, EFalse);
 
   283 			break;
 
   289 			break;
 
   284 		case ETestRdUnpin1:
 
   290 		case ETestPin1:
 
   285 			r = CheckArgsPresent(aMessage, ETrue,  EFalse,  ETrue, ETrue);
 
   291 			r = CheckArgsPresent(aMessage, ETrue, EFalse, EFalse, EFalse);
 
   286 			break;
 
   292 			break;
 
   287 		case ETestRdUnpin0:
 
   293 		case ETestPin0:
 
   288 			r = CheckArgsPresent(aMessage, EFalse, ETrue, ETrue, ETrue);
 
       
   289 			break;
 
       
   290 		case ETestPinDefault:
 
   294 		case ETestPinDefault:
 
   291 			r = CheckArgsPresent(aMessage, EFalse, EFalse, EFalse, EFalse);
 
   295 			r = CheckArgsPresent(aMessage, EFalse, EFalse, EFalse, EFalse);
 
   292 			break;
 
   296 			break;
 
   293 		case ETestWrPinAll:
 
   297 		case ETestPinWritable:
 
   294 			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, ETrue, ETrue);
 
   298 			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, ETrue, ETrue);
 
   295 			break;
 
   299 			break;
 
   296 		case ETestWrPinNone:
 
   300 		case ETestUnpinWritable:
 
   297 			r = CheckArgsPresent(aMessage, EFalse, EFalse, EFalse, EFalse, ETrue);
 
   301 			r = CheckArgsPresent(aMessage, EFalse, EFalse, EFalse, EFalse, ETrue);
 
   298 			break;
 
   302 			break;
 
   299 		default:
 
   303 		default:
 
   300 			RDebug::Printf("CTestSession::ServiceL Unsupported Function: %d", aMessage.Function());
 
       
   301 			r = KErrNotSupported;
 
   304 			r = KErrNotSupported;
 
   302 
   305 
   303 		}
 
   306 		}
 
   304  	aMessage.Complete(r);
 
   307  	aMessage.Complete(r);
 
   305 
   308 
   442 		test(0);
 
   445 		test(0);
 
   443 		}
 
   446 		}
 
   444 
   447 
   445 	switch((TInt)aTestMode)
 
   448 	switch((TInt)aTestMode)
 
   446 		{
 
   449 		{
 
   447 		case CTestSession::ETestRdPinAll:
 
   450 		case CTestSession::ETestPinAll:
 
   448 			test.Printf(_L("Test pinning all args\n"));
 
   451 			test.Printf(_L("Test pinning all args\n"));
 
   449 			r = session.PublicSendReceive(CTestSession::ETestRdPinAll, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs());
 
   452 			r = session.PublicSendReceive(CTestSession::ETestPinAll, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs());
 
   450 			break;
 
   453 			break;
 
   451 
   454 
   452 		case CTestSession::ETestRdUnpin3:
 
   455 		case CTestSession::ETestPinOdd:
 
   453 			test.Printf(_L("Read Arg3 unpinned\n"));
 
   456 			test.Printf(_L("Test pinning odd args\n"));
 
   454 			r = session.PublicSendReceive(CTestSession::ETestRdUnpin3, TIpcArgs(&arg0, argTmp, &argTmpBuf, &arg3).PinArgs(ETrue, ETrue, ETrue, EFalse));
 
   457 			r = session.PublicSendReceive(CTestSession::ETestPinOdd, TIpcArgs(&arg0, &argTmpBuf, &arg2, &arg3).PinArgs(EFalse, ETrue, EFalse, ETrue));
 
   455 			break;
 
   458 			break;
 
   456 
   459 
   457 		case CTestSession::ETestRdUnpin2:
 
   460 		case CTestSession::ETestPinEven:
 
   458 			test.Printf(_L("Read Arg2 unpinned\n"));
 
   461 			test.Printf(_L("Test pinning even args\n"));
 
   459 			r = session.PublicSendReceive(CTestSession::ETestRdUnpin2, TIpcArgs(argTmp, &arg1, &arg2, &arg3).PinArgs(ETrue, ETrue, EFalse,  ETrue));
 
   462 			r = session.PublicSendReceive(CTestSession::ETestPinEven, TIpcArgs(&arg0, &arg1, argTmp, &arg3).PinArgs(ETrue, EFalse, ETrue, EFalse));
 
   460 			break;
 
   463 			break;
 
   461 
   464 
   462 		case CTestSession::ETestRdUnpin1:
 
   465 		case CTestSession::ETestPin3:
 
   463 			test.Printf(_L("Read Arg1 unpinned\n"));
 
   466 			test.Printf(_L("Test pinning 3 args\n"));
 
   464 			r = session.PublicSendReceive(CTestSession::ETestRdUnpin1, TIpcArgs(&argTmpBuf, &arg1, &arg2, &arg3).PinArgs(ETrue, EFalse,  ETrue,  ETrue));
 
   467 			r = session.PublicSendReceive(CTestSession::ETestPin3, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs(ETrue, ETrue, ETrue, EFalse));
 
   465 			break;
 
   468 			break;
 
   466 
   469 
   467 		case CTestSession::ETestRdUnpin0:
 
   470 		case CTestSession::ETestPin2:
 
   468 			test.Printf(_L("Read Arg0 unpinned\n"));
 
   471 			test.Printf(_L("Test pinning 2 args\n"));
 
   469 			r = session.PublicSendReceive(CTestSession::ETestRdUnpin0, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs(EFalse, ETrue, ETrue, ETrue));
 
   472 			r = session.PublicSendReceive(CTestSession::ETestPin2, TIpcArgs(argTmp, &arg1, &arg2, &arg3).PinArgs(ETrue, ETrue, EFalse, EFalse));
 
       
   473 			break;
 
       
   474 
       
   475 		case CTestSession::ETestPin1:
 
       
   476 			test.Printf(_L("Test pinning 1 args\n"));
 
       
   477 			r = session.PublicSendReceive(CTestSession::ETestPin1, TIpcArgs(&argTmpBuf, &arg1, &arg2, &arg3).PinArgs(ETrue, EFalse, EFalse, EFalse));
 
       
   478 			break;
 
       
   479 
       
   480 		case CTestSession::ETestPin0:
 
       
   481 			test.Printf(_L("Test pinning 0 args\n"));
 
       
   482 			r = session.PublicSendReceive(CTestSession::ETestPin0, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs(EFalse, EFalse, EFalse, EFalse));
 
   470 			break;
 
   483 			break;
 
   471 
   484 
   472 		case CTestSession::ETestPinDefault:
 
   485 		case CTestSession::ETestPinDefault:
 
   473 			test.Printf(_L("Test the default pinning policy of this server\n"));
 
   486 			test.Printf(_L("Test the default pinning policy of this server\n"));
 
   474 			r = session.PublicSendReceive(CTestSession::ETestPinDefault, TIpcArgs(&arg0, &arg1, &arg2, argTmp));
 
   487 			r = session.PublicSendReceive(CTestSession::ETestPinDefault, TIpcArgs(&arg0, &arg1, &arg2, argTmp));
 
   475 			break;
 
   488 			break;
 
   476 
   489 
   477 		case CTestSession::ETestWrPinAll:
 
   490 		case CTestSession::ETestPinWritable:
 
   478 			test.Printf(_L("Test writing to pinned descriptors\n"));
 
   491 			test.Printf(_L("Test writing to pinned descriptors\n"));
 
   479 			r = session.PublicSendReceive(CTestSession::ETestWrPinAll, TIpcArgs(&arg0, &arg3, &arg4, &arg5).PinArgs(ETrue, ETrue, ETrue, ETrue));
 
   492 			r = session.PublicSendReceive(CTestSession::ETestPinWritable, TIpcArgs(&arg0, &arg3, &arg4, &arg5).PinArgs(ETrue, ETrue, ETrue, ETrue));
 
   480 			// Verify the index of each argument has been written to each descriptor.
 
   493 			// Verify the index of each argument has been written to each descriptor.
 
   481 			{
 
   494 			{
 
   482 			TUint maxLength = arg0.MaxLength();
 
   495 			TUint maxLength = arg0.MaxLength();
 
   483 			test_Equal(maxLength, arg0.Length());
 
   496 			test_Equal(maxLength, arg0.Length());
 
   484 			TUint j = 0;
 
   497 			TUint j = 0;
 
   497 			for (j = 0; j < maxLength; j++)
 
   510 			for (j = 0; j < maxLength; j++)
 
   498 				test_Equal(3, arg5[j]);
 
   511 				test_Equal(3, arg5[j]);
 
   499 			}
 
   512 			}
 
   500 			break;
 
   513 			break;
 
   501 
   514 
   502 		case CTestSession::ETestWrPinNone:
 
   515 		case CTestSession::ETestUnpinWritable:
 
   503 			test.Printf(_L("Test writing to unpinned descriptors\n"));
 
   516 			test.Printf(_L("Test writing to unpinned descriptors\n"));
 
   504 			r = session.PublicSendReceive(CTestSession::ETestWrPinNone, TIpcArgs(&arg0, &arg3, &arg4, &arg5).PinArgs(EFalse, EFalse, EFalse, EFalse));
 
   517 			r = session.PublicSendReceive(CTestSession::ETestUnpinWritable, TIpcArgs(&arg0, &arg3, &arg4, &arg5).PinArgs(EFalse, EFalse, EFalse, EFalse));
 
   505 			// Verify the index of each argument has been written to each descriptor.
 
   518 			// Verify the index of each argument has been written to each descriptor.
 
   506 			// Unless this is a pinnning server than the thread will be panicked before we reach there.
 
   519 			// Unless this is a pinnning server than the thread will be panicked before we reach there.
 
   507 			{
 
   520 			{
 
   508 			TUint maxLength = arg0.MaxLength();
 
   521 			TUint maxLength = arg0.MaxLength();
 
   509 			test_Equal(maxLength, arg0.Length());
 
   522 			test_Equal(maxLength, arg0.Length());
 
   527 
   540 
   528 		case CTestSession::ETestDeadServer:
 
   541 		case CTestSession::ETestDeadServer:
 
   529 			test.Printf(_L("Test pinning to dead server\n"));
 
   542 			test.Printf(_L("Test pinning to dead server\n"));
 
   530 			gSem.Signal();
 
   543 			gSem.Signal();
 
   531 			gSem1.Wait();
 
   544 			gSem1.Wait();
 
   532 			r = session.PublicSendReceive(CTestSession::ETestRdPinAll, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs());
 
   545 			r = session.PublicSendReceive(CTestSession::ETestPinAll, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs());
 
   533 			break;
 
   546 			break;
 
   534 
   547 
   535 		case CTestSession::ETestPinOOM:
 
   548 		case CTestSession::ETestPinOOM:
 
   536 			test.Printf(_L("Pinning OOM tests\n"));
 
   549 			test.Printf(_L("Pinning OOM tests\n"));
 
   537 			__KHEAP_MARK;
 
   550 			__KHEAP_MARK;
 
   539 			TUint i;
 
   552 			TUint i;
 
   540 			r = KErrNoMemory;
 
   553 			r = KErrNoMemory;
 
   541 			for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
 
   554 			for (i = 0; i < KMaxKernelAllocations && r == KErrNoMemory; i++)
 
   542 				{
 
   555 				{
 
   543 				__KHEAP_FAILNEXT(i);
 
   556 				__KHEAP_FAILNEXT(i);
 
   544 				r = session.PublicSendReceive(CTestSession::ETestRdPinAll, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs());
 
   557 				r = session.PublicSendReceive(CTestSession::ETestPinAll, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs());
 
   545 				__KHEAP_RESET;
 
   558 				__KHEAP_RESET;
 
   546 				}
 
   559 				}
 
   547 			test.Printf(_L("SendReceive took %d tries\n"),i);
 
   560 			test.Printf(_L("SendReceive took %d tries\n"),i);
 
   548 			test_KErrNone(r);
 
   561 			test_KErrNone(r);
 
   549 
   562 
   619 		// Wait for the server to start and then create a session to it.
 
   632 		// Wait for the server to start and then create a session to it.
 
   620 		gSem.Wait();
 
   633 		gSem.Wait();
 
   621 		RSession session;
 
   634 		RSession session;
 
   622 		test_KErrNone(session.PublicCreateSession(_L("CTestServer"),5));
 
   635 		test_KErrNone(session.PublicCreateSession(_L("CTestServer"),5));
 
   623 		
   636 		
   624 		for (	TUint clientTest = CTestSession::ETestRdPinAll; 
   637 		for (	TUint clientTest = CTestSession::ETestPinAll; 
   625 				clientTest <= CTestSession::ETestPinDefault && !exitFailure;
 
   638 				clientTest <= CTestSession::ETestPinDefault && !exitFailure;
 
   626 				clientTest++)
 
   639 				clientTest++)
 
   627 			{
 
   640 			{
 
   628 			// Create the client thread it needs to have a paged stack and heap.
 
   641 			// Create the client thread it needs to have a paged stack and heap.
 
   629 			TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)clientTest);
 
   642 			TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)clientTest);
 
   639 			// Wait for the client thread to end.
 
   652 			// Wait for the client thread to end.
 
   640 			User::WaitForRequest(clientStat);
 
   653 			User::WaitForRequest(clientStat);
 
   641 
   654 
   642 			// If all the descriptor arguments were not pinned then the client 
   655 			// If all the descriptor arguments were not pinned then the client 
   643 			// thread should have been panicked.
 
   656 			// thread should have been panicked.
 
   644 			TBool expectPanic = (clientTest == CTestSession::ETestRdPinAll || 
   657 			TBool expectPanic = (clientTest == CTestSession::ETestPinAll || 
   645 								clientTest == CTestSession::ETestWrPinAll ||
 
   658 								clientTest == CTestSession::ETestPinWritable ||
 
   646 								clientTest == CTestSession::ETestPinOOM )? 0 : 1;
 
   659 								clientTest == CTestSession::ETestPinOOM )? 0 : 1;
 
   647 			expectPanic = !UpdateExpected(!expectPanic);
 
   660 			expectPanic = !UpdateExpected(!expectPanic);
 
   648 
   661 
   649 			TInt exitReason = clientThread.ExitReason();
 
   662 			TInt exitReason = clientThread.ExitReason();
 
   650 			TInt exitType = clientThread.ExitType();
 
   663 			TInt exitType = clientThread.ExitType();
 
   651 			if (expectPanic)
 
   664 			if (expectPanic)
 
   652 				{
 
   665 				{
 
   653 				if (exitType != EExitPanic || 
   666 				if (exitType != EExitPanic || 
   654 					exitReason != EIllegalFunctionForRealtimeThread ||
 
   667 					exitReason != EIllegalFunctionForRealtimeThread ||
 
   655 					clientThread.ExitCategory() != _L("KERN-EXEC"))
 
   668 					clientThread.ExitCategory() != _L("KERN-EXEC"))
 
   656 					{
 
   669 					{// Thread didn't panic as expected.
 
   657 					test.Printf(_L("Thread didn't panic as expected\n"));
 
       
   658 					exitFailure = ETrue;
 
   670 					exitFailure = ETrue;
 
   659 					}
 
   671 					}
 
   660 				}
 
   672 				}
 
   661 			else
 
   673 			else
 
   662 				{
 
   674 				{
 
   663 				if (exitType != EExitKill || exitReason != KErrNone)
 
   675 				if (exitType != EExitKill || exitReason != KErrNone)
 
   664 					{
 
   676 					{// Thread didn't exit gracefully as expected.
 
   665 					test.Printf(_L("Thread didn't exit gracefully as expected\n"));
 
       
   666 					exitFailure = ETrue;
 
   677 					exitFailure = ETrue;
 
   667 					}
 
   678 					}
 
   668 				}
 
   679 				}
 
   669 			test(!exitFailure);
 
       
   670 			CLOSE_AND_WAIT(clientThread);
 
   680 			CLOSE_AND_WAIT(clientThread);
 
   671 			}
 
   681 			}
 
   672 
   682 
   673 		test.Next(_L("Test client sending message to closed server"));
 
   683 		test.Next(_L("Test client sending message to closed server"));
 
   674 		TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)CTestSession::ETestDeadServer);
 
   684 		TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)CTestSession::ETestDeadServer);
 
   685 		session.PublicSendReceive(CTestSession::EStop, TIpcArgs());
 
   695 		session.PublicSendReceive(CTestSession::EStop, TIpcArgs());
 
   686 		session.Close();
 
   696 		session.Close();
 
   687 		User::WaitForRequest(serverStat);
 
   697 		User::WaitForRequest(serverStat);
 
   688 		if (serverThread.ExitType() != EExitKill)
 
   698 		if (serverThread.ExitType() != EExitKill)
 
   689 			{
 
   699 			{
 
   690 			test.Printf(_L("!!Server thread did something bizarre %d\n"), serverThread.ExitReason());
 
   700 			test.Printf(_L("!!Server thread did something bizarre %d"), serverThread.ExitReason());
 
   691 			}
 
   701 			}
 
   692 
   702 
   693 		gSem1.Signal();
 
   703 		gSem1.Signal();
 
   694 		User::WaitForRequest(clientStat);
 
   704 		User::WaitForRequest(clientStat);
 
   695 		test_Equal(EExitKill, clientThread.ExitType());
 
   705 		test_Equal(EExitKill, clientThread.ExitType());
 
   698 		CLOSE_AND_WAIT(clientThread);
 
   708 		CLOSE_AND_WAIT(clientThread);
 
   699 		CLOSE_AND_WAIT(serverThread);
 
   709 		CLOSE_AND_WAIT(serverThread);
 
   700 		CLOSE_AND_WAIT(gSem);
 
   710 		CLOSE_AND_WAIT(gSem);
 
   701 		CLOSE_AND_WAIT(gSem1);
 
   711 		CLOSE_AND_WAIT(gSem1);
 
   702 		}
 
   712 		}
 
       
   713 	test(!exitFailure);
 
   703 
   714 
   704 	test.Next(_L("Test server setting pinning policy after server started"));
 
   715 	test.Next(_L("Test server setting pinning policy after server started"));
 
   705 	RThread serverThread;
 
   716 	RThread serverThread;
 
   706 	test_KErrNone(serverThread.Create(_L("Server Thread"),ServerThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize, (TAny*)gServerPinningState));
 
   717 	test_KErrNone(serverThread.Create(_L("Server Thread"),ServerThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize, (TAny*)gServerPinningState));
 
   707 	TRequestStatus serverStat;
 
   718 	TRequestStatus serverStat;
FCL/sf/os/kernelhwsrv