FailedOk

th/SRPMS[OK]
th/x32[OK]
th/i686[OK]
th/x86_64[OK]

ac/SRPMS[OK]
ac/i386[OK]
ac/i586[OK]
ac/i686[OK]
ac/alpha[OK]
ac/amd64[OK]
ac/athlon[OK]
ac/ppc[OK]
ac/sparc[OK]
ac/sparc64[OK]

Advanced Search
main()
Powered by PLD Linux
(c) 2002-2017 PLD Team
$Revision: 1.37 $
Powered by ELF.
Your IP: 54.156.67.122

python-setuptools_scm 67a4abea-475d-48f8-a8cb-4cbc181bd89e

Status:Failed
Source URL:ftp://buildlogs.pld-linux.org/th/i686/FAIL/python-setuptools_scm,67a4abea-475d-48f8-a8cb-4cbc181bd89e.bz2
text/plain URL:View!
full text:View!
rpm -qa of builder:View!
Date:2017/03/11 18:13:09
Runtime:0:00:07.737310

Toc:

  • error 1
  • E OSError: [Errno 2] No such file or directory
  • error 2
  • E OSError: [Errno 2] No such file or directory
  • error 3
  • E OSError: [Errno 2] No such file or directory
  • error 4
  • E OSError: [Errno 2] No such file or directory
  • error 5
  • E OSError: [Errno 2] No such file or directory
  • error 6
  • E OSError: [Errno 2] No such file or directory
  • error 7
  • E OSError: [Errno 2] No such file or directory
  • error 8
  • E OSError: [Errno 2] No such file or directory
  • error 9
  • E OSError: [Errno 2] No such file or directory
  • error 10
  • E OSError: [Errno 2] No such file or directory
  • error 11
  • E OSError: [Errno 2] No such file or directory
  • error 12
  • E OSError: [Errno 2] No such file or directory
  • error 13
  • E OSError: [Errno 2] No such file or directory
  • error 14
  • err 'Traceback (most recent call last):\n File "setup.py", line 1, in <module>\n from setuptools import setup;setup(use_scm_version={"root": ".."})\n File "/usr/lib/python2.7/distutils/core.py", line 111, in setup\n _setup_distribution = dist = klass(attrs)\n File "/usr/share/python2.7/site-packages/setuptools/dist.py", line 272, in __init__\n File "/usr/lib/python2.7/distutils/dist.py", line 287, in __init__\n self.finalize_options()\n File "/usr/share/python2.7/site-packages/setuptools/dist.py", line 327, in finalize_options\n File "/usr/share/python2.7/site-packages/setuptools_scm/integration.py", line 19, in version_keyword\n File "/usr/share/python2.7/site-packages/setuptools_scm/__init__.py", line 104, in get_version\n File "/usr/share/python2.7/site-packages/setuptools_scm/__init__.py", line 82, in _do_parse\nLookupError: setuptools-scm was unable to detect version for \'/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_pkginfo_noscmroot0/sub\'.\n\nMake sure you\'re either building from a fully intact git repository or PyPI tarballs. Most other sources (such as GitHub\'s tarballs, a git checkout without the .git folder) don\'t contain the necessary metadata and will not work.\n\nFor example, if you\'re using pip, instead of https://github.com/user/proj/archive/master.zip use git+https://github.com/user/proj.git#egg=proj\n'
  • error 15
  • error: Bad exit status from /tmp/B.tST9x7/BUILD/tmp/rpm-tmp.36033 (%build)
  • error 16
  • RPM build errors:
  • error 17
  • error: No files produced.

Content:

                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
_____________________ ERROR at setup of test_git_worktree ______________________

wd = <conftest.Wd object at 0xf69b33ac>

    @pytest.fixture
    def wd(wd):
>       wd('git init')

testing/test_git.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf69b356c>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_git_worktree0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
____________________ ERROR at setup of test_git_dirty_notag ____________________

wd = <conftest.Wd object at 0xf691de8c>

    @pytest.fixture
    def wd(wd):
>       wd('git init')

testing/test_git.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf691d90c>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_git_dirty_notag0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
________________ ERROR at setup of test_git_parse_shallow_warns ________________

