/*
    * 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.beanutils2;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  import static org.junit.jupiter.api.Assumptions.assumeTrue;
  
  import java.beans.IndexedPropertyDescriptor;
  import java.beans.PropertyDescriptor;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.commons.beanutils2.bugs.other.Jira492IndexedListsSupport;
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * <p>
   * Test Case for the Indexed Properties.
   * </p>
   */
  
  public class IndexedPropertyTest {
  
      /**
       * The test bean for each test.
       */
      private IndexedTestBean bean;
      private BeanUtilsBean beanUtilsBean;
      private PropertyUtilsBean propertyUtilsBean;
      private String[] testArray;
      private String[] newArray;
      private List<String> testList;
      private List<Object> newList;
      private ArrayList<Object> arrayList;
  
      /**
       * Sets up instance variables required by this test case.
       */
      @BeforeEach
      public void setUp() {
  
          // BeanUtils
          beanUtilsBean = new BeanUtilsBean();
          propertyUtilsBean = beanUtilsBean.getPropertyUtils();
  
          // initialize Arrays and Lists
          testArray = new String[] { "array-0", "array-1", "array-2" };
          newArray = new String[] { "newArray-0", "newArray-1", "newArray-2" };
  
          testList = new ArrayList<>();
          testList.add("list-0");
          testList.add("list-1");
          testList.add("list-2");
  
          newList = new ArrayList<>();
          newList.add("newList-0");
          newList.add("newList-1");
          newList.add("newList-2");
  
          arrayList = new ArrayList<>();
          arrayList.add("arrayList-0");
          arrayList.add("arrayList-1");
          arrayList.add("arrayList-2");
  
          // initialize Test Bean properties
          bean = new IndexedTestBean();
          bean.setStringArray(testArray);
          bean.setStringList(testList);
          bean.setArrayList(arrayList);
      }
  
      /**
       * Tear down instance variables required by this test case.
       */
      @AfterEach
      public void tearDown() {
          bean = null;
      }
  
      /**
       * Test IndexedPropertyDescriptor for an Array
      */
     @Test
     public void testArrayIndexedPropertyDescriptor() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringArray");
         assertNotNull(descriptor, "No Array Descriptor");
         assertEquals(IndexedPropertyDescriptor.class, descriptor.getClass(), "Not IndexedPropertyDescriptor");
         assertEquals(testArray.getClass(), descriptor.getPropertyType(), "PropertyDescriptor Type invalid");
     }
 
     /**
      * Test Indexed Read Method for an Array
      */
     @Test
     public void testArrayIndexedReadMethod() throws Exception {
         final IndexedPropertyDescriptor descriptor = (IndexedPropertyDescriptor) propertyUtilsBean.getPropertyDescriptor(bean, "stringArray");
         assertNotNull(descriptor.getIndexedReadMethod(), "No Array Indexed Read Method");
     }
 
     /**
      * Test Indexed Write Method for an Array
      */
     @Test
     public void testArrayIndexedWriteMethod() throws Exception {
         final IndexedPropertyDescriptor descriptor = (IndexedPropertyDescriptor) propertyUtilsBean.getPropertyDescriptor(bean, "stringArray");
         assertNotNull(descriptor.getIndexedWriteMethod(), "No Array Indexed Write Method");
     }
 
     /**
      * Test IndexedPropertyDescriptor for an ArrayList
      */
     @Test
     public void testArrayListIndexedPropertyDescriptor() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "arrayList");
         assertNotNull(descriptor, "No ArrayList Descriptor");
         if (Jira492IndexedListsSupport.supportsIndexedLists()) {
             assertEquals(IndexedPropertyDescriptor.class, descriptor.getClass(), "Not IndexedPropertyDescriptor");
         }
         assertEquals(ArrayList.class, descriptor.getPropertyType(), "PropertyDescriptor Type invalid");
     }
 
     /**
      * Test Read Method for an ArrayList
      */
     @Test
     public void testArrayListReadMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "arrayList");
         assertNotNull(descriptor.getReadMethod(), "No ArrayList Read Method");
     }
 
     /**
      * Test Write Method for an ArrayList
      */
     @Test
     public void testArrayListWriteMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "arrayList");
         assertNotNull(descriptor.getWriteMethod(), "No ArrayList Write Method");
     }
 
     /**
      * Test Read Method for an Array
      */
     @Test
     public void testArrayReadMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringArray");
         assertNotNull(descriptor.getReadMethod(), "No Array Read Method");
     }
 
     /**
      * Test Write Method for an Array
      */
     @Test
     public void testArrayWriteMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringArray");
         assertNotNull(descriptor.getWriteMethod(), "No Array Write Method");
     }
 
     /**
      * Test getting an array property
      */
     @Test
     public void testGetArray() throws Exception {
         assertEquals(testArray, propertyUtilsBean.getProperty(bean, "stringArray"));
     }
 
     /**
      * Test getting an array property as a String
      *
      * NOTE: Why does retrieving array just return the first element in the array, whereas retrieving a List returns a comma separated list of all the elements?
      */
     @Test
     public void testGetArrayAsString() throws Exception {
         assertEquals("array-0", beanUtilsBean.getProperty(bean, "stringArray"));
     }
 
     /**
      * Test getting an indexed item of an Array using getProperty("name[x]")
      */
     @Test
     public void testGetArrayItemA() throws Exception {
         assertEquals("array-1", beanUtilsBean.getProperty(bean, "stringArray[1]"));
     }
 
     /**
      * Test getting an indexed item of an Array using getIndexedProperty("name")
      */
     @Test
     public void testGetArrayItemB() throws Exception {
         assertEquals("array-1", beanUtilsBean.getIndexedProperty(bean, "stringArray", 1));
     }
 
     /**
      * Test getting an ArrayList
      */
     @Test
     public void testGetArrayList() throws Exception {
         assertEquals(arrayList, propertyUtilsBean.getProperty(bean, "arrayList"));
     }
 
     /**
      * Test getting a List
      *
      * JDK 1.3.1_04: Test Passes JDK 1.4.2_05: Test Fails - fails NoSuchMethodException, i.e. reason as testListReadMethod() failed.
      */
     @Test
     public void testGetList() throws Exception {
         assertEquals(testList, propertyUtilsBean.getProperty(bean, "stringList"));
     }
 
     /**
      * Test getting a List property as a String
      *
      * JDK 1.3.1_04: Test Passes JDK 1.4.2_05: Test Fails - fails NoSuchMethodException, i.e. reason as testListReadMethod() failed.
      */
     @Test
     public void testGetListAsString() throws Exception {
         assertEquals("list-0", beanUtilsBean.getProperty(bean, "stringList"));
     }
 
     /**
      * Test getting an indexed item of a List using getProperty("name[x]")
      */
     @Test
     public void testGetListItemA() throws Exception {
         assertEquals("list-1", beanUtilsBean.getProperty(bean, "stringList[1]"));
     }
 
     /**
      * Test getting an indexed item of a List using getIndexedProperty("name")
      */
     @Test
     public void testGetListItemB() throws Exception {
         assertEquals("list-1", beanUtilsBean.getIndexedProperty(bean, "stringList", 1));
     }
 
     /**
      * Test IndexedPropertyDescriptor for a List
      */
     @Test
     public void testListIndexedPropertyDescriptor() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringList");
         assertNotNull(descriptor, "No List Descriptor");
         if (Jira492IndexedListsSupport.supportsIndexedLists()) {
             // BEANUTILS-492 - can't assume lists are handled as arrays in Java 8+
             assertEquals(IndexedPropertyDescriptor.class, descriptor.getClass(), "Not IndexedPropertyDescriptor");
         }
         assertEquals(List.class, descriptor.getPropertyType(), "PropertyDescriptor Type invalid");
     }
 
     /**
      * Test Indexed Read Method for a List
      */
     @Test
     public void testListIndexedReadMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringList");
         assertNotNull(descriptor, "stringList descriptor not found");
         assumeTrue(Jira492IndexedListsSupport.supportsIndexedLists(), "JDK does not support index bean properties on java.util.List");
         assertNotNull(((IndexedPropertyDescriptor) descriptor).getIndexedReadMethod(), "No List Indexed Read Method");
     }
 
     /**
      * Test Indexed Write Method for a List
      */
     @Test
     public void testListIndexedWriteMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringList");
         assertNotNull(descriptor, "stringList descriptor not found");
         assumeTrue(Jira492IndexedListsSupport.supportsIndexedLists(), "JDK does not support index bean properties on java.util.List");
         assertNotNull(((IndexedPropertyDescriptor) descriptor).getIndexedWriteMethod(), "No List Indexed Write Method");
     }
 
     /**
      * Test Read Method for a List
      *
      * JDK 1.3.1_04: Test Passes JDK 1.4.2_05: Test Fails - getter which returns java.util.List not returned by IndexedPropertyDescriptor.getReadMethod();
      */
     @Test
     public void testListReadMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringList");
         assertNotNull(descriptor.getReadMethod(), "No List Read Method");
     }
 
     /**
      * Test Write Method for a List
      *
      * JDK 1.3.1_04: Test Passes JDK 1.4.2_05: Test Fails - setter which java.util.List argument not returned by IndexedPropertyDescriptor.getWriteMethod();
      */
     @Test
     public void testListWriteMethod() throws Exception {
         final PropertyDescriptor descriptor = propertyUtilsBean.getPropertyDescriptor(bean, "stringList");
         assertNotNull(descriptor.getWriteMethod(), "No List Write Method");
     }
 
     /**
      * Test setting an Array property
      *
      * JDK 1.3.1_04 and 1.4.2_05: Test Fails - IllegalArgumentException can't invoke setter, argument type mismatch
      *
      * Fails because of a bug in BeanUtilsBean.setProperty() method. Value is always converted to the array's component type which in this case is a String.
      * Then it calls the setStringArray(String[]) passing a String rather than String[] causing this exception. If there isn't an "index" value then the
      * PropertyType (rather than IndexedPropertyType) should be used.
      */
     @Test
     public void testSetArray() throws Exception {
         beanUtilsBean.setProperty(bean, "stringArray", newArray);
         final Object value = bean.getStringArray();
         assertEquals(newArray.getClass(), value.getClass(), "Type is different");
         final String[] array = (String[]) value;
         assertEquals(newArray.length, array.length, "Array Length is different");
         for (int i = 0; i < array.length; i++) {
             assertEquals(newArray[i], array[i], "Element " + i + " is different");
         }
     }
 
     /**
      * Test setting an indexed item of an Array using setProperty("name[x]", value)
      */
     @Test
     public void testSetArrayItemA() throws Exception {
         beanUtilsBean.setProperty(bean, "stringArray[1]", "modified-1");
         assertEquals("modified-1", bean.getStringArray(1));
     }
 
     /**
      * Test setting an indexed item of an Array using setIndexedProperty("name", value)
      */
     @Test
     public void testSetArrayItemB() throws Exception {
         propertyUtilsBean.setIndexedProperty(bean, "stringArray", 1, "modified-1");
         assertEquals("modified-1", bean.getStringArray(1));
     }
 
     /**
      * Test setting an ArrayList property
      */
     @Test
     public void testSetArrayList() throws Exception {
         beanUtilsBean.setProperty(bean, "arrayList", newList);
         final Object value = bean.getArrayList();
         assertEquals(newList.getClass(), value.getClass(), "Type is different");
         final List<?> list = (List<?>) value;
         assertEquals(newList.size(), list.size(), "List size is different");
         for (int i = 0; i < list.size(); i++) {
             assertEquals(newList.get(i), list.get(i), "Element " + i + " is different");
         }
     }
 
     /**
      * Test setting a List property
      *
      * JDK 1.3.1_04: Test Passes JDK 1.4.2_05: Test Fails - setter which returns java.util.List not returned by IndexedPropertyDescriptor.getWriteMethod() -
      * therefore setProperty does nothing and values remain unchanged.
      */
     @Test
     public void testSetList() throws Exception {
         beanUtilsBean.setProperty(bean, "stringList", newList);
         final Object value = bean.getStringList();
         assertEquals(newList.getClass(), value.getClass(), "Type is different");
         final List<?> list = (List<?>) value;
         assertEquals(newList.size(), list.size(), "List size is different");
         for (int i = 0; i < list.size(); i++) {
             assertEquals(newList.get(i), list.get(i), "Element " + i + " is different");
         }
     }
 
     /**
      * Test setting an indexed item of a List using setProperty("name[x]", value)
      */
     @Test
     public void testSetListItemA() throws Exception {
         beanUtilsBean.setProperty(bean, "stringList[1]", "modified-1");
         assertEquals("modified-1", bean.getStringList(1));
     }
 
     /**
      * Test setting an indexed item of a List using setIndexedProperty("name", value)
      */
     @Test
     public void testSetListItemB() throws Exception {
         propertyUtilsBean.setIndexedProperty(bean, "stringList", 1, "modified-1");
         assertEquals("modified-1", bean.getStringList(1));
     }
 
 }