// Copyright (c) 1999-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:

// TBITFLAGS.CPP

// 

//

#include "T_BitFlags.h"

// System includes

#include <e32test.h>

// Literal constants

_LIT(KTestTitle, "TestBitFlags");

RTest TheTest(KTestTitle);

void TestBitFlags::TestSetAll()

	{

	iTestFlags.SetAll();

	}

void TestBitFlags::TestClearAll()

	{

	iTestFlags.ClearAll();

	}

void TestBitFlags::TestSetL(TInt aColor)

	{

	iTestFlags.Set(aColor);

	if	(!(iTestFlags.IsSet(aColor)))

		User::Leave(KErrGeneral);

	}

void TestBitFlags::TestClearL(TInt aColor)

	{

	iTestFlags.Clear(aColor);

	if	(iTestFlags.IsSet(aColor))

		User::Leave(KErrGeneral);

	}

void TestBitFlags::TestAssign(TInt aColor, TBool aSetOrClear)

	{

	iTestFlags.Assign(aColor, aSetOrClear);

	}

void TestBitFlags::TestToggleL(TInt aColor)

	{

	TBool isSet = iTestFlags.IsSet(aColor);

	iTestFlags.Toggle(aColor);

	if	(isSet == iTestFlags.IsSet(aColor))

		User::Leave(KErrGeneral);

	}

TBool TestBitFlags::TestOperator1(TInt aColor) //testing operator []

	{

	return iTestFlags.operator[](aColor);

	}

void TestBitFlags::TestOperator2() // test operator =

	{

	iFlagA.Set(TestBitFlags::EBlue);

	iFlagB = iFlagA;

	TheTest(iFlagB == iFlagA);

	iFlagB.Set(TestBitFlags::ERed);

	TheTest(!(iFlagB == iFlagA));

	}

void TestBitFlags::TestOperator3() //test operator ==

	{

	iFlagA.Set(TestBitFlags::EBlue);

	iFlagB.Set(TestBitFlags::EBlue);

	TheTest(iFlagA == iFlagB);

	iFlagB.Set(TestBitFlags::ERed);

	TheTest(!(iFlagB == iFlagA));

	}

TBool TestBitFlags::TestIsSet(TInt aColor)

	{

	return iTestFlags.IsSet(aColor);

	}

TBool TestBitFlags::TestIsClear(TInt aColor)

	{

	return iTestFlags.IsClear(aColor);

	}

