/*

* Copyright (c) 2008 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:

*

*/

#include "TestContentHandler.h"

#include "xmlengtester.h"

#include <e32svr.h>

#include <e32std.h>

#include <Xml\ParserFeature.h>

#include "xmlengtesterdef.h"

#include <InetProtTextUtils.h>

#include <libc\string.h>

#include <charconv.h>

#include <UTF.H>

// -----------------------------------------------------------------------------

// CLibxml2Tester::DeserializeL

// deserialize from file, using setter SetInputFileL

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CLibxml2Tester::DeserializeInfosetL( CStifItemParser& aItem)

    {

    TInt err;

    TPtrC pDeserializerType;

    aItem.GetNextString( pDeserializerType );

    TPtrC pInputFile;

    aItem.GetNextString( pInputFile );

    TPtrC pOutputFile;

    aItem.GetNextString( pOutputFile );

    TPtrC pDirtyReturn;

    aItem.GetNextString( pDirtyReturn );

    TLex inputNum (pDirtyReturn);

    TInt dirtyReturn;

     inputNum.Val(dirtyReturn);	

    iDoc = parser.ParseFileL(pInputFile);

	TBufC<100> chunkName(_L("ChunkContainer") );

    TInt size = 2000;

    TInt maxSize = 10000;

    TInt offset = 0;

    TInt binarySize = CID_1().Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);

	TBuf8<32> contbuff = _L8("binary container some data...");

	RFs aRFs;

    aRFs.Connect();

    CleanupClosePushL( aRFs );

	RFile fp;

	CleanupClosePushL(fp); 	

    TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);

    TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);

	TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);

	iDoc.DocumentElement().AppendChildL(bincont);

	iDoc.DocumentElement().AppendChildL(chunkcont);

	iDoc.DocumentElement().AppendChildL(filecont);										

	RArray<TXmlEngDataContainer> list;

	CleanupClosePushL(list);

	iDoc.GetDataContainerList(list); 

    RFile fileHandle;

    RFs aRFs_2;

    aRFs_2.Connect();

    CleanupClosePushL( aRFs_2 );

    User::LeaveIfError( fileHandle.Replace( aRFs_2, pOutputFile, EFileStream | EFileWrite | EFileShareExclusive));

    CleanupClosePushL( fileHandle );

    CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );

    if( pDeserializerType.FindF( DEFAULT ) != KErrNotFound )

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerDefault );

        CleanupStack::PushL( des );

        des->SetInputFileL( pInputFile );

        TRAP(err,des->DeserializeL());

        }

    else if( pDeserializerType.FindF( XOP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOP );

        CleanupStack::PushL( des );

        des->SetInputFileL( pInputFile );

        TRAP(err,des->DeserializeL());

        }

    else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOPInfoset );

        CleanupStack::PushL( des );

        des->SetInputFileL( pInputFile );

        des->UseExternalDataL( list );

        TRAP(err,des->DeserializeL());

        }    

    else if( pDeserializerType.FindF( GZIP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerGZip );

        CleanupStack::PushL( des );

        des->SetInputFileL( pInputFile );

        TRAP(err,des->DeserializeL());

        }

    CleanupStack::PopAndDestroy( 8 );

    if ( err == dirtyReturn ) return KErrNone;		

    else return err;

    }

// -----------------------------------------------------------------------------

// CLibxml2Tester::Deserialize2L

// deserialize from buffer, using setter SetInputBuffer

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//    

