--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/apputils/tsrc/T_BitFlags.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,559 @@
+// 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;
+ }