1  import os 
  2  import os.path 
  3  import re 
  4  import gc 
  5  import sys 
  6  import unittest 
  7   
  8  try: 
  9      import urlparse 
 10  except ImportError: 
 11      import urllib.parse as urlparse  
 12   
 13  try: 
 14      from urllib import pathname2url 
 15  except: 
 16      from urllib.request import pathname2url 
 17   
 18  from lxml import etree, html 
 19   
 21      l = [] 
 22      for part in re.findall('([0-9]+|[^0-9.]+)', version_string): 
 23          try: 
 24              l.append(int(part)) 
 25          except ValueError: 
 26              l.append(part) 
 27      return tuple(l) 
  28   
 29  IS_PYPY = (getattr(sys, 'implementation', None) == 'pypy' or 
 30             getattr(sys, 'pypy_version_info', None) is not None) 
 31   
 32  IS_PYTHON3 = sys.version_info[0] >= 3 
 33   
 34  try: 
 35      from xml.etree import ElementTree  
 36  except ImportError: 
 37      try: 
 38          from elementtree import ElementTree  
 39      except ImportError: 
 40          ElementTree = None 
 41   
 42  if hasattr(ElementTree, 'VERSION'): 
 43      ET_VERSION = make_version_tuple(ElementTree.VERSION) 
 44  else: 
 45      ET_VERSION = (0,0,0) 
 46   
 47  try: 
 48      from xml.etree import cElementTree  
 49  except ImportError: 
 50      try: 
 51          import cElementTree  
 52      except ImportError: 
 53          cElementTree = None 
 54   
 55  if hasattr(cElementTree, 'VERSION'): 
 56      CET_VERSION = make_version_tuple(cElementTree.VERSION) 
 57  else: 
 58      CET_VERSION = (0,0,0) 
 59   
 61      """Remove test methods that do not work with the current lib version. 
 62      """ 
 63      find_required_version = version_dict.get 
 64      def dummy_test_method(self): 
 65          pass 
  66      for name in dir(test_class): 
 67          expected_version = find_required_version(name, (0,0,0)) 
 68          if expected_version > current_version: 
 69              setattr(test_class, name, dummy_test_method) 
 70   
 71  try: 
 72      import doctest 
 73       
 74      doctest.DocFileSuite 
 75      doctest.DocTestParser 
 76      doctest.NORMALIZE_WHITESPACE 
 77      doctest.ELLIPSIS 
 78  except (ImportError, AttributeError): 
 79       
 80      import local_doctest as doctest 
 81   
 82  try: 
 83      sorted 
 84  except NameError: 
 86          seq = list(seq) 
 87          seq.sort(**kwargs) 
 88          return seq 
  89  else: 
 90      locals()['sorted'] = sorted 
 91   
 92   
 93  try: 
 94      next 
 95  except NameError: 
 98  else: 
 99      locals()['next'] = next 
100   
101   
102  try: 
103      import pytest 
104  except ImportError: 
106          "Using a class because a function would bind into a method when used in classes" 
108 -        def __call__(self, func, *args): return func 
  109  else: 
110      skipif = pytest.mark.skipif 
111   
113      module = sys.modules[sys._getframe(frame_depth).f_globals['__name__']] 
114      return os.path.normpath(os.path.join( 
115              os.path.dirname(getattr(module, '__file__', '')), filename)) 
 116   
117  from io import StringIO 
118   
119  if sys.version_info[0] >= 3: 
120       
121      from builtins import str as unicode 
122      _chr = chr 
123 -    def _str(s, encoding="UTF-8"): 
 125 -    def _bytes(s, encoding="UTF-8"): 
 127      from io import BytesIO as _BytesIO 
129          if args and isinstance(args[0], str): 
130              args = (args[0].encode("UTF-8"),) 
131          return _BytesIO(*args) 
 132   
133      doctest_parser = doctest.DocTestParser() 
134      _fix_unicode = re.compile(r'(\s+)u(["\'])').sub 
135      _fix_exceptions = re.compile(r'(.*except [^(]*),\s*(.*:)').sub 
144  else: 
145       
146      unichr_escape = re.compile(r'\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}') 
147   
148      from __builtin__ import unicode 
149      _chr = unichr 
150 -    def _str(s, encoding="UTF-8"): 
 155 -    def _bytes(s, encoding="UTF-8"): 
 157      from io import BytesIO 
158   
159      doctest_parser = doctest.DocTestParser() 
160      _fix_traceback = re.compile(r'^(\s*)(?:\w+\.)+(\w*(?:Error|Exception|Invalid):)', re.M).sub 
161      _fix_exceptions = re.compile(r'(.*except [^(]*)\s+as\s+(.*:)').sub 
162      _fix_bytes = re.compile(r'(\s+)b(["\'])').sub 
172   
173  try: 
174      skipIf = unittest.skipIf 
175  except AttributeError: 
176 -    def skipIf(condition, why, 
177                 _skip=lambda test_method: None, 
178                 _keep=lambda test_method: test_method): 
 179          if condition: 
180              return _skip 
181          return _keep 
 182   
183   
187   
188 -    def parse(self, text, parser=None): 
 191       
195   
196       
197      try: 
198          unittest.TestCase.assertFalse 
199      except AttributeError: 
200          assertFalse = unittest.TestCase.failIf 
 201   
202   
205          self.xml_data = xml_data 
 206           
207 -    def read(self, amount=None): 
 208          if self.xml_data: 
209              if amount: 
210                  data = self.xml_data[:amount] 
211                  self.xml_data = self.xml_data[amount:] 
212              else: 
213                  data = self.xml_data 
214                  self.xml_data = _bytes('') 
215              return data 
216          return _bytes('') 
 219 -    def __init__(self, charlen=100, depth=4, children=5): 
 220          self.data = BytesIO() 
221          self.chars  = _bytes('a') * charlen 
222          self.children = range(children) 
223          self.more = self.iterelements(depth) 
 224   
226          yield _bytes('<root>') 
227          depth -= 1 
228          if depth > 0: 
229              for child in self.children: 
230                  for element in self.iterelements(depth): 
231                      yield element 
232                  yield self.chars 
233          else: 
234              yield self.chars 
235          yield _bytes('</root>') 
 236   
237 -    def read(self, amount=None): 
 257 -    def __init__(self, charlen=100, depth=4, children=5): 
 262   
264          yield _str('<root>') 
265          depth -= 1 
266          if depth > 0: 
267              for child in self.children: 
268                  for element in self.iterelements(depth): 
269                      yield element 
270                  yield self.chars 
271          else: 
272              yield self.chars 
273          yield _str('</root>') 
 276      _testdir = os.path.dirname(__file__) 
277      return os.path.join(_testdir, name) 
 278   
280      return urlparse.urljoin( 
281          'file:', pathname2url(path)) 
 282   
285   
293   
300   
303   
305      tree = etree.parse(BytesIO(xml) if isinstance(xml, bytes) else StringIO(xml)) 
306      f = BytesIO() 
307      tree.write_c14n(f) 
308      return f.getvalue() 
 309   
314