// -----------------------------------------------------------------------------
// 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);
	
	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;
	User::LeaveIfError( fp.Open(aRFs, _L("c:\\testing\\data\\xmleng\\efute\\input\\containers\\petit.jpg"), EFileRead) );
	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->SetInputFileL(pDoc);
   	des->UseExternalDataL( list );
   	des->DeserializeL();
    	
	CleanupStack::PopAndDestroy( 8 );
	return KErrNone;	
	}
void CTFontSessionCache::ConstructL()
    {
    User::LeaveIfError(iChunk.CreateGlobal(KNullDesC,0x10000,0x10000));
    iSharedHeap = UserHeap::ChunkHeap(iChunk,0x10000,0x1000,0x10000,0,EFalse,0);
    if(iSharedHeap == NULL)
        {
        RDebug::Print(_L("iSharedHeap = NULL"));
        User::Leave(KErrNoMemory);
        }
    iIFontStore = CTIsolatedFontStore::NewL(iSharedHeap);
    iIFontStore->LoadRasterizersL();
    iIFontStore->iFs->LoadFontsAtStartupL();
    
    _LIT(KTypefaceName, "DejaVu Sans Condensed");
    TFontSpec spec(KTypefaceName, KFontHeight);   
    
    TInt ret = iIFontStore->iFs->GetNearestFontToDesignHeightInPixels(iFont,spec);
    TEST(ret == KErrNone);
 
    }
Ejemplo n.º 3
0
PassRefPtr<SharedMemory> SharedMemory::create(size_t size)
{
    // On Symbian, global chunks (shared memory segments) have system-unique names, so we pick a random
    // number from the kernel's random pool and use it as a string.
    // Using an integer simplifies serialization of the name in Handle::encode()
    uint32_t random = Math::Random();

    TBuf<KMaxKernelName> chunkName;
    chunkName.Format(_L("%d"), random);

    RChunk chunk;
    TInt error = chunk.CreateGlobal(chunkName, size, size);
    if (error) {
        qCritical() << "Failed to create WK2 shared memory of size " << size << " with error " << error;
        return 0;
    }

    RefPtr<SharedMemory> sharedMemory(adoptRef(new SharedMemory));
    sharedMemory->m_handle = chunk.Handle();
    sharedMemory->m_size = chunk.Size();
    sharedMemory->m_data = static_cast<void*>(chunk.Base());
    return sharedMemory.release();
}
// -----------------------------------------------------------------------------
// CLibxml2Tester::TestUseExternalDataL
// test deserialize from file, using external data
// (other items were commented in a header).
// -----------------------------------------------------------------------------
// 	
TInt CLibxml2Tester::TestUseExternalDataInfosetL(CStifItemParser& aItem)
	{
	TInt err;
    TPtrC pDeserializerType;
    aItem.GetNextString( pDeserializerType );
	
    TPtrC pInputFile;
    aItem.GetNextString( pInputFile );
	
	TPtrC pBinary;
	aItem.GetNextString( pBinary );
	
	TPtrC pFile;
	aItem.GetNextString(pFile);
	
    TPtrC pOutputFile;
    aItem.GetNextString( pOutputFile );
    
    TPtrC pDirtyReturn;
    aItem.GetNextString( pDirtyReturn );
    
    TLex inputNum (pDirtyReturn);
    TInt dirtyReturn;
     inputNum.Val(dirtyReturn);	
    
    TInt nContainers = 3;
    RFile fileHandle;
    RFs aRFs;
    aRFs.Connect();
    CleanupClosePushL( aRFs );
	
	SetupDocumentL();
	  
    HBufC8* binbuf = ReadFileToBufferL(pBinary);
	CleanupStack::PushL(binbuf);
    
	
	TBufC<100> chunkName(_L("ChunkContainer") );
    TInt size = 2000;
    TInt maxSize = 10000;
    TInt offset = 0;
    TInt binarySize = CID_2().Length();
//    TBool isReadOnly = EFalse;
    RChunk chunk;
    chunk.CreateGlobal(chunkName, size, maxSize);
    CleanupClosePushL(chunk);

	
	RFile fp;
	User::LeaveIfError( fp.Open(aRFs, pFile, EFileRead) );
	CleanupClosePushL(fp); 	
  
  
	
    TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), binbuf->Des());
    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);
	
    User::LeaveIfError( fileHandle.Replace( aRFs, pOutputFile, EFileStream | EFileWrite | EFileShareExclusive));
    CleanupClosePushL( fileHandle );
	
    CTestHandler* testHandle = CTestHandler::NewLC( fileHandle );
    RArray<TXmlEngDataContainer> list;
	CleanupClosePushL(list);	////
	iDoc.GetDataContainerList(list); 
	CXmlEngDeserializer* des;
    if( pDeserializerType.FindF( XOP ) != KErrNotFound )     
        {
        des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOP );
        CleanupStack::PushL( des );
        des->SetInputFileL( pInputFile );
        des->UseExternalDataL( list );
        TRAP(err,des->DeserializeL());
        
        }
    else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )     
        {
        des = CXmlEngDeserializer::NewL( *testHandle, EDeserializerXOPInfoset );
        CleanupStack::PushL( des );
        des->SetInputFileL( pInputFile );
        des->UseExternalDataL( list );
        TRAP(err,des->DeserializeL());
        }
    if(list.Count() != nContainers) User::Leave(KErrGeneral);

    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;
	User::LeaveIfError( fp.Open(aRFs, _L("c:\\testing\\data\\xmleng\\efute\\input\\containers\\petit.jpg"), EFileRead) );
	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;	
    }
