diff -r -u ..\original\py3k\Lib/mailbox.py Lib/mailbox.py
--- ..\original\py3k\Lib/mailbox.py	2008-03-26 13:48:06.917859100 +0100
+++ Lib/mailbox.py	2008-03-26 14:44:20.665576100 +0100
@@ -198,12 +198,10 @@
             gen.flatten(message)
             buffer.seek(0)
             data = buffer.read()
-            ##data = data.replace('\n', os.linesep)
             target.write(data)
         elif isinstance(message, str):
             if mangle_from_:
                 message = message.replace('\nFrom ', '\n>From ')
-            ##message = message.replace('\n', os.linesep)
             target.write(message)
         elif hasattr(message, 'read'):
             while True:
@@ -212,7 +210,6 @@
                     break
                 if mangle_from_ and line.startswith('From '):
                     line = '>From ' + line[5:]
-                ##line = line.replace('\n', os.linesep)
                 target.write(line)
         else:
             raise TypeError('Invalid message type: %s' % type(message))
@@ -311,7 +308,7 @@
     def get_message(self, key):
         """Return a Message representation or raise a KeyError."""
         subpath = self._lookup(key)
-        f = open(os.path.join(self._path, subpath), 'r')
+        f = open(os.path.join(self._path, subpath), 'r', newline='\n')
         try:
             if self._factory:
                 msg = self._factory(f)
@@ -328,7 +325,7 @@
 
     def get_string(self, key):
         """Return a string representation or raise a KeyError."""
-        f = open(os.path.join(self._path, self._lookup(key)), 'r')
+        f = open(os.path.join(self._path, self._lookup(key)), 'r', newline='\n')
         try:
             return f.read()
         finally:
@@ -336,7 +333,7 @@
 
     def get_file(self, key):
         """Return a file-like representation or raise a KeyError."""
-        f = open(os.path.join(self._path, self._lookup(key)), 'r')
+        f = open(os.path.join(self._path, self._lookup(key)), 'r', newline='\n')
         return _ProxyFile(f)
 
     def iterkeys(self):
@@ -502,15 +499,15 @@
         """Initialize a single-file mailbox."""
         Mailbox.__init__(self, path, factory, create)
         try:
-            f = open(self._path, 'r+')
+            f = open(self._path, 'r+', newline='\n')
         except IOError as e:
             if e.errno == errno.ENOENT:
                 if create:
-                    f = open(self._path, 'w+')
+                    f = open(self._path, 'w+', newline='\n')
                 else:
                     raise NoSuchMailboxError(self._path)
             elif e.errno == errno.EACCES:
-                f = open(self._path, 'r')
+                f = open(self._path, 'r', newline='\n')
             else:
                 raise
         self._file = f
@@ -676,9 +673,9 @@
         """Return a Message representation or raise a KeyError."""
         start, stop = self._lookup(key)
         self._file.seek(start)
-        from_line = self._file.readline().replace(os.linesep, '')
+        from_line = self._file.readline().replace('\n', '')
         string = self._file.read(stop - self._file.tell())
-        msg = self._message_factory(string.replace(os.linesep, '\n'))
+        msg = self._message_factory(string)
         msg.set_from(from_line[5:])
         return msg
 
@@ -689,7 +686,7 @@
         if not from_:
             self._file.readline()
         string = self._file.read(stop - self._file.tell())
-        return string.replace(os.linesep, '\n')
+        return string
 
     def get_file(self, key, from_=False):
         """Return a file-like representation or raise a KeyError."""
@@ -717,7 +714,7 @@
         if from_line is None:
             from_line = 'From MAILER-DAEMON %s' % time.asctime(time.gmtime())
         start = self._file.tell()
-        self._file.write(from_line + os.linesep)
+        self._file.write(from_line + '\n')
         self._dump_message(message, self._file, self._mangle_from_)
         stop = self._file.tell()
         return (start, stop)
@@ -736,7 +733,7 @@
     def _pre_message_hook(self, f):
         """Called before writing each message to file f."""
         if f.tell() != 0:
