def test_frozen(self):
        with captured_stdout() as stdout:
            try:
                import __hello__
            except ImportError as x:
                self.fail("import __hello__ failed:" + str(x))
            self.assertEqual(__hello__.initialized, True)
            expect = set(self.module_attrs)
            expect.add('initialized')
            self.assertEqual(set(dir(__hello__)), expect)
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        with captured_stdout() as stdout:
            try:
                import __phello__
            except ImportError as x:
                self.fail("import __phello__ failed:" + str(x))
            self.assertEqual(__phello__.initialized, True)
            expect = set(self.package_attrs)
            expect.add('initialized')
            if not "__phello__.spam" in sys.modules:
                self.assertEqual(set(dir(__phello__)), expect)
            else:
                expect.add('spam')
                self.assertEqual(set(dir(__phello__)), expect)
            self.assertEqual(__phello__.__path__, [__phello__.__name__])
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        with captured_stdout() as stdout:
            try:
                import __phello__.spam
            except ImportError as x:
                self.fail("import __phello__.spam failed:" + str(x))
            self.assertEqual(__phello__.spam.initialized, True)
            spam_expect = set(self.module_attrs)
            spam_expect.add('initialized')
            self.assertEqual(set(dir(__phello__.spam)), spam_expect)
            phello_expect = set(self.package_attrs)
            phello_expect.add('initialized')
            phello_expect.add('spam')
            self.assertEqual(set(dir(__phello__)), phello_expect)
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        try:
            import __phello__.foo
        except ImportError:
            pass
        else:
            self.fail("import __phello__.foo should have failed")

            try:
                import __phello__.foo
            except ImportError:
                pass
            else:
                self.fail("import __phello__.foo should have failed")

        del sys.modules['__hello__']
        del sys.modules['__phello__']
        del sys.modules['__phello__.spam']

    def test_debug_print(self):
        file_list = FileList()
        with captured_stdout() as stdout:
            file_list.debug_print('xxx')
        self.assertEqual(stdout.getvalue(), '')

        debug.DEBUG = True
        try:
            with captured_stdout() as stdout:
                file_list.debug_print('xxx')
            self.assertEqual(stdout.getvalue(), 'xxx\n')
        finally:
            debug.DEBUG = False

    def test_frozen(self):
        with captured_stdout() as stdout:
            try:
                import __hello__
            except ImportError as x:
                self.fail("import __hello__ failed:" + str(x))
            self.assertEqual(__hello__.initialized, True)
            self.assertEqual(len(dir(__hello__)), 7, dir(__hello__))
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        with captured_stdout() as stdout:
            try:
                import __phello__
            except ImportError as x:
                self.fail("import __phello__ failed:" + str(x))
            self.assertEqual(__phello__.initialized, True)
            if not "__phello__.spam" in sys.modules:
                self.assertEqual(len(dir(__phello__)), 8, dir(__phello__))
            else:
                self.assertEqual(len(dir(__phello__)), 9, dir(__phello__))
            self.assertEqual(__phello__.__path__, [__phello__.__name__])
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        with captured_stdout() as stdout:
            try:
                import __phello__.spam
            except ImportError as x:
                self.fail("import __phello__.spam failed:" + str(x))
            self.assertEqual(__phello__.spam.initialized, True)
            self.assertEqual(len(dir(__phello__.spam)), 7)
            self.assertEqual(len(dir(__phello__)), 9)
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        try:
            import __phello__.foo
        except ImportError:
            pass
        else:
            self.fail("import __phello__.foo should have failed")

            try:
                import __phello__.foo
            except ImportError:
                pass
            else:
                self.fail("import __phello__.foo should have failed")

        del sys.modules['__hello__']
        del sys.modules['__phello__']
        del sys.modules['__phello__.spam']

    def test_debug_print(self):
        cmd = self.cmd
        with captured_stdout() as stdout:
            cmd.debug_print('xxx')
        stdout.seek(0)
        self.assertEqual(stdout.read(), '')

        debug.DEBUG = True
        try:
            with captured_stdout() as stdout:
                cmd.debug_print('xxx')
            stdout.seek(0)
            self.assertEqual(stdout.read(), 'xxx\n')
        finally:
            debug.DEBUG = False

 def run_test(self, leftovers=False, dump=False, verbose=False):
     """Parse the input buffer prepared through the 'add_' functions
     and compare the results to the expected output.  `leftovers`
     should be `True` if the input buffer is expected to have excess
     data in it.  If `dump` is `True`, the state of the mock socket
     will be dumped after parsing."""
     if verbose:
         print("Initial state of socket")
         self.sock.dump()
     self.expected_output.append("")
     with contextlib.ExitStack() as stack:
         for parse_error in self.expected_parse_errors:
             stack.enter_context(self.assertRaises(ParseError,
                                                   msg=parse_error))
         with support.captured_stdout() as stdout:
             mtapi = mtcmds.MTAPI(self.sock)
             mtapi()
             while mtapi.state != mtapi.read_sof:
                 mtapi()
     if dump:
         print("Final state of socket")
         self.sock.dump()
     if leftovers:
         self.assertFalse(self.sock.eof())
     else:
         self.assertTrue(self.sock.eof())
     if verbose:
         print("Parse output:")
         print(stdout.getvalue())
     actual_output = stdout.getvalue().split("\n")
     for (expected, actual) in zip(self.expected_output, actual_output):
         self.assertEqual(expected, actual)

 def test_frozen(self):
     name = '__hello__'
     if name in sys.modules:
         del sys.modules[name]
     with captured_stdout() as out:
         import __hello__
     self.assertEqual(out.getvalue(), 'Hello world!\n')

 def test_resolve_false(self):
     # Issue #23008: pydoc enum.{,Int}Enum failed
     # because bool(enum.Enum) is False.
     with captured_stdout() as help_io:
         pydoc.help('enum.Enum')
     helptext = help_io.getvalue()
     self.assertIn('class Enum', helptext)

 def test_compile_file_pathlike(self):
     self.assertFalse(os.path.isfile(self.bc_path))
     # we should also test the output
     with support.captured_stdout() as stdout:
         self.assertTrue(compileall.compile_file(pathlib.Path(self.source_path)))
     self.assertRegex(stdout.getvalue(), r'Compiling ([^WindowsPath|PosixPath].*)')
     self.assertTrue(os.path.isfile(self.bc_path))

 def test_help(self):
     for opt in '-h', '--help':
         with self.subTest(opt=opt):
             with support.captured_stdout() as out, \
                  self.assertRaises(SystemExit):
                 libregrtest._parse_args([opt])
             self.assertIn('Run Python regression tests.', out.getvalue())

 def test_compile_dir_pathlike(self):
     self.assertFalse(os.path.isfile(self.bc_path))
     with support.captured_stdout() as stdout:
         compileall.compile_dir(pathlib.Path(self.directory))
     line = stdout.getvalue().splitlines()[0]
     self.assertRegex(line, r'Listing ([^WindowsPath|PosixPath].*)')
     self.assertTrue(os.path.isfile(self.bc_path))

 def report(self, pat):
     grep.engine._pat = pat
     with captured_stdout() as s:
         grep.grep_it(re.compile(pat), __file__)
     lines = s.getvalue().split('\n')
     lines.pop()  # remove bogus '' after last \n
     return lines

 def test_module_reuse(self):
     with util.uncache('__hello__'), captured_stdout() as stdout:
         module1 = machinery.FrozenImporter.load_module('__hello__')
         module2 = machinery.FrozenImporter.load_module('__hello__')
         self.assertTrue(module1 is module2)
         self.assertEqual(stdout.getvalue(),
                          'Hello world!\nHello world!\n')

 def test_repr(self):
     with support.captured_stdout() as template:
         A = recordclass('A', 'x')
     self.assertEqual(repr(A(1)), 'A(x=1)')
     # repr should show the name of the subclass
     class B(A):
         pass
     self.assertEqual(repr(B(1)), 'B(x=1)')

 def test_namedtuple_public_underscore(self):
     NT = namedtuple("NT", ["abc", "def"], rename=True)
     with captured_stdout() as help_io:
         pydoc.help(NT)
     helptext = help_io.getvalue()
     self.assertIn("_1", helptext)
     self.assertIn("_replace", helptext)
     self.assertIn("_asdict", helptext)

    def test_show_formats(self):
        with captured_stdout() as stdout:
            show_formats()

        # the output should be a header line + one line per format
        num_formats = len(ARCHIVE_FORMATS.keys())
        output = [line for line in stdout.getvalue().split("\n") if line.strip().startswith("--formats=")]
        self.assertEqual(len(output), num_formats)

 def test_eval(self):
     with open(_fname + '.dir', 'w') as stream:
         stream.write("str(print('Hacked!')), 0\n")
     with support.captured_stdout() as stdout:
         with self.assertRaises(ValueError):
             with dumbdbm.open(_fname) as f:
                 pass
         self.assertEqual(stdout.getvalue(), '')

 def test_namedtuple_public_underscore(self):
     NT = namedtuple('NT', ['abc', 'def'], rename=True)
     with captured_stdout() as help_io:
         help(NT)
     helptext = help_io.getvalue()
     self.assertIn('_1', helptext)
     self.assertIn('_replace', helptext)
     self.assertIn('_asdict', helptext)

 def test_module(self):
     with util.uncache('__hello__'), captured_stdout() as stdout:
         module = machinery.FrozenImporter.load_module('__hello__')
         check = {'__name__': '__hello__', '__file__': '<frozen>',
                 '__package__': '', '__loader__': machinery.FrozenImporter}
         for attr, value in check.items():
             self.assertEqual(getattr(module, attr), value)
         self.assertEqual(stdout.getvalue(), 'Hello world!\n')

    def test_debug_mode(self):
        # this covers the code called when DEBUG is set
        sys.argv = ['setup.py', '--name']
        with captured_stdout() as stdout:
            distutils.core.setup(name='bar')
        stdout.seek(0)
        self.assertEqual(stdout.read(), 'bar\n')

        distutils.core.DEBUG = True
        try:
            with captured_stdout() as stdout:
                distutils.core.setup(name='bar')
        finally:
            distutils.core.DEBUG = False
        stdout.seek(0)
        wanted = "options (after parsing config files):\n"
        self.assertEqual(stdout.readlines()[0], wanted)

 def test_repr(self):
     with support.captured_stdout() as template:
         A = namedtuple('A', 'x', verbose=True)
     self.assertEqual(repr(A(1)), 'A(x=1)')
     # repr should show the name of the subclass
     class B(A):
         pass
     self.assertEqual(repr(B(1)), 'B(x=1)')