#!/usr/bin/python

# -*- coding: utf-8; -*-

#

# Copyright (C) 2009 Google Inc. All rights reserved.

# Copyright (C) 2009 Torch Mobile Inc.

# Copyright (C) 2009 Apple Inc. All rights reserved.

# Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are

# met:

#

#    * Redistributions of source code must retain the above copyright

# notice, this list of conditions and the following disclaimer.

#    * Redistributions in binary form must reproduce the above

# copyright notice, this list of conditions and the following disclaimer

# in the documentation and/or other materials provided with the

# distribution.

#    * Neither the name of Google Inc. nor the names of its

# contributors may be used to endorse or promote products derived from

# this software without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

"""Unit test for cpp_style.py."""

# FIXME: Add a good test that tests UpdateIncludeState.

import codecs

import os

import random

import re

import unittest

import cpp as cpp_style

from cpp import CppChecker

# This class works as an error collector and replaces cpp_style.Error

# function for the unit tests.  We also verify each category we see

# is in STYLE_CATEGORIES, to help keep that list up to date.

class ErrorCollector:

    _all_style_categories = CppChecker.categories

    # This is a list including all categories seen in any unit test.

    _seen_style_categories = {}

    def __init__(self, assert_fn):

        """assert_fn: a function to call when we notice a problem."""

        self._assert_fn = assert_fn

        self._errors = []

    def __call__(self, unused_linenum, category, confidence, message):

        self._assert_fn(category in self._all_style_categories,

                        'Message "%s" has category "%s",'

                        ' which is not in STYLE_CATEGORIES' % (message, category))

        self._seen_style_categories[category] = 1

        self._errors.append('%s  [%s] [%d]' % (message, category, confidence))

    def results(self):

        if len(self._errors) < 2:

            return ''.join(self._errors)  # Most tests expect to have a string.

        else:

            return self._errors  # Let's give a list if there is more than one.

    def result_list(self):

        return self._errors

    def verify_all_categories_are_seen(self):

        """Fails if there's a category in _all_style_categories - _seen_style_categories.

        This should only be called after all tests are run, so

        _seen_style_categories has had a chance to fully populate.  Since

        this isn't called from within the normal unittest framework, we

        can't use the normal unittest assert macros.  Instead we just exit

        when we see an error.  Good thing this test is always run last!

        """

        for category in self._all_style_categories:

            if category not in self._seen_style_categories:

                import sys

                sys.exit('FATAL ERROR: There are no tests for category "%s"' % category)

    def remove_if_present(self, substr):

        for (index, error) in enumerate(self._errors):

            if error.find(substr) != -1:

                self._errors = self._errors[0:index] + self._errors[(index + 1):]

                break

# This class is a lame mock of codecs. We do not verify filename, mode, or

# encoding, but for the current use case it is not needed.

class MockIo:

    def __init__(self, mock_file):

        self.mock_file = mock_file

    def open(self, unused_filename, unused_mode, unused_encoding, _):  # NOLINT

        # (lint doesn't like open as a method name)

        return self.mock_file

class CppFunctionsTest(unittest.TestCase):

    """Supports testing functions that do not need CppStyleTestBase."""

    def test_is_c_or_objective_c(self):

        self.assertTrue(cpp_style.is_c_or_objective_c("c"))

        self.assertTrue(cpp_style.is_c_or_objective_c("m"))

        self.assertFalse(cpp_style.is_c_or_objective_c("cpp"))