-            f.write(os.linesep)
+            f.write('\n')
 
     def _generate_toc(self):
         """Generate key-to-(start, stop) table of contents."""
@@ -747,7 +744,7 @@
             line = self._file.readline()
             if line.startswith('From '):
                 if len(stops) < len(starts):
-                    stops.append(line_pos - len(os.linesep))
+                    stops.append(line_pos - 1)
                 starts.append(line_pos)
             elif not line:
                 stops.append(line_pos)
@@ -767,11 +764,11 @@
 
     def _pre_message_hook(self, f):
         """Called before writing each message to file f."""
-        f.write('\001\001\001\001' + os.linesep)
+        f.write('\001\001\001\001\n')
 
     def _post_message_hook(self, f):
         """Called after writing each message to file f."""
-        f.write(os.linesep + '\001\001\001\001' + os.linesep)
+        f.write('\n\001\001\001\001\n')
 
     def _generate_toc(self):
         """Generate key-to-(start, stop) table of contents."""
@@ -782,14 +779,14 @@
             line_pos = next_pos
             line = self._file.readline()
             next_pos = self._file.tell()
-            if line.startswith('\001\001\001\001' + os.linesep):
+            if line.startswith('\001\001\001\001\n'):
                 starts.append(next_pos)
                 while True:
                     line_pos = next_pos
                     line = self._file.readline()
                     next_pos = self._file.tell()
-                    if line == '\001\001\001\001' + os.linesep:
-                        stops.append(line_pos - len(os.linesep))
+                    if line == '\001\001\001\001\n':
+                        stops.append(line_pos - 1)
                         break
                     elif not line:
                         stops.append(line_pos)
@@ -866,7 +863,7 @@
         """Replace the keyed message; raise KeyError if it doesn't exist."""
         path = os.path.join(self._path, str(key))
         try:
-            f = open(path, 'r+')
+            f = open(path, 'r+', newline='\n')
         except IOError as e:
             if e.errno == errno.ENOENT:
                 raise KeyError('No message with key: %s' % key)
@@ -890,9 +887,9 @@
         """Return a Message representation or raise a KeyError."""
         try:
             if self._locked:
-                f = open(os.path.join(self._path, str(key)), 'r+')
+                f = open(os.path.join(self._path, str(key)), 'r+', newline='\n')
             else:
-                f = open(os.path.join(self._path, str(key)), 'r')
+                f = open(os.path.join(self._path, str(key)), 'r', newline='\n')
         except IOError as e:
             if e.errno == errno.ENOENT:
                 raise KeyError('No message with key: %s' % key)
@@ -917,9 +914,9 @@
         """Return a string representation or raise a KeyError."""
         try:
             if self._locked:
-                f = open(os.path.join(self._path, str(key)), 'r+')
+                f = open(os.path.join(self._path, str(key)), 'r+', newline='\n')
             else:
-                f = open(os.path.join(self._path, str(key)), 'r')
+                f = open(os.path.join(self._path, str(key)), 'r', newline='\n')
         except IOError as e:
             if e.errno == errno.ENOENT:
                 raise KeyError('No message with key: %s' % key)
@@ -939,7 +936,7 @@
     def get_file(self, key):
         """Return a file-like representation or raise a KeyError."""
         try:
-            f = open(os.path.join(self._path, str(key)), 'r')
+            f = open(os.path.join(self._path, str(key)), 'r', newline='\n')
         except IOError as e:
             if e.errno == errno.ENOENT:
                 raise KeyError('No message with key: %s' % key)
@@ -1017,7 +1014,7 @@
     def get_sequences(self):
         """Return a name-to-key-list dictionary to define each sequence."""
         results = {}
-        f = open(os.path.join(self._path, '.mh_sequences'), 'r')
+        f = open(os.path.join(self._path, '.mh_sequences'), 'r', newline='\n')
         try:
             all_keys = set(self.keys())
             for line in f:
