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_pkg.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  8.9 KB  |  284 lines

  1. # Test packages (dotted-name import)
  2.  
  3. import sys
  4. import os
  5. import tempfile
  6. import textwrap
  7. import unittest
  8. from test import test_support
  9.  
  10.  
  11. # Helpers to create and destroy hierarchies.
  12.  
  13. def cleanout(root):
  14.     names = os.listdir(root)
  15.     for name in names:
  16.         fullname = os.path.join(root, name)
  17.         if os.path.isdir(fullname) and not os.path.islink(fullname):
  18.             cleanout(fullname)
  19.         else:
  20.             os.remove(fullname)
  21.     os.rmdir(root)
  22.  
  23. def fixdir(lst):
  24.     if "__builtins__" in lst:
  25.         lst.remove("__builtins__")
  26.     return lst
  27.  
  28.  
  29. # XXX Things to test
  30. #
  31. # import package without __init__
  32. # import package with __init__
  33. # __init__ importing submodule
  34. # __init__ importing global module
  35. # __init__ defining variables
  36. # submodule importing other submodule
  37. # submodule importing global module
  38. # submodule import submodule via global name
  39. # from package import submodule
  40. # from package import subpackage
  41. # from package import variable (defined in __init__)
  42. # from package import * (defined in __init__)
  43.  
  44.  
  45. class Test(unittest.TestCase):
  46.  
  47.     def setUp(self):
  48.         self.root = None
  49.         self.pkgname = None
  50.         self.syspath = list(sys.path)
  51.  
  52.     def tearDown(self):
  53.         sys.path[:] = self.syspath
  54.         cleanout(self.root)
  55.  
  56.         # delete all modules concerning the tested hiearchy
  57.         if self.pkgname:
  58.             modules = [name for name in sys.modules
  59.                        if self.pkgname in name.split('.')]
  60.             for name in modules:
  61.                 del sys.modules[name]
  62.  
  63.     def run_code(self, code):
  64.         exec(textwrap.dedent(code), globals(), {"self": self})
  65.  
  66.     def mkhier(self, descr):
  67.         root = tempfile.mkdtemp()
  68.         sys.path.insert(0, root)
  69.         if not os.path.isdir(root):
  70.             os.mkdir(root)
  71.         for name, contents in descr:
  72.             comps = name.split()
  73.             fullname = root
  74.             for c in comps:
  75.                 fullname = os.path.join(fullname, c)
  76.             if contents is None:
  77.                 os.mkdir(fullname)
  78.             else:
  79.                 f = open(fullname, "w")
  80.                 f.write(contents)
  81.                 if contents and contents[-1] != '\n':
  82.                     f.write('\n')
  83.                 f.close()
  84.         self.root = root
  85.         # package name is the name of the first item
  86.         self.pkgname = descr[0][0]
  87.  
  88.     def test_1(self):
  89.         hier = [("t1", None), ("t1 __init__"+os.extsep+"py", "")]
  90.         self.mkhier(hier)
  91.         import t1
  92.  
  93.     def test_2(self):
  94.         hier = [
  95.          ("t2", None),
  96.          ("t2 __init__"+os.extsep+"py", "'doc for t2'"),
  97.          ("t2 sub", None),
  98.          ("t2 sub __init__"+os.extsep+"py", ""),
  99.          ("t2 sub subsub", None),
  100.          ("t2 sub subsub __init__"+os.extsep+"py", "spam = 1"),
  101.         ]
  102.         self.mkhier(hier)
  103.  
  104.         import t2
  105.         self.assertEqual(t2.__doc__, "doc for t2")
  106.  
  107.         import t2.sub
  108.         import t2.sub.subsub
  109.         self.assertEqual(t2.__name__, "t2")
  110.         self.assertEqual(t2.sub.__name__, "t2.sub")
  111.         self.assertEqual(t2.sub.subsub.__name__, "t2.sub.subsub")
  112.  
  113.         # This exec crap is needed because Py3k forbids 'import *' outside
  114.         # of module-scope and __import__() is insufficient for what we need.
  115.         s = """
  116.             import t2
  117.             from t2 import *
  118.             self.assertEqual(dir(), ['self', 'sub', 't2'])
  119.             """
  120.         self.run_code(s)
  121.  
  122.         from t2 import sub
  123.         from t2.sub import subsub
  124.         from t2.sub.subsub import spam
  125.         self.assertEqual(sub.__name__, "t2.sub")
  126.         self.assertEqual(subsub.__name__, "t2.sub.subsub")
  127.         self.assertEqual(sub.subsub.__name__, "t2.sub.subsub")
  128.         for name in ['spam', 'sub', 'subsub', 't2']:
  129.             self.failUnless(locals()["name"], "Failed to import %s" % name)
  130.  
  131.         import t2.sub
  132.         import t2.sub.subsub
  133.         self.assertEqual(t2.__name__, "t2")
  134.         self.assertEqual(t2.sub.__name__, "t2.sub")
  135.         self.assertEqual(t2.sub.subsub.__name__, "t2.sub.subsub")
  136.  
  137.         s = """
  138.             from t2 import *
  139.             self.failUnless(dir(), ['self', 'sub'])
  140.             """
  141.         self.run_code(s)
  142.  
  143.     def test_3(self):
  144.         hier = [
  145.                 ("t3", None),
  146.                 ("t3 __init__"+os.extsep+"py", ""),
  147.                 ("t3 sub", None),
  148.                 ("t3 sub __init__"+os.extsep+"py", ""),
  149.                 ("t3 sub subsub", None),
  150.                 ("t3 sub subsub __init__"+os.extsep+"py", "spam = 1"),
  151.                ]
  152.         self.mkhier(hier)
  153.  
  154.         import t3.sub.subsub
  155.         self.assertEqual(t3.__name__, "t3")
  156.         self.assertEqual(t3.sub.__name__, "t3.sub")
  157.         self.assertEqual(t3.sub.subsub.__name__, "t3.sub.subsub")
  158.  
  159.     def test_4(self):
  160.         hier = [
  161.         ("t4.py", "raise RuntimeError('Shouldnt load t4.py')"),
  162.         ("t4", None),
  163.         ("t4 __init__"+os.extsep+"py", ""),
  164.         ("t4 sub.py", "raise RuntimeError('Shouldnt load sub.py')"),
  165.         ("t4 sub", None),
  166.         ("t4 sub __init__"+os.extsep+"py", ""),
  167.         ("t4 sub subsub"+os.extsep+"py",
  168.          "raise RuntimeError('Shouldnt load subsub.py')"),
  169.         ("t4 sub subsub", None),
  170.         ("t4 sub subsub __init__"+os.extsep+"py", "spam = 1"),
  171.                ]
  172.         self.mkhier(hier)
  173.  
  174.         s = """
  175.             from t4.sub.subsub import *
  176.             self.assertEqual(spam, 1)
  177.             """
  178.         self.run_code(s)
  179.  
  180.     def test_5(self):
  181.         hier = [
  182.         ("t5", None),
  183.         ("t5 __init__"+os.extsep+"py", "import t5.foo"),
  184.         ("t5 string"+os.extsep+"py", "spam = 1"),
  185.         ("t5 foo"+os.extsep+"py",
  186.          "from . import string; assert string.spam == 1"),
  187.          ]
  188.         self.mkhier(hier)
  189.  
  190.         import t5
  191.         s = """
  192.             from t5 import *
  193.             self.assertEqual(dir(), ['foo', 'self', 'string', 't5'])
  194.             """
  195.         self.run_code(s)
  196.  
  197.         import t5
  198.         self.assertEqual(fixdir(dir(t5)),
  199.                          ['__doc__', '__file__', '__name__',
  200.                           '__package__', '__path__', 'foo', 'string', 't5'])
  201.         self.assertEqual(fixdir(dir(t5.foo)),
  202.                          ['__doc__', '__file__', '__name__', '__package__',
  203.                           'string'])
  204.         self.assertEqual(fixdir(dir(t5.string)),
  205.                          ['__doc__', '__file__', '__name__','__package__',
  206.                           'spam'])
  207.  
  208.     def test_6(self):
  209.         hier = [
  210.                 ("t6", None),
  211.                 ("t6 __init__"+os.extsep+"py",
  212.                  "__all__ = ['spam', 'ham', 'eggs']"),
  213.                 ("t6 spam"+os.extsep+"py", ""),
  214.                 ("t6 ham"+os.extsep+"py", ""),
  215.                 ("t6 eggs"+os.extsep+"py", ""),
  216.                ]
  217.         self.mkhier(hier)
  218.  
  219.         import t6
  220.         self.assertEqual(fixdir(dir(t6)),
  221.                          ['__all__', '__doc__', '__file__',
  222.                           '__name__', '__package__', '__path__'])
  223.         s = """
  224.             import t6
  225.             from t6 import *
  226.             self.assertEqual(fixdir(dir(t6)),
  227.                              ['__all__', '__doc__', '__file__',
  228.                               '__name__', '__package__', '__path__',
  229.                               'eggs', 'ham', 'spam'])
  230.             self.assertEqual(dir(), ['eggs', 'ham', 'self', 'spam', 't6'])
  231.             """
  232.         self.run_code(s)
  233.  
  234.     def test_7(self):
  235.         hier = [
  236.                 ("t7", None),
  237.                 ("t7"+os.extsep+"py", ""),
  238.                 ("t7 __init__"+os.extsep+"py", ""),
  239.                 ("t7 sub"+os.extsep+"py",
  240.                  "raise RuntimeError('Shouldnt load sub.py')"),
  241.                 ("t7 sub", None),
  242.                 ("t7 sub __init__"+os.extsep+"py", ""),
  243.                 ("t7 sub "+os.extsep+"py",
  244.                  "raise RuntimeError('Shouldnt load subsub.py')"),
  245.                 ("t7 sub subsub", None),
  246.                 ("t7 sub subsub __init__"+os.extsep+"py",
  247.                  "spam = 1"),
  248.                ]
  249.         self.mkhier(hier)
  250.  
  251.  
  252.         t7, sub, subsub = None, None, None
  253.         import t7 as tas
  254.         self.assertEqual(fixdir(dir(tas)),
  255.                          ['__doc__', '__file__', '__name__',
  256.                           '__package__', '__path__'])
  257.         self.failIf(t7)
  258.         from t7 import sub as subpar
  259.         self.assertEqual(fixdir(dir(subpar)),
  260.                          ['__doc__', '__file__', '__name__',
  261.                           '__package__', '__path__'])
  262.         self.failIf(t7)
  263.         self.failIf(sub)
  264.         from t7.sub import subsub as subsubsub
  265.         self.assertEqual(fixdir(dir(subsubsub)),
  266.                          ['__doc__', '__file__', '__name__',
  267.                          '__package__', '__path__', 'spam'])
  268.         self.failIf(t7)
  269.         self.failIf(sub)
  270.         self.failIf(subsub)
  271.         from t7.sub.subsub import spam as ham
  272.         self.assertEqual(ham, 1)
  273.         self.failIf(t7)
  274.         self.failIf(sub)
  275.         self.failIf(subsub)
  276.  
  277.  
  278. def test_main():
  279.     test_support.run_unittest(__name__)
  280.  
  281.  
  282. if __name__ == "__main__":
  283.     test_main()
  284.