/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:    CGlxGarbageCollector unit tests

*

*/

//  CLASS HEADER

#include "glxcachemanager.h"

#include "t_cglxgarbagecollector.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <digia/eunit/eunitdecorators.h>

#include <mpxattribute.h>

#include <mpxmediageneraldefs.h>

#include <glxmediageneraldefs.h>

//  INTERNAL INCLUDES

#include "glxerrormanager.h"

#include "glxfetcherrorarray.h"

#include "glxgarbagecollector.h"

#include "glxmedia.h"

#include "t_cachetesthelpers.h"

T_CGlxGarbageCollector* T_CGlxGarbageCollector::iGarbageCollectorTest = NULL;

const TInt KIdSpaceId1 = 1;

const TInt KIdSpaceId2 = 2;

const TInt KIdSpaceId3 = 3;

const TInt KCache1Media1Id = 1;

const TInt KCache1Media2Id = 2;

const TInt KCache1Media3Id = 3;

const TInt KCache2Media1Id = 1;

const TInt KCache2Media2Id = 2;

const TInt KCache3Media1Id = 1;

const TInt KCache3Media2Id = 2;

const TInt KCache3Media3Id = 3;

const TInt KCache3Media4Id = 4;

const TInt KCache3Media5Id = 5;

const TInt KCache3Media6Id = 6;

const TInt KCache3Media7Id = 7;

_LIT(KCache1Media1Title, "Captured");

//_LIT(KCache1Media2Title, "Albums");

//_LIT(KCache1Media3Title, "All");

_LIT(KCache1Media1SubTitle, "0 items");

//_LIT(KCache1Media2SubTitle, "0 albums");

//_LIT(KCache1Media3SubTitle, "7 items");

_LIT(KCache2Media1Title, "Favourites");

_LIT(KCache2Media2Title, "Print later");

_LIT(KCache2Media1SubTitle, "0 items");

_LIT(KCache2Media2SubTitle, "0 items");

_LIT(KCache3Media1Title, "Spring");

//_LIT(KCache3Media2Title, "Summer");

_LIT(KCache3Media3Title, "Autumn");

_LIT(KCache3Media4Title, "Winter");

_LIT(KCache3Media5Title, "Sun");

//_LIT(KCache3Media6Title, "Moon");

//_LIT(KCache3Media7Title, "Stars");

const TInt KCache3Media1Size = 8;

const TInt KCache3Media2Size = 16;

const TInt KCache3Media3Size = 32;

//const TInt KCache3Media4Size = 64;

//const TInt KCache3Media5Size = 128;

//const TInt KCache3Media6Size = 256;

//const TInt KCache3Media7Size = 512;

// This value must be the same as in the garbage collector

const TInt KItemsScannedPerGCRound = 10;

const TInt KErrorExpiryPeriod = 30;

const TInt KTimerCallbackPeriod1 = 5;

const TInt KTimerCallbackPeriod2 = 35;

const TInt KMicrosecondsInSeconds = 1000000;

// These values are for CleanupCaches test

const TInt KItemsToScan = 10;

const TInt KCache1ItemCount = 3;

const TInt KCache2ItemCount = 2;

const TInt KCache3ItemCount = 7;

// CONSTRUCTION

T_CGlxGarbageCollector* T_CGlxGarbageCollector::NewL()

    {

    T_CGlxGarbageCollector* self = T_CGlxGarbageCollector::NewLC();

    CleanupStack::Pop();

    return self;

    }

