TokenTest

package de.fhdw.wtf.common.token;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;

import org.junit.Test;

import de.fhdw.wtf.common.token.keywords.AbstractToken;
import de.fhdw.wtf.common.token.keywords.ClassToken;
import de.fhdw.wtf.common.token.keywords.ExceptionToken;
import de.fhdw.wtf.common.token.keywords.FindableToken;
import de.fhdw.wtf.common.token.keywords.GroupToken;
import de.fhdw.wtf.common.token.keywords.MutableToken;
import de.fhdw.wtf.common.token.keywords.OperationToken;
import de.fhdw.wtf.common.token.keywords.PriorToken;
import de.fhdw.wtf.common.token.keywords.ServiceToken;
import de.fhdw.wtf.common.token.keywords.SymmetricToken;
import de.fhdw.wtf.common.token.keywords.TransientToken;
import de.fhdw.wtf.common.token.keywords.VisitableToken;
import de.fhdw.wtf.common.token.symbols.ArrowToken;
import de.fhdw.wtf.common.token.symbols.AsteriskToken;
import de.fhdw.wtf.common.token.symbols.BracketCloseToken;
import de.fhdw.wtf.common.token.symbols.BracketOpenToken;
import de.fhdw.wtf.common.token.symbols.ColonToken;
import de.fhdw.wtf.common.token.symbols.CommaToken;
import de.fhdw.wtf.common.token.symbols.CurlyBracketCloseToken;
import de.fhdw.wtf.common.token.symbols.CurlyBracketOpenToken;
import de.fhdw.wtf.common.token.symbols.DoubleSquareBracketCloseToken;
import de.fhdw.wtf.common.token.symbols.DoubleSquareBracketOpenToken;
import de.fhdw.wtf.common.token.symbols.EqualToken;
import de.fhdw.wtf.common.token.symbols.GreaterSymbolToken;
import de.fhdw.wtf.common.token.symbols.HyphenToken;
import de.fhdw.wtf.common.token.symbols.PipeToken;
import de.fhdw.wtf.common.token.symbols.PlusSymbolToken;
import de.fhdw.wtf.common.token.symbols.SemicolonToken;
import de.fhdw.wtf.common.token.symbols.SquareBracketCloseToken;
import de.fhdw.wtf.common.token.symbols.SquareBracketOpenToken;

/**
 * Tests some methods of {@link Token}s.
 */
public class TokenTest {

	/**
	 * Tests {@link Position}s are not equal.
	 */
	@Test
	public void testPositionNotEquals() {
		final Position position1 = Position.create("", 3, 3, 0);
		final Position position2 = Position.create("", 3, 3, 1);

		assertNotEquals(position1, position2);

	}

	/**
	 * Tests hashCode() of {@link Position}.
	 */
	@Test
	public void testPositionHashCode() {
		final Position position1 = Position.create("file1", 333, 546, 2);
		final Position position2 = Position.create("file1", 333, 546, 2);

		assertEquals(position1, position2);
		assertEquals(position1.hashCode(), position2.hashCode());

	}

