/*

* Copyright (c) 2008-2009 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:  

 *

*/

//  CLASS HEADER

#include "t_glxlogging.h"

//  EXTERNAL INCLUDES

#include <EUnitMacros.h>

#include <EUnitDecorators.h>

//  INTERNAL INCLUDES

#include "glxlogger.h"

#include "glxlogchunk.h"

// CONSTRUCTION

T_GlxLogging* T_GlxLogging::NewL()

    {

    T_GlxLogging* self = T_GlxLogging::NewLC();

    CleanupStack::Pop();

    return self;

    }

T_GlxLogging* T_GlxLogging::NewLC()

    {

    T_GlxLogging* self = new( ELeave ) T_GlxLogging;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

T_GlxLogging::~T_GlxLogging()

    {

    }

// Default constructor

T_GlxLogging::T_GlxLogging()

    {

    }

// Second phase construct

void T_GlxLogging::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void T_GlxLogging::SetupL()

    {

    }

void T_GlxLogging::Teardown()

    {

    }

// local stub version of RDebug

TPtrC8 gPrintBuffer;

EXPORT_C void RDebug::RawPrint( const TDesC8& aDes )

	{

	gPrintBuffer.Set( aDes );

	}

_LIT8( KStrContents, "abcdefghijklmnopqrstuwxyz" );

void T_GlxLogging::T_TestWithoutChunkL()

    {

    // make a print

    _LIT8( KPrintStr, "FooBar");

    GlxLogger::WriteFormat( KPrintStr );

	// check it went through to RDebug

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr(), gPrintBuffer, "test that strings match");

	// test variables

    _LIT8( KPrintStr2, "FooBar %d,%.1f");

    _LIT8( KPrintStr2Result, "FooBar 1,2.5");

    GlxLogger::WriteFormat( KPrintStr2, 1, 2.45 );

	// check it went through to RDebug

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr2Result(), gPrintBuffer, "test that strings match");

	// test buffer overflow, 300 chars long buffer

	HBufC8* bigbuffer = HBufC8::NewL( 300 );

	TPtr8 ptr = bigbuffer->Des();

	for( TInt i = 0; i < 300; i++ )

		{

		TInt index = (i % KStrContents().Length() );

		TChar ch = KStrContents()[ index ];

		ptr.Append( ch );

		}

	// write big buffer alone

    GlxLogger::WriteFormat( *bigbuffer );

    // take a ptr to verify the content

    TPtr8 check = bigbuffer->Des();

    check.SetLength( 256 );

    EUNIT_ASSERT_EQUALS_DESC( check, gPrintBuffer, "test that strings match");

    // with data

    GlxLogger::WriteFormat( *bigbuffer, 1, 2, 3 );

    EUNIT_ASSERT_EQUALS_DESC( check, gPrintBuffer, "test that strings match");

	// release the buffer

	delete bigbuffer;

    }

// these are copied from glxlogchunk.cpp

// name for chunk 1

_LIT( KLogChunk1Name, "MC_Photos_Logchunk1" );

// name for chunk 2

_LIT( KLogChunk2Name, "MC_Photos_Logchunk2" );

// local helper to read a TPtrC from memory

inline TPtrC8 ReadTPtrC( TUint8*& aAddr )

	{

	TInt32* int_ptr = reinterpret_cast< TInt32* >( aAddr );

	// read size

	TInt32 size = *int_ptr;

    // adjust given addres and create the TPtrC

    aAddr += sizeof( TInt32 );

	TPtrC8 des( aAddr, size );

	// then adjust address to point to the next byte after this descriptor 

	aAddr += size;

	return des;

	}

void T_GlxLogging::T_TestWithChunk1L()

	{

	// create the chunks with the manager

	RGlxLogManager manager;

	manager.CreateL();

    // make a print

    _LIT8( KPrintStr, "FooBar");

    GlxLogger::WriteFormat( KPrintStr );

	// open chunk1 in read only

	RGlxLogUtility chunk;

	TInt err = chunk.Open( KLogChunk1Name(), ETrue );

    EUNIT_ASSERT_EQUALS_DESC( KErrNone, err, "no error in chunk open");

	// check that the descriptor is really there

	// read first descriptor

	TUint8* addres =  chunk.BaseAddress();

	TPtrC8 des = ReadTPtrC( addres );

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr().Size(), des.Size(), "all bytes written");

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr(), des, "data matches");

    // make another print

    _LIT8( KPrintStr2, "FooBar %d, %.2f");

    _LIT8( KPrintStr2Result, "FooBar 99, 1.23");

    GlxLogger::WriteFormat( KPrintStr2, 99, 1.23 );

	// now we should have two descriptors there

	addres =  chunk.BaseAddress();

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr(), ReadTPtrC( addres ), "descriptor 1 matches");

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr2Result(), ReadTPtrC( addres ), "descriptor 2 matches");

	manager.Release();

	}

