static void output_roots (xmlTextWriterPtr xo, char **roots) { size_t i; XMLERROR (-1, xmlTextWriterStartElement (xo, BAD_CAST "operatingsystems")); for (i = 0; roots[i] != NULL; ++i) output_root (xo, roots[i]); XMLERROR (-1, xmlTextWriterEndElement (xo)); }
std::string OutputFileHandler::GetRelativePath() const { FileFinder output_root("", RelativeTo::ChasteTestOutput); std::string relative_path = FindFile("").GetRelativePath(output_root); if (!relative_path.empty() && *relative_path.rbegin() == '/') { relative_path.erase(--relative_path.end()); // Remove trailing slash } return relative_path; }
std::string OutputFileHandler::MakeFoldersAndReturnFullPath(const std::string& rDirectory) const { fs::path output_root(GetChasteTestOutputDirectory()); fs::path rel_path(rDirectory); if (!rel_path.empty() && (*(--rel_path.end())) == ".") { // rDirectory has a trailing slash, which gives an unhelpful last component rel_path.remove_leaf(); } // Make master wait (because other processes may be checking whether a directory exists) PetscTools::Barrier("OutputFileHandler::MakeFoldersAndReturnFullPathBeforeCreation"); // Are we the master process? Only the master should make any new directories if (PetscTools::AmMaster()) { try { // If necessary make the ChasteTestOutputDirectory - don't make it deleteable by Chaste fs::create_directories(output_root); // Note that this is a no-op if the folder exists already // Now make all the sub-folders requested one-by-one and add the .chaste_deletable_folder file to them fs::path next_folder(output_root); for (fs::path::iterator path_iter = rel_path.begin(); path_iter != rel_path.end(); ++path_iter) { next_folder /= *path_iter; bool created_dir = fs::create_directory(next_folder); if (created_dir) { // Add the Chaste signature file fs::ofstream sig_file(next_folder / SIG_FILE_NAME); sig_file.close(); } } } // LCOV_EXCL_START catch (const fs::filesystem_error& e) { TERMINATE("Error making test output folder: " << e.what()); } // LCOV_EXCL_STOP } // Wait for master to finish before going on to use the directory. PetscTools::Barrier("OutputFileHandler::MakeFoldersAndReturnFullPath"); std::string path_with_slash = (output_root / rel_path).string(); AddTrailingSlash(path_with_slash); return path_with_slash; }
OutputFileHandler::OutputFileHandler(const FileFinder& rDirectory, bool cleanOutputDirectory) { FileFinder output_root("", RelativeTo::ChasteTestOutput); std::string relative_path; try { relative_path = rDirectory.GetRelativePath(output_root); } catch (const Exception&) { EXCEPTION("The location provided to OutputFileHandler must be inside CHASTE_TEST_OUTPUT; '" << rDirectory.GetAbsolutePath() << "' is not under '" << output_root.GetAbsolutePath() << "'."); } if (*output_root.GetAbsolutePath().rbegin() != '/' && !relative_path.empty()) { assert(*relative_path.begin() == '/'); relative_path.erase(0, 1); // Remove leading slash } CommonConstructor(relative_path, cleanOutputDirectory); }
void TestHandler() throw(Exception) { // Test that CHASTE_TEST_OUTPUT always has a trailing slash even before // a class object is instantiated const std::string chaste_test_output(OutputFileHandler::GetChasteTestOutputDirectory()); TS_ASSERT_EQUALS( *(chaste_test_output.end()-1), '/'); // Make a handler that points straight to the CHASTE_TEST_OUTPUT directory. OutputFileHandler handler(""); const std::string handler_path(handler.GetOutputDirectoryFullPath()); TS_ASSERT(handler_path.length() > 0); TS_ASSERT_EQUALS(handler_path, handler.GetChasteTestOutputDirectory()); TS_ASSERT_EQUALS(handler.GetRelativePath(), ""); // Test that CHASTE_TEST_OUTPUT always has a trailing slash TS_ASSERT_EQUALS( *(handler_path.end()-1), '/'); // Make a handler that points to a sub-directory. std::string dir = "testhandler"; OutputFileHandler handler2(dir); std::string full_dir = handler2.GetOutputDirectoryFullPath(); TS_ASSERT_EQUALS(full_dir.substr(full_dir.length()-dir.length()-1), dir+"/"); TS_ASSERT_EQUALS(full_dir.substr(0, full_dir.length()-dir.length()-1), handler_path); TS_ASSERT_EQUALS(handler2.GetRelativePath(), dir); // We can also create handlers from a FileFinder (provided it points to a location in CHASTE_TEST_OUTPUT) OutputFileHandler handler3(handler.FindFile("testhandler2")); full_dir = handler3.GetOutputDirectoryFullPath(); TS_ASSERT_EQUALS(full_dir.substr(full_dir.length()-dir.length()-2), dir+"2/"); TS_ASSERT_EQUALS(full_dir.substr(0, full_dir.length()-dir.length()-2), handler_path); TS_ASSERT_EQUALS(handler3.GetRelativePath(), "testhandler2"); // Check that all three handlers can create files out_stream p_file_stream; p_file_stream = handler.OpenOutputFile("test_file", std::ios::out); TS_ASSERT(FileFinder(handler_path + "test_file").Exists()); p_file_stream = handler.OpenOutputFile("test_file2"); TS_ASSERT(FileFinder(handler_path + "test_file2").Exists()); p_file_stream = handler2.OpenOutputFile("test_file"); TS_ASSERT(FileFinder(handler2.GetOutputDirectoryFullPath() + "test_file").Exists()); p_file_stream = handler2.OpenOutputFile("test_", 34, ".txt"); TS_ASSERT(FileFinder(handler2.GetOutputDirectoryFullPath() + "test_34.txt").Exists()); p_file_stream = handler3.OpenOutputFile("test_file"); TS_ASSERT(FileFinder(handler3.GetOutputDirectoryFullPath() + "test_file").Exists()); // This should try to write files to /, which isn't allowed (we hope!) TS_ASSERT_THROWS_CONTAINS(OutputFileHandler bad_handler("../../../../../../../../../../../../../../../", false), "due to it potentially being above, and cleaning, CHASTE_TEST_OUTPUT."); TS_ASSERT_THROWS_CONTAINS(OutputFileHandler bad_handler("/", false), "The constructor argument to OutputFileHandler must be a relative path"); TS_ASSERT_THROWS_CONTAINS(OutputFileHandler bad_handler(FileFinder("/"), false), "The location provided to OutputFileHandler must be inside CHASTE_TEST_OUTPUT"); // Check the CopyFileTo method FileFinder source_file("global/test/TestOutputFileHandler.hpp", RelativeTo::ChasteSourceRoot); TS_ASSERT(!handler2.FindFile("TestOutputFileHandler.hpp").Exists()); PetscTools::Barrier("TestOutputFileHandler-0"); FileFinder dest_file = handler2.CopyFileTo(source_file); TS_ASSERT(dest_file.Exists()); FileFinder missing_file("global/no_file", RelativeTo::ChasteSourceRoot); TS_ASSERT_THROWS_CONTAINS(handler2.CopyFileTo(missing_file), "Can only copy single files"); FileFinder global_dir("global", RelativeTo::ChasteSourceRoot); TS_ASSERT_THROWS_CONTAINS(handler2.CopyFileTo(global_dir), "Can only copy single files"); // We don't want other people using CHASTE_TEST_OUTPUT whilst we are messing with it! PetscTools::Barrier("TestOutputFileHandler-1"); // Test that the environment variable actually influences the location of files { setenv("CHASTE_TEST_OUTPUT", "", 1/*Overwrite*/); // Check this folder is not present FileFinder test_folder("testoutput/whatever", RelativeTo::ChasteSourceRoot); TS_ASSERT(!test_folder.Exists()); PetscTools::Barrier("TestOutputFileHandler-2"); // Make a folder and erase it - NB only master can erase files and check it is successful! OutputFileHandler handler4("whatever"); TS_ASSERT(test_folder.Exists()); PetscTools::Barrier("TestOutputFileHandler-2b"); if (PetscTools::AmMaster()) { test_folder.Remove(); // If we've not written anything else to the testoutput folder, remove that too // rather than leaving an empty folder lieing around in the source tree! FileFinder output_root("", RelativeTo::ChasteTestOutput); if (output_root.IsEmpty()) { output_root.DangerousRemove(); } } PetscTools::Barrier("TestOutputFileHandler-2c"); } { setenv("CHASTE_TEST_OUTPUT", "config__cyborg__T800__cooper", 1/*Overwrite*/); // Test that CHASTE_TEST_OUTPUT always has a trailing slash even before // a class object is instantiated and when the directory does not exist const std::string nonexistent_test_path(OutputFileHandler::GetChasteTestOutputDirectory()); TS_ASSERT_EQUALS( *(nonexistent_test_path.end()-1), '/'); } { // Check this folder is not present std::string test_folder("somewhere_without_trailing_forward_slash"); TS_ASSERT(!FileFinder(test_folder, RelativeTo::CWD).Exists()); PetscTools::Barrier("TestOutputFileHandler-3"); setenv("CHASTE_TEST_OUTPUT", test_folder.c_str(), 1/*Overwrite*/); // Make a folder using a FileFinder, for coverage of the case where the root output folder doesn't exist FileFinder sub_folder("test_folder", RelativeTo::ChasteTestOutput); TS_ASSERT(!sub_folder.Exists()); PetscTools::Barrier("TestOutputFileHandler-3a"); OutputFileHandler creating_handler(sub_folder); TS_ASSERT(sub_folder.Exists()); // Make a folder OutputFileHandler handler5("whatever"); TS_ASSERT(FileFinder(test_folder, RelativeTo::CWD).Exists()); PetscTools::Barrier("TestOutputFileHandler-3b"); // Erase it if (PetscTools::AmMaster()) { FileFinder(test_folder).DangerousRemove(); } } // Reset the location of CHASTE_TEST_OUTPUT setenv("CHASTE_TEST_OUTPUT", chaste_test_output.c_str(), 1/*Overwrite*/); // We don't want other people using CHASTE_TEST_OUTPUT while we are messing with it! PetscTools::Barrier("TestOutputFileHandler-4"); // Coverage of the case where we can't open a file for writing OutputFileHandler handler6("no_write_access"); if (PetscTools::AmMaster()) { std::string dir_path = handler6.GetOutputDirectoryFullPath(); #ifndef _MSC_VER // This test can never pass on modern Windows OS! See: http://support.microsoft.com/kb/326549 // You can't change DIRECTORY attributes chmod(dir_path.c_str(), CHASTE_READONLY); TS_ASSERT_THROWS_CONTAINS(p_file_stream = handler6.OpenOutputFile("test_file"), "Could not open file"); #endif chmod(dir_path.c_str(), CHASTE_READ_WRITE_EXECUTE); fs::remove(dir_path + ".chaste_deletable_folder"); fs::remove(dir_path); } // Check behaviour of FindFile("") FileFinder handler_self = handler.FindFile(""); TS_ASSERT_EQUALS(handler_self.GetAbsolutePath(), handler.GetOutputDirectoryFullPath()); }
bool U6Lzw::decompress_buffer(unsigned char *source, uint32 source_length, unsigned char *destination, uint32 destination_length) { const int max_codeword_length = 12; bool end_marker_reached = false; int codeword_size = 9; long bits_read = 0; int next_free_codeword = 0x102; int dictionary_size = 0x200; long bytes_written = 0; int cW; int pW = 0; // get rid of uninitialized warning. unsigned char C; source += 4; //skip the filesize dword. while (! end_marker_reached) { cW = get_next_codeword(&bits_read, source, codeword_size); switch (cW) { // re-init the dictionary case 0x100: codeword_size = 9; next_free_codeword = 0x102; dictionary_size = 0x200; dict->reset(); cW = get_next_codeword(&bits_read, source, codeword_size); output_root((unsigned char)cW, destination, &bytes_written); break; // end of compressed file has been reached case 0x101: end_marker_reached = true; break; // (cW <> 0x100) && (cW <> 0x101) default: if (cW < next_free_codeword) // codeword is already in the dictionary { // create the string associated with cW (on the stack) get_string(cW); C = stack->gettop(); // output the string represented by cW while (!stack->is_empty()) { output_root(stack->pop(), destination, &bytes_written); } // add pW+C to the dictionary dict->add(C,pW); next_free_codeword++; if (next_free_codeword >= dictionary_size) { if (codeword_size < max_codeword_length) { codeword_size += 1; dictionary_size *= 2; } } } else // codeword is not yet defined { // create the string associated with pW (on the stack) get_string(pW); C = stack->gettop(); // output the string represented by pW while (!stack->is_empty()) { output_root(stack->pop(), destination, &bytes_written); } // output the char C output_root(C, destination, &bytes_written); // the new dictionary entry must correspond to cW // if it doesn't, something is wrong with the lzw-compressed data. if (cW != next_free_codeword) { DEBUG(0,LEVEL_ERROR,"cW != next_free_codeword!\n"); return(false); } // add pW+C to the dictionary dict->add(C,pW); next_free_codeword++; if (next_free_codeword >= dictionary_size) { if (codeword_size < max_codeword_length) { codeword_size += 1; dictionary_size *= 2; } } }; break; } // shift roles - the current cW becomes the new pW pW = cW; } return true; }