/*

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

*

*/

#include <caf/caf.h>

#include <caf/bitset.h>

#include <caf/attribute.h>

#include <s32mem.h>

#include "bitsetstep.h"

const TInt KAttrTop = 10;

using namespace ContentAccess;

CBitsetBaseStep::CBitsetBaseStep(const TDesC& aStepName)

	{

	SetTestStepName(aStepName);

	}

TVerdict CBitsetBaseStep::doTestStepPreambleL()

	{

	return TestStepResult();

	}

TVerdict CBitsetBaseStep::doTestStepPostambleL()

	{

	return TestStepResult();

	}

CBitset* CBitsetBaseStep::GetBitsetLC(const TDesC& aHeader)

	{

	_LIT(KBitCount, "bitcount");

	_LIT(KBit, "bit%02d");

	// Firstly, from the script, get the number of bits to set. If aHeader

	// is "left-", then the bitcount key is "left-bitcount"

	HBufC* buf = HBufC::NewLC(aHeader.Length() + KBitCount().Length());

	TPtr ptr(buf->Des());

	ptr = aHeader;

	ptr.Append(KBitCount());

	TInt bitcount = 0;

	GetIntFromConfig(ConfigSection(), ptr, bitcount);

	INFO_PRINTF3(_L("%S = %d"), &ptr, bitcount);

	// Now, create the bitset

	CBitset* bitset = CBitset::NewLC(bitcount);

	TInt i = 0;

	for (; i < bitcount; ++i)

		{

		TInt bit = 0;

		ptr = aHeader;

		ptr.AppendFormat(KBit, i);

		GetIntFromConfig(ConfigSection(), ptr, bit);

		if (bit)

			{

			bitset->Set(i);

			INFO_PRINTF2(_L("%S is set"), &ptr);

			}

		}

	CleanupStack::Pop(bitset);

	CleanupStack::PopAndDestroy(buf);

	CleanupStack::PushL(bitset);

	return bitset;

	}

/*

 * Step2 performs some basic internal Bitset sanity tests

 *

 */

CBasicBitsetStep::CBasicBitsetStep() 

	: CBitsetBaseStep(KBasicBitsetStep)

	{

	}

//	EIsProtected EIsForwardable EIsModifyable EIsCopyable

TVerdict CBasicBitsetStep::doTestStepL()

	{

	TInt i;

	SetTestStepResult(EPass); // Default result to PASS

	__UHEAP_MARK;

	INFO_PRINTF1(_L("Basic Bitset Test"));

	// Note we must size according to current EAttrTop (attribute.h)

	INFO_PRINTF1(_L("Creating set1..."));

	CBitset *set1 = CBitset::NewLC((TAttribute) KAttrTop); // on cleanup

	// check that all the bits are initially not set

	for(i = 0; i < KAttrTop; i++)

		{

		if (set1->IsSet(i))

			{

			INFO_PRINTF1(_L("Bitset::NewLC() test failed."));

			SetTestStepResult(EFail);

			}

		}

	INFO_PRINTF1(_L("Performing single bit set/test..."));

	set1->Set(EIsForwardable);

	// check that only EIsForwardable is set

	for(i = 0; i < KAttrTop; i++)

		{

		if (set1->IsSet(i) && i != EIsForwardable)

			{

			INFO_PRINTF1(_L("Single test/set(1) test failed."));

			SetTestStepResult(EFail);

			}

		}

	if (!set1->IsSet(EIsForwardable))

		{

		INFO_PRINTF1(_L("Single test/set(2) failed."));

		SetTestStepResult(EFail);

		}

	set1->Unset(EIsForwardable);

	// check that none of the bits are set

	for(i = 0; i < KAttrTop; i++)

		{

		if (set1->IsSet(i))

			{

			INFO_PRINTF1(_L("Single test/set(3) failed."));

			SetTestStepResult(EFail);

			}

		}

	INFO_PRINTF1(_L("Performing setall tests..."));

	set1->SetAll();

	// check that all bits are set

	for(i = 0; i < KAttrTop; i++)

		{

		if (!set1->IsSet(i))

			{

			INFO_PRINTF1(_L("SetAll test failed."));

			SetTestStepResult(EFail);

			}

		}

	set1->Reset();

	// check all bits are reset

	for(i = 0; i < KAttrTop; i++)

		{

		if (set1->IsSet(i))

			{

			INFO_PRINTF1(_L("Reset test failed."));

			SetTestStepResult(EFail);

			}

		}

	CleanupStack::PopAndDestroy(set1);	

	__UHEAP_MARKEND;

	return TestStepResult();

	}

