tests.unit.test_numbertheory

Complexity

Total Complexity

112

Size/Duplication

Total Lines	499
Duplicated Lines	0 %

Importance

Changes

0

48 Functions

Rating	Name	Duplication	Size	Complexity
A	test_divisor_count_bad_n_type_float()	0	6	2
A	test_divisor_sum_correctness()	0	13	3
A	test_is_probably_prime_correctness()	0	15	4
A	test_is_probably_prime_bad_n_type_str()	0	6	2
A	test_is_even_bad_n_type_str()	0	4	2
A	test_perfect_power_exponent_bad_n_type_str()	0	6	2
A	test_miller_rabin_bad_n_type_float()	0	6	2
A	test_is_even_correctness()	0	13	3
A	test_divisor_count_bad_n_type_str()	0	6	2
A	test_divisor_sum_aliquot_bad_n_zero()	0	5	2
A	test_perfect_power_exponent_bad_n_type_float()	0	6	2
A	test_miller_rabin_bad_n_type_str()	0	5	2
A	test_miller_rabin_bad_n_too_small()	0	4	2
A	test_is_even_bad_n_type_float()	0	5	2
A	test_sieve_correctness_bound()	0	18	4
A	test_miller_rabin_bad_k_zero()	0	4	2
A	test_divisor_count_bad_n_zero()	0	4	2
A	test_divisor_sum_aliquot_bad_n_type_float()	0	6	2
A	test_divisor_count_correctness()	0	13	3
B	test_factor_correctness_random()	0	24	3
A	test_is_odd_bad_n_type_float()	0	4	2
A	test_sieve_bad_upper_bound_type_str()	0	6	2
A	test_divisor_sum_aliquot_correctness()	0	13	3
A	test_perfect_power_exponent_correctness_square_free()	0	11	3
A	test_factor_bad_n_type_str()	0	4	2
A	test_is_square_bad_n_type_str()	0	5	2
A	test_sieve_bad_upper_bound_negative()	0	4	2
A	test_is_odd_bad_n_type_str()	0	4	2
A	test_sieve_bad_upper_bound_too_big()	0	5	2
A	test_perfect_power_exponent_bad_n_zero()	0	4	2
A	test_is_probably_prime_bad_k_type_float()	0	6	2
A	test_divisor_sum_bad_n_type_float()	0	6	2
A	test_divisor_sum_bad_n_zero()	0	4	2
A	test_miller_rabin_bad_k_type_float()	0	6	2
A	test_is_probably_prime_bad_n_type_float()	0	6	2
A	test_factor_correctness_negative()	0	20	4
A	test_is_square_bad_n_type_float()	0	5	2
A	test_perfect_power_exponent_correctness_not_square_free()	0	12	3
A	test_is_probably_prime_bad_k_type_str()	0	6	2
A	test_is_square_correctness()	0	13	3
A	test_miller_rabin_bad_k_type_str()	0	5	2
A	test_factor_correctness()	0	11	2
A	test_factor_bad_n_type_float()	0	4	2
A	test_divisor_sum_bad_n_type_str()	0	5	2
A	test_divisor_sum_aliquot_bad_n_type_str()	0	6	2
A	test_sieve_correctness()	0	17	3
A	test_is_odd_correctness()	0	13	3
A	test_sieve_bad_upper_bound_type_float()	0	6	2

"""
:mod:`tests.unit.test_numbertheory` -- Unit Tests
=================================================

.. module:: tests.unit.test_numbertheory
   :synopsis: Unit tests for the lib.numbertheory package.

.. moduleauthor:: Bill Maroney <bill@invalid.com>
"""

from collections import Counter
from itertools import takewhile
import pytest
from random import choice, randint

standard import "from random import choice, randint" should be placed before "import pytest"

from lib.util import load_dataset
from lib.numbertheory import is_even, is_odd, is_square
from lib.numbertheory import divisor_count, divisor_sum, divisor_sum_aliquot
from lib.numbertheory import is_probably_prime, sieve
from lib.numbertheory.primality import miller_rabin, eratosthenes, segmented_eratosthenes
from lib.numbertheory import factor
from lib.numbertheory.factorisation import perfect_power_exponent


@pytest.mark.parametrize("value,expected_answer", [(0, True), (1, False), (200, True), (-123, False), (-24, True)])

