/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed 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.
   */
  package de.smartics.properties.spi.core.constraint.jsr303;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Field;
  import java.util.Date;
  import java.util.List;
  
  import javax.validation.constraints.AssertFalse;
  import javax.validation.constraints.AssertTrue;
  import javax.validation.constraints.DecimalMax;
  import javax.validation.constraints.DecimalMin;
  import javax.validation.constraints.Digits;
  import javax.validation.constraints.Future;
  import javax.validation.constraints.Max;
  import javax.validation.constraints.Min;
  import javax.validation.constraints.NotNull;
  import javax.validation.constraints.Null;
  import javax.validation.constraints.Past;
  import javax.validation.constraints.Pattern;
  import javax.validation.constraints.Size;
  
  import org.junit.Test;
  
  import de.smartics.testdoc.annotations.Uut;
  
  /**
   * Tests {@link ConstraintPrettifier} with constraints from the package
   * <code>javax.validation.constraints</code>.
   */
  @Uut(type = ConstraintPrettifier.class)
  public class ConstraintPrettifierJsr303Test
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Inner Classes *****************************
  
    private static final class Annotations
    {
      @AssertFalse
      boolean assertFalse;
  
      @AssertTrue
      boolean assertTrue;
  
      @DecimalMax(value = "10.0")
      int decimalMax;
  
      @DecimalMin(value = "-10.0")
      int decimalMin;
  
      @Digits(fraction = 2, integer = 3)
      double digits;
  
      @Future
      Date future;
  
      @Max(value = 42)
      int max;
  
      @Min(value = -1 * 42)
      int min;
  
      @NotNull
      String notNull;
  
      @Null
      String isNull;
  
      @Past
      Date past;
  
      @Pattern(regexp = "\\d+")
      String noFlagPattern;
  
      @Pattern(regexp = "\\w+", flags = { Pattern.Flag.MULTILINE,
                                         Pattern.Flag.CASE_INSENSITIVE })
     String multiFlagPattern;
 
     @Pattern(regexp = "\\w+", flags = { Pattern.Flag.MULTILINE })
     String singleFlagPattern;
 
     @Size(min = -1 * 42, max = 42)
     List<?> size;
   }
 
   // ********************************* Methods ********************************
 
   // --- prepare --------------------------------------------------------------
 
   // --- helper ---------------------------------------------------------------
 
   private static Annotation calcAnnotation(final String fieldName,
       final Class<? extends Annotation> annotationType)
   {
     try
     {
       final Field field = Annotations.class.getDeclaredField(fieldName);
       return field.getAnnotation(annotationType);
     }
     catch (final Exception e)
     {
       throw new IllegalStateException("Cannot fetch annotation of type '"
                                       + annotationType + "' from field '"
                                       + fieldName + "'.");
     }
   }
 
   // --- tests ----------------------------------------------------------------
 
   @Test(expected = NullPointerException.class)
   public void rejectsNullAnnotations()
   {
     new ConstraintPrettifier(null);
   }
 
   @Test
   public void acceptsAssertFalse()
   {
     final Annotation annotation =
         calcAnnotation("assertFalse", AssertFalse.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("AssertFalse")));
   }
 
   @Test
   public void acceptsAssertTrue()
   {
     final Annotation annotation =
         calcAnnotation("assertTrue", AssertTrue.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("AssertTrue")));
   }
 
   @Test
   public void acceptsDecimalMax()
   {
     final Annotation annotation =
         calcAnnotation("decimalMax", DecimalMax.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("DecimalMax(value=10.0)")));
   }
 
   @Test
   public void acceptsDecimalMin()
   {
     final Annotation annotation =
         calcAnnotation("decimalMin", DecimalMin.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("DecimalMin(value=-10.0)")));
   }
 
   @Test
   public void acceptsDigits()
   {
     final Annotation annotation = calcAnnotation("digits", Digits.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Digits(fraction=2, integer=3)")));
   }
 
   @Test
   public void acceptsFuture()
   {
     final Annotation annotation = calcAnnotation("future", Future.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Future")));
   }
 
   @Test
   public void acceptsMax()
   {
     final Annotation annotation = calcAnnotation("max", Max.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Max(value=42)")));
   }
 
   @Test
   public void acceptsMin()
   {
     final Annotation annotation = calcAnnotation("min", Min.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Min(value=-42)")));
   }
 
   @Test
   public void acceptsNotNull()
   {
     final Annotation annotation = calcAnnotation("notNull", NotNull.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("NotNull")));
   }
 
   @Test
   public void acceptsNull()
   {
     final Annotation annotation = calcAnnotation("isNull", Null.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Null")));
   }
 
   @Test
   public void acceptsPast()
   {
     final Annotation annotation = calcAnnotation("past", Past.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Past")));
   }
 
   @Test
   public void acceptsNoFlagPattern()
   {
     final Annotation annotation =
         calcAnnotation("noFlagPattern", Pattern.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Pattern(regexp=\\d+)")));
   }
 
   @Test
   public void acceptsMultiFlagPattern()
   {
     final Annotation annotation =
         calcAnnotation("multiFlagPattern", Pattern.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(
         uut.toString(),
         is(equalTo("Pattern(flags=[MULTILINE, CASE_INSENSITIVE], regexp=\\w+)")));
   }
 
   @Test
   public void acceptsSingleFlagPattern()
   {
     final Annotation annotation =
         calcAnnotation("singleFlagPattern", Pattern.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(),
         is(equalTo("Pattern(flags=[MULTILINE], regexp=\\w+)")));
   }
 
   @Test
   public void acceptsSize()
   {
     final Annotation annotation = calcAnnotation("size", Size.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Size(min=-42, max=42)")));
   }
 }