def test_to_roman(integer, roman_numeral):
"""
Test that `~plasmapy.utils.roman.to_roman` correctly converts
integers to Roman numerals, and that the inverse is true as well.
"""
run_test(func=roman.to_roman, args=integer, expected_outcome=roman_numeral)
run_test(func=roman.from_roman, args=roman_numeral, expected_outcome=int(integer))
def test_from_roman(integer, roman_numeral):
"""
Test that `~plasmapy.utils.roman.from_roman` correctly converts
Roman numerals to integers.
"""
run_test(func=roman.from_roman,
args=roman_numeral,
expected_outcome=int(integer))
def test_from_roman_exceptions(input, expected_exception):
"""
Test that `~plasmapy.utils.roman.from_roman` raises the correct
exceptions when necessary.
"""
run_test(func=roman.from_roman,
args=input,
expected_outcome=expected_exception)
def test_run_test(f, args, kwargs, expected, whaterror):
"""
Test the behavior of the test helper function.
The arguments `f`, `args`, `kwargs`, and `expected` are to be
passed directly to `~plasmapy.utils.run_test`. If the test is
expected to pass, then `whaterror` should be set to `None`. If the
test is expected to fail, then `whaterror` should be set to the
exception that should be raised during the test failure.
This function does not test that the exception messages are correct;
it only checks that the exception messages do not raise any
unexpected exceptions.
Parameters
----------
f : callable
The function or method to be tested.
args : tuple
The positional arguments to be sent to f.
kwargs : dict
The keyword arguments to be sent to f.
expected : object
The expected result from the test, which can be an `object`, an
exception, a warning, or a `tuple` containing the expected
result and the type of warning.
whaterror : exception or None
The type of exception that the test helper function is supposed
to raise, or `None` if the test helper function is not supposed
to raise an exception.
"""
try:
if whaterror is None:
run_test(f, args, kwargs, expected)
else:
with pytest.raises(whaterror):
run_test(f, args, kwargs, expected)
pytest.fail(
f"run_test did not raise an exception for "
f"{call_string(f, args, kwargs, color=None)} "
f"with expected = {repr(expected)} and "
f"whaterror = {repr(whaterror)}."
)
except Exception as spectacular_exception:
raise Exception(
f"An unexpected exception was raised while running "
f"{call_string(f, args, kwargs, color=None)} with "
f"expected = {repr(expected)} and "
f"whaterror = {repr(whaterror)}."
) from spectacular_exception
def test_IonizationState_exceptions(test):
"""
Test that appropriate exceptions are raised for inappropriate inputs
to `IonizationState`.
"""
run_test(
IonizationState,
kwargs=tests_for_exceptions[test].inputs,
expected_outcome=tests_for_exceptions[test].expected_exception,
)
def test_exceptions_upon_instantiation(test_name):
"""
Test that appropriate exceptions are raised for inappropriate inputs
to IonizationStates when first instantiated.
"""
run_test(
IonizationStates,
kwargs=tests_for_exceptions[test_name].inputs,
expected_outcome=tests_for_exceptions[test_name].expected_exception,
)
def test_run_test_atol():
run_test(return_arg, 1.0, {}, 0.999999, atol=1.1e-6, rtol=0.0)
def test_is_roman_numeral(input, expected):
run_test(func=roman.is_roman_numeral,
args=input,
expected_outcome=expected)
def test_run_test_rtol_failure():
with pytest.raises(UnexpectedResultFail):
run_test(return_arg, 1.0, {}, 0.999999, rtol=1e-7)
pytest.fail("No exception raised for rtol test.")
def test_nuclear_table(tested_object, args, kwargs, expected_value):
run_test(tested_object, args, kwargs, expected_value, rtol=1e-3)
def test_to_roman(integer, roman_numeral):
"""
Test that `~plasmapy.utils.roman.to_roman` correctly converts
integers to Roman numerals.
"""
run_test(func=roman.to_roman, args=integer, expected_outcome=roman_numeral)
def test_atomic_functions(inputs):
print(inputs)
run_test(inputs)
def test_run_test_atol_failure():
with pytest.raises(UnexpectedResultError):
run_test(return_arg, (1.0, ), {}, 0.999999, atol=1e-7)
pytest.fail("No exception raised for atol test.")
def test_func(inputs):
"""Test cases originally put in the docstring."""
run_test(inputs)
def test_functions_and_values(tested_function, args, kwargs, expected_output):
run_test(tested_function, args, kwargs, expected_output)
def test_run_test_rtol():
run_test(return_arg, 1.0, {}, 0.999999, rtol=1.1e-6)
def test_is_roman_numeral(argument, expected):
run_test(func=roman.is_roman_numeral, args=argument, expected_outcome=expected)
def test_to_roman_exceptions(function, argument, expected_exception):
"""
Test that `~plasmapy.utils.roman` functions raise the correct
exceptions when necessary.
"""
run_test(func=function, args=argument, expected_outcome=expected_exception)
def test_nuclear(test_inputs):
run_test(*test_inputs, rtol=1e-3)