	/**
	 * Tests isKeywordToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsKeywordToken() {
		final ColonToken colonToken = ColonToken.create(Position.createDummyPosition());
		assertFalse(colonToken.isKeywordToken());
		assertTrue(colonToken.isColonToken());

		final ClassToken classToken = ClassToken.create(Position.createDummyPosition());
		assertTrue(classToken.isKeywordToken());
	}

	/**
	 * Tests isOperationToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsOperationToken() {
		final OperationToken operationToken = OperationToken.create(Position.createDummyPosition());
		assertTrue(operationToken.isOperationToken());

		final ClassToken classToken = ClassToken.create(Position.createDummyPosition());
		assertFalse(classToken.isOperationToken());
	}

	/**
	 * Tests isAbstractOperationToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsAbstractOperationToken() {
		final AbstractToken abstractToken = AbstractToken.create(Position.createDummyPosition());
		assertTrue(abstractToken.isAbstractOperationToken());

		final ColonToken colonToken = ColonToken.create(Position.createDummyPosition());
		assertFalse(colonToken.isAbstractOperationToken());
	}

	/**
	 * Tests isAttributeModifierToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsAttributeModifierToken() {
		final PriorToken priorToken = PriorToken.create(Position.createDummyPosition());
		assertTrue(priorToken.isAttributeModifierToken());

		final ColonToken colonToken = ColonToken.create(Position.createDummyPosition());
		assertFalse(colonToken.isAttributeModifierToken());
	}

	/**
	 * Tests isInvalidToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsInvalidToken() {
		final InvalidToken invalidToken = InvalidToken.create('z', Position.createDummyPosition());
		assertTrue(invalidToken.isInvalidToken());

		final ColonToken colonToken = ColonToken.create(Position.createDummyPosition());
		assertFalse(colonToken.isInvalidToken());
	}

	/**
	 * Tests isSymbolToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsSymbolToken() {
		final SquareBracketOpenToken sbot = SquareBracketOpenToken.create(Position.createDummyPosition());
		assertTrue(sbot.isSymbolToken());

		final ClassToken classToken = ClassToken.create(Position.createDummyPosition());
		assertFalse(classToken.isSymbolToken());
	}

	/**
	 * Tests isHyphenToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsHyphenToken() {
		final HyphenToken hyphenToken = HyphenToken.create(Position.createDummyPosition());
		assertTrue(hyphenToken.isHyphenToken());

		final ColonToken colonToken = ColonToken.create(Position.createDummyPosition());
		assertFalse(colonToken.isHyphenToken());
	}

	/**
	 * Tests isPipeToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsPipeToken() {
		final PipeToken pipeToken = PipeToken.create(Position.createDummyPosition());
		assertTrue(pipeToken.isPipeToken());

		final ColonToken colonToken = ColonToken.create(Position.createDummyPosition());
		assertFalse(colonToken.isPipeToken());
	}

	/**
	 * Tests isSymmetricToken() with <code>true</code> and <code>false</code>.
	 */
	@Test
	public void testIsSymmetricToken() {
		final SymmetricToken symmetricToken = SymmetricToken.create(Position.createDummyPosition());
		assertTrue(symmetricToken.isSymmetricToken());

		final ColonToken colonToken = ColonToken.create(Position.createDummyPosition());
		assertFalse(colonToken.isSymmetricToken());
	}

