home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / Bureautique / gImageReader / gimagereader_0.9-1_win32.exe / bin / enchant / tests.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2011-03-24  |  22KB  |  691 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. '''
  5.  
  6.     enchant.tests:  testcases for pyenchant
  7.  
  8. '''
  9. import os
  10. import sys
  11. import unittest
  12.  
  13. try:
  14.     import subprocess
  15. except ImportError:
  16.     subprocess is None
  17.  
  18. import enchant
  19. from enchant import *
  20. from enchant import _enchant as _e
  21. from enchant.utils import unicode, raw_unicode, printf
  22.  
  23. def runcmd(cmd):
  24.     if subprocess is not None:
  25.         kwds = dict(stdout = subprocess.PIPE, stderr = subprocess.PIPE, shell = True)
  26.         p = subprocess.Popen(cmd, **kwds)
  27.         (stdout, stderr) = p.communicate()
  28.         if p.returncode:
  29.             if sys.version_info[0] >= 3:
  30.                 stderr = stderr.decode(sys.getdefaultencoding(), 'replace')
  31.             sys.stderr.write(stderr)
  32.         return p.returncode
  33.     return None.system(cmd)
  34.  
  35.  
  36. class TestBroker(unittest.TestCase):
  37.     '''Test cases for the proper functioning of Broker objects.
  38.  
  39.     These tests assume that there is at least one working provider
  40.     with a dictionary for the "en_US" language.
  41.     '''
  42.     
  43.     def setUp(self):
  44.         self.broker = Broker()
  45.  
  46.     
  47.     def tearDown(self):
  48.         del self.broker
  49.  
  50.     
  51.     def test_HasENUS(self):
  52.         '''Test that the en_US language is available.'''
  53.         self.assertTrue(self.broker.dict_exists('en_US'))
  54.  
  55.     
  56.     def test_LangsAreAvail(self):
  57.         '''Test whether all advertised languages are in fact available.'''
  58.         for lang in self.broker.list_languages():
  59.             if not self.broker.dict_exists(lang) or False:
  60.                 raise AssertionError, "language '" + lang + "' advertised but non-existent"
  61.         
  62.  
  63.     
  64.     def test_ProvsAreAvail(self):
  65.         '''Test whether all advertised providers are in fact available.'''
  66.         for lang, prov in self.broker.list_dicts():
  67.             self.assertTrue(self.broker.dict_exists(lang))
  68.             if not self.broker.dict_exists(lang) and False:
  69.                 raise AssertionError, "language '" + lang + "' advertised but non-existent"
  70.             if not prov not in self.broker.describe() or False:
  71.                 raise AssertionError, "provier '" + str(prov) + "' advertised but non-existent"
  72.         
  73.  
  74.     
  75.     def test_ProvOrdering(self):
  76.         '''Test that provider ordering works correctly.'''
  77.         langs = { }
  78.         provs = []
  79.         for tag, prov in self.broker.list_dicts():
  80.             if tag.startswith('hyph_') and prov.name == 'myspell':
  81.                 continue
  82.             tag = tag.replace('-', '_')
  83.             langs[tag] = []
  84.             if prov not in provs and prov.name != 'zemberek':
  85.                 provs.append(prov)
  86.                 continue
  87.         for prov in provs:
  88.             for tag in langs:
  89.                 b2 = Broker()
  90.                 b2.set_ordering(tag, prov.name)
  91.                 
  92.                 try:
  93.                     d = b2.request_dict(tag)
  94.                     if d.provider != prov:
  95.                         raise ValueError()
  96.                     langs[tag].append(prov)
  97.                 continue
  98.                 continue
  99.  
  100.             
  101.         
  102.         for tag in langs:
  103.             for prov in langs[tag]:
  104.                 b2 = Broker()
  105.                 b2.set_ordering(tag, prov.name)
  106.                 d = b2.request_dict(tag)
  107.                 self.assertEqual((d.provider, tag), (prov, tag))
  108.                 del d
  109.                 del b2
  110.             
  111.         
  112.         for tag in langs:
  113.             for prov in langs[tag]:
  114.                 order = prov.name
  115.                 for prov2 in provs:
  116.                     if prov2 not in langs[tag]:
  117.                         order = prov2.name + ',' + order
  118.                         continue
  119.                 b2 = Broker()
  120.                 b2.set_ordering(tag, order)
  121.                 d = b2.request_dict(tag)
  122.                 self.assertEqual((d.provider, tag, order), (prov, tag, order))
  123.                 del d
  124.                 del b2
  125.             
  126.         
  127.  
  128.     
  129.     def test_UnicodeTag(self):
  130.         '''Test that unicode language tags are accepted'''
  131.         d1 = self.broker._request_dict_data(raw_unicode('en_US'))
  132.         self.assertTrue(d1)
  133.         _e.broker_free_dict(self.broker._this, d1)
  134.         d1 = Dict(raw_unicode('en_US'))
  135.         self.assertTrue(d1)
  136.  
  137.     
  138.     def test_GetSetParam(self):
  139.         
  140.         try:
  141.             self.broker.get_param('pyenchant.unittest')
  142.         except AttributeError:
  143.             return None
  144.  
  145.         self.assertEqual(self.broker.get_param('pyenchant.unittest'), None)
  146.         self.broker.set_param('pyenchant.unittest', 'testing')
  147.         self.assertEqual(self.broker.get_param('pyenchant.unittest'), 'testing')
  148.         self.assertEqual(Broker().get_param('pyenchant.unittest'), None)
  149.  
  150.  
  151.  
  152. class TestDict(unittest.TestCase):
  153.     '''Test cases for the proper functioning of Dict objects.
  154.     These tests assume that there is at least one working provider
  155.     with a dictionary for the "en_US" language.
  156.     '''
  157.     
  158.     def setUp(self):
  159.         self.dict = Dict('en_US')
  160.  
  161.     
  162.     def tearDown(self):
  163.         del self.dict
  164.  
  165.     
  166.     def test_HasENUS(self):
  167.         '''Test that the en_US language is available through default broker.'''
  168.         self.assertTrue(dict_exists('en_US'))
  169.  
  170.     
  171.     def test_check(self):
  172.         '''Test that check() works on some common words.'''
  173.         self.assertTrue(self.dict.check('hello'))
  174.         self.assertTrue(self.dict.check('test'))
  175.         self.assertFalse(self.dict.check('helo'))
  176.         self.assertFalse(self.dict.check('testt'))
  177.  
  178.     
  179.     def test_broker(self):
  180.         """Test that the dict's broker is set correctly."""
  181.         self.assertTrue(self.dict._broker is enchant._broker)
  182.  
  183.     
  184.     def test_tag(self):
  185.         """Test that the dict's tag is set correctly."""
  186.         self.assertEqual(self.dict.tag, 'en_US')
  187.  
  188.     
  189.     def test_suggest(self):
  190.         '''Test that suggest() gets simple suggestions right.'''
  191.         self.assertTrue(self.dict.check('hello'))
  192.         self.assertTrue('hello' in self.dict.suggest('helo'))
  193.  
  194.     
  195.     def test_suggestHang1(self):
  196.         '''Test whether suggest() hangs on some inputs (Bug #1404196)'''
  197.         self.assertTrue(len(self.dict.suggest('Thiis')) >= 0)
  198.         self.assertTrue(len(self.dict.suggest('Thiiis')) >= 0)
  199.         self.assertTrue(len(self.dict.suggest('Thiiiis')) >= 0)
  200.  
  201.     
  202.     def test_unicode1(self):
  203.         '''Test checking/suggesting for unicode strings'''
  204.         us1 = raw_unicode('he\\u2149lo')
  205.         self.assertTrue(type(us1) is unicode)
  206.         self.assertFalse(self.dict.check(us1))
  207.         for s in self.dict.suggest(us1):
  208.             self.assertTrue(type(s) is unicode)
  209.         
  210.  
  211.     
  212.     def test_session(self):
  213.         '''Test that adding words to the session works as required.'''
  214.         self.assertFalse(self.dict.check('Lozz'))
  215.         self.assertFalse(self.dict.is_added('Lozz'))
  216.         self.dict.add_to_session('Lozz')
  217.         self.assertTrue(self.dict.is_added('Lozz'))
  218.         self.assertTrue(self.dict.check('Lozz'))
  219.         self.dict.remove_from_session('Lozz')
  220.         self.assertFalse(self.dict.check('Lozz'))
  221.         self.assertFalse(self.dict.is_added('Lozz'))
  222.         self.dict.remove_from_session('hello')
  223.         self.assertFalse(self.dict.check('hello'))
  224.         self.assertTrue(self.dict.is_removed('hello'))
  225.         self.dict.add_to_session('hello')
  226.  
  227.     
  228.     def test_AddRemove(self):
  229.         '''Test adding/removing from default user dictionary.'''
  230.         nonsense = 'kxhjsddsi'
  231.         self.assertFalse(self.dict.check(nonsense))
  232.         self.dict.add(nonsense)
  233.         self.assertTrue(self.dict.is_added(nonsense))
  234.         self.assertTrue(self.dict.check(nonsense))
  235.         self.dict.remove(nonsense)
  236.         self.assertFalse(self.dict.is_added(nonsense))
  237.         self.assertFalse(self.dict.check(nonsense))
  238.         self.dict.remove('pineapple')
  239.         self.assertFalse(self.dict.check('pineapple'))
  240.         self.assertTrue(self.dict.is_removed('pineapple'))
  241.         self.assertFalse(self.dict.is_added('pineapple'))
  242.         self.dict.add('pineapple')
  243.         self.assertTrue(self.dict.check('pineapple'))
  244.  
  245.     
  246.     def test_DefaultLang(self):
  247.         '''Test behaviour of default language selection.'''
  248.         defLang = utils.get_default_language()
  249.         if defLang is None:
  250.             self.assertRaises(Error, Dict)
  251.         else:
  252.             
  253.             try:
  254.                 d = Dict()
  255.                 self.assertEqual(d.tag, defLang)
  256.             except DictNotFoundError:
  257.                 pass
  258.  
  259.  
  260.  
  261.  
  262. class TestPWL(unittest.TestCase):
  263.     '''Test cases for the proper functioning of PWLs and DictWithPWL objects.
  264.     These tests assume that there is at least one working provider
  265.     with a dictionary for the "en_US" language.
  266.     '''
  267.     
  268.     def setUp(self):
  269.         self._tempDir = self._mkdtemp()
  270.         self._fileName = 'pwl.txt'
  271.  
  272.     
  273.     def tearDown(self):
  274.         import shutil as shutil
  275.         shutil.rmtree(self._tempDir)
  276.  
  277.     
  278.     def _mkdtemp(self):
  279.         import tempfile as tempfile
  280.         return tempfile.mkdtemp()
  281.  
  282.     
  283.     def _path(self, nm = None):
  284.         if nm is None:
  285.             nm = self._fileName
  286.         nm = os.path.join(self._tempDir, nm)
  287.         if not os.path.exists(nm):
  288.             open(nm, 'w').close()
  289.         return nm
  290.  
  291.     
  292.     def setPWLContents(self, contents):
  293.         '''Set the contents of the PWL file.'''
  294.         pwlFile = open(self._path(), 'w')
  295.         for ln in contents:
  296.             pwlFile.write(ln)
  297.             pwlFile.write('\n')
  298.         
  299.         pwlFile.flush()
  300.         pwlFile.close()
  301.  
  302.     
  303.     def getPWLContents(self):
  304.         '''Retrieve the contents of the PWL file.'''
  305.         pwlFile = open(self._path(), 'r')
  306.         contents = pwlFile.readlines()
  307.         pwlFile.close()
  308.         return [ c.strip() for c in contents ]
  309.  
  310.     
  311.     def test_check(self):
  312.         '''Test that basic checking works for PWLs.'''
  313.         self.setPWLContents([
  314.             'Sazz',
  315.             'Lozz'])
  316.         d = request_pwl_dict(self._path())
  317.         self.assertTrue(d.check('Sazz'))
  318.         self.assertTrue(d.check('Lozz'))
  319.         self.assertFalse(d.check('hello'))
  320.  
  321.     
  322.     def test_UnicodeFN(self):
  323.         '''Test that unicode PWL filenames are accepted.'''
  324.         d = request_pwl_dict(unicode(self._path()))
  325.         self.assertTrue(d)
  326.  
  327.     
  328.     def test_add(self):
  329.         '''Test that adding words to a PWL works correctly.'''
  330.         d = request_pwl_dict(self._path())
  331.         self.assertFalse(d.check('Flagen'))
  332.         d.add('Esquilax')
  333.         d.add('Esquilam')
  334.         self.assertTrue(d.check('Esquilax'))
  335.         self.assertTrue('Esquilax' in self.getPWLContents())
  336.         self.assertTrue(d.is_added('Esquilax'))
  337.  
  338.     
  339.     def test_suggestions(self):
  340.         '''Test getting suggestions from a PWL.'''
  341.         self.setPWLContents([
  342.             'Sazz',
  343.             'Lozz'])
  344.         d = request_pwl_dict(self._path())
  345.         self.assertTrue('Sazz' in d.suggest('Saz'))
  346.         self.assertTrue('Lozz' in d.suggest('laz'))
  347.         self.assertTrue('Sazz' in d.suggest('laz'))
  348.         d.add('Flagen')
  349.         self.assertTrue('Flagen' in d.suggest('Flags'))
  350.         self.assertFalse('sazz' in d.suggest('Flags'))
  351.  
  352.     
  353.     def test_DWPWL(self):
  354.         '''Test functionality of DictWithPWL.'''
  355.         self.setPWLContents([
  356.             'Sazz',
  357.             'Lozz'])
  358.         d = DictWithPWL('en_US', self._path(), self._path('pel.txt'))
  359.         self.assertTrue(d.check('Sazz'))
  360.         self.assertTrue(d.check('Lozz'))
  361.         self.assertTrue(d.check('hello'))
  362.         self.assertFalse(d.check('helo'))
  363.         self.assertFalse(d.check('Flagen'))
  364.         d.add('Flagen')
  365.         self.assertTrue(d.check('Flagen'))
  366.         self.assertTrue('Flagen' in self.getPWLContents())
  367.         self.assertTrue('Flagen' in d.suggest('Flagn'))
  368.         self.assertTrue('hello' in d.suggest('helo'))
  369.         d.remove('hello')
  370.         self.assertFalse(d.check('hello'))
  371.         self.assertTrue('hello' not in d.suggest('helo'))
  372.         d.remove('Lozz')
  373.         self.assertFalse(d.check('Lozz'))
  374.  
  375.     
  376.     def test_DWPWL_empty(self):
  377.         '''Test functionality of DictWithPWL using transient dicts.'''
  378.         d = DictWithPWL('en_US', None, None)
  379.         self.assertTrue(d.check('hello'))
  380.         self.assertFalse(d.check('helo'))
  381.         self.assertFalse(d.check('Flagen'))
  382.         d.add('Flagen')
  383.         self.assertTrue(d.check('Flagen'))
  384.         d.remove('hello')
  385.         self.assertFalse(d.check('hello'))
  386.         d.add('hello')
  387.         self.assertTrue(d.check('hello'))
  388.  
  389.     
  390.     def test_PyPWL(self):
  391.         '''Test our pure-python PWL implementation.'''
  392.         d = PyPWL()
  393.         self.assertTrue(list(d._words) == [])
  394.         d.add('hello')
  395.         d.add('there')
  396.         d.add('duck')
  397.         ws = list(d._words)
  398.         self.assertTrue(len(ws) == 3)
  399.         self.assertTrue('hello' in ws)
  400.         self.assertTrue('there' in ws)
  401.         self.assertTrue('duck' in ws)
  402.         d.remove('duck')
  403.         d.remove('notinthere')
  404.         ws = list(d._words)
  405.         self.assertTrue(len(ws) == 2)
  406.         self.assertTrue('hello' in ws)
  407.         self.assertTrue('there' in ws)
  408.  
  409.     
  410.     def test_UnicodeCharsInPath(self):
  411.         '''Test that unicode chars in PWL paths are accepted.'''
  412.         self._fileName = raw_unicode('test_\\xe5\\xe4\\xf6_ing')
  413.         d = request_pwl_dict(self._path())
  414.         self.assertTrue(d)
  415.  
  416.  
  417.  
  418. class TestDocStrings(unittest.TestCase):
  419.     """Test the spelling on all docstrings we can find in this module.
  420.  
  421.     This serves two purposes - to provide a lot of test data for the
  422.     checker routines, and to make sure we don't suffer the embarrassment
  423.     of having spelling errors in a spellchecking package!
  424.     """
  425.     WORDS = [
  426.         'spellchecking',
  427.         'utf',
  428.         'dict',
  429.         'unicode',
  430.         'bytestring',
  431.         'bytestrings',
  432.         'str',
  433.         'pyenchant',
  434.         'ascii',
  435.         'utils',
  436.         'setup',
  437.         'distutils',
  438.         'pkg',
  439.         'filename',
  440.         'tokenization',
  441.         'tuple',
  442.         'tuples',
  443.         'tokenizer',
  444.         'tokenizers',
  445.         'testcase',
  446.         'testcases',
  447.         'whitespace',
  448.         'wxpython',
  449.         'spellchecker',
  450.         'dialog',
  451.         'urls',
  452.         'wikiwords',
  453.         'enchantobject',
  454.         'providerdesc',
  455.         'spellcheck',
  456.         'pwl',
  457.         'aspell',
  458.         'myspell',
  459.         'docstring',
  460.         'docstrings',
  461.         'stopiteration',
  462.         'pwls',
  463.         'pypwl',
  464.         'dictwithpwl',
  465.         'skippable',
  466.         'dicts',
  467.         "dict's",
  468.         'filenames',
  469.         'trie',
  470.         'api',
  471.         'ctypes',
  472.         'wxspellcheckerdialog',
  473.         'stateful',
  474.         'cmdlinechecker',
  475.         'spellchecks',
  476.         'callback',
  477.         'clunkier',
  478.         'iterator',
  479.         'ispell',
  480.         'cor',
  481.         'backends']
  482.     
  483.     def test_docstrings(self):
  484.         '''Test that all our docstrings are error-free.'''
  485.         import enchant
  486.         import enchant.utils as enchant
  487.         import enchant.pypwl as enchant
  488.         import enchant.tokenize as enchant
  489.         import enchant.tokenize.en as enchant
  490.         import enchant.checker as enchant
  491.         import enchant.checker.CmdLineChecker as enchant
  492.         
  493.         try:
  494.             import enchant.checker.GtkSpellCheckerDialog as enchant
  495.         except ImportError:
  496.             pass
  497.  
  498.         
  499.         try:
  500.             import enchant.checker.wxSpellCheckerDialog as enchant
  501.         except ImportError:
  502.             pass
  503.  
  504.         errors = []
  505.         tocheck = [
  506.             enchant]
  507.         checked = []
  508.         for obj in newobjs:
  509.             if obj not in checked:
  510.                 continue
  511.                 []([][obj])
  512.             self.assertEqual(len(errors), 0)
  513.             return None
  514.  
  515.     
  516.     def _check_docstrings(self, obj, errors):
  517.         import enchant
  518.         if hasattr(obj, '__doc__'):
  519.             skip_errors = [ w for w in getattr(obj, '_DOC_ERRORS', []) ]
  520.             chkr = enchant.checker.SpellChecker('en_AU', obj.__doc__, filters = [
  521.                 enchant.tokenize.URLFilter])
  522.             for err in chkr:
  523.                 if len(err.word) == 1:
  524.                     continue
  525.                 if err.word.lower() in self.WORDS:
  526.                     continue
  527.                 if skip_errors and skip_errors[0] == err.word:
  528.                     skip_errors.pop(0)
  529.                     continue
  530.                 errors.append((obj, err.word, err.wordpos))
  531.                 msg = '\nDOCSTRING SPELLING ERROR: %s %s %d %s\n' % (obj, err.word, err.wordpos, chkr.suggest())
  532.                 printf([
  533.                     msg], file = sys.stderr)
  534.             
  535.         for name in dir(obj):
  536.             if name.startswith('__'):
  537.                 continue
  538.             child = getattr(obj, name)
  539.             if hasattr(child, '__file__'):
  540.                 if not hasattr(globals(), '__file__'):
  541.                     continue
  542.                 if not child.__file__.startswith(os.path.dirname(__file__)):
  543.                     continue
  544.                 
  545.             else:
  546.                 cmod = getattr(child, '__module__', None)
  547.                 if not cmod:
  548.                     cclass = getattr(child, '__class__', None)
  549.                     cmod = getattr(cclass, '__module__', None)
  550.                 if cmod and not cmod.startswith('enchant'):
  551.                     continue
  552.             yield child
  553.         
  554.  
  555.  
  556.  
  557. class TestInstallEnv(unittest.TestCase):
  558.     '''Run all testcases in a variety of install environments.'''
  559.     
  560.     def setUp(self):
  561.         self._tempDir = self._mkdtemp()
  562.         self._insDir = 'build'
  563.  
  564.     
  565.     def tearDown(self):
  566.         import shutil
  567.         shutil.rmtree(self._tempDir)
  568.  
  569.     
  570.     def _mkdtemp(self):
  571.         import tempfile
  572.         return tempfile.mkdtemp()
  573.  
  574.     
  575.     def install(self):
  576.         import os
  577.         import sys
  578.         import shutil
  579.         insdir = os.path.join(self._tempDir, self._insDir)
  580.         os.makedirs(insdir)
  581.         shutil.copytree('enchant', os.path.join(insdir, 'enchant'))
  582.  
  583.     
  584.     def runtests(self):
  585.         import os
  586.         import sys
  587.         insdir = os.path.join(self._tempDir, self._insDir)
  588.         if str is not unicode and isinstance(insdir, unicode):
  589.             insdir = insdir.encode(sys.getfilesystemencoding())
  590.         os.environ['PYTHONPATH'] = insdir
  591.         script = os.path.join(insdir, 'enchant', '__init__.py')
  592.         res = runcmd('"%s" %s' % (sys.executable, script))
  593.         self.assertEqual(res, 0)
  594.  
  595.     
  596.     def test_basic(self):
  597.         '''Test proper functioning of TestInstallEnv suite.'''
  598.         self.install()
  599.         self.runtests()
  600.  
  601.     test_basic._DOC_ERRORS = [
  602.         'TestInstallEnv']
  603.     
  604.     def test_UnicodeInstallPath(self):
  605.         '''Test installation in a path containing unicode chars.'''
  606.         self._insDir = raw_unicode('test_\\xe5\\xe4\\xf6_ing')
  607.         self.install()
  608.         self.runtests()
  609.  
  610.  
  611.  
  612. class TestPy2exe(unittest.TestCase):
  613.     '''Run all testcases inside a py2exe executable'''
  614.     _DOC_ERRORS = [
  615.         'py',
  616.         'exe']
  617.     
  618.     def setUp(self):
  619.         self._tempDir = self._mkdtemp()
  620.  
  621.     
  622.     def tearDown(self):
  623.         import shutil
  624.         shutil.rmtree(self._tempDir)
  625.  
  626.     
  627.     def test_py2exe(self):
  628.         '''Test pyenchant running inside a py2exe executable.'''
  629.         import os
  630.         import sys
  631.         import shutil
  632.         path = path
  633.         import os
  634.         dirname = dirname
  635.         import os.path
  636.         
  637.         try:
  638.             import py2exe as py2exe
  639.         except ImportError:
  640.             return None
  641.  
  642.         os.environ['PYTHONPATH'] = dirname(dirname(__file__))
  643.         setup_py = path.join(dirname(__file__), '..', 'tools', 'setup.py2exe.py')
  644.         if not path.exists(setup_py):
  645.             return None
  646.         buildCmd = None
  647.         buildCmd = buildCmd % (sys.executable, setup_py, self._tempDir)
  648.         res = runcmd(buildCmd)
  649.         self.assertEqual(res, 0)
  650.         testCmd = self._tempDir + '\\test_pyenchant.exe'
  651.         self.assertTrue(os.path.exists(testCmd))
  652.         res = runcmd(testCmd)
  653.         self.assertEqual(res, 0)
  654.  
  655.     test_py2exe._DOC_ERRORS = [
  656.         'py',
  657.         'exe']
  658.     
  659.     def _mkdtemp(self):
  660.         import tempfile
  661.         return tempfile.mkdtemp()
  662.  
  663.  
  664.  
  665. def buildtestsuite(recurse = True):
  666.     TestChecker = TestChecker
  667.     import enchant.checker.tests
  668.     TestTokenization = TestTokenization
  669.     TestFilters = TestFilters
  670.     import enchant.tokenize.tests
  671.     TestTokenizeEN = TestTokenizeEN
  672.     import enchant.tokenize.tests
  673.     suite = unittest.TestSuite()
  674.     if recurse:
  675.         suite.addTest(unittest.makeSuite(TestInstallEnv))
  676.         suite.addTest(unittest.makeSuite(TestPy2exe))
  677.     suite.addTest(unittest.makeSuite(TestBroker))
  678.     suite.addTest(unittest.makeSuite(TestDict))
  679.     suite.addTest(unittest.makeSuite(TestPWL))
  680.     suite.addTest(unittest.makeSuite(TestDocStrings))
  681.     suite.addTest(unittest.makeSuite(TestChecker))
  682.     suite.addTest(unittest.makeSuite(TestTokenization))
  683.     suite.addTest(unittest.makeSuite(TestTokenizeEN))
  684.     suite.addTest(unittest.makeSuite(TestFilters))
  685.     return suite
  686.  
  687.  
  688. def runtestsuite(recurse = False):
  689.     return unittest.TextTestRunner(verbosity = 0).run(buildtestsuite(recurse = recurse))
  690.  
  691.