TInt CLibxml2Tester::Deserialize2InfosetL( CStifItemParser& aItem)

    {

    TInt err;

    TPtrC pDeserializerType;

    aItem.GetNextString( pDeserializerType );

    TPtrC pInputFile;

    aItem.GetNextString( pInputFile );

    TPtrC pOutputFile;

    aItem.GetNextString( pOutputFile );

    TPtrC pDirtyReturn;

    aItem.GetNextString( pDirtyReturn );

    TLex inputNum (pDirtyReturn);

    TInt dirtyReturn;

     inputNum.Val(dirtyReturn);

    iDoc = parser.ParseFileL(pInputFile);

	TBufC<100> chunkName(_L("ChunkContainer") );

    TInt size = 2000;

    TInt maxSize = 10000;

    TInt offset = 0;

    TInt binarySize = CID_1().Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);

	TBuf8<32> contbuff = _L8("binary container some data...");

	RFs aRFs;

    aRFs.Connect();

    CleanupClosePushL( aRFs );

	RFile fp;

	CleanupClosePushL(fp); 	

    TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);

    TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);

	TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);

	iDoc.DocumentElement().AppendChildL(bincont);

	iDoc.DocumentElement().AppendChildL(chunkcont);

	iDoc.DocumentElement().AppendChildL(filecont);										

	RArray<TXmlEngDataContainer> list;

	CleanupClosePushL(list);

	iDoc.GetDataContainerList(list); 

    RFile fileHandle;

    RFs aRFs_2;

    aRFs_2.Connect();

    CleanupClosePushL( aRFs_2 );

    User::LeaveIfError( fileHandle.Replace( aRFs_2, pOutputFile, EFileStream | EFileWrite | EFileShareExclusive));

    CleanupClosePushL( fileHandle );

     HBufC8* buf = ReadFileL(pInputFile);

    CleanupStack::PushL(buf);

    CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );

    if( pDeserializerType.FindF( DEFAULT ) != KErrNotFound )

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerDefault );

        CleanupStack::PushL( des );

        des->SetInputBuffer(buf->Des());

        TRAP(err,des->DeserializeL());

        }

    else if( pDeserializerType.FindF( XOP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOP );

        CleanupStack::PushL( des );

        des->SetInputBuffer(buf->Des());

        TRAP(err,des->DeserializeL());

        }

    else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOPInfoset );

        CleanupStack::PushL( des );

        des->SetInputBuffer(buf->Des());

        des->UseExternalDataL( list );

        TRAP(err,des->DeserializeL());

        }

    else if( pDeserializerType.FindF( GZIP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle,EDeserializerGZip );

        CleanupStack::PushL( des );

        des->SetInputBuffer(buf->Des());

        TRAP(err,des->DeserializeL());

        }

    CleanupStack::PopAndDestroy( 9 );		

    if ( err == dirtyReturn ) return KErrNone;		

    else return err;

    }    

// -----------------------------------------------------------------------------

// CLibxml2Tester::DeserializeFromFileL

// deserialize from file, convinience function

// (other items were commented in a header).

// -----------------------------------------------------------------------------

// 

