tests.unit.test_grouptheory

Complexity

Total Complexity

15

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Importance

Changes

0

7 Functions

Rating	Name	Duplication	Size	Complexity
A	test_multiplicative_order_bad_a_n_not_coprime()	0	4	2
A	test_multiplicative_order_bad_a_type_str()	0	6	2
A	test_multiplicative_order_bad_n_type_str()	0	6	2
A	test_multiplicative_order_bad_n_zero()	0	5	2
A	test_multiplicative_order_bad_n_type_float()	0	6	2
A	test_multiplicative_order_correctness()	0	14	3
A	test_multiplicative_order_bad_a_type_float()	0	6	2

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

.. module:: tests.unit.test_grouptheory
   :synopsis: Unit tests for the lib.grouptheory module.

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

import pytest

from lib.grouptheory import multiplicative_order


@pytest.mark.parametrize("a,n,order", [(2, 7, 3), (10, 99, 2), (937, 9008, 562), (2, 11111111111, 6158856)])

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

def test_multiplicative_order_correctness(a: int, n: int, order: int):

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

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

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

    """ Test the correctness of :func:`lib.grouptheory.multiplicative_order` using known answer tests

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

    :param a: the base input value
    :param n: the modulus defining the multiplicative group
    :param order: the expected answer, i.e. :math:`ord_n(a)`
    :raises AssertionError: if :func:`lib.grouptheory.multiplicative_order` returns the wrong type
    :raises AssertionError: if :func:`lib.grouptheory.multiplicative_order` returns the wrong value
    """

    computed_answer = multiplicative_order(a, n)
    assert isinstance(computed_answer, multiplicative_order.__annotations__["return"]), "wrong type"
    assert computed_answer == order, "wrong answer"


def test_multiplicative_order_bad_a_type_str():

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

    """ Test that :func:`lib.grouptheory.multiplicative_order` raises a ``TypeError`` for a non-``int`` value for `a`

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

    (``str``)
    """
    with pytest.raises(TypeError):
        multiplicative_order("123", 10)


def test_multiplicative_order_bad_a_type_float():

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

    """ Test that :func:`lib.grouptheory.multiplicative_order` raises a ``TypeError`` for a non-``int`` value for `a`

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

    (``float``)
    """
    with pytest.raises(TypeError):
        multiplicative_order(123.0, 10)


def test_multiplicative_order_bad_n_type_str():

The name test_multiplicative_order_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.grouptheory.multiplicative_order` 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):
        multiplicative_order(2, "123")


def test_multiplicative_order_bad_n_type_float():

The name test_multiplicative_order_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.grouptheory.multiplicative_order` 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):
        multiplicative_order(2, 123.0)


def test_multiplicative_order_bad_n_zero():

The name test_multiplicative_order_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.grouptheory.multiplicative_order` 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):
        multiplicative_order(2, 0)


def test_multiplicative_order_bad_a_n_not_coprime():

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

    """ Test that :func:`lib.grouptheory.multiplicative_order` raises a ``ValueError`` for non co-prime `a,n` """

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

    with pytest.raises(ValueError):
        multiplicative_order(2, 4)