/cmake-2.8.9-rc2/Source/cmCTest.cxx
C++ | 3225 lines | 2801 code | 248 blank | 176 comment | 495 complexity | d84bf56181d0ac26d8a59d9659e27288 MD5 | raw file
Possible License(s): BSD-3-Clause, LGPL-2.0, Apache-2.0
Large files files are truncated, but you can click here to view the full file
- /*============================================================================
- CMake - Cross Platform Makefile Generator
- Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
- Distributed under the OSI-approved BSD License (the "License");
- see accompanying file Copyright.txt for details.
- This software is distributed WITHOUT ANY WARRANTY; without even the
- implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- See the License for more information.
- ============================================================================*/
- #include "cm_curl.h"
- #include "cmCTest.h"
- #include "cmake.h"
- #include "cmMakefile.h"
- #include "cmLocalGenerator.h"
- #include "cmGlobalGenerator.h"
- #include <cmsys/Base64.h>
- #include <cmsys/Directory.hxx>
- #include <cmsys/SystemInformation.hxx>
- #include "cmDynamicLoader.h"
- #include "cmGeneratedFileStream.h"
- #include "cmXMLSafe.h"
- #include "cmVersionMacros.h"
- #include "cmCTestCommand.h"
- #include "cmCTestStartCommand.h"
- #include "cmCTestBuildHandler.h"
- #include "cmCTestBuildAndTestHandler.h"
- #include "cmCTestConfigureHandler.h"
- #include "cmCTestCoverageHandler.h"
- #include "cmCTestMemCheckHandler.h"
- #include "cmCTestScriptHandler.h"
- #include "cmCTestSubmitHandler.h"
- #include "cmCTestTestHandler.h"
- #include "cmCTestUpdateHandler.h"
- #include "cmCTestUploadHandler.h"
- #include "cmVersion.h"
- #include <cmsys/RegularExpression.hxx>
- #include <cmsys/Process.h>
- #include <cmsys/Glob.hxx>
- #include <stdlib.h>
- #include <math.h>
- #include <float.h>
- #include <ctype.h>
- #include <cmsys/auto_ptr.hxx>
- #include <cm_zlib.h>
- #include <cmsys/Base64.h>
- #if defined(__BEOS__) && !defined(__HAIKU__)
- #include <be/kernel/OS.h> /* disable_debugger() API. */
- #endif
- #if defined(__HAIKU__)
- #include <os/kernel/OS.h> /* disable_debugger() API. */
- #endif
- #define DEBUGOUT std::cout << __LINE__ << " "; std::cout
- #define DEBUGERR std::cerr << __LINE__ << " "; std::cerr
- //----------------------------------------------------------------------
- struct tm* cmCTest::GetNightlyTime(std::string str,
- bool tomorrowtag)
- {
- struct tm* lctime;
- time_t tctime = time(0);
- lctime = gmtime(&tctime);
- char buf[1024];
- // add todays year day and month to the time in str because
- // curl_getdate no longer assumes the day is today
- sprintf(buf, "%d%02d%02d %s",
- lctime->tm_year+1900,
- lctime->tm_mon +1,
- lctime->tm_mday,
- str.c_str());
- cmCTestLog(this, OUTPUT, "Determine Nightly Start Time" << std::endl
- << " Specified time: " << str.c_str() << std::endl);
- //Convert the nightly start time to seconds. Since we are
- //providing only a time and a timezone, the current date of
- //the local machine is assumed. Consequently, nightlySeconds
- //is the time at which the nightly dashboard was opened or
- //will be opened on the date of the current client machine.
- //As such, this time may be in the past or in the future.
- time_t ntime = curl_getdate(buf, &tctime);
- cmCTestLog(this, DEBUG, " Get curl time: " << ntime << std::endl);
- tctime = time(0);
- cmCTestLog(this, DEBUG, " Get the current time: " << tctime << std::endl);
- const int dayLength = 24 * 60 * 60;
- cmCTestLog(this, DEBUG, "Seconds: " << tctime << std::endl);
- while ( ntime > tctime )
- {
- // If nightlySeconds is in the past, this is the current
- // open dashboard, then return nightlySeconds. If
- // nightlySeconds is in the future, this is the next
- // dashboard to be opened, so subtract 24 hours to get the
- // time of the current open dashboard
- ntime -= dayLength;
- cmCTestLog(this, DEBUG, "Pick yesterday" << std::endl);
- cmCTestLog(this, DEBUG, " Future time, subtract day: " << ntime
- << std::endl);
- }
- while ( tctime > (ntime + dayLength) )
- {
- ntime += dayLength;
- cmCTestLog(this, DEBUG, " Past time, add day: " << ntime << std::endl);
- }
- cmCTestLog(this, DEBUG, "nightlySeconds: " << ntime << std::endl);
- cmCTestLog(this, DEBUG, " Current time: " << tctime
- << " Nightly time: " << ntime << std::endl);
- if ( tomorrowtag )
- {
- cmCTestLog(this, OUTPUT, " Use future tag, Add a day" << std::endl);
- ntime += dayLength;
- }
- lctime = gmtime(&ntime);
- return lctime;
- }
- //----------------------------------------------------------------------
- std::string cmCTest::CleanString(const std::string& str)
- {
- std::string::size_type spos = str.find_first_not_of(" \n\t\r\f\v");
- std::string::size_type epos = str.find_last_not_of(" \n\t\r\f\v");
- if ( spos == str.npos )
- {
- return std::string();
- }
- if ( epos != str.npos )
- {
- epos = epos - spos + 1;
- }
- return str.substr(spos, epos);
- }
- //----------------------------------------------------------------------
- std::string cmCTest::CurrentTime()
- {
- time_t currenttime = time(0);
- struct tm* t = localtime(¤ttime);
- //return ::CleanString(ctime(¤ttime));
- char current_time[1024];
- if ( this->ShortDateFormat )
- {
- strftime(current_time, 1000, "%b %d %H:%M %Z", t);
- }
- else
- {
- strftime(current_time, 1000, "%a %b %d %H:%M:%S %Z %Y", t);
- }
- cmCTestLog(this, DEBUG, " Current_Time: " << current_time << std::endl);
- return cmXMLSafe(cmCTest::CleanString(current_time)).str();
- }
- //----------------------------------------------------------------------
- std::string cmCTest::GetCostDataFile()
- {
- std::string fname = this->GetCTestConfiguration("CostDataFile");
- if(fname == "")
- {
- fname= this->GetBinaryDir() + "/Testing/Temporary/CTestCostData.txt";
- }
- return fname;
- }
- #ifdef CMAKE_BUILD_WITH_CMAKE
- //----------------------------------------------------------------------------
- static size_t
- HTTPResponseCallback(void *ptr, size_t size, size_t nmemb, void *data)
- {
- register int realsize = (int)(size * nmemb);
- std::string *response
- = static_cast<std::string*>(data);
- const char* chPtr = static_cast<char*>(ptr);
- *response += chPtr;
- return realsize;
- }
- //----------------------------------------------------------------------------
- int cmCTest::HTTPRequest(std::string url, HTTPMethod method,
- std::string& response,
- std::string fields,
- std::string putFile, int timeout)
- {
- CURL* curl;
- FILE* file;
- ::curl_global_init(CURL_GLOBAL_ALL);
- curl = ::curl_easy_init();
- //set request options based on method
- switch(method)
- {
- case cmCTest::HTTP_POST:
- ::curl_easy_setopt(curl, CURLOPT_POST, 1);
- ::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, fields.c_str());
- break;
- case cmCTest::HTTP_PUT:
- if(!cmSystemTools::FileExists(putFile.c_str()))
- {
- response = "Error: File ";
- response += putFile + " does not exist.\n";
- return -1;
- }
- ::curl_easy_setopt(curl, CURLOPT_PUT, 1);
- file = ::fopen(putFile.c_str(), "rb");
- ::curl_easy_setopt(curl, CURLOPT_INFILE, file);
- //fall through to append GET fields
- case cmCTest::HTTP_GET:
- if(fields.size())
- {
- url += "?" + fields;
- }
- break;
- default:
- break;
- }
-
- ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
- ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
- ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
- //set response options
- ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, HTTPResponseCallback);
- ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&response);
- ::curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
- CURLcode res = ::curl_easy_perform(curl);
- ::curl_easy_cleanup(curl);
- ::curl_global_cleanup();
-
- return static_cast<int>(res);
- }
- #endif
- //----------------------------------------------------------------------
- std::string cmCTest::MakeURLSafe(const std::string& str)
- {
- cmOStringStream ost;
- char buffer[10];
- for ( std::string::size_type pos = 0; pos < str.size(); pos ++ )
- {
- unsigned char ch = str[pos];
- if ( ( ch > 126 || ch < 32 ||
- ch == '&' ||
- ch == '%' ||
- ch == '+' ||
- ch == '=' ||
- ch == '@'
- ) && ch != 9 )
- {
- sprintf(buffer, "%02x;", (unsigned int)ch);
- ost << buffer;
- }
- else
- {
- ost << ch;
- }
- }
- return ost.str();
- }
- //----------------------------------------------------------------------------
- std::string cmCTest::DecodeURL(const std::string& in)
- {
- std::string out;
- for(const char* c = in.c_str(); *c; ++c)
- {
- if(*c == '%' && isxdigit(*(c+1)) && isxdigit(*(c+2)))
- {
- char buf[3] = {*(c+1), *(c+2), 0};
- out.append(1, char(strtoul(buf, 0, 16)));
- c += 2;
- }
- else
- {
- out.append(1, *c);
- }
- }
- return out;
- }
- //----------------------------------------------------------------------
- cmCTest::cmCTest()
- {
- this->LabelSummary = true;
- this->ParallelLevel = 1;
- this->SubmitIndex = 0;
- this->Failover = false;
- this->BatchJobs = false;
- this->ForceNewCTestProcess = false;
- this->TomorrowTag = false;
- this->Verbose = false;
-
- this->Debug = false;
- this->ShowLineNumbers = false;
- this->Quiet = false;
- this->ExtraVerbose = false;
- this->ProduceXML = false;
- this->ShowOnly = false;
- this->RunConfigurationScript = false;
- this->UseHTTP10 = false;
- this->PrintLabels = false;
- this->CompressTestOutput = true;
- this->CompressMemCheckOutput = true;
- this->TestModel = cmCTest::EXPERIMENTAL;
- this->MaxTestNameWidth = 30;
- this->InteractiveDebugMode = true;
- this->TimeOut = 0;
- this->GlobalTimeout = 0;
- this->LastStopTimeout = 24 * 60 * 60;
- this->CompressXMLFiles = false;
- this->CTestConfigFile = "";
- this->ScheduleType = "";
- this->StopTime = "";
- this->NextDayStopTime = false;
- this->OutputLogFile = 0;
- this->OutputLogFileLastTag = -1;
- this->SuppressUpdatingCTestConfiguration = false;
- this->DartVersion = 1;
- this->OutputTestOutputOnTestFailure = false;
- this->ComputedCompressTestOutput = false;
- this->ComputedCompressMemCheckOutput = false;
- if(cmSystemTools::GetEnv("CTEST_OUTPUT_ON_FAILURE"))
- {
- this->OutputTestOutputOnTestFailure = true;
- }
- this->InitStreams();
- this->Parts[PartStart].SetName("Start");
- this->Parts[PartUpdate].SetName("Update");
- this->Parts[PartConfigure].SetName("Configure");
- this->Parts[PartBuild].SetName("Build");
- this->Parts[PartTest].SetName("Test");
- this->Parts[PartCoverage].SetName("Coverage");
- this->Parts[PartMemCheck].SetName("MemCheck");
- this->Parts[PartSubmit].SetName("Submit");
- this->Parts[PartNotes].SetName("Notes");
- this->Parts[PartExtraFiles].SetName("ExtraFiles");
- this->Parts[PartUpload].SetName("Upload");
- // Fill the part name-to-id map.
- for(Part p = PartStart; p != PartCount; p = Part(p+1))
- {
- this->PartMap[cmSystemTools::LowerCase(this->Parts[p].GetName())] = p;
- }
- this->ShortDateFormat = true;
- this->TestingHandlers["build"] = new cmCTestBuildHandler;
- this->TestingHandlers["buildtest"] = new cmCTestBuildAndTestHandler;
- this->TestingHandlers["coverage"] = new cmCTestCoverageHandler;
- this->TestingHandlers["script"] = new cmCTestScriptHandler;
- this->TestingHandlers["test"] = new cmCTestTestHandler;
- this->TestingHandlers["update"] = new cmCTestUpdateHandler;
- this->TestingHandlers["configure"] = new cmCTestConfigureHandler;
- this->TestingHandlers["memcheck"] = new cmCTestMemCheckHandler;
- this->TestingHandlers["submit"] = new cmCTestSubmitHandler;
- this->TestingHandlers["upload"] = new cmCTestUploadHandler;
- cmCTest::t_TestingHandlers::iterator it;
- for ( it = this->TestingHandlers.begin();
- it != this->TestingHandlers.end(); ++ it )
- {
- it->second->SetCTestInstance(this);
- }
- // Make sure we can capture the build tool output.
- cmSystemTools::EnableVSConsoleOutput();
- }
- //----------------------------------------------------------------------
- cmCTest::~cmCTest()
- {
- cmCTest::t_TestingHandlers::iterator it;
- for ( it = this->TestingHandlers.begin();
- it != this->TestingHandlers.end(); ++ it )
- {
- delete it->second;
- it->second = 0;
- }
- this->SetOutputLogFileName(0);
- }
- void cmCTest::SetParallelLevel(int level)
- {
- this->ParallelLevel = level < 1 ? 1 : level;
- }
- //----------------------------------------------------------------------------
- bool cmCTest::ShouldCompressTestOutput()
- {
- if(!this->ComputedCompressTestOutput)
- {
- std::string cdashVersion = this->GetCDashVersion();
- //version >= 1.6?
- bool cdashSupportsGzip = cmSystemTools::VersionCompare(
- cmSystemTools::OP_GREATER, cdashVersion.c_str(), "1.6") ||
- cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
- cdashVersion.c_str(), "1.6");
- this->CompressTestOutput &= cdashSupportsGzip;
- this->ComputedCompressTestOutput = true;
- }
- return this->CompressTestOutput;
- }
- //----------------------------------------------------------------------------
- bool cmCTest::ShouldCompressMemCheckOutput()
- {
- if(!this->ComputedCompressMemCheckOutput)
- {
- std::string cdashVersion = this->GetCDashVersion();
- bool compressionSupported = cmSystemTools::VersionCompare(
- cmSystemTools::OP_GREATER, cdashVersion.c_str(), "1.9.0");
- this->CompressMemCheckOutput &= compressionSupported;
- this->ComputedCompressMemCheckOutput = true;
- }
- return this->CompressMemCheckOutput;
- }
- //----------------------------------------------------------------------------
- std::string cmCTest::GetCDashVersion()
- {
- #ifdef CMAKE_BUILD_WITH_CMAKE
- //First query the server. If that fails, fall back to the local setting
- std::string response;
- std::string url = "http://";
- url += this->GetCTestConfiguration("DropSite");
- std::string cdashUri = this->GetCTestConfiguration("DropLocation");
- cdashUri = cdashUri.substr(0, cdashUri.find("/submit.php"));
- int res = 1;
- if ( ! cdashUri.empty() )
- {
- url += cdashUri + "/api/getversion.php";
- res = cmCTest::HTTPRequest(url, cmCTest::HTTP_GET, response, "", "", 3);
- }
- return res ? this->GetCTestConfiguration("CDashVersion") : response;
- #else
- return this->GetCTestConfiguration("CDashVersion");
- #endif
- }
- //----------------------------------------------------------------------------
- cmCTest::Part cmCTest::GetPartFromName(const char* name)
- {
- // Look up by lower-case to make names case-insensitive.
- std::string lower_name = cmSystemTools::LowerCase(name);
- PartMapType::const_iterator i = this->PartMap.find(lower_name);
- if(i != this->PartMap.end())
- {
- return i->second;
- }
- // The string does not name a valid part.
- return PartCount;
- }
- //----------------------------------------------------------------------
- int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
- {
- cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
- if(!this->InteractiveDebugMode)
- {
- this->BlockTestErrorDiagnostics();
- }
- else
- {
- cmSystemTools::PutEnv("CTEST_INTERACTIVE_DEBUG_MODE=1");
- }
- this->BinaryDir = binary_dir;
- cmSystemTools::ConvertToUnixSlashes(this->BinaryDir);
- this->UpdateCTestConfiguration();
- cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
- if ( this->ProduceXML )
- {
- cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
- cmCTestLog(this, OUTPUT,
- " Site: " << this->GetCTestConfiguration("Site") << std::endl
- << " Build name: " << this->GetCTestConfiguration("BuildName")
- << std::endl);
- cmCTestLog(this, DEBUG, "Produce XML is on" << std::endl);
- if ( this->TestModel == cmCTest::NIGHTLY &&
- this->GetCTestConfiguration("NightlyStartTime").empty() )
- {
- cmCTestLog(this, WARNING,
- "WARNING: No nightly start time found please set in"
- " CTestConfig.cmake or DartConfig.cmake" << std::endl);
- cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
- return 0;
- }
- }
- cmake cm;
- cmGlobalGenerator gg;
- gg.SetCMakeInstance(&cm);
- cmsys::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator());
- cmMakefile *mf = lg->GetMakefile();
- if ( !this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(), mf) )
- {
- cmCTestLog(this, DEBUG, "Cannot find custom configuration file tree"
- << std::endl);
- return 0;
- }
- if ( this->ProduceXML )
- {
- // Verify "Testing" directory exists:
- //
- std::string testingDir = this->BinaryDir + "/Testing";
- if ( cmSystemTools::FileExists(testingDir.c_str()) )
- {
- if ( !cmSystemTools::FileIsDirectory(testingDir.c_str()) )
- {
- cmCTestLog(this, ERROR_MESSAGE, "File " << testingDir
- << " is in the place of the testing directory" << std::endl);
- return 0;
- }
- }
- else
- {
- if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory "
- << testingDir << std::endl);
- return 0;
- }
- }
- // Create new "TAG" file or read existing one:
- //
- bool createNewTag = true;
- if (command)
- {
- createNewTag = command->ShouldCreateNewTag();
- }
- std::string tagfile = testingDir + "/TAG";
- std::ifstream tfin(tagfile.c_str());
- std::string tag;
- if (createNewTag)
- {
- time_t tctime = time(0);
- if ( this->TomorrowTag )
- {
- tctime += ( 24 * 60 * 60 );
- }
- struct tm *lctime = gmtime(&tctime);
- if ( tfin && cmSystemTools::GetLineFromStream(tfin, tag) )
- {
- int year = 0;
- int mon = 0;
- int day = 0;
- int hour = 0;
- int min = 0;
- sscanf(tag.c_str(), "%04d%02d%02d-%02d%02d",
- &year, &mon, &day, &hour, &min);
- if ( year != lctime->tm_year + 1900 ||
- mon != lctime->tm_mon+1 ||
- day != lctime->tm_mday )
- {
- tag = "";
- }
- std::string tagmode;
- if ( cmSystemTools::GetLineFromStream(tfin, tagmode) )
- {
- if (tagmode.size() > 4 && !this->Parts[PartStart])
- {
- this->TestModel = cmCTest::GetTestModelFromString(tagmode.c_str());
- }
- }
- tfin.close();
- }
- if (tag.size() == 0 || (0 != command) || this->Parts[PartStart])
- {
- cmCTestLog(this, DEBUG, "TestModel: " << this->GetTestModelString()
- << std::endl);
- cmCTestLog(this, DEBUG, "TestModel: " << this->TestModel << std::endl);
- if ( this->TestModel == cmCTest::NIGHTLY )
- {
- lctime = this->GetNightlyTime(
- this->GetCTestConfiguration("NightlyStartTime"),
- this->TomorrowTag);
- }
- char datestring[100];
- sprintf(datestring, "%04d%02d%02d-%02d%02d",
- lctime->tm_year + 1900,
- lctime->tm_mon+1,
- lctime->tm_mday,
- lctime->tm_hour,
- lctime->tm_min);
- tag = datestring;
- std::ofstream ofs(tagfile.c_str());
- if ( ofs )
- {
- ofs << tag << std::endl;
- ofs << this->GetTestModelString() << std::endl;
- }
- ofs.close();
- if ( 0 == command )
- {
- cmCTestLog(this, OUTPUT, "Create new tag: " << tag << " - "
- << this->GetTestModelString() << std::endl);
- }
- }
- }
- else
- {
- if ( tfin )
- {
- cmSystemTools::GetLineFromStream(tfin, tag);
- tfin.close();
- }
- if ( tag.empty() )
- {
- cmCTestLog(this, ERROR_MESSAGE,
- "Cannot read existing TAG file in " << testingDir
- << std::endl);
- return 0;
- }
- cmCTestLog(this, OUTPUT, " Use existing tag: " << tag << " - "
- << this->GetTestModelString() << std::endl);
- }
- this->CurrentTag = tag;
- }
- return 1;
- }
- //----------------------------------------------------------------------
- bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
- {
- std::string src_dir
- = this->GetCTestConfiguration("SourceDirectory").c_str();
- std::string bld_dir = this->GetCTestConfiguration("BuildDirectory").c_str();
- this->DartVersion = 1;
- for(Part p = PartStart; p != PartCount; p = Part(p+1))
- {
- this->Parts[p].SubmitFiles.clear();
- }
- cmMakefile* mf = command->GetMakefile();
- std::string fname;
- std::string src_dir_fname = src_dir;
- src_dir_fname += "/CTestConfig.cmake";
- cmSystemTools::ConvertToUnixSlashes(src_dir_fname);
- std::string bld_dir_fname = bld_dir;
- bld_dir_fname += "/CTestConfig.cmake";
- cmSystemTools::ConvertToUnixSlashes(bld_dir_fname);
- if ( cmSystemTools::FileExists(bld_dir_fname.c_str()) )
- {
- fname = bld_dir_fname;
- }
- else if ( cmSystemTools::FileExists(src_dir_fname.c_str()) )
- {
- fname = src_dir_fname;
- }
- if ( !fname.empty() )
- {
- cmCTestLog(this, OUTPUT, " Reading ctest configuration file: "
- << fname.c_str() << std::endl);
- bool readit = mf->ReadListFile(mf->GetCurrentListFile(),
- fname.c_str() );
- if(!readit)
- {
- std::string m = "Could not find include file: ";
- m += fname;
- command->SetError(m.c_str());
- return false;
- }
- }
- else
- {
- cmCTestLog(this, WARNING,
- "Cannot locate CTest configuration: in BuildDirectory: "
- << bld_dir_fname.c_str() << std::endl);
- cmCTestLog(this, WARNING,
- "Cannot locate CTest configuration: in SourceDirectory: "
- << src_dir_fname.c_str() << std::endl);
- }
- this->SetCTestConfigurationFromCMakeVariable(mf, "NightlyStartTime",
- "CTEST_NIGHTLY_START_TIME");
- this->SetCTestConfigurationFromCMakeVariable(mf, "Site", "CTEST_SITE");
- this->SetCTestConfigurationFromCMakeVariable(mf, "BuildName",
- "CTEST_BUILD_NAME");
- const char* dartVersion = mf->GetDefinition("CTEST_DART_SERVER_VERSION");
- if ( dartVersion )
- {
- this->DartVersion = atoi(dartVersion);
- if ( this->DartVersion < 0 )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Invalid Dart server version: "
- << dartVersion << ". Please specify the version number."
- << std::endl);
- return false;
- }
- }
- if ( !this->Initialize(bld_dir.c_str(), command) )
- {
- return false;
- }
- cmCTestLog(this, OUTPUT, " Use " << this->GetTestModelString()
- << " tag: " << this->GetCurrentTag() << std::endl);
- return true;
- }
- //----------------------------------------------------------------------
- bool cmCTest::UpdateCTestConfiguration()
- {
- if ( this->SuppressUpdatingCTestConfiguration )
- {
- return true;
- }
- std::string fileName = this->CTestConfigFile;
- if ( fileName.empty() )
- {
- fileName = this->BinaryDir + "/CTestConfiguration.ini";
- if ( !cmSystemTools::FileExists(fileName.c_str()) )
- {
- fileName = this->BinaryDir + "/DartConfiguration.tcl";
- }
- }
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "UpdateCTestConfiguration from :"
- << fileName.c_str() << "\n");
- if ( !cmSystemTools::FileExists(fileName.c_str()) )
- {
- // No need to exit if we are not producing XML
- if ( this->ProduceXML )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Cannot find file: " << fileName.c_str()
- << std::endl);
- return false;
- }
- }
- else
- {
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Parse Config file:"
- << fileName.c_str() << "\n");
- // parse the dart test file
- std::ifstream fin(fileName.c_str());
- if(!fin)
- {
- return false;
- }
- char buffer[1024];
- while ( fin )
- {
- buffer[0] = 0;
- fin.getline(buffer, 1023);
- buffer[1023] = 0;
- std::string line = cmCTest::CleanString(buffer);
- if(line.size() == 0)
- {
- continue;
- }
- while ( fin && (line[line.size()-1] == '\\') )
- {
- line = line.substr(0, line.size()-1);
- buffer[0] = 0;
- fin.getline(buffer, 1023);
- buffer[1023] = 0;
- line += cmCTest::CleanString(buffer);
- }
- if ( line[0] == '#' )
- {
- continue;
- }
- std::string::size_type cpos = line.find_first_of(":");
- if ( cpos == line.npos )
- {
- continue;
- }
- std::string key = line.substr(0, cpos);
- std::string value
- = cmCTest::CleanString(line.substr(cpos+1, line.npos));
- this->CTestConfiguration[key] = value;
- }
- fin.close();
- }
- if ( !this->GetCTestConfiguration("BuildDirectory").empty() )
- {
- this->BinaryDir = this->GetCTestConfiguration("BuildDirectory");
- cmSystemTools::ChangeDirectory(this->BinaryDir.c_str());
- }
- this->TimeOut = atoi(this->GetCTestConfiguration("TimeOut").c_str());
- if ( this->ProduceXML )
- {
- this->CompressXMLFiles = cmSystemTools::IsOn(
- this->GetCTestConfiguration("CompressSubmission").c_str());
- }
- return true;
- }
- //----------------------------------------------------------------------
- void cmCTest::BlockTestErrorDiagnostics()
- {
- cmSystemTools::PutEnv("DART_TEST_FROM_DART=1");
- cmSystemTools::PutEnv("DASHBOARD_TEST_FROM_CTEST=" CMake_VERSION);
- #if defined(_WIN32)
- SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
- #elif defined(__BEOS__) || defined(__HAIKU__)
- disable_debugger(1);
- #endif
- }
- //----------------------------------------------------------------------
- void cmCTest::SetTestModel(int mode)
- {
- this->InteractiveDebugMode = false;
- this->TestModel = mode;
- }
- //----------------------------------------------------------------------
- bool cmCTest::SetTest(const char* ttype, bool report)
- {
- if ( cmSystemTools::LowerCase(ttype) == "all" )
- {
- for(Part p = PartStart; p != PartCount; p = Part(p+1))
- {
- this->Parts[p].Enable();
- }
- return true;
- }
- Part p = this->GetPartFromName(ttype);
- if(p != PartCount)
- {
- this->Parts[p].Enable();
- return true;
- }
- else
- {
- if ( report )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Don't know about test \"" << ttype
- << "\" yet..." << std::endl);
- }
- return false;
- }
- }
- //----------------------------------------------------------------------
- void cmCTest::Finalize()
- {
- }
- //----------------------------------------------------------------------
- bool cmCTest::OpenOutputFile(const std::string& path,
- const std::string& name, cmGeneratedFileStream& stream,
- bool compress)
- {
- std::string testingDir = this->BinaryDir + "/Testing";
- if ( path.size() > 0 )
- {
- testingDir += "/" + path;
- }
- if ( cmSystemTools::FileExists(testingDir.c_str()) )
- {
- if ( !cmSystemTools::FileIsDirectory(testingDir.c_str()) )
- {
- cmCTestLog(this, ERROR_MESSAGE, "File " << testingDir
- << " is in the place of the testing directory"
- << std::endl);
- return false;
- }
- }
- else
- {
- if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory " << testingDir
- << std::endl);
- return false;
- }
- }
- std::string filename = testingDir + "/" + name;
- stream.Open(filename.c_str());
- if( !stream )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Problem opening file: " << filename
- << std::endl);
- return false;
- }
- if ( compress )
- {
- if ( this->CompressXMLFiles )
- {
- stream.SetCompression(true);
- }
- }
- return true;
- }
- //----------------------------------------------------------------------
- bool cmCTest::AddIfExists(Part part, const char* file)
- {
- if ( this->CTestFileExists(file) )
- {
- this->AddSubmitFile(part, file);
- }
- else
- {
- std::string name = file;
- name += ".gz";
- if ( this->CTestFileExists(name.c_str()) )
- {
- this->AddSubmitFile(part, file);
- }
- else
- {
- return false;
- }
- }
- return true;
- }
- //----------------------------------------------------------------------
- bool cmCTest::CTestFileExists(const std::string& filename)
- {
- std::string testingDir = this->BinaryDir + "/Testing/" +
- this->CurrentTag + "/" + filename;
- return cmSystemTools::FileExists(testingDir.c_str());
- }
- //----------------------------------------------------------------------
- cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
- {
- cmCTest::t_TestingHandlers::iterator it =
- this->TestingHandlers.find(handler);
- if ( it == this->TestingHandlers.end() )
- {
- return 0;
- }
- it->second->Initialize();
- return it->second;
- }
- //----------------------------------------------------------------------
- cmCTestGenericHandler* cmCTest::GetHandler(const char* handler)
- {
- cmCTest::t_TestingHandlers::iterator it =
- this->TestingHandlers.find(handler);
- if ( it == this->TestingHandlers.end() )
- {
- return 0;
- }
- return it->second;
- }
- //----------------------------------------------------------------------
- int cmCTest::ExecuteHandler(const char* shandler)
- {
- cmCTestGenericHandler* handler = this->GetHandler(shandler);
- if ( !handler )
- {
- return -1;
- }
- handler->Initialize();
- return handler->ProcessHandler();
- }
- //----------------------------------------------------------------------
- int cmCTest::ProcessTests()
- {
- int res = 0;
- bool notest = true;
- int update_count = 0;
- for(Part p = PartStart; notest && p != PartCount; p = Part(p+1))
- {
- notest = !this->Parts[p];
- }
- if (this->Parts[PartUpdate] &&
- (this->GetRemainingTimeAllowed() - 120 > 0))
- {
- cmCTestGenericHandler* uphandler = this->GetHandler("update");
- uphandler->SetPersistentOption("SourceDirectory",
- this->GetCTestConfiguration("SourceDirectory").c_str());
- update_count = uphandler->ProcessHandler();
- if ( update_count < 0 )
- {
- res |= cmCTest::UPDATE_ERRORS;
- }
- }
- if ( this->TestModel == cmCTest::CONTINUOUS && !update_count )
- {
- return 0;
- }
- if (this->Parts[PartConfigure] &&
- (this->GetRemainingTimeAllowed() - 120 > 0))
- {
- if (this->GetHandler("configure")->ProcessHandler() < 0)
- {
- res |= cmCTest::CONFIGURE_ERRORS;
- }
- }
- if (this->Parts[PartBuild] &&
- (this->GetRemainingTimeAllowed() - 120 > 0))
- {
- this->UpdateCTestConfiguration();
- if (this->GetHandler("build")->ProcessHandler() < 0)
- {
- res |= cmCTest::BUILD_ERRORS;
- }
- }
- if ((this->Parts[PartTest] || notest) &&
- (this->GetRemainingTimeAllowed() - 120 > 0))
- {
- this->UpdateCTestConfiguration();
- if (this->GetHandler("test")->ProcessHandler() < 0)
- {
- res |= cmCTest::TEST_ERRORS;
- }
- }
- if (this->Parts[PartCoverage] &&
- (this->GetRemainingTimeAllowed() - 120 > 0))
- {
- this->UpdateCTestConfiguration();
- if (this->GetHandler("coverage")->ProcessHandler() < 0)
- {
- res |= cmCTest::COVERAGE_ERRORS;
- }
- }
- if (this->Parts[PartMemCheck] &&
- (this->GetRemainingTimeAllowed() - 120 > 0))
- {
- this->UpdateCTestConfiguration();
- if (this->GetHandler("memcheck")->ProcessHandler() < 0)
- {
- res |= cmCTest::MEMORY_ERRORS;
- }
- }
- if ( !notest )
- {
- std::string notes_dir = this->BinaryDir + "/Testing/Notes";
- if ( cmSystemTools::FileIsDirectory(notes_dir.c_str()) )
- {
- cmsys::Directory d;
- d.Load(notes_dir.c_str());
- unsigned long kk;
- for ( kk = 0; kk < d.GetNumberOfFiles(); kk ++ )
- {
- const char* file = d.GetFile(kk);
- std::string fullname = notes_dir + "/" + file;
- if ( cmSystemTools::FileExists(fullname.c_str()) &&
- !cmSystemTools::FileIsDirectory(fullname.c_str()) )
- {
- if ( this->NotesFiles.size() > 0 )
- {
- this->NotesFiles += ";";
- }
- this->NotesFiles += fullname;
- this->Parts[PartNotes].Enable();
- }
- }
- }
- }
- if (this->Parts[PartNotes])
- {
- this->UpdateCTestConfiguration();
- if ( this->NotesFiles.size() )
- {
- this->GenerateNotesFile(this->NotesFiles.c_str());
- }
- }
- if (this->Parts[PartSubmit])
- {
- this->UpdateCTestConfiguration();
- if (this->GetHandler("submit")->ProcessHandler() < 0)
- {
- res |= cmCTest::SUBMIT_ERRORS;
- }
- }
- if ( res != 0 )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Errors while running CTest"
- << std::endl);
- }
- return res;
- }
- //----------------------------------------------------------------------
- std::string cmCTest::GetTestModelString()
- {
- if ( !this->SpecificTrack.empty() )
- {
- return this->SpecificTrack;
- }
- switch ( this->TestModel )
- {
- case cmCTest::NIGHTLY:
- return "Nightly";
- case cmCTest::CONTINUOUS:
- return "Continuous";
- }
- return "Experimental";
- }
- //----------------------------------------------------------------------
- int cmCTest::GetTestModelFromString(const char* str)
- {
- if ( !str )
- {
- return cmCTest::EXPERIMENTAL;
- }
- std::string rstr = cmSystemTools::LowerCase(str);
- if ( strncmp(rstr.c_str(), "cont", 4) == 0 )
- {
- return cmCTest::CONTINUOUS;
- }
- if ( strncmp(rstr.c_str(), "nigh", 4) == 0 )
- {
- return cmCTest::NIGHTLY;
- }
- return cmCTest::EXPERIMENTAL;
- }
- //######################################################################
- //######################################################################
- //######################################################################
- //######################################################################
- //----------------------------------------------------------------------
- int cmCTest::RunMakeCommand(const char* command, std::string* output,
- int* retVal, const char* dir, int timeout, std::ofstream& ofs)
- {
- // First generate the command and arguments
- std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
- if(args.size() < 1)
- {
- return false;
- }
- std::vector<const char*> argv;
- for(std::vector<cmStdString>::const_iterator a = args.begin();
- a != args.end(); ++a)
- {
- argv.push_back(a->c_str());
- }
- argv.push_back(0);
- if ( output )
- {
- *output = "";
- }
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Run command:");
- std::vector<const char*>::iterator ait;
- for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait )
- {
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, " \"" << *ait << "\"");
- }
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, std::endl);
- // Now create process object
- cmsysProcess* cp = cmsysProcess_New();
- cmsysProcess_SetCommand(cp, &*argv.begin());
- cmsysProcess_SetWorkingDirectory(cp, dir);
- cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
- cmsysProcess_SetTimeout(cp, timeout);
- cmsysProcess_Execute(cp);
- // Initialize tick's
- std::string::size_type tick = 0;
- std::string::size_type tick_len = 1024;
- std::string::size_type tick_line_len = 50;
- char* data;
- int length;
- cmCTestLog(this, HANDLER_OUTPUT,
- " Each . represents " << tick_len << " bytes of output" << std::endl
- << " " << std::flush);
- while(cmsysProcess_WaitForData(cp, &data, &length, 0))
- {
- if ( output )
- {
- for(int cc =0; cc < length; ++cc)
- {
- if(data[cc] == 0)
- {
- data[cc] = '\n';
- }
- }
- output->append(data, length);
- while ( output->size() > (tick * tick_len) )
- {
- tick ++;
- cmCTestLog(this, HANDLER_OUTPUT, "." << std::flush);
- if ( tick % tick_line_len == 0 && tick > 0 )
- {
- cmCTestLog(this, HANDLER_OUTPUT, " Size: "
- << int((double(output->size()) / 1024.0) + 1) << "K" << std::endl
- << " " << std::flush);
- }
- }
- }
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
- if ( ofs )
- {
- ofs << cmCTestLogWrite(data, length);
- }
- }
- cmCTestLog(this, OUTPUT, " Size of output: "
- << int(double(output->size()) / 1024.0) << "K" << std::endl);
- cmsysProcess_WaitForExit(cp, 0);
- int result = cmsysProcess_GetState(cp);
- if(result == cmsysProcess_State_Exited)
- {
- *retVal = cmsysProcess_GetExitValue(cp);
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Command exited with the value: "
- << *retVal << std::endl);
- }
- else if(result == cmsysProcess_State_Exception)
- {
- *retVal = cmsysProcess_GetExitException(cp);
- cmCTestLog(this, WARNING, "There was an exception: " << *retVal
- << std::endl);
- }
- else if(result == cmsysProcess_State_Expired)
- {
- cmCTestLog(this, WARNING, "There was a timeout" << std::endl);
- }
- else if(result == cmsysProcess_State_Error)
- {
- *output += "\n*** ERROR executing: ";
- *output += cmsysProcess_GetErrorString(cp);
- *output += "\n***The build process failed.";
- cmCTestLog(this, ERROR_MESSAGE, "There was an error: "
- << cmsysProcess_GetErrorString(cp) << std::endl);
- }
- cmsysProcess_Delete(cp);
- return result;
- }
- //######################################################################
- //######################################################################
- //######################################################################
- //######################################################################
- //----------------------------------------------------------------------
- int cmCTest::RunTest(std::vector<const char*> argv,
- std::string* output, int *retVal,
- std::ostream* log, double testTimeOut,
- std::vector<std::string>* environment)
- {
- bool modifyEnv = (environment && environment->size()>0);
- // determine how much time we have
- double timeout = this->GetRemainingTimeAllowed() - 120;
- if (this->TimeOut > 0 && this->TimeOut < timeout)
- {
- timeout = this->TimeOut;
- }
- if (testTimeOut > 0
- && testTimeOut < this->GetRemainingTimeAllowed())
- {
- timeout = testTimeOut;
- }
- // always have at least 1 second if we got to here
- if (timeout <= 0)
- {
- timeout = 1;
- }
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
- "Test timeout computed to be: " << timeout << "\n");
- if(cmSystemTools::SameFile(argv[0], this->CTestSelf.c_str()) &&
- !this->ForceNewCTestProcess)
- {
- cmCTest inst;
- inst.ConfigType = this->ConfigType;
- inst.TimeOut = timeout;
- // Capture output of the child ctest.
- cmOStringStream oss;
- inst.SetStreams(&oss, &oss);
- std::vector<std::string> args;
- for(unsigned int i =0; i < argv.size(); ++i)
- {
- if(argv[i])
- {
- // make sure we pass the timeout in for any build and test
- // invocations. Since --build-generator is required this is a
- // good place to check for it, and to add the arguments in
- if (strcmp(argv[i],"--build-generator") == 0 && timeout > 0)
- {
- args.push_back("--test-timeout");
- cmOStringStream msg;
- msg << timeout;
- args.push_back(msg.str());
- }
- args.push_back(argv[i]);
- }
- }
- if ( log )
- {
- *log << "* Run internal CTest" << std::endl;
- }
- std::string oldpath = cmSystemTools::GetCurrentWorkingDirectory();
- cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
- if (modifyEnv)
- {
- saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment);
- cmSystemTools::AppendEnv(*environment);
- }
- *retVal = inst.Run(args, output);
- *output += oss.str();
- if ( log )
- {
- *log << output->c_str();
- }
- cmSystemTools::ChangeDirectory(oldpath.c_str());
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
- "Internal cmCTest object used to run test." << std::endl
- << *output << std::endl);
- return cmsysProcess_State_Exited;
- }
- std::vector<char> tempOutput;
- if ( output )
- {
- *output = "";
- }
- cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
- if (modifyEnv)
- {
- saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment);
- cmSystemTools::AppendEnv(*environment);
- }
- cmsysProcess* cp = cmsysProcess_New();
- cmsysProcess_SetCommand(cp, &*argv.begin());
- cmCTestLog(this, DEBUG, "Command is: " << argv[0] << std::endl);
- if(cmSystemTools::GetRunCommandHideConsole())
- {
- cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
- }
- cmsysProcess_SetTimeout(cp, timeout);
- cmsysProcess_Execute(cp);
- char* data;
- int length;
- while(cmsysProcess_WaitForData(cp, &data, &length, 0))
- {
- if ( output )
- {
- tempOutput.insert(tempOutput.end(), data, data+length);
- }
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
- if ( log )
- {
- log->write(data, length);
- }
- }
- cmsysProcess_WaitForExit(cp, 0);
- if(output && tempOutput.begin() != tempOutput.end())
- {
- output->append(&*tempOutput.begin(), tempOutput.size());
- }
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "-- Process completed"
- << std::endl);
- int result = cmsysProcess_GetState(cp);
- if(result == cmsysProcess_State_Exited)
- {
- *retVal = cmsysProcess_GetExitValue(cp);
- if(*retVal != 0 && this->OutputTestOutputOnTestFailure)
- {
- OutputTestErrors(tempOutput);
- }
- }
- else if(result == cmsysProcess_State_Exception)
- {
- if(this->OutputTestOutputOnTestFailure)
- {
- OutputTestErrors(tempOutput);
- }
- *retVal = cmsysProcess_GetExitException(cp);
- std::string outerr = "\n*** Exception executing: ";
- outerr += cmsysProcess_GetExceptionString(cp);
- *output += outerr;
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl
- << std::flush);
- }
- else if(result == cmsysProcess_State_Error)
- {
- std::string outerr = "\n*** ERROR executing: ";
- outerr += cmsysProcess_GetErrorString(cp);
- *output += outerr;
- cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl
- << std::flush);
- }
- cmsysProcess_Delete(cp);
- return result;
- }
- //----------------------------------------------------------------------
- std::string cmCTest::SafeBuildIdField(const std::string& value)
- {
- std::string safevalue(value);
- if (safevalue != "")
- {
- // Disallow non-filename and non-space whitespace characters.
- // If they occur, replace them with ""
- //
- const char *disallowed = "\\/:*?\"<>|\n\r\t\f\v";
- if (safevalue.find_first_of(disallowed) != value.npos)
- {
- std::string::size_type i = 0;
- std::string::size_type n = strlen(disallowed);
- char replace[2];
- replace[1] = 0;
- for (i= 0; i<n; ++i)
- {
- replace[0] = disallowed[i];
- cmSystemTools::ReplaceString(safevalue, replace, "");
- }
- }
- safevalue = cmXMLSafe(safevalue).str();
- }
- if (safevalue == "")
- {
- safevalue = "(empty)";
- }
- return safevalue;
- }
- //----------------------------------------------------------------------
- void cmCTest::StartXML(std::ostream& ostr, bool append)
- {
- if(this->CurrentTag.empty())
- {
- cmCTestLog(this, ERROR_MESSAGE,
- "Current Tag empty, this may mean"
- " NightlStartTime was not set correctly." << std::endl);
- cmSystemTools::SetFatalErrorOccured();
- }
- // find out about the system
- cmsys::SystemInformation info;
- info.RunCPUCheck();
- info.RunOSCheck();
- info.RunMemoryCheck();
- std::string buildname = cmCTest::SafeBuildIdField(
- this->GetCTestConfiguration("BuildName"));
- std::string stamp = cmCTest::SafeBuildIdField(
- this->CurrentTag + "-" + this->GetTestModelString());
- std::string site = cmCTest::SafeBuildIdField(
- this->GetCTestConfiguration("Site"));
- ostr << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- << "<Site BuildName=\"" << buildname << "\"\n"
- << "\tBuildStamp=\"" << stamp << "\"\n"
- << "\tName=\"" << site << "\"\n"
- << "\tGenerator=\"ctest-" << cmVersion::GetCMakeVersion() << "\"\n"
- << (append? "\tAppend=\"true\"\n":"")
- << "\tCompilerName=\"" << this->GetCTestConfiguration("Compiler")
- << "\"\n"
- #ifdef _COMPILER_VERSION
- << "\tCompilerVersion=\"_COMPILER_VERSION\"\n"
- #endif
- << "\tOSName=\"" << info.GetOSName() << "\"\n"
- << "\tHostname=\"" << info.GetHostname() << "\"\n"
- << "\tOSRelease=\"" << info.GetOSRelease() << "\"\n"
- << "\tOSVersion=\"" << info.GetOSVersion() << "\"\n"
- << "\tOSPlatform=\"" << info.GetOSPlatform() << "\"\n"
- << "\tIs64Bits=\"" << info.Is64Bits() << "\"\n"
- << "\tVendorString=\"" << info.GetVendorString() << "\"\n"
- << "\tVendorID=\"" << info.GetVendorID() << "\"\n"
- << "\tFamilyID=\"" << info.GetFamilyID() << "\"\n"
- << "\tModelID=\"" << info.GetModelID() << "\"\n"
- << "\tProcessorCacheSize=\"" << info.GetProcessorCacheSize() << "\"\n"
- << "\tNumberOfLogicalCPU=\"" << info.GetNumberOfLogicalCPU() << "\"\n"
- << "\tNumberOfPhysicalCPU=\""<< info.GetNumberOfPhysicalCPU() << "\"\n"
- << "\tTotalVirtualMemory=\"" << info.GetTotalVirtualMemory() << "\"\n"
- << "\tTotalPhysicalMemory=\""<< info.GetTotalPhysicalMemory() << "\"\n"
- << "\tLogicalProcessorsPerPhysical=\""
- << info.GetLogicalProcessorsPerPhysical() << "\"\n"
- << "\tProcessorClockFrequency=\""
- << info.GetProcessorClockFrequency() << "\"\n"
- << ">" << std::endl;
- this->AddSiteProperties(ostr);
- }
- //----------------------------------------------------------------------
- void cmCTest::AddSiteProperties(std::ostream& ostr)
- {
- cmCTestScriptHandler* ch =
- static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
- cmake* cm = ch->GetCMake();
- // if no CMake then this is the old style script and props like
- // this will not work anyway.
- if(!cm)
- {
- return;
- }
- // This code should go when cdash is changed to use labels only
- const char* subproject = cm->GetProperty("SubProject", cmProperty::GLOBAL);
- if(subproject)
- {
- ostr << "<Subproject name=\"" << subproject << "\">\n";
- const char* labels =
- ch->GetCMake()->GetProperty("SubProjectLabels", cmProperty::GLOBAL);
- if(labels)
- {
- ostr << " <Labels>\n";
- std::string l = labels;
- std::vector<std::string> args;
- cmSystemTools::ExpandListArgument(l, args);
- for(std::vector<std::string>::iterator i = args.begin();
- i != args.end(); ++i)
- {
- ostr << " <Label>" << i->c_str() << "</Label>\n";
- }
- ostr << " </Labels>\n";
- }
- ostr << "</Subproject>\n";
- }
-
- // This code should stay when cdash only does label based sub-projects
- const char* label = cm->GetProperty("Label", cmProperty::GLOBAL);
- if(label)
- {
- ostr << "<Labels>\n";
- ostr << " <Label>" << label << "</Label>\n";
- ostr << "</Labels>\n";
- }
- }
- //----------------------------------------------------------------------
- void cmCTest::EndXML(std::ostream& ostr)
- {
- ostr << "</Site>" << std::endl;
- }
- //----------------------------------------------------------------------
- int cmCTest::GenerateCTestNotesOutput(std::ostream& os,
- const cmCTest::VectorOfStrings& files)
- {
- cmCTest::VectorOfStrings::const_iterator it;
- os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
- << "<?xml-stylesheet type=\"text/xsl\" "
- "href=\"Dart/Source/Server/XSL/Build.xsl "
- "<file:///Dart/Source/Server/XSL/Build.xsl> \"?>\n"
- << "<Site BuildName=\"" << this->GetCTestConfiguration("BuildName")
- << "\" BuildStamp=\""
- << this->CurrentTag << "-" << this->GetTestModelString() << "\" Name=\""
- << this->GetCTestConfiguration("Site") << "\" Generator=\"ctest"
- << cmVersion::GetCMakeVersion()
- << "\">\n";
- this->AddSiteProperties(os);
- os << "<Notes>" << std::endl;
- for ( it = files.begin(); it != files.end(); it ++ )
- {
- cmCTestLog(this, OUTPUT, "\tAdd file: " << it->c_str() << std::endl);
- std::string note_time = this->CurrentTime();
- os << "<Note Name=\"" << cmXMLSafe(*it) << "\">\n"
- << "<Time>" << cmSystemTools::GetTime() << "</Time>\n"
- << "<DateTime>" << note_time << "</DateTime>\n"
- << "<Text>" << std::endl;
- std::ifstream ifs(it->c_str());
- if ( ifs )
- {
- std::string line;
- while ( cmSystemTools::GetLineFromStream(ifs, line) )
- {
- os << cmXMLSafe(line) << std::endl;
- }
- ifs.close();
- }
- else
- {
- os << "Problem reading file: " << it->c_str() << std::endl;
- cmCTestLog(this, ERROR_MESSAGE, "Problem reading file: " << it->c_str()
- << " while creating notes" << std::endl);
- }
- os << "</Text>\n"
- << "</Note>" << std::endl;
- }
- os << "</Notes>\n"
- << "</Site>" << std::endl;
- return 1;
- }
- //----------------------------------------------------------------------
- int cmCTest::GenerateNotesFile(const std::vector<cmStdString> &files)
- {
- cmGeneratedFileStream ofs;
- if ( !this->OpenOutputFile(this->CurrentTag, "Notes.xml", ofs) )
- {
- cmCTestLog(this, ERROR_MESSAGE, "Cannot open notes file" << std::endl);
- return 1;
- }
- this->GenerateCTestNotesOutput(ofs, files);
- return 0;
- }
- //----------------------------------------------------------------------
- int cmCTest::GenerateNotesFile(const char* cfiles)
- {
- if ( !cfiles )
- {
- return 1;
- }
- std::vector<cmStdString> files;
- cmCTestLog(this, OUTPUT, "Create notes file" << std::endl);
- files = cmSystemTools::SplitString(cfiles, ';');
- if ( files.size() == 0 )
- {
- return 1;
- }
- return this->GenerateNotesFile(files);
- }
- //-------------------------------------------…
Large files files are truncated, but you can click here to view the full file