T_CGlxGarbageCollector* T_CGlxGarbageCollector::NewLC()

    {

    T_CGlxGarbageCollector* self = new( ELeave ) T_CGlxGarbageCollector();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

T_CGlxGarbageCollector::~T_CGlxGarbageCollector()

    {

    }

// Default constructor

T_CGlxGarbageCollector::T_CGlxGarbageCollector()

    {

    }

// Second phase construct

void T_CGlxGarbageCollector::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void T_CGlxGarbageCollector::SetupL(  )

    {

    EUNIT_PRINT(_L("T_CGlxGarbageCollector::SetupL()"));

    SetupCachesL();

    iCGlxGarbageCollector = CGlxGarbageCollector::NewL(iCaches);

    // Set this variable to 'this' in the tests if they need to know

    // if idlecallbacks have been called on garbage collector

    iGarbageCollectorTest = NULL;

    }

void T_CGlxGarbageCollector::Teardown(  )

    {

    iCaches.ResetAndDestroy();

    iCacheManager->Close();

    delete iCGlxGarbageCollector;

    iCGlxGarbageCollector = NULL;

    }

void T_CGlxGarbageCollector::RemoveMediaReference(TInt aIndex)

    {

    EUNIT_PRINT(_L("Remove iMediaUser_Test from the mentioned Cache"));

    // Remove this mediauser from the mentioned Caache

    /* Case specific medias must be removed from the caches.

        CGlxCache* cache3 = iCaches[2];

        RemoveMediaUserFromCacheMedias(*cache3, *iMediaUser_Test);

    */

    }

void T_CGlxGarbageCollector::T_CGlxGarbageCollector_Cleanup_SubTest0L()

    {

    //Create media users

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    EUNIT_PRINT(_L("Thumbnail attribute wanted by mediauser3"));

    attributes.Reset();

    attributes.AppendL(KMPXMediaGeneralThumbnail1);

    CGlxMediaUserTest* mediaUser3 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser3);

    EUNIT_PRINT(_L("All media in cache3 used by mediauser3"));

    CGlxCache* cache3 = iCaches[2];

    AddMediaUserToCacheMediasL(*cache3, *mediaUser3);

    iMediaUser_Test = mediaUser3;

    // Cleanup

    EUNIT_PRINT(_L("iCGlxGarbageCollector.Cleanup"));

    iCGlxGarbageCollector->CleanupL();

    // Timer callback will stop the wait loop we are about to start

    CTimerTest* timer = CTimerTest::NewL(this);

    CleanupStack::PushL(timer);

    timer->StartTimer(KTimerCallbackPeriod1); //5

    // Start the wait loop

    iWait.Start();

    // Wait loop stopped

    CleanupStack::PopAndDestroy(timer);

    CleanupStack::PopAndDestroy(mediaUser3);   

    CleanupStack::PopAndDestroy(&attributes);

    }

