text: """Tests for distutils.command.install."""
  
  import os
  import sys
  import unittest
  import site
  
  from test.support import captured_stdout, run_unittest
  
  from distutils import sysconfig
  from distutils.command.install import install
  from distutils.command import install as install_module
  from distutils.command.build_ext import build_ext
  from distutils.command.install import INSTALL_SCHEMES
  from distutils.core import Distribution
  from distutils.errors import DistutilsOptionError
  from distutils.extension import Extension
  
  from distutils.tests import support
  from test import support as test_support
  
  
  def _make_ext_name(modname):
      return modname + sysconfig.get_config_var('EXT_SUFFIX')
  
  
  class InstallTestCase(support.TempdirManager,
                        support.EnvironGuard,
                        support.LoggingSilencer,
                        unittest.TestCase):
  
      def test_home_installation_scheme(self):
          # This ensure two things:
          # - that --home generates the desired set of directory names
          # - test --home is supported on all platforms
          builddir = self.mkdtemp()
          destination = os.path.join(builddir, "installation")
  
          dist = Distribution({"name": "foopkg"})
          # script_name need not exist, it just need to be initialized
          dist.script_name = os.path.join(builddir, "setup.py")
          dist.command_obj["build"] = support.DummyCommand(
              build_base=builddir,
              build_lib=os.path.join(builddir, "lib"),
              )
  
          cmd = install(dist)
          cmd.home = destination
          cmd.ensure_finalized()
  
          self.assertEqual(cmd.install_base, destination)
          self.assertEqual(cmd.install_platbase, destination)
  
          def check_path(got, expected):
              got = os.path.normpath(got)
              expected = os.path.normpath(expected)
              self.assertEqual(got, expected)
  
          libdir = os.path.join(destination, "lib", "python")
          check_path(cmd.install_lib, libdir)
          platlibdir = os.path.join(destination, sys.platlibdir, "python")
          check_path(cmd.install_platlib, platlibdir)
          check_path(cmd.install_purelib, libdir)
          check_path(cmd.install_headers,
                     os.path.join(destination, "include", "python", "foopkg"))
          check_path(cmd.install_scripts, os.path.join(destination, "bin"))
          check_path(cmd.install_data, destination)
  
      def test_user_site(self):
          # test install with --user
          # preparing the environment for the test
          self.old_user_base = site.USER_BASE
          self.old_user_site = site.USER_SITE
          self.tmpdir = self.mkdtemp()
          self.user_base = os.path.join(self.tmpdir, 'B')
          self.user_site = os.path.join(self.tmpdir, 'S')
          site.USER_BASE = self.user_base
          site.USER_SITE = self.user_site
          install_module.USER_BASE = self.user_base
          install_module.USER_SITE = self.user_site
  
          def _expanduser(path):
              return self.tmpdir
          self.old_expand = os.path.expanduser
          os.path.expanduser = _expanduser
  
          def cleanup():
              site.USER_BASE = self.old_user_base
              site.USER_SITE = self.old_user_site
              install_module.USER_BASE = self.old_user_base
              install_module.USER_SITE = self.old_user_site
              os.path.expanduser = self.old_expand
  
          self.addCleanup(cleanup)
  
          for key in ('nt_user', 'unix_user', 'os2_user'):
              self.assertIn(key, INSTALL_SCHEMES)
  
          dist = Distribution({'name': 'xx'})
          cmd = install(dist)
  
          # making sure the user option is there
          options = [name for name, short, lable in
                     cmd.user_options]
          self.assertIn('user', options)
  
          # setting a value
          cmd.user = 1
  
          # user base and site shouldn't be created yet
          self.assertFalse(os.path.exists(self.user_base))
          self.assertFalse(os.path.exists(self.user_site))
  
          # let's run finalize
          cmd.ensure_finalized()
  
          # now they should
          self.assertTrue(os.path.exists(self.user_base))
          self.assertTrue(os.path.exists(self.user_site))
  
          self.assertIn('userbase', cmd.config_vars)
          self.assertIn('usersite', cmd.config_vars)
  
      def test_handle_extra_path(self):
          dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})
          cmd = install(dist)
  
          # two elements
          cmd.handle_extra_path()
          self.assertEqual(cmd.extra_path, ['path', 'dirs'])
          self.assertEqual(cmd.extra_dirs, 'dirs')
          self.assertEqual(cmd.path_file, 'path')
  
          # one element
          cmd.extra_path = ['path']
          cmd.handle_extra_path()
          self.assertEqual(cmd.extra_path, ['path'])
          self.assertEqual(cmd.extra_dirs, 'path')
          self.assertEqual(cmd.path_file, 'path')
  
          # none
          dist.extra_path = cmd.extra_path = None
          cmd.handle_extra_path()
          self.assertEqual(cmd.extra_path, None)
          self.assertEqual(cmd.extra_dirs, '')
          self.assertEqual(cmd.path_file, None)
  
          # three elements (no way !)
          cmd.extra_path = 'path,dirs,again'
          self.assertRaises(DistutilsOptionError, cmd.handle_extra_path)
  
      def test_finalize_options(self):
          dist = Distribution({'name': 'xx'})
          cmd = install(dist)
  
          # must supply either prefix/exec-prefix/home or
          # install-base/install-platbase -- not both
          cmd.prefix = 'prefix'
          cmd.install_base = 'base'
          self.assertRaises(DistutilsOptionError, cmd.finalize_options)
  
          # must supply either home or prefix/exec-prefix -- not both
          cmd.install_base = None
          cmd.home = 'home'
          self.assertRaises(DistutilsOptionError, cmd.finalize_options)
  
          # can't combine user with prefix/exec_prefix/home or
          # install_(plat)base
          cmd.prefix = None
          cmd.user = 'user'
          self.assertRaises(DistutilsOptionError, cmd.finalize_options)
  
      def test_record(self):
          install_dir = self.mkdtemp()
          project_dir, dist = self.create_dist(py_modules=['hello'],
                                               scripts=['sayhi'])
          os.chdir(project_dir)
          self.write_file('hello.py', "def main(): print('o hai')")
          self.write_file('sayhi', 'from hello import main; main()')
  
          cmd = install(dist)
          dist.command_obj['install'] = cmd
          cmd.root = install_dir
          cmd.record = os.path.join(project_dir, 'filelist')
          cmd.ensure_finalized()
          cmd.run()
  
          f = open(cmd.record)
          try:
              content = f.read()
          finally:
              f.close()
  
          found = [os.path.basename(line) for line in content.splitlines()]
          expected = ['hello.py', 'hello.%s.pyc' % sys.implementation.cache_tag,
                      'sayhi',
                      'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2]]
          self.assertEqual(found, expected)
  
      def test_record_extensions(self):
          cmd = test_support.missing_compiler_executable()
          if cmd is not None:
              self.skipTest('The %r command is not found' % cmd)
          install_dir = self.mkdtemp()
          project_dir, dist = self.create_dist(ext_modules=[
              Extension('xx', ['xxmodule.c'])])
          os.chdir(project_dir)
          support.copy_xxmodule_c(project_dir)
  
          buildextcmd = build_ext(dist)
          support.fixup_build_ext(buildextcmd)
          buildextcmd.ensure_finalized()
  
          cmd = install(dist)
          dist.command_obj['install'] = cmd
          dist.command_obj['build_ext'] = buildextcmd
          cmd.root = install_dir
          cmd.record = os.path.join(project_dir, 'filelist')
          cmd.ensure_finalized()
          cmd.run()
  
          f = open(cmd.record)
          try:
              content = f.read()
          finally:
              f.close()
  
          found = [os.path.basename(line) for line in content.splitlines()]
          expected = [_make_ext_name('xx'),
                      'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2]]
          self.assertEqual(found, expected)
  
      def test_debug_mode(self):
          # this covers the code called when DEBUG is set
          old_logs_len = len(self.logs)
          install_module.DEBUG = True
          try:
              with captured_stdout():
                  self.test_record()
          finally:
              install_module.DEBUG = False
          self.assertGreater(len(self.logs), old_logs_len)
  
  
  def test_suite():
      return unittest.makeSuite(InstallTestCase)
  
  if __name__ == "__main__":
      run_unittest(test_suite())
  