Mercurial Mercurial > oss > FCL > sf > app > phone / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
phoneapp/phoneuiqtviewadapter/tsrc/ut_phonecallheaderutil/unit_tests.cpp
changeset 76 cfea66083b62
parent 74 d1c62c765e48
equal deleted inserted replaced
74:d1c62c765e48 76:cfea66083b62 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 #include <QtTest/QtTest>
 
    18 #include <QtTest/QtTest>
 
    19 #include <mockservice.h>
 
    19 #include <mockservice.h>
 
    20 #include "qtestmains60.h"
 
    20 #include "phonetestmain.h"
 
    21 #include "phonecallheaderutil.h"
 
    21 #include "phonecallheaderutil.h"
 
    22 #include "pevirtualengine.h"
 
    22 #include "pevirtualengine.h"
 
    23 #include "cpeengineinfo.h"
 
    23 #include "cpeengineinfo.h"
 
    24 #include "tphonecmdparamcallheaderdata.h"
 
    24 #include "tphonecmdparamcallheaderdata.h"
 
    25 #include "cphonemainresourceresolver.h"
 
    25 #include "cphonemainresourceresolver.h"
 
    57     void cleanupTestCase ();
 
    57     void cleanupTestCase ();
 
    58     void init ();
 
    58     void init ();
 
    59     void cleanup (); 
    59     void cleanup (); 
    60     
    60     
    61 private slots:
 
    61 private slots:
 
    62     void testSetIncomingCallHeaderParams();
 
    62     void testLabelText();
 
    63     void testSetOutgoingCallHeaderParams();
 
    63     void testGetCliTexts();
 
    64     void testUpdateCallHeaderInfo();
 
       
    65     void testSetCallHeaderType();
 
       
    66     void testSetDivertIndication();
 
       
    67     void testGetRemoteInfoData();
 
    64     void testGetRemoteInfoData();
 
    68     void testSetCallHeaderTexts();
 
    65     void testEngineInfo();
 
    69     void testLabelText();
 
    66     void testIsVoiceCall();
 
       
    67     void testIsVideoCall();
 
       
    68     void testCallHeaderLabelTextForRingingCall();
 
    70     void testEmergencyHeaderText();
 
    69     void testEmergencyHeaderText();
 
    71     void testAttemptingEmergencyText();
 
    70     void testAttemptingEmergencyText();
 
    72     void testCallState();            
       
    73     void testLoadResource();
 
       
    74     
    71     
    75 private:
 
    72 private:
 
    76     CPEEngineInfo* m_engineInfo;
 
    73     CPEEngineInfo* m_engineInfo;
 
    77     PhoneCallHeaderUtil* m_util;
 
    74     PhoneCallHeaderUtil* m_util;
 
    78     CPhoneMainResourceResolverMock* m_resourceResolverMock;
 
    75     CPhoneMainResourceResolverMock* m_resourceResolverMock;
 
   115 void TestPhoneCallHeaderUtil::cleanup ()
 
   112 void TestPhoneCallHeaderUtil::cleanup ()
 
   116 {
 
   113 {
 
   117     reset();
 
   114     reset();
 
   118 }
 
   115 }
 
   119 
   116 
   120 void TestPhoneCallHeaderUtil::testSetIncomingCallHeaderParams()
 
   117 void TestPhoneCallHeaderUtil::testLabelText()
 
   121 {
 
   118 {
 
   122     TPhoneCmdParamCallHeaderData data;       
   119     const int callId = 1;
 
   123     
   120     QVERIFY( m_util->LabelText(1) == KNullDesC() );
 
   124     const int callId = 1;
 
   121     
   125     const int serviceId = 100;
 
   122     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
       
   123     
       
   124     m_engineInfo->SetCallState(EPEStateHeld, callId);       
       
   125     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCallOnHold);
 
       
   126     TBuf<100> label = m_util->LabelText(1);
 
       
   127     QVERIFY(verify());
 
       
   128     reset();
 
       
   129     
       
   130     m_engineInfo->SetCallState(EPEStateHeldConference, callId);
 
       
   131     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCallOnHold);
 
       
   132     label = m_util->LabelText(1);
 
       
   133     QVERIFY(verify());
 
       
   134     reset();
 
       
   135     
       
   136     m_engineInfo->SetCallState(EPEStateDisconnecting, callId);
 
       
   137     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneInCallDisconnected);
 
       
   138     label = m_util->LabelText(1);
 
       
   139     QVERIFY(verify());
 
       
   140     reset();
 
       
   141     
       
   142     m_engineInfo->SetCallState(EPEStateConnectedConference, callId);
 
       
   143     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCLIConferenceCall);
 
       
   144     label = m_util->LabelText(1);
 
       
   145     QVERIFY(verify());
 
       
   146     reset();
 
       
   147     
       
   148     m_engineInfo->SetCallState(EPEStateDialing, callId);
 
       
   149     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneOutgoingCallLabel);
 
       
   150     label = m_util->LabelText(1);
 
       
   151     QVERIFY(verify());
 
       
   152     reset();
 
       
   153     
       
   154     m_engineInfo->SetCallType(EPECallTypeVideo, callId);
 
       
   155     m_engineInfo->SetCallState(EPEStateDialing, callId);
 
       
   156     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneOutgoingVideoCallLabel);
 
       
   157     label = m_util->LabelText(1);
 
       
   158     QVERIFY(verify());
 
       
   159     reset();
 
       
   160 }
 
       
   161 
       
   162 void TestPhoneCallHeaderUtil::testGetCliTexts()
 
       
   163 {
 
       
   164     const int callId = 1;
 
       
   165     const int conferenceCallId = 8;
 
       
   166     const int emergencyCallId = 7;
 
   126     _LIT(KPhoneNumber,"123456");
 
   167     _LIT(KPhoneNumber,"123456");
 
   127     _LIT(KCallerImage,"image.jpg");
 
   168     _LIT(KPhoneRemoteName,"test_name");
 
   128     
   169     
   129     m_engineInfo->SetCallState(EPEStateRinging, callId);
 
   170     TBuf<100> cliText;
 
   130     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
   171     PhoneCallHeaderUtil::ClippingDirection cliClip;
 
   131     m_engineInfo->SetCallSecureStatus(EFalse, callId);
 
   172     TBuf<100> secondaryCliText;
 
   132     m_engineInfo->SetSecureSpecified(ETrue);
 
   173     PhoneCallHeaderUtil::ClippingDirection secondaryCliClip;
 
   133     m_engineInfo->SetServiceId(callId, serviceId);
 
   174     
       
   175     
   134     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(), callId);
 
   176     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(), callId);
 
   135     m_engineInfo->SetRemotePhoneNumberType(EPEMobileNumber, callId);
 
   177 
   136     m_engineInfo->SetCallerImage(KCallerImage(), callId);
 
   178     m_util->GetCliTexts(callId,cliText, cliClip, secondaryCliText, secondaryCliClip);
 
   137     m_engineInfo->SetIncomingCallForwarded(ETrue, callId);
 
   179     QVERIFY(cliText == KPhoneNumber());
 
   138     
   180     QVERIFY(cliClip == PhoneCallHeaderUtil::ELeft);
 
   139     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneIncomingCallLabel);    
   181     QVERIFY(secondaryCliText == KNullDesC());
 
   140     m_util->SetIncomingCallHeaderParams(callId,EFalse,EFalse,&data);
 
   182     
   141     QVERIFY(verify());
 
   183     m_engineInfo->SetRemoteName(KPhoneRemoteName(), callId);
 
   142     
   184     
   143     QVERIFY(data.CallState()==EPEStateRinging);
 
   185     m_util->GetCliTexts(callId,cliText, cliClip, secondaryCliText, secondaryCliClip);
 
   144     QVERIFY(data.CallType()==EPECallTypeCSVoice);
 
   186     QVERIFY(cliText == KPhoneRemoteName());
 
   145     QVERIFY(data.Ciphering()==EFalse);
 
   187     QVERIFY(cliClip == PhoneCallHeaderUtil::ERight);
 
   146     QVERIFY(data.CipheringIndicatorAllowed()==ETrue);
 
   188     QVERIFY(secondaryCliText == KPhoneNumber());
 
   147     QVERIFY(data.ServiceId()==serviceId);
 
   189     QVERIFY(secondaryCliClip == PhoneCallHeaderUtil::ELeft);
 
   148     QVERIFY(data.RemotePhoneNumber()==KPhoneNumber);
 
   190     
   149     QVERIFY(data.NumberType()==EPEMobileNumber);
 
   191     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCLIConferenceCall);
 
   150     QVERIFY(data.Picture()==KCallerImage);
 
   192     m_util->GetCliTexts(conferenceCallId,cliText, cliClip, secondaryCliText, secondaryCliClip);
 
   151     QVERIFY(data.Diverted()==ETrue);
 
   193     QVERIFY(verify());
 
   152 }
 
   194     reset();
 
   153 
   195     
   154 void TestPhoneCallHeaderUtil::testSetOutgoingCallHeaderParams()
 
   196     secondaryCliText = KNullDesC();
 
   155 {
 
   197     m_util->GetCliTexts(emergencyCallId,cliText, cliClip, secondaryCliText, secondaryCliClip);
 
   156     TPhoneCmdParamCallHeaderData data;
 
   198     QVERIFY( secondaryCliText == KNullDesC() );
 
   157     
   199     QVERIFY( cliClip == PhoneCallHeaderUtil::ERight );
 
   158     const int callId = 1;
 
   200     
   159     const int serviceId = 100;
 
   201     m_util->GetSecondaryCli(emergencyCallId, secondaryCliText, secondaryCliClip);
 
       
   202     QVERIFY( secondaryCliText == KNullDesC() );
 
       
   203     
       
   204     m_util->GetCli(emergencyCallId, cliText, cliClip);
 
       
   205     QVERIFY( secondaryCliText == KNullDesC() );
 
       
   206 }
 
       
   207 
       
   208 void TestPhoneCallHeaderUtil::testGetRemoteInfoData()
 
       
   209 {
 
       
   210     const int callId = 1;
 
       
   211     const int conferenceCallId = 8;
 
       
   212     const int emergencyCallId = 7;
 
   160     _LIT(KPhoneNumber,"123456");
 
   213     _LIT(KPhoneNumber,"123456");
 
   161     _LIT(KCallerImage,"image.jpg");
 
   214     _LIT(KPhoneRemoteName,"test_remotename");
 
   162     
   215     _LIT(KPhoneRemotePartyName,"test_remotepartyname");
 
   163     m_engineInfo->SetCallState(EPEStateDialing, callId);
 
   216     _LIT(KPhoneRemoteCompanyName,"test_remotecompanyname");
 
   164     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
   217     TBuf<100> cliText;
 
   165     m_engineInfo->SetCallSecureStatus(EFalse, callId);
 
   218     PhoneCallHeaderUtil::ClippingDirection cliClip;
 
   166     m_engineInfo->SetSecureSpecified(ETrue);
 
       
   167     m_engineInfo->SetServiceId(callId, serviceId);
 
       
   168     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(), callId);
 
       
   169     m_engineInfo->SetRemotePhoneNumberType(EPEMobileNumber, callId);
 
       
   170     m_engineInfo->SetCallerImage(KCallerImage(), callId);
 
       
   171     
       
   172     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneOutgoingCallLabel);    
       
   173     m_util->SetOutgoingCallHeaderParams(callId,&data);
 
       
   174     QVERIFY(verify());
 
       
   175     
       
   176     QVERIFY(data.CallState()==EPEStateDialing);
 
       
   177     QVERIFY(data.CallType()==EPECallTypeCSVoice);
 
       
   178     QVERIFY(data.Ciphering()==EFalse);
 
       
   179     QVERIFY(data.CipheringIndicatorAllowed()==ETrue);
 
       
   180     QVERIFY(data.ServiceId()==serviceId);
 
       
   181     QVERIFY(data.RemotePhoneNumber()==KPhoneNumber);
 
       
   182     QVERIFY(data.NumberType()==EPEMobileNumber);
 
       
   183     QVERIFY(data.Picture()==KCallerImage);
 
       
   184 }
 
       
   185 
       
   186 void TestPhoneCallHeaderUtil::testUpdateCallHeaderInfo()
 
       
   187 {
 
       
   188     TPhoneCmdParamCallHeaderData data;
 
       
   189     
       
   190     const int callId = 1;
 
       
   191     const int serviceId = 100;
 
       
   192     _LIT(KPhoneNumber,"123456");
 
       
   193     _LIT(KCallerImage,"image.jpg");
 
       
   194     
       
   195     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(), callId);
 
       
   196     m_engineInfo->SetRemotePhoneNumberType(EPEMobileNumber, callId);
 
       
   197     m_engineInfo->SetRemoteIdentity(RMobileCall::ERemoteIdentityAvailable, callId);
 
       
   198     m_engineInfo->SetCallerImage(KCallerImage(), callId);
 
       
   199     
       
   200     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneIncomingCallLabel);    
       
   201     m_util->UpdateCallHeaderInfo(1,0,0,&data);
 
       
   202     QVERIFY(verify());
 
       
   203     
       
   204     QVERIFY(data.CLIText()==KPhoneNumber);
 
       
   205     QVERIFY(data.Picture()==KCallerImage);          
       
   206 }
 
       
   207 
       
   208 void TestPhoneCallHeaderUtil::testSetCallHeaderType()
 
       
   209 {
 
       
   210     m_util->SetCallHeaderType(EPECallTypeCSVoice);
 
       
   211     QVERIFY(m_util->CallHeaderType()==EPECallTypeCSVoice);
 
       
   212 }
 
       
   213 
       
   214 void TestPhoneCallHeaderUtil::testSetDivertIndication()
 
       
   215 {
 
       
   216     m_util->SetDivertIndication(ETrue);
 
       
   217 }
 
       
   218 
       
   219 void TestPhoneCallHeaderUtil::testGetRemoteInfoData()
 
       
   220 {
 
       
   221     TBuf<100> buf;
 
       
   222     const int callId = 1;
 
       
   223     _LIT(KPhoneNumber,"123456");
 
       
   224     
       
   225     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(), callId);
 
       
   226     m_engineInfo->SetRemotePhoneNumberType(EPEMobileNumber, callId);
 
       
   227     m_engineInfo->SetCallDirection(RMobileCall::EMobileTerminated, callId);
 
       
   228     m_engineInfo->SetRemoteIdentity(RMobileCall::ERemoteIdentityAvailable, callId);
 
       
   229     
       
   230     m_util->GetRemoteInfoData(callId,buf);
 
       
   231     QVERIFY(buf==KPhoneNumber());
 
       
   232 }
 
       
   233 
       
   234 void TestPhoneCallHeaderUtil::testSetCallHeaderTexts()
 
       
   235 {
 
       
   236     TPhoneCmdParamCallHeaderData data;    
       
   237     
       
   238     const int callId = 1;
 
       
   239     const int serviceId = 100;
 
       
   240     _LIT(KPhoneNumber,"123456");
 
       
   241         
   219         
   242     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(), callId);
 
   220     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(), callId);
 
       
   221     m_engineInfo->SetRemoteName(KPhoneRemoteName(), callId);
 
       
   222 
       
   223     m_util->GetCli(callId,cliText, cliClip);
 
       
   224     QVERIFY(cliText == KPhoneRemoteName());
 
       
   225     QVERIFY(cliClip == PhoneCallHeaderUtil::ERight);
 
       
   226     
       
   227     m_engineInfo->SetRemoteName(KNullDesC(), callId);
 
       
   228     m_engineInfo->SetRemotePartyName(KPhoneRemotePartyName(), callId);
 
       
   229     m_util->GetCli(callId,cliText, cliClip);
 
       
   230     QVERIFY(cliText == KPhoneRemotePartyName());
 
       
   231     QVERIFY(cliClip == PhoneCallHeaderUtil::ERight);
 
       
   232     
       
   233     m_engineInfo->SetRemotePartyName(KNullDesC(), callId);
 
       
   234     m_engineInfo->SetRemoteCompanyName(KPhoneRemoteCompanyName(), callId);
 
       
   235     m_util->GetCli(callId,cliText, cliClip);
 
       
   236     QVERIFY(cliText == KPhoneRemoteCompanyName());
 
       
   237     QVERIFY(cliClip == PhoneCallHeaderUtil::ERight);
 
       
   238     
       
   239     m_engineInfo->SetRemoteCompanyName(KNullDesC(), callId);
 
       
   240     m_engineInfo->SetRemotePhoneNumber(KNullDesC(), callId);
 
       
   241     m_engineInfo->SetCallDirection(RMobileCall::EMobileTerminated , callId);
 
       
   242     m_engineInfo->SetRemotePhoneNumberType( EPEPrivateNumber, callId);
 
       
   243        
       
   244     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCLIWithheld);
 
       
   245     m_util->GetCli(callId,cliText, cliClip);
 
       
   246     QVERIFY(verify());
 
       
   247     reset();
 
       
   248     
       
   249     m_engineInfo->SetRemotePhoneNumberType( EPEMobileNumber, callId);
 
       
   250     m_engineInfo->SetRemoteIdentity(
 
       
   251             RMobileCall::ERemoteIdentityUnavailableNoCliCoinOrPayphone, callId);
 
       
   252     
       
   253     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCLIPayphone);
 
       
   254     m_util->GetCli(callId,cliText, cliClip);
 
       
   255     QVERIFY(verify());
 
       
   256     reset();
 
       
   257     
       
   258     m_engineInfo->SetRemoteIdentity(
 
       
   259             RMobileCall::ERemoteIdentityAvailableNoCliCoinOrPayphone, callId);
 
       
   260     
       
   261     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCLIPayphone);
 
       
   262     m_util->GetCli(callId,cliText, cliClip);
 
       
   263     QVERIFY(verify());
 
       
   264     reset();
 
       
   265     
       
   266     m_engineInfo->SetRemoteIdentity(
 
       
   267             RMobileCall::ERemoteIdentityUnknown, callId);
 
       
   268     
       
   269     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCallCLIUnknown);
 
       
   270     m_util->GetCli(callId,cliText, cliClip);
 
       
   271     QVERIFY(verify());
 
       
   272     reset();
 
       
   273 }
 
       
   274 
       
   275 void TestPhoneCallHeaderUtil::testEngineInfo()
 
       
   276 {
 
       
   277     const int callId = 1;
 
       
   278     _LIT(KPhoneNumber,"123456");
 
       
   279     m_engineInfo->SetRemotePhoneNumber(KPhoneNumber(),callId);
 
       
   280     QVERIFY(m_util->RemotePhoneNumber(callId)==KPhoneNumber());
 
       
   281     
       
   282     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
       
   283     QVERIFY(m_util->CallType(callId)==EPECallTypeCSVoice);
 
       
   284     
       
   285     m_engineInfo->SetServiceId(callId, 1);
 
       
   286     QVERIFY(m_util->ServiceId(callId)==1);
 
       
   287     
       
   288     m_engineInfo->SetIncomingCallForwarded(true,callId);
 
       
   289     QVERIFY(m_util->IsCallForwarded(callId)==true);
 
       
   290     
       
   291     m_engineInfo->SetSecureSpecified(true);
 
       
   292     QVERIFY(m_util->SecureSpecified()==true);
 
       
   293     
       
   294     m_engineInfo->SetCallSecureStatus(true, callId);
 
       
   295     QVERIFY(m_util->Ciphering(callId)==true);
 
       
   296     
       
   297     QVERIFY(m_util->CallerImage(callId)==KNullDesC());
 
       
   298     
       
   299     m_engineInfo->SetCallState(EPEStateDialing,callId);
 
       
   300     QVERIFY(m_util->CallState(callId)==EPEStateDialing);    
       
   301 }
 
       
   302 
       
   303 
       
   304 void TestPhoneCallHeaderUtil::testIsVoiceCall()
 
       
   305 {
 
       
   306     const int callId = 1;
 
       
   307     const int invalidCallId = -1;
 
       
   308     
       
   309     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
       
   310     QVERIFY(true == m_util->IsVoiceCall(callId));
 
       
   311     
       
   312     m_engineInfo->SetCallType(EPECallTypeVoIP, callId);
 
       
   313     QVERIFY(true == m_util->IsVoiceCall(callId));
 
       
   314     
       
   315     m_engineInfo->SetCallType(EPECallTypeVideo, callId);
 
       
   316     QVERIFY(false == m_util->IsVoiceCall(callId));
 
       
   317     
       
   318     m_engineInfo->SetCallTypeCommand(EPECallTypeCSVoice);
 
       
   319     QVERIFY(true == m_util->IsVoiceCall(invalidCallId));
 
       
   320     
       
   321     m_engineInfo->SetCallTypeCommand(EPECallTypeVoIP);
 
       
   322     QVERIFY(true == m_util->IsVoiceCall(invalidCallId));
 
       
   323     
       
   324     m_engineInfo->SetCallTypeCommand(EPECallTypeVideo);
 
       
   325     QVERIFY(false == m_util->IsVoiceCall(invalidCallId));
 
       
   326 }
 
       
   327 
       
   328 void TestPhoneCallHeaderUtil::testIsVideoCall()
 
       
   329 {
 
       
   330     const int callId = 1;
 
       
   331     const int invalidCallId = -1;
 
       
   332     
       
   333     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
       
   334     QVERIFY(false == m_util->IsVideoCall(callId));
 
       
   335     
       
   336     m_engineInfo->SetCallType(EPECallTypeVideo, callId);
 
       
   337     QVERIFY(true == m_util->IsVideoCall(callId));
 
       
   338     
       
   339     m_engineInfo->SetCallTypeCommand(EPECallTypeCSVoice);
 
       
   340     QVERIFY(false == m_util->IsVideoCall(invalidCallId));
 
       
   341     
       
   342     m_engineInfo->SetCallTypeCommand(EPECallTypeVideo);
 
       
   343     QVERIFY(true == m_util->IsVideoCall(invalidCallId));
 
       
   344 }
 
       
   345 
       
   346 void TestPhoneCallHeaderUtil::testCallHeaderLabelTextForRingingCall()
 
       
   347 {
 
       
   348     const int callId = 1;
 
       
   349     
       
   350     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
       
   351     
       
   352     m_engineInfo->SetCallState(EPEStateRinging, callId);       
       
   353     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneIncomingCallLabel);
 
       
   354     TBuf<100> label = m_util->LabelText(1);
 
       
   355     QVERIFY(verify());
 
       
   356     reset();
 
       
   357     
       
   358     m_engineInfo->SetCallType(EPECallTypeVideo, callId);
 
       
   359     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneVideoCallIncoming);
 
       
   360     label = m_util->LabelText(1);
 
       
   361     QVERIFY(verify());
 
       
   362     reset();
 
       
   363     
       
   364     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
       
   365     m_engineInfo->SetCallState(EPEStateConnected, 2);
 
       
   366     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCallWaitingLabel);
 
       
   367     label = m_util->LabelText(1);
 
       
   368     QVERIFY(verify());
 
       
   369     reset();
 
       
   370     
       
   371     m_engineInfo->SetCallState(EPEStateIdle, 2);
 
   243     m_engineInfo->SetRemotePhoneNumberType(EPEMobileNumber, callId);
 
   372     m_engineInfo->SetRemotePhoneNumberType(EPEMobileNumber, callId);
 
   244     m_engineInfo->SetALSLine(CCCECallParameters::ECCELineTypePrimary);
 
   373     m_engineInfo->SetRemotePhoneNumber(KNullDesC(), callId);
 
   245     
   374     m_engineInfo->SetRemotePartyName(KNullDesC(), callId);
 
   246     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneIncomingCallLabel);
 
   375     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(KPhoneRssCommonFirst);
 
   247     m_util->SetCallHeaderTexts(1,0,0,&data);
 
   376     label = m_util->LabelText(1);
 
   248 
   377     QVERIFY(verify());
 
   249     QVERIFY(verify());                
   378     reset();
 
   250 }
 
       
   251 
       
   252 void TestPhoneCallHeaderUtil::testLabelText()
 
       
   253 {
 
       
   254     const int callId = 1;
 
       
   255    
       
   256     m_engineInfo->SetCallState(EPEStateHeld, callId);
 
       
   257     m_engineInfo->SetCallType(EPECallTypeCSVoice, callId);
 
       
   258     
       
   259     TBuf<100> label = m_util->LabelText(1);
 
       
   260     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(EPhoneCallOnHold);
 
       
   261 }
 
   379 }
 
   262 
   380 
   263 void TestPhoneCallHeaderUtil::testEmergencyHeaderText()
 
   381 void TestPhoneCallHeaderUtil::testEmergencyHeaderText()
 
   264 {
 
   382 {
 
   265     _LIT( KResourceText, "emergency" );
 
   383     _LIT( KResourceText, "emergency" );
 
   266     HBufC* text = KResourceText().AllocLC();
 
   384     HBufC* text = KResourceText().AllocL();
 
   267     EXPECT(StringLoader,LoadL).returns<HBufC*>(0);
 
   385     EXPECT(StringLoader,LoadL).returns<HBufC*>(0);
 
   268     QVERIFY(m_util->EmergencyHeaderText()==KNullDesC);
 
   386     QVERIFY(m_util->EmergencyHeaderText()==KNullDesC);
 
   269     verify();
 
   387     verify();
 
   270     EXPECT(StringLoader,LoadL).returns(text);   
   388     EXPECT(StringLoader,LoadL).returns(text);   
   271     QVERIFY(m_util->EmergencyHeaderText()==text->Des());
 
   389     QVERIFY(m_util->EmergencyHeaderText()==text->Des());
 
   273 }
 
   391 }
 
   274 
   392 
   275 void TestPhoneCallHeaderUtil::testAttemptingEmergencyText()
 
   393 void TestPhoneCallHeaderUtil::testAttemptingEmergencyText()
 
   276 {
 
   394 {
 
   277     _LIT( KResourceText, "attempting" );
 
   395     _LIT( KResourceText, "attempting" );
 
   278     HBufC* text = KResourceText().AllocLC();
 
   396     HBufC* text = KResourceText().AllocL();
 
   279     EXPECT(StringLoader,LoadL).returns<HBufC*>(0);
 
   397     EXPECT(StringLoader,LoadL).returns<HBufC*>(0);
 
   280     QVERIFY(m_util->AttemptingEmergencyText()==KNullDesC);
 
   398     QVERIFY(m_util->AttemptingEmergencyText()==KNullDesC);
 
   281     verify();
 
   399     verify();
 
   282     EXPECT(StringLoader,LoadL).returns(text);   
   400     EXPECT(StringLoader,LoadL).returns(text);   
   283     QVERIFY(m_util->AttemptingEmergencyText()==text->Des());
 
   401     QVERIFY(m_util->AttemptingEmergencyText()==text->Des());
 
   284     verify();
 
   402     verify();
 
   285 }
 
   403 }
 
   286 
   404 
   287 void TestPhoneCallHeaderUtil::testCallState()
 
   405 PHONE_TEST_MAIN(TestPhoneCallHeaderUtil)
 
   288 {
 
       
   289     m_engineInfo->SetCallState(EPEStateDialing,1);
 
       
   290     QVERIFY(m_util->CallState(1)==EPEStateDialing);    
       
   291 }
 
       
   292 
       
   293 void TestPhoneCallHeaderUtil::testLoadResource()
 
       
   294 {
 
       
   295     TBuf<100> buf;
 
       
   296     
       
   297     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(1).returns(1);
 
       
   298     EXPECT(StringLoader,Load).willOnce(invoke(simulateStringLoad));
 
       
   299     m_util->LoadResource(buf,1);
 
       
   300     QVERIFY(verify());
 
       
   301     QVERIFY(buf==KSimulatedStringLoaderString());
 
       
   302     
       
   303     _LIT( KResourceText, "resource" );
 
       
   304     HBufC* text = KResourceText().AllocLC();
 
       
   305     EXPECT(CPhoneMainResourceResolver,ResolveResourceID).with(1).returns(1);
 
       
   306     EXPECT(StringLoader,LoadL).returns(text);   
       
   307     HBufC* ret = m_util->LoadResource(1);
 
       
   308     QVERIFY(ret==text);
 
       
   309     delete text;
 
       
   310 }
 
       
   311 
       
   312 QTEST_MAIN_S60(TestPhoneCallHeaderUtil)
 
       
   313 #include "unit_tests.moc"
 
   406 #include "unit_tests.moc"
FCL/sf/app/phone