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:  Tests for JvmStarter class

    15 *

    16 */

    17 

    18 #include <string>

    19 #include <vector>

    20 #include <memory>

    21 

    22 #include "coreuitestimpl.h"

    23 #include "dynamiclibloader.h"

    24 

    25 #include "TestHarness.h"

    26 #include "testutils.h"

    27 #include "javaoslayer.h"

    28 #include "logger.h"

    29 

    30 using namespace java::util;

    31 using namespace java::ui;

    32 

    33 

    34 class CoreUiTestHandlerImpl : public CoreUiTestHandler

    35 {

    36 public:

    37     CoreUiTestHandlerImpl() : mUiParams(0)

    38     {

    39         reset();

    40     }

    41     ~CoreUiTestHandlerImpl()

    42     {

    43         delete mUiParams;

    44         mUiParams = 0;

    45     }

    46 

    47     virtual void startCalled(const Uid& midletUid, CoreUiParams* uiParams)

    48     {

    49         mMidletUid = midletUid;

    50         if (mUiParams)

    51         {

    52             delete mUiParams;

    53             mUiParams = 0;

    54         }

    55         if (uiParams)

    56         {

    57             mUiParams = new CoreUiParams();

    58             *mUiParams = *uiParams;

    59         }

    60         mStartCalledCount++;

    61     }

    62     virtual void releaseCalled()

    63     {

    64         mReleaseCalledCount++;

    65     }

    66     virtual void error(const std::string& info)

    67     {

    68         CHECKWITHNOTE(false, info)

    69     }

    70 

    71     void reset()

    72     {

    73         mStartCalledCount = 0;

    74         mReleaseCalledCount = 0;

    75     }

    76     int  mStartCalledCount;

    77     int  mReleaseCalledCount;

    78     CoreUiParams* mUiParams;

    79     Uid  mMidletUid;

    80 };

    81 

    82 #define UIPARAMSCHECK(check1, check2, fname, info) \

    83     CHECKWITHNOTE(check1 == check2, info << ": " << fname << " failed: 1=" << check1 << " 2=" << check2);

    84 

    85 

    86 void compare(const CoreUiParams* uiParams1, const CoreUiParams* uiParams2, const std::string& info)

    87 {

    88     bool pass = false;

    89     if ((uiParams1 == 0 && uiParams2 != 0) || (uiParams1 != 0 && uiParams2 == 0))

    90     {

    91         CHECKWITHNOTE(false, info << ": pointer mismatch 1=" << std::hex << uiParams1  << ", 2=" << std::hex << uiParams2);

    92         return;

    93     }

    94 

    95     if (uiParams1 == 0 && uiParams2 == 0)

    96     {

    97         return;

    98     }

    99     else if (uiParams1 != uiParams2)

   100     {

   101         pass = true;

   102     }

   103     CHECKWITHNOTE(pass, info << ": pointer mismatch 1=" << std::hex << uiParams1  << ", 2=" << std::hex << uiParams2);

   104     UIPARAMSCHECK(uiParams1->getOrientation(), uiParams2->getOrientation(), "getOrientation", info);

   105     UIPARAMSCHECK(uiParams1->getScreenMode(), uiParams2->getScreenMode(), "getScreenMode", info);

   106     UIPARAMSCHECK(uiParams1->getImagePath(), uiParams2->getImagePath(), "getImagePath", info);

   107     UIPARAMSCHECK(uiParams1->isBackgroundStart(), uiParams2->isBackgroundStart(), "isBackgroundStart", info);

   108 

   109 }

   110 

   111 void checkCallCounts(const CoreUiTestHandlerImpl& testHandler, int start, int release, const std::string& info)

   112 {

   113     CHECKWITHNOTE(testHandler.mStartCalledCount == start, info <<". Start call count incorrect: " << testHandler.mStartCalledCount

   114                   <<", expecting: "<<start);

   115     CHECKWITHNOTE(testHandler.mReleaseCalledCount == release, info << "Release call count incorrect: " << testHandler.mReleaseCalledCount

   116                   <<", expecting: "<<release);

   117 }

   118 

   119 typedef void (*SetTestHandler)(CoreUiTestHandler*);

   120 

   121 // Run these tests with tst.bat. These tests require that the test version of the

   122 // javacoreui.dll is compiled

   123 TEST_GROUP(TestCoreUi)

   124 {

   125     CoreUiTestHandlerImpl testHandler;

   126     CoreUiParams uiParams;

   127     Uid uid;

   128     std::auto_ptr<java::util::DynamicLibLoader> basicCoreUiLoader;

   129     TEST_SETUP()

   130     {

   131         basicCoreUiLoader.reset(new java::util::DynamicLibLoader(COREUI_LIB_NAME));

   132         SetTestHandler setTestHandler =

   133             reinterpret_cast<SetTestHandler>(basicCoreUiLoader->getFunction("setTestHandler",

   134                                              true));

   135         setTestHandler(&testHandler);

   136     }

   137 

   138     TEST_TEARDOWN()

   139     {

   140     }

   141 };

   142 

   143 

   144 // Run these tests with tst2.bat. These tests require that the javacoreui.dll

   145 // doesn't exist at all.

   146 TEST_GROUP(NoDllCoreUiTest)

   147 {

   148     Uid uid;

   149     TEST_SETUP()

   150     {

   151     }

   152 

   153     TEST_TEARDOWN()

   154     {

   155     }

   156 };

   157 

   158 TEST(TestCoreUi, testBasic)

   159 {

   160     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   161     // __BREAKPOINT();

   162     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testBasic, start");

   163     checkCallCounts(testHandler, 1, 0, "Before release");

   164     CHECKWITHNOTE(CoreUi::releaseUi(coreUiLoader), "testBasic release");

   165     checkCallCounts(testHandler, 1, 1, "After release");

   166     compare(testHandler.mUiParams, &uiParams, "Final check basic");

   167 }

   168 

   169 TEST(TestCoreUi, testNullUiParams)

   170 {

   171     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   172     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid), "testNullUiParams, start");

   173     checkCallCounts(testHandler, 1, 0, "Before release");

   174     CHECKWITHNOTE(CoreUi::releaseUi(coreUiLoader), "testNullUiParams release");

   175     checkCallCounts(testHandler, 1, 1, "After release");

   176     compare(testHandler.mUiParams, 0, "Final check Null ui");

   177 }

   178 

   179 TEST(TestCoreUi, testModifiedOrientationArgs)

   180 {

   181     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   182 

   183     uiParams.setOrientation(UNDEFINED);

   184     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedOrientationArgs, start1");

   185     checkCallCounts(testHandler, 1, 0, "Before release");

   186     compare(testHandler.mUiParams, &uiParams, "OrientationArgs UNDEFINED");

   187 

   188     uiParams.setOrientation(LANDSCAPE);

   189     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedOrientationArgs, start2");

   190     checkCallCounts(testHandler, 2, 0, "Before release");

   191     compare(testHandler.mUiParams, &uiParams, "OrientationArgs LANDSCAPE");

   192 

   193     uiParams.setOrientation(PORTRAIT);

   194     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedOrientationArgs, start3");

   195     checkCallCounts(testHandler, 3, 0, "Before release");

   196     compare(testHandler.mUiParams, &uiParams, "OrientationArgs PORTRAIT");

   197 

   198     CHECKWITHNOTE(CoreUi::releaseUi(coreUiLoader), "testModifiedOrientationArgs release");

   199     checkCallCounts(testHandler, 3, 1, "After release");

   200 }

   201 

   202 TEST(TestCoreUi, testModifiedScreenModeArgs)

   203 {

   204     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   205 

   206     uiParams.setScreenMode(NO_START_SCREEN);

   207     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedScreenModeArgs, start1");

   208     checkCallCounts(testHandler, 1, 0, "Before release");

   209     compare(testHandler.mUiParams, &uiParams, "ScreenModeArgs NO_START_SCREEN");

   210 

   211     uiParams.setScreenMode(DEFAULT_START_SCREEN);

   212     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedScreenModeArgs, start2");

   213     checkCallCounts(testHandler, 2, 0, "Before release");

   214     compare(testHandler.mUiParams, &uiParams, "ScreenModeArgs DEFAULT_START_SCREEN");

   215 

   216     uiParams.setScreenMode(MIDLET_DEFINED_SCREEN);

   217     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedScreenModeArgs, start3");

   218     checkCallCounts(testHandler, 3, 0, "Before release");

   219     compare(testHandler.mUiParams, &uiParams, "ScreenModeArgs MIDLET_DEFINED_SCREEN");

   220 

   221     uiParams.setScreenMode(USER_DEFINED_SCREEN);

   222     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedScreenModeArgs, start4");

   223     checkCallCounts(testHandler, 4, 0, "Before release");

   224     compare(testHandler.mUiParams, &uiParams, "ScreenModeArgs USER_DEFINED_SCREEN");

   225 

   226     CHECKWITHNOTE(CoreUi::releaseUi(coreUiLoader), "testModifiedScreenModeArgs release");

   227     checkCallCounts(testHandler, 4, 1, "After release");

   228 }

   229 

   230 TEST(TestCoreUi, testModifiedImagePathArgs)

   231 {

   232     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   233 

   234     uiParams.setImagePath(L"c:\\logs\\java\\");

   235     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedImagePathArgs start");

   236     checkCallCounts(testHandler, 1, 0, "Before release");

   237     compare(testHandler.mUiParams, &uiParams, "ImagePathArgs");

   238 

   239     CHECKWITHNOTE(CoreUi::releaseUi(coreUiLoader), "testModifiedImagePathArgs release");

   240     checkCallCounts(testHandler, 1, 1, "After release");

   241 }

   242 

   243 TEST(TestCoreUi, testModifiedForeGroundArgs)

   244 {

   245     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   246 

   247     uiParams.setBackgroundStart(true);

   248     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedForeGroundArgs start1");

   249     checkCallCounts(testHandler, 1, 0, "Before release");

   250     compare(testHandler.mUiParams, &uiParams, "ForeGround");

   251 

   252     uiParams.setBackgroundStart(false);

   253     CHECKWITHNOTE(CoreUi::start(coreUiLoader, uid, &uiParams), "testModifiedForeGroundArgs start2");

   254     checkCallCounts(testHandler, 2, 0, "Before release");

   255     compare(testHandler.mUiParams, &uiParams, "ForeGround");

   256 

   257     CHECKWITHNOTE(CoreUi::releaseUi(coreUiLoader), "testModifiedForeGroundArgs release");

   258     checkCallCounts(testHandler, 2, 1, "After release");

   259 }

   260 

   261 TEST(TestCoreUi, testNoStartCall)

   262 {

   263     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   264     CHECKWITHNOTE(CoreUi::releaseUi(coreUiLoader), "testNoStartCall release");

   265     checkCallCounts(testHandler, 0, 1, "After release");

   266 }

   267 

   268 TEST(NoDllCoreUiTest, testBasic)

   269 {

   270     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   271     CHECKWITHNOTE(!CoreUi::start(coreUiLoader, uid), "testBasic NO_DLL start");

   272     CHECKWITHNOTE(!CoreUi::releaseUi(coreUiLoader), "testBasic NO_DLL release");

   273 }

   274 

   275 TEST(NoDllCoreUiTest, testOnlyStart)

   276 {

   277     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   278     CHECKWITHNOTE(!CoreUi::start(coreUiLoader, uid), "testOnlyStart NO_DLL start");

   279 }

   280 

   281 TEST(NoDllCoreUiTest, testOnlyRelease)

   282 {

   283     std::auto_ptr<java::util::DynamicLibLoader> coreUiLoader;

   284     CHECKWITHNOTE(!CoreUi::releaseUi(coreUiLoader), "testOnlyRelease NO_DLL release");

   285 }