wd = <conftest.Wd object at 0xf699d72c>

    @pytest.fixture
    def wd(wd):
>       wd('git init')

testing/test_git.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf699deac>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_git_parse_shallow_warns0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
________________ ERROR at setup of test_git_parse_shallow_fail _________________

wd = <conftest.Wd object at 0xf692268c>

    @pytest.fixture
    def wd(wd):
>       wd('git init')

testing/test_git.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf69225ac>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_git_parse_shallow_fail0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
________________ ERROR at setup of test_git_shallow_autocorrect ________________

wd = <conftest.Wd object at 0xf691a56c>

    @pytest.fixture
    def wd(wd):
>       wd('git init')

testing/test_git.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf691a76c>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_git_shallow_autocorrect0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
______________ ERROR at setup of test_find_files_stop_at_root_git ______________

wd = <conftest.Wd object at 0xf692162c>

    @pytest.fixture
    def wd(wd):
>       wd('git init')

testing/test_git.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf6921c2c>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_find_files_stop_at_root_g0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
________________ ERROR at setup of test_alphanumeric_tags_match ________________

wd = <conftest.Wd object at 0xf6925bac>

    @pytest.fixture
    def wd(wd):
>       wd('git init')

testing/test_git.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf6925a0c>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_alphanumeric_tags_match0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'git init'
______________ ERROR at setup of test_find_files_stop_at_root_hg _______________

wd = <conftest.Wd object at 0xf691506c>

    @pytest.fixture
    def wd(wd):
>       wd('hg init')

testing/test_mercurial.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf6928a6c>, args = ['hg', 'init']
executable = 'hg', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_find_files_stop_at_root_h0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'hg init'
__________________ ERROR at setup of test_version_from_hg_id ___________________

wd = <conftest.Wd object at 0xf6973c0c>

    @pytest.fixture
    def wd(wd):
>       wd('hg init')

testing/test_mercurial.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf6973b6c>, args = ['hg', 'init']
executable = 'hg', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_version_from_hg_id0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'hg init'
_________________ ERROR at setup of test_version_from_archival _________________

wd = <conftest.Wd object at 0xf68ca04c>

    @pytest.fixture
    def wd(wd):
>       wd('hg init')

testing/test_mercurial.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf68ca0ec>, args = ['hg', 'init']
executable = 'hg', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_version_from_archival0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'hg init'
___________________ ERROR at setup of test_version_in_merge ____________________

wd = <conftest.Wd object at 0xf689492c>

    @pytest.fixture
    def wd(wd):
>       wd('hg init')

testing/test_mercurial.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
testing/conftest.py:30: in __call__
    return do(cmd, self.cwd)
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf689402c>, args = ['hg', 'init']
executable = 'hg', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_version_in_merge0/wd'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
---------------------------- Captured stdout setup -----------------------------
cmd 'hg init'
=================================== FAILURES ===================================
____________________________ test_pkginfo_noscmroot ____________________________

tmpdir = local('/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_pkginfo_noscmroot0')
monkeypatch = <_pytest.monkeypatch.monkeypatch instance at 0xf68c5c0c>

    def test_pkginfo_noscmroot(tmpdir, monkeypatch):
        """if we are indeed a sdist, the root does not apply"""
        monkeypatch.delenv("SETUPTOOLS_SCM_DEBUG")
    
        # we should get the version from pkg-info if git is broken
        p = tmpdir.ensure('sub/package', dir=1)
        tmpdir.mkdir('.git')
        p.join('setup.py').write(
            'from setuptools import setup;'
            'setup(use_scm_version={"root": ".."})')
    
        _, stderr, ret = do_ex('python setup.py --version', p)
        assert 'setuptools-scm was unable to detect version for' in stderr
        assert ret == 1
    
        p.join("PKG-INFO").write('Version: 1.0')
        res = do('python setup.py --version', p)
        assert res == '1.0'
    
>       do('git init', p.dirpath())

testing/test_regressions.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
setuptools_scm/utils.py:79: in do
    out, err, ret = do_ex(cmd, cwd)
setuptools_scm/utils.py:67: in do_ex
    p = _popen_pipes(cmd, cwd)
