FCL/sf/os/kernelhwsrv: comparison kerneltest/e32test/usb/t_usb

equal deleted inserted replaced

-:d8d70de2bd36
+:57b9594f5772
-// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2000-2010 Nokia Corporation and/or its subsidiary(-ies).
 // All rights reserved.
 // This component and the accompanying materials are made available
 // under the terms of the License "Eclipse Public License v1.0"
 // which accompanies this distribution, and is available
 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 //
 // Description:
 // e32test/usb/t_usb_device/src/apitests.cpp
 // USB Test Program T_USB_DEVICE, functional part.
 // Device-side part, to work against T_USB_HOST running on the host.
 //
 //
 #include "general.h"									// CActiveControl, CActiveRW
 #include "config.h"
 #include "usblib.h"										// Helpers
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "apitestsTraces.h"
+#endif
 extern RTest test;
 extern TBool gVerbose;
 extern TBool gSkip;
 extern TBool gTempTest;
 	// Change the device vendor ID (VID)
 	deviceDescriptor[KUsbVendorIdOffset]   = LoByte(aLddPtr->iVid);			// little endian!
 	deviceDescriptor[KUsbVendorIdOffset+1] = HiByte(aLddPtr->iVid);
 	// Change the device product ID (PID)
 	if (aPid != 0)
 		{
 		deviceDescriptor[KUsbProductIdOffset]	= LoByte(aPid);		// little endian!
 		deviceDescriptor[KUsbProductIdOffset+1] = HiByte(aPid);
 		}
 	else
 		{
 		deviceDescriptor[KUsbProductIdOffset]	= LoByte(aLddPtr->iPid);		// little endian!
 		deviceDescriptor[KUsbProductIdOffset+1] = HiByte(aLddPtr->iPid);
 		}
 	// Change the device release number
 	deviceDescriptor[KUsbDevReleaseOffset]	 = LoByte(aLddPtr->iRelease);	// little endian!
 	deviceDescriptor[KUsbDevReleaseOffset+1] = HiByte(aLddPtr->iRelease);
 	r = aPort->SetDeviceDescriptor(deviceDescriptor);
 		r = aPort->GetDeviceDescriptor(descriptor2);
 		test_KErrNone(r);
 		test.Next(_L("Compare device descriptor with value set"));
 		r = descriptor2.Compare(deviceDescriptor);
 		test_KErrNone(r);
 		}
 	// === Configuration Descriptor
 	test.Next(_L("GetConfigurationDescriptorSize"));
 	// Change Self Power and Remote Wakeup
 	const TInt KUsbAttributesOffset = 7;
 	const TUint8 KUsbAttributeDefault = 0x80;
 	const TUint8 KUsbAttributeSelfPower = 0x40;
 	const TUint8 KUsbAttributeRemoteWakeup = 0x20;
 	configDescriptor[KUsbAttributesOffset] = KUsbAttributeDefault | (aLddPtr->iSelfPower ? KUsbAttributeSelfPower : 0)
 													| (aLddPtr->iRemoteWakeup ? KUsbAttributeRemoteWakeup : 0);
 	// Change the reported max power
 	// 100mA (= 2 * 0x32) is the highest value allowed for a bus-powered device.
 	const TInt KUsbMaxPowerOffset = 8;
 	configDescriptor[KUsbMaxPowerOffset] = aLddPtr->iMaxPower;
 		test.Next(_L("Compare configuration desc with value set"));
 		r = descriptor2.Compare(configDescriptor);
 		test_KErrNone(r);
 		}
 	// === String Descriptors
 	test.Next(_L("SetStringDescriptor"));
 	// Set up any standard string descriptors that were defined in the xml config
 	if (aLddPtr->iManufacturer)
 		{
 		r = aPort->SetManufacturerStringDescriptor(* aLddPtr->iManufacturer);
 		test_KErrNone(r);
 		}
 	if (aLddPtr->iProduct)
 		{
 		r = aPort->SetProductStringDescriptor(* aLddPtr->iProduct);
 		test_KErrNone(r);
 		}
 		test_KErrNone(r);
 		}
 	// Set up two arbitrary string descriptors, which can be queried
 	// manually from the host side for testing purposes
 	TBuf16<KUsbStringDescStringMaxSize / 2> wr_str(KString_one);
 	r = aPort->SetStringDescriptor(stridx1, wr_str);
 	test_KErrNone(r);
 	wr_str.FillZ(wr_str.MaxLength());
 	wr_str = KString_two;
 	r = aPort->SetStringDescriptor(stridx2, wr_str);
 	test_KErrNone(r);
 	test.End();
 	}
 static void TestDeviceQualifierDescriptor(RDEVCLIENT* aPort)
 	{
 	test.Start(_L("Device_Qualifier Descriptor Manipulation"));
 	TInt r = 0;
 	TBuf8<KUsbDescSize_Interface> descriptor;
 	TBuf8<KUsbDescSize_Interface> descriptor2;
 	for (TInt i =0; i < aNumSettings; i++)
 		{
 		test.Next(_L("GetInterfaceDescriptorSize()"));
 		r = aPort->GetInterfaceDescriptorSize(i, desc_size);
 		if (r != KErrNone)
 			{
-			RDebug::Printf ("Error %d in GetInterfaceDescriptorSize %d\n",r,i);
+			OstTraceExt2(TRACE_NORMAL, TESTINTERFACEDESCRIPTOR_TESTINTERFACEDESCRIPTOR, "Error %d in GetInterfaceDescriptorSize %d\n",r,i);
 			}
 		test_KErrNone(r);
 		test_Equal(KUsbDescSize_Interface,static_cast<TUint>(desc_size));
 		test.Next(_L("GetInterfaceDescriptor()"));
 		test.Next(_L("Compare interface descriptor with value set"));
 		r = descriptor2.Compare(descriptor);
 		test_KErrNone(r);
 		}
 	test.Next(_L("GetInterfaceDescriptor()"));
 	r = aPort->GetInterfaceDescriptor(aNumSettings, descriptor);
 	test_Equal(KErrNotFound,r);
 	test.Next(_L("SetInterfaceDescriptor()"));
 	r = aPort->SetInterfaceDescriptor(aNumSettings, descriptor);
 	test_Equal(KErrNotFound,r);
 	test.End();
 	}
 static void TestClassSpecificDescriptors(RDEVCLIENT* aPort)
 	test(((aEpInfo.iDir & KUsbEpDirIn) && (epDescriptor[KEpDesc_AddressOffset] & 0x80) ||
 		!(aEpInfo.iDir & KUsbEpDirIn) && !(epDescriptor[KEpDesc_AddressOffset] & 0x80)) &&
 			EpTypeMask2Value(aEpInfo.iType) == (TUint)(epDescriptor[KEpDesc_AttributesOffset] & 0x03) &&
 			aEpInfo.iInterval == epDescriptor[KEpDesc_IntervalOffset]);
 	// Change the endpoint poll interval
 	TUint8 ival = 0x66;
 	if (epDescriptor[KEpDesc_IntervalOffset] == ival)
 		ival++;
 	test.Next(_L("GetStringDescriptorLangId()"));
 	TUint16 rd_langid_orig;
 	TInt r = aPort->GetStringDescriptorLangId(rd_langid_orig);
 	test_KErrNone(r);
 	test.Printf(_L("Original LANGID code: 0x%04X\n"), rd_langid_orig);