TInt TestBitFlags::TestValue()

	{

	return iTestFlags.Value();

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0468

@SYMTestCaseDesc        Tests the behaviour of bits

@SYMTestPriority        High

@SYMTestActions         Tests for bits by setting and clearing

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void DoTest1()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0468 Pure Set and Clear and related functions only "));

	TestBitFlags test;

	TBool checkTestFlags;

	TInt  checkValue;

	TRAPD(errCode, test.TestSetL(TestBitFlags::EBlue));

	TheTest(errCode==KErrNone);

	checkTestFlags = test.TestIsSet(TestBitFlags::EBlue); //expect 1

	checkValue = test.TestValue(); //expect 1 (hex)

	TheTest(checkTestFlags == 1);

	TheTest(checkValue == 1);

	TRAP(errCode, test.TestSetL(TestBitFlags::EGreen));

	TheTest(errCode==KErrNone);

	checkTestFlags = test.TestIsSet(TestBitFlags::EGreen); //expect 4

	TheTest(checkTestFlags == 4);

	checkTestFlags = test.TestIsClear(TestBitFlags::EGreen); //expect 0 - means it hasnt been cleared

	checkValue = test.TestValue(); //expect 5 (hex)

	TheTest(checkTestFlags == 0);

	TheTest(checkValue == 5);

	TRAP(errCode, test.TestSetL(TestBitFlags::EYellow));

	TheTest(errCode==KErrNone);

	checkTestFlags = test.TestIsSet(TestBitFlags::EYellow); //expect 8

	checkValue = test.TestValue(); //expect d (hex)

	TheTest(checkTestFlags == 8);

	TheTest(checkValue == 13);

	test.TestClearL(TestBitFlags::EGreen);

	checkTestFlags = test.TestIsClear(TestBitFlags::EGreen); //expect 1

	checkValue = test.TestValue(); //expect 9 (hex)

	TheTest(checkTestFlags == 1);

	TheTest(checkValue == 9);

	checkTestFlags = test.TestIsClear(TestBitFlags::ERed); //expect 1 - means it has been cleared

	checkValue = test.TestValue(); //expect 9 (hex)

	TheTest(checkTestFlags == 1);

	TheTest(checkValue == 9);

	test.TestSetAll();

	checkTestFlags = test.TestIsSet(TestBitFlags::EBlue);

	TheTest(checkTestFlags == 1);

	checkTestFlags = test.TestIsSet(TestBitFlags::ERed);

	TheTest(checkTestFlags == 2);

	checkTestFlags = test.TestIsSet(TestBitFlags::EGreen);

	TheTest(checkTestFlags == 4);

	checkTestFlags = test.TestIsSet(TestBitFlags::EYellow);

	TheTest(checkTestFlags == 8);

	checkTestFlags = test.TestIsSet(TestBitFlags::EPurple);

	TheTest(checkTestFlags == 16);

	checkTestFlags = test.TestIsSet(TestBitFlags::EBlack);

	TheTest(checkTestFlags == 32);

	checkTestFlags = test.TestIsSet(TestBitFlags::EWhite);

	TheTest(checkTestFlags == 64);

	checkTestFlags = test.TestIsSet(TestBitFlags::EGrey);

	TheTest(checkTestFlags == 128);

	checkValue = test.TestValue(); //expect 0xffffffff (hex)

	TheTest(checkValue == -1);

	test.TestClearL(TestBitFlags::EBlue);

	checkTestFlags = test.TestIsClear(TestBitFlags::EBlue);

	TheTest(checkTestFlags == 1);

	test.TestClearL(TestBitFlags::ERed);

	checkTestFlags = test.TestIsClear(TestBitFlags::ERed);

	TheTest(checkTestFlags == 1);

	test.TestClearL(TestBitFlags::EGreen);

	checkTestFlags = test.TestIsClear(TestBitFlags::EGreen);

	TheTest(checkTestFlags == 1);

	test.TestClearL(TestBitFlags::EYellow);

	checkTestFlags = test.TestIsClear(TestBitFlags::EYellow);

	TheTest(checkTestFlags == 1);

	test.TestClearL(TestBitFlags::EPurple);

	checkTestFlags = test.TestIsClear(TestBitFlags::EPurple);

	TheTest(checkTestFlags == 1);

	test.TestClearL(TestBitFlags::EBlack);

	checkTestFlags = test.TestIsClear(TestBitFlags::EBlack);

	TheTest(checkTestFlags == 1);

	test.TestClearL(TestBitFlags::EWhite);

	checkTestFlags = test.TestIsClear(TestBitFlags::EWhite);

	TheTest(checkTestFlags == 1);

	test.TestClearL(TestBitFlags::EGrey);

	checkTestFlags = test.TestIsClear(TestBitFlags::EGrey);

	TheTest(checkTestFlags == 1);

	checkValue = test.TestValue(); //expect 0xffffff00

	TheTest(checkValue == -256);

	test.TestClearAll();

	checkValue = test.TestValue();

	TheTest(checkValue ==0);

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0469

@SYMTestCaseDesc        Tests the behaviour of bits

@SYMTestPriority        High

@SYMTestActions         Tests for bits by reading them back (assign function)

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void DoTest2()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0469 Assign function "));

	TestBitFlags test;

	TBool checkTestFlags;

	TInt checkValue;

	test.TestAssign(TestBitFlags::ERed, 1);

	checkTestFlags = test.TestIsSet(TestBitFlags::ERed); //expect 2

	checkValue = test.TestValue(); //expect 2

	TheTest(checkTestFlags == 2);

	TheTest(checkValue == 2);

	test.TestAssign(TestBitFlags::EWhite, 1);

	checkTestFlags = test.TestIsSet(TestBitFlags::EWhite); //expect 64

	checkValue = test.TestValue(); //expect 66

	TheTest(checkTestFlags == 64);

	TheTest(checkValue == 66);

	test.TestAssign(TestBitFlags::ERed, 0);

	checkTestFlags = test.TestIsClear(TestBitFlags::ERed); //expect 1

	checkValue = test.TestValue(); //expect 64

	TheTest(checkTestFlags == 1);

	TheTest(checkValue == 64);

	test.TestAssign(TestBitFlags::ERed, 3); //test anything other than 1 will activate Set function

	checkTestFlags = test.TestIsSet(TestBitFlags::ERed); //expect 2

	checkValue = test.TestValue(); //expect 66

	TheTest(checkTestFlags == 2);

	TheTest(checkValue == 66);

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0470

@SYMTestCaseDesc        Tests the behaviour of bits

@SYMTestPriority        High

@SYMTestActions         Tests for [] operator

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void DoTest3()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0470 operator [] "));

	TestBitFlags test;

	TBool checkTestFlags;

	TRAPD(errCode, test.TestSetL(TestBitFlags::EBlue));

	TheTest(errCode==KErrNone);

	checkTestFlags = test.TestOperator1(TestBitFlags::ERed); //0

	TheTest(checkTestFlags == 0);

	TRAP(errCode, test.TestSetL(TestBitFlags::EYellow));

	TheTest(errCode==KErrNone);

	checkTestFlags = test.TestOperator1(TestBitFlags::EGreen); //0

	TheTest(checkTestFlags == 0);

	checkTestFlags = test.TestOperator1(TestBitFlags::EBlack); //0

	TheTest(checkTestFlags == 0);

	checkTestFlags = test.TestOperator1(TestBitFlags::EYellow); //8

	TheTest(checkTestFlags == 8);

	checkTestFlags = test.TestOperator1(TestBitFlags::EBlue); //1

	TheTest(checkTestFlags == 1);

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0471

@SYMTestCaseDesc        Tests the behaviour of bits

@SYMTestPriority        High

@SYMTestActions         Tests for == operator

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void DoTest4()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0471 Operator== "));

	TestBitFlags test;

	test.TestOperator3();

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0472

@SYMTestCaseDesc        Tests the behaviour of bits

@SYMTestPriority        High

@SYMTestActions         Tests for toggling the value

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void DoTest5()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0472 Toggle "));

	TestBitFlags test;

	TInt checkTestFlags;

	test.TestToggleL(TestBitFlags::EBlue);

	checkTestFlags = test.TestValue();

	TheTest(checkTestFlags == 1);

	test.TestToggleL(TestBitFlags::ERed);

	checkTestFlags = test.TestValue();

	TheTest(checkTestFlags == 3);

	test.TestToggleL(TestBitFlags::EBlue);

	checkTestFlags = test.TestValue();

	TheTest(checkTestFlags == 2);

	test.TestToggleL(TestBitFlags::EGreen);

	checkTestFlags = test.TestValue();

	TheTest(checkTestFlags == 6);

	test.TestToggleL(TestBitFlags::ERed);

	checkTestFlags = test.TestValue();

	TheTest(checkTestFlags == 4);

	test.TestToggleL(TestBitFlags::EGreen);

	checkTestFlags = test.TestValue();

	TheTest(checkTestFlags == 0);

	test.TestToggleL(TestBitFlags::EYellow);

	checkTestFlags = test.TestValue();

	TheTest(checkTestFlags == 8);

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0473

@SYMTestCaseDesc        Tests the behaviour of bits

@SYMTestPriority        High

@SYMTestActions         Tests for assignment operator

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void DoTest6()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0473 Operator= "));

	TestBitFlags test;

	test.TestOperator2();

	}

