lxml.tests.common

1 import unittest 2 import os.path 3 import re, gc, sys 4 5 from lxml import etree 6

7 -def make_version_tuple(version_string):

8 l = [] 9 for part in re.findall('([0-9]+|[^0-9.]+)', version_string): 10 try: 11 l.append(int(part)) 12 except ValueError: 13 l.append(part) 14 return tuple(l)

15 16 IS_PYPY = (getattr(sys, 'implementation', None) == 'pypy' or 17 getattr(sys, 'pypy_version_info', None) is not None) 18 19 IS_PYTHON3 = sys.version_info[0] >= 3 20 21 try: 22 from xml.etree import ElementTree # Python 2.5+ 23 except ImportError: 24 try: 25 from elementtree import ElementTree # standard ET 26 except ImportError: 27 ElementTree = None 28 29 if hasattr(ElementTree, 'VERSION'): 30 ET_VERSION = make_version_tuple(ElementTree.VERSION) 31 else: 32 ET_VERSION = (0,0,0) 33 34 try: 35 from xml.etree import cElementTree # Python 2.5+ 36 except ImportError: 37 try: 38 import cElementTree # standard ET 39 except ImportError: 40 cElementTree = None 41 42 if hasattr(cElementTree, 'VERSION'): 43 CET_VERSION = make_version_tuple(cElementTree.VERSION) 44 else: 45 CET_VERSION = (0,0,0) 46

47 -def filter_by_version(test_class, version_dict, current_version):

48 """Remove test methods that do not work with the current lib version. 49 """ 50 find_required_version = version_dict.get 51 def dummy_test_method(self): 52 pass

53 for name in dir(test_class): 54 expected_version = find_required_version(name, (0,0,0)) 55 if expected_version > current_version: 56 setattr(test_class, name, dummy_test_method) 57 58 try: 59 import doctest 60 # check if the system version has everything we need 61 doctest.DocFileSuite 62 doctest.DocTestParser 63 doctest.NORMALIZE_WHITESPACE 64 doctest.ELLIPSIS 65 except (ImportError, AttributeError): 66 # we need our own version to make it work (Python 2.3?) 67 import local_doctest as doctest 68 69 try: 70 sorted 71 except NameError:

72 - def sorted(seq, **kwargs):

73 seq = list(seq) 74 seq.sort(**kwargs) 75 return seq

76 else: 77 locals()['sorted'] = sorted 78 79 try: 80 import pytest 81 except ImportError:

82 - class skipif(object):

83 "Using a class because a function would bind into a method when used in classes"

84 - def __init__(self, *args): pass

85 - def __call__(self, func, *args): return func

86 else: 87 skipif = pytest.mark.skipif 88

89 -def _get_caller_relative_path(filename, frame_depth=2):

90 module = sys.modules[sys._getframe(frame_depth).f_globals['__name__']] 91 return os.path.normpath(os.path.join( 92 os.path.dirname(getattr(module, '__file__', '')), filename))

93 94 if sys.version_info[0] >= 3: 95 # Python 3 96 from builtins import str as unicode

97 - def _str(s, encoding="UTF-8"):

98 return s

99 - def _bytes(s, encoding="UTF-8"):

100 return s.encode(encoding)

101 from io import StringIO, BytesIO as _BytesIO

102 - def BytesIO(*args):

103 if args and isinstance(args[0], str): 104 args = (args[0].encode("UTF-8"),) 105 return _BytesIO(*args)

106 107 doctest_parser = doctest.DocTestParser() 108 _fix_unicode = re.compile(r'(\s+)u(["\'])').sub 109 _fix_exceptions = re.compile(r'(.*except [^(]*),\s*(.*:)').sub

110 - def make_doctest(filename):

111 filename = _get_caller_relative_path(filename) 112 doctests = read_file(filename) 113 doctests = _fix_unicode(r'\1\2', doctests) 114 doctests = _fix_exceptions(r'\1 as \2', doctests) 115 return doctest.DocTestCase( 116 doctest_parser.get_doctest( 117 doctests, {}, os.path.basename(filename), filename, 0))

118 else: 119 # Python 2 120 from __builtin__ import unicode

121 - def _str(s, encoding="UTF-8"):

122 return unicode(s, encoding=encoding)

123 - def _bytes(s, encoding="UTF-8"):

124 return s

125 from StringIO import StringIO 126 BytesIO = StringIO 127 128 doctest_parser = doctest.DocTestParser() 129 _fix_traceback = re.compile(r'^(\s*)(?:\w+\.)+(\w*(?:Error|Exception|Invalid):)', re.M).sub 130 _fix_exceptions = re.compile(r'(.*except [^(]*)\s+as\s+(.*:)').sub 131 _fix_bytes = re.compile(r'(\s+)b(["\'])').sub

