while start < limit and line['line'][start] == next_['line'][start]:

            start += 1

        end = -1

        limit -= start

        while -end <= limit and line['line'][end] == next_['line'][end]:

            end -= 1

        end += 1

        if start or end:

            def do(l):

                last = end + len(l['line'])

                if l['action'] == 'add':

                    tag = 'ins'

                else:

                    tag = 'del'

                l['line'] = '%s<%s>%s</%s>%s' % (

                    l['line'][:start],

                    tag,

                    l['line'][start:last],

                    tag,

                    l['line'][last:]

                )

            do(line)

            do(next_)

    def _get_header(self, diff_chunk):

        """

        parses the diff header, and returns parts, and leftover diff

        parts consists of 14 elements::

            a_path, b_path, similarity_index, rename_from, rename_to,

            old_mode, new_mode, new_file_mode, deleted_file_mode,

            a_blob_id, b_blob_id, b_mode, a_file, b_file

        :param diff_chunk:

        """

        match = None

        if self.vcs == 'git':

            match = self._git_header_re.match(diff_chunk)

        elif self.vcs == 'hg':

            match = self._hg_header_re.match(diff_chunk)

        if match is None:

            raise Exception('VCS type %s is not supported' % self.vcs)

        groups = match.groupdict()

        rest = diff_chunk[match.end():]

        if rest and not rest.startswith('@') and not rest.startswith('literal '):

            raise Exception('cannot parse diff header: %r followed by %r' % (diff_chunk[:match.end()], rest[:1000]))

        difflines = imap(self._escaper, rest.splitlines(True))

        return groups, difflines

    def _clean_line(self, line, command):

        if command in ['+', '-', ' ']:

            #only modify the line if it's actually a diff thing

            line = line[1:]

        return line

    def _parse_gitdiff(self, inline_diff=True):

        _files = []

        diff_container = lambda arg: arg

        ##split the diff in chunks of separate --git a/file b/file chunks

        for raw_diff in ('\n' + self._diff).split('\ndiff --git')[1:]:

            head, diff = self._get_header(raw_diff)

            op = None

            stats = {

                'added': 0,

                'deleted': 0,

                'binary': False,

                'ops': {},

            }

            if head['deleted_file_mode']:

                op = 'D'

                stats['binary'] = True

                stats['ops'][DEL_FILENODE] = 'deleted file'

            elif head['new_file_mode']:

                op = 'A'

                stats['binary'] = True

                stats['ops'][NEW_FILENODE] = 'new file %s' % head['new_file_mode']

            else:  # modify operation, can be cp, rename, chmod

                # CHMOD

                if head['new_mode'] and head['old_mode']:

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][CHMOD_FILENODE] = ('modified file chmod %s => %s'

                                        % (head['old_mode'], head['new_mode']))

                # RENAME

                if (head['rename_from'] and head['rename_to']

                      and head['rename_from'] != head['rename_to']):

                    op = 'R'

                    stats['binary'] = True

                    stats['ops'][RENAMED_FILENODE] = ('file renamed from %s to %s'

                                    % (head['rename_from'], head['rename_to']))

                # COPY

                if head.get('copy_from') and head.get('copy_to'):

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][COPIED_FILENODE] = ('file copied from %s to %s'

                                        % (head['copy_from'], head['copy_to']))

                # FALL BACK: detect missed old style add or remove

                if op is None:

                    if not head['a_file'] and head['b_file']:

                        op = 'A'

                        stats['binary'] = True

                        stats['ops'][NEW_FILENODE] = 'new file'

                    elif head['a_file'] and not head['b_file']:

                        op = 'D'

                        stats['binary'] = True

                        stats['ops'][DEL_FILENODE] = 'deleted file'

                # it's not ADD not DELETE

                if op is None:

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][MOD_FILENODE] = 'modified file'

            # a real non-binary diff

            if head['a_file'] or head['b_file']:

                try:

                    chunks, _stats = self._parse_lines(diff)

                    stats['binary'] = False

                    stats['added'] = _stats[0]

                    stats['deleted'] = _stats[1]

                    # explicit mark that it's a modified file

                    if op == 'M':

                        stats['ops'][MOD_FILENODE] = 'modified file'

                except DiffLimitExceeded:

                    diff_container = lambda _diff: \

                        LimitedDiffContainer(self.diff_limit,

                                            self.cur_diff_size, _diff)

                    break

            else:  # GIT binary patch (or empty diff)

                # GIT Binary patch

                if head['bin_patch']:

                    stats['ops'][BIN_FILENODE] = 'binary diff not shown'

                chunks = []

            if op == 'D' and chunks:

                # a way of seeing deleted content could perhaps be nice - but

                # not with the current UI

                chunks = []

            chunks.insert(0, [{

                'old_lineno': '',

                'new_lineno': '',

                'action':     'context',

                'line':       msg,

                } for _op, msg in stats['ops'].iteritems()

                  if _op not in [MOD_FILENODE]])

            _files.append({

                'filename':         head['b_path'],

                'old_revision':     head['a_blob_id'],

                'new_revision':     head['b_blob_id'],

                'chunks':           chunks,

                'operation':        op,

                'stats':            stats,

            })

        if not inline_diff:

            return diff_container(_files)

        # highlight inline changes

        for diff_data in _files:

            for chunk in diff_data['chunks']:

                lineiter = iter(chunk)

                try:

                    while 1:

                        line = lineiter.next()

                        if line['action'] not in ['unmod', 'context']:

                            nextline = lineiter.next()

                            if nextline['action'] in ['unmod', 'context'] or \

                               nextline['action'] == line['action']:

                                continue

                            self.differ(line, nextline)

                except StopIteration:

                    pass

        return diff_container(_files)

    def _parse_udiff(self, inline_diff=True):

        raise NotImplementedError()

    def _parse_lines(self, diff):

        """

        Parse the diff and return data for the template.

        """

        stats = [0, 0]

        try:

            chunks = []

                lines = []

                chunks.append(lines)

                match = self._chunk_re.match(line)

                if not match:

                gr = match.groups()

                (old_line, old_end,

                 new_line, new_end) = [int(x or 1) for x in gr[:-1]]

                old_line -= 1

                new_line -= 1

                context = len(gr) == 5

                old_end += old_line

                new_end += new_line

                if context:

                    # skip context only if it's first line

                    if int(gr[0]) > 1:

                        lines.append({

                            'old_lineno': '...',

                            'new_lineno': '...',

                            'action':     'context',

                            'line':       line,

                        })

                while old_line < old_end or new_line < new_end:

                    affects_old = affects_new = False

                        affects_new = True

                        action = 'add'

                        stats[0] += 1

                    elif command == '-':

                        affects_old = True

                        action = 'del'

                        stats[1] += 1

                        affects_old = affects_new = True

                        action = 'unmod'

                    if not self._newline_marker.match(line):

                        old_line += affects_old

                        new_line += affects_new

                        lines.append({

                            'old_lineno':   affects_old and old_line or '',

                            'new_lineno':   affects_new and new_line or '',

                            'action':       action,

                            'line':         self._clean_line(line, command)

                        })

                    if self._newline_marker.match(line):

                        # we need to append to lines, since this is not

                        # counted in the line specs of diff

                        lines.append({

                            'old_lineno':   '...',

                            'new_lineno':   '...',

                            'action':       'context',

                            'line':         self._clean_line(line, command)

                        })

        except StopIteration:

            pass

        return chunks, stats

    def _safe_id(self, idstring):

        """Make a string safe for including in an id attribute.

        The HTML spec says that id attributes 'must begin with

        a letter ([A-Za-z]) and may be followed by any number

        of letters, digits ([0-9]), hyphens ("-"), underscores

        ("_"), colons (":"), and periods (".")'. These regexps

        are slightly over-zealous, in that they remove colons

        and periods unnecessarily.

        Whitespace is transformed into underscores, and then

        anything which is not a hyphen or a character that

        matches \w (alphanumerics and underscore) is removed.

        """

        # Transform all whitespace to underscore

        idstring = re.sub(r'\s', "_", '%s' % idstring)

        # Remove everything that is not a hyphen or a member of \w

        idstring = re.sub(r'(?!-)\W', "", idstring).lower()

        return idstring

    def prepare(self, inline_diff=True):

        """

        Prepare the passed udiff for HTML rendering. It'l return a list

        of dicts with diff information

        """

        parsed = self._parser(inline_diff=inline_diff)

        self.parsed = True

        self.parsed_diff = parsed

        return parsed

    def as_raw(self, diff_lines=None):

        """

        Returns raw string diff

        """

        return self._diff

        #return u''.join(imap(self._line_counter, self._diff.splitlines(1)))

    def as_html(self, table_class='code-difftable', line_class='line',

                old_lineno_class='lineno old', new_lineno_class='lineno new',

                code_class='code', enable_comments=False, parsed_lines=None):

        """

        Return given diff as html table with customized css classes

        """

        def _link_to_if(condition, label, url):

            """

            Generates a link if condition is meet or just the label if not.

            """

            if condition:

                return '''<a href="%(url)s">%(label)s</a>''' % {

                    'url': url,

                    'label': label

                }

            else:

                return label

        if not self.parsed:

            self.prepare()

        diff_lines = self.parsed_diff

        if parsed_lines:

            diff_lines = parsed_lines

        _html_empty = True

        _html = []

        _html.append('''<table class="%(table_class)s">\n''' % {

            'table_class': table_class

        })

        for diff in diff_lines:

            for line in diff['chunks']:

                _html_empty = False

                for change in line:

                    _html.append('''<tr class="%(lc)s %(action)s">\n''' % {

                        'lc': line_class,

                        'action': change['action']

                    })

                    anchor_old_id = ''

                    anchor_new_id = ''

                    anchor_old = "%(filename)s_o%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

                        'oldline_no': change['old_lineno']

                    }

                    anchor_new = "%(filename)s_n%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

                        'oldline_no': change['new_lineno']

                    }

                    cond_old = (change['old_lineno'] != '...' and

                                change['old_lineno'])

                    cond_new = (change['new_lineno'] != '...' and

                                change['new_lineno'])

                    if cond_old:

                        anchor_old_id = 'id="%s"' % anchor_old

                    if cond_new:

                        anchor_new_id = 'id="%s"' % anchor_new

                    ###########################################################

                    # OLD LINE NUMBER

                    ###########################################################

                    _html.append('''\t<td %(a_id)s class="%(olc)s">''' % {

                        'a_id': anchor_old_id,

                        'olc': old_lineno_class

                    })

                    _html.append('''%(link)s''' % {

                        'link': _link_to_if(True, change['old_lineno'],

                                            '#%s' % anchor_old)

                    })

                    _html.append('''</td>\n''')

                    ###########################################################

                    # NEW LINE NUMBER

                    ###########################################################

                    _html.append('''\t<td %(a_id)s class="%(nlc)s">''' % {

                        'a_id': anchor_new_id,

                        'nlc': new_lineno_class

                    })

                    _html.append('''%(link)s''' % {

                        'link': _link_to_if(True, change['new_lineno'],

                                            '#%s' % anchor_new)

                    })

                    _html.append('''</td>\n''')

                    ###########################################################

                    # CODE

                    ###########################################################

                    comments = '' if enable_comments else 'no-comment'

                    _html.append('''\t<td class="%(cc)s %(inc)s">''' % {

                        'cc': code_class,

                        'inc': comments

                    })

                    _html.append('''\n\t\t<div class="add-bubble"><div>&nbsp;</div></div><pre>%(code)s</pre>\n''' % {

                        'code': change['line']

                    })

                    _html.append('''\t</td>''')

                    _html.append('''\n</tr>\n''')

        _html.append('''</table>''')

        if _html_empty:

            return None

        return ''.join(_html)

    def stat(self):

        """

        Returns tuple of added, and removed lines for this instance

        """

        return self.adds, self.removes

