/*
 * [The "BSD license"]
 *  Copyright (c) 2010 Terence Parr
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *  1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.antlr.test;

import org.antlr.tool.Grammar;
import org.junit.Test;

import static org.junit.Assert.*;

public class TestASTConstruction extends BaseTest {

    /** Public default constructor used by TestRig */
    public TestASTConstruction() {
    }

	@Test public void testA() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : A;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT A <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testEmptyAlt() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : ;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT epsilon <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testNakeRulePlusInLexer() throws Exception {
		Grammar g = new Grammar(
				"lexer grammar P;\n"+
				"A : B+;\n" +
				"B : 'a';");
		String expecting =
			"(rule A ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT B <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("A").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testRulePlus() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : (b)+;\n" +
				"b : B;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT b <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testNakedRulePlus() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : b+;\n" +
				"b : B;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT b <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testRuleOptional() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : (b)?;\n" +
				"b : B;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (? (BLOCK (ALT b <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testNakedRuleOptional() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : b?;\n" +
				"b : B;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (? (BLOCK (ALT b <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testRuleStar() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : (b)*;\n" +
				"b : B;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (* (BLOCK (ALT b <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testNakedRuleStar() throws Exception {
		Grammar g = new Grammar(
				"parser grammar P;\n"+
				"a : b*;\n" +
				"b : B;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (* (BLOCK (ALT b <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testCharStar() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : 'a'*;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (* (BLOCK (ALT 'a' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testCharStarInLexer() throws Exception {
		Grammar g = new Grammar(
				"lexer grammar P;\n"+
				"B : 'b'*;");
		String expecting =
			"(rule B ARG RET scope (BLOCK (ALT (* (BLOCK (ALT 'b' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("B").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testStringStar() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : 'while'*;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (* (BLOCK (ALT 'while' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testStringStarInLexer() throws Exception {
		Grammar g = new Grammar(
				"lexer grammar P;\n"+
				"B : 'while'*;");
		String expecting =
			"(rule B ARG RET scope (BLOCK (ALT (* (BLOCK (ALT 'while' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("B").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testCharPlus() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : 'a'+;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT 'a' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testCharPlusInLexer() throws Exception {
		Grammar g = new Grammar(
				"lexer grammar P;\n"+
				"B : 'b'+;");
		String expecting =
			"(rule B ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT 'b' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("B").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testCharOptional() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : 'a'?;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (? (BLOCK (ALT 'a' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testCharOptionalInLexer() throws Exception {
		Grammar g = new Grammar(
				"lexer grammar P;\n"+
				"B : 'b'?;");
		String expecting =
			"(rule B ARG RET scope (BLOCK (ALT (? (BLOCK (ALT 'b' <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("B").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testCharRangePlus() throws Exception {
		Grammar g = new Grammar(
				"lexer grammar P;\n"+
				"ID : 'a'..'z'+;");
		String expecting =
			"(rule ID ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT (.. 'a' 'z') <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("ID").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testLabel() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x=ID;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (= x ID) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testLabelOfOptional() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x=ID?;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (? (BLOCK (ALT (= x ID) <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testLabelOfClosure() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x=ID*;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (* (BLOCK (ALT (= x ID) <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testRuleLabel() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x=b;\n" +
				"b : ID;\n");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (= x b) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testSetLabel() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x=(A|B);\n");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (= x (BLOCK (ALT A <end-of-alt>) (ALT B <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testNotSetLabel() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x=~(A|B);\n");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (= x (~ (BLOCK (ALT A <end-of-alt>) (ALT B <end-of-alt>) <end-of-block>))) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testNotSetListLabel() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x+=~(A|B);\n");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (+= x (~ (BLOCK (ALT A <end-of-alt>) (ALT B <end-of-alt>) <end-of-block>))) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testNotSetListLabelInLoop() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x+=~(A|B)+;\n");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT (+= x (~ (BLOCK (ALT A <end-of-alt>) (ALT B <end-of-alt>) <end-of-block>))) <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testRuleLabelOfPositiveClosure() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x=b+;\n" +
				"b : ID;\n");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT (= x b) <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testListLabelOfClosure() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x+=ID*;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (* (BLOCK (ALT (+= x ID) <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testListLabelOfClosure2() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n"+
				"a : x+='int'*;");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (* (BLOCK (ALT (+= x 'int') <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testRuleListLabelOfPositiveClosure() throws Exception {
		Grammar g = new Grammar(
				"grammar P;\n" +
				"options {output=AST;}\n"+
				"a : x+=b+;\n" +
				"b : ID;\n");
		String expecting =
			"(rule a ARG RET scope (BLOCK (ALT (+ (BLOCK (ALT (+= x b) <end-of-alt>) <end-of-block>)) <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("a").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testRootTokenInStarLoop() throws Exception {
		Grammar g = new Grammar(
				"grammar Expr;\n" +
				"options { output=AST; backtrack=true; }\n" +
				"a : ('*'^)* ;\n");  // bug: the synpred had nothing in it
		String expecting =
			"(rule synpred1_Expr ARG RET scope (BLOCK (ALT '*' <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("synpred1_Expr").tree.toStringTree();
		assertEquals(expecting, found);
	}

	@Test public void testActionInStarLoop() throws Exception {
		Grammar g = new Grammar(
				"grammar Expr;\n" +
				"options { backtrack=true; }\n" +
				"a : ({blort} 'x')* ;\n");  // bug: the synpred had nothing in it
		String expecting =
			"(rule synpred1_Expr ARG RET scope (BLOCK (ALT 'x' <end-of-alt>) <end-of-block>) <end-of-rule>)";
		String found = g.getRule("synpred1_Expr").tree.toStringTree();
		assertEquals(expecting, found);
	}

}