132 - def make_doctest(filename):

133 filename = _get_caller_relative_path(filename) 134 doctests = read_file(filename) 135 doctests = _fix_traceback(r'\1\2', doctests) 136 doctests = _fix_exceptions(r'\1, \2', doctests) 137 doctests = _fix_bytes(r'\1\2', doctests) 138 return doctest.DocTestCase( 139 doctest_parser.get_doctest( 140 doctests, {}, os.path.basename(filename), filename, 0))

141 142 try: 143 skipIf = unittest.skipIf 144 except AttributeError:

145 - def skipIf(condition, why, 146 _skip=lambda test_method: None, 147 _keep=lambda test_method: test_method):

148 if condition: 149 return _skip 150 return _keep

151

152 -class HelperTestCase(unittest.TestCase):

153 - def tearDown(self):

154 gc.collect()

155

156 - def parse(self, text, parser=None):

157 f = BytesIO(text) 158 return etree.parse(f, parser=parser)

159

160 - def _rootstring(self, tree):

161 return etree.tostring(tree.getroot()).replace( 162 _bytes(' '), _bytes('')).replace(_bytes('\n'), _bytes(''))

163 164 # assertFalse doesn't exist in Python 2.3 165 try: 166 unittest.TestCase.assertFalse 167 except AttributeError: 168 assertFalse = unittest.TestCase.failIf

169

170 -class SillyFileLike:

171 - def __init__(self, xml_data=_bytes('<foo><bar/></foo>')):

172 self.xml_data = xml_data

173

174 - def read(self, amount=None):

175 if self.xml_data: 176 if amount: 177 data = self.xml_data[:amount] 178 self.xml_data = self.xml_data[amount:] 179 else: 180 data = self.xml_data 181 self.xml_data = _bytes('') 182 return data 183 return _bytes('')

184

185 -class LargeFileLike:

186 - def __init__(self, charlen=100, depth=4, children=5):

187 self.data = BytesIO() 188 self.chars = _bytes('a') * charlen 189 self.children = range(children) 190 self.more = self.iterelements(depth)

191

192 - def iterelements(self, depth):

193 yield _bytes('<root>') 194 depth -= 1 195 if depth > 0: 196 for child in self.children: 197 for element in self.iterelements(depth): 198 yield element 199 yield self.chars 200 else: 201 yield self.chars 202 yield _bytes('</root>')

203

204 - def read(self, amount=None):

205 data = self.data 206 append = data.write 207 if amount: 208 for element in self.more: 209 append(element) 210 if data.tell() >= amount: 211 break 212 else: 213 for element in self.more: 214 append(element) 215 result = data.getvalue() 216 data.seek(0) 217 data.truncate() 218 if amount: 219 append(result[amount:]) 220 result = result[:amount] 221 return result

222

223 -class LargeFileLikeUnicode(LargeFileLike):

224 - def __init__(self, charlen=100, depth=4, children=5):

225 LargeFileLike.__init__(self, charlen, depth, children) 226 self.data = StringIO() 227 self.chars = _str('a') * charlen 228 self.more = self.iterelements(depth)

229

230 - def iterelements(self, depth):

231 yield _str('<root>') 232 depth -= 1 233 if depth > 0: 234 for child in self.children: 235 for element in self.iterelements(depth): 236 yield element 237 yield self.chars 238 else: 239 yield self.chars 240 yield _str('</root>')

241

242 -def fileInTestDir(name):

243 _testdir = os.path.dirname(__file__) 244 return os.path.join(_testdir, name)

245

246 -def read_file(name, mode='r'):

247 f = open(name, mode) 248 try: 249 data = f.read() 250 finally: 251 f.close() 252 return data

253

254 -def write_to_file(name, data, mode='w'):

255 f = open(name, mode) 256 try: 257 data = f.write(data) 258 finally: 259 f.close()

260

261 -def readFileInTestDir(name, mode='r'):

262 return read_file(fileInTestDir(name), mode)

263

264 -def canonicalize(xml):

265 tree = etree.parse(BytesIO(xml)) 266 f = BytesIO() 267 tree.write_c14n(f) 268 return f.getvalue()

269

270 -def unentitify(xml):

271 for entity_name, value in re.findall("(&#([0-9]+);)", xml): 272 xml = xml.replace(entity_name, unichr(int(value))) 273 return xml

274

Source Code for Module lxml.tests.common_imports