1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Main test class for hsapplicationlauncher library.

    15 *

    16 */

    17 

    18 #include <e32base.h>

    19 #include <e32property.h>

    20 #include "t_hsapplicationlauncher.h"

    21 #include "hsapplicationlauncher.h"

    22 

    23 const TInt KPSCategoryUid(0x20022F36);

    24 const TInt KPSCrashCountKey(1);

    25 

    26 

    27 // ---------------------------------------------------------------------------

    28 // ---------------------------------------------------------------------------

    29 //

    30 void t_hsapplicationlauncher::initTestCase()

    31 {

    32 }

    33 

    34 // ---------------------------------------------------------------------------

    35 // ---------------------------------------------------------------------------

    36 //

    37 void t_hsapplicationlauncher::cleanupTestCase()

    38 {

    39 }

    40 

    41 // ---------------------------------------------------------------------------

    42 // ---------------------------------------------------------------------------

    43 //

    44 void t_hsapplicationlauncher::testActivate()

    45 {

    46     CHsLaunch *hsApplicationLauncher = 0;

    47     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

    48     QCOMPARE(errNo, KErrNone);

    49     hsApplicationLauncher->Activate();        

    50     delete hsApplicationLauncher;    

    51 }

    52 

    53 // ---------------------------------------------------------------------------

    54 // ---------------------------------------------------------------------------

    55 //

    56 void t_hsapplicationlauncher::testRunL()

    57 {

    58     CHsLaunch *hsApplicationLauncher = 0;

    59     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

    60     QCOMPARE(errNo, KErrNone);

    61     hsApplicationLauncher->Activate();     

    62     hsApplicationLauncher->RunL();

    63     delete hsApplicationLauncher;    

    64 }

    65 

    66 // ---------------------------------------------------------------------------

    67 // ---------------------------------------------------------------------------

    68 //

    69 void t_hsapplicationlauncher::testInitProcessMonitorL()

    70 {

    71     CHsLaunch *hsApplicationLauncher = 0;

    72     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

    73     QCOMPARE(errNo, KErrNone);

    74     hsApplicationLauncher->Activate();

    75     hsApplicationLauncher->InitProcessMonitorL(0);

    76     QVERIFY(hsApplicationLauncher->iProcessMonitor);

    77     hsApplicationLauncher->InitProcessMonitorL(0);

    78     QVERIFY(hsApplicationLauncher->iProcessMonitor);

    79     delete hsApplicationLauncher;    

    80 }

    81 

    82 // ---------------------------------------------------------------------------

    83 // ---------------------------------------------------------------------------

    84 //

    85 void t_hsapplicationlauncher::testDoCancel()

    86 {

    87     CHsLaunch *hsApplicationLauncher = 0;

    88     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

    89     QCOMPARE(errNo, KErrNone);

    90     hsApplicationLauncher->Activate();

    91     hsApplicationLauncher->InitProcessMonitorL(0);    

    92     hsApplicationLauncher->DoCancel();

    93     delete hsApplicationLauncher;    

    94 }

    95 

    96 // ---------------------------------------------------------------------------

    97 // ---------------------------------------------------------------------------

    98 //

    99 void t_hsapplicationlauncher::testShutdownApp()

   100 {

   101     CHsLaunch *hsApplicationLauncher = 0;

   102     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   103     QCOMPARE(errNo, KErrNone);

   104     hsApplicationLauncher->Activate();

   105     hsApplicationLauncher->ShutdownApp(KErrGeneral);

   106     QVERIFY(hsApplicationLauncher->iApplicationReturnValue == KErrGeneral);

   107     QCOMPARE(hsApplicationLauncher->ApplicationReturnValue(), KErrGeneral);

   108     delete hsApplicationLauncher;

   109 }

   110 

   111 // ---------------------------------------------------------------------------

   112 // ---------------------------------------------------------------------------

   113 //

   114 void t_hsapplicationlauncher::testRunError()

   115 {

   116     CHsLaunch *hsApplicationLauncher = 0;

   117     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   118     QCOMPARE(errNo, KErrNone);

   119     hsApplicationLauncher->Activate();

   120     hsApplicationLauncher->RunError(KErrGeneral);

   121     QVERIFY(hsApplicationLauncher->iApplicationReturnValue == KErrGeneral);

   122     delete hsApplicationLauncher;

   123 }

   124 

   125 // ---------------------------------------------------------------------------

   126 // ---------------------------------------------------------------------------

   127 //

   128 void t_hsapplicationlauncher::testListeningLanguageSelection()

   129 {

   130     CHsLaunch *hsApplicationLauncher = 0;

   131     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   132     QCOMPARE(errNo, KErrNone);

   133     hsApplicationLauncher->Activate();

   134     hsApplicationLauncher->StartListeningLanguageSelectionL();

   135     QVERIFY(hsApplicationLauncher->iCenRepNotifyHandler);

   136     hsApplicationLauncher->StopListeningLanguageSelection();

   137     QVERIFY(!hsApplicationLauncher->iCenRepNotifyHandler);

   138     delete hsApplicationLauncher;

   139 }

   140 

   141 // ---------------------------------------------------------------------------

   142 // ---------------------------------------------------------------------------

   143 //

   144 void t_hsapplicationlauncher::testHandleNotifyInt()

   145 {

   146     CHsLaunch *hsApplicationLauncher = 0;

   147     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   148     QCOMPARE(errNo, KErrNone);

   149     hsApplicationLauncher->Activate();

   150     hsApplicationLauncher->StartListeningLanguageSelectionL();

   151     hsApplicationLauncher->HandleNotifyInt(0x00000007, 1);

   152     QVERIFY(!hsApplicationLauncher->iCenRepNotifyHandler);

   153     hsApplicationLauncher->HandleNotifyInt(0x00000008, 1);

   154     QVERIFY(!hsApplicationLauncher->iCenRepNotifyHandler);    

   155     delete hsApplicationLauncher;

   156 }

   157 

   158 // ---------------------------------------------------------------------------

   159 // ---------------------------------------------------------------------------

   160 //

   161 void t_hsapplicationlauncher::testStartHomeScreen()

   162 {

   163     CHsLaunch *hsApplicationLauncher = 0;

   164     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   165     QCOMPARE(errNo, KErrNone);

   166     hsApplicationLauncher->Activate();

   167     hsApplicationLauncher->StartHomeScreen();

   168     QVERIFY(hsApplicationLauncher->iProcessMonitor);

   169     delete hsApplicationLauncher;

   170 }

   171 

   172 // ---------------------------------------------------------------------------

   173 // ---------------------------------------------------------------------------

   174 //

   175 void t_hsapplicationlauncher::testProcessEnded()

   176 {

   177     CHsLaunch *hsApplicationLauncher = 0;

   178     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   179     QCOMPARE(errNo, KErrNone);

   180 

   181     TExitCategoryName panicString;

   182     hsApplicationLauncher->ProcessEnded(EExitPanic, KErrNone, panicString);

   183     TInt crashCount = 0;

   184     RProperty::Get(TUid::Uid(KPSCategoryUid), KPSCrashCountKey, crashCount);

   185     QVERIFY(crashCount == 1);

   186 

   187     if(hsApplicationLauncher->IsActive())

   188     {

   189         hsApplicationLauncher->Cancel();

   190     }

   191 

   192     hsApplicationLauncher->ProcessEnded(EExitKill, KErrGeneral, panicString);

   193     RProperty::Get(TUid::Uid(KPSCategoryUid), KPSCrashCountKey, crashCount);

   194     QVERIFY(crashCount == 2);    

   195 

   196     if(hsApplicationLauncher->IsActive())

   197     {

   198         hsApplicationLauncher->Cancel();

   199     }

   200 

   201     hsApplicationLauncher->ProcessEnded(EExitTerminate, KErrGeneral, panicString);

   202     RProperty::Get(TUid::Uid(KPSCategoryUid), KPSCrashCountKey, crashCount);

   203     QVERIFY(crashCount == 2);

   204     

   205     delete hsApplicationLauncher;

   206 }

   207 

   208 // ---------------------------------------------------------------------------

   209 // ---------------------------------------------------------------------------

   210 //

   211 void t_hsapplicationlauncher::testProcessMonitoringError()

   212 {

   213     CHsLaunch *hsApplicationLauncher = 0;

   214     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   215     QCOMPARE(errNo, KErrNone);

   216     hsApplicationLauncher->Activate();

   217     hsApplicationLauncher->ProcessMonitoringError(KErrGeneral);

   218     QVERIFY(hsApplicationLauncher->iApplicationReturnValue == KErrGeneral);

   219     delete hsApplicationLauncher;

   220 }

   221 

   222 // ---------------------------------------------------------------------------

   223 // ---------------------------------------------------------------------------

   224 //

   225 void t_hsapplicationlauncher::testSystemShutdownEvent()

   226 {

   227     CHsLaunch *hsApplicationLauncher = 0;

   228     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   229     QCOMPARE(errNo, KErrNone);

   230     hsApplicationLauncher->Activate();

   231     hsApplicationLauncher->SystemShutdownEvent();    

   232     delete hsApplicationLauncher;

   233 }

   234 

   235 // ---------------------------------------------------------------------------

   236 // ---------------------------------------------------------------------------

   237 //

   238 void t_hsapplicationlauncher::testIsLanguageSelectedL()

   239 {

   240     CHsLaunch *hsApplicationLauncher = 0;

   241     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());

   242     QCOMPARE(errNo, KErrNone);

   243     hsApplicationLauncher->Activate();

   244     hsApplicationLauncher->StartListeningLanguageSelectionL();

   245     TBool languageSelected = ETrue;

   246     TRAP(errNo, languageSelected = hsApplicationLauncher->IsLanguageSelectedL());

   247     QCOMPARE(errNo, KErrNone);

   248 #if defined( __WINS__ )    

   249     QVERIFY(languageSelected == EFalse);

   250 #else

   251     QVERIFY(languageSelected);

   252 #endif

   253     hsApplicationLauncher->StopListeningLanguageSelection();

   254     delete hsApplicationLauncher;

   255 }

   256 

   257 // ---------------------------------------------------------------------------

   258 // ---------------------------------------------------------------------------

   259 //

   260 void t_hsapplicationlauncher::testProcessMonitorRunL()

   261 {

   262     CHsLaunch *hsApplicationLauncher = 0;

   263     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());    

   264     QCOMPARE(errNo, KErrNone);

   265     hsApplicationLauncher->Activate();

   266     hsApplicationLauncher->InitProcessMonitorL(0);

   267     hsApplicationLauncher->iProcessMonitor->RunL();

   268     delete hsApplicationLauncher;

   269 }

   270 

   271 // ---------------------------------------------------------------------------

   272 // ---------------------------------------------------------------------------

   273 //

   274 void t_hsapplicationlauncher::testProcessMonitorDoCancel()

   275 {

   276     CHsLaunch *hsApplicationLauncher = 0;

   277     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());    

   278     QCOMPARE(errNo, KErrNone);

   279     hsApplicationLauncher->Activate();

   280     hsApplicationLauncher->InitProcessMonitorL(0);    

   281     hsApplicationLauncher->iProcessMonitor->DoCancel();

   282     delete hsApplicationLauncher;

   283 }

   284 

   285 // ---------------------------------------------------------------------------

   286 // ---------------------------------------------------------------------------

   287 //

   288 void t_hsapplicationlauncher::testProcessMonitorRunError()

   289 {

   290     CHsLaunch *hsApplicationLauncher = 0;

   291     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());    

   292     QCOMPARE(errNo, KErrNone);

   293     hsApplicationLauncher->Activate();

   294     hsApplicationLauncher->InitProcessMonitorL(0);  

   295     hsApplicationLauncher->iProcessMonitor->RunError(KErrGeneral);

   296     delete hsApplicationLauncher;

   297 }

   298 

   299 // ---------------------------------------------------------------------------

   300 // ---------------------------------------------------------------------------

   301 //

   302 void t_hsapplicationlauncher::testShutDownMonitorRunL()

   303 {

   304     CHsLaunch *hsApplicationLauncher = 0;

   305     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());    

   306     QCOMPARE(errNo, KErrNone);

   307     hsApplicationLauncher->Activate();

   308     QVERIFY(hsApplicationLauncher->iShutdownMonitor);

   309     if(hsApplicationLauncher->iShutdownMonitor->IsActive())

   310     {

   311         hsApplicationLauncher->iShutdownMonitor->Cancel();

   312     }

   313     hsApplicationLauncher->iShutdownMonitor->RunL();

   314     delete hsApplicationLauncher;

   315 }

   316 

   317 // ---------------------------------------------------------------------------

   318 // ---------------------------------------------------------------------------

   319 //

   320 void t_hsapplicationlauncher::testShutDownMonitorDoCancel()

   321 {

   322     CHsLaunch *hsApplicationLauncher = 0;

   323     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());    

   324     QCOMPARE(errNo, KErrNone);

   325     hsApplicationLauncher->Activate();

   326     QVERIFY(hsApplicationLauncher->iShutdownMonitor);

   327     hsApplicationLauncher->iShutdownMonitor->DoCancel();

   328     delete hsApplicationLauncher;

   329 }

   330 

   331 // ---------------------------------------------------------------------------

   332 // ---------------------------------------------------------------------------

   333 //

   334 void t_hsapplicationlauncher::testShutDownMonitorRunError()

   335 {

   336     CHsLaunch *hsApplicationLauncher = 0;

   337     TRAPD(errNo, hsApplicationLauncher = CHsLaunch::NewL());    

   338     QCOMPARE(errNo, KErrNone);

   339     hsApplicationLauncher->Activate();

   340     QVERIFY(hsApplicationLauncher->iShutdownMonitor);

   341     errNo = hsApplicationLauncher->iShutdownMonitor->RunError(KErrGeneral);

   342     QCOMPARE(errNo, KErrGeneral);

   343     delete hsApplicationLauncher;

   344 }

   345 

   346 QTEST_MAIN(t_hsapplicationlauncher)