// second thread function

_LIT8( KPrintStrThread2, "T2 FooBar");

_LIT8( KPrintStr2Thread2, "T2 %d FooBar %.4f");

_LIT8( KPrintStr2Thread2Verify, "T2 -987 FooBar 0.0012");

TInt SecondThread( TAny* )

	{

    // make a print

    GlxLogger::WriteFormat( KPrintStrThread2 );

    // make another print

    GlxLogger::WriteFormat( KPrintStr2Thread2(), -987, 0.0012 );

	// signal that we are done

	RThread::Rendezvous( KErrNone );

	return 0;

	}

void T_GlxLogging::T_TestWithBothChunksL()

	{

	// create the chunks with the manager

	RGlxLogManager manager;

	manager.CreateL();

    // make a print from this thread

    _LIT8( KPrintStr3, "T1 FooBar");

    GlxLogger::WriteFormat( KPrintStr3 );

	// create another thread to write the log entries

	RThread thread2;

	User::LeaveIfError( 

		thread2.Create( _L("SecondThread"), &SecondThread, 1000, NULL, NULL ) );

	// request status to sync the test

	TRequestStatus requestStatus;

	// logon to the other thread

	thread2.Rendezvous( requestStatus );

	// run the created thread

	thread2.Resume();

	// wait untill the thread is complete

	User::WaitForRequest( requestStatus );

    // make another print from this thread

    _LIT8( KPrintStr4, "T1 FooBar %.4f %d,");

    _LIT8( KPrintStr4Verify, "T1 FooBar 0.0012 -11,");

    GlxLogger::WriteFormat( KPrintStr4(), 0.0012, -11 );

	// validate both the chunks

	// open chunk1 in read only

	RGlxLogUtility chunk1;

	TInt err = chunk1.Open( KLogChunk1Name(), ETrue );

    EUNIT_ASSERT_EQUALS_DESC( KErrNone, err, "no error in chunk open");

	// check that the descriptor is really there

	// read first descriptor

	TUint8* addres =  chunk1.BaseAddress();

	// we should have two descriptors in chunk 1

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr3(), ReadTPtrC( addres ), "descriptor 1 matches");

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr4Verify(), ReadTPtrC( addres ), "descriptor 2 matches");

	// open chunk2 in read only

	RGlxLogUtility chunk2;

	err = chunk2.Open( KLogChunk2Name(), ETrue );

    EUNIT_ASSERT_EQUALS_DESC( KErrNone, err, "no error in chunk open");

	// check that the descriptor is really there

	// read first descriptor

	addres =  chunk2.BaseAddress();

	// we should have two descriptors in chunk 2

    EUNIT_ASSERT_EQUALS_DESC( KPrintStrThread2(), ReadTPtrC( addres ), "descriptor 1 matches");

    EUNIT_ASSERT_EQUALS_DESC( KPrintStr2Thread2Verify(), ReadTPtrC( addres ), "descriptor 2 matches");

	manager.Release();

	}

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    T_GlxLogging,

    "Test suite for logging",

    "UNIT" )

EUNIT_TEST(

    "Test printing to RDebug",

    "GlxLogger",

    "WriteFormat",

    "FUNCTIONALITY",

    SetupL, T_TestWithoutChunkL, Teardown )

EUNIT_TEST(

    "Test printing to chunk 1",

    "GlxLogger",

    "WriteFormat",

    "FUNCTIONALITY",

    SetupL, T_TestWithChunk1L, Teardown )

EUNIT_TEST(

    "Test printing to chunk 2",

    "GlxLogger",

    "WriteFormat",

    "FUNCTIONALITY",

    SetupL, T_TestWithBothChunksL, Teardown )

EUNIT_END_TEST_TABLE

//  END OF FILE