# highlight inline changes when one del is followed by one add

        for diff_data in _files:

            for chunk in diff_data['chunks']:

                lineiter = iter(chunk)

                try:

                    while True:

                        # find a first del line

                        while peekline['action'] != 'del':

                        delline = peekline

                        # if not followed by add, eat all following del lines

                        if peekline['action'] != 'add':

                            while peekline['action'] == 'del':

                            continue

                        # found an add - make sure it is the only one

                        addline = peekline

                        try:

                        except StopIteration:

                            # add was last line - ok

                            _highlight_inline_diff(delline, addline)

                            raise

                        if peekline['action'] != 'add':

                            # there was only one add line - ok

    """

    added = deleted = 0

    old_line = old_end = new_line = new_end = None

    chunks = []

    try:

        while True:

            lines = []

            chunks.append(lines)

            match = _chunk_re.match(line)

                        'old_lineno': '...',

                        'new_lineno': '...',

                        'action':     'context',

                        'line':       line,

                    })

            while old_line < old_end or new_line < new_end:

                if not line:

                    raise Exception('error parsing diff - empty line at -%s+%s' % (old_line, new_line))

                affects_old = affects_new = False

                        'old_lineno':   affects_old and old_line or '',

                        'new_lineno':   affects_new and new_line or '',

                        'action':       action,

                        'line':         line[1:],

                    })

                if _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':         line,

                    })

            if old_line > old_end:

                raise Exception('error parsing diff - more than %s "-" lines at -%s+%s' % (old_end, old_line, new_line))

            if new_line > new_end:

                raise Exception('error parsing diff - more than %s "+" lines at -%s+%s' % (new_end, old_line, new_line))

    except StopIteration:

        pass

    color_dict = {}

    def get_color_string(cs):

        if cs in color_dict:

            col = color_dict[cs]

        else:

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(changeset):

        author = escape(changeset.author)

        date = changeset.date

        message = escape(changeset.message)

    def doc_ids(self):

        docs_id = []

        while self.matcher.is_active():

            docnum = self.matcher.id()

            chunks = [offsets for offsets in self.get_chunks()]

            docs_id.append([docnum, chunks])

        return docs_id

    def __str__(self):

        return '<%s at %s>' % (self.__class__.__name__, len(self.doc_ids))

    def __repr__(self):

class ResultIter:

    def __init__(self, result, meter, description):

        self._result_close = getattr(result, 'close', None) or (lambda: None)

        self._meter = meter

        self._description = description

    def __iter__(self):

        return self

        chunk = self._next()

        self._meter.measure(chunk)

        return chunk

    def close(self):

        self._result_close()

    # Generator's methods

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

    def __iter__(self):

        return self

        while not len(self.data) and not self.worker.EOF.is_set():

            self.worker.data_added.clear()

            self.worker.data_added.wait(0.2)

        if len(self.data):

            self.worker.keep_reading.set()

            return bytes(self.data.popleft())

        self.error = bg_err

        self.inputstream = inputstream

    def __iter__(self):

        return self

        if self.process:

            returncode = self.process.poll()

            if (returncode is not None # process has terminated

                and returncode != 0

            ): # and it failed

                self.output.stop()

                self.error.stop()

                err = ''.join(self.error)

                raise EnvironmentError("Subprocess exited due to an error:\n" + err)

    def throw(self, type, value=None, traceback=None):

        if self.output.length or not self.output.done_reading:

            raise type(value)

    def close(self):

    Generate some files, add it to dest_dir repo and push back

    vcs is git or hg and defines what VCS we want to make those files for

    :param vcs:

    :param dest_dir:

    """

    open(os.path.join(dest_dir, added_file), 'a').close()

    Command(dest_dir).execute(vcs, 'add', added_file)

    email = 'me@example.com'

    if os.name == 'nt':

        author_str = 'User <%s>' % email

                Session().delete(entry)

        Session().commit()

    @pytest.fixture(scope="module")

    def testfork(self):

        # create fork so the repo stays untouched

        fixture.create_fork(base.GIT_REPO, git_fork_name)

        fixture.create_fork(base.HG_REPO, hg_fork_name)

        return {'git': git_fork_name, 'hg': hg_fork_name}

    @parametrize_vcs_test

    def test_clone_repo_by_admin(self, webserver, vt):

        clone_url = vt.repo_url_param(webserver, vt.repo_name)

    def test_push_new_repo(self, webserver, vt):

        # Clear the log so we know what is added

        UserLog.query().delete()

        Session().commit()

        # Create an empty server repo using the API

        usr = User.get_by_username(base.TEST_USER_ADMIN_LOGIN)

        params = {

            "id": 7,

            "api_key": usr.api_key,

            "method": 'create_repo',

            "args": dict(repo_name=repo_name,

        try:

            backend = sys.argv[4]

        except IndexError:

            backend = 'hg'

        if METHOD == 'pull':

            test_clone_with_credentials(repo=sys.argv[1], method='clone',

                                        backend=backend)

        s = time.time()

        for i in range(1, int(sys.argv[2]) + 1):

            print('take', i)

            test_clone_with_credentials(repo=sys.argv[1], method=METHOD,