/*

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

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <Xml\Parser.h>

#include <Xml\ParserFeature.h>

#include <libc\string.h>

#include <charconv.h>

#include <UTF.H>

using namespace Xml;

/************************************** CHUNK ****************************************/

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

// CLibxml2Tester::ParseFileChunkL

// test method function.

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

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

//

TInt CLibxml2Tester::ParseFileChunkL( CStifItemParser& aItem )

    {

    _LIT(KSourceFileErrorName,"No source file name.");

    _LIT(KEndParsing,"Parsing end.");

    TPtrC SrcFile;

    TPtrC tmp;

//    TBool map = TRUE;

    if ( aItem.GetNextString(SrcFile) != KErrNone )

        {

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

        iLog->Log((TDesC)KSourceFileErrorName);

        return KErrGeneral;

        }

    TPtrC pChunkSize;

    aItem.GetNextString( pChunkSize );

    TLex lexer (pChunkSize);

    TInt chunkSize;

     lexer.Val(chunkSize);

    TFileName srcFileName;

    srcFileName.Copy(SrcFile);

	RXmlEngDOMParser chunkparser;

    chunkparser.Open(DOM_impl);

    CleanupClosePushL(chunkparser);

    TInt err;

    TRAP(err,iDoc = chunkparser.ParseFileL(srcFileName,chunkSize));

    if(err == KXmlEngErrParsing)

        {

        iLastError = chunkparser.GetLastParsingError();	

        }

    else

        {

        iLastError = err;		

        }   

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

    iLog->Log((TDesC)KEndParsing);

    CleanupStack::PopAndDestroy(&chunkparser);

    return KErrNone;    

    }   

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

// CLibxml2Tester::ChunkContainer_GetListL

// test method function.

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

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

//

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

    {

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

    _LIT(KChunkError,"Chunk Error GetList.");

    _LIT(KEndParsing,"Parsing end.");

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

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 200;

    TInt maxSize = 1000;

    TInt offset = 0;

    TInt binarySize = cid.Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);

    TInt multiplicity = 19;

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

        {

        TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

											cid, chunk,offset, binarySize);

        TXmlEngNode ref = iDoc.DocumentElement().AppendChildL(binData);

        if(!ref.IsSameNode(binData))

            {

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

            iLog->Log((TDesC)KChunkError);

            CleanupStack::PopAndDestroy();//chunk

            return KErrGeneral;

            }

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

            {

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

            iLog->Log((TDesC)KChunkError);

            CleanupStack::PopAndDestroy();// chunk

            return KErrGeneral;   

            }

        }

   RArray<TXmlEngDataContainer> list;

    CleanupClosePushL(list);

    iDoc.GetDataContainerList(list);

    TInt count = list.Count();

    //TInt maxsize = iDoc->dataNodeMax; ???????

    if(count != multiplicity)

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy(2);//list, chunk

        return KErrGeneral;  

        }    

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

        {

        if( list[i].Cid() != cid)

            {

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

            iLog->Log((TDesC)KChunkError);

            CleanupStack::PopAndDestroy(2);//list, chunk

            return KErrGeneral;  

            }            

       if( list[i].AsChunkContainer().Chunk().Name() != chunk.Name() )

            {

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

            iLog->Log((TDesC)KChunkError);

            CleanupStack::PopAndDestroy(2);//list, chunk

            return KErrGeneral;  

            }

        if( list[i].AsChunkContainer().ChunkOffset() != offset )

            {

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

            iLog->Log((TDesC)KChunkError);

            CleanupStack::PopAndDestroy(2);//list, chunk

            return KErrGeneral;  

            }

        if( list[i].Size() != binarySize )

            {

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

            iLog->Log((TDesC)KChunkError);

            CleanupStack::PopAndDestroy(2);//list, chunk

            return KErrGeneral;  

            }		

        }

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

    iLog->Log((TDesC)KEndParsing);

    CleanupStack::PopAndDestroy(2);//list, chunk

    return KErrNone;    

    }   

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

// CLibxml2Tester::ChunkContainer_CidL

// test method function.

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

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

