def wrapper(f): assert failure_source in valid_failure_sources assert isinstance(flaky, bool) tagged_func = attr(known_failure=failure_source, jira_url=jira_url)(f) if flaky: tagged_func = attr('known_flaky')(tagged_func) if notes: tagged_func = attr(failure_notes=notes)(tagged_func) return tagged_func
def wrapper(f): assert failure_source in valid_failure_sources assert isinstance(flaky, bool) tagged_func = attr(known_failure=failure_source, jira_url=jira_url)(f) if flaky: tagged_func = attr("known_flaky")(tagged_func) if notes: tagged_func = attr(failure_notes=notes)(tagged_func) return tagged_func
def wrapper(f): assert_in(failure_source, valid_failure_sources) assert_is_instance(flaky, bool) tagged_func = attr(known_failure=failure_source, jira_url=jira_url)(f) if flaky: tagged_func = attr('known_flaky')(tagged_func) tagged_func = attr(failure_notes=notes)(tagged_func) return tagged_func
def use_vcr(func=None, **kwargs): """ Decorator for test functions which go online. A vcr cassette will automatically be created and used to capture and play back online interactions. The nose 'vcr' attribute will be set, and the nose 'online' attribute will be set on it based on whether it might go online. The record mode of VCR can be set using the VCR_RECORD_MODE environment variable when running tests. Depending on the record mode, and the existence of an already recorded cassette, this decorator will also dynamically set the nose 'online' attribute. Keyword arguments to :func:`vcr.VCR.use_cassette` can be supplied. """ if func is None: # When called with kwargs, e.g. @use_vcr(inject_cassette=True) return functools.partial(use_vcr, **kwargs) module = func.__module__.split('tests.')[-1] class_name = inspect.stack()[1][3] cassette_name = '.'.join([module, class_name, func.__name__]) kwargs.setdefault('path', cassette_name) cassette_path = os.path.join(VCR_CASSETTE_DIR, cassette_name) online = True # Set our nose online attribute based on the VCR record mode if vcr.record_mode == 'none': online = False elif vcr.record_mode == 'once': online = not os.path.exists(cassette_path) func = attr(online=online, vcr=True)(func) # If we are not going online, disable domain delay during test if not online: func = mock.patch('flexget.utils.requests.wait_for_domain', new=mock.MagicMock())(func) if VCR_RECORD_MODE == 'off': return func else: return vcr.use_cassette(**kwargs)(func)
def require(require_pattern, broken_in=None): """Skips the decorated class or method, unless the argument 'require_pattern' is a case-insensitive regex match for the name of the git branch in the directory from which Cassandra is running. For example, the method defined here: @require('compaction-fixes') def compaction_test(self): ... will run if Cassandra is running from a directory whose current git branch is named 'compaction-fixes'. If 'require_pattern' were '.*compaction-fixes.*', it would run only when Cassandra is being run from a branch whose name contains 'compaction-fixes'. To accommodate current branch-naming conventions, it also will run if the current Cassandra branch matches 'CASSANDRA-{require_pattern}'. This allows users to run tests like: @require(4200) class TestNewFeature(self): ... on branches named 'CASSANDRA-4200'. If neither 'require_pattern' nor 'CASSANDRA-{require_pattern}' is a case-insensitive match for the name of Cassandra's current git branch, the test function or class will be skipped with unittest.skip. To run decorated methods as if they were not decorated with @require, set the environment variable IGNORE_REQUIRE to 'yes' or 'true'. To only run methods decorated with require, set IGNORE_REQUIRE to 'yes' or 'true' and run `nosetests` with `-a required`. (This uses the built-in `attrib` plugin.) """ tagging_decorator = attr('required') if IGNORE_REQUIRE: return tagging_decorator require_pattern = str(require_pattern) git_branch = '' git_branch = cassandra_git_branch() if git_branch: git_branch = git_branch.lower() run_on_branch_patterns = (require_pattern, 'cassandra-{b}'.format(b=require_pattern)) # always run the test if the git branch name matches if any(re.match(p, git_branch, re.IGNORECASE) for p in run_on_branch_patterns): return tagging_decorator # if skipping a buggy/flapping test, use since elif broken_in: def tag_and_skip_after_version(decorated): return since('0', broken_in)(tagging_decorator(decorated)) return tag_and_skip_after_version # otherwise, skip with a message else: def tag_and_skip(decorated): return unittest.skip('require ' + str(require_pattern))(tagging_decorator(decorated)) return tag_and_skip else: return tagging_decorator
def travis_only(func): @functools.wraps(func) def run_test(*args, **kwargs): if not travis: raise SkipTest('Tunnel tests are run in travis-ci only.') func(*args, **kwargs) return attr('travis_only')(run_test)
def test_values(): # @attr(mood="hohum", colors=['red','blue']) def test(): pass test = attr(mood="hohum", colors=['red','blue'])(test) eq_(test.mood, "hohum") eq_(test.colors, ['red','blue'])
def test_flags(): # @attr('one','two') def test(): pass test = attr('one','two')(test) eq_(test.one, 1) eq_(test.two, 1)
def make_steps(cls, step_container, steps, is_background, outline=None): """ Construct either a scenario or a background calling the specified steps. The method will have debugging information corresponding to the lines in the feature file. """ assert len(steps) > 0 step_definitions = [cls.prepare_step(step) for step in steps] source = 'def run_steps(self):\n' if not is_background: source += ' self.background()\n' source += '\n'.join( ' func{i}(step{i}, *args{i}, **kwargs{i})'.format(i=i) for i in range(len(step_definitions))) source = ast.parse(source) # Set locations of the steps for step, step_call in zip(steps, source.body[0].body[1:]): for node in ast.walk(step_call): node.lineno = step.described_at.line # Supply all the step functions and arguments context = { k + str(i): v for i, definition in enumerate(step_definitions) for k, v in definition.items() } if is_background: func_name = 'background' else: func_name = step_container.name run_steps = make_function( source=source, context=context, source_file=step_container.described_at.file, name=func_name, ) try: tags = step_container.tags except AttributeError: tags = () for tag in tags: run_steps = attr(tag)(run_steps) if not is_background: run_steps = CALLBACK_REGISTRY.wrap('example', run_steps, step_container, outline, steps) return run_steps
def _test_notebooks_in_path(root_path): with TemporaryDirectory() as tmp: tmp_path = Path(tmp) for nb_path in notebooks_in_path(root_path): rel_path = nb_path.relative_to(root_path) workdir = tmp_path / rel_path.parent workdir.mkdir(parents=True, exist_ok=True) description = "Running notebook {}".format(rel_path) yield attr(description=description)(run_notebook), nb_path, workdir
def wip(f): @wraps(f) def run_test(*args, **kwargs): try: f(*args, **kwargs) except Exception as e: raise SkipTest("WIP test failed: " + str(e)) fail("test passed but marked as work in progress") return attr('wip')(run_test)
def test_mixed(): # @attr('slow', 'net', role='integration') def test(): pass test = attr('slow', 'net', role='integration')(test) eq_(test.slow, 1) eq_(test.net, 1) eq_(test.role, 'integration')
def wip(f): @wraps(f) def run_test(*args, **kwargs): try: f(*args, **kwargs) except Exception as e: raise SkipTest("WIP test failed: " + str(e)) raise AssertionError("Passing test marked as WIP") return attr('wip')(run_test)
def wip(func): @functools.wraps(func) def run_test(*args, **kwargs): try: func(*args, **kwargs) except Exception as e: raise SkipTest("WIP test failed: " + str(e)) assert False, "test passed but marked as work in progress" return attr('wip')(run_test)
def integration(f): @wraps(f) def run_test(*args, **kwargs): integration_run = (os.getenv('INTEGRATION', None) is not None) if integration_run: f(*args, **kwargs) else: raise SkipTest("Skipping integration test") return attr('integration')(run_test)
def wip(f): @wraps(f) def run_test(*args, **kwargs): try: # Set to success so we don't save out the output when we know things # are awry args[0].success = True f(*args, **kwargs) except Exception as e: raise SkipTest("WIP test failed: " + str(e)) fail("test passed but marked as work in progress") return attr('wip')(run_test)
def make_example(cls, method, scenario, index): """ Set the method attributes to associate it with given scenario and index. """ method.is_example = True method.scenario = scenario method.scenario_index = index for tag in scenario.tags: method = attr(tag)(method) return method
def wip(f): """ Use this as a decorator to mark tests that are "works in progress" """ @wraps(f) def run_test(*args, **kwargs): try: f(*args, **kwargs) except Exception as e: raise SkipTest("WIP test failed: " + str(e)) fail("test passed but marked as work in progress") return attr('wip')(run_test)
def wipd(f): """ - "work in progress decorator" Custom decorator and flag. # Then "nosetests -a wip" can be used at the command line to narrow the execution of the test to # the ones marked with @wipd Usage: @widp def test_channelistion(self): pass """ return attr('wip')(f)
def wrapper(f): assert_in(failure_source, valid_failure_sources) assert_is_instance(flaky, bool) try: existing_failure_annotations = f.known_failure except AttributeError: existing_failure_annotations = [] new_annotation = [{'failure_source': failure_source, 'jira_url': jira_url, 'notes': notes, 'flaky': flaky}] failure_annotations = existing_failure_annotations + new_annotation tagged_func = attr(known_failure=failure_annotations)(f) return tagged_func
def make_scenario(cls, scenario, index): """ Construct a method running the scenario steps. index is the 1-based number of the scenario in the feature. """ if scenario.outlines: source = 'def run_outlines(self):\n' + '\n'.join( ' outline{i}(self)'.format(i=i) for i in range(len(scenario.outlines)) ) source = ast.parse(source) # Set locations of the steps for outline, outline_call in \ zip(scenario.outlines, source.body[0].body): for node in ast.walk(outline_call): node.lineno = outline.line context = { 'outline' + str(i): cls.make_steps(scenario, steps, is_background=False, outline=outline) for i, (outline, steps) in enumerate(scenario.evaluated) } result = make_function( source=source, context=context, source_file=scenario.feature.filename, name=scenario.name, ) else: result = cls.make_steps(scenario, scenario.steps, is_background=False) result.is_scenario = True result.scenario = scenario result.scenario_index = index for tag in scenario.tags: result = attr(tag)(result) return result
def wip(fn): """ Work-in-progress decorator @wip This decorator lets you check tests into version control and not gate a push while allowing you to work on making them pass - If the test fails it will be skipped - If the test passes it will report a failure """ @wraps(fn) def run_test(*args, **kwargs): try: fn(*args, **kwargs) except Exception as ex: raise SkipTest("WIP FAILURE: %s" % str(ex)) raise AssertionError("Test passed but is work in progress") return attr('wip')(run_test)
def wip(fn): """ Work-in-progress decorator @wip This decorator lets you check tests into version control and not gate a push while allowing you to work on making them pass - If the test fails it will be skipped - If the test passes it will report a failure """ @wraps(fn) def run_test(*args, **kwargs): try: fn(*args, **kwargs) except Exception as ex: raise SkipTest( "WIP FAILURE: %s" % str(ex)) raise AssertionError("Test passed but is work in progress") return attr('wip')(run_test)
def use_vcr(func): """ Decorator for test functions which go online. A vcr cassette will automatically be created and used to capture and play back online interactions. The nose 'vcr' attribute will be set, and the nose 'online' attribute will be set on it based on whether it might go online. The record mode of VCR can be set using the VCR_RECORD_MODE environment variable when running tests. Depending on the record mode, and the existence of an already recorded cassette, this decorator will also dynamically set the nose 'online' attribute. """ module = func.__module__.split('tests.')[-1] class_name = inspect.stack()[1][3] cassette_name = '.'.join([module, class_name, func.__name__]) cassette_path, _ = vcr.get_path_and_merged_config(cassette_name) online = True # Set our nose online attribute based on the VCR record mode if vcr.record_mode == 'none': online = False elif vcr.record_mode == 'once': online = not os.path.exists(cassette_path) func = attr(online=online, vcr=True)(func) # If we are not going online, disable domain delay during test if not online: func = mock.patch('flexget.utils.requests.wait_for_domain', new=mock.MagicMock())(func) # VCR playback on windows needs a bit of help https://github.com/kevin1024/vcrpy/issues/116 if sys.platform.startswith( 'win') and vcr.record_mode != 'all' and os.path.exists( cassette_path): func = mock.patch( 'requests.packages.urllib3.connectionpool.is_connection_dropped', new=mock.MagicMock(return_value=False))(func) @wraps(func) def func_with_cassette(*args, **kwargs): with vcr.use_cassette(cassette_name) as cassette: try: func(*args, cassette=cassette, **kwargs) except TypeError: func(*args, **kwargs) if VCR_RECORD_MODE == 'off': return func else: return func_with_cassette
def wip(f): """Allows to run a single test using a @wip decorator i.e. from superdesk.tests import TestCase from tests import wip class TestWIP(TestCase): @wip def test_something(self): self.assertEqual(1, 1) then run with: nosetests -a wip """ return attr("wip")(f)
def flaky(max_runs=None, min_passes=None): """ Decorator used to mark a test as "flaky". When used in conjuction with the flaky nosetests plugin, will cause the decorated test to be retried until min_passes successes are achieved out of up to max_runs test runs. :param max_runs: The maximum number of times the decorated test will be run. :type max_runs: `int` :param min_passes: The minimum number of times the test must pass to be a success. :type min_passes: `int` :return: A wrapper function that includes attributes describing the flaky test. :rtype: `callable` """ if max_runs is None: max_runs = 2 if min_passes is None: min_passes = 1 if min_passes <= 0: raise ValueError('min_passes must be positive') # In case @flaky is applied to a function or class without arguments # (and without parentheses), max_runs will refer to the wrapped object. # In this case, the default value can be used. wrapped = None if hasattr(max_runs, '__call__'): wrapped = max_runs max_runs = 2 if max_runs < min_passes: raise ValueError('min_passes cannot be greater than max_runs!') wrapper = attr( **{ FlakyNames.MAX_RUNS: max_runs, FlakyNames.MIN_PASSES: min_passes, FlakyNames.CURRENT_RUNS: 0, FlakyNames.CURRENT_PASSES: 0, }) return wrapper(wrapped) if wrapped is not None else wrapper
def test_class_attrs(): # @attr('slow', 'net', role='integration') class MyTest: def setUp(): pass def test_one(self): pass def test_two(self): pass class SubClass(MyTest): pass MyTest = attr('slow', 'net', role='integration')(MyTest) eq_(MyTest.slow, 1) eq_(MyTest.net, 1) eq_(MyTest.role, 'integration') eq_(SubClass.slow, 1) assert not hasattr(MyTest.setUp, 'slow') assert not hasattr(MyTest.test_two, 'slow')
def wrapper(f): assert_in(failure_source, valid_failure_sources) assert_is_instance(flaky, bool) try: existing_failure_annotations = f.known_failure except AttributeError: existing_failure_annotations = [] new_annotation = [{ 'failure_source': failure_source, 'jira_url': jira_url, 'notes': notes, 'flaky': flaky }] failure_annotations = existing_failure_annotations + new_annotation tagged_func = attr(known_failure=failure_annotations)(f) return tagged_func
def test_tutorials(): with TemporaryDirectory() as tmp: tmp_path = Path(tmp) # Copy tutorial file resources for f_path in _TUTORIAL_FILES: src = _TUTORIALS_ROOT / f_path dest = tmp_path / f_path dest.parent.mkdir(parents=True, exist_ok=True) if src.is_dir(): shutil.copytree(src, dest) else: shutil.copy(src, dest) # Emit a test for each notebook for nb_path in notebooks_in_path(_TUTORIALS_ROOT): rel_path = nb_path.relative_to(_TUTORIALS_ROOT) workdir = tmp_path / rel_path.parent workdir.mkdir(parents=True, exist_ok=True) description = "Running notebook {}".format(rel_path) yield attr(description=description)(run_notebook), nb_path, workdir
def flaky(max_runs=None, min_passes=None): """ Decorator used to mark a test as "flaky". When used in conjuction with the flaky nosetests plugin, will cause the decorated test to be retried until min_passes successes are achieved out of up to max_runs test runs. :param max_runs: The maximum number of times the decorated test will be run. :type max_runs: `int` :param min_passes: The minimum number of times the test must pass to be a success. :type min_passes: `int` :return: A wrapper function that includes attributes describing the flaky test. :rtype: `callable` """ if max_runs is None: max_runs = 2 if min_passes is None: min_passes = 1 if min_passes <= 0: raise ValueError('min_passes must be positive') # In case @flaky is applied to a function or class without arguments # (and without parentheses), max_runs will refer to the wrapped object. # In this case, the default value can be used. wrapped = None if hasattr(max_runs, '__call__'): wrapped = max_runs max_runs = 2 if max_runs < min_passes: raise ValueError('min_passes cannot be greater than max_runs!') wrapper = attr(**{ FlakyNames.MAX_RUNS: max_runs, FlakyNames.MIN_PASSES: min_passes, FlakyNames.CURRENT_RUNS: 0, FlakyNames.CURRENT_PASSES: 0, }) return wrapper(wrapped) if wrapped is not None else wrapper
def use_vcr(func): """ Decorator for test functions which go online. A vcr cassette will automatically be created and used to capture and play back online interactions. The nose 'vcr' attribute will be set, and the nose 'online' attribute will be set on it based on whether it might go online. The record mode of VCR can be set using the VCR_RECORD_MODE environment variable when running tests. Depending on the record mode, and the existence of an already recorded cassette, this decorator will also dynamically set the nose 'online' attribute. """ module = func.__module__.split('tests.')[-1] class_name = inspect.stack()[1][3] cassette_name = '.'.join([module, class_name, func.__name__]) cassette_path, _ = vcr.get_path_and_merged_config(cassette_name) online = True # Set our nose online attribute based on the VCR record mode if vcr.record_mode == 'none': online = False elif vcr.record_mode == 'once': online = not os.path.exists(cassette_path) func = attr(online=online, vcr=True)(func) # If we are not going online, disable domain delay during test if not online: func = mock.patch('flexget.utils.requests.wait_for_domain', new=mock.MagicMock())(func) # VCR playback on windows needs a bit of help https://github.com/kevin1024/vcrpy/issues/116 if sys.platform.startswith('win') and vcr.record_mode != 'all' and os.path.exists(cassette_path): func = mock.patch('requests.packages.urllib3.connectionpool.is_connection_dropped', new=mock.MagicMock(return_value=False))(func) @wraps(func) def func_with_cassette(*args, **kwargs): with vcr.use_cassette(cassette_name) as cassette: try: func(*args, cassette=cassette, **kwargs) except TypeError: func(*args, **kwargs) if VCR_RECORD_MODE == 'off': return func else: return func_with_cassette
def __call__(self, function): def setup(): args = [ "Xephyr", "-keybd", "evdev", "-name", "qtile_test", self.display, "-ac", "-screen", "%sx%s" % (self.width, self.height) ] if self.two_screens: args.extend( ["-screen", "%sx%s+800+0" % (SECOND_WIDTH, SECOND_HEIGHT)]) if self.xinerama: args.extend(["+xinerama"]) if self.randr: args.extend(["+extension", "RANDR"]) self.sub = subprocess.Popen( args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) time.sleep(0.05) self.testwindows = [] if self.start_qtile: self.startQtile(self.config) def teardown(): if self.start_qtile: libqtile.hook.clear() self.stopQtile() os.kill(self.sub.pid, 9) os.waitpid(self.sub.pid, 0) @wraps(function) def wrapped_fun(): return function(self) return attr('xephyr')(with_setup(setup, teardown)(wrapped_fun))
def __call__(self, function): def setup(): args = [ "Xephyr", "-keybd", "evdev", "-name", "qtile_test", self.display, "-ac", "-screen", "%sx%s" % (self.width, self.height)] if self.two_screens: args.extend(["-screen", "%sx%s+800+0" % ( SECOND_WIDTH, SECOND_HEIGHT)]) if self.xinerama: args.extend(["+xinerama"]) if self.randr: args.extend(["+extension", "RANDR"]) self.sub = subprocess.Popen( args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) time.sleep(0.05) self.testwindows = [] if self.start_qtile: self.startQtile(self.config) def teardown(): if self.start_qtile: libqtile.hook.clear() self.stopQtile() os.kill(self.sub.pid, 9) os.waitpid(self.sub.pid, 0) @wraps(function) def wrapped_fun(): return function(self) return attr('xephyr')(with_setup(setup, teardown)(wrapped_fun))
def slow(f): """Mark test as a slow, although not necessarily integration or usecase test """ return attr('slow')(f)
def integration(f): """Mark test as an "integration" test which generally is not needed to be run Generally tend to be slower """ return attr('integration')(f)
from nose.plugins.attrib import attr gpu = attr('gpu') cudnn = attr('gpu', 'cudnn')
def get_suite(plugin, plugin_kwargs=None, tags=None): if plugin_kwargs is None: plugin_kwargs = {} if tags is None: tags = [] def test_input_d_1_default_remove_mean_threshold_stretch(): arr_in = np.zeros((20, 30, 1), dtype=DTYPE) inker_shape = 5, 5 arr_out = np.zeros((16, 26, 1), dtype=DTYPE) np.random.seed(42) data = np.random.randn(np.prod(arr_in.shape)) arr_in[:] = data.reshape(arr_in.shape) idx = [[4, 3], [20, 12]] gt = np.array([[0.20177312], [0.21249016]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=inker_shape, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=inker_shape, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_input_d_4_div_euclidean_remove_mean_false_default_rest(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 3], [20, 12]] gt = np.array([[ 0.13273999, -0.09456467, -0.01975331, -0.04648187], [ 0.00148955, -0.00257985, 0.02118244, -0.01543736]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=inker_shape, div_method='euclidean', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=inker_shape, div_method='euclidean', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_div_euclidean_remove_mean_false_threshold_1_stretch_1e_2(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 3], [20, 12]] gt = np.array([[ 0.01255756, -0.00894607, -0.00186872, -0.00439731], [ 0.00013929, -0.00024125, 0.00198085, -0.0014436 ]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=inker_shape, div_method='euclidean', remove_mean=False, threshold=1, stretch=1e-2, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=inker_shape, div_method='euclidean', remove_mean=False, threshold=1, stretch=1e-2, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_div_euclidean_remove_mean_true(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 3], [20, 12]] gt = np.array([[ 1.27813682e-01, -9.97862518e-02, -2.48777084e-02, -5.16409911e-02], [ -2.00690944e-02, -2.42322776e-02, 7.76741435e-05, -3.73861268e-02]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=inker_shape, div_method='euclidean', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=inker_shape, div_method='euclidean', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_div_std_remove_mean_false(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 8], [20, 12]] gt = np.array([[ 1.32899761, -0.94678491, -0.19777086, -0.46537822], [ 1.67757177, 0.42027149, -0.70711917, -0.05593578]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=inker_shape, div_method='std', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=inker_shape, div_method='std', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_div_std_remove_mean_true(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 8], [20, 12]] gt = np.array([[ 1.27801514, -0.99776751, -0.2487534 , -0.51636076], [ 1.42037416, 0.16307378, -0.9643169 , -0.31313351]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=inker_shape, div_method='std', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=inker_shape, div_method='std', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_outker_shape_0_div_mag_remove_mean_false(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 outker_shape = 0, 0 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 3], [20, 12]] gt = np.array([[ 0.24052431, -0.18180957, -0.04978044, -0.0898783 ], [ 0.00301287, -0.00500357, 0.04109935, -0.03260877]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=outker_shape, div_method='euclidean', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=outker_shape, div_method='euclidean', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_outker_shape_0_div_mag_remove_mean_true(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 outker_shape = 0, 0 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 3], [20, 12]] gt = np.array([[ 0.18866782, -0.17986178, -0.05663793, -0.06177634], [-0.00420652, -0.03951693, -0.0673274 , -0.05859426]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=outker_shape, div_method='euclidean', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=outker_shape, div_method='euclidean', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_outker_shape_0_div_std_remove_mean_false(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 outker_shape = 0, 0 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 8], [20, 12]] gt = np.array([[ 1.26222396, -0.90901738, -0.24902068, -0.45406818], [ 1.54160333, 0.49371463, -0.80440265, -0.05310058]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=outker_shape, div_method='std', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=outker_shape, div_method='std', remove_mean=False, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_outker_shape_0_div_std_remove_mean_true(): arr_in = np.zeros((20, 30, 4), dtype=DTYPE) inker_shape = 5, 5 outker_shape = 0, 0 arr_out = np.zeros((16, 26, 4), dtype=DTYPE) np.random.seed(42) arr_in[:] = np.random.randn(np.prod(arr_in.shape)).reshape(arr_in.shape) idx = [[4, 8], [20, 12]] gt = np.array([[ 0.94326323, -0.89923584, -0.28315943, -0.30885619], [ 1.27807069, 0.63492846, -1.23798132, -0.50979644]], dtype=DTYPE) lnorm(arr_in, arr_out=arr_out, inker_shape=inker_shape, outker_shape=outker_shape, div_method='std', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) arr_out = lnorm(arr_in, inker_shape=inker_shape, outker_shape=outker_shape, div_method='std', remove_mean=True, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_lena_npy_array(): arr_in = lena()[::32, ::32].astype(DTYPE) idx = [[4, 2], [4, 2]] gt = np.array([0.2178068, 0.30647671], dtype=DTYPE) arr_out = lnorm(arr_in, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) def test_lena_npy_array_non_C_contiguous(): arr_in = lena()[::32, ::32].astype(DTYPE) arr_in = np.asfortranarray(arr_in) idx = [[4, 2], [4, 2]] gt = np.array([0.2178068, 0.30647671], dtype=DTYPE) try: arr_out = lnorm(arr_in, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) except NotImplementedError: raise SkipTest def test_lena_pt3_array(): lena32 = lena()[::32, ::32].astype(DTYPE)/255. arr_in = Array(lena32.shape, dtype=DTYPE) arr_in[:] = lena32 idx = [[4, 2], [4, 2]] gt = np.array([0.21779411, 0.30645376], dtype=DTYPE) arr_out = lnorm(arr_in, plugin=plugin, plugin_kwargs=plugin_kwargs) gv = arr_out[idx] assert_allclose(gv, gt, rtol=RTOL, atol=ATOL) suite = {} if plugin_kwargs: plugin_kwarg_hash = '__kwargs_hash_' + get_pkl_sha1(plugin_kwargs) else: plugin_kwarg_hash = "" for key, value in locals().iteritems(): if isinstance(value, types.FunctionType) and key.startswith('test_'): func = value func.__name__ += '__plugin_%s' % plugin + plugin_kwarg_hash func = attr(*tags)(info(plugin, plugin_kwargs, func)) suite[func.__name__] = func return suite
def multi_gpu(gpu_num): return attrib.attr(gpu=gpu_num)
from nose.plugins import attrib gpu = attrib.attr('gpu') cudnn = attrib.attr('gpu', 'cudnn') def multi_gpu(gpu_num): return attrib.attr(gpu=gpu_num)
class TestAttrClass: from_super = True def ends_with_test(self): pass def test_one(self): pass def test_two(self): pass test_two.from_super = False TestAttrClass = attr('a')(TestAttrClass) class TestAttrSubClass(TestAttrClass): def test_sub_three(self): pass def added_later_test(self): pass TestAttrSubClass.added_later_test = added_later_test class TestClassAndMethodIterAttr(object): foo = [ 'a' ] def test_one(self):
import logging from os import path import time try: from nose.tools import eq_ from nose.plugins.skip import SkipTest from nose.plugins.attrib import attr def skip_test(reason="No reason given to skip_test"): raise SkipTest(reason) mark_slow = attr("slow") except ImportError: import pytest def eq_(a, b): assert a == b def skip_test(reason="No reason given to skip_test"): pytest.skip(reason) def mark_slow(f): return f import _mssql import pymssql class Config(object):
def usecase(f): """Mark test as a usecase user ran into and which (typically) caused bug report to be filed/troubleshooted """ return attr('usecase')(f)
def partitioned(cls): """ Marks a test to be run with the partitioned database settings in addition to the non-partitioned database settings. """ return attr(sql_backend=True)(cls)
def wipd(f): return attr('wip')(f)
from nose.plugins import attrib gpu = attrib.attr('gpu') cudnn = attrib.attr('gpu', 'cudnn') slow = attrib.attr('slow') def multi_gpu(gpu_num): return attrib.attr(gpu=gpu_num)
import sys import imp import shutil import unittest import subprocess import tempfile from contextlib import contextmanager from nose.tools import assert_true, assert_equal from nose.plugins.attrib import attr from nose.plugins.skip import SkipTest if sys.version_info[0] >= 3: basestring = str unit = attr('unit') integration = attr('integration') def cleanfs(paths): """Removes the paths from the file system.""" for p in paths: p = os.path.join(*p) if os.path.isfile(p): os.remove(p) elif os.path.isdir(p): shutil.rmtree(p) def check_cmd(args, cwd, holdsrtn): """Runs a command in a subprocess and verifies that it executed properly. """ if not isinstance(args, basestring):
import os import pickle from nose.plugins.attrib import attr try: import tracer except ImportError: tracer = None bin_location = str(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../../binaries')) if not os.path.isdir(bin_location): raise Exception("Can't find the angr/binaries repo for holding testcases. It should be cloned into the same folder as the rest of your angr modules.") slow_test = attr(speed='slow') TRACE_VERSION = 1 def do_trace(proj, test_name, input_data, **kwargs): """ trace, magic, crash_mode, crash_addr = load_cached_trace(proj, "test_blurble") """ fname = os.path.join(bin_location, 'tests_data', 'runner_traces', '%s_%s_%s.p' % (test_name, os.path.basename(proj.filename), proj.arch.name)) if os.path.isfile(fname): try: with open(fname, 'rb') as f: r = pickle.load(f) if type(r) is tuple and len(r) == 2 and r[1] == TRACE_VERSION: return r[0] except (pickle.UnpicklingError, UnicodeDecodeError):