Symaptic: os/persistentdata/featuremgmt/featuremgr/test/rtest/src/t

     1 // Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <e32test.h>

    17 #include <e32math.h>

    18 #include <featmgr.h>

    19 #include <featureuids.h>

    20 #include "featurepanics.h"

    21 #include <featurecontrol.h>

    22 #include <featurenotifier.h>

    23 #include "../src/inc/featmgrconfiguration.h"

    24 #include "../src/inc/featmgrclientserver.h"

    26 using namespace NFeature;

    28 static RTest TheTest(_L("t_fmgrbadclient"));

    30 const TInt KTestIterCount = 5000;

    32 enum TArgType

    33     {

    34     EIntArgType,

    35     ETextArgType,

    36     EBinArgType,

    37     ELastArgType

    38     };

    40 const TInt KMaxDesArgLen = 1000;

    42 //If the FeatMgr server crashes and the test receives KErrServerTerminated error, then the

    43 //next set will contain the last:

    44 // - iteration number;

    45 // - handle type;

    46 // - function code;

    47 // - handle;

    48 // - IPC arguments values;

    49 struct TThreadData

    50     {

    51     TInt                iIteration;

    52     TInt                iFunction;

    53     TArgType            iArgType[KMaxMessageArguments];

    54     TInt                iIntArg[KMaxMessageArguments];

    55     TBuf<KMaxDesArgLen> iTextArg[KMaxMessageArguments];

    56     TBuf8<KMaxDesArgLen> iBinArg[KMaxMessageArguments];

    57     TInt64              iSeed;

    58     };

    60 _LIT(KPanicCategory, "SrvTerm");

    61 _LIT(KPanicCategory2, "InvArg");

    62 const TInt KPanicCode = 1111;

    63 const TInt KPanicCode2 = 2222;

    65 ///////////////////////////////////////////////////////////////////////////////////////

    67 //Deletes all created test files.

    68 void DestroyTestEnv()

    69     {

    70     }

    72 ///////////////////////////////////////////////////////////////////////////////////////

    73 ///////////////////////////////////////////////////////////////////////////////////////

    74 //Test macros and functions

    75 void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)

    76     {

    77     if(!aValue)

    78         {

    79         DestroyTestEnv();

    80         if(aPrintThreadName)

    81             {

    82             RThread th;

    83             TName name = th.Name();

    84             RDebug::Print(_L("*** Expression evaluated to false. Thread %S, Line %d\r\n"), &name, aLine);

    85             }

    86         else

    87             {

    88             TheTest.Printf(_L("*** Expression evaluated to false. Line %d\r\n"), aLine);

    89             }

    90         TheTest(EFalse, aLine);

    91         }

    92     }

    93 void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)

    94     {

    95     if(aValue != aExpected)

    96         {

    97         DestroyTestEnv();

    98         if(aPrintThreadName)

    99             {

   100             RThread th;

   101             TName name = th.Name();

   102             RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue);

   103             }

   104         else

   105             {

   106             RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);

   107             }

   108         TheTest(EFalse, aLine);

   109         }

   110     }

   111 #define TEST(arg) ::Check1((arg), __LINE__)

   112 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

   113 #define TTEST(arg) ::Check1((arg), __LINE__, ETrue)

   114 #define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue)

   116 //////////////////////////////////////////////////////////////////////////////////////////////////

   118 static TInt StartFeatMgrServer()

   119     {

   120     RProcess server;

   121     const TUidType serverUid( KNullUid, KServerUid2, KNullUid );

   122     TInt err = server.Create( KServerExeName, // FeatMgrServer.exe

   123                            KNullDesC, // A descriptor containing data passed as

   124                                       // an argument to the thread function of

   125                                       // the new process's main thread, when it

   126                                       // is first scheduled.

   127                            serverUid, // FeatMgr server UID

   128                            EOwnerProcess ); // Ownership of this process handle

   130     // Return error code if we couldn't create a process

   131     if ( err == KErrNone )

   132         {

   133         // Rendezvous is used to detect server start

   134         TRequestStatus stat;

   135         server.Rendezvous( stat );

   137         if ( stat != KRequestPending )

   138             {

   139             server.Kill( KErrNone ); // Abort startup

   140             }

   141         else

   142             {

   143             server.Resume();  // Logon OK - start the server

   144             }

   146         User::WaitForRequest( stat ); // Wait for start or death

   148         // We can't use the 'exit reason' if the server paniced as this

   149         // is the panic 'reason' and may be '0' which cannot be distinguished

   150         // from KErrNone

   151         err = (server.ExitType() == EExitPanic)? KErrGeneral : stat.Int();

   153         // We can close the handle now

   154         server.Close();

   155         }

   157     return err;

   158     }

   160 //////////////////////////////////////////////////////////////////////////////////////////////////

   161 /////////////////////////////        RTestFeatMgrSession          ////////////////////////////////

   162 //////////////////////////////////////////////////////////////////////////////////////////////////

   164 class RTestFeatMgrSession : public RSessionBase

   165     {

   166 public:

   167     TInt Connect();

   168     void Close();

   169     TInt SendReceive(TInt aFunction);

   170     TInt SendReceive(TInt aFunction, const TIpcArgs& aArgs);

   171     void SendReceive(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus);

   173 private:

   174     TInt DoCreateSession();

   175     };

   177 TInt RTestFeatMgrSession::Connect()

   178     {

   179     TInt err = DoCreateSession();

   180     if(err != KErrNone && err != KErrAlreadyExists)

   181         {

   182         Close();

   183         }

   184     return err;

   185     }

   187 void RTestFeatMgrSession::Close()

   188     {

   189     RSessionBase::Close();

   190     }

   192 TInt RTestFeatMgrSession::SendReceive(TInt aFunction)

   193     {

   194     return RSessionBase::SendReceive(aFunction);

   195     }

   197 TInt RTestFeatMgrSession::SendReceive(TInt aFunction, const TIpcArgs& aArgs)

   198     {

   199     return RSessionBase::SendReceive(aFunction, aArgs);

   200     }

   202 void RTestFeatMgrSession::SendReceive(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus)

   203     {

   204     RSessionBase::SendReceive(aFunction, aArgs, aStatus);

   205     }

   207 TInt RTestFeatMgrSession::DoCreateSession()

   208     {

   209     const TInt KRetry( 2 );

   210     // Try this twice

   211     TInt retry( KRetry );

   212     TInt err( KErrNone );

   214     while ( retry > 0 )

   215         {

   216         // Try to create a FeatMgr Server session

   217         err = CreateSession(KServerProcessName,

   218                             TVersion(KServerVersionMajor, KServerVersionMinor, KServerVersionBuild),

   219                             KDefaultAsyncSlots);

   221         if ( err != KErrNotFound && err != KErrServerTerminated )

   222             {

   223             // KErrNone or unrecoverable error

   224             retry = 0;

   225             }

   226         else

   227             {

   228             // Return code was KErrNotFound or KErrServerTerminated.

   229             // Try to start a new FeatMgr Server

   230             err = StartFeatMgrServer();

   232             if ( err != KErrNone && err != KErrAlreadyExists )

   233                 {

   234                 // Unrecoverable error

   235                 retry = 0;

   236                 }

   237             }

   239         retry--;

   240         }

   242     return err;

   243     }

   245 void PrintIterationCount(TInt aIteration, TBool aFromThread = EFalse)

   246     {

   247     if((aIteration % 100) == 0)

   248         {

   249         TTime time;

   250         time.HomeTime();

   251         TDateTime dt = time.DateTime();

   252         TBuf<16> tbuf;

   253         tbuf.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());

   254         if(aFromThread)

   255             {

   256             RDebug::Print(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);

   257             }

   258         else

   259             {

   260             TheTest.Printf(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);

   261             }

   262         }

   263     }

   265 //Worker thread function.

   266 //It behaves as a malicious client. Connects to the FeatMgr server. In each test iteration generates some random values

   267 //for the function number, handle, IPC arguments. Then sends a command to the server using these

   268 //randomly generated values. If the server crashes and the thread function receives KErrServerTerminated error,

   269 //then the thread kills itself and the main thread will get KPanicCategory and KPanicCode as a reason for the

   270 //worker thread's death. The last set of randomly generated values will be stored in the memory, pointed by aData argument.

   271 TInt ThreadFunc1(void* aData)

   272     {

   273     __UHEAP_MARK;

   275     CTrapCleanup* tc = CTrapCleanup::New();

   276     TTEST(tc != NULL);

   278     TThreadData* p = static_cast <TThreadData*> (aData);

   279     TTEST(p != NULL);

   280     TThreadData& data = *p;

   282     RTestFeatMgrSession sess;

   283     TInt err = sess.Connect();

   284     TTEST2(err, KErrNone);

   286     while(++data.iIteration <= KTestIterCount)

   287         {

   288         PrintIterationCount(data.iIteration, ETrue);

   289         TIpcArgs args;

   290         data.iFunction = Math::Rand(data.iSeed) % (EFeatMgrSWIEnd + 1);//EFeatMgrSWIEnd - the last server message number (without resource checking IPCs))

   291         for(TInt i=0;i<KMaxMessageArguments;++i)

   292             {

   293             //Initialize arguments

   294             data.iArgType[i] = static_cast <TArgType> (Math::Rand(data.iSeed) % ELastArgType);

   295             switch(data.iArgType[i])

   296                 {

   297                 case EIntArgType:

   298                     data.iIntArg[i] = Math::Rand(data.iSeed) % 9711;

   299                     args.Set(i, data.iIntArg[i]);

   300                     break;

   301                 case ETextArgType:

   302                     {

   303                     TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;

   304                     data.iTextArg[i].SetLength(len);

   305                     args.Set(i, &data.iTextArg[i]);

   306                     }

   307                     break;

   308                 case EBinArgType:

   309                     {

   310                     TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;

   311                     data.iBinArg[i].SetLength(len);

   312                     args.Set(i, &data.iBinArg[i]);

   313                     }

   314                     break;

   315                 default:

   316                     User::Panic(KPanicCategory2, KPanicCode2);

   317                     break;

   318                 }

   319             }

   320         //Send arguments

   321         User::SetJustInTime(EFalse);

   322         TInt err = KErrNone;

   323         if(data.iFunction == EFeatMgrReqNotify)

   324             {

   325             TRequestStatus status;

   326             sess.SendReceive(data.iFunction, args, status);

   327             if(status == KRequestPending)

   328                 {

   329                 err = sess.SendReceive(EFeatMgrReqNotifyCancelAll);

   330                 }

   331             else

   332                 {

   333                 err = status.Int();

   334                 }

   335             }

   336         else

   337             {

   338             err = sess.SendReceive(data.iFunction, args);

   339             }

   340         if(err == KErrServerTerminated)

   341             {

   342             User::Panic(KPanicCategory, KPanicCode);

   343             }

   344         User::SetJustInTime(ETrue);

   345         }

   347     sess.Close();

   349     delete tc;

   351     __UHEAP_MARKEND;

   353     return KErrNone;

   354     }

   356 ////////////////////////////////////////////////////////////////////////////////////////////////////////////

   358 /**

   359 @SYMTestCaseID          PDS-EFM-CT-4065

   360 @SYMTestCaseDesc

   361 @SYMTestPriority        High

   362 @SYMTestActions

   363 @SYMTestExpectedResults Test must not fail

   364 @SYMDEF                 DEF144262

   365 */

   366 void BadClientTest()

   367     {

   368     TThreadData* p = new TThreadData;

   369     TEST(p != NULL);

   370     TThreadData& data = *p;

   371     data.iFunction = 0;

   372     TTime now;

   373     now.UniversalTime();

   374     data.iSeed = now.Int64();

   376     _LIT(KThreadName, "WorkThrd");

   378     for(data.iIteration=0;data.iIteration<KTestIterCount;++data.iIteration)

   379         {

   380         PrintIterationCount(data.iIteration);

   381         //Run the malicious client (one worker theread which will try to crash the FeatMgr server)

   382         RThread thread;

   383         TEST2(thread.Create(KThreadName, &ThreadFunc1, 0x2000, 0x1000, 0x10000, &data, EOwnerProcess), KErrNone);

   384         TRequestStatus status;

   385         thread.Logon(status);

   386         TEST2(status.Int(), KRequestPending);

   387         thread.Resume();

   388         User::WaitForRequest(status);

   389         User::SetJustInTime(ETrue); // enable debugger panic handling

   390         if(thread.ExitType() == EExitPanic)

   391             {

   392             if(thread.ExitReason() == KPanicCode)

   393                 {

   394                 TheTest.Printf(_L("##Server terminated!\r\n"));

   395                 TheTest.Printf(_L("##Iteration=%d, Function(hex)=%X, Handle=%d\r\n"), data.iIteration, data.iFunction);

   396                 for(TInt i=0;i<KMaxMessageArguments;++i)

   397                     {

   398                     switch(data.iArgType[i])

   399                         {

   400                         case EIntArgType:

   401                             TheTest.Printf(_L("##Arg %d, Integer, value=%d\r\n"), i, data.iIntArg[i]);

   402                             break;

   403                         case ETextArgType:

   404                             TheTest.Printf(_L("##Arg %d, Text,    length=%d\r\n"), i, data.iTextArg[i].Length());

   405                             break;

   406                         case EBinArgType:

   407                             TheTest.Printf(_L("##Arg %d, Binary,  length=%d\r\n"), i, data.iBinArg[i].Length());

   408                             break;

   409                         default:

   410                             TheTest.Printf(_L("##Arg %d, Invalid argument type: %d\r\n"), i, data.iArgType[i]);

   411                             break;

   412                         }

   413                     }

   414                 TEST(0);

   415                 }

   416             }

   417         thread.Close();

   418         }

   419     User::SetJustInTime(ETrue); // enable debugger panic handling

   420     delete p;

   421     }

   423 void DoTestsL()

   424     {

   425     //This test won't pass

   426     TheTest.Start(_L("@SYMTestCaseID:PDS-EFM-CT-4065 Bad client test"));

   427     BadClientTest();

   428     }

   430 TInt E32Main()

   431     {

   432     TheTest.Title();

   434     CTrapCleanup* tc = CTrapCleanup::New();

   435     TheTest(tc != NULL);

   437     __UHEAP_MARK;

   439     TRAPD(err, DoTestsL());

   440     DestroyTestEnv();

   441     TEST2(err, KErrNone);

   443     __UHEAP_MARKEND;

   445     TheTest.End();

   446     TheTest.Close();

   448     delete tc;

   450     User::Heap().Check();

   451     return KErrNone;

   452     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--