+from vcs.nodes import FileNode

 from vcs.utils.compat import unittest

+from vcs.exceptions import ChangesetDoesNotExistError

-from conf import TEST_USER_CONFIG_FILE

 class RepositoryBaseTest(BackendTestMixin):

     recreate_repo_per_test = False

@@ -29,6 +32,176 @@ class RepositoryBaseTest(BackendTestMixin):

             'foo.bar@example.com')

+

+class RepositoryGetDiffTest(BackendTestMixin):

+

+    @classmethod

+    def _get_commits(cls):

+        commits = [

+            {

+                'message': 'Initial commit',

+                'author': 'Joe Doe <joe.doe@example.com>',

+                'date': datetime.datetime(2010, 1, 1, 20),

+                'added': [

+                    FileNode('foobar', content='foobar'),

+                    FileNode('foobar2', content='foobar2'),

+                ],

+            },

+            {

+                'message': 'Changed foobar, added foobar3',

+                'author': 'Jane Doe <jane.doe@example.com>',

+                'date': datetime.datetime(2010, 1, 1, 21),

+                'added': [

+                    FileNode('foobar3', content='foobar3'),

+                ],

+                'changed': [

+                    FileNode('foobar', 'FOOBAR'),

+                ],

+            },

+            {

+                'message': 'Removed foobar, changed foobar3',

+                'author': 'Jane Doe <jane.doe@example.com>',

+                'date': datetime.datetime(2010, 1, 1, 22),

+                'changed': [

+                    FileNode('foobar3', content='FOOBAR\nFOOBAR\nFOOBAR\n'),

+                ],

+                'removed': [FileNode('foobar')],

+            },

+        ]

