package org.apache.commons.beanutils2;

/*
 * 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.
 */

import static java.util.Arrays.fill;
import static org.apache.commons.beanutils2.Assertions.checkArgument;
import static org.apache.commons.beanutils2.Assertions.checkNoneIsNull;
import static org.apache.commons.beanutils2.Assertions.checkNotNull;
import static org.apache.commons.beanutils2.Assertions.checkState;
import static org.junit.Assert.assertSame;

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

public class AssertionsTest
{

    private static final int INT_VALUE = 15;

    private static final String STRING_VALUE = "doing something awesome";

    private static final String PLACEHOLDER = "%s";

    private static final String ERROR_PART1 = "Something went wrong while ";

    private static final String ERROR_PART2 = " because we got a value of ";

    private static final String ERROR_MSG = ERROR_PART1 + PLACEHOLDER + ERROR_PART2 + PLACEHOLDER;

    @Rule
    public final ExpectedException thrown = ExpectedException.none();

    @Test
    public void checkArgumentTrueString()
    {
        checkArgument( true, "True has to be okay!" );
    }

    @Test
    public void checkArgumentFalseString()
    {
        thrown.expect( IllegalArgumentException.class );
        thrown.expectMessage( ERROR_PART1 );
        checkArgument( false, ERROR_PART1 );
    }

    @Test
    public void checkArgumentFalseStringObjectObject()
    {
        thrown.expect( IllegalArgumentException.class );
        thrown.expectMessage( ERROR_PART1 );
        thrown.expectMessage( ERROR_PART2 );
        thrown.expectMessage( String.valueOf( INT_VALUE ) );
        thrown.expectMessage( STRING_VALUE );
        checkArgument( false, ERROR_MSG, STRING_VALUE, INT_VALUE );
    }

    @Test( expected = NullPointerException.class )
    public void checkArgumentFalseNull()
    {
        checkArgument( false, null );
    }

    @Test( expected = NullPointerException.class )
    public void checkArgumentFalseNullObjects()
    {
        checkArgument( false, null, STRING_VALUE, INT_VALUE );
    }

    @Test
    public void checkStateTrueString()
    {
        checkState( true, "True has to be okay!" );
    }

    @Test
    public void checkStateFalseString()
    {
        thrown.expect( IllegalStateException.class );
        thrown.expectMessage( ERROR_PART1 );
        checkState( false, ERROR_PART1 );
    }

    @Test
    public void checkStateFalseStringObjects()
    {
        thrown.expect( IllegalStateException.class );
        thrown.expectMessage( ERROR_PART1 );
        thrown.expectMessage( ERROR_PART2 );
        thrown.expectMessage( STRING_VALUE );
        thrown.expectMessage( String.valueOf( INT_VALUE ) );
        checkState( false, ERROR_MSG, STRING_VALUE, INT_VALUE );
    }

    @Test( expected = NullPointerException.class )
    public void checkStateFalseNull()
    {
        checkState( false, null );
    }

    @Test( expected = NullPointerException.class )
    public void checkStateFalseNullObjects()
    {
        checkState( false, null, STRING_VALUE, INT_VALUE );
    }

    @Test
    public void checkNotNullObjectString()
    {
        Object obj = new Object();
        Object checkedObj = checkNotNull( obj, "An object reference has to be okay!" );
        assertSame( obj, checkedObj );
    }

    @Test
    public void checkNotNullNullString()
    {
        thrown.expect( NullPointerException.class );
        thrown.expectMessage( ERROR_PART1 );
        checkNotNull( null, ERROR_PART1 );
    }

    @Test
    public void checkNotNullNullStringObjects()
    {
        thrown.expect( NullPointerException.class );
        thrown.expectMessage( ERROR_PART1 );
        thrown.expectMessage( ERROR_PART2 );
        thrown.expectMessage( STRING_VALUE );
        thrown.expectMessage( String.valueOf( INT_VALUE ) );
        checkNotNull( null, ERROR_MSG, STRING_VALUE, INT_VALUE );
    }

    // this is a bit ambiguous, we do not distinguish if NPE is thrown because reference is null or if NPE is
    // thrown because errorTemplate or errorMessageArgs are null

    @Test( expected = NullPointerException.class )
    public void checkNotNullNullNull()
    {
        checkNotNull( null, null );
    }

    @Test( expected = NullPointerException.class )
    public void checkNotNullNullObjects()
    {
        checkNotNull( null, null, STRING_VALUE, INT_VALUE );
    }

    @Test( expected = NullPointerException.class )
    public void checkNotNullNullStringNull()
    {
        checkNotNull( null, ERROR_MSG, (Object[]) null );
    }

    @Test( expected = NullPointerException.class )
    public void checkNotNullNullNullNull()
    {
        checkNotNull( null, null, (Object[]) null );
    }

    @Test
    public void checkNoneIsNullEmptyObjectArray()
    {
        Object[] refs = new Object[0];
        Object[] checkedRefs = checkNoneIsNull( refs );
        assertSame( refs, checkedRefs );
    }

    @Test
    public void checkNoneIsNullObjectArray()
    {
        Object[] refs = getObjectArray( 10 );
        Object[] checkedRefs = checkNoneIsNull( refs );
        assertSame( refs, checkedRefs );
        for ( int i = 0; i < refs.length; i++ )
        {
            assertSame( refs[i], checkedRefs[i] );
        }
    }

    @Test
    public void checkNoneIsNullObjectArrayWithNullRefs()
    {

        Object[] refs = getObjectArray( 10 );
        refs[5] = null;
        thrown.expect( NullPointerException.class );
        thrown.expectMessage( "5/10" );
        thrown.expectMessage( "Reference at index" );
        thrown.expectMessage( "is null!" );
        checkNoneIsNull( refs );
    }

    private Object[] getObjectArray( int size )
    {
        Object[] array = new Object[size];
        fill( array, new Object() );
        return array;
    }

    @Test(expected = NullPointerException.class)
    public void checkNoneIsNullNull()
    {
        checkNoneIsNull( null );
    }

}