reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-24 20:19:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ENH: Add compression support to XML files

Browse Source
This commit is contained in:
Andy Cedilnik 2005-01-27 10:15:01 -05:00
parent 14477cee6e
commit 62b310bc52
8 changed files with 82 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Source/CTest/cmCTestBuildHandler.cxx
View File

@ -22,6 +22,7 @@
#include "cmMakefile.h"
#include "cmLocalGenerator.h"
#include "cmGlobalGenerator.h"
#include "cmGeneratedFileStream.h"
//#include <cmsys/RegularExpression.hxx>
#include <cmsys/Process.h>
@ -211,12 +212,13 @@ int cmCTestBuildHandler::BuildDirectory(cmCTest *ctest_inst)
return 1;
}
std::ofstream ofs;
cmGeneratedFileStream ofs;
double elapsed_time_start = cmSystemTools::GetTime();
if ( !m_CTest->OpenOutputFile("Temporary", "LastBuild.log", ofs) )
{
std::cerr << "Cannot create LastBuild.log file" << std::endl;
}
m_StartBuild = m_CTest->CurrentTime();
std::string output;
int retVal = 0;
@ -237,10 +239,6 @@ int cmCTestBuildHandler::BuildDirectory(cmCTest *ctest_inst)
{
std::cerr << "Error(s) when building project" << std::endl;
}
if ( ofs )
{
ofs.close();
}
std::vector<cmStdString>::size_type cc;
if ( m_CTest->GetDartConfiguration("SourceDirectory").size() > 20 ||
@ -440,12 +438,13 @@ int cmCTestBuildHandler::BuildDirectory(cmCTest *ctest_inst)
std::cout << " " << errors << " Compiler errors" << std::endl;
std::cout << " " << warnings << " Compiler warnings" << std::endl;
if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Build.xml", ofs) )
cmGeneratedFileStream xofs;
if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Build.xml", xofs, true) )
{
std::cerr << "Cannot create build XML file" << std::endl;
return 1;
}
this->GenerateDartBuildOutput(ofs, errorsWarnings, elapsed_build_time);
this->GenerateDartBuildOutput(xofs, errorsWarnings, elapsed_build_time);
return 0;
}

7
Source/CTest/cmCTestConfigureHandler.cxx
View File