// TestData

TTestEnum KEnumArray[] =

	{

	ETest1, ETest2, ETest3, ETest4, ETest5, ETest6, ETest7, ETest8,

	ETest9, ETest10, ETest11, ETest12, ETest13, ETest14, ETest15, ETest16,

	ETest17, ETest18, ETest19, ETest20, ETest21, ETest22, ETest23, ETest24,

	ETest25, ETest26, ETest27, ETest28, ETest29, ETest30, ETest31, ETest32

	};

/**

@SYMTestCaseID				SYSLIB-BAFL-CT-3387

@SYMTestCaseDesc			Tests the behaviour of template class when type is an enum.

@SYMTestPriority				High

@SYMTestActions				For each bit test each function in class for when T is an enum.

							It is important that this test includes the MSB bit because enums

							are stored as an unsigned int and the MSB is the signed bit.

@SYMTestExpectedResults		Flags must be set and reset to the expected values

@SYMDEF					DEF102233

*/

void DEF102233()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-3387 Tests for DEF102233 "));

	TInt arrayPos;

	TInt bitPos;

	for(TInt x = 0; x <= 31; x++)

		{

		arrayPos = x;

		bitPos = x;

		// Constructor

		TBitFlagsT<TTestEnum> myBitFlagMSB1(KEnumArray[arrayPos]);

		TheTest(myBitFlagMSB1.IsSet(bitPos));

		// Copy Constructor

		TBitFlagsT<TTestEnum> myBitFlagMSB2(myBitFlagMSB1);

		TheTest(myBitFlagMSB2.IsSet(bitPos));

		// SetAll

		myBitFlagMSB1.SetAll();

		TheTest(myBitFlagMSB1.IsSet(bitPos));

		// ClearAll

		myBitFlagMSB1.ClearAll();

		TheTest(!myBitFlagMSB1.IsSet(bitPos));

		// Set and Clear

		myBitFlagMSB1.Set(bitPos);

		TheTest(myBitFlagMSB1.IsSet(bitPos));

		myBitFlagMSB1.Clear(bitPos);

		TheTest(!myBitFlagMSB1.IsSet(bitPos));

		// Assign

		myBitFlagMSB1.Assign(bitPos, ETrue);

		TheTest(myBitFlagMSB1.IsSet(bitPos));

		myBitFlagMSB1.Assign(bitPos, EFalse);

		TheTest(!myBitFlagMSB1.IsSet(bitPos));

		// Toggle

		myBitFlagMSB1.Toggle(bitPos);

		TheTest(myBitFlagMSB1.IsSet(bitPos));

		myBitFlagMSB1.Toggle(bitPos);

		TheTest(!myBitFlagMSB1.IsSet(bitPos));

		// operator[]

		TheTest(!myBitFlagMSB1[arrayPos]);

		myBitFlagMSB1.Set(bitPos);

		TheTest(myBitFlagMSB1[arrayPos]);

		// operator=

		myBitFlagMSB2 = myBitFlagMSB1;

		TheTest(myBitFlagMSB2[arrayPos]);

		myBitFlagMSB1.Toggle(bitPos);

		myBitFlagMSB2 = myBitFlagMSB1;

		TheTest(!myBitFlagMSB2[arrayPos]);

		// operator==

		TheTest(myBitFlagMSB1 == myBitFlagMSB2);

		myBitFlagMSB1.Toggle(bitPos);

		myBitFlagMSB2.Toggle(bitPos);

		TheTest(myBitFlagMSB1 == myBitFlagMSB2);

		myBitFlagMSB1.Toggle(bitPos);

		TheTest(!(myBitFlagMSB1 == myBitFlagMSB2));

		// IsSet and IsClear

		TheTest(myBitFlagMSB1.IsClear(bitPos));

		myBitFlagMSB1.Toggle(bitPos);

		TheTest(myBitFlagMSB1.IsSet(bitPos));

		// Value and SetValue

		myBitFlagMSB1.ClearAll();

		myBitFlagMSB1.SetValue(KEnumArray[arrayPos]);

		TheTest(myBitFlagMSB1.Value() == KEnumArray[arrayPos]);

		// Value against a signed integer

		TInt signedInteger = KEnumArray[arrayPos];

		TheTest(myBitFlagMSB1.Value() == signedInteger);

		// Value against an unsigned integer

		TUint unsignedInteger = KEnumArray[arrayPos];

		TheTest(myBitFlagMSB1.Value() == unsignedInteger);

		// iFlags

		myBitFlagMSB1.ClearAll();

		myBitFlagMSB1.iFlags = KEnumArray[arrayPos];

		TheTest(myBitFlagMSB1.Value() == KEnumArray[arrayPos]);

		}

	// check MSB was tested

	TheTest(KEnumArray[arrayPos] == ETest32);

	TheTest(bitPos == 31);

	}

