diff options
| -rw-r--r-- | coverage/cmdline.py | 12 | ||||
| -rw-r--r-- | coverage/collector.py | 44 | ||||
| -rw-r--r-- | coverage/config.py | 4 | ||||
| -rw-r--r-- | coverage/control.py | 8 | ||||
| -rw-r--r-- | coverage/tracer.c | 20 | ||||
| -rw-r--r-- | tests/test_cmdline.py | 2 | ||||
| -rw-r--r-- | tests/test_concurrency.py (renamed from tests/test_coroutine.py) | 34 |
7 files changed, 62 insertions, 62 deletions
diff --git a/coverage/cmdline.py b/coverage/cmdline.py index c723fa9..51aa5fe 100644 --- a/coverage/cmdline.py +++ b/coverage/cmdline.py @@ -19,9 +19,9 @@ class Opts(object): '', '--branch', action='store_true', help="Measure branch coverage in addition to statement coverage." ) - coroutine = optparse.make_option( - '', '--coroutine', action='store', metavar="LIB", - help="Properly measure code using coroutines." + concurrency = optparse.make_option( + '', '--concurrency', action='store', metavar="LIB", + help="Properly measure code using a concurrency library." ) debug = optparse.make_option( '', '--debug', action='store', metavar="OPTS", @@ -125,7 +125,7 @@ class CoverageOptionParser(optparse.OptionParser, object): self.set_defaults( actions=[], branch=None, - coroutine=None, + concurrency=None, debug=None, directory=None, fail_under=None, @@ -320,7 +320,7 @@ CMDS = { [ Opts.append, Opts.branch, - Opts.coroutine, + Opts.concurrency, Opts.debug, Opts.pylib, Opts.parallel_mode, @@ -429,7 +429,7 @@ class CoverageScript(object): omit = omit, include = include, debug = debug, - coroutine = options.coroutine, + concurrency = options.concurrency, ) if 'debug' in options.actions: diff --git a/coverage/collector.py b/coverage/collector.py index 97b45de..0731824 100644 --- a/coverage/collector.py +++ b/coverage/collector.py @@ -46,7 +46,7 @@ class Collector(object): _collectors = [] def __init__(self, - should_trace, check_include, timid, branch, warn, coroutine, + should_trace, check_include, timid, branch, warn, concurrency, ): """Create a collector. @@ -68,7 +68,7 @@ class Collector(object): `warn` is a warning function, taking a single string message argument, to be used if a warning needs to be issued. - TODO: `coroutine` + TODO: `concurrency` """ self.should_trace = should_trace @@ -76,21 +76,21 @@ class Collector(object): self.warn = warn self.branch = branch self.threading = None - self.coroutine = coroutine + self.concurrency = concurrency - self.coroutine_id_func = None + self.concur_id_func = None try: - if coroutine == "greenlet": - import greenlet - self.coroutine_id_func = greenlet.getcurrent - elif coroutine == "eventlet": - import eventlet.greenthread - self.coroutine_id_func = eventlet.greenthread.getcurrent - elif coroutine == "gevent": - import gevent - self.coroutine_id_func = gevent.getcurrent - elif coroutine == "thread" or not coroutine: + if concurrency == "greenlet": + import greenlet # pylint: disable=import-error + self.concur_id_func = greenlet.getcurrent + elif concurrency == "eventlet": + import eventlet.greenthread # pylint: disable=import-error + self.concur_id_func = eventlet.greenthread.getcurrent + elif concurrency == "gevent": + import gevent # pylint: disable=import-error + self.concur_id_func = gevent.getcurrent + elif concurrency == "thread" or not concurrency: # It's important to import threading only if we need it. If # it's imported early, and the program being measured uses # gevent, then gevent's monkey-patching won't work properly. @@ -98,12 +98,12 @@ class Collector(object): self.threading = threading else: raise CoverageException( - "Don't understand coroutine=%s" % coroutine + "Don't understand concurrency=%s" % concurrency ) except ImportError: raise CoverageException( - "Couldn't trace with coroutine=%s, " - "the module isn't installed." % coroutine + "Couldn't trace with concurrency=%s, " + "the module isn't installed." % concurrency ) self.reset() @@ -148,13 +148,13 @@ class Collector(object): tracer.should_trace_cache = self.should_trace_cache tracer.warn = self.warn - if hasattr(tracer, 'coroutine_id_func'): - tracer.coroutine_id_func = self.coroutine_id_func - elif self.coroutine_id_func: + if hasattr(tracer, 'concur_id_func'): + tracer.concur_id_func = self.concur_id_func + elif self.concur_id_func: raise CoverageException( - "Can't support coroutine=%s with %s, " + "Can't support concurrency=%s with %s, " "only threads are supported" % ( - self.coroutine, self.tracer_name(), + self.concurrency, self.tracer_name(), ) ) diff --git a/coverage/config.py b/coverage/config.py index c671ef7..44bf393 100644 --- a/coverage/config.py +++ b/coverage/config.py @@ -140,7 +140,7 @@ class CoverageConfig(object): # Defaults for [run] self.branch = False - self.coroutine = None + self.concurrency = None self.cover_pylib = False self.data_file = ".coverage" self.parallel = False @@ -235,7 +235,7 @@ class CoverageConfig(object): # [run] ('branch', 'run:branch', 'boolean'), - ('coroutine', 'run:coroutine'), + ('concurrency', 'run:concurrency'), ('cover_pylib', 'run:cover_pylib', 'boolean'), ('data_file', 'run:data_file'), ('debug', 'run:debug', 'list'), diff --git a/coverage/control.py b/coverage/control.py index 86a2ae2..510ced7 100644 --- a/coverage/control.py +++ b/coverage/control.py @@ -45,7 +45,7 @@ class Coverage(object): def __init__(self, data_file=None, data_suffix=None, cover_pylib=None, auto_data=False, timid=None, branch=None, config_file=True, source=None, omit=None, include=None, debug=None, - debug_file=None, coroutine=None, plugins=None): + debug_file=None, concurrency=None, plugins=None): """ `data_file` is the base name of the data file to use, defaulting to ".coverage". `data_suffix` is appended (with a dot) to `data_file` to @@ -84,7 +84,7 @@ class Coverage(object): desired. `debug_file` is the file to write debug messages to, defaulting to stderr. - `coroutine` is a string indicating the coroutining library being used + `concurrency` is a string indicating the concurrency library being used in the measured code. Without this, coverage.py will get incorrect results. Valid strings are "greenlet", "eventlet", or "gevent", which are all equivalent. TODO: really? @@ -128,7 +128,7 @@ class Coverage(object): data_file=data_file, cover_pylib=cover_pylib, timid=timid, branch=branch, parallel=bool_or_none(data_suffix), source=source, omit=omit, include=include, debug=debug, - coroutine=coroutine, plugins=plugins, + concurrency=concurrency, plugins=plugins, ) # Create and configure the debugging controller. @@ -170,7 +170,7 @@ class Coverage(object): timid=self.config.timid, branch=self.config.branch, warn=self._warn, - coroutine=self.config.coroutine, + concurrency=self.config.concurrency, ) # Suffixes are a bit tricky. We want to use the data suffix only when diff --git a/coverage/tracer.c b/coverage/tracer.c index 5bf5c46..dcc3b72 100644 --- a/coverage/tracer.c +++ b/coverage/tracer.c @@ -81,7 +81,7 @@ typedef struct { /* Python objects manipulated directly by the Collector class. */ PyObject * should_trace; PyObject * warn; - PyObject * coroutine_id_func; + PyObject * concur_id_func; PyObject * data; PyObject * plugin_data; PyObject * should_trace_cache; @@ -104,8 +104,8 @@ typedef struct { (None). */ - DataStack data_stack; /* Used if we aren't doing coroutines. */ - PyObject * data_stack_index; /* Used if we are doing coroutines. */ + DataStack data_stack; /* Used if we aren't doing concurrency. */ + PyObject * data_stack_index; /* Used if we are doing concurrency. */ DataStack * data_stacks; int data_stacks_alloc; int data_stacks_used; @@ -191,7 +191,7 @@ CTracer_init(CTracer *self, PyObject *args_unused, PyObject *kwds_unused) self->should_trace = NULL; self->warn = NULL; - self->coroutine_id_func = NULL; + self->concur_id_func = NULL; self->data = NULL; self->plugin_data = NULL; self->should_trace_cache = NULL; @@ -234,7 +234,7 @@ CTracer_dealloc(CTracer *self) Py_XDECREF(self->should_trace); Py_XDECREF(self->warn); - Py_XDECREF(self->coroutine_id_func); + Py_XDECREF(self->concur_id_func); Py_XDECREF(self->data); Py_XDECREF(self->plugin_data); Py_XDECREF(self->should_trace_cache); @@ -327,18 +327,18 @@ CTracer_record_pair(CTracer *self, int l1, int l2) static int CTracer_set_pdata_stack(CTracer *self) { - if (self->coroutine_id_func != Py_None) { + if (self->concur_id_func != Py_None) { PyObject * co_obj = NULL; PyObject * stack_index = NULL; long the_index = 0; - co_obj = PyObject_CallObject(self->coroutine_id_func, NULL); + co_obj = PyObject_CallObject(self->concur_id_func, NULL); if (co_obj == NULL) { return RET_ERROR; } stack_index = PyDict_GetItem(self->data_stack_index, co_obj); if (stack_index == NULL) { - /* A new coroutine object. Make a new data stack. */ + /* A new concurrency object. Make a new data stack. */ the_index = self->data_stacks_used; stack_index = MyInt_FromLong(the_index); if (PyDict_SetItem(self->data_stack_index, co_obj, stack_index) < 0) { @@ -781,8 +781,8 @@ CTracer_members[] = { { "warn", T_OBJECT, offsetof(CTracer, warn), 0, PyDoc_STR("Function for issuing warnings.") }, - { "coroutine_id_func", T_OBJECT, offsetof(CTracer, coroutine_id_func), 0, - PyDoc_STR("Function for determining coroutine context") }, + { "concur_id_func", T_OBJECT, offsetof(CTracer, concur_id_func), 0, + PyDoc_STR("Function for determining concurrency context") }, { "data", T_OBJECT, offsetof(CTracer, data), 0, PyDoc_STR("The raw dictionary of trace data.") }, diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py index 08f7937..bf96f27 100644 --- a/tests/test_cmdline.py +++ b/tests/test_cmdline.py @@ -20,7 +20,7 @@ class CmdLineTest(CoverageTest): defaults.coverage( cover_pylib=None, data_suffix=None, timid=None, branch=None, config_file=True, source=None, include=None, omit=None, debug=None, - coroutine=None, + concurrency=None, ) defaults.annotate( directory=None, ignore_errors=None, include=None, omit=None, morfs=[], diff --git a/tests/test_coroutine.py b/tests/test_concurrency.py index 4abdd6f..5ea756f 100644 --- a/tests/test_coroutine.py +++ b/tests/test_concurrency.py @@ -1,4 +1,4 @@ -"""Tests for coroutining.""" +"""Tests for concurrency libraries.""" import os, os.path, sys, threading @@ -36,8 +36,8 @@ def line_count(s): return sum(1 for l in s.splitlines() if code_line(l)) -class CoroutineTest(CoverageTest): - """Tests of the coroutine support in coverage.py.""" +class ConcurrencyTest(CoverageTest): + """Tests of the concurrency support in coverage.py.""" LIMIT = 1000 @@ -103,7 +103,7 @@ class CoroutineTest(CoverageTest): import gevent.queue as queue """ + COMMON - # Uncomplicated code that doesn't use any of the coroutining stuff, to test + # Uncomplicated code that doesn't use any of the concurrency stuff, to test # the simple case under each of the regimes. SIMPLE = """\ total = 0 @@ -112,32 +112,32 @@ class CoroutineTest(CoverageTest): print(total) """.format(LIMIT=LIMIT) - def try_some_code(self, code, coroutine, the_module, expected_out=None): - """Run some coroutine testing code and see that it was all covered. + def try_some_code(self, code, concurrency, the_module, expected_out=None): + """Run some concurrency testing code and see that it was all covered. - `code` is the Python code to execute. `coroutine` is the name of the - coroutine regime to test it under. `the_module` is the imported module - that must be available for this to work at all. `expected_out` is the - text we expect the code to produce. + `code` is the Python code to execute. `concurrency` is the name of + the concurrency regime to test it under. `the_module` is the imported + module that must be available for this to work at all. `expected_out` + is the text we expect the code to produce. """ self.make_file("try_it.py", code) - cmd = "coverage run --coroutine=%s try_it.py" % coroutine + cmd = "coverage run --concurrency=%s try_it.py" % concurrency out = self.run_command(cmd) if not the_module: # We don't even have the underlying module installed, we expect # coverage to alert us to this fact. expected_out = ( - "Couldn't trace with coroutine=%s, " - "the module isn't installed.\n" % coroutine + "Couldn't trace with concurrency=%s, " + "the module isn't installed.\n" % concurrency ) self.assertEqual(out, expected_out) - elif C_TRACER or coroutine == "thread": + elif C_TRACER or concurrency == "thread": # We can fully measure the code if we are using the C tracer, which - # can support all the coroutining, or if we are using threads. + # can support all the concurrency, or if we are using threads. if expected_out is None: expected_out = "%d\n" % (sum(range(self.LIMIT))) self.assertEqual(out, expected_out) @@ -157,8 +157,8 @@ class CoroutineTest(CoverageTest): self.assertEqual(data.summary()['try_it.py'], lines) else: expected_out = ( - "Can't support coroutine=%s with PyTracer, " - "only threads are supported\n" % coroutine + "Can't support concurrency=%s with PyTracer, " + "only threads are supported\n" % concurrency ) self.assertEqual(out, expected_out) |