/* ====================================================================
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================== */

package org.apache.poi.util;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.Test;

/**
 * Class to test IntList
 */
final class TestIntList {
    @Test
    void testConstructors() {
        IntList list = new IntList();

        assertTrue(list.isEmpty());
        list.add(0);
        list.add(1);
        IntList list2 = new IntList(list);

        assertEquals(list, list2);
        IntList list3 = new IntList(2);

        assertTrue(list3.isEmpty());
    }

    @Test
    void testAdd() {
        IntList list = new IntList();
        int[] testArray =
            {
                0, 1, 2, 3, 5
            };

        for (int element : testArray) {
            list.add(element);
        }
        for (int j = 0; j < testArray.length; j++) {
            assertEquals(testArray[j], list.get(j));
        }
        assertEquals(testArray.length, list.size());

        // add at the beginning
        list.add(0, -1);
        assertEquals(-1, list.get(0));
        assertEquals(testArray.length + 1, list.size());
        for (int j = 0; j < testArray.length; j++) {
            assertEquals(testArray[j], list.get(j + 1));
        }

        // add in the middle
        list.add(5, 4);
        assertEquals(4, list.get(5));
        assertEquals(testArray.length + 2, list.size());
        for (int j = 0; j < list.size(); j++) {
            assertEquals(j - 1, list.get(j));
        }

        // add at the end
        list.add(list.size(), 6);
        assertEquals(testArray.length + 3, list.size());
        for (int j = 0; j < list.size(); j++) {
            assertEquals(j - 1, list.get(j));
        }

        // add past end
        IntList list2 = list;
        assertThrows(IndexOutOfBoundsException.class, () -> list2.add(list2.size() + 1, 8));

        // test growth
        list = new IntList(0);
        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        assertEquals(1000, list.size());
        for (int j = 0; j < 1000; j++) {
            assertEquals(j, list.get(j));
        }
        list = new IntList(0);
        for (int j = 0; j < 1000; j++) {
            list.add(0, j);
        }
        assertEquals(1000, list.size());
        for (int j = 0; j < 1000; j++) {
            assertEquals(j, list.get(999 - j));
        }
    }

    @Test
    void testAddAll() {
        IntList list = new IntList();

        for (int j = 0; j < 5; j++) {
            list.add(j);
        }
        IntList list2 = new IntList(0);

        list2.addAll(list);
        list2.addAll(list);
        assertEquals(2 * list.size(), list2.size());
        for (int j = 0; j < 5; j++) {
            assertEquals(list2.get(j), j);
            assertEquals(list2.get(j + list.size()), j);
        }
        IntList empty = new IntList();
        int limit = list.size();

        for (int j = 0; j < limit; j++) {
            assertTrue(list.addAll(j, empty));
            assertEquals(limit, list.size());
        }

        assertThrows(IndexOutOfBoundsException.class, () -> list.addAll(limit + 1, empty));

        // try add at beginning
        empty.addAll(0, list);
        assertEquals(empty, list);

        // try in the middle
        empty.addAll(1, list);
        assertEquals(2 * list.size(), empty.size());
        assertEquals(list.get(0), empty.get(0));
        assertEquals(list.get(0), empty.get(1));
        assertEquals(list.get(1), empty.get(2));
        assertEquals(list.get(1), empty.get(6));
        assertEquals(list.get(2), empty.get(3));
        assertEquals(list.get(2), empty.get(7));
        assertEquals(list.get(3), empty.get(4));
        assertEquals(list.get(3), empty.get(8));
        assertEquals(list.get(4), empty.get(5));
        assertEquals(list.get(4), empty.get(9));

        // try at the end
        empty.addAll(empty.size(), list);
        assertEquals(3 * list.size(), empty.size());
        assertEquals(list.get(0), empty.get(0));
        assertEquals(list.get(0), empty.get(1));
        assertEquals(list.get(0), empty.get(10));
        assertEquals(list.get(1), empty.get(2));
        assertEquals(list.get(1), empty.get(6));
        assertEquals(list.get(1), empty.get(11));
        assertEquals(list.get(2), empty.get(3));
        assertEquals(list.get(2), empty.get(7));
        assertEquals(list.get(2), empty.get(12));
        assertEquals(list.get(3), empty.get(4));
        assertEquals(list.get(3), empty.get(8));
        assertEquals(list.get(3), empty.get(13));
        assertEquals(list.get(4), empty.get(5));
        assertEquals(list.get(4), empty.get(9));
        assertEquals(list.get(4), empty.get(14));
    }