+        return commits

+

+    def test_raise_for_wrong(self):

+        with self.assertRaises(ChangesetDoesNotExistError):

+            self.repo.get_diff('a' * 40, 'b' * 40)

+

+class GitRepositoryGetDiffTest(RepositoryGetDiffTest, unittest.TestCase):

+    backend_alias = 'git'

+

+    def test_initial_commit_diff(self):

+        initial_rev = self.repo.revisions[0]

+        self.assertEqual(self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev), '''diff --git a/foobar b/foobar

+new file mode 100644

+index 0000000..f6ea049

+--- /dev/null

++++ b/foobar

+@@ -0,0 +1 @@

++foobar

+\ No newline at end of file

+diff --git a/foobar2 b/foobar2

+new file mode 100644

+index 0000000..e8c9d6b

+--- /dev/null

++++ b/foobar2

+@@ -0,0 +1 @@

++foobar2

+\ No newline at end of file

+''')

+

+    def test_second_changeset_diff(self):

+        revs = self.repo.revisions

+        self.assertEqual(self.repo.get_diff(revs[0], revs[1]), '''diff --git a/foobar b/foobar

+index f6ea049..389865b 100644

+--- a/foobar

++++ b/foobar

+@@ -1 +1 @@

+-foobar

+\ No newline at end of file

++FOOBAR

+\ No newline at end of file

+diff --git a/foobar3 b/foobar3

+new file mode 100644

+index 0000000..c11c37d

+--- /dev/null

++++ b/foobar3

+@@ -0,0 +1 @@

++foobar3

+\ No newline at end of file

+''')

