Instances of :class:`set` are compared to instances of :class:`frozenset` based
on their members. For example, ``set('abc') == frozenset('abc')`` returns
-``True``.
+``True`` and so does ``set('abc') in set([frozenset('abc')])``.
The subset and equality comparisons do not generalize to a complete ordering
function. For example, any two disjoint sets are not equal and are not subsets
Update the set, keeping only elements found in either set, but not in both.
-.. method:: set.add(el)
+.. method:: set.add(elem)
- Add element *el* to the set.
+ Add element *elem* to the set.
-.. method:: set.remove(el)
+.. method:: set.remove(elem)
- Remove element *el* from the set. Raises :exc:`KeyError` if *el* is not
+ Remove element *elem* from the set. Raises :exc:`KeyError` if *elem* is not
contained in the set.
-.. method:: set.discard(el)
+.. method:: set.discard(elem)
- Remove element *el* from the set if it is present.
+ Remove element *elem* from the set if it is present.
.. method:: set.pop()
:meth:`symmetric_difference_update` methods will accept any iterable as an
argument.
+Note, the *elem* argument to the :meth:`__contains__`, :meth:`remove`, and
+:meth:`discard` methods may be a set. To support searching for an equivalent
+frozenset, the *elem* set is temporarily mutated during the search and then
+restored. During the search, the *elem* set should not be read or mutated
+since it does not have a meaningful value.
+
.. _typesmapping:
This will run all tests defined in the named module.
-.. function:: catch_warning()
+.. function:: catch_warning(record=True)
- This is a context manager that guards the warnings filter from being
+ Return a context manager that guards the warnings filter from being
permanently changed and records the data of the last warning that has been
- issued.
+ issued. The ``record`` argument specifies whether any raised warnings are
+ captured by the object returned by :func:`warnings.catch_warning` or allowed
+ to propagate as normal.
- Use like this::
+ The context manager is typically used like this::
with catch_warning() as w:
warnings.warn("foo")
log.info("creating '%s' and adding '%s' to it",
zip_filename, base_dir)
- def visit (z, dirname, names):
- for name in names:
- path = os.path.normpath(os.path.join(dirname, name))
- if os.path.isfile(path):
- z.write(path, path)
- log.info("adding '%s'" % path)
-
if not dry_run:
z = zipfile.ZipFile(zip_filename, "w",
compression=zipfile.ZIP_DEFLATED)
- os.path.walk(base_dir, visit, z)
+ for dirpath, dirnames, filenames in os.walk(base_dir):
+ for name in filenames:
+ path = os.path.normpath(os.path.join(dirpath, name))
+ if os.path.isfile(path):
+ z.write(path, path)
+ log.info("adding '%s'" % path)
z.close()
return zip_filename
fp.write(text)
fp.close()
-def zap(actions, dirname, names):
- for name in names:
- actions.append(os.path.join(dirname, name))
-
class LongReprTest(unittest.TestCase):
def setUp(self):
longname = 'areallylongpackageandmodulenametotestreprtruncation'
def tearDown(self):
actions = []
- os.path.walk(self.pkgname, zap, actions)
+ for dirpath, dirnames, filenames in os.walk(self.pkgname):
+ for name in dirnames + filenames:
+ actions.append(os.path.join(dirpath, name))
actions.append(self.pkgname)
actions.sort()
actions.reverse()
and unexpected skips.
"""
+def import_module(name, deprecated=False):
+ """Import the module to be tested, raising TestSkipped if it is not
+ available."""
+ with catch_warning(record=False):
+ if deprecated:
+ warnings.filterwarnings("ignore", ".+ module", DeprecationWarning)
+ try:
+ module = __import__(name, level=0)
+ except ImportError:
+ raise TestSkipped("No module named " + name)
+ else:
+ return module
+
verbose = 1 # Flag set to 0 by regrtest.py
use_resources = None # Flag set to [] by regrtest.py
max_memuse = 0 # Disable bigmem tests (they will still be run with
@contextlib.contextmanager
-def catch_warning(module=warnings):
+def catch_warning(module=warnings, record=True):
"""
Guard the warnings filter from being permanently changed and record the
data of the last warning that has been issued.
warnings.warn("foo")
assert str(w.message) == "foo"
"""
- warning_obj = WarningMessage()
original_filters = module.filters[:]
original_showwarning = module.showwarning
- module.showwarning = warning_obj._showwarning
+ if record:
+ warning_obj = WarningMessage()
+ module.showwarning = warning_obj._showwarning
try:
- yield warning_obj
+ yield warning_obj if record else None
finally:
module.showwarning = original_showwarning
module.filters = original_filters
self.failUnless(sys.flags)
attrs = ("debug", "division_warning",
"inspect", "interactive", "optimize", "dont_write_bytecode",
- "no_site", "ignore_environment", "tabcheck", "verbose")
+ "no_site", "ignore_environment", "tabcheck", "verbose",
+ "bytes_warning")
for attr in attrs:
self.assert_(hasattr(sys.flags, attr), attr)
self.assertEqual(type(getattr(sys.flags, attr)), int, attr)