/**

@SYMTestCaseID				BASESRVCS-BAFL-CT-4078

@SYMTestCaseDesc			tests the IsSet API for out of bounds index values.

@SYMTestPriority			High

@SYMTestActions				query flag state statinig an index that is out of bound 

@SYMTestExpectedResults		should return EFalse for out of bound values

@SYMDEF						DEF130663

*/

void DEF130663()

	{

	// type is considered as an enum here 

	TheTest.Next(_L(" @SYMTestCaseID:BASESRVCS-BAFL-CT-4078 Tests for DEF130663 "));

	TInt arrayPos;

	TInt bitPos;

	for(TInt x = 0; x <= 31; x++)

		{

		arrayPos = x;

		bitPos = x;

		// Constructor

		TBitFlagsT<TTestEnum> myBitFlag(KEnumArray[arrayPos]);

		TheTest(myBitFlag.IsSet(bitPos));

		//clear all and set one paricular bit

		myBitFlag.ClearAll();

		myBitFlag.Set(bitPos);

		// check "out of bounds" values as well

		// expected behavior is that for all out of bound values the 

		// result should be EFalse for IsSet("out of bounds") call.

		// IsSet and all the functions directly calling IsSet are being tested here

		// this test in conjuction with the other cts listed here 

		// should be sufficient to validate the fix

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

			{

			if(i==x)

				{

				TheTest(myBitFlag.IsSet(i));

				TheTest(!myBitFlag.IsClear(i));

				TheTest(myBitFlag[i]);

				}

			else

				{

				TheTest(!myBitFlag.IsSet(i));

				TheTest(myBitFlag.IsClear(i));

				TheTest(!myBitFlag[i]);

				}

			}

		}

	// check MSB was tested

	TheTest(KEnumArray[arrayPos] == ETest32);

	TheTest(bitPos == 31);

	}

void RunTestsL()

	{