+	OstTrace1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS, "Original LANGID code: 0x%04X\n", rd_langid_orig);
 	test.Next(_L("SetStringDescriptorLangId()"));
 	TUint16 wr_langid = 0x0809;								// English (UK) Language ID
 	if (wr_langid == rd_langid_orig)
 		wr_langid = 0x0444;									// Tatar Language ID
 	test.Next(_L("GetStringDescriptorLangId()"));
 	TUint16 rd_langid;
 	r = aPort->GetStringDescriptorLangId(rd_langid);
 	test_KErrNone(r);
 	test.Printf(_L("New LANGID code: 0x%04X\n"), rd_langid);
+	OstTrace1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP01, "New LANGID code: 0x%04X\n", rd_langid);
 	test.Next(_L("Compare LANGID codes"));
 	test_Equal(wr_langid,rd_langid);
 	test.Next(_L("Restore original LANGID code"));
 	test(r == KErrNone || r == KErrNotFound);
 	TBool restore_string;
 	if (r == KErrNone)
 		{
 		test.Printf(_L("Original Manufacturer string: \"%lS\"\n"), &rd_str_orig);
+		OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP02, "Original Manufacturer string: \"%lS\"\n", rd_str_orig);
 		restore_string = ETrue;
 		}
 	else
 		{
 		test.Printf(_L("No Manufacturer string set\n"));
+		OstTrace0(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP03, "No Manufacturer string set\n");
 		restore_string = EFalse;
 		}
 	test.Next(_L("SetManufacturerStringDescriptor()"));
 	_LIT16(manufacturer, "Manufacturer Which Manufactures Devices");
 	test.Next(_L("GetManufacturerStringDescriptor()"));
 	TBuf16<KUsbStringDescStringMaxSize / 2> rd_str;
 	r = aPort->GetManufacturerStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Manufacturer string: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP04, "New Manufacturer string: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Manufacturer strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	test.Next(_L("GetManufacturerStringDescriptor()"));
 	rd_str.FillZ(rd_str.MaxLength());
 	r = aPort->GetManufacturerStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Manufacturer string: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP05, "New Manufacturer string: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Manufacturer strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	r = aPort->GetProductStringDescriptor(rd_str_orig);
 	test(r == KErrNone || r == KErrNotFound);
 	if (r == KErrNone)
 		{
 		test.Printf(_L("Old Product string: \"%lS\"\n"), &rd_str_orig);
+		OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP06, "Old Product string: \"%lS\"\n", rd_str_orig);
 		restore_string = ETrue;
 		}
 	else
 		restore_string = EFalse;
 	test.Next(_L("GetProductStringDescriptor()"));
 	rd_str.FillZ(rd_str.MaxLength());
 	r = aPort->GetProductStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Product string: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP07, "New Product string: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Product strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	test.Next(_L("GetProductStringDescriptor()"));
 	rd_str.FillZ(rd_str.MaxLength());
 	r = aPort->GetProductStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Product string: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP08, "New Product string: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Product strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	r = aPort->GetSerialNumberStringDescriptor(rd_str_orig);
 	test(r == KErrNone || r == KErrNotFound);
 	if (r == KErrNone)
 		{
 		test.Printf(_L("Old Serial Number: \"%lS\"\n"), &rd_str_orig);
+		OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP09, "Old Serial Number: \"%lS\"\n", rd_str_orig);
 		restore_string = ETrue;
 		}
 	else
 		restore_string = EFalse;
 	test.Next(_L("GetSerialNumberStringDescriptor()"));
 	rd_str.FillZ(rd_str.MaxLength());
 	r = aPort->GetSerialNumberStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Serial Number: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP10, "New Serial Number: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Serial Number strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	test.Next(_L("GetSerialNumberStringDescriptor()"));
 	rd_str.FillZ(rd_str.MaxLength());
 	r = aPort->GetSerialNumberStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Serial Number: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP11, "New Serial Number: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Serial Number strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	r = aPort->GetConfigurationStringDescriptor(rd_str_orig);
 	test(r == KErrNone || r == KErrNotFound);
 	if (r == KErrNone)
 		{
 		test.Printf(_L("Old Configuration string: \"%lS\"\n"), &rd_str_orig);
+		OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP12, "Old Configuration string: \"%lS\"\n", rd_str_orig);
 		restore_string = ETrue;
 		}
 	else
 		restore_string = EFalse;
 	test.Next(_L("GetConfigurationStringDescriptor()"));
 	rd_str.FillZ(rd_str.MaxLength());
 	r = aPort->GetConfigurationStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Configuration string: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP13, "New Configuration string: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Configuration strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	test.Next(_L("GetConfigurationStringDescriptor()"));
 	rd_str.FillZ(rd_str.MaxLength());
 	r = aPort->GetConfigurationStringDescriptor(rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New Configuration string: \"%lS\"\n"), &rd_str);