@@ -1043,7 +1040,7 @@
 
     def set_sequences(self, sequences):
         """Set sequences using the given name-to-key-list dictionary."""
-        f = open(os.path.join(self._path, '.mh_sequences'), 'r+')
+        f = open(os.path.join(self._path, '.mh_sequences'), 'r+', newline='\n')
         try:
             os.close(os.open(f.name, os.O_WRONLY | os.O_TRUNC))
             for name, keys in sequences.items():
@@ -1148,17 +1145,16 @@
         original_headers = io.StringIO()
         while True:
             line = self._file.readline()
-            if line == '*** EOOH ***' + os.linesep or not line:
+            if line == '*** EOOH ***\n' or not line:
                 break
-            original_headers.write(line.replace(os.linesep, '\n'))
+            original_headers.write(line)
         visible_headers = io.StringIO()
         while True:
             line = self._file.readline()
-            if line == os.linesep or not line:
+            if line == '\n' or not line:
                 break
-            visible_headers.write(line.replace(os.linesep, '\n'))
-        body = self._file.read(stop - self._file.tell()).replace(os.linesep,
-                                                                 '\n')
+            visible_headers.write(line)
+        body = self._file.read(stop - self._file.tell())
         msg = BabylMessage(original_headers.getvalue() + body)
         msg.set_visible(visible_headers.getvalue())
         if key in self._labels:
@@ -1173,21 +1169,19 @@
         original_headers = io.StringIO()
         while True:
             line = self._file.readline()
-            if line == '*** EOOH ***' + os.linesep or not line:
+            if line == '*** EOOH ***\n' or not line:
                 break
-            original_headers.write(line.replace(os.linesep, '\n'))
+            original_headers.write(line)
         while True:
             line = self._file.readline()
-            if line == os.linesep or not line:
+            if line == '\n' or not line:
                 break
         return original_headers.getvalue() + \
-               self._file.read(stop - self._file.tell()).replace(os.linesep,
-                                                                 '\n')
+               self._file.read(stop - self._file.tell())
 
     def get_file(self, key):
         """Return a file-like representation or raise a KeyError."""
-        return io.StringIO(self.get_string(key).replace('\n',
-                                                              os.linesep))
+        return io.StringIO(self.get_string(key))
 
     def get_labels(self):
         """Return a list of user-defined labels in the mailbox."""
@@ -1208,19 +1202,19 @@
             line_pos = next_pos
             line = self._file.readline()
             next_pos = self._file.tell()
-            if line == '\037\014' + os.linesep:
+            if line == '\037\014\n':
                 if len(stops) < len(starts):
-                    stops.append(line_pos - len(os.linesep))
+                    stops.append(line_pos - 1)
                 starts.append(next_pos)
                 labels = [label.strip() for label
                                         in self._file.readline()[1:].split(',')
                                         if label.strip()]
                 label_lists.append(labels)
-            elif line == '\037' or line == '\037' + os.linesep:
+            elif line == '\037' or line == '\037\n':
                 if len(stops) < len(starts):
-                    stops.append(line_pos - len(os.linesep))
+                    stops.append(line_pos - 1)
             elif not line:
-                stops.append(line_pos - len(os.linesep))
+                stops.append(line_pos - 1)
                 break
         self._toc = dict(enumerate(zip(starts, stops)))
         self._labels = dict(enumerate(label_lists))
@@ -1230,17 +1224,16 @@
 
     def _pre_mailbox_hook(self, f):
         """Called before writing the mailbox to file f."""
-        f.write('BABYL OPTIONS:%sVersion: 5%sLabels:%s%s\037' %
-                (os.linesep, os.linesep, ','.join(self.get_labels()),
-                 os.linesep))
+        f.write('BABYL OPTIONS:\nVersion: 5\nLabels:%s\n\037' %
+                ','.join(self.get_labels()))
 
     def _pre_message_hook(self, f):
         """Called before writing each message to file f."""
-        f.write('\014' + os.linesep)
+        f.write('\014\n')
 
     def _post_message_hook(self, f):
         """Called after writing each message to file f."""
