/*
    * 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.configuration2.convert;
  
  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Calendar;
  import java.util.Collection;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.commons.configuration2.ex.ConversionException;
  import org.apache.commons.configuration2.interpol.ConfigurationInterpolator;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * Test class for {@code DefaultConversionHandler}.
   */
  public class TestDefaultConversionHandler {
  
      /** Constant for a variable. */
      private static final String VAR = "${test}";
  
      /** Constant for the value to replace the variable. */
      private static final String REPLACEMENT = "1";
  
      /**
       * Creates a special test ConfigurationInterpolator. This object only replaces the test variable by its replacement.
       * Other substitutions are not performed.
       *
       * @return the test {@code ConfigurationInterpolator}
       */
      private static ConfigurationInterpolator createInterpolator() {
          return new ConfigurationInterpolator() {
              @Override
              public Object interpolate(final Object value) {
                  if (VAR.equals(value)) {
                      return REPLACEMENT;
                  }
                  return value;
              }
          };
      }
  
      /** The conversion handler to be tested. */
      private DefaultConversionHandler handler;
  
      /**
       * Helper method for testing the result of the conversion of a single value.
       *
       * @param expResult the expected result
       */
      private void checkSingleValue(final Integer expResult) {
          assertEquals(Integer.parseInt(REPLACEMENT), expResult.intValue());
      }
  
      @BeforeEach
      public void setUp() {
          handler = new DefaultConversionHandler();
      }
  
      /**
       * Tests whether the default date format is used if no format has been set.
       */
      @Test
      void testGetDateFormatNotSet() {
          assertEquals(DefaultConversionHandler.DEFAULT_DATE_FORMAT, handler.getDateFormat());
      }
  
      @Test
      public synchronized void testListDelimiterHandler() {
          assertEquals(DefaultConversionHandler.LIST_DELIMITER_HANDLER, handler.getListDelimiterHandler());
          handler.setListDelimiterHandler(null);
          assertEquals(DefaultConversionHandler.LIST_DELIMITER_HANDLER, handler.getListDelimiterHandler());
          final LegacyListDelimiterHandler legacyListDelimiterHandler = new LegacyListDelimiterHandler(',');
          handler.setListDelimiterHandler(legacyListDelimiterHandler);
          assertEquals(legacyListDelimiterHandler, handler.getListDelimiterHandler());
         handler.setListDelimiterHandler(null);
         assertEquals(DefaultConversionHandler.LIST_DELIMITER_HANDLER, handler.getListDelimiterHandler());
     }
 
     /**
      * Tests whether the date format can be changed.
      */
     @Test
     void testSetDateFormat() {
         final String dateFormat = "dd.MM.yyyy";
         handler.setDateFormat(dateFormat);
         assertEquals(dateFormat, handler.getDateFormat());
     }
 
     /**
      * Tests a conversion to an array from an empty string. An empty string should be interpreted as an empty array.
      */
     @Test
     void testToArrayEmptyString() {
         final int[] array = (int[]) handler.toArray("", Integer.TYPE, null);
         assertEquals(0, array.length);
     }
 
     /**
      * Tests toArray() if the source object is null.
      */
     @Test
     void testToArrayNullInput() {
         assertNull(handler.toArray(null, Integer.class, null));
     }
 
     /**
      * Tests a conversion to an array of Objects.
      */
     @Test
     void testToArrayObject() {
         final List<String> src = Arrays.asList(VAR, "100");
         final Integer[] array = (Integer[]) handler.toArray(src, Integer.class, createInterpolator());
         assertArrayEquals(new Integer[] {Integer.valueOf(REPLACEMENT), Integer.valueOf(src.get(1))}, array);
     }
 
     /**
      * Tests a conversion to an array of primitive type if the source object is something else.
      */
     @Test
     void testToArrayPrimitiveOtherType() {
         final List<String> src = Arrays.asList(VAR, "100");
         final int[] array = (int[]) handler.toArray(src, Integer.TYPE, createInterpolator());
         assertArrayEquals(new int[] {Integer.parseInt(REPLACEMENT), Integer.parseInt(src.get(1))}, array);
     }
 
     /**
      * Tests a conversion to an array of primitive type if the source array already has the correct type.
      */
     @Test
     void testToArrayPrimitiveSameType() {
         final int[] src = {1, 2, 3, 4, 5, 6};
         final int[] array = (int[]) handler.toArray(src, Integer.TYPE, createInterpolator());
         assertArrayEquals(src, array);
     }
 
     /**
      * Tests a conversion to an array of primitive type if the source array is of the corresponding wrapper type.
      */
     @Test
     void testToArrayPrimitiveWrapperType() {
         final Integer[] src = {0, 1, 2, 4, 8, 16, 32, 64, 128};
         final int[] array = (int[]) handler.toArray(src, Integer.TYPE, createInterpolator());
         assertArrayEquals(new int[] {0, 1, 2, 4, 8, 16, 32, 64, 128}, array);
     }
 
     /**
      * Tests a conversion to a Calendar object using the default format.
      */
     @Test
     void testToCalendarWithDefaultFormat() {
         final Calendar cal = handler.to("2013-08-19 21:17:22", Calendar.class, null);
         assertEquals(19, cal.get(Calendar.DATE));
         assertEquals(Calendar.AUGUST, cal.get(Calendar.MONTH));
         assertEquals(2013, cal.get(Calendar.YEAR));
         assertEquals(21, cal.get(Calendar.HOUR_OF_DAY));
         assertEquals(17, cal.get(Calendar.MINUTE));
         assertEquals(22, cal.get(Calendar.SECOND));
     }
 
     /**
      * Tests a conversion to a collection if an empty string is passed in. An empty string should be interpreted as a list
      * with no values.
      */
     @Test
     void testToCollectionEmptyString() {
         final List<Integer> col = new ArrayList<>(1);
         handler.toCollection("", Integer.class, null, col);
         assertTrue(col.isEmpty());
     }
 
     /**
      * Tries to pass a null collection to toCollection().
      */
     @Test
     void testToCollectionNullCollection() {
         final List<Integer> src = Arrays.asList(1, 2, 3);
         assertThrows(IllegalArgumentException.class, () -> handler.toCollection(src, Integer.class, null, null));
     }
 
     /**
      * Tests a conversion to a collection if the source object is null.
      */
     @Test
     void testToCollectionNullInput() {
         final ArrayList<Integer> col = new ArrayList<>();
         handler.toCollection(null, Integer.class, null, col);
         assertTrue(col.isEmpty());
     }
 
     /**
      * Tests a successful conversion to a collection.
      */
     @Test
     void testToCollectionSuccess() {
         final Object[] src = {VAR, "100"};
         final List<Integer> col = new ArrayList<>(src.length);
         handler.toCollection(src, Integer.class, createInterpolator(), col);
         assertEquals(Arrays.asList(Integer.valueOf(REPLACEMENT), Integer.valueOf(src[1].toString())), col);
     }
 
     @Test
     void testToCustomNumber() {
         // convertValue()
         assertEquals(new MyNumber(1), DefaultConversionHandler.INSTANCE.convertValue(new MyNumber(1), MyNumber.class, null));
         assertEquals(new MyNumber(2), DefaultConversionHandler.INSTANCE.convertValue(new MyNumber(2), MyNumber.class, null));
         assertEquals(new MyNumber(3), DefaultConversionHandler.INSTANCE.convertValue("3", MyNumber.class, null));
         assertNull(DefaultConversionHandler.INSTANCE.convertValue(null, MyNumber.class, null));
         // to()
         assertEquals(new MyNumber(1), DefaultConversionHandler.INSTANCE.to(new MyNumber(1), MyNumber.class, null));
         assertEquals(new MyNumber(2), DefaultConversionHandler.INSTANCE.to(new MyNumber(2), MyNumber.class, null));
         assertEquals(new MyNumber(3), DefaultConversionHandler.INSTANCE.to("3", MyNumber.class, null));
         assertNull(DefaultConversionHandler.INSTANCE.to(null, MyNumber.class, null));
     }
 
     /**
      * Tests whether a conversion to a date object is possible if a specific date format is used.
      */
     @Test
     void testToDateWithFormat() {
         handler.setDateFormat("dd.MM.yyyy");
         final Date dt = handler.to("19.08.2013", Date.class, null);
         final Calendar cal = Calendar.getInstance();
         cal.setTime(dt);
         assertEquals(19, cal.get(Calendar.DATE));
         assertEquals(Calendar.AUGUST, cal.get(Calendar.MONTH));
         assertEquals(2013, cal.get(Calendar.YEAR));
     }
 
     /**
      * Tests a failed conversion.
      */
     @Test
     void testToFailedConversion() {
         assertThrows(ConversionException.class, () -> handler.to(VAR, Integer.class, null));
     }
 
     /**
      * Tests whether a conversion from an array is possible.
      */
     @Test
     void testToFromArray() {
         final Object[] src = {VAR, true, 20130808221759L};
         checkSingleValue(handler.to(src, Integer.class, createInterpolator()));
     }
 
     /**
      * Tests whether a conversion from a collection is possible.
      */
     @Test
     void testToFromCollection() {
         final Collection<String> src = Arrays.asList(VAR, "true", "1000");
         checkSingleValue(handler.to(src, Integer.class, createInterpolator()));
     }
 
     /**
      * Tests whether empty complex objects are handled when converting to a single value.
      */
     @Test
     void testToFromEmptyCollection() {
         assertNull(handler.to(new ArrayList<>(), Integer.class, createInterpolator()));
     }
 
     /**
      * Tests whether a conversion from an iterator is possible.
      */
     @Test
     void testToFromIterator() {
         final Iterator<String> src = Arrays.asList(VAR, "true", "1000").iterator();
         checkSingleValue(handler.to(src, Integer.class, createInterpolator()));
     }
 
     /**
      * Tests whether a ConfigurationInterpolator is optional.
      */
     @Test
     void testToNoInterpolator() {
         final Integer result = handler.to(REPLACEMENT, Integer.class, null);
         checkSingleValue(result);
     }
 
     /**
      * Tests whether null input is handled by to().
      */
     @Test
     void testToNull() {
         assertNull(handler.to(null, Integer.class, null));
     }
 
     /**
      * Tests a conversion to a primitive type.
      */
     @Test
     void testToPrimitive() {
         final Long value = 20130819214935L;
         final Object result = handler.to(value.toString(), Long.TYPE, null);
         assertEquals(value, result);
     }
 
     /**
      * Tests a conversion with a ConfigurationInterpolator.
      */
     @Test
     void testToWithInterpolator() {
         final Integer result = handler.to(VAR, Integer.class, createInterpolator());
         checkSingleValue(result);
     }
 }