PEParserTest.java

package aima.test.core.unit.logic.propositional.parsing;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import aima.core.logic.propositional.parsing.PEParser;
import aima.core.logic.propositional.parsing.ast.AtomicSentence;
import aima.core.logic.propositional.parsing.ast.BinarySentence;
import aima.core.logic.propositional.parsing.ast.FalseSentence;
import aima.core.logic.propositional.parsing.ast.MultiSentence;
import aima.core.logic.propositional.parsing.ast.Symbol;
import aima.core.logic.propositional.parsing.ast.TrueSentence;
import aima.core.logic.propositional.parsing.ast.UnarySentence;

/**
 * @author Ravi Mohan
 * 
 */
public class PEParserTest {
	private PEParser parser;

	@Before
	public void setUp() {
		parser = new PEParser();
	}

	@Test
	public void testAtomicSentenceTrueParse() {
		AtomicSentence sen = (AtomicSentence) parser.parse("true");
		Assert.assertEquals(TrueSentence.class, sen.getClass());
		sen = (AtomicSentence) parser.parse("(true)");
		Assert.assertEquals(TrueSentence.class, sen.getClass());
		sen = (AtomicSentence) parser.parse("((true))");
		Assert.assertEquals(TrueSentence.class, sen.getClass());
	}

	@Test
	public void testAtomicSentenceFalseParse() {
		AtomicSentence sen = (AtomicSentence) parser.parse("faLse");
		Assert.assertEquals(FalseSentence.class, sen.getClass());
	}

	@Test
	public void testAtomicSentenceSymbolParse() {
		AtomicSentence sen = (AtomicSentence) parser.parse("AIMA");
		Assert.assertEquals(Symbol.class, sen.getClass());
	}

	@Test
	public void testNotSentenceParse() {
		UnarySentence sen = (UnarySentence) parser.parse("NOT AIMA");
		Assert.assertEquals(UnarySentence.class, sen.getClass());
	}

	@Test
	public void testBinarySentenceParse() {
		BinarySentence sen = (BinarySentence) parser
				.parse("(PETER  AND  NORVIG)");
		Assert.assertEquals(BinarySentence.class, sen.getClass());
	}

	@Test
	public void testMultiSentenceAndParse() {
		MultiSentence sen = (MultiSentence) parser
				.parse("(AND  NORVIG AIMA LISP)");
		Assert.assertEquals(MultiSentence.class, sen.getClass());
	}

	@Test
	public void testMultiSentenceOrParse() {
		MultiSentence sen = (MultiSentence) parser
				.parse("(OR  NORVIG AIMA LISP)");
		Assert.assertEquals(MultiSentence.class, sen.getClass());
	}

	@Test
	public void testMultiSentenceBracketedParse() {
		MultiSentence sen = (MultiSentence) parser
				.parse("((OR  NORVIG AIMA LISP))");
		Assert.assertEquals(MultiSentence.class, sen.getClass());
	}

	@Test
	public void testComplexSentenceParse() {
		BinarySentence sen = (BinarySentence) parser
				.parse("((OR  NORVIG AIMA LISP) AND TRUE)");
		Assert.assertEquals(BinarySentence.class, sen.getClass());

		sen = (BinarySentence) parser
				.parse("((OR  NORVIG AIMA LISP) AND (((LISP => COOL))))");
		Assert.assertEquals(BinarySentence.class, sen.getClass());
		Assert.assertEquals(
				" ( ( OR NORVIG AIMA LISP  )  AND  ( LISP => COOL ) )",
				sen.toString());

		String s = "((NOT (P AND Q ))  AND ((NOT (R AND S))))";
		sen = (BinarySentence) parser.parse(s);
		Assert.assertEquals(
				" (  ( NOT  ( P AND Q ) )  AND  ( NOT  ( R AND S ) )  )",
				sen.toString());

		s = "((P AND Q) OR (S AND T))";
		sen = (BinarySentence) parser.parse(s);
		Assert.assertEquals(" (  ( P AND Q ) OR  ( S AND T ) )", sen.toString());
		Assert.assertEquals("OR", sen.getOperator());

		s = "(NOT ((P AND Q) => (S AND T)))";
		UnarySentence nsen = (UnarySentence) parser.parse(s);
		// assertEquals("=>",sen.getOperator());
		s = "(NOT (P <=> (S AND T)))";
		nsen = (UnarySentence) parser.parse(s);
		Assert.assertEquals(" ( NOT  ( P <=>  ( S AND T ) ) ) ",
				nsen.toString());

		s = "(P <=> (S AND T))";
		sen = (BinarySentence) parser.parse(s);

		s = "(P => Q)";
		sen = (BinarySentence) parser.parse(s);

		s = "((P AND Q) => R)";
		sen = (BinarySentence) parser.parse(s);
	}
}