def test_reap_children(self):
     subp = get_test_subprocess()
     p = psutil.Process(subp.pid)
     assert p.is_running()
     reap_children()
     assert not p.is_running()
     assert not psutil.tests._pids_started
     assert not psutil.tests._subprocesses_started

 def tearDown(self):
     safe_rmpath(TESTFN)
     reap_children()
     if not NETBSD:
         # Make sure we closed all resources.
         # NetBSD opens a UNIX socket to /var/log/run.
         cons = thisproc.connections(kind='all')
         assert not cons, cons

def subprocess_supports_unicode(name):
    """Return True if both the fs and the subprocess module can
    deal with a unicode file name.
    """
    if PY3:
        return True
    try:
        safe_rmpath(name)
        create_exe(name)
        get_test_subprocess(cmd=[name])
    except UnicodeEncodeError:
        return False
    else:
        reap_children()
        return True

 def test_pid_exists_2(self):
     reap_children()
     pids = psutil.pids()
     for pid in pids:
         try:
             assert psutil.pid_exists(pid)
         except AssertionError:
             # in case the process disappeared in meantime fail only
             # if it is no longer in psutil.pids()
             time.sleep(.1)
             if pid in psutil.pids():
                 self.fail(pid)
     pids = range(max(pids) + 5000, max(pids) + 6000)
     for pid in pids:
         self.assertFalse(psutil.pid_exists(pid), msg=pid)

    def test_create_proc_children_pair(self):
        p1, p2 = create_proc_children_pair()
        self.assertNotEqual(p1.pid, p2.pid)
        assert p1.is_running()
        assert p2.is_running()
        children = psutil.Process().children(recursive=True)
        self.assertEqual(len(children), 2)
        self.assertIn(p1, children)
        self.assertIn(p2, children)
        self.assertEqual(p1.ppid(), os.getpid())
        self.assertEqual(p2.ppid(), p1.pid)

        # make sure both of them are cleaned up
        reap_children()
        assert not p1.is_running()
        assert not p2.is_running()
        assert not psutil.tests._pids_started
        assert not psutil.tests._subprocesses_started

 def tearDownClass(cls):
     reap_children()

 def tearDown(self):
     reap_children()
     safe_rmpath(self.funky_name)

 def tearDown(self):
     reap_children()

 def tearDownClass(cls):
     super(TestTerminatedProcessLeaks, cls).tearDownClass()
     reap_children()

 def tearDown(self):
     self.proc32.communicate()
     self.proc64.communicate()
     reap_children()

 def tearDownClass(cls):
     reap_children()
     safe_rmpath(cls.funky_name)

 def test_reap_children(self):
     subp = get_test_subprocess()
     assert psutil.pid_exists(subp.pid)
     reap_children()
     assert not psutil.pid_exists(subp.pid)