This line is too long as per the coding-style (115/100).

def test_is_even_correctness(value: int, expected_answer: bool):
    """ Test the correctness of :func:`lib.numbertheory.is_even` using known answer tests

    :param value: the input value
    :param expected_answer: the expected answer
    :raises AssertionError: if :func:`lib.numbertheory.is_even` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.is_even` returns the wrong value
    """

    computed_answer = is_even(value)
    assert isinstance(computed_answer, is_even.__annotations__["return"]), "wrong type"
    assert computed_answer == expected_answer, "wrong answer"


def test_is_even_bad_n_type_str():
    """ Test that :func:`lib.numbertheory.is_even` raises a ``TypeError`` for a non-``int`` value for `n` (``str``) """

This line is too long as per the coding-style (119/100).

    with pytest.raises(TypeError):
        is_even("123")


def test_is_even_bad_n_type_float():
    """ Test that :func:`lib.numbertheory.is_even` raises a ``TypeError`` for a non-``int`` value for `n` (``float``)

This line is too long as per the coding-style (117/100).

    """
    with pytest.raises(TypeError):
        is_even(123.0)


@pytest.mark.parametrize("value,expected_answer", [(0, False), (1, True), (200, False), (-123, True), (-24, False)])

This line is too long as per the coding-style (116/100).

def test_is_odd_correctness(value: int, expected_answer: bool):
    """ Test the correctness of :func:`lib.numbertheory.is_odd` using known answer tests

    :param value: the input value
    :param expected_answer: the expected answer
    :raises AssertionError: if :func:`lib.numbertheory.is_odd` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.is_odd` returns the wrong value
    """

    computed_answer = is_odd(value)
    assert isinstance(computed_answer, is_odd.__annotations__["return"]), "wrong type"
    assert computed_answer == expected_answer, "wrong answer"


def test_is_odd_bad_n_type_str():
    """ Test that :func:`lib.numbertheory.is_odd` raises a ``TypeError`` for a non-``int`` value for `n` (``str``) """

This line is too long as per the coding-style (118/100).

    with pytest.raises(TypeError):
        is_odd("123")


def test_is_odd_bad_n_type_float():
    """ Test that :func:`lib.numbertheory.is_odd` raises a ``TypeError`` for a non-``int`` value for `n` (``float``) """

This line is too long as per the coding-style (120/100).

    with pytest.raises(TypeError):
        is_odd(123.0)


@pytest.mark.parametrize("value,expected_answer", [(0, True), (1, True), (122, False), (16, True), (10000, True)])

This line is too long as per the coding-style (114/100).

def test_is_square_correctness(value: int, expected_answer: bool):
    """ Test the correctness of :func:`lib.numbertheory.is_square` using known answer tests

    :param value: the input value
    :param expected_answer: the expected answer
    :raises AssertionError: if :func:`lib.numbertheory.is_square` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.is_square` returns the wrong value
    """

    computed_answer = is_square(value)
    assert isinstance(computed_answer, is_square.__annotations__["return"]), "wrong type"
    assert computed_answer == expected_answer, "wrong answer"


def test_is_square_bad_n_type_str():
    """ Test that :func:`lib.numbertheory.is_square` raises a ``TypeError`` for a non-``int`` value for `n` (``str``)

This line is too long as per the coding-style (117/100).

    """
    with pytest.raises(TypeError):
        is_square("123")


def test_is_square_bad_n_type_float():
    """ Test that :func:`lib.numbertheory.is_square` raises a ``TypeError`` for a non-``int`` value for `n` (``float``)

This line is too long as per the coding-style (119/100).

    """
    with pytest.raises(TypeError):
        is_square(123.0)


@pytest.mark.parametrize("value,expected_answer", [(1, 1), (17, 2), (10, 4), (30, 8), (275, 6), (10000, 25)])

This line is too long as per the coding-style (109/100).

def test_divisor_count_correctness(value: int, expected_answer: bool):
    """ Test the correctness of :func:`lib.numbertheory.divisor_count` using known answer tests

    :param value: the input value
    :param expected_answer: the expected answer
    :raises AssertionError: if :func:`lib.numbertheory.divisor_count` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.divisor_count` returns the wrong value
    """

    computed_answer = divisor_count(value)
    assert isinstance(computed_answer, divisor_count.__annotations__["return"]), "wrong type"
    assert computed_answer == expected_answer, "wrong answer"


