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 <bautils.h>

    18 #include <featmgr.h>

    19 #include <featureuids.h>

    20 #include <featurecontrol.h>

    21 #include <featdiscovery.h>

    22 #include <featurenotifier.h>

    23 #include "../../../src/clientdll/featmgrresourcetester.h"

    25 using namespace NFeature;

    28 const TInt KInvalidFeatureId    = 90901671;

    29 const TUid KInvalidFeatureUid   = {KInvalidFeatureId};

    31 static TInt TheProcessHandleCount = 0;

    32 static TInt TheThreadHandleCount = 0;

    33 static TInt TheAllocatedCellsCount = 0;

    35 #ifdef _DEBUG

    36 static const TInt KBurstRate = 20;

    37 #endif

    39 enum TFeatMgrOomTestMode

    40     {

    41     EFeatMgrOomServerTestMode,

    42     EFeatMgrOomClientTestMode,

    43     };

    45 ///////////////////////////////////////////////////////////////////////////////////////

    47 static RTest TheTest(_L("t_fmgroom"));

    51 ///////////////////////////////////////////////////////////////////////////////////////

    52 ///////////////////////////////////////////////////////////////////////////////////////

    53 //Test macros and functions

    54 void Check1(TInt aValue, TInt aLine)

    55     {

    56     if(!aValue)

    57         {

    58         RDebug::Print(_L("*** Expression evaluated to false. Line %d\r\n"), aLine);

    59         TheTest(EFalse, aLine);

    60         }

    61     }

    62 void Check2(TInt aValue, TInt aExpected, TInt aLine)

    63     {

    64     if(aValue != aExpected)

    65         {

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

    67         TheTest(EFalse, aLine);

    68         }

    69     }

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

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

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

    75 static void MarkHandles()

    76     {

    77     RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);

    78     }

    80 static void MarkAllocatedCells()

    81     {

    82     TheAllocatedCellsCount = User::CountAllocCells();

    83     }

    85 static void CheckAllocatedCells()

    86     {

    87     TInt allocatedCellsCount = User::CountAllocCells();

    88     TEST2(allocatedCellsCount, TheAllocatedCellsCount);

    89     }

    91 static void CheckHandles()

    92     {

    93     TInt endProcessHandleCount;

    94     TInt endThreadHandleCount;

    96     RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

    98     TEST2(TheProcessHandleCount, endProcessHandleCount);

    99     TEST2(TheThreadHandleCount, endThreadHandleCount);

   100     }

   102 static void OomPreStep(TInt aFailingAllocationNo, TFeatMgrOomTestMode aMode = EFeatMgrOomClientTestMode)

   103     {

   104     if(aMode == EFeatMgrOomClientTestMode)

   105         {

   106         MarkHandles();

   107         MarkAllocatedCells();

   108         __UHEAP_MARK;

   109         __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, aFailingAllocationNo, KBurstRate);

   110         }

   111     else

   112         {

   113         TFeatMgrResourceTester::Mark();

   114         TFeatMgrResourceTester::SetHeapFailure(RHeap::EBurstFailNext, aFailingAllocationNo);

   115         }

   116     }

   118 static void OomPostStep(TFeatMgrOomTestMode aMode = EFeatMgrOomClientTestMode)

   119     {

   120     if(aMode == EFeatMgrOomClientTestMode)

   121         {

   122         __UHEAP_RESET;

   123         __UHEAP_MARKEND;

   124         CheckAllocatedCells();

   125         CheckHandles();

   126         }

   127     else

   128         {

   129         TFeatMgrResourceTester::SetHeapFailure(RHeap::ENone, 0);

   130         TFeatMgrResourceTester::Check();

   131         }

   132     }

   134 ///////////////////////////////////////////////////////////////////////////////////////

   136 /**

   137 @SYMTestCaseID          PDS-EFM-CT-4068

   138 @SYMTestCaseDesc        Include test case 4069 too

   139 @SYMTestPriority        High

   140 @SYMTestActions

   141 @SYMTestExpectedResults Test must not fail

   142 @SYMDEF                 DEF144262

   143 */

   144 void ControlOpenOomTest(TBool aUseConnect)

   145     {

   146     TInt err = KErrNoMemory;

   147     TInt failingAllocationNo = 0;

   148     RFeatureControl ctrl;

   149     TheTest.Printf(_L("Iteration:\r\n"));

   150     while(err == KErrNoMemory)

   151         {

   152         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   153         OomPreStep(failingAllocationNo);

   154         err = aUseConnect ? ctrl.Connect() : ctrl.Open();

   155         ctrl.Close();

   156         OomPostStep();

   157         }

   158     if(err != KErrNoMemory)

   159         {

   160         TEST2(err, KErrNone);

   161         }

   162     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   163     }

   165 /**

   166 @SYMTestCaseID          PDS-EFM-CT-4070

   167 @SYMTestCaseDesc        Include test case 4071-4077 too

   168 @SYMTestPriority        High

   169 @SYMTestActions

   170 @SYMTestExpectedResults Test must not fail

   171 @SYMDEF                 DEF144262

   172 */

   173 void ControlFeatureSupportedOomTest(TBool aUseUid, TBool aInvalidFeature, TFeatMgrOomTestMode aMode)

   174     {

   175     RFeatureControl ctrl;

   176     TInt err = ctrl.Open();

   177     TEST2(err, KErrNone);

   179     const TUid KFeatureUid(aInvalidFeature ? KInvalidFeatureUid : KConnectivity);

   180     TFeatureEntry fentry(KFeatureUid);

   182     err = KErrNoMemory;

   183     TInt failingAllocationNo = 0;

   184     TheTest.Printf(_L("Iteration:\r\n"));

   185     while(err == KErrNoMemory)

   186         {

   187         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   188         OomPreStep(failingAllocationNo, aMode);

   189         err = aUseUid ? ctrl.FeatureSupported(KFeatureUid) : ctrl.FeatureSupported(fentry);

   190         OomPostStep(aMode);

   191         }

   192     ctrl.Close();

   193     if(err != KErrNoMemory)

   194         {

   195         TEST2(err, aInvalidFeature ? KErrNotFound : KFeatureSupported);

   196         }

   197     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   198     }

   200 /**

   201 @SYMTestCaseID          PDS-EFM-CT-4078

   202 @SYMTestCaseDesc        Include test case 4079 too

   203 @SYMTestPriority        High

   204 @SYMTestActions

   205 @SYMTestExpectedResults Test must not fail

   206 @SYMDEF                 DEF144262

   207 */

   208 void ControlListSupportedFeaturesOomTest(TFeatMgrOomTestMode aMode)

   209     {

   210     RFeatureControl ctrl;

   211     TInt err = ctrl.Open();

   212     TEST2(err, KErrNone);

   214     err = KErrNoMemory;

   215     TInt failingAllocationNo = 0;

   216     TheTest.Printf(_L("Iteration:\r\n"));

   217     while(err == KErrNoMemory)

   218         {

   219         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   220         OomPreStep(failingAllocationNo, aMode);

   221         const TInt KGranularity = 1;

   222         RFeatureUidArray farray(KGranularity);

   223         err = ctrl.ListSupportedFeatures(farray);

   224         if(err != KErrNoMemory)

   225             {

   226             TEST2(err, KErrNone);

   227             TInt count = farray.Count();

   228             TheTest.Printf(_L("===Features count: %d\r\n"), count);

   229             TEST(count > 0);

   230             }

   231         farray.Close();

   232         OomPostStep(aMode);

   233         }

   234     ctrl.Close();

   235     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   236     }

   238 /**

   239 @SYMTestCaseID          PDS-EFM-CT-4080

   240 @SYMTestCaseDesc        Include test case 4081 too

   241 @SYMTestPriority        High

   242 @SYMTestActions

   243 @SYMTestExpectedResults Test must not fail

   244 @SYMDEF                 DEF144262

   245 */

   246 void ControlFeaturesSupportedOomTest(TFeatMgrOomTestMode aMode)

   247     {

   248     RFeatureControl ctrl;

   249     TInt err = ctrl.Open();

   250     TEST2(err, KErrNone);

   251     RFeatureUidArray farray;

   252     err = ctrl.ListSupportedFeatures(farray);

   253     TEST2(err, KErrNone);

   255     err = KErrNoMemory;

   256     TInt failingAllocationNo = 0;

   257     TheTest.Printf(_L("Iteration:\r\n"));

   258     while(err == KErrNoMemory)

   259         {

   260         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   261         OomPreStep(failingAllocationNo, aMode);

   262         RFeatureArray farray2;

   263         err = KErrNone;

   264         for(TInt i=0;i<farray.Count() && err==KErrNone;++i)

   265             {

   266             err = farray2.Append(farray[i]);

   267             }

   268         if(err == KErrNone)

   269             {

   270             err = ctrl.FeaturesSupported(farray2);

   271             }

   272         if(err != KErrNoMemory)

   273             {

   274             TEST2(err, KErrNone);

   275             TInt count = farray2.Count();

   276             TheTest.Printf(_L("===Features count: %d\r\n"), count);

   277             TEST(count > 0);

   278             }

   279         farray2.Close();

   280         OomPostStep(aMode);

   281         }

   282     farray.Close();

   283     ctrl.Close();

   284     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   285     }

   287 /**

   288 @SYMTestCaseID          PDS-EFM-CT-4082

   289 @SYMTestCaseDesc        Include test case 4083 too

   290 @SYMTestPriority        High

   291 @SYMTestActions

   292 @SYMTestExpectedResults Test must not fail

   293 @SYMDEF                 DEF144262

   294 */

   295 void ControlAddFeatureOomTest(TFeatMgrOomTestMode aMode)

   296     {

   297     RFeatureControl ctrl;

   298     TInt err = ctrl.Open();

   299     TEST2(err, KErrNone);

   301     const TUid KNewFeatureUid = {0x7888ABCE};

   302     TBitFlags32 flags;

   303     flags.Set(EFeatureSupported);

   304     flags.Set(EFeatureModifiable);

   305     flags.Set(EFeaturePersisted);

   306     TFeatureEntry fentry(KNewFeatureUid, flags, 0x0);

   308     err = KErrNoMemory;

   309     TInt failingAllocationNo = 0;

   310     TheTest.Printf(_L("Iteration:\r\n"));

   311     while(err == KErrNoMemory)

   312         {

   313         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   314         OomPreStep(failingAllocationNo, aMode);

   315         err = ctrl.AddFeature(fentry);

   316         OomPostStep(aMode);

   317         if(err == KErrNoMemory)

   318             {

   319             err = ctrl.EnableFeature(fentry.FeatureUid());

   320             TEST2(err, KErrNotFound);

   321             }

   322         }

   323     TEST2(err, KErrNone);

   324     err = ctrl.DeleteFeature(fentry.FeatureUid());

   325     TEST2(err, KErrNone);

   327     ctrl.Close();

   328     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   329     }

   331 /**

   332 @SYMTestCaseID          PDS-EFM-CT-4084

   333 @SYMTestCaseDesc        Include test case 4085 too

   334 @SYMTestPriority        High

   335 @SYMTestActions

   336 @SYMTestExpectedResults Test must not fail

   337 @SYMDEF                 DEF144262

   338 */

   339 void ControlDeleteFeatureOomTest(TFeatMgrOomTestMode aMode)

   340     {

   341     RFeatureControl ctrl;

   342     TInt err = ctrl.Open();

   343     TEST2(err, KErrNone);

   345     const TUid KNewFeatureUid = {0x7888ABCE};

   346     TBitFlags32 flags;

   347     flags.Set(EFeatureSupported);

   348     flags.Set(EFeatureModifiable);

   349     TFeatureEntry fentry(KNewFeatureUid, flags, 0x0);

   350     err = ctrl.AddFeature(fentry);

   351     TEST2(err, KErrNone);

   353     err = KErrNoMemory;

   354     TInt failingAllocationNo = 0;

   355     TheTest.Printf(_L("Iteration:\r\n"));

   356     while(err == KErrNoMemory)

   357         {

   358         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   359         OomPreStep(failingAllocationNo, aMode);

   360         err = ctrl.DeleteFeature(fentry.FeatureUid());

   361         OomPostStep(aMode);

   362         if(err == KErrNoMemory)

   363             {

   364             err = ctrl.EnableFeature(fentry.FeatureUid());

   365             TEST2(err, KErrNone);

   366             }

   367         }

   368     TEST2(err, KErrNone);

   370     ctrl.Close();

   371     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   372     }

   374 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   375 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   377 class TTestFeatureObserver : public MFeatureObserver

   378     {

   379     public:

   380         virtual void HandleNotifyChange(TFeatureChangeType /*aType*/, TFeatureEntry /*aFeature*/)

   381             {

   382             }

   383         virtual void HandleNotifyError(TInt /*aError*/)

   384             {

   385             }

   386     };

   388 /**

   389 @SYMTestCaseID          PDS-EFM-CT-4086

   390 @SYMTestCaseDesc        Include test case 4087 too

   391 @SYMTestPriority        High

   392 @SYMTestActions

   393 @SYMTestExpectedResults Test must not fail

   394 @SYMDEF                 DEF144262

   395 */

   396 void NotifierNewLOomTest(TFeatMgrOomTestMode aMode)

   397     {

   398     CActiveScheduler* scheduler = new CActiveScheduler;

   399     TEST(scheduler != NULL);

   400     CActiveScheduler::Install(scheduler);

   402     RFeatureControl ctrl;

   403     TInt err = ctrl.Open();

   404     TEST2(err, KErrNone);

   406     TTestFeatureObserver observer;

   407     err = KErrNoMemory;

   408     TInt failingAllocationNo = 0;

   409     TheTest.Printf(_L("Iteration:\r\n"));

   410     while(err == KErrNoMemory)

   411         {

   412         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   413         OomPreStep(failingAllocationNo, aMode);

   414         CFeatureNotifier* notifier = NULL;

   415         TRAP(err, notifier = CFeatureNotifier::NewL(observer));

   416         delete notifier;

   417         OomPostStep(aMode);

   418         }

   419     TEST2(err, KErrNone);

   420     ctrl.Close();

   421     delete scheduler;

   422     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   423     }

   425 /**

   426 @SYMTestCaseID          PDS-EFM-CT-4088

   427 @SYMTestCaseDesc        Include test case 4089-4091 too

   428 @SYMTestPriority        High

   429 @SYMTestActions

   430 @SYMTestExpectedResults Test must not fail

   431 @SYMDEF                 DEF144262

   432 */

   433 void NotifierNotifyRequestOomTest(TBool aInvalidFeature, TFeatMgrOomTestMode aMode)

   434     {

   435     CActiveScheduler* scheduler = new CActiveScheduler;

   436     TEST(scheduler != NULL);

   437     CActiveScheduler::Install(scheduler);

   439     RFeatureControl ctrl;

   440     TInt err = ctrl.Open();

   441     TEST2(err, KErrNone);

   443     TTestFeatureObserver observer;

   444     CFeatureNotifier* notifier = NULL;

   445     TRAP(err, notifier = CFeatureNotifier::NewL(observer));

   446     TEST2(err, KErrNone);

   448     const TUid KFeatureUid(aInvalidFeature ? KInvalidFeatureUid : KConnectivity);

   450     err = KErrNoMemory;

   451     TInt failingAllocationNo = 0;

   452     TheTest.Printf(_L("Iteration:\r\n"));

   453     while(err == KErrNoMemory)

   454         {

   455         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   456         OomPreStep(failingAllocationNo, aMode);

   457         err = notifier->NotifyRequest(KFeatureUid);

   458         (void)notifier->NotifyCancelAll();

   459         OomPostStep(aMode);

   460         }

   461     TEST2(err, KErrNone);

   462     delete notifier;

   463     ctrl.Close();

   464     delete scheduler;

   465     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   466     }

   468 /**

   469 @SYMTestCaseID          PDS-EFM-CT-4092

   470 @SYMTestCaseDesc        Include test case 4093 too

   471 @SYMTestPriority        High

   472 @SYMTestActions

   473 @SYMTestExpectedResults Test must not fail

   474 @SYMDEF                 DEF144262

   475 */

   476 void NotifierNotifyRequestsOomTest(TFeatMgrOomTestMode aMode)

   477     {

   478     CActiveScheduler* scheduler = new CActiveScheduler;

   479     TEST(scheduler != NULL);

   480     CActiveScheduler::Install(scheduler);

   482     RFeatureControl ctrl;

   483     TInt err = ctrl.Open();

   484     TEST2(err, KErrNone);

   486     TTestFeatureObserver observer;

   487     CFeatureNotifier* notifier = NULL;

   488     TRAP(err, notifier = CFeatureNotifier::NewL(observer));

   489     TEST2(err, KErrNone);

   491     RFeatureUidArray features;

   492     err = features.Append(KConnectivity);

   493     TEST2(err, KErrNone);

   494     err = features.Append(KFax);

   495     TEST2(err, KErrNone);

   496     err = features.Append(KConnectivity);

   497     TEST2(err, KErrNone);

   498     err = features.Append(KLocationManagement);

   499     TEST2(err, KErrNone);

   501     err = KErrNoMemory;

   502     TInt failingAllocationNo = 0;

   503     TheTest.Printf(_L("Iteration:\r\n"));

   504     while(err == KErrNoMemory)

   505         {

   506         TheTest.Printf(_L(" %d"), ++failingAllocationNo);

   507         OomPreStep(failingAllocationNo, aMode);

   508         err = notifier->NotifyRequest(features);

   509         (void)notifier->NotifyCancelAll();

   510         OomPostStep(aMode);

   511         }

   512     TEST2(err, KErrNone);

   513     features.Close();

   514     delete notifier;

   515     ctrl.Close();

   516     delete scheduler;

   517     TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

   518     }

   522 void DoTestsL()

   523     {

   524     TheTest.Start(_L("@SYMTestCaseID:PDS-EFM-CT-4068 RFeatureControl::Connect() OOM test"));

   525     ControlOpenOomTest(ETrue);

   526     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4069 RFeatureControl::Open() OOM test"));

   527     ControlOpenOomTest(EFalse);

   529     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4070 RFeatureControl::FeatureSupported(UID) + valid feature, client side OOM test"));

   530     ControlFeatureSupportedOomTest(ETrue, EFalse, EFeatMgrOomClientTestMode);

   531     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4071 RFeatureControl::FeatureSupported(UID) + valid feature, server side OOM test"));

   532     ControlFeatureSupportedOomTest(ETrue, EFalse, EFeatMgrOomServerTestMode);

   534     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4072 RFeatureControl::FeatureSupported() + valid feature, client side OOM test"));

   535     ControlFeatureSupportedOomTest(EFalse, EFalse, EFeatMgrOomClientTestMode);

   536     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4073 RFeatureControl::FeatureSupported() + valid feature, server side OOM test"));

   537     ControlFeatureSupportedOomTest(EFalse, EFalse, EFeatMgrOomServerTestMode);

   539     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4074 RFeatureControl::FeatureSupported(UID) + invalid feature, client side OOM test"));

   540     ControlFeatureSupportedOomTest(ETrue, ETrue, EFeatMgrOomClientTestMode);

   541     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4075 RFeatureControl::FeatureSupported(UID) + invalid feature, server side OOM test"));

   542     ControlFeatureSupportedOomTest(ETrue, ETrue, EFeatMgrOomServerTestMode);

   544     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4076 RFeatureControl::FeatureSupported() + invalid feature, client side OOM OOM test"));

   545     ControlFeatureSupportedOomTest(EFalse, ETrue, EFeatMgrOomClientTestMode);

   546     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4077 RFeatureControl::FeatureSupported() + invalid feature, server side OOM OOM test"));

   547     ControlFeatureSupportedOomTest(EFalse, ETrue, EFeatMgrOomServerTestMode);

   549     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4078 RFeatureControl::ListSupportedFeatures(), client side OOM test"));

   550     ControlListSupportedFeaturesOomTest(EFeatMgrOomClientTestMode);

   551     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4079 RFeatureControl::ListSupportedFeatures(), server side OOM test"));

   552     ControlListSupportedFeaturesOomTest(EFeatMgrOomServerTestMode);

   554     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4080 RFeatureControl::FeaturesSupported(), client side OOM test"));

   555     ControlFeaturesSupportedOomTest(EFeatMgrOomClientTestMode);

   556     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4081 RFeatureControl::FeaturesSupported(),server side OOM test"));

   557     ControlFeaturesSupportedOomTest(EFeatMgrOomServerTestMode);

   559     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4082 RFeatureControl::AddFeature(), client side OOM test"));

   560     ControlAddFeatureOomTest(EFeatMgrOomClientTestMode);

   561     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4083 RFeatureControl::AddFeature(), server side OOM test"));

   562     ControlAddFeatureOomTest(EFeatMgrOomServerTestMode);

   564     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4084 RFeatureControl::DeleteFeature(), client side OOM test"));

   565     ControlDeleteFeatureOomTest(EFeatMgrOomClientTestMode);

   566     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4085 RFeatureControl::DeleteFeature(), server side OOM test"));

   567     ControlDeleteFeatureOomTest(EFeatMgrOomServerTestMode);

   569     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4086 CFeatureNotifier::NewL(), client side OOM test"));

   570     NotifierNewLOomTest(EFeatMgrOomClientTestMode);

   571     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4087 CFeatureNotifier::NewL(), server side OOM test"));

   572     NotifierNewLOomTest(EFeatMgrOomServerTestMode);

   574     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4088 CFeatureNotifier::NotifyRequest(), valid feature, client side OOM test"));

   575     NotifierNotifyRequestOomTest(ETrue, EFeatMgrOomClientTestMode);

   576     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4089 CFeatureNotifier::NotifyRequest(), valid feature, server side OOM test"));

   577     NotifierNotifyRequestOomTest(ETrue, EFeatMgrOomServerTestMode);

   579     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4090 CFeatureNotifier::NotifyRequest(), invalid feature, client side OOM test"));

   580     NotifierNotifyRequestOomTest(EFalse, EFeatMgrOomClientTestMode);

   581     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4091 CFeatureNotifier::NotifyRequest(), invalid feature, server side OOM test"));

   582     NotifierNotifyRequestOomTest(EFalse, EFeatMgrOomServerTestMode);

   584     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4092 CFeatureNotifier::NotifyRequest(<array>), valid feature, client side OOM test"));

   585     NotifierNotifyRequestsOomTest(EFeatMgrOomClientTestMode);

   586     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4093 CFeatureNotifier::NotifyRequest(<array>), valid feature, server side OOM test"));

   587     NotifierNotifyRequestsOomTest(EFeatMgrOomServerTestMode);

   588     }

   590 TInt E32Main()

   591     {

   592     TheTest.Title();

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

   595     TheTest(tc != NULL);

   597     __UHEAP_MARK;

   599     TRAPD(err, DoTestsL());

   600     TEST2(err, KErrNone);

   602     __UHEAP_MARKEND;

   604     TheTest.End();

   605     TheTest.Close();

   607     delete tc;

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

   610     return KErrNone;

   611     }

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