# -*- coding: iso-8859-1 -*-
# Copyright (C) 2001,2002 Python Software Foundation
from StringIO
import StringIO
from test
import test_support
class Test_Csv(unittest
.TestCase
):
Test the underlying C csv parser in ways that are not appropriate
from the high level interface. Further tests of this nature are done
def test_reader_arg_valid(self
):
self
.assertRaises(TypeError, csv
.reader
)
self
.assertRaises(TypeError, csv
.reader
, None)
self
.assertRaises(AttributeError, csv
.reader
, [], bad_attr
= 0)
self
.assertRaises(csv
.Error
, csv
.reader
, [], 'foo')
self
.assertRaises(IOError, csv
.reader
, [], BadClass
)
self
.assertRaises(TypeError, csv
.reader
, [], None)
self
.assertRaises(AttributeError, csv
.reader
, [], BadDialect
)
def test_writer_arg_valid(self
):
self
.assertRaises(TypeError, csv
.writer
)
self
.assertRaises(TypeError, csv
.writer
, None)
self
.assertRaises(AttributeError, csv
.writer
, StringIO(), bad_attr
= 0)
def _test_attrs(self
, obj
):
self
.assertEqual(obj
.dialect
.delimiter
, ',')
obj
.dialect
.delimiter
= '\t'
self
.assertEqual(obj
.dialect
.delimiter
, '\t')
self
.assertRaises(TypeError, delattr, obj
.dialect
, 'delimiter')
self
.assertRaises(TypeError, setattr, obj
.dialect
,
obj
.dialect
.escapechar
= None
self
.assertEqual(obj
.dialect
.escapechar
, None)
self
.assertRaises(TypeError, delattr, obj
.dialect
, 'quoting')
self
.assertRaises(TypeError, setattr, obj
.dialect
, 'quoting', None)
obj
.dialect
.quoting
= csv
.QUOTE_MINIMAL
self
.assertEqual(obj
.dialect
.quoting
, csv
.QUOTE_MINIMAL
)
def test_reader_attrs(self
):
self
._test
_attrs
(csv
.reader([]))
def test_writer_attrs(self
):
self
._test
_attrs
(csv
.writer(StringIO()))
def _write_test(self
, fields
, expect
, **kwargs
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, **kwargs
)
self
.assertEqual(fileobj
.read(),
expect
+ writer
.dialect
.lineterminator
)
def test_write_arg_valid(self
):
self
.assertRaises(csv
.Error
, self
._write
_test
, None, '')
self
._write
_test
([None], '""')
self
.assertRaises(csv
.Error
, self
._write
_test
,
[None], None, quoting
= csv
.QUOTE_NONE
)
# Check that exceptions are passed up the chain
def __getitem__(self
, i
):
self
.assertRaises(IOError, self
._write
_test
, BadList(), '')
self
.assertRaises(IOError, self
._write
_test
, [BadItem()], '')
def test_write_bigfield(self
):
# This exercises the buffer realloc functionality
self
._write
_test
([bigstring
,bigstring
], '%s,%s' % \
def test_write_quoting(self
):
self
._write
_test
(['a','1','p,q'], 'a,1,"p,q"')
self
.assertRaises(csv
.Error
,
['a','1','p,q'], 'a,1,"p,q"',
quoting
= csv
.QUOTE_NONE
)
self
._write
_test
(['a','1','p,q'], 'a,1,"p,q"',
quoting
= csv
.QUOTE_MINIMAL
)
self
._write
_test
(['a','1','p,q'], '"a",1,"p,q"',
quoting
= csv
.QUOTE_NONNUMERIC
)
self
._write
_test
(['a','1','p,q'], '"a","1","p,q"',
def test_write_escape(self
):
self
._write
_test
(['a','1','p,q'], 'a,1,"p,q"',
# FAILED - needs to be fixed [am]:
# self._write_test(['a','1','p,"q"'], 'a,1,"p,\\"q\\"',
# escapechar='\\', doublequote = 0)
self
._write
_test
(['a','1','p,q'], 'a,1,p\\,q',
escapechar
='\\', quoting
= csv
.QUOTE_NONE
)
def test_writerows(self
):
writer
= csv
.writer(BrokenFile())
self
.assertRaises(IOError, writer
.writerows
, [['a']])
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
)
self
.assertRaises(TypeError, writer
.writerows
, None)
writer
.writerows([['a','b'],['c','d']])
self
.assertEqual(fileobj
.read(), "a,b\r\nc,d\r\n")
def _read_test(self
, input, expect
, **kwargs
):
reader
= csv
.reader(input, **kwargs
)
self
.assertEqual(result
, expect
)
def test_read_oddinputs(self
):
self
._read
_test
([''], [[]])
self
.assertRaises(csv
.Error
, self
._read
_test
,
['"ab"c'], None, strict
= 1)
# cannot handle null bytes for the moment
self
.assertRaises(csv
.Error
, self
._read
_test
,
['ab\0c'], None, strict
= 1)
self
._read
_test
(['"ab"c'], [['abc']], doublequote
= 0)
self
._read
_test
(['a,b'], [['a','b']])
self
._read
_test
(['a,b\n'], [['a','b']])
self
._read
_test
(['a,b\r\n'], [['a','b']])
self
._read
_test
(['a,b\r'], [['a','b']])
self
.assertRaises(csv
.Error
, self
._read
_test
, ['a,b\rc,d'], [])
self
.assertRaises(csv
.Error
, self
._read
_test
, ['a,b\nc,d'], [])
self
.assertRaises(csv
.Error
, self
._read
_test
, ['a,b\r\nc,d'], [])
def test_read_escape(self
):
self
._read
_test
(['a,\\b,c'], [['a', '\\b', 'c']], escapechar
='\\')
self
._read
_test
(['a,b\\,c'], [['a', 'b,c']], escapechar
='\\')
self
._read
_test
(['a,"b\\,c"'], [['a', 'b,c']], escapechar
='\\')
self
._read
_test
(['a,"b,\\c"'], [['a', 'b,\\c']], escapechar
='\\')
self
._read
_test
(['a,"b,c\\""'], [['a', 'b,c"']], escapechar
='\\')
self
._read
_test
(['a,"b,c"\\'], [['a', 'b,c\\']], escapechar
='\\')
def test_read_bigfield(self
):
# This exercises the buffer realloc functionality
bigline
= '%s,%s' % (bigstring
, bigstring
)
self
._read
_test
([bigline
], [[bigstring
, bigstring
]])
class TestDialectRegistry(unittest
.TestCase
):
def test_registry_badargs(self
):
self
.assertRaises(TypeError, csv
.list_dialects
, None)
self
.assertRaises(TypeError, csv
.get_dialect
)
self
.assertRaises(csv
.Error
, csv
.get_dialect
, None)
self
.assertRaises(csv
.Error
, csv
.get_dialect
, "nonesuch")
self
.assertRaises(TypeError, csv
.unregister_dialect
)
self
.assertRaises(csv
.Error
, csv
.unregister_dialect
, None)
self
.assertRaises(csv
.Error
, csv
.unregister_dialect
, "nonesuch")
self
.assertRaises(TypeError, csv
.register_dialect
, None)
self
.assertRaises(TypeError, csv
.register_dialect
, None, None)
self
.assertRaises(TypeError, csv
.register_dialect
, "nonesuch", None)
self
.assertRaises(KeyError, csv
.register_dialect
, "nonesuch", bogus
)
class myexceltsv(csv
.excel
):
expected_dialects
= csv
.list_dialects() + [name
]
csv
.register_dialect(name
, myexceltsv
)
self
.failUnless(isinstance(csv
.get_dialect(name
), myexceltsv
))
got_dialects
= csv
.list_dialects()
self
.assertEqual(expected_dialects
, got_dialects
)
csv
.unregister_dialect(name
)
def test_incomplete_dialect(self
):
class myexceltsv(csv
.Dialect
):
self
.assertRaises(csv
.Error
, myexceltsv
)
def test_space_dialect(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
fileobj
.write("abc def\nc1ccccc1 benzene\n")
rdr
= csv
.reader(fileobj
, dialect
=space())
self
.assertEqual(rdr
.next(), ["abc", "def"])
self
.assertEqual(rdr
.next(), ["c1ccccc1", "benzene"])
def test_dialect_apply(self
):
csv
.register_dialect('testC', testC
)
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
)
self
.assertEqual(fileobj
.read(), "1,2,3\r\n")
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, testA
)
self
.assertEqual(fileobj
.read(), "1\t2\t3\r\n")
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
=testB())
self
.assertEqual(fileobj
.read(), "1:2:3\r\n")
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
='testC')
self
.assertEqual(fileobj
.read(), "1|2|3\r\n")
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
=testA
, delimiter
=';')
self
.assertEqual(fileobj
.read(), "1;2;3\r\n")
csv
.unregister_dialect('testC')
def test_bad_dialect(self
):
self
.assertRaises(AttributeError, csv
.reader
, [], bad_attr
= 0)
self
.assertRaises(TypeError, csv
.reader
, [], delimiter
= None)
self
.assertRaises(TypeError, csv
.reader
, [], quoting
= -1)
self
.assertRaises(TypeError, csv
.reader
, [], quoting
= 100)
class TestCsvBase(unittest
.TestCase
):
def readerAssertEqual(self
, input, expected_result
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
reader
= csv
.reader(fileobj
, dialect
= self
.dialect
)
self
.assertEqual(fields
, expected_result
)
def writerAssertEqual(self
, input, expected_result
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
= self
.dialect
)
self
.assertEqual(fileobj
.read(), expected_result
)
class TestDialectExcel(TestCsvBase
):
self
.readerAssertEqual('abc', [['abc']])
self
.readerAssertEqual('1,2,3,4,5', [['1','2','3','4','5']])
def test_blankline(self
):
self
.readerAssertEqual('', [])
def test_empty_fields(self
):
self
.readerAssertEqual(',', [['', '']])
def test_singlequoted(self
):
self
.readerAssertEqual('""', [['']])
def test_singlequoted_left_empty(self
):
self
.readerAssertEqual('"",', [['','']])
def test_singlequoted_right_empty(self
):
self
.readerAssertEqual(',""', [['','']])
def test_single_quoted_quote(self
):
self
.readerAssertEqual('""""', [['"']])
def test_quoted_quotes(self
):
self
.readerAssertEqual('""""""', [['""']])
def test_inline_quote(self
):
self
.readerAssertEqual('a""b', [['a""b']])
def test_inline_quotes(self
):
self
.readerAssertEqual('a"b"c', [['a"b"c']])
def test_quotes_and_more(self
):
self
.readerAssertEqual('"a"b', [['ab']])
def test_lone_quote(self
):
self
.readerAssertEqual('a"b', [['a"b']])
def test_quote_and_quote(self
):
self
.readerAssertEqual('"a" "b"', [['a "b"']])
def test_space_and_quote(self
):
self
.readerAssertEqual(' "a"', [[' "a"']])
self
.readerAssertEqual('1,2,3,"I think, therefore I am",5,6',
'I think, therefore I am',
def test_quoted_quote(self
):
self
.readerAssertEqual('1,2,3,"""I see,"" said the blind man","as he picked up his hammer and saw"',
'"I see," said the blind man',
'as he picked up his hammer and saw']])
def test_quoted_nl(self
):
said the blind man","as he picked up his
self
.readerAssertEqual(input,
'"I see,"\nsaid the blind man',
'as he picked up his\nhammer and saw'],
def test_dubious_quote(self
):
self
.readerAssertEqual('12,12,1",', [['12', '12', '1"', '']])
self
.writerAssertEqual([], '')
self
.writerAssertEqual([['abc']], 'abc\r\n')
self
.writerAssertEqual([[1, 2, 'abc', 3, 4]], '1,2,abc,3,4\r\n')
self
.writerAssertEqual([[1, 2, 'a"bc"', 3, 4]], '1,2,"a""bc""",3,4\r\n')
def test_quote_fieldsep(self
):
self
.writerAssertEqual([['abc,def']], '"abc,def"\r\n')
self
.writerAssertEqual([[1, 2, 'a\nbc', 3, 4]], '1,2,"a\nbc",3,4\r\n')
class EscapedExcel(csv
.excel
):
class TestEscapedExcel(TestCsvBase
):
def test_escape_fieldsep(self
):
self
.writerAssertEqual([['abc,def']], 'abc\\,def\r\n')
def test_read_escape_fieldsep(self
):
self
.readerAssertEqual('abc\\,def\r\n', [['abc,def']])
class QuotedEscapedExcel(csv
.excel
):
quoting
= csv
.QUOTE_NONNUMERIC
class TestQuotedEscapedExcel(TestCsvBase
):
dialect
= QuotedEscapedExcel()
def test_write_escape_fieldsep(self
):
self
.writerAssertEqual([['abc,def']], '"abc,def"\r\n')
def test_read_escape_fieldsep(self
):
self
.readerAssertEqual('"abc\\,def"\r\n', [['abc,def']])
class TestDictFields(unittest
.TestCase
):
### "long" means the row is longer than the number of fieldnames
### "short" means there are fewer elements in the row than fieldnames
def test_write_simple_dict(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.DictWriter(fileobj
, fieldnames
= ["f1", "f2", "f3"])
writer
.writerow({"f1": 10, "f3": "abc"})
self
.assertEqual(fileobj
.read(), "10,,abc\r\n")
def test_write_no_fields(self
):
self
.assertRaises(TypeError, csv
.DictWriter
, fileobj
)
def test_read_dict_fields(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
fileobj
.write("1,2,abc\r\n")
reader
= csv
.DictReader(fileobj
,
fieldnames
=["f1", "f2", "f3"])
self
.assertEqual(reader
.next(), {"f1": '1', "f2": '2', "f3": 'abc'})
def test_read_dict_no_fieldnames(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
fileobj
.write("f1,f2,f3\r\n1,2,abc\r\n")
reader
= csv
.DictReader(fileobj
)
self
.assertEqual(reader
.next(), {"f1": '1', "f2": '2', "f3": 'abc'})
def test_read_long(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
fileobj
.write("1,2,abc,4,5,6\r\n")
reader
= csv
.DictReader(fileobj
,
self
.assertEqual(reader
.next(), {"f1": '1', "f2": '2',
None: ["abc", "4", "5", "6"]})
def test_read_long_with_rest(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
fileobj
.write("1,2,abc,4,5,6\r\n")
reader
= csv
.DictReader(fileobj
,
fieldnames
=["f1", "f2"], restkey
="_rest")
self
.assertEqual(reader
.next(), {"f1": '1', "f2": '2',
"_rest": ["abc", "4", "5", "6"]})
def test_read_long_with_rest_no_fieldnames(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
fileobj
.write("f1,f2\r\n1,2,abc,4,5,6\r\n")
reader
= csv
.DictReader(fileobj
, restkey
="_rest")
self
.assertEqual(reader
.next(), {"f1": '1', "f2": '2',
"_rest": ["abc", "4", "5", "6"]})
def test_read_short(self
):
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
fileobj
.write("1,2,abc,4,5,6\r\n1,2,abc\r\n")
reader
= csv
.DictReader(fileobj
,
fieldnames
="1 2 3 4 5 6".split(),
self
.assertEqual(reader
.next(), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
self
.assertEqual(reader
.next(), {"1": '1', "2": '2', "3": 'abc',
"4": 'DEFAULT', "5": 'DEFAULT',
def test_read_multi(self
):
'2147483648,43.0e12,17,abc,def\r\n',
'147483648,43.0e2,17,abc,def\r\n',
'47483648,43.0,170,abc,def\r\n'
reader
= csv
.DictReader(sample
,
fieldnames
="i1 float i2 s1 s2".split())
self
.assertEqual(reader
.next(), {"i1": '2147483648',
def test_read_with_blanks(self
):
reader
= csv
.DictReader(["1,2,abc,4,5,6\r\n","\r\n",
fieldnames
="1 2 3 4 5 6".split())
self
.assertEqual(reader
.next(), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
self
.assertEqual(reader
.next(), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
def test_read_semi_sep(self
):
reader
= csv
.DictReader(["1;2;abc;4;5;6\r\n"],
fieldnames
="1 2 3 4 5 6".split(),
self
.assertEqual(reader
.next(), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
class TestArrayWrites(unittest
.TestCase
):
def test_int_write(self
):
contents
= [(20-i
) for i
in range(20)]
a
= array
.array('i', contents
)
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
="excel")
expected
= ",".join([str(i
) for i
in a
])+"\r\n"
self
.assertEqual(fileobj
.read(), expected
)
def test_double_write(self
):
contents
= [(20-i
)*0.1 for i
in range(20)]
a
= array
.array('d', contents
)
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
="excel")
expected
= ",".join([str(i
) for i
in a
])+"\r\n"
self
.assertEqual(fileobj
.read(), expected
)
def test_float_write(self
):
contents
= [(20-i
)*0.1 for i
in range(20)]
a
= array
.array('f', contents
)
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
="excel")
expected
= ",".join([str(i
) for i
in a
])+"\r\n"
self
.assertEqual(fileobj
.read(), expected
)
def test_char_write(self
):
a
= array
.array('c', string
.letters
)
fd
, name
= tempfile
.mkstemp()
fileobj
= os
.fdopen(fd
, "w+b")
writer
= csv
.writer(fileobj
, dialect
="excel")
expected
= ",".join(a
)+"\r\n"
self
.assertEqual(fileobj
.read(), expected
)
class TestDialectValidity(unittest
.TestCase
):
class mydialect(csv
.Dialect
):
self
.assertRaises(csv
.Error
, mydialect
)
mydialect
.quoting
= csv
.QUOTE_NONE
mydialect
.escapechar
= None
self
.assertRaises(csv
.Error
, mydialect
)
mydialect
.doublequote
= True
mydialect
.quoting
= csv
.QUOTE_ALL
mydialect
.quotechar
= '"'
mydialect
.quotechar
= "''"
self
.assertRaises(csv
.Error
, mydialect
)
self
.assertRaises(csv
.Error
, mydialect
)
def test_delimiter(self
):
class mydialect(csv
.Dialect
):
mydialect
.delimiter
= ":::"
self
.assertRaises(csv
.Error
, mydialect
)
self
.assertRaises(csv
.Error
, mydialect
)
def test_lineterminator(self
):
class mydialect(csv
.Dialect
):
mydialect
.lineterminator
= ":::"
mydialect
.lineterminator
= 4
self
.assertRaises(csv
.Error
, mydialect
)
class TestSniffer(unittest
.TestCase
):
Harry's, Arlington Heights, IL, 2/1/03, Kimi Hayes
Shark City, Glendale Heights, IL, 12/28/02, Prezence
Tommy's Place, Blue Island, IL, 12/28/02, Blue Sunday/White Crow
Stonecutters Seafood and Chop House, Lemont, IL, 12/19/02, Week Back
'Harry''s':'Arlington Heights':'IL':'2/1/03':'Kimi Hayes'
'Shark City':'Glendale Heights':'IL':'12/28/02':'Prezence'
'Tommy''s Place':'Blue Island':'IL':'12/28/02':'Blue Sunday/White Crow'
'Stonecutters Seafood and Chop House':'Lemont':'IL':'12/19/02':'Week Back'
"venue","city","state","date","performers"
05/05/03?05/05/03?05/05/03?05/05/03?05/05/03?05/05/03
05/05/03?05/05/03?05/05/03?05/05/03?05/05/03?05/05/03
05/05/03?05/05/03?05/05/03?05/05/03?05/05/03?05/05/03
2147483648;43.0e12;17;abc;def
147483648;43.0e2;17;abc;def
47483648;43.0;170;abc;def
def test_has_header(self
):
self
.assertEqual(sniffer
.has_header(self
.sample1
), False)
self
.assertEqual(sniffer
.has_header(self
.header
+self
.sample1
), True)
dialect
= sniffer
.sniff(self
.sample1
)
self
.assertEqual(dialect
.delimiter
, ",")
self
.assertEqual(dialect
.quotechar
, '"')
self
.assertEqual(dialect
.skipinitialspace
, True)
dialect
= sniffer
.sniff(self
.sample2
)
self
.assertEqual(dialect
.delimiter
, ":")
self
.assertEqual(dialect
.quotechar
, "'")
self
.assertEqual(dialect
.skipinitialspace
, False)
def test_delimiters(self
):
dialect
= sniffer
.sniff(self
.sample3
)
self
.assertEqual(dialect
.delimiter
, "0")
dialect
= sniffer
.sniff(self
.sample3
, delimiters
="?,")
self
.assertEqual(dialect
.delimiter
, "?")
dialect
= sniffer
.sniff(self
.sample3
, delimiters
="/,")
self
.assertEqual(dialect
.delimiter
, "/")
dialect
= sniffer
.sniff(self
.sample4
)
self
.assertEqual(dialect
.delimiter
, ";")
if not hasattr(sys
, "gettotalrefcount"):
if test_support
.verbose
: print "*** skipping leakage tests ***"
class TestLeaks(unittest
.TestCase
):
def test_create_read(self
):
lastrc
= sys
.gettotalrefcount()
self
.assertEqual(gc
.garbage
, [])
rc
= sys
.gettotalrefcount()
csv
.reader(["a,b,c\r\n"])
csv
.reader(["a,b,c\r\n"])
csv
.reader(["a,b,c\r\n"])
# if csv.reader() leaks, last delta should be 3 or more
self
.assertEqual(delta
< 3, True)
def test_create_write(self
):
lastrc
= sys
.gettotalrefcount()
self
.assertEqual(gc
.garbage
, [])
rc
= sys
.gettotalrefcount()
# if csv.writer() leaks, last delta should be 3 or more
self
.assertEqual(delta
< 3, True)
lastrc
= sys
.gettotalrefcount()
self
.assertEqual(gc
.garbage
, [])
rc
= sys
.gettotalrefcount()
# if reader leaks during read, delta should be 5 or more
self
.assertEqual(delta
< 5, True)
lastrc
= sys
.gettotalrefcount()
self
.assertEqual(gc
.garbage
, [])
rc
= sys
.gettotalrefcount()
# if writer leaks during write, last delta should be 5 or more
self
.assertEqual(delta
< 5, True)
# commented out for now - csv module doesn't yet support Unicode
## class TestUnicode(unittest.TestCase):
## def test_unicode_read(self):
## f = codecs.EncodedFile(StringIO("Martin von Löwis,"
## "François Pinard\r\n"),
## data_encoding='iso-8859-1')
## reader = csv.reader(f)
## self.assertEqual(list(reader), [[u"Martin von Löwis",
## u"Marc André Lemburg",
## u"François Pinardn"]])
mod
= sys
.modules
[__name__
]
test_support
.run_unittest(
*[getattr(mod
, name
) for name
in dir(mod
) if name
.startswith('Test')]
if __name__
== '__main__':