-        f.write(os.linesep + '\037')
+        f.write('\n\037')
 
     def _install_message(self, message):
         """Write message contents and return (start, stop)."""
@@ -1259,9 +1252,9 @@
             self._file.write(',,')
             for label in labels:
                 self._file.write(' ' + label + ',')
-            self._file.write(os.linesep)
+            self._file.write('\n')
         else:
-            self._file.write('1,,' + os.linesep)
+            self._file.write('1,,\n')
         if isinstance(message, email.message.Message):
             orig_buffer = io.StringIO()
             orig_generator = email.generator.Generator(orig_buffer, False, 0)
@@ -1269,52 +1262,49 @@
             orig_buffer.seek(0)
             while True:
                 line = orig_buffer.readline()
-                self._file.write(line.replace('\n', os.linesep))
+                self._file.write(line)
                 if line == '\n' or not line:
                     break
-            self._file.write('*** EOOH ***' + os.linesep)
+            self._file.write('*** EOOH ***\n')
             if isinstance(message, BabylMessage):
                 vis_buffer = io.StringIO()
                 vis_generator = email.generator.Generator(vis_buffer, False, 0)
                 vis_generator.flatten(message.get_visible())
                 while True:
                     line = vis_buffer.readline()
-                    self._file.write(line.replace('\n', os.linesep))
+                    self._file.write(line)
                     if line == '\n' or not line:
                         break
             else:
                 orig_buffer.seek(0)
                 while True:
                     line = orig_buffer.readline()
-                    self._file.write(line.replace('\n', os.linesep))
+                    self._file.write(line)
                     if line == '\n' or not line:
                         break
             while True:
                 buffer = orig_buffer.read(4096) # Buffer size is arbitrary.
                 if not buffer:
                     break
-                self._file.write(buffer.replace('\n', os.linesep))
+                self._file.write(buffer)
         elif isinstance(message, str):
             body_start = message.find('\n\n') + 2
             if body_start - 2 != -1:
-                self._file.write(message[:body_start].replace('\n',
-                                                              os.linesep))
-                self._file.write('*** EOOH ***' + os.linesep)
-                self._file.write(message[:body_start].replace('\n',
-                                                              os.linesep))
-                self._file.write(message[body_start:].replace('\n',
-                                                              os.linesep))
+                self._file.write(message[:body_start])
+                self._file.write('*** EOOH ***\n')
+                self._file.write(message[:body_start])
+                self._file.write(message[body_start:])
             else:
-                self._file.write('*** EOOH ***' + os.linesep + os.linesep)
-                self._file.write(message.replace('\n', os.linesep))
+                self._file.write('*** EOOH ***\n\n')
+                self._file.write(message)
         elif hasattr(message, 'readline'):
             original_pos = message.tell()
             first_pass = True
             while True:
                 line = message.readline()
-                self._file.write(line.replace('\n', os.linesep))
+                self._file.write(line)
                 if line == '\n' or not line:
-                    self._file.write('*** EOOH ***' + os.linesep)
+                    self._file.write('*** EOOH ***\n')
                     if first_pass:
                         first_pass = False
                         message.seek(original_pos)
@@ -1324,7 +1314,7 @@
                 buffer = message.read(4096)     # Buffer size is arbitrary.
                 if not buffer:
                     break
-                self._file.write(buffer.replace('\n', os.linesep))
+                self._file.write(buffer)
         else:
             raise TypeError('Invalid message type: %s' % type(message))
         stop = self._file.tell()
@@ -1904,7 +1894,7 @@
     """Create a file if it doesn't exist and open for reading and writing."""
     fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDWR)
     try:
-        return open(path, 'r+')
+        return open(path, 'r+', newline='\n')
     finally:
         os.close(fd)
 
@@ -2072,7 +2062,7 @@
         if not self.boxes:
             return None
         fn = self.boxes.pop()
-        fp = open(os.path.join(self.dirname, fn))
+        fp = open(os.path.join(self.dirname, fn), newline='\n')
         msg = self.factory(fp)
         try:
             msg._mh_msgno = fn
