diff -r 000000000000 -r 3ce708148e4d customization/tsrc/tarmcustomization/src/TestParams.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/customization/tsrc/tarmcustomization/src/TestParams.cpp Thu Dec 17 08:40:12 2009 +0200 @@ -0,0 +1,1157 @@ +/* +* Copyright (c) 2002-2004 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: Implementation of customization components +* +*/ + + + +// INCLUDE FILES + +#include "TestParams.h" + +//#include + +#include +#include +//#include + +//#include "ThemesTest.h" +#include "TestDmCallback.h" +#include "TestDmDDFObject.h" +#include "FileCoderB64.h" + +#include "nsmldmuri.h" + + +// EXTERNAL DATA STRUCTURES +//extern ?external_data; + +// EXTERNAL FUNCTION PROTOTYPES +//extern ?external_function( ?arg_type,?arg_type ); + +// CONSTANTS +//const ?type ?constant_var = ?constant; + +// MACROS +//#define ?macro ?macro_def + +// LOCAL CONSTANTS AND MACROS +//const ?type ?constant_var = ?constant; +//#define ?macro_name ?macro_def + +// MODULE DATA STRUCTURES +//enum ?declaration +//typedef ?declaration + +// LOCAL FUNCTION PROTOTYPES +//?type ?function_name( ?arg_type, ?arg_type ); + +// FORWARD DECLARATIONS +//class ?FORWARD_CLASSNAME; + +// ============================= LOCAL FUNCTIONS =============================== + + + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CTestParams::CTestParams +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CTestParams::CTestParams( CStifLogger *aLog ) + : iLog( aLog ) +// , iStr( 0 ) + , iUri( 0 ) + , iData( 0 ) + , iDataType( 0 ) + , iOutputFile( 0 ) + , iExpectedStatus( -1 ) + , iExpectedData( 0 ) + , iExpectedType( 0 ) + , iStatusRef( -1 ) + , iResultsRef( -1 ) + { + /**/ + } + +// ----------------------------------------------------------------------------- +// CTestParams::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CTestParams::ConstructL( CStifItemParser& aItem ) + { + // Parse parameters + TPtrC str; + TInt ret = aItem.Remainder( str ); + + TBuf8<200> buf; + buf.Copy( str ) ; + + iLog->Log( _L("CmdParams: '%S'"), &str ); + + +// TInt i = 0; +// while (aItem.GetNextString( str ) == KErrNone ) +// { +// iLog->Log( _L("Par[%d]: '%S'"), i, &str ); +// } + +// iLog->Log( _L("Version is")) ; +// iLog->Log( version->Ptr(0) ) ; +// +// iLog->Log( _L("Add Test Adding Policy data failed! %d" ), iStatus ); + + TTestParamVar var( buf ); + while (var.Next()) + { + TPtrC8 key = var.Name(); + TPtrC8 value = var.Value(); + TBool exist = var.ValueExist(); + iLog->Log(_L8("key: '%S', value: '%S', exist: %d"), &key, &value, exist); + +/* + Syntax: + ------- + + URI= + + File= + Text= + + IT= Input (text) + IF= Input File (filename) + OF= Output File + + ET= Expected result (text) + EF= Expected file (filename) + +*/ + _LIT8( KURI, "URI" ); // = value + + _LIT8( KText, "Text" ); // = "Text input" + _LIT8( KFile, "File" ); // = Filename (and path) + _LIT8( KType, "Type" ); // = MimeType (of data) + + _LIT8( KInputText, "IT" ); // = "Input Text" + _LIT8( KInputFile, "IF" ); // = InputFileName (and path) + _LIT8( KInputFile2, "IF2" ); // = InputFileName (and path) + _LIT8( KInputType, "IM" ); // = Input MimeType (of data) + _LIT8( KOutputFile, "OF" ); // = OutputFileName (and path) (where result data is saved) + + _LIT8( KExpectedStatus, "ES" ); // = + _LIT8( KExpectedText, "ET" ); // = "Expected Result Text" + _LIT8( KExpectedFile, "EF" ); // = ExpectedResultFile (and path) + _LIT8( KExpectedFile2, "EF2" ); // = ExpectedResultFile (and path) + _LIT8( KExpectedType, "EM" ); // = Expected MimeType (of return data) + +// , iUri( 0 ) +// , iData( 0 ) +// , iDataType( 0 ) + + if ( key.CompareF( KURI ) == 0 ) + { + if (iUri == 0) + { + delete iUri; + iUri = 0; + iUri = value.AllocL(); + } + else + { + iLog->Log(_L8("Warning: URI already given, not resetting to: '%S'"), &value ); + } + } + else if ( key.CompareF( KInputText ) == 0 || key.CompareF( KText ) == 0 ) + { + delete iData; + iData = 0; + iData = value.AllocL(); + } + else if ( key.CompareF( KInputFile ) == 0 || key.CompareF( KFile ) == 0 ) + { + delete iData; + iData = 0; + + TFileCoderB64 coder; + User::LeaveIfError( coder.EncodeL( value, iData ) ); + } + else if ( key.CompareF( KInputFile2) == 0 ) + { + delete iData; + iData = 0; + + RFs fs; fs.Connect(); + TFileName fn; fn.Copy(value); + RFile f; f.Open(fs, fn, EFileShareExclusive|EFileRead); + + TInt size; f.Size( size ); + iData = HBufC8::NewL( size ); + TPtr8 ptr( iData->Des() ); + f.Read( ptr ); + + f.Close(); + fs.Close(); + } + else if ( key.CompareF( KInputType ) == 0 || key.CompareF( KType ) == 0 ) + { + delete iDataType; + iDataType = 0; + iDataType = value.AllocL(); + } + else if (key.CompareF( KOutputFile ) == 0 ) + { + delete iOutputFile; + iOutputFile = 0; + iOutputFile = value.AllocL(); + } + else if (key.CompareF( KExpectedStatus ) == 0 ) + { + TLex8 lex( value ); + User::LeaveIfError( lex.Val( iExpectedStatus ) ); + } + else if (key.CompareF( KExpectedText ) == 0 ) + { + delete iExpectedData; + iExpectedData = 0; + iExpectedData = value.AllocL(); + } + else if (key.CompareF( KExpectedFile ) == 0 ) + { + delete iExpectedData; + iExpectedData = 0; + + TFileCoderB64 coder; + User::LeaveIfError( coder.EncodeL( value, iExpectedData ) ); + } + else if (key.CompareF( KExpectedFile2 ) == 0 ) + { + delete iExpectedData; + iExpectedData = 0; + + RFs fs; fs.Connect(); + TFileName fn; fn.Copy(value); + RFile f; f.Open(fs, fn, EFileShareExclusive|EFileRead); + + TInt size; f.Size( size ); + iExpectedData = HBufC8::NewL( size ); + TPtr8 ptr( iExpectedData->Des() ); + f.Read( ptr ); + + f.Close(); + fs.Close(); + } + else if (key.CompareF( KExpectedType ) == 0 ) + { + delete iExpectedType; + iExpectedType = 0; + iExpectedType = value.AllocL(); + } + else + { + // Unknown parameter + iLog->Log(_L8("Warning: Unknown parameter: key: '%S', value: '%S', exist: %d"), &key, &value, exist); + } + + } + // Cleanup + } + + +// ----------------------------------------------------------------------------- +// CTestParams::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CTestParams* CTestParams::NewL( CStifLogger *aLog, CStifItemParser& aItem ) + { + CTestParams* self = NewLC( aLog, aItem ); + CleanupStack::Pop( self ); + + return self; + } +CTestParams* CTestParams::NewLC( CStifLogger *aLog, CStifItemParser& aItem ) + { + CTestParams* self = new (ELeave) CTestParams( aLog ); + + CleanupStack::PushL( self ); + self->ConstructL( aItem ); + + return self; + } + + +// Destructor +CTestParams::~CTestParams() + { + /**/ + delete iUri; + delete iData; + delete iDataType; + delete iOutputFile; + delete iExpectedData; + delete iExpectedType; + } + + +// ----------------------------------------------------------------------------- +// CTestParams::?member_function +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +/*?type CTestParams::?member_function( + ?arg_type arg, + ?arg_type arg ) + { + + ?code + + } +*/ + + + + + +/* +void CTestParams::SetL( CStifItemParser& aItem ) + { +// iString = aItem. + TPtrC str; + TInt ret = aItem.Remainder( str ); + } +*/ +const TDesC8& CTestParams::Uri() + { + if (iUri != 0) + { + return *iUri; + } + else + { + return KNullDesC8; + } + } +const TDesC8& CTestParams::Data() + { + if (iData != 0) + { + return *iData; + } + else + { + return KNullDesC8; + } + } +const TDesC8& CTestParams::DataType() + { + if (iDataType != 0) + { + return *iDataType; + } + else + { + return KNullDesC8; + } + } +//sf-void CTestParams::SetCallback( CTestDmCallback* aCallback ) +//sf- { +//sf- iCallback = aCallback; +//sf- } +void CTestParams::SetResultsRef( TInt aResultsRef ) + { + iResultsRef = aResultsRef; + } +void CTestParams::SetStatusRef( TInt aStatusRef ) + { + iStatusRef = aStatusRef; + } + + +//sf-TInt CTestParams::CheckStatusL( MSmlDmAdapter::TError aStatus ) +TInt CTestParams::CheckStatusL( TInt aStatus ) + { + TInt ret = KErrNone; + + if (iExpectedStatus >= 0 && iExpectedStatus != aStatus) + { + iLog->Log( _L8("Error: CTestParams::CheckStatusL: expected=%d, status=%d"), iExpectedStatus, aStatus ); + ret = KErrGeneral; + } + + return ret; + } + +TInt CTestParams::CheckDataL( CBufFlat& aObject ) + { + TPtrC8 ptr = aObject.Ptr(0); + TInt ret = CheckDataL( ptr ); + return ret; +/* + TInt ret = KErrNone; + + if (iExpectedData) + { + TPtrC8 ptr = aObject.Ptr(0); + if (iExpectedData->Compare( ptr ) != 0) + { + iLog->Log( _L8("Error: CTestParams::CheckDataL") ); + ret = KErrGeneral; + } + } + + return ret; +*/ + } + +TInt CTestParams::CheckDataL( const TDesC8& aObject ) + { + TInt ret = KErrNone; + + if (iExpectedData) + { + TInt len1 = iExpectedData->Length(); + TInt len2 = aObject.Length(); + if (iExpectedData->Compare( aObject ) != 0) + { + TPtrC8 expt = iExpectedData->Left( 80 ); + TPtrC8 real = aObject.Left( 80 ); +//sf- iLog->Log( _L8("Error: CTestParams::CheckDataL") ); + iLog->Log( _L8("Error: CTestParams::CheckDataL: expected='%S', real='%S'"), &expt, &real ); + ret = KErrGeneral; + } + } + + return ret; + } + +TInt CTestParams::CheckTypeL( const TDesC8 &aType ) + { + TInt ret = KErrNone; + + if (iExpectedType) + { + if (iExpectedType->CompareF( aType ) != 0) + { + iLog->Log( _L8("Error: CTestParams::CheckTypeL: exp='%S', typ='%S'"), iExpectedType, &aType ); + ret = KErrGeneral; + } + } + + return ret; + } + +TInt CTestParams::CheckL( CTestDmCallback* aCallback ) + { + TInt ret = KErrNone; +// MSmlDmAdapter::TError status = EOk; +// const CBufBase& GetResultsObjectL( TInt aResultsRef ); +// const TDesC8& GetResultsTypeL( TInt aResultsRef ); + + if (iStatusRef >= 0) + { + MSmlDmAdapter::TError status = aCallback->GetStatusL( iStatusRef ); + TInt ret1 = CheckStatusL( status ); + + ret = (ret != KErrNone) ? ret : ret1; + } + else + { +// iLog->"Error: StatusRef not set" + } + + if (iResultsRef >= 0) + { + const CBufBase& tmpObject = aCallback->GetResultsObjectL( iResultsRef ); + TInt ret1 = CheckDataL( *(CBufFlat*) &tmpObject ); + + TPtrC8 tmpType = aCallback->GetResultsTypeL( iResultsRef ); + TInt ret2 = CheckTypeL( tmpType ); + + // choose first error code + ret = (ret != KErrNone) ? ret : ret1; + ret = (ret != KErrNone) ? ret : ret2; + } + else + { +// iLog->"Note: ResultsRef not set" + } + + return ret; + } + +TInt CTestParams::CheckStatusRefL( TInt aStatusRef ) + { + TInt ret = KErrNone; + + if (iExpectedStatus) + { + + } + + return ret; + } +TInt CTestParams::CheckResultsRefL( TInt aResultsRef ) + { + TInt ret = KErrNone; + + if (iExpectedStatus) + { + + } + + return ret; + } + + +//****************************************************************************** +// +// +// +//****************************************************************************** + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CDDFTestParams::CDDFTestParams +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CDDFTestParams::CDDFTestParams( CStifLogger *aLog ) + : iLog( aLog ) + , iUri( 0 ) + +// , iAccessTypes + , iDefaultValue( 0 ) + , iDescription( 0 ) +// , iFormat( 0 ) +// , iOccurence( 0 ) +// , iScope( 0 ) + , iTitle( 0 ) + , iMimeType( 0 ) + , iObjectGroup( 0 ) + { + /**/ + } + +// ----------------------------------------------------------------------------- +// CDDFTestParams::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CDDFTestParams::ConstructL( CStifItemParser& aItem ) + { + // Parse parameters + TPtrC str; + TInt ret = aItem.Remainder( str ); + + HBufC8* ptr = HBufC8::NewLC( str.Length() ); + ptr->Des().Copy( str ); + +//sf- TBuf8<400> buf; +//sf- buf.Copy( str ) ; + + iLog->Log( _L("CmdParams: '%S'"), &str ); + +/* + Syntax: + ------- +//same as uri Name= + AccessTypes= + DefaultValue= + Description= + Format= + Occurence= + Scope= + Title= + MimeType= + ObjectGroup= +*/ + /* Keywords */ + _LIT8( KURI, "URI" ); // = uri + _LIT8( KAccessTypes, "AccessTypes" ); // = + _LIT8( KDefaultValue, "DefaultValue" ); // = + _LIT8( KDescription, "Description" ); // = + _LIT8( KFormat, "Format" ); // = + _LIT8( KOccurence, "Occurence" ); // = + _LIT8( KScope, "Scope" ); // = + _LIT8( KTitle, "Title" ); // = + _LIT8( KMimeType, "MimeType" ); // = + _LIT8( KObjectGroup, "ObjectGroup" ); // = + + /* AccessTypes */ + const TChar KAccessType_Add = 'A'; + const TChar KAccessType_Copy = 'C'; + const TChar KAccessType_Delete = 'D'; + const TChar KAccessType_Exec = 'E'; + const TChar KAccessType_Get = 'G'; + const TChar KAccessType_Replace = 'R'; + + /* Format */ + _LIT8( KFormat_B64, "B64" ); + _LIT8( KFormat_Bool, "Bool" ); + _LIT8( KFormat_Chr, "Chr" ); + _LIT8( KFormat_Int, "Int" ); + _LIT8( KFormat_Node, "Node" ); + _LIT8( KFormat_Null, "Null" ); + _LIT8( KFormat_Xml, "Xml" ); + _LIT8( KFormat_Bin, "Bin" ); + + /* Occurrence */ + _LIT8( KOccurence_One, "One" ); + _LIT8( KOccurence_ZeroOrOne, "ZeroOrOne" ); + _LIT8( KOccurence_ZeroOrMore, "ZeroOrMore" ); + _LIT8( KOccurence_OneOrMore, "OneOrMore" ); + _LIT8( KOccurence_ZeroOrN, "ZeroOrN" ); + _LIT8( KOccurence_OneOrN, "OneOrN" ); + + /* Scope */ + _LIT8( KScope_Permanent, "Permanent" ); + _LIT8( KScope_Dynamic, "Dynamic" ); + + + TTestParamVar var( *ptr ); +//sf- TTestParamVar var( buf ); + while (var.Next()) + { + TPtrC8 key = var.Name(); + TPtrC8 value = var.Value(); + TBool exist = var.ValueExist(); + iLog->Log(_L8("key: '%S', value: '%S', exist: %d"), &key, &value, exist); + + if ( key.CompareF( KURI ) == 0 ) + { + delete iUri; + iUri = 0; + iUri = value.AllocL(); + } + else if ( key.CompareF( KAccessTypes ) == 0) + { +//sf- SetAccessTypes( value ); + for (TInt i = 0 ; i < value.Length() ; i++) + { + if ( value[i] == KAccessType_Add ) + { +//sf- iAccessTypes |= TSmlDmAccessTypes::EAccessType_Add; + iAccessTypes.SetAdd(); + } + else if ( value[i] == KAccessType_Copy ) + { +//sf- iAccessTypes |= TSmlDmAccessTypes::EAccessType_Copy; + iAccessTypes.SetCopy(); + } + else if ( value[i] == KAccessType_Delete ) + { +//sf- iAccessTypes |= TSmlDmAccessTypes::EAccessType_Delete; + iAccessTypes.SetDelete(); + } + else if ( value[i] == KAccessType_Exec ) + { +//sf- iAccessTypes |= TSmlDmAccessTypes::EAccessType_Exec; + iAccessTypes.SetExec(); + } + else if ( value[i] == KAccessType_Get ) + { +//sf- iAccessTypes |= TSmlDmAccessTypes::EAccessType_Get; + iAccessTypes.SetGet(); + } + else if ( value[i] == KAccessType_Replace ) + { +//sf- iAccessTypes |= TSmlDmAccessTypes::EAccessType_Replace; + iAccessTypes.SetReplace(); + } + else + { + iLog->Log(_L8("Warning: Unknown AccessType: '%S'"), &value ); + } + } + } + else if ( key.CompareF( KDefaultValue ) == 0 ) + { + delete iDefaultValue; + iDefaultValue = 0; + iDefaultValue = value.AllocL(); + } + else if ( key.CompareF( KDescription ) == 0 ) + { + delete iDescription; + iDescription = 0; + iDescription = value.AllocL(); + } + else if ( key.CompareF( KFormat ) == 0 ) + { +//sf- SetFormat( value ); + if (value.CompareF( KFormat_B64 ) == 0 ) + { + iFormat = MSmlDmDDFObject::EB64; + } + else if (value.CompareF( KFormat_Bool ) == 0 ) + { + iFormat = MSmlDmDDFObject::EBool; + } + else if (value.CompareF( KFormat_Chr ) == 0 ) + { + iFormat = MSmlDmDDFObject::EChr; + } + else if (value.CompareF( KFormat_Int ) == 0 ) + { + iFormat = MSmlDmDDFObject::EInt; + } + else if (value.CompareF( KFormat_Node ) == 0 ) + { + iFormat = MSmlDmDDFObject::ENode; + } + else if (value.CompareF( KFormat_Null ) == 0 ) + { + iFormat = MSmlDmDDFObject::ENull; + } + else if (value.CompareF( KFormat_Xml ) == 0 ) + { + iFormat = MSmlDmDDFObject::EXml; + } + else if (value.CompareF( KFormat_Bin ) == 0 ) + { + iFormat = MSmlDmDDFObject::EBin; + } + else + { + iLog->Log(_L8("Warning: Unknown Format: '%S'"), &value ); + } + } + else if ( key.CompareF( KOccurence ) == 0 ) + { + if (value.CompareF( KOccurence_One ) == 0 ) + { + iOccurence = MSmlDmDDFObject::EOne; + } + else if (value.CompareF( KOccurence_ZeroOrOne ) == 0 ) + { + iOccurence = MSmlDmDDFObject::EZeroOrOne; + } + else if (value.CompareF( KOccurence_ZeroOrMore ) == 0 ) + { + iOccurence = MSmlDmDDFObject::EZeroOrMore; + } + else if (value.CompareF( KOccurence_OneOrMore ) == 0 ) + { + iOccurence = MSmlDmDDFObject::EOneOrMore; + } + else if (value.CompareF( KOccurence_ZeroOrN ) == 0 ) + { + iOccurence = MSmlDmDDFObject::EZeroOrN; + } + else if (value.CompareF( KOccurence_OneOrN ) == 0 ) + { + iOccurence = MSmlDmDDFObject::EOneOrN; + } + else + { + iLog->Log(_L8("Warning: Unknown Occurrence: '%S'"), &value ); + } + } + else if ( key.CompareF( KScope ) == 0 ) + { + if (value.CompareF( KScope_Permanent ) == 0 ) + { + iScope = MSmlDmDDFObject::EPermanent; + } + else if (value.CompareF( KScope_Dynamic ) == 0 ) + { + iScope = MSmlDmDDFObject::EDynamic; + } + else + { + iLog->Log(_L8("Warning: Unknown Scope: '%S'"), &value ); + } + } + else if ( key.CompareF( KTitle ) == 0 ) + { + delete iTitle; + iTitle = 0; + iTitle = value.AllocL(); + } + else if ( key.CompareF( KMimeType ) == 0 ) + { + delete iMimeType; + iMimeType = 0; + iMimeType = value.AllocL(); + } + else if ( key.CompareF( KObjectGroup ) == 0 ) + { + TLex8 lex( value ); + lex.Val( iObjectGroup ); + } + else + { + // Unknown parameter + iLog->Log(_L8("Warning: Unknown parameter: key: '%S', value: '%S', exist: %d"), &key, &value, exist); + } + + } + + // Cleanup + CleanupStack::PopAndDestroy( ptr ); + } + + +// ----------------------------------------------------------------------------- +// CDDFTestParams::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CDDFTestParams* CDDFTestParams::NewL( CStifLogger *aLog, CStifItemParser& aItem ) + { + CDDFTestParams* self = NewLC( aLog, aItem ); + CleanupStack::Pop( self ); + + return self; + } +CDDFTestParams* CDDFTestParams::NewLC( CStifLogger *aLog, CStifItemParser& aItem ) + { + CDDFTestParams* self = new (ELeave) CDDFTestParams( aLog ); + + CleanupStack::PushL( self ); + self->ConstructL( aItem ); + + return self; + } + + +// Destructor +CDDFTestParams::~CDDFTestParams() + { + /**/ + delete iUri; + delete iDefaultValue; + delete iDescription; + delete iTitle; + delete iMimeType; + } + + +// ----------------------------------------------------------------------------- +// CTestParams::?member_function +// ?implementation_description +// (other items were commented in a header). +// ----------------------------------------------------------------------------- +// +/*?type CTestParams::?member_function( + ?arg_type arg, + ?arg_type arg ) + { + + ?code + + } +*/ + +const TDesC8& CDDFTestParams::Uri() + { + if (iUri != 0) + { + return *iUri; + } + else + { + return KNullDesC8; + } + } + +TInt CDDFTestParams::CheckL( CTestDmDDFObject* aDdfRoot ) + { + TInt ret = KErrNone; + + // Find correct node + CTestDmDDFObject* curNode = aDdfRoot; + TInt num = NSmlDmURI::NumOfURISegs( *iUri ); + + for (TInt i = 0 ; i < num && curNode != 0 ; i++) + { + TPtrC8 nodeName = NSmlDmURI::URISeg( *iUri, i ); + if ( nodeName.CompareF( _L8("") ) == 0 ) + { + nodeName.Set( KNullDesC8 ); + } + curNode = curNode->FindChildObject( nodeName ); + } + + // Check node data + iLog->Log(_L8("Checking node: URI='%S'"), iUri ); + + if (curNode != 0) + { +/* + if ( iUri && iUri->Compare( curNode->Uri() ) != 0 ) + { + TPtrC8 expt = *iUri; + TPtrC8 real = curNode->Uri(); + iLog->Log(_L8("Error: Uri: expected='%S' real='%S'"), &expt, &real ); + ret = KErrGeneral; + } +*/ + if ( iAccessTypes.GetACL() != curNode->AccessTypes().GetACL() ) + { + TUint8 expt = iAccessTypes.GetACL(); + TUint8 real = curNode->AccessTypes().GetACL(); + iLog->Log(_L8("Error: AccessTypes: expected=%d real=%d"), expt, real ); + ret = KErrGeneral; + } + if ( iDefaultValue && iDefaultValue->Compare( curNode->DefaultValue() ) != 0 ) + { + TPtrC8 expt = *iDefaultValue; + TPtrC8 real = curNode->DefaultValue(); + iLog->Log(_L8("Error: DefaultValue: expected='%S' real='%S'"), &expt, &real ); + ret = KErrGeneral; + } + if ( iDescription && iDescription->Compare( curNode->Description() ) != 0 ) + { + TPtrC8 expt = *iDescription; + TPtrC8 real = curNode->Description(); + iLog->Log(_L8("Error: DefaultValue: expected='%S' real='%S'"), &expt, &real ); + ret = KErrGeneral; + } + if ( iFormat != curNode->DFFormat() ) + { + TInt expt = iFormat; + TInt real = curNode->DFFormat(); + iLog->Log(_L8("Error: Format: expected=%d real=%d"), expt, real ); + ret = KErrGeneral; + } + if ( iOccurence != curNode->Occurence() ) + { + TInt expt = iOccurence; + TInt real = curNode->Occurence(); + iLog->Log(_L8("Error: Occurence: expected=%d real=%d"), expt, real ); + ret = KErrGeneral; + } + if ( iScope != curNode->Scope() ) + { + TInt expt = iScope; + TInt real = curNode->Scope(); + iLog->Log(_L8("Error: Scope: expected=%d real=%d"), expt, real ); + ret = KErrGeneral; + } + if ( iTitle && iTitle->Compare( curNode->DFTitle() ) != 0 ) + { + TPtrC8 expt = *iTitle; + TPtrC8 real = curNode->DFTitle(); + iLog->Log(_L8("Error: Title: expected='%S' real='%S'"), &expt, &real ); + ret = KErrGeneral; + } + if ( iMimeType && iMimeType->Compare( curNode->DFTypeMimeType() ) != 0 ) + { + TPtrC8 expt = *iMimeType; + TPtrC8 real = curNode->DFTypeMimeType(); + iLog->Log(_L8("Error: MimeType: expected='%S' real='%S'"), &expt, &real ); + ret = KErrGeneral; + } + if ( iObjectGroup != curNode->ObjectGroup() ) + { + TInt expt = iObjectGroup; + TInt real = curNode->ObjectGroup(); + iLog->Log(_L8("Error: ObjectGroup: expected=%d real=%d"), expt, real ); + ret = KErrGeneral; + } + } + else + { + iLog->Log(_L8("Error: Node not found") ); + ret = KErrGeneral; + } + + return ret; + } + +//****************************************************************************** +// +// +// +//****************************************************************************** + + +TTestParamVar::TTestParamVar( const TDesC8 &aStr ) + : iLog( 0 ) + , iLex( aStr ) +//sf- : iStr( aStr ) +//sf- , iPos( 0 ) + , iName( KNullDesC8 ) + , iValue( KNullDesC8 ) + , iValueExist( EFalse ) + { + } + +TBool TTestParamVar::Next() + { + TBool ok = ETrue; + + iName.Set( KNullDesC8 ); + iValue.Set( KNullDesC8 ); + iValueExist = EFalse; + + ok = !iLex.Eos(); + + if (ok) + { + iName.Set( GetWord() ); + if (iName.Length() == 0) + { + ok = EFalse; + } + } + + TChar chr = GetChar(); + if (chr == '=') + { + iValue.Set( GetWord() ); +/* + TInt i, j, k = iValue.Length(); + for( i=j=0; iLog( _L8("name: '%S', value: '%S', exist: %d"), &iName, &iValue, iValueExist ); + } + + return ok; + } + +const TDesC8& TTestParamVar::Name() + { + return iName; + } + +const TDesC8& TTestParamVar::Value() + { + return iValue; + } + +TBool TTestParamVar::ValueExist() + { + return iValueExist; + } + +TChar TTestParamVar::GetChar() + { + iLex.SkipSpace(); + return iLex.Get(); + } + +void TTestParamVar::UnGetChar() + { + iLex.UnGet(); + } + +TPtrC8 TTestParamVar::GetWord() + { + TBool quoted = EFalse; + + iLex.SkipSpace(); + + // Check if word is quoted + if (iLex.Peek() == '\"') + { + iLex.Get(); + quoted = ETrue; + } + + // Mark start position of word + iLex.Mark(); + + // Seek end of word and extract it + TBool ready = EFalse; + while (!ready && !iLex.Eos()) + { + TChar chr = iLex.Get(); + +//sf- if (chr == '\"' || (!quoted && (chr.IsSpace() || chr == '='))) + if (quoted) + { + if (chr == '\"') + { + if((iLex.Eos()) || (iLex.Peek() == ' ')) + { + iLex.UnGet(); + ready = ETrue; + } + } + } + else if (chr.IsSpace() || chr == '=' || chr == '\"') + { + iLex.UnGet(); + ready = ETrue; + } + } + + // Extract word + TPtrC8 word = iLex.MarkedToken(); + if (quoted) + { + iLex.Get(); + } + + // return + return word; + } + + +/* +// ========================== OTHER EXPORTED FUNCTIONS ========================= + +// ----------------------------------------------------------------------------- +// ?function_name implements... +// ?implementation_description. +// Returns: ?value_1: ?description +// ?value_n: ?description +// ?description +// ----------------------------------------------------------------------------- +// +?type ?function_name( + ?arg_type arg, // ?description + ?arg_type arg ) // ?description + { + + ?code + + } +*/ +// End of File