Debian Codegraph @

Lib/test/test_csv.py

raw
1 # Copyright (C) 2001 Python Software Foundation
2 # csv package unit tests
3
4 import copy
5 import sys
6 import unittest
7 from io import StringIO
8 from tempfile import TemporaryFile
9 import csv
10 import gc
11 import pickle
12 from test import support
13 from test.support import cpython_only, import_helper, check_disallow_instantiation
14 from test.support.import_helper import ensure_lazy_imports
15 from itertools import permutations
16 from textwrap import dedent
17 from collections import OrderedDict
18
19
20 class BadIterable:
21 def __iter__(self):
22 raise OSError
23
24
25 class Test_Csv(unittest.TestCase):
26 """
27 Test the underlying C csv parser in ways that are not appropriate
28 from the high level interface. Further tests of this nature are done
29 in TestDialectRegistry.
30 """
31 def _test_arg_valid(self, ctor, arg):
32 ctor(arg)
33 self.assertRaises(TypeError, ctor)
34 self.assertRaises(TypeError, ctor, None)
35 self.assertRaises(TypeError, ctor, arg, bad_attr=0)
36 self.assertRaises(TypeError, ctor, arg, delimiter='')
37 self.assertRaises(TypeError, ctor, arg, escapechar='')
38 self.assertRaises(TypeError, ctor, arg, quotechar='')
39 self.assertRaises(TypeError, ctor, arg, delimiter='^^')
40 self.assertRaises(TypeError, ctor, arg, escapechar='^^')
41 self.assertRaises(TypeError, ctor, arg, quotechar='^^')
42 self.assertRaises(csv.Error, ctor, arg, 'foo')
43 self.assertRaises(TypeError, ctor, arg, delimiter=None)
44 self.assertRaises(TypeError, ctor, arg, delimiter=1)
45 self.assertRaises(TypeError, ctor, arg, escapechar=1)
46 self.assertRaises(TypeError, ctor, arg, quotechar=1)
47 self.assertRaises(TypeError, ctor, arg, lineterminator=None)
48 self.assertRaises(TypeError, ctor, arg, lineterminator=1)
49 self.assertRaises(TypeError, ctor, arg, quoting=None)
50 self.assertRaises(TypeError, ctor, arg,
51 quoting=csv.QUOTE_ALL, quotechar='')
52 self.assertRaises(TypeError, ctor, arg,
53 quoting=csv.QUOTE_ALL, quotechar=None)
54 self.assertRaises(TypeError, ctor, arg,
55 quoting=csv.QUOTE_NONE, quotechar='')
56 self.assertRaises(ValueError, ctor, arg, delimiter='\n')
57 self.assertRaises(ValueError, ctor, arg, escapechar='\n')
58 self.assertRaises(ValueError, ctor, arg, quotechar='\n')
59 self.assertRaises(ValueError, ctor, arg, delimiter='\r')
60 self.assertRaises(ValueError, ctor, arg, escapechar='\r')
61 self.assertRaises(ValueError, ctor, arg, quotechar='\r')
62 ctor(arg, delimiter=' ')
63 ctor(arg, escapechar=' ')
64 ctor(arg, quotechar=' ')
65 ctor(arg, delimiter='\t', skipinitialspace=True)
66 ctor(arg, escapechar='\t', skipinitialspace=True)
67 ctor(arg, quotechar='\t', skipinitialspace=True)
68 ctor(arg, delimiter=' ', skipinitialspace=True)
69 self.assertRaises(ValueError, ctor, arg,
70 escapechar=' ', skipinitialspace=True)
71 self.assertRaises(ValueError, ctor, arg,
72 quotechar=' ', skipinitialspace=True)
73 ctor(arg, delimiter='^')
74 ctor(arg, escapechar='^')
75 ctor(arg, quotechar='^')
76 self.assertRaises(ValueError, ctor, arg, delimiter='^', escapechar='^')
77 self.assertRaises(ValueError, ctor, arg, delimiter='^', quotechar='^')
78 self.assertRaises(ValueError, ctor, arg, escapechar='^', quotechar='^')
79 ctor(arg, delimiter='\x85')
80 ctor(arg, escapechar='\x85')
81 ctor(arg, quotechar='\x85')
82 ctor(arg, lineterminator='\x85')
83 self.assertRaises(ValueError, ctor, arg,
84 delimiter='\x85', lineterminator='\x85')
85 self.assertRaises(ValueError, ctor, arg,
86 escapechar='\x85', lineterminator='\x85')
87 self.assertRaises(ValueError, ctor, arg,
88 quotechar='\x85', lineterminator='\x85')
89
90 def test_reader_arg_valid(self):
91 self._test_arg_valid(csv.reader, [])
92 self.assertRaises(OSError, csv.reader, BadIterable())
93
94 def test_writer_arg_valid(self):
95 self._test_arg_valid(csv.writer, StringIO())
96 class BadWriter:
97 @property
98 def write(self):
99 raise OSError
100 self.assertRaises(OSError, csv.writer, BadWriter())
101
102 def _test_default_attrs(self, ctor, *args):
103 obj = ctor(*args)
104 # Check defaults
105 self.assertEqual(obj.dialect.delimiter, ',')
106 self.assertIs(obj.dialect.doublequote, True)
107 self.assertEqual(obj.dialect.escapechar, None)
108 self.assertEqual(obj.dialect.lineterminator, "\r\n")
109 self.assertEqual(obj.dialect.quotechar, '"')
110 self.assertEqual(obj.dialect.quoting, csv.QUOTE_MINIMAL)
111 self.assertIs(obj.dialect.skipinitialspace, False)
112 self.assertIs(obj.dialect.strict, False)
113 # Try deleting or changing attributes (they are read-only)
114 self.assertRaises(AttributeError, delattr, obj.dialect, 'delimiter')
115 self.assertRaises(AttributeError, setattr, obj.dialect, 'delimiter', ':')
116 self.assertRaises(AttributeError, delattr, obj.dialect, 'quoting')
117 self.assertRaises(AttributeError, setattr, obj.dialect,
118 'quoting', None)
119
120 def test_reader_attrs(self):
121 self._test_default_attrs(csv.reader, [])
122
123 def test_writer_attrs(self):
124 self._test_default_attrs(csv.writer, StringIO())
125
126 def _test_kw_attrs(self, ctor, *args):
127 # Now try with alternate options
128 kwargs = dict(delimiter=':', doublequote=False, escapechar='\\',
129 lineterminator='\r', quotechar='*',
130 quoting=csv.QUOTE_NONE, skipinitialspace=True,
131 strict=True)
132 obj = ctor(*args, **kwargs)
133 self.assertEqual(obj.dialect.delimiter, ':')
134 self.assertIs(obj.dialect.doublequote, False)
135 self.assertEqual(obj.dialect.escapechar, '\\')
136 self.assertEqual(obj.dialect.lineterminator, "\r")
137 self.assertEqual(obj.dialect.quotechar, '*')
138 self.assertEqual(obj.dialect.quoting, csv.QUOTE_NONE)
139 self.assertIs(obj.dialect.skipinitialspace, True)
140 self.assertIs(obj.dialect.strict, True)
141
142 def test_reader_kw_attrs(self):
143 self._test_kw_attrs(csv.reader, [])
144
145 def test_writer_kw_attrs(self):
146 self._test_kw_attrs(csv.writer, StringIO())
147
148 def _test_dialect_attrs(self, ctor, *args):
149 # Now try with dialect-derived options
150 class dialect:
151 delimiter='-'
152 doublequote=False
153 escapechar='^'
154 lineterminator='$'
155 quotechar='#'
156 quoting=csv.QUOTE_ALL
157 skipinitialspace=True
158 strict=False
159 args = args + (dialect,)
160 obj = ctor(*args)
161 self.assertEqual(obj.dialect.delimiter, '-')
162 self.assertIs(obj.dialect.doublequote, False)
163 self.assertEqual(obj.dialect.escapechar, '^')
164 self.assertEqual(obj.dialect.lineterminator, "$")
165 self.assertEqual(obj.dialect.quotechar, '#')
166 self.assertEqual(obj.dialect.quoting, csv.QUOTE_ALL)
167 self.assertIs(obj.dialect.skipinitialspace, True)
168 self.assertIs(obj.dialect.strict, False)
169
170 def test_reader_dialect_attrs(self):
171 self._test_dialect_attrs(csv.reader, [])
172
173 def test_writer_dialect_attrs(self):
174 self._test_dialect_attrs(csv.writer, StringIO())
175
176
177 def _write_test(self, fields, expect, **kwargs):
178 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
179 writer = csv.writer(fileobj, **kwargs)
180 writer.writerow(fields)
181 fileobj.seek(0)
182 self.assertEqual(fileobj.read(),
183 expect + writer.dialect.lineterminator)
184
185 def _write_error_test(self, exc, fields, **kwargs):
186 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
187 writer = csv.writer(fileobj, **kwargs)
188 with self.assertRaises(exc):
189 writer.writerow(fields)
190 fileobj.seek(0)
191 self.assertEqual(fileobj.read(), '')
192
193 def test_write_arg_valid(self):
194 self._write_error_test(csv.Error, None)
195 # Check that exceptions are passed up the chain
196 self._write_error_test(OSError, BadIterable())
197 class BadList:
198 def __len__(self):
199 return 10
200 def __getitem__(self, i):
201 if i > 2:
202 raise OSError
203 self._write_error_test(OSError, BadList())
204 class BadItem:
205 def __str__(self):
206 raise OSError
207 self._write_error_test(OSError, [BadItem()])
208 def test_write_bigfield(self):
209 # This exercises the buffer realloc functionality
210 bigstring = 'X' * 50000
211 self._write_test([bigstring,bigstring], '%s,%s' % \
212 (bigstring, bigstring))
213
214 def test_write_quoting(self):
215 self._write_test(['a',1,'p,q'], 'a,1,"p,q"')
216 self._write_error_test(csv.Error, ['a',1,'p,q'],
217 quoting = csv.QUOTE_NONE)
218 self._write_test(['a',1,'p,q'], 'a,1,"p,q"',
219 quoting = csv.QUOTE_MINIMAL)
220 self._write_test(['a',1,'p,q'], '"a",1,"p,q"',
221 quoting = csv.QUOTE_NONNUMERIC)
222 self._write_test(['a',1,'p,q'], '"a","1","p,q"',
223 quoting = csv.QUOTE_ALL)
224 self._write_test(['a\nb',1], '"a\nb","1"',
225 quoting = csv.QUOTE_ALL)
226 self._write_test(['a','',None,1], '"a","",,1',
227 quoting = csv.QUOTE_STRINGS)
228 self._write_test(['a','',None,1], '"a","",,"1"',
229 quoting = csv.QUOTE_NOTNULL)
230
231 def test_write_escape(self):
232 self._write_test(['a',1,'p,q'], 'a,1,"p,q"',
233 escapechar='\\')
234 self._write_error_test(csv.Error, ['a',1,'p,"q"'],
235 escapechar=None, doublequote=False)
236 self._write_test(['a',1,'p,"q"'], 'a,1,"p,\\"q\\""',
237 escapechar='\\', doublequote = False)
238 self._write_test(['"'], '""""',
239 escapechar='\\', quoting = csv.QUOTE_MINIMAL)
240 self._write_test(['"'], '\\"',
241 escapechar='\\', quoting = csv.QUOTE_MINIMAL,
242 doublequote = False)
243 self._write_test(['"'], '\\"',
244 escapechar='\\', quoting = csv.QUOTE_NONE)
245 self._write_test(['a',1,'p,q'], 'a,1,p\\,q',
246 escapechar='\\', quoting = csv.QUOTE_NONE)
247 self._write_test(['\\', 'a'], '\\\\,a',
248 escapechar='\\', quoting=csv.QUOTE_NONE)
249 self._write_test(['\\', 'a'], '\\\\,a',
250 escapechar='\\', quoting=csv.QUOTE_MINIMAL)
251 self._write_test(['\\', 'a'], '"\\\\","a"',
252 escapechar='\\', quoting=csv.QUOTE_ALL)
253 self._write_test(['\\ ', 'a'], '\\\\ ,a',
254 escapechar='\\', quoting=csv.QUOTE_MINIMAL)
255 self._write_test(['\\,', 'a'], '\\\\\\,,a',
256 escapechar='\\', quoting=csv.QUOTE_NONE)
257 self._write_test([',\\', 'a'], '",\\\\",a',
258 escapechar='\\', quoting=csv.QUOTE_MINIMAL)
259 self._write_test(['C\\', '6', '7', 'X"'], 'C\\\\,6,7,"X"""',
260 escapechar='\\', quoting=csv.QUOTE_MINIMAL)
261
262 def test_write_lineterminator(self):
263 for lineterminator in '\r\n', '\n', '\r', '!@#', '\0':
264 with self.subTest(lineterminator=lineterminator):
265 with StringIO() as sio:
266 writer = csv.writer(sio, lineterminator=lineterminator)
267 writer.writerow(['a', 'b'])
268 writer.writerow([1, 2])
269 writer.writerow(['\r', '\n'])
270 self.assertEqual(sio.getvalue(),
271 f'a,b{lineterminator}'
272 f'1,2{lineterminator}'
273 f'"\r","\n"{lineterminator}')
274
275 def test_write_iterable(self):
276 self._write_test(iter(['a', 1, 'p,q']), 'a,1,"p,q"')
277 self._write_test(iter(['a', 1, None]), 'a,1,')
278 self._write_test(iter([]), '')
279 self._write_test(iter([None]), '""')
280 self._write_error_test(csv.Error, iter([None]), quoting=csv.QUOTE_NONE)
281 self._write_test(iter([None, None]), ',')
282
283 def test_writerows(self):
284 class BrokenFile:
285 def write(self, buf):
286 raise OSError
287 writer = csv.writer(BrokenFile())
288 self.assertRaises(OSError, writer.writerows, [['a']])
289
290 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
291 writer = csv.writer(fileobj)
292 self.assertRaises(TypeError, writer.writerows, None)
293 writer.writerows([['a', 'b'], ['c', 'd']])
294 fileobj.seek(0)
295 self.assertEqual(fileobj.read(), "a,b\r\nc,d\r\n")
296
297 def test_writerows_with_none(self):
298 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
299 writer = csv.writer(fileobj)
300 writer.writerows([['a', None], [None, 'd']])
301 fileobj.seek(0)
302 self.assertEqual(fileobj.read(), "a,\r\n,d\r\n")
303
304 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
305 writer = csv.writer(fileobj)
306 writer.writerows([[None], ['a']])
307 fileobj.seek(0)
308 self.assertEqual(fileobj.read(), '""\r\na\r\n')
309
310 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
311 writer = csv.writer(fileobj)
312 writer.writerows([['a'], [None]])
313 fileobj.seek(0)
314 self.assertEqual(fileobj.read(), 'a\r\n""\r\n')
315
316
317 def test_write_empty_fields(self):
318 self._write_test((), '')
319 self._write_test([''], '""')
320 self._write_error_test(csv.Error, [''], quoting=csv.QUOTE_NONE)
321 self._write_test([''], '""', quoting=csv.QUOTE_STRINGS)
322 self._write_test([''], '""', quoting=csv.QUOTE_NOTNULL)
323 self._write_test([None], '""')
324 self._write_error_test(csv.Error, [None], quoting=csv.QUOTE_NONE)
325 self._write_error_test(csv.Error, [None], quoting=csv.QUOTE_STRINGS)
326 self._write_error_test(csv.Error, [None], quoting=csv.QUOTE_NOTNULL)
327 self._write_test(['', ''], ',')
328 self._write_test([None, None], ',')
329
330 def test_write_empty_fields_space_delimiter(self):
331 self._write_test([''], '""', delimiter=' ', skipinitialspace=False)
332 self._write_test([''], '""', delimiter=' ', skipinitialspace=True)
333 self._write_test([None], '""', delimiter=' ', skipinitialspace=False)
334 self._write_test([None], '""', delimiter=' ', skipinitialspace=True)
335
336 self._write_test(['', ''], ' ', delimiter=' ', skipinitialspace=False)
337 self._write_test(['', ''], '"" ""', delimiter=' ', skipinitialspace=True)
338 self._write_test([None, None], ' ', delimiter=' ', skipinitialspace=False)
339 self._write_test([None, None], '"" ""', delimiter=' ', skipinitialspace=True)
340
341 self._write_test(['', ''], ' ', delimiter=' ', skipinitialspace=False,
342 quoting=csv.QUOTE_NONE)
343 self._write_error_test(csv.Error, ['', ''],
344 delimiter=' ', skipinitialspace=True,
345 quoting=csv.QUOTE_NONE)
346 for quoting in csv.QUOTE_STRINGS, csv.QUOTE_NOTNULL:
347 self._write_test(['', ''], '"" ""', delimiter=' ', skipinitialspace=False,
348 quoting=quoting)
349 self._write_test(['', ''], '"" ""', delimiter=' ', skipinitialspace=True,
350 quoting=quoting)
351
352 for quoting in csv.QUOTE_NONE, csv.QUOTE_STRINGS, csv.QUOTE_NOTNULL:
353 self._write_test([None, None], ' ', delimiter=' ', skipinitialspace=False,
354 quoting=quoting)
355 self._write_error_test(csv.Error, [None, None],
356 delimiter=' ', skipinitialspace=True,
357 quoting=quoting)
358
359 def test_writerows_errors(self):
360 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
361 writer = csv.writer(fileobj)
362 self.assertRaises(TypeError, writer.writerows, None)
363 self.assertRaises(OSError, writer.writerows, BadIterable())
364
365 def _read_test(self, input, expect, **kwargs):
366 reader = csv.reader(input, **kwargs)
367 result = list(reader)
368 self.assertEqual(result, expect)
369
370 def test_read_oddinputs(self):
371 self._read_test([], [])
372 self._read_test([''], [[]])
373 self.assertRaises(csv.Error, self._read_test,
374 ['"ab"c'], None, strict = 1)
375 self._read_test(['"ab"c'], [['abc']], doublequote = 0)
376
377 self.assertRaises(csv.Error, self._read_test,
378 [b'abc'], None)
379
380 def test_read_eol(self):
381 self._read_test(['a,b', 'c,d'], [['a','b'], ['c','d']])
382 self._read_test(['a,b\n', 'c,d\n'], [['a','b'], ['c','d']])
383 self._read_test(['a,b\r\n', 'c,d\r\n'], [['a','b'], ['c','d']])
384 self._read_test(['a,b\r', 'c,d\r'], [['a','b'], ['c','d']])
385
386 errmsg = "with newline=''"
387 with self.assertRaisesRegex(csv.Error, errmsg):
388 next(csv.reader(['a,b\rc,d']))
389 with self.assertRaisesRegex(csv.Error, errmsg):
390 next(csv.reader(['a,b\nc,d']))
391 with self.assertRaisesRegex(csv.Error, errmsg):
392 next(csv.reader(['a,b\r\nc,d']))
393
394 def test_read_eof(self):
395 self._read_test(['a,"'], [['a', '']])
396 self._read_test(['"a'], [['a']])
397 self._read_test(['^'], [['\n']], escapechar='^')
398 self.assertRaises(csv.Error, self._read_test, ['a,"'], [], strict=True)
399 self.assertRaises(csv.Error, self._read_test, ['"a'], [], strict=True)
400 self.assertRaises(csv.Error, self._read_test,
401 ['^'], [], escapechar='^', strict=True)
402
403 def test_read_nul(self):
404 self._read_test(['\0'], [['\0']])
405 self._read_test(['a,\0b,c'], [['a', '\0b', 'c']])
406 self._read_test(['a,b\0,c'], [['a', 'b\0', 'c']])
407 self._read_test(['a,b\\\0,c'], [['a', 'b\0', 'c']], escapechar='\\')
408 self._read_test(['a,"\0b",c'], [['a', '\0b', 'c']])
409
410 def test_read_delimiter(self):
411 self._read_test(['a,b,c'], [['a', 'b', 'c']])
412 self._read_test(['a;b;c'], [['a', 'b', 'c']], delimiter=';')
413 self._read_test(['a\0b\0c'], [['a', 'b', 'c']], delimiter='\0')
414
415 def test_read_escape(self):
416 self._read_test(['a,\\b,c'], [['a', 'b', 'c']], escapechar='\\')
417 self._read_test(['a,b\\,c'], [['a', 'b,c']], escapechar='\\')
418 self._read_test(['a,"b\\,c"'], [['a', 'b,c']], escapechar='\\')
419 self._read_test(['a,"b,\\c"'], [['a', 'b,c']], escapechar='\\')
420 self._read_test(['a,"b,c\\""'], [['a', 'b,c"']], escapechar='\\')
421 self._read_test(['a,"b,c"\\'], [['a', 'b,c\\']], escapechar='\\')
422 self._read_test(['a,^b,c'], [['a', 'b', 'c']], escapechar='^')
423 self._read_test(['a,\0b,c'], [['a', 'b', 'c']], escapechar='\0')
424 self._read_test(['a,\\b,c'], [['a', '\\b', 'c']], escapechar=None)
425 self._read_test(['a,\\b,c'], [['a', '\\b', 'c']])
426
427 def test_read_quoting(self):
428 self._read_test(['1,",3,",5'], [['1', ',3,', '5']])
429 self._read_test(['1,",3,",5'], [['1', '"', '3', '"', '5']],
430 quotechar=None, escapechar='\\')
431 self._read_test(['1,",3,",5'], [['1', '"', '3', '"', '5']],
432 quoting=csv.QUOTE_NONE, escapechar='\\')
433 # will this fail where locale uses comma for decimals?
434 self._read_test([',3,"5",7.3, 9'], [['', 3, '5', 7.3, 9]],
435 quoting=csv.QUOTE_NONNUMERIC)
436 self._read_test([',3,"5",7.3, 9'], [[None, '3', '5', '7.3', ' 9']],
437 quoting=csv.QUOTE_NOTNULL)
438 self._read_test([',3,"5",7.3, 9'], [[None, 3, '5', 7.3, 9]],
439 quoting=csv.QUOTE_STRINGS)
440
441 self._read_test([',,"",'], [['', '', '', '']])
442 self._read_test([',,"",'], [['', '', '', '']],
443 quoting=csv.QUOTE_NONNUMERIC)
444 self._read_test([',,"",'], [[None, None, '', None]],
445 quoting=csv.QUOTE_NOTNULL)
446 self._read_test([',,"",'], [[None, None, '', None]],
447 quoting=csv.QUOTE_STRINGS)
448
449 self._read_test(['"a\nb", 7'], [['a\nb', ' 7']])
450 self.assertRaises(ValueError, self._read_test,
451 ['abc,3'], [[]],
452 quoting=csv.QUOTE_NONNUMERIC)
453 self.assertRaises(ValueError, self._read_test,
454 ['abc,3'], [[]],
455 quoting=csv.QUOTE_STRINGS)
456 self._read_test(['1,@,3,@,5'], [['1', ',3,', '5']], quotechar='@')
457 self._read_test(['1,\0,3,\0,5'], [['1', ',3,', '5']], quotechar='\0')
458 self._read_test(['1\\.5,\\.5,.5'], [[1.5, 0.5, 0.5]],
459 quoting=csv.QUOTE_NONNUMERIC, escapechar='\\')
460 self._read_test(['1\\.5,\\.5,"\\.5"'], [[1.5, 0.5, ".5"]],
461 quoting=csv.QUOTE_STRINGS, escapechar='\\')
462
463 def test_read_skipinitialspace(self):
464 self._read_test(['no space, space, spaces,\ttab'],
465 [['no space', 'space', 'spaces', '\ttab']],
466 skipinitialspace=True)
467 self._read_test([' , , '],
468 [['', '', '']],
469 skipinitialspace=True)
470 self._read_test([' , , '],
471 [[None, None, None]],
472 skipinitialspace=True, quoting=csv.QUOTE_NOTNULL)
473 self._read_test([' , , '],
474 [[None, None, None]],
475 skipinitialspace=True, quoting=csv.QUOTE_STRINGS)
476
477 def test_read_space_delimiter(self):
478 self._read_test(['a b', ' a ', ' ', ''],
479 [['a', '', '', 'b'], ['', '', 'a', '', ''], ['', '', ''], []],
480 delimiter=' ', skipinitialspace=False)
481 self._read_test(['a b', ' a ', ' ', ''],
482 [['a', 'b'], ['a', ''], [''], []],
483 delimiter=' ', skipinitialspace=True)
484
485 def test_read_bigfield(self):
486 # This exercises the buffer realloc functionality and field size
487 # limits.
488 limit = csv.field_size_limit()
489 try:
490 size = 50000
491 bigstring = 'X' * size
492 bigline = '%s,%s' % (bigstring, bigstring)
493 self._read_test([bigline], [[bigstring, bigstring]])
494 csv.field_size_limit(size)
495 self._read_test([bigline], [[bigstring, bigstring]])
496 self.assertEqual(csv.field_size_limit(), size)
497 csv.field_size_limit(size-1)
498 self.assertRaises(csv.Error, self._read_test, [bigline], [])
499 self.assertRaises(TypeError, csv.field_size_limit, None)
500 self.assertRaises(TypeError, csv.field_size_limit, 1, None)
501 finally:
502 csv.field_size_limit(limit)
503
504 def test_read_linenum(self):
505 r = csv.reader(['line,1', 'line,2', 'line,3'])
506 self.assertEqual(r.line_num, 0)
507 next(r)
508 self.assertEqual(r.line_num, 1)
509 next(r)
510 self.assertEqual(r.line_num, 2)
511 next(r)
512 self.assertEqual(r.line_num, 3)
513 self.assertRaises(StopIteration, next, r)
514 self.assertEqual(r.line_num, 3)
515
516 def test_roundtrip_quoteed_newlines(self):
517 rows = [
518 ['\na', 'b\nc', 'd\n'],
519 ['\re', 'f\rg', 'h\r'],
520 ['\r\ni', 'j\r\nk', 'l\r\n'],
521 ['\n\rm', 'n\n\ro', 'p\n\r'],
522 ['\r\rq', 'r\r\rs', 't\r\r'],
523 ['\n\nu', 'v\n\nw', 'x\n\n'],
524 ]
525 for lineterminator in '\r\n', '\n', '\r':
526 with self.subTest(lineterminator=lineterminator):
527 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
528 writer = csv.writer(fileobj, lineterminator=lineterminator)
529 writer.writerows(rows)
530 fileobj.seek(0)
531 for i, row in enumerate(csv.reader(fileobj)):
532 self.assertEqual(row, rows[i])
533
534 def test_roundtrip_escaped_unquoted_newlines(self):
535 rows = [
536 ['\na', 'b\nc', 'd\n'],
537 ['\re', 'f\rg', 'h\r'],
538 ['\r\ni', 'j\r\nk', 'l\r\n'],
539 ['\n\rm', 'n\n\ro', 'p\n\r'],
540 ['\r\rq', 'r\r\rs', 't\r\r'],
541 ['\n\nu', 'v\n\nw', 'x\n\n'],
542 ]
543 for lineterminator in '\r\n', '\n', '\r':
544 with self.subTest(lineterminator=lineterminator):
545 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
546 writer = csv.writer(fileobj, lineterminator=lineterminator,
547 quoting=csv.QUOTE_NONE, escapechar="\\")
548 writer.writerows(rows)
549 fileobj.seek(0)
550 for i, row in enumerate(csv.reader(fileobj,
551 quoting=csv.QUOTE_NONE,
552 escapechar="\\")):
553 self.assertEqual(row, rows[i])
554
555
556 def test_reader_reentrant_iterator(self):
557 # gh-145105: re-entering the reader from the iterator must not crash.
558 class ReentrantIter:
559 def __init__(self):
560 self.reader = None
561 self.n = 0
562 def __iter__(self):
563 return self
564 def __next__(self):
565 self.n += 1
566 if self.n == 1:
567 try:
568 next(self.reader)
569 except StopIteration:
570 pass
571 return "a,b"
572 if self.n == 2:
573 return "x"
574 raise StopIteration
575
576 it = ReentrantIter()
577 reader = csv.reader(it)
578 it.reader = reader
579 with self.assertRaises(csv.Error):
580 next(reader)
581
582
583 class TestDialectRegistry(unittest.TestCase):
584 def test_registry_badargs(self):
585 self.assertRaises(TypeError, csv.list_dialects, None)
586 self.assertRaises(TypeError, csv.get_dialect)
587 self.assertRaises(csv.Error, csv.get_dialect, None)
588 self.assertRaises(csv.Error, csv.get_dialect, "nonesuch")
589 self.assertRaises(TypeError, csv.unregister_dialect)
590 self.assertRaises(csv.Error, csv.unregister_dialect, None)
591 self.assertRaises(csv.Error, csv.unregister_dialect, "nonesuch")
592 self.assertRaises(TypeError, csv.register_dialect, None)
593 self.assertRaises(TypeError, csv.register_dialect, None, None)
594 self.assertRaises(TypeError, csv.register_dialect, "nonesuch", 0, 0)
595 self.assertRaises(TypeError, csv.register_dialect, "nonesuch",
596 badargument=None)
597 self.assertRaises(TypeError, csv.register_dialect, "nonesuch",
598 quoting=None)
599 self.assertRaises(TypeError, csv.register_dialect, [])
600
601 def test_registry(self):
602 class myexceltsv(csv.excel):
603 delimiter = "\t"
604 name = "myexceltsv"
605 expected_dialects = csv.list_dialects() + [name]
606 expected_dialects.sort()
607 csv.register_dialect(name, myexceltsv)
608 self.addCleanup(csv.unregister_dialect, name)
609 self.assertEqual(csv.get_dialect(name).delimiter, '\t')
610 got_dialects = sorted(csv.list_dialects())
611 self.assertEqual(expected_dialects, got_dialects)
612
613 def test_register_kwargs(self):
614 name = 'fedcba'
615 csv.register_dialect(name, delimiter=';')
616 self.addCleanup(csv.unregister_dialect, name)
617 self.assertEqual(csv.get_dialect(name).delimiter, ';')
618 self.assertEqual([['X', 'Y', 'Z']], list(csv.reader(['X;Y;Z'], name)))
619
620 def test_register_kwargs_override(self):
621 class mydialect(csv.Dialect):
622 delimiter = "\t"
623 quotechar = '"'
624 doublequote = True
625 skipinitialspace = False
626 lineterminator = '\r\n'
627 quoting = csv.QUOTE_MINIMAL
628
629 name = 'test_dialect'
630 csv.register_dialect(name, mydialect,
631 delimiter=';',
632 quotechar="'",
633 doublequote=False,
634 skipinitialspace=True,
635 lineterminator='\n',
636 quoting=csv.QUOTE_ALL)
637 self.addCleanup(csv.unregister_dialect, name)
638
639 # Ensure that kwargs do override attributes of a dialect class:
640 dialect = csv.get_dialect(name)
641 self.assertEqual(dialect.delimiter, ';')
642 self.assertEqual(dialect.quotechar, "'")
643 self.assertEqual(dialect.doublequote, False)
644 self.assertEqual(dialect.skipinitialspace, True)
645 self.assertEqual(dialect.lineterminator, '\n')
646 self.assertEqual(dialect.quoting, csv.QUOTE_ALL)
647
648 def test_incomplete_dialect(self):
649 class myexceltsv(csv.Dialect):
650 delimiter = "\t"
651 self.assertRaises(csv.Error, myexceltsv)
652
653 def test_space_dialect(self):
654 class space(csv.excel):
655 delimiter = " "
656 quoting = csv.QUOTE_NONE
657 escapechar = "\\"
658
659 with TemporaryFile("w+", encoding="utf-8") as fileobj:
660 fileobj.write("abc def\nc1ccccc1 benzene\n")
661 fileobj.seek(0)
662 reader = csv.reader(fileobj, dialect=space())
663 self.assertEqual(next(reader), ["abc", "", "", "def"])
664 self.assertEqual(next(reader), ["c1ccccc1", "benzene"])
665
666 def compare_dialect_123(self, expected, *writeargs, **kwwriteargs):
667
668 with TemporaryFile("w+", newline='', encoding="utf-8") as fileobj:
669
670 writer = csv.writer(fileobj, *writeargs, **kwwriteargs)
671 writer.writerow([1,2,3])
672 fileobj.seek(0)
673 self.assertEqual(fileobj.read(), expected)
674
675 def test_dialect_apply(self):
676 class testA(csv.excel):
677 delimiter = "\t"
678 class testB(csv.excel):
679 delimiter = ":"
680 class testC(csv.excel):
681 delimiter = "|"
682 class testUni(csv.excel):
683 delimiter = "\u039B"
684
685 class unspecified():
686 # A class to pass as dialect but with no dialect attributes.
687 pass
688
689 csv.register_dialect('testC', testC)
690 try:
691 self.compare_dialect_123("1,2,3\r\n")
692 self.compare_dialect_123("1,2,3\r\n", dialect=None)
693 self.compare_dialect_123("1,2,3\r\n", dialect=unspecified)
694 self.compare_dialect_123("1\t2\t3\r\n", testA)
695 self.compare_dialect_123("1:2:3\r\n", dialect=testB())
696 self.compare_dialect_123("1|2|3\r\n", dialect='testC')
697 self.compare_dialect_123("1;2;3\r\n", dialect=testA,
698 delimiter=';')
699 self.compare_dialect_123("1\u039B2\u039B3\r\n",
700 dialect=testUni)
701
702 finally:
703 csv.unregister_dialect('testC')
704
705 def test_copy(self):
706 for name in csv.list_dialects():
707 dialect = csv.get_dialect(name)
708 self.assertRaises(TypeError, copy.copy, dialect)
709
710 def test_pickle(self):
711 for name in csv.list_dialects():
712 dialect = csv.get_dialect(name)
713 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
714 self.assertRaises(TypeError, pickle.dumps, dialect, proto)
715
716 class TestCsvBase(unittest.TestCase):
717 def readerAssertEqual(self, input, expected_result):
718 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
719 fileobj.write(input)
720 fileobj.seek(0)
721 reader = csv.reader(fileobj, dialect = self.dialect)
722 fields = list(reader)
723 self.assertEqual(fields, expected_result)
724
725 def writerAssertEqual(self, input, expected_result):
726 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
727 writer = csv.writer(fileobj, dialect = self.dialect)
728 writer.writerows(input)
729 fileobj.seek(0)
730 self.assertEqual(fileobj.read(), expected_result)
731
732 class TestDialectExcel(TestCsvBase):
733 dialect = 'excel'
734
735 def test_single(self):
736 self.readerAssertEqual('abc', [['abc']])
737
738 def test_simple(self):
739 self.readerAssertEqual('1,2,3,4,5', [['1','2','3','4','5']])
740
741 def test_blankline(self):
742 self.readerAssertEqual('', [])
743
744 def test_empty_fields(self):
745 self.readerAssertEqual(',', [['', '']])
746
747 def test_singlequoted(self):
748 self.readerAssertEqual('""', [['']])
749
750 def test_singlequoted_left_empty(self):
751 self.readerAssertEqual('"",', [['','']])
752
753 def test_singlequoted_right_empty(self):
754 self.readerAssertEqual(',""', [['','']])
755
756 def test_single_quoted_quote(self):
757 self.readerAssertEqual('""""', [['"']])
758
759 def test_quoted_quotes(self):
760 self.readerAssertEqual('""""""', [['""']])
761
762 def test_inline_quote(self):
763 self.readerAssertEqual('a""b', [['a""b']])
764
765 def test_inline_quotes(self):
766 self.readerAssertEqual('a"b"c', [['a"b"c']])
767
768 def test_quotes_and_more(self):
769 # Excel would never write a field containing '"a"b', but when
770 # reading one, it will return 'ab'.
771 self.readerAssertEqual('"a"b', [['ab']])
772
773 def test_lone_quote(self):
774 self.readerAssertEqual('a"b', [['a"b']])
775
776 def test_quote_and_quote(self):
777 # Excel would never write a field containing '"a" "b"', but when
778 # reading one, it will return 'a "b"'.
779 self.readerAssertEqual('"a" "b"', [['a "b"']])
780
781 def test_space_and_quote(self):
782 self.readerAssertEqual(' "a"', [[' "a"']])
783
784 def test_quoted(self):
785 self.readerAssertEqual('1,2,3,"I think, therefore I am",5,6',
786 [['1', '2', '3',
787 'I think, therefore I am',
788 '5', '6']])
789
790 def test_quoted_quote(self):
791 self.readerAssertEqual('1,2,3,"""I see,"" said the blind man","as he picked up his hammer and saw"',
792 [['1', '2', '3',
793 '"I see," said the blind man',
794 'as he picked up his hammer and saw']])
795
796 def test_quoted_nl(self):
797 input = '''\
798 1,2,3,"""I see,""
799 said the blind man","as he picked up his
800 hammer and saw"
801 9,8,7,6'''
802 self.readerAssertEqual(input,
803 [['1', '2', '3',
804 '"I see,"\nsaid the blind man',
805 'as he picked up his\nhammer and saw'],
806 ['9','8','7','6']])
807
808 def test_dubious_quote(self):
809 self.readerAssertEqual('12,12,1",', [['12', '12', '1"', '']])
810
811 def test_null(self):
812 self.writerAssertEqual([], '')
813
814 def test_single_writer(self):
815 self.writerAssertEqual([['abc']], 'abc\r\n')
816
817 def test_simple_writer(self):
818 self.writerAssertEqual([[1, 2, 'abc', 3, 4]], '1,2,abc,3,4\r\n')
819
820 def test_quotes(self):
821 self.writerAssertEqual([[1, 2, 'a"bc"', 3, 4]], '1,2,"a""bc""",3,4\r\n')
822
823 def test_quote_fieldsep(self):
824 self.writerAssertEqual([['abc,def']], '"abc,def"\r\n')
825
826 def test_newlines(self):
827 self.writerAssertEqual([[1, 2, 'a\nbc', 3, 4]], '1,2,"a\nbc",3,4\r\n')
828
829 class EscapedExcel(csv.excel):
830 quoting = csv.QUOTE_NONE
831 escapechar = '\\'
832
833 class TestEscapedExcel(TestCsvBase):
834 dialect = EscapedExcel()
835
836 def test_escape_fieldsep(self):
837 self.writerAssertEqual([['abc,def']], 'abc\\,def\r\n')
838
839 def test_read_escape_fieldsep(self):
840 self.readerAssertEqual('abc\\,def\r\n', [['abc,def']])
841
842 class TestDialectUnix(TestCsvBase):
843 dialect = 'unix'
844
845 def test_simple_writer(self):
846 self.writerAssertEqual([[1, 'abc def', 'abc']], '"1","abc def","abc"\n')
847
848 def test_simple_reader(self):
849 self.readerAssertEqual('"1","abc def","abc"\n', [['1', 'abc def', 'abc']])
850
851 class QuotedEscapedExcel(csv.excel):
852 quoting = csv.QUOTE_NONNUMERIC
853 escapechar = '\\'
854
855 class TestQuotedEscapedExcel(TestCsvBase):
856 dialect = QuotedEscapedExcel()
857
858 def test_write_escape_fieldsep(self):
859 self.writerAssertEqual([['abc,def']], '"abc,def"\r\n')
860
861 def test_read_escape_fieldsep(self):
862 self.readerAssertEqual('"abc\\,def"\r\n', [['abc,def']])
863
864 class TestDictFields(unittest.TestCase):
865 ### "long" means the row is longer than the number of fieldnames
866 ### "short" means there are fewer elements in the row than fieldnames
867 def test_writeheader_return_value(self):
868 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
869 writer = csv.DictWriter(fileobj, fieldnames = ["f1", "f2", "f3"])
870 writeheader_return_value = writer.writeheader()
871 self.assertEqual(writeheader_return_value, 10)
872
873 def test_write_simple_dict(self):
874 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
875 writer = csv.DictWriter(fileobj, fieldnames = ["f1", "f2", "f3"])
876 writer.writeheader()
877 fileobj.seek(0)
878 self.assertEqual(fileobj.readline(), "f1,f2,f3\r\n")
879 writer.writerow({"f1": 10, "f3": "abc"})
880 fileobj.seek(0)
881 fileobj.readline() # header
882 self.assertEqual(fileobj.read(), "10,,abc\r\n")
883
884 def test_write_multiple_dict_rows(self):
885 fileobj = StringIO()
886 writer = csv.DictWriter(fileobj, fieldnames=["f1", "f2", "f3"])
887 writer.writeheader()
888 self.assertEqual(fileobj.getvalue(), "f1,f2,f3\r\n")
889 writer.writerows([{"f1": 1, "f2": "abc", "f3": "f"},
890 {"f1": 2, "f2": 5, "f3": "xyz"}])
891 self.assertEqual(fileobj.getvalue(),
892 "f1,f2,f3\r\n1,abc,f\r\n2,5,xyz\r\n")
893
894 def test_write_no_fields(self):
895 fileobj = StringIO()
896 self.assertRaises(TypeError, csv.DictWriter, fileobj)
897
898 def test_write_fields_not_in_fieldnames(self):
899 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
900 writer = csv.DictWriter(fileobj, fieldnames = ["f1", "f2", "f3"])
901 # Of special note is the non-string key (issue 19449)
902 with self.assertRaises(ValueError) as cx:
903 writer.writerow({"f4": 10, "f2": "spam", 1: "abc"})
904 exception = str(cx.exception)
905 self.assertIn("fieldnames", exception)
906 self.assertIn("'f4'", exception)
907 self.assertNotIn("'f2'", exception)
908 self.assertIn("1", exception)
909
910 def test_typo_in_extrasaction_raises_error(self):
911 fileobj = StringIO()
912 self.assertRaises(ValueError, csv.DictWriter, fileobj, ['f1', 'f2'],
913 extrasaction="raised")
914
915 def test_write_field_not_in_field_names_raise(self):
916 fileobj = StringIO()
917 writer = csv.DictWriter(fileobj, ['f1', 'f2'], extrasaction="raise")
918 dictrow = {'f0': 0, 'f1': 1, 'f2': 2, 'f3': 3}
919 self.assertRaises(ValueError, csv.DictWriter.writerow, writer, dictrow)
920
921 # see bpo-44512 (differently cased 'raise' should not result in 'ignore')
922 writer = csv.DictWriter(fileobj, ['f1', 'f2'], extrasaction="RAISE")
923 self.assertRaises(ValueError, csv.DictWriter.writerow, writer, dictrow)
924
925 def test_write_field_not_in_field_names_ignore(self):
926 fileobj = StringIO()
927 writer = csv.DictWriter(fileobj, ['f1', 'f2'], extrasaction="ignore")
928 dictrow = {'f0': 0, 'f1': 1, 'f2': 2, 'f3': 3}
929 csv.DictWriter.writerow(writer, dictrow)
930 self.assertEqual(fileobj.getvalue(), "1,2\r\n")
931
932 # bpo-44512
933 writer = csv.DictWriter(fileobj, ['f1', 'f2'], extrasaction="IGNORE")
934 csv.DictWriter.writerow(writer, dictrow)
935
936 def test_dict_reader_fieldnames_accepts_iter(self):
937 fieldnames = ["a", "b", "c"]
938 f = StringIO()
939 reader = csv.DictReader(f, iter(fieldnames))
940 self.assertEqual(reader.fieldnames, fieldnames)
941
942 def test_dict_reader_fieldnames_accepts_list(self):
943 fieldnames = ["a", "b", "c"]
944 f = StringIO()
945 reader = csv.DictReader(f, fieldnames)
946 self.assertEqual(reader.fieldnames, fieldnames)
947
948 def test_dict_reader_set_fieldnames(self):
949 fieldnames = ["a", "b", "c"]
950 f = StringIO()
951 reader = csv.DictReader(f)
952 self.assertIsNone(reader.fieldnames)
953 reader.fieldnames = fieldnames
954 self.assertEqual(reader.fieldnames, fieldnames)
955
956 def test_dict_writer_fieldnames_rejects_iter(self):
957 fieldnames = ["a", "b", "c"]
958 f = StringIO()
959 writer = csv.DictWriter(f, iter(fieldnames))
960 self.assertEqual(writer.fieldnames, fieldnames)
961
962 def test_dict_writer_fieldnames_accepts_list(self):
963 fieldnames = ["a", "b", "c"]
964 f = StringIO()
965 writer = csv.DictWriter(f, fieldnames)
966 self.assertEqual(writer.fieldnames, fieldnames)
967
968 def test_dict_reader_fieldnames_is_optional(self):
969 f = StringIO()
970 reader = csv.DictReader(f, fieldnames=None)
971 self.assertIsNone(reader.fieldnames)
972
973 def test_read_dict_fields(self):
974 with TemporaryFile("w+", encoding="utf-8") as fileobj:
975 fileobj.write("1,2,abc\r\n")
976 fileobj.seek(0)
977 reader = csv.DictReader(fileobj,
978 fieldnames=["f1", "f2", "f3"])
979 self.assertEqual(next(reader), {"f1": '1', "f2": '2', "f3": 'abc'})
980
981 def test_read_dict_no_fieldnames(self):
982 with TemporaryFile("w+", encoding="utf-8") as fileobj:
983 fileobj.write("f1,f2,f3\r\n1,2,abc\r\n")
984 fileobj.seek(0)
985 reader = csv.DictReader(fileobj)
986 self.assertEqual(next(reader), {"f1": '1', "f2": '2', "f3": 'abc'})
987 self.assertEqual(reader.fieldnames, ["f1", "f2", "f3"])
988
989 # Two test cases to make sure existing ways of implicitly setting
990 # fieldnames continue to work. Both arise from discussion in issue3436.
991 def test_read_dict_fieldnames_from_file(self):
992 with TemporaryFile("w+", encoding="utf-8") as fileobj:
993 fileobj.write("f1,f2,f3\r\n1,2,abc\r\n")
994 fileobj.seek(0)
995 reader = csv.DictReader(fileobj,
996 fieldnames=next(csv.reader(fileobj)))
997 self.assertEqual(reader.fieldnames, ["f1", "f2", "f3"])
998 self.assertEqual(next(reader), {"f1": '1', "f2": '2', "f3": 'abc'})
999
1000 def test_read_dict_fieldnames_chain(self):
1001 import itertools
1002 with TemporaryFile("w+", encoding="utf-8") as fileobj:
1003 fileobj.write("f1,f2,f3\r\n1,2,abc\r\n")
1004 fileobj.seek(0)
1005 reader = csv.DictReader(fileobj)
1006 first = next(reader)
1007 for row in itertools.chain([first], reader):
1008 self.assertEqual(reader.fieldnames, ["f1", "f2", "f3"])
1009 self.assertEqual(row, {"f1": '1', "f2": '2', "f3": 'abc'})
1010
1011 def test_read_long(self):
1012 with TemporaryFile("w+", encoding="utf-8") as fileobj:
1013 fileobj.write("1,2,abc,4,5,6\r\n")
1014 fileobj.seek(0)
1015 reader = csv.DictReader(fileobj,
1016 fieldnames=["f1", "f2"])
1017 self.assertEqual(next(reader), {"f1": '1', "f2": '2',
1018 None: ["abc", "4", "5", "6"]})
1019
1020 def test_read_long_with_rest(self):
1021 with TemporaryFile("w+", encoding="utf-8") as fileobj:
1022 fileobj.write("1,2,abc,4,5,6\r\n")
1023 fileobj.seek(0)
1024 reader = csv.DictReader(fileobj,
1025 fieldnames=["f1", "f2"], restkey="_rest")
1026 self.assertEqual(next(reader), {"f1": '1', "f2": '2',
1027 "_rest": ["abc", "4", "5", "6"]})
1028
1029 def test_read_long_with_rest_no_fieldnames(self):
1030 with TemporaryFile("w+", encoding="utf-8") as fileobj:
1031 fileobj.write("f1,f2\r\n1,2,abc,4,5,6\r\n")
1032 fileobj.seek(0)
1033 reader = csv.DictReader(fileobj, restkey="_rest")
1034 self.assertEqual(reader.fieldnames, ["f1", "f2"])
1035 self.assertEqual(next(reader), {"f1": '1', "f2": '2',
1036 "_rest": ["abc", "4", "5", "6"]})
1037
1038 def test_read_short(self):
1039 with TemporaryFile("w+", encoding="utf-8") as fileobj:
1040 fileobj.write("1,2,abc,4,5,6\r\n1,2,abc\r\n")
1041 fileobj.seek(0)
1042 reader = csv.DictReader(fileobj,
1043 fieldnames="1 2 3 4 5 6".split(),
1044 restval="DEFAULT")
1045 self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
1046 "4": '4', "5": '5', "6": '6'})
1047 self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
1048 "4": 'DEFAULT', "5": 'DEFAULT',
1049 "6": 'DEFAULT'})
1050
1051 def test_read_multi(self):
1052 sample = [
1053 '2147483648,43.0e12,17,abc,def\r\n',
1054 '147483648,43.0e2,17,abc,def\r\n',
1055 '47483648,43.0,170,abc,def\r\n'
1056 ]
1057
1058 reader = csv.DictReader(sample,
1059 fieldnames="i1 float i2 s1 s2".split())
1060 self.assertEqual(next(reader), {"i1": '2147483648',
1061 "float": '43.0e12',
1062 "i2": '17',
1063 "s1": 'abc',
1064 "s2": 'def'})
1065
1066 def test_read_with_blanks(self):
1067 reader = csv.DictReader(["1,2,abc,4,5,6\r\n","\r\n",
1068 "1,2,abc,4,5,6\r\n"],
1069 fieldnames="1 2 3 4 5 6".split())
1070 self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
1071 "4": '4', "5": '5', "6": '6'})
1072 self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
1073 "4": '4', "5": '5', "6": '6'})
1074
1075 def test_read_semi_sep(self):
1076 reader = csv.DictReader(["1;2;abc;4;5;6\r\n"],
1077 fieldnames="1 2 3 4 5 6".split(),
1078 delimiter=';')
1079 self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
1080 "4": '4', "5": '5', "6": '6'})
1081
1082 class TestArrayWrites(unittest.TestCase):
1083 def test_int_write(self):
1084 import array
1085 contents = [(20-i) for i in range(20)]
1086 a = array.array('i', contents)
1087
1088 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
1089 writer = csv.writer(fileobj, dialect="excel")
1090 writer.writerow(a)
1091 expected = ",".join([str(i) for i in a])+"\r\n"
1092 fileobj.seek(0)
1093 self.assertEqual(fileobj.read(), expected)
1094
1095 def test_double_write(self):
1096 import array
1097 contents = [(20-i)*0.1 for i in range(20)]
1098 a = array.array('d', contents)
1099 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
1100 writer = csv.writer(fileobj, dialect="excel")
1101 writer.writerow(a)
1102 expected = ",".join([str(i) for i in a])+"\r\n"
1103 fileobj.seek(0)
1104 self.assertEqual(fileobj.read(), expected)
1105
1106 def test_float_write(self):
1107 import array
1108 contents = [(20-i)*0.1 for i in range(20)]
1109 a = array.array('f', contents)
1110 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
1111 writer = csv.writer(fileobj, dialect="excel")
1112 writer.writerow(a)
1113 expected = ",".join([str(i) for i in a])+"\r\n"
1114 fileobj.seek(0)
1115 self.assertEqual(fileobj.read(), expected)
1116
1117 def test_char_write(self):
1118 import array, string
1119 a = array.array('w', string.ascii_letters)
1120
1121 with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
1122 writer = csv.writer(fileobj, dialect="excel")
1123 writer.writerow(a)
1124 expected = ",".join(a)+"\r\n"
1125 fileobj.seek(0)
1126 self.assertEqual(fileobj.read(), expected)
1127
1128 class TestDialectValidity(unittest.TestCase):
1129 def test_quoting(self):
1130 class mydialect(csv.Dialect):
1131 delimiter = ";"
1132 escapechar = '\\'
1133 doublequote = False
1134 skipinitialspace = True
1135 lineterminator = '\r\n'
1136 quoting = csv.QUOTE_NONE
1137 d = mydialect()
1138 self.assertEqual(d.quoting, csv.QUOTE_NONE)
1139
1140 mydialect.quoting = None
1141 self.assertRaises(csv.Error, mydialect)
1142
1143 mydialect.quoting = 42
1144 with self.assertRaises(csv.Error) as cm:
1145 mydialect()
1146 self.assertEqual(str(cm.exception),
1147 'bad "quoting" value')
1148
1149 mydialect.doublequote = True
1150 mydialect.quoting = csv.QUOTE_ALL
1151 mydialect.quotechar = '"'
1152 d = mydialect()
1153 self.assertEqual(d.quoting, csv.QUOTE_ALL)
1154 self.assertEqual(d.quotechar, '"')
1155 self.assertTrue(d.doublequote)
1156
1157 mydialect.quotechar = ""
1158 with self.assertRaises(csv.Error) as cm:
1159 mydialect()
1160 self.assertEqual(str(cm.exception),
1161 '"quotechar" must be a unicode character or None, '
1162 'not a string of length 0')
1163
1164 mydialect.quotechar = "''"
1165 with self.assertRaises(csv.Error) as cm:
1166 mydialect()
1167 self.assertEqual(str(cm.exception),
1168 '"quotechar" must be a unicode character or None, '
1169 'not a string of length 2')
1170
1171 mydialect.quotechar = 4
1172 with self.assertRaises(csv.Error) as cm:
1173 mydialect()
1174 self.assertEqual(str(cm.exception),
1175 '"quotechar" must be a unicode character or None, '
1176 'not int')
1177
1178 def test_delimiter(self):
1179 class mydialect(csv.Dialect):
1180 delimiter = ";"
1181 escapechar = '\\'
1182 doublequote = False
1183 skipinitialspace = True
1184 lineterminator = '\r\n'
1185 quoting = csv.QUOTE_NONE
1186 d = mydialect()
1187 self.assertEqual(d.delimiter, ";")
1188
1189 mydialect.delimiter = ":::"
1190 with self.assertRaises(csv.Error) as cm:
1191 mydialect()
1192 self.assertEqual(str(cm.exception),
1193 '"delimiter" must be a unicode character, '
1194 'not a string of length 3')
1195
1196 mydialect.delimiter = ""
1197 with self.assertRaises(csv.Error) as cm:
1198 mydialect()
1199 self.assertEqual(str(cm.exception),
1200 '"delimiter" must be a unicode character, not a string of length 0')
1201
1202 mydialect.delimiter = b","
1203 with self.assertRaises(csv.Error) as cm:
1204 mydialect()
1205 self.assertEqual(str(cm.exception),
1206 '"delimiter" must be a unicode character, not bytes')
1207
1208 mydialect.delimiter = 4
1209 with self.assertRaises(csv.Error) as cm:
1210 mydialect()
1211 self.assertEqual(str(cm.exception),
1212 '"delimiter" must be a unicode character, not int')
1213
1214 mydialect.delimiter = None
1215 with self.assertRaises(csv.Error) as cm:
1216 mydialect()
1217 self.assertEqual(str(cm.exception),
1218 '"delimiter" must be a unicode character, not NoneType')
1219
1220 def test_escapechar(self):
1221 class mydialect(csv.Dialect):
1222 delimiter = ";"
1223 escapechar = '\\'
1224 doublequote = False
1225 skipinitialspace = True
1226 lineterminator = '\r\n'
1227 quoting = csv.QUOTE_NONE
1228 d = mydialect()
1229 self.assertEqual(d.escapechar, "\\")
1230
1231 mydialect.escapechar = ""
1232 with self.assertRaises(csv.Error) as cm:
1233 mydialect()
1234 self.assertEqual(str(cm.exception),
1235 '"escapechar" must be a unicode character or None, '
1236 'not a string of length 0')
1237
1238 mydialect.escapechar = "**"
1239 with self.assertRaises(csv.Error) as cm:
1240 mydialect()
1241 self.assertEqual(str(cm.exception),
1242 '"escapechar" must be a unicode character or None, '
1243 'not a string of length 2')
1244
1245 mydialect.escapechar = b"*"
1246 with self.assertRaises(csv.Error) as cm:
1247 mydialect()
1248 self.assertEqual(str(cm.exception),
1249 '"escapechar" must be a unicode character or None, '
1250 'not bytes')
1251
1252 mydialect.escapechar = 4
1253 with self.assertRaises(csv.Error) as cm:
1254 mydialect()
1255 self.assertEqual(str(cm.exception),
1256 '"escapechar" must be a unicode character or None, '
1257 'not int')
1258
1259 def test_lineterminator(self):
1260 class mydialect(csv.Dialect):
1261 delimiter = ";"
1262 escapechar = '\\'
1263 doublequote = False
1264 skipinitialspace = True
1265 lineterminator = '\r\n'
1266 quoting = csv.QUOTE_NONE
1267 d = mydialect()
1268 self.assertEqual(d.lineterminator, '\r\n')
1269
1270 mydialect.lineterminator = ":::"
1271 d = mydialect()
1272 self.assertEqual(d.lineterminator, ":::")
1273
1274 mydialect.lineterminator = 4
1275 with self.assertRaises(csv.Error) as cm:
1276 mydialect()
1277 self.assertEqual(str(cm.exception),
1278 '"lineterminator" must be a string, not int')
1279
1280 mydialect.lineterminator = None
1281 with self.assertRaises(csv.Error) as cm:
1282 mydialect()
1283 self.assertEqual(str(cm.exception),
1284 '"lineterminator" must be a string, not NoneType')
1285
1286 def test_invalid_chars(self):
1287 def create_invalid(field_name, value, **kwargs):
1288 class mydialect(csv.Dialect):
1289 delimiter = ','
1290 quoting = csv.QUOTE_ALL
1291 quotechar = '"'
1292 lineterminator = '\r\n'
1293 setattr(mydialect, field_name, value)
1294 for field_name, value in kwargs.items():
1295 setattr(mydialect, field_name, value)
1296 d = mydialect()
1297
1298 for field_name in ("delimiter", "escapechar", "quotechar"):
1299 with self.subTest(field_name=field_name):
1300 self.assertRaises(csv.Error, create_invalid, field_name, "")
1301 self.assertRaises(csv.Error, create_invalid, field_name, "abc")
1302 self.assertRaises(csv.Error, create_invalid, field_name, b'x')
1303 self.assertRaises(csv.Error, create_invalid, field_name, 5)
1304 self.assertRaises(ValueError, create_invalid, field_name, "\n")
1305 self.assertRaises(ValueError, create_invalid, field_name, "\r")
1306 if field_name != "delimiter":
1307 self.assertRaises(ValueError, create_invalid, field_name, " ",
1308 skipinitialspace=True)
1309
1310
1311 class TestSniffer(unittest.TestCase):
1312 sample1 = """\
1313 Harry's, Arlington Heights, IL, 2/1/03, Kimi Hayes
1314 Shark City, Glendale Heights, IL, 12/28/02, Prezence
1315 Tommy's Place, Blue Island, IL, 12/28/02, Blue Sunday/White Crow
1316 Stonecutters Seafood and Chop House, Lemont, IL, 12/19/02, Week Back
1317 """
1318 sample2 = """\
1319 'Harry''s':'Arlington Heights':'IL':'2/1/03':'Kimi Hayes'
1320 'Shark City':'Glendale Heights':'IL':'12/28/02':'Prezence'
1321 'Tommy''s Place':'Blue Island':'IL':'12/28/02':'Blue Sunday/White Crow'
1322 'Stonecutters ''Seafood'' and Chop House':'Lemont':'IL':'12/19/02':'Week Back'
1323 """
1324 header1 = '''\
1325 "venue","city","state","date","performers"
1326 '''
1327 sample3 = '''\
1328 05/05/03?05/05/03?05/05/03?05/05/03?05/05/03?05/05/03
1329 05/05/03?05/05/03?05/05/03?05/05/03?05/05/03?05/05/03
1330 05/05/03?05/05/03?05/05/03?05/05/03?05/05/03?05/05/03
1331 '''
1332
1333 sample4 = '''\
1334 2147483648;43.0e12;17;abc;def
1335 147483648;43.0e2;17;abc;def
1336 47483648;43.0;170;abc;def
1337 '''
1338
1339 sample5 = "aaa\tbbb\r\nAAA\t\r\nBBB\t\r\n"
1340 sample6 = "a|b|c\r\nd|e|f\r\n"
1341 sample7 = "'a'|'b'|'c'\r\n'd'|e|f\r\n"
1342
1343 # Issue 18155: Use a delimiter that is a special char to regex:
1344
1345 header2 = '''\
1346 "venue"+"city"+"state"+"date"+"performers"
1347 '''
1348 sample8 = """\
1349 Harry's+ Arlington Heights+ IL+ 2/1/03+ Kimi Hayes
1350 Shark City+ Glendale Heights+ IL+ 12/28/02+ Prezence
1351 Tommy's Place+ Blue Island+ IL+ 12/28/02+ Blue Sunday/White Crow
1352 Stonecutters Seafood and Chop House+ Lemont+ IL+ 12/19/02+ Week Back
1353 """
1354 sample9 = """\
1355 'Harry''s'+ Arlington Heights'+ 'IL'+ '2/1/03'+ 'Kimi Hayes'
1356 'Shark City'+ Glendale Heights'+' IL'+ '12/28/02'+ 'Prezence'
1357 'Tommy''s Place'+ Blue Island'+ 'IL'+ '12/28/02'+ 'Blue Sunday/White Crow'
1358 'Stonecutters ''Seafood'' and Chop House'+ 'Lemont'+ 'IL'+ '12/19/02'+ 'Week Back'
1359 """
1360
1361 sample10 = dedent("""
1362 abc,def
1363 ghijkl,mno
1364 ghi,jkl
1365 """)
1366
1367 sample11 = dedent("""
1368 abc,def
1369 ghijkl,mnop
1370 ghi,jkl
1371 """)
1372
1373 sample12 = dedent(""""time","forces"
1374 1,1.5
1375 0.5,5+0j
1376 0,0
1377 1+1j,6
1378 """)
1379
1380 sample13 = dedent(""""time","forces"
1381 0,0
1382 1,2
1383 a,b
1384 """)
1385
1386 sample14 = """\
1387 abc\0def
1388 ghijkl\0mno
1389 ghi\0jkl
1390 """
1391
1392 sample15 = "\n\n\n"
1393 sample16 = "abc\ndef\nghi"
1394
1395 sample17 = ["letter,offset"]
1396 sample17.extend(f"{chr(ord('a') + i)},{i}" for i in range(20))
1397 sample17.append("v,twenty_one") # 'u' was skipped
1398 sample17 = '\n'.join(sample17)
1399
1400 sample18 = ["letter,offset"]
1401 sample18.extend(f"{chr(ord('a') + i)},{i}" for i in range(21))
1402 sample18.append("v,twenty_one") # 'u' was not skipped
1403 sample18 = '\n'.join(sample18)
1404
1405 def test_issue43625(self):
1406 sniffer = csv.Sniffer()
1407 self.assertTrue(sniffer.has_header(self.sample12))
1408 self.assertFalse(sniffer.has_header(self.sample13))
1409
1410 def test_has_header_strings(self):
1411 "More to document existing (unexpected?) behavior than anything else."
1412 sniffer = csv.Sniffer()
1413 self.assertFalse(sniffer.has_header(self.sample10))
1414 self.assertFalse(sniffer.has_header(self.sample11))
1415
1416 def test_has_header(self):
1417 sniffer = csv.Sniffer()
1418 self.assertIs(sniffer.has_header(self.sample1), False)
1419 self.assertIs(sniffer.has_header(self.header1 + self.sample1), True)
1420
1421 def test_has_header_regex_special_delimiter(self):
1422 sniffer = csv.Sniffer()
1423 self.assertIs(sniffer.has_header(self.sample8), False)
1424 self.assertIs(sniffer.has_header(self.header2 + self.sample8), True)
1425
1426 def test_has_header_checks_20_rows(self):
1427 sniffer = csv.Sniffer()
1428 self.assertFalse(sniffer.has_header(self.sample17))
1429 self.assertTrue(sniffer.has_header(self.sample18))
1430
1431 def test_guess_quote_and_delimiter(self):
1432 sniffer = csv.Sniffer()
1433 for header in (";'123;4';", "'123;4';", ";'123;4'", "'123;4'"):
1434 with self.subTest(header):
1435 dialect = sniffer.sniff(header, ",;")
1436 self.assertEqual(dialect.delimiter, ';')
1437 self.assertEqual(dialect.quotechar, "'")
1438 self.assertIs(dialect.doublequote, False)
1439 self.assertIs(dialect.skipinitialspace, False)
1440
1441 def test_sniff(self):
1442 sniffer = csv.Sniffer()
1443 dialect = sniffer.sniff(self.sample1)
1444 self.assertEqual(dialect.delimiter, ",")
1445 self.assertEqual(dialect.quotechar, '"')
1446 self.assertIs(dialect.skipinitialspace, True)
1447
1448 dialect = sniffer.sniff(self.sample2)
1449 self.assertEqual(dialect.delimiter, ":")
1450 self.assertEqual(dialect.quotechar, "'")
1451 self.assertIs(dialect.skipinitialspace, False)
1452
1453 def test_delimiters(self):
1454 sniffer = csv.Sniffer()
1455 dialect = sniffer.sniff(self.sample3)
1456 # given that all three lines in sample3 are equal,
1457 # I think that any character could have been 'guessed' as the
1458 # delimiter, depending on dictionary order
1459 self.assertIn(dialect.delimiter, self.sample3)
1460 dialect = sniffer.sniff(self.sample3, delimiters="?,")
1461 self.assertEqual(dialect.delimiter, "?")
1462 dialect = sniffer.sniff(self.sample3, delimiters="/,")
1463 self.assertEqual(dialect.delimiter, "/")
1464 dialect = sniffer.sniff(self.sample4)
1465 self.assertEqual(dialect.delimiter, ";")
1466 dialect = sniffer.sniff(self.sample5)
1467 self.assertEqual(dialect.delimiter, "\t")
1468 dialect = sniffer.sniff(self.sample6)
1469 self.assertEqual(dialect.delimiter, "|")
1470 dialect = sniffer.sniff(self.sample7)
1471 self.assertEqual(dialect.delimiter, "|")
1472 self.assertEqual(dialect.quotechar, "'")
1473 dialect = sniffer.sniff(self.sample8)
1474 self.assertEqual(dialect.delimiter, '+')
1475 dialect = sniffer.sniff(self.sample9)
1476 self.assertEqual(dialect.delimiter, '+')
1477 self.assertEqual(dialect.quotechar, "'")
1478 dialect = sniffer.sniff(self.sample14)
1479 self.assertEqual(dialect.delimiter, '\0')
1480 self.assertRaisesRegex(csv.Error, "Could not determine delimiter",
1481 sniffer.sniff, self.sample15)
1482 self.assertRaisesRegex(csv.Error, "Could not determine delimiter",
1483 sniffer.sniff, self.sample16)
1484
1485 def test_doublequote(self):
1486 sniffer = csv.Sniffer()
1487 dialect = sniffer.sniff(self.header1)
1488 self.assertFalse(dialect.doublequote)
1489 dialect = sniffer.sniff(self.header2)
1490 self.assertFalse(dialect.doublequote)
1491 dialect = sniffer.sniff(self.sample2)
1492 self.assertTrue(dialect.doublequote)
1493 dialect = sniffer.sniff(self.sample8)
1494 self.assertFalse(dialect.doublequote)
1495 dialect = sniffer.sniff(self.sample9)
1496 self.assertTrue(dialect.doublequote)
1497
1498 class NUL:
1499 def write(s, *args):
1500 pass
1501 writelines = write
1502
1503 @unittest.skipUnless(hasattr(sys, "gettotalrefcount"),
1504 'requires sys.gettotalrefcount()')
1505 class TestLeaks(unittest.TestCase):
1506 def test_create_read(self):
1507 delta = 0
1508 lastrc = sys.gettotalrefcount()
1509 for i in range(20):
1510 gc.collect()
1511 self.assertEqual(gc.garbage, [])
1512 rc = sys.gettotalrefcount()
1513 csv.reader(["a,b,c\r\n"])
1514 csv.reader(["a,b,c\r\n"])
1515 csv.reader(["a,b,c\r\n"])
1516 delta = rc-lastrc
1517 lastrc = rc
1518 # if csv.reader() leaks, last delta should be 3 or more
1519 self.assertLess(delta, 3)
1520
1521 def test_create_write(self):
1522 delta = 0
1523 lastrc = sys.gettotalrefcount()
1524 s = NUL()
1525 for i in range(20):
1526 gc.collect()
1527 self.assertEqual(gc.garbage, [])
1528 rc = sys.gettotalrefcount()
1529 csv.writer(s)
1530 csv.writer(s)
1531 csv.writer(s)
1532 delta = rc-lastrc
1533 lastrc = rc
1534 # if csv.writer() leaks, last delta should be 3 or more
1535 self.assertLess(delta, 3)
1536
1537 def test_read(self):
1538 delta = 0
1539 rows = ["a,b,c\r\n"]*5
1540 lastrc = sys.gettotalrefcount()
1541 for i in range(20):
1542 gc.collect()
1543 self.assertEqual(gc.garbage, [])
1544 rc = sys.gettotalrefcount()
1545 rdr = csv.reader(rows)
1546 for row in rdr:
1547 pass
1548 delta = rc-lastrc
1549 lastrc = rc
1550 # if reader leaks during read, delta should be 5 or more
1551 self.assertLess(delta, 5)
1552
1553 def test_write(self):
1554 delta = 0
1555 rows = [[1,2,3]]*5
1556 s = NUL()
1557 lastrc = sys.gettotalrefcount()
1558 for i in range(20):
1559 gc.collect()
1560 self.assertEqual(gc.garbage, [])
1561 rc = sys.gettotalrefcount()
1562 writer = csv.writer(s)
1563 for row in rows:
1564 writer.writerow(row)
1565 delta = rc-lastrc
1566 lastrc = rc
1567 # if writer leaks during write, last delta should be 5 or more
1568 self.assertLess(delta, 5)
1569
1570 class TestUnicode(unittest.TestCase):
1571
1572 names = ["Martin von Löwis",
1573 "Marc André Lemburg",
1574 "Guido van Rossum",
1575 "François Pinard"]
1576
1577 def test_unicode_read(self):
1578 with TemporaryFile("w+", newline='', encoding="utf-8") as fileobj:
1579 fileobj.write(",".join(self.names) + "\r\n")
1580 fileobj.seek(0)
1581 reader = csv.reader(fileobj)
1582 self.assertEqual(list(reader), [self.names])
1583
1584
1585 def test_unicode_write(self):
1586 with TemporaryFile("w+", newline='', encoding="utf-8") as fileobj:
1587 writer = csv.writer(fileobj)
1588 writer.writerow(self.names)
1589 expected = ",".join(self.names)+"\r\n"
1590 fileobj.seek(0)
1591 self.assertEqual(fileobj.read(), expected)
1592
1593 class KeyOrderingTest(unittest.TestCase):
1594
1595 def test_ordering_for_the_dict_reader_and_writer(self):
1596 resultset = set()
1597 for keys in permutations("abcde"):
1598 with TemporaryFile('w+', newline='', encoding="utf-8") as fileobject:
1599 dw = csv.DictWriter(fileobject, keys)
1600 dw.writeheader()
1601 fileobject.seek(0)
1602 dr = csv.DictReader(fileobject)
1603 kt = tuple(dr.fieldnames)
1604 self.assertEqual(keys, kt)
1605 resultset.add(kt)
1606 # Final sanity check: were all permutations unique?
1607 self.assertEqual(len(resultset), 120, "Key ordering: some key permutations not collected (expected 120)")
1608
1609 def test_ordered_dict_reader(self):
1610 data = dedent('''\
1611 FirstName,LastName
1612 Eric,Idle
1613 Graham,Chapman,Over1,Over2
1614
1615 Under1
1616 John,Cleese
1617 ''').splitlines()
1618
1619 self.assertEqual(list(csv.DictReader(data)),
1620 [OrderedDict([('FirstName', 'Eric'), ('LastName', 'Idle')]),
1621 OrderedDict([('FirstName', 'Graham'), ('LastName', 'Chapman'),
1622 (None, ['Over1', 'Over2'])]),
1623 OrderedDict([('FirstName', 'Under1'), ('LastName', None)]),
1624 OrderedDict([('FirstName', 'John'), ('LastName', 'Cleese')]),
1625 ])
1626
1627 self.assertEqual(list(csv.DictReader(data, restkey='OtherInfo')),
1628 [OrderedDict([('FirstName', 'Eric'), ('LastName', 'Idle')]),
1629 OrderedDict([('FirstName', 'Graham'), ('LastName', 'Chapman'),
1630 ('OtherInfo', ['Over1', 'Over2'])]),
1631 OrderedDict([('FirstName', 'Under1'), ('LastName', None)]),
1632 OrderedDict([('FirstName', 'John'), ('LastName', 'Cleese')]),
1633 ])
1634
1635 del data[0] # Remove the header row
1636 self.assertEqual(list(csv.DictReader(data, fieldnames=['fname', 'lname'])),
1637 [OrderedDict([('fname', 'Eric'), ('lname', 'Idle')]),
1638 OrderedDict([('fname', 'Graham'), ('lname', 'Chapman'),
1639 (None, ['Over1', 'Over2'])]),
1640 OrderedDict([('fname', 'Under1'), ('lname', None)]),
1641 OrderedDict([('fname', 'John'), ('lname', 'Cleese')]),
1642 ])
1643
1644
1645 class MiscTestCase(unittest.TestCase):
1646 def test__all__(self):
1647 support.check__all__(self, csv, ('csv', '_csv'))
1648
1649 @cpython_only
1650 def test_lazy_import(self):
1651 ensure_lazy_imports("csv", {"re"})
1652
1653 def test_subclassable(self):
1654 # issue 44089
1655 class Foo(csv.Error): ...
1656
1657 @support.cpython_only
1658 def test_disallow_instantiation(self):
1659 _csv = import_helper.import_module("_csv")
1660 for tp in _csv.Reader, _csv.Writer:
1661 with self.subTest(tp=tp):
1662 check_disallow_instantiation(self, tp)
1663
1664 if __name__ == '__main__':
1665 unittest.main()