setuptools_scm/utils.py:57: in _popen_pipes
    HGPLAIN='1',
/usr/lib/python2.7/subprocess.py:390: in __init__
    errread, errwrite)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <subprocess.Popen object at 0xf68c520c>, args = ['git', 'init']
executable = 'git', preexec_fn = None, close_fds = False
cwd = '/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_pkginfo_noscmroot0/sub'
env = {'CC': 'i686-pld-linux-gcc', 'CFLAGS': ' -O2 -fwrapv -pipe -Wformat -Werror=format-security -gdwarf-4 -fno-debug-types...ibraries/Java:/usr/local/lib/GNUstep/Libraries/Java:/usr/lib/GNUstep/Libraries/Java', 'CXX': 'i686-pld-linux-g++', ...}
universal_newlines = False, startupinfo = None, creationflags = 0, shell = False
to_close = set([9, 12]), p2cread = None, p2cwrite = None, c2pread = 9
c2pwrite = 11, errread = 12, errwrite = 13

    def _execute_child(self, args, executable, preexec_fn, close_fds,
                       cwd, env, universal_newlines,
                       startupinfo, creationflags, shell, to_close,
                       p2cread, p2cwrite,
                       c2pread, c2pwrite,
                       errread, errwrite):
        """Execute program (POSIX version)"""
    
        if isinstance(args, types.StringTypes):
            args = [args]
        else:
            args = list(args)
    
        if shell:
            args = ["/bin/sh", "-c"] + args
            if executable:
                args[0] = executable
    
        if executable is None:
            executable = args[0]
    
        def _close_in_parent(fd):
            os.close(fd)
            to_close.remove(fd)
    
        # For transferring possible exec failure from child to parent
        # The first char specifies the exception type: 0 means
        # OSError, 1 means some other error.
        errpipe_read, errpipe_write = self.pipe_cloexec()
        try:
            try:
                gc_was_enabled = gc.isenabled()
                # Disable gc to avoid bug where gc -> file_dealloc ->
                # write to stderr -> hang.  http://bugs.python.org/issue1336
                gc.disable()
                try:
                    self.pid = os.fork()
                except:
                    if gc_was_enabled:
                        gc.enable()
                    raise
                self._child_created = True
                if self.pid == 0:
                    # Child
                    try:
                        # Close parent's pipe ends
                        if p2cwrite is not None:
                            os.close(p2cwrite)
                        if c2pread is not None:
                            os.close(c2pread)
                        if errread is not None:
                            os.close(errread)
                        os.close(errpipe_read)
    
                        # When duping fds, if there arises a situation
                        # where one of the fds is either 0, 1 or 2, it
                        # is possible that it is overwritten (#12607).
                        if c2pwrite == 0:
                            c2pwrite = os.dup(c2pwrite)
                        if errwrite == 0 or errwrite == 1:
                            errwrite = os.dup(errwrite)
    
                        # Dup fds for child
                        def _dup2(a, b):
                            # dup2() removes the CLOEXEC flag but
                            # we must do it ourselves if dup2()
                            # would be a no-op (issue #10806).
                            if a == b:
                                self._set_cloexec_flag(a, False)
                            elif a is not None:
                                os.dup2(a, b)
                        _dup2(p2cread, 0)
                        _dup2(c2pwrite, 1)
                        _dup2(errwrite, 2)
    
                        # Close pipe fds.  Make sure we don't close the
                        # same fd more than once, or standard fds.
                        closed = { None }
                        for fd in [p2cread, c2pwrite, errwrite]:
                            if fd not in closed and fd > 2:
                                os.close(fd)
                                closed.add(fd)
    
                        if cwd is not None:
                            os.chdir(cwd)
    
                        if preexec_fn:
                            preexec_fn()
    
                        # Close all other fds, if asked for - after
                        # preexec_fn(), which may open FDs.
                        if close_fds:
                            self._close_fds(but=errpipe_write)
    
                        if env is None:
                            os.execvp(executable, args)
                        else:
                            os.execvpe(executable, args, env)
    
                    except:
                        exc_type, exc_value, tb = sys.exc_info()
                        # Save the traceback and attach it to the exception object
                        exc_lines = traceback.format_exception(exc_type,
                                                               exc_value,
                                                               tb)
                        exc_value.child_traceback = ''.join(exc_lines)
                        os.write(errpipe_write, pickle.dumps(exc_value))
    
                    # This exitcode won't be reported to applications, so it
                    # really doesn't matter what we return.
                    os._exit(255)
    
                # Parent
                if gc_was_enabled:
                    gc.enable()
            finally:
                # be sure the FD is closed no matter what
                os.close(errpipe_write)
    
            # Wait for exec to fail or succeed; possibly raising exception
            data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            pickle_bits = []
            while data:
                pickle_bits.append(data)
                data = _eintr_retry_call(os.read, errpipe_read, 1048576)
            data = "".join(pickle_bits)
        finally:
            if p2cread is not None and p2cwrite is not None:
                _close_in_parent(p2cread)
            if c2pwrite is not None and c2pread is not None:
                _close_in_parent(c2pwrite)
            if errwrite is not None and errread is not None:
                _close_in_parent(errwrite)
    
            # be sure the FD is closed no matter what
            os.close(errpipe_read)
    
        if data != "":
            try:
                _eintr_retry_call(os.waitpid, self.pid, 0)
            except OSError as e:
                if e.errno != errno.ECHILD:
                    raise
            child_exception = pickle.loads(data)
