C++ FileOutputStream::close方法代码示例

TEST(TestCommand, testInsertCommand) {
	cout << "testInsertCommand" << endl;
	FileOutputStream* fos = new FileOutputStream("test.dat", "wb");

	CommandWriter* commandWriter = new CommandWriter(fos);
	InsertCommand cmd;
	cmd.setDB("testdb");
	cmd.setNameSpace("test.namespace.db");
	BSONObj* obj = new BSONObj();
	obj->add("name", "Cross");
	obj->add("age", 18);
	cmd.setBSON(obj);

	commandWriter->writeCommand(&cmd);

	fos->close();
	delete fos;
	delete commandWriter;

	FileInputStream* fis = new FileInputStream("test.dat", "rb");
	CommandReader* reader = new CommandReader(fis);
	InsertCommand* rdCmd = (InsertCommand*) reader->readCommand();
	EXPECT_TRUE(rdCmd != NULL);
	EXPECT_TRUE(rdCmd->nameSpace()->compare("test.namespace.db") == 0);
	EXPECT_TRUE(rdCmd->DB()->compare("testdb") == 0);
	const BSONObj* objResult = rdCmd->bson();
	EXPECT_TRUE(objResult != NULL);
	EXPECT_TRUE(objResult->has("name"));	
	EXPECT_TRUE(objResult->getString("name").compare("Cross") == 0);
}

TEST(testIndexP, generateNames) {
	// this will avoid overriding previously generated names and keep consistent the results
	if (!existFile("names.txt")) {
		FileInputStream* fisNames = new FileInputStream("names.csv", "r");
		const char* fullNames = fisNames->readFull();
		FileInputStream* fisLastNames = new FileInputStream("last.csv", "r");
		const char* fullLast = fisLastNames->readFull();

		std::vector<string> names = split(fullNames, "\r");
		cout << names.size() << endl;
		std::vector<string> lastNames = split(fullLast, "\r");
		cout << lastNames.size() << endl;

		FileOutputStream* fos = new FileOutputStream("names.txt", "w+");
		for (int x = 0; x < 10000000; x++) {
			int i = rand() % names.size();
			std::string name = names.at(i);

			i = rand() % lastNames.size();
			std::string lastName = lastNames.at(i);

			std::string fullName = name + " " + lastName;

			fos->writeString(fullName);
		}

		fos->close();
		fisNames->close();
		fisLastNames->close();

		delete fos;
		delete fisNames;
		delete fisLastNames;
	}
}

// protected
void
FileOutputStreamTestCase::seek (void)
{
    File ff (TEST_FILE_NAME);
    if (ff.exists () == false)
        ff.create ();

    FileOutputStream fout (TEST_FILE_NAME, OPEN_MODE);
    String ss = "dflajdkjasldjfaksldjfsalkdjalksdjadflajdkjasldjfaksldjfsalkdjalksdjadflajdkjasldjfaksldjfsalkdjalksdjadflajdkjasldjfaksldjfsalkdjalksdjadflajdkjasldjfaksldjfsalkdjalksdja sd";
    fout.write ((unsigned char *)ss.getCStr (), ss.getLength ());
    fout.flush ();

    CPPUNIT_ASSERT_THROW (fout.seek (-1, BEGIN_ORIGIN), Exception);
    CPPUNIT_ASSERT (fout.seek (3, BEGIN_ORIGIN) == 3);
    CPPUNIT_ASSERT (fout.seek (21, BEGIN_ORIGIN) == 21);
    CPPUNIT_ASSERT (fout.seek (38, BEGIN_ORIGIN) == 38);

    CPPUNIT_ASSERT (fout.seek (-7, CURRENT_ORIGIN) == 31);
    CPPUNIT_ASSERT (fout.seek (2, CURRENT_ORIGIN) == 33);
    CPPUNIT_ASSERT_THROW (fout.seek (-73, CURRENT_ORIGIN), Exception);
    CPPUNIT_ASSERT (fout.seek (24, CURRENT_ORIGIN) == 57);
    CPPUNIT_ASSERT (fout.seek (24, CURRENT_ORIGIN) == 81);

    fout.close ();
}

