310 	CAP_TEST(none, KTestCapSet, ERun);

   311 	CAP_TEST(pauseRequired, KTestCapSet, EFail);

   312 	CAP_TEST(pauseRequired_skip, KTestCapSet, ESkip);

   313 	CAP_TEST(pauseNotWanted, KTestCapSet, ERun);

   314 	CAP_TEST(hwDesNotWanted, KTestCapSet, EFail);	

   315 	CAP_TEST(hwDesNotWanted_skip, KTestCapSet, ESkip);

   316 	CAP_TEST(hwDesWanted, KTestCapSet, ERun);

   531 	// The mean of these numbers is 10

   585 

   586 	test.Next(_L("Test IsFilled()"));

   587 	TUint8 buffer[] = {0,0,0,0};

   588 	TAddrRange range((TUint)buffer, 4);

   589 	test(range.IsFilled(0));

   590 	buffer[3] = 1;

   591 	test(!range.IsFilled(0));

   592 	buffer[2] = 1;

   593 	buffer[1] = 1;

   594 	buffer[0] = 1;

   595 	test(range.IsFilled(1));

   596 

   632 	}

   633 

   634 void TIsrRequeArgsSet::SelfTest()

   635 	{

   636 	test.Start(_L("Selftest of TIsrRequeArgsSet"));

   637 

   638 	TUint size = 0x1000;

   639 	TDmaTransferArgs tferArgs(0, 1*size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);

   640 

   641 	TIsrRequeArgs requeArgArray[] = {

   642 		TIsrRequeArgs(),									// Repeat

   643 		TIsrRequeArgs(KPhysAddrInvalidUser, 2*size, 0),		// Change destination

   644 		TIsrRequeArgs(),									// Repeat

   645 		TIsrRequeArgs(3*size, KPhysAddrInvalidUser, 0),		// Change source

   646 		TIsrRequeArgs(),									// Repeat

   647 	};

   648 	TIsrRequeArgsSet argSet(requeArgArray, ARRAY_LENGTH(requeArgArray));

   649 

   650 	test.Next(_L("Test that Substitute updates transfer args in order"));

   651 	argSet.Substitute(tferArgs);

   652 

   653 	TAddressParms expectedFinal(3*size, 2*size, size);

   654 	if(!(expectedFinal == argSet.iRequeArgs[4]))

   655 		{

   656 		TBuf<0x100> out;

   657 

   658 		out += _L("substitue: ");

   659 		GetAddrParms(tferArgs).AppendString(out);

   660 		test.Printf(out);

   661 

   662 		out.Zero();

   663 		out += _L("\nexpected final: ");

   664 		expectedFinal.AppendString(out);

   665 		test.Printf(out);

   666 

   667 		out.Zero();

   668 		out += _L("\nactual: ");

   669 		argSet.iRequeArgs[4].AppendString(out);

   670 		test.Printf(out);

   671 

   672 		test(EFalse);

   673 		}

   674 

   675 	TIsrRequeArgs requeArgArray2[] = {

   676 		TIsrRequeArgs(),									// Repeat

   677 		TIsrRequeArgs(KPhysAddrInvalidUser, 2*size, 0),		// Change destination

   678 		TIsrRequeArgs(KPhysAddrInvalidUser, 1*size, 0),		// Change destination back

   679 	};

   680 	argSet = TIsrRequeArgsSet(requeArgArray2, ARRAY_LENGTH(requeArgArray2));

   681 

   682 	test.Next(_L("CheckRange(), negative"));

   683 

   684 	test(!argSet.CheckRange(0, (2 * size) - 1, tferArgs));

   685 	test(!argSet.CheckRange(0, (2 * size) + 1, tferArgs));

   686 	test(!argSet.CheckRange(0, (2 * size), tferArgs));

   687 

   688 	test(!argSet.CheckRange(1 ,(3 * size), tferArgs));

   689 	test(!argSet.CheckRange(1 ,(3 * size) + 1, tferArgs));

   690 

   691 	test(!argSet.CheckRange(1 * size , 2 * size, tferArgs));

   692 

   693 	test.Next(_L("CheckRange(), positive"));

   694 	test(argSet.CheckRange(0, 3 * size, tferArgs));

   695 	test(argSet.CheckRange(0, 3 * size+1, tferArgs));

   696 	test(argSet.CheckRange(0, 4 * size, tferArgs));

   697 

   698 

   699 	test.End();

   700 	}

   701 

   702 void RArrayCopyTestL()

   703 	{

   704 	test.Start(_L("Selftest of RArray CopyL"));

   705 

   706 	RArray<TInt> orig;

   707 	TInt i;													// VC++

   708 	for(i=0; i<10; i++)

   709 		{

   710 		orig.AppendL(i);

   711 		}

   712 

   713 	RArray<TInt> newArray;

   714 	CopyL(orig, newArray);

   715 

   716 	test_Equal(10, newArray.Count());

   717 

   718 	for(i=0; i<10; i++)

   719 		{

   720 		test_Equal(orig[i], newArray[i])

   721 		}

   722 

   723 	orig.Close();

   724 	newArray.Close();

   725 	test.End();

   726 	}

   727 

   728 void RArrayInsertLTest()

   729 	{

   730 	test.Start(_L("Selftest of RArray InsertL"));

   731 

   732 	RArray<TInt> array;

   733 	TInt numbers[10] = {0,1,2,3,4,5,6,7,8,9};

   734 	ArrayAppendL(array, &numbers[0], numbers + ARRAY_LENGTH(numbers));

   735 

   736 	test_Equal(10, array.Count());

   737 	for(TInt i=0; i<10; i++)

   738 		{

   739 		test_Equal(numbers[i], array[i])

   740 		}

   741 

   742 	array.Close();

   743 	test.End();

   744 	}

   745 

   746 /**

   747 Run check buffers on the supplied TAddressParms array

   748 */

   749 TBool DoTferParmTestL(const TAddressParms* aParms, TInt aCount, TBool aAllowRepeat, TBool aPositive)

   750 	{

   751 	_LIT(KPositive, "positive");

   752 	_LIT(KNegative, "negative");

   753 	test.Printf(_L("CheckBuffers %S test: %d args, repeats allowed %d\n"),

   754 			(aPositive ? &KPositive : &KNegative), aCount, aAllowRepeat);

   755 	RArray<const TAddressParms> array;

   756 	ArrayAppendL(array, aParms, aParms + aCount);

   757 	TPreTransferIncrBytes preTran;

   758 	TBool r = preTran.CheckBuffers(array, aAllowRepeat);

   759 	array.Close();

   760 	return r;

   761 	}

   762 

   763 void TPreTransferIncrBytes::SelfTest()

   764 	{

   765 	// Test that TPreTransferIncrBytes::CheckBuffers can identify

   766 	// overlapping buffers

   767 	test.Start(_L("Selftest of TPreTransferIncrBytes"));

   768 

   769 // Macro generates test for 2 element array

   770 #define TPARM_TEST2(EXPECT, ALLOW_REPEAT, EL0, EL1)\

   771 		{\

   772 		TAddressParms set[2] = {EL0, EL1}; \

   773 		const TBool r = DoTferParmTestL(set, 2, ALLOW_REPEAT, EXPECT);\

   774 		test_Equal(EXPECT, r);\

   775 		}

   776 

   777 // Generate positive 2 element test

   778 #define TPARM_TEST2_POSITIVE(ALLOW_REPEAT, EL0, EL1) TPARM_TEST2(ETrue, ALLOW_REPEAT, EL0, EL1)

   779 // Generate negative 2 element test

   780 #define TPARM_TEST2_NEG(ALLOW_REPEAT, EL0, EL1) TPARM_TEST2(EFalse, ALLOW_REPEAT, EL0, EL1)

   781 

   782 // Macro generates test for 3 element array

   783 #define TPARM_TEST3(EXPECT, ALLOW_REPEAT, EL0, EL1, EL2)\

   784 		{\

   785 		TAddressParms set[3] = {EL0, EL1, EL2}; \

   786 		const TBool r = DoTferParmTestL(set, 3, ALLOW_REPEAT, EXPECT);\

   787 		test_Equal(EXPECT, r);\

   788 		}

   789 

   790 // Generate positive 3 element test

   791 #define TPARM_TEST3_POSITIVE(ALLOW_REPEAT, EL0, EL1, EL2) TPARM_TEST3(ETrue, ALLOW_REPEAT, EL0, EL1, EL2)

   792 // Generate negative 3 element test

   793 #define TPARM_TEST3_NEG(ALLOW_REPEAT, EL0, EL1, EL2) TPARM_TEST3(EFalse, ALLOW_REPEAT, EL0, EL1, EL2)

   794 

   795 	TPARM_TEST2_POSITIVE(EFalse, TAddressParms(0,16,16), TAddressParms(32, 48, 16));

   796 	TPARM_TEST2_POSITIVE(ETrue, TAddressParms(0, 16, 16), TAddressParms(0, 16, 16)); // both overlap (repeat allowed)

   797 

   798 	TPARM_TEST2_NEG(EFalse, TAddressParms(0,16,16), TAddressParms(24, 40, 16)); // second source depends on first destination

   799 	TPARM_TEST2_NEG(EFalse, TAddressParms(0,16,16), TAddressParms(16, 0, 16)); // second dest overwrites first source

   800 	TPARM_TEST2_NEG(EFalse, TAddressParms(0, 16, 16), TAddressParms(0, 16, 16)); // both overlap (repeat not allowed)

   801 	TPARM_TEST2_NEG(ETrue, TAddressParms(0, 16, 16), TAddressParms(0, 20, 16)); // exact repeat allowed, but overlap is only partial

   802 	TPARM_TEST2_NEG(ETrue, TAddressParms(0, 16, 16), TAddressParms(32, 16, 16)); // exact repeat allowed, but 2nd overwrites first dest

   803 

   804 

   805 	TPARM_TEST3_POSITIVE(EFalse, TAddressParms(0,16,16), TAddressParms(32, 48, 16), TAddressParms(64, 128, 64)); // no overlaps

   806 	TPARM_TEST3_POSITIVE(ETrue, TAddressParms(0, 16, 16), TAddressParms(0, 16, 16), TAddressParms(0, 16, 16)); // all overlap (repeat allowed)

   807 	TPARM_TEST3_POSITIVE(EFalse, TAddressParms(0,16,16), TAddressParms(0, 32, 16), TAddressParms(0, 48, 16)); // no overlaps (1 src to 3 dsts)

   808 

   809 	TPARM_TEST3_NEG(EFalse, TAddressParms(0,16,16), TAddressParms(128, 256, 128), TAddressParms(24, 40, 16)); // 3rd source depends on first destination

   810 	TPARM_TEST3_NEG(EFalse, TAddressParms(0,16,16), TAddressParms(128, 256, 128), TAddressParms(16, 0, 16)); // 3rd dest overwrites first source

   811 	TPARM_TEST3_NEG(EFalse, TAddressParms(0, 16, 16), TAddressParms(0, 16, 16), TAddressParms(0, 16, 16)); // all overlap (repeat not allowed)

   812 	test.Next(_L("CheckBuffers(RArray<TAddressParms>)"));

   826 	TIsrRequeArgsSet::SelfTest();

   827 	RArrayCopyTestL();

   828 	RArrayInsertLTest();

   829 	TPreTransferIncrBytes::SelfTest();