TInt CLibxml2Tester::TestDOMExternalDataL(CStifItemParser& aItem)
	{
 TInt err;
    TPtrC pDeserializerType;
    aItem.GetNextString( pDeserializerType );
	
    TPtrC pInputFile;
    aItem.GetNextString( pInputFile );
	
    TPtrC pBinary;
   TPtrC pFile;
   if( (pDeserializerType.FindF( INFOSET ) != KErrNotFound ) || (pDeserializerType.FindF( XOP ) != KErrNotFound )  )   
        {
        aItem.GetNextString( pBinary );
        aItem.GetNextString(pFile);	
        }
	
    TPtrC pOutputFile;
    aItem.GetNextString( pOutputFile );
    
    TPtrC pDirtyReturn;
    aItem.GetNextString( pDirtyReturn );
    
    TLex inputNum (pDirtyReturn);
    TInt dirtyReturn;
     inputNum.Val(dirtyReturn);	
        
    TInt nContainers = 3;
    RFile fileHandle;
    RFs aRFs;
    aRFs.Connect();
    CleanupClosePushL( aRFs );
    RArray<TXmlEngDataContainer> list;
    if( (pDeserializerType.FindF( INFOSET ) != KErrNotFound ) || (pDeserializerType.FindF( XOP ) != KErrNotFound ) )   
        {
        SetupDocumentL();	  
        HBufC8* binbuf = ReadFileToBufferL(pBinary);
        CleanupStack::PushL(binbuf);
        TBufC<100> chunkName(_L("ChunkContainer") );
        TInt size = 2000;
        TInt maxSize = 10000;
        TInt offset = 0;
        TInt binarySize = CID_2().Length();
//        TBool isReadOnly = EFalse;
        RChunk chunk;
        chunk.CreateGlobal(chunkName, size, maxSize);
        CleanupClosePushL(chunk);	
	RFile fp;
	User::LeaveIfError( fp.Open(aRFs, pFile, EFileRead) );
	CleanupClosePushL(fp); 	
        TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), binbuf->Des());
        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);
        CleanupClosePushL(list);	////
        iDoc.GetDataContainerList(list); 
        }	
	
    RXmlEngDocument doc;
    	
         CXmlEngDeserializerDOM* des = CXmlEngDeserializerDOM::NewL();
        CleanupStack::PushL( des );
        des->UseDOMImplementationL( DOM_impl);
    if( pDeserializerType.FindF( XOP ) != KErrNotFound )     
        {
        des->UseExternalDataL( list );
        des->SetInputFileL( pInputFile,EDeserializerXOP);
        TRAP(err,doc=des->DeserializeL());
        }
    else if( pDeserializerType.FindF( INFOSET ) != KErrNotFound )     
        {
        des->UseExternalDataL( list );
        des->SetInputFileL( pInputFile,EDeserializerXOPInfoset );
        TRAP(err,doc=des->DeserializeL());
        }    
          
    if(list.Count() != nContainers) User::Leave(KErrGeneral);
    
    RArray<TXmlEngDataContainer>* fromDeserializer = des->ExternalData();
    
    if(fromDeserializer->Count() != nContainers) User::Leave(KErrGeneral);	
    	for(TInt i = 0; i < nContainers; i++ )
		{
		if (fromDeserializer->operator[](i).NodeType() != list.operator[](i).NodeType() ) User::Leave( KErrGeneral );
		if (fromDeserializer->operator[](i).Size() != list.operator[](i).Size() ) User::Leave( KErrGeneral );
		}
