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 org.apache.commons.beanutils2.BeanUtils.on;
import static org.junit.Assert.assertNotNull;

import org.apache.commons.beanutils2.testbeans.TestBean;
import org.junit.Test;

public class BeanUtilsTest
{

    private static final byte BYTE = 6;

    private static final short SHOT = 45;

    private static final int INT = 329;

    private static final long LONG = 451268l;

    private static final float FLOAT = 47.11f;

    private static final double DOUBLE = 0.4e12d;

    private static final char CHAR = 'X';

    private static final String STRING = "Hello World!";

    @Test
    public void onBeanBooleanPrimitive()
    {
        assertNotNull( on( true ) );
    }

    @Test
    public void onBeanBooleanWrapper()
    {
        assertNotNull( on( new Boolean( true ) ) );
    }

    @Test
    public void onBeanBytePrimtive()
    {
        assertNotNull( on( BYTE ) );
    }

    @Test
    public void onBeanByteWrapper()
    {
        assertNotNull( on( new Byte( BYTE ) ) );
    }

    @Test
    public void onBeanShortPrimitive()
    {
        assertNotNull( on( SHOT ) );
    }

    @Test
    public void onBeanShortWrapper()
    {
        assertNotNull( on( new Short( SHOT ) ) );
    }

    @Test
    public void onBeanIntPrimitive()
    {
        assertNotNull( on( INT ) );
    }

    @Test
    public void onBeanIntegerWrapper()
    {
        assertNotNull( on( new Integer( INT ) ) );
    }

    @Test
    public void onBeanLongPrimitive()
    {
        assertNotNull( on( LONG ) );
    }

    @Test
    public void onBeanLongWrapper()
    {
        assertNotNull( on( new Long( LONG ) ) );
    }

    @Test
    public void onBeanFloatPrimitive()
    {
        assertNotNull( on( FLOAT ) );
    }

    @Test
    public void onBeanFloatWrapper()
    {
        assertNotNull( on( new Float( FLOAT ) ) );
    }

    @Test
    public void onBeanDoublePrimitive()
    {
        assertNotNull( on( DOUBLE ) );
    }

    @Test
    public void onBeanDoubleWrapper()
    {
        assertNotNull( on( new Double( DOUBLE ) ) );
    }

    @Test
    public void onBeanCharPrimitive()
    {
        assertNotNull( on( CHAR ) );
    }

    @Test
    public void onBeanCharacterWrapper()
    {
        assertNotNull( on( new Character( CHAR ) ) );
    }

    @Test
    public void onBeanString()
    {
        assertNotNull( on( STRING ) );
    }

    @Test
    public void onBeanObject()
    {
        assertNotNull( on( new Object() ) );
    }

    @Test
    public void onBeanTestBean()
    {
        assertNotNull( on( new TestBean( FLOAT, STRING ) ) );
    }

    @Test( expected = NullPointerException.class )
    public void onBeanNull()
    {
        on( (Object) null );
    }

    @Test
    public void onClassBooleanPrimitive()
    {
        assertNotNull( on( boolean.class ) );
    }

    @Test
    public void onClassBytePrimitive()
    {
        assertNotNull( on( byte.class ) );
    }

    @Test
    public void onClassShortPrimitive()
    {
        assertNotNull( on( short.class ) );
    }

    @Test
    public void onClassIntPrimitive()
    {
        assertNotNull( on( int.class ) );
    }

    @Test
    public void onClassLongPrimitive()
    {
        assertNotNull( on( long.class ) );
    }

    @Test
    public void onClassFloatPrimitive()
    {
        assertNotNull( on( float.class ) );
    }

    @Test
    public void onClassDoublePrimitive()
    {
        assertNotNull( on( double.class ) );
    }

    @Test
    public void onClassCharPrimitive()
    {
        assertNotNull( on( char.class ) );
    }

    @Test
    public void onClassBooleanWrapper()
    {
        assertNotNull( on( Boolean.class ) );
    }

    @Test
    public void onClassByteWrapper()
    {
        assertNotNull( on( Byte.class ) );
    }

    @Test
    public void onClassShortWrapper()
    {
        assertNotNull( on( Short.class ) );
    }

    @Test
    public void onClassIntegerWrapper()
    {
        assertNotNull( on( Integer.class ) );
    }

    @Test
    public void onClassLongWrapper()
    {
        assertNotNull( on( Long.class ) );
    }

    @Test
    public void onClassFloatWrapper()
    {
        assertNotNull( on( Float.class ) );
    }

    @Test
    public void onClassDoubleWrapper()
    {
        assertNotNull( on( Double.class ) );
    }

    @Test
    public void onClassWrappers()
    {
        assertNotNull( on( Character.class ) );
    }

    @Test
    public void onClassString()
    {
        assertNotNull( on( String.class ) );
    }

    @Test
    public void onClassObject()
    {
        assertNotNull( on( Object.class ) );
    }

    @Test
    public void onClassTestBean()
    {
        assertNotNull( on( TestBean.class ) );
    }

    @Test( expected = NullPointerException.class )
    public void onClassNull()
    {
        on( null );
    }

}