>           raise child_exception
E           OSError: [Errno 2] No such file or directory

/usr/lib/python2.7/subprocess.py:1024: OSError
----------------------------- Captured stdout call -----------------------------
cmd 'python setup.py --version'
err 'Traceback (most recent call last):\n  File "setup.py", line 1, in <module>\n    from setuptools import setup;setup(use_scm_version={"root": ".."})\n  File "/usr/lib/python2.7/distutils/core.py", line 111, in setup\n    _setup_distribution = dist = klass(attrs)\n  File "/usr/share/python2.7/site-packages/setuptools/dist.py", line 272, in __init__\n  File "/usr/lib/python2.7/distutils/dist.py", line 287, in __init__\n    self.finalize_options()\n  File "/usr/share/python2.7/site-packages/setuptools/dist.py", line 327, in finalize_options\n  File "/usr/share/python2.7/site-packages/setuptools_scm/integration.py", line 19, in version_keyword\n  File "/usr/share/python2.7/site-packages/setuptools_scm/__init__.py", line 104, in get_version\n  File "/usr/share/python2.7/site-packages/setuptools_scm/__init__.py", line 82, in _do_parse\nLookupError: setuptools-scm was unable to detect version for \'/tmp/B.tST9x7/BUILD/tmp/pytest-of-builder/pytest-0/test_pkginfo_noscmroot0/sub\'.\n\nMake sure you\'re either building from a fully intact git repository or PyPI tarballs. Most other sources (such as GitHub\'s tarballs, a git checkout without the .git folder) don\'t contain the necessary metadata and will not work.\n\nFor example, if you\'re using pip, instead of https://github.com/user/proj/archive/master.zip use git+https://github.com/user/proj.git#egg=proj\n'
ret 1
cmd 'python setup.py --version'
out '1.0\n'
cmd 'git init'
=========== 1 failed, 33 passed, 1 skipped, 12 error in 5.43 seconds ===========
error: Bad exit status from /tmp/B.tST9x7/BUILD/tmp/rpm-tmp.36033 (%build)


RPM build errors:
    Bad exit status from /tmp/B.tST9x7/BUILD/tmp/rpm-tmp.36033 (%build)
ended at: Sat Mar 11 18:13:08 2017, done in 0:00:07.737310
error: No files produced.
+ chmod -R u+rwX /tmp/B.tST9x7/BUILD
+ rm -rf /tmp/B.tST9x7/tmp /tmp/B.tST9x7/BUILD
+ rm -rf /tmp/B.tST9x7
Begin-PLD-Builder-Info
Build-Time: user:5.54s sys:0.39s real:10.68s (faults io:1 non-io:163047)

End-PLD-Builder-Info
[Back to list of logs] [View rpm -qa of builder]