/*
 * 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.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

/**
 * Test class for {@code DisabledListDelimiterHandler}. Note that some functionality of the base class is tested, too.
 */
public class TestDisabledListDelimiterHandler {

    /** An array with some test values. */
    private static final Object[] VALUES = {20130630213801L, "A test value", 5};

    /** Constant for a test string value. */
    private static final String STR_VALUE = "  A test, string; value! ";

    /**
     * Checks whether the passed in container contains the expected values.
     *
     * @param container the iterator to test
     */
    private static void checkIterator(final Iterable<?> container) {
        final Iterator<?> it = container.iterator();
        for (final Object o : VALUES) {
            assertEquals(o, it.next());
        }
        assertFalse(it.hasNext());
    }

    /** The instance to be tested. */
    private DisabledListDelimiterHandler handler;

    @BeforeEach
    public void setUp() throws Exception {
        handler = new DisabledListDelimiterHandler();
    }

    /**
     * Tests escapeList(). This operation is not supported.
     */
    @Test
    void testEscapeList() {
        final List<Object> values = Arrays.asList(VALUES);
        assertThrows(UnsupportedOperationException.class, () -> handler.escapeList(values, ListDelimiterHandler.NOOP_TRANSFORMER));
    }

    /**
     * Tests whether a non-string value is correctly escaped. The object should not be modified.
     */
    @Test
    void testEscapeNonStringValue() {
        final Object value = 42;
        assertEquals(value, handler.escape(value, ListDelimiterHandler.NOOP_TRANSFORMER));
    }

    /**
     * Tests whether the transformer is correctly called when escaping a non string value.
     */
    @Test
    void testEscapeNonStringValueTransformer() {
        final ValueTransformer trans = mock(ValueTransformer.class);
        final Object value = 42;

        when(trans.transformValue(value)).thenReturn(STR_VALUE);

        assertEquals(STR_VALUE, handler.escape(value, trans));

        verify(trans).transformValue(value);
        verifyNoMoreInteractions(trans);
    }

    /**
     * Tests whether a string value is correctly escaped. The string should not be modified.
     */
    @Test
    void testEscapeStringValue() {
        assertEquals(STR_VALUE, handler.escape(STR_VALUE, ListDelimiterHandler.NOOP_TRANSFORMER));
    }

    /**
     * Tests whether the transformer is correctly invoked when escaping a string.
     */
    @Test
    void testEscapeStringValueTransformer() {
        final ValueTransformer trans = mock(ValueTransformer.class);
        final String testStr = "Some other string";

        when(trans.transformValue(testStr)).thenReturn(STR_VALUE);

        assertEquals(STR_VALUE, handler.escape(testStr, trans));

        verify(trans).transformValue(testStr);
        verifyNoMoreInteractions(trans);
    }

    /**
     * Tests whether a limit is applied when extracting values from an array.
     */
    @Test
    void testFlattenArrayWithLimit() {
        final Collection<?> res = handler.flatten(VALUES, 1);
        assertEquals(1, res.size());
        assertEquals(VALUES[0], res.iterator().next());
    }

    /**
     * Tests whether elements can be extracted from a collection that contains an array if a limit is specified.
     */
    @Test
    void testFlattenCollectionWithArrayWithLimit() {
        final Collection<Object> src = new ArrayList<>(2);
        src.add(STR_VALUE);
        src.add(VALUES);
        final Collection<?> res = handler.flatten(src, 2);
        assertEquals(2, res.size());
        final Iterator<?> it = res.iterator();
        assertEquals(STR_VALUE, it.next());
        assertEquals(VALUES[0], it.next());
    }

    /**
     * Tests whether a limit is applied when extracting elements from a collection.
     */
    @Test
    void testFlattenCollectionWithLimit() {
        final Collection<Object> src = Arrays.asList(VALUES);
        final Collection<?> res = handler.flatten(src, 1);
        assertEquals(1, res.size());
        assertEquals(VALUES[0], res.iterator().next());
    }

    /**
     * Tests whether the values of an array can be extracted.
     */
    @Test
    void testParseArray() {
        checkIterator(handler.parse(VALUES));
    }

    /**
     * Tests whether the values of an Iterable object can be extracted.
     */
    @Test
    void testParseIterable() {
        checkIterator(handler.parse(Arrays.asList(VALUES)));
    }

    /**
     * Tests whether the values of an Iterator object can be extracted.
     */
    @Test
    void testParseIterator() {
        checkIterator(handler.parse(Arrays.asList(VALUES).iterator()));
    }

    /**
     * Tests whether a null value can be parsed.
     */
    @Test
    void testParseNull() {
        assertFalse(handler.parse(null).iterator().hasNext());
    }

    /**
     * Tests whether a simple string value can be parsed.
     */
    @Test
    void testParseSimpleValue() {
        final Iterator<?> it = handler.parse(STR_VALUE).iterator();
        assertEquals(STR_VALUE, it.next());
        assertFalse(it.hasNext());
    }
}
