sl@0: // Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // TBITFLAGS.CPP
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include "T_BitFlags.h"
sl@0: 
sl@0: // System includes
sl@0: #include <e32test.h>
sl@0: 
sl@0: // Literal constants
sl@0: _LIT(KTestTitle, "TestBitFlags");
sl@0: 
sl@0: RTest TheTest(KTestTitle);
sl@0: 
sl@0: 
sl@0: void TestBitFlags::TestSetAll()
sl@0: 	{
sl@0: 	iTestFlags.SetAll();
sl@0: 	}
sl@0: 
sl@0: void TestBitFlags::TestClearAll()
sl@0: 	{
sl@0: 	iTestFlags.ClearAll();
sl@0: 	}
sl@0: 
sl@0: void TestBitFlags::TestSetL(TInt aColor)
sl@0: 	{
sl@0: 	iTestFlags.Set(aColor);
sl@0: 	if	(!(iTestFlags.IsSet(aColor)))
sl@0: 		User::Leave(KErrGeneral);
sl@0: 	}
sl@0: 
sl@0: void TestBitFlags::TestClearL(TInt aColor)
sl@0: 	{
sl@0: 	iTestFlags.Clear(aColor);
sl@0: 	if	(iTestFlags.IsSet(aColor))
sl@0: 		User::Leave(KErrGeneral);
sl@0: 	}
sl@0: 
sl@0: void TestBitFlags::TestAssign(TInt aColor, TBool aSetOrClear)
sl@0: 	{
sl@0: 	iTestFlags.Assign(aColor, aSetOrClear);
sl@0: 	}
sl@0: 
sl@0: void TestBitFlags::TestToggleL(TInt aColor)
sl@0: 	{
sl@0: 	TBool isSet = iTestFlags.IsSet(aColor);
sl@0: 	iTestFlags.Toggle(aColor);
sl@0: 	if	(isSet == iTestFlags.IsSet(aColor))
sl@0: 		User::Leave(KErrGeneral);
sl@0: 	}
sl@0: 
sl@0: TBool TestBitFlags::TestOperator1(TInt aColor) //testing operator []
sl@0: 	{
sl@0: 	return iTestFlags.operator[](aColor);
sl@0: 	}
sl@0: 
sl@0: void TestBitFlags::TestOperator2() // test operator =
sl@0: 	{
sl@0: 	iFlagA.Set(TestBitFlags::EBlue);
sl@0: 	iFlagB = iFlagA;
sl@0: 	TheTest(iFlagB == iFlagA);
sl@0: 
sl@0: 	iFlagB.Set(TestBitFlags::ERed);
sl@0: 	TheTest(!(iFlagB == iFlagA));
sl@0: 	}
sl@0: 
sl@0: void TestBitFlags::TestOperator3() //test operator ==
sl@0: 	{
sl@0: 	iFlagA.Set(TestBitFlags::EBlue);
sl@0: 	iFlagB.Set(TestBitFlags::EBlue);
sl@0: 	TheTest(iFlagA == iFlagB);
sl@0: 
sl@0: 	iFlagB.Set(TestBitFlags::ERed);
sl@0: 	TheTest(!(iFlagB == iFlagA));
sl@0: 	}
sl@0: 
sl@0: TBool TestBitFlags::TestIsSet(TInt aColor)
sl@0: 	{
sl@0: 	return iTestFlags.IsSet(aColor);
sl@0: 	}
sl@0: 
sl@0: TBool TestBitFlags::TestIsClear(TInt aColor)
sl@0: 	{
sl@0: 	return iTestFlags.IsClear(aColor);
sl@0: 	}
sl@0: 
sl@0: TInt TestBitFlags::TestValue()
sl@0: 	{
sl@0: 	return iTestFlags.Value();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-BAFL-CT-0468
sl@0: @SYMTestCaseDesc        Tests the behaviour of bits
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Tests for bits by setting and clearing
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void DoTest1()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0468 Pure Set and Clear and related functions only "));
sl@0: 	TestBitFlags test;
sl@0: 	TBool checkTestFlags;
sl@0: 	TInt  checkValue;
sl@0: 
sl@0: 	TRAPD(errCode, test.TestSetL(TestBitFlags::EBlue));
sl@0: 	TheTest(errCode==KErrNone);
sl@0: 
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EBlue); //expect 1
sl@0: 	checkValue = test.TestValue(); //expect 1 (hex)
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	TheTest(checkValue == 1);
sl@0: 
sl@0: 	TRAP(errCode, test.TestSetL(TestBitFlags::EGreen));
sl@0: 	TheTest(errCode==KErrNone);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EGreen); //expect 4
sl@0: 	TheTest(checkTestFlags == 4);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EGreen); //expect 0 - means it hasnt been cleared
sl@0: 	checkValue = test.TestValue(); //expect 5 (hex)
sl@0: 	TheTest(checkTestFlags == 0);
sl@0: 	TheTest(checkValue == 5);
sl@0: 
sl@0: 	TRAP(errCode, test.TestSetL(TestBitFlags::EYellow));
sl@0: 	TheTest(errCode==KErrNone);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EYellow); //expect 8
sl@0: 	checkValue = test.TestValue(); //expect d (hex)
sl@0: 	TheTest(checkTestFlags == 8);
sl@0: 	TheTest(checkValue == 13);
sl@0: 
sl@0: 	test.TestClearL(TestBitFlags::EGreen);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EGreen); //expect 1
sl@0: 	checkValue = test.TestValue(); //expect 9 (hex)
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	TheTest(checkValue == 9);
sl@0: 
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::ERed); //expect 1 - means it has been cleared
sl@0: 	checkValue = test.TestValue(); //expect 9 (hex)
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	TheTest(checkValue == 9);
sl@0: 
sl@0: 	test.TestSetAll();
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EBlue);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::ERed);
sl@0: 	TheTest(checkTestFlags == 2);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EGreen);
sl@0: 	TheTest(checkTestFlags == 4);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EYellow);
sl@0: 	TheTest(checkTestFlags == 8);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EPurple);
sl@0: 	TheTest(checkTestFlags == 16);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EBlack);
sl@0: 	TheTest(checkTestFlags == 32);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EWhite);
sl@0: 	TheTest(checkTestFlags == 64);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EGrey);
sl@0: 	TheTest(checkTestFlags == 128);
sl@0: 	checkValue = test.TestValue(); //expect 0xffffffff (hex)
sl@0: 	TheTest(checkValue == -1);
sl@0: 
sl@0: 
sl@0: 	test.TestClearL(TestBitFlags::EBlue);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EBlue);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	test.TestClearL(TestBitFlags::ERed);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::ERed);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	test.TestClearL(TestBitFlags::EGreen);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EGreen);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	test.TestClearL(TestBitFlags::EYellow);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EYellow);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	test.TestClearL(TestBitFlags::EPurple);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EPurple);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	test.TestClearL(TestBitFlags::EBlack);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EBlack);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	test.TestClearL(TestBitFlags::EWhite);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EWhite);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	test.TestClearL(TestBitFlags::EGrey);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::EGrey);
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	checkValue = test.TestValue(); //expect 0xffffff00
sl@0: 	TheTest(checkValue == -256);
sl@0: 
sl@0: 	test.TestClearAll();
sl@0: 	checkValue = test.TestValue();
sl@0: 	TheTest(checkValue ==0);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-BAFL-CT-0469
sl@0: @SYMTestCaseDesc        Tests the behaviour of bits
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Tests for bits by reading them back (assign function)
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void DoTest2()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0469 Assign function "));
sl@0: 	TestBitFlags test;
sl@0: 	TBool checkTestFlags;
sl@0: 	TInt checkValue;
sl@0: 
sl@0: 	test.TestAssign(TestBitFlags::ERed, 1);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::ERed); //expect 2
sl@0: 	checkValue = test.TestValue(); //expect 2
sl@0: 	TheTest(checkTestFlags == 2);
sl@0: 	TheTest(checkValue == 2);
sl@0: 
sl@0: 	test.TestAssign(TestBitFlags::EWhite, 1);
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::EWhite); //expect 64
sl@0: 	checkValue = test.TestValue(); //expect 66
sl@0: 	TheTest(checkTestFlags == 64);
sl@0: 	TheTest(checkValue == 66);
sl@0: 
sl@0: 	test.TestAssign(TestBitFlags::ERed, 0);
sl@0: 	checkTestFlags = test.TestIsClear(TestBitFlags::ERed); //expect 1
sl@0: 	checkValue = test.TestValue(); //expect 64
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	TheTest(checkValue == 64);
sl@0: 
sl@0: 	test.TestAssign(TestBitFlags::ERed, 3); //test anything other than 1 will activate Set function
sl@0: 	checkTestFlags = test.TestIsSet(TestBitFlags::ERed); //expect 2
sl@0: 	checkValue = test.TestValue(); //expect 66
sl@0: 	TheTest(checkTestFlags == 2);
sl@0: 	TheTest(checkValue == 66);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-BAFL-CT-0470
sl@0: @SYMTestCaseDesc        Tests the behaviour of bits
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Tests for [] operator
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void DoTest3()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0470 operator [] "));
sl@0: 
sl@0: 	TestBitFlags test;
sl@0: 	TBool checkTestFlags;
sl@0: 
sl@0: 	TRAPD(errCode, test.TestSetL(TestBitFlags::EBlue));
sl@0: 	TheTest(errCode==KErrNone);
sl@0: 
sl@0: 	checkTestFlags = test.TestOperator1(TestBitFlags::ERed); //0
sl@0: 	TheTest(checkTestFlags == 0);
sl@0: 
sl@0: 	TRAP(errCode, test.TestSetL(TestBitFlags::EYellow));
sl@0: 	TheTest(errCode==KErrNone);
sl@0: 
sl@0: 	checkTestFlags = test.TestOperator1(TestBitFlags::EGreen); //0
sl@0: 	TheTest(checkTestFlags == 0);
sl@0: 
sl@0: 	checkTestFlags = test.TestOperator1(TestBitFlags::EBlack); //0
sl@0: 	TheTest(checkTestFlags == 0);
sl@0: 
sl@0: 	checkTestFlags = test.TestOperator1(TestBitFlags::EYellow); //8
sl@0: 	TheTest(checkTestFlags == 8);
sl@0: 
sl@0: 	checkTestFlags = test.TestOperator1(TestBitFlags::EBlue); //1
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-BAFL-CT-0471
sl@0: @SYMTestCaseDesc        Tests the behaviour of bits
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Tests for == operator
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void DoTest4()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0471 Operator== "));
sl@0: 	TestBitFlags test;
sl@0: 	test.TestOperator3();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-BAFL-CT-0472
sl@0: @SYMTestCaseDesc        Tests the behaviour of bits
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Tests for toggling the value
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void DoTest5()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0472 Toggle "));
sl@0: 	TestBitFlags test;
sl@0: 	TInt checkTestFlags;
sl@0: 
sl@0: 	test.TestToggleL(TestBitFlags::EBlue);
sl@0: 	checkTestFlags = test.TestValue();
sl@0: 	TheTest(checkTestFlags == 1);
sl@0: 
sl@0: 	test.TestToggleL(TestBitFlags::ERed);
sl@0: 	checkTestFlags = test.TestValue();
sl@0: 	TheTest(checkTestFlags == 3);
sl@0: 
sl@0: 	test.TestToggleL(TestBitFlags::EBlue);
sl@0: 	checkTestFlags = test.TestValue();
sl@0: 	TheTest(checkTestFlags == 2);
sl@0: 
sl@0: 	test.TestToggleL(TestBitFlags::EGreen);
sl@0: 	checkTestFlags = test.TestValue();
sl@0: 	TheTest(checkTestFlags == 6);
sl@0: 
sl@0: 	test.TestToggleL(TestBitFlags::ERed);
sl@0: 	checkTestFlags = test.TestValue();
sl@0: 	TheTest(checkTestFlags == 4);
sl@0: 
sl@0: 	test.TestToggleL(TestBitFlags::EGreen);
sl@0: 	checkTestFlags = test.TestValue();
sl@0: 	TheTest(checkTestFlags == 0);
sl@0: 
sl@0: 	test.TestToggleL(TestBitFlags::EYellow);
sl@0: 	checkTestFlags = test.TestValue();
sl@0: 	TheTest(checkTestFlags == 8);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-BAFL-CT-0473
sl@0: @SYMTestCaseDesc        Tests the behaviour of bits
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Tests for assignment operator
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void DoTest6()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0473 Operator= "));
sl@0: 	TestBitFlags test;
sl@0: 	test.TestOperator2();
sl@0: 	}
sl@0: 
sl@0: // TestData
sl@0: 
sl@0: TTestEnum KEnumArray[] =
sl@0: 	{
sl@0: 	ETest1, ETest2, ETest3, ETest4, ETest5, ETest6, ETest7, ETest8,
sl@0: 	ETest9, ETest10, ETest11, ETest12, ETest13, ETest14, ETest15, ETest16,
sl@0: 	ETest17, ETest18, ETest19, ETest20, ETest21, ETest22, ETest23, ETest24,
sl@0: 	ETest25, ETest26, ETest27, ETest28, ETest29, ETest30, ETest31, ETest32
sl@0: 	};
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID				SYSLIB-BAFL-CT-3387
sl@0: @SYMTestCaseDesc			Tests the behaviour of template class when type is an enum.
sl@0: @SYMTestPriority				High
sl@0: @SYMTestActions				For each bit test each function in class for when T is an enum.
sl@0: 							It is important that this test includes the MSB bit because enums
sl@0: 							are stored as an unsigned int and the MSB is the signed bit.
sl@0: @SYMTestExpectedResults		Flags must be set and reset to the expected values
sl@0: @SYMDEF					DEF102233
sl@0: */
sl@0: void DEF102233()
sl@0: 	{
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-3387 Tests for DEF102233 "));
sl@0: 
sl@0: 	TInt arrayPos;
sl@0: 	TInt bitPos;
sl@0: 	for(TInt x = 0; x <= 31; x++)
sl@0: 		{
sl@0: 		arrayPos = x;
sl@0: 		bitPos = x;
sl@0: 
sl@0: 		// Constructor
sl@0: 		TBitFlagsT<TTestEnum> myBitFlagMSB1(KEnumArray[arrayPos]);
sl@0: 		TheTest(myBitFlagMSB1.IsSet(bitPos));
sl@0: 
sl@0: 		// Copy Constructor
sl@0: 		TBitFlagsT<TTestEnum> myBitFlagMSB2(myBitFlagMSB1);
sl@0: 		TheTest(myBitFlagMSB2.IsSet(bitPos));
sl@0: 
sl@0: 		// SetAll
sl@0: 		myBitFlagMSB1.SetAll();
sl@0: 		TheTest(myBitFlagMSB1.IsSet(bitPos));
sl@0: 
sl@0: 		// ClearAll
sl@0: 		myBitFlagMSB1.ClearAll();
sl@0: 		TheTest(!myBitFlagMSB1.IsSet(bitPos));
sl@0: 
sl@0: 		// Set and Clear
sl@0: 		myBitFlagMSB1.Set(bitPos);
sl@0: 		TheTest(myBitFlagMSB1.IsSet(bitPos));
sl@0: 		myBitFlagMSB1.Clear(bitPos);
sl@0: 		TheTest(!myBitFlagMSB1.IsSet(bitPos));
sl@0: 
sl@0: 		// Assign
sl@0: 		myBitFlagMSB1.Assign(bitPos, ETrue);
sl@0: 		TheTest(myBitFlagMSB1.IsSet(bitPos));
sl@0: 		myBitFlagMSB1.Assign(bitPos, EFalse);
sl@0: 		TheTest(!myBitFlagMSB1.IsSet(bitPos));
sl@0: 
sl@0: 		// Toggle
sl@0: 		myBitFlagMSB1.Toggle(bitPos);
sl@0: 		TheTest(myBitFlagMSB1.IsSet(bitPos));
sl@0: 		myBitFlagMSB1.Toggle(bitPos);
sl@0: 		TheTest(!myBitFlagMSB1.IsSet(bitPos));
sl@0: 
sl@0: 		// operator[]
sl@0: 		TheTest(!myBitFlagMSB1[arrayPos]);
sl@0: 		myBitFlagMSB1.Set(bitPos);
sl@0: 		TheTest(myBitFlagMSB1[arrayPos]);
sl@0: 
sl@0: 		// operator=
sl@0: 		myBitFlagMSB2 = myBitFlagMSB1;
sl@0: 		TheTest(myBitFlagMSB2[arrayPos]);
sl@0: 		myBitFlagMSB1.Toggle(bitPos);
sl@0: 		myBitFlagMSB2 = myBitFlagMSB1;
sl@0: 		TheTest(!myBitFlagMSB2[arrayPos]);
sl@0: 
sl@0: 		// operator==
sl@0: 		TheTest(myBitFlagMSB1 == myBitFlagMSB2);
sl@0: 		myBitFlagMSB1.Toggle(bitPos);
sl@0: 		myBitFlagMSB2.Toggle(bitPos);
sl@0: 		TheTest(myBitFlagMSB1 == myBitFlagMSB2);
sl@0: 		myBitFlagMSB1.Toggle(bitPos);
sl@0: 		TheTest(!(myBitFlagMSB1 == myBitFlagMSB2));
sl@0: 
sl@0: 		// IsSet and IsClear
sl@0: 		TheTest(myBitFlagMSB1.IsClear(bitPos));
sl@0: 		myBitFlagMSB1.Toggle(bitPos);
sl@0: 		TheTest(myBitFlagMSB1.IsSet(bitPos));
sl@0: 
sl@0: 		// Value and SetValue
sl@0: 		myBitFlagMSB1.ClearAll();
sl@0: 		myBitFlagMSB1.SetValue(KEnumArray[arrayPos]);
sl@0: 		TheTest(myBitFlagMSB1.Value() == KEnumArray[arrayPos]);
sl@0: 
sl@0: 		// Value against a signed integer
sl@0: 		TInt signedInteger = KEnumArray[arrayPos];
sl@0: 		TheTest(myBitFlagMSB1.Value() == signedInteger);
sl@0: 
sl@0: 		// Value against an unsigned integer
sl@0: 		TUint unsignedInteger = KEnumArray[arrayPos];
sl@0: 		TheTest(myBitFlagMSB1.Value() == unsignedInteger);
sl@0: 
sl@0: 		// iFlags
sl@0: 		myBitFlagMSB1.ClearAll();
sl@0: 		myBitFlagMSB1.iFlags = KEnumArray[arrayPos];
sl@0: 		TheTest(myBitFlagMSB1.Value() == KEnumArray[arrayPos]);
sl@0: 		}
sl@0: 	// check MSB was tested
sl@0: 	TheTest(KEnumArray[arrayPos] == ETest32);
sl@0: 	TheTest(bitPos == 31);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID				BASESRVCS-BAFL-CT-4078
sl@0: @SYMTestCaseDesc			tests the IsSet API for out of bounds index values.
sl@0: @SYMTestPriority			High
sl@0: @SYMTestActions				query flag state statinig an index that is out of bound 
sl@0: @SYMTestExpectedResults		should return EFalse for out of bound values
sl@0: @SYMDEF						DEF130663
sl@0: */
sl@0: void DEF130663()
sl@0: 	{
sl@0: 	// type is considered as an enum here 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:BASESRVCS-BAFL-CT-4078 Tests for DEF130663 "));
sl@0: 
sl@0: 	TInt arrayPos;
sl@0: 	TInt bitPos;
sl@0: 	for(TInt x = 0; x <= 31; x++)
sl@0: 		{
sl@0: 		arrayPos = x;
sl@0: 		bitPos = x;
sl@0: 
sl@0: 		// Constructor
sl@0: 		TBitFlagsT<TTestEnum> myBitFlag(KEnumArray[arrayPos]);
sl@0: 		TheTest(myBitFlag.IsSet(bitPos));
sl@0: 		
sl@0: 		//clear all and set one paricular bit
sl@0: 		myBitFlag.ClearAll();
sl@0: 		myBitFlag.Set(bitPos);
sl@0: 		
sl@0: 		// check "out of bounds" values as well
sl@0: 		// expected behavior is that for all out of bound values the 
sl@0: 		// result should be EFalse for IsSet("out of bounds") call.
sl@0: 		// IsSet and all the functions directly calling IsSet are being tested here
sl@0: 		// this test in conjuction with the other cts listed here 
sl@0: 		// should be sufficient to validate the fix
sl@0: 		for(TInt i = 0; i < 64; i++)
sl@0: 			{
sl@0: 			if(i==x)
sl@0: 				{
sl@0: 				TheTest(myBitFlag.IsSet(i));
sl@0: 				TheTest(!myBitFlag.IsClear(i));
sl@0: 				TheTest(myBitFlag[i]);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				TheTest(!myBitFlag.IsSet(i));
sl@0: 				TheTest(myBitFlag.IsClear(i));
sl@0: 				TheTest(!myBitFlag[i]);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	// check MSB was tested
sl@0: 	TheTest(KEnumArray[arrayPos] == ETest32);
sl@0: 	TheTest(bitPos == 31);
sl@0: 	}
sl@0: 
sl@0: void RunTestsL()
sl@0: 	{
sl@0: 	DoTest1();
sl@0: 	DoTest2();
sl@0: 	DoTest3();
sl@0: 	DoTest4();
sl@0: 	DoTest5();
sl@0: 	DoTest6();
sl@0: 	DEF102233();
sl@0: 	DEF130663();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 
sl@0: 	CTrapCleanup* cleanup = CTrapCleanup::New();
sl@0: 	if	(!cleanup)
sl@0: 	return KErrNoMemory;
sl@0: 
sl@0: 	TheTest.Start(_L("TBITFLAGS "));
sl@0: 	TheTest.Title();
sl@0: 
sl@0: 	TRAPD(err, RunTestsL());
sl@0: 	TheTest(err == KErrNone);
sl@0: 
sl@0: 	delete cleanup;
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 	return KErrNone;
sl@0: 	}