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:  Implementation of the Ut_VmbxEngine class

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 #include <cvoicemailbox.h>

    20 #include <cvoicemailboxentry.h>

    21 #include <voicemailboxdefs.h>

    22 

    23 #include "ut_vmbxengine.h"

    24 

    25 _LIT(KNumber, "987654321");

    26 _LIT(KName, "Name");

    27 _LIT8(KBrandId, "Brand Id");

    28 

    29 Ut_VmbxEngine::Ut_VmbxEngine(): mVmbx(NULL),mEntry(NULL)

    30 {

    31     qDebug("Ut_VmbxEngine");

    32 }

    33 

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

    35 // Ut_VmbxEngine::~Ut_VmbxEngine

    36 // -----------------------------------------------------------------------------    

    37 Ut_VmbxEngine::~Ut_VmbxEngine()

    38 {

    39     delete mVmbx;

    40     mVmbx = NULL;

    41     delete mEntry;

    42     mEntry = NULL; 

    43     qDebug("~Ut_VmbxEngine");

    44 }

    45 

    46 // Test API

    47 void Ut_VmbxEngine::testVmbxApi()

    48 {

    49     createVmbxApi();

    50     deleteVmbxApi();

    51 }

    52 

    53 void Ut_VmbxEngine::testEntryApi()

    54 {

    55     createEntryApi();

    56     deleteEntryApi();  

    57 }

    58 

    59 // Test Vmbx start

    60 void Ut_VmbxEngine::testGetStoredEntry()

    61 {

    62     createVmbxApi();

    63     

    64     TVoiceMailboxParams params;

    65     params.iType = EVmbxVoice;

    66     CVoiceMailboxEntry *tmpEntry = NULL;

    67     

    68     QCOMPARE(mVmbx->GetStoredEntry(params, tmpEntry), KErrNone);

    69     qDebug("Get entry");

    70     if (tmpEntry){

    71         delete tmpEntry;

    72         tmpEntry = NULL;  

    73         qDebug("delete tmp entry pointer");

    74     }

    75     

    76     // Save a entry first, get and compare after that

    77     createEntryApi();

    78     mEntry->SetVoiceMailboxType(EVmbxVoice);

    79     mEntry->SetVmbxNumber(KNumber);

    80     qDebug("Set type");

    81     QCOMPARE(mVmbx->SaveEntry(*mEntry), KErrNone);

    82     qDebug("Save entry");

    83     deleteEntryApi();

    84     

    85     params.iType = EVmbxVoice;

    86     mVmbx->GetStoredEntry(params, tmpEntry);

    87     qDebug("Get entry");

    88     if (tmpEntry){

    89         QCOMPARE(tmpEntry->VoiceMailboxType(), EVmbxVoice);

    90         delete tmpEntry;

    91         tmpEntry = NULL;  

    92         qDebug("delete tmp entry pointer");

    93     }

    94     

    95     deleteVmbxApi();

    96 }

    97 

    98 void Ut_VmbxEngine::testSaveEntry()

    99 {

   100     createVmbxApi();

   101     

   102     // Set some attributes to the new empty entry and save it

   103     createEntryApi();

   104     mEntry->SetVoiceMailboxType(EVmbxVoice);

   105     mEntry->SetUsingMemoryLocation(EVmbxPhoneMemory);

   106     mEntry->SetVmbxNumber(KNumber);

   107     qDebug("Set type & location");

   108     QCOMPARE(mVmbx->SaveEntry(*mEntry), KErrNone);

   109     qDebug("Save entry");

   110     deleteEntryApi();  

   111     

   112     TVoiceMailboxParams params;

   113     params.iType = EVmbxVoice;

   114     CVoiceMailboxEntry *tmpEntry = NULL;;

   115     mVmbx->GetStoredEntry(params, tmpEntry);

   116     qDebug("Get entry");

   117     if (tmpEntry){

   118         QCOMPARE(tmpEntry->VoiceMailboxType(), EVmbxVoice);

   119         qDebug("Verify type");

   120         QCOMPARE(tmpEntry->UsingMemoryLocation(), EVmbxPhoneMemory);

   121         qDebug("Verify location");

   122         delete tmpEntry;

   123         tmpEntry = NULL;

   124     }

   125     deleteVmbxApi();

   126 }

   127 

   128 void Ut_VmbxEngine::testQueryNewEntry()

   129 {

   130     createVmbxApi();

   131     CVoiceMailboxEntry *tmpEntry = NULL;

   132     TVoiceMailboxParams params;

   133     

   134     // Query a new voice entry

   135     // Mock the CRepository

   136     params.iType = EVmbxVoice;  

   137     QCOMPARE(mVmbx->QueryNewEntry(params, tmpEntry), KErrNone);

   138     QVERIFY(tmpEntry);

   139     QCOMPARE(tmpEntry->VoiceMailboxType(), EVmbxVoice);

   140     delete tmpEntry;

   141     tmpEntry = NULL;

   142     

   143     /*

   144     // Query a new Video entry

   145     params.iType = EVmbxVideo;

   146     QCOMPARE(mVmbx->QueryNewEntry(params, tmpEntry), KErrNone);

   147     QVERIFY(tmpEntry);

   148     QCOMPARE(tmpEntry->VoiceMailboxType(), EVmbxVideo);

   149     delete tmpEntry;

   150     tmpEntry = NULL;

   151     

   152     // Query a new voice entry

   153     params.iType = EVmbxVoip;

   154     QCOMPARE(mVmbx->QueryNewEntry(params, tmpEntry), KErrNone);

   155     QVERIFY(tmpEntry);

   156     QCOMPARE(tmpEntry->VoiceMailboxType(), EVmbxVoip);

   157     delete tmpEntry;

   158     tmpEntry = NULL;    

   159     

   160     // Query a unknown entry

   161     params.iType = EVmbxNone;

   162     QCOMPARE(mVmbx->QueryNewEntry(params, tmpEntry), KErrNone);

   163     QVERIFY(tmpEntry);

   164     QCOMPARE(tmpEntry->VoiceMailboxType(), EVmbxNone);

   165     delete tmpEntry;

   166     tmpEntry = NULL;       

   167     */

   168     deleteVmbxApi();

   169     

   170 }

   171 

   172 void Ut_VmbxEngine::testQueryChangeEntry()

   173 {

   174     createVmbxApi();

   175     

   176     CVoiceMailboxEntry *tmpEntry = NULL;;

   177     TVoiceMailboxParams params;

   178     params.iType = EVmbxVoice;  

   179     // Always get KErrNotFound, Check why.

   180     //QCOMPARE(mVmbx->QueryChangeEntry(params, tmpEntry), KErrNone);

   181     mVmbx->QueryChangeEntry(params, tmpEntry);

   182     //QVERIFY(tmpEntry);

   183     delete tmpEntry;

   184     tmpEntry = NULL;    

   185     

   186     deleteVmbxApi();

   187 }

   188 

   189 void Ut_VmbxEngine::testQueryVmbxType()

   190 {

   191     createVmbxApi(); 

   192 

   193     // Save a entry first

   194     CVoiceMailboxEntry *tmpEntry = NULL;

   195     TVoiceMailboxParams params;

   196     params.iType = EVmbxVoice;  

   197     QCOMPARE(mVmbx->QueryNewEntry(params, tmpEntry), KErrNone);

   198     tmpEntry->SetVoiceMailboxType(EVmbxVoice);

   199     tmpEntry->SetVmbxNumber(KNumber);

   200     QCOMPARE(mVmbx->SaveEntry(*tmpEntry), KErrNone);

   201     delete tmpEntry;

   202     tmpEntry = NULL;

   203     

   204     // Query and compare vmbx type after saving

   205     mVmbx->QueryVmbxType(params);

   206 

   207     deleteVmbxApi();

   208 }

   209 

   210 // TODO: Add 2 public test cases for notification, mock observer frist.

   211 //void testNotifyVmbxNumberChangeL();

   212 //void NotifyVmbxNumberChangeCancel();

   213 

   214 void Ut_VmbxEngine::testGetServiceIds()

   215 {

   216     createVmbxApi(); 

   217     /*

   218     // Save a entry first

   219     createEntryApi();

   220     TServiceId idExp(10);

   221     mEntry->SetServiceId(idExp);

   222     mEntry->SetVoiceMailboxType(EVmbxVoip);

   223     QCOMPARE(mVmbx->SaveEntry(*mEntry), KErrNone);

   224     deleteEntryApi();

   225     

   226     // Query and compare vmbx type after saving

   227     RIdArray ids;

   228     QCOMPARE(mVmbx->GetServiceIds(ids), KErrNone);

   229     TServiceId idAct = ids[0];

   230     QCOMPARE(idAct, idExp);

   231     */

   232     deleteVmbxApi();    

   233 }

   234 

   235 void Ut_VmbxEngine::testCheckConfiguration()

   236 {

   237     createVmbxApi();

   238     TVoiceMailboxParams params;

   239     params.iType = EVmbxVoice;

   240     TBool result = mVmbx->CheckConfiguration(

   241         params, EVmbxChangeNbrAllowedOnUi);

   242     if (!result) {

   243         QEXPECT_FAIL("","voice not allowed changed", Continue);

   244     }

   245     params.iType = EVmbxVideo;

   246     result = mVmbx->CheckConfiguration(

   247         params,EVmbxChangeNbrAllowedOnUi);

   248     if (!result) {

   249         QEXPECT_FAIL("","video not allowed changed", Continue);

   250     }

   251     params.iType = EVmbxVoip;

   252     result = mVmbx->CheckConfiguration(

   253         params,EVmbxChangeNbrAllowedOnUi);

   254     if (result) {

   255         QFAIL ("voip failed");

   256     }

   257     deleteVmbxApi();

   258 }

   259 

   260 void Ut_VmbxEngine::testSaveProvisionedEntry()

   261 {

   262     createVmbxApi();    

   263     // Voice

   264     createEntryApi();

   265     mEntry->SetVoiceMailboxType(EVmbxVoice);

   266     mEntry->SetVmbxNumber(KNumber);

   267     QCOMPARE(mVmbx->SaveProvisionedEntry(*mEntry), KErrNone);

   268     deleteEntryApi();

   269     

   270     // Video

   271     createEntryApi();

   272     mEntry->SetVoiceMailboxType(EVmbxVideo);

   273     mEntry->SetVmbxNumber(KNumber);

   274     QCOMPARE(mVmbx->SaveProvisionedEntry(*mEntry), KErrNone);

   275     deleteEntryApi();

   276     

   277     deleteVmbxApi();

   278 }

   279 // Test Vmbx end

   280 

   281 

   282 // Test Entry start

   283 void Ut_VmbxEngine::testType()

   284 {

   285     createEntryApi();

   286     mEntry->SetVoiceMailboxType(EVmbxNone);

   287     QCOMPARE(mEntry->VoiceMailboxType(), EVmbxNone);

   288     

   289     mEntry->SetVoiceMailboxType(EVmbxVoice);

   290     QCOMPARE(mEntry->VoiceMailboxType(), EVmbxVoice);

   291     

   292     mEntry->SetVoiceMailboxType(EVmbxVideo);

   293     QCOMPARE(mEntry->VoiceMailboxType(), EVmbxVideo);

   294     

   295     deleteEntryApi();

   296 }

   297 

   298 void Ut_VmbxEngine::testName()

   299 {

   300     createEntryApi();

   301     

   302     // Valid string

   303     TPtrC nameIn(KName);

   304     mEntry->SetVmbxName(nameIn);

   305     TPtrC nameOut(KNullDesC);

   306     mEntry->GetVmbxName(nameOut);

   307     QCOMPARE(nameOut, nameIn);

   308     

   309     // Invalid string

   310 //    HBufC *name = HBufC::NewLC(KVmbxMaxNumberLength+1);

   311 //    QCOMPARE(mEntry->SetVmbxName(name->Des()), KErrArgument);

   312 //    CleanupStack::PopAndDestroy(name);

   313     

   314     deleteEntryApi();      

   315 }

   316 

   317 void Ut_VmbxEngine::testServiceId()

   318 {

   319     createEntryApi();

   320     

   321     TServiceId idIn(10);

   322     mEntry->SetServiceId(idIn);

   323     QCOMPARE(mEntry->ServiceId(), idIn);    

   324     

   325     deleteEntryApi();      

   326 }

   327 

   328 void Ut_VmbxEngine::testLineType()

   329 {

   330     createEntryApi();

   331    

   332     // Als is disable in TB10.1

   333     /*

   334     mEntry->SetVmbxAlsLineType(EVmbxAlsLineDefault);

   335     QCOMPARE(mEntry->VmbxAlsLineType(), EVmbxAlsLineDefault);

   336     

   337     mEntry->SetVmbxAlsLineType(EVmbxAlsLine1);

   338     QCOMPARE(mEntry->VmbxAlsLineType(), EVmbxAlsLine1);

   339     

   340     mEntry->SetVmbxAlsLineType(EVmbxAlsLine2);

   341     QCOMPARE(mEntry->VmbxAlsLineType(), EVmbxAlsLine2);

   342     */

   343     deleteEntryApi();  

   344 }

   345 

   346 void Ut_VmbxEngine::testNumber()

   347 {

   348     createEntryApi();

   349     

   350     // Valid number

   351     TPtrC numberIn(KNumber);

   352     mEntry->SetVmbxNumber(numberIn);

   353     TPtrC numberOut(KNullDesC);

   354     mEntry->GetVmbxNumber(numberOut);

   355     QCOMPARE(numberOut, numberIn);

   356     

   357     // Invalid number

   358 //    HBufC *number = HBufC::NewLC(KVmbxMaxNumberLength+1);

   359 //    QCOMPARE(mEntry->SetVmbxNumber(number->Des()), KErrArgument);

   360 //    CleanupStack::PopAndDestroy(number);

   361     

   362     deleteEntryApi();  

   363 }

   364 

   365 void Ut_VmbxEngine::testBrandId()

   366 {

   367     createEntryApi();

   368 

   369     // Valid braind id

   370     TPtrC8 brandIn(KBrandId);

   371     QCOMPARE(mEntry->SetBrandId(brandIn), KErrNone);  

   372     

   373     TPtrC8 brandOut(KNullDesC8);

   374     QCOMPARE(mEntry->GetBrandId(brandOut), KErrNone);

   375     

   376     if (brandOut.Compare(brandIn)){

   377         QFAIL("Fail to Set/Get BrandId");

   378     }

   379     

   380     // Invalid Brand Id

   381 //    HBufC8 *invalid = HBufC8::NewLC(KVmbxMaxNumberLength+1);

   382 //    QCOMPARE(mEntry->SetBrandId(invalid->Des()), KErrArgument);

   383 //    CleanupStack::PopAndDestroy(invalid);    

   384     

   385     deleteEntryApi();  

   386 }

   387 

   388 void Ut_VmbxEngine::testUsingMemoryLocation()

   389 {

   390     createEntryApi();

   391     

   392     mEntry->SetUsingMemoryLocation(EVmbxPhoneMemory);

   393     QCOMPARE(mEntry->UsingMemoryLocation(), EVmbxPhoneMemory);

   394     

   395     mEntry->SetUsingMemoryLocation(EVmbxSimMemory);

   396         QCOMPARE(mEntry->UsingMemoryLocation(), EVmbxSimMemory);

   397         

   398     deleteEntryApi();  

   399 }

   400 

   401 void Ut_VmbxEngine::testReset()

   402 {

   403     createEntryApi();

   404     

   405     mEntry->Reset();

   406     QCOMPARE(mEntry->ServiceId(), KVmbxServiceIdNone);

   407     QCOMPARE(mEntry->VoiceMailboxType(), EVmbxNone);

   408     QCOMPARE(mEntry->VmbxAlsLineType(), EVmbxAlsLineDefault);

   409     

   410     TPtrC8 brand(KNullDesC8);

   411     QCOMPARE(mEntry->GetBrandId(brand), KErrNotFound);

   412     

   413     TPtrC name;

   414     QCOMPARE(mEntry->GetVmbxName(name), KErrNotFound);

   415     

   416     TPtrC number;

   417     QCOMPARE(mEntry->GetVmbxNumber(number), KErrNotFound);

   418     

   419     QCOMPARE(mEntry->UsingMemoryLocation(), EVmbxSimMemory);

   420     

   421     deleteEntryApi();  

   422 }

   423 // Test Entry end 

   424 

   425 // Private function: create 2 data member

   426 void Ut_VmbxEngine::createVmbxApi()

   427 {   

   428     if (!mVmbx){

   429         TRAPD( err, mVmbx = CVoiceMailbox::NewL());

   430         QVERIFY(mVmbx);

   431         qDebug("Create vmbx api TRAP: %d", err);

   432     }

   433 }

   434 void Ut_VmbxEngine::deleteVmbxApi()

   435 {

   436     delete mVmbx;

   437     mVmbx = NULL;

   438     qDebug("Delete vmbx api");

   439 }

   440 void Ut_VmbxEngine::createEntryApi()

   441 {

   442     if (!mEntry){

   443         TRAPD( err, mEntry = CVoiceMailboxEntry::NewL());

   444         QVERIFY(mEntry);

   445         qDebug("Create entry Api TRAP: %d", err);

   446     }  

   447 }

   448 

   449 void Ut_VmbxEngine::deleteEntryApi()

   450 {

   451     delete mEntry;

   452     mEntry = NULL;

   453     qDebug("Delete entry api");

   454 }

   455 // End of file