Lines Matching refs:self
135 self = super().__new__(cls, name, id)
136 return self
158 self = super().__new__(cls, action, end, interp)
159 return self
161 def __init__(self, *args, **kwargs):
162 if self.action == 'use':
163 if self.end not in ('same', 'opposite', 'send', 'recv'):
164 raise ValueError(self.end)
165 elif self.action in ('close', 'force-close'):
166 if self.end not in ('both', 'same', 'opposite', 'send', 'recv'):
167 raise ValueError(self.end)
169 raise ValueError(self.action)
170 if self.interp not in ('main', 'same', 'other', 'extra'):
171 raise ValueError(self.interp)
173 def resolve_end(self, end):
174 if self.end == 'same':
176 elif self.end == 'opposite':
179 return self.end
181 def resolve_interp(self, interp, other, extra):
182 if self.interp == 'same':
184 elif self.interp == 'other':
188 elif self.interp == 'extra':
192 elif self.interp == 'main':
205 self = super().__new__(cls, pending, closed)
206 return self
208 def incr(self):
209 return type(self)(self.pending + 1, closed=self.closed)
211 def decr(self):
212 return type(self)(self.pending - 1, closed=self.closed)
214 def close(self, *, force=True):
215 if self.closed:
216 if not force or self.pending == 0:
217 return self
218 return type(self)(0 if force else self.pending, closed=True)
298 def tearDown(self):
308 def test_default_shareables(self):
319 with self.subTest(obj):
320 self.assertTrue(
323 def test_not_shareable(self):
325 def __init__(self, name):
326 self.name = name
327 def __str__(self):
328 return self.name
351 with self.subTest(repr(obj)):
352 self.assertFalse(
358 def setUp(self):
360 self.cid = interpreters.channel_create()
362 def tearDown(self):
363 interpreters.channel_destroy(self.cid)
366 def _assert_values(self, values):
368 with self.subTest(obj):
369 interpreters.channel_send(self.cid, obj)
370 got = interpreters.channel_recv(self.cid)
372 self.assertEqual(got, obj)
373 self.assertIs(type(got), type(obj))
375 #self.assertIsNot(got, obj)
377 def test_singletons(self):
379 with self.subTest(obj):
380 interpreters.channel_send(self.cid, obj)
381 got = interpreters.channel_recv(self.cid)
384 self.assertIs(got, obj)
386 def test_types(self):
387 self._assert_values([
390 self.cid,
393 def test_bytes(self):
394 self._assert_values(i.to_bytes(2, 'little', signed=True)
397 def test_strs(self):
398 self._assert_values(['hello world', '你好世界', ''])
400 def test_int(self):
401 self._assert_values(itertools.chain(range(-1, 258),
404 def test_non_shareable_int(self):
411 with self.subTest(i):
412 with self.assertRaises(OverflowError):
413 interpreters.channel_send(self.cid, i)
421 def test_initial(self):
424 self.assertEqual(ids, [main])
426 def test_after_creating(self):
431 self.assertEqual(ids, [main, first, second])
433 def test_after_destroying(self):
439 self.assertEqual(ids, [main, second])
444 def test_main(self):
447 self.assertEqual(cur, main)
448 self.assertIsInstance(cur, interpreters.InterpreterID)
450 def test_subinterpreter(self):
461 self.assertEqual(cur, expected)
462 self.assertNotEqual(cur, main)
467 def test_from_main(self):
470 self.assertEqual(main, expected)
471 self.assertIsInstance(main, interpreters.InterpreterID)
473 def test_from_subinterpreter(self):
483 self.assertEqual(main, expected)
488 def test_main(self):
490 self.assertTrue(interpreters.is_running(main))
493 def test_subinterpreter(self):
495 self.assertFalse(interpreters.is_running(interp))
498 self.assertTrue(interpreters.is_running(interp))
499 self.assertFalse(interpreters.is_running(interp))
501 def test_from_subinterpreter(self):
510 self.assertEqual(out.strip(), 'True')
512 def test_already_destroyed(self):
515 with self.assertRaises(RuntimeError):
518 def test_does_not_exist(self):
519 with self.assertRaises(RuntimeError):
522 def test_bad_id(self):
523 with self.assertRaises(ValueError):
529 def test_with_int(self):
532 self.assertEqual(int(id), 10)
534 def test_coerce_id(self):
536 def __index__(self):
540 self.assertEqual(int(id), 10)
542 def test_bad_id(self):
543 self.assertRaises(TypeError, interpreters.InterpreterID, object())
544 self.assertRaises(TypeError, interpreters.InterpreterID, 10.0)
545 self.assertRaises(TypeError, interpreters.InterpreterID, '10')
546 self.assertRaises(TypeError, interpreters.InterpreterID, b'10')
547 self.assertRaises(ValueError, interpreters.InterpreterID, -1)
548 self.assertRaises(OverflowError, interpreters.InterpreterID, 2**64)
550 def test_does_not_exist(self):
552 with self.assertRaises(RuntimeError):
555 def test_str(self):
557 self.assertEqual(str(id), '10')
559 def test_repr(self):
561 self.assertEqual(repr(id), 'InterpreterID(10)')
563 def test_equality(self):
568 self.assertTrue(id1 == id1)
569 self.assertTrue(id1 == id2)
570 self.assertTrue(id1 == int(id1))
571 self.assertTrue(int(id1) == id1)
572 self.assertTrue(id1 == float(int(id1)))
573 self.assertTrue(float(int(id1)) == id1)
574 self.assertFalse(id1 == float(int(id1)) + 0.1)
575 self.assertFalse(id1 == str(int(id1)))
576 self.assertFalse(id1 == 2**1000)
577 self.assertFalse(id1 == float('inf'))
578 self.assertFalse(id1 == 'spam')
579 self.assertFalse(id1 == id3)
581 self.assertFalse(id1 != id1)
582 self.assertFalse(id1 != id2)
583 self.assertTrue(id1 != id3)
588 def test_in_main(self):
590 self.assertIsInstance(id, interpreters.InterpreterID)
592 self.assertIn(id, interpreters.list_all())
595 def test_unique_id(self):
602 self.assertEqual(len(seen), 100)
604 def test_in_thread(self):
617 self.assertIn(id, interpreters.list_all())
619 def test_in_subinterpreter(self):
630 self.assertEqual(set(interpreters.list_all()), {main, id1, id2})
632 def test_in_threaded_subinterpreter(self):
649 self.assertEqual(set(interpreters.list_all()), {main, id1, id2})
651 def test_after_destroy_all(self):
663 self.assertEqual(set(interpreters.list_all()), before | {id})
665 def test_after_destroy_some(self):
676 self.assertEqual(set(interpreters.list_all()), before | {id, id2})
681 def test_one(self):
685 self.assertIn(id2, interpreters.list_all())
687 self.assertNotIn(id2, interpreters.list_all())
688 self.assertIn(id1, interpreters.list_all())
689 self.assertIn(id3, interpreters.list_all())
691 def test_all(self):
697 self.assertEqual(set(interpreters.list_all()), before | ids)
700 self.assertEqual(set(interpreters.list_all()), before)
702 def test_main(self):
704 with self.assertRaises(RuntimeError):
708 with self.assertRaises(RuntimeError):
715 def test_already_destroyed(self):
718 with self.assertRaises(RuntimeError):
721 def test_does_not_exist(self):
722 with self.assertRaises(RuntimeError):
725 def test_bad_id(self):
726 with self.assertRaises(ValueError):
729 def test_from_current(self):
741 self.assertEqual(set(interpreters.list_all()), {main, id})
743 def test_from_sibling(self):
753 self.assertEqual(set(interpreters.list_all()), {main, id1})
755 def test_from_other_thread(self):
764 def test_still_running(self):
768 self.assertTrue(interpreters.is_running(interp),
771 with self.assertRaises(RuntimeError,
774 self.assertTrue(interpreters.is_running(interp))
779 def setUp(self):
781 self.id = interpreters.create()
783 def test_success(self):
786 interpreters.run_string(self.id, script)
789 self.assertEqual(out, 'it worked!')
791 def test_in_thread(self):
795 interpreters.run_string(self.id, script)
802 self.assertEqual(out, 'it worked!')
804 def test_create_thread(self):
819 self.assertEqual(out, 'it worked!')
822 def test_fork(self):
837 interpreters.run_string(self.id, script)
841 self.assertEqual(content, expected)
843 def test_already_running(self):
844 with _running(self.id):
845 with self.assertRaises(RuntimeError):
846 interpreters.run_string(self.id, 'print("spam")')
848 def test_does_not_exist(self):
852 with self.assertRaises(RuntimeError):
855 def test_error_id(self):
856 with self.assertRaises(ValueError):
859 def test_bad_id(self):
860 with self.assertRaises(TypeError):
863 def test_bad_script(self):
864 with self.assertRaises(TypeError):
865 interpreters.run_string(self.id, 10)
867 def test_bytes_for_script(self):
868 with self.assertRaises(TypeError):
869 interpreters.run_string(self.id, b'print("spam")')
872 def assert_run_failed(self, exctype, msg=None):
873 with self.assertRaises(interpreters.RunFailedError) as caught:
876 self.assertEqual(str(caught.exception).split(':')[0],
879 self.assertEqual(str(caught.exception),
882 def test_invalid_syntax(self):
883 with self.assert_run_failed(SyntaxError):
885 interpreters.run_string(self.id, 'print("spam"')
887 def test_failure(self):
888 with self.assert_run_failed(Exception, 'spam'):
889 interpreters.run_string(self.id, 'raise Exception("spam")')
891 def test_SystemExit(self):
892 with self.assert_run_failed(SystemExit, '42'):
893 interpreters.run_string(self.id, 'raise SystemExit(42)')
895 def test_sys_exit(self):
896 with self.assert_run_failed(SystemExit):
897 interpreters.run_string(self.id, dedent("""
902 with self.assert_run_failed(SystemExit, '42'):
903 interpreters.run_string(self.id, dedent("""
908 def test_with_shared(self):
927 interpreters.run_string(self.id, script, shared)
931 self.assertEqual(ns['spam'], 42)
932 self.assertEqual(ns['eggs'], -1)
933 self.assertEqual(ns['result'], 41)
934 self.assertIsNone(ns['cheddar'])
936 def test_shared_overwrites(self):
937 interpreters.run_string(self.id, dedent("""
948 interpreters.run_string(self.id, script, shared)
958 interpreters.run_string(self.id, script)
962 self.assertEqual(ns['ns1']['spam'], 'eggs')
963 self.assertEqual(ns['ns2']['spam'], b'ham')
964 self.assertEqual(ns['spam'], b'ham')
966 def test_shared_overwrites_default_vars(self):
979 interpreters.run_string(self.id, script, shared)
983 self.assertEqual(ns['__name__'], b'not __main__')
985 def test_main_reused(self):
987 interpreters.run_string(self.id, dedent(f"""
1001 interpreters.run_string(self.id, dedent(f"""
1013 self.assertIn('spam', ns1)
1014 self.assertNotIn('eggs', ns1)
1015 self.assertIn('eggs', ns2)
1016 self.assertIn('spam', ns2)
1018 def test_execution_namespace_is_main(self):
1030 interpreters.run_string(self.id, script)
1036 self.assertEqual(ns, {
1047 def test_still_running_at_exit(self):
1068 self.assertEqual(retcode, 0)
1076 def test_default_kwargs(self):
1079 self.assertEqual(int(cid), 10)
1080 self.assertEqual(cid.end, 'both')
1082 def test_with_kwargs(self):
1084 self.assertEqual(cid.end, 'send')
1087 self.assertEqual(cid.end, 'send')
1090 self.assertEqual(cid.end, 'recv')
1093 self.assertEqual(cid.end, 'recv')
1096 self.assertEqual(cid.end, 'both')
1098 def test_coerce_id(self):
1100 def __index__(self):
1104 self.assertEqual(int(cid), 10)
1106 def test_bad_id(self):
1107 self.assertRaises(TypeError, interpreters._channel_id, object())
1108 self.assertRaises(TypeError, interpreters._channel_id, 10.0)
1109 self.assertRaises(TypeError, interpreters._channel_id, '10')
1110 self.assertRaises(TypeError, interpreters._channel_id, b'10')
1111 self.assertRaises(ValueError, interpreters._channel_id, -1)
1112 self.assertRaises(OverflowError, interpreters._channel_id, 2**64)
1114 def test_bad_kwargs(self):
1115 with self.assertRaises(ValueError):
1118 def test_does_not_exist(self):
1120 with self.assertRaises(interpreters.ChannelNotFoundError):
1123 def test_str(self):
1125 self.assertEqual(str(cid), '10')
1127 def test_repr(self):
1129 self.assertEqual(repr(cid), 'ChannelID(10)')
1132 self.assertEqual(repr(cid), 'ChannelID(10, send=True)')
1135 self.assertEqual(repr(cid), 'ChannelID(10, recv=True)')
1138 self.assertEqual(repr(cid), 'ChannelID(10)')
1140 def test_equality(self):
1145 self.assertTrue(cid1 == cid1)
1146 self.assertTrue(cid1 == cid2)
1147 self.assertTrue(cid1 == int(cid1))
1148 self.assertTrue(int(cid1) == cid1)
1149 self.assertTrue(cid1 == float(int(cid1)))
1150 self.assertTrue(float(int(cid1)) == cid1)
1151 self.assertFalse(cid1 == float(int(cid1)) + 0.1)
1152 self.assertFalse(cid1 == str(int(cid1)))
1153 self.assertFalse(cid1 == 2**1000)
1154 self.assertFalse(cid1 == float('inf'))
1155 self.assertFalse(cid1 == 'spam')
1156 self.assertFalse(cid1 == cid3)
1158 self.assertFalse(cid1 != cid1)
1159 self.assertFalse(cid1 != cid2)
1160 self.assertTrue(cid1 != cid3)
1165 def test_create_cid(self):
1167 self.assertIsInstance(cid, interpreters.ChannelID)
1169 def test_sequential_ids(self):
1176 self.assertEqual(id2, int(id1) + 1)
1177 self.assertEqual(id3, int(id2) + 1)
1178 self.assertEqual(set(after) - set(before), {id1, id2, id3})
1180 def test_ids_global(self):
1197 self.assertEqual(cid2, int(cid1) + 1)
1199 def test_channel_list_interpreters_none(self):
1205 self.assertEqual(send_interps, [])
1206 self.assertEqual(recv_interps, [])
1208 def test_channel_list_interpreters_basic(self):
1216 self.assertEqual(send_interps, [interp0])
1217 self.assertEqual(recv_interps, [])
1227 self.assertEqual(send_interps, [interp0])
1228 self.assertEqual(recv_interps, [interp1])
1230 def test_channel_list_interpreters_multiple(self):
1253 self.assertEqual(set(send_interps), {interp0, interp1})
1254 self.assertEqual(set(recv_interps), {interp2, interp3})
1256 def test_channel_list_interpreters_destroyed(self):
1269 self.assertEqual(send_interps, [interp0])
1270 self.assertEqual(recv_interps, [interp1])
1276 self.assertEqual(send_interps, [interp0])
1277 self.assertEqual(recv_interps, [])
1279 def test_channel_list_interpreters_released(self):
1300 self.assertEqual(len(send_interps), 1)
1301 self.assertEqual(len(recv_interps), 2)
1308 self.assertEqual(len(send_interps), 0)
1309 self.assertEqual(len(recv_interps), 2)
1319 self.assertEqual(len(send_interps), 0)
1320 self.assertEqual(recv_interps, [interp1])
1322 def test_channel_list_interpreters_closed(self):
1333 self.assertEqual(len(send_interps), 1)
1334 self.assertEqual(len(recv_interps), 0)
1339 with self.assertRaises(interpreters.ChannelClosedError):
1341 with self.assertRaises(interpreters.ChannelClosedError):
1344 def test_channel_list_interpreters_closed_send_end(self):
1355 self.assertEqual(len(send_interps), 1)
1356 self.assertEqual(len(recv_interps), 0)
1361 with self.assertRaises(interpreters.ChannelClosedError):
1365 self.assertEqual(len(recv_interps), 0)
1373 with self.assertRaises(interpreters.ChannelClosedError):
1375 with self.assertRaises(interpreters.ChannelClosedError):
1380 def test_send_recv_main(self):
1386 self.assertEqual(obj, orig)
1387 self.assertIsNot(obj, orig)
1389 def test_send_recv_same_interpreter(self):
1401 def test_send_recv_different_interpreters(self):
1410 self.assertEqual(obj, b'spam')
1412 def test_send_recv_different_threads(self):
1430 self.assertEqual(obj, b'spam')
1432 def test_send_recv_different_interpreters_and_threads(self):
1458 self.assertEqual(obj, b'eggs')
1460 def test_send_not_found(self):
1461 with self.assertRaises(interpreters.ChannelNotFoundError):
1464 def test_recv_not_found(self):
1465 with self.assertRaises(interpreters.ChannelNotFoundError):
1468 def test_recv_empty(self):
1470 with self.assertRaises(interpreters.ChannelEmptyError):
1473 def test_recv_default(self):
1487 self.assertIs(obj1, default)
1488 self.assertIs(obj2, None)
1489 self.assertEqual(obj3, 1)
1490 self.assertEqual(obj4, b'spam')
1491 self.assertEqual(obj5, b'eggs')
1492 self.assertIs(obj6, default)
1494 def test_run_string_arg_unresolved(self):
1506 self.assertEqual(obj, b'spam')
1507 self.assertEqual(out.strip(), 'send')
1513 def test_run_string_arg_resolved(self):
1526 self.assertEqual(obj, b'spam')
1527 self.assertEqual(out.strip(), 'send')
1531 def test_close_single_user(self):
1537 with self.assertRaises(interpreters.ChannelClosedError):
1539 with self.assertRaises(interpreters.ChannelClosedError):
1542 def test_close_multiple_users(self):
1555 with self.assertRaises(interpreters.RunFailedError) as cm:
1559 self.assertIn('ChannelClosedError', str(cm.exception))
1560 with self.assertRaises(interpreters.RunFailedError) as cm:
1564 self.assertIn('ChannelClosedError', str(cm.exception))
1566 def test_close_multiple_times(self):
1572 with self.assertRaises(interpreters.ChannelClosedError):
1575 def test_close_empty(self):
1583 with self.subTest((send, recv)):
1589 with self.assertRaises(interpreters.ChannelClosedError):
1591 with self.assertRaises(interpreters.ChannelClosedError):
1594 def test_close_defaults_with_unused_items(self):
1599 with self.assertRaises(interpreters.ChannelNotEmptyError):
1604 def test_close_recv_with_unused_items_unforced(self):
1609 with self.assertRaises(interpreters.ChannelNotEmptyError):
1617 def test_close_send_with_unused_items_unforced(self):
1623 with self.assertRaises(interpreters.ChannelClosedError):
1627 with self.assertRaises(interpreters.ChannelClosedError):
1630 def test_close_both_with_unused_items_unforced(self):
1635 with self.assertRaises(interpreters.ChannelNotEmptyError):
1643 def test_close_recv_with_unused_items_forced(self):
1649 with self.assertRaises(interpreters.ChannelClosedError):
1651 with self.assertRaises(interpreters.ChannelClosedError):
1654 def test_close_send_with_unused_items_forced(self):
1660 with self.assertRaises(interpreters.ChannelClosedError):
1662 with self.assertRaises(interpreters.ChannelClosedError):
1665 def test_close_both_with_unused_items_forced(self):
1671 with self.assertRaises(interpreters.ChannelClosedError):
1673 with self.assertRaises(interpreters.ChannelClosedError):
1676 def test_close_never_used(self):
1680 with self.assertRaises(interpreters.ChannelClosedError):
1682 with self.assertRaises(interpreters.ChannelClosedError):
1685 def test_close_by_unassociated_interp(self):
1693 with self.assertRaises(interpreters.ChannelClosedError):
1695 with self.assertRaises(interpreters.ChannelClosedError):
1698 def test_close_used_multiple_times_by_single_user(self):
1706 with self.assertRaises(interpreters.ChannelClosedError):
1708 with self.assertRaises(interpreters.ChannelClosedError):
1711 def test_channel_list_interpreters_invalid_channel(self):
1714 with self.assertRaises(interpreters.ChannelNotFoundError):
1719 with self.assertRaises(interpreters.ChannelClosedError):
1722 def test_channel_list_interpreters_invalid_args(self):
1725 with self.assertRaises(TypeError):
1772 def test_single_user(self):
1778 with self.assertRaises(interpreters.ChannelClosedError):
1780 with self.assertRaises(interpreters.ChannelClosedError):
1783 def test_multiple_users(self):
1801 self.assertEqual(out.strip(), "b'spam'")
1803 def test_no_kwargs(self):
1809 with self.assertRaises(interpreters.ChannelClosedError):
1811 with self.assertRaises(interpreters.ChannelClosedError):
1814 def test_multiple_times(self):
1820 with self.assertRaises(interpreters.ChannelClosedError):
1823 def test_with_unused_items(self):
1829 with self.assertRaises(interpreters.ChannelClosedError):
1832 def test_never_used(self):
1836 with self.assertRaises(interpreters.ChannelClosedError):
1838 with self.assertRaises(interpreters.ChannelClosedError):
1841 def test_by_unassociated_interp(self):
1852 with self.assertRaises(interpreters.ChannelClosedError):
1854 self.assertEqual(obj, b'spam')
1856 def test_close_if_unassociated(self):
1866 with self.assertRaises(interpreters.ChannelClosedError):
1869 def test_partially(self):
1878 self.assertEqual(obj, b'spam')
1880 def test_used_multiple_times_by_single_user(self):
1888 with self.assertRaises(interpreters.ChannelClosedError):
1890 with self.assertRaises(interpreters.ChannelClosedError):
1916 self = super().__new__(cls, end, interp, other, extra, creator)
1917 self._prepped = set()
1918 self._state = ChannelState()
1919 self._known = known
1920 return self
1923 def state(self):
1924 return self._state
1927 def cid(self):
1929 return self._cid
1931 creator = self._get_interpreter(self.creator)
1932 self._cid = self._new_channel(creator)
1933 return self._cid
1935 def get_interpreter(self, interp):
1936 interp = self._get_interpreter(interp)
1937 self._prep_interpreter(interp)
1940 def expect_closed_error(self, end=None):
1942 end = self.end
1943 if end == 'recv' and self.state.closed == 'send':
1945 return bool(self.state.closed)
1947 def prep_interpreter(self, interp):
1948 self._prep_interpreter(interp)
1950 def record_action(self, action, result):
1951 self._state = result
1953 def clean_up(self):
1959 def _new_channel(self, creator):
1972 self._cid = interpreters.channel_recv(ch)
1973 return self._cid
1975 def _get_interpreter(self, interp):
1977 return self.interp
1979 return self.other
1981 return self.extra
1985 interp = self._known[name]
1987 interp = self._known[name] = Interpreter(name)
1990 def _prep_interpreter(self, interp):
1991 if interp.id in self._prepped:
1993 self._prepped.add(interp.id)
2003 cid = interpreters._channel_id({self.cid})
2050 def iter_action_sets(self):
2060 for closeactions in self._iter_close_action_sets('same', 'other'):
2062 for postactions in self._iter_post_close_action_sets():
2064 for closeactions in self._iter_close_action_sets('other', 'extra'):
2066 for postactions in self._iter_post_close_action_sets():
2070 for useactions in self._iter_use_action_sets('same', 'other'):
2072 for closeactions in self._iter_close_action_sets('same', 'other'):
2075 for postactions in self._iter_post_close_action_sets():
2077 for closeactions in self._iter_close_action_sets('other', 'extra'):
2080 for postactions in self._iter_post_close_action_sets():
2082 for useactions in self._iter_use_action_sets('other', 'extra'):
2084 for closeactions in self._iter_close_action_sets('same', 'other'):
2087 for postactions in self._iter_post_close_action_sets():
2089 for closeactions in self._iter_close_action_sets('other', 'extra'):
2092 for postactions in self._iter_post_close_action_sets():
2095 def _iter_use_action_sets(self, interp1, interp2):
2144 def _iter_close_action_sets(self, interp1, interp2):
2163 def _iter_post_close_action_sets(self):
2172 def run_actions(self, fix, actions):
2174 self.run_action(fix, action)
2176 def run_action(self, fix, action, *, hideclosed=True):
2208 def iter_fixtures(self):
2221 def _close(self, fix, *, force):
2225 self.run_action(fix, close, hideclosed=False)
2227 with self.assertRaises(interpreters.ChannelClosedError):
2228 self.run_action(fix, close, hideclosed=False)
2230 def _assert_closed_in_interp(self, fix, interp=None):
2232 with self.assertRaises(interpreters.ChannelClosedError):
2234 with self.assertRaises(interpreters.ChannelClosedError):
2236 with self.assertRaises(interpreters.ChannelClosedError):
2238 with self.assertRaises(interpreters.ChannelClosedError):
2258 def _assert_closed(self, fix):
2259 self.assertTrue(fix.state.closed)
2263 self._assert_closed_in_interp(fix)
2269 self._assert_closed_in_interp(fix, interp)
2272 self._assert_closed_in_interp(fix, interp)
2274 def _iter_close_tests(self, verbose=False):
2276 for actions in self.iter_action_sets():
2278 for fix in self.iter_fixtures():
2296 def _skim_close_tests(self):
2298 for i, fix, actions in self._iter_close_tests():
2301 def test_close(self):
2302 for i, fix, actions in self._iter_close_tests():
2303 with self.subTest('{} {} {}'.format(i, fix, actions)):
2305 self.run_actions(fix, actions)
2307 self._close(fix, force=False)
2309 self._assert_closed(fix)
2313 def test_force_close(self):
2314 for i, fix, actions in self._iter_close_tests():
2315 with self.subTest('{} {} {}'.format(i, fix, actions)):
2317 self.run_actions(fix, actions)
2319 self._close(fix, force=True)
2321 self._assert_closed(fix)