CMake/Source/CTest/cmCTestCoverageHandler.h

162 lines
5.2 KiB
C
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc.
2004-09-09 16:41:05 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2004-09-09 16:41:05 +04:00
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.
============================================================================*/
2004-09-09 16:41:05 +04:00
#ifndef cmCTestCoverageHandler_h
#define cmCTestCoverageHandler_h
2005-01-27 19:43:22 +03:00
#include "cmCTestGenericHandler.h"
2004-09-09 16:41:05 +04:00
#include "cmListFileCache.h"
#include <cmsys/RegularExpression.hxx>
class cmGeneratedFileStream;
class cmXMLWriter;
2010-05-25 17:23:25 +04:00
class cmCTestCoverageHandlerContainer
{
public:
int Error;
std::string SourceDir;
std::string BinaryDir;
typedef std::vector<int> SingleFileCoverageVector;
typedef std::map<std::string, SingleFileCoverageVector> TotalCoverageMap;
TotalCoverageMap TotalCoverage;
std::ostream* OFS;
2015-02-17 23:57:26 +03:00
bool Quiet;
2010-05-25 17:23:25 +04:00
};
2004-09-09 16:41:05 +04:00
/** \class cmCTestCoverageHandler
2015-02-17 23:57:26 +03:00
* \brief A class that handles coverage computation for ctest
2004-09-09 16:41:05 +04:00
*
*/
2005-01-27 19:43:22 +03:00
class cmCTestCoverageHandler : public cmCTestGenericHandler
2004-09-09 16:41:05 +04:00
{
public:
cmTypeMacro(cmCTestCoverageHandler, cmCTestGenericHandler);
2004-09-09 16:41:05 +04:00
/*
* The main entry point for this class
*/
2005-01-27 23:54:47 +03:00
int ProcessHandler();
2006-03-09 19:17:10 +03:00
2004-09-09 16:41:05 +04:00
cmCTestCoverageHandler();
2006-03-09 19:17:10 +03:00
virtual void Initialize();
/**
* This method is called when reading CTest custom file
*/
void PopulateCustomVectors(cmMakefile *mf);
2006-03-09 19:17:10 +03:00
/** Report coverage only for sources with these labels. */
void SetLabelFilter(std::set<std::string> const& labels);
2004-09-09 16:41:05 +04:00
private:
bool ShouldIDoCoverage(const char* file, const char* srcDir,
const char* binDir);
void CleanCoverageLogFiles(std::ostream& log);
bool StartCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
void EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
2004-09-09 16:41:05 +04:00
void StartCoverageLogXML(cmXMLWriter& xml);
void EndCoverageLogXML(cmXMLWriter& xml);
2007-04-27 17:01:22 +04:00
//! Handle coverage using GCC's GCov
int HandleGCovCoverage(cmCTestCoverageHandlerContainer* cont);
void FindGCovFiles(std::vector<std::string>& files);
2007-04-27 17:01:22 +04:00
//! Handle coverage using Intel's LCov
int HandleLCovCoverage(cmCTestCoverageHandlerContainer* cont);
bool FindLCovFiles(std::vector<std::string>& files);
2010-05-25 17:23:25 +04:00
//! Handle coverage using xdebug php coverage
int HandlePHPCoverage(cmCTestCoverageHandlerContainer* cont);
//! Handle coverage for Python with coverage.py
int HandleCoberturaCoverage(cmCTestCoverageHandlerContainer* cont);
//! Handle coverage for mumps
int HandleMumpsCoverage(cmCTestCoverageHandlerContainer* cont);
2010-05-25 17:23:25 +04:00
//! Handle coverage for Jacoco
int HandleJacocoCoverage(cmCTestCoverageHandlerContainer* cont);
//! Handle coverage for Delphi (Pascal)
int HandleDelphiCoverage(cmCTestCoverageHandlerContainer* cont);
//! Handle coverage for Jacoco
int HandleBlanketJSCoverage(cmCTestCoverageHandlerContainer* cont);
//! Handle coverage using Bullseye
2007-06-01 23:40:07 +04:00
int HandleBullseyeCoverage(cmCTestCoverageHandlerContainer* cont);
int RunBullseyeSourceSummary(cmCTestCoverageHandlerContainer* cont);
int RunBullseyeCoverageBranch(cmCTestCoverageHandlerContainer* cont,
std::set<std::string>& coveredFileNames,
2007-06-01 23:40:07 +04:00
std::vector<std::string>& files,
std::vector<std::string>& filesFullPath);
2010-04-23 17:16:18 +04:00
2007-06-01 23:40:07 +04:00
int RunBullseyeCommand(
cmCTestCoverageHandlerContainer* cont,
const char* cmd,
const char* arg,
std::string& outputFile);
bool ParseBullsEyeCovsrcLine(
std::string const& inputLine,
std::string& sourceFile,
int& functionsCalled,
int& totalFunctions,
int& percentFunction,
int& branchCovered,
int& totalBranches,
int& percentBranch);
bool GetNextInt(std::string const& inputLine,
std::string::size_type& pos,
int& value);
2007-04-27 17:01:22 +04:00
//! Handle Python coverage using Python's Trace.py
int HandleTracePyCoverage(cmCTestCoverageHandlerContainer* cont);
2007-04-27 17:01:22 +04:00
// Find the source file based on the source and build tree. This is used for
// Trace.py mode, since that one does not tell us where the source file is.
std::string FindFile(cmCTestCoverageHandlerContainer* cont,
std::string fileName);
2010-04-23 17:16:18 +04:00
std::set<std::string> FindUncoveredFiles(
cmCTestCoverageHandlerContainer* cont);
std::vector<std::string> CustomCoverageExclude;
2006-03-10 23:03:09 +03:00
std::vector<cmsys::RegularExpression> CustomCoverageExcludeRegex;
std::vector<std::string> ExtraCoverageGlobs;
// Map from source file to label ids.
class LabelSet: public std::set<int> {};
typedef std::map<std::string, LabelSet> LabelMapType;
LabelMapType SourceLabels;
LabelMapType TargetDirs;
// Map from label name to label id.
typedef std::map<std::string, int> LabelIdMapType;
LabelIdMapType LabelIdMap;
std::vector<std::string> Labels;
int GetLabelId(std::string const& label);
// Label reading and writing methods.
void LoadLabels();
void LoadLabels(const char* dir);
void WriteXMLLabels(cmXMLWriter& xml, std::string const& source);
// Label-based filtering.
std::set<int> LabelFilter;
bool IntersectsFilter(LabelSet const& labels);
bool IsFilteredOut(std::string const& source);
2004-09-09 16:41:05 +04:00
};
#endif