CMake/Source/cmaketest.cxx

288 lines
8.6 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-06-22 01:52:54 +04:00
#include "cmaketest.h"
#include "cmSystemTools.h"
#include "cmRegularExpression.h"
2001-08-29 23:57:57 +04:00
#include "cmake.h"
#include "cmListFileCache.h"
#include "cmCacheManager.h"
2001-11-28 18:51:28 +03:00
#if defined(_WIN32) && !defined(__CYGWIN__)
#include "windows.h"
#endif
2001-06-22 01:52:54 +04:00
2001-06-22 01:52:54 +04:00
// this is a test driver program for cmake.
int main (int argc, char **argv)
2001-06-22 01:52:54 +04:00
{
if (argc < 4)
{
2001-06-22 17:27:11 +04:00
std::cerr << "Usage: " << argv[0] << " test-src-dir test-bin-dir test-executable\n";
2001-06-22 01:52:54 +04:00
return 1;
}
2001-06-22 01:52:54 +04:00
// does the directory exist ?
if (!cmSystemTools::FileIsDirectory(argv[2]))
{
cmSystemTools::MakeDirectory(argv[2]);
}
2001-08-24 00:00:46 +04:00
const char* sourceDirectory = argv[1];
const char* binaryDirectory = argv[2];
const char* executableName = argv[3];
const char* executableDirectory = "";
2001-08-24 00:00:46 +04:00
if(argc > 4)
{
executableDirectory = argv[4];
}
2001-12-19 23:26:21 +03:00
const char* projectName = executableName;
if(argc > 5)
{
projectName = argv[5];
}
// WARNING: the rest of the args is passed to cmake
2001-06-22 01:52:54 +04:00
/**
* Run an executable command and put the stdout in output.
*/
std::string output;
// change to the tests directory and run cmake
2001-08-29 23:57:57 +04:00
// use the cmake object instead of calling cmake
2001-06-22 01:52:54 +04:00
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
2001-12-19 23:26:21 +03:00
std::cout << "Changing into directory: " << binaryDirectory << "\n";
2001-08-24 00:00:46 +04:00
cmSystemTools::ChangeDirectory(binaryDirectory);
2001-08-29 23:57:57 +04:00
std::vector<std::string> args;
std::string intdir = ".";
#ifdef CMAKE_INTDIR
intdir = CMAKE_INTDIR;
#endif
2001-11-15 02:12:22 +03:00
// make sure the same generator is used
2001-08-29 23:57:57 +04:00
// use this program as the cmake to be run, it should not
// be run that way but the cmake object requires a vailid path
std::string cmakeCommand = CMAKE_BINARY_DIR;
cmakeCommand += "/Source";
cmakeCommand += "/";
cmakeCommand += intdir;
cmakeCommand += "/cmake";
cmakeCommand += cmSystemTools::GetExecutableExtension();
std::cout << "*** " << cmakeCommand << "\n";
2001-08-29 23:57:57 +04:00
args.push_back(cmakeCommand.c_str());
args.push_back(sourceDirectory);
2001-11-15 02:12:22 +03:00
std::string generator = "-G";
generator += CMAKE_GENERATOR;
args.push_back(generator);
std::vector<std::string> progArgs;
if(argc > 6)
{
if(strcmp(argv[6] , "CMAKE_ARGS") == 0)
{
for (int j = 7; j < argc ; j++)
{
args.push_back(argv[j]);
}
}
else
{
for(int j = 6; j < argc; j++)
{
progArgs.push_back(argv[j]);
}
}
}
2001-12-19 23:26:21 +03:00
std::cout << "Generating build files...\n";
cmake cm;
2002-09-06 21:06:23 +04:00
if (cm.Run(args) != 0)
2001-06-22 01:52:54 +04:00
{
2001-06-22 17:27:11 +04:00
std::cerr << "Error: cmake execution failed\n";
2001-06-22 01:52:54 +04:00
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
return 1;
}
2001-12-19 23:26:21 +03:00
std::cout << "Done Generating build files.\n";
cmake cm2;
std::cout << "Generating build files (again)...\n";
2002-09-06 21:06:23 +04:00
if (cm2.Run(args) != 0)
{
std::cerr << "Error: cmake execution failed\n";
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
return 1;
}
std::cout << "Done Generating build files (again).\n";
2001-08-29 23:57:57 +04:00
cmListFileCache::GetInstance()->ClearCache();
2001-06-22 01:52:54 +04:00
// now build the test
2001-06-27 17:17:12 +04:00
std::string makeCommand = MAKEPROGRAM;
2001-11-22 01:45:01 +03:00
if(makeCommand.size() == 0)
{
std::cerr << "Error: cmaketest does not have a valid MAKEPROGRAM\n";
}
makeCommand = cmSystemTools::ConvertToOutputPath(makeCommand.c_str());
2001-11-15 02:12:22 +03:00
std::string lowerCaseCommand = makeCommand;
cmSystemTools::LowerCase(lowerCaseCommand);
// if msdev is the make program then do the following
2002-02-20 23:26:51 +03:00
// MSDEV 6.0
2001-11-15 02:12:22 +03:00
if(lowerCaseCommand.find("msdev") != std::string::npos)
{
2001-11-15 02:12:22 +03:00
// if there are spaces in the makeCommand, assume a full path
// and convert it to a path with no spaces in it as the
// RunCommand does not like spaces
2001-11-22 01:45:01 +03:00
#if defined(_WIN32) && !defined(__CYGWIN__)
2001-11-15 02:12:22 +03:00
if(makeCommand.find(' ') != std::string::npos)
{
cmSystemTools::GetShortPath(makeCommand.c_str(), makeCommand);
}
2001-11-22 01:45:01 +03:00
#endif
2001-11-15 02:12:22 +03:00
makeCommand += " ";
2001-12-19 23:26:21 +03:00
makeCommand += projectName;
makeCommand += ".dsw /MAKE \"ALL_BUILD - ";
makeCommand += intdir + "\" /REBUILD";
2001-11-15 02:12:22 +03:00
}
2002-02-20 23:26:51 +03:00
// MSDEV 7.0 .NET
else if (lowerCaseCommand.find("devenv") != std::string::npos)
{
2002-02-21 16:43:19 +03:00
#if defined(_WIN32) && !defined(__CYGWIN__)
2002-02-20 23:26:51 +03:00
if(makeCommand.find(' ') != std::string::npos)
{
cmSystemTools::GetShortPath(makeCommand.c_str(), makeCommand);
2002-02-20 23:26:51 +03:00
}
2002-02-21 16:43:19 +03:00
#endif
2002-02-20 23:26:51 +03:00
makeCommand += " ";
makeCommand += projectName;
makeCommand += ".sln /rebuild ";
makeCommand += intdir + " /project ALL_BUILD";
2002-02-20 23:26:51 +03:00
}
// command line make program
2001-11-15 02:12:22 +03:00
else
{
// assume a make sytle program
// clean first
std::string cleanCommand = makeCommand;
cleanCommand += " clean";
std::cout << "Running make clean command: " << cleanCommand.c_str() << " ...\n";
if (!cmSystemTools::RunCommand(cleanCommand.c_str(), output))
{
std::cerr << "Error: " << cleanCommand.c_str() << " execution failed\n";
std::cerr << output.c_str() << "\n";
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
return 1;
}
// now build
2001-11-15 02:12:22 +03:00
makeCommand += " all";
}
2001-12-19 23:26:21 +03:00
std::cout << "Running make command: " << makeCommand.c_str() << " ...\n";
2001-06-27 17:17:12 +04:00
if (!cmSystemTools::RunCommand(makeCommand.c_str(), output))
2001-06-22 01:52:54 +04:00
{
2001-06-27 17:17:12 +04:00
std::cerr << "Error: " << makeCommand.c_str() << " execution failed\n";
2001-06-22 17:27:11 +04:00
std::cerr << output.c_str() << "\n";
2001-06-22 01:52:54 +04:00
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
return 1;
}
2001-06-27 17:17:12 +04:00
// now run the compiled test if we can find it
// See if the executable exists as written.
std::string fullPath;
2001-08-24 00:00:46 +04:00
if(cmSystemTools::FileExists(executableName))
2001-06-22 01:52:54 +04:00
{
2001-08-24 00:00:46 +04:00
fullPath = cmSystemTools::CollapseFullPath(executableName);
2001-06-27 17:17:12 +04:00
}
2001-08-24 00:00:46 +04:00
std::string tryPath = executableName;
2001-06-27 17:17:12 +04:00
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
2001-08-29 23:57:57 +04:00
// try the Debug extension
tryPath = intdir + "/";
2001-08-24 00:00:46 +04:00
tryPath += cmSystemTools::GetFilenameName(executableName);
2001-06-27 17:17:12 +04:00
if(cmSystemTools::FileExists(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
2001-08-24 00:00:46 +04:00
tryPath = executableDirectory;
tryPath += "/";
tryPath += executableName;
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
tryPath = executableDirectory;
tryPath += "/";
tryPath += intdir + "/";
2001-08-24 00:00:46 +04:00
tryPath += executableName;
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
if(!cmSystemTools::FileExists(fullPath.c_str()))
{
std::cerr << "Could not find path to executable, perhaps it was not built: " <<
executableName << "\n";
std::cerr << "Error: " << fullPath.c_str() << " execution failed\n";
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
return 1;
}
fullPath = cmSystemTools::ConvertToOutputPath(fullPath.c_str());
for(std::vector<std::string>::iterator p = progArgs.begin();
p != progArgs.end(); ++p)
{
fullPath += " ";
fullPath += *p;
}
2001-12-19 23:26:21 +03:00
std::cout << "Running test executable: " << fullPath.c_str() << "\n";
int ret = 0;
if (!cmSystemTools::RunCommand(fullPath.c_str(), output, ret, 0, true))
2001-06-27 17:17:12 +04:00
{
std::cerr << "Error: " << fullPath.c_str() << " execution failed\n";
2001-06-22 01:52:54 +04:00
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
return 1;
}
2002-03-26 20:38:18 +03:00
std::cout << output << "\n";
2001-06-22 01:52:54 +04:00
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
if(ret)
{
cmSystemTools::Error("test executable ", fullPath.c_str(),
"returned a non-zero value");
}
return ret;
2001-06-22 01:52:54 +04:00
}