TInt CLibxml2Tester::DeserializeFromFileInfosetL( CStifItemParser& aItem)

    {

    TInt err;

    TPtrC pDeserializerType;

    aItem.GetNextString( pDeserializerType );

    TPtrC pInputFile;

    aItem.GetNextString( pInputFile );

    TPtrC pOutputFile;

    aItem.GetNextString( pOutputFile );

    TPtrC pDirtyReturn;

    aItem.GetNextString( pDirtyReturn );

    TLex inputNum (pDirtyReturn);

    TInt dirtyReturn;

     inputNum.Val(dirtyReturn);

    iDoc = parser.ParseFileL(pInputFile);

	TBufC<100> chunkName(_L("ChunkContainer") );

    TInt size = 2000;

    TInt maxSize = 10000;

    TInt offset = 0;

    TInt binarySize = CID_1().Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);

	TBuf8<32> contbuff = _L8("binary container some data...");

	RFs aRFs;

    aRFs.Connect();

    CleanupClosePushL( aRFs );

	RFile fp;

	CleanupClosePushL(fp); 	

    TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);

    TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);

	TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);

	iDoc.DocumentElement().AppendChildL(bincont);

	iDoc.DocumentElement().AppendChildL(chunkcont);

	iDoc.DocumentElement().AppendChildL(filecont);										

	RArray<TXmlEngDataContainer> list;

	CleanupClosePushL(list);

	iDoc.GetDataContainerList(list);

    RFile fileHandle;

    RFs aRFs_2;

    aRFs_2.Connect();

    CleanupClosePushL( aRFs_2 );

    User::LeaveIfError( fileHandle.Replace( aRFs_2, pOutputFile, EFileStream | EFileWrite | EFileShareExclusive));

    CleanupClosePushL( fileHandle );

    CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );

    if( pDeserializerType.FindF( DEFAULT ) != KErrNotFound )

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerDefault );

        CleanupStack::PushL( des );

        TRAP(err,des->DeserializeL( pInputFile ));

        }

    else if( pDeserializerType.FindF( XOP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle,EDeserializerXOP );

        CleanupStack::PushL( des );

        TRAP(err,des->DeserializeL( pInputFile ));

        }

    else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle,EDeserializerXOPInfoset );

        CleanupStack::PushL( des );

        des->UseExternalDataL( list );

        TRAP(err,des->DeserializeL( pInputFile ));

        }

    else if( pDeserializerType.FindF( GZIP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerGZip );

        CleanupStack::PushL( des );

        RFs fs; 

        CleanupClosePushL(fs);

        User::LeaveIfError(fs.Connect());    				

        TRAP(err,des->DeserializeL( fs ,pInputFile ));			

        CleanupStack::PopAndDestroy(&fs);

        }

    CleanupStack::PopAndDestroy( 8 );		

    if ( err == dirtyReturn ) return KErrNone;		

    else return err;

    }

// -----------------------------------------------------------------------------

// CLibxml2Tester::DeserializeFromBufferL

// deserialize from buffer, convinience function

// (other items were commented in a header).

// -----------------------------------------------------------------------------

// 

TInt CLibxml2Tester::DeserializeFromBufferInfosetL(CStifItemParser& aItem)

    {    

    TInt err;    

    TPtrC pDeserializerType;

    aItem.GetNextString( pDeserializerType );

    TPtrC pInputFile;

    aItem.GetNextString( pInputFile );

    TPtrC pOutputFile;

    aItem.GetNextString( pOutputFile );

    TPtrC pDirtyReturn;

    aItem.GetNextString( pDirtyReturn );

    TLex lexer (pDirtyReturn);

    TInt dirtyReturn;

    lexer.Val(dirtyReturn);

    HBufC8* buf = ReadFileL(pInputFile);

    CleanupStack::PushL(buf);

	iDoc = parser.ParseFileL(pInputFile);

	TBufC<100> chunkName(_L("ChunkContainer") );

    TInt size = 2000;

    TInt maxSize = 10000;

    TInt offset = 0;

    TInt binarySize = CID_1().Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);

	TBuf8<32> contbuff = _L8("binary container some data...");

	RFs aRFs;

    aRFs.Connect();

    CleanupClosePushL( aRFs );

	RFile fp;

	CleanupClosePushL(fp); 	

    TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);

    TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);

	TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);

	iDoc.DocumentElement().AppendChildL(bincont);

	iDoc.DocumentElement().AppendChildL(chunkcont);

	iDoc.DocumentElement().AppendChildL(filecont);										

	RArray<TXmlEngDataContainer> list;

	CleanupClosePushL(list);

	iDoc.GetDataContainerList(list);

    RFile handleOutput;

    RFs rfOutput;

    rfOutput.Connect();

    CleanupClosePushL( rfOutput );

    User::LeaveIfError( handleOutput.Replace( rfOutput, pOutputFile, EFileWrite));

    CleanupClosePushL( handleOutput );	

    CTestHandler* testHandle = CTestHandler::NewLC( handleOutput );

    if( pDeserializerType.FindF( DEFAULT ) != KErrNotFound )

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerDefault );

        CleanupStack::PushL( des );

        TRAP(err,des->DeserializeL(buf->Des()));

        }

    else if( pDeserializerType.FindF( XOP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOP );

        CleanupStack::PushL( des );

        TRAP(err,des->DeserializeL(buf->Des()));

        }

    else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOPInfoset );

        CleanupStack::PushL( des );

        des->UseExternalDataL( list );

        TRAP(err,des->DeserializeL(buf->Des()));

        }

    else if( pDeserializerType.FindF( GZIP ) != KErrNotFound )     

        {

        CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerGZip );

        CleanupStack::PushL( des );

        TRAP(err,des->DeserializeL(buf->Des()));

        }

    CleanupStack::PopAndDestroy( 9 );

    if ( err == dirtyReturn ) return KErrNone;		

    else return err;	

    }