+	OstTraceExt1(TRACE_NORMAL, TESTSTANDARDSTRINGDESCRIPTORS_TESTSTANDARDSTRINGDESCRIPTORS_DUP14, "New Configuration string: \"%lS\"\n", rd_str);
 	test.Next(_L("Compare Configuration strings"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	test.Next(_L("GetStringDescriptor() 3"));
 	r = aPort->GetStringDescriptor(stridx3, rd_str);
 	test_KErrNone(r);
 	test.Printf(_L("New test string @ idx %d: \"%lS\"\n"), stridx3, &rd_str);
+	OstTraceExt2(TRACE_NORMAL, TESTARBITRARYSTRINGDESCRIPTORS_TESTARBITRARYSTRINGDESCRIPTORS, "New test string @ idx %d: \"%lS\"\n", stridx3, rd_str);
 	test.Next(_L("Compare test strings 3"));
 	r = rd_str.Compare(wr_str);
 	test_KErrNone(r);
 	test.Start(_L("Test Invalid Interface Setting"));
 	if (SupportsAlternateInterfaces())
 		{
 		TInt r = aPort->SetInterface(aNumSettings+1, ifc);
 		test_Compare(r,!=,KErrNone);
 		}
 	if (aNumSettings > 1)
 		{
 		TInt r = aPort->SetInterface(aNumSettings-1, ifc);
 		test_Compare(r,!=,KErrNone);
 		}
 	TInt r = aPort->SetInterface(0, ifc);
 	test_Compare(r,!=,KErrNone);
 	test.End();
 	}
 void TestInvalidReleaseInterface (RDEVCLIENT* aPort,TInt aNumSettings)
 	test.Start(_L("Test Invalid Interface Release"));
 	if (aNumSettings > 2)
 		{
 		TInt r = aPort->ReleaseInterface(aNumSettings-3);
 		test_Compare(r,!=,KErrNone);
 		}
 	if (aNumSettings > 1)
 		{
 		TInt r = aPort->ReleaseInterface(aNumSettings-2);
 		test_Compare(r,!=,KErrNone);
 		}
 	test.End();
 	}
 	if (aHighSpeed)
 		{
 		TestDeviceQualifierDescriptor(aPort);
 		TestOtherSpeedConfigurationDescriptor(aPort);
 		}
 	TestInterfaceDescriptor(aPort,aNumSettings);
 	TestClassSpecificDescriptors(aPort);
 	TestStandardStringDescriptors(aPort);
 	TestArbitraryStringDescriptors(aPort,aNumSettings);
