Skip to content

GitLab

Commit 5a5cc522 authored by Zach's avatar Zach
Browse files

Fixed conversion warning on 64 bit machines

parent bf830eea
Hide whitespace changes
Inline Side-by-side
Source/CTest/cmCTestMultiProcessHandler.h
View file @ 5a5cc522
......@@ -81,9 +81,9 @@ protected:
// map from test number to set of depend tests
TestMap Tests;
//Total number of tests we'll be running
int Total;
size_t Total;
//Number of tests that are complete
int Completed;
size_t Completed;
//list of test properties (indices concurrent to the test map)
PropertiesMap Properties;
std::map<int, bool> TestRunningMap;
......
Source/CTest/cmCTestRunTest.cxx
View file @ 5a5cc522
......@@ -56,7 +56,7 @@ void cmCTestRunTest::CheckOutput()
}
//---------------------------------------------------------
bool cmCTestRunTest::EndTest(int completed, int total)
bool cmCTestRunTest::EndTest(size_t completed, size_t total)
{
//restore the old environment
if (this->ModifyEnv)
......@@ -427,7 +427,7 @@ bool cmCTestRunTest::CreateProcess(double testTimeOut,
return this->TestProcess->StartProcess();
}
void cmCTestRunTest::WriteLogOutputTop(int completed, int total)
void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
{
/* Not sure whether we want to prepend the test index anymore
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3)
......
Source/CTest/cmCTestRunTest.h
View file @ 5a5cc522
......@@ -56,14 +56,14 @@ public:
//launch the test process, return whether it started correctly
bool StartTest();
//capture and report the test results
bool EndTest(int completed, int total);
bool EndTest(size_t completed, size_t total);
//Called by ctest -N to log the command string
void ComputeArguments();
private:
void DartProcessing();
bool CreateProcess(double testTimeOut,
std::vector<std::string>* environment);
void WriteLogOutputTop(int completed, int total);
void WriteLogOutputTop(size_t completed, size_t total);
//Run post processing of the process output for MemCheck
void MemCheckPostProcess();
......
Source/CTest/cmCTestTestHandler.cxx
View file @ 5a5cc522
......@@ -709,321 +709,7 @@ void cmCTestTestHandler::PrintLabelSummary()
}
}
}
/*
//----------------------------------------------------------------------
void cmCTestTestHandler::ProcessOneTest(cmCTestTestProperties *it,
std::vector<cmStdString> &passed,
std::vector<cmStdString> &failed,
int cnt, int tmsize)
{
const std::string& testname = it->Name;
std::vector<std::string>& args = it->Args;
cmCTestTestResult cres;
cres.Properties = &*it;
cres.ExecutionTime = 0;
cres.ReturnValue = -1;
cres.Status = cmCTestTestHandler::NOT_RUN;
cres.TestCount = cnt;
cres.Name = testname;
cres.Path = it->Directory.c_str();
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << cnt << "/");
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << tmsize << " ");
if ( this->MemCheck )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Memory Check");
}
else
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Testing");
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, " ");
const int maxTestNameWidth = this->CTest->GetMaxTestNameWidth();
std::string outname = testname + " ";
outname.resize(maxTestNameWidth, '.');
*this->LogFile << cnt << "/" << tmsize << " Testing: " << testname
<< std::endl;
if ( this->CTest->GetShowOnly() )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str() << std::endl);
}
else
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str());
}
cmCTestLog(this->CTest, DEBUG, "Testing " << args[0].c_str() << " ... ");
// find the test executable
std::string actualCommand = this->FindTheExecutable(args[1].c_str());
std::string testCommand
= cmSystemTools::ConvertToOutputPath(actualCommand.c_str());
// continue if we did not find the executable
if (testCommand == "")
{
*this->LogFile << "Unable to find executable: " << args[1].c_str()
<< std::endl;
cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to find executable: "
<< args[1].c_str() << std::endl);
cres.Output = "Unable to find executable: " + args[1];
if ( !this->CTest->GetShowOnly() )
{
cres.FullCommandLine = actualCommand;
this->TestResults.push_back( cres );
failed.push_back(testname);
return;
}
}
// add the arguments
std::vector<std::string>::const_iterator j = args.begin();
++j; // skip test name
++j; // skip command as it is in actualCommand
std::vector<const char*> arguments;
this->GenerateTestCommand(arguments);
arguments.push_back(actualCommand.c_str());
for(;j != args.end(); ++j)
{
testCommand += " ";
testCommand += cmSystemTools::EscapeSpaces(j->c_str());
arguments.push_back(j->c_str());
}
arguments.push_back(0);
std::string output;
int retVal = 0;
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
<< (this->MemCheck?"MemCheck":"Test")
<< " command: " << testCommand
<< std::endl);
*this->LogFile << cnt << "/" << tmsize
<< " Test: " << testname.c_str() << std::endl;
*this->LogFile << "Command: ";
std::vector<cmStdString>::size_type ll;
for ( ll = 0; ll < arguments.size()-1; ll ++ )
{
*this->LogFile << "\"" << arguments[ll] << "\" ";
}
*this->LogFile
<< std::endl
<< "Directory: " << it->Directory << std::endl
<< "\"" << testname.c_str() << "\" start time: "
<< this->CTest->CurrentTime() << std::endl
<< "Output:" << std::endl
<< "----------------------------------------------------------"
<< std::endl;
int res = 0;
double clock_start, clock_finish;
clock_start = cmSystemTools::GetTime();
if ( !this->CTest->GetShowOnly() )
{
res = this->CTest->RunTest(arguments, &output, &retVal, this->LogFile,
it->Timeout, &it->Environment);
}
clock_finish = cmSystemTools::GetTime();
cres.ExecutionTime = (double)(clock_finish - clock_start);
cres.FullCommandLine = testCommand;
std::string reason;
if ( !this->CTest->GetShowOnly() )
{
std::vector<std::pair<cmsys::RegularExpression,
std::string> >::iterator passIt;
bool forceFail = false;
if ( it->RequiredRegularExpressions.size() > 0 )
{
bool found = false;
for ( passIt = it->RequiredRegularExpressions.begin();
passIt != it->RequiredRegularExpressions.end();
++ passIt )
{
if ( passIt->first.find(output.c_str()) )
{
found = true;
reason = "Required regular expression found.";
}
}
if ( !found )
{
reason = "Required regular expression not found.";
forceFail = true;
}
reason += "Regex=[";
for ( passIt = it->RequiredRegularExpressions.begin();
passIt != it->RequiredRegularExpressions.end();
++ passIt )
{
reason += passIt->second;
reason += "\n";
}
reason += "]";
}
if ( it->ErrorRegularExpressions.size() > 0 )
{
for ( passIt = it->ErrorRegularExpressions.begin();
passIt != it->ErrorRegularExpressions.end();
++ passIt )
{
if ( passIt->first.find(output.c_str()) )
{
reason = "Error regular expression found in output.";
reason += " Regex=[";
reason += passIt->second;
reason += "]";
forceFail = true;
}
}
}
if (res == cmsysProcess_State_Exited)
{
bool success =
!forceFail && (retVal == 0 || it->RequiredRegularExpressions.size());
if((success && !it->WillFail) || (!success && it->WillFail))
{
cres.Status = cmCTestTestHandler::COMPLETED;
cmCTestLog(this->CTest, HANDLER_OUTPUT, " Passed " );
}
else
{
cres.Status = cmCTestTestHandler::FAILED;
cmCTestLog(this->CTest, HANDLER_OUTPUT,
"***Failed " << reason );
}
}
else if ( res == cmsysProcess_State_Expired )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Timeout");
cres.Status = cmCTestTestHandler::TIMEOUT;
}
else if ( res == cmsysProcess_State_Exception )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Exception: ");
switch ( retVal )
{
case cmsysProcess_Exception_Fault:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "SegFault");
cres.Status = cmCTestTestHandler::SEGFAULT;
break;
case cmsysProcess_Exception_Illegal:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Illegal");
cres.Status = cmCTestTestHandler::ILLEGAL;
break;
case cmsysProcess_Exception_Interrupt:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Interrupt");
cres.Status = cmCTestTestHandler::INTERRUPT;
break;
case cmsysProcess_Exception_Numerical:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Numerical");
cres.Status = cmCTestTestHandler::NUMERICAL;
break;
default:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Other");
cres.Status = cmCTestTestHandler::OTHER_FAULT;
}
}
else // if ( res == cmsysProcess_State_Error )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Bad command " << res );
cres.Status = cmCTestTestHandler::BAD_COMMAND;
}
if(cres.Status == cmCTestTestHandler::COMPLETED)
{
passed.push_back(testname);
}
else
{
failed.push_back(testname);
}
char buf[1024];
sprintf(buf, "%6.2f sec", cres.ExecutionTime);
cmCTestLog(this->CTest, HANDLER_OUTPUT, buf << "\n" );
if (!output.empty() && output.find("<DartMeasurement") != output.npos)
{
if (this->DartStuff.find(output.c_str()))
{
std::string dartString = this->DartStuff.match(1);
// keep searching and replacing until none are left
while (this->DartStuff1.find(output.c_str()))
{
// replace the exact match for the string
cmSystemTools::ReplaceString(output,
this->DartStuff1.match(1).c_str(), "");
}
cres.RegressionImages
= this->GenerateRegressionImages(dartString);
}
}
}
// if this is doing MemCheck then all the output needs to be put into
// Output since that it what is parsed to by cmCTestMemCheckHandler
if(!this->MemCheck)
{
if ( cres.Status == cmCTestTestHandler::COMPLETED )
{
this->CleanTestOutput(output, static_cast<size_t>
(this->CustomMaximumPassedTestOutputSize));
}
else
{
this->CleanTestOutput(output, static_cast<size_t>
(this->CustomMaximumFailedTestOutputSize));
}
}
cres.Reason = reason;
if ( this->LogFile )
{
bool pass = true;
const char* reasonType = "Test Pass Reason";
if(cres.Status != cmCTestTestHandler::COMPLETED &&
cres.Status != cmCTestTestHandler::NOT_RUN)
{
reasonType = "Test Fail Reason";
pass = false;
}
double ttime = clock_finish - clock_start;
int hours = static_cast<int>(ttime / (60 * 60));
int minutes = static_cast<int>(ttime / 60) % 60;
int seconds = static_cast<int>(ttime) % 60;
char buffer[100];
sprintf(buffer, "%02d:%02d:%02d", hours, minutes, seconds);
*this->LogFile
<< "----------------------------------------------------------"
<< std::endl;
if(cres.Reason.size())
{
*this->LogFile << reasonType << ":\n" << cres.Reason << "\n";
}
else
{
if(pass)
{
*this->LogFile << "Test Passed.\n";
}
else
{
*this->LogFile << "Test Failed.\n";
}
}
*this->LogFile << "\"" << testname.c_str() << "\" end time: "
<< this->CTest->CurrentTime() << std::endl
<< "\"" << testname.c_str() << "\" time elapsed: "
<< buffer << std::endl
<< "----------------------------------------------------------"
<< std::endl << std::endl;
}
cres.Output = output;
cres.ReturnValue = retVal;
cres.CompletionStatus = "Completed";
this->TestResults.push_back( cres );
}
*/
//----------------------------------------------------------------------
void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it)
{
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment