tests/tests_numpy_basics.py - develop - oop_nust_misis/NumpyBasics-Plesik

tests/tests_numpy_basics.py
166 строк6 KB
OOP Nust MISIS
Initial commit
29 окт 2025, 18:52
29 окт 2025, 18:520905eea
import pytest
import numpy as np
from numpy_basics import *  # noqa: F403


class TestNumpyBasics:
    """Тесты для базовых заданий по NumPy."""

    def test_task1_create_arrays(self):
        """Тест создания массивов."""
        array_1d, array_2d, zeros_array, ones_array = task1_create_arrays()

        # Проверка одномерного массива
        assert array_1d is not None
        assert np.array_equal(array_1d, np.array([1, 2, 3, 4, 5]))

        # Проверка двумерного массива
        assert array_2d is not None
        assert array_2d.shape == (3, 3)
        expected_2d = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
        assert np.array_equal(array_2d, expected_2d)

        # Проверка массива нулей
        assert zeros_array is not None
        assert zeros_array.shape == (5, 5)
        assert np.all(zeros_array == 0)

        # Проверка массива единиц
        assert ones_array is not None
        assert ones_array.shape == (4, 4)
        assert np.all(ones_array == 1)

    def test_task2_array_operations(self):
        """Тест базовых операций."""
        addition, multiplication, scalar_multiplication, squaring = (
            task2_array_operations()
        )

        assert addition is not None
        assert np.array_equal(addition, np.array([6, 8, 10, 12]))

        assert multiplication is not None
        assert np.array_equal(multiplication, np.array([5, 12, 21, 32]))

        assert scalar_multiplication is not None
        assert np.array_equal(scalar_multiplication, np.array([3, 6, 9, 12]))

        assert squaring is not None
        assert np.array_equal(squaring, np.array([25, 36, 49, 64]))

    def test_task3_indexing_slicing(self):
        """Тест индексации и срезов."""
        element, first_row, last_column, subarray = task3_indexing_slicing()

        assert element == 7
        assert np.array_equal(first_row, np.array([1, 2, 3, 4]))
        assert np.array_equal(last_column, np.array([4, 8, 12]))
        assert np.array_equal(subarray, np.array([[3, 4], [7, 8]]))

    def test_task4_array_properties(self):
        """Тест свойств массивов."""
        shape, ndim, size, dtype = task4_array_properties()

        assert shape == (4, 3)
        assert ndim == 2
        assert size == 12
        assert dtype == np.int64

    def test_task5_reshaping(self):
        """Тест изменения формы."""
        reshaped, flattened, transposed = task5_reshaping()

        assert reshaped.shape == (3, 4)
        assert flattened.shape == (12,)
        assert transposed.shape == (4, 3)
        assert np.array_equal(flattened, np.arange(12))

    def test_task6_aggregate_functions(self):
        """Тест агрегирующих функций."""
        total_sum, average, maximum, minimum, std_dev = task6_aggregate_functions()

        assert total_sum == 45
        assert average == 5.0
        assert maximum == 9
        assert minimum == 1
        assert std_dev > 0  # Стандартное отклонение должно быть положительным

    def test_task7_random_arrays(self):
        """Тест случайных массивов."""
        random_uniform, random_integers, random_normal = task7_random_arrays()

        assert random_uniform.shape == (3, 3)
        assert random_integers.shape == (5,)
        assert random_normal.shape == (2, 4)

        # Проверка диапазонов
        assert np.all(random_uniform >= 0) and np.all(random_uniform <= 1)
        assert np.all(random_integers >= 1) and np.all(random_integers <= 100)

    def test_task8_boolean_indexing(self):
        """Тест булевой индексации."""
        greater_than_5, even_numbers, count_less_than_3 = task8_boolean_indexing()

        assert np.array_equal(greater_than_5, np.array([8, 6, 9, 7]))
        assert np.array_equal(even_numbers, np.array([8, 6, 2, 4]))
        assert count_less_than_3 == 2

    def test_task9_where_function(self):
        """Тест функции np.where."""
        result = task9_where_function()

        expected = np.array([0, 1, 0, 0, 1, 0, 1, 0, 1])
        assert np.array_equal(result, expected)

    def test_task10_stack_arrays(self):
        """Тест объединения массивов."""
        vertical_stack, horizontal_stack = task10_stack_arrays()

        expected_vertical = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
        expected_horizontal = np.array([[1, 2, 5, 6], [3, 4, 7, 8]])

        assert np.array_equal(vertical_stack, expected_vertical)
        assert np.array_equal(horizontal_stack, expected_horizontal)

    def test_task11_broadcasting(self):
        """Тест трансляции."""
        result = task11_broadcasting()

        expected = np.array([[11, 22, 33], [14, 25, 36], [17, 28, 39]])
        assert np.array_equal(result, expected)

    def test_task12_simple_statistics(self):
        """Тест простой статистики."""
        overall_mean, column_means, row_sums = task12_simple_statistics()

        assert overall_mean == 5.0
        assert np.array_equal(column_means, np.array([4.0, 5.0, 6.0]))
        assert np.array_equal(row_sums, np.array([6, 15, 24]))


@pytest.mark.parametrize(
    "function",
    [
        task1_create_arrays,
        task2_array_operations,
        task3_indexing_slicing,
    ],
)
def test_functions_return_values(function):
    """Параметризованный тест возвращаемых значений."""
    result = function()
    assert result is not None
    # Все функции должны возвращать кортежи
    assert isinstance(result, tuple)


def test_demonstrate_operations(capsys):
    """Тест демонстрационной функции."""
    demonstrate_operations()
    captured = capsys.readouterr()
    assert "Демонстрация операций с NumPy" in captured.out
    assert "Исходный массив" in captured.out


if __name__ == "__main__":
    pytest.main([__file__, "-v"])