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

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

     2 // All rights reserved.

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

     4 // under the terms of "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 <featmgr.h>

    18 #include <featureuids.h>

    19 #include "featurepanics.h"

    20 #include <featurecontrol.h>

    21 #include <featurenotifier.h>

    23 using namespace NFeature;

    25 static RTest TheTest(_L("t_fmgrpanic"));

    27 _LIT(KPanicCategory, "RFeatureControl");

    29 ///////////////////////////////////////////////////////////////////////////////////////

    31 //Deletes all created test files.

    32 void DestroyTestEnv()

    33     {

    34     }

    36 ///////////////////////////////////////////////////////////////////////////////////////

    37 ///////////////////////////////////////////////////////////////////////////////////////

    38 //Test macros and functions

    39 void Check1(TInt aValue, TInt aLine)

    40     {

    41     if(!aValue)

    42         {

    43         DestroyTestEnv();

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

    45         TheTest(EFalse, aLine);

    46         }

    47     }

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

    49     {

    50     if(aValue != aExpected)

    51         {

    52         DestroyTestEnv();

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

    54         TheTest(EFalse, aLine);

    55         }

    56     }

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

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

    60 ///////////////////////////////////////////////////////////////////////////////////////

    62 //Panic thread function.

    63 //It will cast aData parameter to a TFunctor pointer and call it.

    64 //The expectation is that the called function will panic and kill the panic thread.

    65 TInt ThreadFunc(void* aData)

    66     {

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

    68     TEST(tc != NULL);

    70     User::SetJustInTime(EFalse);    // disable debugger panic handling

    72     TFunctor* obj = reinterpret_cast<TFunctor*> (aData);

    73     TEST(obj != NULL);

    74     (*obj)();//call the panic function

    76     delete tc;

    78     return KErrNone;

    79     }

    81 //Panic test.

    82 //PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to

    83 //be executed and the expectation is that the function will panic and kill the panic thread.

    84 //PanicTest function will check the panic thread exit code, exit category and the panic code.

    86 /**

    87 @SYMTestCaseID          PDS-EFM-CT-4094

    88 @SYMTestCaseDesc        Include test case 4105 too

    89 @SYMTestPriority        High

    90 @SYMTestActions         PanicTest function will create a new thread - panic

    91                         thread, giving it a pointer to the function which has to

    92                         be executed and the expectation is that the function

    93                         will panic and kill the panic thread.

    94                         PanicTest function will check the panic thread exit code,

    95                         exit category and the panic code.

    96 @SYMTestExpectedResults Test must not fail

    97 @SYMDEF                 DEF144262

    98 */

    99 void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)

   100     {

   101     RThread thread;

   102     _LIT(KThreadName,"FeatMgrPanicThread");

   103     TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);

   105     TRequestStatus status;

   106     thread.Logon(status);

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

   108     thread.Resume();

   109     User::WaitForRequest(status);

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

   112     TEST2(thread.ExitType(), aExpectedExitType);

   113     TEST(thread.ExitCategory() == aExpectedCategory);

   114     TEST2(thread.ExitReason(), aExpectedPanicCode);

   116     CLOSE_AND_WAIT(thread);

   117     }

   119 ////////////////////////////////////////////////////////////////////////////////////////////////////////////

   120 //////////////////////////////     Panic test functions    /////////////////////////////////////////////////

   121 ////////////////////////////////////////////////////////////////////////////////////////////////////////////

   123 //1 Panic when calling RFeatureControl::FeatureSupported() on an invalid RFeatureControl object.

   124 class TFeatureControl_NotCreated_FeatureSupported1 : public TFunctor

   125     {

   126 private:

   127     virtual void operator()()

   128         {

   129         RFeatureControl ctrl;

   130         (void)ctrl.FeatureSupported(KConnectivity);

   131         }

   132     };

   133 static TFeatureControl_NotCreated_FeatureSupported1 TheFeatureControl_NotCreated_FeatureSupported1;

   135 //2 Panic when calling RFeatureControl::FeatureSupported() on an invalid RFeatureControl object.

   136 class TFeatureControl_NotCreated_FeatureSupported2 : public TFunctor

   137     {

   138 private:

   139     virtual void operator()()

   140         {

   141         RFeatureControl ctrl;

   142         TFeatureEntry fentry;

   143         (void)ctrl.FeatureSupported(fentry);

   144         }

   145     };

   146 static TFeatureControl_NotCreated_FeatureSupported2 TheFeatureControl_NotCreated_FeatureSupported2;

   148 //Panic when calling RFeatureControl::FeaturesSupported() on an invalid RFeatureControl object.

   149 class TFeatureControl_NotCreated_FeaturesSupported : public TFunctor

   150     {

   151 private:

   152     virtual void operator()()

   153         {

   154         RFeatureControl ctrl;

   155         RFeatureArray farray;

   156         TFeatureEntry fentry;

   157         TInt err = farray.Append(fentry);

   158         TEST2(err, KErrNone);

   159         (void)ctrl.FeaturesSupported(farray);

   160         }

   161     };

   162 static TFeatureControl_NotCreated_FeaturesSupported TheFeatureControl_NotCreated_FeaturesSupported;

   164 //Panic when calling RFeatureControl::EnableFeature() on an invalid RFeatureControl object.

   165 class TFeatureControl_NotCreated_EnableFeature : public TFunctor

   166     {

   167 private:

   168     virtual void operator()()

   169         {

   170         RFeatureControl ctrl;

   171         (void)ctrl.EnableFeature(KConnectivity);

   172         }

   173     };

   174 static TFeatureControl_NotCreated_EnableFeature TheFeatureControl_NotCreated_EnableFeature;

   176 //Panic when calling RFeatureControl::DisableFeature() on an invalid RFeatureControl object.

   177 class TFeatureControl_NotCreated_DisableFeature : public TFunctor

   178     {

   179 private:

   180     virtual void operator()()

   181         {

   182         RFeatureControl ctrl;

   183         (void)ctrl.DisableFeature(KConnectivity);

   184         }

   185     };

   186 static TFeatureControl_NotCreated_DisableFeature TheFeatureControl_NotCreated_DisableFeature;

   188 //1 Panic when calling RFeatureControl::SetFeature() on an invalid RFeatureControl object.

   189 class TFeatureControl_NotCreated_SetFeature1 : public TFunctor

   190     {

   191 private:

   192     virtual void operator()()

   193         {

   194         RFeatureControl ctrl;

   195         (void)ctrl.SetFeature(KConnectivity, EFalse, 0);

   196         }

   197     };

   198 static TFeatureControl_NotCreated_SetFeature1 TheFeatureControl_NotCreated_SetFeature1;

   200 //2 Panic when calling RFeatureControl::SetFeature() on an invalid RFeatureControl object.

   201 class TFeatureControl_NotCreated_SetFeature2 : public TFunctor

   202     {

   203 private:

   204     virtual void operator()()

   205         {

   206         RFeatureControl ctrl;

   207         (void)ctrl.SetFeature(KConnectivity, 0);

   208         }

   209     };

   210 static TFeatureControl_NotCreated_SetFeature2 TheFeatureControl_NotCreated_SetFeature2;

   212 //Panic when calling RFeatureControl::AddFeature() on an invalid RFeatureControl object.

   213 class TFeatureControl_NotCreated_AddFeature : public TFunctor

   214     {

   215 private:

   216     virtual void operator()()

   217         {

   218         RFeatureControl ctrl;

   219         TFeatureEntry fentry;

   220         (void)ctrl.AddFeature(fentry);

   221         }

   222     };

   223 static TFeatureControl_NotCreated_AddFeature TheFeatureControl_NotCreated_AddFeature;

   225 //Panic when calling RFeatureControl::DeleteFeature() on an invalid RFeatureControl object.

   226 class TFeatureControl_NotCreated_DeleteFeature : public TFunctor

   227     {

   228 private:

   229     virtual void operator()()

   230         {

   231         RFeatureControl ctrl;

   232         (void)ctrl.DeleteFeature(KConnectivity);

   233         }

   234     };

   235 static TFeatureControl_NotCreated_DeleteFeature TheFeatureControl_NotCreated_DeleteFeature;

   237 //Panic when calling RFeatureControl::ListSupportedFeatures() on an invalid RFeatureControl object.

   238 class TFeatureControl_NotCreated_ListSupportedFeatures : public TFunctor

   239     {

   240 private:

   241     virtual void operator()()

   242         {

   243         RFeatureControl ctrl;

   244         RFeatureUidArray farray;

   245         (void)ctrl.ListSupportedFeatures(farray);

   246         }

   247     };

   248 static TFeatureControl_NotCreated_ListSupportedFeatures TheFeatureControl_NotCreated_ListSupportedFeatures;

   250 //Panic when calling RFeatureControl::SWIStart() on an invalid RFeatureControl object.

   251 class TFeatureControl_NotCreated_SWIStart : public TFunctor

   252     {

   253 private:

   254     virtual void operator()()

   255         {

   256         RFeatureControl ctrl;

   257         (void)ctrl.SWIStart();

   258         }

   259     };

   260 static TFeatureControl_NotCreated_SWIStart TheFeatureControl_NotCreated_SWIStart;

   262 //Panic when calling RFeatureControl::SWIEnd() on an invalid RFeatureControl object.

   263 class TFeatureControl_NotCreated_SWIEnd : public TFunctor

   264     {

   265 private:

   266     virtual void operator()()

   267         {

   268         RFeatureControl ctrl;

   269         (void)ctrl.SWIEnd();

   270         }

   271     };

   272 static TFeatureControl_NotCreated_SWIEnd TheFeatureControl_NotCreated_SWIEnd;

   274 ////////////////////////////////////////////////////////////////////////////////////////////////////////////

   276 void DoTestsL()

   277     {

   278     TheTest.Start(_L("@SYMTestCaseID:PDS-EFM-CT-4094 RFeatureControl::FeatureSupported() panic test 1"));

   279     PanicTest(TheFeatureControl_NotCreated_FeatureSupported1, EExitPanic, KPanicCategory, EPanicBadHandle);

   281     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4095 RFeatureControl::FeatureSupported() panic test 2"));

   282     PanicTest(TheFeatureControl_NotCreated_FeatureSupported2, EExitPanic, KPanicCategory, EPanicBadHandle);

   284     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4096 RFeatureControl::FeaturesSupported() panic test"));

   285     PanicTest(TheFeatureControl_NotCreated_FeaturesSupported, EExitPanic, KPanicCategory, EPanicBadHandle);

   287     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4097 RFeatureControl::EnableFeature() panic test"));

   288     PanicTest(TheFeatureControl_NotCreated_EnableFeature, EExitPanic, KPanicCategory, EPanicBadHandle);

   290     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4098 RFeatureControl::DisableFeature() panic test"));

   291     PanicTest(TheFeatureControl_NotCreated_DisableFeature, EExitPanic, KPanicCategory, EPanicBadHandle);

   293     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4099 RFeatureControl::SetFeature() panic test 1"));

   294     PanicTest(TheFeatureControl_NotCreated_SetFeature1, EExitPanic, KPanicCategory, EPanicBadHandle);

   296     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4100 RFeatureControl::SetFeature() panic test 2"));

   297     PanicTest(TheFeatureControl_NotCreated_SetFeature2, EExitPanic, KPanicCategory, EPanicBadHandle);

   299     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4101 RFeatureControl::AddFeature() panic test"));

   300     PanicTest(TheFeatureControl_NotCreated_AddFeature, EExitPanic, KPanicCategory, EPanicBadHandle);

   302     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4102 RFeatureControl::DeleteFeature() panic test"));

   303     PanicTest(TheFeatureControl_NotCreated_DeleteFeature, EExitPanic, KPanicCategory, EPanicBadHandle);

   305     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4103 RFeatureControl::ListSupportedFeatures() panic test"));

   306     PanicTest(TheFeatureControl_NotCreated_ListSupportedFeatures, EExitPanic, KPanicCategory, EPanicBadHandle);

   308     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4104 RFeatureControl::SWIStart() panic test"));

   309     PanicTest(TheFeatureControl_NotCreated_SWIStart, EExitPanic, KPanicCategory, EPanicBadHandle);

   311     TheTest.Next(_L("@SYMTestCaseID:PDS-EFM-CT-4105 RFeatureControl::SWIEnd() panic test"));

   312     PanicTest(TheFeatureControl_NotCreated_SWIEnd, EExitPanic, KPanicCategory, EPanicBadHandle);

   313     }

   315 TInt E32Main()

   316     {

   317     TheTest.Title();

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

   320     TheTest(tc != NULL);

   322     __UHEAP_MARK;

   324     TRAPD(err, DoTestsL());

   325     DestroyTestEnv();

   326     TEST2(err, KErrNone);

   328     __UHEAP_MARKEND;

   330     TheTest.End();

   331     TheTest.Close();

   333     delete tc;

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

   336     return KErrNone;

   337     }

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