Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
CMake
CMake
Commits
5a5cc522
Commit
5a5cc522
authored
Aug 31, 2009
by
Zach
Browse files
Fixed conversion warning on 64 bit machines
parent
bf830eea
Changes
4
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
in
t
Total
;
size_
t
Total
;
//Number of tests that are complete
in
t
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
(
in
t
completed
,
in
t
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
(
in
t
completed
,
in
t
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
(
in
t
completed
,
in
t
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
(
in
t
completed
,
in
t
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
)
{
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment