--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videofeeds/server/tsrc/VCXScheduledReminderTest/src/VCXScheduledReminderTestBlocks.cpp Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,1169 @@
+/*
+* 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 "VCXScheduledReminderTest.h"
+
+#include <f32file.h>
+#include "VCXTestLog.h"
+#include "CIptvUtil.h"
+#include <s32mem.h>
+#include "CIptvTestUtilities.h"
+
+#include <ipvideo/CCseSchedulerAPI.h>
+#include <ipvideo/CCseScheduledProgram.h>
+//#include <CseSchedulerPluginIF.hrh>
+#include "iptvvodscheduleddownloaddefinitions.h"
+#include "IptvEngineUids.h"
+
+#include "CIptvTestTimer.h"
+
+// EXTERNAL DATA STRUCTURES
+//extern ?external_data;
+
+// EXTERNAL FUNCTION PROTOTYPES
+//extern ?external_function( ?arg_type,?arg_type );
+
+// CONSTANTS
+const TInt KTestPanic = -69;
+const TInt KTmpBufLen = 256;
+const TInt32 KInvalidPluginUid = -1;
+
+// MACROS
+//#define ?macro ?macro_def
+
+// LOCAL CONSTANTS AND MACROS
+//const ?type ?constant_var = ?constant;
+//#define ?macro_name ?macro_def
+
+// MODULE DATA STRUCTURES
+//enum ?declaration
+//typedef ?declaration
+
+// LOCAL FUNCTION PROTOTYPES
+//?type ?function_name( ?arg_type, ?arg_type );
+
+// FORWARD DECLARATIONS
+//class ?FORWARD_CLASSNAME;
+
+// ============================= LOCAL FUNCTIONS ===============================
+void PrintTime(TTime time)
+ {
+ TDateTime date(time.DateTime());
+ _LIT( KTimeFormat, "Time = %d.%d.%d %d:%d" );
+ TBuf<80> buffer;
+ buffer.Format( KTimeFormat, date.Day() + 1, date.Month() + 1, date.Year(), date.Hour(), date.Minute() );
+ VCXLOGLO2( "%S", &buffer );
+ }
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::Delete
+// Delete here all resources allocated and opened from test methods.
+// Called from destructor.
+// -----------------------------------------------------------------------------
+//
+void CVCXScheduledReminderTest::Delete()
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::Delete");
+ if(iSchedulerClient)
+ {
+ delete iSchedulerClient;
+ iSchedulerClient = NULL;
+ }
+
+ if(iTestUtil!=NULL)
+ {
+ delete iTestUtil;
+ iTestUtil=NULL;
+ }
+
+ if(iShutdownTimer!=NULL)
+ {
+ iShutdownTimer->CancelTimer();
+ delete iShutdownTimer;
+ iShutdownTimer = NULL;
+ }
+
+ iScheduleArray.ResetAndDestroy();
+ iScheduleArray.Close();
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::Delete");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::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", CVCXScheduledReminderTest::CreateL ),
+ ENTRY( "RefreshService", CVCXScheduledReminderTest::RefreshServiceL ),
+ ENTRY( "SetIap", CVCXScheduledReminderTest::SetIapL ),
+ ENTRY( "ScheduleDownload", CVCXScheduledReminderTest::ScheduleDownloadL ),
+ ENTRY( "AddSchedule", CVCXScheduledReminderTest::AddScheduleL ),
+ ENTRY( "RemoveSchedule", CVCXScheduledReminderTest::RemoveScheduleL ),
+ ENTRY( "RemoveAllSchedules", CVCXScheduledReminderTest::RemoveAllSchedulesL ),
+ ENTRY( "RemoveAllFromArray", CVCXScheduledReminderTest::RemoveAllFromArrayL ),
+ ENTRY( "GetSchedulesByAppUid", CVCXScheduledReminderTest::GetSchedulesByAppUidL ),
+ ENTRY( "GetOverlappingSchedules", CVCXScheduledReminderTest::GetOverlappingSchedulesL ),
+ ENTRY( "GetSchedulesByPluginUid", CVCXScheduledReminderTest::GetSchedulesByPluginUidL ),
+ ENTRY( "GetSchedulesByType", CVCXScheduledReminderTest::GetSchedulesByTypeL ),
+ ENTRY( "GetSchedulesByTime", CVCXScheduledReminderTest::GetSchedulesByTimeL ),
+ ENTRY( "CheckCount", CVCXScheduledReminderTest::CheckCountL ),
+ ENTRY( "EmptyArray", CVCXScheduledReminderTest::EmptyArray ),
+ ENTRY( "AdjustClock", CVCXScheduledReminderTest::AdjustClockL ),
+ ENTRY( "SetTimeout", CVCXScheduledReminderTest::SetTimeoutL ),
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CIptvVodDlApiTest::SetTimeoutL
+// Set the timeout timer for the testcase. Timeout is given as 1/1000 seconds.
+// Timeout's max value is 2147482 ms = 37 minutes.
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::SetTimeoutL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::SetTimeoutL");
+
+ iShutdownTimer = CIptvTestTimer::NewL(*this, 0);
+
+ TInt timeout(0);
+
+ if(iShutdownTimer != NULL)
+ {
+ if(KErrNone!=aItem.GetNextInt(timeout))
+ {
+ VCXLOGLO1("Timeout value missing");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::SetTimeoutL");
+
+ delete iShutdownTimer;
+ iShutdownTimer = NULL;
+ return KErrArgument;
+ }
+ }
+ else
+ {
+ VCXLOGLO1("Couldn't create the timer");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::SetTimeoutL");
+
+ return KErrGeneral;
+ }
+
+ TTimeIntervalMicroSeconds32 interval((timeout * 1000));
+
+ iShutdownTimer->After(interval);
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::SetTimeoutL");
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::TimerComplete
+//
+// -----------------------------------------------------------------------------
+//
+void CVCXScheduledReminderTest::TimerComplete( TInt /* aTimerId */, TInt /* aError */ )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::TimerComplete");
+
+ VCXLOGLO1("XXXXXXXX TESTCASE TIMEOUT XXXXXXXXX");
+
+ Signal( KErrTimedOut );
+ //User::Leave( KErrTimedOut );
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::TimerComplete");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::CreateL
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::CreateL( CStifItemParser& /*aItem*/ )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::CreateL");
+ // Print to UI
+ _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );
+ _LIT( KCreate, "In Create" );
+ TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KCreate );
+ // Print to log file
+ iLog->Log( KCreate );
+
+ iSchedulerClient = CCseSchedulerApi::NewL();
+
+ iTestUtil = CIptvTestUtilities::NewL();
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::CreateL");
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::RefreshServiceL
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::RefreshServiceL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::RefreshServiceL");
+ // Print to UI
+ _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );
+ _LIT( KRefreshService, "In RefreshService" );
+ TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KRefreshService );
+ // Print to log file
+ iLog->Log( KRefreshService );
+
+ TUint serviceId = GetServiceL(aItem);
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ TTime refreshDate(0);
+
+ TPtrC dateString;
+ if(aItem.GetNextString(dateString) != KErrNone) {
+ VCXLOGLO1("CVCXScheduledReminderTest::RefreshServiceL -- No date given as parameter, using Universal Time.");
+ refreshDate.UniversalTime();
+ }
+ else {
+ VCXLOGLO2("CVCXScheduledReminderTest::RefreshServiceL -- Using date string %S", &dateString);
+ TInt err;
+ err = refreshDate.Set( dateString );
+ if( err != KErrNone ) {
+ VCXLOGLO2("CVCXScheduledReminderTest::RefreshServiceL -- refreshDate.Set() returned error code %d", err);
+ return KErrArgument;
+ }
+ }
+
+ VCXLOGLO2("CSchedulingTest::RefreshService: sid = %d", serviceId);
+
+ TInt ret = iTestUtil->RefreshService(serviceId, refreshDate);
+
+ VCXLOGLO2("CSchedulingTest::RefreshService returned %d", ret);
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::RefreshServiceL");
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::SetIapL ( service (name or id), iap (name or id) )
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::SetIapL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::SetIapL");
+ // Print to UI
+ _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );
+ _LIT( KSetIap, "In SetIap" );
+ TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KSetIap );
+ // Print to log file
+ iLog->Log( KSetIap );
+
+ TUint sid = GetServiceL(aItem);
+ TUint iap = GetIapL(aItem);
+
+ VCXLOGLO3("CSchedulingTest::SetIap: sid = %d, iap = %d",sid, iap);
+
+ TInt ret = iTestUtil->SetUsedIap(sid, iap);
+
+ VCXLOGLO2("CSchedulingTest: SetUsedIap returned %d", ret);
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::SetIapL");
+
+ return ret;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::ScheduleDownloadL(start, end, service )
+//
+// start and end times are given as seconds relative to this moment.
+// If values are negative, times are in the past.
+// Service can be name or id
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::ScheduleDownloadL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::ScheduleDownloadL");
+ // Print to UI
+ _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );
+ _LIT( KScheduleDownload, "In ScheduleDownload" );
+ TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KScheduleDownload );
+ // Print to log file
+ iLog->Log( KScheduleDownload );
+
+ CCseScheduledProgram* program = CCseScheduledProgram::NewL();
+
+
+ TInt start(0);
+ TInt end(0);
+ aItem.GetNextInt(start);
+ aItem.GetNextInt(end);
+ TTime now;
+ now.UniversalTime();
+ TTime startTime = now + TTimeIntervalSeconds(start);
+ TTime endTime = now + TTimeIntervalSeconds(end);
+ program->SetStartTime(TTime(startTime));
+ program->SetEndTime(TTime(endTime));
+
+
+ VCXLOGLO1("Now / Universal time:");
+ PrintTime(now);
+ TTime local;
+ local.HomeTime();
+ VCXLOGLO1("Now / Local time:");
+ PrintTime(local);
+ VCXLOGLO1("Scheduled starttime:");
+ PrintTime(startTime);
+ VCXLOGLO1("Scheduled endtime:");
+ PrintTime(endTime);
+
+
+ TUint id = GetServiceL(aItem);
+ HBufC8* dataBuf = HBufC8::NewLC(sizeof(TIptvServiceId));
+ TPtr8 dataPtr(dataBuf->Des());
+ RDesWriteStream writeStream;
+ CleanupClosePushL(writeStream);
+ writeStream.Open(dataPtr);
+ writeStream.WriteUint32L(id);
+ CleanupStack::PopAndDestroy(&writeStream);
+ program->SetApplicationDataL(dataPtr);
+ CleanupStack::PopAndDestroy(dataBuf);
+
+
+ TPtrC name(_L("<empty>"));
+ //aItem.GetNextString(name);
+ TBuf8<KTmpBufLen> nameBuf;
+ nameBuf.Copy(name);
+ program->SetName(nameBuf);
+
+
+ TInt dbId(id);
+ //aItem.GetNextInt(dbId);
+ program->SetDbIdentifier(dbId);
+
+
+ TInt appUid( IPTV_SERVER_UID );
+ //aItem.GetNextInt(appUid);
+ program->SetAppUid(appUid);
+
+
+ TInt pluginUid( KIptvScheduledDownloadPluginImplementationUid );
+ //aItem.GetNextInt(pluginUid);
+ program->SetPluginUid(pluginUid);
+
+
+ TInt type( CCseScheduledProgram::ECseScheduleDownload );
+ //aItem.GetNextInt(type);
+ program->SetScheduleType(type);
+
+ //TUint32 pluginType = CCseScheduledProgram::ECseUniPlugin;
+ //program->SetPluginType(pluginType);
+
+ iSchedulerClient->AddSchedule(*program);
+
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::ScheduleDownloadL");
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::AddScheduleL( CStifItemParser& aItem )
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::AddScheduleL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>VCXScheduledReminderTest::AddScheduleL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In ScheduleDownload" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ // Construct the program
+ CCseScheduledProgram* program = CCseScheduledProgram::NewL();
+ CleanupStack::PushL( program );
+
+ TPtrC name(_L("<empty>"));
+ TBuf8<KTmpBufLen> nameBuf;
+ nameBuf.Copy(name);
+ program->SetName(nameBuf);
+ VCXLOGLO2("VCXScheduledReminderTest: ServiceName: %S", &nameBuf);
+
+ // Set type
+ TInt schedType( 0 );
+ if( aItem.GetNextInt( schedType ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+ program->SetScheduleType( schedType );
+ VCXLOGLO2("VCXScheduledReminderTest: ScheduleType: %d", schedType);
+
+ // Set start & end
+ TInt start(0);
+ TInt end(0);
+ if( aItem.GetNextInt(start) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt to start");
+ VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+ if( aItem.GetNextInt(end) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt to end");
+ VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+ TTime now;
+ now.UniversalTime();
+ TTime startTime = now + TTimeIntervalSeconds(start);
+ TTime endTime = now + TTimeIntervalSeconds(end);
+ VCXLOGLO2("VCXScheduledReminderTest: Start: %d", start);
+ VCXLOGLO2("VCXScheduledReminderTest: End: %d", end);
+ program->SetStartTime(TTime(startTime));
+ program->SetEndTime(TTime(endTime));
+
+ // Print times
+ VCXLOGLO1("Now / Universal time:");
+ PrintTime(now);
+ TTime local;
+ local.HomeTime();
+ VCXLOGLO1("Now / Local time:");
+ PrintTime(local);
+ VCXLOGLO1("Scheduled starttime:");
+ PrintTime(TTime(startTime));
+ VCXLOGLO1("Scheduled endtime:");
+ PrintTime(TTime(endTime));
+
+ // Set plugin UID to use
+ TInt pluginId( 0 );
+ if ( aItem.GetNextInt( pluginId ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+
+ program->SetPluginUid( GetPluginUidByNumber(pluginId) );
+
+ // Set plugin type
+ TInt pluginType( 0 );
+ if ( aItem.GetNextInt( pluginType ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+ if( pluginType == 0 )
+ {
+ program->SetPluginType( CCseScheduledProgram::ECseUniPlugin );
+ }
+ else
+ {
+ program->SetPluginType( CCseScheduledProgram::ECseMultiPlugin );
+ }
+
+ // Set app uid
+ // This is used as a default, does it matter?
+ program->SetAppUid( IPTV_SERVER_UID );
+
+ // Set application data
+ TUint id = GetServiceL(aItem);
+ VCXLOGLO2("VCXScheduledReminderTest: Using Service id: %d", id);
+ HBufC8* dataBuf = HBufC8::NewLC(sizeof(TIptvServiceId));
+ TPtr8 dataPtr(dataBuf->Des());
+ RDesWriteStream writeStream;
+ CleanupClosePushL(writeStream);
+ writeStream.Open(dataPtr);
+ writeStream.WriteUint32L(id);
+ CleanupStack::PopAndDestroy(&writeStream);
+ program->SetApplicationDataL(dataPtr);
+ CleanupStack::PopAndDestroy(dataBuf);
+
+ VCXLOGLO1("VCXScheduledReminderTest::AddScheduleL: Adding following item:");
+ program->DebugDump();
+
+ // Add schedule to engine
+ TInt error( 0 );
+ error = iSchedulerClient->AddSchedule(*program);
+ VCXLOGLO2("VCXScheduledReminderTest: AddSchedule returned %d", error);
+
+ CleanupStack::PopAndDestroy( program );
+
+ VCXLOGLO1("<<<VCXScheduledReminderTest::AddScheduleL");
+
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::RemoveScheduleL( CStifItemParser& aItem )
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::RemoveScheduleL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::RemoveScheduleL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In RemoveSchedule" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ TInt index( 0 );
+
+ // Attempt to read from aItem
+ if( aItem.GetNextInt( index ) != KErrNone )
+ {
+ VCXLOGLO1("CVCXScheduledReminderTest::RemoveScheduleL: Unable to read parameter");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::RemoveScheduleL");
+ return KErrArgument;
+ }
+
+ // Attempt to remove schedule by given index
+ TInt error( KErrNone );
+ error = iSchedulerClient->RemoveSchedule( index );
+ VCXLOGLO2("VCXScheduledReminderTest: RemoveSchedule returned %d", error);
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::RemoveScheduleL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::RemoveAllSchedulesL( CStifItemParser& aItem )
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::RemoveAllSchedulesL( CStifItemParser& /* aItem */ )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::RemoveAllSchedulesL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In RemoveAllSchedules" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ RPointerArray<CCseScheduledProgram> tempArray;
+ iSchedulerClient->GetSchedulesByAppUid( IPTV_SERVER_UID, tempArray );
+
+ TInt count( 0 );
+ TInt error( 0 );
+ for( count = 0; count < tempArray.Count(); count++ )
+ {
+ error = iSchedulerClient->RemoveSchedule( tempArray[count]->DbIdentifier() );
+ VCXLOGLO2("CVCXScheduledReminderTest: RemoveSchedule returned %d", error);
+ }
+
+ tempArray.ResetAndDestroy();
+ tempArray.Close();
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::RemoveAllSchedulesL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::RemoveAllFromArrayL( CStifItemParser& aItem )
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::RemoveAllFromArrayL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::RemoveAllFromArrayL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In RemoveAllFromArrayL" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ TInt count( 0 );
+ TInt error( 0 );
+ for( count = 0; count < iScheduleArray.Count(); count++ )
+ {
+ error = iSchedulerClient->RemoveSchedule( iScheduleArray[count]->DbIdentifier() );
+ VCXLOGLO2("CVCXScheduledReminderTest: RemoveSchedule returned %d", error);
+ }
+
+ // Clean up the iScheduleArray
+ EmptyArray( aItem );
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::RemoveAllFromArrayL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetScheduleL()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::GetScheduleL( CStifItemParser& /* aItem */ )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetScheduleL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In GetScheduleL" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ CCseScheduledProgram* iProgram = CCseScheduledProgram::NewL();
+
+ TInt error( 0 );
+ error = iSchedulerClient->GetSchedule( NULL, iProgram );
+ VCXLOGLO2("CVCXScheduledReminderTest::GetScheduleL: error: %d", error);
+
+ // Print
+ iProgram->DebugDump();
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetScheduleL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetSchedulesByAppUid()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::GetSchedulesByAppUidL( CStifItemParser& /* aItem */ )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetSchedulesByAppUidL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In GetSchedulesByAppUIDL" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ // Fetch schedules from client
+ TInt error( 0 );
+ error = iSchedulerClient->GetSchedulesByAppUid( IPTV_SERVER_UID, iScheduleArray );
+ VCXLOGLO2("CVCXScheduledReminderTest: GetSchedulesByAppUid returned errorcode %d", error);
+
+ // Print schedules
+ PrintArray( iScheduleArray );
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesByAppUidL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetOverlappingSchedulesL()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::GetOverlappingSchedulesL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetOverlappingSchedulesL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In GetOverlappingSchedulesL" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ CCseScheduledProgram* program = CCseScheduledProgram::NewL();
+ CleanupStack::PushL( program );
+
+ //Program object, add type and starttime/endtime, etc etc
+ TInt type( 0 );
+ if( aItem.GetNextInt( type ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+
+ // Start & end times
+ TInt start(0);
+ TInt end(0);
+ if( aItem.GetNextInt( start ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+
+ if( aItem.GetNextInt( end ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesL");
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+ return KErrArgument;
+ }
+
+ TTime now;
+ now.UniversalTime();
+ TTime startTime = now - TTimeIntervalDays( start );
+ TTime endTime = now + TTimeIntervalDays( end );
+
+ // Set the needed values
+ program->SetScheduleType( type );
+ program->SetStartTime( startTime );
+ program->SetEndTime( endTime );
+
+ // Fetch schedules from client
+ TInt error( 0 );
+ error = iSchedulerClient->GetOverlappingSchedules( *program, iScheduleArray );
+ VCXLOGLO2("CVCXScheduledReminderTest: GetOverlappingSchedules returned errorcode %d", error);
+
+ CleanupStack::PopAndDestroy(); //CCseScheduledProgram
+
+ // Print schedules
+ PrintArray( iScheduleArray );
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetOverlappingSchedulesL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetSchedulesByPluginUIDL()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::GetSchedulesByPluginUidL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetSchedulesByPluginUidL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In GetSchedulesByPluginUidL" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ // Set plugin UID to use
+ TInt pluginId( 0 );
+ if ( aItem.GetNextInt( pluginId ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<VCXScheduledReminderTest::GetSchedulesByPluginUidL");
+ return KErrArgument;
+ }
+
+ TInt32 pluginUid( 0 );
+ pluginUid = GetPluginUidByNumber(pluginId);
+
+ // Fetch schedules from client
+ TInt error( 0 );
+ error = iSchedulerClient->GetSchedulesByPluginUid( pluginUid, iScheduleArray );
+ VCXLOGLO2("CVCXScheduledReminderTest: GetSchedulesByPluginUidL returned errorcode %d", error);
+
+ // Print schedules
+ PrintArray( iScheduleArray );
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesByPluginUidL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetSchedulesByTypeL()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::GetSchedulesByTypeL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetSchedulesByTypeL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In GetSchedulesByTypeL" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ TInt type( 0 );
+ if( aItem.GetNextInt( type ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesL");
+ return KErrArgument;
+ }
+
+ // Fetch schedules from client
+ TInt error( 0 );
+ error = iSchedulerClient->GetSchedulesByType( type, iScheduleArray );
+ VCXLOGLO2("<<<CVCXScheduledReminderTest: GetSchedulesByType returned errorcode %d", error);
+
+ // Print schedules
+ PrintArray( iScheduleArray );
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesByTypeL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetSchedulesByTime()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::GetSchedulesByTimeL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetSchedulesByTimeL");
+
+ // Print to UI
+ _LIT( KModule, "VCXScheduledReminderTest" );
+ _LIT( KWhere, "In GetSchedulesByTimeL" );
+ TestModuleIf().Printf( 0, KModule, KWhere );
+
+ // Start & end times
+ TInt start( 0 );
+ TInt end( 0 );
+ if( aItem.GetNextInt( start ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesL");
+ return KErrArgument;
+ }
+ if( aItem.GetNextInt( end ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesL");
+ return KErrArgument;
+ }
+ TTime now;
+ now.UniversalTime();
+ TTime startTime = now - TTimeIntervalDays( start );
+ TTime endTime = now + TTimeIntervalDays( end );
+
+ // Fetch schedules from client
+ TInt error( 0 );
+ error = iSchedulerClient->GetSchedulesByTime( startTime, endTime, iScheduleArray );
+ VCXLOGLO2("VCXScheduledReminderTest: GetSchedulesByTime returned errorcode %d", error);
+
+ // Print schedules
+ PrintArray( iScheduleArray );
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetSchedulesByTimeL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::CheckCountL()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::CheckCountL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::CheckCountL");
+ TInt expectedCount( 0 );
+ TInt error( KErrNone );
+
+ if( aItem.GetNextInt( expectedCount ) != KErrNone )
+ {
+ VCXLOGLO1("Unable to read NextInt");
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::CheckCountL");
+ return KErrArgument;
+ }
+
+ VCXLOGLO2("CVCXScheduledReminderTest::CheckCountL: Expecting %d items", expectedCount);
+ VCXLOGLO2("CVCXScheduledReminderTest::CheckCountL: iScheduleArray.Count() = %d", iScheduleArray.Count());
+
+ if( iScheduleArray.Count() != expectedCount )
+ {
+ VCXLOGLO1("CVCXScheduledReminderTest::CheckCountL: The amount of scheduled items doesn't match the expected value!");
+ error = KErrGeneral;
+ }
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::CheckCountL");
+ return error;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::CheckCountL()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::EmptyArray( CStifItemParser& /* aItem */ )
+ {
+ iScheduleArray.Reset();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::CompareScheduleLists()
+// Compare schedule array to the class member array
+// -----------------------------------------------------------------------------
+//
+TBool CVCXScheduledReminderTest::CompareScheduleLists( RPointerArray<CCseScheduledProgram> aList )
+ {
+ // if the amount of items doesn't match, then lists obviously don't match
+ if( aList.Count() != iScheduleArray.Count() )
+ {
+ return EFalse;
+ }
+
+ // compare every item
+ TInt count(0);
+ for( count = 0; count < iScheduleArray.Count(); count++ )
+ {
+ if( !CompareScheduleItems( aList[count], iScheduleArray[count] ) )
+ {
+ return EFalse;
+ }
+ }
+
+ // finally, if previous tests didn't return false, the lists obviously match!
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::CompareScheduleItems()
+// Compares given programs
+// -----------------------------------------------------------------------------
+//
+TBool CVCXScheduledReminderTest::CompareScheduleItems( CCseScheduledProgram* aFirst, CCseScheduledProgram* aSecond )
+ {
+ // Now this is easy and stupid. Is there any convenient way?
+
+ if( aFirst->Name() != aSecond->Name() ) return EFalse;
+ if( aFirst->StartTime() != aSecond->StartTime() ) return EFalse;
+ if( aFirst->EndTime() != aSecond->EndTime() ) return EFalse;
+ if( aFirst->AppUid() != aSecond->AppUid() ) return EFalse;
+ if( aFirst->PluginUid() != aSecond->PluginUid() ) return EFalse;
+ if( aFirst->ApplicationData() != aSecond->ApplicationData() ) return EFalse;
+ if( aFirst->DbIdentifier() != aSecond->DbIdentifier() ) return EFalse;
+ if( aFirst->ScheduleType() != aSecond->ScheduleType() ) return EFalse;
+
+ // If all else "fails"
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::PrintArray()
+//
+// -----------------------------------------------------------------------------
+//
+void CVCXScheduledReminderTest::PrintArray( RPointerArray<CCseScheduledProgram> aList )
+ {
+ TInt count( 0 );
+ for( count = 0; count < aList.Count(); count++ )
+ {
+ aList[count]->DebugDump();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetPluginUidByNumber( TInt aValue )
+// Returns plugin uid based on number
+// -----------------------------------------------------------------------------
+//
+TInt32 CVCXScheduledReminderTest::GetPluginUidByNumber( TInt aValue )
+ {
+ TInt32 pluginUID( 0 );
+
+ switch( aValue )
+ {
+ case 0:
+ {
+ VCXLOGLO1("VCXScheduledReminderTest: Plugin id: KSceSchedulerPluginEcomIfUid");
+ //pluginUID = KSceSchedulerPluginEcomIfUid;
+ break;
+ }
+ case 1:
+ {
+ VCXLOGLO1("VCXScheduledReminderTest: Plugin id: KIptvSchedulerPluginIpmlementationUid");
+ //pluginUID = KIptvSchedulerPluginIpmlementationUid;
+ break;
+ }
+ case 2:
+ {
+ VCXLOGLO1("VCXScheduledReminderTest: Plugin id: KIptvSchedulerPluginUid");
+ //pluginUID = KIptvSchedulerPluginUid;
+ break;
+ }
+ case 3:
+ {
+ VCXLOGLO1("VCXScheduledReminderTest: Plugin id: INVALID PLUGIN UID");
+ pluginUID = KInvalidPluginUid;
+ break;
+ }
+ default:
+ {
+ VCXLOGLO1("VCXScheduledReminderTest: Plugin id: KIptvScheduledDownloadPluginImplementationUid");
+ pluginUID = KIptvScheduledDownloadPluginImplementationUid;
+ break;
+ }
+ }
+ return pluginUID;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::AdjustClockL ( timeintervalinseconds )
+// adds to given interval to current system time. interval may also be negative.
+// -----------------------------------------------------------------------------
+//
+TInt CVCXScheduledReminderTest::AdjustClockL( CStifItemParser& aItem )
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::AdjustClockL");
+ // Print to UI
+ _LIT( KVCXScheduledReminderTest, "VCXScheduledReminderTest" );
+ _LIT( KAdjustClock, "In AdjustClock" );
+ TestModuleIf().Printf( 0, KVCXScheduledReminderTest, KAdjustClock );
+ // Print to log file
+ iLog->Log( KAdjustClock );
+
+ TInt tmp;
+ T1L( aItem.GetNextInt(tmp), KErrNone );
+ TTimeIntervalSeconds ts(tmp);
+
+ TTime oldTime;
+ oldTime.UniversalTime();
+
+ User::SetUTCTime(TTime(oldTime + ts));
+
+ VCXLOGLO2("CSchedulingTest: AdjustClock ts: %d", ts.Int());
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::AdjustClockL");
+
+ return KErrNone;
+ }
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetServiceL
+// If aItem = string, returns given service's id, otherwise returns given number.
+// -----------------------------------------------------------------------------
+//
+TUint32 CVCXScheduledReminderTest::GetServiceL(CStifItemParser& aItem)
+ {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetServiceL");
+
+ TPtrC serviceName;
+ TUint serviceId(0);
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ if( KErrNone == aItem.GetNextString(serviceName) && iTestUtil!=NULL)
+ {
+ VCXLOGLO2("CVCXScheduledReminderTest:: Service name = %S",&serviceName);
+ TInt sidTemp(0);
+
+ if( iTestUtil->GetServiceIdByNameL(serviceName, sidTemp) == KErrNone )
+ {
+ serviceId = sidTemp;
+ }
+ else
+ {
+ TLex lex(serviceName);
+ TInt64 tmp2;
+ if(lex.Val(tmp2)==KErrNone)
+ {
+ serviceId = tmp2;
+ VCXLOGLO2("Service name not found, using parsed int %d.",serviceId);
+ }
+ else
+ {
+ VCXLOGLO1("Service not found");
+ _LIT(KTestErr, "Invalid service");
+ User::Panic(KTestErr, KTestPanic);
+ }
+ }
+ }
+ else
+ {
+ VCXLOGLO1("Missing parameter: service");
+ _LIT(KTestErr, "Service missing");
+ User::Panic(KTestErr,KTestPanic);
+ }
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetServiceL");
+ return serviceId;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXScheduledReminderTest::GetIapL
+// If aItem = string, returns given iap's id, otherwise returns given number.
+// -----------------------------------------------------------------------------
+//
+TUint32 CVCXScheduledReminderTest::GetIapL( CStifItemParser& aItem ) {
+ VCXLOGLO1(">>>CVCXScheduledReminderTest::GetIapL");
+
+ TPtrC iapName;
+ TUint32 iapId(0);
+
+ aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
+
+ /*
+ TInt temp;
+ if( aItem.GetNextInt( temp ) == KErrNone ) {
+ iapId = (TUint32)temp;
+ VCXLOGLO2("Using int %d as Iap ID.",iapId);
+ }
+ else {
+ aItem.GetNextString(iapName);
+ if( !iTestUtil->GetIapIdL(iapName, iapId) ) {
+ VCXLOGLO1("Iap not found");
+ _LIT(KTestErr, "Invalid iap");
+ User::Panic(KTestErr,KTestPanic);
+ }
+ }*/
+
+
+ if( KErrNone == aItem.GetNextString(iapName) && iTestUtil!=NULL) {
+ VCXLOGLO2("CVCXScheduledReminderTest:: Iap name = %S",&iapName);
+ if( !iTestUtil->GetIapIdL(iapName, iapId) ) {
+ TLex lex(iapName);
+ TInt64 tmp1;
+ if(lex.Val(tmp1)==KErrNone) {
+ iapId = tmp1;
+ VCXLOGLO2("Iap name not found, using parsed int %d.",iapId);
+ }
+ else {
+ VCXLOGLO1("Iap not found");
+ _LIT(KTestErr, "Invalid iap");
+ User::Panic(KTestErr,KTestPanic);
+ }
+ }
+ }
+ else {
+ VCXLOGLO1("Error finding Iap !");
+ _LIT(KTestErr, "iap missing");
+ User::Panic(KTestErr,KTestPanic);
+ }
+
+ VCXLOGLO1("<<<CVCXScheduledReminderTest::GetIapL");
+ return iapId;
+}
+
+// End of File