diff -r -u ..\original\py3k\Lib/test/test_mailbox.py Lib/test/test_mailbox.py
--- ..\original\py3k\Lib/test/test_mailbox.py	2008-03-26 13:48:57.369825900 +0100
+++ Lib/test/test_mailbox.py	2008-03-26 14:43:06.157248400 +0100
@@ -170,10 +170,8 @@
         key1 = self._box.add(_sample_message)
         data0 = self._box.get_file(key0).read()
         data1 = self._box.get_file(key1).read()
-        self.assertEqual(data0.replace(os.linesep, '\n'),
-                         self._template % 0)
-        self.assertEqual(data1.replace(os.linesep, '\n'),
-                         _sample_message)
+        self.assertEqual(data0, self._template % 0)
+        self.assertEqual(data1, _sample_message)
 
     def test_iterkeys(self):
         # Get keys using iterkeys()
@@ -408,8 +406,7 @@
                       _sample_message, io.StringIO(_sample_message)):
             output = io.StringIO()
             self._box._dump_message(input, output)
-            self.assertEqual(output.getvalue(),
-                         _sample_message.replace('\n', os.linesep))
+            self.assertEqual(output.getvalue(), _sample_message)
         output = io.StringIO()
         self.assertRaises(TypeError,
                           lambda: self._box._dump_message(None, output))
@@ -591,10 +588,10 @@
         # Remove old files from 'tmp'
         foo_path = os.path.join(self._path, 'tmp', 'foo')
         bar_path = os.path.join(self._path, 'tmp', 'bar')
-        f = open(foo_path, 'w')
+        f = open(foo_path, 'w', newline='\n')
         f.write("@")
         f.close()
-        f = open(bar_path, 'w')
+        f = open(bar_path, 'w', newline='\n')
         f.write("@")
         f.close()
         self._box.clean()
@@ -755,7 +752,7 @@
         self._box._file.seek(0)
         contents = self._box._file.read()
         self._box.close()
-        self.assertEqual(contents, open(self._path, 'r').read())
+        self.assertEqual(contents, open(self._path, 'r', newline='\n').read())
         self._box = self._factory(self._path)
 
     def test_lock_conflict(self):
@@ -986,7 +983,7 @@
 
     def test_initialize_with_file(self):
         # Initialize based on contents of file
-        f = open(self._path, 'w+')
+        f = open(self._path, 'w+', newline='\n')
         f.write(_sample_message)
         f.seek(0)
         msg = self._factory(f)
@@ -1517,59 +1514,54 @@
 
     def _test_readline(self, proxy):
         # Read by line
-        linesep = os.linesep.encode()
         proxy.seek(0)
-        self.assertEqual(proxy.readline(), b'foo' + linesep)
-        self.assertEqual(proxy.readline(), b'bar' + linesep)
-        self.assertEqual(proxy.readline(), b'fred' + linesep)
+        self.assertEqual(proxy.readline(), b'foo\n')
+        self.assertEqual(proxy.readline(), b'bar\n')
+        self.assertEqual(proxy.readline(), b'fred\n')
         self.assertEqual(proxy.readline(), b'bob')
         proxy.seek(2)
-        self.assertEqual(proxy.readline(), b'o' + linesep)
-        proxy.seek(6 + 2 * len(os.linesep))
-        self.assertEqual(proxy.readline(), b'fred' + linesep)
-        proxy.seek(6 + 2 * len(os.linesep))
+        self.assertEqual(proxy.readline(), b'o\n')
+        proxy.seek(8)
+        self.assertEqual(proxy.readline(), b'fred\n')
+        proxy.seek(8)
         self.assertEqual(proxy.readline(2), b'fr')
-        self.assertEqual(proxy.readline(-10), b'ed' + linesep)
+        self.assertEqual(proxy.readline(-10), b'ed\n')
 
     def _test_readlines(self, proxy):
         # Read multiple lines
-        linesep = os.linesep.encode()
         proxy.seek(0)