//

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

    {

    //check working of Cid() for ChunkContainer

    _LIT(KChunkError,"Chunk Cid() Error.");

//    _LIT(KChunkError2,"Chunk Cid() Error with binary content.");

    _LIT(KEndParsing,"Checking end.");

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

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 1000;

    TInt maxSize = 5000;

    TInt offset = 0;

    TInt binarySize = cid.Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk); 

    TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

									cid,	 chunk,		 offset,	 binarySize);        

    TXmlEngNode ref = iDoc.DocumentElement().AppendChildL(binData);

    TPtrC8 fetchedCid = binData.Cid();

    if (fetchedCid !=cid)

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy();//chunk   

        return KErrGeneral;       

        }

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

    iLog->Log((TDesC)KEndParsing);

   CleanupStack::PopAndDestroy();//chunk

    return KErrNone;         

    }   

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

// CLibxml2Tester::ChunkContainer_CidL

// test method function.

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

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

//

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

    {

    //create 2 cid with the same name, do some operation on tree ->ReplaceWith, 

    _LIT(KChunkError,"Chunk Cid() Error.");

    _LIT(KEndParsing,"Checking Cid() end.");

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

    TBufC8<100> cid2(_L8("133456789@123456789") );

    TBufC8<100> cid3(_L8("100000000@123456789") );

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 1000;

    TInt maxSize = 5000;

    TInt offset = 0;

    TInt binarySize = cid.Length();

    TInt offset2 = binarySize;

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk); 

    TXmlEngElement el = iDoc.CreateElementL(_L8("chunk container"));

    iDoc.DocumentElement().AppendChildL(el);

    TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

									cid,	 chunk,		 offset,	 binarySize);        

    el.AppendChildL(binData);

    TPtrC8 fetchedCid = binData.Cid();

    if (fetchedCid !=cid)

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy();//chunk   

        return KErrGeneral;       

        }

    TXmlEngChunkContainer binData2 = iDoc.CreateChunkContainerL(

									cid,	 chunk,		 offset2,	 binarySize);        

    el.AppendChildL(binData2);

    TPtrC8 fetchedCid2 = binData2.Cid();

    if (fetchedCid2 !=cid)

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy();//chunk  

        return KErrGeneral;       

        }

    el.AppendChildL(binData); // this nothing does to tree

    TXmlEngChunkContainer binData3 = iDoc.CreateChunkContainerL(

											cid3, chunk,offset, binarySize);

    binData2.ReplaceWith(binData3);	//by replacing, removes cid-matching chunks from list 

                                                                            	//and appends new chunk to list								

    RArray<TXmlEngDataContainer> list;

    CleanupClosePushL(list);

    iDoc.GetDataContainerList(list);

    TInt count = list.Count();

   if(count != 2)

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy(2);//chunk ,list 

        return KErrGeneral;       

        }  

    TPtrC8 fetchedCid3 = binData3.Cid();

    if (fetchedCid3 !=cid3)

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy(2);//chunk,list  

        return KErrGeneral;       

        }   

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

    iLog->Log((TDesC)KEndParsing);

   CleanupStack::PopAndDestroy(2);//chunk,list

    return KErrNone;         

    }       

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

// CLibxml2Tester::ChunkContainer_ChunkL

// test method function.

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

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

//

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

    {

    //check working of Chunk() for ChunkContainer

    _LIT(KChunkError,"Chunk Chunk() Error.");

    _LIT(KEndParsing,"Checking end.");

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

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 1000;

    TInt maxSize = 5000;

    TInt offset = 0;

    TInt binarySize = cid.Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);      

    TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

										cid,	 chunk,	 offset, binarySize);

    RChunk fetchedChunk = binData.Chunk();

    TBuf<100> fetchedName = fetchedChunk.Name();

    if (fetchedName != chunkName)

        {

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

        iLog->Log((TDesC)KChunkError);

        return KErrGeneral;       

        }

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

    iLog->Log((TDesC)KEndParsing);

    CleanupStack::PopAndDestroy();//chunk

    return KErrNone;         

    }   

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

// CLibxml2Tester::ChunkContainer_ChunkOffsetL

// test method function.

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

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

//

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

    {

    //check working of ChunkOffset() for ChunkContainer

    _LIT(KChunkError,"Chunk ChunkOffset() Error.");

    _LIT(KEndParsing,"Checking end.");

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

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 1000;

    TInt maxSize = 5000;

    TInt offset = 0;

    TInt binarySize = cid.Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);      

    TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

										cid,	 chunk,	 offset, binarySize);

    if (binData.ChunkOffset() != offset)

        {

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

        iLog->Log((TDesC)KChunkError);

        return KErrGeneral;       

        }

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

    iLog->Log((TDesC)KEndParsing);

    CleanupStack::PopAndDestroy();//chunk

    return KErrNone;         

    }   

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

