/* * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "VtsCoverageProcessor.h" #include <dirent.h> #include <fcntl.h> #include <fstream> #include <iostream> #include <map> #include <string> #include <vector> #include <google/protobuf/text_format.h> #include <test/vts/proto/VtsReportMessage.pb.h> using namespace std; using google::protobuf::TextFormat; namespace android { namespace vts { void VtsCoverageProcessor::ParseCoverageData(const string& coverage_file, TestReportMessage* report_msg) { ifstream in(coverage_file, std::ios::in); string msg_str((istreambuf_iterator<char>(in)), istreambuf_iterator<char>()); if (!TextFormat::MergeFromString(msg_str, report_msg)) { cerr << "Can't parse a given coverage report: " << msg_str << endl; exit(-1); } } void VtsCoverageProcessor::UpdateCoverageData( const CoverageReportMessage& ref_msg, CoverageReportMessage* msg_to_be_updated) { if (ref_msg.file_path() == msg_to_be_updated->file_path()) { for (int line = 0; line < ref_msg.line_coverage_vector_size(); line++) { if (line < msg_to_be_updated->line_coverage_vector_size()) { if (ref_msg.line_coverage_vector(line) > 0 && msg_to_be_updated->line_coverage_vector(line) > 0) { msg_to_be_updated->set_line_coverage_vector(line, 0); msg_to_be_updated->set_covered_line_count( msg_to_be_updated->covered_line_count() - 1); } } else { cout << "Reached the end of line_coverage_vector." << endl; break; } } // sanity check. if (msg_to_be_updated->covered_line_count() < 0) { cerr << __func__ << ": covered_line_count should not be negative." << endl; exit(-1); } } } void VtsCoverageProcessor::MergeCoverage(const string& coverage_file_dir, const string& merged_coverage_file) { DIR* coverage_dir = opendir(coverage_file_dir.c_str()); if (coverage_dir == 0) { cerr << __func__ << ": " << coverage_file_dir << " does not exist." << endl; return; } TestReportMessage merged_coverage_report; struct dirent* file; while ((file = readdir(coverage_dir)) != NULL) { if (file->d_type == DT_REG) { string coverage_file = coverage_file_dir; if (coverage_file_dir.substr(coverage_file_dir.size() - 1) != "/") { coverage_file += "/"; } string coverage_file_base_name = file->d_name; coverage_file += coverage_file_base_name; TestReportMessage coverage_report; ParseCoverageData(coverage_file, &coverage_report); for (const auto& cov : coverage_report.coverage()) { bool seen_cov = false; for (int i = 0; i < merged_coverage_report.coverage_size(); i++) { if (merged_coverage_report.coverage(i).file_path() == cov.file_path()) { MergeCoverageMsg(cov, merged_coverage_report.mutable_coverage(i)); seen_cov = true; break; } } if (!seen_cov) { *merged_coverage_report.add_coverage() = cov; } } } } PrintCoverageSummary(merged_coverage_report); ofstream fout; fout.open(merged_coverage_file); fout << merged_coverage_report.DebugString(); fout.close(); } void VtsCoverageProcessor::MergeCoverageMsg( const CoverageReportMessage& ref_coverage_msg, CoverageReportMessage* merged_coverage_msg) { // sanity check. if (ref_coverage_msg.file_path() != merged_coverage_msg->file_path()) { cerr << "Trying to merge coverage data for different files." << endl; exit(-1); } if (ref_coverage_msg.line_coverage_vector_size() != merged_coverage_msg->line_coverage_vector_size()) { cerr << "Trying to merge coverage data with different lines." << "ref_coverage_msg: " << ref_coverage_msg.DebugString() << "merged_coverage_msg: " << merged_coverage_msg->DebugString() << endl; exit(-1); } for (int i = 0; i < ref_coverage_msg.line_coverage_vector_size(); i++) { if (i > merged_coverage_msg->line_coverage_vector_size() - 1) { cerr << "Reach the end of coverage vector" << endl; break; } int ref_line_count = ref_coverage_msg.line_coverage_vector(i); int merged_line_count = merged_coverage_msg->line_coverage_vector(i); if (ref_line_count > 0) { if (merged_line_count == 0) { merged_coverage_msg->set_covered_line_count( merged_coverage_msg->covered_line_count() + 1); } merged_coverage_msg->set_line_coverage_vector( i, merged_line_count + ref_line_count); } } } void VtsCoverageProcessor::CompareCoverage(const string& ref_msg_file, const string& new_msg_file) { TestReportMessage ref_coverage_report; TestReportMessage new_coverage_report; ParseCoverageData(ref_msg_file, &ref_coverage_report); ParseCoverageData(new_msg_file, &new_coverage_report); map<string, vector<int>> new_coverage_map; for (const auto& new_coverage : new_coverage_report.coverage()) { bool seen_file = false; for (const auto& ref_coverage : ref_coverage_report.coverage()) { if (new_coverage.file_path() == ref_coverage.file_path()) { int line = 0; for (; line < new_coverage.line_coverage_vector_size(); line++) { if (new_coverage.line_coverage_vector(line) > 0 && ref_coverage.line_coverage_vector(line) == 0) { if (new_coverage_map.find(new_coverage.file_path()) != new_coverage_map.end()) { new_coverage_map[new_coverage.file_path()].push_back(line); } else { new_coverage_map.insert(std::pair<string, vector<int>>( new_coverage.file_path(), vector<int>{line})); } } } seen_file = true; break; } } if (!seen_file) { vector<int> new_line; for (int line = 0; line < new_coverage.line_coverage_vector_size(); line++) { if (new_coverage.line_coverage_vector(line) > 0) { new_line.push_back(line); } } new_coverage_map.insert( std::pair<string, vector<int>>(new_coverage.file_path(), new_line)); } } for (auto it = new_coverage_map.begin(); it != new_coverage_map.end(); it++) { cout << it->first << ": " << endl; for (int covered_line : it->second) { cout << covered_line << endl; } } } void VtsCoverageProcessor::GetSubsetCoverage(const string& ref_msg_file, const string& full_msg_file, const string& result_msg_file) { TestReportMessage ref_coverage_report; TestReportMessage full_coverage_report; TestReportMessage result_coverage_report; ParseCoverageData(ref_msg_file, &ref_coverage_report); ParseCoverageData(full_msg_file, &full_coverage_report); for (const auto& ref_coverage : ref_coverage_report.coverage()) { bool seen_file = false; for (const auto& coverage : full_coverage_report.coverage()) { if (coverage.file_path() == ref_coverage.file_path()) { *result_coverage_report.add_coverage() = coverage; seen_file = true; break; } } if (!seen_file) { cout << ": missing coverage for file " << ref_coverage.file_path() << endl; CoverageReportMessage* empty_coverage = result_coverage_report.add_coverage(); *empty_coverage = ref_coverage; for (int line = 0; line < empty_coverage->line_coverage_vector_size(); line++) { if (empty_coverage->line_coverage_vector(line) > 0) { empty_coverage->set_line_coverage_vector(line, 0); } } empty_coverage->set_covered_line_count(0); } } PrintCoverageSummary(result_coverage_report); ofstream fout; fout.open(result_msg_file); fout << result_coverage_report.DebugString(); fout.close(); } void VtsCoverageProcessor::GetCoverageSummary(const string& coverage_msg_file) { TestReportMessage coverage_report; ParseCoverageData(coverage_msg_file, &coverage_report); PrintCoverageSummary(coverage_report); } void VtsCoverageProcessor::PrintCoverageSummary( const TestReportMessage& coverage_report) { long total_lines_covered = GetTotalCoverageLine(coverage_report); long total_code_lines = GetTotalCodeLine(coverage_report); double coverage_rate = (double)total_lines_covered / total_code_lines; cout << "total lines covered: " << total_lines_covered << endl; cout << "total lines: " << total_code_lines << endl; cout << "coverage rate: " << coverage_rate << endl; } long VtsCoverageProcessor::GetTotalCoverageLine( const TestReportMessage& msg) const { long total_coverage_line = 0; for (const auto& coverage : msg.coverage()) { total_coverage_line += coverage.covered_line_count(); } return total_coverage_line; } long VtsCoverageProcessor::GetTotalCodeLine( const TestReportMessage& msg) const { long total_line = 0; for (const auto& coverage : msg.coverage()) { total_line += coverage.total_line_count(); } return total_line; } } // namespace vts } // namespace android