| #!/usr/bin/env vpython |
| # Copyright 2018 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import os |
| import sys |
| import unittest |
| |
| import mock |
| |
| THIS_DIR = os.path.dirname(os.path.abspath(__file__)) |
| sys.path.insert(0, |
| os.path.abspath(os.path.join(THIS_DIR, os.pardir, 'resources'))) |
| |
| import generate_coverage_metadata as generator |
| |
| |
| class GenerateCoverageMetadataTest(unittest.TestCase): |
| |
| # This test uses the following code: |
| # 1| 1|int main() { |
| # 2| 1| if ((2 > 1) || (3 > 2)) { |
| # 3| 1| return 0; |
| # 4| 1| } |
| # 5| 0| |
| # 6| 0| return 1; |
| # 7| 0|} |
| # |
| # Where the first column is the line number and the second column is the |
| # expected number of times the line is executed. |
| def test_parse_exported_coverage_json(self): |
| segments = [ |
| [1, 12, 1, True, True], |
| [2, 7, 1, True, True], |
| [2, 14, 1, True, False], |
| [2, 18, 0, True, True], |
| [2, 25, 1, True, False], |
| [2, 27, 1, True, True], |
| [4, 4, 0, True, False], |
| [6, 3, 0, True, True], |
| [7, 2, 0, False, False], |
| ] |
| |
| expected_line_data = dict([(1, 1), (2, 1), (3, 1), (4, 1), (5, 0), (6, 0), |
| (7, 0)]) |
| expected_block_data = {2: [[18, 24]]} |
| line_data, block_data = generator._extract_coverage_info(segments) |
| self.assertDictEqual(expected_line_data, line_data) |
| self.assertDictEqual(expected_block_data, block_data) |
| |
| # This test uses the following code: |
| # 1| 1|int main() { return 0; } |
| # |
| # Where the first column is the line number and the second column is the |
| # expected number of times the line is executed. |
| def test_parse_exported_coverage_json_one_line(self): |
| segments = [[1, 12, 1, True, True], [1, 25, 0, False, False]] |
| |
| expected_line_data = dict([(1, 1)]) |
| expected_block_data = {} |
| line_data, block_data = generator._extract_coverage_info(segments) |
| self.assertDictEqual(expected_line_data, line_data) |
| self.assertDictEqual(expected_block_data, block_data) |
| |
| # This test uses the following code: |
| # 1| 1|int main() { |
| # 2| 1| if ((2 > 1) || (3 > 2)) { |
| # 3| 1| return 0; |
| # 4| 1| } |
| # 5| 0| |
| # 6| 0| return 1; |
| # 7| 0|} |
| # |
| # Where the first column is the line number and the second column is the |
| # expected number of times the line is executed. |
| def test_to_compressed_file_record(self): |
| src_path = '/path/to/chromium/src' |
| file_coverage_data = { |
| 'segments': [ |
| [1, 12, 1, True, True], |
| [2, 7, 1, True, True], |
| [2, 14, 1, True, False], |
| [2, 18, 0, True, True], |
| [2, 25, 1, True, False], |
| [2, 27, 1, True, True], |
| [4, 4, 0, True, False], |
| [6, 3, 0, True, True], |
| [7, 2, 0, False, False], |
| ], |
| 'summary': { |
| 'lines': { |
| 'count': 7, |
| } |
| }, |
| 'filename': |
| '/path/to/chromium/src/base/base.cc', |
| } |
| expected_record = { |
| 'path': |
| 'base/base.cc', |
| 'total_lines': |
| 7, |
| 'lines': [ |
| { |
| 'first': 1, |
| 'last': 4, |
| 'count': 1, |
| }, |
| { |
| 'first': 5, |
| 'last': 7, |
| 'count': 0, |
| }, |
| ], |
| 'uncovered_blocks': [{ |
| 'line': 2, |
| 'ranges': [{ |
| 'first': 18, |
| 'last': 24, |
| }] |
| }], |
| } |
| self.maxDiff = None |
| record = generator._to_compressed_file_record(src_path, file_coverage_data) |
| self.assertDictEqual(expected_record, record) |
| |
| # This test uses made-up segments, and the intention is to test that for |
| # *uncontinous* regions, even if their lines are executed the same number of |
| # times, when converted to compressed format, lines in different regions |
| # shouldn't be merged together. |
| def test_to_compressed_file_record_for_uncontinous_lines(self): |
| src_path = '/path/to/chromium/src' |
| file_coverage_data = { |
| 'segments': [ |
| [102, 35, 4, True, True], |
| [104, 4, 0, False, False], |
| [107, 35, 4, True, True], |
| [109, 4, 0, False, False], |
| ], |
| 'summary': { |
| 'lines': { |
| 'count': 6, |
| } |
| }, |
| 'filename': |
| '/path/to/chromium/src/base/base.cc', |
| } |
| expected_record = { |
| 'path': |
| 'base/base.cc', |
| 'total_lines': |
| 6, |
| 'lines': [ |
| { |
| 'first': 102, |
| 'last': 104, |
| 'count': 4, |
| }, |
| { |
| 'first': 107, |
| 'last': 109, |
| 'count': 4, |
| }, |
| ] |
| } |
| self.maxDiff = None |
| record = generator._to_compressed_file_record(src_path, file_coverage_data) |
| self.assertDictEqual(expected_record, record) |
| |
| # This test uses the following code: |
| # 1| 1|int main() { |
| # 2| 1| if ((2 > 1) || (3 > 2)) { |
| # 3| 1| return 0; |
| # 4| 1| } |
| # 5| 0| |
| # 6| 0| return 1; |
| # 7| 0|} |
| # |
| # Where the first column is the line number and the second column is the |
| # expected number of times the line is executed. |
| def test_rebase_line_and_block_data(self): |
| line_data = [(1, 1), (2, 1), (3, 1), (4, 1), (5, 0), (6, 0), (7, 0)] |
| block_data = {2: [[18, 24]]} |
| file_name = 'base/base.cc' |
| diff_mapping = {'base/base.cc': {'2': [16, 'A line added by the patch.']}} |
| |
| rebased_line_data, rebased_block_data = ( |
| generator._rebase_line_and_block_data(line_data, block_data, |
| diff_mapping[file_name])) |
| |
| expected_line_data = [(16, 1)] |
| expected_block_data = {16: [[18, 24]]} |
| self.maxDiff = None |
| self.assertListEqual(expected_line_data, rebased_line_data) |
| self.assertDictEqual(expected_block_data, rebased_block_data) |
| |
| # This test uses the following code: |
| # 1| 1|int main() { |
| # 2| 1| if ((2 > 1) || (3 > 2)) { |
| # 3| 1| return 0; |
| # 4| 1| } |
| # 5| 0| |
| # 6| 0| return 1; |
| # 7| 0|} |
| # |
| # Where the first column is the line number and the second column is the |
| # expected number of times the line is executed. |
| def test_to_compressed_file_record_with_diff_mapping(self): |
| src_path = '/path/to/chromium/src' |
| file_coverage_data = { |
| 'segments': [ |
| [1, 12, 1, True, True], |
| [2, 7, 1, True, True], |
| [2, 14, 1, True, False], |
| [2, 18, 0, True, True], |
| [2, 25, 1, True, False], |
| [2, 27, 1, True, True], |
| [4, 4, 0, True, False], |
| [6, 3, 0, True, True], |
| [7, 2, 0, False, False], |
| ], |
| 'summary': { |
| 'lines': { |
| 'count': 7, |
| } |
| }, |
| 'filename': |
| '/path/to/chromium/src/base/base.cc', |
| } |
| diff_mapping = { |
| 'base/base.cc': { |
| '2': [10, 'A line added by the patch.'], |
| '3': [11, 'Another added line.'], |
| '5': [16, 'One more line.'] |
| } |
| } |
| |
| record = generator._to_compressed_file_record(src_path, file_coverage_data, |
| diff_mapping) |
| |
| expected_record = { |
| 'path': |
| 'base/base.cc', |
| 'total_lines': |
| 7, |
| 'lines': [ |
| { |
| 'first': 10, |
| 'last': 11, |
| 'count': 1, |
| }, |
| { |
| 'first': 16, |
| 'last': 16, |
| 'count': 0, |
| }, |
| ], |
| 'uncovered_blocks': [{ |
| 'line': 10, |
| 'ranges': [{ |
| 'first': 18, |
| 'last': 24, |
| }] |
| }], |
| } |
| |
| self.maxDiff = None |
| self.assertDictEqual(expected_record, record) |
| |
| def test_compute_llvm_args_with_sharded_output(self): |
| args, shard_dir = generator._compute_llvm_args( |
| '/path/to/coverage.profdata', |
| '/path/to/llvm-cov', ['/path/to/1.exe', '/path/to/2.exe'], |
| ['/src/a.cc', '/src/b.cc'], |
| '/path/output/dir', |
| 5, |
| no_sharded_output=False) |
| expected_args = [ |
| '/path/to/llvm-cov', |
| 'export', |
| '-output-dir', |
| '/path/output/dir/shards', |
| '-num-threads', |
| '5', |
| '-instr-profile', |
| '/path/to/coverage.profdata', |
| '/path/to/1.exe', |
| '-object', |
| '/path/to/2.exe', |
| '/src/a.cc', |
| '/src/b.cc', |
| ] |
| self.assertListEqual(expected_args, args) |
| self.assertEqual('/path/output/dir/shards', shard_dir) |
| |
| def test_compute_llvm_args_without_sharded_output(self): |
| args, shard_dir = generator._compute_llvm_args( |
| '/path/to/coverage.profdata', |
| '/path/to/llvm-cov', ['/path/to/1.exe', '/path/to/2.exe'], |
| ['/src/a.cc', '/src/b.cc'], |
| '/path/output/dir', |
| 5, |
| no_sharded_output=True) |
| expected_args = [ |
| '/path/to/llvm-cov', |
| 'export', |
| '-instr-profile', |
| '/path/to/coverage.profdata', |
| '/path/to/1.exe', |
| '-object', |
| '/path/to/2.exe', |
| '/src/a.cc', |
| '/src/b.cc', |
| ] |
| self.assertListEqual(expected_args, args) |
| self.assertIsNone(shard_dir) |
| |
| # This test uses the following code: |
| # 1| 1|int main() { |
| # 2| 1| if ((2 > 1) || (3 > 2)) { |
| # 3| 1| return 0; |
| # 4| 1| } |
| # 5| 0| |
| # 6| 0| return 1; |
| # 7| 0|} |
| # |
| # Where the first column is the line number and the second column is the |
| # expected number of times the line is executed. |
| @mock.patch.object(generator, '_get_coverage_data_in_json') |
| def test_generate_metadata_for_per_cl_coverage(self, mock_get_coverage_data): |
| mock_get_coverage_data.return_value = { |
| 'data': [{ |
| 'files': [{ |
| 'segments': [[1, 12, 1, True, True], [2, 7, 1, True, True], |
| [2, 14, 1, True, False], [2, 18, 0, True, True], |
| [2, 25, 1, True, False], [2, 27, 1, True, True], |
| [4, 4, 0, True, False], [6, 3, 0, True, True], |
| [7, 2, 0, False, False]], |
| 'summary': { |
| 'functions': { |
| 'count': 1, |
| 'covered': 1, |
| 'percent': 100 |
| }, |
| 'lines': { |
| 'count': 7, |
| 'covered': 4, |
| 'percent': 57 |
| }, |
| 'regions': { |
| 'count': 6, |
| 'covered': 4, |
| 'notcovered': 2, |
| 'percent': 67 |
| }, |
| }, |
| 'filename': |
| '/path/to/src/dir/file.cc', |
| }] |
| }] |
| } |
| |
| diff_mapping = { |
| 'dir/file.cc': { |
| '2': [10, 'A line added by the patch.'], |
| '3': [11, 'Another added line.'], |
| '5': [16, 'One more line.'] |
| } |
| } |
| |
| compressed_data = generator._generate_metadata( |
| src_path='/path/to/src', |
| output_dir='/path/to/output_dir', |
| profdata_path='/path/to/coverage.profdata', |
| llvm_cov_path='/path/to/llvm-cov', |
| binaries=['/path/to/binary1', '/path/to/binary2'], |
| component_mapping=None, |
| sources=['/path/to/src/dir/file.cc'], |
| diff_mapping=diff_mapping) |
| |
| expected_compressed_files = [{ |
| 'path': |
| '//dir/file.cc', |
| 'lines': [{ |
| 'count': 1, |
| 'last': 11, |
| 'first': 10 |
| }, { |
| 'count': 0, |
| 'last': 16, |
| 'first': 16 |
| }], |
| 'total_lines': |
| 7, |
| 'uncovered_blocks': [{ |
| 'ranges': [{ |
| 'last': 24, |
| 'first': 18 |
| }], |
| 'line': 10 |
| }] |
| }] |
| self.maxDiff = None |
| self.assertListEqual(expected_compressed_files, compressed_data['files']) |
| |
| # This test uses the following code: |
| # /path/to/src/dir1/file1.cc |
| # 1| 1|int main() { |
| # 2| 1| if ((2 > 1) || (3 > 2)) { |
| # 3| 1| return 0; |
| # 4| 1| } |
| # 5| 0| |
| # 6| 0| return 1; |
| # 7| 0|} |
| # |
| # /path/to/src/dir2/file2.cc |
| # 1| 1|int main() { return 0; } |
| # |
| # Where the first column is the line number and the second column is the |
| # expected number of times the line is executed. |
| @mock.patch.object(generator.repository_util, 'GetFileRevisions') |
| @mock.patch.object(generator, '_get_coverage_data_in_json') |
| def test_generate_metadata_for_full_repo_coverage( |
| self, mock_get_coverage_data, mock_GetFileRevisions): |
| # Number of files should not exceed 1000; otherwise sharding will happen. |
| mock_GetFileRevisions.return_value = { |
| '//dir1/file1.cc': ('hash1', 1234), |
| '//dir2/file2.cc': ('hash2', 5678), |
| } |
| mock_get_coverage_data.return_value = { |
| 'data': [{ |
| 'files': [ |
| { |
| 'segments': [ |
| [1, 12, 1, True, True], |
| [2, 7, 1, True, True], |
| [2, 14, 1, True, False], |
| [2, 18, 0, True, True], |
| [2, 25, 1, True, False], |
| [2, 27, 1, True, True], |
| [4, 4, 0, True, False], |
| [6, 3, 0, True, True], |
| [7, 2, 0, False, False], |
| ], |
| 'summary': { |
| 'functions': { |
| 'count': 1, |
| 'covered': 1, |
| 'percent': 100 |
| }, |
| 'lines': { |
| 'count': 7, |
| 'covered': 4, |
| 'percent': 57 |
| }, |
| 'regions': { |
| 'count': 6, |
| 'covered': 4, |
| 'notcovered': 2, |
| 'percent': 67 |
| }, |
| }, |
| 'filename': |
| '/path/to/src/dir1/file1.cc', |
| }, |
| { |
| 'segments': [[1, 12, 1, True, True], |
| [1, 25, 0, False, False]], |
| 'summary': { |
| 'lines': { |
| 'count': 1, |
| 'covered': 1, |
| 'percent': 100, |
| }, |
| 'functions': { |
| 'count': 1, |
| 'covered': 1, |
| 'percent': 100, |
| }, |
| 'regions': { |
| 'count': 1, |
| 'covered': 1, |
| 'percent': 100, |
| }, |
| }, |
| 'filename': |
| '/path/to/src/dir2/file2.cc', |
| }, |
| ] |
| }] |
| } |
| |
| component_mapping = {'dir1': 'Test>Component', 'dir2': 'Test>Component'} |
| |
| compressed_data = generator._generate_metadata( |
| src_path='/path/to/src', |
| output_dir='/path/to/output_dir', |
| profdata_path='/path/to/coverage.profdata', |
| llvm_cov_path='/path/to/llvm-cov', |
| binaries=['/path/to/binary1', '/path/to/binary2'], |
| component_mapping=component_mapping, |
| sources=[], |
| diff_mapping=None) |
| |
| expected_compressed_components = [{ |
| 'dirs': [ |
| { |
| 'path': |
| '//dir1/', |
| 'name': |
| 'dir1/', |
| 'summaries': [{ |
| 'covered': 4, |
| 'total': 6, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 4, |
| 'total': 7, |
| 'name': 'line' |
| }] |
| }, |
| { |
| 'path': |
| '//dir2/', |
| 'name': |
| 'dir2/', |
| 'summaries': [{ |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'line' |
| }] |
| }, |
| ], |
| 'path': |
| 'Test>Component', |
| 'summaries': [{ |
| 'covered': 5, |
| 'total': 7, |
| 'name': 'region' |
| }, { |
| 'covered': 2, |
| 'total': 2, |
| 'name': 'function' |
| }, { |
| 'covered': 5, |
| 'total': 8, |
| 'name': 'line' |
| }] |
| }] |
| |
| self.maxDiff = None |
| self.assertListEqual(expected_compressed_components, |
| compressed_data['components']) |
| |
| expected_compressed_summaries = [{ |
| 'covered': 5, |
| 'total': 7, |
| 'name': 'region' |
| }, { |
| 'covered': 2, |
| 'total': 2, |
| 'name': 'function' |
| }, { |
| 'covered': 5, |
| 'total': 8, |
| 'name': 'line' |
| }] |
| |
| self.assertListEqual(expected_compressed_summaries, |
| compressed_data['summaries']) |
| |
| expected_compressed_dirs = [ |
| { |
| 'dirs': [ |
| { |
| 'path': |
| '//dir1/', |
| 'name': |
| 'dir1/', |
| 'summaries': [{ |
| 'covered': 4, |
| 'total': 6, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 4, |
| 'total': 7, |
| 'name': 'line' |
| }] |
| }, |
| { |
| 'path': |
| '//dir2/', |
| 'name': |
| 'dir2/', |
| 'summaries': [{ |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'line' |
| }] |
| }, |
| ], |
| 'files': [], |
| 'summaries': [{ |
| 'covered': 5, |
| 'total': 7, |
| 'name': 'region' |
| }, { |
| 'covered': 2, |
| 'total': 2, |
| 'name': 'function' |
| }, { |
| 'covered': 5, |
| 'total': 8, |
| 'name': 'line' |
| }], |
| 'path': |
| '//' |
| }, |
| { |
| 'dirs': [], |
| 'files': [{ |
| 'name': |
| 'file1.cc', |
| 'path': |
| '//dir1/file1.cc', |
| 'summaries': [{ |
| 'covered': 4, |
| 'total': 6, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 4, |
| 'total': 7, |
| 'name': 'line' |
| }] |
| }], |
| 'summaries': [{ |
| 'covered': 4, |
| 'total': 6, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 4, |
| 'total': 7, |
| 'name': 'line' |
| }], |
| 'path': |
| '//dir1/' |
| }, |
| { |
| 'dirs': [], |
| 'files': [{ |
| 'name': |
| 'file2.cc', |
| 'path': |
| '//dir2/file2.cc', |
| 'summaries': [{ |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'line' |
| }] |
| }], |
| 'summaries': [{ |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'region' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'function' |
| }, { |
| 'covered': 1, |
| 'total': 1, |
| 'name': 'line' |
| }], |
| 'path': |
| '//dir2/' |
| }, |
| ] |
| |
| self.assertListEqual(expected_compressed_dirs, compressed_data['dirs']) |
| |
| expected_compressed_files = [ |
| { |
| 'path': |
| '//dir1/file1.cc', |
| 'lines': [{ |
| 'count': 1, |
| 'last': 4, |
| 'first': 1, |
| }, { |
| 'count': 0, |
| 'last': 7, |
| 'first': 5, |
| }], |
| 'total_lines': |
| 7, |
| 'uncovered_blocks': [{ |
| 'ranges': [{ |
| 'last': 24, |
| 'first': 18, |
| }], |
| 'line': 2 |
| }], |
| 'revision': |
| 'hash1', |
| 'timestamp': |
| 1234, |
| }, |
| { |
| 'path': '//dir2/file2.cc', |
| 'lines': [{ |
| 'count': 1, |
| 'last': 1, |
| 'first': 1 |
| }], |
| 'total_lines': 1, |
| 'revision': 'hash2', |
| 'timestamp': 5678, |
| }, |
| ] |
| |
| self.assertListEqual(expected_compressed_files, compressed_data['files']) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
