src/test/java/CustomArrayImplTest.java - master - khomec/homework3

src/test/java/CustomArrayImplTest.java
350 строк9 KB
Your Name
Третье ДЗ
08 ноя 2025, 13:52
08 ноя 2025, 13:529ac2e36
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import ru.sbrf.edu.CustomArrayImpl;

import java.util.ArrayList;

import static org.junit.jupiter.api.Assertions.*;

class CustomArrayImplTest {

    private CustomArrayImpl<Integer> array;

    @BeforeEach
    void setUp() {
        array = new CustomArrayImpl<>();
    }

    @Test
    void testAddAndGet() {
        array.add(10);
        array.add(20);
        array.add(30);

        assertEquals(3, array.size());
        assertEquals(10, array.get(0));
        assertEquals(20, array.get(1));
        assertEquals(30, array.get(2));
    }

    @Test
    void testGetWithInvalidIndex() {
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.get(-1));
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.get(0));
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.get(1));

        array.add(5);
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.get(1));
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.get(-1));
    }

    @Test
    void testSet() {
        array.add(10);
        array.add(20);

        Integer oldValue = array.set(1, 25);
        assertEquals(20, oldValue);
        assertEquals(25, array.get(1));
        assertEquals(2, array.size());
    }

    @Test
    void testSetWithInvalidIndex() {
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.set(0, 10));
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.set(-1, 10));

        array.add(100);
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.set(1, 200));
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.set(-1, 200));
    }

    @Test
    void testRemoveByIndex() {
        array.add(10);
        array.add(20);
        array.add(30);

        array.remove(1);
        assertEquals(2, array.size());
        assertEquals(10, array.get(0));
        assertEquals(30, array.get(1));
    }

    @Test
    void testRemoveFirstElement() {
        array.add(10);
        array.add(20);
        array.add(30);

        array.remove(0);
        assertEquals(2, array.size());
        assertEquals(20, array.get(0));
        assertEquals(30, array.get(1));
    }

    @Test
    void testRemoveLastElement() {
        array.add(10);
        array.add(20);
        array.add(30);

        array.remove(2);
        assertEquals(2, array.size());
        assertEquals(10, array.get(0));
        assertEquals(20, array.get(1));
    }

    @Test
    void testRemoveWithInvalidIndex() {
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.remove(0));
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.remove(-1));

        array.add(10);
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.remove(1));
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.remove(-1));
    }

    @Test
    void testRemoveByValue() {
        array.add(10);
        array.add(20);
        array.add(30);

        assertTrue(array.remove(Integer.valueOf(20)));
        assertEquals(2, array.size());
        assertEquals(10, array.get(0));
        assertEquals(30, array.get(1));

        assertFalse(array.remove(Integer.valueOf(99))); // Несуществующий элемент
        assertEquals(2, array.size());
    }

    @Test
    void testRemoveNullByValue() {
        array.add(10);
        array.add(null);
        array.add(30);

        assertTrue(array.remove(null));
        assertEquals(2, array.size());
        assertEquals(10, array.get(0));
        assertEquals(30, array.get(1));
    }

    @Test
    void testSize() {
        assertEquals(0, array.size());

        array.add(1);
        assertEquals(1, array.size());

        array.add(2);
        array.add(3);
        assertEquals(3, array.size());

        array.remove(0);
        assertEquals(2, array.size());
    }

    @Test
    void testIsEmpty() {
        assertTrue(array.isEmpty());

        array.add(100);
        assertFalse(array.isEmpty());

        array.remove(0);
        assertTrue(array.isEmpty());
    }

    @Test
    void testAddMultipleElementsAndGrow() {
        // Проверяем динамическое расширение
        for (int i = 0; i < 15; i++) {
            array.add(i * 10);
        }

        assertEquals(15, array.size());
        for (int i = 0; i < 15; i++) {
            assertEquals(i * 10, array.get(i));
        }
    }

    @Test
    void testClear() {
        // Метода clear() нет в интерфейсе, поэтому эмулируем очистку
        array.add(10);
        array.add(20);
        array.add(30);

        assertEquals(3, array.size());
        assertFalse(array.isEmpty());

        // Эмулируем clear через удаление всех элементов
        while (!array.isEmpty()) {
            array.remove(0);
        }

        assertEquals(0, array.size());
        assertTrue(array.isEmpty());
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> array.get(0));
    }

    @Test
    void testToString() {
        assertEquals("[ ]", array.toString());

        array.add(1);
        array.add(2);
        array.add(3);

        String result = array.toString();
        assertTrue(result.contains("1"));
        assertTrue(result.contains("2"));
        assertTrue(result.contains("3"));
        assertTrue(result.startsWith("["));
        assertTrue(result.endsWith("]"));
    }

    @Test
    void testAddNull() {
        array.add(null);
        assertEquals(1, array.size());
        assertNull(array.get(0));
    }

    @Test
    void testGenericTypes() {
        CustomArrayImpl<String> stringArray = new CustomArrayImpl<>();
        stringArray.add("hello");
        stringArray.add("world");

        assertEquals("hello", stringArray.get(0));
        assertEquals("world", stringArray.get(1));
        assertEquals(2, stringArray.size());
    }

    @Test
    void testAddAllArray() {
        Integer[] items = {1, 2, 3};
        assertTrue(array.addAll(items));
        assertEquals(3, array.size());
        assertEquals(1, array.get(0));
        assertEquals(2, array.get(1));
        assertEquals(3, array.get(2));
    }

    @Test
    void testAddAllArrayWithNull() {
        assertThrows(IllegalArgumentException.class, () -> array.addAll((Integer[]) null));
    }

    @Test
    void testAddAllAtIndex() {
        array.add(10);
        array.add(40);

        Integer[] items = {20, 30};
        assertTrue(array.addAll(1, items));

        assertEquals(4, array.size());
        assertEquals(10, array.get(0));
        assertEquals(20, array.get(1));
        assertEquals(30, array.get(2));
        assertEquals(40, array.get(3));
    }

    @Test
    void testContains() {
        array.add(10);
        array.add(20);
        array.add(null);

        assertTrue(array.contains(10));
        assertTrue(array.contains(20));
        assertTrue(array.contains(null));
        assertFalse(array.contains(30));
    }

    @Test
    void testIndexOf() {
        array.add(10);
        array.add(20);
        array.add(10);
        array.add(null);

        assertEquals(0, array.indexOf(10));
        assertEquals(1, array.indexOf(20));
        assertEquals(3, array.indexOf(null));
        assertEquals(-1, array.indexOf(99));
    }

    @Test
    void testEnsureCapacity() {
        assertEquals(10, array.getCapacity()); // Начальная емкость по умолчанию

        array.ensureCapacity(20);
        assertTrue(array.getCapacity() >= 20);

        // Добавляем много элементов для проверки автоматического расширения
        for (int i = 0; i < 25; i++) {
            array.add(i);
        }
        assertTrue(array.getCapacity() >= 25);
    }

    @Test
    void testReverse() {
        array.add(1);
        array.add(2);
        array.add(3);

        array.reverse();

        assertEquals(3, array.get(0));
        assertEquals(2, array.get(1));
        assertEquals(1, array.get(2));

        // Проверяем reverse пустого массива
        CustomArrayImpl<Integer> emptyArray = new CustomArrayImpl<>();
        emptyArray.reverse(); // Не должно вызывать исключение
        assertEquals(0, emptyArray.size());
    }

    @Test
    void testToArray() {
        array.add(1);
        array.add(2);
        array.add(3);

        Object[] result = array.toArray();
        assertEquals(3, result.length);
        assertEquals(1, result[0]);
        assertEquals(2, result[1]);
        assertEquals(3, result[2]);
    }

    @Test
    void testConstructors() {
        // Конструктор по умолчанию
        CustomArrayImpl<Integer> defaultArray = new CustomArrayImpl<>();
        assertEquals(0, defaultArray.size());

        // Конструктор с емкостью
        CustomArrayImpl<Integer> capacityArray = new CustomArrayImpl<>(5);
        assertEquals(0, capacityArray.size());

        // Конструктор с коллекцией
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        CustomArrayImpl<Integer> collectionArray = new CustomArrayImpl<>(list);
        assertEquals(3, collectionArray.size());
        assertEquals(1, collectionArray.get(0));
        assertEquals(2, collectionArray.get(1));
        assertEquals(3, collectionArray.get(2));
    }
}