// --------------------------------------------------------------------------

// This step tests the bitset SetList and IsSetList functions

CBitsetListStep::CBitsetListStep()

	: CBitsetBaseStep(KBitsetListStep)

	{

	}

TVerdict CBitsetListStep::doTestStepL()

	{

	TInt i;

	SetTestStepResult(EPass); 

	__UHEAP_MARK;

	INFO_PRINTF1(_L("Creating set1..."));

	CBitset *set1 = CBitset::NewLC(KAttrTop); 

	INFO_PRINTF1(_L("Performing SetList call"));

	set1->SetListL(2, EIsCopyable, EIsModifyable);

	for(i = 0; i < KAttrTop; i++)

		{

		if (set1->IsSet(i) && i != EIsCopyable && i != EIsModifyable)

			{

			INFO_PRINTF1(_L("SetList(1) failed."));

			SetTestStepResult(EFail);

			}

		}

	if (!set1->IsSet(EIsModifyable) || !set1->IsSet(EIsCopyable))

		{

		INFO_PRINTF1(_L("SetList(2) failed."));

		SetTestStepResult(EFail);

		}

	// Now check the IsSetList call

	INFO_PRINTF1(_L("Performing IsSetList calls"));

	if (!set1->IsSetList(2, EIsCopyable, EIsModifyable))

		{

		INFO_PRINTF1(_L("IsSetList call(3) failed."));

		SetTestStepResult(EFail);

		}

	if (set1->IsSetList(2, EIsProtected, EIsForwardable))

		{

		INFO_PRINTF1(_L("IsSetList call(4) failed."));

		SetTestStepResult(EFail);

		}

	CleanupStack::PopAndDestroy(set1);	

	__UHEAP_MARKEND;

	return TestStepResult();

	}

// --------------------------------------------------------------------------

CBitsetEqualityStep::CBitsetEqualityStep()

	: CBitsetBaseStep(KBitsetEqualityStep)

	{

	}

TVerdict CBitsetEqualityStep::doTestStepL()

	{

	SetTestStepResult(EPass); // Default result to EPass

	__UHEAP_MARK;

	// Get the bitset from the script section

	CBitset* left = GetBitsetLC(_L("left-"));

	CBitset* right = GetBitsetLC(_L("right-"));

	// Now see whether we expect the result to be equal

	TBool equalExpected = EFalse;

	GetIntFromConfig(ConfigSection(), _L("equal"), equalExpected);

	if (equalExpected)

		{

		INFO_PRINTF1(_L("Equality expected"));

		}

	else

		{

		INFO_PRINTF1(_L("Inequality expected"));

		}

	TBool result = (*left == *right);

	if (!result != !equalExpected)

		{

		INFO_PRINTF1(_L("Equality test failed."));

		SetTestStepResult(EFail);

		}

	CleanupStack::PopAndDestroy(2, left);

	__UHEAP_MARKEND;

	return TestStepResult();

	}

// --------------------------------------------------------------------------

CBitsetCopyStep::CBitsetCopyStep()

	: CBitsetBaseStep(KBitsetCopyStep)

	{

	}

