Skip source code files with file paths that match the given regular expression.
+.. option:: -whitelist-filename-regex=<PATTERN>
+
+ Show code coverage only for files that match the given regular expression.
+
.. option:: -format=<FORMAT>
Use the specified output format. The supported formats are: "text", "html".
--- /dev/null
+########################
+# Test "report" command.
+########################
+# Only source files
+RUN: llvm-cov report -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN: -path-equivalence=/tmp,%S/Inputs -whitelist-filename-regex='.*\.cc$' \
+RUN: %S/Inputs/sources_specified/main.covmapping \
+RUN: | FileCheck -check-prefix=REPORT_WHITELIST_SOURCE %s
+
+REPORT_WHITELIST_SOURCE-NOT: {{.*}}dec.h{{.*}}
+REPORT_WHITELIST_SOURCE-NOT: {{.*}}inc.h{{.*}}
+REPORT_WHITELIST_SOURCE-NOT: {{.*}}abs.h{{.*}}
+REPORT_WHITELIST_SOURCE: {{.*}}main.cc{{.*}}
+REPORT_WHITELIST_SOURCE: {{^}}TOTAL 1{{.*}}100.00%{{$}}
+
+# Whitelist all files from "extra" directory.
+RUN: llvm-cov report -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN: -path-equivalence=/tmp,%S/Inputs -whitelist-filename-regex='.*extra[/\\].*' \
+RUN: %S/Inputs/sources_specified/main.covmapping \
+RUN: | FileCheck -check-prefix=REPORT_WHITELIST_DIR %s
+
+REPORT_WHITELIST_DIR: {{.*}}dec.h{{.*}}
+REPORT_WHITELIST_DIR: {{.*}}inc.h{{.*}}
+REPORT_WHITELIST_DIR-NOT: {{.*}}abs.h{{.*}}
+REPORT_WHITELIST_DIR-NOT: {{.*}}main.cc{{.*}}
+REPORT_WHITELIST_DIR: {{^}}TOTAL 2{{.*}}50.00%{{$}}
+
+# Whitelist ignored files
+RUN: llvm-cov report -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN: -path-equivalence=/tmp,%S/Inputs \
+RUN: -ignore-filename-regex='.*' -whitelist-filename-regex='.*' \
+RUN: %S/Inputs/sources_specified/main.covmapping \
+RUN: | FileCheck -check-prefix=REPORT_WHITELIST_IGNORED %s
+
+REPORT_WHITELIST_IGNORED-NOT: {{.*}}dec.h{{.*}}
+REPORT_WHITELIST_IGNORED-NOT: {{.*}}inc.h{{.*}}
+REPORT_WHITELIST_IGNORED-NOT: {{.*}}abs.h{{.*}}
+REPORT_WHITELIST_IGNORED-NOT: {{.*}}main.cc{{.*}}
+REPORT_WHITELIST_IGNORED-NOT: {{^}}TOTAL 0{{.*}}0.00%{{$}}
+
+# Whitelist all files from "extra" directory even when SOURCES specified.
+RUN: llvm-cov report -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN: -path-equivalence=/tmp,%S/Inputs -whitelist-filename-regex='.*extra[/\\].*' \
+RUN: %S/Inputs/sources_specified/main.covmapping \
+RUN: %S/Inputs/sources_specified/extra %S/Inputs/sources_specified/abs.h \
+RUN: | FileCheck -check-prefix=REPORT_WHITELIST_DIR_WITH_SOURCES %s
+
+REPORT_WHITELIST_DIR_WITH_SOURCES: {{.*}}dec.h{{.*}}
+REPORT_WHITELIST_DIR_WITH_SOURCES: {{.*}}inc.h{{.*}}
+REPORT_WHITELIST_DIR_WITH_SOURCES-NOT: {{.*}}abs.h{{.*}}
+REPORT_WHITELIST_DIR_WITH_SOURCES-NOT: {{.*}}main.cc{{.*}}
+REPORT_WHITELIST_DIR_WITH_SOURCES: {{^}}TOTAL 2{{.*}}50.00%{{$}}
+
+########################
+# Test "show" command.
+########################
+# Whitelist a couple files
+RUN: llvm-cov show -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN: -path-equivalence=/tmp,%S/Inputs \
+RUN: -whitelist-filename-regex='.*\.cc$' -whitelist-filename-regex='.*abs\.h$' \
+RUN: %S/Inputs/sources_specified/main.covmapping \
+RUN: | FileCheck -check-prefix=SHOW_WHITELIST_CC %s
+
+# Order of files may differ, check that there are 3 files and not abs.h.
+SHOW_IGNORE_CC-NOT: {{.*}}main.cc{{.*}}
+
+SHOW_WHITELIST_CC-NOT: {{.*}}dec.h{{.*}}
+SHOW_WHITELIST_CC-NOT: {{.*}}inc.h{{.*}}
+SHOW_WHITELIST_CC: {{.*}}sources_specified{{.*}}
+SHOW_WHITELIST_CC: {{.*}}sources_specified{{.*}}
+
+########################
+# Test "export" command.
+########################
+# Use a temp .json file as output in a single line. Whitelist headers that have
+# an 'a' follow by 2 chars followed by '.h'.
+RUN: llvm-cov export -instr-profile %S/Inputs/sources_specified/main.profdata \
+RUN: -path-equivalence=/tmp,%S/Inputs -whitelist-filename-regex='.*a..\.h$' \
+RUN: %S/Inputs/sources_specified/main.covmapping \
+RUN: > %t.export.json
+
+RUN: FileCheck -check-prefix=NO-EXPORT_WHITELIST_3_SYMBOLS_H %s < %t.export.json
+RUN: FileCheck -check-prefix=EXPORT_WHITELIST_3_SYMBOLS_H %s < %t.export.json
+
+NO-EXPORT_WHITELIST_3_SYMBOLS_H-NOT: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)inc.h"}}
+NO-EXPORT_WHITELIST_3_SYMBOLS_H-NOT: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)dec.h"}}
+NO-EXPORT_WHITELIST_3_SYMBOLS_H-NOT: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)main.cc"}}
+EXPORT_WHITELIST_3_SYMBOLS_H: {{"filename":"(/|\\\\)tmp(/|\\\\)sources_specified(/|\\\\)abs.h"}}
std::vector<StringRef> ObjectFilenames;
CoverageViewOptions ViewOpts;
CoverageFiltersMatchAll Filters;
- CoverageFilters IgnoreFilenameFilters;
+ FilenameCoverageFilters FilenameFilters;
/// The path to the indexed profile.
std::string PGOFilename;
return;
}
sys::path::remove_dots(EffectivePath, /*remove_dot_dots=*/true);
- if (!IgnoreFilenameFilters.matchesFilename(EffectivePath))
+ if (FilenameFilters.matchesFilename(EffectivePath))
SourceFiles.emplace_back(EffectivePath.str());
}
"regular expression"),
cl::ZeroOrMore, cl::cat(FilteringCategory));
+ cl::list<std::string> WhitelistFilenameRegexFilters(
+ "whitelist-filename-regex", cl::Optional,
+ cl::desc("Show code coverage only for file paths that match the given "
+ "regular expression"),
+ cl::ZeroOrMore, cl::cat(FilteringCategory));
+
cl::list<std::string> IgnoreFilenameRegexFilters(
"ignore-filename-regex", cl::Optional,
cl::desc("Skip source code files with file paths that match the given "
Filters.push_back(std::move(StatFilterer));
}
- // Create the ignore filename filters.
+ // Create the filename filters.
for (const auto &RE : IgnoreFilenameRegexFilters)
- IgnoreFilenameFilters.push_back(
- std::make_unique<NameRegexCoverageFilter>(RE));
+ FilenameFilters.blacklist(std::make_unique<NameRegexCoverageFilter>(RE));
+ for (const auto &RE : WhitelistFilenameRegexFilters)
+ FilenameFilters.whitelist(std::make_unique<NameRegexCoverageFilter>(RE));
if (!Arches.empty()) {
for (const std::string &Arch : Arches) {
}
}
- // IgnoreFilenameFilters are applied even when InputSourceFiles specified.
+ // FilenameFilters are applied even when InputSourceFiles specified.
for (const std::string &File : InputSourceFiles)
collectPaths(File);
if (SourceFiles.empty())
// Get the source files from the function coverage mapping.
for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
- if (!IgnoreFilenameFilters.matchesFilename(Filename))
+ if (FilenameFilters.matchesFilename(Filename))
SourceFiles.push_back(Filename);
}
CoverageReport Report(ViewOpts, *Coverage.get());
if (!ShowFunctionSummaries) {
if (SourceFiles.empty())
- Report.renderFileReports(llvm::outs(), IgnoreFilenameFilters);
+ Report.renderFileReports(llvm::outs(), FilenameFilters);
else
Report.renderFileReports(llvm::outs(), SourceFiles);
} else {
}
if (SourceFiles.empty())
- Exporter->renderRoot(IgnoreFilenameFilters);
+ Exporter->renderRoot(FilenameFilters);
else
Exporter->renderRoot(SourceFiles);
virtual ~CoverageExporter(){};
/// Render the CoverageMapping object.
- virtual void renderRoot(const CoverageFilters &IgnoreFilters) = 0;
+ virtual void renderRoot(const FilenameCoverageFilters &FilenameFilters) = 0;
/// Render the CoverageMapping object for specified source files.
virtual void renderRoot(ArrayRef<std::string> SourceFiles) = 0;
} // end anonymous namespace
-void CoverageExporterJson::renderRoot(const CoverageFilters &IgnoreFilters) {
+void CoverageExporterJson::renderRoot(
+ const FilenameCoverageFilters &FilenameFilters) {
std::vector<std::string> SourceFiles;
for (StringRef SF : Coverage.getUniqueSourceFiles()) {
- if (!IgnoreFilters.matchesFilename(SF))
+ if (FilenameFilters.matchesFilename(SF))
SourceFiles.emplace_back(SF);
}
renderRoot(SourceFiles);
: CoverageExporter(CoverageMapping, Options, OS) {}
/// Render the CoverageMapping object.
- void renderRoot(const CoverageFilters &IgnoreFilters) override;
+ void renderRoot(const FilenameCoverageFilters &FilenameFilters) override;
/// Render the CoverageMapping object for specified source files.
void renderRoot(ArrayRef<std::string> SourceFiles) override;
} // end anonymous namespace
-void CoverageExporterLcov::renderRoot(const CoverageFilters &IgnoreFilters) {
+void CoverageExporterLcov::renderRoot(
+ const FilenameCoverageFilters &FilenameFilters) {
std::vector<std::string> SourceFiles;
for (StringRef SF : Coverage.getUniqueSourceFiles()) {
- if (!IgnoreFilters.matchesFilename(SF))
+ if (FilenameFilters.matchesFilename(SF))
SourceFiles.emplace_back(SF);
}
renderRoot(SourceFiles);
: CoverageExporter(CoverageMapping, Options, OS) {}
/// Render the CoverageMapping object.
- void renderRoot(const CoverageFilters &IgnoreFilters) override;
+ void renderRoot(const FilenameCoverageFilters &FilenameFilters) override;
/// Render the CoverageMapping object for specified source files.
void renderRoot(ArrayRef<std::string> SourceFiles) override;
}
return true;
}
+
+bool FilenameCoverageFilters::matchesFilename(StringRef Filename) const {
+ if (!Whitelist.empty() && !Whitelist.matchesFilename(Filename)) {
+ return false;
+ }
+ return !Blacklist.matchesFilename(Filename);
+}
+
+void FilenameCoverageFilters::whitelist(
+ std::unique_ptr<CoverageFilter> Filter) {
+ Whitelist.push_back(std::move(Filter));
+}
+
+void FilenameCoverageFilters::blacklist(
+ std::unique_ptr<CoverageFilter> Filter) {
+ Blacklist.push_back(std::move(Filter));
+}
const coverage::FunctionRecord &Function) const override;
};
+/// A collection of filters.
+/// Matches filenames that are whitelisted and not blacklisted.
+class FilenameCoverageFilters : public CoverageFilter {
+protected:
+ CoverageFilters Whitelist;
+ CoverageFilters Blacklist;
+
+public:
+
+ void whitelist(std::unique_ptr<CoverageFilter> Filter);
+ void blacklist(std::unique_ptr<CoverageFilter> Filter);
+
+ bool matchesFilename(StringRef Filename) const override;
+};
+
+
} // namespace llvm
#endif // LLVM_COV_COVERAGEFILTERS_H
}
void CoverageReport::renderFileReports(
- raw_ostream &OS, const CoverageFilters &IgnoreFilenameFilters) const {
+ raw_ostream &OS, const FilenameCoverageFilters &FilenameFilters) const {
std::vector<std::string> UniqueSourceFiles;
for (StringRef SF : Coverage.getUniqueSourceFiles()) {
- // Apply ignore source files filters.
- if (!IgnoreFilenameFilters.matchesFilename(SF))
+ // Apply source files filters.
+ if (FilenameFilters.matchesFilename(SF))
UniqueSourceFiles.emplace_back(SF.str());
}
renderFileReports(OS, UniqueSourceFiles);
/// Render file reports for every unique file in the coverage mapping.
void renderFileReports(raw_ostream &OS,
- const CoverageFilters &IgnoreFilenameFilters) const;
+ const FilenameCoverageFilters &FilenameFilters) const;
/// Render file reports for the files specified in \p Files.
void renderFileReports(raw_ostream &OS, ArrayRef<std::string> Files) const;