eric: comparison DebugClients/Python/coverage/misc.py

-:bedab77d0fa3
+:d6c795b5ce33
 import os
 import sys
 import types
 from coverage import env
-from coverage.backward import string_class, to_bytes, unicode_class
+from coverage.backward import to_bytes, unicode_class
 ISOLATED_MODULES = {}
 def isolate_module(mod):
 return ISOLATED_MODULES[mod]
 os = isolate_module(os)
+def dummy_decorator_with_args(*args_unused, **kwargs_unused):
+"""Dummy no-op implementation of a decorator with arguments."""
+def _decorator(func):
+return func
+return _decorator
 # Use PyContracts for assertion testing on parameters and returns, but only if
 # we are running our own test suite.
 if env.TESTING:
 from contracts import contract              # pylint: disable=unused-import
 from contracts import new_contract as raw_new_contract
 # Define contract words that PyContract doesn't have.
 new_contract('bytes', lambda v: isinstance(v, bytes))
 if env.PY3:
 new_contract('unicode', lambda v: isinstance(v, unicode_class))
-else:                                           # pragma: not covered
-# We aren't using real PyContracts, so just define a no-op decorator as a
+def one_of(argnames):
-# stunt double.
+"""Ensure that only one of the argnames is non-None."""
-def contract(**unused):
+def _decorator(func):
-"""Dummy no-op implementation of `contract`."""
+argnameset = set(name.strip() for name in argnames.split(","))
-return lambda func: func
+def _wrapped(*args, **kwargs):
+vals = [kwargs.get(name) for name in argnameset]
+assert sum(val is not None for val in vals) == 1
+return func(*args, **kwargs)
+return _wrapped
+return _decorator
+else:                                           # pragma: not testing
+# We aren't using real PyContracts, so just define our decorators as
+# stunt-double no-ops.
+contract = dummy_decorator_with_args
+one_of = dummy_decorator_with_args
 def new_contract(*args_unused, **kwargs_unused):
 """Dummy no-op implementation of `new_contract`."""
 pass
 even if there are gaps between statements.
 For example, if `statements` is [1,2,3,4,5,10,11,12,13,14] and
 `lines` is [1,2,5,10,11,13,14] then the result will be "1-2, 5-11, 13-14".
-"""
+Both `lines` and `statements` can be any iterable. All of the elements of
-pairs = []
+`lines` must be in `statements`, and all of the values must be positive
-i = 0
+integers.
-j = 0
-start = None
+"""
 statements = sorted(statements)
 lines = sorted(lines)
-while i < len(statements) and j < len(lines):
-if statements[i] == lines[j]:
+pairs = []
-if start is None:
+start = None
-start = lines[j]
+lidx = 0
-end = lines[j]
+for stmt in statements:
-j += 1
+if lidx >= len(lines):
+break
+if stmt == lines[lidx]:
+lidx += 1
+if not start:
+start = stmt
+end = stmt
 elif start:
 pairs.append((start, end))
 start = None
-i += 1
 if start:
 pairs.append((start, end))
 ret = ', '.join(map(nice_pair, pairs))
 return ret
 attr = "_once_" + fn.__name__
 def _wrapped(self):
 """Inner function that checks the cache."""
 if hasattr(self, attr):
-raise Exception("Shouldn't have called %s more than once" % fn.__name__)
+raise AssertionError("Shouldn't have called %s more than once" % fn.__name__)
 setattr(self, attr, True)
 return fn(self)
 return _wrapped
 else:
-return fn
+return fn                   # pragma: not testing
 def bool_or_none(b):
 """Return bool(b), but preserve None."""
 if b is None:
 self.md5 = hashlib.md5()
 def update(self, v):
 """Add `v` to the hash, recursively if needed."""
 self.md5.update(to_bytes(str(type(v))))
-if isinstance(v, string_class):
+if isinstance(v, unicode_class):
-self.md5.update(to_bytes(v))
+self.md5.update(v.encode('utf8'))
 elif isinstance(v, bytes):
 self.md5.update(v)
 elif v is None:
 pass
 elif isinstance(v, (int, float)):
 thing=thing, name=name, func_name=func_name
 )
 )
-class CoverageException(Exception):
+class SimpleRepr(object):
-"""An exception specific to coverage.py."""
+"""A mixin implementing a simple __repr__."""
+def __repr__(self):
+return "<{klass} @{id:x} {attrs}>".format(
+klass=self.__class__.__name__,
+id=id(self) & 0xFFFFFF,
+attrs=" ".join("{}={!r}".format(k, v) for k, v in self.__dict__.items()),
+)
+class BaseCoverageException(Exception):
+"""The base of all Coverage exceptions."""
+pass
+class CoverageException(BaseCoverageException):
+"""A run-of-the-mill exception specific to coverage.py."""
 pass
 class NoSource(CoverageException):
 """We couldn't find the source for a module."""
 Construct it with three arguments, the values from `sys.exc_info`.
 """
 pass
+class StopEverything(BaseCoverageException):
+"""An exception that means everything should stop.
+The CoverageTest class converts these to SkipTest, so that when running
+tests, raising this exception will automatically skip the test.
+"""
+pass

Mercurial Repositories > eric / file comparison

comparison: DebugClients/Python/coverage/misc.py

DebugClients/Python/coverage/misc.py