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.assertIn('1', errors[0])

self.assertIn('3', errors[1])

self.assertIn('5', errors[2])

def testIgnoresReadmes(self):

lines = [

'A First Level Header', '====================', '',

'A Second Level Header', '---------------------'

]

errors = PRESUBMIT._CheckForVersionControlConflictsInFile(

MockInputApi(), MockFile('some/polymer/README.md', lines))

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.assertIn('foo.cc.rej', results[0].items[0])

self.assertIn('bar.h.rej', 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.assertIn('qux.h.orig', 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())

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.assertIn('foo.h: Includes STL', results[0].message)

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.assertIn('Found base::Singleton<T>', 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())

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))

def testInvalidIfDefinedMacroNames(self):

lines = [

'#if defined(TARGET_IPHONE_SIMULATOR)',

'#if !defined(TARGET_IPHONE_SIMULATOR)',

'#elif defined(TARGET_IPHONE_SIMULATOR)',

'#ifdef TARGET_IPHONE_SIMULATOR',

'#elifdef 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', '#if TARGET_IPHONE_SIMULATOR'

]

errors = PRESUBMIT._CheckForInvalidIfDefinedMacrosInFile(

MockInputApi(), MockFile('some/path/source.cc', lines))

def testUnitTestMacros(self):

lines = [

'#if defined(UNIT_TEST)', '#if defined UNIT_TEST',

'#if !defined(UNIT_TEST)', '#elif defined(UNIT_TEST)',

'#ifdef UNIT_TEST', ' # ifdef UNIT_TEST', '#ifndef UNIT_TEST',

'# if defined(VALID) || defined(UNIT_TEST)',

'# if defined(UNIT_TEST) && defined(VALID)',

'# else // defined(UNIT_TEST)', '#endif // defined(UNIT_TEST)'

]

errors = PRESUBMIT._CheckNoUNIT_TESTInSourceFiles(

MockInputApi(), MockFile('some/path/source.cc', lines))

self.assertEqual(len(lines), len(errors))

def testNotUnitTestMacros(self):

lines = [

'// Comment about "#if defined(UNIT_TEST)"',

'/* Comment about #if defined(UNIT_TEST)" */',

'#ifndef UNIT_TEST_H', '#define UNIT_TEST_H',

'#ifndef TEST_UNIT_TEST', '#define TEST_UNIT_TEST',

'#if defined(_UNIT_TEST)', '#if defined(UNIT_TEST_)',

'#ifdef _UNIT_TEST', '#ifdef UNIT_TEST_', '#ifndef _UNIT_TEST',

'#ifndef UNIT_TEST_'

]

errors = PRESUBMIT._CheckNoUNIT_TESTInSourceFiles(

MockInputApi(), MockFile('some/path/source.cc', lines))

def testNewSha256FileNoDEPS(self):

input_api = MockInputApi()

