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 );
     }
 
 }