// 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()
{
DoTest1();
DoTest2();
DoTest3();
DoTest4();
DoTest5();
DoTest6();
DEF102233();
DEF130663();
}
TInt E32Main()
{
__UHEAP_MARK;
CTrapCleanup* cleanup = CTrapCleanup::New();
if (!cleanup)
return KErrNoMemory;
TheTest.Start(_L("TBITFLAGS "));
TheTest.Title();
TRAPD(err, RunTestsL());
TheTest(err == KErrNone);
delete cleanup;
TheTest.End();
TheTest.Close();
__UHEAP_MARKEND;
return KErrNone;
}