// CLibxml2Tester::ChunkContainer_SizeL

// test method function.

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

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

//

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

    {

    //check working of Size() for ChunkContainer

    _LIT(KChunkError,"Chunk ChunkOffset() Error.");

    _LIT(KEndParsing,"Checking end.");

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

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 1000;

    TInt maxSize = 5000;

    TInt offset = 0;

    TInt binarySize = cid.Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);      

    TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

										cid,	 chunk,	 offset, binarySize);

    if (binData.Size() != binarySize)

        {

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

        iLog->Log((TDesC)KChunkError);

         CleanupStack::PopAndDestroy();//chunk

        return KErrGeneral;       

        }

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

    iLog->Log((TDesC)KEndParsing);

    CleanupStack::PopAndDestroy();//chunk

    return KErrNone;         

    }   

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

// CLibxml2Tester::ChunkContainer_NodeTypeL

// test method function.

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

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

//

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

    {

    //check working of NodeType() for ChunkContainer

    _LIT(KChunkError,"Chunk NodeType() Error.");

    _LIT(KEndParsing,"Checking end.");

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

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 1000;

    TInt maxSize = 5000;

    TInt offset = 0;

    TInt binarySize = cid.Length();

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);      

    TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

										cid,	 chunk,	 offset, binarySize);

    if (binData.NodeType() != TXmlEngNode::EChunkContainer) //XmlEngine::DOM::TNodeType

        {

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

        iLog->Log((TDesC)KChunkError);

        return KErrGeneral;       

        }

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

    iLog->Log((TDesC)KEndParsing);

    CleanupStack::PopAndDestroy();//chunk

    return KErrNone;         

    }   

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

// CLibxml2Tester::ChunkContainer_RemoveL

// test method function.

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

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

//

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

    {

    //check working of Removing ChunkContainer

    //1. input 3 chunks, removes second, check if cid of 1 and 3 comapare with test data - returns 2 chunks in list

    _LIT(KChunkError,"Chunk Remove Error.");

    _LIT(KEndParsing,"Checking RemoveChunk end.");

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

    TBufC8<100> cid1(_L8("11111111@123456789") );

    TBufC8<100> cid2(_L8("22222222@123456789") );

    TBufC8<100> cid3(_L8("33333333@123456789") );

    TBufC<100> chunkName(_L("test chunk") );

    TInt size = 1000;

    TInt maxSize = 5000;

    TInt offset = 100;

    TInt binarySize = 25; 

//    TBool isReadOnly = EFalse;

    RChunk chunk;

    chunk.CreateGlobal(chunkName, size, maxSize);

    CleanupClosePushL(chunk);

    iDoc.OpenL(DOM_impl);

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

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

    iDoc.DocumentElement().AppendChildL(el); 

    TXmlEngChunkContainer binData = iDoc.CreateChunkContainerL(

											cid, chunk,offset, binarySize);

    el.AppendChildL(binData);

    TXmlEngChunkContainer binData1 = iDoc.CreateChunkContainerL(

											cid1, chunk,offset, binarySize);

    el.AppendChildL(binData1);

    TXmlEngChunkContainer binData2 = iDoc.CreateChunkContainerL(

											cid2, chunk,offset, binarySize);

    el.AppendChildL(binData2);	

    // (1.) removes chunk with matching cid

    binData1.Remove();								

    RArray<TXmlEngDataContainer> list;

    CleanupClosePushL(list);

    iDoc.GetDataContainerList(list);

    TInt count = list.Count();

    if ( count != 2)

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy(2);//chunk,list

        return KErrGeneral;         

        }

    if ( (list[0].Cid() != cid) && (list[0].Cid() != cid2))

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy(2);//chunk,list

        return KErrGeneral;         

        }

    if ( (list[1].Cid() != cid) && (list[1].Cid() != cid2))

        {

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

        iLog->Log((TDesC)KChunkError);

        CleanupStack::PopAndDestroy(2);//chunk,list

        return KErrGeneral;         

        }

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

    iLog->Log((TDesC)KEndParsing);

   CleanupStack::PopAndDestroy(2);//chunk,list

    return KErrNone;         

    }