Lines Matching refs:self
34 def setUp(self):
38 def tearDown(self):
44 def test_basic(self):
62 self.assertEqual(m.find(b'foo'), PAGESIZE)
64 self.assertEqual(len(m), 2*PAGESIZE)
66 self.assertEqual(m[0], 0)
67 self.assertEqual(m[0:3], b'\0\0\0')
70 self.assertRaises(IndexError, m.__getitem__, len(m))
71 self.assertRaises(IndexError, m.__setitem__, len(m), b'\0')
78 self.assertEqual(m[0], b'3'[0])
79 self.assertEqual(m[0:3], b'3\0\0')
80 self.assertEqual(m[PAGESIZE-1 : PAGESIZE + 7], b'\0foobar\0')
87 self.fail('regex match on mmap failed!')
92 self.assertEqual(start, PAGESIZE)
93 self.assertEqual(end, PAGESIZE + 6)
97 self.assertEqual(m.tell(), 0)
99 self.assertEqual(m.tell(), 42)
101 self.assertEqual(m.tell(), len(m))
104 self.assertRaises(ValueError, m.seek, -1)
107 self.assertRaises(ValueError, m.seek, 1, 2)
110 self.assertRaises(ValueError, m.seek, -len(m)-1, 2)
122 self.assertEqual(len(m), 512)
124 self.assertRaises(ValueError, m.seek, 513, 0)
131 self.assertEqual(f.tell(), 512)
134 self.assertEqual(m.size(), 512)
138 def test_access_parameter(self):
145 self.assertEqual(m[:], b'a'*mapsize, "Readonly memory map data incorrect.")
153 self.fail("Able to write to readonly memory map")
161 self.fail("Able to write to readonly memory map")
170 self.fail("Able to write to readonly memory map")
179 self.fail("Able to write to readonly memory map")
189 self.fail("Able to resize readonly memory map")
191 self.assertEqual(fp.read(), b'a'*mapsize,
204 self.fail("Opening mmap with size+1 should work on Windows.")
208 self.fail("Opening mmap with size+1 should raise ValueError.")
220 self.assertEqual(m[:], b'c'*mapsize,
226 self.assertEqual(stuff, b'c'*mapsize,
234 self.assertEqual(m[:], b'd' * mapsize,
238 self.assertEqual(fp.read(), b'c'*mapsize,
241 self.assertRaises(TypeError, m.resize, 2*mapsize)
246 self.assertRaises(ValueError, mmap.mmap, f.fileno(), mapsize, access=4)
251 self.assertRaises(ValueError, mmap.mmap, f.fileno(), mapsize,
259 self.assertRaises(TypeError, m.write, b"abcdef")
260 self.assertRaises(TypeError, m.write_byte, 0)
263 def test_bad_file_desc(self):
265 self.assertRaises(OSError, mmap.mmap, -2, 4096)
267 def test_tougher_find(self):
281 self.assertEqual(m.find(slice), data.find(slice))
282 self.assertEqual(m.find(slice + b'x'), -1)
285 def test_find_end(self):
294 self.assertEqual(m.find(b'one'), 0)
295 self.assertEqual(m.find(b'ones'), 8)
296 self.assertEqual(m.find(b'one', 0, -1), 0)
297 self.assertEqual(m.find(b'one', 1), 8)
298 self.assertEqual(m.find(b'one', 1, -1), 8)
299 self.assertEqual(m.find(b'one', 1, -2), -1)
300 self.assertEqual(m.find(bytearray(b'one')), 0)
303 def test_rfind(self):
312 self.assertEqual(m.rfind(b'one'), 8)
313 self.assertEqual(m.rfind(b'one '), 0)
314 self.assertEqual(m.rfind(b'one', 0, -1), 8)
315 self.assertEqual(m.rfind(b'one', 0, -2), 0)
316 self.assertEqual(m.rfind(b'one', 1, -1), 8)
317 self.assertEqual(m.rfind(b'one', 1, -2), -1)
318 self.assertEqual(m.rfind(bytearray(b'one')), 8)
321 def test_double_close(self):
331 def test_entire_file(self):
338 self.assertEqual(len(mf), 2**16, "Map size should equal file size.")
339 self.assertEqual(mf.read(2**16), 2**16 * b"m")
341 def test_length_0_offset(self):
351 self.assertRaises(IndexError, mf.__getitem__, 80000)
353 def test_length_0_large_offset(self):
360 self.assertRaises(ValueError, mmap.mmap, f.fileno(), 0,
363 def test_move(self):
372 self.assertEqual(mf[:], b"ABCDEABCDE", "Map move should have duplicated front 5")
384 self.assertEqual(m[:], expected)
399 self.assertRaises(ValueError, m.move, source, dest, size)
404 self.assertRaises(ValueError, m.move, 0, 0, 2)
405 self.assertRaises(ValueError, m.move, 1, 0, 1)
406 self.assertRaises(ValueError, m.move, 0, 1, 1)
410 def test_anonymous(self):
414 self.assertEqual(m[x], 0,
420 self.assertEqual(m[x], b)
422 def test_read_all(self):
424 self.addCleanup(m.close)
429 self.assertEqual(m.read(), bytes(range(16)))
431 self.assertEqual(m.read(), bytes(range(8, 16)))
433 self.assertEqual(m.read(), b'')
435 self.assertEqual(m.read(None), bytes(range(3, 16)))
437 self.assertEqual(m.read(-1), bytes(range(4, 16)))
439 self.assertEqual(m.read(-2), bytes(range(5, 16)))
441 self.assertEqual(m.read(-42), bytes(range(9, 16)))
443 def test_read_invalid_arg(self):
445 self.addCleanup(m.close)
447 self.assertRaises(TypeError, m.read, 'foo')
448 self.assertRaises(TypeError, m.read, 5.5)
449 self.assertRaises(TypeError, m.read, [1, 2, 3])
451 def test_extended_getslice(self):
456 self.assertEqual(m[:], s)
462 self.assertEqual(m[start:stop:step],
465 def test_extended_set_del_slice(self):
475 self.assertEqual(m[:], s)
483 self.assertEqual(m[:], bytes(L))
485 def make_mmap_file (self, f, halfsize):
493 def test_empty_file (self):
497 self.assertRaisesRegex(ValueError,
502 def test_offset (self):
507 m = self.make_mmap_file (f, halfsize)
517 self.assertEqual(0, 1)
521 self.assertEqual(0, 0)
527 self.assertEqual(m[0:3], b'foo')
537 self.assertEqual(len(m), 512)
539 self.assertRaises(ValueError, m.seek, 513, 0)
541 self.assertEqual(m[0:3], b'foo')
546 self.assertEqual(f.tell(), halfsize + 512)
548 self.assertEqual(m.size(), halfsize + 512)
559 def test_subclass(self):
566 def test_prot_readonly(self):
572 self.assertRaises(TypeError, m.write, "foo")
574 def test_error(self):
575 self.assertIs(mmap.error, OSError)
577 def test_io_methods(self):
585 self.assertEqual(m.tell(), i)
587 self.assertEqual(m.tell(), i+1)
588 self.assertRaises(ValueError, m.write_byte, b"x"[0])
589 self.assertEqual(m[:], data)
593 self.assertEqual(m.tell(), i)
594 self.assertEqual(m.read_byte(), data[i])
595 self.assertEqual(m.tell(), i+1)
596 self.assertRaises(ValueError, m.read_byte)
599 self.assertEqual(m.read(3), b"345")
600 self.assertEqual(m.tell(), 6)
604 self.assertEqual(m.tell(), 6)
605 self.assertEqual(m[:], b"012bar6789")
607 self.assertEqual(m.tell(), 9)
608 self.assertEqual(m[:], b"012barbaz9")
609 self.assertRaises(ValueError, m.write, b"ba")
611 def test_non_ascii_byte(self):
615 self.assertEqual(m[0], b)
617 self.assertEqual(m.read_byte(), b)
621 def test_tagname(self):
633 self.assertEqual(m1[:], data2)
634 self.assertEqual(m2[:], data2)
643 self.assertEqual(m1[:], data1)
644 self.assertEqual(m2[:], data2)
650 def test_sizeof(self):
654 self.assertEqual(sys.getsizeof(m2),
658 def test_crasher_on_windows(self):
685 def test_invalid_descriptor(self):
691 with self.assertRaises(OSError):
696 def test_context_manager(self):
698 self.assertFalse(m.closed)
699 self.assertTrue(m.closed)
701 def test_context_manager_exception(self):
703 with self.assertRaises(Exception) as exc:
706 self.assertIsInstance(exc.exception, OSError,
708 self.assertTrue(m.closed, "context manager failed")
710 def test_weakref(self):
714 self.assertIs(wr(), mm)
717 self.assertIs(wr(), None)
719 def test_write_returning_the_number_of_bytes_written(self):
721 self.assertEqual(mm.write(b""), 0)
722 self.assertEqual(mm.write(b"x"), 1)
723 self.assertEqual(mm.write(b"yz"), 2)
724 self.assertEqual(mm.write(b"python"), 6)
726 def test_resize_past_pos(self):
728 self.addCleanup(m.close)
733 self.skipTest("resizing not supported")
734 self.assertEqual(m.read(14), b'')
735 self.assertRaises(ValueError, m.read_byte)
736 self.assertRaises(ValueError, m.write_byte, 42)
737 self.assertRaises(ValueError, m.write, b'abc')
739 def test_concat_repeat_exception(self):
741 with self.assertRaises(TypeError):
743 with self.assertRaises(TypeError):
746 def test_flush_return_value(self):
750 self.addCleanup(mm.close)
753 self.assertIsNone(result)
757 self.assertRaises(OSError, mm.flush, 1, len(b'python'))
759 def test_repr(self):
787 self.assertIsNotNone(match)
788 self.assertEqual(match.group('access'), access)
789 self.assertEqual(match.group('length'), str(length))
790 self.assertEqual(match.group('pos'), str(pos))
791 self.assertEqual(match.group('offset'), str(offset))
793 self.assertIsNotNone(match)
796 def test_madvise(self):
800 with self.assertRaisesRegex(ValueError, "madvise start out of bounds"):
802 with self.assertRaisesRegex(ValueError, "madvise start out of bounds"):
804 with self.assertRaisesRegex(ValueError, "madvise length invalid"):
806 with self.assertRaisesRegex(OverflowError, "madvise length too large"):
808 self.assertEqual(m.madvise(mmap.MADV_NORMAL), None)
809 self.assertEqual(m.madvise(mmap.MADV_NORMAL, PAGESIZE), None)
810 self.assertEqual(m.madvise(mmap.MADV_NORMAL, PAGESIZE, size), None)
811 self.assertEqual(m.madvise(mmap.MADV_NORMAL, 0, 2), None)
812 self.assertEqual(m.madvise(mmap.MADV_NORMAL, 0, size), None)
815 def test_resize_up_when_mapped_to_pagefile(self):
826 self.assertEqual(len(m), new_size)
827 self.assertEqual(m[:start_size], data[:start_size])
830 def test_resize_down_when_mapped_to_pagefile(self):
841 self.assertEqual(len(m), new_size)
842 self.assertEqual(m[:new_size], data[:new_size])
845 def test_resize_fails_if_mapping_held_elsewhere(self):
857 with self.assertRaises(OSError):
859 with self.assertRaises(OSError):
863 self.assertEqual(m1.size(), reduced_size)
864 self.assertEqual(os.stat(f.fileno()).st_size, reduced_size)
869 def test_resize_succeeds_with_error_for_second_named_mapping(self):
882 self.assertEqual(m2[:data_length], data)
883 with self.assertRaises(OSError):
885 self.assertEqual(m1.size(), start_size)
886 self.assertEqual(m1[:data_length], data)
887 self.assertEqual(m2[:data_length], data)
889 def test_mmap_closed_by_int_scenarios(self):
896 def __init__(self, access) -> None:
897 self.access = access
899 def __enter__(self):
900 self.f = open(TESTFN, "w+b")
901 self.f.write(random.randbytes(100))
902 self.f.flush()
904 m = mmap.mmap(self.f.fileno(), 100, access=self.access)
907 def __index__(self):
913 def __exit__(self, exc_type, exc_value, traceback):
914 self.f.close()
931 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
935 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
939 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
943 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
947 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
951 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
956 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
960 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
964 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
968 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
972 with self.assertRaisesRegex(ValueError, "mmap closed or invalid"):
977 def setUp(self):
980 def tearDown(self):
983 def _make_test_file(self, num_zeroes, tail):
1000 def test_large_offset(self):
1001 with self._make_test_file(0x14FFFFFFF, b" ") as f:
1003 self.assertEqual(m[0xFFFFFFF], 32)
1005 def test_large_filesize(self):
1006 with self._make_test_file(0x17FFFFFFF, b" ") as f:
1010 with self.assertRaises(OverflowError):
1012 with self.assertRaises(ValueError):
1015 self.assertEqual(m.size(), 0x180000000)
1019 def _test_around_boundary(self, boundary):
1023 with self._make_test_file(start, tail) as f:
1025 self.assertEqual(m[start:end], tail)
1028 def test_around_2GB(self):
1029 self._test_around_boundary(_2G)
1032 def test_around_4GB(self):
1033 self._test_around_boundary(_4G)