void TestPageStream() { CommonLib::simple_alloc_t alloc; embDB::CStorage storage(&alloc, 1000); storage.AddRef(); storage.open(L"d:\\db\\pagestorage.data", false, false, true, false); embDB::FilePagePtr pPage = storage.getNewPage(PAGE_SIZE_8K); storage.initStorage(pPage->getAddr()); storage.saveStorageInfo(); bool bCheckCRC = false; short nType1 = 1; short nType2 = 2; int64 nAddr = storage.getNewPageAddr(PAGE_SIZE_8K); { embDB::TWriteStreamPage<embDB::IDBStorage> writeStream(&storage, PAGE_SIZE_8K, bCheckCRC, nType1, nType2); writeStream.open(nAddr, 0); for (int64 i = 0; i < 10000; ++i) { writeStream.write(i); } writeStream.Save(); } { embDB::TWriteStreamPage<embDB::IDBStorage> writeStream(&storage, PAGE_SIZE_8K, bCheckCRC, nType1, nType2); writeStream.open(nAddr, 0, true); for (int64 i = 0; i <100000; ++i) { writeStream.write(i); } writeStream.Save(); } { embDB::TReadStreamPage<embDB::IDBStorage> readStream(&storage, PAGE_SIZE_8K, bCheckCRC, nType1, nType2); readStream.open(nAddr, 0); for (int64 i = 0; i < 20000; ++i) { int64 d = readStream.readInt64(); if (d != i) { d++; assert(false); } } } }
void SettingsSerializer::writePackedVariant(QDataStream& stream, const QVariant& v) { assert(v.canConvert(QVariant::String)); QString str = v.toString(); if (str == "true") writeStream(stream, QString("1")); else if (str == "false") writeStream(stream, QString("0")); else writeStream(stream, str.toUtf8()); }
void PdfExport::writeGzStream(Stream* str, GList* replacementList) { XOJ_CHECK_TYPE(PdfExport); Object obj1; str->getDict()->lookup("Length", &obj1); if (!obj1.isInt()) { g_error("PDFDoc::writeGzStream, no Length in stream dict"); return; } const int length = obj1.getInt(); obj1.free(); char* buffer = new char[length]; str->unfilteredReset(); for (int i = 0; i < length; i++) { int c = str->getUnfilteredChar(); buffer[i] = c; } GString* text = GzHelper::gzuncompress(buffer, length); writeStream(text->str, text->len, replacementList); g_string_free(text, true); delete buffer; str->reset(); }
void PdfExport::writePlainStream(Stream* str, GList* replacementList) { XOJ_CHECK_TYPE(PdfExport); Object obj1; str->getDict()->lookup("Length", &obj1); if (!obj1.isInt()) { g_error("PDFDoc::writePlainStream, no Length in stream dict"); return; } const int length = obj1.getInt(); obj1.free(); str->unfilteredReset(); GString* buffer = g_string_sized_new(10240); for (int i = 0; i < length; i++) { int c = str->getUnfilteredChar(); buffer = g_string_append_c(buffer, c); } writeStream(buffer->str, buffer->len, replacementList); g_string_free(buffer, true); str->reset(); }
// ----------------------------------------------------------------------------- // CCommonTestClass::ExternalizeMPXCollectionTypeL() // Returns: Symbian OS errors. // ----------------------------------------------------------------------------- TInt CCommonTestClass::ExternalizeMPXCollectionTypeL() { FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL begin"))); iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL begin")); TInt err = KErrNone; if ( iType != NULL ) { FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL started Externalize"))); iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL started Externalize")); CBufBase* buffer = CBufFlat::NewL( 50 ); CleanupStack::PushL( buffer ); RBufWriteStream writeStream( *buffer ); CleanupClosePushL( writeStream ); iType->ExternalizeL( writeStream ); writeStream.CommitL(); buffer->Compress(); CleanupStack::PopAndDestroy( &writeStream ); CleanupStack::PopAndDestroy( buffer ); } else { err = KErrBadTestParameter; FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL Stif test script is wrong."))); iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL Stif test script is wrong.")); } FTRACE(FPrint(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL end err=%d"), err)); iLog->Log(_L("CCommonTestClass::ExternalizeMPXCollectionTypeL testing CMPXCollectionType::ExternalizeMPXCollectionTypeL end err=%d"), err); return err; }
void CCmdTestList::AddMultipleWaitCommandL(TInt32 aTimeout) { RDebug::Printf("CCmdTestList::AddMultipleWaitCommandL"); SSMLOGLEAVEIFNULL(iCommandList); // const TInt KTempDataLength = 1024; CBufFlat* inputBuffer = CBufFlat::NewL(KTempDataLength); CleanupStack::PushL(inputBuffer); RBufWriteStream writeStream(*inputBuffer); CleanupClosePushL(writeStream); writeStream.WriteInt32L(aTimeout); #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE writeStream.WriteUint16L(KDefaultCommandPriority); #endif //SYMBIAN_SSM_FLEXIBLE_MERGE writeStream.CommitL(); RDesReadStream readStream(inputBuffer->Ptr(0)); CleanupClosePushL(readStream); TArray<MSsmCommand*> deferredList = iDeferredList.Array(); CSsmCommandBase* cmd = CCmdMultipleWait::NewL(readStream, deferredList); CleanupStack::PushL(cmd); static_cast<MSsmCommandList&>(*iCommandList).AppendL(cmd); iDeferredList.Reset(); CleanupStack::Pop(cmd); CleanupStack::PopAndDestroy(&readStream); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(inputBuffer); }
void Console::output() { // Print Non-linear Residual if (onNonlinearResidual()) { if (_write_screen) Moose::out << std::setw(2) << _nonlinear_iter << " Nonlinear |R| = " << outputNorm(_old_nonlinear_norm, _norm) << std::endl; if (_write_file) _file_output_stream << std::setw(2) << _nonlinear_iter << " Nonlinear |R| = " << std::scientific << _norm << std::endl; } // Print Linear Residual else if (onLinearResidual()) { if (_write_screen) Moose::out << std::setw(7) << _linear_iter << " Linear |R| = " << std::scientific << outputNorm(_old_linear_norm, _norm) << std::endl; if (_write_file) _file_output_stream << std::setw(7) << _linear_iter << std::scientific << " Linear |R| = " << std::scientific << _norm << std::endl; } // Call the base class output function else { writeVariableNorms(); TableOutputter::output(); } // Write the file if (_write_file) writeStream(); }
/** Write matching contacts back to client. @param aMessage.Ptr0() Descriptor to write array of matching contacts. */ void CViewSubSessionBase::GetContactMatchingCriteriaL(const RMessage2& aMessage) { // Compute contacts externalized size. const TInt contactsCount = iContacts.Count(); TInt contactsExternalizedSize=0; contactsExternalizedSize+=sizeof(TInt32); for (TInt jj=0;jj<contactsCount;++jj) { contactsExternalizedSize+=(iContacts)[jj]->ExternalizedSize(); } HBufC8* buf=HBufC8::NewLC(contactsExternalizedSize); TPtr8 bufPtr(buf->Des()); RDesWriteStream writeStream(bufPtr); CleanupClosePushL(writeStream); writeStream.WriteUint32L(contactsCount); for (TInt ii=0;ii<contactsCount;++ii) { CViewContact* thisContact = (iContacts)[ii]; writeStream << *thisContact; } bufPtr.SetLength(contactsExternalizedSize); aMessage.WriteL(0,*buf); CleanupStack::PopAndDestroy(2, buf); //writeStream.Close(), buf DeleteFindContacts(); }
/** Helper function to compare the data of the command. */ void CCmdTestWaitForApparcInit::CompareCommandsDataL(CCmdWaitForApparcInit* aTestCmd, TCmdErrorSeverity aSeverity, const TUint16 aPriority) { // create output buffer and stream CBufFlat* outputBuffer = CBufFlat::NewL(KTempDataLength); CleanupStack::PushL(outputBuffer); RBufWriteStream writeStream(*outputBuffer); CleanupClosePushL(writeStream); // externalise the data aTestCmd->ExternalizeL(writeStream); RDesReadStream readStream(outputBuffer->Ptr(0)); CleanupClosePushL(readStream); TCmdErrorSeverity severity = static_cast<TCmdErrorSeverity>(readStream.ReadInt16L()); TEST(aSeverity == severity); #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE TUint16 priority = readStream.ReadUint16L(); TEST(aPriority == priority); #else TEST(aPriority == KDefaultPriority); #endif CleanupStack::PopAndDestroy(&readStream); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(outputBuffer); }
GTEST_TEST_F(ConfigManager, newSave) { ConfigMan.create(); ConfigMan.setInt("width", 640); ConfigMan.setInt("height", 480); const Common::UString game1 = ConfigMan.createGame("/path/to/game1/"); ConfigMan.setGame(game1); ConfigMan.setString("path", "/path/to/game1/"); ConfigMan.setInt("width", 800); ConfigMan.setInt("height", 600); ConfigMan.setBool("fullscreen", true); const Common::UString game2 = ConfigMan.createGame("/path/to/game2/"); ConfigMan.setGame(game2); ConfigMan.setString("path", "/path/to/game2"); Common::MemoryWriteStreamDynamic writeStream(true); ConfigMan.save(writeStream); compareStream(writeStream, kConfigFile); }
Console::~Console() { // Write the libMesh performance log header if (_perf_header) { if (_write_screen && !_timing) Moose::out << Moose::perf_log.get_info_header(); if (_write_file) _file_output_stream << Moose::perf_log.get_info_header(); } // Write the solve log (Moose Test Performance) if (_solve_log) { if (_write_screen && !_timing) Moose::out << Moose::perf_log.get_perf_info(); if (_write_file) _file_output_stream << Moose::perf_log.get_perf_info(); } // Write the setup log (Setup Performance) if (_setup_log) { if (_write_screen && !_timing) Moose::out << Moose::setup_perf_log.get_perf_info(); if (_write_file) _file_output_stream << Moose::setup_perf_log.get_perf_info(); } // Write the libMesh log #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING if (_libmesh_log) { if (_write_screen && !_timing) Moose::out << libMesh::perflog.get_perf_info(); if (_write_file) _file_output_stream << libMesh::perflog.get_perf_info(); } #endif // Write the file output stream if (_write_file) writeStream(); /* If --timing was not used disable the logging b/c the destructor of these * object does the output, if --timing was used do nothing because all other * screen related output was disabled above */ if (!_timing) { /* Disable the logs, without this the logs will be printed during the destructors of the logs themselves */ Moose::perf_log.disable_logging(); Moose::setup_perf_log.disable_logging(); #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING libMesh::perflog.disable_logging(); #endif } }
GTEST_TEST_F(ConfigManager, save) { loadConfigMan(); Common::MemoryWriteStreamDynamic writeStream(true); ConfigMan.save(writeStream); compareStream(writeStream, kConfigFile); }
bool SkBBoxHierarchyRecord::shouldRewind(void* data) { // SkBBoxHierarchy::rewindInserts is called by SkPicture after the // SkPicture has rewound its command stream. To match that rewind in the // BBH, we rewind all draws that reference commands that were recorded // past the point to which the SkPicture has rewound, which is given by // writeStream().bytesWritten(). SkPictureStateTree::Draw* draw = static_cast<SkPictureStateTree::Draw*>(data); return draw->fOffset >= writeStream().bytesWritten(); }
Console::Console(const std::string & name, InputParameters parameters) : TableOutputter(name, parameters), _max_rows(getParam<unsigned int>("max_rows")), _fit_mode(getParam<MooseEnum>("fit_mode")), _use_color(false), _scientific_time(getParam<bool>("scientific_time")), _write_file(getParam<bool>("output_file")), _write_screen(getParam<bool>("output_screen")), _verbose(getParam<bool>("verbose")), _old_linear_norm(std::numeric_limits<Real>::max()), _old_nonlinear_norm(std::numeric_limits<Real>::max()), _perf_log(getParam<bool>("perf_log")), _solve_log(isParamValid("solve_log") ? getParam<bool>("solve_log") : _perf_log), _setup_log(isParamValid("setup_log") ? getParam<bool>("setup_log") : _perf_log), #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING _libmesh_log(getParam<bool>("libmesh_log")), #endif _setup_log_early(getParam<bool>("setup_log_early")), _perf_header(isParamValid("perf_header") ? getParam<bool>("perf_header") : _perf_log), _all_variable_norms(getParam<bool>("all_variable_norms")), _outlier_variable_norms(getParam<bool>("outlier_variable_norms")), _outlier_multiplier(getParam<std::vector<Real> >("outlier_multiplier")), _timing(_app.getParam<bool>("timing")) { // If --timing was used from the command-line, do nothing, all logs are enabled if (!_timing) { // Disable performance logging (all log input options must be false) if (!_perf_log && !_setup_log && !_solve_log && !_perf_header && !_setup_log_early) { Moose::perf_log.disable_logging(); Moose::setup_perf_log.disable_logging(); } // Disable libMesh log #ifdef LIBMESH_ENABLE_PERFORMANCE_LOGGING if (!_libmesh_log) libMesh::perflog.disable_logging(); #endif } // Set output coloring if (getParam<bool>("use_color")) { char * term_env = getenv("TERM"); if (term_env) { std::string term(term_env); if (term == "xterm-256color" || term == "xterm") _use_color = true; } } // If file output is desired, wipe out the existing file if not recovering if (_write_file && !_app.isRecovering()) writeStream(false); }
void CViewSubSessionBase::ContactAtL(const RMessage2& aMessage) const { const TInt externalizedSize=iContact->ExternalizedSize(); HBufC8* buf=HBufC8::NewLC(externalizedSize); TPtr8 bufPtr(buf->Des()); RDesWriteStream writeStream(bufPtr); CleanupClosePushL(writeStream); writeStream << *iContact; bufPtr.SetLength(externalizedSize); aMessage.WriteL(0,*buf); CleanupStack::PopAndDestroy(2); // writeStream, buf. }
HBufC8* RContactRemoteView::PackageSortOrderLC(const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes) const { TInt bufLength=aSortOrder.ExternalizedSize(); bufLength+=sizeof(TContactViewPreferences);// HBufC8* buf=HBufC8::NewLC(bufLength); TPtr8 bufPtr(buf->Des()); RDesWriteStream writeStream(bufPtr); writeStream << (TInt32&)aContactTypes; writeStream << aSortOrder; bufPtr.SetLength(bufLength); return buf; }
void CNSmlDummyDataProvider_Test::DoStoreFormatLL() { const CSmlDataStoreFormat& storeFormat = iCNSmlDummyDataProvider->DoStoreFormatL(); EUNIT_PRINT( storeFormat.DisplayName() ); EUNIT_PRINT( _L("Property count %d"), storeFormat.FolderPropertyCount() ); CBufFlat* store = CBufFlat::NewL( 512 ); CleanupStack::PushL( store ); RBufWriteStream writeStream(*store, 0); CleanupClosePushL( writeStream ); storeFormat.ExternalizeL( writeStream ); CleanupStack::PopAndDestroy( 2, store ); }
/** Searches all contact items in the view for fields that contain the search strings specified. @capability ReadUserData @param aFindWords A descriptor array containing one or more search strings @param aMatchedContacts On return, an array of matching contact items @param find behaviour configuration uid to be passed to the server. */ void RContactRemoteView::ContactsMatchingCriteriaL(const MDesCArray& aFindWords, RPointerArray<CViewContact>& aMatchedContacts, TBool aPrefixSearch,TUid aUid) { if(aUid != KNullUid) { TIpcArgs args(aUid.iUid); User::LeaveIfError(SendReceive(ECntSendPluginUidToServer,args)); } CBufBase* buffer = CBufFlat::NewL(32); CleanupStack::PushL(buffer); RBufWriteStream writeStream(*buffer); CleanupClosePushL(writeStream); writeStream.WriteUint32L(aPrefixSearch); const TInt count = aFindWords.MdcaCount(); writeStream.WriteUint32L(count); for (TInt i=0; i<count; ++i) { TPtrC ptr = aFindWords.MdcaPoint(i); writeStream.WriteUint32L(ptr.Length()); writeStream << ptr; } writeStream.CommitL(); CleanupStack::PopAndDestroy(&writeStream); //writeStream.Close() TPtr8 ptr(buffer->Ptr(0)); const TInt bufferSize = buffer->Size(); TPckg<TInt> size(bufferSize); TPckgBuf<TInt> pckg; TIpcArgs args(&pckg,&size,&ptr); User::LeaveIfError(SendReceive(ECntContactMatchingCriteriaExternalizedSize,args)); CleanupStack::PopAndDestroy(buffer); //Internalize Contacts HBufC8* buf=HBufC8::NewLC(pckg()); TPtr8 contactsbufPtr(buf->Des()); TIpcArgs args2(&contactsbufPtr); User::LeaveIfError(SendReceive(ECntGetContactMatchingCriteria,args2)); RDesReadStream readStream(contactsbufPtr); CleanupClosePushL(readStream); const TInt findCount = readStream.ReadUint32L(); for (TInt zz=0;zz<findCount;++zz) { CViewContact* thisContact = CViewContact::NewLC(KNullContactId); readStream >> *thisContact; aMatchedContacts.AppendL(thisContact); CleanupStack::Pop(thisContact); } CleanupStack::PopAndDestroy(2, buf); }
bool ossimOpjJp2Writer::writeFile() { // This method is called from ossimImageFileWriter::execute(). bool result = false; if( theInputConnection.valid() && (getErrorStatus() == ossimErrorCodes::OSSIM_OK) ) { // Make sure Area of Interest is an even multiple of tiles ossimIrect areaOfInterest = theInputConnection->getAreaOfInterest(); ossimIpt imageSize(areaOfInterest.size()); ossimIpt imageLr(areaOfInterest.lr()); ossim_uint32 xBoundaryAdjustFactor = DEFAULT_TILE_SIZE.x - (imageSize.x % DEFAULT_TILE_SIZE.x); ossim_uint32 yBoundaryAdjustFactor = DEFAULT_TILE_SIZE.y - (imageSize.y % DEFAULT_TILE_SIZE.y); imageLr.x += xBoundaryAdjustFactor; imageLr.y += yBoundaryAdjustFactor; areaOfInterest.set_lr(imageLr); theInputConnection->setAreaOfInterest(areaOfInterest); // Set the tile size for all processes. theInputConnection->setTileSize( DEFAULT_TILE_SIZE ); theInputConnection->setToStartOfSequence(); //--- // Note only the master process used for writing... //--- if(theInputConnection->isMaster()) { if (!isOpen()) { open(); } if ( isOpen() ) { result = writeStream(); } } else // Slave process. { // This will return after all tiles for this node have been processed. theInputConnection->slaveProcessTiles(); result = true; } } return result; } // End: ossimOpjJp2Writer::writeFile()
void CViewSubSession::GetSortOrderL(const RMessage2& aMessage) const { const RContactViewSortOrder& sortOrder=View().SortOrder(); const TInt externalizedSize=sortOrder.ExternalizedSize(); HBufC8* buf=HBufC8::NewLC(externalizedSize); TPtr8 bufPtr(buf->Des()); RDesWriteStream writeStream(bufPtr); CleanupClosePushL(writeStream); writeStream << sortOrder; bufPtr.SetLength(externalizedSize); aMessage.WriteL(0,*buf); CleanupStack::PopAndDestroy(2); // writeStream, buf. }
fbtBinTables* fbtBuilder::write(void) { fbtMemoryStream ms; ms.open(fbtStream::SM_WRITE); m_writeMode = -1; writeStream(&ms); void* buffer = fbtMalloc(ms.size() + 1); fbtMemcpy(buffer, ms.ptr(), ms.size()); return new fbtBinTables(buffer, ms.size()); }
/** Construct and delete a command using Internalise */ void CCmdTestLoadSup::CallInternalizeDataTestL(TCmdErrorSeverity aSeverity, TSsmExecutionBehaviour aExecutionBehaviour, TInt16 aRetries, const TSsmSupInfo& aInfo, const TUint16 aPriority) { // create a set of data and put it into a buffer CBufFlat* bufferin = CBufFlat::NewL(1024); CleanupStack::PushL(bufferin); // create write stream on buffer and put the data in RBufWriteStream writeStream(*bufferin); CleanupClosePushL(writeStream); writeStream.WriteInt16L(aSeverity); writeStream.WriteInt8L(aExecutionBehaviour); aInfo.ExternalizeL(writeStream); writeStream.WriteInt16L(aRetries); #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE writeStream.WriteUint16L(aPriority); #else TEST(aPriority == KDefaultPriority); #endif writeStream.CommitL(); // create a readstream on the data and put the data into the command RDesReadStream aReadStream(bufferin->Ptr(0)); CleanupClosePushL(aReadStream); CCmdLoadSup* loadSupCmd = CCmdLoadSup::NewL(aReadStream); CleanupStack::PushL(loadSupCmd); TEST(loadSupCmd->Type() == ESsmCmdLoadSup); // create output buffer and stream CBufFlat* bufferout = CBufFlat::NewL(1024); CleanupStack::PushL(bufferout); RBufWriteStream writeStream2(*bufferout); CleanupClosePushL(writeStream2); // externalise the data loadSupCmd->ExternalizeL(writeStream2); // check the data is correct #ifdef SYMBIAN_SSM_FLEXIBLE_MERGE CompareInputAndOutputL(aSeverity, aExecutionBehaviour, aRetries, aInfo, bufferout, aPriority); #else CompareInputAndOutputL(aSeverity, aExecutionBehaviour, aRetries, aInfo, bufferout); #endif CleanupStack::PopAndDestroy(&writeStream2); CleanupStack::PopAndDestroy(bufferout); CleanupStack::PopAndDestroy(loadSupCmd); CleanupStack::PopAndDestroy(&aReadStream); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(bufferin); }
bool SGFParser::exportSGFtoClipB(QString *str, Tree *tree) { CHECK_PTR(tree); if (stream != NULL) delete stream; stream = new QTextStream(str, IO_WriteOnly); bool res = writeStream(tree); delete stream; stream = NULL; return res; }
/* * takes a game tree, and puts it in SGF format */ bool SGFParser::exportSGFtoClipB(QString *str, Tree *tree, GameData *gd) { Q_CHECK_PTR(tree); if (stream != NULL) delete stream; stream = new QTextStream(str, QIODevice::WriteOnly); bool res = writeStream(tree,gd); delete stream; stream = NULL; return res; }
void tst_QWidgetsVariant::writeToReadFromDataStream() { QFETCH( QVariant, writeVariant ); QFETCH( bool, isNull ); QByteArray data; QDataStream writeStream( &data, QIODevice::WriteOnly ); writeStream << writeVariant; QVariant readVariant; QDataStream readStream( &data, QIODevice::ReadOnly ); readStream >> readVariant; QVERIFY( readVariant.isNull() == isNull ); }
void CCmdTestLoadSup::doTestResourceReaderWithGoodDataL() { TInt err = KErrNone; TInt expectedErr = KErrNone; // these values must match what is in the resource file TCmdErrorSeverity severity = ECmdCriticalSeverity; TSsmExecutionBehaviour executionBehaviour = ESsmWaitForSignal; TUid uid; uid.iUid = 0; TInt32 ordinal = 1; TInt16 retries = 5; TSsmSupInfo info; info.SetL(KFileName, ordinal, uid); INFO_PRINTF1(_L("Test:doTestResourceReaderWithGoodDataL:01 Test: ExternalizeL")); // open reader on contents RResourceReader& reader = LoadResourcesL(KRscFileBuffer, R_COMMAND_LOAD_SUP1); // construct command TSsmCommandParameters params(reader, NULL, 0); CCmdLoadSup* loadSupCmd = CCmdLoadSup::NewL(params); CleanupStack::PushL(loadSupCmd); TEST(loadSupCmd->Type() == ESsmCmdLoadSup); // create output buffer CBufFlat* writebuf = CBufFlat::NewL(1024); CleanupStack::PushL(writebuf); // create output stream on buffer RBufWriteStream writeStream(*writebuf); CleanupClosePushL(writeStream); // externalise the data TRAP(err, loadSupCmd->ExternalizeL(writeStream)); INFO_PRINTF3(_L("ExternalizeL completed with err : %d. expected err : %d"), err, expectedErr); TEST(err == expectedErr); // check the data is correct CompareInputAndOutputL(severity, executionBehaviour, retries, info, writebuf); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(writebuf); CleanupStack::PopAndDestroy(loadSupCmd); FreeResources(); }
void CMultiThreadTestApp::SynchEntryL(CCalEntryView& aView) { FetchEntryL(aView, iEntries); if(iEntries.Count()>0) { _LIT(KExportFile,"Multithread_export"); RFile outFile; TestRegister().CreateTempFileLC(outFile, KExportFile); RFileWriteStream writeStream(outFile); CleanupClosePushL(writeStream); DataExchangeL().ExportAsyncL(KUidVCalendar, writeStream, iEntries, *this); CActiveScheduler::Start(); CleanupStack::PopAndDestroy(2, &outFile); // outFile.Close(), writeStream.Close() } }
void fbtBuilder::writeFile(const fbtId& id, fbtStream* fp) { if (!fp) return; fp->writef("unsigned char %sFBT[]={\n", id.c_str()); m_writeMode = 0; writeStream(fp); fp->writef("\n};\n"); fp->writef("int %sLen=sizeof(%sFBT);\n", id.c_str(), id.c_str()); }
/** Export contact items specified by aIds to aFileName */ void CAgentTest::ExportContactsL(const TDesC& aFileName) { RFile outfile; outfile.Replace(iTest.Fs(),aFileName,EFileWrite); CleanupClosePushL(outfile); RFileWriteStream writeStream(outfile); CleanupClosePushL(writeStream); TUid uid; uid.iUid=KUidVCardConvDefaultImpl; iDb->ExportSelectedContactsL(uid,*iIdArray,writeStream,CContactDatabase::EDefault); writeStream.CommitL(); CleanupStack::PopAndDestroy(2); //writeStream.Close(), outfile.Close() }
bool SaveConverter::createStream(SaveWriter &writer) { // Allocate memory for the internal new save data uint32 contSize = writer.getSize(); _data = new byte[contSize]; // Save the newly created new save data Common::MemoryWriteStream writeStream(_data, contSize); if (!writer.save(writeStream)) return false; // Create a reading stream upon that new save data _stream = new Common::MemoryReadStream(_data, contSize); return true; }