普通文本  |  219行  |  8.82 KB

#!/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()