| #!/usr/bin/env python3 |
| # Copyright (c) 2012 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 io |
| import os.path |
| import subprocess |
| import unittest |
| |
| import PRESUBMIT |
| |
| from PRESUBMIT_test_mocks import MockFile, MockAffectedFile |
| from PRESUBMIT_test_mocks import MockInputApi, MockOutputApi |
| |
| |
| _TEST_DATA_DIR = 'base/test/data/presubmit' |
| |
| |
| class VersionControlConflictsTest(unittest.TestCase): |
| def testTypicalConflict(self): |
| lines = ['<<<<<<< HEAD', |
| ' base::ScopedTempDir temp_dir_;', |
| '=======', |
| ' ScopedTempDir temp_dir_;', |
| '>>>>>>> master'] |
| errors = PRESUBMIT._CheckForVersionControlConflictsInFile( |
| MockInputApi(), MockFile('some/path/foo_platform.cc', lines)) |
| self.assertEqual(3, len(errors)) |
| self.assertTrue('1' in errors[0]) |
| self.assertTrue('3' in errors[1]) |
| self.assertTrue('5' in errors[2]) |
| |
| def testIgnoresReadmes(self): |
| lines = ['A First Level Header', |
| '====================', |
| '', |
| 'A Second Level Header', |
| '---------------------'] |
| errors = PRESUBMIT._CheckForVersionControlConflictsInFile( |
| MockInputApi(), MockFile('some/polymer/README.md', lines)) |
| self.assertEqual(0, len(errors)) |
| |
| |
| class BadExtensionsTest(unittest.TestCase): |
| def testBadRejFile(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('some/path/foo.cc', ''), |
| MockFile('some/path/foo.cc.rej', ''), |
| MockFile('some/path2/bar.h.rej', ''), |
| ] |
| |
| results = PRESUBMIT.CheckPatchFiles(mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertEqual(2, len(results[0].items)) |
| self.assertTrue('foo.cc.rej' in results[0].items[0]) |
| self.assertTrue('bar.h.rej' in results[0].items[1]) |
| |
| def testBadOrigFile(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('other/path/qux.h.orig', ''), |
| MockFile('other/path/qux.h', ''), |
| MockFile('other/path/qux.cc', ''), |
| ] |
| |
| results = PRESUBMIT.CheckPatchFiles(mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertEqual(1, len(results[0].items)) |
| self.assertTrue('qux.h.orig' in results[0].items[0]) |
| |
| def testGoodFiles(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('other/path/qux.h', ''), |
| MockFile('other/path/qux.cc', ''), |
| ] |
| results = PRESUBMIT.CheckPatchFiles(mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| |
| class CheckForSuperfluousStlIncludesInHeadersTest(unittest.TestCase): |
| def testGoodFiles(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| # The check is not smart enough to figure out which definitions correspond |
| # to which header. |
| MockFile('other/path/foo.h', |
| ['#include <string>', |
| 'std::vector']), |
| # The check is not smart enough to do IWYU. |
| MockFile('other/path/bar.h', |
| ['#include "base/check.h"', |
| 'std::vector']), |
| MockFile('other/path/qux.h', |
| ['#include "base/stl_util.h"', |
| 'foobar']), |
| MockFile('other/path/baz.h', |
| ['#include "set/vector.h"', |
| 'bazzab']), |
| # The check is only for header files. |
| MockFile('other/path/not_checked.cc', |
| ['#include <vector>', |
| 'bazbaz']), |
| ] |
| results = PRESUBMIT.CheckForSuperfluousStlIncludesInHeaders( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| def testBadFiles(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('other/path/foo.h', |
| ['#include <vector>', |
| 'vector']), |
| MockFile('other/path/bar.h', |
| ['#include <limits>', |
| '#include <set>', |
| 'no_std_namespace']), |
| ] |
| results = PRESUBMIT.CheckForSuperfluousStlIncludesInHeaders( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertTrue('foo.h: Includes STL' in results[0].message) |
| self.assertTrue('bar.h: Includes STL' in results[0].message) |
| |
| |
| class CheckSingletonInHeadersTest(unittest.TestCase): |
| def testSingletonInArbitraryHeader(self): |
| diff_singleton_h = ['base::subtle::AtomicWord ' |
| 'base::Singleton<Type, Traits, DifferentiatingType>::'] |
| diff_foo_h = ['// base::Singleton<Foo> in comment.', |
| 'friend class base::Singleton<Foo>'] |
| diff_foo2_h = [' //Foo* bar = base::Singleton<Foo>::get();'] |
| diff_bad_h = ['Foo* foo = base::Singleton<Foo>::get();'] |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [MockAffectedFile('base/memory/singleton.h', |
| diff_singleton_h), |
| MockAffectedFile('foo.h', diff_foo_h), |
| MockAffectedFile('foo2.h', diff_foo2_h), |
| MockAffectedFile('bad.h', diff_bad_h)] |
| warnings = PRESUBMIT.CheckSingletonInHeaders(mock_input_api, |
| MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertEqual(1, len(warnings[0].items)) |
| self.assertEqual('error', warnings[0].type) |
| self.assertTrue('Found base::Singleton<T>' in warnings[0].message) |
| |
| def testSingletonInCC(self): |
| diff_cc = ['Foo* foo = base::Singleton<Foo>::get();'] |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [MockAffectedFile('some/path/foo.cc', diff_cc)] |
| warnings = PRESUBMIT.CheckSingletonInHeaders(mock_input_api, |
| MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| |
| class DeprecatedOSMacroNamesTest(unittest.TestCase): |
| def testDeprecatedOSMacroNames(self): |
| lines = ['#if defined(OS_WIN)', |
| ' #elif defined(OS_WINDOW)', |
| ' # if defined(OS_MAC) || defined(OS_CHROME)'] |
| errors = PRESUBMIT._CheckForDeprecatedOSMacrosInFile( |
| MockInputApi(), MockFile('some/path/foo_platform.cc', lines)) |
| self.assertEqual(len(lines) + 1, len(errors)) |
| self.assertTrue(':1: defined(OS_WIN) -> BUILDFLAG(IS_WIN)' in errors[0]) |
| |
| |
| class InvalidIfDefinedMacroNamesTest(unittest.TestCase): |
| def testInvalidIfDefinedMacroNames(self): |
| lines = ['#if defined(TARGET_IPHONE_SIMULATOR)', |
| '#if !defined(TARGET_IPHONE_SIMULATOR)', |
| '#elif defined(TARGET_IPHONE_SIMULATOR)', |
| '#ifdef TARGET_IPHONE_SIMULATOR', |
| ' # ifdef TARGET_IPHONE_SIMULATOR', |
| '# if defined(VALID) || defined(TARGET_IPHONE_SIMULATOR)', |
| '# else // defined(TARGET_IPHONE_SIMULATOR)', |
| '#endif // defined(TARGET_IPHONE_SIMULATOR)'] |
| errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile( |
| MockInputApi(), MockFile('some/path/source.mm', lines)) |
| self.assertEqual(len(lines), len(errors)) |
| |
| def testValidIfDefinedMacroNames(self): |
| lines = ['#if defined(FOO)', |
| '#ifdef BAR'] |
| errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile( |
| MockInputApi(), MockFile('some/path/source.cc', lines)) |
| self.assertEqual(0, len(errors)) |
| |
| |
| class CheckAddedDepsHaveTestApprovalsTest(unittest.TestCase): |
| |
| def calculate(self, old_include_rules, old_specific_include_rules, |
| new_include_rules, new_specific_include_rules): |
| return PRESUBMIT._CalculateAddedDeps( |
| os.path, 'include_rules = %r\nspecific_include_rules = %r' % ( |
| old_include_rules, old_specific_include_rules), |
| 'include_rules = %r\nspecific_include_rules = %r' % ( |
| new_include_rules, new_specific_include_rules)) |
| |
| def testCalculateAddedDeps(self): |
| old_include_rules = [ |
| '+base', |
| '-chrome', |
| '+content', |
| '-grit', |
| '-grit/",', |
| '+jni/fooblat.h', |
| '!sandbox', |
| ] |
| old_specific_include_rules = { |
| 'compositor\.*': { |
| '+cc', |
| }, |
| } |
| |
| new_include_rules = [ |
| '-ash', |
| '+base', |
| '+chrome', |
| '+components', |
| '+content', |
| '+grit', |
| '+grit/generated_resources.h",', |
| '+grit/",', |
| '+jni/fooblat.h', |
| '+policy', |
| '+' + os.path.join('third_party', 'WebKit'), |
| ] |
| new_specific_include_rules = { |
| 'compositor\.*': { |
| '+cc', |
| }, |
| 'widget\.*': { |
| '+gpu', |
| }, |
| } |
| |
| expected = set([ |
| os.path.join('chrome', 'DEPS'), |
| os.path.join('gpu', 'DEPS'), |
| os.path.join('components', 'DEPS'), |
| os.path.join('policy', 'DEPS'), |
| os.path.join('third_party', 'WebKit', 'DEPS'), |
| ]) |
| self.assertEqual( |
| expected, |
| self.calculate(old_include_rules, old_specific_include_rules, |
| new_include_rules, new_specific_include_rules)) |
| |
| def testCalculateAddedDepsIgnoresPermutations(self): |
| old_include_rules = [ |
| '+base', |
| '+chrome', |
| ] |
| new_include_rules = [ |
| '+chrome', |
| '+base', |
| ] |
| self.assertEqual(set(), |
| self.calculate(old_include_rules, {}, new_include_rules, |
| {})) |
| |
| |
| class JSONParsingTest(unittest.TestCase): |
| def testSuccess(self): |
| input_api = MockInputApi() |
| filename = 'valid_json.json' |
| contents = ['// This is a comment.', |
| '{', |
| ' "key1": ["value1", "value2"],', |
| ' "key2": 3 // This is an inline comment.', |
| '}' |
| ] |
| input_api.files = [MockFile(filename, contents)] |
| self.assertEqual(None, |
| PRESUBMIT._GetJSONParseError(input_api, filename)) |
| |
| def testFailure(self): |
| input_api = MockInputApi() |
| test_data = [ |
| ('invalid_json_1.json', |
| ['{ x }'], |
| 'Expecting property name'), |
| ('invalid_json_2.json', |
| ['// Hello world!', |
| '{ "hello": "world }'], |
| 'Unterminated string starting at:'), |
| ('invalid_json_3.json', |
| ['{ "a": "b", "c": "d", }'], |
| 'Expecting property name'), |
| ('invalid_json_4.json', |
| ['{ "a": "b" "c": "d" }'], |
| "Expecting ',' delimiter:"), |
| ] |
| |
| input_api.files = [MockFile(filename, contents) |
| for (filename, contents, _) in test_data] |
| |
| for (filename, _, expected_error) in test_data: |
| actual_error = PRESUBMIT._GetJSONParseError(input_api, filename) |
| self.assertTrue(expected_error in str(actual_error), |
| "'%s' not found in '%s'" % (expected_error, actual_error)) |
| |
| def testNoEatComments(self): |
| input_api = MockInputApi() |
| file_with_comments = 'file_with_comments.json' |
| contents_with_comments = ['// This is a comment.', |
| '{', |
| ' "key1": ["value1", "value2"],', |
| ' "key2": 3 // This is an inline comment.', |
| '}' |
| ] |
| file_without_comments = 'file_without_comments.json' |
| contents_without_comments = ['{', |
| ' "key1": ["value1", "value2"],', |
| ' "key2": 3', |
| '}' |
| ] |
| input_api.files = [MockFile(file_with_comments, contents_with_comments), |
| MockFile(file_without_comments, |
| contents_without_comments)] |
| |
| self.assertNotEqual(None, |
| str(PRESUBMIT._GetJSONParseError(input_api, |
| file_with_comments, |
| eat_comments=False))) |
| self.assertEqual(None, |
| PRESUBMIT._GetJSONParseError(input_api, |
| file_without_comments, |
| eat_comments=False)) |
| |
| |
| class IDLParsingTest(unittest.TestCase): |
| def testSuccess(self): |
| input_api = MockInputApi() |
| filename = 'valid_idl_basics.idl' |
| contents = ['// Tests a valid IDL file.', |
| 'namespace idl_basics {', |
| ' enum EnumType {', |
| ' name1,', |
| ' name2', |
| ' };', |
| '', |
| ' dictionary MyType1 {', |
| ' DOMString a;', |
| ' };', |
| '', |
| ' callback Callback1 = void();', |
| ' callback Callback2 = void(long x);', |
| ' callback Callback3 = void(MyType1 arg);', |
| ' callback Callback4 = void(EnumType type);', |
| '', |
| ' interface Functions {', |
| ' static void function1();', |
| ' static void function2(long x);', |
| ' static void function3(MyType1 arg);', |
| ' static void function4(Callback1 cb);', |
| ' static void function5(Callback2 cb);', |
| ' static void function6(Callback3 cb);', |
| ' static void function7(Callback4 cb);', |
| ' };', |
| '', |
| ' interface Events {', |
| ' static void onFoo1();', |
| ' static void onFoo2(long x);', |
| ' static void onFoo2(MyType1 arg);', |
| ' static void onFoo3(EnumType type);', |
| ' };', |
| '};' |
| ] |
| input_api.files = [MockFile(filename, contents)] |
| self.assertEqual(None, |
| PRESUBMIT._GetIDLParseError(input_api, filename)) |
| |
| def testFailure(self): |
| input_api = MockInputApi() |
| test_data = [ |
| ('invalid_idl_1.idl', |
| ['//', |
| 'namespace test {', |
| ' dictionary {', |
| ' DOMString s;', |
| ' };', |
| '};'], |
| 'Unexpected "{" after keyword "dictionary".\n'), |
| # TODO(yoz): Disabled because it causes the IDL parser to hang. |
| # See crbug.com/363830. |
| # ('invalid_idl_2.idl', |
| # (['namespace test {', |
| # ' dictionary MissingSemicolon {', |
| # ' DOMString a', |
| # ' DOMString b;', |
| # ' };', |
| # '};'], |
| # 'Unexpected symbol DOMString after symbol a.'), |
| ('invalid_idl_3.idl', |
| ['//', |
| 'namespace test {', |
| ' enum MissingComma {', |
| ' name1', |
| ' name2', |
| ' };', |
| '};'], |
| 'Unexpected symbol name2 after symbol name1.'), |
| ('invalid_idl_4.idl', |
| ['//', |
| 'namespace test {', |
| ' enum TrailingComma {', |
| ' name1,', |
| ' name2,', |
| ' };', |
| '};'], |
| 'Trailing comma in block.'), |
| ('invalid_idl_5.idl', |
| ['//', |
| 'namespace test {', |
| ' callback Callback1 = void(;', |
| '};'], |
| 'Unexpected ";" after "(".'), |
| ('invalid_idl_6.idl', |
| ['//', |
| 'namespace test {', |
| ' callback Callback1 = void(long );', |
| '};'], |
| 'Unexpected ")" after symbol long.'), |
| ('invalid_idl_7.idl', |
| ['//', |
| 'namespace test {', |
| ' interace Events {', |
| ' static void onFoo1();', |
| ' };', |
| '};'], |
| 'Unexpected symbol Events after symbol interace.'), |
| ('invalid_idl_8.idl', |
| ['//', |
| 'namespace test {', |
| ' interface NotEvent {', |
| ' static void onFoo1();', |
| ' };', |
| '};'], |
| 'Did not process Interface Interface(NotEvent)'), |
| ('invalid_idl_9.idl', |
| ['//', |
| 'namespace test {', |
| ' interface {', |
| ' static void function1();', |
| ' };', |
| '};'], |
| 'Interface missing name.'), |
| ] |
| |
| input_api.files = [MockFile(filename, contents) |
| for (filename, contents, _) in test_data] |
| |
| for (filename, _, expected_error) in test_data: |
| actual_error = PRESUBMIT._GetIDLParseError(input_api, filename) |
| self.assertTrue(expected_error in str(actual_error), |
| "'%s' not found in '%s'" % (expected_error, actual_error)) |
| |
| |
| class UserMetricsActionTest(unittest.TestCase): |
| def testUserMetricsActionInActions(self): |
| input_api = MockInputApi() |
| file_with_user_action = 'file_with_user_action.cc' |
| contents_with_user_action = [ |
| 'base::UserMetricsAction("AboutChrome")' |
| ] |
| |
| input_api.files = [MockFile(file_with_user_action, |
| contents_with_user_action)] |
| |
| self.assertEqual( |
| [], PRESUBMIT.CheckUserActionUpdate(input_api, MockOutputApi())) |
| |
| def testUserMetricsActionNotAddedToActions(self): |
| input_api = MockInputApi() |
| file_with_user_action = 'file_with_user_action.cc' |
| contents_with_user_action = [ |
| 'base::UserMetricsAction("NotInActionsXml")' |
| ] |
| |
| input_api.files = [MockFile(file_with_user_action, |
| contents_with_user_action)] |
| |
| output = PRESUBMIT.CheckUserActionUpdate(input_api, MockOutputApi()) |
| self.assertEqual( |
| ('File %s line %d: %s is missing in ' |
| 'tools/metrics/actions/actions.xml. Please run ' |
| 'tools/metrics/actions/extract_actions.py to update.' |
| % (file_with_user_action, 1, 'NotInActionsXml')), |
| output[0].message) |
| |
| def testUserMetricsActionInTestFile(self): |
| input_api = MockInputApi() |
| file_with_user_action = 'file_with_user_action_unittest.cc' |
| contents_with_user_action = [ |
| 'base::UserMetricsAction("NotInActionsXml")' |
| ] |
| |
| input_api.files = [MockFile(file_with_user_action, |
| contents_with_user_action)] |
| |
| self.assertEqual( |
| [], PRESUBMIT.CheckUserActionUpdate(input_api, MockOutputApi())) |
| |
| |
| class PydepsNeedsUpdatingTest(unittest.TestCase): |
| class MockPopen: |
| def __init__(self, stdout_func): |
| self._stdout_func = stdout_func |
| |
| def wait(self): |
| self.stdout = io.StringIO(self._stdout_func()) |
| return 0 |
| |
| class MockSubprocess: |
| CalledProcessError = subprocess.CalledProcessError |
| PIPE = 0 |
| |
| def __init__(self): |
| self._popen_func = None |
| |
| def SetPopenCallback(self, func): |
| self._popen_func = func |
| |
| def Popen(self, cmd, *args, **kwargs): |
| return PydepsNeedsUpdatingTest.MockPopen(lambda: self._popen_func(cmd)) |
| |
| def _MockParseGclientArgs(self, is_android=True): |
| return lambda: {'checkout_android': 'true' if is_android else 'false' } |
| |
| def setUp(self): |
| mock_all_pydeps = ['A.pydeps', 'B.pydeps', 'D.pydeps'] |
| self.old_ALL_PYDEPS_FILES = PRESUBMIT._ALL_PYDEPS_FILES |
| PRESUBMIT._ALL_PYDEPS_FILES = mock_all_pydeps |
| mock_android_pydeps = ['D.pydeps'] |
| self.old_ANDROID_SPECIFIC_PYDEPS_FILES = ( |
| PRESUBMIT._ANDROID_SPECIFIC_PYDEPS_FILES) |
| PRESUBMIT._ANDROID_SPECIFIC_PYDEPS_FILES = mock_android_pydeps |
| self.old_ParseGclientArgs = PRESUBMIT._ParseGclientArgs |
| PRESUBMIT._ParseGclientArgs = self._MockParseGclientArgs() |
| self.mock_input_api = MockInputApi() |
| self.mock_output_api = MockOutputApi() |
| self.mock_input_api.subprocess = PydepsNeedsUpdatingTest.MockSubprocess() |
| self.checker = PRESUBMIT.PydepsChecker(self.mock_input_api, mock_all_pydeps) |
| self.checker._file_cache = { |
| 'A.pydeps': '# Generated by:\n# CMD --output A.pydeps A\nA.py\nC.py\n', |
| 'B.pydeps': '# Generated by:\n# CMD --output B.pydeps B\nB.py\nC.py\n', |
| 'D.pydeps': '# Generated by:\n# CMD --output D.pydeps D\nD.py\n', |
| } |
| |
| def tearDown(self): |
| PRESUBMIT._ALL_PYDEPS_FILES = self.old_ALL_PYDEPS_FILES |
| PRESUBMIT._ANDROID_SPECIFIC_PYDEPS_FILES = ( |
| self.old_ANDROID_SPECIFIC_PYDEPS_FILES) |
| PRESUBMIT._ParseGclientArgs = self.old_ParseGclientArgs |
| |
| def _RunCheck(self): |
| return PRESUBMIT.CheckPydepsNeedsUpdating(self.mock_input_api, |
| self.mock_output_api, |
| checker_for_tests=self.checker) |
| |
| def testAddedPydep(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile('new.pydeps', [], action='A'), |
| ] |
| |
| self.mock_input_api.CreateMockFileInPath( |
| [x.LocalPath() for x in self.mock_input_api.AffectedFiles( |
| include_deletes=True)]) |
| results = self._RunCheck() |
| self.assertEqual(1, len(results)) |
| self.assertIn('PYDEPS_FILES', str(results[0])) |
| |
| def testPydepNotInSrc(self): |
| self.mock_input_api.files = [ |
| MockAffectedFile('new.pydeps', [], action='A'), |
| ] |
| self.mock_input_api.CreateMockFileInPath([]) |
| results = self._RunCheck() |
| self.assertEqual(0, len(results)) |
| |
| def testRemovedPydep(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile(PRESUBMIT._ALL_PYDEPS_FILES[0], [], action='D'), |
| ] |
| self.mock_input_api.CreateMockFileInPath( |
| [x.LocalPath() for x in self.mock_input_api.AffectedFiles( |
| include_deletes=True)]) |
| results = self._RunCheck() |
| self.assertEqual(1, len(results)) |
| self.assertIn('PYDEPS_FILES', str(results[0])) |
| |
| def testRandomPyIgnored(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile('random.py', []), |
| ] |
| |
| results = self._RunCheck() |
| self.assertEqual(0, len(results), 'Unexpected results: %r' % results) |
| |
| def testRelevantPyNoChange(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile('A.py', []), |
| ] |
| |
| def popen_callback(cmd): |
| self.assertEqual('CMD --output A.pydeps A --output ""', cmd) |
| return self.checker._file_cache['A.pydeps'] |
| |
| self.mock_input_api.subprocess.SetPopenCallback(popen_callback) |
| |
| results = self._RunCheck() |
| self.assertEqual(0, len(results), 'Unexpected results: %r' % results) |
| |
| def testRelevantPyOneChange(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile('A.py', []), |
| ] |
| |
| def popen_callback(cmd): |
| self.assertEqual('CMD --output A.pydeps A --output ""', cmd) |
| return 'changed data' |
| |
| self.mock_input_api.subprocess.SetPopenCallback(popen_callback) |
| |
| results = self._RunCheck() |
| self.assertEqual(1, len(results)) |
| # Check that --output "" is not included. |
| self.assertNotIn('""', str(results[0])) |
| self.assertIn('File is stale', str(results[0])) |
| |
| def testRelevantPyTwoChanges(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile('C.py', []), |
| ] |
| |
| def popen_callback(cmd): |
| return 'changed data' |
| |
| self.mock_input_api.subprocess.SetPopenCallback(popen_callback) |
| |
| results = self._RunCheck() |
| self.assertEqual(2, len(results)) |
| self.assertIn('File is stale', str(results[0])) |
| self.assertIn('File is stale', str(results[1])) |
| |
| def testRelevantAndroidPyInNonAndroidCheckout(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile('D.py', []), |
| ] |
| |
| def popen_callback(cmd): |
| self.assertEqual('CMD --output D.pydeps D --output ""', cmd) |
| return 'changed data' |
| |
| self.mock_input_api.subprocess.SetPopenCallback(popen_callback) |
| PRESUBMIT._ParseGclientArgs = self._MockParseGclientArgs(is_android=False) |
| |
| results = self._RunCheck() |
| self.assertEqual(1, len(results)) |
| self.assertIn('Android', str(results[0])) |
| self.assertIn('D.pydeps', str(results[0])) |
| |
| def testGnPathsAndMissingOutputFlag(self): |
| # PRESUBMIT.CheckPydepsNeedsUpdating is only implemented for Linux. |
| if not self.mock_input_api.platform.startswith('linux'): |
| return [] |
| |
| self.checker._file_cache = { |
| 'A.pydeps': '# Generated by:\n# CMD --gn-paths A\n//A.py\n//C.py\n', |
| 'B.pydeps': '# Generated by:\n# CMD --gn-paths B\n//B.py\n//C.py\n', |
| 'D.pydeps': '# Generated by:\n# CMD --gn-paths D\n//D.py\n', |
| } |
| |
| self.mock_input_api.files = [ |
| MockAffectedFile('A.py', []), |
| ] |
| |
| def popen_callback(cmd): |
| self.assertEqual('CMD --gn-paths A --output A.pydeps --output ""', cmd) |
| return 'changed data' |
| |
| self.mock_input_api.subprocess.SetPopenCallback(popen_callback) |
| |
| results = self._RunCheck() |
| self.assertEqual(1, len(results)) |
| self.assertIn('File is stale', str(results[0])) |
| |
| |
| class IncludeGuardTest(unittest.TestCase): |
| def testIncludeGuardChecks(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('content/browser/thing/foo.h', [ |
| '// Comment', |
| '#ifndef CONTENT_BROWSER_THING_FOO_H_', |
| '#define CONTENT_BROWSER_THING_FOO_H_', |
| 'struct McBoatFace;', |
| '#endif // CONTENT_BROWSER_THING_FOO_H_', |
| ]), |
| MockAffectedFile('content/browser/thing/bar.h', [ |
| '#ifndef CONTENT_BROWSER_THING_BAR_H_', |
| '#define CONTENT_BROWSER_THING_BAR_H_', |
| 'namespace content {', |
| '#endif // CONTENT_BROWSER_THING_BAR_H_', |
| '} // namespace content', |
| ]), |
| MockAffectedFile('content/browser/test1.h', [ |
| 'namespace content {', |
| '} // namespace content', |
| ]), |
| MockAffectedFile('content\\browser\\win.h', [ |
| '#ifndef CONTENT_BROWSER_WIN_H_', |
| '#define CONTENT_BROWSER_WIN_H_', |
| 'struct McBoatFace;', |
| '#endif // CONTENT_BROWSER_WIN_H_', |
| ]), |
| MockAffectedFile('content/browser/test2.h', [ |
| '// Comment', |
| '#ifndef CONTENT_BROWSER_TEST2_H_', |
| 'struct McBoatFace;', |
| '#endif // CONTENT_BROWSER_TEST2_H_', |
| ]), |
| MockAffectedFile('content/browser/internal.h', [ |
| '// Comment', |
| '#ifndef CONTENT_BROWSER_INTERNAL_H_', |
| '#define CONTENT_BROWSER_INTERNAL_H_', |
| '// Comment', |
| '#ifndef INTERNAL_CONTENT_BROWSER_INTERNAL_H_', |
| '#define INTERNAL_CONTENT_BROWSER_INTERNAL_H_', |
| 'namespace internal {', |
| '} // namespace internal', |
| '#endif // INTERNAL_CONTENT_BROWSER_THING_BAR_H_', |
| 'namespace content {', |
| '} // namespace content', |
| '#endif // CONTENT_BROWSER_THING_BAR_H_', |
| ]), |
| MockAffectedFile('content/browser/thing/foo.cc', [ |
| '// This is a non-header.', |
| ]), |
| MockAffectedFile('content/browser/disabled.h', [ |
| '// no-include-guard-because-multiply-included', |
| 'struct McBoatFace;', |
| ]), |
| # New files don't allow misspelled include guards. |
| MockAffectedFile('content/browser/spleling.h', [ |
| '#ifndef CONTENT_BROWSER_SPLLEING_H_', |
| '#define CONTENT_BROWSER_SPLLEING_H_', |
| 'struct McBoatFace;', |
| '#endif // CONTENT_BROWSER_SPLLEING_H_', |
| ]), |
| # New files don't allow + in include guards. |
| MockAffectedFile('content/browser/foo+bar.h', [ |
| '#ifndef CONTENT_BROWSER_FOO+BAR_H_', |
| '#define CONTENT_BROWSER_FOO+BAR_H_', |
| 'struct McBoatFace;', |
| '#endif // CONTENT_BROWSER_FOO+BAR_H_', |
| ]), |
| # Old files allow misspelled include guards (for now). |
| MockAffectedFile('chrome/old.h', [ |
| '// New contents', |
| '#ifndef CHROME_ODL_H_', |
| '#define CHROME_ODL_H_', |
| '#endif // CHROME_ODL_H_', |
| ], [ |
| '// Old contents', |
| '#ifndef CHROME_ODL_H_', |
| '#define CHROME_ODL_H_', |
| '#endif // CHROME_ODL_H_', |
| ]), |
| # Using a Blink style include guard outside Blink is wrong. |
| MockAffectedFile('content/NotInBlink.h', [ |
| '#ifndef NotInBlink_h', |
| '#define NotInBlink_h', |
| 'struct McBoatFace;', |
| '#endif // NotInBlink_h', |
| ]), |
| # Using a Blink style include guard in Blink is no longer ok. |
| MockAffectedFile('third_party/blink/InBlink.h', [ |
| '#ifndef InBlink_h', |
| '#define InBlink_h', |
| 'struct McBoatFace;', |
| '#endif // InBlink_h', |
| ]), |
| # Using a bad include guard in Blink is not ok. |
| MockAffectedFile('third_party/blink/AlsoInBlink.h', [ |
| '#ifndef WrongInBlink_h', |
| '#define WrongInBlink_h', |
| 'struct McBoatFace;', |
| '#endif // WrongInBlink_h', |
| ]), |
| # Using a bad include guard in Blink is not accepted even if |
| # it's an old file. |
| MockAffectedFile('third_party/blink/StillInBlink.h', [ |
| '// New contents', |
| '#ifndef AcceptedInBlink_h', |
| '#define AcceptedInBlink_h', |
| 'struct McBoatFace;', |
| '#endif // AcceptedInBlink_h', |
| ], [ |
| '// Old contents', |
| '#ifndef AcceptedInBlink_h', |
| '#define AcceptedInBlink_h', |
| 'struct McBoatFace;', |
| '#endif // AcceptedInBlink_h', |
| ]), |
| # Using a non-Chromium include guard in third_party |
| # (outside blink) is accepted. |
| MockAffectedFile('third_party/foo/some_file.h', [ |
| '#ifndef REQUIRED_RPCNDR_H_', |
| '#define REQUIRED_RPCNDR_H_', |
| 'struct SomeFileFoo;', |
| '#endif // REQUIRED_RPCNDR_H_', |
| ]), |
| # Not having proper include guard in *_message_generator.h |
| # for old IPC messages is allowed. |
| MockAffectedFile('content/common/content_message_generator.h', [ |
| '#undef CONTENT_COMMON_FOO_MESSAGES_H_', |
| '#include "content/common/foo_messages.h"', |
| '#ifndef CONTENT_COMMON_FOO_MESSAGES_H_', |
| '#error "Failed to include content/common/foo_messages.h"', |
| '#endif', |
| ]), |
| ] |
| msgs = PRESUBMIT.CheckForIncludeGuards( |
| mock_input_api, mock_output_api) |
| expected_fail_count = 8 |
| self.assertEqual(expected_fail_count, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (expected_fail_count, len(msgs), msgs)) |
| self.assertEqual(msgs[0].items, ['content/browser/thing/bar.h']) |
| self.assertEqual(msgs[0].message, |
| 'Include guard CONTENT_BROWSER_THING_BAR_H_ ' |
| 'not covering the whole file') |
| |
| self.assertIn('content/browser/test1.h', msgs[1].message) |
| self.assertIn('Recommended name: CONTENT_BROWSER_TEST1_H_', |
| msgs[1].message) |
| |
| self.assertEqual(msgs[2].items, ['content/browser/test2.h:3']) |
| self.assertEqual(msgs[2].message, |
| 'Missing "#define CONTENT_BROWSER_TEST2_H_" for ' |
| 'include guard') |
| |
| self.assertEqual(msgs[3].items, ['content/browser/spleling.h:1']) |
| self.assertEqual(msgs[3].message, |
| 'Header using the wrong include guard name ' |
| 'CONTENT_BROWSER_SPLLEING_H_') |
| |
| self.assertIn('content/browser/foo+bar.h', msgs[4].message) |
| self.assertIn('Recommended name: CONTENT_BROWSER_FOO_BAR_H_', |
| msgs[4].message) |
| |
| self.assertEqual(msgs[5].items, ['content/NotInBlink.h:1']) |
| self.assertEqual(msgs[5].message, |
| 'Header using the wrong include guard name ' |
| 'NotInBlink_h') |
| |
| self.assertEqual(msgs[6].items, ['third_party/blink/InBlink.h:1']) |
| self.assertEqual(msgs[6].message, |
| 'Header using the wrong include guard name ' |
| 'InBlink_h') |
| |
| self.assertEqual(msgs[7].items, ['third_party/blink/AlsoInBlink.h:1']) |
| self.assertEqual(msgs[7].message, |
| 'Header using the wrong include guard name ' |
| 'WrongInBlink_h') |
| |
| class AccessibilityRelnotesFieldTest(unittest.TestCase): |
| def testRelnotesPresent(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [MockAffectedFile('ui/accessibility/foo.bar', [''])] |
| mock_input_api.change.DescriptionText = lambda : 'Commit description' |
| mock_input_api.change.footers['AX-Relnotes'] = [ |
| 'Important user facing change'] |
| |
| msgs = PRESUBMIT.CheckAccessibilityRelnotesField( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| def testRelnotesMissingFromAccessibilityChange(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('some/file', ['']), |
| MockAffectedFile('ui/accessibility/foo.bar', ['']), |
| MockAffectedFile('some/other/file', ['']) |
| ] |
| mock_input_api.change.DescriptionText = lambda : 'Commit description' |
| |
| msgs = PRESUBMIT.CheckAccessibilityRelnotesField( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (1, len(msgs), msgs)) |
| self.assertTrue("Missing 'AX-Relnotes:' field" in msgs[0].message, |
| 'Missing AX-Relnotes field message not found in errors') |
| |
| # The relnotes footer is not required for changes which do not touch any |
| # accessibility directories. |
| def testIgnoresNonAccesssibilityCode(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('some/file', ['']), |
| MockAffectedFile('some/other/file', ['']) |
| ] |
| mock_input_api.change.DescriptionText = lambda : 'Commit description' |
| |
| msgs = PRESUBMIT.CheckAccessibilityRelnotesField( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that our presubmit correctly raises an error for a set of known paths. |
| def testExpectedPaths(self): |
| filesToTest = [ |
| "chrome/browser/accessibility/foo.py", |
| "chrome/browser/ash/arc/accessibility/foo.cc", |
| "chrome/browser/ui/views/accessibility/foo.h", |
| "chrome/browser/extensions/api/automation/foo.h", |
| "chrome/browser/extensions/api/automation_internal/foo.cc", |
| "chrome/renderer/extensions/accessibility_foo.h", |
| "chrome/tests/data/accessibility/foo.html", |
| "content/browser/accessibility/foo.cc", |
| "content/renderer/accessibility/foo.h", |
| "content/tests/data/accessibility/foo.cc", |
| "extensions/renderer/api/automation/foo.h", |
| "ui/accessibility/foo/bar/baz.cc", |
| "ui/views/accessibility/foo/bar/baz.h", |
| ] |
| |
| for testFile in filesToTest: |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile(testFile, ['']) |
| ] |
| mock_input_api.change.DescriptionText = lambda : 'Commit description' |
| |
| msgs = PRESUBMIT.CheckAccessibilityRelnotesField( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d messages, found %d: %s, for file %s' |
| % (1, len(msgs), msgs, testFile)) |
| self.assertTrue("Missing 'AX-Relnotes:' field" in msgs[0].message, |
| ('Missing AX-Relnotes field message not found in errors ' |
| ' for file %s' % (testFile))) |
| |
| # Test that AX-Relnotes field can appear in the commit description (as long |
| # as it appears at the beginning of a line). |
| def testRelnotesInCommitDescription(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('ui/accessibility/foo.bar', ['']), |
| ] |
| mock_input_api.change.DescriptionText = lambda : ('Description:\n' + |
| 'AX-Relnotes: solves all accessibility issues forever') |
| |
| msgs = PRESUBMIT.CheckAccessibilityRelnotesField( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that we don't match AX-Relnotes if it appears in the middle of a line. |
| def testRelnotesMustAppearAtBeginningOfLine(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('ui/accessibility/foo.bar', ['']), |
| ] |
| mock_input_api.change.DescriptionText = lambda : ('Description:\n' + |
| 'This change has no AX-Relnotes: we should print a warning') |
| |
| msgs = PRESUBMIT.CheckAccessibilityRelnotesField( |
| mock_input_api, mock_output_api) |
| self.assertTrue("Missing 'AX-Relnotes:' field" in msgs[0].message, |
| 'Missing AX-Relnotes field message not found in errors') |
| |
| # Tests that the AX-Relnotes field can be lowercase and use a '=' in place |
| # of a ':'. |
| def testRelnotesLowercaseWithEqualSign(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('ui/accessibility/foo.bar', ['']), |
| ] |
| mock_input_api.change.DescriptionText = lambda : ('Description:\n' + |
| 'ax-relnotes= this is a valid format for accessibiliy relnotes') |
| |
| msgs = PRESUBMIT.CheckAccessibilityRelnotesField( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| class AccessibilityEventsTestsAreIncludedForAndroidTest(unittest.TestCase): |
| # Test that no warning is raised when the Android file is also modified. |
| def testAndroidChangeIncluded(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/event/foo.html', |
| [''], action='A'), |
| MockAffectedFile( |
| 'accessibility/WebContentsAccessibilityEventsTest.java', |
| [''], action='M') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityEventsTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that a warning is raised when the Android file is not modified. |
| def testAndroidChangeMissing(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/event/foo.html', |
| [''], action='A'), |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityEventsTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (1, len(msgs), msgs)) |
| |
| # Test that Android change is not required when no html file is added/removed. |
| def testIgnoreNonHtmlFiles(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/event/foo.txt', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/event/foo.cc', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/event/foo.h', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/event/foo.py', |
| [''], action='A') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityEventsTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that Android change is not required for unrelated html files. |
| def testIgnoreNonRelatedHtmlFiles(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/aria/foo.html', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/html/foo.html', |
| [''], action='A'), |
| MockAffectedFile('chrome/tests/data/accessibility/foo.html', |
| [''], action='A') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityEventsTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that only modifying an html file will not trigger the warning. |
| def testIgnoreModifiedFiles(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/event/foo.html', |
| [''], action='M') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityEventsTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that deleting an html file will trigger the warning. |
| def testAndroidChangeMissingOnDeletedFile(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/event/foo.html', |
| [], action='D') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityEventsTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (1, len(msgs), msgs)) |
| |
| class AccessibilityTreeTestsAreIncludedForAndroidTest(unittest.TestCase): |
| # Test that no warning is raised when the Android file is also modified. |
| def testAndroidChangeIncluded(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/aria/foo.html', |
| [''], action='A'), |
| MockAffectedFile( |
| 'accessibility/WebContentsAccessibilityTreeTest.java', |
| [''], action='M') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityTreeTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that no warning is raised when the Android file is also modified. |
| def testAndroidChangeIncludedManyFiles(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/accname/foo.html', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/aria/foo.html', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/css/foo.html', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/html/foo.html', |
| [''], action='A'), |
| MockAffectedFile( |
| 'accessibility/WebContentsAccessibilityTreeTest.java', |
| [''], action='M') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityTreeTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that a warning is raised when the Android file is not modified. |
| def testAndroidChangeMissing(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/aria/foo.html', |
| [''], action='A'), |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityTreeTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (1, len(msgs), msgs)) |
| |
| # Test that Android change is not required when no html file is added/removed. |
| def testIgnoreNonHtmlFiles(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/accname/foo.txt', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/aria/foo.cc', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/css/foo.h', |
| [''], action='A'), |
| MockAffectedFile('content/test/data/accessibility/tree/foo.py', |
| [''], action='A') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityTreeTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that Android change is not required for unrelated html files. |
| def testIgnoreNonRelatedHtmlFiles(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/event/foo.html', |
| [''], action='A'), |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityTreeTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that only modifying an html file will not trigger the warning. |
| def testIgnoreModifiedFiles(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/aria/foo.html', |
| [''], action='M') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityTreeTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| # Test that deleting an html file will trigger the warning. |
| def testAndroidChangeMissingOnDeletedFile(self): |
| mock_input_api = MockInputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('content/test/data/accessibility/accname/foo.html', |
| [], action='D') |
| ] |
| |
| msgs = PRESUBMIT.CheckAccessibilityTreeTestsAreIncludedForAndroid( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d messages, found %d: %s' |
| % (1, len(msgs), msgs)) |
| |
| class AndroidDeprecatedTestAnnotationTest(unittest.TestCase): |
| def testCheckAndroidTestAnnotationUsage(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('LalaLand.java', [ |
| 'random stuff' |
| ]), |
| MockAffectedFile('CorrectUsage.java', [ |
| 'import android.support.test.filters.LargeTest;', |
| 'import android.support.test.filters.MediumTest;', |
| 'import android.support.test.filters.SmallTest;', |
| ]), |
| MockAffectedFile('UsedDeprecatedLargeTestAnnotation.java', [ |
| 'import android.test.suitebuilder.annotation.LargeTest;', |
| ]), |
| MockAffectedFile('UsedDeprecatedMediumTestAnnotation.java', [ |
| 'import android.test.suitebuilder.annotation.MediumTest;', |
| ]), |
| MockAffectedFile('UsedDeprecatedSmallTestAnnotation.java', [ |
| 'import android.test.suitebuilder.annotation.SmallTest;', |
| ]), |
| MockAffectedFile('UsedDeprecatedSmokeAnnotation.java', [ |
| 'import android.test.suitebuilder.annotation.Smoke;', |
| ]) |
| ] |
| msgs = PRESUBMIT._CheckAndroidTestAnnotationUsage( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (1, len(msgs), msgs)) |
| self.assertEqual(4, len(msgs[0].items), |
| 'Expected %d items, found %d: %s' |
| % (4, len(msgs[0].items), msgs[0].items)) |
| self.assertTrue('UsedDeprecatedLargeTestAnnotation.java:1' in msgs[0].items, |
| 'UsedDeprecatedLargeTestAnnotation not found in errors') |
| self.assertTrue('UsedDeprecatedMediumTestAnnotation.java:1' |
| in msgs[0].items, |
| 'UsedDeprecatedMediumTestAnnotation not found in errors') |
| self.assertTrue('UsedDeprecatedSmallTestAnnotation.java:1' in msgs[0].items, |
| 'UsedDeprecatedSmallTestAnnotation not found in errors') |
| self.assertTrue('UsedDeprecatedSmokeAnnotation.java:1' in msgs[0].items, |
| 'UsedDeprecatedSmokeAnnotation not found in errors') |
| |
| |
| class CheckNoDownstreamDepsTest(unittest.TestCase): |
| def testInvalidDepFromUpstream(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('BUILD.gn', [ |
| 'deps = [', |
| ' "//clank/target:test",', |
| ']' |
| ]), |
| MockAffectedFile('chrome/android/BUILD.gn', [ |
| 'deps = [ "//clank/target:test" ]' |
| ]), |
| MockAffectedFile('chrome/chrome_java_deps.gni', [ |
| 'java_deps = [', |
| ' "//clank/target:test",', |
| ']' |
| ]), |
| ] |
| mock_input_api.change.RepositoryRoot = lambda: 'chromium/src' |
| msgs = PRESUBMIT.CheckNoUpstreamDepsOnClank( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (1, len(msgs), msgs)) |
| self.assertEqual(3, len(msgs[0].items), |
| 'Expected %d items, found %d: %s' |
| % (3, len(msgs[0].items), msgs[0].items)) |
| self.assertTrue(any('BUILD.gn:2' in item for item in msgs[0].items), |
| 'BUILD.gn not found in errors') |
| self.assertTrue( |
| any('chrome/android/BUILD.gn:1' in item for item in msgs[0].items), |
| 'chrome/android/BUILD.gn:1 not found in errors') |
| self.assertTrue( |
| any('chrome/chrome_java_deps.gni:2' in item for item in msgs[0].items), |
| 'chrome/chrome_java_deps.gni:2 not found in errors') |
| |
| def testAllowsComments(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('BUILD.gn', [ |
| '# real implementation in //clank/target:test', |
| ]), |
| ] |
| mock_input_api.change.RepositoryRoot = lambda: 'chromium/src' |
| msgs = PRESUBMIT.CheckNoUpstreamDepsOnClank( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| def testOnlyChecksBuildFiles(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('README.md', [ |
| 'DEPS = [ "//clank/target:test" ]' |
| ]), |
| MockAffectedFile('chrome/android/java/file.java', [ |
| '//clank/ only function' |
| ]), |
| ] |
| mock_input_api.change.RepositoryRoot = lambda: 'chromium/src' |
| msgs = PRESUBMIT.CheckNoUpstreamDepsOnClank( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| def testValidDepFromDownstream(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('BUILD.gn', [ |
| 'DEPS = [', |
| ' "//clank/target:test",', |
| ']' |
| ]), |
| MockAffectedFile('java/BUILD.gn', [ |
| 'DEPS = [ "//clank/target:test" ]' |
| ]), |
| ] |
| mock_input_api.change.RepositoryRoot = lambda: 'chromium/src/clank' |
| msgs = PRESUBMIT.CheckNoUpstreamDepsOnClank( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (0, len(msgs), msgs)) |
| |
| class AndroidDeprecatedJUnitFrameworkTest(unittest.TestCase): |
| def testCheckAndroidTestJUnitFramework(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('LalaLand.java', [ |
| 'random stuff' |
| ]), |
| MockAffectedFile('CorrectUsage.java', [ |
| 'import org.junit.ABC', |
| 'import org.junit.XYZ;', |
| ]), |
| MockAffectedFile('UsedDeprecatedJUnit.java', [ |
| 'import junit.framework.*;', |
| ]), |
| MockAffectedFile('UsedDeprecatedJUnitAssert.java', [ |
| 'import junit.framework.Assert;', |
| ]), |
| ] |
| msgs = PRESUBMIT._CheckAndroidTestJUnitFrameworkImport( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (1, len(msgs), msgs)) |
| self.assertEqual(2, len(msgs[0].items), |
| 'Expected %d items, found %d: %s' |
| % (2, len(msgs[0].items), msgs[0].items)) |
| self.assertTrue('UsedDeprecatedJUnit.java:1' in msgs[0].items, |
| 'UsedDeprecatedJUnit.java not found in errors') |
| self.assertTrue('UsedDeprecatedJUnitAssert.java:1' |
| in msgs[0].items, |
| 'UsedDeprecatedJUnitAssert not found in errors') |
| |
| |
| class AndroidJUnitBaseClassTest(unittest.TestCase): |
| def testCheckAndroidTestJUnitBaseClass(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('LalaLand.java', [ |
| 'random stuff' |
| ]), |
| MockAffectedFile('CorrectTest.java', [ |
| '@RunWith(ABC.class);' |
| 'public class CorrectTest {', |
| '}', |
| ]), |
| MockAffectedFile('HistoricallyIncorrectTest.java', [ |
| 'public class Test extends BaseCaseA {', |
| '}', |
| ], old_contents=[ |
| 'public class Test extends BaseCaseB {', |
| '}', |
| ]), |
| MockAffectedFile('CorrectTestWithInterface.java', [ |
| '@RunWith(ABC.class);' |
| 'public class CorrectTest implement Interface {', |
| '}', |
| ]), |
| MockAffectedFile('IncorrectTest.java', [ |
| 'public class IncorrectTest extends TestCase {', |
| '}', |
| ]), |
| MockAffectedFile('IncorrectWithInterfaceTest.java', [ |
| 'public class Test implements X extends BaseClass {', |
| '}', |
| ]), |
| MockAffectedFile('IncorrectMultiLineTest.java', [ |
| 'public class Test implements X, Y, Z', |
| ' extends TestBase {', |
| '}', |
| ]), |
| ] |
| msgs = PRESUBMIT._CheckAndroidTestJUnitInheritance( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (1, len(msgs), msgs)) |
| self.assertEqual(3, len(msgs[0].items), |
| 'Expected %d items, found %d: %s' |
| % (3, len(msgs[0].items), msgs[0].items)) |
| self.assertTrue('IncorrectTest.java:1' in msgs[0].items, |
| 'IncorrectTest not found in errors') |
| self.assertTrue('IncorrectWithInterfaceTest.java:1' |
| in msgs[0].items, |
| 'IncorrectWithInterfaceTest not found in errors') |
| self.assertTrue('IncorrectMultiLineTest.java:2' in msgs[0].items, |
| 'IncorrectMultiLineTest not found in errors') |
| |
| class AndroidDebuggableBuildTest(unittest.TestCase): |
| |
| def testCheckAndroidDebuggableBuild(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('RandomStuff.java', [ |
| 'random stuff' |
| ]), |
| MockAffectedFile('CorrectUsage.java', [ |
| 'import org.chromium.base.BuildInfo;', |
| 'some random stuff', |
| 'boolean isOsDebuggable = BuildInfo.isDebugAndroid();', |
| ]), |
| MockAffectedFile('JustCheckUserdebugBuild.java', [ |
| 'import android.os.Build;', |
| 'some random stuff', |
| 'boolean isOsDebuggable = Build.TYPE.equals("userdebug")', |
| ]), |
| MockAffectedFile('JustCheckEngineeringBuild.java', [ |
| 'import android.os.Build;', |
| 'some random stuff', |
| 'boolean isOsDebuggable = "eng".equals(Build.TYPE)', |
| ]), |
| MockAffectedFile('UsedBuildType.java', [ |
| 'import android.os.Build;', |
| 'some random stuff', |
| 'boolean isOsDebuggable = Build.TYPE.equals("userdebug")' |
| '|| "eng".equals(Build.TYPE)', |
| ]), |
| MockAffectedFile('UsedExplicitBuildType.java', [ |
| 'some random stuff', |
| 'boolean isOsDebuggable = android.os.Build.TYPE.equals("userdebug")' |
| '|| "eng".equals(android.os.Build.TYPE)', |
| ]), |
| ] |
| |
| msgs = PRESUBMIT._CheckAndroidDebuggableBuild( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(msgs), |
| 'Expected %d items, found %d: %s' |
| % (1, len(msgs), msgs)) |
| self.assertEqual(4, len(msgs[0].items), |
| 'Expected %d items, found %d: %s' |
| % (4, len(msgs[0].items), msgs[0].items)) |
| self.assertTrue('JustCheckUserdebugBuild.java:3' in msgs[0].items) |
| self.assertTrue('JustCheckEngineeringBuild.java:3' in msgs[0].items) |
| self.assertTrue('UsedBuildType.java:3' in msgs[0].items) |
| self.assertTrue('UsedExplicitBuildType.java:2' in msgs[0].items) |
| |
| |
| class LogUsageTest(unittest.TestCase): |
| |
| def testCheckAndroidCrLogUsage(self): |
| mock_input_api = MockInputApi() |
| mock_output_api = MockOutputApi() |
| |
| mock_input_api.files = [ |
| MockAffectedFile('RandomStuff.java', [ |
| 'random stuff' |
| ]), |
| MockAffectedFile('HasAndroidLog.java', [ |
| 'import android.util.Log;', |
| 'some random stuff', |
| 'Log.d("TAG", "foo");', |
| ]), |
| MockAffectedFile('HasExplicitUtilLog.java', [ |
| 'some random stuff', |
| 'android.util.Log.d("TAG", "foo");', |
| ]), |
| MockAffectedFile('IsInBasePackage.java', [ |
| 'package org.chromium.base;', |
| 'private static final String TAG = "cr_Foo";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('IsInBasePackageButImportsLog.java', [ |
| 'package org.chromium.base;', |
| 'import android.util.Log;', |
| 'private static final String TAG = "cr_Foo";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasBothLog.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "cr_Foo";', |
| 'Log.d(TAG, "foo");', |
| 'android.util.Log.d("TAG", "foo");', |
| ]), |
| MockAffectedFile('HasCorrectTag.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "cr_Foo";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasOldTag.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "cr.Foo";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasDottedTag.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "cr_foo.bar";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasDottedTagPublic.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'public static final String TAG = "cr_foo.bar";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasNoTagDecl.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasIncorrectTagDecl.java', [ |
| 'import org.chromium.base.Log;', |
| 'private static final String TAHG = "cr_Foo";', |
| 'some random stuff', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasInlineTag.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "cr_Foo";', |
| 'Log.d("TAG", "foo");', |
| ]), |
| MockAffectedFile('HasInlineTagWithSpace.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "cr_Foo";', |
| 'Log.d("log message", "foo");', |
| ]), |
| MockAffectedFile('HasUnprefixedTag.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "rubbish";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasTooLongTag.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "21_charachers_long___";', |
| 'Log.d(TAG, "foo");', |
| ]), |
| MockAffectedFile('HasTooLongTagWithNoLogCallsInDiff.java', [ |
| 'import org.chromium.base.Log;', |
| 'some random stuff', |
| 'private static final String TAG = "21_charachers_long___";', |
| ]), |
| ] |
| |
| msgs = PRESUBMIT._CheckAndroidCrLogUsage( |
| mock_input_api, mock_output_api) |
| |
| self.assertEqual(5, len(msgs), |
| 'Expected %d items, found %d: %s' % (5, len(msgs), msgs)) |
| |
| # Declaration format |
| nb = len(msgs[0].items) |
| self.assertEqual(2, nb, |
| 'Expected %d items, found %d: %s' % (2, nb, msgs[0].items)) |
| self.assertTrue('HasNoTagDecl.java' in msgs[0].items) |
| self.assertTrue('HasIncorrectTagDecl.java' in msgs[0].items) |
| |
| # Tag length |
| nb = len(msgs[1].items) |
| self.assertEqual(2, nb, |
| 'Expected %d items, found %d: %s' % (2, nb, msgs[1].items)) |
| self.assertTrue('HasTooLongTag.java' in msgs[1].items) |
| self.assertTrue('HasTooLongTagWithNoLogCallsInDiff.java' in msgs[1].items) |
| |
| # Tag must be a variable named TAG |
| nb = len(msgs[2].items) |
| self.assertEqual(3, nb, |
| 'Expected %d items, found %d: %s' % (3, nb, msgs[2].items)) |
| self.assertTrue('HasBothLog.java:5' in msgs[2].items) |
| self.assertTrue('HasInlineTag.java:4' in msgs[2].items) |
| self.assertTrue('HasInlineTagWithSpace.java:4' in msgs[2].items) |
| |
| # Util Log usage |
| nb = len(msgs[3].items) |
| self.assertEqual(3, nb, |
| 'Expected %d items, found %d: %s' % (3, nb, msgs[3].items)) |
| self.assertTrue('HasAndroidLog.java:3' in msgs[3].items) |
| self.assertTrue('HasExplicitUtilLog.java:2' in msgs[3].items) |
| self.assertTrue('IsInBasePackageButImportsLog.java:4' in msgs[3].items) |
| |
| # Tag must not contain |
| nb = len(msgs[4].items) |
| self.assertEqual(3, nb, |
| 'Expected %d items, found %d: %s' % (2, nb, msgs[4].items)) |
| self.assertTrue('HasDottedTag.java' in msgs[4].items) |
| self.assertTrue('HasDottedTagPublic.java' in msgs[4].items) |
| self.assertTrue('HasOldTag.java' in msgs[4].items) |
| |
| |
| class GoogleAnswerUrlFormatTest(unittest.TestCase): |
| |
| def testCatchAnswerUrlId(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('somewhere/file.cc', |
| ['char* host = ' |
| ' "https://support.google.com/chrome/answer/123456";']), |
| MockFile('somewhere_else/file.cc', |
| ['char* host = ' |
| ' "https://support.google.com/chrome/a/answer/123456";']), |
| ] |
| |
| warnings = PRESUBMIT.CheckGoogleSupportAnswerUrlOnUpload( |
| input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertEqual(2, len(warnings[0].items)) |
| |
| def testAllowAnswerUrlParam(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('somewhere/file.cc', |
| ['char* host = ' |
| ' "https://support.google.com/chrome/?p=cpn_crash_reports";']), |
| ] |
| |
| warnings = PRESUBMIT.CheckGoogleSupportAnswerUrlOnUpload( |
| input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| |
| class HardcodedGoogleHostsTest(unittest.TestCase): |
| |
| def testWarnOnAssignedLiterals(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('content/file.cc', |
| ['char* host = "https://www.google.com";']), |
| MockFile('content/file.cc', |
| ['char* host = "https://www.googleapis.com";']), |
| MockFile('content/file.cc', |
| ['char* host = "https://clients1.google.com";']), |
| ] |
| |
| warnings = PRESUBMIT.CheckHardcodedGoogleHostsInLowerLayers( |
| input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertEqual(3, len(warnings[0].items)) |
| |
| def testAllowInComment(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('content/file.cc', |
| ['char* host = "https://www.aol.com"; // google.com']) |
| ] |
| |
| warnings = PRESUBMIT.CheckHardcodedGoogleHostsInLowerLayers( |
| input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| |
| class ChromeOsSyncedPrefRegistrationTest(unittest.TestCase): |
| |
| def testWarnsOnChromeOsDirectories(self): |
| files = [ |
| MockFile('ash/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| MockFile('chrome/browser/chromeos/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| MockFile('chromeos/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| MockFile('components/arc/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| MockFile('components/exo/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| ] |
| input_api = MockInputApi() |
| for file in files: |
| input_api.files = [file] |
| warnings = PRESUBMIT.CheckChromeOsSyncedPrefRegistration( |
| input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| |
| def testDoesNotWarnOnSyncOsPref(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('chromeos/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_OS_PREF']), |
| ] |
| warnings = PRESUBMIT.CheckChromeOsSyncedPrefRegistration( |
| input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testDoesNotWarnOnOtherDirectories(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('chrome/browser/ui/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| MockFile('components/sync/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| MockFile('content/browser/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| MockFile('a/notchromeos/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF']), |
| ] |
| warnings = PRESUBMIT.CheckChromeOsSyncedPrefRegistration( |
| input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testSeparateWarningForPriorityPrefs(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('chromeos/file.cc', |
| ['PrefRegistrySyncable::SYNCABLE_PREF', |
| 'PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF']), |
| ] |
| warnings = PRESUBMIT.CheckChromeOsSyncedPrefRegistration( |
| input_api, MockOutputApi()) |
| self.assertEqual(2, len(warnings)) |
| |
| |
| class ForwardDeclarationTest(unittest.TestCase): |
| def testCheckHeadersOnlyOutsideThirdParty(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('somewhere/file.cc', [ |
| 'class DummyClass;' |
| ]), |
| MockAffectedFile('third_party/header.h', [ |
| 'class DummyClass;' |
| ]) |
| ] |
| warnings = PRESUBMIT.CheckUselessForwardDeclarations(mock_input_api, |
| MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testNoNestedDeclaration(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('somewhere/header.h', [ |
| 'class SomeClass {', |
| ' protected:', |
| ' class NotAMatch;', |
| '};' |
| ]) |
| ] |
| warnings = PRESUBMIT.CheckUselessForwardDeclarations(mock_input_api, |
| MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testSubStrings(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('somewhere/header.h', [ |
| 'class NotUsefulClass;', |
| 'struct SomeStruct;', |
| 'UsefulClass *p1;', |
| 'SomeStructPtr *p2;' |
| ]) |
| ] |
| warnings = PRESUBMIT.CheckUselessForwardDeclarations(mock_input_api, |
| MockOutputApi()) |
| self.assertEqual(2, len(warnings)) |
| |
| def testUselessForwardDeclaration(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('somewhere/header.h', [ |
| 'class DummyClass;', |
| 'struct DummyStruct;', |
| 'class UsefulClass;', |
| 'std::unique_ptr<UsefulClass> p;' |
| ]) |
| ] |
| warnings = PRESUBMIT.CheckUselessForwardDeclarations(mock_input_api, |
| MockOutputApi()) |
| self.assertEqual(2, len(warnings)) |
| |
| def testBlinkHeaders(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('third_party/blink/header.h', [ |
| 'class DummyClass;', |
| 'struct DummyStruct;', |
| ]), |
| MockAffectedFile('third_party\\blink\\header.h', [ |
| 'class DummyClass;', |
| 'struct DummyStruct;', |
| ]) |
| ] |
| warnings = PRESUBMIT.CheckUselessForwardDeclarations(mock_input_api, |
| MockOutputApi()) |
| self.assertEqual(4, len(warnings)) |
| |
| |
| class RelativeIncludesTest(unittest.TestCase): |
| def testThirdPartyNotWebKitIgnored(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('third_party/test.cpp', '#include "../header.h"'), |
| MockAffectedFile('third_party/test/test.cpp', '#include "../header.h"'), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForRelativeIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(errors)) |
| |
| def testNonCppFileIgnored(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('test.py', '#include "../header.h"'), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForRelativeIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(errors)) |
| |
| def testInnocuousChangesAllowed(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('test.cpp', '#include "header.h"'), |
| MockAffectedFile('test2.cpp', '../'), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForRelativeIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(errors)) |
| |
| def testRelativeIncludeNonWebKitProducesError(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('test.cpp', ['#include "../header.h"']), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForRelativeIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| |
| def testRelativeIncludeWebKitProducesError(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('third_party/blink/test.cpp', |
| ['#include "../header.h']), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForRelativeIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| |
| |
| class CCIncludeTest(unittest.TestCase): |
| def testThirdPartyNotBlinkIgnored(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('third_party/test.cpp', '#include "file.cc"'), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForCcIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(errors)) |
| |
| def testPythonFileIgnored(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('test.py', '#include "file.cc"'), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForCcIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(errors)) |
| |
| def testIncFilesAccepted(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('test.py', '#include "file.inc"'), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForCcIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(errors)) |
| |
| def testInnocuousChangesAllowed(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('test.cpp', '#include "header.h"'), |
| MockAffectedFile('test2.cpp', 'Something "file.cc"'), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForCcIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(0, len(errors)) |
| |
| def testCcIncludeNonBlinkProducesError(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('test.cpp', ['#include "file.cc"']), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForCcIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| |
| def testCppIncludeBlinkProducesError(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('third_party/blink/test.cpp', |
| ['#include "foo/file.cpp"']), |
| ] |
| |
| mock_output_api = MockOutputApi() |
| |
| errors = PRESUBMIT.CheckForCcIncludes( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| |
| |
| class GnGlobForwardTest(unittest.TestCase): |
| def testAddBareGlobs(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.gni', [ |
| 'forward_variables_from(invoker, "*")']), |
| MockAffectedFile('base/BUILD.gn', [ |
| 'forward_variables_from(invoker, "*")']), |
| ] |
| warnings = PRESUBMIT.CheckGnGlobForward(mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| msg = '\n'.join(warnings[0].items) |
| self.assertIn('base/stuff.gni', msg) |
| # Should not check .gn files. Local templates don't need to care about |
| # visibility / testonly. |
| self.assertNotIn('base/BUILD.gn', msg) |
| |
| def testValidUses(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.gni', [ |
| 'forward_variables_from(invoker, "*", [])']), |
| MockAffectedFile('base/stuff2.gni', [ |
| 'forward_variables_from(invoker, "*", TESTONLY_AND_VISIBILITY)']), |
| MockAffectedFile('base/stuff3.gni', [ |
| 'forward_variables_from(invoker, [ "testonly" ])']), |
| ] |
| warnings = PRESUBMIT.CheckGnGlobForward(mock_input_api, MockOutputApi()) |
| self.assertEqual([], warnings) |
| |
| |
| class NewHeaderWithoutGnChangeTest(unittest.TestCase): |
| def testAddHeaderWithoutGn(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertTrue('base/stuff.h' in warnings[0].items) |
| |
| def testModifyHeader(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', '', action='M'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testDeleteHeader(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', '', action='D'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testAddHeaderWithGn(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| MockAffectedFile('base/BUILD.gn', 'stuff.h'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testAddHeaderWithGni(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| MockAffectedFile('base/files.gni', 'stuff.h'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testAddHeaderWithOther(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| MockAffectedFile('base/stuff.cc', 'stuff.h'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| |
| def testAddHeaderWithWrongGn(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| MockAffectedFile('base/BUILD.gn', 'stuff_h'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| |
| def testAddHeadersWithGn(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| MockAffectedFile('base/another.h', ''), |
| MockAffectedFile('base/BUILD.gn', 'another.h\nstuff.h'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testAddHeadersWithWrongGn(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| MockAffectedFile('base/another.h', ''), |
| MockAffectedFile('base/BUILD.gn', 'another_h\nstuff.h'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertFalse('base/stuff.h' in warnings[0].items) |
| self.assertTrue('base/another.h' in warnings[0].items) |
| |
| def testAddHeadersWithWrongGn2(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('base/stuff.h', ''), |
| MockAffectedFile('base/another.h', ''), |
| MockAffectedFile('base/BUILD.gn', 'another_h\nstuff_h'), |
| ] |
| warnings = PRESUBMIT.CheckNewHeaderWithoutGnChangeOnUpload( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertTrue('base/stuff.h' in warnings[0].items) |
| self.assertTrue('base/another.h' in warnings[0].items) |
| |
| |
| class CorrectProductNameInMessagesTest(unittest.TestCase): |
| def testProductNameInDesc(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('chrome/app/google_chrome_strings.grd', [ |
| '<message name="Foo" desc="Welcome to Chrome">', |
| ' Welcome to Chrome!', |
| '</message>', |
| ]), |
| MockAffectedFile('chrome/app/chromium_strings.grd', [ |
| '<message name="Bar" desc="Welcome to Chrome">', |
| ' Welcome to Chromium!', |
| '</message>', |
| ]), |
| ] |
| warnings = PRESUBMIT.CheckCorrectProductNameInMessages( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(warnings)) |
| |
| def testChromeInChromium(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('chrome/app/google_chrome_strings.grd', [ |
| '<message name="Foo" desc="Welcome to Chrome">', |
| ' Welcome to Chrome!', |
| '</message>', |
| ]), |
| MockAffectedFile('chrome/app/chromium_strings.grd', [ |
| '<message name="Bar" desc="Welcome to Chrome">', |
| ' Welcome to Chrome!', |
| '</message>', |
| ]), |
| ] |
| warnings = PRESUBMIT.CheckCorrectProductNameInMessages( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertTrue('chrome/app/chromium_strings.grd' in warnings[0].items[0]) |
| |
| def testChromiumInChrome(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('chrome/app/google_chrome_strings.grd', [ |
| '<message name="Foo" desc="Welcome to Chrome">', |
| ' Welcome to Chromium!', |
| '</message>', |
| ]), |
| MockAffectedFile('chrome/app/chromium_strings.grd', [ |
| '<message name="Bar" desc="Welcome to Chrome">', |
| ' Welcome to Chromium!', |
| '</message>', |
| ]), |
| ] |
| warnings = PRESUBMIT.CheckCorrectProductNameInMessages( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertTrue( |
| 'chrome/app/google_chrome_strings.grd:2' in warnings[0].items[0]) |
| |
| def testMultipleInstances(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('chrome/app/chromium_strings.grd', [ |
| '<message name="Bar" desc="Welcome to Chrome">', |
| ' Welcome to Chrome!', |
| '</message>', |
| '<message name="Baz" desc="A correct message">', |
| ' Chromium is the software you are using.', |
| '</message>', |
| '<message name="Bat" desc="An incorrect message">', |
| ' Google Chrome is the software you are using.', |
| '</message>', |
| ]), |
| ] |
| warnings = PRESUBMIT.CheckCorrectProductNameInMessages( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(warnings)) |
| self.assertTrue( |
| 'chrome/app/chromium_strings.grd:2' in warnings[0].items[0]) |
| self.assertTrue( |
| 'chrome/app/chromium_strings.grd:8' in warnings[0].items[1]) |
| |
| def testMultipleWarnings(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('chrome/app/chromium_strings.grd', [ |
| '<message name="Bar" desc="Welcome to Chrome">', |
| ' Welcome to Chrome!', |
| '</message>', |
| '<message name="Baz" desc="A correct message">', |
| ' Chromium is the software you are using.', |
| '</message>', |
| '<message name="Bat" desc="An incorrect message">', |
| ' Google Chrome is the software you are using.', |
| '</message>', |
| ]), |
| MockAffectedFile('components/components_google_chrome_strings.grd', [ |
| '<message name="Bar" desc="Welcome to Chrome">', |
| ' Welcome to Chrome!', |
| '</message>', |
| '<message name="Baz" desc="A correct message">', |
| ' Chromium is the software you are using.', |
| '</message>', |
| '<message name="Bat" desc="An incorrect message">', |
| ' Google Chrome is the software you are using.', |
| '</message>', |
| ]), |
| ] |
| warnings = PRESUBMIT.CheckCorrectProductNameInMessages( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(2, len(warnings)) |
| self.assertTrue( |
| 'components/components_google_chrome_strings.grd:5' |
| in warnings[0].items[0]) |
| self.assertTrue( |
| 'chrome/app/chromium_strings.grd:2' in warnings[1].items[0]) |
| self.assertTrue( |
| 'chrome/app/chromium_strings.grd:8' in warnings[1].items[1]) |
| |
| |
| class ServiceManifestOwnerTest(unittest.TestCase): |
| def testServiceManifestChangeNeedsSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('services/goat/public/cpp/manifest.cc', |
| [ |
| '#include "services/goat/public/cpp/manifest.h"', |
| 'const service_manager::Manifest& GetManifest() {}', |
| ])] |
| mock_output_api = MockOutputApi() |
| errors = PRESUBMIT.CheckSecurityOwners( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| self.assertEqual( |
| 'Found OWNERS files that need to be updated for IPC security review ' + |
| 'coverage.\nPlease update the OWNERS files below:', errors[0].message) |
| |
| def testNonServiceManifestSourceChangesDoNotRequireSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('some/non/service/thing/foo_manifest.cc', |
| [ |
| 'const char kNoEnforcement[] = "not a manifest!";', |
| ])] |
| mock_output_api = MockOutputApi() |
| errors = PRESUBMIT.CheckSecurityOwners( |
| mock_input_api, mock_output_api) |
| self.assertEqual([], errors) |
| |
| |
| class FuchsiaSecurityOwnerTest(unittest.TestCase): |
| def testFidlChangeNeedsSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('potentially/scary/ipc.fidl', |
| [ |
| 'library test.fidl' |
| ])] |
| mock_output_api = MockOutputApi() |
| errors = PRESUBMIT.CheckSecurityOwners( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| self.assertEqual( |
| 'Found OWNERS files that need to be updated for IPC security review ' + |
| 'coverage.\nPlease update the OWNERS files below:', errors[0].message) |
| |
| def testComponentManifestV1ChangeNeedsSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('potentially/scary/v2_manifest.cmx', |
| [ |
| '{ "that is no": "manifest!" }' |
| ])] |
| mock_output_api = MockOutputApi() |
| errors = PRESUBMIT.CheckSecurityOwners( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| self.assertEqual( |
| 'Found OWNERS files that need to be updated for IPC security review ' + |
| 'coverage.\nPlease update the OWNERS files below:', errors[0].message) |
| |
| def testComponentManifestV2NeedsSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('potentially/scary/v2_manifest.cml', |
| [ |
| '{ "that is no": "manifest!" }' |
| ])] |
| mock_output_api = MockOutputApi() |
| errors = PRESUBMIT.CheckSecurityOwners( |
| mock_input_api, mock_output_api) |
| self.assertEqual(1, len(errors)) |
| self.assertEqual( |
| 'Found OWNERS files that need to be updated for IPC security review ' + |
| 'coverage.\nPlease update the OWNERS files below:', errors[0].message) |
| |
| def testThirdPartyTestsDoNotRequireSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('third_party/crashpad/test/tests.cmx', |
| [ |
| 'const char kNoEnforcement[] = "Security?!? Pah!";', |
| ])] |
| mock_output_api = MockOutputApi() |
| errors = PRESUBMIT.CheckSecurityOwners( |
| mock_input_api, mock_output_api) |
| self.assertEqual([], errors) |
| |
| def testOtherFuchsiaChangesDoNotRequireSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile('some/non/service/thing/fuchsia_fidl_cml_cmx_magic.cc', |
| [ |
| 'const char kNoEnforcement[] = "Security?!? Pah!";', |
| ])] |
| mock_output_api = MockOutputApi() |
| errors = PRESUBMIT.CheckSecurityOwners( |
| mock_input_api, mock_output_api) |
| self.assertEqual([], errors) |
| |
| |
| class SecurityChangeTest(unittest.TestCase): |
| class _MockOwnersClient(object): |
| def ListOwners(self, f): |
| return ['apple@chromium.org', 'orange@chromium.org'] |
| |
| def _mockChangeOwnerAndReviewers(self, input_api, owner, reviewers): |
| def __MockOwnerAndReviewers(input_api, email_regexp, approval_needed=False): |
| return [owner, reviewers] |
| input_api.canned_checks.GetCodereviewOwnerAndReviewers = \ |
| __MockOwnerAndReviewers |
| |
| def testDiffGetServiceSandboxType(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockAffectedFile( |
| 'services/goat/teleporter_host.cc', |
| [ |
| 'template <>', |
| 'inline content::SandboxType', |
| 'content::GetServiceSandboxType<chrome::mojom::GoatTeleporter>() {', |
| '#if defined(OS_WIN)', |
| ' return SandboxType::kGoaty;', |
| '#else', |
| ' return SandboxType::kNoSandbox;', |
| '#endif // !defined(OS_WIN)', |
| '}' |
| ] |
| ), |
| ] |
| files_to_functions = PRESUBMIT._GetFilesUsingSecurityCriticalFunctions( |
| mock_input_api) |
| self.assertEqual({ |
| 'services/goat/teleporter_host.cc': set([ |
| 'content::GetServiceSandboxType<>()' |
| ])}, |
| files_to_functions) |
| |
| def testDiffRemovingLine(self): |
| mock_input_api = MockInputApi() |
| mock_file = MockAffectedFile('services/goat/teleporter_host.cc', '') |
| mock_file._scm_diff = """--- old 2020-05-04 14:08:25.000000000 -0400 |
| +++ new 2020-05-04 14:08:32.000000000 -0400 |
| @@ -1,5 +1,4 @@ |
| template <> |
| inline content::SandboxType |
| -content::GetServiceSandboxType<chrome::mojom::GoatTeleporter>() { |
| #if defined(OS_WIN) |
| return SandboxType::kGoaty; |
| """ |
| mock_input_api.files = [mock_file] |
| files_to_functions = PRESUBMIT._GetFilesUsingSecurityCriticalFunctions( |
| mock_input_api) |
| self.assertEqual({ |
| 'services/goat/teleporter_host.cc': set([ |
| 'content::GetServiceSandboxType<>()' |
| ])}, |
| files_to_functions) |
| |
| def testChangeOwnersMissing(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.owners_client = self._MockOwnersClient() |
| mock_input_api.is_committing = False |
| mock_input_api.files = [ |
| MockAffectedFile('file.cc', ['GetServiceSandboxType<Goat>(Sandbox)']) |
| ] |
| mock_output_api = MockOutputApi() |
| self._mockChangeOwnerAndReviewers( |
| mock_input_api, 'owner@chromium.org', ['banana@chromium.org']) |
| result = PRESUBMIT.CheckSecurityChanges(mock_input_api, mock_output_api) |
| self.assertEqual(1, len(result)) |
| self.assertEqual(result[0].type, 'notify') |
| self.assertEqual(result[0].message, |
| 'The following files change calls to security-sensive functions\n' \ |
| 'that need to be reviewed by ipc/SECURITY_OWNERS.\n' |
| ' file.cc\n' |
| ' content::GetServiceSandboxType<>()\n\n') |
| |
| def testChangeOwnersMissingAtCommit(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.owners_client = self._MockOwnersClient() |
| mock_input_api.is_committing = True |
| mock_input_api.files = [ |
| MockAffectedFile('file.cc', ['GetServiceSandboxType<mojom::Goat>()']) |
| ] |
| mock_output_api = MockOutputApi() |
| self._mockChangeOwnerAndReviewers( |
| mock_input_api, 'owner@chromium.org', ['banana@chromium.org']) |
| result = PRESUBMIT.CheckSecurityChanges(mock_input_api, mock_output_api) |
| self.assertEqual(1, len(result)) |
| self.assertEqual(result[0].type, 'error') |
| self.assertEqual(result[0].message, |
| 'The following files change calls to security-sensive functions\n' \ |
| 'that need to be reviewed by ipc/SECURITY_OWNERS.\n' |
| ' file.cc\n' |
| ' content::GetServiceSandboxType<>()\n\n') |
| |
| def testChangeOwnersPresent(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.owners_client = self._MockOwnersClient() |
| mock_input_api.files = [ |
| MockAffectedFile('file.cc', ['WithSandboxType(Sandbox)']) |
| ] |
| mock_output_api = MockOutputApi() |
| self._mockChangeOwnerAndReviewers( |
| mock_input_api, 'owner@chromium.org', |
| ['apple@chromium.org', 'banana@chromium.org']) |
| result = PRESUBMIT.CheckSecurityChanges(mock_input_api, mock_output_api) |
| self.assertEqual(0, len(result)) |
| |
| def testChangeOwnerIsSecurityOwner(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.owners_client = self._MockOwnersClient() |
| mock_input_api.files = [ |
| MockAffectedFile('file.cc', ['GetServiceSandboxType<T>(Sandbox)']) |
| ] |
| mock_output_api = MockOutputApi() |
| self._mockChangeOwnerAndReviewers( |
| mock_input_api, 'orange@chromium.org', ['pear@chromium.org']) |
| result = PRESUBMIT.CheckSecurityChanges(mock_input_api, mock_output_api) |
| self.assertEqual(1, len(result)) |
| |
| |
| class BannedTypeCheckTest(unittest.TestCase): |
| |
| def testBannedCppFunctions(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('some/cpp/problematic/file.cc', |
| ['using namespace std;']), |
| MockFile('third_party/blink/problematic/file.cc', |
| ['GetInterfaceProvider()']), |
| MockFile('some/cpp/ok/file.cc', |
| ['using std::string;']), |
| MockFile('some/cpp/problematic/file2.cc', |
| ['set_owned_by_client()']), |
| MockFile('some/cpp/nocheck/file.cc', |
| ['using namespace std; // nocheck']), |
| MockFile('some/cpp/comment/file.cc', |
| [' // A comment about `using namespace std;`']), |
| ] |
| |
| results = PRESUBMIT.CheckNoBannedFunctions(input_api, MockOutputApi()) |
| |
| # warnings are results[0], errors are results[1] |
| self.assertEqual(2, len(results)) |
| self.assertTrue('some/cpp/problematic/file.cc' in results[1].message) |
| self.assertTrue( |
| 'third_party/blink/problematic/file.cc' in results[0].message) |
| self.assertTrue('some/cpp/ok/file.cc' not in results[1].message) |
| self.assertTrue('some/cpp/problematic/file2.cc' in results[0].message) |
| self.assertFalse('some/cpp/nocheck/file.cc' in results[0].message) |
| self.assertFalse('some/cpp/nocheck/file.cc' in results[1].message) |
| self.assertFalse('some/cpp/comment/file.cc' in results[0].message) |
| self.assertFalse('some/cpp/comment/file.cc' in results[1].message) |
| |
| def testBannedIosObjcFunctions(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('some/ios/file.mm', |
| ['TEST(SomeClassTest, SomeInteraction) {', |
| '}']), |
| MockFile('some/mac/file.mm', |
| ['TEST(SomeClassTest, SomeInteraction) {', |
| '}']), |
| MockFile('another/ios_file.mm', |
| ['class SomeTest : public testing::Test {};']), |
| MockFile('some/ios/file_egtest.mm', |
| ['- (void)testSomething { EXPECT_OCMOCK_VERIFY(aMock); }']), |
| MockFile('some/ios/file_unittest.mm', |
| ['TEST_F(SomeTest, TestThis) { EXPECT_OCMOCK_VERIFY(aMock); }']), |
| ] |
| |
| errors = PRESUBMIT.CheckNoBannedFunctions(input_api, MockOutputApi()) |
| self.assertEqual(1, len(errors)) |
| self.assertTrue('some/ios/file.mm' in errors[0].message) |
| self.assertTrue('another/ios_file.mm' in errors[0].message) |
| self.assertTrue('some/mac/file.mm' not in errors[0].message) |
| self.assertTrue('some/ios/file_egtest.mm' in errors[0].message) |
| self.assertTrue('some/ios/file_unittest.mm' not in errors[0].message) |
| |
| def testBannedMojoFunctions(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('some/cpp/problematic/file2.cc', |
| ['mojo::ConvertTo<>']), |
| MockFile('third_party/blink/ok/file3.cc', |
| ['mojo::ConvertTo<>']), |
| MockFile('content/renderer/ok/file3.cc', |
| ['mojo::ConvertTo<>']), |
| ] |
| |
| results = PRESUBMIT.CheckNoBannedFunctions(input_api, MockOutputApi()) |
| |
| # warnings are results[0], errors are results[1] |
| self.assertEqual(1, len(results)) |
| self.assertTrue('some/cpp/problematic/file2.cc' in results[0].message) |
| self.assertTrue('third_party/blink/ok/file3.cc' not in results[0].message) |
| self.assertTrue('content/renderer/ok/file3.cc' not in results[0].message) |
| |
| def testBannedMojomPatterns(self): |
| input_api = MockInputApi() |
| input_api.files = [ |
| MockFile('bad.mojom', |
| ['struct Bad {', |
| ' handle<shared_buffer> buffer;', |
| '};']), |
| MockFile('good.mojom', |
| ['struct Good {', |
| ' mojo_base.mojom.ReadOnlySharedMemoryRegion region1;', |
| ' mojo_base.mojom.WritableSharedMemoryRegion region2;', |
| ' mojo_base.mojom.UnsafeSharedMemoryRegion region3;', |
| '};']), |
| ] |
| |
| results = PRESUBMIT.CheckNoBannedFunctions(input_api, MockOutputApi()) |
| |
| # warnings are results[0], errors are results[1] |
| self.assertEqual(1, len(results)) |
| self.assertTrue('bad.mojom' in results[0].message) |
| self.assertTrue('good.mojom' not in results[0].message) |
| |
| class NoProductionCodeUsingTestOnlyFunctionsTest(unittest.TestCase): |
| def testTruePositives(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('some/path/foo.cc', ['foo_for_testing();']), |
| MockFile('some/path/foo.mm', ['FooForTesting();']), |
| MockFile('some/path/foo.cxx', ['FooForTests();']), |
| MockFile('some/path/foo.cpp', ['foo_for_test();']), |
| ] |
| |
| results = PRESUBMIT.CheckNoProductionCodeUsingTestOnlyFunctions( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertEqual(4, len(results[0].items)) |
| self.assertTrue('foo.cc' in results[0].items[0]) |
| self.assertTrue('foo.mm' in results[0].items[1]) |
| self.assertTrue('foo.cxx' in results[0].items[2]) |
| self.assertTrue('foo.cpp' in results[0].items[3]) |
| |
| def testFalsePositives(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('some/path/foo.h', ['foo_for_testing();']), |
| MockFile('some/path/foo.mm', ['FooForTesting() {']), |
| MockFile('some/path/foo.cc', ['::FooForTests();']), |
| MockFile('some/path/foo.cpp', ['// foo_for_test();']), |
| ] |
| |
| results = PRESUBMIT.CheckNoProductionCodeUsingTestOnlyFunctions( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| def testAllowedFiles(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('path/foo_unittest.cc', ['foo_for_testing();']), |
| MockFile('path/bar_unittest_mac.cc', ['foo_for_testing();']), |
| MockFile('path/baz_unittests.cc', ['foo_for_testing();']), |
| ] |
| |
| results = PRESUBMIT.CheckNoProductionCodeUsingTestOnlyFunctions( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| |
| class NoProductionJavaCodeUsingTestOnlyFunctionsTest(unittest.TestCase): |
| def testTruePositives(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/java/src/foo.java', ['FooForTesting();']), |
| MockFile('dir/java/src/bar.java', ['FooForTests(x);']), |
| MockFile('dir/java/src/baz.java', ['FooForTest(', 'y', ');']), |
| MockFile('dir/java/src/mult.java', [ |
| 'int x = SomethingLongHere()', |
| ' * SomethingLongHereForTesting();' |
| ]) |
| ] |
| |
| results = PRESUBMIT.CheckNoProductionCodeUsingTestOnlyFunctionsJava( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertEqual(4, len(results[0].items)) |
| self.assertTrue('foo.java' in results[0].items[0]) |
| self.assertTrue('bar.java' in results[0].items[1]) |
| self.assertTrue('baz.java' in results[0].items[2]) |
| self.assertTrue('mult.java' in results[0].items[3]) |
| |
| def testFalsePositives(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/java/src/foo.xml', ['FooForTesting();']), |
| MockFile('dir/java/src/foo.java', ['FooForTests() {']), |
| MockFile('dir/java/src/bar.java', ['// FooForTest();']), |
| MockFile('dir/java/src/bar2.java', ['x = 1; // FooForTest();']), |
| MockFile('dir/java/src/bar3.java', ['@VisibleForTesting']), |
| MockFile('dir/java/src/bar4.java', ['@VisibleForTesting()']), |
| MockFile('dir/java/src/bar5.java', [ |
| '@VisibleForTesting(otherwise = VisibleForTesting.PROTECTED)' |
| ]), |
| MockFile('dir/javatests/src/baz.java', ['FooForTest(', 'y', ');']), |
| MockFile('dir/junit/src/baz.java', ['FooForTest(', 'y', ');']), |
| MockFile('dir/junit/src/javadoc.java', [ |
| '/** Use FooForTest(); to obtain foo in tests.' |
| ' */' |
| ]), |
| MockFile('dir/junit/src/javadoc2.java', [ |
| '/** ', |
| ' * Use FooForTest(); to obtain foo in tests.' |
| ' */' |
| ]), |
| ] |
| |
| results = PRESUBMIT.CheckNoProductionCodeUsingTestOnlyFunctionsJava( |
| mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| |
| class NewImagesWarningTest(unittest.TestCase): |
| def testTruePositives(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/android/res/drawable/foo.png', []), |
| MockFile('dir/android/res/drawable-v21/bar.svg', []), |
| MockFile('dir/android/res/mipmap-v21-en/baz.webp', []), |
| MockFile('dir/android/res_gshoe/drawable-mdpi/foobar.png', []), |
| ] |
| |
| results = PRESUBMIT._CheckNewImagesWarning(mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertEqual(4, len(results[0].items)) |
| self.assertTrue('foo.png' in results[0].items[0].LocalPath()) |
| self.assertTrue('bar.svg' in results[0].items[1].LocalPath()) |
| self.assertTrue('baz.webp' in results[0].items[2].LocalPath()) |
| self.assertTrue('foobar.png' in results[0].items[3].LocalPath()) |
| |
| def testFalsePositives(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/pngs/README.md', []), |
| MockFile('java/test/res/drawable/foo.png', []), |
| MockFile('third_party/blink/foo.png', []), |
| MockFile('dir/third_party/libpng/src/foo.cc', ['foobar']), |
| MockFile('dir/resources.webp/.gitignore', ['foo.png']), |
| ] |
| |
| results = PRESUBMIT._CheckNewImagesWarning(mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| |
| class CheckUniquePtrTest(unittest.TestCase): |
| def testTruePositivesNullptr(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/baz.cc', ['std::unique_ptr<T>()']), |
| MockFile('dir/baz-p.cc', ['std::unique_ptr<T<P>>()']), |
| ] |
| |
| results = PRESUBMIT.CheckUniquePtrOnUpload(mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertTrue('nullptr' in results[0].message) |
| self.assertEqual(2, len(results[0].items)) |
| self.assertTrue('baz.cc' in results[0].items[0]) |
| self.assertTrue('baz-p.cc' in results[0].items[1]) |
| |
| def testTruePositivesConstructor(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/foo.cc', ['return std::unique_ptr<T>(foo);']), |
| MockFile('dir/bar.mm', ['bar = std::unique_ptr<T>(foo)']), |
| MockFile('dir/mult.cc', [ |
| 'return', |
| ' std::unique_ptr<T>(barVeryVeryLongFooSoThatItWouldNotFitAbove);' |
| ]), |
| MockFile('dir/mult2.cc', [ |
| 'barVeryVeryLongLongBaaaaaarSoThatTheLineLimitIsAlmostReached =', |
| ' std::unique_ptr<T>(foo);' |
| ]), |
| MockFile('dir/mult3.cc', [ |
| 'bar = std::unique_ptr<T>(', |
| ' fooVeryVeryVeryLongStillGoingWellThisWillTakeAWhileFinallyThere);' |
| ]), |
| MockFile('dir/multi_arg.cc', [ |
| 'auto p = std::unique_ptr<std::pair<T, D>>(new std::pair(T, D));']), |
| ] |
| |
| results = PRESUBMIT.CheckUniquePtrOnUpload(mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertTrue('std::make_unique' in results[0].message) |
| self.assertEqual(6, len(results[0].items)) |
| self.assertTrue('foo.cc' in results[0].items[0]) |
| self.assertTrue('bar.mm' in results[0].items[1]) |
| self.assertTrue('mult.cc' in results[0].items[2]) |
| self.assertTrue('mult2.cc' in results[0].items[3]) |
| self.assertTrue('mult3.cc' in results[0].items[4]) |
| self.assertTrue('multi_arg.cc' in results[0].items[5]) |
| |
| def testFalsePositives(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/foo.cc', ['return std::unique_ptr<T[]>(foo);']), |
| MockFile('dir/bar.mm', ['bar = std::unique_ptr<T[]>(foo)']), |
| MockFile('dir/file.cc', ['std::unique_ptr<T> p = Foo();']), |
| MockFile('dir/baz.cc', [ |
| 'std::unique_ptr<T> result = std::make_unique<T>();' |
| ]), |
| MockFile('dir/baz2.cc', [ |
| 'std::unique_ptr<T> result = std::make_unique<T>(' |
| ]), |
| MockFile('dir/nested.cc', ['set<std::unique_ptr<T>>();']), |
| MockFile('dir/nested2.cc', ['map<U, std::unique_ptr<T>>();']), |
| |
| # Two-argument invocation of std::unique_ptr is exempt because there is |
| # no equivalent using std::make_unique. |
| MockFile('dir/multi_arg.cc', [ |
| 'auto p = std::unique_ptr<T, D>(new T(), D());']), |
| ] |
| |
| results = PRESUBMIT.CheckUniquePtrOnUpload(mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| class CheckNoDirectIncludesHeadersWhichRedefineStrCat(unittest.TestCase): |
| def testBlocksDirectIncludes(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/foo_win.cc', ['#include "shlwapi.h"']), |
| MockFile('dir/bar.h', ['#include <propvarutil.h>']), |
| MockFile('dir/baz.h', ['#include <atlbase.h>']), |
| MockFile('dir/jumbo.h', ['#include "sphelper.h"']), |
| ] |
| results = PRESUBMIT._CheckNoStrCatRedefines(mock_input_api, MockOutputApi()) |
| self.assertEqual(1, len(results)) |
| self.assertEqual(4, len(results[0].items)) |
| self.assertTrue('StrCat' in results[0].message) |
| self.assertTrue('foo_win.cc' in results[0].items[0]) |
| self.assertTrue('bar.h' in results[0].items[1]) |
| self.assertTrue('baz.h' in results[0].items[2]) |
| self.assertTrue('jumbo.h' in results[0].items[3]) |
| |
| def testAllowsToIncludeWrapper(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('dir/baz_win.cc', ['#include "base/win/shlwapi.h"']), |
| MockFile('dir/baz-win.h', ['#include "base/win/atl.h"']), |
| ] |
| results = PRESUBMIT._CheckNoStrCatRedefines(mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| def testAllowsToCreateWrapper(self): |
| mock_input_api = MockInputApi() |
| mock_input_api.files = [ |
| MockFile('base/win/shlwapi.h', [ |
| '#include <shlwapi.h>', |
| '#include "base/win/windows_defines.inc"']), |
| ] |
| results = PRESUBMIT._CheckNoStrCatRedefines(mock_input_api, MockOutputApi()) |
| self.assertEqual(0, len(results)) |
| |
| |
| class StringTest(unittest.TestCase): |
| """Tests ICU syntax check and translation screenshots check.""" |
| |
| # An empty grd file. |
| OLD_GRD_CONTENTS = """<?xml version="1.0" encoding="UTF-8"?> |
| <grit latest_public_release="1" current_release="1"> |
| <release seq="1"> |
| <messages></messages> |
| </release> |
| </grit> |
| """.splitlines() |
| # A grd file with a single message. |
| NEW_GRD_CONTENTS1 = """<?xml version="1.0" encoding="UTF-8"?> |
| <grit latest_public_release="1" current_release="1"> |
| <release seq="1"> |
| <messages> |
| <message name="IDS_TEST1"> |
| Test string 1 |
| </message> |
| <message name="IDS_TEST_STRING_NON_TRANSLATEABLE1" |
| translateable="false"> |
| Non translateable message 1, should be ignored |
| </message> |
| <message name="IDS_TEST_STRING_ACCESSIBILITY" |
| is_accessibility_with_no_ui="true"> |
| Accessibility label 1, should be ignored |
| </message> |
| </messages> |
| </release> |
| </grit> |
| """.splitlines() |
| # A grd file with two messages. |
| NEW_GRD_CONTENTS2 = """<?xml version="1.0" encoding="UTF-8"?> |
| <grit latest_public_release="1" current_release="1"> |
| <release seq="1"> |
| <messages> |
| <message name="IDS_TEST1"> |
| Test string 1 |
| </message> |
| <message name="IDS_TEST2"> |
| Test string 2 |
| </message> |
| <message name="IDS_TEST_STRING_NON_TRANSLATEABLE2" |
| translateable="false"> |
| Non translateable message 2, should be ignored |
| </message> |
| </messages> |
| </release> |
| </grit> |
| """.splitlines() |
| # A grd file with one ICU syntax message without syntax errors. |
| NEW_GRD_CONTENTS_ICU_SYNTAX_OK1 = """<?xml version="1.0" encoding="UTF-8"?> |
| <grit latest_public_release="1" current_release="1"> |
| <release seq="1"> |
| <messages> |
| <message name="IDS_TEST1"> |
| {NUM, plural, |
| =1 {Test text for numeric one} |
| other {Test text for plural with {NUM} as number}} |
| </message> |
| </messages> |
| </release> |
| </grit> |
| """.splitlines() |
| # A grd file with one ICU syntax message without syntax errors. |
| NEW_GRD_CONTENTS_ICU_SYNTAX_OK2 = """<?xml version="1.0" encoding="UTF-8"?> |
| <grit latest_public_release="1" current_release="1"> |
| <release seq="1"> |
| <messages> |
| <message name="IDS_TEST1"> |
| {NUM, plural, |
| =1 {Different test text for numeric one} |
| other {Different test text for plural with {NUM} as number}} |
| </message> |
| </messages> |
| </release> |
| </grit> |
| """.splitlines() |
| # A grd file with one ICU syntax message with syntax errors (misses a comma). |
| NEW_GRD_CONTENTS_ICU_SYNTAX_ERROR = """<?xml version="1.0" encoding="UTF-8"?> |
| <grit latest_public_release="1" current_release="1"> |
| <release seq="1"> |
| <messages> |
| <message name="IDS_TEST1"> |
| {NUM, plural |
| =1 {Test text for numeric one} |
| other {Test text for plural with {NUM} as number}} |
| </message> |
| </messages> |
| </release> |
| </grit> |
| """.splitlines() |
| |
| OLD_GRDP_CONTENTS = ( |
| '<?xml version="1.0" encoding="utf-8"?>', |
| '<grit-part>', |
| '</grit-part>' |
| ) |
| |
| NEW_GRDP_CONTENTS1 = ( |
| '<?xml version="1.0" encoding="utf-8"?>', |
| '<grit-part>', |
| '<message name="IDS_PART_TEST1">', |
| 'Part string 1', |
| '</message>', |
| '</grit-part>') |
| |
| NEW_GRDP_CONTENTS2 = ( |
| '<?xml version="1.0" encoding="utf-8"?>', |
| '<grit-part>', |
| '<message name="IDS_PART_TEST1">', |
| 'Part string 1', |
| '</message>', |
| '<message name="IDS_PART_TEST2">', |
| 'Part string 2', |
| '</message>', |
| '</grit-part>') |
| |
| NEW_GRDP_CONTENTS3 = ( |
| '<?xml version="1.0" encoding="utf-8"?>', |
| '<grit-part>', |
| '<message name="IDS_PART_TEST1" desc="Description with typo.">', |
| |