// -----------------------------------------------------------------------------

// CLibxml2Tester::TestDeserializerL

// loop test, deserialize from file, one deserializer instance

// (other items were commented in a header).

// -----------------------------------------------------------------------------

// 

TInt CLibxml2Tester::TestDeserializerInfosetL(CStifItemParser& aItem)

	{

	TPtrC pType;

	aItem.GetNextString(pType);

	TPtrC pDoc;

	aItem.GetNextString(pDoc);

	TPtrC pOut;

	aItem.GetNextString(pOut);

	iDoc = parser.ParseFileL(pDoc);

	TBufC<100> chunkName(_L("ChunkContainer") );

    TInt size = 2000;

    TInt maxSize = 10000;

    TInt offset = 0;

    TInt binarySize = CID_1().Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);

	TBuf8<32> contbuff = _L8("binary container some data...");

	RFs aRFs;

    aRFs.Connect();

    CleanupClosePushL( aRFs );

	RFile fp;

	CleanupClosePushL(fp); 	

    TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), contbuff);

    TXmlEngChunkContainer chunkcont = iDoc.CreateChunkContainerL(CID_2(), chunk, offset, binarySize);

	TXmlEngFileContainer filecont = iDoc.CreateFileContainerL(CID_3(), fp);

	iDoc.DocumentElement().AppendChildL(bincont);

	iDoc.DocumentElement().AppendChildL(chunkcont);

	iDoc.DocumentElement().AppendChildL(filecont);										

	RArray<TXmlEngDataContainer> list;

	CleanupClosePushL(list);

	iDoc.GetDataContainerList(list);

	RFile fileHandle;

    RFs aRFs_2;

    aRFs_2.Connect();

    CleanupClosePushL( aRFs_2 );

    User::LeaveIfError( fileHandle.Replace( aRFs_2, pOut, EFileStream | EFileWrite | EFileShareExclusive));

    CleanupClosePushL( fileHandle );

    CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );

    CXmlEngDeserializer* des = CXmlEngDeserializer::NewL( *testHandle, RetDeserializerType(pType) );

    CleanupStack::PushL( des );

    des->UseExternalDataL( list );

    for (TInt i = 0; i < 20; i++ )

    	{

    	des->SetInputFileL(pDoc);

    	des->DeserializeL();

    	des->DeserializeL();

    	des->EnableFeature(	EReportNamespaces );

    	des->DeserializeL();

    	if( des->IsFeatureEnabled( EReportNamespaces )) 

    		{

    	   	des->DisableFeature( EReportNamespaces );

    		}

    		else User::Leave( KErrGeneral );

    	des->EnableFeature( EReportNamespaceMapping );

    	des->EnableFeature( EReportUnrecognisedTags );

    	}

	CleanupStack::PopAndDestroy( 8 );

	return KErrNone;	

	}

// -----------------------------------------------------------------------------

// CLibxml2Tester::TestSetInputFileL

// test setting input file

// (other items were commented in a header).

// -----------------------------------------------------------------------------

// 

TInt CLibxml2Tester::TestSetInputFileInfosetL(CStifItemParser& aItem)

	{

	TPtrC pType;

	aItem.GetNextString(pType);

	TPtrC pDoc;

	aItem.GetNextString(pDoc);