/*
    * 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 test.de.smartics.properties.spi.core.metadata;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  
  import java.lang.reflect.Method;
  import java.util.List;
  
  import org.junit.Before;
  
  import de.smartics.properties.api.core.domain.PropertyConstraint;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.api.core.domain.PropertyExpression;
  import de.smartics.properties.api.core.domain.PropertyKey;
  import de.smartics.properties.api.core.domain.PropertyType;
  import de.smartics.properties.api.core.domain.PropertyValueRange;
  import de.smartics.properties.spi.core.metadata.PropertyMetaDataParser;
  import de.smartics.testdoc.annotations.Uut;
  
  /**
   * Base implementation for tests on {@link PropertyMetaDataParser}.
   */
  @Uut(type = PropertyMetaDataParser.class)
  public abstract class AbstractPropertyMetaDataParserTestBase
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    protected PropertyMetaDataParser uut;
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- prepare --------------------------------------------------------------
  
    @Before
    public void setUp()
    {
      uut = PropertyMetaDataParser.createWithoutContextAccess();
    }
  
    // --- helper ---------------------------------------------------------------
  
    protected static final Method fetchMethod(final Class<?> type,
        final String methodName)
    {
      try
      {
        return type.getDeclaredMethod(methodName, new Class<?>[0]);
      }
      catch (final Exception e)
      {
        throw new IllegalStateException(String.format(
            "No method named '%s' found in type '%s'.", methodName,
            type.getName()));
      }
    }
  
    // CHECKSTYLE:OFF
    @SuppressWarnings("rawtypes")
    protected static final void checkThat(
        // NOPMD
        final PropertyDescriptor descriptor, final PropertyKey expectedKey,
        final PropertyType expectedType,
        final PropertyExpression expectedExpression,
        final PropertyValueRange expectedRange, final List expectedConstraints)
    {
      // CHECKSTYLE:ON
      checkThat(descriptor, expectedKey, expectedType, false, expectedExpression,
          expectedRange, expectedConstraints);
    }
  
    // CHECKSTYLE:OFF
    @SuppressWarnings("rawtypes")
    protected static final void checkThat(
        // NOPMD
        final PropertyDescriptor descriptor, final PropertyKey expectedKey,
        final PropertyType expectedType, final boolean mandatory,
        final PropertyExpression expectedExpression,
       final PropertyValueRange expectedRange, final List expectedConstraints)
   {
     // CHECKSTYLE:ON
     assertThat(descriptor.getKey(), is(equalTo(expectedKey)));
     assertThat(descriptor.getType(), is(equalTo(expectedType)));
     assertThat(descriptor.isMandatory(), is(equalTo(mandatory)));
     assertThat(descriptor.getDefaultExpression().getExpression(),
         is(equalTo(expectedExpression.getExpression())));
     assertThat(descriptor.getValueRange(), is(equalTo(expectedRange)));
 
     final List<? extends PropertyConstraint<?>> actualConstraints =
         descriptor.getConstraints();
     assertThat(actualConstraints.size(),
         is(equalTo(expectedConstraints.size())));
     for (int i = actualConstraints.size() - 1; i >= 0; i--)
     {
       final PropertyConstraint actual = actualConstraints.get(i);
       final PropertyConstraint expected =
           (PropertyConstraint) expectedConstraints.get(i);
       assertThat(actual.toString(), is(equalTo(expected.toString())));
     }
   }
 
   // --- tests ----------------------------------------------------------------
 
 }