CMake/Source/ctest.cxx

338 lines
8.8 KiB
C++
Raw Normal View History

2002-01-21 23:30:43 +03:00
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Insight Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
2001-08-23 19:12:19 +04:00
#include <stdio.h>
#include "ctest.h"
2001-08-30 00:42:03 +04:00
#include "cmRegularExpression.h"
2002-05-22 17:47:41 +04:00
#include "cmSystemTools.h"
2001-08-23 19:12:19 +04:00
bool TryExecutable(const char *dir, const char *file,
std::string *fullPath, const char *subdir)
{
// try current directory
std::string tryPath;
if (dir && strcmp(dir,""))
{
tryPath = dir;
tryPath += "/";
}
if (subdir && strcmp(subdir,""))
{
tryPath += subdir;
tryPath += "/";
}
tryPath += file;
if(cmSystemTools::FileExists(tryPath.c_str()))
{
*fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
return true;
}
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str()))
{
*fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
return true;
}
return false;
}
std::string ctest::FindExecutable(const char *exe)
{
std::string fullPath = "";
std::string dir;
std::string file;
cmSystemTools::SplitProgramPath(exe, dir, file);
if(m_ConfigType != "")
{
if(TryExecutable(dir.c_str(), file.c_str(), &fullPath, m_ConfigType.c_str()))
{
return fullPath;
}
std::string tried = dir;
dir += "/";
dir += m_ConfigType;
dir += "/";
dir += file;
cmSystemTools::Error("config type specified on the command line, but test executable not found.",
dir.c_str());
return "";
}
2001-08-23 19:12:19 +04:00
if (TryExecutable(dir.c_str(),file.c_str(),&fullPath,"."))
{
return fullPath;
}
if (TryExecutable(dir.c_str(),file.c_str(),&fullPath,""))
{
return fullPath;
}
if (TryExecutable(dir.c_str(),file.c_str(),&fullPath,"Release"))
{
return fullPath;
}
if (TryExecutable(dir.c_str(),file.c_str(),&fullPath,"Debug"))
{
return fullPath;
}
if (TryExecutable(dir.c_str(),file.c_str(),&fullPath,"MinSizeRel"))
{
return fullPath;
}
if (TryExecutable(dir.c_str(),file.c_str(),&fullPath,"RelWithDebInfo"))
{
return fullPath;
}
2001-08-23 21:12:13 +04:00
// if everything else failed, check the users path
if (dir != "")
{
std::string path = cmSystemTools::FindProgram(file.c_str());
if (path != "")
{
return path;
}
}
2001-08-23 19:12:19 +04:00
return fullPath;
}
void ctest::ProcessDirectory(std::vector<std::string> &passed,
std::vector<std::string> &failed)
2001-08-23 19:12:19 +04:00
{
// does the DartTestfile.txt exist ?
if(!cmSystemTools::FileExists("DartTestfile.txt"))
{
return;
}
// parse the file
std::ifstream fin("DartTestfile.txt");
if(!fin)
{
return;
}
2002-03-15 18:43:24 +03:00
int firstTest = 1;
2001-08-23 19:12:19 +04:00
std::string name;
std::vector<std::string> args;
cmRegularExpression ireg(this->m_IncludeRegExp.c_str());
cmRegularExpression ereg(this->m_ExcludeRegExp.c_str());
2001-09-11 23:17:40 +04:00
cmRegularExpression dartStuff("([\t\n ]*<DartMeasurement.*/DartMeasurement[a-zA-Z]*>[\t ]*[\n]*)");
2001-08-30 00:42:03 +04:00
2001-11-30 00:44:22 +03:00
bool parseError;
2001-08-23 19:12:19 +04:00
while ( fin )
{
2001-11-30 00:44:22 +03:00
if(cmSystemTools::ParseFunction(fin, name, args, "DartTestfile.txt",
parseError))
2001-08-23 19:12:19 +04:00
{
if (name == "SUBDIRS")
{
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
for(std::vector<std::string>::iterator j = args.begin();
j != args.end(); ++j)
{
std::string nwd = cwd + "/";
nwd += *j;
if (cmSystemTools::FileIsDirectory(nwd.c_str()))
{
cmSystemTools::ChangeDirectory(nwd.c_str());
this->ProcessDirectory(passed, failed);
2001-08-23 19:12:19 +04:00
}
}
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
}
2001-08-30 00:42:03 +04:00
2001-08-23 19:12:19 +04:00
if (name == "ADD_TEST")
{
if (this->m_UseExcludeRegExp &&
this->m_UseExcludeRegExpFirst &&
ereg.find(args[0].c_str()))
{
continue;
}
if (this->m_UseIncludeRegExp && !ireg.find(args[0].c_str()))
{
continue;
}
if (this->m_UseExcludeRegExp &&
!this->m_UseExcludeRegExpFirst &&
ereg.find(args[0].c_str()))
2001-08-30 00:42:03 +04:00
{
continue;
}
2002-03-15 18:43:24 +03:00
if (firstTest)
{
std::string nwd = cmSystemTools::GetCurrentWorkingDirectory();
std::cerr << "Changing directory into " << nwd.c_str() << "\n";
firstTest = 0;
}
2001-08-27 18:23:45 +04:00
fprintf(stderr,"Testing %-30s ",args[0].c_str());
2001-12-11 18:39:19 +03:00
fflush(stderr);
2001-08-27 18:23:45 +04:00
//std::cerr << "Testing " << args[0] << " ... ";
2001-08-23 19:12:19 +04:00
// find the test executable
2001-09-21 00:43:51 +04:00
std::string testCommand =
cmSystemTools::EscapeSpaces(this->FindExecutable(args[1].c_str()).c_str());
2001-12-03 23:55:28 +03:00
// continue if we did not find the executable
if (testCommand == "")
{
std::cerr << "Unable to find executable: " <<
args[1].c_str() << "\n";
continue;
}
testCommand = cmSystemTools::ConvertToOutputPath(testCommand.c_str());
2001-08-23 19:12:19 +04:00
// add the arguments
std::vector<std::string>::iterator j = args.begin();
++j;
++j;
for(;j != args.end(); ++j)
{
testCommand += " ";
2001-09-21 00:43:51 +04:00
testCommand += cmSystemTools::EscapeSpaces(j->c_str());
2001-08-23 19:12:19 +04:00
}
/**
* Run an executable command and put the stdout in output.
*/
std::string output;
int retVal;
if (!cmSystemTools::RunCommand(testCommand.c_str(), output,
retVal, 0, false) || retVal != 0)
2001-08-23 19:12:19 +04:00
{
2001-08-30 00:42:03 +04:00
fprintf(stderr,"***Failed\n");
2001-08-23 19:12:19 +04:00
if (output != "")
{
2001-09-11 23:17:40 +04:00
if (dartStuff.find(output.c_str()))
{
cmSystemTools::ReplaceString(output,
dartStuff.match(1).c_str(),"");
}
if (output != "")
{
std::cerr << output.c_str() << "\n";
}
2001-08-23 19:12:19 +04:00
}
failed.push_back(args[0]);
2001-08-23 19:12:19 +04:00
}
else
{
2001-08-30 00:42:03 +04:00
fprintf(stderr," Passed\n");
2001-08-23 19:12:19 +04:00
if (output != "")
{
2001-09-11 23:17:40 +04:00
if (dartStuff.find(output.c_str()))
{
cmSystemTools::ReplaceString(output,
dartStuff.match(1).c_str(),"");
}
if (output != "")
{
std::cerr << output.c_str() << "\n";
}
2001-08-23 19:12:19 +04:00
}
passed.push_back(args[0]);
2001-08-23 19:12:19 +04:00
}
}
}
}
}
// this is a test driver program for cmake.
int main (int argc, char *argv[])
{
std::vector<std::string> passed;
std::vector<std::string> failed;
2001-08-23 19:12:19 +04:00
int total;
ctest inst;
2001-08-30 00:42:03 +04:00
// look at the args
std::vector<std::string> args;
for(int i =0; i < argc; ++i)
{
args.push_back(argv[i]);
}
for(unsigned int i=1; i < args.size(); ++i)
{
std::string arg = args[i];
if(arg.find("-D",0) == 0 && i < args.size() - 1)
{
inst.m_ConfigType = args[i+1];
}
2001-08-30 00:42:03 +04:00
if(arg.find("-R",0) == 0 && i < args.size() - 1)
{
inst.m_UseIncludeRegExp = true;
inst.m_IncludeRegExp = args[i+1];
}
if(arg.find("-E",0) == 0 && i < args.size() - 1)
{
inst.m_UseExcludeRegExp = true;
inst.m_ExcludeRegExp = args[i+1];
inst.m_UseExcludeRegExpFirst = inst.m_UseIncludeRegExp ? false : true;
2001-08-30 00:42:03 +04:00
}
}
2001-08-23 19:12:19 +04:00
// call process directory
inst.ProcessDirectory(passed, failed);
total = int(passed.size()) + int(failed.size());
2001-08-23 19:12:19 +04:00
if (total == 0)
{
std::cerr << "No tests were found!!!\n";
}
else
{
if (passed.size() && (inst.m_UseIncludeRegExp || inst.m_UseExcludeRegExp))
{
std::cerr << "\nThe following tests passed:\n";
for(std::vector<std::string>::iterator j = passed.begin();
j != passed.end(); ++j)
{
std::cerr << "\t" << *j << "\n";
}
}
float percent = float(passed.size()) * 100.0f / total;
fprintf(stderr,"\n%.0f%% tests passed, %i tests failed out of %i\n",
2002-06-19 00:32:36 +04:00
percent, int(failed.size()), total);
if (failed.size())
{
std::cerr << "\nThe following tests FAILED:\n";
for(std::vector<std::string>::iterator j = failed.begin();
j != failed.end(); ++j)
{
std::cerr << "\t" << *j << "\n";
}
}
2001-08-23 19:12:19 +04:00
}
2002-03-13 18:25:11 +03:00
return int(failed.size());
2001-08-23 19:12:19 +04:00
}