diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btsdp/test/protocolmanl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetooth/btsdp/test/protocolmanl.cpp	Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,597 @@
+// Copyright (c) 2005-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:
+// protocol manual from protocol main
+// a test harness for SDP protocol to send manual PDUs into the server
+// and onto the wire.
+// 
+//
+
+
+
+#include <e32test.h>
+#include <f32file.h>
+#include <c32comm.h>
+#include "listener.h"
+#include "protocolmanl.h"
+#include "reqhandler.h"
+// #include "builddb.h" we need one of these
+#include "debug.h"
+
+#if defined (__WINS__)
+#define PDD_NAME _L("ECDRV")
+#define LDD_NAME _L("ECOMM")
+#else  // __GCC32__
+#define PDD_NAME _L("EUART1")
+#define LDD_NAME _L("ECOMM")
+// #define ETNA_PDD_NAME _L("EUART2") // for debugging over com2
+#endif
+
+CSdpDatabase* BuildDbL();
+CSdpDatabase* BuildUpf4DbL();
+// in Builddb.cpp
+
+// tsdpdb.cpp
+void HexDes(const TDesC8& aDes);
+
+
+// being called by tsdpdb
+// GLDEF_D RTest test(_L("SDP Server injection tests"));
+
+GLDEF_D CSdpDatabase* gSdpTestDatabase;
+GLDEF_D TInt sdp_debug_level = 4;
+
+/*
+ ** Injector test
+ *
+ *  load up manual packets to 
+		respond synthetically to requests
+		send into the server
+ */  
+static TUint8 transId = 42;
+
+// Inject dummy SDP requests
+// inject buffers and return the response
+// first parameter is the request ID, and returns the response ID
+// so if an error occurs this can be checked...
+HBufC8* InjectLC(TUint8& aReqResID, const TPtr8& aReqBuf, TUint aMTU)
+{
+	TSdpPdu iRequest;
+	TSdpPdu iOutput;
+               
+	iRequest.iTransId = transId++;
+	iRequest.iPduId = aReqResID;
+	iRequest.iParams.Set(aReqBuf);
+	SDP_DEBUG(2, FPrint(_L("InjectLC")));
+	SDP_DEBUG(3, FPrint(_L("SDP PDU ID %d, transaction ID %d, parameter length %d, [params]"), iRequest.iPduId, iRequest.iTransId, iRequest.iParams.Length()));
+	SDP_DEBUG(4, FHex(iRequest.iParams));
+
+	HBufC8* iWriteHBuf = HBufC8::NewL(aMTU);
+	CleanupStack::PushL(iWriteHBuf);
+
+	iOutput.iParams.Set(iWriteHBuf->Des());
+	iOutput.iParams.Zero();
+	__UHEAP_MARK;
+	TRAPD(errorCode, SdpReqHandler::HandleL(*gSdpTestDatabase, iRequest, iOutput));
+	__UHEAP_MARKEND;
+	if (errorCode != KErrNone)
+		{
+		errorCode = SdpReqHandler::RunError(errorCode, iRequest, iOutput);
+		}
+	aReqResID = iOutput.iPduId;
+	SDP_DEBUG(3, FPrint(_L("Writing %d bytes of response data [contents]"), iWriteHBuf->Des().Length()));
+	SDP_DEBUG(4, FHex(iWriteHBuf->Des()));
+	return iWriteHBuf;
+}
+
+#define KErrorResponse 0x01
+#define KServiceSearchRequest 0x02
+#define KServiceSearchResponse 0x03
+#define KAttributeRequest 0x04
+#define KAttributeResponse 0x05
+#define KServiceAttSearchRequest 0x06
+#define KServiceAttSearchResponse 0x07
+
+#define DUMMTU 156
+
+
+// send a request and match a known response, show data only if a mismatch
+TBool testSdpReqL(RTest& test, TUint8* aReqData, TUint aReqLen, TUint8 aReqId, TUint8* aRespData, TUint aRespLen, TUint8 aRespId, TUint aRespSize)
+{
+	TUint8 pduId = aReqId;
+	TBool testMatch;
+	HBufC8* requestHBuf = HBufC8::New(aReqLen);
+	HBufC8* responseHBuf;
+	TPtr8 request = requestHBuf->Des();
+
+	request.SetLength(0);
+	request.Append(aReqData, aReqLen);
+	responseHBuf = InjectLC(pduId, request, aRespSize);
+	if (pduId == aRespId)
+		{
+		TInt respCmp = Mem::Compare(aRespData, aRespLen, &responseHBuf->Des()[0], responseHBuf->Length());
+		if (respCmp)
+			{
+			test.Printf(_L("no match at offset %d:\n"), respCmp);
+			HexDes(responseHBuf->Des());
+			test.Printf(_L("\n"));
+			testMatch = EFalse;
+			}
+		else
+			{
+			test.Printf(_L("Response OK\n"));
+			testMatch = ETrue;
+			}
+		}
+	else
+		{
+			test.Printf(_L("Error:"));
+			HexDes(responseHBuf->Des());
+			test.Printf(_L("\n"));
+			testMatch = EFalse;
+		}
+	CleanupStack::PopAndDestroy(/*responseHBuf*/);
+	delete requestHBuf;
+	return testMatch;
+}
+
+// send a request and resend any continuations - use SDP_DEBUG to dump
+TUint testSdpContL(RTest& test, TUint8* aReqData, TUint aReqLen, TUint8 aReqId, /*TUint8* aRespData,*/ TUint aMtu)
+{
+	TUint8 pduId = aReqId;
+	HBufC8* requestHBuf = HBufC8::New(aReqLen + 10 /*KSdpContinuationStateLength*/);
+	HBufC8* responseHBuf;
+	TPtr8 request = requestHBuf->Des();
+	TPtr8 buf(0,0);
+	TInt continuationLen = 0;
+	TInt partial = 0;
+	TInt continutations = 0;
+
+	request.SetLength(0);
+	request.Append(aReqData, aReqLen);
+	do
+		{
+		pduId = aReqId;
+		responseHBuf = InjectLC(pduId, request, aMtu);
+		buf.Set(responseHBuf->Des());
+
+		switch(pduId)
+			{
+			case 0x03:
+				test.Printf(_L("Got SDP_ServiceSearchResponse\n"));
+				partial = BigEndian::Get16(&buf[2]);
+				partial *= 4;
+				partial += 4;
+				continuationLen = buf[partial];
+				break;
+			
+			case 0x05:
+				test.Printf(_L("Got SDP_ServiceAttributeResponse\n"));
+				partial = BigEndian::Get16(&buf[0]);
+				partial += 2;
+				continuationLen = buf[partial];
+				break;
+			
+			case 0x07:
+				test.Printf(_L("Got SDP_ServiceSearchAttributeResponse\n"));
+				partial = BigEndian::Get16(&buf[0]);
+				partial += 2;
+				continuationLen = buf[partial];
+				break;
+			default:
+
+				test.Printf(_L("Got UnknownResponse (0x%x)\n"), buf[0]);
+				continuationLen = 0;	// create a dummy non-continuation
+				break;
+			}
+		continutations++;
+
+		request.Zero();
+		request.Append(aReqData, aReqLen-1);
+		request.Append(&buf[partial], continuationLen+1);  //1 for continuation len
+		CleanupStack::PopAndDestroy(/*responseHBuf*/);
+		} while (continuationLen != 0);
+
+	
+	delete requestHBuf;
+	return continutations;
+}
+
+
+void TestBL(RTest& test)
+	{
+	__UHEAP_MARK;
+	test.Start(_L("Test B -- UPF back to back tests"));
+
+	gSdpTestDatabase = BuildUpf4DbL();
+	gSdpTestDatabase->EncodeDbL();
+
+	test.Printf(_L("SS for RFCOMM "));
+	TUint8 requestdata00[] = {
+		0x35, 0x03, 0x19, 0x00, 0x03,	// UUID list
+		0x00, 0x03,						// max handles
+		0x00							// continuation
+		};
+	TUint8 responsedata00[] = {
+		0x00, 0x03,						// total handle count
+		0x00, 0x03,						// this handle count
+		0x00, 0x01, 0x00, 0x00,			// handle
+		0x00, 0x01, 0x00, 0x01,			// handle
+		0x00, 0x01, 0x00, 0x02,			// handle
+		0x00							// continuation
+		};
+	testSdpReqL(test, &requestdata00[0], sizeof(requestdata00), KServiceSearchRequest, &responsedata00[0], sizeof(responsedata00), KServiceSearchResponse, DUMMTU);
+
+
+	test.Printf(_L("AR for Server Description "));
+	TUint8 requestdata01[] = {
+		0x00, 0x00, 0x00, 0x00,			// handle
+		0x01, 0x00,						// max bytes
+		0x35, 0x03,						// DES header attrib list
+		0x09, 0x01, 0x01,				// attribute ID 0101
+		0x00							// continuation
+		};
+	TUint8 responsedata01[] = {
+		0x00, 0x1c,						// this byte count
+		0x35, 0x1a,						// DES of attribute list
+		0x09, 0x01, 0x01,				// attribute ID 0101
+		0x25, 0x15,						// string of 15h (21) bytes
+		0x45, 0x50, 0x4f, 0x43, 0x20, 0x53, 0x44, 0x50, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x55, 0x50, 0x46, 0x2d, 0x34,
+		0x00							// continuation
+		};
+	testSdpReqL(test, &requestdata01[0], sizeof(requestdata01), KAttributeRequest, &responsedata01[0], sizeof(responsedata01), KAttributeResponse, 0x100);
+
+	test.Printf(_L("UPF test 01 SS "));
+	TUint8 requestdataU01a[] = {
+		0x35, 0x03, 0x19, 0x11, 0x03,	// UUID list
+		0x00, 0x03,						// max handles
+		0x00							// continuation
+		};
+	TUint8 responsedataU01a[] = {
+		0x00, 0x01,						// total handle count
+		0x00, 0x01,						// this handle count
+		0x00, 0x01, 0x00, 0x00,			// handle
+		0x00							// continuation
+		};
+	testSdpReqL(test, &requestdataU01a[0], sizeof(requestdataU01a), KServiceSearchRequest, &responsedataU01a[0], sizeof(responsedataU01a), KServiceSearchResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 01 AR "));
+	TUint8 requestdataU01b[] = {
+		0x00, 0x01, 0x00, 0x00,			// handle
+		0x01, 0x00,						// max bytes
+		0x35, 0x03,						// DES header attrib list
+		0x09, 0x00, 0x04,				// attribute ID 0004
+		0x00							// continuation
+		};
+	TUint8 responsedataU01b[] = {
+		0x00, 0x13,						// this byte count
+		0x35, 0x11,						// DES of attribute list
+		0x09, 0x00, 0x04,				// attribute ID 0101
+		0x35, 0x0c,						// protocol DES
+		0x35, 0x03,						// DES for L2Cap
+		0x19, 0x01, 0x00,				// UUID L2CAP
+		0x35, 0x05,						// DES for RFCOMM
+		0x19, 0x00, 0x03,				// UUID for RFCOMM
+		0x08, 0x01,						// RFCOMM port number
+// 0x0a, 0x00, 0x00, 0x00, 0x01,			// RFCOMM port number
+		0x00							// continuation
+		};
+	testSdpReqL(test, &requestdataU01b[0], sizeof(requestdataU01b), KAttributeRequest, &responsedataU01b[0], sizeof(responsedataU01b), KAttributeResponse, 0x100);
+
+	test.Printf(_L("UPF test 02 "));
+	TUint8 requestdataU02a[] = {
+		0x35, 0x03, 0x19, 0x10, 0x02,	// UUID list
+		0x01, 0x00,						// max byte count
+		0x35, 0x03,						// DES header attrib list
+		0x09, 0x01, 0x00,				// attribute ID 0100
+		0x00							// continuation
+		};
+	TUint8 responsedataU02a[] = {
+		0x00, 0x4d,						// this byte count
+		0x35, 0x4b,						// DES of lists of attribute lists
+		0x35, 0x0f,						// DES of first attribute list
+		0x09, 0x01, 0x00,				// attribute ID 0100
+		0x25, 0x0a,						// string of 0ah (10) bytes
+		0x53, 0x44, 0x50, 0x20, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72,
+		0x35, 0x17,						// DES of second attribute list
+		0x09, 0x01, 0x00,				// attribute ID 0100
+		0x25, 0x12,						// string of 12h (18) bytes
+		0x44, 0x69, 0x61, 0x6c, 0x2d, 0x75, 0x70, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67,
+		0x35, 0x08,						// DES of third attribute list
+		0x09, 0x01, 0x00,				// attribute ID 0100
+		0x25, 0x03,						// string of 03h bytes
+		0x46, 0x61, 0x78,
+		0x35, 0x15,						// DES of fourth attribute list
+		0x09, 0x01, 0x00,				// attribute ID 0100
+		0x25, 0x10,						// string of 10h (16) bytes
+		0x4f, 0x42, 0x45, 0x58, 0x20, 0x4f, 0x62, 0x6a, 0x65, 0x78, 0x74, 0x20, 0x50, 0x75, 0x73, 0x68,
+		0x00							// continuation
+		};
+	testSdpReqL(test, requestdataU02a, sizeof(requestdataU02a), KServiceAttSearchRequest, responsedataU02a, sizeof(responsedataU02a), KServiceAttSearchResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 03 part 1"));
+	TUint8 requestdataU03a[] = {
+		0x35, 0x03, 0x19, 0x11, 0x05,	// UUID list
+		0x00, 0x45,						// max byte count
+		0x35, 0x05, 0x0a, 0x00, 0x00, 0xff, 0xff, // atttribute range
+		0x00							// continuation
+		};
+	TUint8 responsedataU03a[] = {
+		0x00, 0x45,						// this byte count
+		0x35, 0x6b,						// outer DES header
+		0x35, 0x69,						// first record DES
+		0x09, 0x00, 0x00,				// attribute 0
+		0x0a, 0x00, 0x01, 0x00, 0x02,	// record 10002
+		0x09, 0x00, 0x01,				// attribute 1
+		0x35, 0x03, 0x19, 0x11, 0x05,	// service class ID
+		0x09, 0x00, 0x04,				// attribute 4
+		0x35, 0x14,						// protocol list
+		0x35, 0x03, 0x19, 0x01, 0x00,
+		0x35, 0x08, 0x19, 0x00, 0x03, 0x0a, 0x00, 0x00, 0x00, 0x03,
+		0x35, 0x03, 0x19, 0x00, 0x08,
+		0x09, 0x00, 0x05,
+		0x35, 0x03, 0x19, 0x10, 0x02,
+		0x09, 0x00, 0x06,				// attribute 6
+		0x35, 0x0f,
+		0x0a, 0x00, 0x00, 0x65, 0x6e,
+		0x0a, 0x00, 0x00, 0x00, 0x6a,
+		0x0a,							// start of next part
+		0x0a, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00 // continuation
+		};
+	testSdpReqL(test, requestdataU03a, sizeof(requestdataU03a), KServiceAttSearchRequest, responsedataU03a, sizeof(responsedataU03a), KServiceAttSearchResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 03 cont. "));
+	TUint8 requestdataU03b[] = {
+		0x35, 0x03, 0x19, 0x11, 0x05,	// UUID list
+		0x00, 0x45,						// max byte count
+		0x35, 0x05, 0x0a, 0x00, 0x00, 0xff, 0xff, // atttribute range
+		0x0a, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00 // continuation
+		};
+	TUint8 responsedataU03b[] = {
+		0x00, 0x28,						// this byte count
+		0x00, 0x00, 0x01, 0x00,			// the rest of a continuation
+		0x09, 0x00, 0x09, 
+		0x35, 0x0a, 
+		0x35, 0x08, 
+		0x19, 0x11, 0x05, 
+		0x0a, 0x00, 0x00, 0x01, 0x00,
+		0x09, 0x01, 0x00,
+		0x25, 0x10, 0x4f, 0x42, 0x45, 0x58, 0x20, 0x4f, 0x62, 0x6a, 0x65, 0x78, 0x74, 0x20, 0x50, 0x75, 0x73, 0x68,
+		0x00
+		};
+	testSdpReqL(test, requestdataU03b, sizeof(requestdataU03b), KServiceAttSearchRequest, responsedataU03b, sizeof(responsedataU03b), KServiceAttSearchResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 04 "));
+	TUint8 requestdataU04[] = {
+		0x35, 0x03, 0x19, 0x12, 0x34,	// UUID list
+		0x00, 0x03,						// max handles
+		0x00							// continuation
+		};
+	TUint8 responsedataU04[] = {
+		0x00, 0x00,						// total handle count
+		0x00, 0x00,						// this handle count
+										// no handle
+		0x00							// continuation
+		};
+	testSdpReqL(test, requestdataU04, sizeof(requestdataU04), KServiceSearchRequest, responsedataU04, sizeof(responsedataU04), KServiceSearchResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 05 "));
+	TUint8 requestdataU05[] = {
+		0x12, 0x34, 0x56, 0x78,			// handle
+		0x01, 0x00,						// max bytes
+		0x35, 0x03,						// DES header attrib list
+		0x09, 0x00, 0x06,				// attribute ID 0006
+		0x00							// continuation
+		};
+	TUint8 responsedataU05[] = {
+		0x00, 0x02						// error response
+		};
+	testSdpReqL(test, &requestdataU05[0], sizeof(requestdataU05), KAttributeRequest, &responsedataU05[0], sizeof(responsedataU05), KErrorResponse, 0x100);
+
+	test.Printf(_L("UPF test 06 "));
+	TUint8 requestdataU06[] = {
+		0x35, 0x03, 0x19, 0x11, 0x11,	// UUID list
+		0x00, 0x45,						// max byte count
+		0x35, 0x03, 0x09, 0xab, 0xcd,	// non existent attrib
+		0x00
+		};
+	TUint8 responsedataU06[] = {
+		0x00, 0x02,						// this byte count
+		0x35, 0x00, 
+		0x00
+		};
+	testSdpReqL(test, requestdataU06, sizeof(requestdataU06), KServiceAttSearchRequest, responsedataU06, sizeof(responsedataU06), KServiceAttSearchResponse, DUMMTU);
+
+// can't do this test - length is handled in ParseNextPacket - fails with wrong code
+	test.Printf(_L("UPF test 07 (can't test) "));
+	TUint8 requestdataU07[] = {
+		0x00, 0x01, 0x00, 0x02,			// handle for OBEX
+		0x01, 0x00,						// max bytes
+		0x35, 0x03,						// DES header attrib list
+		0x09, 0x00, 0x09,				// attribute ID 0009
+		0x00							// continuation
+		};
+	TUint8 responsedataU07[] = {
+		0x00, 0x02						// error response
+		};
+	testSdpReqL(test, &requestdataU07[0], 50, KAttributeRequest, &responsedataU07[0], sizeof(responsedataU07), KErrorResponse, DUMMTU);
+
+
+	test.Printf(_L("UPF test 08 "));
+	TUint8 requestdataU08[] = {
+		0x35, 0x03, 0x09, 0x11, 0x11,	// UINT list instead of UUID list
+		0x00, 0x45,						// max byte count
+		0x35, 0x03, 0x09, 0x00, 0x09,	// non existent attrib
+		0x00
+		};
+	TUint8 responsedataU08[] = {
+		0x00, 0x03						// invalid request syntax
+		};
+	testSdpReqL(test, requestdataU08, sizeof(requestdataU08), KServiceAttSearchRequest, responsedataU08, sizeof(responsedataU08), KErrorResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 09 "));
+	TUint8 requestdataU09[] = {
+		0x35, 0x09,						// UUID list
+		0x19, 0x11, 0x05,				// OBEX
+		0x19, 0x00, 0x03,				// RFCOMM
+		0x19, 0x01, 0x00,				// L2CAP
+		0x00, 0x45,						// max byte count
+		0x35, 0x03, 0x09, 0x00, 0x04,	// attrib 04
+		0x00
+		};
+	TUint8 responsedataU09[] = {
+		0x00, 0x1d,
+		0x35, 0x1b,
+		0x35, 0x19,
+		0x09, 0x00, 0x04,
+		0x35, 0x14,
+		0x35, 0x03, 0x19, 0x01, 0x00,
+		0x35, 0x08, 0x19, 0x00, 0x03, 0x0a, 0x00, 0x00, 0x00, 0x03,
+		0x35, 0x03, 0x19, 0x00, 0x08,
+		0x00
+		};
+	testSdpReqL(test, requestdataU09, sizeof(requestdataU09), KServiceAttSearchRequest, responsedataU09, sizeof(responsedataU09), KServiceAttSearchResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 10 "));
+	TUint8 requestdataU10[] = {
+		0x35, 0x03, 0x19, 0x00, 0x03,	// UUID list
+		0x00, 0x02,						// max handles
+		0x00							// continuation
+		};
+	TUint8 responsedataU10[] = {
+		0x00, 0x02,						// total handle count
+		0x00, 0x02,						// this handle count
+		0x00, 0x01, 0x00, 0x00,			// handle
+		0x00, 0x01, 0x00, 0x01,			// handle
+		0x00							// continuation
+		};
+	testSdpReqL(test, &requestdataU10[0], sizeof(requestdataU10), KServiceSearchRequest, &responsedataU10[0], sizeof(responsedataU10), KServiceSearchResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 11 "));
+	TUint8 requestdataU11[] = {
+		0x00, 0x01, 0x00, 0x00,			// handle for system
+		0x01, 0x00,						// max bytes
+		0x35, 0x09,						// DES header attrib list
+		0x09, 0x00, 0x06,				// attribute exists
+		0x09, 0x00, 0x11,				// attribute doesn't exist
+		0x09, 0x01, 0x00,				// attribute exists
+		0x00							// continuation
+		};
+	TUint8 responsedataU11[] = {
+		0x00, 0x2d,						//  response
+		0x35, 0x2b,
+		0x09, 0x00, 0x06,
+		0x35, 0x0f, 0x0a, 0x00, 0x00, 0x65, 0x6e, 0x0a, 0x00, 0x00, 0x00, 0x6a, 0x0a, 0x00, 0x00, 0x01, 0x00,
+		0x09, 0x01, 0x00,
+		0x25, 0x12, 0x44, 0x69, 0x61, 0x6c, 0x2d, 0x75, 0x70, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67,
+		0x00
+		};
+	testSdpReqL(test, &requestdataU11[0], sizeof(requestdataU11), KAttributeRequest, &responsedataU11[0], sizeof(responsedataU11), KAttributeResponse, DUMMTU);
+
+	test.Printf(_L("UPF test 12 (can't test)"));
+	
+//	CleanupStack::PopAndDestroy(/*CSdpReqHandler*/);
+	delete gSdpTestDatabase;
+	gSdpTestDatabase = 0;
+	__UHEAP_MARKEND;
+	test.End();
+	}
+
+
+void TestCL(RTest& test, CSdpDatabase *aDb)
+	{
+	test.Start(_L("Test C -- continuation stress test"));
+
+	gSdpTestDatabase = aDb;
+	gSdpTestDatabase->EncodeDbL();
+
+	sdp_debug_level = 1;  // wind the noise down - this works
+	test.Printf(_L("SS for KSdpContTestUUID\n"));
+	TUint8 requestdata00a[] = {
+		0x35, 0x03, 0x19, 0x01, 0x00,	// UUID list
+		0xff, 0xff,						// max handles
+		0x00							// continuation
+		};
+
+	TUint tCount = testSdpContL(test, requestdata00a, sizeof(requestdata00a), KServiceSearchRequest, /*TUint8* aRespData,*/ DUMMTU);
+	test.Printf(_L("SS for KSdpContTestUUID %d continuations\n"), tCount);
+	test.Getch();
+
+	test.Printf(_L("AR for all attributes\n"));
+	TUint8 requestdata01[] = {
+		0x00, 0x00, 0x00, 0x00,			// handle
+		0x01, 0x00,						// max bytes
+		0x35, 0x05,						// DES header attrib list
+		0x0a, 0x00, 0x00, 0xff, 0xff,	// attribute ID range 0000 to ffff
+		0x00							// continuation
+		};
+	tCount = testSdpContL(test, requestdata01, sizeof(requestdata01), KAttributeRequest, /*TUint8* aRespData,*/ DUMMTU);
+	test.Printf(_L("AR for all attributes, handle 00000000 %d continuations\n"), tCount);
+	test.Getch();
+
+	test.Printf(_L("AR for all attributes\n"));
+	TUint8 requestdata02[] = {
+		0x00, 0x01, 0x00, 0x00,			// handle
+		0x01, 0x00,						// max bytes
+		0x35, 0x05,						// DES header attrib list
+		0x0a, 0x00, 0x00, 0xff, 0xff,	// attribute ID range 0000 to ffff
+		0x00							// continuation
+		};
+	tCount = testSdpContL(test, requestdata02, sizeof(requestdata02), KAttributeRequest, /*TUint8* aRespData,*/ DUMMTU);
+	test.Printf(_L("AR for all attributes, handle 00010000 %d continuations\n"), tCount);
+	test.Getch();
+
+	test.Printf(_L("AR for attribute 0004\n"));
+	TUint8 requestdata03[] = {
+		0x00, 0x01, 0x00, 0x00,			// handle
+		0x01, 0x00,						// max bytes
+		0x35, 0x03,						// DES header attrib list
+		0x09, 0x00, 0x04,				// attribute ID 0004
+		0x00							// continuation
+		};
+	tCount = testSdpContL(test, requestdata03, sizeof(requestdata03), KAttributeRequest, /*TUint8* aRespData,*/ DUMMTU);
+	test.Printf(_L("AR for attribute 0004, handle 00010000 %d continuations\n"), tCount);
+	test.Getch();
+
+	test.Printf(_L("AR for all attributes\n"));
+	TUint8 requestdata04[] = {
+		0x00, 0x01, 0x00, 0x03e,		// handle
+		0x01, 0x00,						// max bytes
+		0x35, 0x05,						// DES header attrib list
+		0x0a, 0x00, 0x00, 0xff, 0xff,	// attribute ID range 0000 to ffff
+		0x00							// continuation
+		};
+	tCount = testSdpContL(test, requestdata04, sizeof(requestdata04), KAttributeRequest, /*TUint8* aRespData,*/ DUMMTU);
+	test.Printf(_L("AR for all attributes, handle 0001003e %d continuations\n"), tCount);
+	test.Getch();
+
+	sdp_debug_level = 5;
+
+	test.Printf(_L("SAS for all attributes\n"));
+	TUint8 requestdata05[] = {
+		0x35, 0x03, 0x19, 0x01, 0x00,	// UUID list
+		0x01, 0x00,						// max byte count
+		0x35, 0x05,						// DES header attrib list
+		0x0a, 0x00, 0x00, 0xff, 0xff,	// attribute ID range 0000 to ffff
+		0x00							// continuation
+		};
+	tCount = testSdpContL(test, requestdata05, sizeof(requestdata05), KServiceAttSearchRequest, /*TUint8* aRespData,*/ DUMMTU);
+//	tCount = testSdpCont(test, requestdata05, sizeof(requestdata05), KServiceAttSearchRequest, /*TUint8* aRespData,*/ 102);
+	test.Printf(_L("SAS for all attributes, %d continuations\n"), tCount);
+	test.Getch();
+	
+//	CleanupStack::PopAndDestroy(/*CSdpReqHandler*/);
+	delete gSdpTestDatabase;
+	gSdpTestDatabase = 0;
+	test.End();
+	}