    @Test
    void testAddAllGrow() {
        IntList list = new IntList(0);
        IntList addList = new IntList(0);
        addList.add(1);
        addList.add(2);

        assertTrue(list.addAll(0, addList));
    }

    @Test
    void testClear() {
        IntList list = new IntList();

        for (int j = 0; j < 500; j++) {
            list.add(j);
        }
        assertEquals(500, list.size());
        list.clear();
        assertEquals(0, list.size());
        for (int j = 0; j < 500; j++) {
            list.add(j + 1);
        }
        assertEquals(500, list.size());
        for (int j = 0; j < 500; j++) {
            assertEquals(j + 1, list.get(j));
        }
    }

    @Test
    void testContains() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j += 2) {
            list.add(j);
        }
        for (int j = 0; j < 1000; j++) {
            if (j % 2 == 0) {
                assertTrue(list.contains(j));
            } else {
                assertFalse(list.contains(j));
            }
        }
    }

    @Test
    void testContainsAll() {
        IntList list = new IntList();

        assertTrue(list.containsAll(list));
        for (int j = 0; j < 10; j++) {
            list.add(j);
        }
        IntList list2 = new IntList(list);

        assertTrue(list2.containsAll(list));
        assertTrue(list.containsAll(list2));
        list2.add(10);
        assertTrue(list2.containsAll(list));
        assertFalse(list.containsAll(list2));
        list.add(11);
        assertFalse(list2.containsAll(list));
        assertFalse(list.containsAll(list2));
    }

    @Test
    void testEquals() {
        IntList list = new IntList();

        assertEquals(list, list);
        //noinspection ObjectEqualsNull
        assertNotEquals(null, list);
        IntList list2 = new IntList(200);

        assertEquals(list, list2);
        assertEquals(list2, list);
        assertEquals(list.hashCode(), list2.hashCode());
        list.add(0);
        list.add(1);
        list2.add(1);
        list2.add(0);
        assertNotEquals(list, list2);
        list2.removeValue(1);
        list2.add(1);
        assertEquals(list, list2);
        assertEquals(list2, list);
        assertEquals(list.hashCode(), list2.hashCode());
        list2.add(2);
        assertNotEquals(list, list2);
        assertNotEquals(list2, list);
    }

    @Test
    void testGet() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        for (int j = 0; j < 1000; j++) {
            assertEquals(j, list.get(j));
        }

        assertThrows(IndexOutOfBoundsException.class, () -> list.get(1000));
    }

    @Test
    void testIndexOf() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j / 2);
        }
        for (int j = 0; j < 1000; j++) {
            if (j < 500) {
                assertEquals(j * 2, list.indexOf(j));
            } else {
                assertEquals(-1, list.indexOf(j));
            }
        }
    }

    @Test
    void testIsEmpty() {
        IntList list1 = new IntList();
        IntList list2 = new IntList(1000);
        IntList list3 = new IntList(list1);

        assertTrue(list1.isEmpty());
        assertTrue(list2.isEmpty());
        assertTrue(list3.isEmpty());
        list1.add(1);
        list2.add(2);
        list3 = new IntList(list2);
        assertFalse(list1.isEmpty());
        assertFalse(list2.isEmpty());
        assertFalse(list3.isEmpty());
        list1.clear();
        list2.remove(0);
        list3.removeValue(2);
        assertTrue(list1.isEmpty());
        assertTrue(list2.isEmpty());
        assertTrue(list3.isEmpty());
    }

    @Test
    void testLastIndexOf() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j / 2);
        }
        for (int j = 0; j < 1000; j++) {
            if (j < 500) {
                assertEquals(1 + j * 2, list.lastIndexOf(j));
            } else {
                assertEquals(-1, list.indexOf(j));
            }
        }
    }

    @Test
    void testRemove() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        for (int j = 0; j < 1000; j++) {
            assertEquals(j, list.remove(0));
            assertEquals(999 - j, list.size());
        }
        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        for (int j = 0; j < 1000; j++) {
            assertEquals(999 - j, list.remove(999 - j));
            assertEquals(999 - j, list.size());
        }

        assertThrows(IndexOutOfBoundsException.class, () -> list.remove(0));
    }

    @Test
    void testRemoveValue() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j / 2);
        }
        for (int j = 0; j < 1000; j++) {
            if (j < 500) {
                assertTrue(list.removeValue(j));
                assertTrue(list.removeValue(j));
            }
            assertFalse(list.removeValue(j));
        }
    }

    @Test
    void testRemoveAll() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        IntList listCopy = new IntList(list);
        IntList listOdd = new IntList();
        IntList listEven = new IntList();

        for (int j = 0; j < 1000; j++) {
            if (j % 2 == 0) {
                listEven.add(j);
            } else {
                listOdd.add(j);
            }
        }

        assertTrue(list.removeAll(listEven));
        assertEquals(list, listOdd);

        assertTrue(list.removeAll(listOdd));
        assertTrue(list.isEmpty());

        assertTrue(listCopy.removeAll(listOdd));
        assertEquals(listCopy, listEven);

        assertTrue(listCopy.removeAll(listEven));
        assertTrue(listCopy.isEmpty());

        assertFalse(list.removeAll(listEven));
        assertFalse(list.removeAll(listOdd));
        assertFalse(listCopy.removeAll(listEven));
        assertFalse(listCopy.removeAll(listEven));
    }

    @Test
    void testRetainAll() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        IntList listCopy = new IntList(list);
        IntList listOdd = new IntList();
        IntList listEven = new IntList();

        for (int j = 0; j < 1000; j++) {
            if (j % 2 == 0) {
                listEven.add(j);
            } else {
                listOdd.add(j);
            }
        }
        assertTrue(list.retainAll(listOdd));
        assertEquals(list, listOdd);

        assertTrue(list.retainAll(listEven));
        assertTrue(list.isEmpty());

        assertTrue(listCopy.retainAll(listEven));
        assertEquals(listCopy, listEven);

        assertTrue(listCopy.retainAll(listOdd));
        assertTrue(listCopy.isEmpty());

        assertFalse(list.retainAll(listOdd));
        assertFalse(list.retainAll(listEven));
        assertFalse(listCopy.retainAll(listEven));
        assertFalse(listCopy.retainAll(listOdd));
    }

    @Test
    void testSet() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        for (int j = 0; j < 1000; j++) {
            list.set(j, j + 1);
            assertEquals(j + 1, list.get(j));
        }
        assertThrows(IndexOutOfBoundsException.class, () -> list.set(1000, 1001));
    }

    @Test
    void testSize() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            assertEquals(j, list.size());
            list.add(j);
            assertEquals(j + 1, list.size());
        }
        for (int j = 0; j < 1000; j++) {
            assertEquals(1000 - j, list.size());
            list.removeValue(j);
            assertEquals(999 - j, list.size());
        }
    }

    @Test
    void testToArray() {
        IntList list = new IntList();

        for (int j = 0; j < 1000; j++) {
            list.add(j);
        }
        int[] a1 = list.toArray();

        assertEquals(a1.length, list.size());
        for (int j = 0; j < 1000; j++) {
            assertEquals(a1[j], list.get(j));
        }
        int[] a2 = new int[list.size()];
        int[] a3 = list.toArray(a2);

        assertSame(a2, a3);
        for (int j = 0; j < 1000; j++) {
            assertEquals(a2[j], list.get(j));
        }
        int[] aShort = new int[list.size() - 1];
        int[] aLong = new int[list.size() + 1];
        int[] a4 = list.toArray(aShort);
        int[] a5 = list.toArray(aLong);

        assertNotSame(a4, aShort);
        assertNotSame(a5, aLong);
        assertEquals(a4.length, list.size());
        for (int j = 0; j < 1000; j++) {
            assertEquals(a3[j], list.get(j));
        }
        assertEquals(a5.length, list.size());
        for (int j = 0; j < 1000; j++) {
            assertEquals(a5[j], list.get(j));
        }
    }
}