package com.sourceforge.jpatterns.core.configuration;
   
   import com.sourceforge.jpatterns.core.configuration.model.IJPatternsConfigBeansBuilder;
   import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigBeansBuilderImpl;
   import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigBeansBuilderMockImpl;
   import com.sourceforge.jpatterns.utils.junit.JPatternsTestUtils;
   import com.zmicer.utils.LoggingUtils;
   import junit.framework.Test;
   import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import org.apache.log4j.Logger;
  
  /**
   * $Author:: zmicer             $<br/>
   * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>
   * $Date:: 2007-08-28 21:37:07 #$<br/>
   */
  public class PropertiesBasedFactoryTest extends TestCase
  {
      /**
       * Logger instance.
       */
      final public static Logger LOG = Logger.getLogger(PropertiesBasedFactoryTest.class);
  
      /**
       * Instance of the covered class to be used below in the tests
       */
      private PropertiesBasedFactory m_propertiesBasedFactory = PropertiesBasedFactory.getInstance();
  
      /**
       * Interface defining the cases to be used
       */
      interface Cases
      {
          String ALL_PROPS = "allPropertiesCase";
          String CUSTOM_PROP = "customPropertyCase";
          String DEFAULT_PROP = "defaultPropertyCase";
          String NO_PROPS = "noPropertiesCase";
      }
  
      /**
       * Contructor with name of test attribute.
       *
       * @param name name of the test
       */
      public PropertiesBasedFactoryTest(String name)
      {
          super(name);
      }
  
      /**
       * Perform the set up functionality for the test.
       *
       * @throws Exception may occur in the case of some problems
       */
      public void setUp() throws Exception
      {
          super.setUp();
      }
  
      /**
       * Perform the tear down functionality for the test
       *
       * @throws Exception may occur in the case of some problems
       */
      public void tearDown() throws Exception
      {
          super.tearDown();
      }
  
      /**
       * Test suite method
       *
       * @return the built test suite
       */
      public static Test suite()
      {
          return new TestSuite(PropertiesBasedFactoryTest.class);
      }
  
      /**
       * Tests {@link PropertiesBasedFactory#getInstance}
       *
       * @throws Exception in the case smth. wrong occuried.
       * @forversion 1.0
       */
      public void testGetInstance() throws Exception
      {
          assertNotNull(m_propertiesBasedFactory);
      }
  
      /**
       * Tests {@link PropertiesBasedFactory#getPropertiesManager}
       *
       * @throws Exception in the case smth. wrong occuried.
       * @forversion 1.0
       */
      public void testGetPropertiesManager() throws Exception
      {
         assertNotNull(m_propertiesBasedFactory.getPropertiesManager());
     }
 
     /**
      * Tests {@link PropertiesBasedFactory#getJPConfigurator}
      *
      * @throws Exception in the case smth. wrong occuried.
      * @forversion 1.0
      */
     public void testGetJPatternsConfigBeansBuilder() throws Exception
     {
         final IPropertiesManager propsManager = m_propertiesBasedFactory.getPropertiesManager();
         // normal sub-case: on default it would be got from the custom properties
         try
         {
             // 00: trying to obtain the implementation of the IJPConfigurator, on default mock is defined (custom properties has place)
             // find the way to check the mock implementation
             JPatternsTestUtils.setJVMPropsParams(PropertiesBasedFactoryTest.class, false, null, null, null, true);
             m_propertiesBasedFactory.cleanImplementations();
             IJPatternsConfigBeansBuilder builder = m_propertiesBasedFactory.getJPatternsConfigBaseBeanBuilder();
             assertNotNull(builder);
             assertTrue(builder instanceof JPatternsConfigBeansBuilderMockImpl);
 
             // 01: setting the cusom properties name to the default one
             PropertiesBasedFactory.getInstance().cleanImplementations();
 
             JPatternsTestUtils.setJVMPropsParams(PropertiesBasedFactoryTest.class, false, Cases.ALL_PROPS, null, null, true);
             m_propertiesBasedFactory.cleanImplementations();
             builder = m_propertiesBasedFactory.getJPatternsConfigBaseBeanBuilder();
             assertNotNull(builder);
             assertTrue(builder instanceof JPatternsConfigBeansBuilderImpl);
 
             // 01: setting the custom properties name to the not existed and default one to the PropertiesBasedFactoryTest.properties -
             // this file also contains the default implementation.
             PropertiesBasedFactory.getInstance().cleanImplementations();
             JPatternsTestUtils.setJVMPropsParams(PropertiesBasedFactoryTest.class, false, null, null, null, true);
             m_propertiesBasedFactory.cleanImplementations();
             builder = m_propertiesBasedFactory.getJPatternsConfigBaseBeanBuilder();
             assertNotNull(builder);
             assertTrue(builder instanceof JPatternsConfigBeansBuilderMockImpl);
             JPatternsTestUtils.resetJVMProps();
         }
         catch (Exception ex)
         {
             LoggingUtils.logException(LOG, ex, null, null);
             fail("Exception should not occur for that case params" + ex.getMessage());
         }
 
     }
 
     /**
      * Tests {@link PropertiesBasedFactory#getJPatternsConfigBaseBeanBuilder}
      *
      * @throws Exception in the case smth. wrong occuried.
      * @forversion 1.0
      */
     public void testGetJPatternsConfigBaseBeanBuilder() throws Exception
     {
         // normal sub-case: no exception: check the default implementation exists
         try
         {
             JPatternsTestUtils.setJVMPropsParams(PropertiesBasedFactoryTest.class, false, null, null, null, true);
 
             assertNotNull(PropertiesBasedFactory.getInstance());
             final IJPatternsConfigBeansBuilder configBeansBuilder =
                 PropertiesBasedFactory.getInstance().getJPatternsConfigBaseBeanBuilder();
             assertNotNull(configBeansBuilder);
 
             JPatternsTestUtils.resetJVMProps();
         }
         catch (Exception ex)
         {
             LoggingUtils.logException(LOG, ex, null, null);
             fail("Exception should not occur for that case " + ex.getMessage());
         }
     }
 
     /**
      * Tests {@link PropertiesBasedFactory#getJPConfigurator}
      *
      * @throws Exception in the case smth. wrong occuried.
      * @forversion 1.0
      */
     public void testGetJPConfigurator() throws Exception
     {
         // normal sub-case: no exception: check the default implementation exists
         try
         {
             JPatternsTestUtils.setJVMPropsParams(PropertiesBasedFactoryTest.class, false, Cases.ALL_PROPS, null, null, true);
             JPatternsTestUtils.setJVMXmlParams(PropertiesBasedFactoryTest.class, false, Cases.ALL_PROPS, null, false);
 
             assertNotNull(PropertiesBasedFactory.getInstance());
             PropertiesBasedFactory.getInstance().cleanImplementations();
             final IJPConfigurator configBeansBuilder =
                 PropertiesBasedFactory.getInstance().getJPConfigurator();
             assertNotNull(configBeansBuilder);
             assertTrue(configBeansBuilder instanceof JPConfiguratorImpl);
 
             JPatternsTestUtils.resetJVMXmlParams();
             JPatternsTestUtils.resetJVMProps();
         }
         catch (Exception ex)
         {
             LoggingUtils.logException(LOG, ex, null, null);
             fail("Exception should not occur for that case " + ex.getMessage());
         }
     }
 }