--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videofeeds/server/tsrc/VCXServiceManagementApiTest/src/IptvServiceManagementApiTestBlocks.cpp Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,2582 @@
+/*
+* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: ?Description*
+*/
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+#include <StifParser.h>
+#include <Stiftestinterface.h>
+#include "IptvServiceManagementApiTest.h"
+#include "CIptvServiceManagementSync.h"
+#include "CIptvTestUtilities.h"
+#include "CIptvTestMobilecrashWatcher.h"
+#include "VCXTestLog.h"
+#include <f32file.h>
+#include <S32FILE.H>
+#include "IptvTestUtilALR.h"
+
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+#include "../../../server/IptvScheduledDownload/inc/iptvvodscheduleddownloaddefinitions.h"
+
+#include "CIptvTestServiceStore.h"
+
+//#include <commdb.h>
+
+// EXTERNAL DATA STRUCTURES
+
+// EXTERNAL FUNCTION PROTOTYPES
+
+// CONSTANTS
+
+// MACROS
+
+// LOCAL CONSTANTS AND MACROS
+
+// MODULE DATA STRUCTURES
+
+// LOCAL FUNCTION PROTOTYPES
+
+// FORWARD DECLARATIONS
+
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::Delete
+// Delete here all resources allocated and opened from test methods.
+// Called from destructor.
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementApiTest::Delete()
+ {
+ DeAllocateResources();
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+ ENTRY( "Create", CIptvServiceManagementApiTest::CreateL ),
+ ENTRY( "AddHardCodedService", CIptvServiceManagementApiTest::AddHardCodedServiceL ),
+ ENTRY( "UpdateService", CIptvServiceManagementApiTest::UpdateServiceL ),
+ ENTRY( "UpdateServiceField", CIptvServiceManagementApiTest::UpdateServiceFieldL ),
+ ENTRY( "DeleteService", CIptvServiceManagementApiTest::DeleteServiceL ),
+ ENTRY( "DeleteAllServices", CIptvServiceManagementApiTest::DeleteAllServicesL ),
+ ENTRY( "GetServices", CIptvServiceManagementApiTest::GetServicesL ),
+ ENTRY( "GetServicesByProviderId", CIptvServiceManagementApiTest::GetServicesByProviderIdL ),
+ ENTRY( "GetAllSelectedServices", CIptvServiceManagementApiTest::GetAllSelectedServicesL ), // GetFilteredServices should be used
+ ENTRY( "GetServicesFiltered", CIptvServiceManagementApiTest::GetServicesFilteredL ),
+ ENTRY( "GetServicesByType", CIptvServiceManagementApiTest::GetServicesByTypeL ),
+ ENTRY( "ShutdownServer", CIptvServiceManagementApiTest::ShutdownServerL ),
+ ENTRY( "SetUsedIap", CIptvServiceManagementApiTest::SetUsedIap ),
+ ENTRY( "GetUsedIap", CIptvServiceManagementApiTest::GetUsedIap ),
+ ENTRY( "ClearUsedIap", CIptvServiceManagementApiTest::ClearUsedIapL ),
+ ENTRY( "SetAllIaps", CIptvServiceManagementApiTest::SetAllIapsL ),
+ ENTRY( "SetConnectionAllowed", CIptvServiceManagementApiTest::SetConnectionAllowedL ),
+ ENTRY( "IsConnectionAllowed", CIptvServiceManagementApiTest::IsConnectionAllowedL ),
+ ENTRY( "VerifyServerIsShutdown", CIptvServiceManagementApiTest::VerifyServerIsShutdownL ),
+ ENTRY( "SetSpecialAction", CIptvServiceManagementApiTest::SetSpecialAction),
+ ENTRY( "RepeatNextRequest", CIptvServiceManagementApiTest::RepeatNextRequest),
+
+ ENTRY( "DeleteServicesDb", CIptvServiceManagementApiTest::Dummy),
+ ENTRY( "Cleanup", CIptvServiceManagementApiTest::Dummy),
+ ENTRY( "Initialize", CIptvServiceManagementApiTest::Dummy),
+
+ ENTRY( "Destroy", CIptvServiceManagementApiTest::DestroyL ),
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+/*****************************************************/
+/*************** Test methods *****************/
+/*****************************************************/
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::CreateL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::CreateL( CStifItemParser& /* aItem */ )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::CreateL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KCreate, "In Create" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KCreate );
+ // Print to log file
+ iLog->Log( KCreate );
+
+ TInt err = KErrNone;
+
+ TRAP(err, iIptvTestMobilecrashWatcher = CIptvTestMobilecrashWatcher::NewL() );
+ if(KErrNone != err)//Leave
+ {
+ if(iIptvTestMobilecrashWatcher)
+ {
+ delete iIptvTestMobilecrashWatcher;
+ iIptvTestMobilecrashWatcher = NULL;
+ }
+ VCXLOGLO1("Leave in creating iIptvTestMobilecrashWatcher instance");
+ return err;
+ }
+
+ TRAP(err, iIptvServiceManagementSync = CIptvServiceManagementSync::NewL() );
+ if(err != KErrNone)
+ {
+ VCXLOGLO1("CIptvServiceManagementApiTest:: ** FAIL ** Creating CIptvServiceManagementSync failed!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::CreateL");
+ return err;
+ }
+
+ CDesC8ArraySeg* servicesArrayDesc = NULL;
+
+ // This will execute the possible provisioning of services.xml
+ TRespStatus respStatus = iIptvServiceManagementSync->CallGetServices(CIptvServiceManagementSync::EIptvSmTestSync, 0, 10, &servicesArrayDesc);
+ if(respStatus == ESucceeded)
+ {
+ servicesArrayDesc->Reset();
+ delete servicesArrayDesc;
+ servicesArrayDesc = NULL;
+ }
+
+ // Wait for the provisioning events
+ iIptvServiceManagementSync->WaitForProvisioningEvents();
+
+ TRAP(err, iIptvTestUtilities = CIptvTestUtilities::NewL() );
+ if(err != KErrNone)
+ {
+ VCXLOGLO1("CIptvServiceManagementApiTest:: ** FAIL ** Creating CIptvTestUtilities failed!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::CreateL");
+ return err;
+ }
+
+ iServiceStore = CIptvTestServiceStore::NewL(NULL, iIptvTestUtilities);
+
+ // Construct list of iaps
+
+ iIapNumList = new (ELeave) CArrayFixFlat<TUint32>(30);
+
+ TBuf<1024> iapName;
+
+ for(TInt id=0;id<20;id++)
+ {
+ // If there's iap with the id then add it
+ iapName.Zero();
+ if(iIptvTestUtilities->GetIapNameById(iapName, id) )
+ {
+ iIapNumList->AppendL(id);
+ }
+ }
+
+ iAlrUtil = CIptvTestUtilALR::NewL();
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::CreateL");
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::DestroyL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::DestroyL( CStifItemParser& /*aItem*/ )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::DestroyL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KDestroy, "In Destroy" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KDestroy );
+ // Print to log file
+ iLog->Log( KDestroy );
+
+ DeAllocateResources();
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::DestroyL");
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::Dummy
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::Dummy( CStifItemParser& /*aItem*/ )
+ {
+ return KErrNone;
+ }
+
+ // -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::AddHardCodedServiceL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::AddHardCodedServiceL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::AddHardCodedServiceL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KAddHardCodedService, "In AddHardCodedService" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KAddHardCodedService );
+ // Print to log file
+ iLog->Log( KAddHardCodedService );
+
+ TInt msgTypeInt = 0;
+ TPtrC serviceToAdd;
+ TInt loopCnt = 1; // Default loop once
+ TInt iapsToAdd = 0;
+ TInt expectedServiceId = -1;
+ TBool iapNameSpecified = EFalse;
+ TPtrC iapName;
+ TRespStatus respStatus = ESucceeded;
+ TRespStatus expectedRespStatus = ESucceeded;
+ TInt rv = KErrNone;
+
+ CIptvService* iptvService = NULL;
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ aItem.GetNextInt(msgTypeInt);
+ aItem.GetNextString(serviceToAdd);
+ if(KErrNone != aItem.GetNextString(iapName) )
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter! Iap name or count was not specified.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::AddHardCodedServiceL");
+ return KErrArgument;
+ }
+
+ TLex lex(iapName);
+ if( KErrNone != lex.Val(iapsToAdd) )
+ {
+ iapNameSpecified = ETrue;
+ }
+
+ aItem.GetNextInt(loopCnt);
+
+ VCXLOGLO2("MsgType: %d", msgTypeInt);
+ VCXLOGLO2("ServiceNumberToAdd: %S", &serviceToAdd);
+ VCXLOGLO2("IapsToAdd: %d", iapsToAdd);
+ VCXLOGLO2("IapName: %d", &iapName);
+ VCXLOGLO2("LoopCount: %d", loopCnt);
+ VCXLOGLO2("ExpectedServiceId: %d", expectedServiceId);
+
+ if(loopCnt < 0 || msgTypeInt < 0 || msgTypeInt > 1)
+ {
+ VCXLOGLO1("** FAIL **Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::AddHardCodedServiceL");
+ return KErrArgument;
+ }
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ // No full verifying when request is repeated
+
+ TUint repeatRequest = iIptvServiceManagementSync->GetRepeatNextRequestCount();
+
+ for(TInt i = 0; i < loopCnt; i++)
+ {
+ VCXLOGLO2("loop %d",i);
+
+ // Create service
+
+ if(iapNameSpecified)
+ iptvService = GetHardcodedService(serviceToAdd, iapName);
+ else
+ iptvService = GetHardcodedService(serviceToAdd, iapsToAdd);
+
+ if(iptvService == NULL)
+ {
+ VCXLOGLO1("** FAIL ** Invalid params? GetHardcodedService failed");
+ rv = KErrArgument;
+ break;
+ }
+
+ CleanupStack::PushL(iptvService);
+
+ // Check provider ID
+
+ TBuf<512> newProviderId(iptvService->GetProviderId());
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ RPointerArray<CIptvService> services;
+ iServiceStore->GetServicesByProviderId(services, newProviderId);
+
+ // If there's already service(s) with the provider ID, create an unique ID
+ if(services.Count() > 0)
+ {
+ TUint32 lastServiceId (0);
+
+ if(iServiceStore->ServiceCount() >= 1)
+ {
+ lastServiceId = iServiceStore->GetService( iServiceStore->ServiceCount()-1 )->GetId();
+ newProviderId.AppendNum(lastServiceId);
+ }
+
+ iptvService->SetProviderId(newProviderId);
+ }
+
+ services.Reset();
+
+ // Do the request
+
+ respStatus = iIptvServiceManagementSync->CallAddService(msgType, *iptvService);
+
+ if(respStatus != expectedRespStatus)
+ {
+ rv = respStatus;
+ break;
+ }
+
+ // Verify
+ CIptvTestServiceStore* oldServices = CIptvTestServiceStore::NewL( iServiceStore );
+ CleanupStack::PushL(oldServices);
+
+ oldServices->AddServiceL( *iptvService );
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+ iServiceStore->PrintServices();
+
+ rv = iServiceStore->Compare( *oldServices );
+ if(rv != KErrNone)
+ {
+ break;
+ }
+
+ CleanupStack::PopAndDestroy(oldServices);
+ CleanupStack::PopAndDestroy(iptvService);
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::AddHardCodedServiceL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::UpdateServiceL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::UpdateServiceL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::UpdateServiceL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KUpdateService, "In UpdateService" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KUpdateService );
+ // Print to log file
+ iLog->Log( KUpdateService );
+
+ TInt msgTypeInt(0);
+ TInt destinationId(0);
+ TInt sourceId(0);
+ TBuf<256> destinationName;
+ TBuf<256> sourceName;
+ TInt rv = KErrNone;
+ TPtrC service1, service2;
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ aItem.GetNextInt(msgTypeInt);
+
+ rv = GetServiceIdFromParam(aItem, destinationId, destinationName);
+ if(rv != KErrNone)
+ {
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");
+ return rv;
+ }
+ rv = GetServiceIdFromParam(aItem, sourceId, sourceName);
+ if(rv != KErrNone)
+ {
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");
+ return rv;
+ }
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ if(sourceId == KLastServiceInDb)
+ {
+ sourceId = iServiceStore->GetService( iServiceStore->ServiceCount()-1 )->GetId();
+ sourceName = iServiceStore->GetService( iServiceStore->ServiceCount()-1 )->GetName();
+ }
+
+ VCXLOGLO2("destinationId = %d", destinationId );
+ VCXLOGLO2("destinationName = %S", &destinationName );
+ VCXLOGLO2("sourceId = %d", sourceId );
+ VCXLOGLO2("sourceName = %S", &sourceName );
+
+ if(destinationId < 0 || sourceId < 0 || msgTypeInt < 0 || msgTypeInt > 1)
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");
+ return KErrArgument;
+ }
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ // Do the request
+
+ rv = TestUpdateService(msgType, destinationId, sourceId);
+ if(rv == KErrNone)
+ {
+
+ // Verify
+
+ CIptvTestServiceStore* oldServices = CIptvTestServiceStore::NewL( iServiceStore );
+ CleanupStack::PushL(oldServices);
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ VCXLOGLO1("Services before: ");
+ oldServices->PrintServices();
+ VCXLOGLO1("Services after: ");
+ iServiceStore->PrintServices();
+
+ CIptvService* sourceService;
+ CIptvService* destService;
+
+ sourceService = oldServices->GetServiceById( sourceId );
+ destService = oldServices->GetServiceById( destinationId );
+
+ if( sourceService && destService )
+ {
+ oldServices->ReplaceServiceL( destService->GetId(), *sourceService );
+
+ rv = iServiceStore->Compare( *oldServices );
+ }
+
+ CleanupStack::PopAndDestroy(oldServices);
+
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::UpdateServiceFieldL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::UpdateServiceFieldL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KUpdateServiceField, "In UpdateServiceFieldL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KUpdateServiceField );
+ // Print to log file
+ iLog->Log( KUpdateServiceField );
+
+ TInt msgTypeInt(0);
+ TInt fieldIdInt(0);
+ TInt serviceId(-1);
+ TBuf<256> serviceName;
+ TInt rv = KErrNone;
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ aItem.GetNextInt(msgTypeInt);
+
+ rv = GetServiceIdFromParam(aItem, serviceId, serviceName);
+ if(rv != KErrNone)
+ {
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return rv;
+ }
+
+ aItem.GetNextInt(fieldIdInt);
+
+ VCXLOGLO3("serviceId, Name = %d, %S", serviceId, &serviceName );
+ VCXLOGLO2("fieldId = %d", fieldIdInt );
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ if(iServiceStore->ServiceCount() <= 0)
+ {
+ VCXLOGLO1("** FAIL ** No services in db, Cannot update!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ TServiceFieldId fieldId = static_cast<TServiceFieldId>(fieldIdInt);
+
+ TPtrC stringValue;
+ TInt intValue(0);
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ TInt err = KErrNone;
+
+ // disables event verifying. run cases without this line
+ iIptvServiceManagementSync->SetSpecialAction(CIptvServiceManagementSync::EIptvSmWaitNoEvents);
+
+/* // Only updating these fields causes an event
+ if(!(fieldId == EAddress || fieldId == EScheduleDlTime || fieldId == EScheduleDlNetwork ||
+ fieldId == EScheduleDlType || fieldId == EScheduleLastDlTime) )
+ {
+// iIptvServiceManagementSync->SetSpecialAction(CIptvServiceManagementSync::EIptvSmWaitNoEvents);
+ }*/
+
+ if( (serviceId < 0 || msgTypeInt < 0 || msgTypeInt > 1)
+ || (intValue < 0 ) )
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+
+ // Find the service
+
+ CIptvService *service = NULL;
+ service = iServiceStore->GetServiceById( serviceId );
+
+ if(service == NULL)
+ {
+ VCXLOGLO1("** FAIL ** Could not find service.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+
+ // Read the new value and update the service field
+
+ VCXLOGLO1("Updating the field.");
+
+ CIptvSmEvent::TEvent expectedEvent;
+ expectedEvent = CIptvSmEvent::EServiceModified;
+
+ switch(fieldId)
+ {
+ case EName:
+ {
+ VCXLOGLO1("service->SetName.");
+ aItem.GetNextString(stringValue);
+ err = service->SetName(stringValue);
+ }
+ break;
+
+ case EAddress:
+ {
+ VCXLOGLO1("service->SetAddress.");
+ aItem.GetNextString(stringValue);
+
+ HBufC* address = HBufC::NewL(2048 + 128); // 2048 is the max, reserve some extra for too long addresses
+
+ CleanupStack::PushL(address);
+
+ *address = stringValue;
+
+ if(stringValue == _L("Address_2kLongUrl"))
+ {
+ *address = K2kLongUrl;
+ }
+ else
+ if(stringValue == _L("Address_256CharsLongFileName"))
+ {
+ *address = K256LongFile;
+ }
+
+ // if addresses are same there will not be ServiceModified event
+ if(service->GetAddress() == stringValue)
+ {
+ iIptvServiceManagementSync->SetSpecialAction(CIptvServiceManagementSync::EIptvSmWaitNoEvents);
+ }
+
+ TInt len = address->Length();
+ VCXLOGLO2("Address length: %d", len);
+ err = service->SetAddress(*address);
+
+ CleanupStack::PopAndDestroy(address);
+ }
+ break;
+
+ case EIconPath:
+ {
+ VCXLOGLO1("service->SetIconPath.");
+ aItem.GetNextString(stringValue);
+ err = service->SetIconPath(stringValue);
+ }
+ break;
+
+ case EEpgPluginUid: // TUid
+ {
+ VCXLOGLO1("service->SetEpgPluginUid.");
+ aItem.GetNextInt(intValue);
+ TUid uid;
+ uid.iUid = intValue;
+ service->SetEpgPluginUid(uid);
+ }
+ break;
+
+ case EVodPluginUid: // TUid
+ {
+ VCXLOGLO1("service->SetVodPluginUid.");
+ aItem.GetNextInt(intValue);
+ TUid uid;
+ uid.iUid = intValue;
+ service->SetVodPluginUid(uid);
+ }
+ break;
+
+ case EIptvPluginUid: // TUid
+ {
+ VCXLOGLO1("service->SetIptvPluginUid.");
+ aItem.GetNextInt(intValue);
+ TUid uid;
+ uid.iUid = intValue;
+ service->SetIptvPluginUid(uid);
+ }
+ break;
+
+ case EServiceType: // TServiceType
+ {
+ aItem.GetNextInt(intValue);
+ VCXLOGLO2("service->SetType (%d).", intValue);
+ service->SetType( static_cast<CIptvService::TServiceType>(intValue) );
+ }
+ break;
+
+ case ESetIapList: // TInt count of iaps
+ {
+ VCXLOGLO1("service->SetIapListL.");
+ TInt index;
+ TIptvIap iap;
+
+ TPtrC iapName;
+
+ intValue = 1; // otherwise parameter check later will fail
+
+ CIptvIapList *iapList;
+ iapList = CIptvIapList::NewL();
+ CleanupStack::PushL(iapList);
+
+ if(KErrNone != aItem.GetNextString(iapName) )
+ {
+ // empty iap list
+
+ TRAPD(err2, err = service->SetIapListL(*iapList) );
+
+ CleanupStack::PopAndDestroy(iapList);
+
+ if(err2 != KErrNone)
+ {
+ VCXLOGLO1("** FAIL ** SetIapListL (empty) caused a leave.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return err2;
+ }
+ break;
+ }
+
+ // parameter can be iap count or list of iap names and priorities
+
+ TBool iapNameSpecified = EFalse;
+
+ TLex lex(iapName);
+ if( KErrNone != lex.Val(intValue) )
+ {
+ iapNameSpecified = ETrue;
+ }
+
+ // Iap count was specified
+ if(!iapNameSpecified)
+ {
+
+ if(intValue >= 0)
+ {
+ if(intValue > iIapNumList->Count())
+ {
+ intValue = iIapNumList->Count();
+ VCXLOGLO2("Not enough iaps, adding only: %d.", intValue);
+
+ }
+
+ for(index = 0; index < intValue; index++)
+ {
+ GetCommDbIapIdByOrder(index, iap.iId);
+ iap.iPriority = index;
+ iapList->AddIap(iap, ETrue);
+ }
+ }
+ // add invalid iaps
+ else
+ {
+ VCXLOGLO1("Adding invalid iaps.");
+
+ intValue *= -1;
+
+ if(intValue > iIapNumList->Count())
+ {
+ intValue = iIapNumList->Count();
+ }
+
+ for(index = 0; index < intValue; index++)
+ {
+ iap.iId = 100 + index;
+ iap.iPriority = index;
+ iapList->AddIap(iap, ETrue);
+ }
+ }
+ }
+
+ // Get the iap names and priorities
+ else
+ {
+ while(1)
+ {
+ TInt prio;
+ if(KErrNone == aItem.GetNextInt(prio) )
+ {
+ TUint32 iapId;
+ TBufC<256> name(iapName);
+
+ if(iIptvTestUtilities->GetIapIdL(name, iapId))
+ {
+ iap.iId = iapId;
+ iap.iPriority = prio;
+ iapList->AddIap(iap, ETrue);
+ }
+ else
+ {
+ VCXLOGLO2("** FAIL ** Test case error. No iap with name: %S.", &iapName);
+ CleanupStack::PopAndDestroy(iapList);
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+
+ }
+ else
+ {
+ VCXLOGLO2("** FAIL ** Test case error. No priority specified for iap: %S", &iapName);
+ CleanupStack::PopAndDestroy(iapList);
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+
+ if(KErrNone != aItem.GetNextString(iapName) )
+ {
+ VCXLOGLO1("All iaps added.");
+ break;
+ }
+ }
+ }
+
+ // set service iaplist
+ TRAPD(err2, err = service->SetIapListL(*iapList) );
+
+ CleanupStack::PopAndDestroy(iapList);
+
+ if(err2 != KErrNone)
+ {
+ VCXLOGLO1("** FAIL ** SetIapListL caused a leave.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return err2;
+ }
+
+ }
+ break;
+
+ case EUserName:
+ {
+ VCXLOGLO1("service->SetUserName.");
+ aItem.GetNextString(stringValue);
+ err = service->SetUserName(stringValue);
+ }
+ break;
+
+ case EPassword:
+ {
+ VCXLOGLO1("service->SetPassword.");
+ aItem.GetNextString(stringValue);
+ err = service->SetPassword(stringValue);
+ }
+ break;
+
+ case EDesc:
+ {
+ VCXLOGLO1("service->SetDesc.");
+ aItem.GetNextString(stringValue);
+ err = service->SetDesc(stringValue);
+ }
+ break;
+
+ case EFlags:
+ {
+ VCXLOGLO1("service->SetFlags with next flags.");
+ TUint flags = 0;
+
+ while( KErrNone == aItem.GetNextInt(intValue) )
+ {
+ flags |= intValue;
+
+ if(intValue & CIptvService::ESelected)
+ {
+ VCXLOGLO1("ESelected");
+ }
+ if(intValue & CIptvService::EReadOnly)
+ {
+ VCXLOGLO1("EReadOnly");
+ }
+ if(intValue & CIptvService::EMainService)
+ {
+ VCXLOGLO1("EMainService");
+ }
+ if(intValue & CIptvService::EConnectionApproved)
+ {
+ VCXLOGLO1("EConnectionApproved");
+ }
+ if(intValue & CIptvService::EReadOnlyIaps)
+ {
+ VCXLOGLO1("EReadOnlyIaps");
+ }
+ if(intValue & CIptvService::EGroupedService)
+ {
+ VCXLOGLO1("EGroupedService");
+ }
+ if(intValue & CIptvService::EGroupReceived)
+ {
+ VCXLOGLO1("EGroupReceived");
+ }
+ }
+
+ VCXLOGLO2("old selection: %d", service->GetFlags() & CIptvSmEvent::EServiceSelectionModified);
+ VCXLOGLO2("new selection: %d", flags & CIptvSmEvent::EServiceSelectionModified);
+
+
+ if( (service->GetFlags() & CIptvSmEvent::EServiceSelectionModified)
+ != (flags & CIptvSmEvent::EServiceSelectionModified) )
+ {
+ // Service selection was modified. Expect event.
+ expectedEvent = CIptvSmEvent::EServiceSelectionModified;
+ }
+ else
+ {
+ // Service selection was not modified
+ iIptvServiceManagementSync->SetSpecialAction(CIptvServiceManagementSync::EIptvSmWaitNoEvents);
+ }
+
+ service->SetFlags(flags);
+ if(service->GetFlags() != flags)
+ {
+ VCXLOGLO1("CIptvService::GetFlags returned wrong flags right after SetFlags.");
+ }
+
+ VCXLOGLO4("Service ID: %d, Name: %S, Flags: 0x%x", service->GetId(), &service->GetName(), flags);
+
+ }
+ break;
+
+ case EApplicationUid: // TInt32
+ {
+ VCXLOGLO1("service->SetApplicationUid.");
+ aItem.GetNextInt(intValue);
+ service->SetApplicationUid(intValue);
+ }
+ break;
+
+ case EDisplayOrder: // TUint32
+ {
+ VCXLOGLO1("service->SetDisplayOrder.");
+ aItem.GetNextInt(intValue);
+ service->SetDisplayOrder(intValue);
+ }
+ break;
+
+ case EProviderId: // TDesC
+ {
+ VCXLOGLO1("service->SetProviderId.");
+ aItem.GetNextString(stringValue);
+ err = service->SetProviderId(stringValue);
+ }
+ break;
+
+ case EAccountManagementUrl:
+ {
+ VCXLOGLO1("service->SetAccountManagementUrl.");
+ aItem.GetNextString(stringValue);
+ err = service->SetAccountManagementUrl(stringValue);
+ }
+ break;
+
+ case EScheduleDlTime:
+ {
+ expectedEvent = CIptvSmEvent::EServiceScheduleModified;
+
+ TUint flags = 0;
+
+ while( KErrNone == aItem.GetNextInt(intValue) )
+ {
+ flags |= intValue;
+
+ if(intValue == 0 )
+ {
+ VCXLOGLO1("ENoSchedule");
+ flags = 0;
+ break;
+ }
+ if(intValue == 1 )
+ {
+ VCXLOGLO1("ENight");
+ }
+ if(intValue == 2 )
+ {
+ VCXLOGLO1("EMorning");
+ }
+ if(intValue == 4 )
+ {
+ VCXLOGLO1("ENoon");
+ }
+ if(intValue == 8 )
+ {
+ VCXLOGLO1("EAfternoon");
+ }
+ if(intValue == 16 )
+ {
+ VCXLOGLO1("EEvening");
+ }
+ }
+
+ VCXLOGLO1("service->SetScheduleDlTime.");
+ service->SetScheduleDlTime(flags);
+ }
+ break;
+
+ case EScheduleDlNetwork:
+ {
+ expectedEvent = CIptvSmEvent::EServiceScheduleModified;
+
+ TInt network;
+ if(KErrNone != aItem.GetNextInt(network) )
+ {
+ VCXLOGLO1("** FAIL ** Specify parameter: network type be used for scheduled download");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+
+ VCXLOGLO1("service->SetScheduleDlNetwork.");
+ service->SetScheduleDlNetwork(network);
+
+ }
+ break;
+
+ case EScheduleLastDlTime:
+ {
+ expectedEvent = CIptvSmEvent::EServiceScheduleModified;
+
+ VCXLOGLO1("service->SetScheduledLastDownloadTime.");
+ TTime time;
+ time.UniversalTime();
+ service->SetScheduledLastDownloadTime(time);
+
+ TTime gotTime;
+ gotTime = service->GetScheduledLastDownloadTime();
+
+ _LIT(KDateTimeString,"%D%M%Y%/0%1%/1%2%/2%3%/3 %-B%:0%H%:1%T%:2%S%.%*C2%:3%-B");
+ TBuf<256> str;
+
+ if(gotTime != time)
+ {
+ VCXLOGLO1("GetScheduledLastDownloadTime does not match to what was set!");
+
+ TRAPD(err, gotTime.FormatL(str, KDateTimeString));
+ if(err != KErrNone)
+ {
+ VCXLOGLO2("TTime::FormatL failed for gotTime: %d", err);
+ }
+ VCXLOGLO2("gotTime: %S", &str);
+
+ TRAP(err, time.FormatL(str, KDateTimeString));
+ if(err != KErrNone)
+ {
+ VCXLOGLO2("TTime::FormatL failed for time: %d", err);
+ }
+ VCXLOGLO2("time: %S", &str);
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrCorrupt;
+ }
+
+ }
+ break;
+
+ case EScheduleDlType:
+ {
+ expectedEvent = CIptvSmEvent::EServiceScheduleModified;
+
+ TInt dlType;
+ TInt dlCount = 0;
+ if(KErrNone != aItem.GetNextInt(dlType))
+ {
+ VCXLOGLO1("** FAIL ** Specify parameter: dl type to be used for scheduled download");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+
+ TInt type = 0;
+
+ if(dlType != EIptvTestNoDownload)
+ {
+ if(KErrNone != aItem.GetNextInt(dlCount))
+ {
+ VCXLOGLO1("** FAIL ** Specify parameter: dl count to be used for scheduled download");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+ }
+
+ type |= dlCount;
+
+ switch(dlType)
+ {
+ case EIptvTestNoDownload:
+ {
+ type = 0;
+ }
+ break;
+
+ case EIptvTestDownloadLatest:
+ {
+ type |= EDownloadLatest;
+ }
+ break;
+
+ case EIptvTestDownloadOldest:
+ {
+ type |= EDownloadOldest;
+ }
+ break;
+
+ case EIptvTestDownloadAddedAfterLastScheduledDownload:
+ {
+ type |= EDownloadAddedAfterLastScheduledDownload;
+ }
+ break;
+
+ case EIptvTestDownloadAll:
+ {
+ type |= EDownloadAll;
+ }
+ break;
+
+ default:
+ {
+ VCXLOGLO1("** FAIL ** Uknown dl type for scheduled download");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+ }
+
+ VCXLOGLO1("service->SetScheduleDlType.");
+ service->SetScheduleDlType(type);
+
+ }
+ break;
+
+ case ESearchUrl:
+ {
+ VCXLOGLO1("service->SetSearchUrl.");
+ aItem.GetNextString(stringValue);
+
+ HBufC* address = HBufC::NewL(2048 + 128); // 2048 is the max, reserve some extra for too long addresses
+
+ CleanupStack::PushL(address);
+
+ *address = stringValue;
+
+ if(stringValue == _L("Address_256charsLongSearchUrl"))
+ {
+ *address = K256charsLongSearchUrl;
+ }
+
+ service->SetSearchUrlL( address->Des() );
+
+ CleanupStack::PopAndDestroy(address);
+ }
+ break;
+
+ default:
+ {
+ VCXLOGLO2("** FAIL ** Invalid field id parameter! %d", fieldId);
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return KErrArgument;
+ }
+ }
+
+ VCXLOGLO2("intValue = %d", intValue);
+ VCXLOGLO2("stringValue = %S", &stringValue);
+
+ if(err != KErrNone)
+ {
+ VCXLOGLO1("** FAIL ** Service set method returned error.");
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return err;
+ }
+
+ // Do the request
+ TRespStatus respStatus = iIptvServiceManagementSync->CallUpdateService(msgType, *service, expectedEvent);
+
+ if(respStatus != ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** Updating service failed: status = %d", respStatus);
+ rv = respStatus;
+ }
+ else
+ {
+ // Verify
+ CIptvTestServiceStore* oldServices = CIptvTestServiceStore::NewL( iServiceStore );
+ CleanupStack::PushL(oldServices);
+
+ oldServices->ReplaceServiceL( service->GetId(), *service );
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+ rv = iServiceStore->Compare( *oldServices );
+
+ CleanupStack::PopAndDestroy(oldServices);
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::UpdateServiceFieldL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::DeleteServiceL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::DeleteServiceL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::DeleteServiceL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KDeleteService, "In DeleteService" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KDeleteService );
+ // Print to log file
+ iLog->Log( KDeleteService );
+
+ TRespStatus expectedRespStatus = ESucceeded;
+ TRespStatus respStatus = ESucceeded;
+ TInt msgTypeInt(0);
+ TInt serviceId(-1);
+ TBuf<256> serviceName;
+ TInt rv = KErrNone;
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ aItem.GetNextInt(msgTypeInt);
+
+ rv = GetServiceIdFromParam(aItem, serviceId, serviceName);
+ if(rv != KErrNone)
+ {
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::DeleteServiceL");
+ return rv;
+ }
+
+ VCXLOGLO3("ServiceId = %d, name: %S",serviceId, &serviceName );
+
+ if(serviceId < 0 || msgTypeInt < 0 || msgTypeInt > 1)
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::DeleteServiceL");
+ return KErrArgument;
+ }
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ // Do the request
+
+ TUint repeatRequest = iIptvServiceManagementSync->GetRepeatNextRequestCount();
+ if(repeatRequest == 0) repeatRequest = 1; // Still need to do this once
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ CIptvTestServiceStore* oldServices = CIptvTestServiceStore::NewL( iServiceStore );
+ CleanupStack::PushL(oldServices);
+
+ respStatus = iIptvServiceManagementSync->CallDeleteService(msgType, serviceId);
+
+ if(respStatus != expectedRespStatus)
+ {
+ VCXLOGLO3("** FAIL ** Service return value was not expected: expected %d, returned %d", expectedRespStatus, respStatus);
+ rv = respStatus;
+ }
+ else
+ {
+ // Verify
+ if( repeatRequest <= 1 )
+ {
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ CIptvService* service(NULL);
+ service = oldServices->GetServiceById( serviceId );
+ if(service)
+ {
+ oldServices->DeleteService( service->GetId() );
+
+ rv = iServiceStore->Compare( *oldServices );
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(oldServices);
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::DeleteServiceL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::DeleteAllServicesL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::DeleteAllServicesL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::DeleteAllServicesL");
+
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KWhere, "In DeleteAllServicesL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KWhere );
+ // Print to log file
+ iLog->Log( KWhere );
+
+ TInt rv = KErrNone;
+ TRespStatus respStatus = ESucceeded;
+ TInt msgTypeInt(0);
+
+ // Read parameters
+
+ aItem.GetNextInt(msgTypeInt);
+
+ if(msgTypeInt < 0 || msgTypeInt > 1)
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::DeleteServiceL");
+ return KErrArgument;
+ }
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ VCXLOGLO2("Services found: %d", iServiceStore->ServiceCount() );
+
+ /* If there is a deletion of group going on .. */
+ RPointerArray<CIptvService> services;
+
+ /*for(i = 0; i < iServiceStore->ServiceCount(); i++)*/
+ while( iServiceStore->ServiceCount() > 0)
+ {
+ iServiceStore->GetServices( services );
+
+ CIptvService* iptvService = NULL;
+ iptvService = services[0];
+
+ VCXLOGLO2("Deleting service: %d", iptvService->GetId());
+
+ if( iptvService->GetType() == CIptvService::EServiceGroup )
+ {
+ respStatus = iIptvServiceManagementSync->CallDeleteService( msgType, iptvService->GetId() );
+
+ /* Grouped services are also deleted, first get the grouped because they still exist */
+ iServiceStore->GetGroupedServicesByGroupId( services, iptvService->GetGroupId() );
+ iServiceStore->DeleteService( iptvService->GetId() );
+
+ /* Increase expected event count by the count of grouped services*/
+ if( services.Count() > 0 )
+ {
+ iIptvServiceManagementSync->IncreaseExpectedEventCount( services.Count() );
+ services.Reset();
+ }
+ }
+ else
+ {
+ /* Delete a single service, also from servicestore */
+ respStatus = iIptvServiceManagementSync->CallDeleteService(msgType, iptvService->GetId());
+ iServiceStore->DeleteService( iptvService->GetId() );
+ }
+
+ if(respStatus != ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** DeleteServiceRequest failed, response = %d",respStatus);
+ rv = respStatus;
+ break;
+ }
+
+ services.Reset();
+ }
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ if(iServiceStore->ServiceCount() != 0)
+ {
+ VCXLOGLO1("* FAIL * Service DB has services.");
+ rv = KErrCorrupt;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::DeleteAllServicesL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetServicesByProviderIdL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetServicesByProviderIdL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::GetServicesByProviderIdL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KGetServicesByProviderId, "In GetServicesByProviderIdL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KGetServicesByProviderId );
+ // Print to log file
+ iLog->Log( KGetServicesByProviderId );
+
+ TRespStatus respStatus = ESucceeded;
+ TInt rv = KErrNone;
+ CIptvServices* services = NULL;
+ TPtrC providerId;
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ if(aItem.GetNextString(providerId) == KErrNone)
+ {
+ VCXLOGLO2("Parameter provider id: %S", &providerId);
+ }
+ else
+ {
+ VCXLOGLO1("** FAIL ** Reading parameter provider id failed");
+ VCXLOGLO1("<<<IptvServiceManagementApiTest::GetServicesByProviderIdL");
+ return KErrArgument;
+ }
+
+ services = CIptvServices::NewL();
+ CleanupStack::PushL(services);
+
+ TRAP(rv, respStatus = iIptvServiceManagementSync->CallGetServicesByProviderId(providerId, *services));
+
+ if(rv != KErrNone)
+ {
+ VCXLOGLO2("** FAIL ** CallGetServicesByProviderId left: %d.", rv);
+ }
+ else
+ if(respStatus != ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** GetServicesByProviderId failed, response = %d",respStatus);
+ rv = respStatus;
+ }
+ else
+ {
+ // Verify
+ CIptvTestServiceStore* gotServices = CIptvTestServiceStore::NewL( services );
+ CleanupStack::PushL( gotServices );
+
+ CIptvTestServiceStore* verifyServices = CIptvTestServiceStore::NewL( );
+ CleanupStack::PushL( verifyServices );
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+ iServiceStore->PrintServices();
+
+ TInt i;
+ for(i=0; i<iServiceStore->ServiceCount(); i++)
+ {
+ CIptvService *service;
+ service = iServiceStore->GetService(i);
+ if(service->GetProviderId() == providerId)
+ {
+ verifyServices->AddServiceL( *service );
+ }
+ }
+
+ rv = verifyServices->Compare( *gotServices );
+
+ CleanupStack::PopAndDestroy(verifyServices);
+ CleanupStack::PopAndDestroy(gotServices);
+ }
+
+ CleanupStack::PopAndDestroy(services);
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetServicesByProviderIdL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::SetUsedIap
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::SetUsedIap( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::SetUsedIap");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KSetUsedIap, "In SetUsedIap" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KSetUsedIap );
+ // Print to log file
+ iLog->Log( KSetUsedIap );
+
+ //TPtrC iapName;
+ TUint32 iapId(0);
+ TInt usedIapNum(0);
+ TInt runOnlyIfIapExists(0);
+ TInt serviceId(-1);
+ TBuf<256> serviceName;
+ MIptvServiceManagementClientObserver::TRespStatus respStatus;
+ TInt rv = KErrNone;
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ rv = GetServiceIdFromParam(aItem, serviceId, serviceName);
+ if(rv != KErrNone)
+ {
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetUsedIap");
+ return rv;
+ }
+
+ TPtrC iapName;
+ if(KErrNone != aItem.GetNextString(iapName) )
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter! Iap name or count was not specified.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetUsedIap");
+ return KErrArgument;
+ }
+
+ TBool iapNameSpecified = EFalse;
+ TLex lex(iapName);
+ if( KErrNone != lex.Val(usedIapNum) )
+ {
+ iapNameSpecified = ETrue;
+ }
+
+ aItem.GetNextInt(runOnlyIfIapExists);
+
+ VCXLOGLO2("iapName = %S", &iapName);
+ VCXLOGLO2("iapNum = %d", usedIapNum);
+ VCXLOGLO3("ServiceId = %d, name: %S",serviceId, &serviceName );
+
+ if(iapNameSpecified)
+ {
+ TBufC<256> name(iapName);
+ if(!iIptvTestUtilities->GetIapIdL(name, iapId))
+ {
+ VCXLOGLO2("** FAIL ** Test case error. Iap with name %S does not exist.", &name);
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetUsedIap");
+ return KErrArgument;
+ }
+ }
+ else
+ {
+ if(usedIapNum >= 0)
+ {
+ // Get iap id and skip the test if needed
+ if(KErrNone != GetCommDbIapIdByOrder(usedIapNum , iapId) && runOnlyIfIapExists )
+ {
+ VCXLOGLO1("Iap does not exist and flag set, skipping.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetUsedIap");
+ return KErrNone;
+ }
+ }
+ // Invalid iap id
+ else
+ {
+ iapId = 1000;
+ }
+ }
+
+ if(serviceId < 0)
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetUsedIap");
+ return KErrArgument;
+ }
+
+ VCXLOGLO2("iapId = %d", iapId);
+
+ // Do the request
+
+ respStatus = iIptvServiceManagementSync->CallSetUsedIap(iapId, serviceId, TRUE );
+
+ // Set also used destination and set the IAP to highest priority.
+ // We presume the IAPs are in Internet destination
+
+ _LIT(KDestinationName, "Internet");
+ TInt err (KErrNone);
+ TBuf<64> destName( KDestinationName );
+ TBuf<64> iapNameTemp( iapName );
+ TRAP(err, iAlrUtil->SetUsedDestinationL( destName ) );
+ if(err != KErrNone)
+ {
+ VCXLOGLO2("** FAIL ** SetUsedDestinationL failed. Error: %d", err );
+ }
+ TRAP(err, iAlrUtil->SetMethodPriorityL( destName, iapNameTemp, 0 ) );
+ if(err != KErrNone)
+ {
+ VCXLOGLO2("** FAIL ** SetMethodPriorityL failed. Error: %d", err );
+ }
+
+ if(respStatus != MIptvServiceManagementClientObserver::ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** CallSetUsedIap returned error. error: %d", respStatus );
+ rv = respStatus;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetUsedIap");
+
+ return rv;
+ }
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetUsedIap
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetUsedIap( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::GetUsedIap");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KGetUsedIap, "In GetUsedIap" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KGetUsedIap );
+ // Print to log file
+ iLog->Log( KGetUsedIap );
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ TUint32 iapId(10000);
+ TUint32 expectedIapId(20000);
+ TInt msgTypeInt(0);
+ TInt expectedIapNumber(0);
+ TInt runOnlyIfIapExists(0);
+ TInt serviceId(-1);
+ TBuf<256> serviceName;
+ TInt rv = KErrNone;
+
+ // Read parameters
+
+ aItem.GetNextInt(msgTypeInt);
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ rv = GetServiceIdFromParam(aItem, serviceId, serviceName);
+ if(rv != KErrNone)
+ {
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetUsedIap");
+ return rv;
+ }
+
+ TPtrC expectedIapName;
+ if(KErrNone != aItem.GetNextString(expectedIapName) )
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter! Iap name or count was not specified.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetUsedIap");
+ return KErrArgument;
+ }
+
+ if(!iIptvTestUtilities->GetIapIdByNameL(expectedIapName, expectedIapId))
+ {
+ VCXLOGLO2("** FAIL ** Test case error. Iap with name %S does not exist.", &expectedIapName);
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetUsedIap");
+ return KErrArgument;
+ }
+
+ aItem.GetNextInt(runOnlyIfIapExists);
+
+ VCXLOGLO3("ServiceId = %d, name: %S",serviceId, &serviceName );
+ VCXLOGLO2("runOnlyIfIapExists: %d", runOnlyIfIapExists);
+ VCXLOGLO2("expectedIapName: %S", &expectedIapName);
+ VCXLOGLO2("expectedIapNumber: %d", expectedIapNumber);
+ VCXLOGLO2("expectedIapId: %d", expectedIapId);
+
+ if(serviceId < 0 || msgTypeInt < 0)
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetUsedIap");
+ return KErrArgument;
+ }
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ MIptvServiceManagementClientObserver::TRespStatus respStatus;
+
+ CIptvService *service = iIptvTestUtilities->GetServiceFromDb(serviceId);
+ if(!service)
+ {
+ VCXLOGLO1("** FAIL ** No such service in DB. Continuing test run.");
+ }
+ else
+ {
+ iIptvTestUtilities->PrintIptvService(service);
+ delete service;
+ service = NULL;
+ }
+
+ // Do the request
+
+ respStatus = iIptvServiceManagementSync->CallGetUsedIap(msgType, serviceId, iapId );
+
+ if(respStatus != MIptvServiceManagementClientObserver::ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** CallGetUsedIap returned error. error: %d", respStatus );
+ rv = respStatus;
+ }
+ else
+ if( iapId != expectedIapId )
+ {
+ VCXLOGLO2("** FAIL ** CallGetUsedIap returned iapId %d", iapId);
+ VCXLOGLO2("Expected iap id: %d", expectedIapId );
+ rv = KErrCorrupt;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetUsedIap");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::ClearUsedIapL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::ClearUsedIapL( CStifItemParser& /*aItem*/ )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::ClearUsedIapL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KClearUsedIap, "In ClearUsedIapL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KClearUsedIap );
+ // Print to log file
+ iLog->Log( KClearUsedIap );
+
+ TInt rv = KErrNone;
+
+ MIptvServiceManagementClientObserver::TRespStatus respStatus;
+
+ respStatus = iIptvServiceManagementSync->CallClearUsedIap();
+
+ if(respStatus == MIptvServiceManagementClientObserver::ESucceeded)
+ {
+
+ // verify somehow
+ }
+ else
+ {
+ VCXLOGLO2("** FAIL ** CallClearUsedIap returned error. error: %d", rv );
+ rv = respStatus;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ClearUsedIapL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::SetAllIapsL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::SetAllIapsL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::SetAllIapsL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KSetAllIapsL, "In SetAllIapsL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KSetAllIapsL );
+ // Print to log file
+ iLog->Log( KSetAllIapsL );
+
+ TRespStatus respStatus = ESucceeded;
+ TInt rv = KErrNone;
+ TInt i = 0;
+ TInt iapCount = 0;
+ TInt ignoreReadOnlyInt = 0;
+ TInt msgTypeInt(0);
+
+ // Read parameters
+
+ aItem.GetNextInt(msgTypeInt);
+ aItem.GetNextInt(iapCount);
+ aItem.GetNextInt(ignoreReadOnlyInt);
+
+ VCXLOGLO2("iapCount: %d", iapCount);
+ VCXLOGLO2("ignoreReadOnlyInt: %d", ignoreReadOnlyInt);
+
+ if(iapCount < 0 || ignoreReadOnlyInt < 0 || ignoreReadOnlyInt > 1 || msgTypeInt < 0 || msgTypeInt > 1)
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetAllIapsL");
+ return KErrArgument;
+ }
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ TBool ignoreReadOnly;
+ ignoreReadOnlyInt == 1 ? ignoreReadOnly = ETrue : ignoreReadOnly = EFalse;
+
+ CIptvIapList* iapList = CIptvIapList::NewL();
+ CleanupStack::PushL(iapList);
+
+ TIptvIap iap;
+
+ for(i=0;i<iapCount;i++)
+ {
+ iap.iId = i+1;
+ iap.iPriority = i+1;
+ iapList->AddIap(iap);
+ }
+
+ respStatus = iIptvServiceManagementSync->CallSetAllIaps(msgType, *iapList, ignoreReadOnly);
+
+ CleanupStack::PopAndDestroy(iapList);
+
+ if(respStatus != ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** CallSetAllIapsL returned error. error: %d", respStatus );
+ rv = respStatus;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetAllIapsL");
+ return rv;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::SetConnectionAllowedL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::SetConnectionAllowedL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::SetConnectionAllowedL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KSetConnectionAllowed, "In SetConnectionAllowedL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KSetConnectionAllowed );
+ // Print to log file
+ iLog->Log( KSetConnectionAllowed );
+
+ TUint32 iapId(0);
+ TPtrC iapName;
+ TInt connectionAllowedInt(0);
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ User::LeaveIfError( aItem.GetNextString(iapName) );
+
+ if( iapName == _L("INVALIDIAPID") )
+ {
+ iapId = 1000;
+ }
+ else
+ if( !iIptvTestUtilities->GetIapIdL(iapName, iapId) )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ aItem.GetNextInt( connectionAllowedInt );
+
+ TBool connectionAllowed = static_cast<TBool>(connectionAllowedInt);
+
+ MIptvServiceManagementClientObserver::TRespStatus respStatus;
+
+ VCXLOGLO2("iapId = %d", iapId);
+ VCXLOGLO2("connectionAllowedInt = %d", connectionAllowedInt);
+
+ TInt rv = KErrNone;
+
+ respStatus = iIptvServiceManagementSync->CallSetConnectionAllowed(connectionAllowed, iapId);
+
+ if(respStatus != MIptvServiceManagementClientObserver::ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** CallSetConnectionAllowedL returned error. error: %d", respStatus );
+ rv = respStatus;
+ }
+ else
+ {
+ // Verify the result
+ CIptvNetworkSelection::TConnectionPermission currentPermission = CIptvNetworkSelection::EMustAskConfirmation;
+
+ CIptvNetworkSelection::TConnectionPermission expectedPermission = CIptvNetworkSelection::EMustAskConfirmation;
+ if( connectionAllowed )
+ {
+ expectedPermission = CIptvNetworkSelection::EAllowed;
+ }
+
+ respStatus = iIptvServiceManagementSync->CallIsConnectionAllowed( currentPermission, iapId );
+
+ if(respStatus != MIptvServiceManagementClientObserver::ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** CallIsConnectionAllowedL failed, response = %d", respStatus);
+ rv = respStatus;
+ }
+ else
+ if( expectedPermission != currentPermission )
+ {
+ VCXLOGLO1("** FAIL ** CallIsConnectionAllowedL returned wrong permission");
+ rv = KErrCorrupt;
+ }
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetConnectionAllowedL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::IsConnectionAllowedL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::IsConnectionAllowedL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::IsConnectionAllowedL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KIsConnectionAllowed, "In IsConnectionAllowedL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KIsConnectionAllowed );
+ // Print to log file
+ iLog->Log( KIsConnectionAllowed );
+
+ TPtrC iapName;
+ TUint32 iapId(0);
+ TInt expectedPermissionInt(0);
+
+ // Read parameters
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ User::LeaveIfError( aItem.GetNextString(iapName) );
+
+ if( iapName == _L("INVALIDIAPID") )
+ {
+ iapId = 1000;
+ }
+ else
+ if( !iIptvTestUtilities->GetIapIdL(iapName, iapId) )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ aItem.GetNextInt(expectedPermissionInt);
+
+ if(expectedPermissionInt < 0)
+ {
+ VCXLOGLO1("** FAIL ** Invalid testcase parameter!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::IsConnectionAllowedL");
+ return KErrArgument;
+ }
+
+ CIptvNetworkSelection::TConnectionPermission expectedPermission = static_cast<CIptvNetworkSelection::TConnectionPermission>(expectedPermissionInt);
+
+ if(expectedPermission == CIptvNetworkSelection::ENotAllowed)
+ {
+ expectedPermission = CIptvNetworkSelection::EMustAskConfirmation;
+ }
+
+ MIptvServiceManagementClientObserver::TRespStatus respStatus;
+
+ VCXLOGLO2("iapId = %d", iapId);
+ VCXLOGLO2("expectedPermissionInt = %d", expectedPermissionInt);
+
+ TInt rv = KErrNone;
+
+ CIptvNetworkSelection::TConnectionPermission permission = CIptvNetworkSelection::ENotAllowed;
+
+ respStatus = iIptvServiceManagementSync->CallIsConnectionAllowed(permission, iapId);
+
+ if(respStatus != MIptvServiceManagementClientObserver::ESucceeded)
+ {
+ VCXLOGLO2("** FAIL ** CallIsConnectionAllowedL failed, response = %d", respStatus);
+ rv = respStatus;
+ }
+ else
+ if(permission != expectedPermission)
+ {
+ VCXLOGLO1("** FAIL ** CallIsConnectionAllowedL returned wrong permission");
+ rv = KErrCorrupt;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::IsConnectionAllowedL");
+ return rv;
+
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetServicesL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetServicesL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::GetServicesL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KGetServices, "In GetServicesL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KGetServices );
+ // Print to log file
+ iLog->Log( KGetServices );
+
+ TRespStatus respStatus = ESucceeded;
+ TInt rv = KErrNone;
+ TInt i = 0;
+ CDesC8ArraySeg* servicesArrayDesc = NULL;
+ TInt msgTypeInt(0);
+ TUint startId(0);
+ TUint endId(0);
+
+ aItem.GetNextInt(msgTypeInt);
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ aItem.GetNextInt(startId);
+ aItem.GetNextInt(endId);
+
+ VCXLOGLO2("startId = %d", startId);
+ VCXLOGLO2("endId = %d", endId);
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ respStatus = iIptvServiceManagementSync->CallGetServices(msgType,
+ startId,
+ endId,
+ &servicesArrayDesc);
+ if(servicesArrayDesc != NULL)
+ {
+
+ VCXLOGLO1("Services:");
+ for(i = 0; i < servicesArrayDesc->MdcaCount(); i++)
+ {
+ CIptvService* iptvService = CIptvService::NewL();
+
+ iptvService->SetL(servicesArrayDesc->MdcaPoint(i));
+ iIptvTestUtilities->PrintIptvService(iptvService);
+
+ delete iptvService;
+ }
+ }
+
+ if(respStatus != ESucceeded && servicesArrayDesc != NULL)
+ {
+ VCXLOGLO2("** FAIL ** CallGetServices returned error. error: %d", respStatus );
+ if(servicesArrayDesc != NULL)
+ {
+ servicesArrayDesc->Reset();
+ delete servicesArrayDesc;
+ servicesArrayDesc = NULL;
+ }
+ else
+ {
+ VCXLOGLO1("** FAIL ** servicesArrayDesc is NULL");
+ }
+
+ rv = respStatus;
+ }
+ else
+ {
+ // verify that right services were returned.
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetServicesL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetAllSelectedServicesL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetAllSelectedServicesL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::GetAllSelectedServicesL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KGetAllSelectedServices, "In GetAllSelectedServicesL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KGetAllSelectedServices );
+ // Print to log file
+ iLog->Log( KGetAllSelectedServices );
+ TRespStatus respStatus = ESucceeded;
+ TInt rv = KErrNone;
+ CDesC8ArraySeg* selectedServicesArray = NULL;
+
+ TInt msgTypeInt;
+ aItem.GetNextInt(msgTypeInt);
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType =
+ static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ // Get selected services
+ respStatus = iIptvServiceManagementSync->CallGetServicesFiltered(
+ CIptvServiceManagementClient::ESelectedServices,
+ CIptvServiceManagementClient::EDisplayOrderAscending,
+ msgType,
+ &selectedServicesArray
+ );
+
+ if(respStatus != MIptvServiceManagementClientObserver::ESucceeded)
+ {
+ if(selectedServicesArray)
+ {
+ selectedServicesArray->Reset();
+ delete selectedServicesArray;
+ selectedServicesArray = NULL;
+ }
+
+ VCXLOGLO2("** FAIL ** CallGetServices returned error. error: %d", respStatus );
+ rv = respStatus;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetAllSelectedServicesL");
+ return rv;
+
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetServicesFilteredL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetServicesFilteredL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::GetServicesFilteredL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KGetServicesFilteredL, "In GetServicesFilteredL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KGetServicesFilteredL );
+ // Print to log file
+ iLog->Log( KGetServicesFilteredL );
+ TRespStatus respStatus = ESucceeded;
+ TInt rv = KErrNone;
+ CDesC8ArraySeg* selectedServicesArray = NULL;
+
+ TInt msgTypeInt;
+ TInt expectedServiceCount = 0;
+ TUint32 flags = 0;
+
+ aItem.GetNextInt(msgTypeInt);
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ aItem.GetNextInt(expectedServiceCount);
+
+ TInt orderInt = 2;
+ aItem.GetNextInt(orderInt);
+ CIptvServiceManagementClient::TOrder order = static_cast<CIptvServiceManagementClient::TOrder>(orderInt);
+ VCXLOGLO2("Order: %d", order);
+
+ TBuf<256> searchLimitFlags;
+
+ TInt flagInt = 0;
+ while(KErrNone == aItem.GetNextInt(flagInt))
+ {
+ flags |= flagInt;
+
+ CIptvServiceManagementClient::TSearchLimitFlag flag = static_cast<CIptvServiceManagementClient::TSearchLimitFlag>(flagInt);
+
+ switch(flag)
+ {
+ case CIptvServiceManagementClient::ESelectedServices:
+ {
+ searchLimitFlags.Append(_L("ESelectedServices "));
+ VCXLOGLO1("Appending ESelectedServices to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EMainServices:
+ {
+ searchLimitFlags.Append(_L("EMainServices "));
+ VCXLOGLO1("Appending EMainServices to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::ESubServices:
+ {
+ searchLimitFlags.Append(_L("ESubServices "));
+ VCXLOGLO1("Appending ESubServices to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EVod:
+ {
+ searchLimitFlags.Append(_L("EVod "));
+ VCXLOGLO1("Appending EVod to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::ELiveTv:
+ {
+ searchLimitFlags.Append(_L("ELiveTv "));
+ VCXLOGLO1("Appending ELiveTv to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EVodCast:
+ {
+ searchLimitFlags.Append(_L("EVodCast "));
+ VCXLOGLO1("Appending EVodCast to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EBrowser:
+ {
+ searchLimitFlags.Append(_L("EBrowser "));
+ VCXLOGLO1("Appending EBrowser to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EApplication:
+ {
+ searchLimitFlags.Append(_L("EApplication "));
+ VCXLOGLO1("Appending EApplication to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EVideoRemote:
+ {
+ searchLimitFlags.Append(_L("EVideoRemote "));
+ VCXLOGLO1("Appending EVideoRemote to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EMobileTv:
+ {
+ searchLimitFlags.Append(_L("EMobileTv "));
+ VCXLOGLO1("Appending EMobileTv to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EServiceGroup:
+ {
+ searchLimitFlags.Append(_L("EServiceGroup "));
+ VCXLOGLO1("Appending EServiceGroup to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EGroupedServices:
+ {
+ searchLimitFlags.Append(_L("EGroupedServices "));
+ VCXLOGLO1("Appending EGroupedServices to search flags");
+ }
+ break;
+ case CIptvServiceManagementClient::EOther:
+ {
+ searchLimitFlags.Append(_L("EOther "));
+ VCXLOGLO1("Appending EOther to search flags");
+ }
+ break;
+ case 0:
+ break;
+ default:
+ VCXLOGLO2("Invalid search limit flag in test case! %d", flagInt);
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetServicesFilteredL");
+ return KErrArgument;
+ }
+ }
+
+ VCXLOGLO2("Search limit flags: ", &searchLimitFlags);
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ respStatus = iIptvServiceManagementSync->CallGetServicesFiltered(flags,
+ order,
+ msgType,
+ &selectedServicesArray
+ );
+
+ if(respStatus != MIptvServiceManagementClientObserver::ESucceeded)
+ {
+ if(selectedServicesArray)
+ {
+ selectedServicesArray->Reset();
+ delete selectedServicesArray;
+ selectedServicesArray = NULL;
+ }
+ VCXLOGLO2("** FAIL ** CallGetServicesFiltered returned error. error: %d", respStatus );
+ rv = respStatus;
+ }
+ else
+ {
+ if(selectedServicesArray != NULL)
+ {
+ /* Print all received services */
+ VCXLOGLO1("Filtered services:");
+ TInt i( 0 );
+ for(i = 0; i < selectedServicesArray->MdcaCount(); i++)
+ {
+ CIptvService* iptvService = CIptvService::NewL();
+ iptvService->SetL(selectedServicesArray->MdcaPoint(i));
+ iIptvTestUtilities->PrintIptvService(iptvService);
+ delete iptvService;
+ }
+
+ /* Verifying the expected amount of services */
+ VCXLOGLO3("CIptvServiceManagementApiTest::GetServicesFilteredL -- Expected %d, Received %d", expectedServiceCount, selectedServicesArray->MdcaCount());
+
+ if( expectedServiceCount != -1 )
+ {
+ /* We were expecting some count */
+ if( expectedServiceCount != selectedServicesArray->MdcaCount() )
+ {
+ VCXLOGLO1("Wrong service count!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetServicesFilteredL");
+ return KErrCorrupt;
+ }
+ }
+ }
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetServicesFilteredL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetServicesByTypeL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetServicesByTypeL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::GetServicesByTypeL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KWhere, "In GetServicesByTypeL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KWhere );
+ // Print to log file
+ iLog->Log( KWhere );
+
+ TInt rv = KErrNone;
+
+ TInt msgTypeInt;
+ TInt expectedServiceCount = 0;
+
+ User::LeaveIfError( aItem.GetNextInt(msgTypeInt) );
+
+ User::LeaveIfError( aItem.GetNextInt(expectedServiceCount) );
+
+ TInt type;
+ User::LeaveIfError( aItem.GetNextInt( type ) );
+
+ VCXLOGLO2("Services with type %d requested.", type);
+
+ iServiceStore->RefreshServicesFromDbL(KNoFilter, KNoSort);
+
+ TInt typeCount(0);
+ for( TInt i=0; i<iServiceStore->ServiceCount(); i++ )
+ {
+ if( iServiceStore->GetService(i)->GetType() == type )
+ {
+ typeCount++;
+ }
+ }
+
+ // Verifying the expected amount of services
+ VCXLOGLO3("CIptvServiceManagementApiTest::GetServicesFilteredL -- Expected %d, Received %d", expectedServiceCount, typeCount);
+
+ if( expectedServiceCount != typeCount )
+ {
+ VCXLOGLO2("Wrong service count: %d!", typeCount);
+ rv = KErrCorrupt;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetServicesFilteredL");
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::ShutdownServerL
+// -----------------------------------------------------------------------------
+//
+// Not supported
+//
+TInt CIptvServiceManagementApiTest::ShutdownServerL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::ShutdownServerL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KWhere, "In ShutdownServerL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KWhere );
+
+ // Print to log file
+ iLog->Log( KWhere );
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ TInt msgTypeInt;
+ if( KErrNone != aItem.GetNextInt(msgTypeInt) )
+ {
+ VCXLOGLO1("* ERROR * Specify parameter async / sync!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ShutdownServerL");
+ return KErrArgument;
+ }
+
+ VCXLOGLO2("MsgType: %d", msgTypeInt);
+
+ CIptvServiceManagementSync::TIptvSmTestConnection msgType = static_cast<CIptvServiceManagementSync::TIptvSmTestConnection>(msgTypeInt);
+
+ TRespStatus respStatus = ESucceeded;
+
+ respStatus = iIptvServiceManagementSync->CallShutdownServer(msgType);
+
+ if(respStatus == ESucceeded)
+ {
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ShutdownServerL");
+ return KErrNone;
+ }
+
+ VCXLOGLO2("Shutdown failed with error code: %d", respStatus);
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ShutdownServerL");
+ return respStatus;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::SetSpecialAction()
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::SetSpecialAction( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::SetSpecialAction");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KSetSpecialAction, "In SetSpecialAction" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KSetSpecialAction );
+ // Print to log file
+ iLog->Log( KSetSpecialAction );
+
+ TInt action(-1);
+
+ aItem.GetNextInt(action);
+
+ if(action < 0)
+ {
+ VCXLOGLO1("Incorrect parameter.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetSpecialAction");
+ return KErrArgument;
+ }
+
+ iIptvServiceManagementSync->SetSpecialAction(action);
+ VCXLOGLO2("SetSpecialAction: %d", action);
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::SetSpecialAction");
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::RepeatNextRequest
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::RepeatNextRequest( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::RepeatNextRequest");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KRepeatNextRequest, "In RepeatNextRequest" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KRepeatNextRequest );
+ // Print to log file
+ iLog->Log( KRepeatNextRequest );
+
+ TInt repeatRequest(0);
+
+ aItem.GetNextInt(repeatRequest);
+
+ iIptvServiceManagementSync->RepeatNextRequest(repeatRequest);
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::RepeatNextRequest");
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::VerifyServerIsShutdownL
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::VerifyServerIsShutdownL( CStifItemParser& /* aItem */ )
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::VerifyServerIsShutdownL");
+ // Print to UI
+ _LIT( KIptvServiceManagementApiTest, "IptvServiceManagementApiTest" );
+ _LIT( KShutDownServer, "In VerifyServerIsShutdownL" );
+ TestModuleIf().Printf( 0, KIptvServiceManagementApiTest, KShutDownServer );
+ // Print to log file
+ iLog->Log( KShutDownServer );
+
+ TInt rv = KErrNone;
+
+ TFindServer findIptvServer( KIptvServerName );
+ TFullName name;
+
+ if ( findIptvServer.Next( name ) == KErrNone )
+ {
+ // Server running
+ VCXLOGLO1("** FAIL ** IptvServer is not closed!");
+ VCXLOGLO2("Name: %S", &name);
+ rv = KErrCorrupt;
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::VerifyServerIsShutdownL");
+
+ return rv;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::DeAllocateResources
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementApiTest::DeAllocateResources()
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::DeAllocateResources");
+
+ iHardcodedServices.ResetAndDestroy();
+ iHardcodedServices.Close();
+
+ delete iIptvServiceManagementSync;
+ iIptvServiceManagementSync = NULL;
+
+ delete iIptvTestUtilities;
+ iIptvTestUtilities = NULL;
+
+ if(iIapNumList)
+ {
+ iIapNumList->Reset();
+ delete iIapNumList;
+ iIapNumList = NULL;
+ }
+
+ TInt err = KErrNone;
+ if(iIptvTestMobilecrashWatcher)
+ {
+ TRAP(err, iIptvTestMobilecrashWatcher->CheckNewCrashesL());
+ delete iIptvTestMobilecrashWatcher;
+ iIptvTestMobilecrashWatcher = NULL;
+ }
+
+ if(err != KErrNone)
+ {
+ User::Leave(err);
+ }
+
+ if(iServiceStore)
+ {
+ delete iServiceStore;
+ iServiceStore = NULL;
+ }
+
+ delete iAlrUtil;
+ iAlrUtil = NULL;
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::DeAllocateResources");
+}
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetCommDbIapIdByOrder
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetCommDbIapIdByOrder(TInt aIndex, TUint32& aIapId)
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::GetCommDbIapIdByOrder");
+ aIapId = 0;
+ if(aIndex >= iIapNumList->Count())
+ {
+ VCXLOGLO1("Index out of bounds.");
+ return KErrOverflow;
+ }
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::GetCommDbIapIdByOrder");
+ aIapId = iIapNumList->At(aIndex);
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::GetServiceIdFromParam
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementApiTest::GetServiceIdFromParam(CStifItemParser& aItem, TInt& aServiceId, TDes& aServiceName)
+ {
+ VCXLOGLO1(">>>CIptvServiceManagementApiTest::ReadServiceNameOrIdParam");
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ TPtrC serviceString;
+
+ if(aItem.GetNextString(serviceString) != KErrNone)
+ {
+ VCXLOGLO1("Can't read testcase parameter, serviceName/number !!!");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ReadServiceNameOrIdParam");
+ return KErrArgument;
+ }
+
+ TInt err = KErrNone;
+
+ if(KErrNone != CIptvTestUtilities::ParseIntFromString(aServiceId, serviceString))
+ {
+ // service name specified, find the service ID
+
+ aServiceName = serviceString;
+ VCXLOGLO2("ServiceName specified: %S", &aServiceName);
+
+ TInt rv = KErrNone;
+
+ TRAPD(err, rv = iIptvTestUtilities->GetServiceIdByNameL(aServiceName, aServiceId));
+ if(KErrNone != err)
+ {
+ VCXLOGLO2("GetServiceIdByNameL caused a leave: %d.", err);
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ReadServiceNameOrIdParam");
+ return err;
+ }
+ if(KErrNone != rv)
+ {
+ VCXLOGLO2("GetServiceIdByNameL returned error: %d.", rv);
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ReadServiceNameOrIdParam");
+ return rv;
+ }
+ }
+ else
+ {
+ RPointerArray<CIptvService> services;
+
+ VCXLOGLO2("ServiceID specified: %d", aServiceId);
+
+ CleanupResetAndDestroyPushL(services);
+
+ if(!iIptvTestUtilities->GetServicesFromDbL(services))
+ {
+ VCXLOGLO1("GetServicesFromDbL returned failed.");
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ReadServiceNameOrIdParam");
+
+ CleanupStack::PopAndDestroy(&services);
+ return err;
+ }
+
+ TInt i;
+ for(i=0; i<services.Count(); i++)
+ {
+ VCXLOGLO2("ServiceName id: %d", services[i]->GetId() );
+ if(services[i]->GetId() == aServiceId)
+ {
+ aServiceName = services[i]->GetName();
+ break;
+ }
+ }
+ CleanupStack::PopAndDestroy(&services);
+ }
+
+ VCXLOGLO1("<<<CIptvServiceManagementApiTest::ReadServiceNameOrIdParam");
+
+ return err;
+ }
+
+// End of File
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+// None
+
+
+// End of File