-        self.assertEqual(proxy.readlines(), [b'foo' + linesep,
-                                           b'bar' + linesep,
-                                           b'fred' + linesep, b'bob'])
+        self.assertEqual(proxy.readlines(), [b'foo\n',
+                                           b'bar\n',
+                                           b'fred\n', b'bob'])
         proxy.seek(0)
-        self.assertEqual(proxy.readlines(2), [b'foo' + linesep])
-        proxy.seek(3 + len(linesep))
-        self.assertEqual(proxy.readlines(4 + len(linesep)),
-                     [b'bar' + linesep, b'fred' + linesep])
+        self.assertEqual(proxy.readlines(2), [b'foo\n'])
+        proxy.seek(4)
+        self.assertEqual(proxy.readlines(5), [b'bar\n', b'fred\n'])
         proxy.seek(3)
-        self.assertEqual(proxy.readlines(1000), [linesep, b'bar' + linesep,
-                                               b'fred' + linesep, b'bob'])
+        self.assertEqual(proxy.readlines(1000), [b'\n', b'bar\n',
+                                                 b'fred\n', b'bob'])
 
     def _test_iteration(self, proxy):
         # Iterate by line
-        linesep = os.linesep.encode()
         proxy.seek(0)
         iterator = iter(proxy)
-        self.assertEqual(next(iterator), b'foo' + linesep)
-        self.assertEqual(next(iterator), b'bar' + linesep)
-        self.assertEqual(next(iterator), b'fred' + linesep)
+        self.assertEqual(next(iterator), b'foo\n')
+        self.assertEqual(next(iterator), b'bar\n')
+        self.assertEqual(next(iterator), b'fred\n')
         self.assertEqual(next(iterator), b'bob')
         self.assertRaises(StopIteration, next, iterator)
 
     def _test_seek_and_tell(self, proxy):
         # Seek and use tell to check position
-        linesep = os.linesep.encode()
         proxy.seek(3)
         self.assertEqual(proxy.tell(), 3)
-        self.assertEqual(proxy.read(len(linesep)), linesep)
+        self.assertEqual(proxy.read(1), b'\n')
         proxy.seek(2, 1)
-        self.assertEqual(proxy.read(1 + len(linesep)), b'r' + linesep)
-        proxy.seek(-3 - len(linesep), 2)
+        self.assertEqual(proxy.read(2), b'r\n')
+        proxy.seek(-4, 2)
         self.assertEqual(proxy.read(3), b'bar')
         proxy.seek(2, 0)
-        self.assertEqual(proxy.read(), b'o' + linesep + b'bar' + linesep)
+        self.assertEqual(proxy.read(), b'o\nbar\n')
         proxy.seek(100)
         self.failIf(proxy.read())
 
@@ -1605,26 +1597,23 @@
         self._test_read(mailbox._ProxyFile(self._file))
 
     def test_readline(self):
-        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
-                                                  os.linesep), 'ascii'))
+        self._file.write(b'foo\nbar\nfred\nbob')
         self._test_readline(mailbox._ProxyFile(self._file))
 
     def test_readlines(self):
-        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
-                                                  os.linesep), 'ascii'))
+        self._file.write(b'foo\nbar\nfred\nbob')
         self._test_readlines(mailbox._ProxyFile(self._file))
 
     def test_iteration(self):
-        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
-                                                  os.linesep), 'ascii'))
+        self._file.write(b'foo\nbar\nfred\nbob')
         self._test_iteration(mailbox._ProxyFile(self._file))
 
     def test_seek_and_tell(self):
-        self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
+        self._file.write(b'foo\nbar\n')
         self._test_seek_and_tell(mailbox._ProxyFile(self._file))
 
     def test_close(self):
-        self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
+        self._file.write(b'foo\nbar\n')
         self._test_close(mailbox._ProxyFile(self._file))
 
 
@@ -1640,43 +1629,35 @@
 
     def test_initialize(self):
         # Initialize and check position
