ArrayUtilsGetDimensionsTest.java

/*
 * 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
 *
 *      https://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.commons.lang3;

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

import java.util.stream.Stream;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

class ArrayUtilsGetDimensionsTest extends AbstractLangTest {

    // Tests cyclic references
    static class Node {

        String name;

        Node next;

        Node(final String name) {
            this.name = name;
        }
    }

    private static Stream<Arguments> provideArraysWithExpectedDimensions() {
        return Stream.of(Arguments.of(new int[] { 1, 2, 3 }, 1), Arguments.of(new int[][] { { 1, 2 }, { 3, 4 } }, 2),
                Arguments.of(new int[][][] { { { 1 } } }, 3), Arguments.of(new String[] { "a", "b" }, 1), Arguments.of(new String[][] { { "a" }, { "b" } }, 2),
                Arguments.of(new Object[5], 1), Arguments.of(new boolean[2][3], 2), Arguments.of(new char[1][2][3][4], 4));
    }

    @Test
    void testArraysOfArrays() {
        final Object[] arrayOfArrays = { new int[] { 1, 2 }, new String[] { "a", "b" } };
        assertEquals(1, ArrayUtils.getDimensions(arrayOfArrays));
    }

    @Test
    void testArraysWithCyclicObjects() {
        final Node node1 = new Node("A");
        final Node node2 = new Node("B");
        node1.next = node2;
        node2.next = node1; // Create cycle
        final Node[] arr = { node1, node2 };
        assertEquals(1, ArrayUtils.getDimensions(arr));
        final Node[][] arr2D = { { node1, node2 }, { node2, node1 } };
        assertEquals(2, ArrayUtils.getDimensions(arr2D));
    }

    @Test
    void testArraysWithNullElements() {
        final String[] arrWithNull = { null, "test", null };
        assertEquals(1, ArrayUtils.getDimensions(arrWithNull));
        final String[][] arr2DWithNull = { { null, "a" }, null, { "b" } };
        assertEquals(2, ArrayUtils.getDimensions(arr2DWithNull));
    }

    @Test
    void testEmptyOneDimensionalArrays() {
        assertEquals(1, ArrayUtils.getDimensions(new int[0]));
        assertEquals(1, ArrayUtils.getDimensions(new String[0]));
    }

    @Test
    void testHighDimensionalArrays() {
        assertEquals(4, ArrayUtils.getDimensions(new int[1][2][3][4]));
        assertEquals(5, ArrayUtils.getDimensions(new byte[1][1][1][1][1]));
        assertEquals(6, ArrayUtils.getDimensions(new String[2][2][2][2][2][2]));
    }

    @Test
    void testInitializedArrays() {
        final int[] arr1D = { 1, 2, 3, 4, 5 };
        assertEquals(1, ArrayUtils.getDimensions(arr1D));
        final int[][] arr2D = { { 1, 2, 3 }, { 4, 5, 6 } };
        assertEquals(2, ArrayUtils.getDimensions(arr2D));
        final int[][][] arr3D = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };
        assertEquals(3, ArrayUtils.getDimensions(arr3D));
    }

    @Test
    void testJaggedArrays() {
        final int[][] jagged = { { 1, 2 }, { 3, 4, 5 }, { 6 } };
        assertEquals(2, ArrayUtils.getDimensions(jagged));
        final String[][] jaggedStrings = { { "a" }, { "b", "c", "d" } };
        assertEquals(2, ArrayUtils.getDimensions(jaggedStrings));
    }

    @Test
    void testNonArrayObject() {
        assertEquals(0, ArrayUtils.getDimensions("Not an array"));
        assertEquals(0, ArrayUtils.getDimensions(42));
        assertEquals(0, ArrayUtils.getDimensions(new Object()));
        assertEquals(0, ArrayUtils.getDimensions(3.14));
    }

    @Test
    void testNullArray() {
        assertEquals(0, ArrayUtils.getDimensions(null));
    }

    @Test
    void testOneDimensionalObjectArrays() {
        assertEquals(1, ArrayUtils.getDimensions(new String[5]));
        assertEquals(1, ArrayUtils.getDimensions(new Object[10]));
        assertEquals(1, ArrayUtils.getDimensions(new Integer[3]));
    }

    @Test
    void testOneDimensionalPrimitiveArrays() {
        assertEquals(1, ArrayUtils.getDimensions(new int[5]));
        assertEquals(1, ArrayUtils.getDimensions(new byte[10]));
        assertEquals(1, ArrayUtils.getDimensions(new short[3]));
        assertEquals(1, ArrayUtils.getDimensions(new long[7]));
        assertEquals(1, ArrayUtils.getDimensions(new float[4]));
        assertEquals(1, ArrayUtils.getDimensions(new double[6]));
        assertEquals(1, ArrayUtils.getDimensions(new boolean[2]));
        assertEquals(1, ArrayUtils.getDimensions(new char[8]));
    }

    @Test
    void testThreeDimensionalArrays() {
        assertEquals(3, ArrayUtils.getDimensions(new int[2][3][4]));
        assertEquals(3, ArrayUtils.getDimensions(new String[1][2][3]));
        assertEquals(3, ArrayUtils.getDimensions(new Object[5][5][5]));
    }

    @Test
    void testTwoDimensionalArrays() {
        assertEquals(2, ArrayUtils.getDimensions(new int[3][4]));
        assertEquals(2, ArrayUtils.getDimensions(new String[2][5]));
        assertEquals(2, ArrayUtils.getDimensions(new double[1][1]));
    }

    @ParameterizedTest
    @MethodSource("provideArraysWithExpectedDimensions")
    void testVariousArrayTypes(final Object array, final int expectedDimensions) {
        assertEquals(expectedDimensions, ArrayUtils.getDimensions(array));
    }
}