TVerdict CBitsetCopyStep::doTestStepL()

	{

	SetTestStepResult(EPass); // Default result to EPass

	__UHEAP_MARK;

	// Get the bitset from the script section

	CBitset* set = GetBitsetLC(KNullDesC);

	// Now, create a copy

	CBitset* copy = CBitset::NewLC(*set);

	// Now check the copy

	if (*set != *copy)

		{

		INFO_PRINTF1(_L("Copy constructor return unequal result."));

		SetTestStepResult(EFail);

		}

	// Now create another bitset of arbitrary length

	CBitset* another = CBitset::NewLC(5);

	// Perform assignment

	*another = *copy;

	// Now check another equals the original set

	if (*set != *another)

		{

		INFO_PRINTF1(_L("operator= returned unequal result."));

		SetTestStepResult(EFail);

		}

	// Now invert another and copy and make sure they are equal

	another->Invert();

	copy->Invert();

	if (*copy != *another)

		{

		INFO_PRINTF1(_L("Invert returned unequal result."));

		SetTestStepResult(EFail);

		}

	// Invert the copy again and ensure it is equal to the original

	copy->Invert();

	if (*set != *copy)

		{

		INFO_PRINTF1(_L("Double invert fails."));

		SetTestStepResult(EFail);

		}

	CleanupStack::PopAndDestroy(3, set);

	__UHEAP_MARKEND;

	return TestStepResult();

	}

// --------------------------------------------------------------------------

CBitsetSerialiseStep::CBitsetSerialiseStep()

	: CBitsetBaseStep(KBitsetSerialiseStep)

	{

	}

TVerdict CBitsetSerialiseStep::doTestStepL()

	{

	SetTestStepResult(EPass); // Default result to EPass

	__UHEAP_MARK;

	// Get the bitset from the script section

	CBitset* set = GetBitsetLC(KNullDesC);

	// Create a buffer stream

	CBufFlat* buf = CBufFlat::NewL(50);

	CleanupStack::PushL(buf);

	RBufWriteStream stream(*buf);

	CleanupClosePushL(stream);

	// call the stream function

	stream << *set;

	CleanupStack::PopAndDestroy(&stream);

	// Now, create an HBufC8 from the stream buf's length, and copy 

	// the stream buffer into this descriptor

	HBufC8* des = HBufC8::NewL(buf->Size());

	TPtr8 ptr(des->Des());

	buf->Read(0, ptr, buf->Size());

	// destroy the buffer

	CleanupStack::PopAndDestroy(buf);

	CleanupStack::PushL(des);

	// Now, stream a new bitset from the descriptor

	CBitset* newset = CBitset::NewLC(5);

	RDesReadStream readstream(*des);

	CleanupClosePushL(readstream);

	readstream >> *newset;

	CleanupStack::PopAndDestroy(&readstream);

	// Now check that the new bitset equals the old one

	if (*set != *newset)

		{

		INFO_PRINTF1(_L("serialisation returned unequal result."));

		SetTestStepResult(EFail);

		}

	CleanupStack::PopAndDestroy(3, set);

	__UHEAP_MARKEND;

	return TestStepResult();

	}

// --------------------------------------------------------------------------

CBitsetPanicStep::CBitsetPanicStep()

	: CBitsetBaseStep(KBitsetPanicStep)

	{

	}

TVerdict CBitsetPanicStep::doTestStepL()

	{

	SetTestStepResult(EPass); // Default result to EPass

	__UHEAP_MARK;

	// Get the bitset from the script section

	CBitset* panic = GetBitsetLC(_L("panic-"));

	// Now see whether we expect the result to be equal

	TInt panictest = -1;

	GetIntFromConfig(ConfigSection(), _L("panictest"), panictest);

	// all of the following cases should panic

	switch(panictest)

		{

	case 1:

		INFO_PRINTF1(_L("IsSet(-1)"));

		panic->IsSet(-1);

		break;

	case 2:

		INFO_PRINTF1(_L("IsSet(MaxBits()+1)"));

		panic->IsSet(panic->MaxBits()+1);

		break;

	case 3:

		INFO_PRINTF1(_L("Set(-1)"));

		panic->Set(-1);

		break;

	case 4:

		INFO_PRINTF1(_L("Set(MaxBits()+1)"));

		panic->Set(panic->MaxBits()+1);

		break;

	case 5:

		INFO_PRINTF1(_L("UnSet(-1)"));

		panic->Unset(-1);

		break;

	case 6:

		INFO_PRINTF1(_L("UnSet(MaxBits()+1)"));

		panic->Unset(panic->MaxBits()+1);

		break;

	default:

		SetTestStepResult(EFail); 

		};

	SetTestStepResult(EFail); 

	CleanupStack::PopAndDestroy(panic);

	__UHEAP_MARKEND;

	return TestStepResult();

	}