	/**
	 * Tests some simple methods of {@link OperationToken}.
	 */
	@Test
	public void testOperationToken() {
		final Position position = Position.create("", 3, 4, 5);
		final OperationToken operationToken = OperationToken.create(position);
		assertEquals(8, operationToken.getLength());
		assertEquals("function", operationToken.stringRepresentation());

		final OperationToken otherOperationToken = OperationToken.create(position);
		assertEquals(operationToken, otherOperationToken);
		assertEquals(operationToken.hashCode(), otherOperationToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link VisitableToken}.
	 */
	@Test
	public void testVisitableToken() {
		final Position position = Position.create("", 3, 4, 5);
		final VisitableToken visitableToken = VisitableToken.create(position);
		assertEquals(9, visitableToken.getLength());
		assertEquals("visitable", visitableToken.stringRepresentation());

		final VisitableToken otherVisitableToken = VisitableToken.create(position);
		assertEquals(visitableToken, otherVisitableToken);
		assertEquals(visitableToken.hashCode(), otherVisitableToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link ExceptionToken}.
	 */
	@Test
	public void testExceptionToken() {
		final Position position = Position.create("", 3, 4, 5);
		final ExceptionToken exceptionToken = ExceptionToken.create(position);
		assertEquals(9, exceptionToken.getLength());
		assertEquals("exception", exceptionToken.stringRepresentation());

		final ExceptionToken otherExceptionToken = ExceptionToken.create(position);
		assertEquals(exceptionToken, otherExceptionToken);
		assertEquals(exceptionToken.hashCode(), otherExceptionToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link FindableToken}.
	 */
	@Test
	public void testFindableToken() {
		final Position position = Position.create("", 3, 4, 5);
		final FindableToken findableToken = FindableToken.create(position);
		assertEquals(8, findableToken.getLength());
		assertEquals("findable", findableToken.stringRepresentation());

		final FindableToken otherFindableToken = FindableToken.create(position);
		assertEquals(findableToken, otherFindableToken);
		assertEquals(findableToken.hashCode(), otherFindableToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link MutableToken}.
	 */
	@Test
	public void testMutableToken() {
		final Position position = Position.create("", 3, 4, 5);
		final MutableToken mutableToken = MutableToken.create(position);
		assertEquals(7, mutableToken.getLength());
		assertEquals("mutable", mutableToken.stringRepresentation());

		final MutableToken otherMutableToken = MutableToken.create(position);
		assertEquals(mutableToken, otherMutableToken);
		assertEquals(mutableToken.hashCode(), otherMutableToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link ServiceToken}.
	 */
	@Test
	public void testServiceToken() {
		final Position position = Position.create("", 3, 4, 5);
		final ServiceToken serviceToken = ServiceToken.create(position);
		assertEquals(7, serviceToken.getLength());
		assertEquals("service", serviceToken.stringRepresentation());

		final ServiceToken otherServiceToken = ServiceToken.create(position);
		assertEquals(serviceToken, otherServiceToken);
		assertEquals(serviceToken.hashCode(), otherServiceToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link SymmetricToken}.
	 */
	@Test
	public void testSymmetricToken() {
		final Position position = Position.create("", 3, 4, 5);
		final SymmetricToken symmetricToken = SymmetricToken.create(position);
		assertEquals(9, symmetricToken.getLength());
		assertEquals("symmetric", symmetricToken.stringRepresentation());

		final SymmetricToken otherSymmetricToken = SymmetricToken.create(position);
		assertEquals(symmetricToken, otherSymmetricToken);
		assertEquals(symmetricToken.hashCode(), otherSymmetricToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link TransientToken}.
	 */
	@Test
	public void testTransientToken() {
		final Position position = Position.create("", 3, 4, 5);
		final TransientToken transientToken = TransientToken.create(position);
		assertEquals(9, transientToken.getLength());
		assertEquals("transient", transientToken.stringRepresentation());

		final TransientToken otherTransientToken = TransientToken.create(position);
		assertEquals(transientToken, otherTransientToken);
		assertEquals(transientToken.hashCode(), otherTransientToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link AbstractToken}.
	 */
	@Test
	public void testAbstractToken() {
		final Position position = Position.create("", 3, 4, 5);
		final AbstractToken abstractToken = AbstractToken.create(position);
		assertEquals(8, abstractToken.getLength());
		assertEquals("abstract", abstractToken.stringRepresentation());

		final AbstractToken otherAbstractToken = AbstractToken.create(position);
		assertEquals(abstractToken, otherAbstractToken);
		assertEquals(abstractToken.hashCode(), otherAbstractToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link ClassToken}.
	 */
	@Test
	public void testClassToken() {
		final Position position = Position.create("", 3, 4, 5);
		final ClassToken classToken = ClassToken.create(position);
		assertEquals(5, classToken.getLength());
		assertEquals("class", classToken.stringRepresentation());

		final ClassToken otherClassToken = ClassToken.create(position);
		assertEquals(classToken, otherClassToken);
		assertEquals(classToken.hashCode(), otherClassToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link GroupToken}.
	 */
	@Test
	public void testGroupToken() {
		final Position position = Position.create("", 3, 4, 5);
		final GroupToken groupToken = GroupToken.create(position);
		assertEquals(5, groupToken.getLength());
		assertEquals("group", groupToken.stringRepresentation());

		final GroupToken otherGroupToken = GroupToken.create(position);
		assertEquals(groupToken, otherGroupToken);
		assertEquals(groupToken.hashCode(), otherGroupToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link PriorToken}.
	 */
	@Test
	public void testPriorToken() {
		final Position position = Position.create("", 3, 4, 5);
		final PriorToken priorToken = PriorToken.create(position);
		assertEquals(5, priorToken.getLength());
		assertEquals("prior", priorToken.stringRepresentation());

		final PriorToken otherPriorToken = PriorToken.create(position);
		assertEquals(priorToken, otherPriorToken);
		assertEquals(priorToken.hashCode(), otherPriorToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link CommaToken}.
	 */
	@Test
	public void testCommaToken() {
		final Position position = Position.createDummyPosition();
		final CommaToken commaToken = CommaToken.create(position);
		assertEquals(",", commaToken.stringRepresentation());

		final CommaToken otherCommaToken = CommaToken.create(position);
		assertEquals(commaToken, otherCommaToken);
		assertEquals(commaToken.hashCode(), otherCommaToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link PipeToken}.
	 */
	@Test
	public void testPipeToken() {
		final Position position = Position.createDummyPosition();
		final PipeToken pipeToken = PipeToken.create(position);
		assertEquals("|", pipeToken.stringRepresentation());

		final PipeToken otherPipeToken = PipeToken.create(position);
		assertEquals(pipeToken, otherPipeToken);
		assertEquals(pipeToken.hashCode(), otherPipeToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link HyphenToken}.
	 */
	@Test
	public void testHyphenToken() {
		final Position position = Position.createDummyPosition();
		final HyphenToken hyphenToken = HyphenToken.create(position);
		assertEquals("-", hyphenToken.stringRepresentation());

		final HyphenToken otherHyphenToken = HyphenToken.create(position);
		assertEquals(hyphenToken, otherHyphenToken);
		assertEquals(hyphenToken.hashCode(), otherHyphenToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link BracketOpenToken}.
	 */
	@Test
	public void testBracketOpenToken() {
		final Position position = Position.createDummyPosition();
		final BracketOpenToken bracketOpenToken = BracketOpenToken.create(position);
		assertEquals("(", bracketOpenToken.stringRepresentation());

		final BracketOpenToken otherBracketOpenToken = BracketOpenToken.create(position);
		assertEquals(bracketOpenToken, otherBracketOpenToken);
		assertEquals(bracketOpenToken.hashCode(), otherBracketOpenToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link ArrowToken}.
	 */
	@Test
	public void testArrowToken() {
		final Position position = Position.createDummyPosition();
		final ArrowToken arrowToken = ArrowToken.create(position);
		assertEquals("->", arrowToken.stringRepresentation());

		final ArrowToken otherArrowToken = ArrowToken.create(position);
		assertEquals(arrowToken, otherArrowToken);
		assertEquals(arrowToken.hashCode(), otherArrowToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link AsteriskToken}.
	 */
	@Test
	public void testAsteriskToken() {
		final Position position = Position.createDummyPosition();
		final AsteriskToken asteriskToken = AsteriskToken.create(position);
		assertEquals("*", asteriskToken.stringRepresentation());

		final AsteriskToken otherAsteriskToken = AsteriskToken.create(position);
		assertEquals(asteriskToken, otherAsteriskToken);
		assertEquals(asteriskToken.hashCode(), otherAsteriskToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link BracketCloseToken}.
	 */
	@Test
	public void testBracketCloseToken() {
		final Position position = Position.createDummyPosition();
		final BracketCloseToken bracketCloseToken = BracketCloseToken.create(position);
		assertEquals(")", bracketCloseToken.stringRepresentation());

		final BracketCloseToken otherBracketCloseToken = BracketCloseToken.create(position);
		assertEquals(bracketCloseToken, otherBracketCloseToken);
		assertEquals(bracketCloseToken.hashCode(), otherBracketCloseToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link ColonToken}.
	 */
	@Test
	public void testColonToken() {
		final Position position = Position.createDummyPosition();
		final ColonToken colonToken = ColonToken.create(position);
		assertEquals(":", colonToken.stringRepresentation());

		final ColonToken otherColonToken = ColonToken.create(position);
		assertEquals(colonToken, otherColonToken);
		assertEquals(colonToken.hashCode(), otherColonToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link CurlyBracketCloseToken}.
	 */
	@Test
	public void testCurlyBracketCloseToken() {
		final Position position = Position.createDummyPosition();
		final CurlyBracketCloseToken curlyBracketCloseToken = CurlyBracketCloseToken.create(position);
		assertEquals("}", curlyBracketCloseToken.stringRepresentation());

		final CurlyBracketCloseToken otherCurlyBracketCloseToken = CurlyBracketCloseToken.create(position);
		assertEquals(curlyBracketCloseToken, otherCurlyBracketCloseToken);
		assertEquals(curlyBracketCloseToken.hashCode(), otherCurlyBracketCloseToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link CurlyBracketOpenToken}.
	 */
	@Test
	public void testCurlyBracketOpenToken() {
		final Position position = Position.createDummyPosition();
		final CurlyBracketOpenToken curlyBracketOpenToken = CurlyBracketOpenToken.create(position);
		assertEquals("{", curlyBracketOpenToken.stringRepresentation());

		final CurlyBracketOpenToken otherCurlyBracketOpenToken = CurlyBracketOpenToken.create(position);
		assertEquals(curlyBracketOpenToken, otherCurlyBracketOpenToken);
		assertEquals(curlyBracketOpenToken.hashCode(), otherCurlyBracketOpenToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link DoubleSquareBracketCloseToken}.
	 */
	@Test
	public void testDoubleSquareBracketCloseToken() {
		final Position position = Position.createDummyPosition();
		final DoubleSquareBracketCloseToken doubleSquareBracketCloseToken =
				DoubleSquareBracketCloseToken.create(position);
		assertEquals("]]", doubleSquareBracketCloseToken.stringRepresentation());

		final DoubleSquareBracketCloseToken otherDoubleSquareBracketCloseToken =
				DoubleSquareBracketCloseToken.create(position);
		assertEquals(doubleSquareBracketCloseToken, otherDoubleSquareBracketCloseToken);
		assertEquals(doubleSquareBracketCloseToken.hashCode(), otherDoubleSquareBracketCloseToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link DoubleSquareBracketOpenToken}.
	 */
	@Test
	public void testDoubleSquareBracketOpenToken() {
		final Position position = Position.createDummyPosition();
		final DoubleSquareBracketOpenToken doubleSquareBracketOpenToken = DoubleSquareBracketOpenToken.create(position);
		assertEquals("[[", doubleSquareBracketOpenToken.stringRepresentation());

		final DoubleSquareBracketOpenToken otherDoubleSquareBracketOpenToken =
				DoubleSquareBracketOpenToken.create(position);
		assertEquals(doubleSquareBracketOpenToken, otherDoubleSquareBracketOpenToken);
		assertEquals(doubleSquareBracketOpenToken.hashCode(), otherDoubleSquareBracketOpenToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link EqualToken}.
	 */
	@Test
	public void testEqualToken() {
		final Position position = Position.createDummyPosition();
		final EqualToken equalToken = EqualToken.create(position);
		assertEquals("=", equalToken.stringRepresentation());

		final EqualToken otherEqualToken = EqualToken.create(position);
		assertEquals(equalToken, otherEqualToken);
		assertEquals(equalToken.hashCode(), otherEqualToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link GreaterSymbolToken}.
	 */
	@Test
	public void testGreaterSymbolToken() {
		final Position position = Position.createDummyPosition();
		final GreaterSymbolToken greaterSymbolToken = GreaterSymbolToken.create(position);
		assertEquals(">", greaterSymbolToken.stringRepresentation());

		final GreaterSymbolToken otherGreaterSymbolToken = GreaterSymbolToken.create(position);
		assertEquals(greaterSymbolToken, otherGreaterSymbolToken);
		assertEquals(greaterSymbolToken.hashCode(), otherGreaterSymbolToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link PlusSymbolToken}.
	 */
	@Test
	public void testPlusSymbolToken() {
		final Position position = Position.createDummyPosition();
		final PlusSymbolToken plusSymbolToken = PlusSymbolToken.create(position);
		assertEquals("+", plusSymbolToken.stringRepresentation());

		final PlusSymbolToken otherPlusSymbolToken = PlusSymbolToken.create(position);
		assertEquals(plusSymbolToken, otherPlusSymbolToken);
		assertEquals(plusSymbolToken.hashCode(), otherPlusSymbolToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link SemicolonToken}.
	 */
	@Test
	public void testSemicolonToken() {
		final Position position = Position.createDummyPosition();
		final SemicolonToken semicolonToken = SemicolonToken.create(position);
		assertEquals(";", semicolonToken.stringRepresentation());

		final SemicolonToken otherSemicolonToken = SemicolonToken.create(position);
		assertEquals(semicolonToken, otherSemicolonToken);
		assertEquals(semicolonToken.hashCode(), otherSemicolonToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link SquareBracketCloseToken}.
	 */
	@Test
	public void testSquareBracketCloseToken() {
		final Position position = Position.createDummyPosition();
		final SquareBracketCloseToken squareBracketCloseToken = SquareBracketCloseToken.create(position);
		assertEquals("]", squareBracketCloseToken.stringRepresentation());

		final SquareBracketCloseToken otherSquareBracketCloseToken = SquareBracketCloseToken.create(position);
		assertEquals(squareBracketCloseToken, otherSquareBracketCloseToken);
		assertEquals(squareBracketCloseToken.hashCode(), otherSquareBracketCloseToken.hashCode());
	}

	/**
	 * Tests some simple methods of {@link SquareBracketOpenToken}.
	 */
	@Test
	public void testSquareBracketOpenToken() {
		final Position position = Position.createDummyPosition();
		final SquareBracketOpenToken squareBracketOpenToken = SquareBracketOpenToken.create(position);
		assertEquals("[", squareBracketOpenToken.stringRepresentation());

		final SquareBracketOpenToken otherSquareBracketOpenToken = SquareBracketOpenToken.create(position);
		assertEquals(squareBracketOpenToken, otherSquareBracketOpenToken);
		assertEquals(squareBracketOpenToken.hashCode(), otherSquareBracketOpenToken.hashCode());
	}

}