/*

* 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 "xmlengtesterdef.h"

#include <InetProtTextUtils.h>

#include <libc\string.h>

#include <charconv.h>

#include <UTF.H>

/************************************** BinCont ****************************************/

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

// CLibxml2Tester::BinaryContainerL

// test binary container method function.

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

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

//

TInt CLibxml2Tester::BinaryContainerL(CStifItemParser& aItem)

	{

	//	get test controls, input&output paths

	TPtrC p_Cid;

 	aItem.GetNextString(p_Cid);

 	HBufC8* aCid=CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_Cid);

 	TPtrC8 cidPtr = aCid->Ptr(); 

 	TPtrC p_BinaryData;

 	aItem.GetNextString(p_BinaryData);

	TPtrC p_XmlFile;

 	aItem.GetNextString(p_XmlFile);

 	TPtrC p_Out;

 	aItem.GetNextString(p_Out);

 	TPtrC p_XmlOut;

 	aItem.GetNextString(p_XmlOut);

 	//	open binary file

 	RFs aRFs;

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

   	CleanupClosePushL(aRFs);

 	TInt size;

 	RFile fileHandle;

 	User::LeaveIfError(fileHandle.Open(aRFs, p_BinaryData, EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(fileHandle);

	User::LeaveIfError(fileHandle.Size(size));

	HBufC8* buffer = HBufC8::NewLC(size);

	TPtr8 bufferPtr = buffer->Des();

	User::LeaveIfError(fileHandle.Read(bufferPtr, size)); 

	//	parse xml file

	iDoc = parser.ParseFileL(p_XmlFile);	

	//	create binary container

	TXmlEngBinaryContainer binaryData = iDoc.CreateBinaryContainerL(cidPtr,bufferPtr);

	//	add binary container node to xml document

	iDoc.DocumentElement().AppendChildL(binaryData);

    //	save xml document to file

    User::LeaveIfError( SaveDocumentL (iDoc, p_XmlOut ) );

	//	get binary data content to TDOMString and set pointer on data

	TPtrC8 p_OutString8 = binaryData.TXmlEngBinaryContainer::Contents();

	//	save binary data to file

	RFs aRFs2;

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

	CleanupClosePushL(aRFs2);

	RFile fileHandle2;

	User::LeaveIfError(fileHandle2.Replace(aRFs2, p_Out, EFileWrite));

	CleanupClosePushL(fileHandle2);

	User::LeaveIfError(fileHandle2.Write(p_OutString8));

	//	cleanup all pushed objests

	CleanupStack::PopAndDestroy( 6 );

	return KErrNone;

	}

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

// CLibxml2Tester::TestCreateBinaryContainerL

// test craeting binary container

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

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

//

TInt CLibxml2Tester::TestCreateBinaryContainerL( TPtrC8 aCid, TPtrC8 binaryDataPtr, TPtrC pOut )

	{

	TPtrC8 bincontName = Node1();

	RXmlEngDocument iDocument;

	iDocument.OpenL(DOM_impl);

	CleanupClosePushL( iDocument );

	iDocument.CreateDocumentElementL(bincontName);

	//	create binary container 

	TXmlEngBinaryContainer binaryDataNode = iDocument.CreateBinaryContainerL(aCid, binaryDataPtr);

	if( !binaryDataNode.IsNull() ) 

		{

		iDocument.DocumentElement().AppendChildL(binaryDataNode);

		User::LeaveIfError( SaveDocumentL (iDocument, pOut ) );

		CleanupStack::PopAndDestroy( &iDocument );

		return KErrNone;

		}

		else 

			{

			CleanupStack::PopAndDestroy( &iDocument );

			return KErrGeneral;

			}

	}

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

// CLibxml2Tester::TestLenghtOfBinaryContainerL

// test functin lenght of binary container

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

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

//

TInt CLibxml2Tester::TestSizeOfBinaryContainerL( RXmlEngDocument& iDocument, TPtrC8 aCid, TPtrC8 binaryDataPtr, TInt size )

	{

	TInt aLength(-1);

	TXmlEngBinaryContainer binaryDataNode = iDocument.CreateBinaryContainerL( aCid, binaryDataPtr );

	// size of binary container

	aLength = binaryDataNode.Size();

	return aLength - size;

	}

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

// CLibxml2Tester::TestBinaryContainerNodeTypeL

// check if created binary container is a text node

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

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

//

TInt CLibxml2Tester::TestBinaryContainerNodeTypeL( RXmlEngDocument& iDocument, TPtrC8 aCid, TPtrC8 binaryDataPtr )

	{

	//	create binary container 

	TXmlEngBinaryContainer binaryDataNode = iDocument.CreateBinaryContainerL( aCid, binaryDataPtr );

	return 30 - binaryDataNode.NodeType();

	}

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

// CLibxml2Tester::TestSetContentsOfBinaryContainerL

// check if function SetContentsL & Contents of Binary Container

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

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

//

TInt CLibxml2Tester::TestContentsOfBinaryContainerL( RXmlEngDocument& iDocument, TPtrC8 aCid, TPtrC8 binaryDataPtr, TPtrC pOut1 )

	{

	TXmlEngBinaryContainer binaryDataNode = iDocument.CreateBinaryContainerL( aCid, binaryDataPtr );

	//  init parser		

	RXmlEngDOMImplementation iDomImpl;

	iDomImpl.OpenL();

	RXmlEngDOMParser iParser; 

	iParser.Open(iDomImpl);

	TXmlEngBinaryContainer binaryDataNode2 = iDocument.CreateBinaryContainerL( aCid, binaryDataPtr );

	binaryDataNode2.SetContentsL(binaryDataPtr);

	TInt compareStrings = binaryDataNode.Contents().Compare(binaryDataNode2.Contents());

	User::LeaveIfError( SaveDocumentL (iDocument, pOut1 ) );

	return compareStrings;

	}

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

// CLibxml2Tester::TestMoveBinaryContainerL

// test craeting binary container

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

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

//

TInt CLibxml2Tester::TestMoveBinaryContainerL( RXmlEngDocument& iDoc1, RXmlEngDocument& iDoc2, TPtrC8 aCid, TPtrC8 binaryDataPtr , TPtrC pOut1, TPtrC pOut2)

	{

	TInt error;

	TXmlEngBinaryContainer binaryDataNode = iDoc1.CreateBinaryContainerL( aCid, binaryDataPtr );

	iDoc1.DocumentElement().FirstChild().NextSibling().AppendChildL(binaryDataNode);

	User::LeaveIfError( SaveDocumentL (iDoc1, pOut1 ) );

	binaryDataNode.Unlink();

	binaryDataNode.ReconcileNamespacesL();

	binaryDataNode.MoveTo(iDoc2.DocumentElement());

	User::LeaveIfError( SaveDocumentL (iDoc2, pOut2 ) );	

	error = binaryDataNode.IsNull();

	return error;

	}

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

// CLibxml2Tester::TestremoveBinaryContainerL

// test craeting binary container

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

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

//

TInt CLibxml2Tester::TestRemoveBinaryContainerL( RXmlEngDocument& iDocument,TPtrC8 aCid, 

										TPtrC8 binaryDataPtr, TPtrC pOut1, TPtrC pOut2)

	{

	TXmlEngBinaryContainer binaryDataNode = iDocument.CreateBinaryContainerL( aCid, binaryDataPtr );

	iDocument.DocumentElement().FirstChild().NextSibling().AppendChildL(binaryDataNode);

	User::LeaveIfError( SaveDocumentL (iDocument, pOut1 ) );

	iDocument.DocumentElement().FirstChild().NextSibling().Remove();	

	User::LeaveIfError( SaveDocumentL (iDocument, pOut2 ) );

	return KErrNone;

	}

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

// CLibxml2Tester::TestCopyBinaryContainerL

// test craeting binary container

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

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

//

TInt CLibxml2Tester::TestCopyBinaryContainerL( RXmlEngDocument& iDocument,TPtrC8 aCid, TPtrC8 binaryDataPtr, TPtrC pOut1, TPtrC pOut2 )

	{

	TXmlEngBinaryContainer binaryDataNode = iDocument.CreateBinaryContainerL( aCid, binaryDataPtr );

	iDocument.DocumentElement().FirstChild().NextSibling().AppendChildL(binaryDataNode);

	User::LeaveIfError( SaveDocumentL (iDocument, pOut1 ) );

	TXmlEngNode binNode = iDocument.DocumentElement().FirstChild().NextSibling().CopyL();

	iDocument.DocumentElement().AppendChildL(binNode);	

	binNode.Unlink();

	binNode.ReconcileNamespacesL();

	User::LeaveIfError( SaveDocumentL (iDocument, pOut2 ) );

	return KErrNone;

	}

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

// CLibxml2Tester::TestReplaceBinaryContainerL

// test craeting binary container

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

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

//

TInt CLibxml2Tester::TestReplaceBinaryContainerL( RXmlEngDocument& iDoc1, RXmlEngDocument& iDoc2,

 										TPtrC8 aCid, TPtrC8 binaryDataPtr, TPtrC pOut1, TPtrC pOut2 )

	{

	TInt error;

	TXmlEngBinaryContainer binaryDataNode = iDoc1.CreateBinaryContainerL( aCid, binaryDataPtr );

	iDoc1.DocumentElement().FirstChild().NextSibling().AppendChildL(binaryDataNode);

	User::LeaveIfError( SaveDocumentL(iDoc1, pOut1) );

	binaryDataNode.Unlink();

	binaryDataNode.ReconcileNamespacesL();

	iDoc2.DocumentElement().LastChild().ReplaceWith(binaryDataNode);	

	User::LeaveIfError( SaveDocumentL(iDoc2, pOut2) );

	error = binaryDataNode.IsNull();

	return error;

	}	

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

// CLibxml2Tester::PartialBinaryContainerL

// test binary container method function.

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

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

//

TInt CLibxml2Tester::PartialBinaryContainerL(CStifItemParser& aItem)

	{

	TInt error(KErrGeneral);

	//	get test controls, input&output paths

	TPtrC p_Control;

	aItem.GetNextString( p_Control );

	TPtrC p_Cid;

 	aItem.GetNextString(p_Cid);

    HBufC8* aCid=CnvUtfConverter::ConvertFromUnicodeToUtf8L(p_Cid);

 	TPtrC8 cidPtr = aCid->Ptr(); 

 	TPtrC p_BinaryData;

 	aItem.GetNextString(p_BinaryData);

	TPtrC p_XmlFile1;

 	aItem.GetNextString(p_XmlFile1);

 	TPtrC p_XmlFile2;

 	aItem.GetNextString(p_XmlFile2);

 	TPtrC p_Out1;					// return value or xml file

 	aItem.GetNextString(p_Out1);

 	TPtrC p_Out2;					// xml file 

 	aItem.GetNextString(p_Out2);

  	//	open binary file

 	RFs aRFs;

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

   	CleanupClosePushL(aRFs);

 	TInt size;

 	RFile fileHandle;

 	User::LeaveIfError(fileHandle.Open(aRFs, p_BinaryData, EFileRead | EFileShareReadersOnly));

	CleanupClosePushL(fileHandle);

	User::LeaveIfError(fileHandle.Size(size));

	HBufC8* buffer = HBufC8::NewLC(size);

	TPtr8 bufferPtr = buffer->Des();

	User::LeaveIfError(fileHandle.Read( bufferPtr, size )); 

	//	parse xml file

	RXmlEngDocument iDoc1;

 	CleanupClosePushL(iDoc1);

	if( p_XmlFile1[0] != 48 )

		{

		iDoc1 = parser.ParseFileL(p_XmlFile1);	

		}

	//	parse xml file

	RXmlEngDocument iDoc2;

	CleanupClosePushL(iDoc2);

	if( p_XmlFile2[0] != 48 )

		{

		iDoc2 = parser.ParseFileL(p_XmlFile2);	

		}

 	if ( p_Control == CREATE_BC )

 		{

 		error = TestCreateBinaryContainerL( cidPtr, bufferPtr, p_Out1 );

 		}

 		else if ( p_Control == CONTENTS_BC )

 			{	

 			error =  TestContentsOfBinaryContainerL( iDoc1, cidPtr, bufferPtr, p_Out1 );

 			}

 			else if ( p_Control == SIZE_BC )

 				{

 				error =  TestSizeOfBinaryContainerL( iDoc1, cidPtr,bufferPtr, size );

 				}

 				else if ( p_Control == NODETYPE_BC )

 					{

 					error =  TestBinaryContainerNodeTypeL( iDoc1, cidPtr, bufferPtr );

 					}

 					else if (p_Control == MOVE_BC)

 						{

						error = TestMoveBinaryContainerL(iDoc1, iDoc2, cidPtr, bufferPtr, p_Out1, p_Out2 ); 						

 						}

 						else if ( p_Control == REMOVE_BC )

 							{

							error = TestRemoveBinaryContainerL( iDoc1, cidPtr, bufferPtr, p_Out1, p_Out2 );

 							}

 							else if ( p_Control == COPY_BC )

	 							{

								error = TestCopyBinaryContainerL( iDoc1, cidPtr, bufferPtr, p_Out1, p_Out2 );

	 							}

	 							else if ( p_Control == REPLACE_BC )

		 							{

									error = TestReplaceBinaryContainerL( iDoc1, iDoc2, cidPtr, bufferPtr, 

																			p_Out1, p_Out2 );

		 							}

				 					else

				 						{

				 						User::Leave( KErrArgument );

				 						}

 	CleanupStack::PopAndDestroy(5 );

  	return error;

	}

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

// CLibxml2Tester::TestAppendContentsL

// test appending contents to binary container

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

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

//

TInt CLibxml2Tester::TestAppendContentsL(CStifItemParser& aItem)

	{

	TPtrC pData;

	aItem.GetNextString(pData);

	TPtrC pOut;

	aItem.GetNextString(pOut);

	HBufC8* buffer = ReadFileToBufferL(pData);

	CleanupStack::PushL(buffer);

	iDoc.OpenL(DOM_impl);

	TXmlEngElement elem = iDoc.CreateElementL(_L8("binary container"));

	iDoc.SetDocumentElement(elem);

	TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), buffer->Left(100)); 

	bincont.AppendContentsL(buffer->Mid(100,100));

	bincont.AppendContentsL(buffer->Right(buffer->Length()-200));

	elem.AppendChildL(bincont);

    if(elem.NotNull())

    	{	

    	iDoc.SaveL(pOut);

    	}

    TInt compareStrings = bincont.Contents().Compare(buffer->Des());

    if (compareStrings) return KErrGeneral;

    compareStrings = bincont.Cid().Compare(CID_1());

	CleanupStack::PopAndDestroy( 1 );

	if (compareStrings != 0) return KErrGeneral;

		else return KErrNone;

	}

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