//    fromDeserializer->Close();

    SaveDocumentL(doc,pOutputFile);
		
    CleanupStack::PopAndDestroy( 6 ); 
    if ( err == dirtyReturn ) return KErrNone;		
    else return err;

	}	
TInt CLibxml2Tester::TestDOMSetInputBufferL(CStifItemParser& aItem)
        {
        TPtrC pType;
        aItem.GetNextString(pType);
	
        TPtrC pDoc;
        aItem.GetNextString(pDoc);
        
        TPtrC pBinary;
        TPtrC pFile;
        if( pType.FindF( INFOSET ) != KErrNotFound )   
            {
        aItem.GetNextString( pBinary );
        aItem.GetNextString(pFile);	
            }
        	
        TPtrC pOut;
        aItem.GetNextString(pOut);
	
        HBufC8* buf = ReadFileL(pDoc);
        CleanupStack::PushL(buf);
		
//             TInt nContainers = 3;
        RFile fileHandle;
        RFs aRFs;
        aRFs.Connect();
        CleanupClosePushL( aRFs );
	
        RArray<TXmlEngDataContainer> list;
        if( pType.FindF( INFOSET ) != KErrNotFound )   
        {
        SetupDocumentL();	  
        HBufC8* binbuf = ReadFileToBufferL(pBinary);
        CleanupStack::PushL(binbuf);
        TBufC<100> chunkName(_L("ChunkContainer") );
        TInt size = 2000;
        TInt maxSize = 10000;
        TInt offset = 0;
        TInt binarySize = CID_2().Length();
//        TBool isReadOnly = EFalse;
        RChunk chunk;
        chunk.CreateGlobal(chunkName, size, maxSize);
        CleanupClosePushL(chunk);	
	RFile fp;
	User::LeaveIfError( fp.Open(aRFs, pFile, EFileRead) );
	CleanupClosePushL(fp); 	
        TXmlEngBinaryContainer bincont = iDoc.CreateBinaryContainerL(CID_1(), binbuf->Des());
        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);
        CleanupClosePushL(list);	////
        iDoc.GetDataContainerList(list); 
        }	
	

        RXmlEngDocument doc;
	
       CXmlEngDeserializerDOM* des = CXmlEngDeserializerDOM::NewL();
       CleanupStack::PushL( des );
       des->UseDOMImplementationL( DOM_impl);
               if( pType.FindF( INFOSET ) != KErrNotFound )   
            {
            des->UseExternalDataL( list );
            }
       des->SetInputBuffer(buf->Des(), RetDeserializerType(pType));
       doc=des->DeserializeL();
       SaveDocumentL(doc,pOut);
          if( pType.FindF( INFOSET ) != KErrNotFound )   
            {
            CleanupStack::PopAndDestroy( 7 );
            }
            else
            {
            CleanupStack::PopAndDestroy( 3 );    
            }
       return KErrNone;	
       }