/*
    * Zemucan: A Syntax Assistant for DB2
    * Copyright (C) 2009, 2010 Andres Gomez Casanova
    *
    * This file is part of Zemucan.
    *
    * Zemucan is free software: you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License as published by
    * the Free Software Foundation; either version 3 of the License, or
   * (at your option) any later version.
   *
   * Zemucan is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this library; if not, see <http://www.gnu.org/licenses/>.
   *
   * Contact:
   * a n g o c a  at  y a h o o  dot  c o m
   * Cra. 45 No 61 - 31, Bogota, Colombia.
   *
   * Author:   $LastChangedBy: angoca $:
   * Date:     $LastChangedDate: 2011-03-06 10:15:32 -0500 (dom, 06 mar 2011) $:
   * Revision: $LastChangedRevision: 1913 $:
   * URL:      $HeadURL: https://zemucan.svn.sourceforge.net/svnroot/zemucan/branches/zemucan_v1/source-code/main/src/test/java/name/angoca/zemucan/main/MainTest.java $:
   */
  package name.angoca.zemucan.main;
  
  import name.angoca.zemucan.AbstractZemucanException;
  import name.angoca.zemucan.tools.configurator.Configurator;
  import name.angoca.zemucan.tools.test.RandomTestRunner;
  import name.angoca.zemucan.ui.api.AbstractInterfaceController;
  import name.angoca.zemucan.ui.api.InputReaderException;
  import name.angoca.zemucan.ui.impl.jline.ImplementationJlineInterfaceController;
  import name.angoca.zemucan.ui.impl.system.ImplementationSystemInterfaceController;
  
  import org.junit.Assert;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  
  /**
   * This executes the main in other way.
   * <p>
   * <b>Control Version</b>
   * <p>
   * <ul>
   * <li>0.0.1 Class creation.</li>
   * <li>0.0.2 final.</li>
   * <li>1.0.0 Moved to version 1.</li>
   * <li>1.0.1 Types for implementations.</li>
   * <li>1.1.0 Tests other methods.</li>
   * </ul>
   *
   * @author Andres Gomez Casanova <a
   *         href="mailto:a n g o c a at y a h o o dot c o m">(AngocA)</a>
   * @version 1.1.0 2009-11-22
   */
  @RunWith(RandomTestRunner.class)
  public final class MainTest {
  
      /**
       * Tests that a controller cannot be null.
       *
       * @throws InputReaderException
       *             Never.
       */
      @Test(expected = AssertionError.class)
      public void testControllerNull() throws InputReaderException {
          Main.getInterfaceControllerType(null);
      }
  
      /**
       * Tests that a element of controller cannot be null.
       *
       * @throws InputReaderException
       *             Never.
       */
      @Test(expected = AssertionError.class)
      public void testControllerNull1() throws InputReaderException {
          final String[] args = new String[] { null };
          Main.getInterfaceControllerType(args);
      }
  
      /**
       * Tests that the controller is System.
       */
      @Test
      public void testGetControllerDefault() {
          final String[] args = new String[] {};
          final int actual = Main.getInterfaceControllerType(args);
          final int expected = Main.ID_JLINE;
          Assert.assertEquals("Interface controller type", expected, //$NON-NLS-1$
                  actual);
      }
  
      /**
       * Tests that the controller is System.
      */
     @Test
     public void testGetControllerJline() {
         final String[] args = new String[] { Main.VALUE_JLINE };
         final int actual = Main.getInterfaceControllerType(args);
         final int expected = Main.ID_JLINE;
         Assert.assertEquals("Interface controller type", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Tests that the controller is Other.
      */
     @Test
     public void testGetControllerOther() {
         final String[] args = new String[] { "Other" }; //$NON-NLS-1$
         final int actual = Main.getInterfaceControllerType(args);
         final int expected = Main.ID_JLINE;
         Assert.assertEquals("Interface controller type", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Tests that the controller is System.
      */
     @Test
     public void testGetControllerSystem() {
         final String[] args = new String[] { Main.VALUE_SYSTEM };
         final int actual = Main.getInterfaceControllerType(args);
         final int expected = Main.ID_SYSTEM;
         Assert.assertEquals("Interface controller type", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test for coverage, just default.
      *
      * @throws AbstractZemucanException
      */
     @Test
     public void testMainParamEmpty() throws AbstractZemucanException {
     }
 
     /**
      * Tests for coverage, just to evaluate the -h parameter value.
      *
      * @throws AbstractZemucanException
      */
     @Test
     public void testMainParamH() throws AbstractZemucanException {
         final String[] args = new String[] { "-h" };
         new Main(args);
     }
 
     /**
      * Tests for coverage, just to evaluate the --help parameter value.
      *
      * @throws AbstractZemucanException
      */
     @Test
     public void testMainParamHelp() throws AbstractZemucanException {
         final String[] args = new String[] { "--help" };
         new Main(args);
     }
 
     /**
      * Tests for coverage, just to evaluate the VALUE_SYSTEM parameter value.
      *
      * @throws AbstractZemucanException
      */
     @Test
     public void testMainParamJline() throws AbstractZemucanException {
     }
 
     /**
      * Test for coverage, array null.
      *
      * @throws AbstractZemucanException
      */
     @Test(expected = AssertionError.class)
     public void testMainParamNull1() throws AbstractZemucanException {
         new Main(null);
     }
 
     /**
      * Test for coverage, null in array.
      *
      * @throws AbstractZemucanException
      */
     @Test(expected = AssertionError.class)
     public void testMainParamNull2() throws AbstractZemucanException {
         final String[] args = new String[] { null };
         new Main(args);
     }
 
     /**
      * Tests for coverage, just to evaluate the /h parameter value.
      *
      * @throws AbstractZemucanException
      */
     @Test
     public void testMainParamSlashH() throws AbstractZemucanException {
         final String[] args = new String[] { "/h" };
         new Main(args);
     }
 
     /**
      * Tests for coverage, just to evaluate the VALUE_SYSTEM parameter value.
      *
      * @throws AbstractZemucanException
      */
     @Test
     public void testMainParamSystem() throws AbstractZemucanException {
     }
 
     /**
      * Prepares the controller with Jline.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testPrepareJline() throws AbstractZemucanException {
         final int type = Main.ID_JLINE;
 
         final AbstractInterfaceController controller = Main.prepare(type);
         Assert.assertTrue("Interface jline", //$NON-NLS-1$
                 controller instanceof ImplementationJlineInterfaceController);
     }
 
     /**
      * Tests that a there is not prompt property. Just for coverage.
      *
      * @throws InputReaderException
      *             Never.
      */
     @Test
     public void testPrepareNoPrompt() throws InputReaderException {
         Configurator.getInstance().deleteProperty(Main.PROMPT_PROPERTY);
         Main.prepare(Main.ID_SYSTEM);
     }
 
     /**
      * Tests that a type cannot be -1.
      *
      * @throws InputReaderException
      *             Never.
      */
     @Test(expected = AssertionError.class)
     public void testPrepareNull() throws InputReaderException {
         Main.prepare(-1);
     }
 
     /**
      * Prepares the controller with System.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testPrepareSystem() throws AbstractZemucanException {
         final int type = Main.ID_SYSTEM;
 
         final AbstractInterfaceController controller = Main.prepare(type);
         Assert.assertTrue("Interface system", //$NON-NLS-1$
                 controller instanceof ImplementationSystemInterfaceController);
     }
 }