// CLibxml2Tester::BinaryContainer_GetListL

// test method function.

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

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

//

TInt CLibxml2Tester::BinaryContainer_GetListL( CStifItemParser& /*aItem*/ )

    {

    //checks how array of nodes is filled with data, and realloc if list > iDoc->dataNodeMax-1

    _LIT(KBinaryError,"BinaryContainer Error GetList..");

    _LIT(KEndParsing,"Checking BinaryContainer GetList end.");

    TBufC8<100> cid(_L8("123456789@123456789") );

    _LIT(KInputFile1,"c:\\testing\\data\\xmleng\\efute\\input\\filecontainer\\test.jpg");

     HBufC8* str1=ReadFileL(KInputFile1);

    CleanupStack::PushL(str1);

     iDoc.OpenL(DOM_impl);

    TXmlEngElement elem = iDoc.CreateDocumentElementL(_L8("doc"));

    TXmlEngElement el = iDoc.CreateElementL(_L8("binarycontainer"));

    iDoc.DocumentElement().AppendChildL(el); 

    TInt multiplicity = 19;

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

        {

        TXmlEngBinaryContainer container = iDoc.CreateBinaryContainerL(cid,*str1);   

        TXmlEngNode ref = el.AppendChildL(container);

        if(!ref.IsSameNode(container))

            {

            TestModuleIf().Printf( infoNum++,KTEST_NAME,KBinaryError);

            iLog->Log((TDesC)KBinaryError);

            CleanupStack::PopAndDestroy();//str1

            return KErrGeneral;

            }

        if( ref.AsBinaryContainer().Cid() != cid)

            {

            TestModuleIf().Printf( infoNum++,KTEST_NAME,KBinaryError);

            iLog->Log((TDesC)KBinaryError);

            CleanupStack::PopAndDestroy();//str1

            return KErrGeneral;   

            }

        }

    RArray<TXmlEngDataContainer> list;

    CleanupClosePushL(list);

    iDoc.GetDataContainerList(list);

    TInt count = list.Count();