class CppStyleTestBase(unittest.TestCase):

    """Provides some useful helper functions for cpp_style tests.

    Attributes:

      min_confidence: An integer that is the current minimum confidence

                      level for the tests.

    """

    # FIXME: Refactor the unit tests so the confidence level is passed

    #        explicitly, just like it is in the real code.

    min_confidence = 1;

    # Helper function to avoid needing to explicitly pass confidence

    # in all the unit test calls to cpp_style.process_file_data().

    def process_file_data(self, filename, file_extension, lines, error):

        """Call cpp_style.process_file_data() with the min_confidence."""

        return cpp_style.process_file_data(filename, file_extension, lines,

                                           error, self.min_confidence)

    # Perform lint on single line of input and return the error message.

    def perform_single_line_lint(self, code, file_name):

        error_collector = ErrorCollector(self.assert_)

        lines = code.split('\n')

        cpp_style.remove_multi_line_comments(lines, error_collector)

        clean_lines = cpp_style.CleansedLines(lines)

        include_state = cpp_style._IncludeState()

        function_state = cpp_style._FunctionState(self.min_confidence)

        ext = file_name[file_name.rfind('.') + 1:]

        class_state = cpp_style._ClassState()

        file_state = cpp_style._FileState()

        cpp_style.process_line(file_name, ext, clean_lines, 0,

                               include_state, function_state,

                               class_state, file_state, error_collector)

        # Single-line lint tests are allowed to fail the 'unlintable function'

        # check.

        error_collector.remove_if_present(

            'Lint failed to find start of function body.')

        return error_collector.results()

    # Perform lint over multiple lines and return the error message.

    def perform_multi_line_lint(self, code, file_extension):

        error_collector = ErrorCollector(self.assert_)

        lines = code.split('\n')

        cpp_style.remove_multi_line_comments(lines, error_collector)

        lines = cpp_style.CleansedLines(lines)

        class_state = cpp_style._ClassState()

        file_state = cpp_style._FileState()

        for i in xrange(lines.num_lines()):

            cpp_style.check_style(lines, i, file_extension, file_state, error_collector)

            cpp_style.check_for_non_standard_constructs(lines, i, class_state,

                                                        error_collector)

        class_state.check_finished(error_collector)

        return error_collector.results()

    # Similar to perform_multi_line_lint, but calls check_language instead of

    # check_for_non_standard_constructs

    def perform_language_rules_check(self, file_name, code):

        error_collector = ErrorCollector(self.assert_)

        include_state = cpp_style._IncludeState()

        lines = code.split('\n')

        cpp_style.remove_multi_line_comments(lines, error_collector)

        lines = cpp_style.CleansedLines(lines)

        ext = file_name[file_name.rfind('.') + 1:]

        for i in xrange(lines.num_lines()):

            cpp_style.check_language(file_name, lines, i, ext, include_state,

                                     error_collector)

        return error_collector.results()

    def perform_function_lengths_check(self, code):

        """Perform Lint function length check on block of code and return warnings.

        Builds up an array of lines corresponding to the code and strips comments

        using cpp_style functions.

        Establishes an error collector and invokes the function length checking

        function following cpp_style's pattern.

        Args:

          code: C++ source code expected to generate a warning message.

        Returns:

          The accumulated errors.

        """

        error_collector = ErrorCollector(self.assert_)

        function_state = cpp_style._FunctionState(self.min_confidence)

        lines = code.split('\n')

        cpp_style.remove_multi_line_comments(lines, error_collector)

        lines = cpp_style.CleansedLines(lines)

        for i in xrange(lines.num_lines()):

            cpp_style.check_for_function_lengths(lines, i,

                                                 function_state, error_collector)

        return error_collector.results()

    def perform_include_what_you_use(self, code, filename='foo.h', io=codecs):

        # First, build up the include state.

        error_collector = ErrorCollector(self.assert_)

        include_state = cpp_style._IncludeState()

        lines = code.split('\n')

        cpp_style.remove_multi_line_comments(lines, error_collector)

        lines = cpp_style.CleansedLines(lines)

        file_extension = filename[filename.rfind('.') + 1:]

        for i in xrange(lines.num_lines()):

            cpp_style.check_language(filename, lines, i, file_extension, include_state,

                                     error_collector)

        # We could clear the error_collector here, but this should

        # also be fine, since our IncludeWhatYouUse unittests do not

        # have language problems.

        # Second, look for missing includes.

        cpp_style.check_for_include_what_you_use(filename, lines, include_state,

                                                 error_collector, io)

        return error_collector.results()

    # Perform lint and compare the error message with "expected_message".

    def assert_lint(self, code, expected_message, file_name='foo.cpp'):

        self.assertEquals(expected_message, self.perform_single_line_lint(code, file_name))

    def assert_lint_one_of_many_errors_re(self, code, expected_message_re, file_name='foo.cpp'):

        messages = self.perform_single_line_lint(code, file_name)

        for message in messages:

            if re.search(expected_message_re, message):

                return

        self.assertEquals(expected_message_re, messages)

    def assert_multi_line_lint(self, code, expected_message, file_name='foo.h'):

        file_extension = file_name[file_name.rfind('.') + 1:]

        self.assertEquals(expected_message, self.perform_multi_line_lint(code, file_extension))

    def assert_multi_line_lint_re(self, code, expected_message_re, file_name='foo.h'):

        file_extension = file_name[file_name.rfind('.') + 1:]

        message = self.perform_multi_line_lint(code, file_extension)

        if not re.search(expected_message_re, message):

            self.fail('Message was:\n' + message + 'Expected match to "' + expected_message_re + '"')

    def assert_language_rules_check(self, file_name, code, expected_message):

        self.assertEquals(expected_message,

                          self.perform_language_rules_check(file_name, code))

    def assert_include_what_you_use(self, code, expected_message):

        self.assertEquals(expected_message,

                          self.perform_include_what_you_use(code))

    def assert_blank_lines_check(self, lines, start_errors, end_errors):

        error_collector = ErrorCollector(self.assert_)

        self.process_file_data('foo.cpp', 'cpp', lines, error_collector)

        self.assertEquals(

            start_errors,

            error_collector.results().count(

                'Blank line at the start of a code block.  Is this needed?'

                '  [whitespace/blank_line] [2]'))

        self.assertEquals(

            end_errors,

            error_collector.results().count(

                'Blank line at the end of a code block.  Is this needed?'

                '  [whitespace/blank_line] [3]'))