def test_divisor_count_bad_n_type_str():

The name test_divisor_count_bad_n_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.divisor_count` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (111/100).

    (``str``)
    """
    with pytest.raises(TypeError):
        divisor_count("123")


def test_divisor_count_bad_n_type_float():

The name test_divisor_count_bad_n_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.divisor_count` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (111/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        divisor_count(123.0)


def test_divisor_count_bad_n_zero():
    """ Test that :func:`lib.numbertheory.divisor_count` raises a ``ValueError`` for a non-positive value for `n` """

This line is too long as per the coding-style (117/100).

    with pytest.raises(ValueError):
        divisor_count(0)


@pytest.mark.parametrize("value,expected_answer", [(1, 1), (17, 18), (10, 18), (30, 72), (275, 372), (10000, 24211)])

This line is too long as per the coding-style (117/100).

def test_divisor_sum_correctness(value: int, expected_answer: bool):
    """ Test the correctness of :func:`lib.numbertheory.divisor_sum` using known answer tests

    :param value: the input value
    :param expected_answer: the expected answer
    :raises AssertionError: if :func:`lib.numbertheory.divisor_sum` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.divisor_sum` returns the wrong value
    """

    computed_answer = divisor_sum(value)
    assert isinstance(computed_answer, divisor_sum.__annotations__["return"]), "wrong type"
    assert computed_answer == expected_answer, "wrong answer"


def test_divisor_sum_bad_n_type_str():
    """ Test that :func:`lib.numbertheory.divisor_sum` raises a ``TypeError`` for a non-``int`` value for `n` (``str``)

This line is too long as per the coding-style (119/100).

    """
    with pytest.raises(TypeError):
        divisor_sum("123")


def test_divisor_sum_bad_n_type_float():

The name test_divisor_sum_bad_n_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.divisor_sum` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (109/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        divisor_sum(123.0)


def test_divisor_sum_bad_n_zero():
    """ Test that :func:`lib.numbertheory.divisor_sum` raises a ``ValueError`` for a non-positive value for `n` """

This line is too long as per the coding-style (115/100).

    with pytest.raises(ValueError):
        divisor_sum(0)


@pytest.mark.parametrize("value,expected_answer", [(1, 0), (17, 1), (10, 8), (30, 42), (275, 97), (10000, 14211)])

This line is too long as per the coding-style (114/100).

def test_divisor_sum_aliquot_correctness(value: int, expected_answer: bool):

The name test_divisor_sum_aliquot_correctness does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test the correctness of :func:`lib.numbertheory.divisor_sum_aliquot` using known answer tests

This line is too long as per the coding-style (101/100).

    :param value: the input value
    :param expected_answer: the expected answer
    :raises AssertionError: if :func:`lib.numbertheory.divisor_sum_aliquot` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.divisor_sum_aliquot` returns the wrong value
    """

    computed_answer = divisor_sum_aliquot(value)
    assert isinstance(computed_answer, divisor_sum_aliquot.__annotations__["return"]), "wrong type"
    assert computed_answer == expected_answer, "wrong answer"


def test_divisor_sum_aliquot_bad_n_type_str():

The name test_divisor_sum_aliquot_bad_n_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.divisor_sum_aliquot` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (117/100).

    (``str``)
    """
    with pytest.raises(TypeError):
        divisor_sum_aliquot("123")


def test_divisor_sum_aliquot_bad_n_type_float():

The name test_divisor_sum_aliquot_bad_n_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.divisor_sum_aliquot` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (117/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        divisor_sum_aliquot(123.0)


def test_divisor_sum_aliquot_bad_n_zero():

The name test_divisor_sum_aliquot_bad_n_zero does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.divisor_sum_aliquot` raises a ``ValueError`` for a non-positive value for `n`

This line is too long as per the coding-style (119/100).

    """
    with pytest.raises(ValueError):
        divisor_sum_aliquot(0)


def test_is_probably_prime_correctness():

The name test_is_probably_prime_correctness does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test the correctness of :func:`lib.numbertheory.is_probably_prime`

    :raises AssertionError: if :func:`lib.numbertheory.is_probably_prime` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.is_probably_prime` returns the wrong value
    """

    primes = load_dataset("general", "primes", data_type=int)
    primes = set(primes)
    upper_limit = 1000  # artificial cap to limit the run-time of this test
    max_prime = min(upper_limit, max(primes))
    for n in range(1, max_prime + 1):

The name n does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        computed_answer = is_probably_prime(n, k=5)
        assert isinstance(computed_answer, is_probably_prime.__annotations__["return"]), "wrong type"

This line is too long as per the coding-style (101/100).

        assert (n in primes) == computed_answer, "wrong answer"


def test_is_probably_prime_bad_n_type_str():

The name test_is_probably_prime_bad_n_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.is_probably_prime` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (115/100).

    (``str``)
    """
    with pytest.raises(TypeError):
        is_probably_prime("2")


def test_is_probably_prime_bad_n_type_float():

The name test_is_probably_prime_bad_n_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.is_probably_prime` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (115/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        is_probably_prime(2.4)


def test_miller_rabin_bad_n_type_str():

The name test_miller_rabin_bad_n_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.miller_rabin` raises a ``TypeError`` for a non-``int`` value for `n` (``str``)

This line is too long as per the coding-style (120/100).

    """
    with pytest.raises(TypeError):
        miller_rabin("2")


def test_miller_rabin_bad_n_type_float():

The name test_miller_rabin_bad_n_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.miller_rabin` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (110/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        miller_rabin(2.4)


def test_miller_rabin_bad_n_too_small():

The name test_miller_rabin_bad_n_too_small does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.miller_rabin` raises a ``ValueError`` for too small a value for `n` """

This line is too long as per the coding-style (113/100).

    with pytest.raises(ValueError):
        miller_rabin(2)


def test_is_probably_prime_bad_k_type_str():

The name test_is_probably_prime_bad_k_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.is_probably_prime` raises a ``TypeError`` for a non-``int`` value for `k`

This line is too long as per the coding-style (115/100).

    (``str``)
    """
    with pytest.raises(TypeError):
        is_probably_prime(2, "14")


def test_is_probably_prime_bad_k_type_float():

The name test_is_probably_prime_bad_k_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.is_probably_prime` raises a ``TypeError`` for a non-``int`` value for `k`

This line is too long as per the coding-style (115/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        is_probably_prime(2, 12.3)


def test_miller_rabin_bad_k_type_str():

The name test_miller_rabin_bad_k_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.miller_rabin` raises a ``TypeError`` for a non-``int`` value for `k` (``str``)

This line is too long as per the coding-style (120/100).

    """
    with pytest.raises(TypeError):
        miller_rabin(2, "14")


def test_miller_rabin_bad_k_type_float():

The name test_miller_rabin_bad_k_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.miller_rabin` raises a ``TypeError`` for a non-``int`` value for `k`

This line is too long as per the coding-style (110/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        miller_rabin(2, 12.3)


def test_miller_rabin_bad_k_zero():
    """ Test that :func:`lib.numbertheory.miller_rabin` raises a ``ValueError`` for :math:`k=0` """
    with pytest.raises(ValueError):
        miller_rabin(9, 0)


@pytest.mark.parametrize("siever", [sieve, eratosthenes, segmented_eratosthenes])
def test_sieve_correctness(siever):
    """ Test the correctness of all sieves in :func:`lib.numbertheory` including:
        * :func:`lib.numbertheory.primality.sieve`
        * :func:`lib.numbertheory.primality.eratosthenes`
        * :func:`lib.numbertheory.primality.segmented_eratosthenes`

    The integers yielded by these sieves are tested for primality, up to some moderate bound.

    :raises AssertionError: if ``siever(upper_bound)`` yields the wrong type
    :raises AssertionError: if ``siever(upper_bound)`` yields the wrong value
    """

    for p in siever(upper_bound=100):

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        computed_answer = is_probably_prime(p)
        # assert isinstance(computed_answer, sieve.__annotations__["return"]), "wrong type"
        assert computed_answer is True, "wrong answer"


@pytest.mark.parametrize("upper_bound", [100, 10 ** 5, 10 ** 8, 10 ** 10])
def test_sieve_correctness_bound(upper_bound):
    """ Test the correctness of all sieves in :mod:`lib.numbertheory` including:
        * :func:`lib.numbertheory.primality.sieve`
        * :func:`lib.numbertheory.primality.eratosthenes`
        * :func:`lib.numbertheory.primality.segmented_eratosthenes`

    The integers yielded by these sieves are tested for primality, up to some moderate bound. The parameter

This line is too long as per the coding-style (107/100).

    `upper_bound` is set to various values to ensure all sieves are utilised.

    :raises AssertionError: if :func:`lib.numbertheory.sieve` yields the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.sieve` yields the wrong value
    """

    for p in takewhile(lambda _p: _p <= 100, sieve(upper_bound)):

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        computed_answer = is_probably_prime(p)
        # assert isinstance(computed_answer, sieve.__annotations__["return"]), "wrong type"
        assert computed_answer is True, "wrong answer"


def test_sieve_bad_upper_bound_type_str():

The name test_sieve_bad_upper_bound_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.sieve` raises a ``TypeError`` for a non-``int`` value for `upper_bound`

This line is too long as per the coding-style (113/100).

    (``str``)
    """
    with pytest.raises(TypeError):
        sieve("123")


def test_sieve_bad_upper_bound_type_float():

The name test_sieve_bad_upper_bound_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.sieve` raises a ``TypeError`` for a non-``int`` value for `upper_bound`

This line is too long as per the coding-style (113/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        sieve(12.3)


def test_sieve_bad_upper_bound_negative():

The name test_sieve_bad_upper_bound_negative does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.sieve` raises a ``ValueError`` for :math:`\\mbox{upper_bound} \lt 0` """

A suspicious escape sequence \l was found. Did you maybe forget to add an r prefix?

This line is too long as per the coding-style (114/100).

    with pytest.raises(ValueError):
        sieve(-14)


def test_sieve_bad_upper_bound_too_big():

The name test_sieve_bad_upper_bound_too_big does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.sieve` raises a ``ValueError`` for :math:`\\mbox{upper_bound} \ge 10^{16}` """

A suspicious escape sequence \g was found. Did you maybe forget to add an r prefix?

This line is too long as per the coding-style (120/100).

    too_big = 10 ** 20
    with pytest.raises(ValueError):
        sieve(upper_bound=too_big)


@pytest.mark.parametrize("value,expected_answer", [(0, {0: 1}), (1, {1: 1}), (16, {2: 4})])
def test_factor_correctness(value, expected_answer):
    """ Test the correctness of :func:`lib.numbertheory.factor` with known-answer-tests

    :raises AssertionError: if :func:`lib.numbertheory.factor` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.factor` returns the wrong value
    """

    computed_value = factor(value)
    # assert isinstance(computed_value, factor.__annotations__["return"]), "wrong type"
    assert computed_value == expected_answer, "wrong value"


@pytest.mark.parametrize("value,expected_answer", [(16, {2: 4}), (35, {5: 1, 7: 1}), (1001, {7: 1, 11: 1, 13: 1})])

This line is too long as per the coding-style (115/100).

def test_factor_correctness_negative(value, expected_answer):

The name test_factor_correctness_negative does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test the correctness of :func:`lib.numbertheory.factor` with known-answer-tests

    Each `value` is factored. This factorisation is combined with a factor of :math:`-1` to give the expected

This line is too long as per the coding-style (109/100).

    factorisation of :math:`-value`. This negative value is then factored, and the two results are checked for equality.

This line is too long as per the coding-style (120/100).

    :raises AssertionError: if :func:`lib.numbertheory.factor` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.factor` returns the wrong value
    :raises AssertionError: if :func:`lib.numbertheory.factor` doesn't include a factor of :math:`-1`

This line is too long as per the coding-style (101/100).

    """

    computed_value = factor(value)
    # assert isinstance(computed_value, factor.__annotations__["return"]), "wrong type"
    assert computed_value == expected_answer, "wrong value"
    computed_value_negative = factor(-1 * value)
    # assert isinstance(computed_value_negative, factor.__annotations__["return"]), "wrong type"
    assert -1 not in computed_value.keys(), "missing factor of -1"
    computed_value[-1] = 1
    assert computed_value == computed_value_negative, "wrong value"


def test_factor_correctness_random():
    """ Test the correctness of :func:`lib.numbertheory.factor` with known-answer-tests

    A random integer is built as a product of several small primes (selected with replacement); this random integer has

This line is too long as per the coding-style (119/100).

    a known factorisation. :func:`lib.numbertheory.factor` is used to factor the constructed number and it is compared

This line is too long as per the coding-style (118/100).

    to the known and expected factorisation.

    :raises AssertionError: if :func:`lib.numbertheory.factor` returns the wrong type
    :raises AssertionError: if :func:`lib.numbertheory.factor` returns the wrong value
    """

    # First, build a random integer as a product of several small primes (selected with replacement)
    primes = load_dataset("general", "primes", data_type=int)
    value, factorisation = 1, Counter()
    while value < 10 ** 6:
        p = choice(primes)

The name p does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        value *= p
        factorisation[p] += 1
    factorisation = dict(factorisation)

    # Factor the constructed integer and check that it matches the construction
    computed_value = factor(value)
    # assert isinstance(computed_value_negative, factor.__annotations__["return"]), "wrong type"
    assert computed_value == factorisation, "wrong value"


def test_factor_bad_n_type_str():
    """ Test that :func:`lib.numbertheory.factor` raises a ``TypeError`` for a non-``int`` value for `n` (``str``) """

This line is too long as per the coding-style (118/100).

    with pytest.raises(TypeError):
        factor("123")


def test_factor_bad_n_type_float():
    """ Test that :func:`lib.numbertheory.factor` raises a ``TypeError`` for a non-``int`` value for `n` (``float``) """

This line is too long as per the coding-style (120/100).

    with pytest.raises(TypeError):
        factor(145.678)


@pytest.mark.parametrize("square_free", [6, 35, 77])
def test_perfect_power_exponent_correctness_square_free(square_free):

The name test_perfect_power_exponent_correctness_square_free does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test the correctness of :func:`lib.numbertheory.perfect_power_exponent` for square-free inputs

This line is too long as per the coding-style (102/100).

    :raises AssertionError: if :func:`lib.numbertheory.perfect_power_exponent` returns the wrong type

This line is too long as per the coding-style (101/100).

    :raises AssertionError: if :func:`lib.numbertheory.perfect_power_exponent` returns the wrong value

This line is too long as per the coding-style (102/100).

    """

    computed_value = perfect_power_exponent(square_free)
    assert isinstance(computed_value, perfect_power_exponent.__annotations__["return"]), "wrong type"

This line is too long as per the coding-style (101/100).

    assert computed_value == 1, "wrong value"


@pytest.mark.parametrize("square_free", [6, 35, 77])
def test_perfect_power_exponent_correctness_not_square_free(square_free):

The name test_perfect_power_exponent_correctness_not_square_free does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test the correctness of :func:`lib.numbertheory.perfect_power_exponent` for **non** square-free inputs

This line is too long as per the coding-style (110/100).

    :raises AssertionError: if :func:`lib.numbertheory.perfect_power_exponent` returns the wrong type

This line is too long as per the coding-style (101/100).

    :raises AssertionError: if :func:`lib.numbertheory.perfect_power_exponent` returns the wrong value

This line is too long as per the coding-style (102/100).

    """

    exponent = randint(2, 10)  # force each square-free number to be a perfect power
    computed_value = perfect_power_exponent(square_free ** exponent)
    assert isinstance(computed_value, perfect_power_exponent.__annotations__["return"]), "wrong type"

This line is too long as per the coding-style (101/100).

    assert computed_value == exponent, "wrong value"


def test_perfect_power_exponent_bad_n_type_str():

The name test_perfect_power_exponent_bad_n_type_str does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.perfect_power_exponent` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (120/100).

    (``str``)
    """
    with pytest.raises(TypeError):
        perfect_power_exponent("123")


def test_perfect_power_exponent_bad_n_type_float():

The name test_perfect_power_exponent_bad_n_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.perfect_power_exponent` raises a ``TypeError`` for a non-``int`` value for `n`

This line is too long as per the coding-style (120/100).

    (``float``)
    """
    with pytest.raises(TypeError):
        perfect_power_exponent(145.678)


def test_perfect_power_exponent_bad_n_zero():

The name test_perfect_power_exponent_bad_n_zero does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.numbertheory.perfect_power_exponent` raises a ``ValueError`` for :math:`n=0` """

This line is too long as per the coding-style (109/100).

    with pytest.raises(ValueError):
        perfect_power_exponent(0)