@ -18,6 +18,7 @@
#include "cmCTestConfigureHandler.h"
#include "cmCTest.h"
#include "cmGeneratedFileStream.h"
#include "cmake.h"
#include <cmsys/Process.h>
@ -59,15 +60,15 @@ int cmCTestConfigureHandler::ConfigureDirectory(cmCTest *ctest_inst)
int res = 0;
if ( !m_CTest->GetShowOnly() )
{
std::ofstream os;
if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Configure.xml", os) )
cmGeneratedFileStream os;
if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Configure.xml", os, true) )
{
std::cerr << "Cannot open configure file" << std::endl;
return 1;
}
std::string start_time = m_CTest->CurrentTime();
std::ofstream ofs;
cmGeneratedFileStream ofs;
m_CTest->OpenOutputFile("Temporary", "LastConfigure.log", ofs);
res = m_CTest->RunMakeCommand(cCommand.c_str(), &output,
&retVal, buildDirectory.c_str(),

13
Source/CTest/cmCTestCoverageHandler.cxx
View File

@ -20,6 +20,7 @@
#include "cmCTest.h"
#include "cmake.h"
#include "cmSystemTools.h"
#include "cmGeneratedFileStream.h"
#include "cmGlob.h"
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx>
@ -38,13 +39,13 @@ cmCTestCoverageHandler::cmCTestCoverageHandler()
}
//----------------------------------------------------------------------
bool cmCTestCoverageHandler::StartLogFile(std::ofstream& covLogFile, int logFileCount)
bool cmCTestCoverageHandler::StartLogFile(cmGeneratedFileStream& covLogFile, int logFileCount)
{
char covLogFilename[1024];
sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
std::cout << "Open file: " << covLogFilename << std::endl;
if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
covLogFilename, covLogFile))
covLogFilename, covLogFile, true))
{
std::cerr << "Cannot open log file: " << covLogFilename << std::endl;
return false;
@ -57,7 +58,7 @@ bool cmCTestCoverageHandler::StartLogFile(std::ofstream& covLogFile, int logFile
}
//----------------------------------------------------------------------
void cmCTestCoverageHandler::EndLogFile(std::ofstream& ostr, int logFileCount)
void cmCTestCoverageHandler::EndLogFile(cmGeneratedFileStream& ostr, int logFileCount)
{
std::string local_end_time = m_CTest->CurrentTime();
ostr << "\t<EndDateTime>" << local_end_time << "</EndDateTime>" << std::endl
@ -324,11 +325,11 @@ int cmCTestCoverageHandler::CoverageDirectory(cmCTest *ctest_inst)
}
}
std::ofstream covSumFile;
std::ofstream covLogFile;
cmGeneratedFileStream covSumFile;
cmGeneratedFileStream covLogFile;
if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
"Coverage.xml", covSumFile))
"Coverage.xml", covSumFile, true))
{
std::cerr << "Cannot open coverage summary file: Coverage.xml" << std::endl;
return 1;

5
Source/CTest/cmCTestCoverageHandler.h
View File

@ -23,6 +23,7 @@
#include "cmListFileCache.h"
class cmCTest;
class cmGeneratedFileStream;
/** \class cmCTestCoverageHandler
* \brief A class that handles coverage computaiton for ctest
@ -49,8 +50,8 @@ private:
cmCTest *m_CTest;
bool ShouldIDoCoverage(const char* file, const char* srcDir,
const char* binDir, bool verbose);
bool StartLogFile(std::ofstream& ostr, int logFileCount);
void EndLogFile(std::ofstream& ostr, int logFileCount);
bool StartLogFile(cmGeneratedFileStream& ostr, int logFileCount);
void EndLogFile(cmGeneratedFileStream& ostr, int logFileCount);
struct cmCTestCoverage
{

13
Source/CTest/cmCTestTestHandler.cxx
View File

@ -19,6 +19,7 @@
#include "cmCTest.h"
#include "cmake.h"
#include "cmGeneratedFileStream.h"
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx>
#include <cmsys/Base64.h>
@ -302,7 +303,7 @@ int cmCTestTestHandler::TestDirectory(cmCTest *ctest_inst, bool memcheck)
if (failed.size())
{
std::ofstream ofs;
cmGeneratedFileStream ofs;
std::cerr << "\nThe following tests FAILED:\n";
m_CTest->OpenOutputFile("Temporary", "LastTestsFailed.log", ofs);
@ -324,9 +325,9 @@ int cmCTestTestHandler::TestDirectory(cmCTest *ctest_inst, bool memcheck)
if ( m_CTest->GetProduceXML() )
{
std::ofstream xmlfile;
cmGeneratedFileStream xmlfile;
if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
(memcheck ? "DynamicAnalysis.xml" : "Test.xml"), xmlfile) )
(memcheck ? "DynamicAnalysis.xml" : "Test.xml"), xmlfile, true) )
{
std::cerr << "Cannot create " << (memcheck ? "memory check" : "testing")
<< " XML file" << std::endl;
@ -372,8 +373,8 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
this->GetListOfTests(&testlist, memcheck);
tm_ListOfTests::size_type tmsize = testlist.size();
std::ofstream ofs;
std::ofstream *olog = 0;
cmGeneratedFileStream ofs;
cmGeneratedFileStream *olog = 0;
if ( !m_CTest->GetShowOnly() && tmsize > 0 &&
m_CTest->OpenOutputFile("Temporary",
(memcheck?"LastMemCheck.log":"LastTest.log"), ofs) )
@ -1670,7 +1671,7 @@ bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t remove_thre
}
cmOStringStream ostr;
std::string::size_type cc;
std::string::size_type skipsize;
std::string::size_type skipsize = 0;
int inTag = 0;
int skipped = 0;
for ( cc = 0; cc < output.size(); cc ++ )

7
Source/CTest/cmCTestUpdateHandler.cxx
View File

@ -23,6 +23,7 @@
#include "cmLocalGenerator.h"
#include "cmGlobalGenerator.h"
#include "cmVersion.h"
#include "cmGeneratedFileStream.h"
//#include <cmsys/RegularExpression.hxx>
#include <cmsys/Process.h>
@ -95,8 +96,8 @@ int cmCTestUpdateHandler::UpdateDirectory(cmCTest *ctest_inst)
std::string command = cvsCommand + " -z3 update " + cvsOptions +
" " + extra_update_opts;
std::ofstream os;
if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Update.xml", os) )
cmGeneratedFileStream os;
if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Update.xml", os, true) )
{
std::cerr << "Cannot open log file" << std::endl;
}
@ -106,7 +107,7 @@ int cmCTestUpdateHandler::UpdateDirectory(cmCTest *ctest_inst)
std::string goutput;
int retVal = 0;
bool res = true;
std::ofstream ofs;
cmGeneratedFileStream ofs;
if ( !m_CTest->GetShowOnly() )
{
res = cmSystemTools::RunSingleCommand(command.c_str(), &goutput,

78
Source/cmCTest.cxx
View File

@ -24,6 +24,7 @@
#include <cmsys/Directory.hxx>
#include "cmGlob.h"
#include "cmDynamicLoader.h"
#include "cmGeneratedFileStream.h"
#include "cmCTestBuildHandler.h"
#include "cmCTestCoverageHandler.h"
@ -231,6 +232,7 @@ cmCTest::cmCTest()
m_TestModel = cmCTest::EXPERIMENTAL;
m_InteractiveDebugMode = true;
m_TimeOut = 0;
m_CompressXMLFiles = false;
int cc;
for ( cc=0; cc < cmCTest::LAST_TEST; cc ++ )
{
@ -481,7 +483,8 @@ void cmCTest::Finalize()
bool cmCTest::OpenOutputFile(const std::string& path,
const std::string& name, std::ofstream& stream)
const std::string& name, cmGeneratedFileStream& stream,
bool compress)
{
std::string testingDir = m_ToplevelPath + "/Testing";
if ( path.size() > 0 )
@ -508,43 +511,59 @@ bool cmCTest::OpenOutputFile(const std::string& path,
}
}
std::string filename = testingDir + "/" + name;
stream.open(filename.c_str());
stream.Open(filename.c_str());
if( !stream )
{
std::cerr << "Problem opening file: " << filename << std::endl;
return false;
}
if ( compress )
{
if ( m_CompressXMLFiles )
{
stream.SetCompression(true);
}
}
return true;
}
bool cmCTest::AddIfExists(tm_VectorOfStrings& files, const char* file)
{
if ( this->CTestFileExists(file) )
{
files.push_back(file);
}
else
{
std::string name = file;
name += ".gz";
if ( this->CTestFileExists(name.c_str()) )
{
files.push_back(name.c_str());
}
else
{
return false;
}
}
return true;
}
int cmCTest::SubmitResults()
{
std::ofstream ofs;
cmGeneratedFileStream ofs;
this->OpenOutputFile("Temporary", "LastSubmit.log", ofs);
cmCTest::tm_VectorOfStrings files;
std::string prefix = this->GetSubmitResultsPrefix();
// TODO:
// Check if test is enabled
if ( this->CTestFileExists("Update.xml") )
this->AddIfExists(files, "Update.xml");
this->AddIfExists(files, "Configure.xml");
this->AddIfExists(files, "Build.xml");
this->AddIfExists(files, "Test.xml");
if ( this->AddIfExists(files, "Coverage.xml") )
{
files.push_back("Update.xml");
}
if ( this->CTestFileExists("Configure.xml") )
{
files.push_back("Configure.xml");
}
if ( this->CTestFileExists("Build.xml") )
{
files.push_back("Build.xml");
}
if ( this->CTestFileExists("Test.xml") )
{
files.push_back("Test.xml");
}
if ( this->CTestFileExists("Coverage.xml") )
{
files.push_back("Coverage.xml");
cmCTest::tm_VectorOfStrings gfiles;
std::string gpath = m_ToplevelPath + "/Testing/" + m_CurrentTag;
std::string::size_type glen = gpath.size() + 1;
@ -565,18 +584,9 @@ int cmCTest::SubmitResults()
std::cerr << "Problem globbing" << std::endl;
}
}
if ( this->CTestFileExists("DynamicAnalysis.xml") )
{
files.push_back("DynamicAnalysis.xml");
}
if ( this->CTestFileExists("Purify.xml") )
{
files.push_back("Purify.xml");
}
if ( this->CTestFileExists("Notes.xml") )
{
files.push_back("Notes.xml");
}
this->AddIfExists(files, "DynamicAnalysis.xml");
this->AddIfExists(files, "Purify.xml");
this->AddIfExists(files, "Notes.xml");
if ( ofs )
{
@ -1134,7 +1144,7 @@ int cmCTest::GenerateNotesFile(const char* cfiles)
return 1;
}
std::ofstream ofs;
cmGeneratedFileStream ofs;
if ( !this->OpenOutputFile(m_CurrentTag, "Notes.xml", ofs) )
{
std::cerr << "Cannot open notes file" << std::endl;

8
Source/cmCTest.h
View File

@ -30,6 +30,7 @@ class cmCTestCoverageHandler;
class cmCTestScriptHandler;
class cmCTestTestHandler;
class cmCTestUpdateHandler;
class cmGeneratedFileStream;
class cmCTest
{
@ -87,6 +88,7 @@ public:
* Check if CTest file exists
*/
bool CTestFileExists(const std::string& filename);
bool AddIfExists(tm_VectorOfStrings& files, const char* file);
/**
* Set the cmake test
@ -140,7 +142,9 @@ public:
int GenerateNotesFile(const char* files);
bool OpenOutputFile(const std::string& path,
const std::string& name, std::ofstream& stream);
const std::string& name,
cmGeneratedFileStream& stream,
bool compress = false);
static std::string MakeXMLSafe(const std::string&);
static std::string MakeURLSafe(const std::string&);
@ -255,6 +259,8 @@ private:
bool m_InteractiveDebugMode;
bool m_ShortDateFormat;
bool m_CompressXMLFiles;
void BlockTestErrorDiagnostics();