1 //===- CoverageReport.cpp - Code coverage report -------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This class implements rendering of a code coverage report.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "CoverageReport.h"
15 #include "CoverageSummary.h"
16 #include "RenderingSupport.h"
17 #include "llvm/Support/FileSystem.h"
18 #include "llvm/Support/Format.h"
19
20 using namespace llvm;
21 namespace {
22 /// \brief Helper struct which prints trimmed and aligned columns.
23 struct Column {
24 enum TrimKind { NoTrim, LeftTrim, RightTrim };
25
26 enum AlignmentKind { LeftAlignment, RightAlignment };
27
28 StringRef Str;
29 unsigned Width;
30 TrimKind Trim;
31 AlignmentKind Alignment;
32
Column__anona9b5de5c0111::Column33 Column(StringRef Str, unsigned Width)
34 : Str(Str), Width(Width), Trim(NoTrim), Alignment(LeftAlignment) {}
35
set__anona9b5de5c0111::Column36 Column &set(TrimKind Value) {
37 Trim = Value;
38 return *this;
39 }
40
set__anona9b5de5c0111::Column41 Column &set(AlignmentKind Value) {
42 Alignment = Value;
43 return *this;
44 }
45
46 void render(raw_ostream &OS) const;
47 };
operator <<(raw_ostream & OS,const Column & Value)48 raw_ostream &operator<<(raw_ostream &OS, const Column &Value) {
49 Value.render(OS);
50 return OS;
51 }
52 }
53
render(raw_ostream & OS) const54 void Column::render(raw_ostream &OS) const {
55 if (Str.size() <= Width) {
56 if (Alignment == RightAlignment) {
57 OS.indent(Width - Str.size());
58 OS << Str;
59 return;
60 }
61 OS << Str;
62 OS.indent(Width - Str.size());
63 return;
64 }
65
66 switch (Trim) {
67 case NoTrim:
68 OS << Str.substr(0, Width);
69 break;
70 case LeftTrim:
71 OS << "..." << Str.substr(Str.size() - Width + 3);
72 break;
73 case RightTrim:
74 OS << Str.substr(0, Width - 3) << "...";
75 break;
76 }
77 }
78
column(StringRef Str,unsigned Width)79 static Column column(StringRef Str, unsigned Width) {
80 return Column(Str, Width);
81 }
82
83 template <typename T>
column(StringRef Str,unsigned Width,const T & Value)84 static Column column(StringRef Str, unsigned Width, const T &Value) {
85 return Column(Str, Width).set(Value);
86 }
87
88 static const unsigned FileReportColumns[] = {25, 10, 8, 8, 10, 10};
89 static const unsigned FunctionReportColumns[] = {25, 10, 8, 8, 10, 8, 8};
90
91 /// \brief Prints a horizontal divider which spans across the given columns.
92 template <typename T, size_t N>
renderDivider(T (& Columns)[N],raw_ostream & OS)93 static void renderDivider(T (&Columns)[N], raw_ostream &OS) {
94 unsigned Length = 0;
95 for (unsigned I = 0; I < N; ++I)
96 Length += Columns[I];
97 for (unsigned I = 0; I < Length; ++I)
98 OS << '-';
99 }
100
101 /// \brief Return the color which correponds to the coverage
102 /// percentage of a certain metric.
103 template <typename T>
determineCoveragePercentageColor(const T & Info)104 static raw_ostream::Colors determineCoveragePercentageColor(const T &Info) {
105 if (Info.isFullyCovered())
106 return raw_ostream::GREEN;
107 return Info.getPercentCovered() >= 80.0 ? raw_ostream::YELLOW
108 : raw_ostream::RED;
109 }
110
render(const FileCoverageSummary & File,raw_ostream & OS)111 void CoverageReport::render(const FileCoverageSummary &File, raw_ostream &OS) {
112 OS << column(File.Name, FileReportColumns[0], Column::LeftTrim)
113 << format("%*u", FileReportColumns[1], (unsigned)File.RegionCoverage.NumRegions);
114 Options.colored_ostream(OS, File.RegionCoverage.isFullyCovered()
115 ? raw_ostream::GREEN
116 : raw_ostream::RED)
117 << format("%*u", FileReportColumns[2], (unsigned)File.RegionCoverage.NotCovered);
118 Options.colored_ostream(OS,
119 determineCoveragePercentageColor(File.RegionCoverage))
120 << format("%*.2f", FileReportColumns[3] - 1,
121 File.RegionCoverage.getPercentCovered()) << '%';
122 OS << format("%*u", FileReportColumns[4],
123 (unsigned)File.FunctionCoverage.NumFunctions);
124 Options.colored_ostream(
125 OS, determineCoveragePercentageColor(File.FunctionCoverage))
126 << format("%*.2f", FileReportColumns[5] - 1,
127 File.FunctionCoverage.getPercentCovered()) << '%';
128 OS << "\n";
129 }
130
render(const FunctionCoverageSummary & Function,raw_ostream & OS)131 void CoverageReport::render(const FunctionCoverageSummary &Function,
132 raw_ostream &OS) {
133 OS << column(Function.Name, FunctionReportColumns[0], Column::RightTrim)
134 << format("%*u", FunctionReportColumns[1],
135 (unsigned)Function.RegionCoverage.NumRegions);
136 Options.colored_ostream(OS, Function.RegionCoverage.isFullyCovered()
137 ? raw_ostream::GREEN
138 : raw_ostream::RED)
139 << format("%*u", FunctionReportColumns[2],
140 (unsigned)Function.RegionCoverage.NotCovered);
141 Options.colored_ostream(
142 OS, determineCoveragePercentageColor(Function.RegionCoverage))
143 << format("%*.2f", FunctionReportColumns[3] - 1,
144 Function.RegionCoverage.getPercentCovered()) << '%';
145 OS << format("%*u", FunctionReportColumns[4],
146 (unsigned)Function.LineCoverage.NumLines);
147 Options.colored_ostream(OS, Function.LineCoverage.isFullyCovered()
148 ? raw_ostream::GREEN
149 : raw_ostream::RED)
150 << format("%*u", FunctionReportColumns[5],
151 (unsigned)Function.LineCoverage.NotCovered);
152 Options.colored_ostream(
153 OS, determineCoveragePercentageColor(Function.LineCoverage))
154 << format("%*.2f", FunctionReportColumns[6] - 1,
155 Function.LineCoverage.getPercentCovered()) << '%';
156 OS << "\n";
157 }
158
renderFunctionReports(raw_ostream & OS)159 void CoverageReport::renderFunctionReports(raw_ostream &OS) {
160 bool isFirst = true;
161 for (const auto &File : Summary.getFileSummaries()) {
162 if (isFirst)
163 isFirst = false;
164 else
165 OS << "\n";
166 OS << "File '" << File.Name << "':\n";
167 OS << column("Name", FunctionReportColumns[0])
168 << column("Regions", FunctionReportColumns[1], Column::RightAlignment)
169 << column("Miss", FunctionReportColumns[2], Column::RightAlignment)
170 << column("Cover", FunctionReportColumns[3], Column::RightAlignment)
171 << column("Lines", FunctionReportColumns[4], Column::RightAlignment)
172 << column("Miss", FunctionReportColumns[5], Column::RightAlignment)
173 << column("Cover", FunctionReportColumns[6], Column::RightAlignment);
174 OS << "\n";
175 renderDivider(FunctionReportColumns, OS);
176 OS << "\n";
177 for (const auto &Function : File.FunctionSummaries)
178 render(Function, OS);
179 renderDivider(FunctionReportColumns, OS);
180 OS << "\n";
181 render(FunctionCoverageSummary("TOTAL", /*ExecutionCount=*/0,
182 File.RegionCoverage, File.LineCoverage),
183 OS);
184 }
185 }
186
renderFileReports(raw_ostream & OS)187 void CoverageReport::renderFileReports(raw_ostream &OS) {
188 OS << column("Filename", FileReportColumns[0])
189 << column("Regions", FileReportColumns[1], Column::RightAlignment)
190 << column("Miss", FileReportColumns[2], Column::RightAlignment)
191 << column("Cover", FileReportColumns[3], Column::RightAlignment)
192 << column("Functions", FileReportColumns[4], Column::RightAlignment)
193 << column("Executed", FileReportColumns[5], Column::RightAlignment)
194 << "\n";
195 renderDivider(FileReportColumns, OS);
196 OS << "\n";
197 for (const auto &File : Summary.getFileSummaries())
198 render(File, OS);
199 renderDivider(FileReportColumns, OS);
200 OS << "\n";
201 render(Summary.getCombinedFileSummaries(), OS);
202 }
203