def test_builtin_map(self):
self.assertEqual(yp_list(yp_map(lambda x: x + 1, SequenceClass(5))),
yp_list(yp_range(1, 6)))
d = yp_dict({"one": 1, "two": 2, "three": 3})
self.assertEqual(yp_list(yp_map(lambda k, d=d: (k, d[k]), d)),
yp_list(d.items()))
dkeys = yp_list(d.keys())
expected = [(i < len(d) and dkeys[i]
or None, i, i < len(d) and dkeys[i] or None)
for i in range(3)]
f = open(TESTFN, "w", encoding="utf-8")
try:
for i in range(10):
f.write("xy" * i + "\n") # line i has len 2*i+1
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
self.assertEqual(yp_list(yp_map(len, f)),
yp_list(yp_range(1, 21, 2)))
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_builtin_max_min(self):
self.assertEqual(yp_max(SequenceClass(5)), 4)
self.assertEqual(yp_min(SequenceClass(5)), 0)
self.assertEqual(yp_max(8, -1), 8)
self.assertEqual(yp_min(8, -1), -1)
d = yp_dict({"one": 1, "two": 2, "three": 3})
self.assertEqual(yp_max(d), "two")
self.assertEqual(yp_min(d), "one")
self.assertEqual(yp_max(d.values()), 3)
self.assertEqual(yp_min(yp_iter(d.values())), 1)
f = open(TESTFN, "w", encoding="utf-8")
try:
f.write("medium line\n")
f.write("xtra large line\n")
f.write("itty-bitty line\n")
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
self.assertEqual(yp_min(f), "itty-bitty line\n")
f.seek(0, 0)
self.assertEqual(yp_max(f), "xtra large line\n")
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def restore_files(self, saved_value):
fn = os_helper.TESTFN
if fn not in saved_value and (fn + '/') not in saved_value:
if os.path.isfile(fn):
os_helper.unlink(fn)
elif os.path.isdir(fn):
os_helper.rmtree(fn)
def test_builtin_tuple(self):
self.assertEqual(yp_tuple(SequenceClass(5)), (0, 1, 2, 3, 4))
self.assertEqual(yp_tuple(SequenceClass(0)), ())
self.assertEqual(yp_tuple(yp_list()), ())
self.assertEqual(yp_tuple(), ())
self.assertEqual(yp_tuple(yp_str("abc")), ("a", "b", "c"))
d = yp_dict({"one": 1, "two": 2, "three": 3})
self.assertEqual(yp_tuple(d), yp_tuple(d.keys()))
self.assertRaises(TypeError, yp_tuple, yp_list)
self.assertRaises(TypeError, yp_tuple, 42)
f = open(TESTFN, "w", encoding="utf-8")
try:
for i in range(5):
f.write("%d\n" % i)
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
self.assertEqual(yp_tuple(f), ("0\n", "1\n", "2\n", "3\n", "4\n"))
f.seek(0, 0)
self.assertEqual(yp_tuple(f), ("0\n", "1\n", "2\n", "3\n", "4\n"))
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_write_object_to_file(self):
obj = ('\u20ac', b'abc', 123, 45.6, 7 + 8j, 'long line ' * 1000)
for v in range(marshal.version + 1):
_testcapi.pymarshal_write_object_to_file(obj, os_helper.TESTFN, v)
with open(os_helper.TESTFN, 'rb') as f:
data = f.read()
os_helper.unlink(os_helper.TESTFN)
self.assertEqual(marshal.loads(data), obj)
def test_write_long_to_file(self):
for v in range(marshal.version + 1):
_testcapi.pymarshal_write_long_to_file(0x12345678,
os_helper.TESTFN, v)
with open(os_helper.TESTFN, 'rb') as f:
data = f.read()
os_helper.unlink(os_helper.TESTFN)
self.assertEqual(data, b'\x78\x56\x34\x12')
def helper(self, sample, *extra):
new = marshal.loads(marshal.dumps(sample, *extra))
self.assertEqual(sample, new)
try:
with open(os_helper.TESTFN, "wb") as f:
marshal.dump(sample, f, *extra)
with open(os_helper.TESTFN, "rb") as f:
new = marshal.load(f)
self.assertEqual(sample, new)
finally:
os_helper.unlink(os_helper.TESTFN)
def cleanup(self):
import glob
path = os.path.join(glob.escape(self.tmp_dir), 'test_python_*')
print("Cleanup %s directory" % self.tmp_dir)
for name in glob.glob(path):
if os.path.isdir(name):
print("Remove directory: %s" % name)
os_helper.rmtree(name)
else:
print("Remove file: %s" % name)
os_helper.unlink(name)
def test_read_long_from_file(self):
with open(os_helper.TESTFN, 'wb') as f:
f.write(b'\x78\x56\x34\x12xxxx')
r, p = _testcapi.pymarshal_read_long_from_file(os_helper.TESTFN)
os_helper.unlink(os_helper.TESTFN)
self.assertEqual(r, 0x12345678)
self.assertEqual(p, 4)
with open(os_helper.TESTFN, 'wb') as f:
f.write(b'\x56\x34\x12')
with self.assertRaises(EOFError):
_testcapi.pymarshal_read_long_from_file(os_helper.TESTFN)
os_helper.unlink(os_helper.TESTFN)
def test_unpack_iter(self):
a, b = 1, 2
self.assertEqual((a, b), (1, 2))
a, b, c = IteratingSequenceClass(3)
self.assertEqual((a, b, c), (0, 1, 2))
try: # too many values
a, b = IteratingSequenceClass(3)
except ValueError:
pass
else:
self.fail("should have raised ValueError")
try: # not enough values
a, b, c = IteratingSequenceClass(2)
except ValueError:
pass
else:
self.fail("should have raised ValueError")
try: # not iterable
a, b, c = yp_len
except TypeError:
pass
else:
self.fail("should have raised TypeError")
a, b, c = {1: 42, 2: 42, 3: 42}.values()
self.assertEqual((a, b, c), (42, 42, 42))
f = open(TESTFN, "w", encoding="utf-8")
lines = ("a\n", "bb\n", "ccc\n")
try:
for line in lines:
f.write(line)
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
a, b, c = f
self.assertEqual((a, b, c), lines)
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
(a, b), (c, ) = IteratingSequenceClass(2), {42: 24}
self.assertEqual((a, b, c), (0, 1, 42))
def test_writelines(self):
f = open(TESTFN, "w", encoding="utf-8")
try:
self.assertRaises(TypeError, f.writelines, None)
self.assertRaises(TypeError, f.writelines, 42)
f.writelines(yp_list(["1\n", "2\n"]))
f.writelines(yp_tuple(("3\n", "4\n")))
f.writelines(yp_dict({'5\n': None}))
f.writelines(yp_dict())
# Try a big chunk too.
class Iterator:
def __init__(self, start, finish):
self.start = start
self.finish = finish
self.i = self.start
def __next__(self):
if self.i >= self.finish:
raise StopIteration
result = yp_str(self.i) + '\n'
self.i += 1
return result
def __iter__(self):
return self
class Whatever:
def __init__(self, start, finish):
self.start = start
self.finish = finish
def __iter__(self):
return Iterator(self.start, self.finish)
f.writelines(Whatever(6, 6 + 2000))
f.close()
f = open(TESTFN, encoding="utf-8")
expected = [yp_str(i) + "\n" for i in range(1, 2006)]
self.assertEqual(yp_list(f), expected)
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_read_object_from_file(self):
obj = ('\u20ac', b'abc', 123, 45.6, 7 + 8j)
for v in range(marshal.version + 1):
data = marshal.dumps(obj, v)
with open(os_helper.TESTFN, 'wb') as f:
f.write(data + b'xxxx')
r, p = _testcapi.pymarshal_read_object_from_file(os_helper.TESTFN)
os_helper.unlink(os_helper.TESTFN)
self.assertEqual(r, obj)
self.assertEqual(p, len(data))
with open(os_helper.TESTFN, 'wb') as f:
f.write(data[:1])
with self.assertRaises(EOFError):
_testcapi.pymarshal_read_object_from_file(os_helper.TESTFN)
os_helper.unlink(os_helper.TESTFN)
def test_countOf_file(self):
f = open(TESTFN, "w", encoding="utf-8")
try:
f.write("a\n" "b\n" "c\n" "b\n")
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
for letter, count in yp_tuple(
(("a", 1), ("b", 2), ("c", 1), ("d", 0))):
f.seek(0, 0)
self.assertEqual(countOf(f, letter + "\n"), count)
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_iter_file(self):
f = open(TESTFN, "w", encoding="utf-8")
try:
for i in range(5):
f.write("%d\n" % i)
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
self.check_for_loop(f, ["0\n", "1\n", "2\n", "3\n", "4\n"],
pickle=False)
self.check_for_loop(f, [], pickle=False)
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_indexOf_file(self):
f = open(TESTFN, "w", encoding="utf-8")
try:
f.write("a\n" "b\n" "c\n" "d\n" "e\n")
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
fiter = yp_iter(f)
self.assertEqual(indexOf(fiter, "b\n"), 1)
self.assertEqual(indexOf(fiter, "d\n"), 1)
self.assertEqual(indexOf(fiter, "e\n"), 0)
self.assertRaises(ValueError, indexOf, fiter, "a\n")
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_in_and_not_in_file(self):
f = open(TESTFN, "w", encoding="utf-8")
try:
f.write("a\n" "b\n" "c\n")
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
for chunk in yp_str("abc"):
f.seek(0, 0)
self.assertNotIn(chunk, f)
f.seek(0, 0)
self.assertIn((chunk + "\n"), f)
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_unicode_join_endcase(self):
# This class inserts a Unicode object into its argument's natural
# iteration, in the 3rd position.
class OhPhooey:
def __init__(self, seq):
self.it = yp_iter(seq)
self.i = 0
def __iter__(self):
return self
def __next__(self):
i = self.i
self.i = i + 1
if i == 2:
return yp_str("fooled you!")
return next(self.it)
f = open(TESTFN, "w", encoding="utf-8")
try:
f.write("a\n" + "b\n" + "c\n")
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
# Nasty: string.join(s) can't know whether unicode.join() is needed
# until it's seen all of s's elements. But in this case, f's
# iterator cannot be restarted. So what we're testing here is
# whether string.join() can manage to remember everything it's seen
# and pass that on to unicode.join().
try:
got = yp_str(" - ").join(OhPhooey(f))
self.assertEqual(got, "a\n - b\n - fooled you! - c\n")
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
def test_multiple_dumps_and_loads(self):
# Issue 12291: marshal.load() should be callable multiple times
# with interleaved data written by non-marshal code
# Adapted from a patch by Engelbert Gruber.
data = (1, 'abc', b'def', 1.0, (2, 'a', ['b', b'c']))
for interleaved in (b'', b'0123'):
ilen = len(interleaved)
positions = []
try:
with open(os_helper.TESTFN, 'wb') as f:
for d in data:
marshal.dump(d, f)
if ilen:
f.write(interleaved)
positions.append(f.tell())
with open(os_helper.TESTFN, 'rb') as f:
for i, d in enumerate(data):
self.assertEqual(d, marshal.load(f))
if ilen:
f.read(ilen)
self.assertEqual(positions[i], f.tell())
finally:
os_helper.unlink(os_helper.TESTFN)
def tearDown(self):
os_helper.unlink(TESTFN)
def test_builtin_zip(self):
self.assertEqual(yp_list(zip()), [])
self.assertEqual(yp_list(zip(*yp_list())), [])
self.assertEqual(yp_list(zip(*yp_list([(1, 2), 'ab']))), [(1, 'a'),
(2, 'b')])
self.assertRaises(TypeError, zip, None)
self.assertRaises(TypeError, zip, yp_range(10), 42)
self.assertRaises(TypeError, zip, yp_range(10), zip)
self.assertEqual(yp_list(zip(IteratingSequenceClass(3))),
[(0, ), (1, ), (2, )])
self.assertEqual(yp_list(zip(SequenceClass(3))), [(0, ), (1, ), (2, )])
d = yp_dict({"one": 1, "two": 2, "three": 3})
self.assertEqual(yp_list(d.items()), yp_list(zip(d, d.values())))
# Generate all ints starting at constructor arg.
class IntsFrom:
def __init__(self, start):
self.i = start
def __iter__(self):
return self
def __next__(self):
i = self.i
self.i = i + 1
return i
f = open(TESTFN, "w", encoding="utf-8")
try:
f.write("a\n" "bbb\n" "cc\n")
finally:
f.close()
f = open(TESTFN, "r", encoding="utf-8")
try:
self.assertEqual(yp_list(zip(IntsFrom(0), f, IntsFrom(-100))),
[(0, "a\n", -100), (1, "bbb\n", -99),
(2, "cc\n", -98)])
finally:
f.close()
try:
unlink(TESTFN)
except OSError:
pass
self.assertEqual(yp_list(zip(yp_range(5))),
[(i, ) for i in yp_range(5)])
# Classes that lie about their lengths.
class NoGuessLen5:
def __getitem__(self, i):
if i >= 5:
raise IndexError
return i
class Guess3Len5(NoGuessLen5):
def __len__(self):
return 3
class Guess30Len5(NoGuessLen5):
def __len__(self):
return 30
def lzip(*args):
return yp_list(zip(*args))
self.assertEqual(yp_len(Guess3Len5()), 3)
self.assertEqual(yp_len(Guess30Len5()), 30)
self.assertEqual(lzip(NoGuessLen5()), lzip(yp_range(5)))
self.assertEqual(lzip(Guess3Len5()), lzip(yp_range(5)))
self.assertEqual(lzip(Guess30Len5()), lzip(yp_range(5)))
expected = [(i, i) for i in yp_range(5)]
for x in NoGuessLen5(), Guess3Len5(), Guess30Len5():
for y in NoGuessLen5(), Guess3Len5(), Guess30Len5():
self.assertEqual(lzip(x, y), expected)
def tearDown(self):
if self.f:
self.f.close()
os_helper.unlink(TESTFN)
def restore_urllib_requests__url_tempfiles(self, tempfiles):
for filename in tempfiles:
os_helper.unlink(filename)