+

+    def test_third_changeset_diff(self):

+        revs = self.repo.revisions

+        self.assertEqual(self.repo.get_diff(revs[1], revs[2]), '''diff --git a/foobar b/foobar

+deleted file mode 100644

+index 389865b..0000000

+--- a/foobar

++++ /dev/null

+@@ -1 +0,0 @@

+-FOOBAR

+\ No newline at end of file

+diff --git a/foobar3 b/foobar3

+index c11c37d..f932447 100644

+--- a/foobar3

++++ b/foobar3

+@@ -1 +1,3 @@

+-foobar3

+\ No newline at end of file

++FOOBAR

++FOOBAR

++FOOBAR

+''')

+

+

+class HgRepositoryGetDiffTest(RepositoryGetDiffTest, unittest.TestCase):

+    backend_alias = 'hg'

+

+    def test_initial_commit_diff(self):

+        initial_rev = self.repo.revisions[0]

+        self.assertEqual(self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev), '''diff --git a/foobar b/foobar

+new file mode 100755

+--- /dev/null

++++ b/foobar

+@@ -0,0 +1,1 @@

++foobar

+\ No newline at end of file

+diff --git a/foobar2 b/foobar2

+new file mode 100755

+--- /dev/null

++++ b/foobar2

+@@ -0,0 +1,1 @@

++foobar2

+\ No newline at end of file

+''')

