Remove SVN support from PRESUBMIT

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # 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.
 
 """Unit tests for presubmit_support.py and presubmit_canned_checks.py."""
 
 # pylint: disable=E1101,E1103
 
 import StringIO
@@ skipping 50 matching lines @@
   else:
     return %s
 """
 
   presubmit_trymaster = """
 def GetPreferredTryMasters(project, change):
   return %s
 """
 
   presubmit_diffs = """
---- file1       2011-02-09 10:38:16.517224845 -0800
-+++ file2       2011-02-09 10:38:53.177226516 -0800
+diff --git %(filename)s %(filename)s
+index fe3de7b..54ae6e1 100755
+--- %(filename)s       2011-02-09 10:38:16.517224845 -0800
++++ %(filename)s       2011-02-09 10:38:53.177226516 -0800
 @@ -1,6 +1,5 @@
  this is line number 0
  this is line number 1
 -this is line number 2 to be deleted
  this is line number 3
  this is line number 4
  this is line number 5
 @@ -8,7 +7,7 @@
  this is line number 7
  this is line number 8
@@ skipping 60 matching lines @@
     # Special mocks.
     def MockAbsPath(f):
       return f
     def MockChdir(f):
       return None
     # SuperMoxTestBase already mock these but simplify our life.
     presubmit.os.path.abspath = MockAbsPath
     presubmit.os.getcwd = self.RootDir
     presubmit.os.chdir = MockChdir
     self.mox.StubOutWithMock(presubmit.scm, 'determine_scm')
-    self.mox.StubOutWithMock(presubmit.scm.SVN, '_CaptureInfo')
-    self.mox.StubOutWithMock(presubmit.scm.SVN, 'GetFileProperty')
     self.mox.StubOutWithMock(presubmit.gclient_utils, 'FileRead')
     self.mox.StubOutWithMock(presubmit.gclient_utils, 'FileWrite')
-    self.mox.StubOutWithMock(presubmit.scm.SVN, 'GenerateDiff')
     self.mox.StubOutWithMock(presubmit.scm.GIT, 'GenerateDiff')
 
     # On some platforms this does all sorts of undesirable system calls, so
     # just permanently mock it with a lambda that returns 2
     multiprocessing.cpu_count = lambda: 2
 
 
 class PresubmitUnittest(PresubmitTestsBase):
   """General presubmit_support.py tests (excluding InputApi and OutputApi)."""
 
   _INHERIT_SETTINGS = 'inherit-review-settings-ok'
 
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AffectedFile', 'Change', 'DoGetTrySlaves',
       'DoPostUploadExecuter', 'DoPresubmitChecks', 'GetPostUploadExecuter',
       'GetTrySlavesExecuter', 'GitAffectedFile', 'CallCommand', 'CommandData',
       'GitChange', 'InputApi', 'ListRelevantPresubmitFiles', 'main',
       'NonexistantCannedCheckFilter', 'OutputApi', 'ParseFiles',
       'PresubmitFailure', 'PresubmitExecuter', 'PresubmitOutput', 'ScanSubDirs',
-      'SvnAffectedFile', 'SvnChange', 'auth', 'cPickle', 'cpplint', 'cStringIO',
+      'auth', 'cPickle', 'cpplint', 'cStringIO',
       'contextlib', 'canned_check_filter', 'fix_encoding', 'fnmatch',
       'gclient_utils', 'glob', 'inspect', 'json', 'load_files', 'logging',
       'marshal', 'normpath', 'optparse', 'os', 'owners', 'pickle',
       'presubmit_canned_checks', 'random', 're', 'rietveld', 'scm',
       'subprocess', 'sys', 'tempfile', 'time', 'traceback', 'types', 'unittest',
       'urllib2', 'warn', 'multiprocessing', 'DoGetTryMasters',
       'GetTryMastersExecuter', 'itertools', 'urlparse', 'gerrit_util',
       'GerritAccessor',
     ]
     # If this test fails, you should add the relevant test.
@@ skipping 111 matching lines @@
           join(sys_root_dir, 'foo', 'bar', 'moo', 'PRESUBMIT.py')
         ])
 
   def testTagLineRe(self):
     self.mox.ReplayAll()
     m = presubmit.Change.TAG_LINE_RE.match(' BUG =1223, 1445  \t')
     self.failUnless(m)
     self.failUnlessEqual(m.group('key'), 'BUG')
     self.failUnlessEqual(m.group('value'), '1223, 1445')
 