+	test.Next(_L("Test USB Descriptor Manipulation1"));
 	test.End();
 	}
 		TBool b_HnpEnable = (features & KUsbOtgAttr_B_HnpEnable) ? ETrue : EFalse;
 		TBool a_HnpSupport = (features & KUsbOtgAttr_A_HnpSupport) ? ETrue : EFalse;
 		TBool a_AltHnpSupport = (features & KUsbOtgAttr_A_AltHnpSupport) ? ETrue : EFalse;
 		test.Printf(_L("### OTG Features:\nB_HnpEnable(%d)\nA_HnpSupport(%d)\nA_Alt_HnpSupport(%d)\n"),
 					b_HnpEnable, a_HnpSupport, a_AltHnpSupport);
+		OstTraceExt3(TRACE_NORMAL, TESTOTGEXTENSIONS_TESTOTGEXTENSIONS, "### OTG Features:\nB_HnpEnable(%d)\nA_HnpSupport(%d)\nA_Alt_HnpSupport(%d)\n",
+					b_HnpEnable, a_HnpSupport, a_AltHnpSupport);
 		}
 	else
 		{
 		test_Equal(KErrNotSupported,r);
 		test.Printf(_L("GetOtgFeatures() not supported\n"));
+		OstTrace0(TRACE_NORMAL, TESTOTGEXTENSIONS_TESTOTGEXTENSIONS_DUP01, "GetOtgFeatures(not supported\n");
 		}
 	test.End();
 }
 				break;
 				}
 			if (good)
 				{
 				test.Printf(_L("Ep0 supports %d bytes MaxPacketSize\n"), mpsize);
+				OstTrace1(TRACE_NORMAL, TESTENDPOINT0MAXPACKETSIZES_TESTENDPOINT0MAXPACKETSIZES, "Ep0 supports %d bytes MaxPacketSize\n", mpsize);
 				}
 			else
 				{
 				test.Printf(_L("Bad Ep0 size: 0x%08x, failure will occur\n"), bit);
+				OstTrace1(TRACE_NORMAL, TESTENDPOINT0MAXPACKETSIZES_TESTENDPOINT0MAXPACKETSIZES_DUP01, "Bad Ep0 size: 0x%08x, failure will occur\n", bit);
 				r = KErrGeneral;
 				}
 			}
 		}
 	test_KErrNone(r);

changeset 259	57b9594f5772
parent 0	a41df078684a
child 257	3e88ff8f41d5