/*
    * 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.
   */
  package org.apache.commons.flatfile.conversion;
  
  import net.sf.morph.reflect.Reflector;
  import net.sf.morph.reflect.reflectors.SimpleDelegatingReflector;
  import net.sf.morph.transform.DecoratedConverter;
  import net.sf.morph.transform.Transformer;
  import net.sf.morph.transform.copiers.PropertyNameMatchingCopier;
  import net.sf.morph.transform.transformers.SimpleDelegatingTransformer;
  
  //import com.pgac.fixedlength.morph.EntityInstantiatingReflector;
  import org.apache.commons.flatfile.Entity;
  import org.apache.commons.flatfile.EntityParserTestBase;
  import org.apache.commons.flatfile.dsl.DefaultEntityNameStrategy;
  import org.apache.commons.flatfile.dsl.EntityNameStrategy;
  import org.apache.commons.flatfile.morph.ContainerToIndexedEntityCollectionCopier;
  import org.apache.commons.flatfile.morph.EntityCollectionReflector;
  import org.apache.commons.flatfile.morph.EntityInstantiatingReflector;
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   *
   */
  public abstract class ConversionTestBase extends EntityParserTestBase {
      private static final EntityNameStrategy DEFAULT_NAME_STRATEGY = new DefaultEntityNameStrategy();
  
      protected static class TestPair {
          private String entityValue;
  
          private Object modelObject;
  
          public TestPair(String entityValue, Object modelObject) {
              this.entityValue = entityValue;
              this.modelObject = modelObject;
          }
  
          public synchronized String getEntityValue() {
              return entityValue;
          }
  
          public synchronized Object getModelObject() {
              return modelObject;
          }
      }
  
      protected DecoratedConverter converter;
  
      @Override
      @Before
      public void setUp() throws Exception {
          super.setUp();
          entityFactory.setEntityNameStrategy(getEntityNameStrategy());
          Reflector reflector = new SimpleDelegatingReflector(new Reflector[] {
                  new EntityInstantiatingReflector(entityFactory),
                  new EntityCollectionReflector() }, true);
          PropertyNameMatchingCopier entityCopier = new PropertyNameMatchingCopier();
          entityCopier.setDestinationClasses(new Class[] { Entity.class });
          entityCopier.setReflector(reflector);
          SimpleDelegatingTransformer sdt = new SimpleDelegatingTransformer(
                  new Transformer[] {
                          new ContainerToIndexedEntityCollectionCopier(),
                          entityCopier }, true);
          converter = sdt;
      }
  
      @Test
      public void testMe() throws Exception {
          for (TestPair p : getTestPairs()) {
              assertConversion(p);
          }
      }
  
      protected void assertConversion(TestPair pair) {
          Entity e = (Entity) converter.convert(Entity.class, pair
                  .getModelObject());
          assertValue(pair.getEntityValue(), e);
      }
  
      /**
       * Override this method for multiple test pairs
       * @return
       */
      protected TestPair[] getTestPairs() {
         return new TestPair[] { getTestPair() };
     }
 
     /**
      * Override this method for a single test pair
      * @return
      */
     protected TestPair getTestPair() {
         throw new UnsupportedOperationException("getTestPair");
     }
 
     /**
      * Override to provide a different naming strategy
      * @return
      */
     protected EntityNameStrategy getEntityNameStrategy() {
         return DEFAULT_NAME_STRATEGY;
     }
 }