-  def testGclChange(self):
-    description_lines = ('Hello there',
-                         'this is a change',
-                         'BUG=123',
-                         ' STORY =http://foo/  \t',
-                         'and some more regular text  \t')
-    files = [
-      ['A', 'foo/blat.cc'],
-      ['M', 'binary.dll'],  # a binary file
-      ['A', 'isdir'],  # a directory
-      ['?', 'flop/notfound.txt'],  # not found in SVN, still exists locally
-      ['D', 'boo/flap.h'],
-    ]
-    blat = presubmit.os.path.join('foo', 'blat.cc')
-    notfound = presubmit.os.path.join('flop', 'notfound.txt')
-    flap = presubmit.os.path.join('boo', 'flap.h')
-    binary = 'binary.dll'
-    isdir = 'isdir'
-    f_blat = presubmit.os.path.join(self.fake_root_dir, blat)
-    f_notfound = presubmit.os.path.join(self.fake_root_dir, notfound)
-    f_flap = presubmit.os.path.join(self.fake_root_dir, flap)
-    f_binary = presubmit.os.path.join(self.fake_root_dir, binary)
-    f_isdir = presubmit.os.path.join(self.fake_root_dir, isdir)
-    presubmit.os.path.exists(f_blat).AndReturn(True)
-    presubmit.os.path.isdir(f_blat).AndReturn(False)
-    presubmit.os.path.exists(f_binary).AndReturn(True)
-    presubmit.os.path.isdir(f_binary).AndReturn(False)
-    presubmit.os.path.exists(f_isdir).AndReturn(True)
-    presubmit.os.path.isdir(f_isdir).AndReturn(True)
-    presubmit.os.path.exists(f_notfound).AndReturn(True)
-    presubmit.os.path.isdir(f_notfound).AndReturn(False)
-    presubmit.os.path.exists(f_flap).AndReturn(False)
-    presubmit.scm.SVN._CaptureInfo([flap], self.fake_root_dir
-        ).AndReturn({'Node Kind': 'file'})
-    presubmit.scm.SVN.GetFileProperty(
-        blat, 'svn:mime-type', self.fake_root_dir).AndReturn(None)
-    presubmit.scm.SVN.GetFileProperty(
-        binary, 'svn:mime-type', self.fake_root_dir
-        ).AndReturn('application/octet-stream')
-    presubmit.scm.SVN.GetFileProperty(
-        notfound, 'svn:mime-type', self.fake_root_dir).AndReturn('')
-    presubmit.scm.SVN._CaptureInfo([blat], self.fake_root_dir).AndReturn(
-            {'URL': 'svn:/foo/foo/blat.cc'})
-    presubmit.scm.SVN._CaptureInfo([binary], self.fake_root_dir).AndReturn(
-        {'URL': 'svn:/foo/binary.dll'})
-    presubmit.scm.SVN._CaptureInfo([notfound], self.fake_root_dir).AndReturn({})
-    presubmit.scm.SVN._CaptureInfo([flap], self.fake_root_dir).AndReturn(
-            {'URL': 'svn:/foo/boo/flap.h'})
-    presubmit.scm.SVN.GenerateDiff([blat], self.fake_root_dir, False, None
-        ).AndReturn(self.presubmit_diffs)
-    presubmit.scm.SVN.GenerateDiff([notfound], self.fake_root_dir, False, None
-        ).AndReturn(self.presubmit_diffs)
-
-    self.mox.ReplayAll()
-
-    change = presubmit.SvnChange(
-        'mychange',
-        '\n'.join(description_lines),
-        self.fake_root_dir,
-        files,
-        0,
-        0,
-        None)
-    self.failUnless(change.Name() == 'mychange')
-    self.failUnless(change.DescriptionText() ==
-                    'Hello there\nthis is a change\nand some more regular text')
-    self.failUnless(change.FullDescriptionText() ==
-                    '\n'.join(description_lines))
-
-    self.failUnless(change.BUG == '123')
-    self.failUnless(change.STORY == 'http://foo/')
-    self.failUnless(change.BLEH == None)
-
-    self.failUnless(len(change.AffectedFiles()) == 4)
-    self.failUnless(len(change.AffectedFiles(include_dirs=True)) == 5)
-    self.failUnless(len(change.AffectedFiles(include_deletes=False)) == 3)
-    self.failUnless(len(change.AffectedFiles(include_dirs=True,
-                                             include_deletes=False)) == 4)
-
-    affected_text_files = change.AffectedTextFiles()
-    self.failUnless(len(affected_text_files) == 2)
-    self.failIf(filter(lambda x: x.LocalPath() == 'binary.dll',
-                       affected_text_files))
-
-    local_paths = change.LocalPaths()
-    expected_paths = [presubmit.normpath(f[1]) for f in files]
-    self.failUnless(
-        len(filter(lambda x: x in expected_paths, local_paths)) == 4)
-
-    server_paths = change.ServerPaths()
-    expected_paths = ['svn:/foo/%s' % f[1] for f in files if
-                      f[1] != 'flop/notfound.txt']
-    expected_paths.append('')  # one unknown file
-    self.assertEqual(
-      len(filter(lambda x: x in expected_paths, server_paths)), 4)
-
-    files = [[x[0], presubmit.normpath(x[1])] for x in files]
-
-    rhs_lines = []
-    for line in change.RightHandSideLines():
-      rhs_lines.append(line)
-    self.assertEquals(rhs_lines[0][0].LocalPath(), files[0][1])
-    self.assertEquals(rhs_lines[0][1], 10)
-    self.assertEquals(rhs_lines[0][2],'this is line number 10')
-
-    self.assertEquals(rhs_lines[3][0].LocalPath(), files[0][1])
-    self.assertEquals(rhs_lines[3][1], 32)
-    self.assertEquals(rhs_lines[3][2], 'this is line number 32.1')
-
-    self.assertEquals(rhs_lines[8][0].LocalPath(), files[3][1])
-    self.assertEquals(rhs_lines[8][1], 23)
-    self.assertEquals(rhs_lines[8][2], 'this is line number 23.1')
-
-    self.assertEquals(rhs_lines[12][0].LocalPath(), files[3][1])
-    self.assertEquals(rhs_lines[12][1], 46)
-    self.assertEquals(rhs_lines[12][2], '')
-
-    self.assertEquals(rhs_lines[13][0].LocalPath(), files[3][1])
-    self.assertEquals(rhs_lines[13][1], 49)
-    self.assertEquals(rhs_lines[13][2], 'this is line number 48.1')
-
   def testGitChange(self):
     description_lines = ('Hello there',
                          'this is a change',
                          'BUG=123',
                          ' STORY =http://foo/  \t',
                          'and some more regular text  \t')
     unified_diff = [
         'diff --git binary_a.png binary_a.png',
         'new file mode 100644',
         'index 0000000..6fbdd6d',
@@ skipping 86 matching lines @@
     files = [('A      ', 'binary_a.png'),
              ('D      ', 'binary_d.png'),
              ('M      ', 'binary_m.png'),
              ('M      ', 'binary_md.png'),  # Binary w/ diff
              ('A      ', 'boo/blat.cc'),
              ('D      ', 'floo/delburt.cc'),
              ('M      ', 'foo/TestExpectations')]
 
     for op, path in files:
       full_path = presubmit.os.path.join(self.fake_root_dir, *path.split('/'))
-      if op.startswith('D'):
-        os.path.exists(full_path).AndReturn(False)
-      else:
-        os.path.exists(full_path).AndReturn(False)
+      if not op.startswith('D'):
         os.path.isfile(full_path).AndReturn(True)
 
     presubmit.scm.GIT.GenerateDiff(
         self.fake_root_dir, files=[], full_move=True, branch=None
         ).AndReturn('\n'.join(unified_diff))
 
     self.mox.ReplayAll()
 
     change = presubmit.GitChange(
         'mychange',
         '\n'.join(description_lines),
         self.fake_root_dir,
         files,
         0,
         0,
         None,
         upstream=None)
     self.failUnless(change.Name() == 'mychange')
     self.failUnless(change.DescriptionText() ==
                     'Hello there\nthis is a change\nand some more regular text')
     self.failUnless(change.FullDescriptionText() ==
                     '\n'.join(description_lines))
 
     self.failUnless(change.BUG == '123')
     self.failUnless(change.STORY == 'http://foo/')
     self.failUnless(change.BLEH == None)
 
     self.failUnless(len(change.AffectedFiles()) == 7)
-    self.failUnless(len(change.AffectedFiles(include_dirs=True)) == 7)
+    self.failUnless(len(change.AffectedFiles()) == 7)
     self.failUnless(len(change.AffectedFiles(include_deletes=False)) == 5)
-    self.failUnless(len(change.AffectedFiles(include_dirs=True,
-                                             include_deletes=False)) == 5)
+    self.failUnless(len(change.AffectedFiles(include_deletes=False)) == 5)
 
     # Note that on git, there's no distinction between binary files and text
     # files; everything that's not a delete is a text file.
-    affected_text_files = change.AffectedTextFiles()
+    affected_text_files = change.AffectedTestableFiles()
     self.failUnless(len(affected_text_files) == 5)
 
     local_paths = change.LocalPaths()
     expected_paths = [os.path.normpath(f) for op, f in files]
     self.assertEqual(local_paths, expected_paths)
 
-    try:
-      _ = change.ServerPaths()
-      self.fail("ServerPaths implemented.")
-    except NotImplementedError:
-      pass
-
     actual_rhs_lines = []
     for f, linenum, line in change.RightHandSideLines():
       actual_rhs_lines.append((f.LocalPath(), linenum, line))
 
     f_blat = os.path.normpath('boo/blat.cc')
     f_test_expectations = os.path.normpath('foo/TestExpectations')
     expected_rhs_lines = [
         (f_blat, 1, 'This is some text'),
         (f_blat, 2, 'which lacks a copyright warning'),
         (f_blat, 3, 'but it is nonetheless interesting'),
@@ skipping 13 matching lines @@
         (f_test_expectations, 21, 'and have this not be interpreted'),
         (f_test_expectations, 22, 'as the start of a new file'),
         (f_test_expectations, 23, 'or anything messed up like that,'),
         (f_test_expectations, 24, 'because you parsed the header'),
         (f_test_expectations, 25, 'correctly.')]
 
     self.assertEquals(expected_rhs_lines, actual_rhs_lines)
 
   def testInvalidChange(self):
     try:
-      presubmit.SvnChange(
+      presubmit.GitChange(
           'mychange',
           'description',
           self.fake_root_dir,
           ['foo/blat.cc', 'bar'],
           0,
           0,
           None)
       self.fail()
     except AssertionError:
       pass
@@ skipping 241 matching lines @@
         'Running presubmit upload checks ...\n'
         'Warning, no PRESUBMIT.py found.\n'
         'Running default presubmit script.\n'
         '\n'
         '** Presubmit ERRORS **\n!!\n\n'
         'Was the presubmit check useful? If not, run "git cl presubmit -v"\n'
         'to figure out which PRESUBMIT.py was run, then run git blame\n'
         'on the file to figure out who to ask for help.\n')
     self.assertEquals(output.getvalue(), text)
 
-  def testDirectoryHandling(self):
-    files = [
-      ['A', 'isdir'],
-      ['A', presubmit.os.path.join('isdir', 'blat.cc')],
-    ]
-    isdir = presubmit.os.path.join(self.fake_root_dir, 'isdir')
-    blat = presubmit.os.path.join(isdir, 'blat.cc')
-    presubmit.os.path.exists(isdir).AndReturn(True)
-    presubmit.os.path.isdir(isdir).AndReturn(True)
-    presubmit.os.path.exists(blat).AndReturn(True)
-    presubmit.os.path.isdir(blat).AndReturn(False)
-    self.mox.ReplayAll()
-
-    change = presubmit.Change(
-        'mychange', 'foo', self.fake_root_dir, files, 0, 0, None)
-    affected_files = change.AffectedFiles(include_dirs=False)
-    self.failUnless(len(affected_files) == 1)
-    self.failUnless(affected_files[0].LocalPath().endswith('blat.cc'))
-    affected_files_and_dirs = change.AffectedFiles(include_dirs=True)
-    self.failUnless(len(affected_files_and_dirs) == 2)
-
   def testTags(self):
     DEFAULT_SCRIPT = """
 def CheckChangeOnUpload(input_api, output_api):
   if input_api.change.tags['BUG'] != 'boo':
     return [output_api.PresubmitError('Tag parsing failed. 1')]
   if input_api.change.tags['STORY'] != 'http://tracker.com/42':
     return [output_api.PresubmitError('Tag parsing failed. 2')]
   if input_api.change.BUG != 'boo':
     return [output_api.PresubmitError('Tag parsing failed. 6')]
   if input_api.change.STORY != 'http://tracker.com/42':
@@ skipping 317 matching lines @@
 
 
 class InputApiUnittest(PresubmitTestsBase):
   """Tests presubmit.InputApi."""
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
         'AbsoluteLocalPaths',
         'AffectedFiles',
         'AffectedSourceFiles',
+        'AffectedTestableFiles',
         'AffectedTextFiles',
         'DEFAULT_BLACK_LIST',
         'DEFAULT_WHITE_LIST',
-        'DepotToLocalPath',
         'FilterSourceFile',
         'LocalPaths',
-        'LocalToDepotPath',
         'Command',
         'RunTests',
         'PresubmitLocalPath',
         'ReadFile',
         'RightHandSideLines',
-        'ServerPaths',
         'ShutdownPool',
         'basename',
         'cPickle',
         'cpplint',
         'cStringIO',
         'canned_checks',
         'change',
         'cpu_count',
         'environ',
         'fnmatch',
@@ skipping 23 matching lines @@
         'version',
         'verbose',
         'dry_run',
         'gerrit',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(
         presubmit.InputApi(self.fake_change, './.', False, None, False),
         members)
 
-  def testDepotToLocalPath(self):
-    presubmit.scm.SVN._CaptureInfo(['svn://foo/smurf'], self.fake_root_dir
-        ).AndReturn({'Path': 'prout'})
-    presubmit.scm.SVN._CaptureInfo(
-        ['svn:/foo/notfound/burp'], self.fake_root_dir
-        ).AndReturn({})
-    self.mox.ReplayAll()
-
-    path = presubmit.InputApi(
-        self.fake_change, './p', False, None, False).DepotToLocalPath(
-            'svn://foo/smurf')
-    self.failUnless(path == 'prout')
-    path = presubmit.InputApi(
-        self.fake_change, './p', False, None, False).DepotToLocalPath(
-            'svn:/foo/notfound/burp')
-    self.failUnless(path == None)
-
-  def testLocalToDepotPath(self):
-    presubmit.scm.SVN._CaptureInfo(['smurf'], self.fake_root_dir
-        ).AndReturn({'URL': 'svn://foo'})
-    presubmit.scm.SVN._CaptureInfo(['notfound-food'], self.fake_root_dir
-        ).AndReturn({})
-    self.mox.ReplayAll()
-    path = presubmit.InputApi(
-        self.fake_change, './p', False, None, False).LocalToDepotPath(
-            'smurf')
-    self.assertEqual(path, 'svn://foo')
-    path = presubmit.InputApi(
-        self.fake_change, './p', False, None, False).LocalToDepotPath(
-            'notfound-food')
-    self.assertEquals(path, None)
-
   def testInputApiConstruction(self):
     self.mox.ReplayAll()
     api = presubmit.InputApi(
         self.fake_change,
         presubmit_path='foo/path/PRESUBMIT.py',
         is_committing=False, rietveld_obj=None, verbose=False)
     self.assertEquals(api.PresubmitLocalPath(), 'foo/path')
     self.assertEquals(api.change, self.fake_change)
     self.assertEquals(api.host_url, 'http://codereview.chromium.org')
 
   def testInputApiPresubmitScriptFiltering(self):
     join = presubmit.os.path.join
     description_lines = ('Hello there',
                          'this is a change',
                          'BUG=123',
                          ' STORY =http://foo/  \t',
                          'and some more regular text')
     files = [
-      ['A', join('foo', 'blat.cc')],
-      ['M', join('foo', 'blat', 'READ_ME2')],
-      ['M', join('foo', 'blat', 'binary.dll')],
-      ['M', join('foo', 'blat', 'weird.xyz')],
-      ['M', join('foo', 'blat', 'another.h')],
-      ['M', join('foo', 'third_party', 'third.cc')],
-      ['D', join('foo', 'mat', 'beingdeleted.txt')],
-      ['M', join('flop', 'notfound.txt')],
-      ['A', join('boo', 'flap.h')],
+      ['A', join('foo', 'blat.cc'), True],
+      ['M', join('foo', 'blat', 'READ_ME2'), True],
+      ['M', join('foo', 'blat', 'binary.dll'), True],
+      ['M', join('foo', 'blat', 'weird.xyz'), True],
+      ['M', join('foo', 'blat', 'another.h'), True],
+      ['M', join('foo', 'third_party', 'third.cc'), True],
+      ['D', join('foo', 'mat', 'beingdeleted.txt'), False],
+      ['M', join('flop', 'notfound.txt'), False],
+      ['A', join('boo', 'flap.h'), True],
     ]
-    blat = presubmit.normpath(join(self.fake_root_dir, files[0][1]))
-    readme = presubmit.normpath(join(self.fake_root_dir, files[1][1]))
-    binary = presubmit.normpath(join(self.fake_root_dir, files[2][1]))
-    weird = presubmit.normpath(join(self.fake_root_dir, files[3][1]))
-    another = presubmit.normpath(join(self.fake_root_dir, files[4][1]))
-    third_party = presubmit.normpath(join(self.fake_root_dir, files[5][1]))
-    beingdeleted = presubmit.normpath(join(self.fake_root_dir, files[6][1]))
-    notfound = presubmit.normpath(join(self.fake_root_dir, files[7][1]))
-    flap = presubmit.normpath(join(self.fake_root_dir, files[8][1]))
-    for i in (blat, readme, binary, weird, another, third_party):
-      presubmit.os.path.exists(i).AndReturn(True)
-      presubmit.os.path.isdir(i).AndReturn(False)
-    presubmit.os.path.exists(beingdeleted).AndReturn(False)
-    presubmit.os.path.exists(notfound).AndReturn(False)
-    presubmit.os.path.exists(flap).AndReturn(True)
-    presubmit.os.path.isdir(flap).AndReturn(False)
-    presubmit.scm.SVN._CaptureInfo(
-        [files[6][1]], self.fake_root_dir).AndReturn({})
-    presubmit.scm.SVN._CaptureInfo(
-        [files[7][1]], self.fake_root_dir).AndReturn({})
-    presubmit.scm.SVN.GetFileProperty(
-        files[0][1], 'svn:mime-type', self.fake_root_dir
-        ).AndReturn(None)
-    presubmit.scm.SVN.GetFileProperty(
-        files[1][1], 'svn:mime-type', self.fake_root_dir
-        ).AndReturn(None)
-    presubmit.scm.SVN.GetFileProperty(
-        files[2][1], 'svn:mime-type', self.fake_root_dir
-        ).AndReturn('application/octet-stream')
-    presubmit.scm.SVN.GetFileProperty(
-        files[3][1], 'svn:mime-type', self.fake_root_dir
-        ).AndReturn(None)
-    presubmit.scm.SVN.GetFileProperty(
-        files[4][1], 'svn:mime-type', self.fake_root_dir
-        ).AndReturn(None)
-    presubmit.scm.SVN.GetFileProperty(
-        files[5][1], 'svn:mime-type', self.fake_root_dir
-        ).AndReturn(None)
-    presubmit.scm.SVN.GenerateDiff(
-        [files[0][1]], self.fake_root_dir, False, None
-        ).AndReturn(self.presubmit_diffs)
-    presubmit.scm.SVN.GenerateDiff(
-        [files[4][1]], self.fake_root_dir, False, None
-        ).AndReturn(self.presubmit_diffs)
+    diffs = []
+    for _, f, exists in files:
+      full_file = presubmit.os.path.join(self.fake_root_dir, f)
+      if exists and f.startswith('foo/'):
+        presubmit.os.path.isfile(full_file).AndReturn(exists)
+      diffs.append(self.presubmit_diffs % {'filename': f})
+    presubmit.scm.GIT.GenerateDiff(
+        self.fake_root_dir, branch=None, files=[], full_move=True
+        ).AndReturn('\n'.join(diffs))
 
     self.mox.ReplayAll()
 
-    change = presubmit.SvnChange(
+    change = presubmit.GitChange(
         'mychange',
         '\n'.join(description_lines),
         self.fake_root_dir,
-        files,
+        [[f[0], f[1]] for f in files],
         0,
         0,
         None)
     input_api = presubmit.InputApi(
         change,
         join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'),
         False, None, False)
     # Doesn't filter much
     got_files = input_api.AffectedFiles()
     self.assertEquals(len(got_files), 7)
@@ skipping 106 matching lines @@
       self.assertEquals(sorted([f.LocalPath().replace(presubmit.os.sep, '/')
                                 for f in results]),
                         sorted(item[1]))
 
   def testCustomFilter(self):
     def FilterSourceFile(affected_file):
       return 'a' in affected_file.LocalPath()
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee')]
     for _, item in files:
       full_item = presubmit.os.path.join(self.fake_root_dir, item)
-      presubmit.os.path.exists(full_item).AndReturn(True)
-      presubmit.os.path.isdir(full_item).AndReturn(False)
-      presubmit.scm.SVN.GetFileProperty(
-          item, 'svn:mime-type', self.fake_root_dir).AndReturn(None)
+      presubmit.os.path.isfile(full_item).AndReturn(True)
     self.mox.ReplayAll()
 
-    change = presubmit.SvnChange(
+    change = presubmit.GitChange(
         'mychange', '', self.fake_root_dir, files, 0, 0, None)
     input_api = presubmit.InputApi(
         change,
         presubmit.os.path.join(self.fake_root_dir, 'PRESUBMIT.py'),
         False, None, False)
     got_files = input_api.AffectedSourceFiles(FilterSourceFile)
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
     self.assertEquals(got_files[1].LocalPath(), 'eeabee')
 
   def testLambdaFilter(self):
     white_list = presubmit.InputApi.DEFAULT_BLACK_LIST + (r".*?a.*?",)
     black_list = [r".*?b.*?"]
     files = [('A', 'eeaee'), ('M', 'eeabee'), ('M', 'eebcee'), ('M', 'eecaee')]
     for _, item in files:
       full_item = presubmit.os.path.join(self.fake_root_dir, item)
-      presubmit.os.path.exists(full_item).AndReturn(True)
-      presubmit.os.path.isdir(full_item).AndReturn(False)
-      presubmit.scm.SVN.GetFileProperty(
-          item, 'svn:mime-type', self.fake_root_dir).AndReturn(None)
+      presubmit.os.path.isfile(full_item).AndReturn(True)
     self.mox.ReplayAll()
 
-    change = presubmit.SvnChange(
+    change = presubmit.GitChange(
         'mychange', '', self.fake_root_dir, files, 0, 0, None)
     input_api = presubmit.InputApi(
         change, './PRESUBMIT.py', False, None, False)
     # Sample usage of overiding the default white and black lists.
     got_files = input_api.AffectedSourceFiles(
         lambda x: input_api.FilterSourceFile(x, white_list, black_list))
     self.assertEquals(len(got_files), 2)
     self.assertEquals(got_files[0].LocalPath(), 'eeaee')
     self.assertEquals(got_files[1].LocalPath(), 'eecaee')
 
   def testGetAbsoluteLocalPath(self):
     join = presubmit.os.path.join
     normpath = presubmit.normpath
     # Regression test for bug of presubmit stuff that relies on invoking
     # SVN (e.g. to get mime type of file) not working unless gcl invoked
     # from the client root (e.g. if you were at 'src' and did 'cd base' before
     # invoking 'gcl upload' it would fail because svn wouldn't find the files
     # the presubmit script was asking about).
     files = [
       ['A', 'isdir'],
       ['A', join('isdir', 'blat.cc')],
       ['M', join('elsewhere', 'ouf.cc')],
     ]
     self.mox.ReplayAll()
 
     change = presubmit.Change(
         'mychange', '', self.fake_root_dir, files, 0, 0, None)
-    affected_files = change.AffectedFiles(include_dirs=True)
+    affected_files = change.AffectedFiles()
     # Local paths should remain the same
     self.assertEquals(affected_files[0].LocalPath(), normpath('isdir'))
     self.assertEquals(affected_files[1].LocalPath(), normpath('isdir/blat.cc'))
     # Absolute paths should be prefixed
     self.assertEquals(affected_files[0].AbsoluteLocalPath(),
                       normpath(join(self.fake_root_dir, 'isdir')))
     self.assertEquals(affected_files[1].AbsoluteLocalPath(),
                       normpath(join(self.fake_root_dir, 'isdir/blat.cc')))
 
     # New helper functions need to work
-    paths_from_change = change.AbsoluteLocalPaths(include_dirs=True)
+    paths_from_change = change.AbsoluteLocalPaths()
     self.assertEqual(len(paths_from_change), 3)
     presubmit_path = join(self.fake_root_dir, 'isdir', 'PRESUBMIT.py')
     api = presubmit.InputApi(
         change=change, presubmit_path=presubmit_path,
         is_committing=True, rietveld_obj=None, verbose=False)
-    paths_from_api = api.AbsoluteLocalPaths(include_dirs=True)
+    paths_from_api = api.AbsoluteLocalPaths()
     self.assertEqual(len(paths_from_api), 2)
     for absolute_paths in [paths_from_change, paths_from_api]:
       self.assertEqual(absolute_paths[0],
                        normpath(join(self.fake_root_dir, 'isdir')))
       self.assertEqual(absolute_paths[1],
                        normpath(join(self.fake_root_dir, 'isdir', 'blat.cc')))
 
   def testDeprecated(self):
     presubmit.warn(mox.IgnoreArg(), category=mox.IgnoreArg(), stacklevel=2)
     self.mox.ReplayAll()
 
     change = presubmit.Change(
         'mychange', '', self.fake_root_dir, [], 0, 0, None)
     api = presubmit.InputApi(
         change,
         presubmit.os.path.join(self.fake_root_dir, 'foo', 'PRESUBMIT.py'), True,
         None, False)
-    api.AffectedTextFiles(include_deletes=False)
+    api.AffectedTestableFiles(include_deletes=False)
 
   def testReadFileStringDenied(self):
     self.mox.ReplayAll()
 
     change = presubmit.Change(
         'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, None)
     input_api = presubmit.InputApi(
         change, presubmit.os.path.join(self.fake_root_dir, '/p'), False,
         None, False)
     self.assertRaises(IOError, input_api.ReadFile, 'boo', 'x')
@@ skipping 108 matching lines @@
     output.prompt_yes_no('prompt: ')
     self.failIf(output.should_continue())
     self.failUnless(output.getvalue().count('???'))
 
 
 class AffectedFileUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     self.mox.ReplayAll()
     members = [
       'AbsoluteLocalPath', 'Action', 'ChangedContents', 'DIFF_CACHE',
-      'GenerateScmDiff', 'IsDirectory', 'IsTextFile', 'LocalPath',
-      'NewContents', 'Property', 'ServerPath',
+      'GenerateScmDiff', 'IsTestableFile', 'IsTextFile', 'LocalPath',
+      'NewContents',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(
         presubmit.AffectedFile('a', 'b', self.fake_root_dir, None), members)
     self.compareMembers(
-        presubmit.SvnAffectedFile('a', 'b', self.fake_root_dir, None), members)
-    self.compareMembers(
         presubmit.GitAffectedFile('a', 'b', self.fake_root_dir, None), members)
 
   def testAffectedFile(self):
     path = presubmit.os.path.join('foo', 'blat.cc')
     f_path = presubmit.os.path.join(self.fake_root_dir, path)
-    presubmit.os.path.exists(f_path).AndReturn(True)
-    presubmit.os.path.isdir(f_path).AndReturn(False)
     presubmit.gclient_utils.FileRead(f_path, 'rU').AndReturn('whatever\ncookie')
-    presubmit.scm.SVN._CaptureInfo([path], self.fake_root_dir).AndReturn(
-        {'URL': 'svn:/foo/foo/blat.cc'})
     self.mox.ReplayAll()
-    af = presubmit.SvnAffectedFile('foo/blat.cc', 'M', self.fake_root_dir, None)
-    self.assertEquals('svn:/foo/foo/blat.cc', af.ServerPath())
+    af = presubmit.GitAffectedFile('foo/blat.cc', 'M', self.fake_root_dir, None)
     self.assertEquals(presubmit.normpath('foo/blat.cc'), af.LocalPath())
     self.assertEquals('M', af.Action())
     self.assertEquals(['whatever', 'cookie'], af.NewContents())
 
   def testAffectedFileNotExists(self):
     notfound = 'notfound.cc'
     f_notfound = presubmit.os.path.join(self.fake_root_dir, notfound)
-    presubmit.os.path.exists(f_notfound).AndReturn(False)
     presubmit.gclient_utils.FileRead(f_notfound, 'rU').AndRaise(IOError)
     self.mox.ReplayAll()
     af = presubmit.AffectedFile(notfound, 'A', self.fake_root_dir, None)
-    self.assertEquals('', af.ServerPath())
     self.assertEquals([], af.NewContents())
 
-  def testProperty(self):
-    presubmit.scm.SVN.GetFileProperty(
-        'foo.cc', 'svn:secret-property', self.fake_root_dir
-        ).AndReturn('secret-property-value')
-    self.mox.ReplayAll()
-    affected_file = presubmit.SvnAffectedFile('foo.cc', 'A', self.fake_root_dir,
-                                              None)
-    # Verify cache coherency.
-    self.assertEquals('secret-property-value',
-                      affected_file.Property('svn:secret-property'))
-    self.assertEquals('secret-property-value',
-                      affected_file.Property('svn:secret-property'))
-
-  def testIsDirectoryNotExists(self):
-    filename = 'foo.cc'
-    f_filename = presubmit.os.path.join(self.fake_root_dir, filename)
-    presubmit.os.path.exists(f_filename).AndReturn(False)
-    presubmit.scm.SVN._CaptureInfo([filename], self.fake_root_dir).AndReturn({})
-    self.mox.ReplayAll()
-    affected_file = presubmit.SvnAffectedFile(filename, 'A', self.fake_root_dir,
-                                              None)
-    # Verify cache coherency.
-    self.failIf(affected_file.IsDirectory())
-    self.failIf(affected_file.IsDirectory())
-
-  def testIsDirectory(self):
-    filename = 'foo.cc'
-    f_filename = presubmit.os.path.join(self.fake_root_dir, filename)
-    presubmit.os.path.exists(f_filename).AndReturn(True)
-    presubmit.os.path.isdir(f_filename).AndReturn(True)
-    self.mox.ReplayAll()
-    affected_file = presubmit.SvnAffectedFile(filename, 'A', self.fake_root_dir,
-                                              None)
-    # Verify cache coherency.
-    self.failUnless(affected_file.IsDirectory())
-    self.failUnless(affected_file.IsDirectory())
-
-  def testIsTextFile(self):
+  def testIsTestableFile(self):
     files = [
-        presubmit.SvnAffectedFile('foo/blat.txt', 'M', self.fake_root_dir,
+        presubmit.GitAffectedFile('foo/blat.txt', 'M', self.fake_root_dir,
                                   None),
-        presubmit.SvnAffectedFile('foo/binary.blob', 'M', self.fake_root_dir,
+        presubmit.GitAffectedFile('foo/binary.blob', 'M', self.fake_root_dir,
                                   None),
-        presubmit.SvnAffectedFile('blat/flop.txt', 'D', self.fake_root_dir,
+        presubmit.GitAffectedFile('blat/flop.txt', 'D', self.fake_root_dir,
                                   None)
     ]
     blat = presubmit.os.path.join('foo', 'blat.txt')
     blob = presubmit.os.path.join('foo', 'binary.blob')
     f_blat = presubmit.os.path.join(self.fake_root_dir, blat)
     f_blob = presubmit.os.path.join(self.fake_root_dir, blob)
-    presubmit.os.path.exists(f_blat).AndReturn(True)
-    presubmit.os.path.isdir(f_blat).AndReturn(False)
-    presubmit.os.path.exists(f_blob).AndReturn(True)
-    presubmit.os.path.isdir(f_blob).AndReturn(False)
-    presubmit.scm.SVN.GetFileProperty(blat, 'svn:mime-type', self.fake_root_dir
-        ).AndReturn(None)
-    presubmit.scm.SVN.GetFileProperty(blob, 'svn:mime-type', self.fake_root_dir
-        ).AndReturn('application/octet-stream')
+    presubmit.os.path.isfile(f_blat).AndReturn(True)
+    presubmit.os.path.isfile(f_blob).AndReturn(True)
     self.mox.ReplayAll()
 
-    output = filter(lambda x: x.IsTextFile(), files)
-    self.assertEquals(1, len(output))
+    output = filter(lambda x: x.IsTestableFile(), files)
+    self.assertEquals(2, len(output))
     self.assertEquals(files[0], output[0])
 
 
 class ChangeUnittest(PresubmitTestsBase):
   def testMembersChanged(self):
     members = [
-        'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTextFiles', 'AllFiles',
-        'DescriptionText', 'FullDescriptionText', 'LocalPaths', 'Name',
-        'RepositoryRoot', 'RightHandSideLines', 'ServerPaths',
+        'AbsoluteLocalPaths', 'AffectedFiles', 'AffectedTestableFiles',
+        'AffectedTextFiles',
+        'AllFiles', 'DescriptionText', 'FullDescriptionText', 'LocalPaths',
+        'Name', 'RepositoryRoot', 'RightHandSideLines',
         'SetDescriptionText', 'TAG_LINE_RE',
         'author_email', 'issue', 'patchset', 'scm', 'tags',
     ]
     # If this test fails, you should add the relevant test.
     self.mox.ReplayAll()
 
     change = presubmit.Change(
         'foo', 'foo', self.fake_root_dir, [('M', 'AA')], 0, 0, 'foo')
     self.compareMembers(change, members)
 
   def testMembers(self):
     change = presubmit.Change(
         'foo1', 'foo2\nDRU=ro', self.fake_root_dir, [('Y', 'AA')], 3, 5, 'foo3')
     self.assertEquals('foo1', change.Name())
     self.assertEquals('foo2', change.DescriptionText())
     self.assertEquals('foo3', change.author_email)
     self.assertEquals('ro', change.DRU)
     self.assertEquals(3, change.issue)
     self.assertEquals(5, change.patchset)
     self.assertEquals(self.fake_root_dir, change.RepositoryRoot())
-    self.assertEquals(1, len(change.AffectedFiles(include_dirs=True)))
-    self.assertEquals('Y', change.AffectedFiles(include_dirs=True)[0].Action())
+    self.assertEquals(1, len(change.AffectedFiles()))
+    self.assertEquals('Y', change.AffectedFiles()[0].Action())
 
   def testSetDescriptionText(self):
     change = presubmit.Change(
         '', 'foo\nDRU=ro', self.fake_root_dir, [], 3, 5, '')
     self.assertEquals('foo', change.DescriptionText())
     self.assertEquals('foo\nDRU=ro', change.FullDescriptionText())
     self.assertEquals('ro', change.DRU)
 
     change.SetDescriptionText('bar\nWHIZ=bang')
     self.assertEquals('bar', change.DescriptionText())
@@ skipping 57 matching lines @@
       'BLACKLIST_LINT_FILTERS',
       'CheckBuildbotPendingBuilds',
       'CheckChangeHasBugField', 'CheckChangeHasDescription',
       'CheckChangeHasNoStrayWhitespace',
       'CheckChangeHasOnlyOneEol', 'CheckChangeHasNoCR',
       'CheckChangeHasNoCrAndHasOnlyOneEol', 'CheckChangeHasNoTabs',
       'CheckChangeTodoHasOwner',
       'CheckChangeHasQaField', 'CheckChangeHasTestedField',
       'CheckChangeHasTestField',
       'CheckChangeLintsClean',
-      'CheckChangeSvnEolStyle',
       'CheckChangeWasUploaded',
       'CheckDoNotSubmit',
       'CheckDoNotSubmitInDescription', 'CheckDoNotSubmitInFiles',
       'CheckGenderNeutral',
       'CheckLongLines', 'CheckTreeIsOpen', 'PanProjectChecks',
       'CheckLicense',
       'CheckOwners',
       'CheckPatchFormatted',
       'CheckGNFormatted',
       'CheckRietveldTryJobExecution',
       'CheckSingletonInHeaders',
-      'CheckSvnForCommonMimeTypes', 'CheckSvnProperty',
       'RunPythonUnitTests', 'RunPylint',
       'RunUnitTests', 'RunUnitTestsInDirectory',
       'GetCodereviewOwnerAndReviewers',
       'GetPythonUnitTests', 'GetPylint',
       'GetUnitTests', 'GetUnitTestsInDirectory', 'GetUnitTestsRecursively',
     ]
     # If this test fails, you should add the relevant test.
     self.compareMembers(presubmit_canned_checks, members)
 
   def DescriptionTest(self, check, description1, description2, error_type,
@@ skipping 20 matching lines @@
         check: the check to run.
         content1: content which is expected to pass the check.
         content1_path: file path for content1.
         content2: content which is expected to fail the check.
         content2_path: file path for content2.
         error_type: the type of the error expected for content2.
     """
     change1 = presubmit.Change(
         'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
-    affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file = self.mox.CreateMock(presubmit.GitAffectedFile)
     input_api1.AffectedFiles(
         include_deletes=False,
         file_filter=mox.IgnoreArg()).AndReturn([affected_file])
     affected_file.LocalPath().AndReturn(content1_path)
     affected_file.NewContents().AndReturn([
         'afoo',
         content1,
         'bfoo',
         'cfoo',
         'dfoo'])
@@ skipping 26 matching lines @@
     results1 = check(input_api1, presubmit.OutputApi, None)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi, None)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
   def ReadFileTest(self, check, content1, content2, error_type):
     change1 = presubmit.Change(
         'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
-    affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file1 = self.mox.CreateMock(presubmit.GitAffectedFile)
     input_api1.AffectedSourceFiles(None).AndReturn([affected_file1])
     input_api1.ReadFile(affected_file1, 'rb').AndReturn(content1)
     change2 = presubmit.Change(
         'foo2', 'foo2\n', self.fake_root_dir, None, 0, 0, None)
     input_api2 = self.MockInputApi(change2, False)
-    affected_file2 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file2 = self.mox.CreateMock(presubmit.GitAffectedFile)
     input_api2.AffectedSourceFiles(None).AndReturn([affected_file2])
     input_api2.ReadFile(affected_file2, 'rb').AndReturn(content2)
     affected_file2.LocalPath().AndReturn('bar.cc')
     self.mox.ReplayAll()
 
     results = check(input_api1, presubmit.OutputApi)
     self.assertEquals(results, [])
     results2 = check(input_api2, presubmit.OutputApi)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
-  def SvnPropertyTest(self, check, property_name, value1, value2, committing,
-                      error_type, use_source_file):
-    change1 = presubmit.SvnChange(
-        'mychange', '', self.fake_root_dir, [], 0, 0, None)
-    input_api1 = self.MockInputApi(change1, committing)
-    files1 = [
-      presubmit.SvnAffectedFile('foo/bar.cc', 'A', self.fake_root_dir, None),
-      presubmit.SvnAffectedFile('foo.cc', 'M', self.fake_root_dir, None),
-    ]
-    if use_source_file:
-      input_api1.AffectedSourceFiles(None).AndReturn(files1)
-    else:
-      input_api1.AffectedFiles(include_deletes=False).AndReturn(files1)
-    presubmit.scm.SVN.GetFileProperty(
-        presubmit.normpath('foo/bar.cc'), property_name, self.fake_root_dir
-        ).AndReturn(value1)
-    presubmit.scm.SVN.GetFileProperty(
-        presubmit.normpath('foo.cc'), property_name, self.fake_root_dir
-        ).AndReturn(value1)
-    change2 = presubmit.SvnChange(
-        'mychange', '', self.fake_root_dir, [], 0, 0, None)
-    input_api2 = self.MockInputApi(change2, committing)
-    files2 = [
-      presubmit.SvnAffectedFile('foo/bar.cc', 'A', self.fake_root_dir, None),
-      presubmit.SvnAffectedFile('foo.cc', 'M', self.fake_root_dir, None),
-    ]
-    if use_source_file:
-      input_api2.AffectedSourceFiles(None).AndReturn(files2)
-    else:
-      input_api2.AffectedFiles(include_deletes=False).AndReturn(files2)
-
-    presubmit.scm.SVN.GetFileProperty(
-        presubmit.normpath('foo/bar.cc'), property_name, self.fake_root_dir
-        ).AndReturn(value2)
-    presubmit.scm.SVN.GetFileProperty(
-        presubmit.normpath('foo.cc'), property_name, self.fake_root_dir
-        ).AndReturn(value2)
-    self.mox.ReplayAll()
-
-    results1 = check(input_api1, presubmit.OutputApi, None)
-    self.assertEquals(results1, [])
-    results2 = check(input_api2, presubmit.OutputApi, None)
-    self.assertEquals(len(results2), 1)
-    self.assertEquals(results2[0].__class__, error_type)
-
   def testCannedCheckChangeHasBugField(self):
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasBugField,
                          'Foo\nBUG=1234', 'Foo\n',
                          presubmit.OutputApi.PresubmitNotifyResult,
                          False)
 
   def testCheckChangeHasDescription(self):
     self.DescriptionTest(presubmit_canned_checks.CheckChangeHasDescription,
                          'Bleh', '',
                          presubmit.OutputApi.PresubmitNotifyResult,
@@ skipping 69 matching lines @@
 
   def testCannedCheckChangeHasNoTabs(self):
     self.ContentTest(presubmit_canned_checks.CheckChangeHasNoTabs,
                      'blah blah', None, 'blah\tblah', None,
                      presubmit.OutputApi.PresubmitPromptWarning)
 
     # Make sure makefiles are ignored.
     change1 = presubmit.Change(
         'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
-    affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file1 = self.mox.CreateMock(presubmit.GitAffectedFile)
     affected_file1.LocalPath().AndReturn('foo.cc')
-    affected_file2 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file2 = self.mox.CreateMock(presubmit.GitAffectedFile)
     affected_file2.LocalPath().AndReturn('foo/Makefile')
-    affected_file3 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file3 = self.mox.CreateMock(presubmit.GitAffectedFile)
     affected_file3.LocalPath().AndReturn('makefile')
     # Only this one will trigger.
-    affected_file4 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file4 = self.mox.CreateMock(presubmit.GitAffectedFile)
     affected_file1.LocalPath().AndReturn('foo.cc')
     affected_file1.NewContents().AndReturn(['yo, '])
     affected_file4.LocalPath().AndReturn('makefile.foo')
     affected_file4.LocalPath().AndReturn('makefile.foo')
     affected_file4.NewContents().AndReturn(['ye\t'])
     affected_file4.ChangedContents().AndReturn([(46, 'ye\t')])
     affected_file4.LocalPath().AndReturn('makefile.foo')
     affected_files = (affected_file1, affected_file2,
                       affected_file3, affected_file4)
 
-    def test(include_dirs=False, include_deletes=True, file_filter=None):
+    def test(include_deletes=True, file_filter=None):
       self.assertFalse(include_deletes)
       for x in affected_files:
         if file_filter(x):
           yield x
     # Override the mock of these functions.
     input_api1.FilterSourceFile = lambda x: x
     input_api1.AffectedFiles = test
     self.mox.ReplayAll()
 
     results1 = presubmit_canned_checks.CheckChangeHasNoTabs(input_api1,
@@ skipping 86 matching lines @@
   def testCannedCheckLongLinesLongSymbol(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
     self.ContentTest(
         check,
         ' TUP5D_LoNG_SY ',
         None,
         ' TUP5D_LoNG_SY5 ',
         None,
         presubmit.OutputApi.PresubmitPromptWarning)
 
-  def testCheckChangeSvnEolStyleCommit(self):
-    # Test CheckSvnProperty at the same time.
-    self.SvnPropertyTest(presubmit_canned_checks.CheckChangeSvnEolStyle,
-                         'svn:eol-style', 'LF', '', True,
-                         presubmit.OutputApi.PresubmitError, True)
-
-  def testCheckChangeSvnEolStyleUpload(self):
-    self.SvnPropertyTest(presubmit_canned_checks.CheckChangeSvnEolStyle,
-                         'svn:eol-style', 'LF', '', False,
-                         presubmit.OutputApi.PresubmitNotifyResult, True)
-
   def _LicenseCheck(self, text, license_text, committing, expected_result,
       **kwargs):
-    change = self.mox.CreateMock(presubmit.SvnChange)
+    change = self.mox.CreateMock(presubmit.GitChange)
     change.scm = 'svn'
     input_api = self.MockInputApi(change, committing)
-    affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file = self.mox.CreateMock(presubmit.GitAffectedFile)
     input_api.AffectedSourceFiles(42).AndReturn([affected_file])
     input_api.ReadFile(affected_file, 'rb').AndReturn(text)
     if expected_result:
       affected_file.LocalPath().AndReturn('bleh')
 
     self.mox.ReplayAll()
     result = presubmit_canned_checks.CheckLicense(
                  input_api, presubmit.OutputApi, license_text,
                  source_file_filter=42,
                  **kwargs)
@@ skipping 45 matching lines @@
                        presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckLicenseEmptySuccess(self):
     text = ''
     license_text = (
         r".*? Copyright \(c\) 2037 Nobody." "\n"
         r".*? All Rights Reserved\." "\n"
     )
     self._LicenseCheck(text, license_text, True, None, accept_empty_files=True)
 
-  def testCheckSvnForCommonMimeTypes(self):
-    self.mox.StubOutWithMock(presubmit_canned_checks, 'CheckSvnProperty')
-    input_api = self.MockInputApi(None, False)
-    output_api = presubmit.OutputApi(False)
-    A = lambda x: presubmit.AffectedFile(x, 'M', self.fake_root_dir, None)
-    files = [
-      A('a.pdf'), A('b.bmp'), A('c.gif'), A('d.png'), A('e.jpg'), A('f.jpe'),
-      A('random'), A('g.jpeg'), A('h.ico'),
-    ]
-    input_api.AffectedFiles(include_deletes=False).AndReturn(files)
-    presubmit_canned_checks.CheckSvnProperty(
-        input_api, output_api, 'svn:mime-type', 'application/pdf', [files[0]]
-        ).AndReturn([1])
-    presubmit_canned_checks.CheckSvnProperty(
-        input_api, output_api, 'svn:mime-type', 'image/bmp', [files[1]]
-        ).AndReturn([2])
-    presubmit_canned_checks.CheckSvnProperty(
-        input_api, output_api, 'svn:mime-type', 'image/gif', [files[2]]
-        ).AndReturn([3])
-    presubmit_canned_checks.CheckSvnProperty(
-        input_api, output_api, 'svn:mime-type', 'image/png', [files[3]]
-        ).AndReturn([4])
-    presubmit_canned_checks.CheckSvnProperty(
-        input_api, output_api, 'svn:mime-type', 'image/jpeg',
-        [files[4], files[5], files[7]]
-        ).AndReturn([5])
-    presubmit_canned_checks.CheckSvnProperty(
-        input_api, output_api, 'svn:mime-type', 'image/vnd.microsoft.icon',
-        [files[8]]).AndReturn([6])
-    self.mox.ReplayAll()
-
-    results = presubmit_canned_checks.CheckSvnForCommonMimeTypes(
-        input_api, output_api)
-    self.assertEquals(results, [1, 2, 3, 4, 5, 6])
-
   def testCannedCheckTreeIsOpenOpen(self):
     input_api = self.MockInputApi(None, True)
     connection = self.mox.CreateMockAnything()
     input_api.urllib2.urlopen('url_to_open').AndReturn(connection)
     connection.read().AndReturn('The tree is open')
     connection.close()
     self.mox.ReplayAll()
     results = presubmit_canned_checks.CheckTreeIsOpen(
         input_api, presubmit.OutputApi, url='url_to_open', closed='.*closed.*')
     self.assertEquals(results, [])
@@ skipping 192 matching lines @@
     if uncovered_files is None:
       uncovered_files = set()
     if manually_specified_reviewers is None:
       manually_specified_reviewers = []
 
     change = self.mox.CreateMock(presubmit.Change)
     change.issue = issue
     change.author_email = 'john@example.com'
     change.R = ','.join(manually_specified_reviewers)
     change.TBR = ''
-    affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file = self.mox.CreateMock(presubmit.GitAffectedFile)
     input_api = self.MockInputApi(change, False)
     if gerrit_response:
       assert not rietveld_response
       input_api.rietveld = None
       input_api.gerrit = presubmit.GerritAccessor('host')
 
     fake_db = self.mox.CreateMock(owners.Database)
     fake_db.email_regexp = input_api.re.compile(owners.BASIC_EMAIL_REGEXP)
     input_api.owners_db = fake_db
     input_api.is_committing = is_committing
@@ skipping 375 matching lines @@
     self.assertEqual(1, len(results))
     self.assertEqual(
         presubmit.OutputApi.PresubmitNotifyResult, results[0].__class__)
     self.checkstdout('')
 
   def testPanProjectChecks(self):
     # Make sure it accepts both list and tuples.
     change = presubmit.Change(
         'foo1', 'description1', self.fake_root_dir, None, 0, 0, None)
     input_api = self.MockInputApi(change, False)
-    affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file = self.mox.CreateMock(presubmit.GitAffectedFile)
     for _ in range(3):
       input_api.AffectedFiles(file_filter=mox.IgnoreArg(), include_deletes=False
           ).AndReturn([affected_file])
       affected_file.LocalPath()
       affected_file.NewContents().AndReturn('Hey!\nHo!\nHey!\nHo!\n\n')
     affected_file.ChangedContents().AndReturn([
         (0, 'Hey!\n'),
         (1, 'Ho!\n'),
         (2, 'Hey!\n'),
         (3, 'Ho!\n'),
         (4, '\n')])
     for _ in range(5):
       affected_file.LocalPath().AndReturn('hello.py')
     input_api.AffectedSourceFiles(mox.IgnoreArg()).AndReturn([affected_file])
     input_api.ReadFile(affected_file).AndReturn('Hey!\nHo!\nHey!\nHo!\n\n')
-
-    input_api.AffectedSourceFiles(mox.IgnoreArg()).AndReturn([affected_file])
-
     input_api.AffectedSourceFiles(mox.IgnoreArg()).AndReturn([affected_file])
     input_api.ReadFile(affected_file, 'rb').AndReturn(
         'Hey!\nHo!\nHey!\nHo!\n\n')
     affected_file.LocalPath()
 
     self.mox.ReplayAll()
     results = presubmit_canned_checks.PanProjectChecks(
         input_api,
         presubmit.OutputApi,
         excluded_paths=None,
         text_files=None,
         license_header=None,
         project_name=None,
         owners_check=False)
     self.assertEqual(2, len(results))
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()