Lib/test/test_univnewlines.py

   1 # Tests universal newline support for both reading and parsing files.
   2
   3 from __future__ import print_function
   4 from __future__ import unicode_literals
   5
   6 import io
   7 import _pyio as pyio
   8 import unittest
   9 import os
  10 import sys
  11 from test import test_support as support
  12
  13 if not hasattr(sys.stdin, 'newlines'):
  14     raise unittest.SkipTest(
  15         "This Python does not have universal newline support")
  16
  17 FATX = 'x' * (2**14)
  18
  19 DATA_TEMPLATE = [
  20     "line1=1",
  21     "line2='this is a very long line designed to go past any default " +
  22         "buffer limits that exist in io.py but we also want to test " +
  23         "the uncommon case, naturally.'",
  24     "def line3():pass",
  25     "line4 = '%s'" % FATX,
  26     ]
  27
  28 DATA_LF = "\n".join(DATA_TEMPLATE) + "\n"
  29 DATA_CR = "\r".join(DATA_TEMPLATE) + "\r"
  30 DATA_CRLF = "\r\n".join(DATA_TEMPLATE) + "\r\n"
  31
  32 # Note that DATA_MIXED also tests the ability to recognize a lone \r
  33 # before end-of-file.
  34 DATA_MIXED = "\n".join(DATA_TEMPLATE) + "\r"
  35 DATA_SPLIT = [x + "\n" for x in DATA_TEMPLATE]
  36
  37 class TestGenericUnivNewlines(unittest.TestCase):
  38     # use a class variable DATA to define the data to write to the file
  39     # and a class variable NEWLINE to set the expected newlines value
  40     READMODE = 'r'
  41     WRITEMODE = 'wb'
  42
  43     def setUp(self):
  44         data = self.DATA
  45         if "b" in self.WRITEMODE:
  46             data = data.encode("ascii")
  47         with self.open(support.TESTFN, self.WRITEMODE) as fp:
  48             fp.write(data)
  49
  50     def tearDown(self):
  51         try:
  52             os.unlink(support.TESTFN)
  53         except:
  54             pass
  55
  56     def test_read(self):
  57         with self.open(support.TESTFN, self.READMODE) as fp:
  58             data = fp.read()
  59         self.assertEqual(data, DATA_LF)
  60         self.assertEqual(set(fp.newlines), set(self.NEWLINE))
  61
  62     def test_readlines(self):
  63         with self.open(support.TESTFN, self.READMODE) as fp:
  64             data = fp.readlines()
  65         self.assertEqual(data, DATA_SPLIT)
  66         self.assertEqual(set(fp.newlines), set(self.NEWLINE))
  67
  68     def test_readline(self):
  69         with self.open(support.TESTFN, self.READMODE) as fp:
  70             data = []
  71             d = fp.readline()
  72             while d:
  73                 data.append(d)
  74                 d = fp.readline()
  75         self.assertEqual(data, DATA_SPLIT)
  76         self.assertEqual(set(fp.newlines), set(self.NEWLINE))
  77
  78     def test_seek(self):
  79         with self.open(support.TESTFN, self.READMODE) as fp:
  80             fp.readline()
  81             pos = fp.tell()
  82             data = fp.readlines()
  83             self.assertEqual(data, DATA_SPLIT[1:])
  84             fp.seek(pos)
  85             data = fp.readlines()
  86         self.assertEqual(data, DATA_SPLIT[1:])
  87
  88
  89 class TestCRNewlines(TestGenericUnivNewlines):
  90     NEWLINE = '\r'
  91     DATA = DATA_CR
  92
  93 class TestLFNewlines(TestGenericUnivNewlines):
  94     NEWLINE = '\n'
  95     DATA = DATA_LF
  96
  97 class TestCRLFNewlines(TestGenericUnivNewlines):
  98     NEWLINE = '\r\n'
  99     DATA = DATA_CRLF
 100
 101     def test_tell(self):
 102         with self.open(support.TESTFN, self.READMODE) as fp:
 103             self.assertEqual(repr(fp.newlines), repr(None))
 104             data = fp.readline()
 105             pos = fp.tell()
 106         self.assertEqual(repr(fp.newlines), repr(self.NEWLINE))
 107
 108 class TestMixedNewlines(TestGenericUnivNewlines):
 109     NEWLINE = ('\r', '\n')
 110     DATA = DATA_MIXED
 111
 112
 113 def test_main():
 114     base_tests = (TestCRNewlines,
 115                   TestLFNewlines,
 116                   TestCRLFNewlines,
 117                   TestMixedNewlines)
 118     tests = []
 119     # Test the C and Python implementations.
 120     for test in base_tests:
 121         class CTest(test):
 122             open = io.open
 123         CTest.__name__ = str("C" + test.__name__)
 124         class PyTest(test):
 125             open = staticmethod(pyio.open)
 126         PyTest.__name__ = str("Py" + test.__name__)
 127         tests.append(CTest)
 128         tests.append(PyTest)
 129     support.run_unittest(*tests)
 130
 131 if __name__ == '__main__':
 132     test_main()