input_api.files = [

MockFile('base/tracing/test/data_sha256/new.pftrace.sha256', []),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual(

('You must update the DEPS file when you update a .sha256 file '

'in base/tracing/test/data_sha256'), results[0].message)

def testNewSha256FileSuccess(self):

input_api = MockInputApi()

new_deps = """deps = {

}""".splitlines()

input_api.files = [

MockFile('base/tracing/test/data_sha256/new.pftrace.sha256',

['a1b2c3f4']),

MockFile('DEPS', new_deps,

["deps={'src/base/tracing/test/data':{}}"]),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual(0, len(results))

def testNewSha256FileWrongSha256(self):

input_api = MockInputApi()

new_deps = """deps = {

}""".splitlines()

f = MockFile('base/tracing/test/data_sha256/new.pftrace.sha256',

['a1b2c3f4'])

input_api.files = [

f,

MockFile('DEPS', new_deps,

["deps={'src/base/tracing/test/data':{}}"]),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual(

('No corresponding DEPS entry found for %s. '

'Run `base/tracing/test/test_data.py get_deps --filepath %s` '

'to generate the DEPS entry.' % (f.LocalPath(), f.LocalPath())),

results[0].message)

def testDeleteSha256File(self):

input_api = MockInputApi()

old_deps = """deps = {

}""".splitlines()

f = MockFile('base/tracing/test/data_sha256/new.pftrace.sha256', [],

['a1b2c3f4'],

action='D')

input_api.files = [

f,

MockFile('DEPS', old_deps, old_deps),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

self.assertEqual((

'You deleted %s so you must also remove the corresponding DEPS entry.'

% f.LocalPath()), results[0].message)

def testDeleteSha256Success(self):

input_api = MockInputApi()

new_deps = """deps = {

}""".splitlines()

old_deps = """deps = {

}""".splitlines()

f = MockFile('base/tracing/test/data_sha256/new.pftrace.sha256', [],

['a1b2c3f4'],

action='D')

input_api.files = [

f,

MockFile('DEPS', new_deps, old_deps),

]

results = PRESUBMIT.CheckEachPerfettoTestDataFileHasDepsEntry(

input_api, MockOutputApi())

def setUp(self):

self.input_api = input_api = MockInputApi()

input_api.environ = {}

input_api.owners_client = self.FakeOwnersClient()

input_api.gerrit = self.fakeGerrit()

input_api.change.issue = 123

self.mockOwnersAndReviewers('owner', set(['reviewer']))

self.mockListSubmodules([])

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 = {

r'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 = {

r'compositor\.*': {

'+cc',

},

r'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,

{}))

def testFindAddedDepsThatRequireReview(self):

caring = ['new_usages_require_review = True']

self.input_api.InitFiles([

MockAffectedFile('cares/DEPS', caring),

MockAffectedFile('cares/inherits/DEPS', []),

MockAffectedFile('willynilly/DEPS', []),

MockAffectedFile('willynilly/butactually/DEPS', caring),

])

expected = {

'cares': True,

'cares/sub/sub': True,

'cares/inherits': True,

'cares/inherits/sub': True,

'willynilly': False,

'willynilly/butactually': True,

'willynilly/butactually/sub': True,

}

results = PRESUBMIT._FindAddedDepsThatRequireReview(

self.input_api, set(expected))

actual = {k: k in results for k in expected}

self.assertEqual(expected, actual)

class FakeOwnersClient(object):

APPROVED = 'APPROVED'

PENDING = 'PENDING'

returns = {}

def ListOwners(self, *args, **kwargs):

return self.returns.get(self.ListOwners.__name__, '')

def mockListOwners(self, owners):

self.returns[self.ListOwners.__name__] = owners

def GetFilesApprovalStatus(self, *args, **kwargs):

return self.returns.get(self.GetFilesApprovalStatus.__name__, {})

def mockGetFilesApprovalStatus(self, status):

self.returns[self.GetFilesApprovalStatus.__name__] = status

def SuggestOwners(self, *args, **kwargs):

return ['eng1', 'eng2', 'eng3']

class fakeGerrit(object):

def IsOwnersOverrideApproved(self, issue):

return False

def mockOwnersAndReviewers(self, owner, reviewers):

def mock(*args, **kwargs):

return [owner, reviewers]

self.input_api.canned_checks.GetCodereviewOwnerAndReviewers = mock

def mockListSubmodules(self, paths):

def mock(*args, **kwargs):

return paths

self.input_api.ListSubmodules = mock

def testApprovedAdditionalDep(self):

self.input_api.InitFiles([

MockAffectedFile('pdf/DEPS',

['include_rules=["+v8/123", "+foo/bar"]']),

MockAffectedFile('v8/DEPS', ['new_usages_require_review=True']),

# Check that we ignore "DEPS" directories. Note there are real cases

# of directories named "deps/" and, especially for case-insensitive file

# systems we should prevent these from being considered.

MockAffectedFile('foo/bar/DEPS/boofar', ['boofar file contents']),

])

# mark the additional dep as approved.

os_path = self.input_api.os_path

self.input_api.owners_client.mockGetFilesApprovalStatus(

{os_path.join('v8/123', 'DEPS'): self.FakeOwnersClient.APPROVED})

results = PRESUBMIT.CheckAddedDepsHaveTargetApprovals(

self.input_api, MockOutputApi())

# Then, the check should pass.

self.assertEqual([], results)

def testUnapprovedAdditionalDep(self):

self.input_api.InitFiles([

MockAffectedFile('pdf/DEPS', ['include_rules=["+v8/123"]']),

MockAffectedFile('v8/DEPS', ['new_usages_require_review=True']),

])

# pending.

os_path = self.input_api.os_path

self.input_api.owners_client.mockGetFilesApprovalStatus(

{os_path.join('v8/123', 'DEPS'): self.FakeOwnersClient.PENDING})

results = PRESUBMIT.CheckAddedDepsHaveTargetApprovals(

self.input_api, MockOutputApi())

# the check should fail

self.assertIn('You need LGTM', results[0].message)

self.assertIn('+v8/123', results[0].message)

# unless the added dep is from a submodule.

self.mockListSubmodules(['v8'])

results = PRESUBMIT.CheckAddedDepsHaveTargetApprovals(

self.input_api, MockOutputApi())

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.assertIsNone(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", }'],

# Different errors depending on Python version.

[

'Illegal trailing comma before end of object',

'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_errors) in test_data:

actual_error = PRESUBMIT._GetJSONParseError(input_api, filename)

self.assertTrue(

any(e in str(actual_error) for e in expected_errors),

f'{filename}: "{expected_errors}" not found in "{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.assertIsNotNone(

str(

PRESUBMIT._GetJSONParseError(input_api,

file_with_comments,

eat_comments=False)))

self.assertIsNone(

PRESUBMIT._GetJSONParseError(input_api,

file_without_comments,

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.assertIsNone(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)

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(

class MockPopen:

def __init__(self, stdout):

self.stdout = io.StringIO(stdout)

def wait(self):

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(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.InitFiles([

MockAffectedFile('new.pydeps', [], action='A'),

])

results = self._RunCheck()

self.assertEqual(1, len(results))

self.assertIn('PYDEPS_FILES', str(results[0]))

def testPydepNotInSrc(self):

self.mock_input_api.InitFiles([

MockAffectedFile('new.pydeps', [], action='A'),

])

self.mock_input_api.os_path.exists = lambda x: False

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.InitFiles([

MockAffectedFile(PRESUBMIT._ALL_PYDEPS_FILES[0], [], action='D'),

])

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))

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;',