-        self._file.write(bytes('foo' + os.linesep + 'bar', 'ascii'))
+        self._file.write(b'foo\nbar')
         pos = self._file.tell()
         proxy = mailbox._PartialFile(self._file, 2, 5)
         self.assertEqual(proxy.tell(), 0)
         self.assertEqual(self._file.tell(), pos)
 
     def test_read(self):
-        self._file.write(bytes('***bar***', 'ascii'))
+        self._file.write(b'***bar***')
         self._test_read(mailbox._PartialFile(self._file, 3, 6))
 
     def test_readline(self):
-        self._file.write(bytes('!!!!!foo%sbar%sfred%sbob!!!!!' %
-                         (os.linesep, os.linesep, os.linesep), 'ascii'))
-        self._test_readline(mailbox._PartialFile(self._file, 5,
-                                                 18 + 3 * len(os.linesep)))
+        self._file.write(b'!!!!!foo\nbar\nfred\nbob!!!!!')
+        self._test_readline(mailbox._PartialFile(self._file, 5, 21))
 
     def test_readlines(self):
-        self._file.write(bytes('foo%sbar%sfred%sbob?????' %
-                         (os.linesep, os.linesep, os.linesep), 'ascii'))
-        self._test_readlines(mailbox._PartialFile(self._file, 0,
-                                                  13 + 3 * len(os.linesep)))
+        self._file.write(b'foo\nbar\nfred\nbob?????')
+        self._test_readlines(mailbox._PartialFile(self._file, 0, 16))
 
     def test_iteration(self):
-        self._file.write(bytes('____foo%sbar%sfred%sbob####' %
-                         (os.linesep, os.linesep, os.linesep), 'ascii'))
-        self._test_iteration(mailbox._PartialFile(self._file, 4,
-                                                  17 + 3 * len(os.linesep)))
+        self._file.write(b'____foo\nbar\nfred\nbob####')
+        self._test_iteration(mailbox._PartialFile(self._file, 4, 20))
 
     def test_seek_and_tell(self):
-        self._file.write(bytes('(((foo%sbar%s$$$' % (os.linesep, os.linesep), 'ascii'))
-        self._test_seek_and_tell(mailbox._PartialFile(self._file, 3,
-                                                      9 + 2 * len(os.linesep)))
+        self._file.write(b'(((foo\nbar\n$$$')
+        self._test_seek_and_tell(mailbox._PartialFile(self._file, 3, 11))
 
     def test_close(self):
-        self._file.write(bytes('&foo%sbar%s^' % (os.linesep, os.linesep), 'ascii'))
-        self._test_close(mailbox._PartialFile(self._file, 1,
-                                              6 + 3 * len(os.linesep)))
+        self._file.write(b'&foo\nbar\n^')
+        self._test_close(mailbox._PartialFile(self._file, 1, 9))
 
 
 ## Start: tests from the original module (for backward compatibility).
@@ -1716,7 +1697,7 @@
         filename = ".".join((str(t), str(pid), "myhostname", "mydomain"))
         tmpname = os.path.join(self._dir, "tmp", filename)
         newname = os.path.join(self._dir, dir, filename)
-        fp = open(tmpname, "w")
+        fp = open(tmpname, "w", newline='\n')
         self._msgfiles.append(tmpname)
         if mbox:
             fp.write(FROM_)
@@ -1725,7 +1706,7 @@
         if hasattr(os, "link"):
             os.link(tmpname, newname)
         else:
-            fp = open(newname, "w")
+            fp = open(newname, "w", newline='\n')
             fp.write(DUMMY_MESSAGE)
             fp.close()
         self._msgfiles.append(newname)
@@ -1772,7 +1753,7 @@
         import email.parser
         fname = self.createMessage("cur", True)
         n = 0
-        for msg in mailbox.PortableUnixMailbox(open(fname),
+        for msg in mailbox.PortableUnixMailbox(open(fname, newline='\n'),
                                                email.parser.Parser().parse):
             n += 1
             self.assertEqual(msg["subject"], "Simple Test")