class CppStyleTest(CppStyleTestBase):

    # Test get line width.

    def test_get_line_width(self):

        self.assertEquals(0, cpp_style.get_line_width(''))

        self.assertEquals(10, cpp_style.get_line_width(u'x' * 10))

        self.assertEquals(16, cpp_style.get_line_width(u'都|道|府|県|支庁'))

    def test_find_next_multi_line_comment_start(self):

        self.assertEquals(1, cpp_style.find_next_multi_line_comment_start([''], 0))

        lines = ['a', 'b', '/* c']

        self.assertEquals(2, cpp_style.find_next_multi_line_comment_start(lines, 0))

        lines = ['char a[] = "/*";']  # not recognized as comment.

        self.assertEquals(1, cpp_style.find_next_multi_line_comment_start(lines, 0))

    def test_find_next_multi_line_comment_end(self):

        self.assertEquals(1, cpp_style.find_next_multi_line_comment_end([''], 0))

        lines = ['a', 'b', ' c */']

        self.assertEquals(2, cpp_style.find_next_multi_line_comment_end(lines, 0))

    def test_remove_multi_line_comments_from_range(self):

        lines = ['a', '  /* comment ', ' * still comment', ' comment */   ', 'b']

        cpp_style.remove_multi_line_comments_from_range(lines, 1, 4)

        self.assertEquals(['a', '// dummy', '// dummy', '// dummy', 'b'], lines)

    def test_spaces_at_end_of_line(self):

        self.assert_lint(

            '// Hello there ',

            'Line ends in whitespace.  Consider deleting these extra spaces.'

            '  [whitespace/end_of_line] [4]')

    # Test C-style cast cases.

    def test_cstyle_cast(self):

        self.assert_lint(

            'int a = (int)1.0;',

            'Using C-style cast.  Use static_cast<int>(...) instead'

            '  [readability/casting] [4]')

        self.assert_lint(

            'int *a = (int *)DEFINED_VALUE;',

            'Using C-style cast.  Use reinterpret_cast<int *>(...) instead'

            '  [readability/casting] [4]', 'foo.c')

        self.assert_lint(

            'uint16 a = (uint16)1.0;',

            'Using C-style cast.  Use static_cast<uint16>(...) instead'

            '  [readability/casting] [4]')

        self.assert_lint(

            'int32 a = (int32)1.0;',

            'Using C-style cast.  Use static_cast<int32>(...) instead'

            '  [readability/casting] [4]')

        self.assert_lint(

            'uint64 a = (uint64)1.0;',

            'Using C-style cast.  Use static_cast<uint64>(...) instead'

            '  [readability/casting] [4]')

    # Test taking address of casts (runtime/casting)

    def test_runtime_casting(self):

        self.assert_lint(

            'int* x = &static_cast<int*>(foo);',

            'Are you taking an address of a cast?  '

            'This is dangerous: could be a temp var.  '

            'Take the address before doing the cast, rather than after'

            '  [runtime/casting] [4]')

        self.assert_lint(

            'int* x = &dynamic_cast<int *>(foo);',

            ['Are you taking an address of a cast?  '

             'This is dangerous: could be a temp var.  '

             'Take the address before doing the cast, rather than after'

             '  [runtime/casting] [4]',

             'Do not use dynamic_cast<>.  If you need to cast within a class '

             'hierarchy, use static_cast<> to upcast.  Google doesn\'t support '

             'RTTI.  [runtime/rtti] [5]'])

        self.assert_lint(

            'int* x = &reinterpret_cast<int *>(foo);',

            'Are you taking an address of a cast?  '

            'This is dangerous: could be a temp var.  '

            'Take the address before doing the cast, rather than after'

            '  [runtime/casting] [4]')

        # It's OK to cast an address.

        self.assert_lint(

            'int* x = reinterpret_cast<int *>(&foo);',

            '')

    def test_runtime_selfinit(self):

        self.assert_lint(

            'Foo::Foo(Bar r, Bel l) : r_(r_), l_(l_) { }',

            'You seem to be initializing a member variable with itself.'

            '  [runtime/init] [4]')

        self.assert_lint(

            'Foo::Foo(Bar r, Bel l) : r_(r), l_(l) { }',

            '')

        self.assert_lint(

            'Foo::Foo(Bar r) : r_(r), l_(r_), ll_(l_) { }',

            '')

    def test_runtime_rtti(self):

        statement = 'int* x = dynamic_cast<int*>(&foo);'

        error_message = (

            'Do not use dynamic_cast<>.  If you need to cast within a class '

            'hierarchy, use static_cast<> to upcast.  Google doesn\'t support '

            'RTTI.  [runtime/rtti] [5]')

        # dynamic_cast is disallowed in most files.

        self.assert_language_rules_check('foo.cpp', statement, error_message)

        self.assert_language_rules_check('foo.h', statement, error_message)

    # We cannot test this functionality because of difference of

    # function definitions.  Anyway, we may never enable this.

    #

    # # Test for unnamed arguments in a method.

    # def test_check_for_unnamed_params(self):

    #   message = ('All parameters should be named in a function'

    #              '  [readability/function] [3]')

    #   self.assert_lint('virtual void A(int*) const;', message)

    #   self.assert_lint('virtual void B(void (*fn)(int*));', message)

    #   self.assert_lint('virtual void C(int*);', message)

    #   self.assert_lint('void *(*f)(void *) = x;', message)

    #   self.assert_lint('void Method(char*) {', message)

    #   self.assert_lint('void Method(char*);', message)

    #   self.assert_lint('void Method(char* /*x*/);', message)

    #   self.assert_lint('typedef void (*Method)(int32);', message)

    #   self.assert_lint('static void operator delete[](void*) throw();', message)

    # 

    #   self.assert_lint('virtual void D(int* p);', '')

    #   self.assert_lint('void operator delete(void* x) throw();', '')

    #   self.assert_lint('void Method(char* x)\n{', '')

    #   self.assert_lint('void Method(char* /*x*/)\n{', '')

    #   self.assert_lint('void Method(char* x);', '')

    #   self.assert_lint('typedef void (*Method)(int32 x);', '')

    #   self.assert_lint('static void operator delete[](void* x) throw();', '')

    #   self.assert_lint('static void operator delete[](void* /*x*/) throw();', '')

    # 

    #   # This one should technically warn, but doesn't because the function

    #   # pointer is confusing.

    #   self.assert_lint('virtual void E(void (*fn)(int* p));', '')

    # Test deprecated casts such as int(d)

    def test_deprecated_cast(self):

        self.assert_lint(

            'int a = int(2.2);',

            'Using deprecated casting style.  '

            'Use static_cast<int>(...) instead'

            '  [readability/casting] [4]')

        # Checks for false positives...

        self.assert_lint(

            'int a = int(); // Constructor, o.k.',

            '')

        self.assert_lint(

            'X::X() : a(int()) {} // default Constructor, o.k.',

            '')

        self.assert_lint(

            'operator bool(); // Conversion operator, o.k.',

            '')

    # The second parameter to a gMock method definition is a function signature

    # that often looks like a bad cast but should not picked up by lint.

    def test_mock_method(self):

        self.assert_lint(

            'MOCK_METHOD0(method, int());',

            '')

        self.assert_lint(

            'MOCK_CONST_METHOD1(method, float(string));',

            '')

        self.assert_lint(

            'MOCK_CONST_METHOD2_T(method, double(float, float));',

            '')

    # Test sizeof(type) cases.

    def test_sizeof_type(self):

        self.assert_lint(

            'sizeof(int);',

            'Using sizeof(type).  Use sizeof(varname) instead if possible'

            '  [runtime/sizeof] [1]')

        self.assert_lint(

            'sizeof(int *);',

            'Using sizeof(type).  Use sizeof(varname) instead if possible'

            '  [runtime/sizeof] [1]')

    # Test typedef cases.  There was a bug that cpp_style misidentified

    # typedef for pointer to function as C-style cast and produced

    # false-positive error messages.

    def test_typedef_for_pointer_to_function(self):

        self.assert_lint(

            'typedef void (*Func)(int x);',

            '')

        self.assert_lint(

            'typedef void (*Func)(int *x);',

            '')

        self.assert_lint(

            'typedef void Func(int x);',

            '')

        self.assert_lint(

            'typedef void Func(int *x);',

            '')

    def test_include_what_you_use_no_implementation_files(self):

        code = 'std::vector<int> foo;'

        self.assertEquals('Add #include <vector> for vector<>'

                          '  [build/include_what_you_use] [4]',

                          self.perform_include_what_you_use(code, 'foo.h'))

        self.assertEquals('',

                          self.perform_include_what_you_use(code, 'foo.cpp'))

    def test_include_what_you_use(self):

        self.assert_include_what_you_use(

            '''#include <vector>

               std::vector<int> foo;

            ''',

            '')

        self.assert_include_what_you_use(

            '''#include <map>

               std::pair<int,int> foo;

            ''',

            '')

        self.assert_include_what_you_use(

            '''#include <multimap>

               std::pair<int,int> foo;

            ''',

            '')

        self.assert_include_what_you_use(

            '''#include <hash_map>

               std::pair<int,int> foo;

            ''',

            '')

        self.assert_include_what_you_use(

            '''#include <utility>

               std::pair<int,int> foo;

            ''',

            '')

        self.assert_include_what_you_use(

            '''#include <vector>

               DECLARE_string(foobar);

            ''',

            '')

        self.assert_include_what_you_use(

            '''#include <vector>

               DEFINE_string(foobar, "", "");

            ''',

            '')

        self.assert_include_what_you_use(

            '''#include <vector>

               std::pair<int,int> foo;

            ''',

            'Add #include <utility> for pair<>'

            '  [build/include_what_you_use] [4]')

        self.assert_include_what_you_use(

            '''#include "base/foobar.h"

               std::vector<int> foo;

            ''',