/*
    * 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 22:39:08 -0500 (dom, 06 mar 2011) $:
   * Revision: $LastChangedRevision: 1916 $:
   * URL:      $HeadURL: https://zemucan.svn.sourceforge.net/svnroot/zemucan/branches/zemucan_v1/source-code/analyzers/src/test/java/name/angoca/zemucan/core/lexical/impl/ImplementationLexicalAnalyzerTest.java $:
   */
  package name.angoca.zemucan.core.lexical.impl;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import name.angoca.zemucan.AbstractZemucanException;
  import name.angoca.zemucan.core.lexical.model.Token;
  import name.angoca.zemucan.grammarReader.api.GrammarReaderController;
  import name.angoca.zemucan.interfaze.model.ReturnOptions;
  import name.angoca.zemucan.tools.Constants;
  import name.angoca.zemucan.tools.configurator.Configurator;
  import name.angoca.zemucan.tools.test.RandomTestRunner;
  
  import org.junit.AfterClass;
  import org.junit.Assert;
  import org.junit.BeforeClass;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  
  /**
   * This is the set of test for the lexical analyzer. The inputs are phrases that
   * represents the user's command, they are received like strings and this class
   * tests its conversion to Tokens and analyze the results.
   * <p>
   * <b>Control Version</b>
   * <p>
   * <ul>
   * <li>0.0.1 Class creation.</li>
   * <li>0.1.0</li>
   * <li>0.2.0</li>
   * <li>0.2.1 Recommendations from PMD.</li>
   * <li>0.2.2 Organized.</li>
   * <li>0.2.3 Setup class.</li>
   * <li>0.3.0 jUnit 4 annotations.</li>
   * <li>0.4.0 Invalid graph exception.</li>
   * <li>0.4.1 Set up method.</li>
   * <li>0.4.2 Destroy instance.</li>
   * <li>0.4.3 final and comments.</li>
   * <li>0.4.4 Reset system variable.</li>
   * <li>1.0.0 Moved to version 1.</li>
   * <li>1.1.0 Exception hierarchy changed.</li>
   * <li>1.2.0 New excception</li>
   * <li>1.3.0 Throws</li>
   * <li>1.4.0 Space after phrase</li>
   * <li>1.5.0 Null phrase and grammar controller</li>
   * <li>1.6.0 Param null tests</li>
   * <li>1.6.1 Method renamed</li>
   * <li>1.7.0 Token is reserved and tests modification.</li>
   * <li>1.7.1 Method change in analyzer.</li>
   * <li>1.7.2 Changed after the 9 cases.</li>
   * <li>1.7.3 Destroy instances in after class method.</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.7.3 2010-09-25
   */
  @RunWith(RandomTestRunner.class)
  public final class ImplementationLexicalAnalyzerTest {
      /**
       * The ')' word.
       */
      private static final String CLOSE_PARENTHESIS = ")"; //$NON-NLS-1$
  
      /**
       * The '&lt;colName&gt;' word.
       */
      private static final String COL_NAME = "<colName>"; //$NON-NLS-1$
  
      /**
       * The 'create' word.
      */
     private static final String CREATE = "create"; //$NON-NLS-1$
 
     /**
      * The 'create tab' words.
      */
     private static final String CREATE_TAB = "create tab";
     /**
      * The ' ' word.
      */
     private static final String SPACE = " "; //$NON-NLS-1$
 
     /**
      * Load the graph.
      *
      * @throws AbstractZemucanException
      *             Never
      */
     @BeforeClass
     public static void setUpBeforeClass() throws AbstractZemucanException {
         System.setProperty(Constants.ZEMUCAN_CONF_XML_PROPERTY,
                 "sa_conf-test.xml"); //$NON-NLS-1$
         Configurator.getInstance().setProperty(
                 Constants.GRAMMAR_READER_NAME_PROPERTY,
                 Configurator.GRAMMAR_READER_NAME_VALUE);
         Configurator.getInstance()
                 .setProperty(Constants.GRAMMAR_FILE_DESCRIPTORS_PROPERTY,
                         "grammar-test.xml"); //$NON-NLS-1$
 
         // Creates the Lexical analyzer instance.
         ImplementationLexicalAnalyzer.getInstance();
     }
 
     /**
      * Clears the configuration file name property at the end of the test.
      */
     @AfterClass
     public static void tearDownAfterClass() {
         // Destroy any existent instance.
         ImplementationLexicalAnalyzer.destroyInstance();
         GrammarReaderController.destroyInstance();
         // Recreates the configurator instance.
         Configurator.destroyInstance();
         System.clearProperty(Constants.ZEMUCAN_CONF_XML_PROPERTY);
     }
 
     /**
      * Default constructor.
      */
     public ImplementationLexicalAnalyzerTest() {
         // Nothing.
     }
 
     /**
      * Test of the options for the 'create table t1 (c1 int, c2 char(10'
      * command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCloseFirstParenthesis() throws AbstractZemucanException {
         final String cmdIn = "create table t1 (c1 int, c2 char(10"; //$NON-NLS-1$
 
         final String cmdOut = "create table t1 (c1 int, c2 char(10 )"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] {});
 
         Assert.assertEquals("object for 'create table t1 (c1 int, c2 char(10'", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * Test of the options for the 'create table t2(c1 int' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testComma() throws AbstractZemucanException {
         final String cmdIn = "create table t2(c1 int"; //$NON-NLS-1$
 
         final String cmdOut = "create table t2(c1 int "; //$NON-NLS-1$
 
         final String option1 = ","; //$NON-NLS-1$
         final String option2 = ImplementationLexicalAnalyzerTest.CLOSE_PARENTHESIS;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { option1, option2 });
 
         Assert.assertEquals("object for 'create table t2(c1 int'", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * Tests the token conversion.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testConvertionCrea() throws AbstractZemucanException {
         final String phraseIn = "crea"; //$NON-NLS-1$
 
         final String phraseOut = ImplementationLexicalAnalyzerTest.CREATE;
 
         final String token1 = "crea"; //$NON-NLS-1$
         final List<Token> tokens = new ArrayList<Token>();
         tokens.add(new Token(token1, true));
 
         final String actual = ImplementationLexicalAnalyzer.getInstance()
                 .replaceLastToken(phraseIn, tokens,
                         ImplementationLexicalAnalyzerTest.CREATE);
 
         final String expected = phraseOut;
 
         Assert.assertEquals("conversion for 'crea'", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Tests the token conversion 'create tab' -> 'create tab'.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testConvertionCreateTab() throws AbstractZemucanException {
         final String phraseIn = ImplementationLexicalAnalyzerTest.CREATE_TAB;
 
         final String phraseOut = ImplementationLexicalAnalyzerTest.CREATE_TAB;
 
         final String token1 = ImplementationLexicalAnalyzerTest.CREATE;
         final String token2 = "tab"; //$NON-NLS-1$
         final List<Token> tokens = new ArrayList<Token>();
         tokens.add(new Token(token1, true));
         tokens.add(new Token(token2, true));
 
         final String actual = ImplementationLexicalAnalyzer.getInstance()
                 .replaceLastToken(phraseIn, tokens, "tab");
 
         final String expected = phraseOut;
 
         Assert.assertEquals("conversion for 'create tab'", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test to complete the phrase crea (phrase).
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreaPhrase1() throws AbstractZemucanException {
         final String cmdIn = "crea"; //$NON-NLS-1$
 
         final String cmdOut = ImplementationLexicalAnalyzerTest.CREATE;
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final String actual = ret.getPhrase();
 
         final String expected = cmdOut;
 
         Assert.assertEquals("complete for 'crea'", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Test to complete the phrase crea (options).
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreaPhrase2() throws AbstractZemucanException {
         final String cmdIn = "crea"; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final int actual = ret.getOptions().length;
 
         final int expected = new String[] {}.length;
 
         Assert.assertEquals("options for 'crea'", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Test that the phrase 'crea' does not have several phrases.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreaPhrase3() throws AbstractZemucanException {
         final String cmdIn = "crea"; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final int actual = ret.getPhrases().length;
 
         final int expected = new String[] {}.length;
 
         Assert.assertEquals("phrases for 'crea'", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Test to complete the phrase 'crea' (object).
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreaPhrase4() throws AbstractZemucanException {
         final String cmdIn = "crea"; //$NON-NLS-1$
 
         final String cmdOut = ImplementationLexicalAnalyzerTest.CREATE;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] {});
 
         Assert.assertEquals("object for 'crea'", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Test of the options for the 'create' command. There is only one option.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateCommand() throws AbstractZemucanException {
         final String cmdIn = ImplementationLexicalAnalyzerTest.CREATE;
 
         final String cmdOut = ImplementationLexicalAnalyzerTest.CREATE
                 + " table";
 
         final String opt1 = "table"; //$NON-NLS-1$
         final String opt2 = "tablespace"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { opt1, opt2 });
 
         Assert.assertEquals("object for 'create'", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Test the token completion tab -> table.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateTab() throws AbstractZemucanException {
         final String cmdIn = ImplementationLexicalAnalyzerTest.CREATE_TAB;
 
         final String cmdOut = "create table"; //$NON-NLS-1$
 
         final String opt1 = "tablespace"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] { opt1 }, new String[] {});
 
         Assert.assertEquals("object for 'create tab'", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Test of the options for the 'create table' command. Test options.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateTableCommand1() throws AbstractZemucanException {
         final String cmdIn = "create table"; //$NON-NLS-1$
 
         final String opt1 = "<tableName>"; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final String[] actual = ret.getOptions();
 
         final String[] expected = new String[] { opt1 };
 
         Assert.assertEquals("options for 'create table'", //$NON-NLS-1$
                 expected.length, actual.length);
     }
 
     /**
      * Test of the options for the 'create table' command. Test phrases.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateTableCommand2() throws AbstractZemucanException {
         final String cmdIn = "create table"; //$NON-NLS-1$
 
         final String phrase1 = "tablespace"; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final String[] actual = ret.getPhrases();
 
         final String[] expected = new String[] { phrase1 };
 
         Assert.assertEquals("phrases for 'create table'", //$NON-NLS-1$
                 expected.length, actual.length);
     }
 
     /**
      * Test of the options for the 'create table' command. Phrase empty.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateTableCommand3() throws AbstractZemucanException {
         final String cmdIn = "create table"; //$NON-NLS-1$
 
         final String cmdOut = "create table"; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final String actual = ret.getPhrase();
 
         final String expected = cmdOut;
 
         Assert.assertEquals("complete for 'create table'", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test of the options for the 'create table' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateTableCommand4() throws AbstractZemucanException {
         final String cmdIn = "create table"; //$NON-NLS-1$
 
         final String cmdOut = "create table"; //$NON-NLS-1$
 
         final String phrase1 = "tablespace"; //$NON-NLS-1$
 
         final String opt1 = "<tableName>"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] { phrase1 }, new String[] { opt1 });
 
         Assert.assertEquals("object for 'create table'", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test of the options for the 'create table ' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateTableCommand4WithSpace()
             throws AbstractZemucanException {
         final String cmdIn = "create table "; //$NON-NLS-1$
 
         final String cmdOut = "create table "; //$NON-NLS-1$
 
         final String opt1 = "<tableName>"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { opt1 });
 
         Assert.assertEquals("object for 'create table '", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test of the options for the 'create table &lt;tableName&gt;' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCreateTableTableNameCommand()
             throws AbstractZemucanException {
         final String cmdIn = "create table t1"; //$NON-NLS-1$
 
         final String cmdOut = "create table t1 ("; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] {});
 
         Assert.assertEquals("object for 'create table t1'", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test of the options for the 'create table &lt;tableName&gt;(' command.
      * Without space between tableName and command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCTtnParenthesis() throws AbstractZemucanException {
         final String cmdIn = "create table t2("; //$NON-NLS-1$
         final String cmdOut = "create table t2( "; //$NON-NLS-1$
         final String opt1 = ImplementationLexicalAnalyzerTest.COL_NAME;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { opt1 });
 
         Assert.assertEquals("object for 'create table t2('", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test of the options for the 'create table &lt;tableName&gt; (' command.
      * With space between tableName and command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCTtnSpaceParenthesis() throws AbstractZemucanException {
         final String cmdIn = "create table t2 ("; //$NON-NLS-1$
 
         final String cmdOut = "create table t2 ( "; //$NON-NLS-1$
 
         final String opt1 = ImplementationLexicalAnalyzerTest.COL_NAME;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { opt1 });
 
         Assert.assertEquals("object for 'create table t2 ('", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test of the options for the 'create table &lt;tableName&gt; ( ' command.
      * With space between tableName and command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testCTtnSpaceParenthesisWithSpace()
             throws AbstractZemucanException {
         final String cmdIn = "create table t2 ( "; //$NON-NLS-1$
 
         final String cmdOut = "create table t2 ( "; //$NON-NLS-1$
 
         final String opt1 = ImplementationLexicalAnalyzerTest.COL_NAME;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { opt1 });
 
         Assert.assertEquals("object for 'create table t2 ('", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Test of the options for the 'create table t2(c1' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testDataType() throws AbstractZemucanException {
         final String cmdIn = "create table t2(c1"; //$NON-NLS-1$
 
         final String cmdOut = "create table t2(c1 "; //$NON-NLS-1$
 
         final String option1 = "int"; //$NON-NLS-1$
         final String option2 = "char"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { option1, option2 });
 
         Assert.assertEquals("object for 'create table t2(c1'", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * The string with two spaces returns a string empty.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testDoubleSpace() throws AbstractZemucanException {
         final String cmdIn = ImplementationLexicalAnalyzerTest.SPACE
                 + ImplementationLexicalAnalyzerTest.SPACE;
 
         final String cmdOut = ""; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final String actual = ret.getPhrase();
 
         final String expected = cmdOut;
 
         Assert.assertEquals("Empty phrase for an space", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * Empty string as a command gives also a completed phrase empty.
      *
      * @throws AbstractZemucanException
      *             Never
      */
     @Test
     public void testEmptyString1() throws AbstractZemucanException {
         final String cmdIn = ""; //$NON-NLS-1$
 
         final String cmdOut = ""; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final String actual = ret.getPhrase();
 
         final String expected = cmdOut;
 
         Assert.assertEquals("Return Empty phrase", expected, actual); //$NON-NLS-1$
     }
 
     /**
      * Empty string as a command gives a set of options different to zero. At
      * least, the grammar has to have one option.
      * <p>
      * If the grammar was not defined is it possible to return zero options,
      * however this is not a normal case.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testEmptyString2() throws AbstractZemucanException {
         final String cmdIn = ""; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final boolean condition = 0 < actual.getOptions().length;
 
         Assert.assertTrue("Zero options for an empty phrase", //$NON-NLS-1$
                 condition);
     }
 
     /**
      * An empty string does not have several way of phrases.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testEmptyString3() throws AbstractZemucanException {
         final String cmdIn = ""; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         Assert.assertEquals("Zero phrases for an empty phrase", 0, //$NON-NLS-1$
                 actual.getPhrases().length);
     }
 
     /**
      * Invalid, no options.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testInvalidCommand1() throws AbstractZemucanException {
         final String cmdIn = "create table t1 (c1 int char)"; //$NON-NLS-1$
 
         final String cmdOut = "create table t1 (c1 int char)"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] {});
 
         Assert.assertEquals("object for 'create table t1 (c1 int char)'", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * Invalid, no options.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testInvalidCommand2() throws AbstractZemucanException {
         final String cmdIn = "Andres Gomez Casanova"; //$NON-NLS-1$
 
         final String cmdOut = "Andres Gomez Casanova"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] {});
 
         Assert.assertEquals("object for 'Andres Gomez Casanova'", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * Tries to add a null answer.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test(expected = AssertionError.class)
     public void testNullAnswerReplacetoken()
             throws AbstractZemucanException {
         ImplementationLexicalAnalyzer.getInstance().replaceLastToken("", //$NON-NLS-1$
                 new ArrayList<Token>(), null);
     }
 
     /**
      * Tests that a phrase cannot be null.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test(expected = AssertionError.class)
     public void testNullPhrase() throws AbstractZemucanException {
         ImplementationLexicalAnalyzer.getInstance().analyzePhrase(null);
     }
 
     /**
      * Tries to add a null phrase.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test(expected = AssertionError.class)
     public void testNullPhraseReplacetoken()
             throws AbstractZemucanException {
         ImplementationLexicalAnalyzer.getInstance().replaceLastToken(null,
                 new ArrayList<Token>(), "");
     }
 
     /**
      * Tries to add a null in the list of tokens.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test(expected = AssertionError.class)
     public void testNullTokenInTokensReplacetoken()
             throws AbstractZemucanException {
         final List<Token> tokens = new ArrayList<Token>();
         tokens.add(null);
         ImplementationLexicalAnalyzer.getInstance().replaceLastToken("", //$NON-NLS-1$
                 tokens, "");
     }
 
     /**
      * Tries to add a null list of tokens.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test(expected = AssertionError.class)
     public void testNullTokensReplacetoken()
             throws AbstractZemucanException {
         ImplementationLexicalAnalyzer.getInstance().replaceLastToken("", //$NON-NLS-1$
                 null, "");
     }
 
     /**
      * Test of the options for the 'create table t1 (c1 int, c2 char(' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testPrecision() throws AbstractZemucanException {
         final String cmdIn = "create table t1 (c1 int, c2 char("; //$NON-NLS-1$
 
         final String cmdOut = "create table t1 (c1 int, c2 char( "; //$NON-NLS-1$
 
         final String option1 = "<charTypeValue>"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { option1 });
 
         Assert.assertEquals("object for 'create table t1 (c1 int, c2 char('", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * Test of the options for the 'create table t2(c1 int,' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testSecondColumn() throws AbstractZemucanException {
         final String cmdIn = "create table t2(c1 int,"; //$NON-NLS-1$
 
         final String cmdOut = "create table t2(c1 int, "; //$NON-NLS-1$
 
         final String option = ImplementationLexicalAnalyzerTest.COL_NAME;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { option });
 
         Assert.assertEquals("object for create table t2(c1 int,'", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * Test of the options for the 'create table t1 (c1 int, c2 char(10)'
      * command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testSeveralOptionsAfterColumn()
             throws AbstractZemucanException {
         final String cmdIn = "create table t1 (c1 int, c2 char(10)"; //$NON-NLS-1$
 
         final String cmdOut = "create table t1 (c1 int, c2 char(10) "; //$NON-NLS-1$
 
         final String option1 = ","; //$NON-NLS-1$
         final String option2 = ImplementationLexicalAnalyzerTest.CLOSE_PARENTHESIS;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] { option1, option2 });
 
         Assert.assertEquals(
                 "object for 'create table t1 (c1 int, c2 char(10)'", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * The string with just one space returns a string empty.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testSpace1() throws AbstractZemucanException {
         final String cmdIn = ImplementationLexicalAnalyzerTest.SPACE;
 
         final String cmdOut = ""; //$NON-NLS-1$
 
         final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                 .analyzePhrase(cmdIn);
         final String actual = ret.getPhrase();
 
         final String expected = cmdOut;
 
         Assert.assertEquals("Empty phrase for an space", expected, //$NON-NLS-1$
                 actual);
     }
 
     /**
      * The string with just one space returns a string with one space also.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testSpace2() throws AbstractZemucanException {
         final String cmdIn = ImplementationLexicalAnalyzerTest.SPACE;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final boolean condition = 0 < actual.getOptions().length;
 
         Assert.assertTrue("Several options for a space", //$NON-NLS-1$
                 condition);
     }
 
     /**
      * An space does not have several ways of phrases.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testSpace3() throws AbstractZemucanException {
         final String cmdIn = ImplementationLexicalAnalyzerTest.SPACE;
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         Assert.assertEquals("Zero phrases for a space", 0, //$NON-NLS-1$
                 actual.getPhrases().length);
     }
 
     /**
      * Test of the options for the 'create table t1 (c1 int)' command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testValidCommand1() throws AbstractZemucanException {
         final String cmdIn = "create table t1 (c1 int)"; //$NON-NLS-1$
 
         final String cmdOut = "create table t1 (c1 int)"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] {});
 
         Assert.assertEquals("object for 'create table t1 (c1 int)'", //$NON-NLS-1$
                 expected, actual);
     }
 
     /**
      * Test of the options for the 'create table t1 (c1 int, c2 char(10))'
      * command.
      *
      * @throws AbstractZemucanException
      *             Never.
      */
     @Test
     public void testValidCommand2() throws AbstractZemucanException {
         final String cmdIn = "create table t1 (c1 int, c2 char(10))"; //$NON-NLS-1$
 
         final String cmdOut = "create table t1 (c1 int, c2 char(10))"; //$NON-NLS-1$
 
         final ReturnOptions actual = ImplementationLexicalAnalyzer
                 .getInstance().analyzePhrase(cmdIn);
 
         final ReturnOptions expected = new ReturnOptions(cmdOut,
                 new String[] {}, new String[] {});
 
         Assert.assertEquals(
                 "object for 'create table t1 (c1 int, c2 char(10))'", //$NON-NLS-1$
                 expected, actual);
     }
 }