#!/usr/bin/env python # # Copyright (C) 2016 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. # import math import os import struct import unittest from vts.utils.python.coverage import arc_summary from vts.utils.python.coverage import block_summary from vts.utils.python.coverage import function_summary from vts.utils.python.coverage import gcno_parser from vts.utils.python.coverage.parser_test import MockStream class GCNOParserTest(unittest.TestCase): """Tests for GCNO parser of vts.utils.python.coverage. Ensures error handling, byte order detection, and correct parsing of functions, blocks, arcs, and lines. """ def setUp(self): """Creates a stream for each test. """ self.stream = MockStream() def testReadFunction(self): """Asserts that the function is read correctly. Verifies that ident, name, source file name, and first line number are all read correctly. """ ident = 102010 self.stream = MockStream.concat_int(self.stream, ident) self.stream = MockStream.concat_int(self.stream, 0) self.stream = MockStream.concat_int(self.stream, 0) name = "TestFunction" src_file_name = "TestSouceFile.c" first_line_number = 102 self.stream = MockStream.concat_string(self.stream, name) self.stream = MockStream.concat_string(self.stream, src_file_name) self.stream = MockStream.concat_int(self.stream, first_line_number) parser = gcno_parser.GCNOParser(self.stream) summary = parser.ReadFunction() self.assertEqual(name, summary.name) self.assertEqual(ident, summary.ident) self.assertEqual(src_file_name, summary.src_file_name) self.assertEqual(first_line_number, summary.first_line_number) def testReadBlocks(self): """Asserts that blocks are correctly read from the stream. Tests correct values for flag and index. """ n_blocks = 10 func = function_summary.FunctionSummary(0, "func", "src.c", 1) for i in range(n_blocks): self.stream = MockStream.concat_int(self.stream, 3 * i) parser = gcno_parser.GCNOParser(self.stream) parser.ReadBlocks(n_blocks, func) self.assertEqual(len(func.blocks), n_blocks) for i in range(n_blocks): self.assertEqual(func.blocks[i].flag, 3 * i) self.assertEqual(func.blocks[i].index, i) def testReadArcsNormal(self): """Asserts that arcs are correctly read from the stream. Does not test the use of flags. Validates that arcs are created in both blocks and the source/destination are correct for each. """ n_blocks = 50 func = function_summary.FunctionSummary(0, "func", "src.c", 1) func.blocks = [block_summary.BlockSummary(i, 3 * i) for i in range(n_blocks)] src_block_index = 0 skip = 2 self.stream = MockStream.concat_int(self.stream, src_block_index) for i in range(src_block_index + 1, n_blocks, skip): self.stream = MockStream.concat_int(self.stream, i) self.stream = MockStream.concat_int( self.stream, 0) # no flag applied to the arc parser = gcno_parser.GCNOParser(self.stream) n_arcs = len(range(src_block_index + 1, n_blocks, skip)) parser.ReadArcs(n_arcs * 2 + 1, func) j = 0 for i in range(src_block_index + 1, n_blocks, skip): self.assertEqual( func.blocks[src_block_index].exit_arcs[j].src_block.index, src_block_index) self.assertEqual( func.blocks[src_block_index].exit_arcs[j].dst_block.index, i) self.assertEqual(func.blocks[i].entry_arcs[0].src_block.index, src_block_index) self.assertEqual(func.blocks[i].entry_arcs[0].dst_block.index, i) j += 1 def testReadArcFlags(self): """Asserts that arc flags are correctly interpreted. """ n_blocks = 5 func = function_summary.FunctionSummary(0, "func", "src.c", 1) func.blocks = [block_summary.BlockSummary(i, 3 * i) for i in range(n_blocks)] self.stream = MockStream.concat_int(self.stream, 0) # source block index self.stream = MockStream.concat_int(self.stream, 1) # normal arc self.stream = MockStream.concat_int(self.stream, 0) self.stream = MockStream.concat_int(self.stream, 2) # on-tree arc self.stream = MockStream.concat_int( self.stream, arc_summary.ArcSummary.GCOV_ARC_ON_TREE) self.stream = MockStream.concat_int(self.stream, 3) # fake arc self.stream = MockStream.concat_int( self.stream, arc_summary.ArcSummary.GCOV_ARC_FAKE) self.stream = MockStream.concat_int(self.stream, 4) # fallthrough arc self.stream = MockStream.concat_int( self.stream, arc_summary.ArcSummary.GCOV_ARC_FALLTHROUGH) parser = gcno_parser.GCNOParser(self.stream) parser.ReadArcs(4 * 2 + 1, func) self.assertFalse(func.blocks[0].exit_arcs[0].on_tree) self.assertFalse(func.blocks[0].exit_arcs[0].fake) self.assertFalse(func.blocks[0].exit_arcs[0].fallthrough) self.assertTrue(func.blocks[0].exit_arcs[1].on_tree) self.assertFalse(func.blocks[0].exit_arcs[1].fake) self.assertFalse(func.blocks[0].exit_arcs[1].fallthrough) self.assertFalse(func.blocks[0].exit_arcs[2].on_tree) self.assertTrue(func.blocks[0].exit_arcs[2].fake) self.assertFalse(func.blocks[0].exit_arcs[2].fallthrough) self.assertFalse(func.blocks[0].exit_arcs[3].on_tree) self.assertFalse(func.blocks[0].exit_arcs[3].fake) self.assertTrue(func.blocks[0].exit_arcs[3].fallthrough) def testReadLines(self): """Asserts that lines are read correctly. Blocks must have correct references to the lines contained in the block. """ self.stream = MockStream.concat_int(self.stream, 2) # block number self.stream = MockStream.concat_int(self.stream, 0) # dummy name = "src.c" name_length = int( math.ceil(1.0 * len(name) / MockStream.BYTES_PER_WORD)) + 1 self.stream = MockStream.concat_string(self.stream, name) n_arcs = 5 for i in range(1, n_arcs + 1): self.stream = MockStream.concat_int(self.stream, i) n_blocks = 5 func = function_summary.FunctionSummary(0, "func", name, 1) func.blocks = [block_summary.BlockSummary(i, 3 * i) for i in range(n_blocks)] parser = gcno_parser.GCNOParser(self.stream) parser.ReadLines(n_arcs + name_length + 3, func) self.assertEqual(len(func.blocks[2].lines), 5) self.assertEqual(func.blocks[2].lines, range(1, 6)) def testSampleFile(self): """Asserts correct parsing of sample GCNO file. Verifies the blocks and lines for each function in the file. """ path = os.path.join( os.getenv('ANDROID_BUILD_TOP'), 'test/vts/utils/python/coverage/testdata/sample.gcno') summary = gcno_parser.ParseGcnoFile(path) self.assertEqual(len(summary.functions), 2) # Check function: testFunctionName func = summary.functions[4] self.assertEqual(func.name, 'testFunctionName') self.assertEqual(func.src_file_name, 'sample.c') self.assertEqual(func.first_line_number, 35) self.assertEqual(len(func.blocks), 5) expected_list = [[], [], [35, 40, 41], [42], []] for index, expected in zip(range(5), expected_list): self.assertEqual(func.blocks[index].lines, expected) # Check function: main func = summary.functions[3] self.assertEqual(func.name, 'main') self.assertEqual(func.first_line_number, 5) self.assertEqual(len(func.blocks), 12) self.assertEqual(func.blocks[0].lines, []) expected_list = [[], [], [5, 11, 12, 13], [15], [17], [18], [20], [23, 24, 25], [26, 25], [], [29], [31]] for index, expected in zip(range(12), expected_list): self.assertEqual(func.blocks[index].lines, expected) if __name__ == "__main__": unittest.main()