Convert Kernelhwsrv package from SFL to EPL
kernel\eka\compsupp is subject to the ARM EABI LICENSE
userlibandfileserver\fatfilenameconversionplugins\unicodeTables is subject to the Unicode license
kernel\eka\kernel\zlib is subject to the zlib license
// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32test\pipe\t_pipe.cpp
// Overview:
// Test pipe mechanism
// API Information:
// RPipe
// Details:
// - Create various leagal and illegal pipe and verify that pipe
// functionality works as stated in requirements.
// - Create Named and UnNamed Pipes and verify.
// - Test Pipes communication in multiprocess , multithreaded , single process
// single threaded environment.
// Platforms/Drives/Compatibility:
// All.
// Assumptions/Requirement/Pre-requisites:
// Refer Pipes design and requirement document.
// 1. SGL.GT0314.202 PREQ1460 Design Doc
// 2. SGL.GT0314.203 PREQ1460 Pipe Functional Specification
// Refer Pipe test specification document.
// 1. SGL.GT0314.601 Pipes_Test_Specifications
// Failures and causes:
// Base Port information:
// MMP File:
// t_pipe.mmp
//
//
/**
@STMTestCaseID KBASE-T_PIPE-0217
@SYMPREQ PREQ1460
@SYMREQ REQ6141
@SYMCR CR0923
@SYMTestCaseDesc Pipe functional tests
@SYMTestPriority High
@SYMTestActions Tests the functionality of the pipe. Success and failure tests are performed.
@SYMTestExpectedResults Test should pass
*/
#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <e32svr.h>
#include <e32des8.h>
#include <e32des8_private.h>
#include <e32cmn.h>
#include <e32cmn_private.h>
#include <e32math.h>
#include <hal.h>
#include "RPipe.h"
LOCAL_D RTest test(_L("t_pipe"));
//if the test is to run under the debugger, uncomment the following line
const TInt KHeapSize=0x2000;
// Test Data
_LIT8(KTestData,"Pipe Data To Be Passed");
_LIT8(KTestData1,"P");
_LIT8(KTestData2,"Pipe Data To Be Passed");
_LIT8(KTestData3,"ipe Data To Be Passed");
// Test Pipe Names
_LIT(KPipe1Name,"TestPipe1");
_LIT(KPipe3Name,"TestPipe3");
//Global semaphore name
_LIT(KSemaphoreName,"Semaphore1");
// Pipename of max pipe length 80 Charecters.
_LIT(KMaxPipeName,"abcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrst");
// PipeName of max pipe length plus one ,81 charecters
_LIT(KMaxPipeNamePlusOne,"abcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrstabcdefghijklmnopqrst1");
// Thread Name Constants
_LIT(KThread2Name, "thread2");
_LIT(KThread3Name, "thread3");
_LIT(KThread4Name, "thread4");
_LIT(KThread5Name, "thread5");
_LIT(KReaderThread, "ReaderThread");
_LIT(KWriterThread, "WriterThread");
_LIT(KThread8Name, "thread8");
_LIT(KThread9Name, "thread9");
_LIT(KThread11Name, "thread11");
// Test Process Name Constants
_LIT(KProcessName, "t_pipe2.exe");
// Following class is used to pass thread handle information to different threads.
class TData
{
public:
TData(RPipe* aReadEnd, RPipe *aWriteEnd);
TData(RPipe* aReadEnd, RPipe *aWriteEnd, const TDesC8* aPipeData, TInt aIterations=1);
RPipe* iReadEnd;
RPipe* iWriteEnd;
const TDesC8* iPipeData;
TInt iIterations;
};
TData::TData(RPipe* aReadEnd , RPipe *aWriteEnd)
:iReadEnd(aReadEnd),iWriteEnd(aWriteEnd), iPipeData(NULL), iIterations(NULL)
{}
TData::TData(RPipe* aReadEnd , RPipe *aWriteEnd, const TDesC8* aPipeData, TInt aIterations)
:iReadEnd(aReadEnd),iWriteEnd(aWriteEnd), iPipeData(aPipeData), iIterations(aIterations)
{}
/**
A utility class for running functions in other threads/processes
*/
class TTestRemote
{
public:
virtual TInt WaitForExitL()=0;
virtual ~TTestRemote()
{}
virtual void Rendezvous(TRequestStatus& aStatus) =0;
protected:
TTestRemote()
{}
static TInt RunFunctor(TAny* aFunctor)
{
TFunctor& functor = *(TFunctor*)aFunctor;
functor();
return KErrNone;
}
TRequestStatus iLogonStatus;
static TInt iCount;
};
TInt TTestRemote::iCount=0;
class TTestThread : public TTestRemote
{
public:
TTestThread(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume=ETrue)
{
Init(aName, aFn, aData, aAutoResume);
}
/**
Run aFunctor in another thread
*/
TTestThread(const TDesC& aName, TFunctor& aFunctor, TBool aAutoResume=ETrue)
{
Init(aName, RunFunctor, &aFunctor, aAutoResume);
}
~TTestThread()
{
//RTest::CloseHandleAndWaitForDestruction(iThread);
iThread.Close();
}
void Resume()
{
iThread.Resume();
}
/**
If thread exited normally, return its return code
Otherwise, leave with exit reason
*/
virtual TInt WaitForExitL()
{
User::WaitForRequest(iLogonStatus);
const TInt exitType = iThread.ExitType();
const TInt exitReason = iThread.ExitReason();
__ASSERT_ALWAYS(exitType != EExitPending, User::Panic(_L("TTestThread"),0));
if(exitType != EExitKill)
User::Leave(exitReason);
return exitReason;
}
virtual void Rendezvous(TRequestStatus& aStatus)
{
iThread.Rendezvous(aStatus);
}
private:
void Init(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume)
{
TKName name(aName);
name.AppendFormat(_L("-%d"), iCount++);
TInt r=iThread.Create(name, aFn, KDefaultStackSize, KHeapSize, KHeapSize, aData);
User::LeaveIfError(r);
iThread.Logon(iLogonStatus);
__ASSERT_ALWAYS(iLogonStatus == KRequestPending, User::Panic(_L("TTestThread"),0));
if(aAutoResume)
iThread.Resume();
}
RThread iThread;
};
/**
Non blocking reads, verifying data as expected
*/
TInt TestThread2(TAny* aData)
{
RTest test(_L("t_pipe_t2"));
test.Start(_L("Thread 2"));
test.Printf(_L("THREAD 2 called by TestMultiThreadNamedPipes And TestMultiThreadUnNamedPipes\n"));
TBuf8<50> cPipeReadData;
TInt ret,readsize;
TData& data = *(TData *)aData; // aData will have pipe handles and size.
test.Next(_L("PIPE TEST:Thread 2-1 Read 1 byte of data from the pipe : Test for success\n"));
readsize = 1;
ret = data.iReadEnd->Read(cPipeReadData ,readsize);
test_Equal(readsize, ret);
test.Next(_L("PIPE TEST:Thread 2-2 Validate 1 byte received is correct\n"));
ret = cPipeReadData.Compare(KTestData1);
test_KErrNone(ret);
test.Next(_L("PIPE TEST:Thread 2-3 Read remaining data from the pipe\n"));
readsize = 21;
ret = data.iReadEnd->Read(cPipeReadData , readsize);
test_Equal(readsize, ret);
test.Next(_L("PIPE TEST:Thread 2-4 Validate received data\n"));
ret = cPipeReadData.Compare(KTestData3);
test_KErrNone(ret);
test.End();
test.Close();
return KErrNone;
}
/****************************************************************************
This function is used as thread to test Unnamed pipes.
TestMultiThreadUnNamedPipes() will use this function.
TestMultiThreadNamedPipes() will use this function.
@aData : Used to pass the pipe and handle its size information.
Return Value : TInt
******************************************************************************/
TInt TestThread3(TAny* aData) {
TInt ret, aWriteSize;
TBufC8<50> cTestData3(KTestData2); // Test Data
TData& data = *(TData *)aData; // aData will have pipe handles and size.
RTest test(_L("t_pipe_t3"));
test.Start(_L("Thread 3"));
test.Printf(_L(" THREAD 3 called by TestMultiThreadNamedPipes And TestMultiThreadUnNamedPipes\n"));
test.Next(_L("PIPE TEST:Thread 3-1 Call Write blocking and write data\n"));
// Call Writeblocking function. Write one byte of data.
aWriteSize = cTestData3.Length();
ret = data.iWriteEnd->WriteBlocking(cTestData3,aWriteSize);
test_Equal(aWriteSize, ret);
// Call Writeblocking function. Write aSize bye data.
// Write data so that pipe get filled.
test.Next(_L("PIPE TEST:Thread 3-2 Write data till pipe is filled up \n"));
ret = data.iWriteEnd->WriteBlocking(cTestData3,aWriteSize);
test_Equal(aWriteSize, ret);
test.End();
test.Close();
return KErrNone;
}
/****************************************************************************
This function is used as thread to test Unnamed pipes.
TestMultiThreadUnNamedPipes() will use this function.
@aData : Used to pass the pipe and handle its size information.
Return Value : TInt
******************************************************************************/
//TRequestStatus stat1;
TInt TestThread4(TAny* aData) {
TData& data = *(TData *)aData; // aData will have pipe handles and size.
TRequestStatus stat1;
TBuf8<150> cPipeReadData;
TInt ret;
RTest test(_L("t_pipe_t4"));
test.Start(_L("Thread 4"));
RSemaphore sem; // Handle to the global semaphore
ret = sem.OpenGlobal(KSemaphoreName); // Access to the global semaphore identified by its name.
test(ret == KErrNone);
test.Printf(_L("Thread 4:Created by TestNotifyMechanismPipes.\n"));
test.Next(_L("PIPE TEST:Thread 4-1 Register Notify Data available request.\n"));
data.iReadEnd->NotifyDataAvailable(stat1);
test_Equal(KRequestPending, stat1.Int());
sem.Signal(); //signal to say that we have issued notification request
test.Next(_L("PIPE TEST:Thread 4-2 Wait till notified for data. Check for Available.\n"));
User::WaitForRequest(stat1);
test ( stat1.Int() == KErrNone);
test.Next(_L("PIPE TEST:Thread 4-3 Read One byte of data from the pipe.\n"));
sem.Wait(); //wait for signal that 1 byte should be read
ret = data.iReadEnd->Read(cPipeReadData,1);
test (ret == 1);
test.Next(_L("PIPE TEST:Thread 4-4 Verify data is correct ?.\n"));
test (KErrNone == cPipeReadData.Compare(KTestData1));
test.Next(_L("PIPE TEST:Thread 4-5 Read remaining data from the pipe.\n"));
ret = data.iReadEnd->Read(cPipeReadData,21);
test (ret == 21);
test.Next(_L("PIPE TEST:Thread 4-6 Verify data is correct ?.\n"));
test (KErrNone == cPipeReadData.Compare(KTestData3));
sem.Signal(); //signalling to the main thread to continue its operation
sem.Close(); //closing the handle to the semaphore
test.End();
test.Close();
return KErrNone;
}
/****************************************************************************
This function is used as thread to test Unnamed pipes.
TestWaitMechanismPipes() will use this function.
@aData : Used to pass the pipe and handle its size information.
Return Value : TInt
******************************************************************************/
TInt TestThread5(TAny* aData) {
TData& data = *(TData *)aData; // aData will have pipe handles and size.
TRequestStatus stat1;
TInt ret;
RTest test(_L("t_pipe_t5"));
test.Start(_L("Thread 5"));
test.Printf(_L("PIPE TEST:Thread 5:Created by TestWaitMechanismPipes.\n"));
test.Next(_L("PIPE TEST:Thread 5-1:Register one more request to wait till open to read. It shall not allow\n"));
data.iWriteEnd->Wait(KPipe3Name, stat1);
test (stat1.Int() == KErrInUse);
data.iWriteEnd->WaitForReader(KPipe3Name, stat1);
test (stat1.Int() == KErrInUse);
test.Next(_L("PIPE TEST:Thread 5-2:Open Pipe handle to Read.\n"));
ret = data.iReadEnd->Open(KPipe3Name,RPipe::EOpenToRead);
test(ret == KErrNone);
test.End();
test.Close();
return KErrNone;
}
/**
The reader thread will wait till there is data in the pipe
and then continuously read till it has read the total length
of the pipe.
*/
TInt ReaderThread(TAny* aData) {
// Read data from Pipe
RTest test(KReaderThread);
test.Title();
test.Start(_L("Reader Thread"));
TData& data = *(TData *)aData;
TBuf8<10> pipeReadData;
const TInt sizeToRead = data.iReadEnd->MaxSize(); //attempt to read everything from pipe
TRequestStatus status(KErrGeneral);
//do read in loop in case thread is notified before pipe is full
TInt totalDataRead=0;
do
{
data.iReadEnd->NotifyDataAvailable(status);
test.Printf(_L("notify data request status is %d\n"), status.Int());
if(status==KRequestPending)
User::WaitForRequest(status);
test(status==KErrNone);
test.Printf(_L("ready to read data\n"), status.Int());
const TInt sizeRead = data.iReadEnd->Read(pipeReadData, sizeToRead);
test.Printf(_L("Read %d bytes from pipe\n"), sizeRead);
test(sizeRead>0);
totalDataRead+=sizeRead;
}
while(totalDataRead<sizeToRead);
test(totalDataRead==sizeToRead);
test.End();
test.Close();
return KErrNone;
}
_LIT8(KTestDataNum1 , "12345");
_LIT8(KTestDataNum , "1234567890");
/**
Write into pipe to completely fill it.
*/
TInt WriterThread(TAny* aData)
{
// Write data to pipe
RPipe* writeEnd = static_cast<TData*>(aData)->iWriteEnd;
RTest test(_L("WriterThread"));
test.Start(_L("WriterThread"));
writeEnd->Flush(); //make sure pipe is empty
const TInt sizeToWrite = writeEnd->MaxSize();
test.Printf(_L("Writing %d bytes in to pipe\n"), sizeToWrite);
TInt length=writeEnd->WriteBlocking(KTestDataNum1,sizeToWrite);
test(length==sizeToWrite);
test.End();
test.Close();
return KErrNone;
}
/**
The FlusherThread waits till the supplied pipe
is full before flushing it.
*/
TInt FlusherThread(TAny* aData)
{
TData& data = *(TData *)aData; // aData will have pipe handles and size.
//wait for pipe to fill, then flush
TRequestStatus status;
const TInt maxSize=data.iReadEnd->MaxSize();
do
{
data.iReadEnd->NotifyDataAvailable(status);
if(status==KRequestPending)
User::WaitForRequest(status);
if(status!=KErrNone)
return status.Int();
} while(data.iReadEnd->Size()<maxSize);
data.iReadEnd->Flush();
return KErrNone;
}
/****************************************************************************
This function is used as thread to test Unnamed pipes.
TestWaitMechanismPipes() will use this function.
@aData : Used to pass the pipe and handle its size information.
Return Value : TInt
******************************************************************************/
TInt CloseFlag;
TInt TestThread9(TAny* aData) {
TData& data = *(TData *)aData; // aData will have pipe handles and size.
if (CloseFlag == 1)
data.iReadEnd->Close();
if (CloseFlag == 0)
data.iWriteEnd->Close();
return 0;
}
/**
The test will create 2 threads running this function. They will
race to placing the blocking read request. The first
will succeed and wait, the second will write to pipe
*/
TInt ReadBlockThenWrite(TAny* aData) {
TData& data = *(TData *)aData; // aData will have pipe handles and size.
TBuf8<10> cReadData;
RTest test(_L("Concurrent blocking read"));
test.Start(_L("Call blocking read on pipe\n"));
TInt ret = data.iReadEnd->ReadBlocking(cReadData,5);
if(ret == KErrNone)
{
test_KErrNone(cReadData.Compare(KTestDataNum1));
}
if(ret == KErrInUse)
{
test.Next(_L("Other thread beat us - write to pipe so it may proceed"));
TInt write = data.iWriteEnd->Write(KTestDataNum,5);
test_Equal(5, write);
}
test.End();
test.Close();
return ret;
}
/**
The test will create 2 threads running this function. They will
race to placing the blocking write request. The first
will succeed and wait, the second will read from pipe
*/
TInt WriteBlockThenRead(TAny* aData) {
TData& data = *(TData *)aData; // aData will have pipe handles and size.
TBuf8<10> cReadData;
RTest test(_L("Concurrent blocking write"));
test.Start(_L("test writing blocked pipe\n"));
TInt ret = data.iWriteEnd->WriteBlocking(KTestDataNum,10);
if(ret == KErrInUse)
{
test.Next(_L("The other thread beat us - read from pipe so it may proceed"));
TInt read = data.iReadEnd->Read(cReadData,5);
test_Equal(5, read);
test_KErrNone(cReadData.Compare(KTestDataNum1));
}
test.End();
test.Close();
return ret;
}
/****************************************************************************
This function is used as thread to test Unnamed pipes.
TestWaitMechanismPipes() will use this function.
@aData : Used to pass the pipe and handle its size information.
Return Value : TInt
******************************************************************************/
TInt TestThread11(TAny* aData) {
TData& data = *(TData *)aData; // aData will have pipe handles and size.
TRequestStatus stat1;
TBufC<50> cPipeName(KPipe3Name); // Descriptor to hold data for Writing.
TInt ret;
RTest test(_L("t_pipe_t11"));
test.Start(_L("PIPE TEST:Thread 11:Created by TestWaitMechanismPipes.\n"));
test.Next(_L("PIPE TEST:Thread 11-1:Register one more request to wait till open to read. It shall not allow\n"));
data.iReadEnd->WaitForWriter(cPipeName, stat1);
test_Equal(KErrInUse, stat1.Int());
test.Next(_L("PIPE TEST:Thread 11-2:Open Pipe handle to write.\n"));
ret = data.iWriteEnd->Open(cPipeName,RPipe::EOpenToWrite);
test_KErrNone(ret);
test.End();
test.Close();
return KErrNone;
}
/****************************************************************************
This is a function to test Named/UnNamed pipes Performace.
Check the functionality of following library functions
-
-
******************************************************************************/
/**
- test that WriteBlocking unblocks
- when data is read
- whed date is flushed
- test that notify data available request is completed as data is read
- test that ReadBlocking unblocks
- test that data available notification works
*/
void TestBlockingAndNotify() {
TRequestStatus stat1;
RPipe aReader,aWriter;
TInt aSize,ret;
TBufC8<10> cPipeTestDataNum(KTestDataNum);
TBuf8<10> cReadData;
aSize = 5;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess, //
EOwnerProcess //
);
test_KErrNone(ret);
TData data( &aReader, &aWriter);
{
TTestThread readerThread(KReaderThread, ReaderThread, &data);
test.Start(_L("Test that WriteBlock unblocks as data is read from pipe\n"));
ret = aWriter.WriteBlocking(cPipeTestDataNum,10);
test(ret == 10);
test(aWriter.Size()==5);
aWriter.Flush();
test(aWriter.Size()==0);
ret = readerThread.WaitForExitL();
test_KErrNone(ret);
}
{
TTestThread flusherThread(KThread8Name, FlusherThread, &data);
test.Next(_L("Test that WriteBlock unblocks as data is flushed from read end of pipe\n"));
ret = aWriter.WriteBlocking(cPipeTestDataNum,10);
test (ret == 10);
ret = flusherThread.WaitForExitL();
test_KErrNone(ret);
}
test.Next(_L("Test that NotifyDataAvailable request is completed as data is read from pipe\n"));
aWriter.NotifySpaceAvailable(aSize,stat1);
test(stat1==KRequestPending);
{
TTestThread readerThread2(KReaderThread, ReaderThread, &data);
User::WaitForRequest(stat1);
test(stat1==KErrNone);
ret = readerThread2.WaitForExitL();
test_KErrNone(ret);
}
aReader.Flush();
test.Next(_L("PIPE TEST: Test that ReadBlocking unblocks\n"));
{
TTestThread writeThread(KWriterThread, WriterThread, &data);
ret = aReader.ReadBlocking(cReadData,5);
test(ret == 5);
ret = writeThread.WaitForExitL();
test_KErrNone(ret);
}
test.Next(_L("PIPE TEST: Test NotifyDataAvailable\n"));
aReader.Flush();
aReader.NotifyDataAvailable(stat1);
test(stat1==KRequestPending);
{
TTestThread writeThread2(KWriterThread,WriterThread, &data);
User::WaitForRequest(stat1);
test(stat1==KErrNone);
aReader.Flush();
ret = writeThread2.WaitForExitL();
test_KErrNone(ret);
}
test.Next(_L("PIPE TEST: Test reading from pipe closed by the writer\n"));
CloseFlag = 0; // 0 Close Write Handle
//CloseFlag = 1; // 1 Close Read Handle
test.Next(_L("PIPE TEST: TestBlockingAndNotify 10.6\n"));
TTestThread closeThread(KThread9Name, TestThread9, &data);
ret = closeThread.WaitForExitL();
test_KErrNone(ret);
ret = aReader.ReadBlocking(cReadData,5);
test_Equal(KErrNotReady, ret);
aWriter.Close();
aReader.Close();
aSize = 5;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess, //
EOwnerProcess //
);
test_KErrNone(ret);
TData data1(&aReader,&aWriter);
//CloseFlag = 0; // 0 Close Write Handle
CloseFlag = 1; // 1 Close Read Handle
test.Printf(_L("PIPE TEST: TestBlockingAndNotify 10.7\n"));
TTestThread closeThread2(KThread9Name, TestThread9, &data1);
ret = aWriter.WriteBlocking(cPipeTestDataNum,10);
test_Equal(KErrNotReady, ret);
ret = closeThread2.WaitForExitL();
test_KErrNone(ret);
aWriter.Close();
aReader.Close();
test.End();
}
/****************************************************************************
TestPipesPermissionCheck :
This function is used to test Permission and Access related
Errors of Pipes API.
APIs tested are Define , Create , Destroy , Read and Write.
******************************************************************************/
// Different pipes for different capability , VID values.
_LIT(KPipeName2, "PipeWithNoCap");
_LIT(KPipeName3, "PipeWithNoCapVID");
_LIT(KPipeName4, "PipeWithRWCap");
_LIT(KPipeName5, "PipeWithComDDCap");
_LIT(KPipeName6, "PipeWithRWComDDCap");
_LIT(KPipeName7, "PipeWithRWComDDCapVID");
_LIT(KPipeName8, "PipeWithRWRUCap");
// Different processes with different capability , VID values.
_LIT(KProcessNoCap, "t_pipe3.exe");
_LIT(KProcessRCap, "t_pipe5.exe");
// My VID and SID
_LIT_VENDOR_ID(MyVID,0x70000001);
void TestPipesPermissionCheck() {
RProcess proc;
TInt ret;
// Define TSecurity objects with different capabilities and VID .
TSecurityPolicy NoCapVID(MyVID,ECapability_None,ECapability_None,ECapability_None);
TSecurityPolicy RWCap(ECapabilityReadDeviceData,ECapabilityWriteDeviceData);
TSecurityPolicy ComDDCap(ECapabilityCommDD);
TSecurityPolicy RWComDDCap(ECapabilityReadDeviceData,ECapabilityCommDD,ECapabilityWriteDeviceData);
TSecurityPolicy RWComDDCapVID(MyVID,ECapabilityCommDD,ECapabilityReadDeviceData,ECapabilityWriteDeviceData);
TSecurityPolicy RWRUCap(ECapabilityReadUserData,ECapabilityReadDeviceData,ECapabilityWriteDeviceData);
// Define Named pipes with No Cap , combination of Cap and VID
TInt aSize = 10;
ret = RPipe::Define(KPipeName2, aSize);
test (ret == KErrNone);
ret = RPipe::Define(KPipeName3, aSize,NoCapVID);
test (ret == KErrNone);
ret = RPipe::Define(KPipeName4, aSize,RWCap);
test (ret == KErrNone);
ret = RPipe::Define(KPipeName5, aSize,ComDDCap);
test (ret == KErrNone);
ret = RPipe::Define(KPipeName6, aSize,RWComDDCap);
test (ret == KErrNone);
ret = RPipe::Define(KPipeName7, aSize,RWComDDCapVID);
test (ret == KErrNone);
ret = RPipe::Define(KPipeName8, aSize,RWRUCap);
test (ret == KErrNone);
//Lets see who can use pipes. Check for Permissions and Access
test.Next(_L("PIPE TEST:8.1 Create Process with No Cap t_pipe3.exe\n"));
ret = proc.Create (
KProcessNoCap, // Launch t_pipe3.exe process
KNullDesC // No arguments passed to t_pipe3.exe
);
if (ret != KErrNone)
{
test.Printf(_L(" ***** t_pipe3.exe could not start ****"));
}
test_KErrNone(ret);
test.Printf(_L("Process Created successfully"));
TRequestStatus procLogon;
proc.Logon(procLogon);
test(procLogon==KRequestPending);
proc.Resume();
User::WaitForRequest(procLogon);
proc.Close();
// Lets see what happens with Read Capability.
test.Next(_L("PIPE TEST:8.2 Create Process with Read-Write-CommDD Cap t_pipe5.exe\n"));
ret = RPipe::Define(KPipeName2, aSize);
test_KErrNone(ret);
ret = RPipe::Define(KPipeName3, aSize,NoCapVID);
test_KErrNone(ret);
ret = proc.Create (
KProcessRCap, // Launch t_pipe3.exe process
KNullDesC // No arguments passed to t_pipe3.exe
);
if (ret != KErrNone)
{
test.Printf(_L(" ***** t_pipe5.exe could not start ****"));
}
test_KErrNone(ret);
test.Printf(_L("Process Created successfully"));
proc.Logon(procLogon);
test(procLogon==KRequestPending);
proc.Resume();
User::WaitForRequest(procLogon);
proc.Close();
//the t_pipe5.exe process should destroy most of these
//but we call destroy again to verify this
ret = RPipe::Destroy (KPipeName2);
test_Equal(KErrNotFound, ret);
ret = RPipe::Destroy (KPipeName3);
test_KErrNone(ret); //KPipeName3 is not destroyed by the other process.
ret = RPipe::Destroy (KPipeName4);
test_Equal(KErrNotFound, ret);
ret = RPipe::Destroy (KPipeName5);
test_Equal(KErrNotFound, ret);
ret = RPipe::Destroy (KPipeName6);
test_Equal(KErrNotFound, ret);
ret = RPipe::Destroy (KPipeName7);
test_KErrNone(ret); //t_pipe5.exe does not have permission to delete
ret = RPipe::Destroy (KPipeName8);
test_KErrNone(ret); //t_pipe5.exe does not have permission to delete
return;
}
/****************************************************************************
TestMiscPipes :
This is a function to test Named/UnNamed pipes for all Misc test cases.
******************************************************************************/
void TestMiscPipes() {
_LIT(KInvalidPipeName,"PipeNotExist");
TInt ret,aSize;
RPipe aReader,aWriter;
TBufC<50> cPipeName(KInvalidPipeName); // Descriptor to hold data for Writing.
TBufC8<50> cPipeTestData2(KTestData2);
// Try to create unnamed pipe with Negative size
test.Next(_L("PIPE TEST:9.1 Create Pipe of Negative Size.\n"));
aSize = -1;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess, //
EOwnerProcess //
);
test( ret == KErrArgument);
// Try to create unnamed pipe with zero size
test.Next(_L("PIPE TEST:9.2 Create Pipe with of Zero size.\n"));
aSize = 0;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess, //
EOwnerProcess //
);
test( ret == KErrArgument);
// Try to define named pipe with Negative size
test.Next(_L("PIPE TEST:9.3 Define Pipe of Negative size.\n"));
aSize = -1;
ret = RPipe::Define(cPipeName, aSize);
test( ret == KErrArgument);
// Try to define named pipe with Zero size
test.Next(_L("PIPE TEST:9.4 Define Pipe of Zero size.\n"));
aSize = 0;
ret = RPipe::Define(cPipeName, aSize);
test( ret == KErrArgument);
// Try to destroy pipe which does not exists
test.Next(_L("PIPE TEST:9.5 Try to destroy named pipe which do not exist.\n"));
ret = RPipe::Destroy (cPipeName);
test (ret == KErrNotFound);
// Try to read from pipe with invalid length data to be read
RPipe aReaderUN,aWriterUN;
TBuf8<150> cPipeReadData;
aSize = 10;
ret = RPipe::Create( aSize,
aReaderUN,
aWriterUN,
EOwnerProcess, //
EOwnerProcess //
);
test (ret == KErrNone );
test.Next(_L("PIPE TEST:9.6 Try calling ReadBlocking using write handle and WriteBlocking using Read handle.\n"));
ret = aWriterUN.ReadBlocking(cPipeReadData, aSize);
test (ret == KErrAccessDenied);
ret = aReaderUN.WriteBlocking(cPipeTestData2,aSize);
test (ret == KErrAccessDenied);
test.Next(_L("PIPE TEST:9.7 Read negative size data from un-named pipe.\n"));
aSize = -1;
ret = aReaderUN.Read(cPipeReadData, aSize);
test( ret == KErrArgument);
ret = aWriterUN.Write(cPipeTestData2,aSize);
test( ret == KErrArgument);
test.Next(_L("PIPE TEST:9.8 Read/Write zero size data from/to un-named pipe\n"));
aSize = 0;
ret = aReaderUN.Read(cPipeReadData, aSize);
test( ret == KErrNone);
ret = aWriterUN.Write(cPipeTestData2,aSize);
test( ret == KErrNone);
test.Next(_L("PIPE TEST:9.9 Call ReadBlocking and WriteBlocking to Read and Write negative size data.\n"));
// Try to readblocking from pipe with invalid length data to be read
aSize = -1;
ret = aReaderUN.ReadBlocking(cPipeReadData, aSize);
test( ret == KErrArgument);
ret = aWriterUN.WriteBlocking(cPipeTestData2,aSize);
test( ret == KErrArgument);
test.Next(_L("PIPE TEST:9.10 ReadBlocking/WriteBlocking to read/write zero size data.\n"));
aSize = 0;
ret = aReaderUN.ReadBlocking(cPipeReadData, aSize);
test( ret == KErrArgument);
ret = aWriterUN.WriteBlocking(cPipeTestData2,aSize);
test( ret == KErrArgument);
test.Next(_L("PIPE TEST:9.11 Try calling ReadBlocking and WriteBlocking using un opened RPipe handles.\n"));
RPipe aReaderT,aWriterT;
ret = aReaderT.ReadBlocking(cPipeReadData, aSize);
test (ret == KErrBadHandle);
ret = aWriterT.WriteBlocking(cPipeTestData2,aSize);
test (ret == KErrBadHandle);
aReaderUN.Close();
aWriterUN.Close();
return;
}
/****************************************************************************
This is a function to test notify mechanism of pipes.
Check the functionality of following library functions
- Notify...()
******************************************************************************/
void TestWaitMechanismPipes() {
RPipe aReader,aWriter; // Used to pass to thread.
RPipe aWriter2;
TInt ret;
TBufC<50> cPipeName(KPipe3Name); // Descriptor to hold data for Writing.
TInt aSize;
TRequestStatus stat1;
aSize = 22 * 10; // Sizeof(KTestData) * 10
ret = RPipe::Define( cPipeName,aSize);
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
test.Next(_L("PIPE TEST:7.1 Try calling Wait function on BadPipe name.\n"));
_LIT(KBadPipeName , "***R$@#$@#%#$%#^.12-.");
aWriter.Wait(KBadPipeName,stat1);
test(stat1.Int() == KErrBadName);
aWriter.WaitForReader(KBadPipeName,stat1);
test(stat1.Int() == KErrBadName);
_LIT(KBadPipeName2 , "");
aWriter.Wait(KBadPipeName2,stat1);
test(stat1.Int() == KErrBadName);
aWriter.WaitForReader(KBadPipeName2,stat1);
test(stat1.Int() == KErrBadName);
test.Next(_L("PIPE TEST:7.2 Try calling Wait function on non existing Pipe\n"));
_LIT(KInvalidPipe , "NotExistingPipe");
aWriter.Wait(KInvalidPipe,stat1);
test(stat1.Int() == KErrNotFound);
aWriter.WaitForReader(KInvalidPipe,stat1);
test(stat1.Int() == KErrNotFound);
test.Next(_L("PIPE TEST:7.3 Try calling Wait function on Pipe name length more than maxlength.\n"));
aWriter.Wait(KMaxPipeNamePlusOne,stat1);
test(stat1.Int() == KErrBadName);
aWriter.WaitForReader(KMaxPipeNamePlusOne,stat1);
test(stat1.Int() == KErrBadName);
test.Next(_L("PIPE TEST:7.4 Try calling Wait function from unopened handle.\n"));
aWriter2.Wait(cPipeName, stat1);
test (stat1.Int() == KErrInUse);
aWriter2.WaitForReader(cPipeName, stat1);
test (stat1.Int() == KErrInUse);
test.Next(_L("PIPE TEST:7.5 Register a valid Wait Request .\n"));
aWriter.Wait(cPipeName, stat1);
TData data( &aReader, &aWriter);
// Create Thread 5
// Pass TData object with Write and Read handle both
TTestThread thread5(KThread5Name, TestThread5, &data);
User::WaitForRequest(stat1);
ret = thread5.WaitForExitL();
test_KErrNone(ret);
test.Next(_L("PIPE TEST:7.6 After Wait finish check the value of status register.\n"));
test_KErrNone(stat1.Int());
aWriter.Close();
aReader.Close();
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test_KErrNone(ret);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test_KErrNone(ret);
test.Next(_L("PIPE TEST:7.7 After Read handle is open , register request to Wait\n"));
aWriter.Wait(cPipeName, stat1);
test (stat1.Int() == KErrNone);
test.Next(_L("PIPE TEST:7.8 Check for CancelWait.\n"));
aWriter.Close();
aReader.Close();
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
TRequestStatus stat2;
aWriter.Wait(cPipeName, stat1);
aWriter.Wait(cPipeName, stat2);
test(stat2.Int() == KErrInUse);
aWriter.CancelWait();
test(stat1.Int() == KErrCancel);
test(stat2.Int() == KErrInUse);
aWriter.Wait(cPipeName, stat1);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test(stat1.Int() == KErrNone);
test.Next(_L("PIPE TEST:7.9 Check Wait and CancelWait from reader end\n"));
aWriter.Close();
aReader.Close();
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
aReader.Wait(cPipeName, stat1);
test (stat1.Int() == KErrAccessDenied);
aReader.CancelWait();
aWriter.Close();
aReader.Close();
RPipe::Destroy(cPipeName);
/*****************Newly added tests for CR 1114 - WaitForReader *********/
ret = RPipe::Define( cPipeName,aSize);
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
test.Next(_L("PIPE TEST:7.10 Register a valid Wait Request .\n"));
aWriter.WaitForReader(cPipeName, stat1);
test(stat1==KRequestPending);
// Create Thread 5
// Pass TData object with Write and Read handle both
{
TTestThread thread5_1(KThread5Name, TestThread5, &data);
User::WaitForRequest(stat1);
ret = thread5_1.WaitForExitL();
test_KErrNone(ret);
}
test.Next(_L("PIPE TEST:7.11 After Wait finish check the value of status register.\n"));
aWriter.Close();
aReader.Close();
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
aReader.WaitForReader(cPipeName, stat1);
test (stat1.Int() == KErrAccessDenied);
test.Next(_L("PIPE TEST:7.12 After Read handle is open , register request to Wait\n"));
aWriter.WaitForReader(cPipeName, stat1);
test (stat1.Int() == KErrNone);
test.Next(_L("PIPE TEST:7.13 Check for CancelWait.\n"));
aWriter.Close();
aReader.Close();
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
aWriter.WaitForReader(cPipeName, stat1);
aWriter.WaitForReader(cPipeName, stat2);
test(stat2.Int() == KErrInUse);
aWriter.CancelWait();
test(stat1.Int() == KErrCancel);
test(stat2.Int() == KErrInUse);
aWriter.WaitForReader(cPipeName, stat1);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test(stat1.Int() == KErrNone);
// Release all the resources.
aWriter.Close();
aReader.Close();
// Create Thread 5
// Pass TData object with Write and Read handle both
test.Next(_L("PIPE TEST:7.14 Register a valid Wait Request .\n"));
aWriter.WaitForReader(cPipeName, stat1);
{
TTestThread thread5_2(KThread5Name, TestThread5, &data);
User::WaitForRequest(stat1);
ret = thread5_2.WaitForExitL();
test_KErrNone(ret);
}
test.Next(_L("PIPE TEST:7.15 After Wait finish close the handles.\n"));
test (stat1.Int() == KErrNone);
aWriter.Close();
aReader.Close();
// Release all the resources.
ret = RPipe::Destroy(cPipeName);
test_KErrNone(ret);
/*****************Newly added tests for CR 1114 - WaitForWriter *********/
ret = RPipe::Define( cPipeName,aSize);
test_KErrNone(ret);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrNone);
// Create Thread 11
// Pass TData object with Write and Read handle both
test.Next(_L("PIPE TEST:7.16 Register a valid Wait Request .\n"));
aReader.WaitForWriter(cPipeName, stat1);
test(stat1==KRequestPending);
{
TTestThread thread11(KThread11Name, TestThread11, &data);
User::WaitForRequest(stat1);
ret = thread11.WaitForExitL();
test_KErrNone(ret);
}
test.Next(_L("PIPE TEST:7.17 After Wait finish check the value of status register.\n"));
aWriter.Close();
aReader.Close();
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test_KErrNone(ret);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test_KErrNone(ret);
aWriter.WaitForWriter(cPipeName, stat1);
test (stat1.Int() == KErrAccessDenied);
test.Next(_L("PIPE TEST:7.18 After Write handle is open , register request to Wait\n"));
aReader.WaitForWriter(cPipeName, stat1);
test (stat1.Int() == KErrNone);
test.Next(_L("PIPE TEST:7.19 Check for CancelWait.\n"));
aWriter.Close();
aReader.Close();
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
aReader.WaitForWriter(cPipeName, stat1);
aReader.WaitForWriter(cPipeName, stat2);
test(stat2.Int() == KErrInUse);
aReader.CancelWait();
test(stat1.Int() == KErrCancel);
test(stat2.Int() == KErrInUse);
aReader.WaitForWriter(cPipeName, stat1);
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test(stat1.Int() == KErrNone);
// Release all the resources.
aWriter.Close();
aReader.Close();
// Create Thread 11
// Pass TData object with Write and Read handle both
test.Next(_L("PIPE TEST:7.20 Register a valid Wait Request .\n"));
aReader.WaitForWriter(cPipeName, stat1);
{
TTestThread thread11_2(KThread11Name, TestThread11, &data);
User::WaitForRequest(stat1);
test.Next(_L("PIPE TEST:7.21 After Wait finish , close the hadles.\n"));
test (stat1.Int() == KErrNone);
ret = thread11_2.WaitForExitL();
test_KErrNone(ret);
// Release all the resources.
aWriter.Close();
aReader.Close();
}
ret = RPipe::Destroy(cPipeName);
test_KErrNone(ret);
/**********************************************************/
// Define the pipe.
ret = RPipe::Define( cPipeName,aSize);
test(ret == KErrNone);
// Wait for Writer.
aReader.WaitForWriter(cPipeName, stat1);
// Try to open read end again. It should not open because WaitForWriter
// will has already opened the Read End of the pipe.
ret = aReader.Open(cPipeName ,RPipe::EOpenToRead );
test(ret = KErrInUse );
// Status of the wait request is pending because writer is not opened yet.
test (stat1.Int() == KRequestPending);
// Wait on Reader.
aWriter.WaitForReader(cPipeName , stat2);
// Reader was already opened so status is KErrNone.
test ( stat2.Int() == KErrNone);
// Try to open Write end. It should not allow because WaitForReader has
// already opened the write end of the pipe.
ret = aWriter.Open(cPipeName ,RPipe::EOpenToWrite);
test (ret == KErrInUse);
// Check the status of the WaitForWriter request. It should be KErrNone now.
test (stat1.Int() == KErrNone);
// Let's check for pipe attributes.
ret = aReader.MaxSize();
test (ret = aSize);
ret = aWriter.MaxSize();
test (ret = aSize);
ret = aReader.Size();
test (ret = aSize);
ret = aWriter.Size();
test (ret = aSize);
// Close the Reade handle.
aReader.Close();
// Put request to wait for Reader.
aWriter.WaitForReader(cPipeName , stat2);
// It should be pending.
test ( stat2.Int() == KRequestPending);
// Open the reader end of the pipe. It should allow , KErrNone
ret = aReader.Open(cPipeName ,RPipe::EOpenToRead );
test ( stat2.Int() == KErrNone);
test (ret == KErrNone);
aReader.Close();
aWriter.Close();
ret=RPipe::Destroy(cPipeName);
test_KErrNone(ret);
return;
}
/****************************************************************************
This is a function to test notify mechanism of pipes.
Check the functionality of following library functions
- Notify...()
******************************************************************************/
void TestNotifyMechanismPipes() {
// Test NotifyDataAvailable , NotifySpaceAvailable
RSemaphore globalSem; // Handle to a global semaphore. Semaphore is used to maintain synchronisation between thread4 and the main thread
TInt ret; // Return Value variable.
RPipe aReader,aWriter; // Used to pass to thread.
RPipe aReader2,aWriter2; // Used to pass to thread.
TInt aSize; // Used to pass to thread.
const TBufC<50> cPipeName(KPipe1Name); // Descriptor to hold data for Writing.
TRequestStatus stat1;
TBuf8<50> cPipeTestData1(KTestData2);
const TBufC<50> cSemaphoreName(KSemaphoreName); // Descriptor conataining the name of the global semaphore.
ret = globalSem.CreateGlobal(cSemaphoreName,0); //create and open a global semaphore with initial count as 0.
test (ret == KErrNone);
aSize = 22; // Size of KTestData * 10
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess, //
EOwnerProcess //
);
TData data( &aReader, &aWriter);
// Create Thread 4
// Pass TData object with Write and Read handle both
test.Next(_L("PIPE TEST:6.1 Call CancelDataAvailable/CancelSpaceAvailable using unopened RPipe handles.\n"));
ret = aReader2.CancelDataAvailable();
test ( ret == KErrBadHandle);
ret = aWriter2.CancelSpaceAvailable();
test (ret == KErrBadHandle);
test.Next(_L("PIPE TEST:6.2 Call NotifySpaceAvailable with Negative size \n"));
// Call Notfifyspace
TInt tempsize = -1;
aWriter.NotifySpaceAvailable(tempsize, stat1);
test ( stat1.Int() == KErrArgument);
test.Next(_L("PIPE TEST:6.2a Call NotifySpaceAvailable for space larger than pipe.\n"));
aWriter.NotifySpaceAvailable(aSize+1, stat1);
test_Equal( KErrArgument, stat1.Int());
// Start the thread
{
TTestThread thread4(KThread4Name, TestThread4, &data);
// Thread 4
// Call Notifydata available
// Loop for Available
// Read the data and validate
test.Next(_L("PIPE TEST:6.3 Write data into the pipe , verify return value.\n"));
// Write one byte data into the pipe.
globalSem.Wait(); //wait before writing to ensure that other thread can register Data Available request while pipe is empty.
ret = aWriter.Write(cPipeTestData1,cPipeTestData1.Length());
test (ret == cPipeTestData1.Length());
test.Next(_L("PIPE TEST:6.4 Call NotifySpaceAvailable with valid parameters \n"));
tempsize = 1;
aWriter.NotifySpaceAvailable(tempsize, stat1);
test(stat1==KRequestPending);
globalSem.Signal(); //signal that thread 4 may go ahead and read 1 byte
test.Next(_L("PIPE TEST:6.5 Wait till request says AVAILABLE. Available ?\n"));
User::WaitForRequest(stat1);
test ( stat1.Int() == KErrNone || stat1.Int() == KErrCompletion);
// Thread 4
// Notify data available
// Loop for available
// Flush the buffer
// Register two request for Notifydata available
// Register two request for Notifyspace available
// Call Notifydata available using Read handle
// Call Notifydata available using write handle
// return
// Check for Error conditions
// Flush buffer
globalSem.Wait(); // this is waiting for a signal from thread4
test.Next(_L("PIPE TEST:6.6 Register Notification for space availability. Allows ?\n"));
ret = aWriter.Write(cPipeTestData1,cPipeTestData1.Length());
ret = aWriter.Write(cPipeTestData1,cPipeTestData1.Length());
// Register two request for Notifyspace available
aWriter.NotifySpaceAvailable(tempsize, stat1);
test_Equal(KRequestPending, stat1.Int() );
test.Next(_L("PIPE TEST:6.7 Register One more Notification for space availability. Allows ?\n"));
TRequestStatus tempstat1;
aWriter.NotifySpaceAvailable(tempsize, tempstat1);
test ( tempstat1.Int() == KErrInUse);
test.Next(_L("PIPE TEST:6.7a Cancellation of non-outstanding requests must not disrupt oustanding requests\n"));
aWriter.CancelWait();
aWriter.NotifySpaceAvailable(tempsize, tempstat1);
test_Equal( KErrInUse, tempstat1.Int());
test.Next(_L("PIPE TEST:6.8 Cancel all the pending Notifications.\n"));
ret = aWriter.CancelSpaceAvailable();
test ( ret == KErrNone);
test_Equal(KErrCancel, stat1.Int() );
test.Next(_L("PIPE TEST:6.9 Try to cancel some more notifications. It should not allow\n"));
ret = aWriter.CancelSpaceAvailable();
test ( ret == KErrNone);
test.Next(_L("PIPE TEST:6.10 Register Notification for Data availability. Allows ?\n"));
// Register two request for Notifydata available
aWriter.Flush();
aReader.NotifyDataAvailable(stat1);
test.Next(_L("PIPE TEST:6.11 Register One More Notification for Data availability. Allows ?\n"));
aReader.NotifyDataAvailable(tempstat1);
test ( ( tempstat1.Int() == KErrInUse) || (tempstat1.Int() == KErrCompletion));
test.Next(_L("PIPE TEST:6.12 Cancel all the pending Notifications for Data.\n"));
ret = aReader.CancelDataAvailable();
test ( ( ret == KErrNone) || (ret == KErrNotFound));
test (stat1.Int() == KErrCancel);
test.Next(_L("PIPE TEST:6.13 Try to cancel some more notifications. It should not allow\n"));
ret = aReader.CancelDataAvailable();
test ( ret == KErrNone);
test.Next(_L("PIPE TEST:6.14 Try to register Data available notification using Write handle. Should not allow.\n"));
aWriter.NotifyDataAvailable(stat1);
test ( stat1.Int() == KErrAccessDenied);
test.Next(_L("PIPE TEST:6.15 Try to register Space available notification using Read handle. Should not allow.\n"));
aReader.NotifySpaceAvailable(tempsize, stat1);
test ( stat1.Int() == KErrAccessDenied);
test.Next(_L("PIPE TEST:6.16 Try to Cancel Data available notification using Write handle. Should not allow.\n"));
ret = aWriter.CancelDataAvailable();
test ( ret == KErrAccessDenied);
test.Next(_L("PIPE TEST:6.17 Try to Cancel Space available notification using Write handle. Should not allow.\n"));
ret = aReader.CancelSpaceAvailable();
test ( ret == KErrAccessDenied);
// Stop the thread and Close the Thread
ret = thread4.WaitForExitL();
}
test_KErrNone(ret);
// Close all the pipe handles.
aReader.Close();
aWriter.Close();
test.Printf(_L(" TEST NOTIFICATION MECHNISM FOR NAMED PIPES\n"));
aSize = 22; // Size of KTestData
test.Next(_L("PIPE TEST:6.18 Create Named pipe and Open Read/Write Handles.\n"));
ret = RPipe::Define( cPipeName,aSize);
test (ret == KErrNone);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrNone);
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
TData data2( &aReader, &aWriter);
// Create Thread 4
// Pass TData object with Write and Read handle both
TTestThread thread4a(KThread4Name, TestThread4, &data2);
// Thread 4
// Call Notifydata available
// Loop for Available
// Read the data and validate
// Write one byte data into the pipe.
test.Next(_L("PIPE TEST:6.19 Write Data and check for return value.\n"));
globalSem.Wait(); //wait before writing to ensure that other thread can register Data Available request while pipe is empty.
ret = aWriter.Write(cPipeTestData1,cPipeTestData1.Length());
test (ret == cPipeTestData1.Length());
test.Next(_L("PIPE TEST:6.20 Register Notification for Space Available.\n"));
// Call Notfifyspace
tempsize = 1;
aWriter.NotifySpaceAvailable(tempsize, stat1);
test(stat1==KRequestPending);
globalSem.Signal(); //signal that thread 4 may go ahead and read byte
test.Next(_L("PIPE TEST:6.21 Wait till notified for Space Availanle.\n"));
User::WaitForRequest(stat1);
test ( stat1.Int() == KErrNone);
// Thread 4
// Read one byte of data
// Thread 4
// Notify data available
// Loop for available
// Flush the buffer
// Register two request for Notifydata available
// Register two request for Notifyspace available
// Call Notifydata available using Read handle
// Call Notifydata available using write handle
// return
globalSem.Wait(); //waiting for a signal from thread4.
test.Next(_L("PIPE TEST:6.22 Notify for Space available.\n"));
// Register two request for Notifydata available
ret = aWriter.Write(cPipeTestData1,cPipeTestData1.Length());
aWriter.NotifySpaceAvailable(tempsize, stat1);
test.Next(_L("PIPE TEST:6.23 Notify one more notifier for Space available.\n"));
// Register two request for Notifyspace available
TRequestStatus notifyStatus;
aWriter.NotifySpaceAvailable(tempsize, notifyStatus);
test ( notifyStatus.Int() == KErrInUse);
aWriter.Flush();
aWriter.NotifySpaceAvailable(tempsize, stat1);
test ( stat1.Int() == KErrNone);
test.Next(_L("PIPE TEST:6.24 Cancel Notify for Space available.\n"));
ret = aWriter.CancelSpaceAvailable();
test (( ret == KErrNotFound) ||( ret == KErrNone));
test.Next(_L("PIPE TEST:6.25 Cancel one more Notify for Space available.\n"));
ret = aWriter.CancelSpaceAvailable();
test ( ret == KErrNone);
test.Next(_L("PIPE TEST:6.26 Register Notify for Data available.\n"));
// Register two request for Notifydata available
aWriter.Flush();
TRequestStatus stat5,stat6;
aReader.NotifyDataAvailable(stat5);
test.Next(_L("PIPE TEST:6.27 Register One more Notify for Data available.\n"));
// Register two request for Notifyspace available
aReader.NotifyDataAvailable(notifyStatus);
test ( notifyStatus.Int() == KErrInUse);
test.Next(_L("PIPE TEST:6.28 Cancel Notify for Data available.\n"));
ret = aReader.CancelDataAvailable();
test ( ret == KErrNone);
test (stat5.Int() == KErrCancel);
test.Next(_L("PIPE TEST:6.29 Cancel One more Notify for Data available.\n"));
ret = aReader.CancelDataAvailable();
test ( ret == KErrNone);
test.Next(_L("PIPE TEST:6.30 Register Notify for Data available using Write handle\n"));
aWriter.NotifyDataAvailable(stat6);
test ( stat6.Int() == KErrAccessDenied);
test.Next(_L("PIPE TEST:6.31 Register Notify for Space available using Read handle\n"));
aReader.NotifySpaceAvailable(tempsize, stat6);
test ( stat6.Int() == KErrAccessDenied);
test.Next(_L("PIPE TEST:6.32 Cancel Notify for Data available using Write handle\n"));
ret = aWriter.CancelDataAvailable();
test ( ret == KErrAccessDenied);
test.Next(_L("PIPE TEST:6.33 Cancel Notify for Space available using Read handle\n"));
ret = aReader.CancelSpaceAvailable();
test ( ret == KErrAccessDenied);
//close the handle to the global semaphore
globalSem.Close();
// Stop the thread and Close the Thread
ret = thread4a.WaitForExitL();
test_KErrNone(ret);
aReader.Close();
aWriter.Close();
RPipe::Destroy(cPipeName);
return;
} // End TestNotifyMechanismPipes()
/****************************************************************************
This is a function to test Named pipes in Mutli process environment.
Check the functionality of following library functions
- Define ()
-
******************************************************************************/
_LIT8(KTestDataIP, "ABCDEFGHIJ");
void TestMultiProcessNamedPipes() {
_LIT(KPipeName5, "InterProcessPipe1");
TInt ret; // Return value variable
RProcess proc; // Process Handle
RPipe aWriter;
RPipe aWriterUN,aReaderUN;
const TBufC<150> cPipeName1(KPipeName5);
TBufC8<150> cPipeWriteData1(KTestDataIP);
TInt aSize;
TRequestStatus stat1;
TBuf8<150> cPipeReadData1;
aSize = 10;
// Define Pipe with valid size.
test.Next(_L("PIPE TEST:5.1 Define Pipe and Create UnNAmed pipe and pass handle to other process.\n"));
ret = RPipe::Define(cPipeName1, aSize);
test_KErrNone(ret);
ret = proc.Create(
KProcessName, // Launch t_pipe2.exe process
KNullDesC // No arguments passed to t_pipe2.exe
);
if (ret != KErrNone) {
// Check for process successfully launched
test.Printf(_L("Error : Could not start the process t_pipe2.exe \n"));
}
test_KErrNone(ret);
TRequestStatus procLogon;
proc.Logon(procLogon);
test(procLogon==KRequestPending);
aSize = 512;
ret = RPipe::Create( aSize,
aReaderUN,
aWriterUN,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess //TOwnerType aTypeW
);
test_KErrNone(ret);
ret = aWriterUN.Write(KTestData,22);
test (ret == 22);
ret = aReaderUN.Read(cPipeReadData1,10);
test ( ret == 10);
aWriterUN.Close();
ret = aReaderUN.Read(cPipeReadData1,6);
test (ret == 6);
aReaderUN.NotifyDataAvailable(stat1);
ret = stat1.Int();
test (ret == KErrNone);
ret = aReaderUN.ReadBlocking(cPipeReadData1,6);
test (ret == 6);
ret = aReaderUN.Read(cPipeReadData1,1);
test ( ret == KErrNotReady);
ret = aReaderUN.ReadBlocking(cPipeReadData1,1);
test ( ret == KErrNotReady);
aReaderUN.Close();
ret = RPipe::Create( aSize,
aReaderUN,
aWriterUN,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess //TOwnerType aTypeW
);
test_KErrNone(ret);
proc.SetParameter(3,aReaderUN);
aReaderUN.Close();
ret = aWriterUN.Write(KTestData,22);
test (ret == 22 );
proc.Resume();
aSize = 10;
test.Next(_L("PIPE TEST:5.2 Open Write handle to Pipe. Wait till Read handle Opened\n"));
ret = aWriter.Open(cPipeName1, RPipe::EOpenToWrite);
test_KErrNone(ret);
aWriter.Wait(cPipeName1,stat1);
User::WaitForRequest(stat1);
test (stat1.Int() == KErrNone);
test.Next(_L("PIPE TEST:5.3 Write data to Pipe.\n"));
ret = aWriter.Write(cPipeWriteData1,cPipeWriteData1.Length());
test ( ret == cPipeWriteData1.Length());
test.Next(_L("PIPE TEST:5.4 Wait till Space Available in Pipe.\n"));
aWriter.NotifySpaceAvailable(aSize,stat1);
User::WaitForRequest(stat1);
test.Next(_L("PIPE TEST:5.5 Write the data using WriteBlocking call\n"));
test_Equal(0, aWriter.Size());
ret = aWriter.WriteBlocking(cPipeWriteData1,cPipeWriteData1.Length());
test ( ret ==cPipeWriteData1.Length() );
User::WaitForRequest(procLogon);
aWriter.Close();
ret=RPipe::Destroy(cPipeName1);
test_KErrNone(ret);
proc.Close();
aWriterUN.Close();
aReaderUN.Close();
return;
} // End TestMultiProcessNamedPipes ()
/****************************************************************************
This is a function to test Named pipes in Multi threaded environment.
Check the functionality of following library functions
- Define ()
- Read()
- Write()
- ReadBlocking()
- WriteBlocking()
******************************************************************************/
//
// Test defining and opening both ends of pipe
// Attempt to readblock from pipe closed at far end (should fail)
// Attemp writeblock to pipe closed at far end
//
// Do some normal reading and writing between threads
// do some blocking read/write between threads
void TestMultiThreadNamedPipes() {
TInt ret; // Return Value variable.
RPipe aReader,aWriter; // Used to pass to thread.
TInt aSize; // Used to pass to thread.
const TBufC<50> cPipeName(KPipe1Name); // Descriptor to hold data for Writing.
TInt aReadSize;
TBuf8<150> cPipeReadData;
TBufC8<50> cTestData(KTestData); // Test Data
///////////////////////////////////////////////////////////
// PART : 1 ///
// Test Read and Write Functionality ///
///////////////////////////////////////////////////////////
test.Next(_L("PIPE TEST:4.1 Define Pipe , Open Read and Write Handle.\n"));
aSize = 22;
ret = RPipe::Define( cPipeName,aSize);
test (ret == KErrNone);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrNone);
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
aWriter.Close();
test.Next(_L("PIPE TEST:4.2 ReadBlocking: Check for KErrNotReady.\n"));
aReadSize = 1;
ret = aReader.ReadBlocking(cPipeReadData,aReadSize);
test (ret == KErrNotReady);
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
aReader.Close();
test.Next(_L("PIPE TEST:4.3 WriteBlocking: Check for KErrNotReady.\n"));
ret = aWriter.WriteBlocking(cTestData,cTestData.Length());
test (ret == KErrNotReady);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrNone);
TData data( &aReader, &aWriter);
// Write data to Pipe using valid handle
test.Next(_L("PIPE TEST:4.4 Write into the pipe and verify return value.\n"));
ret = aWriter.Write(cTestData,cTestData.Length());
test (ret == cTestData.Length() );
// Keep writing the data into pipe till it overflows
test.Next(_L("PIPE TEST:4.5 Write into the pipe till it overflows.\n"));
ret = aWriter.Write(cTestData,cTestData.Length());
test (( ret == KErrOverflow)) ;
// Start the thread.
TTestThread thread2(KThread2Name, TestThread2, &data);
// Read 1 byte data from pipe
// Validate data
// Read aByte size data
// Validate data
// Thread 2
// Read aByte size data
// User:: After (10000)
// Keep reading data till zero return
// return
// Stop the thread and Close the Thread
ret = thread2.WaitForExitL();
test_KErrNone(ret);
aReader.Close();
aWriter.Close();
ret = RPipe::Destroy(cPipeName);
test_KErrNone(ret);
///////////////////////////////////////////////////////////
// PART : 2 ///
// Test ReadBlocking and WriteBlocking Functionality ///
///////////////////////////////////////////////////////////
// Test Read and Write blocking call
test.Next(_L("PIPE TEST:4.6 Create UnNamed Pipe with valid size.\n"));
aSize = 22;
ret = RPipe::Define( cPipeName,aSize);
test (ret == KErrNone);
ret = aReader.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrNone);
ret = aWriter.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
// Create TData object to pass Pipe handles.
TData data2( &aReader, &aWriter);
// Create Thread ( Note : Thread is in pending state now)
// Flush the data if any in pipe to make sure its empty.
aWriter.Flush();
// Start the thread
TTestThread thread3(KThread3Name, TestThread3, &data2);
// Thread 3
// Write one byte of data
// Write one one byte of data using WriteBlocking call
// Write aByte size data using Writblocking call
// Call Readblocking function.Read one byte of data.
test.Next(_L("PIPE TEST:4.7 Flush the buffer and Call ReadBlocking one byte into the pipe.\n"));
aReadSize = 1;
ret = aReader.ReadBlocking(cPipeReadData,aReadSize);
test_Equal(aReadSize, ret);
test.Next(_L("PIPE TEST:4.8 Verify the data received.\n"));
test ( KErrNone == cPipeReadData.Compare(KTestData1));
test.Next(_L("PIPE TEST:4.9 Call ReadBlocking and read complete data from Pipe. As big as Pipe Size\n"));
// Call Readblocking function.Read aSize bytes of data.
aReadSize = aSize-aReadSize; //read rest of data
ret = aReader.ReadBlocking(cPipeReadData,aReadSize);
test_Equal(aReadSize, ret);
test ( KErrNone == cPipeReadData.Compare(KTestData3));
// Thread 3
// Wait for some time
// Call Readblocking and read 1 byte of data
// Call Readblocking and Read abyte size data
// Call flush buffer
// return
test.Next(_L("PIPE TEST:4.10 Call ReadBlocking and read complete data from Pipe. As big as Pipe Size\n"));
// Call Readblocking function.Read aSize bytes of data.
aReadSize = aSize;
ret = aReader.ReadBlocking(cPipeReadData,aReadSize);
test_Equal(aReadSize, ret);
test ( KErrNone == cPipeReadData.Compare(KTestData2));
// Stop the thread and Close the Thread
ret = thread3.WaitForExitL();
test_KErrNone(ret);
aReader.Close();
aWriter.Close();
ret=RPipe::Destroy(cPipeName);
test_KErrNone(ret);
return ;
} // End TestMultiThreadNamedPipes ()
/****************************************************************************
This is a function to test UnNamed pipes in Multi threaded environment.
Check the functionality of following library functions
- Create()
- Read()
- Write()
- ReadBlocking()
- WriteBlocking()
******************************************************************************/
void TestMultiThreadUnNamedPipes() {
TInt ret; // Return Value variable.
RPipe aReader,aWriter; // Used to pass to thread.
TInt aSize; // Used to pass to thread.
TBuf8<250> cPipeReadData;
TInt aReadSize;
TBufC8<50> cTestData(KTestData); // Test Data
///////////////////////////////////////////////////////////
// PART : 1 ///
// Test Read and Write Functionality ///
///////////////////////////////////////////////////////////
test.Next(_L("PIPE TEST: 3.1 Create Pipe : Check for no erros on Pipe Creation \n"));
ret = 100;
aSize = 22; // Size of KTestData * 10
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess ,//TOwnerType aTypeW
EOwnerProcess //TOwnerType aTypeW
);
test (ret == KErrNone);
// Create TData object to pass Pipe handles.
TData data1( &aReader, &aWriter);
// Create Thread ( Note : Thread is in pending state now)
// Create test data stream.
test.Next(_L("PIPE TEST: 3.2 Write Function test : Write data into the pipe \n"));
ret = aWriter.Write(cTestData,cTestData.Length()); // Write ""Pipe Data To Be Passed"
test (ret == cTestData.Length());
// Keep writing the data into pipe till it overflows
test.Next(_L("PIPE TEST: 3.3 Write Data till the Pipe returns KErrOverFlow\n"));
ret = aWriter.Write(cTestData,cTestData.Length());
test ( ret == KErrOverflow);
TTestThread thread2(KThread2Name, TestThread2, &data1);
// Thread2
// Read 1 byte data from pipe
// Validate data
// Read aByte size data
// Validate data
// Thread 2
// Read aByte size data
// User:: After (10000)
// Keep reading data till zero return
// return
// Stop the thread , Close it.
ret = thread2.WaitForExitL();
test_KErrNone(ret);
aReader.Close();
aWriter.Close();
///////////////////////////////////////////////////////////
// PART : 2 ///
// Test ReadBlocking and WriteBlocking Functionality ///
///////////////////////////////////////////////////////////
aSize = 22; // Size of KTestData
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess , //TOwnerType aTypeW
EOwnerProcess //TOwnerType aTypeW
);
test_KErrNone(ret);
// Create TData object to pass Pipe handles.
TData data2(&aReader, &aWriter);
// Flush the data if any in pipe to make sure its empty.
aWriter.Flush();
// Start the thread
TTestThread thread3(KThread3Name, TestThread3, &data2);
// Thread 3
// Write one byte of data
// Write one one byte of data using WriteBlocking call
// Write aByte size data using Writblocking call
// Call Readblocking function.Read one byte of data.
aReadSize = 1;
test.Next(_L("PIPE TEST: 3.4 : Call readblocking and read one byte of data \n"));
ret = aReader.ReadBlocking(cPipeReadData,aReadSize);
// Call goes to Thread 3
test_Equal(aReadSize, ret);
test.Next(_L("PIPE TEST: 3.5 : Validate the data \n"));
test_Equal(0, cPipeReadData.Compare(KTestData1));
// Call Readblocking function.Read aSize bytes of data.
test.Next(_L("PIPE TEST: 3.6 : Read remaining data \n"));
aReadSize = 21;
ret = aReader.ReadBlocking(cPipeReadData,aReadSize);
test_Equal(aReadSize, ret);
test_Equal(0, cPipeReadData.Compare(KTestData3));
test.Next(_L("PIPE TEST: 3.7 : Read complete pipe size data \n"));
aReadSize = 22;
ret = aReader.ReadBlocking(cPipeReadData,aReadSize);
test_Equal(aReadSize, ret);
test_Equal(0, cPipeReadData.Compare(KTestData2));
// Wait for thread to end and Close
ret = thread3.WaitForExitL();
test_KErrNone(ret);
aReader.Close();
aWriter.Close();
return ;
}// End TestMultiThreadUnNamedPipes()
/****************************************************************************
This is a function to test Named pipes in Single threaded environment.
Check the functionality of following library functions
- Define ()
-
******************************************************************************/
void TestSingleThreadNamedPipes()
{
const TBufC<50> cPipeName(KPipe1Name); // Descriptor to hold data for Writing.
TInt aSize, ret;
RPipe testPipe1;
RPipe testPipe2;
RPipe testPipe3;
RPipe testPipe4;
RPipe testPipe5;
const TBufC<100> cPipeNameMax(KMaxPipeName);
const TBufC<100> cPipeNameMaxPlusOne(KMaxPipeNamePlusOne);
_LIT(KBadName , "***?SFSDFWE?*_-");
_LIT(KBadName2 , "");
test.Next(_L("PIPE TEST: 2.1 Define Function test : Check for No Error\n"));
aSize = 10;
ret = RPipe::Define(cPipeName , aSize);
test (ret == KErrNone);
ret = RPipe::Destroy (cPipeName);
test (ret == KErrNone);
test.Next(_L("PIPE TEST: 2.2 Define Function test : Check for Max length \n"));
aSize = 10;
ret = RPipe::Define(cPipeNameMax , aSize);
test (ret == KErrNone);
ret = RPipe::Destroy (cPipeNameMax);
test (ret == KErrNone);
test.Next(_L("PIPE TEST: 2.3 Define Function test : Check for Max length \n"));
aSize = 10;
ret = RPipe::Define(cPipeNameMaxPlusOne , aSize);
test (ret == KErrBadName);
ret = RPipe::Destroy (cPipeNameMaxPlusOne);
test (ret == KErrBadName);
test.Next(_L("PIPE TEST: 2.4 Open Function test : Test Open \n"));
aSize = 10;
ret = RPipe::Define(cPipeName , aSize);
test_KErrNone(ret);
ret = testPipe1.Open(KBadName,RPipe::EOpenToRead);
test (ret == KErrBadName);
ret = testPipe1.Open(KBadName2,RPipe::EOpenToRead);
test (ret == KErrBadName);
ret = testPipe1.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrNone);
ret = testPipe1.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrInUse);
test.Next(_L("PIPE TEST: 2.5 Destroy Function test : Destroy opened pipe error \n"));
ret = RPipe::Destroy (cPipeName);
test (ret == KErrInUse);
test.Next(_L("PIPE TEST: 2.6 Open Function test : Reopen pipe for reading\n"));
ret = testPipe2.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrInUse);
test.Next(_L("PIPE TEST: 2.7 Open Function test : Bad name test \n"));
ret = testPipe2.Open(cPipeNameMaxPlusOne,RPipe::EOpenToRead);
test (ret == KErrBadName);
test.Next(_L("PIPE TEST: 2.8 Open Function test : Write mode test\n"));
ret = testPipe3.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
ret = testPipe3.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrInUse);
test.Next(_L("PIPE TEST: 2.9 Open Function test : Bad name test \n"));
ret = testPipe4.Open(cPipeNameMaxPlusOne,RPipe::EOpenToWrite);
test (ret == KErrBadName);
test.Next(_L("PIPE TEST: 2.10 Open Function test : Reopen for writing \n"));
ret = testPipe4.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrInUse);
// Do we have pipes created ? Close and Destroy them ....!!
testPipe1.Close();
testPipe2.Close();
testPipe3.Close();
testPipe4.Close();
ret = RPipe::Destroy (cPipeName);
test_KErrNone(ret);
test.Next(_L("PIPE TEST: 2.11a Open Function test : Write But Fail on no Readers mode before pipe defined\n"));
ret = testPipe1.Open(cPipeName,RPipe::EOpenToWriteNamedPipeButFailOnNoReaders);
test_Equal(KErrNotFound,ret);
test.Next(_L("PIPE TEST: 2.11 Open Function test : Write But Fail on no Readers mode Error test\n"));
ret = RPipe::Define(cPipeName , aSize);
test (ret == KErrNone);
ret = testPipe1.Open(cPipeName,RPipe::EOpenToWriteNamedPipeButFailOnNoReaders);
test (ret == KErrNotReady);
test.Next(_L("PIPE TEST: 2.12 Open Function test : Write But Fail on no Readers mode Success test\n"));
ret = testPipe1.Open(cPipeName,RPipe::EOpenToRead);
test_KErrNone(ret);
ret = testPipe2.Open(cPipeName,RPipe::EOpenToWriteNamedPipeButFailOnNoReaders);
test ( ret == KErrNone);
// Do we have pipes created ? Close and Destroy them ....!!
testPipe1.Close();
testPipe2.Close();
testPipe3.Close();
testPipe4.Close();
ret = RPipe::Destroy (cPipeName);
test_KErrNone(ret);
test.Next(_L(" 2.13 Define Function test : Check Incorrect Size\n"));
aSize = -1;
ret = RPipe::Define(cPipeName , aSize);
test (ret == KErrArgument);
test.Next(_L("PIPE TEST: 2.14 Define Function test : Check Incorrect Size\n"));
aSize = 0x1fffffff;
ret = RPipe::Define(cPipeName , aSize);
test (ret == KErrNoMemory);
test.Next(_L("PIPE TEST: 2.15 Size Function test : Size\n"));
aSize = 10;
ret = RPipe::Define(cPipeName , aSize);
ret = testPipe5.MaxSize();
test (ret == KErrBadHandle);
test.Next(_L("PIPE TEST: 2.16 Size Function test : Size\n"));
aSize = 10;
ret = RPipe::Define(cPipeName , aSize);
testPipe5.Open(cPipeName, RPipe::EOpenToRead);
testPipe4.Open(cPipeName, RPipe::EOpenToWrite);
ret = testPipe5.MaxSize();
test (ret == aSize);
ret = testPipe4.MaxSize();
test (ret == aSize);
/* Close all the pipes and Destroy*/
testPipe1.Close();
testPipe2.Close();
testPipe3.Close();
testPipe4.Close();
testPipe5.Close();
ret = RPipe::Destroy (cPipeName);
test_KErrNone(ret);
_LIT(KRedefinePipe , "REDEFINEPIPE");
test.Next(_L("PIPE TEST: 2.17 Check for Redefining same pipe name \n"));
ret = RPipe::Define(KRedefinePipe , aSize);
test_KErrNone(ret);
ret = RPipe::Define(KRedefinePipe , aSize);
test (ret == KErrAlreadyExists);
ret = RPipe::Destroy (KRedefinePipe);
test_KErrNone(ret);
test.Next(_L("PIPE TEST: 2.18 Open Function test : Bad Pipe name\n"));
aSize = 10;
RPipe testPipe6;
ret = testPipe6.Open(cPipeName, RPipe::EOpenToRead);
test (ret == KErrNotFound);
const TBufC<50> cPipeNameNull;
test.Next(_L("PIPE TEST: 2.19 Define Function test : Null Pipe name and Bad Pipe name\n"));
aSize = 10;
ret = RPipe::Define(cPipeNameNull , aSize);
test (ret == KErrBadName);
ret = RPipe::Define(KBadName , aSize);
test (ret == KErrBadName);
ret = RPipe::Destroy(KBadName);
test (ret == KErrBadName);
ret = RPipe::Define(KBadName2 , aSize);
test (ret == KErrBadName);
ret = RPipe::Destroy(KBadName2);
test (ret == KErrBadName);
test.Next(_L("PIPE TEST: 2.20 Destroy a pipe while Write end is open\n"));
ret = RPipe::Define(cPipeName , aSize);
testPipe1.Close();
ret = testPipe1.Open(cPipeName,RPipe::EOpenToRead);
test (ret == KErrNone);
testPipe2.Close();
ret = testPipe2.Open(cPipeName,RPipe::EOpenToWrite);
test (ret == KErrNone);
testPipe1.Close();
ret = RPipe::Destroy (cPipeName);
test (ret == KErrInUse);
testPipe2.Close();
ret = RPipe::Destroy (cPipeName);
test (ret == KErrNone);
testPipe1.Close();
testPipe2.Close();
testPipe3.Close();
testPipe4.Close();
testPipe5.Close();
_LIT(KPipe1Name,"TestPipeA");
_LIT(KPipe2Name,"TestPipeB");
_LIT(KPipe3Name,"TestPipeC");
_LIT(KPipe4Name,"TestPipeD");
test.Next(_L("PIPE TEST: 2.21 Define Four pipes and Destroy in different sequence ( Code Coverage test)\n"));
ret = RPipe::Define(KPipe1Name , aSize);
test (ret == KErrNone);
ret = RPipe::Define(KPipe2Name , aSize);
test (ret == KErrNone);
ret = RPipe::Define(KPipe3Name , aSize);
test (ret == KErrNone);
ret = RPipe::Define(KPipe4Name , aSize);
test (ret == KErrNone);
ret = RPipe::Destroy (KPipe2Name);
test (ret == KErrNone);
ret = RPipe::Destroy (KPipe4Name);
test (ret == KErrNone);
ret = RPipe::Destroy (KPipe1Name);
test (ret == KErrNone);
ret = RPipe::Destroy (KPipe3Name);
test (ret == KErrNone);
return;
} // End TestSingleThreadNamedPipes()
/****************************************************************************
This is a function to test UnNamed pipes in Single threaded environment.
Check the functionality of following library functions
- Create ()
-
******************************************************************************/
_LIT8(KTxtDataToSend,"*Test data to send**");
void TestSingleThreadUnNamedPipes() {
TInt ret = 1; // Return value test variable.
TInt aSize;
TBufC8<40> wData(KTxtDataToSend); // Descriptor to hold data for Writing.
RPipe aReader,aWriter;
RPipe aReader2,aWriter2;
// Following tests will verify all the APIs in single thread
// for all the possible return values.
// This is to verify different paths of API
// not for detail functional verification.
// Create the Pipe and Check for No Errors when Valid parameters are passed.
test.Next(_L("PIPE TEST:1.1 Create Function test : Check for No Error\n"));
aSize = 10;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess //TOwnerType aTypeW
);
test (ret == KErrNone);
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess //TOwnerType aTypeW
);
test (ret == KErrInUse);
aWriter.Close();
aReader.Close();
// How big pipe we can create ?
test.Next(_L("PIPE TEST:1.2 Create Function test : Check for No Memory\n"));
aSize = 0x1BCDEFFF;
ret = RPipe::Create( aSize,
aReader2,
aWriter2,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess //TOwnerType aTypeW
);
test (ret == KErrNoMemory);
aReader2.Close();
aWriter2.Close();
test.Next(_L("PIPE TEST:1.3 Create Function test : Check for Reopening pipe\n"));
aSize = 10;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test_KErrNone(ret);
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test (ret == KErrInUse);
aReader.Close();
aWriter.Close();
test.Next(_L("PIPE TEST:1.4 Read/Write Function test : Check for Writing to pipe\n"));
aSize = 100;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test_KErrNone(ret);
ret=aWriter.Write(wData , wData.Size());
test (ret == wData.Size() );
ret=aWriter.Write(wData , -1);
test (ret == KErrArgument );
test.Next(_L("PIPE TEST:1.5 Read/Write Function test : Check for Reading from pipe\n"));
TBuf8<100> rData ;// Descriptor for reading data from Pipe.
ret=aReader.Read(rData,wData.Size()); // Length of the data to be read from Pipe
test (ret == wData.Size());// Length of the data read from the Pipe
test.Next(_L("PIPE TEST:1.6 Read/Write Function test : Validate data received\n"));
test (KErrNone == rData.Compare(wData));
test.Next(_L("PIPE TEST:1.7 Read/Write Function test : Check for Reading from pipe\n"));
ret=aReader.Read(rData,1);
test (ret == 0);
{
RPipe aReaderT, aWriterT;
aSize = 20;
ret = RPipe::Create( aSize,
aReaderT,
aWriterT,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test_KErrNone(ret);
ret=aWriterT.Write(wData ,15);
test_Equal(15, ret);
ret = aReaderT.Read(rData,10);
test_Equal(10, ret);
ret=aWriterT.Write(wData ,10);
test_Equal(10, ret);
ret = aReaderT.Read(rData,20);
test (ret ==15);
ret = aReaderT.Read(rData,5);
test_Equal(0, ret);
ret = aReaderT.Read(rData,25);
test_Equal(0, ret);
aReaderT.Close();
aWriterT.Close();
}
test.Next(_L("PIPE TEST:1.8 Read/Write Function test : Check for Wrong RPipe Handle\n"));
ret=aWriter.Read(rData,15 );// Length of the data to be read from Pipe
test (ret == KErrAccessDenied );
test.Next(_L("PIPE TEST:1.9 Read/Write Function test : Check for Wrong RPipe Handle\n"));
ret=aReader.Write(rData,rData.Size());
test (ret == KErrAccessDenied );
test.Next(_L("PIPE TEST:1.10 Read/Write Function test : Check for write overflow\n"));
ret=aWriter.Write(wData,wData.Size());
ret=aWriter.Write(wData,wData.Size());
ret=aWriter.Write(wData,wData.Size());
ret=aWriter.Write(wData,wData.Size());
ret=aWriter.Write(wData,wData.Size());
ret=aWriter.Write(wData,wData.Size());
test (ret == KErrOverflow );
test.Next(_L("PIPE TEST:1.11 MaxSize Function test : MaxSize Check \n"));
aSize = 10;
// Just to be on safer side , close pipes if any.
aReader.Close();
aWriter.Close();
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test (ret == KErrNone); // This error condition is not defined yet.
ret =aReader.MaxSize();
test (ret == aSize);
test.Next(_L("PIPE TEST:1.12 Size Function test : Size Check \n"));
rData.Zero();
ret = aReader.Size();
test_Equal(0, ret);
_LIT8(KSizeTestData1,"123456789");
ret = aWriter.Write(KSizeTestData1,9);
test_Equal(9, ret);
ret = aReader.Size();
test_Equal(9, ret);
ret = aReader.Read(rData,1);
test_Equal(1, ret);
ret = rData.Compare(_L8("1"));
test_KErrNone(ret);
ret = aReader.Size();
test_Equal(8, ret);
_LIT8(KSizeTestData2,"ab");
ret = aWriter.Write(KSizeTestData2,2);
test_Equal(2, ret);
ret = aReader.Size();
test_Equal(10, ret);
ret = aWriter.Write(KSizeTestData2,1);
test_Equal(KErrOverflow, ret);
ret = aReader.Size();
test_Equal(10, ret);
ret = aReader.Read(rData,9);
test_Equal(9, ret);
ret = rData.Compare(_L8("23456789a"));
test_KErrNone(ret);
ret = aReader.Size();
test_Equal(1, ret);
ret = aReader.Read(rData,1);
test_Equal(1, ret);
ret = rData.Compare(_L8("b"));
test_KErrNone(ret);
ret = aReader.Size();
test_Equal(0, ret);
ret = aWriter.Size();
test_Equal(0, ret);
RPipe WrongPipeHandle;
ret = WrongPipeHandle.Size();
test ( ret == KErrBadHandle);
test.Next(_L("PIPE TEST:1.13 Size Function test : Size Function call with Wrong handle \n"));
ret = WrongPipeHandle.MaxSize();
test (ret == KErrBadHandle);
aReader.Close();
aWriter.Close();
aReader2.Close();
aWriter2.Close();
test.Next(_L("PIPE TEST:1.14 Read Function : KErrNotReady \n"));
aSize = 10;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test (ret == KErrNone); // This error condition is not defined yet.
aWriter.Close();
ret = aReader.Read(rData,aSize);
test (ret == KErrNotReady);
ret = aReader.Read(rData,110);
test (ret == KErrArgument);
test.Next(_L("PIPE TEST:1.15 Check Handle Type function \n"));
aReader.Close();
aWriter.Close();
aSize = 10;
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test_KErrNone(ret);
ret = aReader.HandleType();
test (ret == RPipe::EReadChannel);
ret = aWriter.HandleType();
test (ret == RPipe::EWriteChannel);
aReader.Close();
ret = aReader.HandleType();
test (ret == KErrBadHandle);
test.Next(_L("PIPE TEST:1.16 Write Function : KErrNotReady \n"));
aSize = 1;
ret = aWriter.Write(wData,aSize);
test (ret == KErrNotReady);
test.Next(_L("PIPE TEST:1.17 Write Function : Write data more than size of Descriptor \n"));
ret = aWriter.Write(wData,110);
test (ret == KErrArgument);
test.Next(_L("PIPE TEST:1.18 Write Function : KErrCompletion \n"));
aWriter.Close();
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test_KErrNone(ret);
ret = aWriter.Write(wData,wData.Size());
test (ret == KErrOverflow);
test.Next(_L("PIPE TEST:1.19 Create Function : KErrInUse \n"));
aReader.Close();
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test (ret == KErrInUse);
aWriter.Close();
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test (ret == KErrNone);
aWriter.Close();
ret = RPipe::Create( aSize,
aReader,
aWriter,
EOwnerProcess,//TOwnerType aTypeW
EOwnerProcess//TOwnerType aTypeW
);
test (ret == KErrInUse);
test.Next(_L("PIPE TEST:1.20 Read / Write using un opened handles \n"));
RPipe aReaderT,aWriterT;
ret = aWriterT.Write(wData,wData.Size());
test (ret == KErrBadHandle);
ret = aReaderT.Read(rData,aSize);
test (ret == KErrBadHandle);
// Close all the pipes and return the resources.
aReader.Close();
aWriter.Close();
aReader2.Close();
aWriter2.Close();
return;
} // End TestSingleThreadUnNamedPipes()
/****************************************************************************
This is a function to test UnNamed pipes and named pipes in Single
threaded environment.
This test ensures that the memory is actually being released when:
RPipe::Close() is called for unnamed pipes and
RPipe::Destroy() is called for named pipes.
******************************************************************************/
void TestCreateClosePipe()
{
//unnamed pipes
RPipe readHandle, writeHandle;
const TInt K3MB = 1024*1024*3;
// The loop is run ten times to ensure that if memory allocated while pipe
// creation is not deallocated by close,then creation of pipe will fail with
// KErrNoMemory in the sixth iteration. Default heap size is assumed.
TInt i;
test.Next(_L("PIPE TEST:11.1 Create Function test in a loop : Check for No Error\n"));
for(i=1; i<10; i++)
{
TInt r = RPipe::Create(K3MB, readHandle, writeHandle,EOwnerProcess, EOwnerProcess);
test(KErrNone == r);
readHandle.Close();
writeHandle.Close();
}
//named pipes
_LIT(KPipeName, "testPipe");
// The loop is run ten times to ensure that if memory allocated while pipe
// creation is not deallocated by destroy,then creation of pipe will fail with
// KErrNoMemory in the sixth iteration. Default heap size is assumed.
test.Next(_L("PIPE TEST:11.2 Define Function test in a loop : Check for No Error\n"));
for(i=1; i<10; i++)
{
TInt r = RPipe::Define(KPipeName,K3MB);
test(KErrNone == r);
r = RPipe::Destroy(KPipeName);
test(KErrNone == r);
}
}// End TestCreateClosePipe()
struct TStressArgs
{
TStressArgs(TInt aIter, TInt aSize)
:iIter(aIter), iSize(aSize)
{}
const TInt iIter;
const TInt iSize;
};
struct TDefDesArgs: public TStressArgs
{
TDefDesArgs(TInt aIter, TInt aSize, const TDesC& aName)
:TStressArgs(aIter,aSize), iName(aName)
{}
const TDesC& iName;
};
/**
Repeatedly define and destroy named pipe
*/
TInt DefineDestroy(TAny* aArgs)
{
const TDefDesArgs args = *static_cast<TDefDesArgs*>(aArgs);
for(TInt i=0; i<args.iIter; i++)
{
TInt r = RPipe::Define(args.iName, args.iSize);
if(r!=KErrNone && r!=KErrAlreadyExists)
{
return r;
}
r = RPipe::Destroy(args.iName);
if(r!=KErrNone && r!=KErrInUse && r!=KErrNotFound)
{
return r;
}
}
return KErrNone;
}
/**
The parent thread will try to repeatedly open and close a named pipe
which is being repeatedly created and destroyed by the child thread.
This attempts to catch race conditions.
*/
void TestRapidDefineDestroy()
{
const TInt iterations=1000;
TDefDesArgs args(iterations, 16, KPipe1Name);
RPipe pipe;
TTestThread thread(_L("DefineDestroy"), DefineDestroy, &args);
TInt r=KErrNone;
for(TInt i=0; i<args.iIter; i++)
{
r = pipe.Open(args.iName, RPipe::EOpenToWrite);
if(r!=KErrNone && r !=KErrNotFound)
{
test_KErrNone(r);
}
pipe.Close();
}
r = thread.WaitForExitL();
test_KErrNone(r);
}
/**
Write the descriptor specified in to the pipe repeating
as many times as specified by TData::iIterations
*/
TInt WriteThread(TAny* aData)
{
TData& data = *static_cast<TData*>(aData);
const TInt iter = data.iIterations;
TInt write=0;
for(TInt i=0; i<iter; i++)
{
write = data.iWriteEnd->WriteBlocking(*data.iPipeData, data.iPipeData->Size());
if(write <KErrNone)
{
return write;
}
}
return write*iter;
}
/**
Fill descriptor with random bytes
*/
void FillRandom(TDes8& aDes)
{
aDes.Zero();
while(aDes.Size()+4<=aDes.MaxSize())
{
TUint8 rand[4];
*(TUint32*)rand = Math::Random();
aDes.Append(rand, 4);
}
}
/**
@param aTotalBytes Bytes transfered in period
@param aTicks number of ticks elapsed in period
@return The rate of the transfer on kilobytes per second
*/
TReal KiloBytesPerSecond(TInt aTotalBytes, TInt aTicks)
{
TInt period=0; //period of nanotick in microseconds
TInt r = HAL::Get(HAL::ENanoTickPeriod, period);
User::LeaveIfError(r);
//we use the definition that a kilobytes is 1000 bytes
TReal result = (aTotalBytes/(aTicks*period/1000));
return result;
}
/**
Create a source data buffer of aTotal bytes and fill with random data.
Create a pipe and thread (WriteThread) to write the source buffer
into the pipe.
Read from the pipe into destination buffer
and optionally verify that buffers match
@param aTotal Size of data buffer
@param aPipeData Size of pipe to create
@param aIter number of times to repeat transfer
@param aVerify Confirm that destination buffer matches source buffer
@param aPollRead read pipe by polling instead of using blocking read
@return Total number of ticks elapsed
*/
TInt TestLoopBack(TInt aTotal, TInt aPipeSize, TInt aIter, TBool aVerify=ETrue, TBool aPollRead=EFalse)
{
const TInt bufferSize = aTotal;
RBuf8 sourceBuffer;
sourceBuffer.CreateL(bufferSize);
FillRandom(sourceBuffer);
test_Equal(bufferSize,sourceBuffer.Size());
const TInt pipeSize=aPipeSize;
RPipe readEnd, writeEnd;
TInt r = RPipe::Create(pipeSize, readEnd, writeEnd ,EOwnerProcess, EOwnerProcess);
test_KErrNone(r);
const TInt maxIter=aIter;
TData data(NULL, &writeEnd, &sourceBuffer, maxIter);
RBuf8 destBuffer;
destBuffer.CreateL(bufferSize);
RBuf8 tempBuffer;
tempBuffer.CreateL(bufferSize);
TTestThread writer(_L("LoopBack"), WriteThread, &data);
const TUint32 startTicks=User::NTickCount();
for(TInt iter=0; iter<maxIter; iter++)
{
TInt remainingData = bufferSize;
do
{
const TInt toRead = Min(pipeSize,remainingData);
if(aPollRead)
{
//an inefficient way to read a pipe!
r = readEnd.Read(tempBuffer, toRead);
test_NotNegative(r);
}
else
{
r = readEnd.ReadBlocking(tempBuffer, toRead );
test_Equal(toRead, r);
}
destBuffer+=tempBuffer;
tempBuffer.Zero();
remainingData-=r;
}
while(remainingData);
if(aVerify)
{
r = sourceBuffer.Compare(destBuffer);
test_KErrNone(r);
}
destBuffer.Zero();
}
const TUint32 endTicks = User::NTickCount();
r = writer.WaitForExitL();
test_Equal(bufferSize*maxIter, r);
const TUint32 ticksElapsed= endTicks - startTicks;
sourceBuffer.Close();
tempBuffer.Close();
destBuffer.Close();
readEnd.Close();
writeEnd.Close();
return ticksElapsed;
}
/**
Simple test to confirm that data is reproduced after being fed through a pipe
*/
void TestTransferIntegrity()
{
TestLoopBack(128*1024, 128, 1, ETrue);
TestLoopBack(1024, 1, 1, ETrue);
//read by constantly polling
TestLoopBack(128*1024, 1024, 1, ETrue, ETrue);
}
/**
Enable Writeblocking and Readblocking notifications
without actual reads and writes
*/
class RTestPipe: public RPipe
{
public:
void RequestWriteBlocking(TInt aNumByte, TRequestStatus& aStatus)
{
DoRequest(EWriteBlocking, aStatus, &aNumByte);
}
void RequestReadBlocking(TRequestStatus& aStatus)
{
DoRequest(EReadBlocking, aStatus);
}
};
/**
A test which will request some type of notification
*/
struct CNotificationTest : public TFunctor
{
CNotificationTest(RTestPipe& aPipe)
:iPipe(aPipe)
{
TInt r = iParent.Open(iParent.Id());
test_KErrNone(r);
}
virtual ~CNotificationTest()
{
}
void operator()()
{
RunTest();
//set up rendezvous with parent
iParent.Rendezvous(iRendezvousStatus);
//announce we have run test
RThread::Rendezvous(KErrNone);
//wait untill parent has reached rendezvous
User::WaitForRequest(iRendezvousStatus);
}
virtual CNotificationTest* Clone()=0;
/**
If necessary, gets pipe into correct state for the start of test
*/
virtual void PreparePipe() =0;
virtual void RunTest() =0;
/**
Cancel the notification
*/
virtual void Cancel() =0;
virtual TInt GetReturn()
{
return iStatus.Int();
}
RTestPipe& iPipe;
TRequestStatus iStatus;
TRequestStatus iRendezvousStatus;
RThread iParent;
};
/**
Will request free space notification
*/
struct CSpaceNotificationTest : public CNotificationTest
{
typedef void (RTestPipe::*TSpaceNotification) (TInt, TRequestStatus&);
/**
@param aPipe Pipe handle to use
@param TSpaceNotification A pointer for the method to test
@param aNumBytes Amount of space to request
*/
CSpaceNotificationTest(RTestPipe& aPipe, TSpaceNotification aFunc, TInt aNumBytes)
:CNotificationTest(aPipe), iFn(aFunc), iNumBytes(aNumBytes)
{}
CNotificationTest* Clone()
{
return new CSpaceNotificationTest(*this);
}
void RunTest()
{
(iPipe.*iFn)(iNumBytes, iStatus);
}
//Make sure space notification won't complete immediately
void PreparePipe()
{
TInt freeSpace = iPipe.MaxSize() - iPipe.Size();
if(freeSpace >= iNumBytes)
{
TInt r = iPipe.Write(KTestData, freeSpace);
test_Equal(freeSpace, r);
}
}
void Cancel()
{
iPipe.CancelSpaceAvailable();
};
TSpaceNotification iFn;
TInt iNumBytes;
};
struct CDataNotificationTest : public CNotificationTest
{
typedef void (RTestPipe::*TDataNotification) (TRequestStatus&);
CDataNotificationTest(RTestPipe& aPipe, TDataNotification aFunc)
:CNotificationTest(aPipe), iFn(aFunc)
{}
CNotificationTest* Clone()
{
return new CDataNotificationTest(*this);
}
void RunTest()
{
(iPipe.*iFn)(iStatus);
}
//make sure we start with an empty pipe
void PreparePipe()
{
iPipe.Flush();
}
void Cancel()
{
iPipe.CancelDataAvailable();
};
TDataNotification iFn;
};
void ProcessNotificationTests(RPointerArray<CNotificationTest>& aArray)
{
const TInt count = aArray.Count();
for(TInt i=0; i < count; i++)
{
for(TInt j=0; j < count; j++)
{
//need copies as objects contain request states
CNotificationTest* testA = aArray[i]->Clone();
test_NotNull(testA);
CNotificationTest* testB = aArray[j]->Clone();
test_NotNull(testB);
testA->PreparePipe(); testB->PreparePipe();
TTestThread a(_L("CNotificationTestA"), *testA, EFalse);
TTestThread b(_L("CNotificationTestB"), *testB, EFalse);
TRequestStatus rendezvousA, rendezvousB;
a.Rendezvous(rendezvousA);
b.Rendezvous(rendezvousB);
a.Resume(); b.Resume();
//wait till after threads have made notification request.
User::WaitForRequest(rendezvousA);
User::WaitForRequest(rendezvousB);
TInt retA = testA->GetReturn(); TInt retB = testB->GetReturn();
//announce that we have read status requests, allowing
//child threads to terminate
RThread::Rendezvous(KErrNone);
a.WaitForExitL();
b.WaitForExitL();
TBool oneRequestSupported = ((retA == KRequestPending) && (retB == KErrInUse))
|| ((retB == KRequestPending) && (retA == KErrInUse));
TBool bothSupported = (retA == KRequestPending) && (retB == KRequestPending);
if(!(oneRequestSupported || bothSupported))
{
test.Printf(_L("Failure: i=%d, j=%d"), i, j);
test(EFalse);
}
testA->Cancel(); testB->Cancel();
delete testA;
delete testB;
}
}
}
/**
Test abillity of pipe channels to handle multiple notification requests
simultaneously.
*/
void TestNotifications()
{
RTestPipe readEnd, writeEnd;
TInt pipeSize = 5;
TInt r = RPipe::Create(pipeSize, readEnd, writeEnd, EOwnerProcess, EOwnerProcess);
test_KErrNone(r);
test.Next(_L("Test write end requests"));
CSpaceNotificationTest writeBlocking(writeEnd, &RTestPipe::RequestWriteBlocking, pipeSize);
CSpaceNotificationTest spaceAvailable(writeEnd, &RTestPipe::NotifySpaceAvailable, pipeSize);
RPointerArray<CNotificationTest> writeEndTests;
writeEndTests.AppendL(&writeBlocking);
writeEndTests.AppendL(&spaceAvailable);
for(TInt i=0; i<10; i++)
{
ProcessNotificationTests(writeEndTests);
}
writeEndTests.Close();
test.Next(_L("Test read end requests"));
CDataNotificationTest readBlocking(readEnd, &RTestPipe::RequestReadBlocking);
CDataNotificationTest dataAvailable(readEnd, &RTestPipe::NotifyDataAvailable);
RPointerArray<CNotificationTest> readEndTests;
readEndTests.AppendL(&readBlocking);
readEndTests.AppendL(&dataAvailable);
for(TInt j=0; j<10; j++)
{
ProcessNotificationTests(readEndTests);
}
readEndTests.Close();
readEnd.Close();
writeEnd.Close();
}
LOCAL_C void RunTests(void)
{
// Test UnNamed Pipes in Single Thread
test.Next(_L("PIPE TEST: 1.Un Named pipes in Single Thread\n"));
TestSingleThreadUnNamedPipes();
// Test Named Pipes in Single Thread
test.Next(_L("PIPE TEST: 2.Named pipes in Single Thread\n"));
TestSingleThreadNamedPipes();
// Test UnNamed Pipes in MultiThread
test.Next(_L("PIPE TEST: 3.Un Named pipes in Multi Thread\n"));
TestMultiThreadUnNamedPipes();
// Test Named Pipes in MultiThread
test.Next(_L("PIPE TEST: 4.Named pipes in Multi Thread\n"));
TestMultiThreadNamedPipes();
// Test Named Pipes in Multi Process
test.Next(_L("PIPE TEST: 5.Named pipes in Multi Process\n"));
TestMultiProcessNamedPipes();
// Test Notify mechanism
test.Next(_L("PIPE TEST: 6.Pipes Notify mechanism test\n"));
TestNotifyMechanismPipes();
// Test Wait Mechanism
test.Next(_L("PIPE TEST: 7.Pipes Wait mechanism test\n"));
TestWaitMechanismPipes();
// Test Pipes performance
test.Next(_L("PIPE TEST: 8.Pipes Permission test\n"));
TestPipesPermissionCheck ();
// Misc Pipe tests
test.Next(_L("PIPE TEST: 9.Misc Pipe tests\n"));
TestMiscPipes();
// Blocking and Notify method tests.
test.Next(_L("PIPE TEST: 10.Blocking and Notification calls test\n"));
TestBlockingAndNotify();
//Creation and closure of a large number of Pipes
test.Next(_L("PIPE TEST: 11. Creation and subsequent closure of a large number of pipes\n"));
TestCreateClosePipe();
test.Next(_L("Test concurrent notification requests"));
TestNotifications();
test.Next(_L("Repeatedly open a named pipe whilst it's being created and destroyed"));
TestRapidDefineDestroy();
test.Next(_L("Check integrity of data after transfer\n"));
TestTransferIntegrity();
test.Next(_L("PIPE TEST: Ending test.\n"));
return;
}
TInt ParseCommandLine()
{
TBuf<20> cmdLine;
//TInt r= cmdLine.Create(User::CommandLineLength());
//test_KErrNone(r);
User::CommandLine(cmdLine);
TLex lex(cmdLine);
TPtrC token=lex.NextToken();
if(token.Length()>0)
{
TInt os=token.Match(_L("-n*"));
if(os==0)
{
if(token.Length()>2)
lex.SkipAndMark(2-lex.TokenLength()); //set mark backwards to after the "-n"
token.Set(lex.NextToken());
if(token.Length()==0)
return KErrArgument;
TLex valLex(token);
TInt value;
TInt r=valLex.Val(value);
if(r<0)
return r;
else
return value;
}
else
{
return KErrArgument;
}
}
else
{
const TInt KDefaultRuns=1;
return KDefaultRuns;
}
}
GLDEF_C TInt E32Main()
// Main entry point for the test.
{
__UHEAP_MARK;
TInt ret = 0;
test.Start(_L("PIPE TEST: Testing"));
ret = RPipe::Init();
if ( ret != KErrNone && ret != KErrAlreadyExists)
{
test.Printf(_L("Fail to load RPIPE driver %d\n"),ret);
return KErrNone;
}
TName pddName(RPipe::Name());
ret = RPipe::Define (KPipe1Name,10);
test_KErrNone(ret);
User::FreeLogicalDevice(pddName);
ret = RPipe::Define (KPipe1Name,10);
test_Equal(KErrNotFound, ret);
ret = RPipe::Init();
if ( ret != KErrNone && ret != KErrAlreadyExists)
{
test.Printf(_L("Fail to load RPIPE driver %d\n"),ret);
return KErrNone;
}
TInt runs=ParseCommandLine();
if(runs>=0)
{
TBool forever=(runs==0);
for(TInt i=0; forever||(i<runs); ++i)
{
if(i!=0)
test.Next(_L("Next iteration"));
test.Start(_L("Starting Run")); //sub nest each test iteration
__UHEAP_MARK;
TRAP(ret, RunTests());
test_KErrNone(ret);
__UHEAP_MARKEND;
test.End();
}
}
else
{
test.Printf(_L("Usage: t_pipe -n N\n N is number of runs to do. If N=0 run forever"));
}
TName pddName2(RPipe::Name());
ret= User::FreeLogicalDevice(pddName2);
test_KErrNone(ret);
test.End();
test.Close();
__UHEAP_MARKEND;
return KErrNone;
}