bool testGzip()
{

    printf("######### Gzip Output ############\n");
    Inkscape::URI gzUri("test.gz");
    Inkscape::URI sourceUri(xmlpath);
    Inkscape::IO::UriInputStream  sourceIns(sourceUri);
    Inkscape::IO::UriOutputStream  gzOuts(gzUri);

    Inkscape::IO::GzipOutputStream gzipOuts(gzOuts);
    pipeStream(sourceIns, gzipOuts);
    sourceIns.close();
    gzipOuts.close();

    printf("######### Gzip Input ############\n");

    Inkscape::IO::UriInputStream  gzIns(gzUri);
    Inkscape::URI destUri("crystalegg2.xml");
    Inkscape::IO::UriOutputStream destOuts(destUri);

    Inkscape::IO::GzipInputStream gzipIns(gzIns);
    pipeStream(gzipIns, destOuts);
    gzipIns.close();
    destOuts.close();

    return true;
}
bool testXslt()
{
    printf("######### XSLT Sheet ############\n");
    Inkscape::URI xsltSheetUri(xslpath);
    Inkscape::IO::UriInputStream  xsltSheetIns(xsltSheetUri);
    Inkscape::IO::XsltStyleSheet stylesheet(xsltSheetIns);
    xsltSheetIns.close();
   
    Inkscape::URI sourceUri(xmlpath);
    Inkscape::IO::UriInputStream  xmlIns(sourceUri);

    printf("######### XSLT Input ############\n");
    Inkscape::URI destUri("test.html");
    Inkscape::IO::UriOutputStream xmlOuts(destUri);
   
    Inkscape::IO::XsltInputStream  xsltIns(xmlIns, stylesheet);
    pipeStream(xsltIns, xmlOuts);
    xsltIns.close();
    xmlOuts.close();


    printf("######### XSLT Output ############\n");

    Inkscape::IO::UriInputStream  xmlIns2(sourceUri);

    Inkscape::URI destUri2("test2.html");
    Inkscape::IO::UriOutputStream xmlOuts2(destUri2);
   
    Inkscape::IO::XsltOutputStream  xsltOuts(xmlOuts2, stylesheet);
    pipeStream(xmlIns2, xsltOuts);
    xmlIns2.close();
    xsltOuts.close();

    return true;
}
FileTransferAPIPtr FileManagerAPI::copy(std::string const &sourceUrl, std::string const &targetUrl, FB::JSObjectPtr const &callback) {
	FBLOG_DEBUG("FileManagerAPI::copy", "this=" << this << "\t" << "sourceUrl=" << sourceUrl << "\t" << "targetUrl=" << targetUrl << "\t" << "callback=" << callback);
	FB::URI sourceUri(sourceUrl);
	FB::URI targetUri(targetUrl);
	if(FileManagerAPI::isHttp(sourceUri) && FileManagerAPI::isHttp(targetUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't copy two Remote resources");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't copy two Remote resources"));
		return FileTransferAPIPtr();
	}
	if(FileManagerAPI::isInternal(targetUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't copy file into Internal resources");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't copy file into Internal resources"));
		return FileTransferAPIPtr();
	}
	if(FileManagerAPI::isHttp(sourceUri) && !isSameHost(sourceUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't use different host with remote resource (XSS)");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't use different host with remote resource (XSS)"));
		return FileTransferAPIPtr();
	}
	if(FileManagerAPI::isHttp(targetUri) && !isSameHost(targetUri)) {
		FBLOG_DEBUG("FileManagerAPI::copy", "Can't use different host with remote resource (XSS)");
		callback->InvokeAsync("", FB::variant_list_of(false)("Can't use different host with remote resource (XSS)"));
		return FileTransferAPIPtr();
	}
	FileTransferAPIPtr fileTransfer = getFactory()->getFileTransfer(sourceUri, targetUri, callback);
	return fileTransfer;
}
DMAD_EXPORT_C void CDmAdEngine::CopyCommandL(const TDesC8& aTargetUri,
                                             const TDesC8& aTargetLuid,
                                             const TDesC8& aSourceUri,
                                             const TDesC8& aSourceLuid,
                                             const TDesC8& aType,
                                             TInt aStatusRef)
    {
    TRACE("CDmAdEngine::CopyCommandL");
    
    DEBUG_LOG1(_L8("aTargetUri = %S"), &aTargetUri);
    DEBUG_LOG1(_L8("aTargetLuid = %S"), &aTargetLuid);
    DEBUG_LOG1(_L8("aSourceUri = %S"), &aSourceUri);
    DEBUG_LOG1(_L8("aSourceLuid = %S"), &aSourceLuid);
    DEBUG_LOG1(_L8("aType = %S"), &aType);
    DEBUG_LOG1(_L("aStatusRef = %d"), aStatusRef);
    

    TInt err = KErrNone;
    TPtrC8 sourceUri(TDmAdUtil::RemoveDotSlash(aSourceUri));
    TInt status = KErrNone;
    CBufBase* object = 0;
    TRAP(err, status = DoFetchLeafObjectL(sourceUri, aSourceLuid, aType, object));
    if (err != KErrNone)
        {
        iCallBack->SetStatusL(aStatusRef, err);
        return;
        }
    if (status != KErrNone)
        {
        delete object;
        iCallBack->SetStatusL(aStatusRef, status);
        return;
        }
    
    CleanupStack::PushL(object);

    DEBUG_LOG(_L("object:"));
    DEBUG_LOG_HEX(object->Ptr(0));
    
    TPtrC8 targetUri(TDmAdUtil::RemoveDotSlash(aTargetUri));
    TRAP(err, DoUpdateLeafObjectL(targetUri, aTargetLuid, object->Ptr(0), aType, aStatusRef));
    if (err != KErrNone)
        {
        iCallBack->SetStatusL(aStatusRef, err);
        }

    CleanupStack::PopAndDestroy(); // object
    }