File manager - Edit - /opt/alt/python35/lib/python3.5/site-packages/joblib/test/test_func_inspect.py
Back
""" Test the func_inspect module. """ # Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org> # Copyright (c) 2009 Gael Varoquaux # License: BSD Style, 3 clauses. import os import shutil import nose import tempfile import functools import sys from joblib.func_inspect import filter_args, get_func_name, get_func_code from joblib.func_inspect import _clean_win_chars, format_signature from joblib.memory import Memory from joblib.test.common import with_numpy from joblib.testing import assert_raises_regex from joblib._compat import PY3_OR_LATER ############################################################################### # Module-level functions, for tests def f(x, y=0): pass def g(x, y=1): """ A module-level function for testing purposes. """ return x ** 2 + y def f2(x): pass # Create a Memory object to test decorated functions. # We should be careful not to call the decorated functions, so that # cache directories are not created in the temp dir. temp_folder = tempfile.mkdtemp(prefix="joblib_test_func_inspect_") mem = Memory(cachedir=temp_folder) def teardown_module(): if os.path.exists(temp_folder): try: shutil.rmtree(temp_folder) except Exception as e: print("Failed to delete temporary folder %s: %r" % (temp_folder, e)) @mem.cache def g(x): return x def h(x, y=0, *args, **kwargs): pass def i(x=1): pass def j(x, y, **kwargs): pass def k(*args, **kwargs): pass class Klass(object): def f(self, x): return x ############################################################################### # Tests def test_filter_args(): yield nose.tools.assert_equal, filter_args(f, [], (1, )),\ {'x': 1, 'y': 0} yield nose.tools.assert_equal, filter_args(f, ['x'], (1, )),\ {'y': 0} yield nose.tools.assert_equal, filter_args(f, ['y'], (0, )),\ {'x': 0} yield nose.tools.assert_equal, filter_args(f, ['y'], (0, ), dict(y=1)), {'x': 0} yield nose.tools.assert_equal, filter_args(f, ['x', 'y'], (0, )), {} yield nose.tools.assert_equal, filter_args(f, [], (0,), dict(y=1)), {'x': 0, 'y': 1} yield nose.tools.assert_equal, filter_args(f, ['y'], (), dict(x=2, y=1)), {'x': 2} yield nose.tools.assert_equal, filter_args(i, [], (2, )), {'x': 2} yield nose.tools.assert_equal, filter_args(f2, [], (), dict(x=1)), {'x': 1} def test_filter_args_method(): obj = Klass() nose.tools.assert_equal(filter_args(obj.f, [], (1, )), {'x': 1, 'self': obj}) def test_filter_varargs(): yield nose.tools.assert_equal, filter_args(h, [], (1, )), \ {'x': 1, 'y': 0, '*': [], '**': {}} yield nose.tools.assert_equal, filter_args(h, [], (1, 2, 3, 4)), \ {'x': 1, 'y': 2, '*': [3, 4], '**': {}} yield nose.tools.assert_equal, filter_args(h, [], (1, 25), dict(ee=2)), \ {'x': 1, 'y': 25, '*': [], '**': {'ee': 2}} yield nose.tools.assert_equal, filter_args(h, ['*'], (1, 2, 25), dict(ee=2)), \ {'x': 1, 'y': 2, '**': {'ee': 2}} def test_filter_kwargs(): nose.tools.assert_equal(filter_args(k, [], (1, 2), dict(ee=2)), {'*': [1, 2], '**': {'ee': 2}}) nose.tools.assert_equal(filter_args(k, [], (3, 4)), {'*': [3, 4], '**': {}}) def test_filter_args_2(): nose.tools.assert_equal(filter_args(j, [], (1, 2), dict(ee=2)), {'x': 1, 'y': 2, '**': {'ee': 2}}) nose.tools.assert_raises(ValueError, filter_args, f, 'a', (None, )) # Check that we capture an undefined argument nose.tools.assert_raises(ValueError, filter_args, f, ['a'], (None, )) ff = functools.partial(f, 1) # filter_args has to special-case partial nose.tools.assert_equal(filter_args(ff, [], (1, )), {'*': [1], '**': {}}) nose.tools.assert_equal(filter_args(ff, ['y'], (1, )), {'*': [1], '**': {}}) def test_func_name(): yield nose.tools.assert_equal, 'f', get_func_name(f)[1] # Check that we are not confused by the decoration yield nose.tools.assert_equal, 'g', get_func_name(g)[1] def test_func_inspect_errors(): # Check that func_inspect is robust and will work on weird objects nose.tools.assert_equal(get_func_name('a'.lower)[-1], 'lower') nose.tools.assert_equal(get_func_code('a'.lower)[1:], (None, -1)) ff = lambda x: x nose.tools.assert_equal(get_func_name(ff, win_characters=False)[-1], '<lambda>') nose.tools.assert_equal(get_func_code(ff)[1], __file__.replace('.pyc', '.py')) # Simulate a function defined in __main__ ff.__module__ = '__main__' nose.tools.assert_equal(get_func_name(ff, win_characters=False)[-1], '<lambda>') nose.tools.assert_equal(get_func_code(ff)[1], __file__.replace('.pyc', '.py')) if PY3_OR_LATER: exec(""" def func_with_kwonly_args(a, b, *, kw1='kw1', kw2='kw2'): pass def func_with_signature(a: int, b: int) -> None: pass """) def test_filter_args_python_3(): nose.tools.assert_equal( filter_args(func_with_kwonly_args, [], (1, 2), {'kw1': 3, 'kw2': 4}), {'a': 1, 'b': 2, 'kw1': 3, 'kw2': 4}) # filter_args doesn't care about keyword-only arguments so you # can pass 'kw1' into *args without any problem assert_raises_regex( ValueError, "Keyword-only parameter 'kw1' was passed as positional parameter", filter_args, func_with_kwonly_args, [], (1, 2, 3), {'kw2': 2}) nose.tools.assert_equal( filter_args(func_with_kwonly_args, ['b', 'kw2'], (1, 2), {'kw1': 3, 'kw2': 4}), {'a': 1, 'kw1': 3}) nose.tools.assert_equal( filter_args(func_with_signature, ['b'], (1, 2)), {'a': 1}) def test_bound_methods(): """ Make sure that calling the same method on two different instances of the same class does resolv to different signatures. """ a = Klass() b = Klass() nose.tools.assert_not_equal(filter_args(a.f, [], (1, )), filter_args(b.f, [], (1, ))) def test_filter_args_error_msg(): """ Make sure that filter_args returns decent error messages, for the sake of the user. """ nose.tools.assert_raises(ValueError, filter_args, f, []) def test_clean_win_chars(): string = r'C:\foo\bar\main.py' mangled_string = _clean_win_chars(string) for char in ('\\', ':', '<', '>', '!'): nose.tools.assert_false(char in mangled_string) def test_format_signature(): # Test signature formatting. path, sgn = format_signature(g, list(range(10))) nose.tools.assert_equal(sgn, 'g([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])') path, sgn = format_signature(g, list(range(10)), y=list(range(10))) nose.tools.assert_equal(sgn, 'g([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],' ' y=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])') @with_numpy def test_format_signature_numpy(): """ Test the format signature formatting with numpy. """ def test_special_source_encoding(): from joblib.test.test_func_inspect_special_encoding import big5_f func_code, source_file, first_line = get_func_code(big5_f) nose.tools.assert_equal(first_line, 5) nose.tools.assert_true("def big5_f():" in func_code) nose.tools.assert_true("test_func_inspect_special_encoding" in source_file) def _get_code(): from joblib.test.test_func_inspect_special_encoding import big5_f return get_func_code(big5_f)[0] def test_func_code_consistency(): from joblib.parallel import Parallel, delayed codes = Parallel(n_jobs=2)(delayed(_get_code)() for _ in range(5)) nose.tools.assert_equal(len(set(codes)), 1)
| ver. 1.4 |
Github
|
.
| PHP 7.3.33 | Generation time: 0.09 |
proxy
|
phpinfo
|
Settings