// protected
void
FileOutputStreamTestCase::write (void)
{
    File f (TEST_FILE_NAME);
    if (f.exists ())
        f.remove ();

    FileOutputStream out (TEST_FILE_NAME, CREATE_NEW_MODE);
    const char* str = "Test line 1\r\nTest line 2\r\nTest line 3";
    out.write ((const unsigned char*)str, strlen (str));
    out.close ();


    File ff (TEST_FILE_NAME);
    CPPUNIT_ASSERT (ff.getLength () == strlen (str));


    File filer (TEST_FILE_NAME1);
    if (filer.exists ())
        filer.remove ();

    FileOutputStream fout5(TEST_FILE_NAME1, APPEND_MODE);
    String s2 = "test line";
    fout5.write ((unsigned char*)s2.getCStr (), s2.getLength ());
    File filetest (TEST_FILE_NAME1);
    CPPUNIT_ASSERT (filetest.getLength () == s2.getLength ());
    fout5.close ();

}

HRESULT CFileHelper::WriteText(LPCTSTR path, LPCTSTR text)
{
	BOOL exists = FALSE;

	HRESULT hr = Contains(path, exists);
	if(FAILED(hr)) return hr;

	if( !exists)
	{
		String folder ;
		if(SUCCEEDED( GetParentFolder(path, folder)))
		{
			hr = CreateFolder(folder.c_str());	
			if(FAILED(hr)) return hr;
		}
	}	

	FileOutputStream ofs;

	ofs.imbue(locale("chs"));

	ofs.open(path);

	if(!ofs.is_open()) return E_FAIL;

	ofs.clear();

	ofs.write(text, STRLEN(text)/* *sizeof(TCHAR)*/);

	ofs.close();

	return S_OK;
}

// protected
void
FileOutputStreamTestCase::flush (void)
{
    File file (_T("testflush"));
    if (file.exists ())
        file.remove ();

    FileOutputStream fout (_T("testflush"), CREATE_NEW_MODE);

    fout.write ((unsigned char*)"1", 1);
    fout.flush ();
    CPPUNIT_ASSERT (file.getLength () == 1);


    fout.close ();
    file.remove ();
}

// protected
void
FileOutputStreamTestCase::ctors (void)
{

    File f1 (TEST_FILE_NAME);
    if (f1.exists () == false)
        f1.create ();

    // open mode
    FileOutputStream fout (TEST_FILE_NAME, OPEN_MODE);
    fout.close ();


    // open or create mode
    File file (TEST_FILE_NAME);
    FileOutputStream fout1 (file, OPEN_OR_CREATE_MODE);
    fout1.close ();


    // read_share
    FileOutputStream fout2(TEST_FILE_NAME, CREATE_MODE, READ_SHARE);
    fout2.close ();
}

void HeightMap::convert(const String& path) {
	FileInputStream* reader = NULL;
	try {
		reader = new FileInputStream(new File(path));
	} catch (...) {
		System::out << "could not open reader" << endl;

		exit(1);
	}

	FileOutputStream* writer = NULL;

	try {
		writer = new FileOutputStream(new File("converted_" + path));
	} catch (...) {
		System::out << "could not open writer" << endl;
		exit(1);
	}

	//FileOutputStream* writer = new FileOutputStream(new File("converted_" + path));

	byte emptybuffer[PLANEWIDTH * HEIGHTSIZE];

	for (int i = 0; i < PLANEWIDTH * HEIGHTSIZE; ++i)
		emptybuffer[i] = 0;

	// first 2 lines
	for (int i = 0; i < 2 * 64; ++i) {
		for (int j = 0; j < PLANEWIDTH; ++j)
			writer->write(emptybuffer, PLANEWIDTH * HEIGHTSIZE);
	}

	int planeIndexX = 2;
	int planeIndexY = 2;

	// inner 60 lines
	for (int i = 0; i < 60; ++i) {
		// 2 beginning plane
		for (int j = 0; j < 2 * PLANEWIDTH; ++j)
			writer->write(emptybuffer, PLANEWIDTH * HEIGHTSIZE);

		// inner 60 planes
		for (int j = 0; j < 60; ++j) {
			System::out << "\r writing(" << planeIndexX << ", " << planeIndexY << ")";

			float plane[PLANEWIDTH * PLANEWIDTH];
			readPlaneForConversion(reader, plane, planeIndexX - 2, planeIndexY - 2);

			writer->write((byte*) plane, PLANEWIDTH * PLANEWIDTH * HEIGHTSIZE);

			++planeIndexX;
		}

		planeIndexX = 2;
		++planeIndexY;

		// 2 ending plane
		for (int j = 0; j < 2 * PLANEWIDTH; ++j)
			writer->write(emptybuffer, PLANEWIDTH * HEIGHTSIZE);
	}

	//last 2 lines
	for (int i = 0; i < 2 * 64; ++i) {
		for (int j = 0; j < PLANEWIDTH; ++j)
			writer->write(emptybuffer, PLANEWIDTH * HEIGHTSIZE);
	}

	writer->close();

	delete writer;
	delete reader;
}