+

+    def test_second_changeset_diff(self):

+        revs = self.repo.revisions

+        self.assertEqual(self.repo.get_diff(revs[0], revs[1]), '''diff --git a/foobar b/foobar

+--- a/foobar

++++ b/foobar

+@@ -1,1 +1,1 @@

+-foobar

+\ No newline at end of file

++FOOBAR

+\ No newline at end of file

+diff --git a/foobar3 b/foobar3

+new file mode 100755

+--- /dev/null

++++ b/foobar3

+@@ -0,0 +1,1 @@

++foobar3

+\ No newline at end of file

+''')

+

+    def test_third_changeset_diff(self):

+        revs = self.repo.revisions

+        self.assertEqual(self.repo.get_diff(revs[1], revs[2]), '''diff --git a/foobar b/foobar

+deleted file mode 100755

+--- a/foobar

++++ /dev/null

+@@ -1,1 +0,0 @@

+-FOOBAR

+\ No newline at end of file

+diff --git a/foobar3 b/foobar3

+--- a/foobar3

++++ b/foobar3

+@@ -1,1 +1,3 @@

+-foobar3

+\ No newline at end of file

++FOOBAR

++FOOBAR

++FOOBAR

+''')

+

+

 # For each backend create test case class

 for alias in SCM_TESTS:

     attrs = {

@@ -38,7 +211,6 @@ for alias in SCM_TESTS:

     bases = (RepositoryBaseTest, unittest.TestCase)

     globals()[cls_name] = type(cls_name, bases, attrs)

-

 if __name__ == '__main__':

     unittest.main()

diff --git a/README.rst b/README

old mode 100755

new mode 100644

rename from README.rst

rename to README

--- a/README.rst

+++ b/README

@@ -1,4 +1,7 @@

 readme2

 line 1

  line2

+line 1

+ line2

    'hg_diff_rename_file.diff': [

        ('file_renamed', 'R',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {RENAMED_FILENODE: 'file renamed from file to file_renamed'}}),

    ],

    'hg_diff_rename_and_chmod_file.diff': [

        ('README', 'R',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755',

                  RENAMED_FILENODE: 'file renamed from README.rst to README'}}),

    ],

    'hg_diff_binary_and_normal.diff': [

        ('img/baseline-10px.png', 'A',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {NEW_FILENODE: 'new file 100644',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('img/baseline-20px.png', 'D',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {DEL_FILENODE: 'deleted file',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('index.html', 'M',

         {'added': 3,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('js/global.js', 'D',

         {'added': 0,

          'deleted': 75,

          'binary': False,

          'ops': {DEL_FILENODE: 'deleted file'}}),

        ('js/jquery/hashgrid.js', 'A',

         {'added': 340,

          'deleted': 0,

          'binary': False,

          'ops': {NEW_FILENODE: 'new file 100755'}}),

        ('less/docs.less', 'M',

         {'added': 34,

          'deleted': 0,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('less/scaffolding.less', 'M',

         {'added': 1,

          'deleted': 3,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('readme.markdown', 'M',

         {'added': 1,

          'deleted': 10,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

    ],

    'git_diff_chmod.diff': [

        ('work-horus.xls', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755'}})

    ],

    'git_diff_rename_file.diff': [

        ('file.xls', 'R',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {RENAMED_FILENODE: 'file renamed from work-horus.xls to file.xls'}})

    ],

    'git_diff_mod_single_binary_file.diff': [

        ('US Warszawa.jpg', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {MOD_FILENODE: 'modified file',

                  BIN_FILENODE: 'binary diff not shown'}})

    ],

    'git_diff_binary_and_normal.diff': [

        ('img/baseline-10px.png', 'A',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {NEW_FILENODE: 'new file 100644',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('img/baseline-20px.png', 'D',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {DEL_FILENODE: 'deleted file',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('index.html', 'M',

         {'added': 3,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('js/global.js', 'D',

         {'added': 0,

          'deleted': 75,

          'binary': False,

          'ops': {DEL_FILENODE: 'deleted file'}}),

        ('js/jquery/hashgrid.js', 'A',

         {'added': 340,

          'deleted': 0,

          'binary': False,

          'ops': {NEW_FILENODE: 'new file 100755'}}),

        ('less/docs.less', 'M',

         {'added': 34,

          'deleted': 0,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('less/scaffolding.less', 'M',

         {'added': 1,

          'deleted': 3,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('readme.markdown', 'M',

         {'added': 1,

          'deleted': 10,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

    ],

    'diff_with_diff_data.diff': [

        ('vcs/backends/base.py', 'M',

         {'added': 18,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/backends/git/repository.py', 'M',

         {'added': 46,

          'deleted': 15,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/backends/hg.py', 'M',

         {'added': 22,

          'deleted': 3,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/tests/test_git.py', 'M',

         {'added': 5,

          'deleted': 5,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('vcs/tests/test_repository.py', 'M',

         {'added': 174,

          'deleted': 2,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

    ],

    'hg_diff_copy_file.diff': [

        ('file2', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {COPIED_FILENODE: 'file copied from file1 to file2'}}),

    ],

    'hg_diff_copy_and_modify_file.diff': [

        ('file3', 'M',

         {'added': 1,

          'deleted': 0,

          'binary': False,

          'ops': {COPIED_FILENODE: 'file copied from file2 to file3',

                  MOD_FILENODE: 'modified file'}}),

    ],

    'hg_diff_copy_and_chmod_file.diff': [

        ('file4', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {COPIED_FILENODE: 'file copied from file3 to file4',

                  CHMOD_FILENODE: 'modified file chmod 100644 => 100755'}}),

    ],

    'hg_diff_copy_chmod_and_edit_file.diff': [

        ('file5', 'M',

         {'added': 2,

          'deleted': 1,

          'binary': False,

          'ops': {COPIED_FILENODE: 'file copied from file4 to file5',

                  CHMOD_FILENODE: 'modified file chmod 100755 => 100644',

                  MOD_FILENODE: 'modified file'}}),

    ]

}

class DiffLibTest(BaseTestCase):

    @parameterized.expand([(x,) for x in DIFF_FIXTURES])

    def test_diff(self, diff_fixture):

        diff_proc = DiffProcessor(diff)

        diff_proc_d = diff_proc.prepare()

        data = [(x['filename'], x['operation'], x['stats']) for x in diff_proc_d]

        expected_data = DIFF_FIXTURES[diff_fixture]

        self.assertListEqual(expected_data, data)