home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_import.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  10.3 KB  |  306 lines
  1. import unittest
  2. import os
  3. import random
  4. import shutil
  5. import sys
  6. import py_compile
  7. import warnings
  8. from test.test_support import unlink, TESTFN, unload, run_unittest, check_warnings
  9.  
  10.  
  11. def remove_files(name):
  12.     for f in (name + os.extsep + "py",
  13.               name + os.extsep + "pyc",
  14.               name + os.extsep + "pyo",
  15.               name + os.extsep + "pyw",
  16.               name + "$py.class"):
  17.         if os.path.exists(f):
  18.             os.remove(f)
  19.  
  20.  
  21. class ImportTest(unittest.TestCase):
  22.  
  23.     def testCaseSensitivity(self):
  24.         # Brief digression to test that import is case-sensitive:  if we got this
  25.         # far, we know for sure that "random" exists.
  26.         try:
  27.             import RAnDoM
  28.         except ImportError:
  29.             pass
  30.         else:
  31.             self.fail("import of RAnDoM should have failed (case mismatch)")
  32.  
  33.     def testDoubleConst(self):
  34.         # Another brief digression to test the accuracy of manifest float constants.
  35.         from test import double_const  # don't blink -- that *was* the test
  36.  
  37.     def testImport(self):
  38.         def test_with_extension(ext):
  39.             # ext normally ".py"; perhaps ".pyw"
  40.             source = TESTFN + ext
  41.             pyo = TESTFN + os.extsep + "pyo"
  42.             if sys.platform.startswith('java'):
  43.                 pyc = TESTFN + "$py.class"
  44.             else:
  45.                 pyc = TESTFN + os.extsep + "pyc"
  46.  
  47.             f = open(source, "w")
  48.             print >> f, "# This tests Python's ability to import a", ext, "file."
  49.             a = random.randrange(1000)
  50.             b = random.randrange(1000)
  51.             print >> f, "a =", a
  52.             print >> f, "b =", b
  53.             f.close()
  54.  
  55.             try:
  56.                 try:
  57.                     mod = __import__(TESTFN)
  58.                 except ImportError, err:
  59.                     self.fail("import from %s failed: %s" % (ext, err))
  60.  
  61.                 self.assertEquals(mod.a, a,
  62.                     "module loaded (%s) but contents invalid" % mod)
  63.                 self.assertEquals(mod.b, b,
  64.                     "module loaded (%s) but contents invalid" % mod)
  65.             finally:
  66.                 os.unlink(source)
  67.  
  68.             try:
  69.                 try:
  70.                     reload(mod)
  71.                 except ImportError, err:
  72.                     self.fail("import from .pyc/.pyo failed: %s" % err)
  73.             finally:
  74.                 try:
  75.                     os.unlink(pyc)
  76.                 except OSError:
  77.                     pass
  78.                 try:
  79.                     os.unlink(pyo)
  80.                 except OSError:
  81.                     pass
  82.                 del sys.modules[TESTFN]
  83.  
  84.         sys.path.insert(0, os.curdir)
  85.         try:
  86.             test_with_extension(os.extsep + "py")
  87.             if sys.platform.startswith("win"):
  88.                 for ext in ".PY", ".Py", ".pY", ".pyw", ".PYW", ".pYw":
  89.                     test_with_extension(ext)
  90.         finally:
  91.             del sys.path[0]
  92.  
  93.     def testImpModule(self):
  94.         # Verify that the imp module can correctly load and find .py files
  95.         import imp
  96.         x = imp.find_module("os")
  97.         os = imp.load_module("os", *x)
  98.  
  99.     def test_module_with_large_stack(self, module='longlist'):
  100.         # create module w/list of 65000 elements to test bug #561858
  101.         filename = module + os.extsep + 'py'
  102.  
  103.         # create a file with a list of 65000 elements
  104.         f = open(filename, 'w+')
  105.         f.write('d = [\n')
  106.         for i in range(65000):
  107.             f.write('"",\n')
  108.         f.write(']')
  109.         f.close()
  110.  
  111.         # compile & remove .py file, we only need .pyc (or .pyo)
  112.         f = open(filename, 'r')
  113.         py_compile.compile(filename)
  114.         f.close()
  115.         os.unlink(filename)
  116.  
  117.         # need to be able to load from current dir
  118.         sys.path.append('')
  119.  
  120.         # this used to crash
  121.         exec 'import ' + module
  122.  
  123.         # cleanup
  124.         del sys.path[-1]
  125.         for ext in 'pyc', 'pyo':
  126.             fname = module + os.extsep + ext
  127.             if os.path.exists(fname):
  128.                 os.unlink(fname)
  129.  
  130.     def test_failing_import_sticks(self):
  131.         source = TESTFN + os.extsep + "py"
  132.         f = open(source, "w")
  133.         print >> f, "a = 1/0"
  134.         f.close()
  135.  
  136.         # New in 2.4, we shouldn't be able to import that no matter how often
  137.         # we try.
  138.         sys.path.insert(0, os.curdir)
  139.         try:
  140.             for i in 1, 2, 3:
  141.                 try:
  142.                     mod = __import__(TESTFN)
  143.                 except ZeroDivisionError:
  144.                     if TESTFN in sys.modules:
  145.                         self.fail("damaged module in sys.modules on %i. try" % i)
  146.                 else:
  147.                     self.fail("was able to import a damaged module on %i. try" % i)
  148.         finally:
  149.             sys.path.pop(0)
  150.             remove_files(TESTFN)
  151.  
  152.     def test_failing_reload(self):
  153.         # A failing reload should leave the module object in sys.modules.
  154.         source = TESTFN + os.extsep + "py"
  155.         f = open(source, "w")
  156.         print >> f, "a = 1"
  157.         print >> f, "b = 2"
  158.         f.close()
  159.  
  160.         sys.path.insert(0, os.curdir)
  161.         try:
  162.             mod = __import__(TESTFN)
  163.             self.assert_(TESTFN in sys.modules, "expected module in sys.modules")
  164.             self.assertEquals(mod.a, 1, "module has wrong attribute values")
  165.             self.assertEquals(mod.b, 2, "module has wrong attribute values")
  166.  
  167.             # On WinXP, just replacing the .py file wasn't enough to
  168.             # convince reload() to reparse it.  Maybe the timestamp didn't
  169.             # move enough.  We force it to get reparsed by removing the
  170.             # compiled file too.
  171.             remove_files(TESTFN)
  172.  
  173.             # Now damage the module.
  174.             f = open(source, "w")
  175.             print >> f, "a = 10"
  176.             print >> f, "b = 20//0"
  177.             f.close()
  178.  
  179.             self.assertRaises(ZeroDivisionError, reload, mod)
  180.  
  181.             # But we still expect the module to be in sys.modules.
  182.             mod = sys.modules.get(TESTFN)
  183.             self.failIf(mod is None, "expected module to still be in sys.modules")
  184.  
  185.             # We should have replaced a w/ 10, but the old b value should
  186.             # stick.
  187.             self.assertEquals(mod.a, 10, "module has wrong attribute values")
  188.             self.assertEquals(mod.b, 2, "module has wrong attribute values")
  189.  
  190.         finally:
  191.             sys.path.pop(0)
  192.             remove_files(TESTFN)
  193.             if TESTFN in sys.modules:
  194.                 del sys.modules[TESTFN]
  195.  
  196.     def test_infinite_reload(self):
  197.         # Bug #742342 reports that Python segfaults (infinite recursion in C)
  198.         #  when faced with self-recursive reload()ing.
  199.  
  200.         sys.path.insert(0, os.path.dirname(__file__))
  201.         try:
  202.             import infinite_reload
  203.         finally:
  204.             sys.path.pop(0)
  205.  
  206.     def test_import_name_binding(self):
  207.         # import x.y.z binds x in the current namespace
  208.         import test as x
  209.         import test.test_support
  210.         self.assert_(x is test, x.__name__)
  211.         self.assert_(hasattr(test.test_support, "__file__"))
  212.  
  213.         # import x.y.z as w binds z as w
  214.         import test.test_support as y
  215.         self.assert_(y is test.test_support, y.__name__)
  216.  
  217.     def test_import_initless_directory_warning(self):
  218.         with warnings.catch_warnings():
  219.             # Just a random non-package directory we always expect to be
  220.             # somewhere in sys.path...
  221.             warnings.simplefilter('error', ImportWarning)
  222.             self.assertRaises(ImportWarning, __import__, "site-packages")
  223.  
  224.     def test_importbyfilename(self):
  225.         path = os.path.abspath(TESTFN)
  226.         try:
  227.             __import__(path)
  228.         except ImportError, err:
  229.             self.assertEqual("Import by filename is not supported.",
  230.                               err.args[0])
  231.         else:
  232.             self.fail("import by path didn't raise an exception")
  233.  
  234. class PathsTests(unittest.TestCase):
  235.     path = TESTFN
  236.  
  237.     def setUp(self):
  238.         os.mkdir(self.path)
  239.         self.syspath = sys.path[:]
  240.  
  241.     def tearDown(self):
  242.         shutil.rmtree(self.path)
  243.         sys.path = self.syspath
  244.  
  245.     # http://bugs.python.org/issue1293
  246.     def test_trailing_slash(self):
  247.         f = open(os.path.join(self.path, 'test_trailing_slash.py'), 'w')
  248.         f.write("testdata = 'test_trailing_slash'")
  249.         f.close()
  250.         sys.path.append(self.path+'/')
  251.         mod = __import__("test_trailing_slash")
  252.         self.assertEqual(mod.testdata, 'test_trailing_slash')
  253.         unload("test_trailing_slash")
  254.  
  255. class RelativeImport(unittest.TestCase):
  256.     def tearDown(self):
  257.         try:
  258.             del sys.modules["test.relimport"]
  259.         except:
  260.             pass
  261.  
  262.     def test_relimport_star(self):
  263.         # This will import * from .test_import.
  264.         from . import relimport
  265.         self.assertTrue(hasattr(relimport, "RelativeImport"))
  266.  
  267.     def test_issue3221(self):
  268.         def check_absolute():
  269.             exec "from os import path" in ns
  270.         def check_relative():
  271.             exec "from . import relimport" in ns
  272.         # Check both OK with __package__ and __name__ correct
  273.         ns = dict(__package__='test', __name__='test.notarealmodule')
  274.         check_absolute()
  275.         check_relative()
  276.         # Check both OK with only __name__ wrong
  277.         ns = dict(__package__='test', __name__='notarealpkg.notarealmodule')
  278.         check_absolute()
  279.         check_relative()
  280.         # Check relative fails with only __package__ wrong
  281.         ns = dict(__package__='foo', __name__='test.notarealmodule')
  282.         with check_warnings() as w:
  283.             check_absolute()
  284.             self.assert_('foo' in str(w.message))
  285.             self.assertEqual(w.category, RuntimeWarning)
  286.         self.assertRaises(SystemError, check_relative)
  287.         # Check relative fails with __package__ and __name__ wrong
  288.         ns = dict(__package__='foo', __name__='notarealpkg.notarealmodule')
  289.         with check_warnings() as w:
  290.             check_absolute()
  291.             self.assert_('foo' in str(w.message))
  292.             self.assertEqual(w.category, RuntimeWarning)
  293.         self.assertRaises(SystemError, check_relative)
  294.         # Check both fail with package set to a non-string
  295.         ns = dict(__package__=object())
  296.         self.assertRaises(ValueError, check_absolute)
  297.         self.assertRaises(ValueError, check_relative)
  298.  
  299. def test_main(verbose=None):
  300.     run_unittest(ImportTest, PathsTests, RelativeImport)
  301.  
  302. if __name__ == '__main__':
  303.     # test needs to be a package, so we can do relative import
  304.     from test.test_import import test_main
  305.     test_main()
  306.