public void testHashCodeDifferent() throws InvalidTokenException {
        final String phrase1 = GraphAnswerTest.CREATE_TABLE;
        final String option11 = GraphAnswerTest.TABLE;
        final String option12 = GraphAnswerTest.TABLESPACE;

        final String phrase2 = GraphAnswerTest.CREATE_TABLESPACE;
        final String option21 = GraphAnswerTest.TABLENAME;
        final String option22 = GraphAnswerTest.TABLESPACENAME;

        final List<Token> phrases1 = new ArrayList<Token>();
        phrases1.add(new Token(phrase1, true));
        final List<Token> options1 = new ArrayList<Token>();
        options1.add(new Token(option11, true));
        options1.add(new Token(option12, true));
        final GraphAnswer expected = new GraphAnswer(phrases1, options1);

        final List<Token> phrases2 = new ArrayList<Token>();
        phrases2.add(new Token(phrase2, true));
        final List<Token> options2 = new ArrayList<Token>();
        options2.add(new Token(option21, true));
        options2.add(new Token(option22, true));
        final GraphAnswer actual = new GraphAnswer(phrases2, options2);

        final boolean condition = expected.hashCode() != actual.hashCode();

    public void testMergeAndSimplify() throws AbstractZemucanException {
        final String graphName1 = GraphTest.GRAPH1;
        final String graphName2 = GraphTest.GRAPH2;
        final String create = GraphTest.CREATE;
        final Graph graph1 = new Graph(graphName1, false);
        final Graph graph2 = new Graph(graphName2, false);

        graph1.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph1.addNode(create, create, true);
        graph1.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph1.firstPhaseFinished();
        graph1.addRelation(Constants.STARTING_NODE, create);
        graph1.addRelation(create, Constants.ENDING_NODE);
        graph1.secondPhaseFinished();

        graph2.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph2.addNode(create, create, true);
        graph2.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph2.firstPhaseFinished();
        graph2.addRelation(Constants.STARTING_NODE, create);
        graph2.addRelation(create, Constants.ENDING_NODE);
        graph2.secondPhaseFinished();

        graph1.merge(graph2);

    public void testHashCodeIdentical() throws InvalidTokenException {
        final String phrase1 = GraphAnswerTest.CREATE;
        final String option1 = GraphAnswerTest.TABLE;
        final String option2 = GraphAnswerTest.TABLESPACE;

        final List<Token> phrases1 = new ArrayList<Token>();
        phrases1.add(new Token(phrase1, true));
        final List<Token> options1 = new ArrayList<Token>();
        options1.add(new Token(option1, true));
        options1.add(new Token(option2, true));
        final GraphAnswer expected = new GraphAnswer(phrases1, options1);

        final List<Token> phrases2 = new ArrayList<Token>();
        phrases2.add(new Token(phrase1, true));
        final List<Token> options2 = new ArrayList<Token>();
        options2.add(new Token(option1, true));
        options2.add(new Token(option2, true));
        final GraphAnswer actual = new GraphAnswer(phrases2, options2);

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

        final Graph graph = new Graph("delimiters", false); //$NON-NLS-1$
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER.info("testNoDelimiters");

        final Graph graph = new Graph(GraphTest.VALIDATED_TWICE, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);
        graph.secondPhaseFinished();

        final StartingNode node = graph.getStartingNode();

        final List<AbstractGraphNode> nodes = node.getChildren();

        Assert.assertEquals(GraphTest.QTY_OF_WAYS, 2, nodes.size());

        final Graph graph = new Graph(GraphTest.VALIDATED_GRAPH, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

        final StartingNode node = graph.getStartingNode();

        final List<AbstractGraphNode> nodes = node.getChildren();

        Assert.assertEquals(GraphTest.QTY_OF_WAYS, 2, nodes.size());

        final Graph graph = new Graph(graphName, true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

        final StartingNode startingNode = graph.getStartingNode();

        final List<AbstractGraphNode> nodes = startingNode.getChildren();
        boolean found = false;
        for (final AbstractGraphNode node : nodes) {
            if (node.getId().equals(
                    graphName + ':' + Constants.LICENSE_TOKEN_ID)) {

        final Graph graph = new Graph("validated twice extra nodes", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);
        graph.secondPhaseFinished();

        final StartingNode node = graph.getStartingNode();

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;
        return xml;
    }

    /**
     * Tests that the configuration file has wrongly defined the delimiters.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testEmptyDelimiters() throws AbstractZemucanException {

        final Graph graph = new Graph(GraphTest.VALIDATED_TWICE, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);

        final Graph graph = new Graph("validated twice extra nodes", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

                + ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

                .info("testErrorBuildWithExtraTokens");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                actual, contentToParse, contentToValidate);
        grammar.generateGraph();
        grammar.getStartingNode();

        final Graph expected = new Graph(
                ImplementationXMLGrammarReaderTest.NORMAL_GRAPH, false);
        expected
                .addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        expected.addNode(ImplementationXMLGrammarReaderTest.CREATE,
                ImplementationXMLGrammarReaderTest.CREATE, true);
        expected.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        expected.firstPhaseFinished();

        expected.addRelation(Constants.STARTING_NODE,
                ImplementationXMLGrammarReaderTest.CREATE);
        expected.addRelation(ImplementationXMLGrammarReaderTest.CREATE,
                Constants.ENDING_NODE);

        expected.secondPhaseFinished();

        Assert.assertFalse(

                + ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

        final Graph graph = new Graph("not going ending node", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        graph.addNode(GraphTest.OTHER, GraphTest.OTHER, true);

        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);

        graph.addRelation(GraphTest.TABLE, GraphTest.OTHER);

        final Graph graph = new Graph(GraphTest.VALIDATED_GRAPH, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

        final Graph graph = new Graph("validated extra nodes", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

        final List<Token> phraseIn = new ArrayList<Token>();
        // Bogus warning in the next lines, but it's a test case :)
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        phraseIn.add(new Token(tokenIn4, true));
        phraseIn.add(new Token(tokenIn5, true));
        phraseIn.add(new Token(tokenIn6, true));
        phraseIn.add(new Token(tokenIn7, true));
        phraseIn.add(new Token(tokenIn8, true));

    public void testGetOptions4options() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String tokenIn2 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String tokenIn3 = ImplementationSyntacticAnalyzerTest.T1;
        final String tokenIn4 = ImplementationSyntacticAnalyzerTest.OPEN_PARENTHESIS;

        final String option1 = ImplementationSyntacticAnalyzerTest.COL_NAME;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        phraseIn.add(new Token(tokenIn4, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

    public void testCase6() throws AbstractZemucanException {
        final String cmdIn = "db2 create tables"; //$NON-NLS-1$

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create tablespace";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);
        // The only option is added in the phrase.
        Assert.assertEquals("phrases: '" + cmdIn + "'", 0, actualPhrasesSize);
    }

    /**
     * Tests case 7: Zero phrases and multiples options. command 'db2 create'
     *
     * @throws AbstractZemucanException
     */
    @Test
    public void testCase7() throws AbstractZemucanException {

@RunWith(RandomTestRunner.class)
public final class MessagesTest {
    /**
     * Default constructor.
     */
    public MessagesTest() {
        // Nothing.
    }

    /**
     * Tests to obtain an empty message.
     */
    @Test(expected = AssertionError.class)
    public void testGetEmpty() {
        Messages.getString(""); //$NON-NLS-1$
    }

    /**
     * Tests to obtain a null message.
     */
    @Test(expected = AssertionError.class)
    public void testGetNull() {
        Messages.getString(null);
    }

    /**
     * Test the retrieve of a non existing message.
     */
    @Test
    public void testGetStringNotExistant() {
        final String name = "NOT_EXISTING_MESSAGE"; //$NON-NLS-1$

        final String actual = Messages.getString(name);

        final String expected = '¡' + name + '!';

        Assert.assertEquals("Not existing message", expected, actual); //$NON-NLS-1$
    }
}

    public void testCase1() throws AbstractZemucanException {
        final String cmdIn = "db2"; //$NON-NLS-1$

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // catalog, create, attach
        Assert.assertEquals("options: '" + cmdIn + "'", 3, actualOptionsSize);
        // db2ilist, db2auto, db2fm, db2fmcu
        Assert.assertEquals("phrases: '" + cmdIn + "'", 4, actualPhrasesSize);
    }

    public void testHashCode() throws InvalidTokenException {
        final String phrase1 = GraphAnswerTest.CREATE;
        final String option1 = GraphAnswerTest.TABLE;
        final String option2 = GraphAnswerTest.TABLESPACE;

        final List<Token> phrases = new ArrayList<Token>();
        phrases.add(new Token(phrase1, true));
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        options.add(new Token(option2, true));
        final GraphAnswer object = new GraphAnswer(phrases, options);

    private String testEmptyGrammarText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += "    <idToken>STARTING_NODE</idToken>"; //$NON-NLS-1$

    public void testEmptyGrammar() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

        final List<Token> phraseIn = new ArrayList<Token>();
        // Bogus warning in the next lines, but it's a test case :)
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        phraseIn.add(new Token(tokenIn4, true));
        phraseIn.add(new Token(tokenIn5, true));
        phraseIn.add(new Token(tokenIn6, true));
        phraseIn.add(new Token(tokenIn7, true));

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);
        Assert.assertEquals("phrases: '" + cmdIn + "'", 0, actualPhrasesSize);
    }

    /**
     * Tests the command ' db2 crea'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test8a() throws AbstractZemucanException {

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // EMPTY
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);
        // db2, db2ilist, db2auto, db2fm, db2fmcu
        Assert.assertEquals("phrases: '" + cmdIn + "'", 5, actualPhrasesSize);
    }

    /**
     * Tests the command 'db2'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test4() throws AbstractZemucanException {

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // catalog, create, attach
        Assert.assertEquals("options: '" + cmdIn + "'", 3, actualOptionsSize);
        // db2ilist, db2auto, db2fm, db2fmcu
        Assert.assertEquals("phrases: '" + cmdIn + "'", 4, actualPhrasesSize);
    }

    /**
     * Tests the command 'db2 '
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test5() throws AbstractZemucanException {

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 2, actualOptionsSize);
        Assert.assertEquals("phrases: '" + cmdIn + "'", 0, actualPhrasesSize);
    }

    /**
     * Tests case 8: Zero phrases and one option. command 'db2 create table'
     *
     * @throws AbstractZemucanException
     */
    @Test
    public void testCase8() throws AbstractZemucanException {

    public void testHashCodeDifferent() throws ParameterNullException {
        final String phrase1 = "create table"; //$NON-NLS-1$
        final String phrase11 = ReturnOptionsTest.TABLESPACE;
        final String option11 = ReturnOptionsTest.TABLE_NAME;

        final String phrase2 = ReturnOptionsTest.CREATE;
        final String option21 = ReturnOptionsTest.TABLE;
        final String option22 = ReturnOptionsTest.TABLESPACE;

        final ReturnOptions object1 = new ReturnOptions(phrase1,
                new String[] { phrase11 }, new String[] { option11 });

        final ReturnOptions object2 = new ReturnOptions(phrase2,
                new String[] {}, new String[] { option21, option22 });

    private String testBuildWithExtraTokensText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;

    public void testValidateGraph() throws AbstractZemucanException {
        final Graph graph = new Graph(GraphTest.VALIDATED_GRAPH, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

        final GraphState actual = graph.getGraphState();

    private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
            .getBundle(Messages.BUNDLE_NAME);

    /**
     * Retrieves a message for the given string.
     *
     * @param key
     *            Name of the message.
     * @return Message in the corresponding language.
     */
    public static/* ! */String getString(final String/* ! */key) {
        assert (key != null) && !key.equals(""); //$NON-NLS-1$

        String message = ""; //$NON-NLS-1$
        try {
            message = Messages.RESOURCE_BUNDLE.getString(key);
        } catch (final MissingResourceException e) {
            message = '¡' + key + '!';
        }

        assert (message != null) && !message.equals(""); //$NON-NLS-1$
        return message;
    }

    /**
     * Default constructor hidden.
     */
    private Messages() {
        // Nothing. No tests.
    }
}

                "Removing relation in graph '{}' between '{}' and '{}'", //$NON-NLS-1$
                new String[] { this.name, parentId, childId });

        if (parentId == null) {
            throw new ParameterNullException("parentId"); //$NON-NLS-1$
        }
        if (childId == null) {
            throw new ParameterNullException("childId"); //$NON-NLS-1$
        }
        if (this.graphState.equals(GraphState.FirstPhase)) {
            throw new InvalidGraphStateException(this.graphState,
                    GraphState.SecondPhase);
        }
        if (this.graphState.equals(GraphState.Validated)) {
            this.graphState = GraphState.SecondPhase;
        }

        final AbstractGraphNode parent = this.nodes.get(this.name + ':'

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create tablespace";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);
        Assert.assertEquals("phrases: '" + cmdIn + "'", 0, actualPhrasesSize);
    }

    public void testToString() throws InvalidTokenException {
        final String phrase1 = GraphAnswerTest.CREATE;
        final String option1 = GraphAnswerTest.TABLE;
        final String option2 = GraphAnswerTest.TABLESPACE;

        final List<Token> phrases1 = new ArrayList<Token>();
        phrases1.add(new Token(phrase1, true));
        final List<Token> options1 = new ArrayList<Token>();
        options1.add(new Token(option1, true));
        options1.add(new Token(option2, true));
        final GraphAnswer answer = new GraphAnswer(phrases1, options1);

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        phraseIn.add(new Token(tokenIn4, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getPhrases();

        final Graph graph = new Graph(name, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        final String id = "CREA"; //$NON-NLS-1$
        final String nameNode = GraphTest.CREATE;
        graph.addNode(id, nameNode, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, id);
        graph.addRelation(id, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

        final String actual = graph.toString();

    public void testGetOptions3options() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String tokenIn2 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String tokenIn3 = ImplementationSyntacticAnalyzerTest.T1;

        final String option1 = ImplementationSyntacticAnalyzerTest.OPEN_PARENTHESIS;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

    public void testBuildNoEndingNode() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 ";

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // catalog, create, attach
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 3);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command 'db2 c'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test6() throws AbstractZemucanException {

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table t1 (";

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command 'd'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test2() throws AbstractZemucanException {

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 2);
    }

    /**
     * Tests the command 'db2 create table'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test16() throws AbstractZemucanException {

    public void removeRelation(final AbstractGraphNode parentNode,
            final AbstractGraphNode childNode)
            throws AbstractZemucanException {
        final int size = this.name.length() + 1;
        String parentId = parentNode.getId();
        String childId = childNode.getId();
        if (parentId.startsWith(this.name)) {
            parentId = parentId.substring(size);
        }
        if (childId.startsWith(this.name)) {
            childId = childId.substring(size);
        }
        this.removeRelation(parentId, childId);

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        phraseOut.add(new Token(tokenOut1, true));

        final Graph graph = new Graph("referencing starting node", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

        Exception e = null;
        try {
            graph.addRelation(GraphTest.CREATE, Constants.STARTING_NODE);

    public void testBuildNoName() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;

    public void testSymmetric() throws InvalidTokenException {
        final String tokenString1 = GraphAnswerTest.TEST1;
        final String tokenString2 = GraphAnswerTest.TEST2;

        final List<Token> phrases = new ArrayList<Token>();
        phrases.add(new Token(tokenString1, true));
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(tokenString2, true));
        final GraphAnswer actual = new GraphAnswer(phrases, options);

        final boolean value = actual.equals(actual);

        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        options.add(new Token(option2, true));
        final GraphAnswer expected = new GraphAnswer(phraseOut, options);

        Assert.assertEquals("'create ' command", expected, actual); //$NON-NLS-1$

        expected += expectedGraphName + graphName1 + ':'
                + Constants.ENDING_NODE + '-' + expectedGraphName + graphName1
                + ':' + Constants.ENDING_NODE + '\n';
        expected += expectedGraphName + graphName1 + ':'
                + Constants.STARTING_NODE + '-' + expectedGraphName
                + graphName1 + ':' + Constants.STARTING_NODE + '\n';
        expected += expectedGraphName + graphName1 + ':' + a + '-' + a + '\n';
        expected += expectedGraphName + graphName1 + ':' + create1Id + '-'
                + create + '\n';
        expected += expectedGraphName + graphName1 + ':' + e + '-' + e + '\n';

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += "    <idToken>STARTING_NODE</idToken>"; //$NON-NLS-1$

                ImplementationXMLGrammarReaderTest.NORMAL_GRAPH, false);
        expected
                .addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        expected.addNode(ImplementationXMLGrammarReaderTest.CREATE,
                ImplementationXMLGrammarReaderTest.CREATE, true);
        expected.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        expected.firstPhaseFinished();

        expected.addRelation(Constants.STARTING_NODE,
                ImplementationXMLGrammarReaderTest.CREATE);
        expected.addRelation(ImplementationXMLGrammarReaderTest.CREATE,
                Constants.ENDING_NODE);

        expected.secondPhaseFinished();

        Assert.assertEquals("Simple graph without extra tokens", expected, //$NON-NLS-1$

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += "    <idToken>STARTING_NODE</idToken>"; //$NON-NLS-1$

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getPhrases();

        phraseIn.add(new Token(tokenIn4, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        final GraphAnswer expected = new GraphAnswer(phraseOut, options);

        Assert.assertEquals("Phrases for 'create table t1' command", //$NON-NLS-1$

        final Graph graph = new Graph(GraphTest.VALIDATED_GRAPH, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

    private String testBuildWithExtraTokensText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;

        final Graph graph = new Graph(graphName, true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

        final StartingNode startingNode = graph.getStartingNode();

        final Graph graph = new Graph(GraphTest.DUMMY_GRAPH, true);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);

    public void testBuildNoIdNoName() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;

        final Graph graph = new Graph(graphName, true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);
        graph.secondPhaseFinished();

                + ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;

        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();

    public void testHashCodeIdentical() throws ParameterNullException {
        final String phrase = "create table"; //$NON-NLS-1$
        final String phrase1 = ReturnOptionsTest.TABLESPACE;
        final String option1 = ReturnOptionsTest.TABLE_NAME;

        final ReturnOptions object1 = new ReturnOptions(phrase,
                new String[] { phrase1 }, new String[] { option1 });

        final ReturnOptions object2 = new ReturnOptions(phrase,
                new String[] { phrase1 }, new String[] { option1 });

        final Graph graph = new Graph("referencing ending node", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

    private String testBuildWithExtraTokensText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;

        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        options.add(new Token(option2, true));

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 2, actualOptionsSize);

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // EMPTY
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 1, actualOptionsSize);

    public void testBuildNotAllChildren() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();

        expected += expectedGraphName + graphName2 + ':'
                + Constants.ENDING_NODE + '-' + expectedGraphName + graphName2
                + ':' + Constants.ENDING_NODE + '\n';
        expected += expectedGraphName + graphName2 + ':'
                + Constants.STARTING_NODE + '-' + expectedGraphName
                + graphName2 + ':' + Constants.STARTING_NODE + '\n';
        expected += expectedGraphName + graphName2 + ':' + create + '-'
                + create + '\n';
        expected += ")]"; //$NON-NLS-1$

        Assert.assertEquals("Merge and Simplify", expected, actual); //$NON-NLS-1$

                + ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;

        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        final GraphAnswer expected = new GraphAnswer(phraseOut, options);

        Assert.assertEquals("'create table t1' command", expected, //$NON-NLS-1$

    @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() {
        // Destroys any existent instance.
        ImplementationLexicalAnalyzer.destroyInstance();

    public void testSimpleMethods() throws AbstractZemucanException {
        final String tokenString1 = GraphAnswerTest.TEST1;
        final String tokenString2 = GraphAnswerTest.TEST2;

        final List<Token> phrases = new ArrayList<Token>();
        phrases.add(new Token(tokenString1, true));
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(tokenString2, true));
        final GraphAnswer graphAnswer = new GraphAnswer(phrases, options);

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        phraseIn.add(new Token(tokenIn4, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);
        Assert.assertEquals("phrases: '" + cmdIn + "'", 0, actualPhrasesSize);
    }

    /**
     * Tests the command 'db2 crea '
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test9() throws AbstractZemucanException {

        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        final GraphAnswer expected = new GraphAnswer(phraseOut, options);

        Assert.assertEquals("'toto' phrase", expected, actual); //$NON-NLS-1$

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getPhrases();

    public void testGetOptions2WithSpace() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String tokenIn2 = ImplementationSyntacticAnalyzerTest.TABLE;

        final String option1 = ImplementationSyntacticAnalyzerTest.TABLE_NAME;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = true;

        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        options.add(new Token(option2, true));

        graph2.addRelation(z, Constants.ENDING_NODE);
        graph2.secondPhaseFinished();

        graph2.merge(graph1);
        graph1.simplifyGraph();

        final String actual = graph1.toString();

        String expectedGraphName = "merged:{" + graphName1 + ',' + graphName2
                + "}:";
        String expected = expectedGraphName + '[' + GraphState.Validated
                + "-WithoutExtraNodes{{" + Constants.STARTING_NODE + '<'
                + expectedGraphName + graphName1 + ':' + create1Id + '-'

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

        final Graph graph = new Graph("node without name", false); //$NON-NLS-1$

        phraseIn.add(new Token(tokenIn4, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getOptions();

        final List<Token> expected = new ArrayList<Token>();
        expected.add(new Token(option1, true));

        Assert.assertEquals("Options for 'create table t1 (' command", //$NON-NLS-1$

        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

        final String id = "no StartingNode"; //$NON-NLS-1$

        if (Boolean.parseBoolean(Configurator.getInstance().getProperty(
                AbstractInterfaceController.SHOW_LICENSE))) {
            this.output.writeLine(AboutNode.readAboutInformation());
        }

        // Shows a introductory help.
        if (Boolean.parseBoolean(Configurator.getInstance().getProperty(
                AbstractInterfaceController.SHOW_INTRO_PROPERTY))) {
            this.output
                    .writeLine(Messages
                            .getString("ImplementationSystemInterfaceController.Instructions")); //$NON-NLS-1$

        System.setProperty(ImplementationExecuter.DB2_PARAMS, "-v"); //$NON-NLS-1$
        final String command = "db2 !dir"; //$NON-NLS-1$
        final String os = System.getProperty("os.name"); //$NON-NLS-1$

        System.setProperty("os.name", "Windows 7"); //$NON-NLS-1$ //$NON-NLS-2$
        final String[] actuals = ImplementationExecuter.getInstance()
                .getCommandsToExecute(command);
        System.setProperty("os.name", os); //$NON-NLS-1$

        final String[] expecteds = new String[] { "cmd.exe", "/c", "db2", "-v", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

        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 EndingNode actual = new EndingNode(new Graph("test", false));

        Assert.assertTrue("HashCode different to 1", //$NON-NLS-1$
                1 != actual.hashCode());
        Assert.assertTrue("HashCode different to 0", //$NON-NLS-1$
                0 != actual.hashCode());
        Assert.assertTrue("HashCode different to -1", //$NON-NLS-1$
                -1 != actual.hashCode());
    }

    /**
     * Test the equals method to a null.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testNullEqualsObject() throws AbstractZemucanException {
        final EndingNode actual = new EndingNode(new Graph("test", false));

    public void testErrorBuildWithExtraTokens() throws AbstractZemucanException {
        final String xml = this.testBuildWithExtraTokensText();

        final String id = ImplementationXMLGrammarReaderTest.NORMAL_GRAPH;
        final Graph actual = new Graph(id, true);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testErrorBuildWithExtraTokens");

        assert !key.equals(""); //$NON-NLS-1$

        String message = ""; //$NON-NLS-1$
        try {
            message = Messages.RESOURCE_BUNDLE.getString(key);
        } catch (final MissingResourceException e) {
            message = '¡' + key + '!';
        }

        assert (message != null) && !message.equals(""); //$NON-NLS-1$
        return message;
    }

    /**
     * Default constructor hidden.
     */
    private Messages() {
        // Nothing. No tests.
    }
}

        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getOptions();

        final List<Token> expected = new ArrayList<Token>();
        expected.add(new Token(option1, true));

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        phraseIn.add(new Token(tokenIn4, true));

        final Graph graph = new Graph("not coming starting node", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        graph.addNode(GraphTest.OTHER, GraphTest.OTHER, true);

        final String node23 = GraphNodeTest.TABLESPACE;

        final GraphNode actual = new GraphNode(node11, graph);
        final GraphNode child1 = new GraphNode(node12, graph);
        actual.addChild(child1);
        final GraphNode expected = new GraphNode(node21, graph);
        final GraphNode child2 = new GraphNode(node22, graph);
        expected.addChild(child2);
        final GraphNode child3 = new GraphNode(node23, graph);

	}

	/*
	 * (non-Javadoc)
	 *
	 * @see java.lang.Object#hashCode()
	 */
	@Override
	public final int hashCode() {
		int superHash = super.hashCode();
		if (superHash == 0) {
			superHash = 1;
		}
		final int value = superHash + GraphNode.class.getName().hashCode();
		return value;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see
	 * name.angoca.zemucan.core.graph.model.AbstractGraphNode#represent(java
	 * .lang.String)
	 */
	@Override
	public final boolean represent(final String/* ! */token) {

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

        final String id = "no StartingNode"; //$NON-NLS-1$

                + z + "]}}(4:\n";

        expected += expectedGraphName + graphName1 + ':'
                + Constants.ENDING_NODE + '-' + expectedGraphName + graphName1
                + ':' + Constants.ENDING_NODE + '\n';
        expected += expectedGraphName + graphName1 + ':'
                + Constants.STARTING_NODE + '-' + expectedGraphName
                + graphName1 + ':' + Constants.STARTING_NODE + '\n';
        expected += expectedGraphName + graphName1 + ':' + create1Id + '-'

        ImplementationXMLGrammarReaderTest.LOGGER.info("testNoDelimiters");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("DelimitersIncorrectlyDefinedException",
                e instanceof DelimitersIncorrectlyDefinedException);
    }

    /**
     * Tests a not existing file as grammar.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void testNotExistingFile() throws AbstractZemucanException {

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

                .info("testBuildNoStartingNode");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("StartingNodeNotDefinedException",
                e instanceof StartingNodeNotDefinedException);
    }

    /**
     * Tests a grammar that has defined all the nodes that are children.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testBuildNotAllChildren() throws AbstractZemucanException {

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

                .info("testBuildUnknownStructure");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("XMLProblemException",
                e instanceof XMLProblemException);
    }

    /**
     * Tests that a simple graph can be constructed with extra tokens.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testBuildWithExtraTokens() throws AbstractZemucanException {

    public void testGetOptions7() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String tokenIn2 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String tokenIn3 = ImplementationSyntacticAnalyzerTest.T1;
        final String tokenIn4 = ImplementationSyntacticAnalyzerTest.OPEN_PARENTHESIS;
        final String tokenIn5 = ImplementationSyntacticAnalyzerTest.C1;
        final String tokenIn6 = ImplementationSyntacticAnalyzerTest.INT;
        final String tokenIn7 = ImplementationSyntacticAnalyzerTest.CLOSE_PARENTHESIS;
        final String tokenIn8 = "in"; //$NON-NLS-1$

        final List<Token> phraseIn = new ArrayList<Token>();

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 1, actualOptionsSize);
        Assert.assertEquals("phrases: '" + cmdIn + "'", 0, actualPhrasesSize);

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);
        Assert.assertEquals("phrases: '" + cmdIn + "'", 2, actualPhrasesSize);

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // <tableName>
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 1);

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);
        Assert.assertEquals("phrases: '" + cmdIn + "'", 2, actualPhrasesSize);

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // <tableName>
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 1);

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // -t, -i
        Assert.assertEquals("options: '" + cmdIn + "'", 2, actualOptionsSize);
        // db2fmcu
        Assert.assertEquals("phrases: '" + cmdIn + "'", 1, actualPhrasesSize);

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);

        final Graph graph = new Graph(GraphTest.VALIDATED_GRAPH, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;

        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;

    public void testGetOptions1options() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;

        final String option1 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String option2 = ImplementationSyntacticAnalyzerTest.TABLESPACE;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests case 1: Multiples phrases and multiples options. command 'db2'
     *
     * @throws AbstractZemucanException
     */
    @Test
    public void testCase1() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // int, char
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 2);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command 'db2 create table t1 ( c1 int )'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test24() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // <colName>
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 1);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command 'db2 create table t1 (c1'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test22() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command ' db2'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test25() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 1);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command 'db2 create table t1('
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test21() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 2);
    }

    // TODO v2.0 tests "db2 update db" Aquí se usan alias y no
    // funciona

    /**
     * Tests the command 'db2 c'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test7() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command 'db2 create table t1 '
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test19() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 2);
    }

    // TODO v2.0 tests "db2 update db" Aquí se usan alias y no
    // funciona

    /**
     * Tests the command 'db2 c'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test7() throws AbstractZemucanException {

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // int, char
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 2);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);
    }

    /**
     * Tests the command 'db2 create table t1( c1'
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void test23() throws AbstractZemucanException {

        expected += expectedGraphName + graphName1 + ':'
                + Constants.ENDING_NODE + '-' + expectedGraphName + graphName1
                + ':' + Constants.ENDING_NODE + '\n';
        expected += expectedGraphName + graphName1 + ':'
                + Constants.STARTING_NODE + '-' + expectedGraphName
                + graphName1 + ':' + Constants.STARTING_NODE + '\n';
        expected += expectedGraphName + graphName1 + ':' + a + '-' + a + '\n';

    public void testHashCodeIdenticalReserved()
            throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String node1 = GraphNodeTest.CREATE;
        final String node2 = GraphNodeTest.CREATE;

        final GraphNode actual = new GraphNode(node1, graph);
        final GraphNode expected = new GraphNode(node2, graph);

        final boolean condition = actual.hashCode() == expected.hashCode();

    public void testHashCodeIdenticalNotReserved()
            throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String node1 = GraphNodeTest.TABLENAME;
        final String node2 = GraphNodeTest.TABLENAME;

        final NonReservedGraphNode actual = new NonReservedGraphNode(node1,
                graph);
        final NonReservedGraphNode expected = new NonReservedGraphNode(node2,
                graph);

        final boolean condition = actual.hashCode() == expected.hashCode();

        final GraphNode actual = new GraphNode(node11, graph);
        final GraphNode child1 = new GraphNode(node12, graph);
        actual.addChild(child1);
        final GraphNode expected = new GraphNode(node21, graph);
        final GraphNode child2 = new GraphNode(node22, graph);
        expected.addChild(child2);
        final boolean condition = actual.equals(expected);

    public void testBuildNoEndingNode() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;

        final GraphNode actual = new GraphNode(node11, graph);
        final GraphNode child1 = new GraphNode(node12, graph);
        actual.addChild(child1);
        final GraphNode expected = new GraphNode(node21, graph);
        final GraphNode child2 = new GraphNode(node22, graph);
        expected.addChild(child2);
        final boolean condition = actual.equals(expected);

    public void testEqualsDifferentParents()
            throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String node11 = GraphNodeTest.CREATE;
        final String node12 = GraphNodeTest.TABLE;
        final String node21 = GraphNodeTest.CREATE;
        final String node22 = GraphNodeTest.TABLESPACE;

        final GraphNode actual = new GraphNode(node11, graph);
        final GraphNode parent1 = new GraphNode(node12, graph);

                + ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;

        final String os = System.getProperty("os.name"); //$NON-NLS-1$

        System.setProperty("os.name", "Windows 7"); //$NON-NLS-1$ //$NON-NLS-2$
        final String[] actuals = ImplementationExecuter.getInstance()
                .getCommandsToExecute(command);
        System.setProperty("os.name", os); //$NON-NLS-1$

        final String[] expecteds = new String[] { "cmd.exe", "/c", "dir" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

        final Graph graph = new Graph(GraphTest.STARTING_NODE, false);
        graph.addNode(GraphTest.ID1, GraphTest.ID1, true);
        graph.addNode(GraphTest.ID2, GraphTest.ID2, true);
        graph.firstPhaseFinished();
        graph.addRelation(GraphTest.ID1, GraphTest.ID2);

        Exception e = null;
        try {
            graph.getStartingNode();

        graph.addNode("tablespace", GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);
        graph.addRelation(GraphTest.CREATE, "tablespace");

        ImplementationXMLGrammarReaderTest.LOGGER.info("testDoubleDelimiters");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("XMLProblemException",
                e instanceof XMLProblemException);
    }

    private String testBuildNodeNotGoesToEndingNodeText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;

                .info("testBuildNotConnectedGraph");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("NodeNotComesFromStartingNodeException",
                e instanceof NodeNotComesFromStartingNodeException);
    }

        ImplementationXMLGrammarReaderTest.LOGGER.info("testDoubleDelimiters");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("XMLProblemException",
                e instanceof XMLProblemException);
    }

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getPhrases();

    public void testGetOptions1WithSpace() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;

        final String option1 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String option2 = ImplementationSyntacticAnalyzerTest.TABLESPACE;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = true;

        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));

    public void testGetOptions1WithSpace() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;

        final String option1 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String option2 = ImplementationSyntacticAnalyzerTest.TABLESPACE;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = true;

        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));

        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(

    public void testGetOptions6() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String tokenIn2 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String tokenIn3 = ImplementationSyntacticAnalyzerTest.T1;
        final String tokenIn4 = ImplementationSyntacticAnalyzerTest.OPEN_PARENTHESIS;
        final String tokenIn5 = ImplementationSyntacticAnalyzerTest.C1;
        final String tokenIn6 = ImplementationSyntacticAnalyzerTest.INT;
        final String tokenIn7 = ImplementationSyntacticAnalyzerTest.CLOSE_PARENTHESIS;
        final String tokenIn8 = "in"; //$NON-NLS-1$

        phraseIn.add(new Token(tokenIn4, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getPhrases();

        final List<Token> expected = new ArrayList<Token>();

        Assert.assertEquals("Phrase for 'create table t1 (' command", //$NON-NLS-1$

        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> actual = graph.getOptions();
        final List<Token> expected = new ArrayList<Token>();
        expected.add(new Token(option1, true));

                e instanceof ParentStartingNodeException);
    }

    /**
     * Tests if two consecutive calls returns the same value.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testCongruent() throws AbstractZemucanException {
        final String node = "test"; //$NON-NLS-1$

        final GraphNode node1 = new GraphNode(node, new Graph("test", false));
        final int val1 = node1.hashCode();
        final int val2 = node1.hashCode();

        final boolean condition = val1 == val2;

    public void testBuildNoEndingNode() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;

        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // table Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_TABLE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_TABLE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

    private String testBuildNodeNotComeFromStartingNodeText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_TABLE_ID_TOKEN;

    public void testGetOptions0options() throws AbstractZemucanException {
        // There is nothing as token in.

        final String option1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String option2 = ImplementationSyntacticAnalyzerTest.ABOUT;
        final String option3 = ImplementationSyntacticAnalyzerTest.HELP;
        final String option4 = ImplementationSyntacticAnalyzerTest.LICENSE;

        final List<Token> phraseIn = new ArrayList<Token>();
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2";

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);

    public void testHashCodeDifferent() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String node1 = GraphNodeTest.CREATE;
        final String node2 = GraphNodeTest.TABLENAME;

        final GraphNode actual = new GraphNode(node1, graph);
        final NonReservedGraphNode expected = new NonReservedGraphNode(node2,
                graph);

        final int actualHashcode = actual.hashCode();

    public void testBuildNotConnectedGraph() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;

        phraseIn.add(new Token(tokenIn7, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();

    @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$
        ImplementationSyntacticAnalyzer.getInstance();

public final class ImplementationLexicalAnalyzerRealGrammarTest {

    /**
     * Load the graph.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @BeforeClass
    public static void setUpBeforeClass() throws AbstractZemucanException {
        System.setProperty(Constants.ZEMUCAN_CONF_XML_PROPERTY,
                "sa_conf-test-realGrammar.xml"); //$NON-NLS-1$
        Configurator.getInstance().setProperty(
                Constants.GRAMMAR_READER_NAME_PROPERTY,
                Configurator.GRAMMAR_READER_NAME_VALUE);

        // Creates the Lexical analyzer instance.
        ImplementationLexicalAnalyzer.getInstance();
    }

    /**
     * Clears the configuration file name property at the end of the test.
     */
    @AfterClass
    public static void tearDownAfterClass() {

public final class IntegrationTest {

    /**
     * Refreshes the singletons.
     *
     * @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$

        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;
        return xml;
    }

    /**
     * Tests that a simple graph is different with and without extra tokens.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testErrorBuildWithExtraTokens() throws AbstractZemucanException {

        final String option1 = ImplementationSyntacticAnalyzerTest.TABLE_NAME;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 2);

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // <tableName>
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 1);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 0);
        Assert.assertTrue("phrases: '" + cmdIn + "'",
                ret.getPhrases().length == 0);

                + parentId);
        if (parent == null) {
            throw new NotExistingNodeException(parentId);
        }

        // Retrieves the child and established the relation.
        final AbstractGraphNode childNode = this.nodes.get(this.name + ':'
                + childId);
        if (childNode == null) {
            throw new NotExistingChildNodeException(parentId, childId);
        }

        parent.removeChild(childNode);

        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getPhrases();

        final List<Token> expected = new ArrayList<Token>();

    @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$

        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 {

    @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$

        final OutputWriter writer = null;

        Exception e = null;
        try {
            ImplementationExecuter.getInstance().execute(command, writer);
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("ParameterNullException",
                e instanceof ParameterNullException);
    }

    /**
     * Tests the execution of a quit command.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void testExecuteQuit() throws AbstractZemucanException {

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        phraseIn.add(new Token(tokenIn3, true));

    public void testHashCode() throws ParameterNullException {
        final String phrase = "create table"; //$NON-NLS-1$
        final String phrase1 = ReturnOptionsTest.TABLESPACE;
        final String option1 = ReturnOptionsTest.TABLE_NAME;

        final ReturnOptions object = new ReturnOptions(phrase,
                new String[] { phrase1 }, new String[] { option1 });

        String expectedGraphName = "merged:{" + graphName1 + ',' + graphName2
                + "}:";
        String expected = expectedGraphName + '[' + GraphState.Validated
                + "-WithoutExtraNodes{{" + Constants.STARTING_NODE + '<'
                + expectedGraphName + graphName1 + ':' + a + '-'
                + expectedGraphName + graphName1 + ':' + create1Id + '-'

        final Graph graph = new Graph("not coming starting node", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        graph2.simplifyGraph();

        final String actual = graph2.toString();

        String expectedGraphName = "merged:{" + graphName2 + ',' + graphName1
                + "}:";
        String expected = expectedGraphName + '[' + GraphState.Validated
                + "-WithoutExtraNodes{{" + Constants.STARTING_NODE + '<'
                + expectedGraphName + graphName2 + ':' + create + ">}-{"

        final Graph graph = new Graph("Duplicated node name", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode("tablespace", GraphTest.TABLE, true);

        ImplementationXMLGrammarReaderTest.LOGGER.info("testEmptyGrammar");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("EmptyGrammarException",

    private String testBuildWithExtraTokensText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;

                .info("testBuildNotAllChildren");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                graph, contentToParse, contentToValidate);

        Exception e = null;
        try {
            grammar.generateGraph();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("NotExistingChildNodeException",

        final List<Token> phrases1 = new ArrayList<Token>();
        phrases1.add(new Token(phrase1, true));
        final List<Token> options1 = new ArrayList<Token>();
        options1.add(new Token(option1, false));

        final String tokenOut2 = ImplementationSyntacticAnalyzerTest.TABLESPACE;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer

        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$

        final Graph graph = new Graph("ending node", false); //$NON-NLS-1$
        graph.addNode(GraphTest.ID1, GraphTest.ID1, true);
        graph.addNode(GraphTest.ID2, GraphTest.ID2, true);
        graph.firstPhaseFinished();
        graph.addRelation(GraphTest.ID1, GraphTest.ID2);

    public void testEqualsNodeReserved() throws AbstractZemucanException {
        final String node = LicenseNodeTest.LICENSE_NODE;
        final Graph graph = new Graph("test", false);

        final LicenseNode actual = new LicenseNode(graph);
        final GraphNode notExpected = new GraphNode(node, graph);

        Assert.assertFalse(

    public void testAddNullRelation2() throws AbstractZemucanException {
        final Graph graph = new Graph(GraphTest.NULL_RELATION, false);
        graph.addNode(GraphTest.ID1, GraphTest.ID1, true);
        graph.firstPhaseFinished();

        Exception e = null;
        try {
            graph.addRelation(null, GraphTest.ID1);

    public void testEqualsNodeReserved() throws AbstractZemucanException {
        final String node = EndingNodeTest.ENDING_NODE;
        final Graph graph = new Graph("test", false);

        final EndingNode actual = new EndingNode(graph);
        final GraphNode notExpected = new GraphNode(node, graph);

        Assert.assertFalse(

    public void testEqualsNodeReserved() throws AbstractZemucanException {
        final String node = AboutNodeTest.ABOUT_NODE;
        final Graph graph = new Graph("test", false);

        final AboutNode actual = new AboutNode(graph);
        final GraphNode notExpected = new GraphNode(node, graph);

        Assert.assertFalse("Equals between AboutNode and a reserved GraphNode", //$NON-NLS-1$

        final LicenseNode node1 = new LicenseNode(new Graph("test", false));
        final int val1 = node1.hashCode();
        final int val2 = node1.hashCode();

        final boolean val = val1 == val2;

        Assert.assertTrue("Two consecutive calls return the same value", val); //$NON-NLS-1$
    }

    /**
     * Test the toString method with no license file.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testDefaultLicense() throws AbstractZemucanException {

        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;
        return xml;
    }

    /**
     * Tests a grammar that has a node that references to StartingNode.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testBuildNodeReferencingStartingNode()

        final List<Token> phrases1 = new ArrayList<Token>();
        phrases1.add(new Token(phrase1, true));
        final List<Token> options1 = new ArrayList<Token>();
        options1.add(new Token(option1, true));

	private ReturnOptions phraseOne(String newPhrase, final List<Token> tokens,
			final GraphAnswer answer, final int sizeOptions,
			String[] setOfOptions, String[] setOfPhrases)
			throws GeneralException, ParameterNullException {
		if (sizeOptions > 1) {
			// There are one phrase and multiple options, then add them.
			ImplementationLexicalAnalyzer.LOGGER.debug("Case 4!");

        final Graph graph1 = new Graph(GraphTest.GRAPH1, false);
        final Graph graph2 = new Graph(GraphTest.GRAPH2, false);

        graph1.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph1.addNode(GraphTest.CREATE1, GraphTest.CREATE, true);

        graph.addNode(GraphTest.OTHER, GraphTest.OTHER, true);

        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);

        graph.addRelation(GraphTest.OTHER, GraphTest.CREATE);

    public void testAddRelationInSecondPhase()
            throws AbstractZemucanException {
        final Graph graph = new Graph(GraphTest.ADD_RELATION, false);
        graph.addNode(GraphTest.ID1, GraphTest.ID1, true);
        graph.addNode(GraphTest.ID2, GraphTest.ID2, true);

    public void testToStringWithParents() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String nodeIn = GraphNodeTest.TABLENAME;
        final String nodeIn1 = GraphNodeTest.TABLENAME;
        final String nodeOut = GraphNodeTest.TABLENAME + "::" + '{'
                + GraphNodeTest.TABLENAME
                + "\n1\t<" + GraphNodeTest.TABLENAME + ">\n0\nfalse|false}"; //$NON-NLS-1$ //$NON-NLS-2$

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        Assert.assertEquals("options: '" + cmdIn + "'", 0, actualOptionsSize);

        final int actualOptionsSize = ret.getOptions().length;
        final int actualPhrasesSize = ret.getPhrases().length;
        Assert.assertEquals("phrase '" + cmdIn + "'", expected, actual);
        // EMPTY
        Assert.assertEquals("options '" + cmdIn + "'", 0, actualOptionsSize);

    public void testEqualsNodeReserved() throws AbstractZemucanException {
        final String node = "StartingNode"; //$NON-NLS-1$
        final Graph graph = new Graph("test", false);

        final StartingNode actual = new StartingNode(graph);
        final GraphNode notExpected = new GraphNode(node, graph);

        Assert.assertFalse("equals for a reserved object", //$NON-NLS-1$

    public void testEqualsSameChildren() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String node11 = GraphNodeTest.CREATE;
        final String node12 = GraphNodeTest.TABLE;
        final String node21 = GraphNodeTest.CREATE;
        final String node22 = GraphNodeTest.TABLE;

        final GraphNode actual = new GraphNode(node11, graph);

        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_2;

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()

public final class JlineInputReaderTest {
    /**
     * Establishes the configuration for the tests. This configuration is before
     * all the tests.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @BeforeClass
    public static void setUpBeforeClass() throws AbstractZemucanException {
        System.setProperty(Constants.ZEMUCAN_CONF_XML_PROPERTY,
                "sa_conf-test-realGrammar.xml"); //$NON-NLS-1$
        Configurator.getInstance().setProperty(
                Constants.GRAMMAR_READER_NAME_PROPERTY,
                Configurator.GRAMMAR_READER_NAME_VALUE);

        // Creates the Lexical analyzer instance.
        ImplementationLexicalAnalyzer.getInstance();
    }

    /**
     * Configuration before each test.
     *
     * @throws IOException
     *             If there is a problem when initializing the console.
     */
    @Before

        final GraphNode actual = new GraphNode(node1, graph);
        final GraphNode expected = new GraphNode(node2, graph);
        final boolean condition = actual.equals(expected);
        final boolean condition2 = expected.equals(actual);

        Assert.assertTrue("two identical nodes - reserved word", //$NON-NLS-1$

        final NonReservedGraphNode actual = new NonReservedGraphNode(node1,
                graph);
        final NonReservedGraphNode expected = new NonReservedGraphNode(node2,
                graph);
        final boolean condition = actual.equals(expected);
        final boolean condition2 = expected.equals(actual);

        Assert.assertTrue("two identical node reserved", condition); //$NON-NLS-1$

        final GraphNode node1 = new GraphNode(node, new Graph("test", false));
        final int val1 = node1.hashCode();
        final int val2 = node1.hashCode();

        final boolean val = val1 == val2;

        Assert.assertTrue("Two consecutive calls return the same value", val); //$NON-NLS-1$
    }

    /**
     * Tests that the graph node has to receive a not null parameter.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test(expected = AssertionError.class)

        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;

        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_TABLE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;

        final List<Token> phraseIn = new ArrayList<Token>();
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getPhrases();

        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$

    public void testEqualsMoreChildren() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String node11 = GraphNodeTest.CREATE;
        final String node12 = GraphNodeTest.TABLE;
        final String node21 = GraphNodeTest.CREATE;
        final String node22 = GraphNodeTest.TABLE;

                .info("testNullContentToValidate");

        Exception e = null;
        try {
            new ImplementationXMLGrammarReader(graph, contentToParse,
                    contentToValidate);
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("ParameterNullException",
                e instanceof ParameterNullException);
    }

    /**
     * Tests that a graph cannot be null.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testNullGraph() throws AbstractZemucanException {

                .info("testBuildWithoutExtraTokens");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                actual, contentToParse, contentToValidate);
        grammar.generateGraph();
        grammar.getStartingNode();

        final Graph expected = new Graph(
                ImplementationXMLGrammarReaderTest.NORMAL_GRAPH, false);

        final Graph graph = new Graph(id, false);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildNoStartingNode");

        System.setProperty(ImplementationExecuter.DB2_PARAMS, "-v"); //$NON-NLS-1$
        System.setProperty("os.name", "Linux Virtual"); //$NON-NLS-1$ //$NON-NLS-2$

        final String command = "db2 !ls"; //$NON-NLS-1$
        final String[] actuals = ImplementationExecuter.getInstance()
                .getCommandsToExecute(command);

        final String[] expecteds = new String[] { "db2", "-v", "!ls" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

    public void testSimplify3() throws AbstractZemucanException {
        final String graphName1 = GraphTest.GRAPH1;
        final String graphName2 = GraphTest.GRAPH2;
        final String create1Id = GraphTest.CREATE1;
        final String create2Id = GraphTest.CREATE2;
        final String create = GraphTest.CREATE;
        final String z = "z"; //$NON-NLS-1$

        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);

        graph2.addNode(GraphTest.OTHER, GraphTest.OTHER, true);
        graph2.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph2.firstPhaseFinished();
        graph2.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph2.addRelation(GraphTest.CREATE, GraphTest.OTHER);

        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

        graph.addNode(GraphTest.ID2, GraphTest.ID2, true);
        graph.firstPhaseFinished();

        Exception e = null;
        try {
            graph.addRelation(GraphTest.ID1, GraphTest.ID2);
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("NotExistingNodeException",

        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);

    public void testAddNullParent() throws AbstractZemucanException {
        final String name = GraphNodeTest.NODE;
        final GraphNode nul = null;

        final GraphNode graphNode = new GraphNode(name,
                new Graph("test", false));

        Exception e = null;
        try {
            graphNode.addParent(nul);

    private String[]/* [!]! */getWindowsCommand(final boolean isADB2Command,
            final boolean thereAreDB2Params, final String/* ? */db2params,
            final String/* ! */db2Command) {
        assert db2Command != null;

        String[] commands;
        if (isADB2Command) {
            if (thereAreDB2Params) {
                ImplementationExecuter.LOGGER
                        .debug("Windows and db2 command with params"); //$NON-NLS-1$

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = true;

        final List<Token> phraseOut = new ArrayList<Token>();
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        final GraphAnswer expected = new GraphAnswer(phraseOut, options);

        Assert.assertEquals("'create table ' command", expected, actual); //$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 t2('", expected, //$NON-NLS-1$

        phrases.add(new Token(phrase1, true));
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        options.add(new Token(option2, true));
        final GraphAnswer object = new GraphAnswer(phrases, options);

        final ReturnOptions actual = ImplementationLexicalAnalyzer
                .getInstance().analyzePhrase(cmdIn);

        final ReturnOptions expected = new ReturnOptions(cmdOut,
                new String[] {}, new String[] {});

        Assert.assertEquals(

                        "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() {
        // Destroys any existent instance.
        ImplementationLexicalAnalyzer.destroyInstance();

        // Recreates the configurator instance.
        Configurator.destroyInstance();
        GrammarReaderController.destroyInstance();
        System.clearProperty(Constants.ZEMUCAN_CONF_XML_PROPERTY);
    }

    /**
     * Default constructor.
     */
    public InterfaceCoreTest() {

        final Graph graph1 = new Graph(graphName1, false);
        final Graph graph2 = new Graph(graphName2, false);

        graph1.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph1.addNode(create1Id, GraphTest.CREATE, true);

        final Graph actual = new Graph(id, false);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildWithoutExtraTokens");

        graph.addRelation(GraphTest.ID1, GraphTest.ID2);

        Exception e = null;
        try {
            graph.getEndingNode();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("InvalidGraphStateException",
                e instanceof InvalidGraphStateException);
    }

    /**
     * Tests the retrieve of starting node.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void testGetStartingNode() throws AbstractZemucanException {

    public void testRemoveParent() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String name = GraphNodeTest.GRAPHNODE;
        final GraphNode graphNode = new GraphNode(name, graph);

        int size = graphNode.getParents().size();

        final StartingNode actual = new StartingNode(new Graph("test", false));

        final boolean value = actual.equals(actual);

        Assert.assertTrue("Symmetry", value); //$NON-NLS-1$
    }

    /**
     * Test the toString method.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void testToString() throws AbstractZemucanException {
        final StartingNode actual = new StartingNode(new Graph("test", false));

        final EndingNode node1 = new EndingNode(graph);
        final int val1 = node1.hashCode();
        final int val2 = node1.hashCode();

        final boolean val = val1 == val2;

        Assert.assertTrue("Two consecutive calls return the same value", val); //$NON-NLS-1$
    }

    /**
     * Test that the hash code is different to hashCode of StartingNode.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testDifferentStartingNodeHashCode()

        final int size = this.parents.size();
        boolean ret = false;
        for (int i = 0; (i < size) && !ret; i += 1) {
            if (graphNode.getId().equals(this.parents.get(i).getId())) {

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;

        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;

                .info("testBuildWithExtraTokens");
        ImplementationXMLGrammarReaderTest.LOGGER.debug(xml);
        final ImplementationXMLGrammarReader grammar = new ImplementationXMLGrammarReader(
                actual, contentToParse, contentToValidate);
        grammar.generateGraph();
        grammar.getStartingNode();

        final Graph expected = new Graph(

    public void testBuildNoEndingNode() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;

    public void testBuildInvalidStructure() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;

        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer
                .getInstance().analyzeTokens(phraseIn, endsWithSpace);

        final List<Token> phraseOut = new ArrayList<Token>();

        phrases.add(new Token(phrase1, true));
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(option1, true));
        options.add(new Token(option2, true));

    public void testHashCodeDifferentObject() throws InvalidTokenException {
        final String token1 = TokenTest.CREATE;
        final String token2 = "table"; //$NON-NLS-1$

        final Token expected = new Token(token1, true);
        final Token actual = new Token(token2, true);

        final String option = ImplementationLexicalAnalyzerTest.COL_NAME;

        final ReturnOptions actual = ImplementationLexicalAnalyzer
                .getInstance().analyzePhrase(cmdIn);

        final ReturnOptions expected = new ReturnOptions(cmdOut,
                new String[] {}, new String[] { option });

    public void testSymmetric() throws ParameterNullException {
        final String phrase = "test"; //$NON-NLS-1$
        final String[] phrases = new String[] { "test1" }; //$NON-NLS-1$
        final String[] options = new String[] { "test2" }; //$NON-NLS-1$
        final ReturnOptions actual = new ReturnOptions(phrase, phrases, options);

        final Graph graph = new Graph("no starting node", false); //$NON-NLS-1$
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

        graph.addNode(GraphTest.OTHER, GraphTest.OTHER, true);

        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(GraphTest.CREATE, GraphTest.TABLE);
        graph.addRelation(GraphTest.TABLE, Constants.ENDING_NODE);

        final Graph graph = new Graph("no starting node", false); //$NON-NLS-1$
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(Constants.STARTING_NODE, GraphTest.CREATE);
        graph.addRelation(Constants.STARTING_NODE, GraphTest.TABLE);

        final Graph graph = new Graph("no starting node", false); //$NON-NLS-1$
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph.firstPhaseFinished();
        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

    private static void changeDescendancyNodeRelations(
            final AbstractGraphNode/* ! */n1, final AbstractGraphNode/* ! */n2,
            final AbstractGraphNode /* ! */node) throws AbstractGraphException {
        assert n1 != null;
        assert n2 != null;
        assert node != null;
        assert n1 != n2;
        assert n2 != node;

        // First adds the parent relation.
        node.addParent(n1);

    public void testBuildNoStartingNode() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;

        graphToFill.addNode(create, create, true);
        graphToFill.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graphToFill.firstPhaseFinished();
        graphToFill.addRelation(Constants.STARTING_NODE, create);
        graphToFill.addRelation(create, Constants.ENDING_NODE);

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        phraseIn.add(new Token(tokenIn2, true));

    public void testCase3() throws AbstractZemucanException {
        final String cmdIn = "db2 c"; //$NON-NLS-1$

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 c";

    public void testCase8() throws AbstractZemucanException {
        final String cmdIn = "db2 create table "; //$NON-NLS-1$

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table ";

    public void testCase5() throws AbstractZemucanException {
        final String cmdIn = "db2 create table"; //$NON-NLS-1$

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

    public void testCase7() throws AbstractZemucanException {
        final String cmdIn = "db2 create"; //$NON-NLS-1$

        final ReturnOptions ret = ImplementationLexicalAnalyzer.getInstance()
                .analyzePhrase(cmdIn);

        final String actual = ret.getPhrase();

        final String expected = "db2 create table";

            new ReturnOptions(phrase, new String[] { null },
                    new String[] { options });
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("ParameterNullException",
                e instanceof ParameterNullException);
    }

    /**
     * Tests the symmetry of equals.
     *
     * @throws ParameterNullException
     *             Never.
     */
    @Test
    public void testSymmetric() throws ParameterNullException {

                controller.start(thread, synchronizedLoad);
            } catch (final AbstractZemucanException exception) {
                Main.LOGGER.error(exception.getMessage());
                Main.LOGGER.info(exception.getStackTrace().toString());

        String expectedGraphName = "merged:{" + graphName1 + ',' + graphName2
                + "}:";
        String expected = expectedGraphName + '[' + GraphState.Validated
                + "-WithoutExtraNodes{{" + Constants.STARTING_NODE + '<'
                + expectedGraphName + graphName1 + ':' + a + '-'

    public void testRemoveNullParent() throws AbstractZemucanException {
        final String name = GraphNodeTest.GRAPHNODE;
        final GraphNode graphNode = new GraphNode(name,
                new Graph("test", false));

        Exception e = null;
        try {
            graphNode.removeParent(null);

        final GraphNode node1 = new GraphNode(node, new Graph("test", false));
        final int val1 = node1.hashCode();
        final int val2 = node1.hashCode();

        final boolean val = val1 == val2;

        Assert.assertTrue("Two consecutive calls return the same value", val); //$NON-NLS-1$
    }

    /**
     * Tests that the graph node has to receive a not null parameter.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test(expected = AssertionError.class)

    public void testSameHashCode() throws AbstractZemucanException {
        final AboutNode actual = new AboutNode(new Graph("test", false));
        final AboutNode expected = new AboutNode(new Graph("test", false));

        Assert.assertEquals("Two AboutNode generate the same hashcode.", //$NON-NLS-1$

                + ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_CREATE_ID_TOKEN;

                "sa_conf-test-grammar1.xml ; sa_conf-test-grammar2.xml"); //$NON-NLS-1$

        try {
            GrammarReaderController.getInstance().getStartingNode();
        } catch (final Exception exception) {
            Assert.assertTrue("GeneralGrammarReaderProblemException",
                    exception instanceof GeneralGrammarReaderProblemException);
        }
    }

    /**
     * Test an invalid value for the grammar reader.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public final void testInexistantGrammar() throws AbstractZemucanException {

        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$

			final boolean endsWithSpace, final GraphAnswer answer,
			final int sizeOptions, String[] setOfOptions, String[] setOfPhrases)
			throws GeneralException, ParameterNullException {
		if (sizeOptions > 1) {
			// There are multiple options and 0 phrases, then show all options
			// and add a space at the end.
			ImplementationLexicalAnalyzer.LOGGER.debug("Case 7");

            new ReturnOptions(phrase, null, new String[] { options });
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("ParameterNullException",
                e instanceof ParameterNullException);
    }

    /**
     * Tests the null exception when one element in the options is null.
     *
     * @throws ParameterNullException
     *             Never.
     */
    @Test
    public void testReturnOptionsOneNullInOptions()

    public void testReturnOptionsOneNullInOptions()
            throws ParameterNullException {
        final String phrase = "create table"; //$NON-NLS-1$
        final String phrases = ReturnOptionsTest.TABLESPACE;

        Exception e = null;
        try {
            new ReturnOptions(phrase, new String[] { phrases },

    public void testSameHashCode() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final StartingNode actual = new StartingNode(graph);
        final StartingNode expected = new StartingNode(graph);

        Assert.assertEquals("hashcode for two identical objects", //$NON-NLS-1$

    public void testSameHashCode() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final LicenseNode actual = new LicenseNode(graph);
        final LicenseNode expected = new LicenseNode(graph);

        Assert.assertEquals("Two LicenseNode generate the same hashcode.", //$NON-NLS-1$

        graph1.addNode(GraphTest.CREATE1, GraphTest.CREATE, true);
        graph1.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph1.firstPhaseFinished();
        graph1.addRelation(Constants.STARTING_NODE, GraphTest.CREATE1);

        graph2.addNode(GraphTest.CREATE2, GraphTest.CREATE, true);
        graph2.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph2.firstPhaseFinished();
        graph2.addRelation(Constants.STARTING_NODE, GraphTest.CREATE2);

        final Graph graph = new Graph("inexistant child", false); //$NON-NLS-1$
        graph.addNode(GraphTest.ID1, GraphTest.ID1, true);
        graph.firstPhaseFinished();

        Exception e = null;
        try {
            graph.addRelation(GraphTest.ID1, GraphTest.ID2);

    public void testAddTwiceSameParent() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String name = GraphNodeTest.NODE;
        final GraphNode node = new GraphNode(name, graph);

        final String parentName = GraphNodeTest.PARENT;

    public void testSameHashCode() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final EndingNode actual = new EndingNode(graph);
        final EndingNode expected = new EndingNode(graph);

        Assert.assertEquals(

    public final StartingNode getStartingNode()
            throws InvalidGraphStateException {
        if (!this.graphState.equals(GraphState.Validated)) {
            throw new InvalidGraphStateException(this.graphState,
                    GraphState.Validated);
        }
        return this.startingNode;

        options1.add(new Token(option2, true));
        final GraphAnswer expected = new GraphAnswer(phrases1, options1);

        final List<Token> phrases2 = new ArrayList<Token>();
        phrases2.add(new Token(phrase1, true));

    public void testHashCodeIdenticalObject() throws InvalidTokenException {
        final String token = TokenTest.CREATE;

        final Token expected = new Token(token, true);
        final Token actual = new Token(token, true);

        Assert.assertEquals("Two identical objects with the same hashcode", //$NON-NLS-1$

        final ReturnOptions actual = ImplementationLexicalAnalyzer
                .getInstance().analyzePhrase(cmdIn);

        final ReturnOptions expected = new ReturnOptions(cmdOut,
                new String[] {}, new String[] { option1 });

        final ReturnOptions actual = ImplementationLexicalAnalyzer
                .getInstance().analyzePhrase(cmdIn);

        final ReturnOptions expected = new ReturnOptions(cmdOut,
                new String[] {}, new String[] { opt1 });

        final ReturnOptions actual = ImplementationLexicalAnalyzer
                .getInstance().analyzePhrase(cmdIn);

        final ReturnOptions expected = new ReturnOptions(cmdOut,
                new String[] {}, new String[] { option1 });

        final OutputWriter writer = new SystemOutputWriter();

        final ExecutionState actual = ImplementationExecuter.getInstance()
                .execute(command, writer);

        final ExecutionState expected = ExecutionState.APPLICATION_EXIT;

        Assert.assertEquals("Execution of 'quit'", expected, actual); //$NON-NLS-1$

        final Graph graph = new Graph("referencing starting node", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        final Graph graph2 = new Graph(GraphTest.DUMMY_GRAPH, true);
        graph2.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph2.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph2.addNode(GraphTest.OTHER, GraphTest.OTHER, true);

        final Graph graph = new Graph("Duplicated node name", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);

        final Graph graph2 = new Graph(GraphTest.TEST, false);
        graph2.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph2.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph2.addNode(GraphTest.TABLE, GraphTest.TABLE, true);

        graph2.addRelation(GraphTest.CREATE2, Constants.ENDING_NODE);
        graph2.secondPhaseFinished();

        graph1.merge(graph2);

        graph2.simplifyGraph();

        final String actual = graph2.toString();

        String expectedGraphName = "merged:{" + GraphTest.GRAPH2 + ','

        final Graph graph = new Graph(GraphTest.VALIDATED_GRAPH, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        graph.addNode(GraphTest.ID2, GraphTest.ID2, true);

        Exception e = null;
        try {
            graph.addRelation(GraphTest.ID1, GraphTest.ID2);
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("InvalidGraphStateException",

        final Graph graph = new Graph("add relation validated", false); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);

        Iterator<AbstractGraphNode> it = this.nodes.values().iterator();
        while (it.hasNext()) {
            final AbstractGraphNode node = it.next();

        final Graph graph = new Graph("empty grammar", false); //$NON-NLS-1$
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER.info("testEmptyGrammar");

        final Graph actual = new Graph(id, true);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildWithExtraTokens");

        final Graph graph = new Graph("node without parent", false); //$NON-NLS-1$
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildNodeNotComeFromStartingNode");

    private String testBuildNodeNotComeFromStartingNodeText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;

        final Graph graph = new Graph("incomplete structure", false); //$NON-NLS-1$
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildInvalidStructure");

        System.clearProperty(ImplementationExecuter.DB2_PARAMS);

        final String command = "db2 !dir"; //$NON-NLS-1$
        final String[] actuals = ImplementationExecuter.getInstance()
                .getCommandsToExecute(command);

        final String[] expecteds = new String[] { "db2", "!dir" }; //$NON-NLS-1$//$NON-NLS-2$

    public void testExecutionInLinuxNoDB2() throws ParameterNullException {
        // Deletes the property, loading other configuration file.
        System.setProperty(Constants.ZEMUCAN_CONF_XML_PROPERTY,
                "sa_conf-test-NoDB2Native.xml"); //$NON-NLS-1$

        // Sets an environment property.
        System.clearProperty(ImplementationExecuter.DB2_PARAMS);
        System.setProperty("os.name", "Linux Virtual"); //$NON-NLS-1$ //$NON-NLS-2$

        final String command = "ls"; //$NON-NLS-1$

    public void testGetOptions5() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String tokenIn2 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String tokenIn3 = ImplementationSyntacticAnalyzerTest.T1;
        final String tokenIn4 = ImplementationSyntacticAnalyzerTest.OPEN_PARENTHESIS;
        final String tokenIn5 = ImplementationSyntacticAnalyzerTest.C1;

        final ReturnOptions actual = ImplementationLexicalAnalyzer
                .getInstance().analyzePhrase(cmdIn);

        final ReturnOptions expected = new ReturnOptions(cmdOut,
                new String[] {}, new String[] { opt1, opt2 });

    public void testOtherTypeEqualsObject() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final StartingNode actual = new StartingNode(graph);
        final EndingNode notExpected = new EndingNode(graph);

    public void testOtherTypeEqualsObject() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final LicenseNode actual = new LicenseNode(graph);
        final StartingNode notExpected = new StartingNode(graph);

    public void testInvalidStartingNode2() throws AbstractZemucanException {
        final Graph graph = new Graph(GraphTest.NAME, true);

        Exception e = null;
        try {
            graph.addNode(Constants.STARTING_NODE, Constants.ENDING_NODE, true);

    public void testInvalidEndingNode21() throws AbstractZemucanException {
        final Graph graph = new Graph(GraphTest.NAME, true);

        Exception e = null;
        try {
            graph.addNode(Constants.ENDING_NODE, Constants.STARTING_NODE, true);

    public void testRemoveChild() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final String name = GraphNodeTest.GRAPHNODE;
        final GraphNode graphNode = new GraphNode(name, graph);

    public void testOtherTypeEqualsObject() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final EndingNode actual = new EndingNode(graph);
        final StartingNode notExpected = new StartingNode(graph);

    public void testOtherTypeEqualsObject() throws AbstractZemucanException {
        final Graph graph = new Graph("test", false);

        final AboutNode actual = new AboutNode(graph);
        final StartingNode notExpected = new StartingNode(graph);

        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;

    private String testBuildWithExtraTokensText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;

        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_CREATE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;

    private String testBuildInvertedText() {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Ending Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;

        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_ENDING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_ENDING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // table Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_TABLE_ID;

        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;
        xml += ImplementationXMLGrammarReaderTest.ID_TOKEN_ENDING_NODE_ID_TOKEN;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN_2;
        xml += ImplementationXMLGrammarReaderTest.TOKEN_2;
        // create Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_CREATE_ID;

    public void testGetOptions5() throws AbstractZemucanException {
        final String tokenIn1 = ImplementationSyntacticAnalyzerTest.CREATE;
        final String tokenIn2 = ImplementationSyntacticAnalyzerTest.TABLE;
        final String tokenIn3 = ImplementationSyntacticAnalyzerTest.T1;
        final String tokenIn4 = ImplementationSyntacticAnalyzerTest.OPEN_PARENTHESIS;
        final String tokenIn5 = ImplementationSyntacticAnalyzerTest.C1;

        phraseIn.add(new Token(tokenIn2, true));
        final boolean endsWithSpace = false;
        final GraphAnswer graph = ImplementationSyntacticAnalyzer.getInstance()
                .analyzeTokens(phraseIn, endsWithSpace);
        final List<Token> actual = graph.getOptions();

        if (synchro != null) {
            synchronized (synchro) {
                synchronizedLoad.alreadyLoaded();
                synchro.notifyAll();
            }
        }

        while (execState != ExecutionState.APPLICATION_EXIT) {

        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() {

    Main(final String[]/* [!]! */args) throws AbstractZemucanException {
        assert args != null;
        boolean assertsEnabled = false;
        // Intentional side-effect!
        assert assertsEnabled = true;
        if (assertsEnabled) {
            for (final String string : args) {
                assert string != null;
            }
        }

        final Graph graph = new Graph(GraphTest.VALIDATED_GRAPH, false);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);

        final Graph graph2 = new Graph(GraphTest.DUMMY_GRAPH, true);
        graph2.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph2.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph2.addNode(GraphTest.OTHER, GraphTest.OTHER, true);

        final Graph graph = new Graph("validated extra nodes", true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);

        final Graph graph = new Graph("no ending node", false); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.firstPhaseFinished();

        final Graph graph = new Graph(graphName, true); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);

        final Graph graph = new Graph("no ending node", false); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.firstPhaseFinished();

        final Graph graph = new Graph(GraphTest.DUMMY_GRAPH, true);
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.addNode(GraphTest.TABLE, GraphTest.TABLE, true);

        final Graph graph = new Graph("no ending node", false); //$NON-NLS-1$
        graph.addNode(Constants.STARTING_NODE, Constants.STARTING_NODE, true);
        graph.addNode(GraphTest.CREATE, GraphTest.CREATE, true);
        graph.firstPhaseFinished();

            final StartingNode token = (StartingNode) object;
            final List<AbstractGraphNode> ways = token.getChildren();
            if ((ways.size() == this.getChildren().size())) {

    public final void testGrammarFilesInOneDirectory()
            throws AbstractZemucanException {
        Configurator.getInstance().setProperty(
                Constants.GRAMMAR_READER_NAME_PROPERTY,
                ImplementationXMLGrammarReaderTest.XML_GRAMMAR_READER);
        Configurator.getInstance().setProperty(
                Constants.GRAMMAR_FILE_DESCRIPTORS_PROPERTY,

        final Graph actual = new Graph(id, true);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildWithExtraTokens");

    public void testBuildNotAllChildren() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;

        final Graph actual = new Graph(id, true);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildWithExtraTokens");

    public void testBuildNoNodes() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

        final Graph actual = new Graph(id, true);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildWithExtraTokens");

    public void testBuildNoNodes() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

        final Graph actual = new Graph(id, true);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildWithExtraTokens");

    public void testBuildNoNodes() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

        final Graph actual = new Graph(id, true);
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER
                .info("testBuildWithExtraTokens");

    public void testBuildNoNodes() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

        final Graph actual = new Graph("grammar inversed", true); //$NON-NLS-1$
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER.info("testBuildInverted");

    public void testBuildNoNodes() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

        final Graph actual = new Graph("grammar inversed", true); //$NON-NLS-1$
        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER.info("testBuildInverted");

    public void testBuildNoNodes() throws AbstractZemucanException {
        String xml = ""; //$NON-NLS-1$
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_OPEN;
        xml += ImplementationXMLGrammarReaderTest.DELIMITERS_DELIMITERS;
        xml += ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        xml += ImplementationXMLGrammarReaderTest.TOKENS_2;

    public final void testUnrecognizedGrammar() throws AbstractZemucanException {
        Configurator.getInstance().setProperty(
                Constants.GRAMMAR_READER_NAME_PROPERTY,
                GrammarReaderControllerTest.IN_MEMORY_GRAMMAR_READER);
        Configurator.getInstance()
                .setProperty(Constants.GRAMMAR_FILE_DESCRIPTORS_PROPERTY,

                "sa_conf-test-InvalidGrammarReaderDefined.xml"); //$NON-NLS-1$

        try {
            GrammarReaderController.getInstance();
        } catch (final Exception exception) {
            Assert.assertTrue("GeneralGrammarReaderProblemException",
                    exception instanceof GeneralGrammarReaderProblemException);
        }
    }

    /**
     * Tests that the grammar reader name cannot be null.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public final void testNullValue() throws AbstractZemucanException {

    public final void testSameGrammarFileTwice() throws AbstractZemucanException {
        Configurator.getInstance().setProperty(
                Constants.GRAMMAR_READER_NAME_PROPERTY,
                GrammarReaderControllerTest.IN_MEMORY_GRAMMAR_READER);
        Configurator.getInstance().setProperty(
                Constants.GRAMMAR_FILE_DESCRIPTORS_PROPERTY,

                Constants.GRAMMAR_READER_NAME_PROPERTY, "Inexistant"); //$NON-NLS-1$

        try {
            GrammarReaderController.getInstance();
        } catch (final Exception exception) {
            Assert.assertTrue("GeneralGrammarReaderProblemException",
                    exception instanceof GeneralGrammarReaderProblemException);
        }
    }

    /**
     * Tests that the grammar reader name cannot be empty.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public final void testInvalidValue() throws AbstractZemucanException {

        System.setProperty(ImplementationExecuter.DB2_PARAMS, "-v"); //$NON-NLS-1$

        final String command = "db2 !dir"; //$NON-NLS-1$
        final String[] actuals = ImplementationExecuter.getInstance()
                .getCommandsToExecute(command);

        final String[] expecteds = new String[] { "db2", "-v", "!dir" }; //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

        final List<Token> phraseIn = new ArrayList<Token>();
        phraseIn.add(new Token(tokenIn1, true));
        final boolean endsWithSpace = false;
        final GraphAnswer actual = ImplementationSyntacticAnalyzer

        for (final Token node : this.phrases) {
            try {
                copy.add(node.clone());
            } catch (final CloneNotSupportedException e) {
                throw new GeneralException(e);
            }
        }

        return copy;
    }

        final Buffer b = new Buffer(command);
        b.op(ConsoleOperations.COMPLETE);

        AssertionHelper.assertBuffer(command, "db2 create", b);
    }

    /**
     * Tests the command ' db2 crea'
     *
     * @throws IOException
     *             Never
     */
    @Test
    public void test8a() throws IOException {

        final Buffer b = new Buffer(command);
        b.op(ConsoleOperations.COMPLETE);

        AssertionHelper.assertBuffer(command, "db2", b);
    }

    /**
     * Tests the command 'db2 '
     *
     * @throws IOException
     *             Never
     */
    @Test
    public void test5() throws IOException {

        final Buffer b = new Buffer(command);
        b.op(ConsoleOperations.COMPLETE);

        AssertionHelper.assertBuffer(command, "db2 create table t1 (", b);
    }

    /**
     * Tests the command 'd'
     *
     * @throws IOException
     *             Never
     */
    @Test
    public void test2() throws IOException {

        final Buffer b = new Buffer(command);
        b.op(ConsoleOperations.COMPLETE);

        AssertionHelper.assertBuffer(command, "db2 create table", b);
    }

    /**
     * Tests the command 'db2 create table '
     *
     * @throws IOException
     *             Never
     */
    @Test
    public void test17() throws IOException {

        final Buffer b = new Buffer(command);
        b.op(ConsoleOperations.COMPLETE);

        AssertionHelper.assertBuffer(command, "db2 create tablespace", b);
    }

    /**
     * Tests the command 'db2 create ta'
     *
     * @throws IOException
     *             Never
     */
    @Test
    public void test15() throws IOException {

        final Buffer b = new Buffer(command);
        b.op(ConsoleOperations.COMPLETE);

        AssertionHelper.assertBuffer(command, "db2 create table", b);
    }

    /**
     * Tests the command 'db2 create table'
     *
     * @throws IOException
     *             Never
     */
    @Test
    public void test16() throws IOException {

        graph2.addNode(GraphTest.CREATE2, GraphTest.CREATE, true);
        graph2.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph2.firstPhaseFinished();
        graph2.addRelation(Constants.STARTING_NODE, GraphTest.CREATE2);

        graph.addRelation(GraphTest.OTHER, GraphTest.CREATE);

        Exception e = null;
        try {
            graph.secondPhaseFinished();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("NodeNotComesFromStartingNodeException",

        graph.addRelation(GraphTest.CREATE, Constants.ENDING_NODE);

        Exception e = null;
        try {
            graph.secondPhaseFinished();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("StartingNodeNotDefinedException",

        graph2.addNode(create2Id, create, true);
        graph2.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph2.firstPhaseFinished();
        graph2.addRelation(Constants.STARTING_NODE, a);

        graph1.addNode(create1Id, create, true);
        graph1.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph1.firstPhaseFinished();
        graph1.addRelation(Constants.STARTING_NODE, a);

        graph2.addNode(create2Id, create, true);
        graph2.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph2.firstPhaseFinished();
        graph2.addRelation(Constants.STARTING_NODE, a);

        graph1.addNode(create1Id, create, true);
        graph1.addNode(Constants.ENDING_NODE, Constants.ENDING_NODE, true);
        graph1.firstPhaseFinished();
        graph1.addRelation(Constants.STARTING_NODE, a);

        graph.addRelation("tablespace", Constants.ENDING_NODE);

        Exception e = null;
        try {
            graph.secondPhaseFinished();
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("DuplicatedNodeNameException",

        final Graph graph = new Graph("inexistant child", false); //$NON-NLS-1$
        graph.addNode(GraphTest.ID1, GraphTest.ID1, true);
        graph.firstPhaseFinished();

        Exception e = null;
        try {
            graph.addRelation(GraphTest.ID1, GraphTest.ID2);

        actualnode.addParent(actualnode1);

        final String actual = actualnode.toString();
        final String expected = nodeOut;

        Assert.assertEquals("String of a node", expected, actual); //$NON-NLS-1$
    }

    /**
     * Tests the transitivity of the equals.
     *
     * @throws AbstractZemucanException
     *             Never.
     */
    @Test
    public void testTransitivity() throws AbstractZemucanException {

            for (final AbstractGraphNode node : super.getChildren()) {
                ret += node.getId() + '-';
            }
            ret = ret.substring(0, ret.length() - 1);
            ret += '>';

        return Constants.STARTING_NODE.hashCode() * -1;
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * name.angoca.zemucan.core.graph.model.AbstractGraphNode#represent(java
     * .lang.String)
     */
    @Override
    public final boolean represent(final String token) {
        boolean ret = false;
        if (token.equals(Constants.STARTING_NODE)) {

            new ImplementationXMLGrammarReader(null, contentToParse,
                    contentToValidate);
        } catch (final Exception exception) {
            e = exception;
        }
        Assert.assertTrue("ParameterNullException",
                e instanceof ParameterNullException);
    }

    /**
     * Test the exception thrown when no filename defined.
     *
     * @throws AbstractZemucanException
     *             Never
     */
    @Test
    public void testReadNoFileDefined() throws AbstractZemucanException {

        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER.info("testNullGraph");

                + ImplementationXMLGrammarReaderTest.GRAMMAR_1_CLOSE;
        xml += ImplementationXMLGrammarReaderTest.TOKENS;
        // Starting Node.
        xml += ImplementationXMLGrammarReaderTest.TOKEN;
        xml += ImplementationXMLGrammarReaderTest.ID_STARTING_NODE_ID;
        xml += ImplementationXMLGrammarReaderTest.NAME_STARTING_NODE_NAME;
        xml += ImplementationXMLGrammarReaderTest.RESERVED;
        xml += ImplementationXMLGrammarReaderTest.CHILDREN;

        final InputSource contentToParse = new InputSource(
                new StringReader(xml));
        final InputSource contentToValidate = new InputSource(new StringReader(
                xml));
        ImplementationXMLGrammarReaderTest.LOGGER.info("testNullGraph");

            commands = new String[] { "cmd.exe", "/c", db2Command }; //$NON-NLS-1$ //$NON-NLS-2$
        }

        assert commands != null;
        if (this.assertsEnabled) {
            for (final String retCommand : commands) {
                assert retCommand != null;
            }
        }
        return commands;
    }

        phrases2.add(new Token(tokenString1, true));
        final List<Token> options = new ArrayList<Token>();
        options.add(new Token(tokenString4, true));

        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$

        Assert.assertEquals("phrase: '" + cmdIn + "'", expected, actual);
        // catalog, create, attach
        Assert.assertTrue("options: '" + cmdIn + "'",
                ret.getOptions().length == 3);

		assert tokens != null;
		boolean assertsEnabled = false;
		// Intentional side-effect!
		assert assertsEnabled = true;
		if (assertsEnabled) {
			for (final Token token : tokens) {
				assert token != null;
			}
		}

            } catch (final AbstractZemucanException exception) {
                Main.LOGGER.error(exception.getMessage());
                Main.LOGGER.info(exception.getStackTrace().toString());