You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
557 lines
18 KiB
Python
557 lines
18 KiB
Python
#!/usr/bin/env python
|
|
# coding: utf-8
|
|
# 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 patch.py."""
|
|
|
|
import logging
|
|
import os
|
|
import posixpath
|
|
import sys
|
|
import unittest
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
|
|
|
from testing_support.patches_data import GIT, RAW
|
|
|
|
import patch
|
|
|
|
|
|
class PatchTest(unittest.TestCase):
|
|
def _check_patch(self,
|
|
p,
|
|
filename,
|
|
diff,
|
|
source_filename=None,
|
|
is_binary=False,
|
|
is_delete=False,
|
|
is_git_diff=False,
|
|
is_new=False,
|
|
patchlevel=0,
|
|
svn_properties=None,
|
|
nb_hunks=None):
|
|
self.assertEquals(p.filename, filename)
|
|
self.assertEquals(p.source_filename, source_filename)
|
|
self.assertEquals(p.is_binary, is_binary)
|
|
self.assertEquals(p.is_delete, is_delete)
|
|
if hasattr(p, 'is_git_diff'):
|
|
self.assertEquals(p.is_git_diff, is_git_diff)
|
|
self.assertEquals(p.is_new, is_new)
|
|
if hasattr(p, 'patchlevel'):
|
|
self.assertEquals(p.patchlevel, patchlevel)
|
|
if diff:
|
|
if is_binary:
|
|
self.assertEquals(p.get(), diff)
|
|
else:
|
|
self.assertEquals(p.get(True), diff)
|
|
if hasattr(p, 'hunks'):
|
|
self.assertEquals(len(p.hunks), nb_hunks)
|
|
else:
|
|
self.assertEquals(None, nb_hunks)
|
|
if hasattr(p, 'svn_properties'):
|
|
self.assertEquals(p.svn_properties, svn_properties or [])
|
|
|
|
def testFilePatchDelete(self):
|
|
p = patch.FilePatchDelete('foo', False)
|
|
self._check_patch(p, 'foo', None, is_delete=True)
|
|
|
|
def testFilePatchDeleteBin(self):
|
|
p = patch.FilePatchDelete('foo', True)
|
|
self._check_patch(p, 'foo', None, is_delete=True, is_binary=True)
|
|
|
|
def testFilePatchBinary(self):
|
|
p = patch.FilePatchBinary('foo', 'data', [], is_new=False)
|
|
self._check_patch(p, 'foo', 'data', is_binary=True)
|
|
|
|
def testFilePatchBinaryNew(self):
|
|
p = patch.FilePatchBinary('foo', 'data', [], is_new=True)
|
|
self._check_patch(p, 'foo', 'data', is_binary=True, is_new=True)
|
|
|
|
def testFilePatchDiff(self):
|
|
p = patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, [])
|
|
self._check_patch(p, 'chrome/file.cc', RAW.PATCH, nb_hunks=1)
|
|
|
|
def testDifferent(self):
|
|
name = 'master/unittests/data/processes-summary.dat'
|
|
p = patch.FilePatchDiff(name, RAW.DIFFERENT, [])
|
|
self._check_patch(p, name, RAW.DIFFERENT, nb_hunks=1)
|
|
|
|
def testFilePatchDiffHeaderMode(self):
|
|
p = patch.FilePatchDiff('git_cl/git-cl', GIT.MODE_EXE, [])
|
|
self._check_patch(
|
|
p, 'git_cl/git-cl', GIT.MODE_EXE, is_git_diff=True, patchlevel=1,
|
|
svn_properties=[('svn:executable', '.')], nb_hunks=0)
|
|
|
|
def testFilePatchDiffHeaderModeIndex(self):
|
|
p = patch.FilePatchDiff('git_cl/git-cl', GIT.MODE_EXE_JUNK, [])
|
|
self._check_patch(
|
|
p, 'git_cl/git-cl', GIT.MODE_EXE_JUNK, is_git_diff=True, patchlevel=1,
|
|
svn_properties=[('svn:executable', '.')], nb_hunks=0)
|
|
|
|
def testFilePatchDiffHeaderNotExecutable(self):
|
|
p = patch.FilePatchDiff(
|
|
'build/android/ant/create.js', GIT.NEW_NOT_EXECUTABLE, [])
|
|
self._check_patch(
|
|
p, 'build/android/ant/create.js', GIT.NEW_NOT_EXECUTABLE,
|
|
is_git_diff=True, patchlevel=1, is_new=True,
|
|
nb_hunks=1)
|
|
|
|
def testFilePatchDiffSvnNew(self):
|
|
# The code path is different for git and svn.
|
|
p = patch.FilePatchDiff('foo', RAW.NEW, [])
|
|
self._check_patch(p, 'foo', RAW.NEW, is_new=True, nb_hunks=1)
|
|
|
|
def testFilePatchDiffGitNew(self):
|
|
# The code path is different for git and svn.
|
|
p = patch.FilePatchDiff('foo', GIT.NEW, [])
|
|
self._check_patch(
|
|
p, 'foo', GIT.NEW, is_new=True, is_git_diff=True, patchlevel=1,
|
|
nb_hunks=1)
|
|
|
|
def testSvn(self):
|
|
# Should not throw.
|
|
p = patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, [])
|
|
lines = RAW.PATCH.splitlines(True)
|
|
header = ''.join(lines[:4])
|
|
hunks = ''.join(lines[4:])
|
|
self.assertEquals(header, p.diff_header)
|
|
self.assertEquals(hunks, p.diff_hunks)
|
|
self.assertEquals(RAW.PATCH, p.get(True))
|
|
self.assertEquals(RAW.PATCH, p.get(False))
|
|
|
|
def testSvnNew(self):
|
|
p = patch.FilePatchDiff('chrome/file.cc', RAW.MINIMAL_NEW, [])
|
|
self.assertEquals(RAW.MINIMAL_NEW, p.diff_header)
|
|
self.assertEquals('', p.diff_hunks)
|
|
self.assertEquals(RAW.MINIMAL_NEW, p.get(True))
|
|
self.assertEquals(RAW.MINIMAL_NEW, p.get(False))
|
|
|
|
def testSvnDelete(self):
|
|
p = patch.FilePatchDiff('chrome/file.cc', RAW.MINIMAL_DELETE, [])
|
|
self.assertEquals(RAW.MINIMAL_DELETE, p.diff_header)
|
|
self.assertEquals('', p.diff_hunks)
|
|
self.assertEquals(RAW.MINIMAL_DELETE, p.get(True))
|
|
self.assertEquals(RAW.MINIMAL_DELETE, p.get(False))
|
|
|
|
def testSvnRename(self):
|
|
p = patch.FilePatchDiff('file_b', RAW.MINIMAL_RENAME, [])
|
|
self.assertEquals(RAW.MINIMAL_RENAME, p.diff_header)
|
|
self.assertEquals('', p.diff_hunks)
|
|
self.assertEquals(RAW.MINIMAL_RENAME, p.get(True))
|
|
self.assertEquals('--- file_b\n+++ file_b\n', p.get(False))
|
|
|
|
def testRelPath(self):
|
|
patches = patch.PatchSet([
|
|
patch.FilePatchDiff('pp', GIT.COPY, []),
|
|
patch.FilePatchDiff(
|
|
'chromeos\\views/webui_menu_widget.h', GIT.RENAME_PARTIAL, []),
|
|
patch.FilePatchDiff('tools/run_local_server.sh', GIT.RENAME, []),
|
|
patch.FilePatchBinary('bar', 'data', [], is_new=False),
|
|
patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, []),
|
|
patch.FilePatchDiff('foo', GIT.NEW, []),
|
|
patch.FilePatchDelete('other/place/foo', True),
|
|
patch.FilePatchDiff(
|
|
'tools\\clang_check/README.chromium', GIT.DELETE, []),
|
|
])
|
|
expected = [
|
|
'pp',
|
|
'chromeos/views/webui_menu_widget.h',
|
|
'tools/run_local_server.sh',
|
|
'bar',
|
|
'chrome/file.cc',
|
|
'foo',
|
|
'other/place/foo',
|
|
'tools/clang_check/README.chromium',
|
|
]
|
|
self.assertEquals(expected, patches.filenames)
|
|
|
|
# Test patch #4.
|
|
orig_name = patches.patches[4].filename
|
|
orig_source_name = patches.patches[4].source_filename or orig_name
|
|
patches.set_relpath(os.path.join('a', 'bb'))
|
|
# Expect posixpath all the time.
|
|
expected = [posixpath.join('a', 'bb', x) for x in expected]
|
|
self.assertEquals(expected, patches.filenames)
|
|
# Make sure each header is updated accordingly.
|
|
header = []
|
|
new_name = posixpath.join('a', 'bb', orig_name)
|
|
new_source_name = posixpath.join('a', 'bb', orig_source_name)
|
|
for line in RAW.PATCH.splitlines(True):
|
|
if line.startswith('@@'):
|
|
break
|
|
if line[:3] == '---':
|
|
line = line.replace(orig_source_name, new_source_name)
|
|
if line[:3] == '+++':
|
|
line = line.replace(orig_name, new_name)
|
|
header.append(line)
|
|
header = ''.join(header)
|
|
self.assertEquals(header, patches.patches[4].diff_header)
|
|
|
|
def testRelPathEmpty(self):
|
|
patches = patch.PatchSet([
|
|
patch.FilePatchDiff('chrome\\file.cc', RAW.PATCH, []),
|
|
patch.FilePatchDelete('other\\place\\foo', True),
|
|
])
|
|
patches.set_relpath('')
|
|
self.assertEquals(
|
|
['chrome/file.cc', 'other/place/foo'],
|
|
[f.filename for f in patches])
|
|
self.assertEquals([None, None], [f.source_filename for f in patches])
|
|
|
|
def testBackSlash(self):
|
|
mangled_patch = RAW.PATCH.replace('chrome/', 'chrome\\')
|
|
patches = patch.PatchSet([
|
|
patch.FilePatchDiff('chrome\\file.cc', mangled_patch, []),
|
|
patch.FilePatchDelete('other\\place\\foo', True),
|
|
])
|
|
expected = ['chrome/file.cc', 'other/place/foo']
|
|
self.assertEquals(expected, patches.filenames)
|
|
self.assertEquals(RAW.PATCH, patches.patches[0].get(True))
|
|
self.assertEquals(RAW.PATCH, patches.patches[0].get(False))
|
|
|
|
def testTwoHunks(self):
|
|
name = 'chrome/app/generated_resources.grd'
|
|
p = patch.FilePatchDiff(name, RAW.TWO_HUNKS, [])
|
|
self._check_patch(p, name, RAW.TWO_HUNKS, nb_hunks=2)
|
|
|
|
def testGitThreeHunks(self):
|
|
p = patch.FilePatchDiff('presubmit_support.py', GIT.FOUR_HUNKS, [])
|
|
self._check_patch(
|
|
p, 'presubmit_support.py', GIT.FOUR_HUNKS, is_git_diff=True,
|
|
patchlevel=1,
|
|
nb_hunks=4)
|
|
|
|
def testDelete(self):
|
|
p = patch.FilePatchDiff('tools/clang_check/README.chromium', RAW.DELETE, [])
|
|
self._check_patch(
|
|
p, 'tools/clang_check/README.chromium', RAW.DELETE, is_delete=True,
|
|
nb_hunks=1)
|
|
|
|
def testDelete2(self):
|
|
name = 'browser/extensions/extension_sidebar_api.cc'
|
|
p = patch.FilePatchDiff(name, RAW.DELETE2, [])
|
|
self._check_patch(p, name, RAW.DELETE2, is_delete=True, nb_hunks=1)
|
|
|
|
def testGitDelete(self):
|
|
p = patch.FilePatchDiff('tools/clang_check/README.chromium', GIT.DELETE, [])
|
|
self._check_patch(
|
|
p, 'tools/clang_check/README.chromium', GIT.DELETE, is_delete=True,
|
|
is_git_diff=True, patchlevel=1, nb_hunks=1)
|
|
|
|
def testGitRename(self):
|
|
p = patch.FilePatchDiff('tools/run_local_server.sh', GIT.RENAME, [])
|
|
self._check_patch(
|
|
p,
|
|
'tools/run_local_server.sh',
|
|
GIT.RENAME,
|
|
is_git_diff=True,
|
|
patchlevel=1,
|
|
source_filename='tools/run_local_server.PY',
|
|
is_new=True,
|
|
nb_hunks=0)
|
|
|
|
def testGitRenamePartial(self):
|
|
p = patch.FilePatchDiff(
|
|
'chromeos/views/webui_menu_widget.h', GIT.RENAME_PARTIAL, [])
|
|
self._check_patch(
|
|
p,
|
|
'chromeos/views/webui_menu_widget.h',
|
|
GIT.RENAME_PARTIAL,
|
|
source_filename='chromeos/views/DOMui_menu_widget.h',
|
|
is_git_diff=True,
|
|
patchlevel=1,
|
|
is_new=True,
|
|
nb_hunks=1)
|
|
|
|
def testGitCopy(self):
|
|
p = patch.FilePatchDiff('pp', GIT.COPY, [])
|
|
self._check_patch(
|
|
p, 'pp', GIT.COPY, is_git_diff=True, patchlevel=1,
|
|
source_filename='PRESUBMIT.py', is_new=True, nb_hunks=0)
|
|
|
|
def testOnlyHeader(self):
|
|
p = patch.FilePatchDiff('file_a', RAW.MINIMAL, [])
|
|
self._check_patch(p, 'file_a', RAW.MINIMAL, nb_hunks=0)
|
|
|
|
def testSmallest(self):
|
|
p = patch.FilePatchDiff('file_a', RAW.NEW_NOT_NULL, [])
|
|
self._check_patch(p, 'file_a', RAW.NEW_NOT_NULL, is_new=True, nb_hunks=1)
|
|
|
|
def testRenameOnlyHeader(self):
|
|
p = patch.FilePatchDiff('file_b', RAW.MINIMAL_RENAME, [])
|
|
self._check_patch(
|
|
p, 'file_b', RAW.MINIMAL_RENAME, source_filename='file_a', is_new=True,
|
|
nb_hunks=0)
|
|
|
|
def testUnicodeFilenameGet(self):
|
|
p = patch.FilePatchDiff(u'filé_b', RAW.RENAME_UTF8, [])
|
|
self._check_patch(
|
|
p, u'filé_b', RAW.RENAME_UTF8, source_filename=u'file_à', is_new=True,
|
|
nb_hunks=1)
|
|
self.assertTrue(isinstance(p.get(False), str))
|
|
p.set_relpath('foo')
|
|
self.assertTrue(isinstance(p.get(False), str))
|
|
self.assertEquals(u'foo/file_à'.encode('utf-8'), p.source_filename_utf8)
|
|
self.assertEquals(u'foo/file_à', p.source_filename)
|
|
self.assertEquals(u'foo/filé_b'.encode('utf-8'), p.filename_utf8)
|
|
self.assertEquals(u'foo/filé_b', p.filename)
|
|
|
|
def testGitCopyPartial(self):
|
|
p = patch.FilePatchDiff('wtf2', GIT.COPY_PARTIAL, [])
|
|
self._check_patch(
|
|
p, 'wtf2', GIT.COPY_PARTIAL, source_filename='wtf', is_git_diff=True,
|
|
patchlevel=1, is_new=True, nb_hunks=1)
|
|
|
|
def testGitCopyPartialAsSvn(self):
|
|
p = patch.FilePatchDiff('wtf2', GIT.COPY_PARTIAL, [])
|
|
# TODO(maruel): Improve processing.
|
|
diff = (
|
|
'diff --git a/wtf2 b/wtf22\n'
|
|
'similarity index 98%\n'
|
|
'copy from wtf2\n'
|
|
'copy to wtf22\n'
|
|
'index 79fbaf3..3560689 100755\n'
|
|
'--- a/wtf2\n'
|
|
'+++ b/wtf22\n'
|
|
'@@ -1,4 +1,4 @@\n'
|
|
'-#!/usr/bin/env python\n'
|
|
'+#!/usr/bin/env python1.3\n'
|
|
' # Copyright (c) 2010 The Chromium Authors. All rights reserved.\n'
|
|
' # blah blah blah as\n'
|
|
' # found in the LICENSE file.\n')
|
|
self.assertEquals(diff, p.get(False))
|
|
|
|
def testGitNewExe(self):
|
|
p = patch.FilePatchDiff('natsort_test.py', GIT.NEW_EXE, [])
|
|
self._check_patch(
|
|
p,
|
|
'natsort_test.py',
|
|
GIT.NEW_EXE,
|
|
is_new=True,
|
|
is_git_diff=True,
|
|
patchlevel=1,
|
|
svn_properties=[('svn:executable', '.')],
|
|
nb_hunks=1)
|
|
|
|
def testGitNewMode(self):
|
|
p = patch.FilePatchDiff('natsort_test.py', GIT.NEW_MODE, [])
|
|
self._check_patch(
|
|
p, 'natsort_test.py', GIT.NEW_MODE, is_new=True, is_git_diff=True,
|
|
patchlevel=1, nb_hunks=1)
|
|
|
|
def testPatchsetOrder(self):
|
|
# Deletes must be last.
|
|
# File renames/move/copy must be first.
|
|
patches = [
|
|
patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, []),
|
|
patch.FilePatchDiff(
|
|
'tools\\clang_check/README.chromium', GIT.DELETE, []),
|
|
patch.FilePatchDiff('tools/run_local_server.sh', GIT.RENAME, []),
|
|
patch.FilePatchDiff(
|
|
'chromeos\\views/webui_menu_widget.h', GIT.RENAME_PARTIAL, []),
|
|
patch.FilePatchDiff('pp', GIT.COPY, []),
|
|
patch.FilePatchDiff('foo', GIT.NEW, []),
|
|
patch.FilePatchDelete('other/place/foo', True),
|
|
patch.FilePatchBinary('bar', 'data', [], is_new=False),
|
|
]
|
|
expected = [
|
|
'pp',
|
|
'chromeos/views/webui_menu_widget.h',
|
|
'tools/run_local_server.sh',
|
|
'bar',
|
|
'chrome/file.cc',
|
|
'foo',
|
|
'other/place/foo',
|
|
'tools/clang_check/README.chromium',
|
|
]
|
|
patchset = patch.PatchSet(patches)
|
|
self.assertEquals(expected, patchset.filenames)
|
|
|
|
def testGitPatch(self):
|
|
p = patch.FilePatchDiff('chrome/file.cc', GIT.PATCH, [])
|
|
self._check_patch(
|
|
p, 'chrome/file.cc', GIT.PATCH, is_git_diff=True, patchlevel=1,
|
|
nb_hunks=1)
|
|
|
|
def testGitPatchShortHunkHeader(self):
|
|
p = patch.FilePatchDiff(
|
|
'chrome/browser/api/OWNERS', GIT.PATCH_SHORT_HUNK_HEADER, [])
|
|
self._check_patch(
|
|
p, 'chrome/browser/api/OWNERS', GIT.PATCH_SHORT_HUNK_HEADER,
|
|
is_git_diff=True, patchlevel=1, nb_hunks=1)
|
|
|
|
|
|
class PatchTestFail(unittest.TestCase):
|
|
# All patches that should throw.
|
|
def testFilePatchDelete(self):
|
|
self.assertFalse(hasattr(patch.FilePatchDelete('foo', False), 'get'))
|
|
|
|
def testFilePatchDeleteBin(self):
|
|
self.assertFalse(hasattr(patch.FilePatchDelete('foo', True), 'get'))
|
|
|
|
def testFilePatchDiffBad(self):
|
|
try:
|
|
patch.FilePatchDiff('foo', 'data', [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testFilePatchDiffEmpty(self):
|
|
try:
|
|
patch.FilePatchDiff('foo', '', [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testFilePatchDiffNone(self):
|
|
try:
|
|
patch.FilePatchDiff('foo', None, [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testFilePatchBadDiffName(self):
|
|
try:
|
|
patch.FilePatchDiff('foo', RAW.PATCH, [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat, e:
|
|
self.assertEquals(
|
|
"Can't process patch for file foo.\nUnexpected diff: chrome/file.cc.",
|
|
str(e))
|
|
|
|
def testFilePatchDiffBadHeader(self):
|
|
try:
|
|
diff = (
|
|
'+++ b/foo\n'
|
|
'@@ -0,0 +1 @@\n'
|
|
'+bar\n')
|
|
patch.FilePatchDiff('foo', diff, [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testFilePatchDiffBadGitHeader(self):
|
|
try:
|
|
diff = (
|
|
'diff --git a/foo b/foo\n'
|
|
'+++ b/foo\n'
|
|
'@@ -0,0 +1 @@\n'
|
|
'+bar\n')
|
|
patch.FilePatchDiff('foo', diff, [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testFilePatchDiffBadHeaderReversed(self):
|
|
try:
|
|
diff = (
|
|
'+++ b/foo\n'
|
|
'--- b/foo\n'
|
|
'@@ -0,0 +1 @@\n'
|
|
'+bar\n')
|
|
patch.FilePatchDiff('foo', diff, [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testFilePatchDiffGitBadHeaderReversed(self):
|
|
try:
|
|
diff = (
|
|
'diff --git a/foo b/foo\n'
|
|
'+++ b/foo\n'
|
|
'--- b/foo\n'
|
|
'@@ -0,0 +1 @@\n'
|
|
'+bar\n')
|
|
patch.FilePatchDiff('foo', diff, [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testFilePatchDiffInvalidGit(self):
|
|
try:
|
|
patch.FilePatchDiff('svn_utils_test.txt', (
|
|
'diff --git a/tests/svn_utils_test_data/svn_utils_test.txt '
|
|
'b/tests/svn_utils_test_data/svn_utils_test.txt\n'
|
|
'index 0e4de76..8320059 100644\n'
|
|
'--- a/svn_utils_test.txt\n'
|
|
'+++ b/svn_utils_test.txt\n'
|
|
'@@ -3,6 +3,7 @@ bb\n'
|
|
'ccc\n'
|
|
'dd\n'
|
|
'e\n'
|
|
'+FOO!\n'
|
|
'ff\n'
|
|
'ggg\n'
|
|
'hh\n'),
|
|
[])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
try:
|
|
patch.FilePatchDiff('svn_utils_test2.txt', (
|
|
'diff --git a/svn_utils_test_data/svn_utils_test.txt '
|
|
'b/svn_utils_test.txt\n'
|
|
'index 0e4de76..8320059 100644\n'
|
|
'--- a/svn_utils_test.txt\n'
|
|
'+++ b/svn_utils_test.txt\n'
|
|
'@@ -3,6 +3,7 @@ bb\n'
|
|
'ccc\n'
|
|
'dd\n'
|
|
'e\n'
|
|
'+FOO!\n'
|
|
'ff\n'
|
|
'ggg\n'
|
|
'hh\n'),
|
|
[])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testRelPathBad(self):
|
|
patches = patch.PatchSet([
|
|
patch.FilePatchDiff('chrome\\file.cc', RAW.PATCH, []),
|
|
patch.FilePatchDelete('other\\place\\foo', True),
|
|
])
|
|
try:
|
|
patches.set_relpath('..')
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testInverted(self):
|
|
try:
|
|
patch.FilePatchDiff(
|
|
'file_a', '+++ file_a\n--- file_a\n@@ -0,0 +1 @@\n+foo\n', [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testInvertedOnlyHeader(self):
|
|
try:
|
|
patch.FilePatchDiff('file_a', '+++ file_a\n--- file_a\n', [])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
def testBadHunkCommas(self):
|
|
try:
|
|
patch.FilePatchDiff(
|
|
'file_a',
|
|
'--- file_a\n'
|
|
'+++ file_a\n'
|
|
'@@ -0,,0 +1 @@\n'
|
|
'+foo\n',
|
|
[])
|
|
self.fail()
|
|
except patch.UnsupportedPatchFormat:
|
|
pass
|
|
|
|
|
|
if __name__ == '__main__':
|
|
logging.basicConfig(level=
|
|
[logging.WARNING, logging.INFO, logging.DEBUG][
|
|
min(2, sys.argv.count('-v'))])
|
|
unittest.main()
|