void T_CGlxGarbageCollector::T_CGlxGarbageCollector_Cleanup_SubTest1L(  )

    {    

    // Create media users

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    EUNIT_PRINT(_L("Title and Subtitle attributes wanted by mediauser1"));

    attributes.AppendL(KMPXMediaGeneralTitle);

    attributes.AppendL(KMPXMediaGeneralSubTitle);

    CGlxMediaUserTest* mediaUser1 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser1);

    EUNIT_PRINT(_L("All media in cache1 used by mediauser1"));

    CGlxCache* cache1 = iCaches[0];

    AddMediaUserToCacheMediasL(*cache1, *mediaUser1);

    EUNIT_PRINT(_L("System Item attribute wanted by mediauser2"));

    attributes.Reset();

    attributes.AppendL(KGlxMediaGeneralSystemItem);

    CGlxMediaUserTest* mediaUser2 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser2);

    EUNIT_PRINT(_L("Media1 in cache2 used by mediauser2"));

    CGlxCache* cache2 = iCaches[1];

    AddMediaUserToMediaL(*cache2, 0, *mediaUser2);

    EUNIT_PRINT(_L("Thumbnail attribute wanted by mediauser3"));

    attributes.Reset();

    attributes.AppendL(KMPXMediaGeneralThumbnail1);

    CGlxMediaUserTest* mediaUser3 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser3);

    EUNIT_PRINT(_L("Title attribute wanted by mediauser4"));

    attributes.Reset();

    attributes.AppendL(KMPXMediaGeneralTitle);

    CGlxMediaUserTest* mediaUser4 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser4);

    EUNIT_PRINT(_L("All media in cache3 used by mediauser3 and mediauser4"));

    CGlxCache* cache3 = iCaches[2];

    AddMediaUserToCacheMediasL(*cache3, *mediaUser3);

    AddMediaUserToCacheMediasL(*cache3, *mediaUser4);

    // Cleanup

    EUNIT_PRINT(_L("Cleanup"));

    iCGlxGarbageCollector->CleanupL();

    EUNIT_PRINT(_L("Cleanup DONE!!"));

    // Timer callback will stop the wait loop we are about to start

    CTimerTest* timer = CTimerTest::NewL(this);

    CleanupStack::PushL(timer);

    timer->StartTimer(KTimerCallbackPeriod1); //5

    // Start the wait loop

    iWait.Start();

    // Wait loop stopped

    CleanupStack::PopAndDestroy(timer);

    // Garbage collector should have cleaned up once

    EUNIT_PRINT(_L("Check remaining media in cache1"));

    EUNIT_ASSERT_DESC(cache1->Count() == 3, "Remaining media should be 3");

    // Create helper class

    T_CacheTestHelpers cache1Helper(cache1);

    EUNIT_PRINT(_L("Check remaining attributes for media1 in cache1"));

    CGlxMedia* media1Cache1 = cache1Helper.ItemPool()[0];

    CheckCache1MediaAttributes(*media1Cache1, 2, ETrue, ETrue, EFalse);

    CheckCache1MediaErrors(*media1Cache1, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media2 in cache1"));

    CGlxMedia* media2Cache1 = cache1Helper.ItemPool()[1];

    CheckCache1MediaAttributes(*media2Cache1, 1, EFalse, EFalse, EFalse, ETrue);

    CheckCache1MediaErrors(*media2Cache1, ETrue, ETrue, ETrue, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media3 in cache1"));

    CGlxMedia* media3Cache1 = cache1Helper.ItemPool()[2];

    CheckCache1MediaAttributes(*media3Cache1, 1, EFalse, EFalse, EFalse, ETrue);

    CheckCache1MediaErrors(*media3Cache1, ETrue, ETrue, EFalse, EFalse);

    EUNIT_PRINT(_L("Check remaining media in cache2"));

    EUNIT_ASSERT_DESC(cache2->Count() == 1, "Remaining media should be 1");

    // Create helper class

    T_CacheTestHelpers cache2Helper(cache2);

    EUNIT_PRINT(_L("Check remaining attributes for media1 in cache2"));

    CGlxMedia* media1Cache2 = cache2Helper.ItemPool()[0];

    CheckCache2MediaAttributes(*media1Cache2, 1, EFalse, EFalse, ETrue);

    CheckCache2MediaErrors(*media1Cache2, EFalse);

    EUNIT_PRINT(_L("Check remaining media in cache3"));

    EUNIT_ASSERT_DESC(cache3->Count() == 4, "Remaining media should be 4");

    // Create helper class

    T_CacheTestHelpers cache3Helper(cache3);

    EUNIT_PRINT(_L("Check remaining attributes for media1 in cache3"));

    CGlxMedia* media1Cache3 = cache3Helper.ItemPool()[0];

    CheckCache3MediaAttributes(*media1Cache3, 2, ETrue, ETrue, EFalse, EFalse);

    CheckCache3MediaErrors(*media1Cache3, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media2 in cache3"));

    CGlxMedia* media2Cache3 = cache3Helper.ItemPool()[1];

    CheckCache3MediaAttributes(*media2Cache3, 1, EFalse, ETrue, EFalse, EFalse);

    CheckCache3MediaErrors(*media2Cache3, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media3 in cache3"));

    CGlxMedia* media3Cache3 = cache3Helper.ItemPool()[2];

    CheckCache3MediaAttributes(*media3Cache3, 1, EFalse, ETrue, EFalse, EFalse);

    CheckCache3MediaErrors(*media3Cache3, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media4 in cache3"));

    CGlxMedia* media4Cache3 = cache3Helper.ItemPool()[3];

    CheckCache3MediaAttributes(*media4Cache3, 2, EFalse, ETrue, EFalse, EFalse, ETrue);

    CheckCache3MediaErrors(*media4Cache3, ETrue, ETrue, EFalse, EFalse, EFalse);

    CleanupStack::PopAndDestroy(mediaUser4);

    CleanupStack::PopAndDestroy(mediaUser3);

    CleanupStack::PopAndDestroy(mediaUser2);

    CleanupStack::PopAndDestroy(mediaUser1);

    CleanupStack::PopAndDestroy(&attributes);

    }

void T_CGlxGarbageCollector::T_CGlxGarbageCollector_Cleanup_SubTest2L(  )

    {

    // Create media users

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    EUNIT_PRINT(_L("Title and Subtitle attributes wanted by mediauser1"));

    attributes.AppendL(KMPXMediaGeneralTitle);

    attributes.AppendL(KMPXMediaGeneralSubTitle);

    CGlxMediaUserTest* mediaUser1 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser1);

    EUNIT_PRINT(_L("All media in cache1 used by mediauser1"));

    CGlxCache* cache1 = iCaches[0];

    AddMediaUserToCacheMediasL(*cache1, *mediaUser1);

    EUNIT_PRINT(_L("System Item attribute wanted by mediauser2"));

    attributes.Reset();

    attributes.AppendL(KGlxMediaGeneralSystemItem);

    CGlxMediaUserTest* mediaUser2 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser2);

    EUNIT_PRINT(_L("Media1 in cache2 used by mediauser2"));

    CGlxCache* cache2 = iCaches[1];

    AddMediaUserToMediaL(*cache2, 0, *mediaUser2);

    EUNIT_PRINT(_L("Thumbnail attribute wanted by mediauser3"));

    attributes.Reset();

    attributes.AppendL(KMPXMediaGeneralThumbnail1);

    CGlxMediaUserTest* mediaUser3 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser3);

    EUNIT_PRINT(_L("Title attribute wanted by mediauser4"));

    attributes.Reset();

    attributes.AppendL(KMPXMediaGeneralTitle);

    CGlxMediaUserTest* mediaUser4 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser4);

    EUNIT_PRINT(_L("All media in cache3 used by mediauser3 and mediauser4"));

    CGlxCache* cache3 = iCaches[2];

    AddMediaUserToCacheMediasL(*cache3, *mediaUser3);

    AddMediaUserToCacheMediasL(*cache3, *mediaUser4);

    // Cleanup

    EUNIT_PRINT(_L("Cleanup"));

    iCGlxGarbageCollector->CleanupL();

    iGarbageCollectorTest = this;

    // Timer callback will stop the wait loop we are about to start

    CTimerTest* timer = CTimerTest::NewL(this);

    CleanupStack::PushL(timer);

    timer->StartTimer(KTimerCallbackPeriod1);

    // Start the wait loop

    iWait.Start();

    // Wait loop stopped

    CleanupStack::PopAndDestroy(timer);

    // Garbage collector should have cleaned up twice

    // Second round caused by updated media

    EUNIT_PRINT(_L("Check remaining media in cache1"));

    EUNIT_ASSERT_DESC(cache1->Count() == 3, "Remaining media should be 3");

    // Create helper class

    T_CacheTestHelpers cache1Helper(cache1);

    EUNIT_PRINT(_L("Check remaining attributes for media1 in cache1"));

    CGlxMedia* media1Cache1 = cache1Helper.ItemPool()[0];

    CheckCache1MediaAttributes(*media1Cache1, 2, ETrue, ETrue, EFalse);

    CheckCache1MediaErrors(*media1Cache1, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media2 in cache1"));

    CGlxMedia* media2Cache1 = cache1Helper.ItemPool()[1];

    CheckCache1MediaAttributes(*media2Cache1, 1, EFalse, EFalse, EFalse, ETrue);

    CheckCache1MediaErrors(*media2Cache1, ETrue, ETrue, ETrue, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media3 in cache1"));

    CGlxMedia* media3Cache1 = cache1Helper.ItemPool()[2];

    CheckCache1MediaAttributes(*media3Cache1, 1, EFalse, EFalse, EFalse, ETrue);

    CheckCache1MediaErrors(*media3Cache1, ETrue, ETrue, EFalse, EFalse);

    EUNIT_PRINT(_L("Check remaining media in cache2"));

    EUNIT_ASSERT_DESC(cache2->Count() == 1, "Remaining media should be 1");

    // Create helper class

    T_CacheTestHelpers cache2Helper(cache2);

    EUNIT_PRINT(_L("Check remaining attributes for media1 in cache2"));

    CGlxMedia* media1Cache2 = cache2Helper.ItemPool()[0];

    CheckCache2MediaAttributes(*media1Cache2, 1, EFalse, EFalse, ETrue);

    CheckCache2MediaErrors(*media1Cache2, EFalse);

    EUNIT_PRINT(_L("Check remaining media in cache3"));

    EUNIT_ASSERT_DESC(cache3->Count() == 4, "Remaining media should be 4");

    // Create helper class

    T_CacheTestHelpers cache3Helper(cache3);

    EUNIT_PRINT(_L("Check remaining attributes for media1 in cache3"));

    CGlxMedia* media1Cache3 = cache3Helper.ItemPool()[0];

    CheckCache3MediaAttributes(*media1Cache3, 2, ETrue, ETrue, EFalse, EFalse);

    CheckCache3MediaErrors(*media1Cache3, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media2 in cache3"));

    CGlxMedia* media2Cache3 = cache3Helper.ItemPool()[1];

    CheckCache3MediaAttributes(*media2Cache3, 1, EFalse, ETrue, EFalse, EFalse);

    CheckCache3MediaErrors(*media2Cache3, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media3 in cache3"));

    CGlxMedia* media3Cache3 = cache3Helper.ItemPool()[2];

    CheckCache3MediaAttributes(*media3Cache3, 1, EFalse, ETrue, EFalse, EFalse);

    CheckCache3MediaErrors(*media3Cache3, EFalse);

    EUNIT_PRINT(_L("Check remaining attributes for media4 in cache3"));

    CGlxMedia* media4Cache3 = cache3Helper.ItemPool()[3];

    CheckCache3MediaAttributes(*media4Cache3, 2, EFalse, ETrue, EFalse, EFalse, ETrue);

    CheckCache3MediaErrors(*media4Cache3, ETrue, ETrue, EFalse, EFalse, EFalse);

    CleanupStack::PopAndDestroy(mediaUser4);

    CleanupStack::PopAndDestroy(mediaUser3);

    CleanupStack::PopAndDestroy(mediaUser2);

    CleanupStack::PopAndDestroy(mediaUser1);

    CleanupStack::PopAndDestroy(&attributes);

    }

void T_CGlxGarbageCollector::T_CGlxGarbageCollector_Cleanup_SubTest3L(  )

    {

    // Create media users

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    EUNIT_PRINT(_L("Title and Subtitle attributes wanted by mediauser1"));

    attributes.AppendL(KMPXMediaGeneralTitle);

    attributes.AppendL(KMPXMediaGeneralSubTitle);

    CGlxMediaUserTest* mediaUser1 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser1);

    EUNIT_PRINT(_L("All media in cache1 used by mediauser1"));

    CGlxCache* cache1 = iCaches[0];

    AddMediaUserToCacheMediasL(*cache1, *mediaUser1);

    EUNIT_PRINT(_L("System Item attribute wanted by mediauser2"));

    attributes.Reset();

    attributes.AppendL(KGlxMediaGeneralSystemItem);

    CGlxMediaUserTest* mediaUser2 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser2);

    EUNIT_PRINT(_L("Media1 in cache2 used by mediauser2"));

    CGlxCache* cache2 = iCaches[1];

    AddMediaUserToMediaL(*cache2, 0, *mediaUser2);

    EUNIT_PRINT(_L("Thumbnail attribute wanted by mediauser3"));

    attributes.Reset();

    attributes.AppendL(KMPXMediaGeneralThumbnail1);

    CGlxMediaUserTest* mediaUser3 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser3);

    EUNIT_PRINT(_L("Title attribute wanted by mediauser4"));

    attributes.Reset();

    attributes.AppendL(KMPXMediaGeneralTitle);

    CGlxMediaUserTest* mediaUser4 = CGlxMediaUserTest::NewL(attributes, *this);

    CleanupStack::PushL(mediaUser4);

    EUNIT_PRINT(_L("All media in cache3 used by mediauser3 and mediauser4"));

    CGlxCache* cache3 = iCaches[2];

    AddMediaUserToCacheMediasL(*cache3, *mediaUser3);

    AddMediaUserToCacheMediasL(*cache3, *mediaUser4);