--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetooth/btsdp/test/tsdpdb.cpp Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,2006 @@
+// 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:
+// SDP Database library test code
+//
+//
+
+
+#include <e32test.h>
+#include <f32file.h>
+#include <e32math.h>
+#include <btsdp.h>
+#include <e32def.h>
+#include <e32const.h>
+#include <e32std.h>
+#include "listener.h"
+#include "reqhandler.h"
+#include "SDPDatabase.h"
+#include "protocolmanl.h"
+#include "MAttributeVisitor.h"
+#include "ServiceSearchVisitor.h"
+#include "DataEncoder.h"
+#include "ExtractorVisitor.h"
+#include "EncoderVisitor.h"
+#include "responsesizevisitor.h"
+#include "debug.h"
+//#ifdef __EPOC32__
+#include <c32comm.h>
+//#endif
+
+GLDEF_D RTest test(_L("SDP database DLL tests"));
+
+#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();
+CSdpDatabase* BuildContinuationDbL();
+CSdpDatabase* BuildNestedListDbL();
+CSdpDatabase* BuildPrequalDbL();
+// in Builddb.cpp
+
+void LoadLDD_PDD()
+ {
+ TInt r;
+//#ifdef __EPOC32__
+ r=StartC32();
+ if (r!=KErrNone && r!=KErrAlreadyExists)
+ {
+ test.Printf(_L("Failed %d!\n\r"),r);
+ test(r==KErrNone);
+ }
+ else
+ test.Printf(_L("Started C32\n"));
+//#endif
+ test.Printf(_L("Loading PDD\n"));
+ r=User::LoadPhysicalDevice(PDD_NAME);
+ if (r!=KErrNone && r!=KErrAlreadyExists)
+ {
+ test.Printf(_L("Failed %d!\n\r"),r);
+ test(r==KErrNone);
+ }
+ else
+ test.Printf(_L("Loaded PDD\n"));
+ test.Printf(_L("Loading LDD\n"));
+ r=User::LoadLogicalDevice(LDD_NAME);
+ if (r!=KErrNone && r!=KErrAlreadyExists)
+ {
+ test.Printf(_L("Failed %d!\n\r"),r);
+ test(r==KErrNone);
+ }
+ else
+ test.Printf(_L("Loaded LDD\n"));
+ }
+
+// plagiarised from tsdp.cpp
+// actually Mel can't cast from Shortest form (TPtrC8) to a TDesC8 without this call
+void HexDes(const TDesC8& aDes)
+ {
+ for (TInt i = 0; i < aDes.Length(); ++i)
+ test.Printf(_L("%02x"), aDes[i]);
+ }
+
+class CAttrPrintVisitor : public CBase, public MAttributeVisitor
+ {
+public:
+ CAttrPrintVisitor(CConsoleBase& aConsole) : iConsole(aConsole) {iIndent=0;}
+ ~CAttrPrintVisitor() {/*iConsole.Getch();*/}
+ void VisitAttributeL(CSdpAttr &aAttribute)
+ {
+ Indent();
+ test.Printf(_L("\nID:0x%x:"), aAttribute.AttributeID());
+ }
+ void VisitAttributeValueL(CSdpAttrValue & aValue, TSdpElementType aType)
+ {
+// FIXME need a new object like the match list that will just store the object in
+// FIXME an array, or perhaps just print it ? Is it a visitor ?
+// CSdpSearchPattern* encAttrList = new (ELeave) CSdpSearchPattern;
+// CleanupStack::PushL(encAttrList);
+
+// CElementParser* parser = CElementParser::NewL(encAttrList);
+// CleanupStack::PushL(parser);
+
+// TInt rem;
+
+ TBuf16<64> iString;
+// TInt iFound;
+ switch (aType)
+ {
+ case ETypeString:
+ iString.Copy(aValue.Des());
+ test.Printf(_L("\"%S\""),&iString);
+ break;
+ case ETypeDES:
+ test.Printf(_L(" DES"));
+ break;
+ case ETypeUint:
+ test.Printf(_L(" UInt:0x%x"), aValue.Uint());
+ break;
+ case ETypeUUID:
+ test.Printf(_L(" UUID:0x"));
+ HexDes(aValue.UUID().ShortestForm());
+ break;
+ case ETypeEncoded:
+ HexDes(aValue.Des()); // simplest
+//parse out the elements in this encoded attribute
+// rem = parser->ParseElementsL(aValue.Des());
+// CleanupStack::PopAndDestroy(/*parser*/);
+// for (iFound=0 ; iFound++ ; (iFound < (encAttrList->Length())))
+// {
+// VisitAttributeValueL(encAttrList->At(iFound).Value, encAttrList->At(iFound).Type);
+// }
+// CleanupStack::PopAndDestroy(/*encAttrList*/);
+ break;
+ default:
+ test.Printf(_L("type %d\n"), aType);
+ }
+ }
+ void StartListL(CSdpAttrValueList &/*aList*/)
+ {
+ ++iIndent;
+ test.Printf(_L("{"));
+ }
+ void EndListL()
+ {
+ if(iIndent<=0)
+ {
+ test.Printf(_L("\nERROR! Unmatched EndList!\n"));
+ __DEBUGGER();
+ }
+ test.Printf(_L("}"));
+ --iIndent;
+ }
+private:
+ void Indent() {/*test.SetPos(iIndent)*/;}
+ CConsoleBase &iConsole;
+ TInt iIndent;
+ };
+
+void PrintDb(CSdpDatabase& aDb, CConsoleBase& aConsole)
+ {
+ aConsole.Printf(_L("Printing Database...\n"));
+
+ for(TServRecordIter recIter(aDb.RecordIter()); recIter; recIter++)
+ {// Iterate thru records in Db
+ aConsole.Printf(_L("\n...Printing Record 0x%x\n"), (*recIter).Handle());
+ for(TServAttrIter attrIter((*recIter).AttributeIter()); attrIter; attrIter++)
+ {// Iterate thru attributes in record
+ CAttrPrintVisitor* theVisitor = new CAttrPrintVisitor(aConsole);
+ (*attrIter).AcceptVisitorL(*theVisitor);
+ delete theVisitor;
+ }
+ }
+ }
+
+class CAttrFlogVisitor : public CBase, public MAttributeVisitor
+ {
+public:
+ CAttrFlogVisitor(){}
+ void VisitAttributeL(CSdpAttr &aAttribute)
+ {
+ Indent();
+
+ //3 lines for one here, but prevents warning.
+ TUint id;
+ id= aAttribute.AttributeID();
+ FTRACE(FPrint(_L("Attribute ID: 0x%x\n"), id));
+
+ (void)(id != 0); // keep compiler happy by referencing id as an r-value in urel
+ }
+ void VisitAttributeValueL(CSdpAttrValue & aValue, TSdpElementType aType)
+ {
+ TBuf16<64> iString;
+ switch (aType)
+ {
+ case ETypeString:
+ iString.Copy(aValue.Des());
+ FTRACE(FPrint(_L("\"%S\""),&iString));
+ break;
+ case ETypeDES:
+ FTRACE(FPrint(_L(" DES")));
+ break;
+ case ETypeUint:
+ FTRACE(FPrint(_L(" UInt:0x%x"), aValue.Uint()));
+ break;
+ case ETypeUUID:
+ FTRACE(FPrint(_L(" UUID:0x")));
+ HexDes(aValue.UUID().ShortestForm());
+ break;
+ case ETypeEncoded:
+ HexDes(aValue.Des()); // simplest
+ break;
+ default:
+ FTRACE(FPrint(_L("type %d\n"), aType));
+ }
+ }
+ //void VisitAttributeValueL(CSdpAttrValue &aValue, TSdpElementType aType)
+ // {
+ // Indent();
+ // FTRACE(FPrint(_L("(Val: type %d)\n"), aType));
+ // if(aType==ETypeUUID)
+ // {
+ // TUUID u = aValue.UUID();
+ // FTRACE(FPrint(_L("(Val: uuid 0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x)\n"),
+ // u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7],u[8],u[9],u[10],u[11],u[12],u[13],u[14],u[15]));
+ // }
+ //
+ // }
+ void StartListL(CSdpAttrValueList &/*aList*/)
+ {
+ ++iIndent;
+ Indent();
+ FTRACE(FPrint(_L("{\n")));
+ }
+ void EndListL()
+ {
+ if(iIndent<=0)
+ {
+ FTRACE(FPrint(_L("\nERROR! Unmatched EndList!\n")));
+ __DEBUGGER();
+ }
+ Indent();
+ FTRACE(FPrint(_L("}\n")));
+ --iIndent;
+ }
+private:
+ void HexDes(const TDesC8& aDes)
+ {
+ for (TInt i = 0; i < aDes.Length(); ++i)
+ {
+ FTRACE(FPrint(_L("%02x"), aDes[i]));
+ }
+ }
+
+ void Indent()
+ {
+ for(TInt i=0; i<iIndent;++i)
+ {
+ FTRACE(FPrint(_L(" ")));
+ }
+
+ }
+ TInt iIndent;
+ };
+
+
+void FlogDb(CSdpDatabase& aDb)
+ {
+ FTRACE(FPrint(_L("\n\nPrinting Database...\n\n")));
+
+ for(TServRecordIter recIter(aDb.RecordIter()); recIter; recIter++)
+ {// Iterate thru records in Db
+ FTRACE(FPrint(_L("\n...Printing Record 0x%x\n"), (*recIter).Handle()));
+ for(TServAttrIter attrIter((*recIter).AttributeIter()); attrIter; attrIter++)
+ {// Iterate thru attributes in record
+ CAttrFlogVisitor* theVisitor = new CAttrFlogVisitor();
+ (*attrIter).AcceptVisitorL(*theVisitor);
+ delete theVisitor;
+ }
+ }
+ FTRACE(FPrint(_L("\n\nEnd Printing Database...\n\n\n\n")));
+ }
+
+
+
+class CSearchObserver : public CBase, public MServiceSearchHandler
+ {
+public:
+ void RecordFoundL(CSdpServRecord& aMatchingRec)
+ {
+ ++iMatchesFound;
+ test.Printf(_L("Match %d found in record 0x%x\n"), iMatchesFound, aMatchingRec.Handle());
+ };
+ TInt iMatchesFound;
+ };
+
+void SearchDbL(CSdpDatabase &aDb, const CSdpSearchPattern &aPattern, TInt aExpectedMatches)
+ {
+ CSearchObserver *ob = new(ELeave) CSearchObserver;
+ CleanupStack::PushL(ob);
+ CServiceSearchVisitor::SearchDbL(aDb, aPattern, *ob);
+ test(aExpectedMatches==ob->iMatchesFound);
+ CleanupStack::PopAndDestroy();
+ }
+
+void RegisterDatabaseInServerL (RSdpDatabase& aDb, CSdpDatabase& aDbStruct)
+ {
+ for(TServRecordIter recIter(aDbStruct.RecordIter()); recIter; recIter++)
+ {// Iterate thru records in Db
+ TServAttrIter attrIter((*recIter).AttributeIter());
+ if(!attrIter)
+ continue;
+ if((*attrIter).AttributeID() == 0)
+ attrIter++; //Skip rec handle
+ if(!attrIter)
+ continue;
+ if((*attrIter).AttributeID() != 1 || (*attrIter).Value().Type() != ETypeDES)
+ continue;
+ // Get service class list
+ TSdpServRecordHandle handle;
+ aDb.CreateServiceRecordL((CSdpAttrValueDES&)(*attrIter).Value(), handle);
+ attrIter++;
+ for(; attrIter; attrIter++)
+ {// Iterate thru attributes in record
+ aDb.UpdateAttributeL(handle, (*attrIter).AttributeID(), (*attrIter).Value());
+ }
+ }
+ }
+
+TSdpServRecordHandle BuildPagonisL(RSdpDatabase& aDb, TUUID aUUID, TUint8 aCN)
+/**
+ Record Pagonis should be used when building a record with a protocol ID
+ list consisting of L2CAP and RFCOMM. This record is for a service of class
+ "serial port" - UUID16 0x1101
+ note that attributes 2, 5 and 0x201 should be updated.
+ also note only English, pas de Francais, keine Deutsch, non Espanol
+**/
+ {
+ TBuf8<4> value1;
+ TBuf8<4> value2;
+ TSdpServRecordHandle recHandle;
+ CSdpAttrValue* attrVal = 0;
+ CSdpAttrValueDES* attrValDES = 0;
+
+
+ value1.FillZ(4);
+ value2.FillZ(4);
+
+ // Set Attr 1 (service class list) to list with UUID = 0x1101 (serial port)
+ // or 0x1102 (LANP)
+ aDb.CreateServiceRecordL(aUUID, recHandle);
+ test.Printf(_L("Service Record Created - Handle: 0x%x!\n\n"), recHandle);
+
+ // Set Attr 2 (service record state) to 0
+ value1.FillZ(4);
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x02, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set attr 4 (protocol list) to L2CAP, and RFCOMM
+ value1.FillZ(4);
+ value1[3] = 3;
+ value2.FillZ(4);
+ value2[3] = aCN;
+ attrValDES = CSdpAttrValueDES::NewDESL(0);
+ CleanupStack::PushL(attrValDES);
+ attrValDES
+ ->StartListL()
+ ->BuildDESL()
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint16(0x0100))) // L2CAP
+ ->BuildUintL(value1)
+ ->EndListL()
+ ->BuildDESL()
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint16(0x0003))) // RFCOMM
+ ->BuildUintL(value2)
+ ->EndListL()
+ ->EndListL();
+ aDb.UpdateAttributeL(recHandle, 0x04, *attrValDES);
+ CleanupStack::PopAndDestroy();
+ attrValDES = 0;
+
+ // Set Attr 5 (browse group list) to list with one UUID
+ // 0x1101 (serial port class)
+ // this should be updated with other service classes when other services are added.
+ attrValDES = CSdpAttrValueDES::NewDESL(0);
+ CleanupStack::PushL(attrValDES);
+ attrValDES
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint32(0x1002)))
+ ->EndListL();
+ aDb.UpdateAttributeL(recHandle, 0x05, *attrValDES);
+ CleanupStack::PopAndDestroy();
+ attrValDES = 0;
+
+
+ // Set Attr 0x006 (language base)
+ value1.FillZ(4);
+ value1[2] = 0x65;
+ value1[3] = 0x6e;
+ TBuf8<4> val2;
+ TBuf8<4> val3;
+ val2.FillZ(4);
+ val3.FillZ(4);
+ val2[3] = 0x6a;
+ val3[2] = 0x01;
+
+ attrValDES = CSdpAttrValueDES::NewDESL(0);
+ CleanupStack::PushL(attrValDES);
+ attrValDES
+ ->StartListL()
+ ->BuildUintL(value1) // english
+ ->BuildUintL(val2) // UTF-8
+ ->BuildUintL(val3) // language base
+ ->EndListL();
+ aDb.UpdateAttributeL(recHandle, 0x06, *attrValDES);
+ CleanupStack::PopAndDestroy();
+ attrValDES = 0;
+
+ // Set Attr 0x007 (time to live) to 1200 (0x4B0) seconds (20 minutes)
+ value1.FillZ(4);
+ value1[2]=4;
+ value1[3]=0xb0;
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x07, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x008 (availability) to 0xff - fully available - not in use
+ value1.FillZ(4);
+ value1[3]=0xff;
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x08, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+
+ // Set Attr 0x100 (default Name) to string
+ attrVal = CSdpAttrValueString::NewStringL(_L8("Pagonis Service"));
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0100, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x101 (def. description) to string
+ attrVal = CSdpAttrValueString::NewStringL(_L8("It's all Greek to me!"));
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0101, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x102 (def. provider) to Symbian
+ attrVal = CSdpAttrValueString::NewStringL(_L8("Symbian Ltd."));
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0102, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x201 (service database state) to 0
+ value1.FillZ(4);
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0201, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ return recHandle;
+}
+
+
+TSdpServRecordHandle BuildWAPL(RSdpDatabase& aDb, TUint8 aCN)
+/**
+ Record Wap should be used when building a record with a protocol ID
+ list consisting of L2CAP and RFCOMM, similar to Pagonis but containing
+ a profile descriptor list with LAN access using PPP.
+ This record is for a service of class "WAP bearer" - UUID16 0x1113
+**/
+ {
+ TBuf8<4> value1;
+ TBuf8<4> value2;
+ TSdpServRecordHandle recHandle;
+ CSdpAttrValue* attrVal = 0;
+ CSdpAttrValueDES* attrValDES = 0;
+
+
+ value1.FillZ(4);
+ value2.FillZ(4);
+
+ // Set Attr 1 (service class list) to list with UUID = 0x1113 (WAP access device)
+ aDb.CreateServiceRecordL(TUUID(TUint16(0x1113)), recHandle);
+ test.Printf(_L("WAP Service Record Created - Handle: 0x%x!\n\n"), recHandle);
+
+ // Set Attr 2 (service record state) to 0
+ value1.FillZ(4);
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x02, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set attr 4 (protocol list) to L2CAP, and RFCOMM
+ value1.FillZ(4);
+ value1[3] = 3;
+ value2.FillZ(4);
+ value2[3] = aCN;
+ attrValDES = CSdpAttrValueDES::NewDESL(0);
+ CleanupStack::PushL(attrValDES);
+ attrValDES
+ ->StartListL()
+ ->BuildDESL()
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint16(0x0100))) // L2CAP
+ ->BuildUintL(value1)
+ ->EndListL()
+ ->BuildDESL()
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint16(0x0003))) // RFCOMM
+ ->BuildUintL(value2)
+ ->EndListL()
+ ->EndListL();
+ aDb.UpdateAttributeL(recHandle, 0x04, *attrValDES);
+ CleanupStack::PopAndDestroy();
+ attrValDES = 0;
+
+ // Set Attr 5 (browse group list) to list with one UUID
+ // 0x1101 (serial port class)
+ // this should be updated with other service classes when other services are added.
+ attrValDES = CSdpAttrValueDES::NewDESL(0);
+ CleanupStack::PushL(attrValDES);
+ attrValDES
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint32(0x1002)))
+ ->EndListL();
+ aDb.UpdateAttributeL(recHandle, 0x05, *attrValDES);
+ CleanupStack::PopAndDestroy();
+ attrValDES = 0;
+
+
+ // Set Attr 0x006 (language base)
+ value1.FillZ(4);
+ value1[2] = 0x65;
+ value1[3] = 0x6e;
+ TBuf8<4> val2;
+ TBuf8<4> val3;
+ val2.FillZ(4);
+ val3.FillZ(4);
+ val2[3] = 0x6a;
+ val3[2] = 0x01;
+
+ attrValDES = CSdpAttrValueDES::NewDESL(0);
+ CleanupStack::PushL(attrValDES);
+ attrValDES
+ ->StartListL()
+ ->BuildUintL(value1) // english
+ ->BuildUintL(val2) // UTF-8
+ ->BuildUintL(val3) // language base
+ ->EndListL();
+ aDb.UpdateAttributeL(recHandle, 0x06, *attrValDES);
+ CleanupStack::PopAndDestroy();
+ attrValDES = 0;
+
+ // Set Attr 0x007 (time to live) to 1200 (0x4B0) seconds (20 minutes)
+ value1.FillZ(4);
+ value1[2]=4;
+ value1[3]=0xb0;
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x07, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x008 (availability) to 0xff - fully available - not in use
+ value1.FillZ(4);
+ value1[3]=0xff;
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x08, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x009 (profile descriptor) to confuse the BTCOMM client when looking for LANP
+ value1.FillZ(4);
+ value1[3] = 1;
+ attrValDES = CSdpAttrValueDES::NewDESL(0);
+ CleanupStack::PushL(attrValDES);
+ attrValDES
+ ->StartListL()
+ ->BuildDESL()
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint16(0x1102))) // LAN access using PPP
+ ->BuildUintL(value1)
+ ->EndListL()
+ ->EndListL();
+ aDb.UpdateAttributeL(recHandle, 0x09, *attrValDES);
+ CleanupStack::PopAndDestroy();
+ attrValDES = 0;
+
+
+ // Set Attr 0x100 (default Name) to string
+ attrVal = CSdpAttrValueString::NewStringL(_L8("Pagonis Service"));
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0100, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x101 (def. description) to string
+ attrVal = CSdpAttrValueString::NewStringL(_L8("It's all Greek to me!"));
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0101, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x102 (def. provider) to Symbian
+ attrVal = CSdpAttrValueString::NewStringL(_L8("Symbian Ltd."));
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0102, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ // Set Attr 0x201 (service database state) to 0
+ value1.FillZ(4);
+ attrVal = CSdpAttrValueUint::NewUintL(value1);
+ CleanupStack::PushL(attrVal);
+ aDb.UpdateAttributeL(recHandle, 0x0201, *attrVal);
+ CleanupStack::PopAndDestroy();
+ attrVal = 0;
+
+ return recHandle;
+}
+
+
+
+void Test0()
+/**
+ Client/server test.
+**/
+ {
+ FLOG(_L("Running test 0"));
+ //FIXME: TRAPD?
+ test.Start(_L("Test 0 -- Client/Server"));
+ TInt ret;
+ LoadLDD_PDD();
+
+ RSdp sdp;
+ ret = sdp.Connect();
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+ RSdpDatabase db;
+ ret = db.Open(sdp);
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+ TSdpServRecordHandle recHandle = 0;
+ TUUID uuid = TUUID(0x20000); //prevents warning
+ db.CreateServiceRecordL(uuid, recHandle);
+ test.Printf(_L("Service Record Created - Handle: 0x%x!\n\n"), recHandle);
+ CSdpAttrValueDES* list = CSdpAttrValueDES::NewDESL(NULL);
+ MSdpElementBuilder* bldr= list;
+ CleanupStack::PushL(list);
+
+ bldr
+ ->StartListL()
+ ->BuildUUIDL(TUUID(TUint32(0x20002000)))
+ ->BuildUUIDL(TUUID(TUint32(0x11112222), TUint32(0x33334444),
+ TUint32(0x55556666), TUint32(0x77778888)))
+ ->BuildUUIDL(TUUID(TUint32(0x40000)))
+ ->EndListL();
+ //db.CreateServiceRecordL(*list, recHandle);
+ CleanupStack::PopAndDestroy(); //list
+ //test.Printf(_L("Service Record Created - Handle: 0x%x!\n\n"), recHandle);
+ //User::WaitForRequest(status);
+ //if(status==KErrNone)
+ // test.Printf(_L("Service Record Created - Handle: 0x%x!\n\n"), recHandlePckgBuf());
+ //else
+ // test.Printf(_L("Service Record Creation ERROR %d!\n\n"), status.Int());
+
+ TBuf8<8> buf8(_L8("Mel!"));
+ buf8[1] = 'E';
+ buf8[2] = 'L';
+ TDesC16 buf16(_L("Nicky!"));
+ db.UpdateAttributeL(recHandle, 0x3454, buf8);
+ db.UpdateAttributeL(recHandle, 0x3455, _L("Nicky!"));
+ db.UpdateAttributeL(recHandle, 0x3455, _L("Micky!"));
+ db.UpdateAttributeL(recHandle, 0x3456, 0x9999);
+ db.DeleteAttributeL(recHandle, 0x3456);
+ db.UpdateAttributeL(recHandle, 0x3456, 0x7777);
+ db.DeleteAttributeL(recHandle, 0x5555); //does not exist!
+ //db.DeleteRecordL(recHandleSpecial);
+ db.Close();
+ sdp.Close();
+ test.End();
+ }
+
+
+void Test1()
+/**
+ Client/server test for use with John Pagonis.
+ Suitable database built on client side, and placed in server.
+ Server left alive till user chooses to kill it.
+**/
+ {
+ FLOG(_L("Running test 1"));
+ //FIXME: TRAPD?
+ test.Start(_L("Test 1 -- Client/Server for BTCOMM testing...\n"));
+ test.Printf(_L("This builds a database with three service records\n"));
+ test.Printf(_L("The First one (UUID 1101) containing protocol attribute value: L2CAP, 3; RFCOMM, 1\n"));
+ test.Printf(_L("the second (UUID 1102 LANP) containing protocol attribute value: L2CAP, 3; RFCOMM, 2.\n"));
+ test.Printf(_L("the third (UUID 1103) containing protocol attribute value: L2CAP, 3; RFCOMM, 3.\n"));
+ test.Printf(_L("the third is a WAP server record and should never be selected\n"));
+ test.Printf(_L("The server then remains in listening mode\n"));
+ test.Printf(_L("until the user of Test 1 types 'x'.\n\n\n\n"));
+
+ TChar c;
+ RSdp sdp;
+ RSdpDatabase db;
+// User::After(5000000);
+ TInt ret;
+ LoadLDD_PDD();
+
+ ret = sdp.Connect();
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+ ret = db.Open(sdp);
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+
+ TSdpServRecordHandle recHandle1;
+ TSdpServRecordHandle recHandle2;
+ TSdpServRecordHandle recHandle3;
+
+ test.Printf(_L("SDP server with record 0, type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle1 = BuildPagonisL(db,TUUID(TUint32(0x1101)), 1);
+ test.Printf(_L("Pagonis record (0x1101), type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+
+ recHandle2 = BuildPagonisL(db,TUUID(TUint32(0x1102)), 2);
+ test.Printf(_L("Pagonis record (0x1102), type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle3 = BuildWAPL(db, 3);
+ test.Printf(_L("one WAP record, type 'x' to continue.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ test.Printf(_L("The database is now ready to test, type 'x' to exit.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+/**/
+ db.DeleteRecordL(recHandle2);
+
+ test.Printf(_L("The database has now had the second Pagonis record removed.\
+ \nWhen you have finished using this database please type 'x'.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+ db.UpdateAttributeL(recHandle1, 0x3455, _L("Nicky!"));
+ test.Printf(_L("\nTo check on updating record STATE attribute we have now\
+ \nupdated one random attribute in the first Pagonis record.\
+ \nPlease type 'x' AGAIN.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+ db.UpdateAttributeL(recHandle1, 0x3455, _L("Nicky!"));
+ test.Printf(_L("\nTo check on updating record STATE attribute we have now\
+ \nupdated ONCE AGAIN a random attribute in the first Pagonis\
+ \nrecord.\
+ \nPlease type 'x' ONCE AGAIN.\n\n"));
+ c = test.Getch();
+ db.DeleteAttributeL(recHandle1, 0x3455);
+ while (c!='x' && c!='X')
+ c = test.Getch();
+ test.Printf(_L("\nTo check on updating record STATE attribute we have now\
+ \ndeleted an attribute in the first Pagonis\
+ \nrecord.\
+ \nPlease type 'x' YET AGAIN - THIS TIME TO KILL THE DATABASE.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+ db.DeleteAttributeL(recHandle1, 0x3455);
+/**/
+ db.DeleteRecordL(recHandle3);
+ // Record with recHandle2 has already been deleted
+ db.DeleteRecordL(recHandle1);
+ db.Close();
+ sdp.Close();
+
+
+ test.End();
+ }
+
+
+
+
+void TestD()
+/**
+ Client/server test for use with John Pagonis.
+ Suitable database built on client side, and placed in server.
+ Server left alive till user chooses to kill it.
+**/
+ {
+ FLOG(_L("Running test D"));
+ //FIXME: TRAPD?
+ test.Start(_L("Test D -- Client/Server for BTCOMM testing...\n"));
+ test.Printf(_L("This builds a database with four service records\n"));
+ test.Printf(_L("The first one (UUID 1103 WAP) containing protocol attribute value: L2CAP, 3; RFCOMM, 3\n"));
+ test.Printf(_L("the second (UUID 1101) containing protocol attribute value: L2CAP, 3; RFCOMM, 1.\n"));
+ test.Printf(_L("the third (UUID 1103 WAP) containing protocol attribute value: L2CAP, 3; RFCOMM, 4.\n"));
+ test.Printf(_L("the forth (UUID 1102 LANP) containing protocol attribute value: L2CAP, 3; RFCOMM, 2.\n"));
+ test.Printf(_L("The server then remains in listening mode\n"));
+ test.Printf(_L("until the user of Test D types 'x'.\n\n\n\n"));
+
+ TChar c;
+ RSdp sdp;
+ RSdpDatabase db;
+// User::After(5000000);
+ TInt ret;
+ LoadLDD_PDD();
+
+ ret = sdp.Connect();
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+ ret = db.Open(sdp);
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+
+ TSdpServRecordHandle recHandle1;
+ TSdpServRecordHandle recHandle2;
+ TSdpServRecordHandle recHandle3;
+ TSdpServRecordHandle recHandle4;
+
+ test.Printf(_L("SDP server with record 0, type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle3 = BuildWAPL(db, 3);
+ test.Printf(_L("one WAP record, type 'x' to continue.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle1 = BuildPagonisL(db,TUUID(TUint32(0x1101)), 1);
+ test.Printf(_L("Pagonis record (0x1101), type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle4 = BuildWAPL(db, 4);
+ test.Printf(_L("one WAP record, type 'x' to continue.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle2 = BuildPagonisL(db,TUUID(TUint32(0x1102)), 2);
+ test.Printf(_L("Pagonis record (0x1102), type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+
+ test.Printf(_L("The database is now ready to test, type 'x' to exit.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+ db.DeleteRecordL(recHandle4);
+ db.DeleteRecordL(recHandle3);
+ db.DeleteRecordL(recHandle2);
+ db.DeleteRecordL(recHandle1);
+ db.Close();
+ sdp.Close();
+
+
+ test.End();
+ }
+
+
+void TestE()
+/**
+ Client/server test for use with John Pagonis.
+ Suitable database built on client side, and placed in server.
+ Server left alive till user chooses to kill it.
+**/
+ {
+ FLOG(_L("Running test D"));
+ //FIXME: TRAPD?
+ test.Start(_L("Test E -- Client/Server for BTCOMM testing...\n"));
+ test.Printf(_L("This builds a database with four service records\n"));
+ test.Printf(_L("The first one (UUID 1103 WAP) containing protocol attribute value: L2CAP, 3; RFCOMM, 3\n"));
+ test.Printf(_L("the second (UUID 1101) containing protocol attribute value: L2CAP, 3; RFCOMM, 1.\n"));
+ test.Printf(_L("the third (UUID 1102 LANP) containing protocol attribute value: L2CAP, 3; RFCOMM, 2.\n"));
+ test.Printf(_L("the forth (UUID 1103 WAP) containing protocol attribute value: L2CAP, 3; RFCOMM, 4.\n"));
+ test.Printf(_L("The server then remains in listening mode\n"));
+ test.Printf(_L("until the user of Test E types 'x'.\n\n\n\n"));
+
+ TChar c;
+ RSdp sdp;
+ RSdpDatabase db;
+// User::After(5000000);
+ TInt ret;
+ LoadLDD_PDD();
+
+ ret = sdp.Connect();
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+ ret = db.Open(sdp);
+ if(ret!=KErrNone)
+ {
+ test.End();
+ return;
+ }
+
+ TSdpServRecordHandle recHandle1;
+ TSdpServRecordHandle recHandle2;
+ TSdpServRecordHandle recHandle3;
+ TSdpServRecordHandle recHandle4;
+
+ test.Printf(_L("SDP server with record 0, type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle3 = BuildWAPL(db, 3);
+ test.Printf(_L("one WAP record, type 'x' to continue.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle1 = BuildPagonisL(db,TUUID(TUint32(0x1101)), 1);
+ test.Printf(_L("Pagonis record (0x1101), type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle2 = BuildPagonisL(db,TUUID(TUint32(0x1102)), 2);
+ test.Printf(_L("Pagonis record (0x1102), type 'x' to continue.\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+ recHandle4 = BuildWAPL(db, 4);
+ test.Printf(_L("one WAP record, type 'x' to continue.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+
+
+ test.Printf(_L("The database is now ready to test, type 'x' to exit.\n\n"));
+ c = test.Getch();
+ while (c!='x' && c!='X')
+ c = test.Getch();
+ db.DeleteRecordL(recHandle4);
+ db.DeleteRecordL(recHandle3);
+ db.DeleteRecordL(recHandle2);
+ db.DeleteRecordL(recHandle1);
+ db.Close();
+ sdp.Close();
+
+
+ test.End();
+ }
+
+void WhichTest()
+ {
+ TChar c;
+ test.Printf(_L("\nwhich test? "));
+ test.Printf(_L("\npress 0 for UUID 1101, 1102, 1103 "));
+ test.Printf(_L("\npress 1 for UUID 1103, 1101, 1103, 1102 "));
+ test.Printf(_L("\npress 2 for UUID 1103, 1101, 1102, 1103 "));
+ c = test.Getch();
+ switch (c)
+ {
+ case '0':
+ Test1();
+ break;
+ case '1':
+ TestD();
+ break;
+ case '2':
+ TestE();
+ break;
+ default:
+ break;
+ }
+ }
+
+
+
+
+
+
+void Test2()
+/**
+ Builds up a static DB, and prints it,
+ using the record and attribute iteraotrs, and a
+ simple console-printing attribute value visitor.
+**/
+ {
+ //FIXME: TRAPD?
+ test.Start(_L("Test 2 -- Build and print Db"));
+// CSdpDatabase *theDb = BuildDbL();
+ CSdpDatabase *theDb = BuildUpf4DbL();
+ test(theDb!=NULL);
+ PrintDb(*theDb, *test.Console());
+ delete theDb;
+
+ test.End();
+ }
+
+void Test3()
+/**
+ Builds up a static DB, and copies it into the RSdpDatabase
+**/
+ {
+ //FIXME: TRAPD?
+ test.Start(_L("Test 3 -- Build and print Db"));
+// CSdpDatabase *theDb = BuildDbL();
+ CSdpDatabase *theDb = BuildUpf4DbL();
+ test(theDb!=NULL);
+ CleanupStack::PushL(theDb);
+
+ RSdp sdp;
+ RSdpDatabase db;
+ TInt ret;
+ LoadLDD_PDD();
+
+ test.Next(_L("Opening SDP Database"));
+ ret = sdp.Connect();
+ test(ret==KErrNone);
+ CleanupClosePushL(sdp);
+ ret = db.Open(sdp);
+ test(ret==KErrNone);
+ CleanupClosePushL(db);
+
+ test.Next(_L("Storing database"));
+ RegisterDatabaseInServerL(db, *theDb);
+
+ test.Next(_L("Database stored. Now run your tests! Press any key to close SDDB"));
+ test.Getch();
+
+ CleanupStack::PopAndDestroy(3); // db, sdp, theDb
+
+ test.End();
+ }
+
+
+void Test4()
+/**
+ Builds a static DB and searches it for a
+ UUID search pattern (as per SDP service search
+ requests)
+**/
+ {
+ test.Start(_L("Test 2 -- Service search over Db"));
+ CSdpDatabase *theDb = BuildDbL();
+
+ CSdpSearchPattern* thePattern = CSdpSearchPattern::NewL();
+ //Service pattern with one UUID in it...
+ test.Next(_L("Doing un-encoded tests"));
+ test.Next(_L("Searching for SDP server service UUID (0x1000)"));
+ thePattern->AddL(TUUID(TUint16(0x1000)));
+ SearchDbL(*theDb, *thePattern, 2); // Expect 2 matches
+
+ test.Next(_L("Searching for SDP server service and bogoid UUID"));
+ thePattern->AddL(TUUID(TUint32(0x55667788)));
+ SearchDbL(*theDb, *thePattern, 1); // Expect 1 matches
+
+ test.Next(_L("Searching for SDP server service and two bogoid UUID"));
+ thePattern->AddL(TUUID(TUint32(0x11112222)));
+ SearchDbL(*theDb, *thePattern, 0); // Expect 0 matches
+
+ test.Next(_L("Searching for RFCOMM uuid"));
+ thePattern->Reset();
+ thePattern->AddL(TUUID(TUint16(0x0003)));
+ SearchDbL(*theDb, *thePattern, 1); // Expect 1 matches
+
+
+ thePattern->Reset();
+
+ theDb->EncodeDbL();
+
+ test.Next(_L("Doing encoded tests"));
+ test.Next(_L("Searching for SDP server service UUID (0x1000)"));
+ thePattern->AddL(TUUID(TUint16(0x1000)));
+ SearchDbL(*theDb, *thePattern, 2); // Expect 2 matches
+
+ test.Next(_L("Searching for SDP server service and bogoid UUID"));
+ thePattern->AddL(TUUID(TUint32(0x55667788)));
+ SearchDbL(*theDb, *thePattern, 1); // Expect 1 matches
+
+ test.Next(_L("Searching for SDP server service and two bogoid UUID"));
+ thePattern->AddL(TUUID(TUint32(0x11112222)));
+ SearchDbL(*theDb, *thePattern, 0); // Expect 0 matches
+
+ test.Next(_L("Searching for RFCOMM uuid"));
+ thePattern->Reset();
+ thePattern->AddL(TUUID(TUint16(0x0003)));
+ SearchDbL(*theDb, *thePattern, 1); // Expect 1 matches
+
+
+
+ delete thePattern;
+ delete theDb;
+ test.End();
+ }
+
+void TestEncoder(TInt aType, CSdpDatabase *aDb)
+ {
+ TInt64 seed = aType * 49;
+
+ test.Start(_L("Test 3 -- Encoder & Parser"));
+ CSdpDatabase *builtDb = CSdpDatabase::NewL();
+
+ HBufC8* outbuf = HBufC8::New(1024);
+ TPtr8 writePtr (outbuf->Des());
+ TElementEncoder theEncoder(writePtr);
+ CElementParser* theParser = CElementParser::NewL(0);
+ CSdpAttrIdMatchList *theAttrList = CSdpAttrIdMatchList::NewL();
+
+ theAttrList->AddL(KAttrRangeAll);
+
+ test.Next(_L("Encode and parse ref DB"));
+ {
+ for(TServRecordIter recIter(aDb->RecordIter()); recIter; recIter++)
+ {// Iterate thru records in Db
+ TInt startPos = writePtr.Length();
+ CAttrExtractVisitor::EncodeAttributesL(theEncoder, *recIter, *theAttrList);
+ // grows writePtr
+
+ CSdpServRecord* builtRec = CSdpServRecord::NewL();
+ theParser->Reset(builtRec);
+ TInt incr = 1;
+ TBool moreExpected = ETrue;
+ for (TInt i = startPos; i < writePtr.Length(); i += incr)
+ {// parse it back, in inreasing chunks
+ switch(aType)
+ {
+ case 0:
+ incr += 1;
+ break;
+ case 1:
+ incr <<= 1;
+ break;
+ case 2:
+ default:
+ incr = Math::Rand(seed) % (i+2);
+ }
+ incr=Min(incr, writePtr.Length() - i);
+ moreExpected = theParser->BufferedParseL(writePtr.Mid(i, incr));
+ }
+ test(!moreExpected);
+ builtDb->AddRecord(builtRec);
+ }
+ }
+
+ HBufC8* outbuf2 = HBufC8::New(outbuf->Size());
+ writePtr.Set (outbuf2->Des());
+
+ test.Next(_L("Re-Encode the DB built from parser"));
+ {
+ for(TServRecordIter recIter(builtDb->RecordIter()); recIter; recIter++)
+ {// Iterate thru records in Db
+ CAttrExtractVisitor::EncodeAttributesL(theEncoder, *recIter, *theAttrList);
+ }
+ }
+
+// test(*outbuf == *outbuf2);
+
+ // The bit below is equivalent to the above line, only easier to debug
+ test(outbuf->Length() == outbuf2->Length());
+ for (TInt i = 0; i < outbuf->Length(); ++i)
+ {
+ test((*outbuf)[i] == (*outbuf2)[i]);
+ }
+
+ delete outbuf;
+ delete outbuf2;
+ delete theParser;
+ delete theAttrList;
+ delete builtDb;
+ test.End();
+ }
+
+
+void Test5()
+ {
+ for (TInt i = 0; i < 8; ++i)
+ {
+ test.Next(_L("Doing tests with ref Db"));
+ CSdpDatabase *theDb = BuildDbL();
+ TestEncoder(i, theDb);
+ delete theDb;
+
+ test.Next(_L("Doing tests with UPF4 Db"));
+ theDb = BuildUpf4DbL();
+ TestEncoder(i, theDb);
+ delete theDb;
+ }
+ }
+
+void Test6()
+ {
+ test.Start(_L("Test 6 -- Database size and encoding stuff"));
+ CSdpDatabase *theDb = BuildDbL();
+
+ const TUint KExpectedSizes[] =
+ {
+ 5, 5, 12, 28,
+ 14, 5, 5, 22,
+ 23, 35, 5, 10,
+ 3, 15, 19,
+ };
+ test.Next(_L("Testing the size functions"));
+ TInt ind = 0;
+ for(TServRecordIter recIter(theDb->RecordIter()); recIter; recIter++)
+ {// Iterate thru records in Db
+ for(TServAttrIter attrIter((*recIter).AttributeIter()); attrIter; attrIter++)
+ {// Iterate thru attributes in record
+ TUint size = TElementEncoder::EncodedSize((*attrIter).Value().Type(), (*attrIter).Value().DataSize());
+ test.Printf(_L("Attribute value Encoded size is %d\n"), size);
+ test(size == KExpectedSizes[ind]);
+ ++ind;
+ }
+ }
+
+ delete theDb;
+
+ test.Next(_L("Testing attribute match list stuff"));
+ CSdpAttrIdMatchList *theAttrList = CSdpAttrIdMatchList::NewL();
+
+ theAttrList->AddL(TAttrRange(10, 15)); // insert at beginning -> 10-15
+ theAttrList->AddL(TAttrRange(30, 40)); // insert at end -> 10-15,30-40
+ theAttrList->AddL(TAttrRange(18, 19)); // insert between 2 -> 10-15, 18-19, 30-40
+ theAttrList->AddL(TAttrRange(27, 29)); // append to start of another range -> 10-15, 18-19, 27-40
+ theAttrList->AddL(TAttrRange(41, 45)); // append to end of another range -> 10-15, 18-19, 27-45
+ theAttrList->AddL(TAttrRange(16, 17)); // join 2 ranges together -> 10-19, 27-45
+ theAttrList->AddL(TAttrRange(21, 24)); // insert between 2 -> 10-19, 21-24, 27-45
+ test(theAttrList->Count() == 3);
+
+ TInt posn;
+ test(theAttrList->InMatchListRange(10, posn));
+ test(theAttrList->InMatchListRange(11, posn));
+ test(theAttrList->InMatchListRange(15, posn));
+
+ test(theAttrList->InMatchListRange(21, posn));
+ test(theAttrList->InMatchListRange(22, posn));
+ test(theAttrList->InMatchListRange(23, posn));
+ test(theAttrList->InMatchListRange(24, posn));
+
+ test(theAttrList->InMatchListRange(45, posn));
+
+ theAttrList->RemoveL(TAttrRange(12, 14)); // mid-range -> 10-11, 15-19, 21-24, 27-45
+ test(theAttrList->Count() == 4);
+
+ theAttrList->RemoveL(TAttrRange(12, 14)); // no change -> 10-11, 15-19, 21-24, 27-45
+ theAttrList->RemoveL(TAttrRange(14, 16)); // overlap start -> 10-11, 17-19, 21-24, 27-45
+ test(theAttrList->Count() == 4);
+ theAttrList->RemoveL(TAttrRange(17, 20)); // remove one item -> 10-11, 21-24, 27-45
+ theAttrList->RemoveL(TAttrRange(40, 45)); // end of range -> 10-11, 21-24, 27-39
+ theAttrList->RemoveL(TAttrRange(28, 28)); // range of one -> 10-11, 21-24, 27, 29-39
+ test(theAttrList->Count() == 4);
+ test(theAttrList->InMatchList(27));
+ theAttrList->RemoveL(TAttrRange(26, 28)); // remove range of one -> 10-11, 21-24, 29-39
+ test(theAttrList->Count() == 3);
+
+ theAttrList->AddL(TAttrRange(15, 15)); // insert between 2 -> 10-11, 15, 21-24, 29-39
+ theAttrList->AddL(TAttrRange(17, 18)); // insert between 2 -> 10-11, 15, 17-18, 21-24, 29-39
+ test(theAttrList->Count() == 5);
+ theAttrList->AddL(TAttrRange(13, 26)); // obliterate 3 with one big insertion -> 10-11, 13-26, 29-39
+ test(theAttrList->Count() == 3);
+ theAttrList->RemoveL(TAttrRange(15, 17)); //-> 10-11, 13-14, 18-26, 29-39
+ theAttrList->RemoveL(TAttrRange(19, 21)); //-> 10-11, 13-14, 18, 22-26, 29-39
+ theAttrList->RemoveL(TAttrRange(23, 24)); //-> 10-11, 13-14, 18, 22, 25-26, 29-39
+ test(theAttrList->Count() == 6);
+ theAttrList->AddL(TAttrRange(16, 28)); // obliterate 3 with one big deletion -> 10-11, 13-14, 29-39
+ test(theAttrList->Count() == 3);
+
+ theAttrList->RemoveL(TAttrRange(31, 31)); //-> 10-11, 13-14, 29-30 32-39
+ test(theAttrList->Count() == 4);
+ theAttrList->AddL(TAttrRange(28, 31)); // new range contiguous with 2 current ranges -> 10-11, 13-14, 28-39
+ test(theAttrList->Count() == 3);
+
+ theAttrList->RemoveL(TAttrRange(0, 45)); // remove all entries
+
+ theAttrList->AddL(TAttrRange(50, 300)); // 50-300
+
+ test(theAttrList->InMatchList(50));
+ test(theAttrList->InMatchList(256));
+ test(theAttrList->InMatchList(300));
+
+ test(theAttrList->InMatchList(301) == EFalse);
+ test(theAttrList->InMatchList(49) == EFalse);
+
+ theAttrList->AddL(TAttrRange(302, 304)); // 50-300, 302-304
+ test(theAttrList->Count() == 2);
+
+ theAttrList->AddL(TAttrRange(50, 50));
+ test(theAttrList->Count() == 2);
+
+ theAttrList->AddL(TAttrRange(45, 310)); // 45-310
+ test(theAttrList->Count() == 1);
+ test(theAttrList->InMatchList(45));
+ test(theAttrList->InMatchList(310));
+ test(theAttrList->InMatchList(311) == EFalse);
+ test(theAttrList->InMatchList(44) == EFalse);
+
+ theAttrList->AddL(TAttrRange(45, 200)); // 45-310
+ test(theAttrList->Count() == 1);
+
+ theAttrList->RemoveL(TAttrRange(50, 60)); // 45-49 61-310
+ test(theAttrList->Count() == 2);
+ test(theAttrList->InMatchList(49));
+ test(theAttrList->InMatchList(50) == EFalse);
+ test(theAttrList->InMatchList(60) == EFalse);
+ test(theAttrList->InMatchList(61));
+ test(theAttrList->InMatchList(45));
+ test(theAttrList->InMatchList(310));
+ test(theAttrList->InMatchList(311) == EFalse);
+
+ theAttrList->RemoveL(TAttrRange(55, 65)); // 45-49 66-310
+ test(theAttrList->Count() == 2);
+ test(theAttrList->InMatchList(66));
+ test(theAttrList->InMatchList(65) == EFalse);
+
+ theAttrList->RemoveL(TAttrRange(55, 55));
+ test(theAttrList->Count() == 2);
+ theAttrList->RemoveL(TAttrRange(1, 2));
+ theAttrList->RemoveL(TAttrRange(400, 500));
+ test(theAttrList->Count() == 2);
+
+ theAttrList->RemoveL(TAttrRange(40, 70)); // 71-310
+ test(theAttrList->Count() == 1);
+
+ theAttrList->AddL(TAttrRange(5, 39)); // 5-39, 71-310
+ test(theAttrList->Count() == 2);
+
+ theAttrList->RemoveL(TAttrRange(38, 38)); // 5-37, 39, 71-310
+ test(theAttrList->Count() == 3);
+ theAttrList->RemoveL(TAttrRange(36, 36)); // 5-35, 37, 39, 71-310
+ test(theAttrList->Count() == 4);
+
+ theAttrList->RemoveL(TAttrRange(30, 70)); // 5-29, 71-310
+ test(theAttrList->Count() == 2);
+
+ theAttrList->RemoveL(TAttrRange(1, 309)); // 310
+ test(theAttrList->Count() == 1);
+ test(theAttrList->InMatchList(310));
+ test(theAttrList->InMatchList(309) == EFalse);
+ test(theAttrList->InMatchList(311) == EFalse);
+
+ theAttrList->RemoveL(TAttrRange(1, 310)); // none
+ test(theAttrList->Count() == 0);
+
+
+ theAttrList->AddL(TAttrRange(45, 310)); // 45-310
+ test(theAttrList->Count() == 1);
+
+ theAttrList->AddL(TAttrRange(2000)); // 45-310, 2000
+ test(theAttrList->Count() == 2);
+ test(theAttrList->InMatchList(2000));
+ test(theAttrList->InMatchList(2001) == EFalse);
+
+ theAttrList->AddL(TAttrRange(2002)); // 45-310, 2000, 2002
+ test(theAttrList->Count() == 3);
+
+ theAttrList->AddL(TAttrRange(2004)); // 45-310, 2000, 2002, 2004
+ test(theAttrList->Count() == 4);
+ test(theAttrList->InMatchList(2004));
+ test(theAttrList->InMatchList(2003) == EFalse);
+
+ theAttrList->AddL(TAttrRange(2003)); // 45-310, 2000, 2002-2004
+ test(theAttrList->Count() == 3);
+
+ theAttrList->AddL(TAttrRange(301, 2001)); // 45-2004
+ test(theAttrList->Count() == 1);
+ test(theAttrList->InMatchList(45));
+ test(theAttrList->InMatchList(2004));
+ test(theAttrList->InMatchList(0) == EFalse);
+ test(theAttrList->InMatchList(2010) == EFalse);
+
+ TInt count = theAttrList->Count();
+ for (TUint16 i = 3000; i < 4000; i += 2)
+ {
+ theAttrList->AddL(TAttrRange(i, i));
+ ++count;
+ test(theAttrList->Count() == count);
+ test(theAttrList->InMatchList(i));
+ test(theAttrList->InMatchList(TUint16(i-1)) == EFalse);
+ test(theAttrList->InMatchList(TUint16(i+1)) == EFalse);
+ }
+
+ for (TUint16 j = 3001; j < 3501; j += 2)
+ {
+ theAttrList->AddL(TAttrRange(j, j));
+ --count;
+ test(theAttrList->Count() == count);
+ test(theAttrList->InMatchList(j));
+ test(theAttrList->InMatchList(TUint16(j-1)));
+ test(theAttrList->InMatchList(TUint16(j+1)));
+ }
+
+ for (TUint16 k = 3001; k < 3400; k += 2)
+ {
+ theAttrList->RemoveL(TAttrRange(k, k));
+ ++count;
+ test(theAttrList->Count() == count);
+ test(theAttrList->InMatchList(k) == EFalse);
+ test(theAttrList->InMatchList(TUint16(k-1)));
+ test(theAttrList->InMatchList(TUint16(k+1)));
+ }
+
+ theAttrList->AddL(TAttrRange(0, 5000));
+ test(theAttrList->Count() == 1);
+ test(theAttrList->InMatchList(0));
+ test(theAttrList->InMatchList(5000));
+ test(theAttrList->InMatchList(5001) == EFalse);
+ test(theAttrList->InMatchList(KMaxTUint16) == EFalse);
+
+ theAttrList->RemoveL(TAttrRange(0, 5000));
+ test(theAttrList->Count() == 0);
+
+ delete theAttrList;
+
+ test.End();
+
+ }
+
+/* moved out to the database dll as a utility method
+CSdpDatabase * EncodeDb(CSdpDatabase * nonEncodedDb)
+{
+ CSdpDatabase *encDb = CSdpDatabase::NewL();
+
+ TUint8 outbuf[72];
+ TPtr8 writePtr (outbuf, 0, 72);
+ CSdpServRecord *theRec = CSdpServRecord::NewL();
+ TElementEncoder theEncoder(writePtr);
+
+ test.Next(_L("Test attribute encoder"));
+ for(TServRecordIter recIter(nonEncodedDb->RecordIter()); recIter; recIter++)
+ {// Iterate through records in Db
+
+ for (TServAttrIter attrIter((*recIter).AttributeIter()); attrIter; attrIter++)
+ {// iterate through attributes in record
+ writePtr.Set(outbuf, 0, 72); // bug, just declaring this (see above) didn't reset the pointer on each loop
+
+ CAttrEncoderVisitor::EncodeAttributeL(theEncoder, (*attrIter).Value());
+ TBuf8<sizeof(TUint)> val(2);
+ TElementEncoder::PutUint(&val[0], (*attrIter).AttributeID(), 2);
+ test.Printf(_L("AttrID:0x%02x%02x, <"), val[0], val[1]);
+ HexDes(writePtr);
+ test.Printf(_L(">\n"));
+ theRec->BuildUintL(val)->BuildEncodedL(writePtr);
+ }
+ encDb->AddRecord(theRec);
+ theRec = CSdpServRecord::NewL(); // need a new one
+ }
+ delete theRec;
+ return encDb;
+}
+*/
+
+// build an encoded version of the database then print it.
+void Test7()
+ {
+ test.Start(_L("Test 7 -- Encoded database"));
+ CSdpDatabase *theDb = BuildUpf4DbL();
+ theDb->EncodeDbL();
+
+ test.Next(_L("Print encoded attributes"));
+ PrintDb(*theDb, *test.Console());
+
+ delete theDb;
+ test.End();
+ }
+
+// test the access routines.
+void ShowCollected( CSizeAccumulator* aCollector)
+{
+ __UHEAP_MARK;
+ CAttrPrintVisitor* theVisitor = new CAttrPrintVisitor(*test.Console());
+ TInt indRec, indAtt;
+ TUint leftOver;
+ TInt startSize = 0;
+ TInt nextLeft;
+ TInt nextSize;
+ TBool succ = EFalse;
+ TInt orig = aCollector->SizeLeft();
+ TInt hcount = aCollector->HandleCount();
+ test.Printf(_L("Size:%d, handles %d\n"), orig, hcount);
+ for (TInt i = 0; i<hcount; i++)
+ {
+ TSdpServRecordHandle hhand = aCollector->HandleAt(i);
+ TInt atcount = aCollector->AttrCount(i);
+ test.Printf(_L("HandleID:%x, attrib count:%d\n"), hhand, atcount);
+ for (TInt j = 0; j<atcount; j++)
+ {
+ CAttrSizeItem* atpointer = aCollector->AttributeOf(i, j);
+ test.Printf(_L("Attribute Pointer:%x\n"), atpointer);
+ test.Printf(_L("Attr:"));
+// HexDes(atpointer->Attr()->Value().Des());
+// just in case we get a non-encoded attribute
+ theVisitor->VisitAttributeL(*atpointer->Attr());
+ theVisitor->VisitAttributeValueL(atpointer->Attr()->Value(), atpointer->Attr()->Value().Type());
+ test.Printf(_L("\n"));
+ nextSize = atpointer->Size();
+ startSize += nextSize;
+ startSize += 3; // the header size...
+ indRec = 0;
+ indAtt = 0;
+ leftOver = 0;
+ succ = aCollector->StartAt(startSize, leftOver, indRec, indAtt);
+ if (succ)
+ {
+ nextLeft = aCollector->SizeLeft();
+ test.Printf(_L("updated start point by (%d+3) from %d to %d\n"), nextSize, orig, nextLeft);
+ test.Printf(_L("indices are L:%d, R:%d, A:%d\n"),leftOver, indRec, indAtt);
+ orig = nextLeft;
+ }
+ else
+ test.Printf(_L("failed to update start point by %d from %d\n"), nextSize, orig);
+
+
+ }
+ }
+ delete theVisitor;
+ __UHEAP_MARKEND;
+ test.Getch();
+}
+
+void Test8()
+ {
+ __UHEAP_MARK;
+ test.Start(_L("Test 8 -- Size visitor"));
+ CSdpDatabase *theDb = BuildUpf4DbL();
+ theDb->EncodeDbL();
+
+// test.Next(_L("Testing sizes of records"));
+ CSdpAttrIdMatchList *theAttrList = CSdpAttrIdMatchList::NewL();
+
+ theAttrList->AddL(TAttrRange(4)); // protocol descriptor list
+
+ theAttrList->AddL(TAttrRange(50, 300)); // mostly text based stuff
+
+ CSdpSearchPattern* thePattern = CSdpSearchPattern::NewL();
+//Service pattern with one UUID in it...
+ thePattern->AddL(TUUID(TUint16(0x1103)));
+ CSizeAccumulator* collector = CSizeAccumulator::NewL();
+ test.Next(_L("Testing for UUID 1103\n"));
+ CResponseSizeVisitor::SizeRespSSL(*theDb, *thePattern, *collector);
+ ShowCollected(collector);
+// Iterate thru records in Db for SizeRespARL
+ test.Next(_L("Testing for attr 4, 50-300\n"));
+ for(TServRecordIter recIter(theDb->RecordIter()); recIter; recIter++)
+ {
+ test.Printf(_L("\n...Sizing Record 0x%x\n"), (*recIter).Handle());
+ delete collector;
+ collector = CSizeAccumulator::NewL();
+ CResponseSizeVisitor::SizeRespARL((*recIter), *theAttrList, *collector); // what does it do if the collectors been used ?
+ ShowCollected(collector);
+ }
+//
+ test.Next(_L("Testing for attr 100\n"));
+ delete theAttrList;
+ theAttrList = CSdpAttrIdMatchList::NewL();
+ theAttrList->AddL(TAttrRange(0x0100)); // names
+ delete thePattern;
+ thePattern = CSdpSearchPattern::NewL();
+//Service pattern with one UUID in it...
+ thePattern->AddL(TUUID(TUint16(0x1002)));
+ delete collector;
+ collector = CSizeAccumulator::NewL();
+ CResponseSizeVisitor::SizeRespSAL(*theDb, *thePattern, *theAttrList, *collector);
+ ShowCollected(collector);
+ delete collector;
+ delete theAttrList;
+ delete thePattern;
+ delete theDb;
+ __UHEAP_MARKEND;
+ test.End();
+ }
+
+
+void Test9(TInt flag)
+ {
+ CSdpDatabase *theDb;
+ __UHEAP_MARK;
+ TChar c = 'c';
+ if(!flag)
+ {
+ c = test.Getch();
+ switch (c)
+ {
+ case 'A': case 'a':
+ test.Start(_L("Test 9 -- \"Rhubarb\" Continuation"));
+ //FIXME: TRAPD?
+ theDb = BuildContinuationDbL();
+ break;
+ case 'B': case 'b':
+ test.Start(_L("Test 9 -- Continuation with Nested Lists"));
+ //FIXME: TRAPD?
+ theDb = BuildNestedListDbL();
+ break;
+ default:
+ return;
+ }
+ }
+ else
+ {
+ test.Start(_L("Test 9 -- Prequal Database"));
+ //FIXME: TRAPD?
+ theDb = BuildPrequalDbL();
+ }
+
+ test(theDb!=NULL);
+ CleanupStack::PushL(theDb);
+ TServRecordIter recIter(theDb->RecordIter());
+ TServAttrIter attrIter((*recIter).AttributeIter());
+ TServAttrIter attrIter2((*recIter).AttributeIter());
+ for(; recIter; recIter++)
+ {// Iterate thru records in Db
+ attrIter = (*recIter).AttributeIter();
+ for(; attrIter; attrIter++)
+ {// Iterate thru attributes in record
+ if((*attrIter).Value().Type()==ETypeString)
+ {
+ TPtrC8 ptr((*attrIter).Value().Des());
+ if(ptr.Length()<0x100)
+ {
+ attrIter2 = attrIter;
+ }
+ }
+ }
+ }
+ if((*attrIter2).Value().Type()==ETypeString)
+ {
+ TPtrC8 ptr1((*attrIter2).Value().Des());
+ TBuf16<0x100> ptr(0);
+ for(TInt i = 0;i<ptr1.Length()&&i<(ptr.MaxLength()-3);++i)
+ ptr.Append(ptr1[i]);
+ if(c=='a'||c=='A')
+ {
+ test.Printf(_L("Id: %d\n"),(*attrIter2).AttributeID());
+ test.Printf(_L("String length: %d\n"),ptr.Length());
+ if(ptr.Length()<0x100)
+ test.Printf(_L("%s\n"),&ptr[0]);
+ }
+ }
+
+ RSdp sdp;
+ RSdpDatabase db;
+ TInt ret;
+ LoadLDD_PDD();
+
+ test.Next(_L("Opening SDP Database"));
+ ret = sdp.Connect();
+ if(ret!=KErrNone)
+ {
+ if(ret==KErrNotFound)
+ test.Printf(_L("Cannot start sdp server, could not find bluetooth.\n"));
+ else
+ test.Printf(_L("Cannot start sdp server.\n"));
+ test.Next(_L("PRESS ANY KEY.\n"));
+ test.Getch();
+
+ CleanupStack::PopAndDestroy(); // theDb
+ goto end;
+ }
+ test(ret==KErrNone);
+ CleanupClosePushL(sdp);
+ ret = db.Open(sdp);
+ test(ret==KErrNone);
+ CleanupClosePushL(db);
+
+ test.Next(_L("Storing database"));
+ RegisterDatabaseInServerL(db, *theDb);
+
+ test.Next(_L("Database stored. Now run your tests!"));
+ test.Next(_L("Press any key to close SDDB"));
+ test.Getch();
+
+ CleanupStack::PopAndDestroy(3); // db, sdp, theDb
+end:
+ __UHEAP_MARKEND;
+ test.End();
+ }
+
+void Test10()
+{
+ __UHEAP_MARK;
+//TUint32
+ TInt64 putVal32 = static_cast<TInt64>(0xBA1EFACE);
+ TPckgBuf<TUint32> value32Packaged;
+ SdpUtil::PutUint(&value32Packaged[0], putVal32, 4);
+
+ TUint32 getVal32= SdpUtil::GetUint(value32Packaged);
+ test.Printf(_L("SdpUtil: TPckgBuf<TUint32> created with 0x%08lx would return 0x%x\n"), putVal32, getVal32);
+
+
+ TBuf8<32/8> testValue32Packaged;
+ testValue32Packaged.SetLength(4);
+ testValue32Packaged = value32Packaged;
+
+ CSdpAttrValue* attrVal = 0;
+ attrVal = CSdpAttrValueUint::NewUintL(testValue32Packaged);
+ TUint getter = attrVal->Uint();
+ delete attrVal;
+
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%08lx returns 0x%x\n"), putVal32, getter);
+
+
+// Now we have confirmed that exercising SdpUtil this way is equivalent to using CSdpAttrValueUint's methods.
+// The CSdpAttrValueUint::Uint64 and CSdpAttrValueUint::Uint128 methods are now exported so we can test them,
+// but they use SdpUtil too, so..
+
+//TUint64
+// TPckgBuf<TUint64> putVal64Packaged =0x1234FACE5678ABCD; // Use this to test the full functionality
+ TPckgBuf<TUint64> putVal64Packaged =0x1234FACE; // This number is acceptable to the gcc_xml compiler
+
+ TUint64 putVal64 = putVal64Packaged();
+
+ TPckgBuf<TUint64> val64Packaged;
+ SdpUtil::PutUint64(&val64Packaged[0], putVal64);
+
+ TUint64 getVal64;
+ SdpUtil::GetUint64(val64Packaged, getVal64);
+
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%lx would return 0x%lx\n"), putVal64, getVal64);
+
+ TBuf8<64/8> testValue64Packaged;
+ testValue64Packaged.SetLength(8);
+ testValue64Packaged = val64Packaged;
+
+ CSdpAttrValue* attrVal64 = 0;
+ attrVal64 = CSdpAttrValueUint::NewUintL(testValue64Packaged);
+ TUint size64 = attrVal64->DataSize();
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%lx would be %d bytes long\n"), putVal64, size64);
+
+ CSdpAttrValueUint& attrValueUint64 = static_cast<CSdpAttrValueUint&>(*attrVal64);
+ attrValueUint64.Uint64(getVal64);
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%lx would return 0x%lx\n"), putVal64, getVal64);
+
+ delete attrVal64;
+
+
+//two TUint64s
+// TUint64 putLoVal = 0x1234FACE5678ABCD; // Use these to test the full functionality
+// TUint64 putHiVal = 0x3456789BA1EFACED;
+
+ TUint64 putLoVal = 0x1234FACE; // These numbers are acceptable to the gcc_xml compiler
+ TUint64 putHiVal = 0xBA1EACED;
+
+ TBuf8<128/8> putValue128Packaged;
+ putValue128Packaged.SetLength(16);
+
+ SdpUtil::PutUint128(&putValue128Packaged[0], putLoVal, putHiVal);
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%lx,0x%lx would be %d bytes long\n"), putHiVal, putLoVal, 16);
+
+ TUint64 getLoVal128;
+ TUint64 getHiVal128;
+ SdpUtil::GetUint128(putValue128Packaged, getLoVal128, getHiVal128);
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%lx,0x%lx would return 0x%lx,0x%lx\n"), putHiVal, putLoVal, getHiVal128, getLoVal128);
+
+ TBuf8<128/8> testValue128Packaged;
+ testValue128Packaged.SetLength(16);
+ testValue128Packaged = putValue128Packaged;
+
+ CSdpAttrValue* attrVal128 = 0;
+ attrVal128 = CSdpAttrValueUint::NewUintL(testValue128Packaged);
+ TUint size128 = attrVal128->DataSize();
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%lx,0x%lx would be %d bytes long\n"), putHiVal, putLoVal, size128);
+
+ CSdpAttrValueUint& attrValueUint128 = static_cast<CSdpAttrValueUint&>(*attrVal128);
+ attrValueUint128.Uint128(getLoVal128, getHiVal128);
+ test.Printf(_L("SdpUtil: CSdpAttrValueUint created with 0x%lx,0x%lx would return 0x%lx,0x%lx\n"), putHiVal, putLoVal, getHiVal128, getLoVal128);
+
+ delete attrVal128;
+
+ __UHEAP_MARKEND;
+
+}
+
+void IntConversionTest()
+/**
+ Checks compiler has done uint-int cast correctly
+ in CSdpAttrValueInt::Int().
+**/
+ {
+ TBuf8<4> tstr;
+ tstr.FillZ(4);
+ tstr[0] = 0xff;
+ tstr[1] = 0xff;
+ tstr[2] = 0xff;
+ tstr[3] = 0xff;
+ TInt ret = 0;
+ CSdpAttrValueInt* avi = 0;
+ avi = CSdpAttrValueInt::NewIntL(tstr);
+ ret = avi->Int();
+ delete avi;
+ avi = 0;
+ __ASSERT_DEBUG(ret==-1, User::Panic(_L("Bad4ByteIntConversion"), KErrGeneral));
+ tstr.SetLength(2);
+ avi = CSdpAttrValueInt::NewIntL(tstr);
+ ret = avi->Int();
+ delete avi;
+ avi = 0;
+ __ASSERT_DEBUG(ret==-1, User::Panic(_L("Bad2ByteIntConversion"), KErrGeneral));
+ //tstr[0] = 0x0e;
+ tstr.SetLength(1);
+ avi = CSdpAttrValueInt::NewIntL(tstr);
+ ret = avi->Int();
+ delete avi;
+ avi = 0;
+ __ASSERT_DEBUG(ret==-1, User::Panic(_L("BadByteIntConversion"), KErrGeneral));
+
+ (void)(ret != 0); // keep compiler happy by referencing ret as an r-value in urel
+
+ return;
+ }
+
+void RunAppL()
+ {
+// TInt ret;
+ test.Title();
+ test.Start(_L("Running SDP server tests"));
+// For some reason, you have to do the following to
+// ensure that the file server behaves properly.
+ RFs fs;
+ (void)fs.Connect();
+ fs.Close();
+// Run through tests
+ IntConversionTest();
+ FOREVER
+ {
+ test.Printf(_L("Choose the test to run...\n"));
+ test.Printf(_L("************************\n"));
+ test.Printf(_L("0. Run client/server\n"));
+ test.Printf(_L("1. Run client/server building the John Pagonis database\n"));
+ test.Printf(_L("2. Build static DB & print\n"));
+ test.Printf(_L("3. Build static DB & copy it over into the SDP database server\n"));
+ test.Printf(_L("4. Service Search (no continuation)\n"));
+ test.Printf(_L("5. Attribute Request (no continuation)\n"));
+ test.Printf(_L("6. Sizing and encoding stuff\n"));
+ test.Printf(_L("7. encoded database\n"));
+ test.Printf(_L("8. size visitor\n"));
+ test.Printf(_L("9a.(Press keys SLOWLY) Build \"Rhubarb\" continuation database\n"));
+ test.Printf(_L("9b.(Press keys SLOWLY) Build nested lists continuation database\n"));
+ test.Printf(_L("B. Run UPF back to back tests\n"));
+ test.Printf(_L("C. Continuation stress tests\n"));
+// test.Printf(_L("U. Unplugfest tests\n"));
+ test.Printf(_L("P. Prequal tests database\n"));
+ test.Printf(_L("Q. SdpUtil tests\n"));
+ test.Printf(_L("\n"));
+ test.Printf(_L("A. Run All tests\n"));
+ test.Printf(_L("************************\n"));
+ test.Printf(_L("press Escape to quit\n\n"));
+
+ __UHEAP_MARK;
+ TChar c = test.Getch();
+ switch (c)
+ {
+ case 'A': case 'a':
+ Test1();
+ __UHEAP_CHECK(0);
+ Test2();
+ __UHEAP_CHECK(0);
+ Test3();
+ __UHEAP_CHECK(0);
+ Test4();
+ __UHEAP_CHECK(0);
+ Test5();
+ __UHEAP_CHECK(0);
+ Test6();
+ __UHEAP_CHECK(0);
+ break;
+ case '0':
+ Test0();
+ break;
+ case '1':
+ WhichTest();
+ break;
+ case '2':
+ Test2();
+ break;
+ case '3':
+ Test3();
+ break;
+ case '4':
+ Test4();
+ break;
+ case '5':
+ Test5();
+ break;
+ case '6':
+ Test6();
+ break;
+ case '7':
+ Test7();
+ break;
+ case '8':
+ Test8();
+ break;
+ case '9':
+ Test9(0);
+ break;
+ case 'B': case 'b':
+ TestBL(test);
+ break;
+ case 'C': case 'c':
+ __UHEAP_MARK;
+ TestCL(test, BuildContinuationDbL());
+ __UHEAP_MARKEND;
+ break;
+ case 'D': case 'd':
+ TestD();
+ break;
+ case 'E': case 'e':
+ TestE();
+ break;
+ case 'P': case 'p':
+ Test9(1);
+ break;
+ case 'Q': case 'q':
+ Test10();
+ break;
+
+ case EKeyEscape:
+ goto done;
+ default:
+ test.Printf(_L("Unknown command\n"));
+ };
+ __UHEAP_MARKEND;
+ }
+
+done:
+
+ test.Printf(_L("Finished! Press any key...\r\n"));
+ test.Getch();
+ test.End();
+ }
+
+
+TInt E32Main()
+ {
+
+ test.SetLogged(ETrue);
+ test.Title();
+ __UHEAP_MARK;
+ CTrapCleanup* cleanup=CTrapCleanup::New();
+ TRAPD(error,RunAppL()); // Run the App
+ __ASSERT_ALWAYS(error==KErrNone,User::Panic(_L("EPOC32EX"),error));
+ delete cleanup;
+ __UHEAP_MARKEND;
+ test.Close();
+ return KErrNone;
+ }