package de.fhdw.wtf.parser.test;
   
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertTrue;
   
   import java.util.Vector;
   
   import org.junit.Before;
   import org.junit.Test;
  
  import de.fhdw.wtf.common.ast.Attribute;
  import de.fhdw.wtf.common.ast.Constructor;
  import de.fhdw.wtf.common.ast.Group;
  import de.fhdw.wtf.common.ast.GroupElement;
  import de.fhdw.wtf.common.ast.Model;
  import de.fhdw.wtf.common.ast.Name;
  import de.fhdw.wtf.common.ast.Operation;
  import de.fhdw.wtf.common.ast.OperationModifier;
  import de.fhdw.wtf.common.ast.OperationModifierAbstract;
  import de.fhdw.wtf.common.ast.UnqualifiedName;
  import de.fhdw.wtf.common.ast.type.ByNameState;
  import de.fhdw.wtf.common.ast.type.ClassModifier;
  import de.fhdw.wtf.common.ast.type.ClassType;
  import de.fhdw.wtf.common.ast.type.ExceptionClassType;
  import de.fhdw.wtf.common.ast.type.ProductElementType;
  import de.fhdw.wtf.common.ast.type.ProductType;
  import de.fhdw.wtf.common.ast.type.RegularClassType;
  import de.fhdw.wtf.common.ast.type.SumType;
  import de.fhdw.wtf.common.ast.type.ThrownType;
  import de.fhdw.wtf.common.ast.type.Type;
  import de.fhdw.wtf.common.ast.type.TypeProxy;
  import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
  import de.fhdw.wtf.common.stream.SimpleTokenStream;
  import de.fhdw.wtf.common.stream.TokenStream;
  import de.fhdw.wtf.common.token.EndToken;
  import de.fhdw.wtf.common.token.IdentifierToken;
  import de.fhdw.wtf.common.token.Position;
  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.GroupToken;
  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.ExclamationToken;
  import de.fhdw.wtf.common.token.symbols.GreaterSymbolToken;
  import de.fhdw.wtf.common.token.symbols.SemicolonToken;
  import de.fhdw.wtf.common.token.symbols.SquareBracketCloseToken;
  import de.fhdw.wtf.common.token.symbols.SquareBracketOpenToken;
  import de.fhdw.wtf.parser.Parser;
  
  /**
   * Tests the parsing of operations and the {@link Operation}.
   */
  public class TestOperations {
  	
  	/**
  	 * Parser which is used to parse the {@link TokenStream} from scanner.
  	 */
  	private Parser parser;
  	
  	/**
  	 * {@link TokenStream} which is used for testing the {@link Parser}.
  	 */
  	private TokenStream stream;
  	
  	/**
  	 * The {@link ColonToken} represents ":".
  	 */
  	private ColonToken colonToken;
  	
  	/**
  	 * The {@link GroupToken} represents "group".
  	 */
  	private GroupToken groupToken;
  	
  	/**
  	 * The {@link EqualToken} represents "=".
  	 */
  	private EqualToken equalToken;
  	
  	/**
  	 * The {@link SquareBracketOpenToken} represents "[".
  	 */
  	private SquareBracketOpenToken squareBracketOpenToken;
  	
  	/**
  	 * The {@link SquareBracketCloseToken} represents "]".
  	 */
  	private SquareBracketCloseToken squareBracketCloseToken;
  	
 	/**
 	 * The {@link SemicolonToken} represents ";".
 	 */
 	private SemicolonToken semicolonToken;
 	
 	/**
 	 * The {@link ClassToken} represents "class".
 	 */
 	private ClassToken classToken;
 	
 	/**
 	 * The {@link CurlyBracketOpenToken} represents "{".
 	 */
 	private CurlyBracketOpenToken curlyBracketOpenToken;
 	
 	/**
 	 * The {@link CurlyBracketCloseToken} represents "}".
 	 */
 	private CurlyBracketCloseToken curlyBracketCloseToken;
 	
 	/**
 	 * The {@link BracketOpenToken} represents "(".
 	 */
 	private BracketOpenToken bracketOpenToken;
 	
 	/**
 	 * The {@link BracketCloseToken} represents ")".
 	 */
 	private BracketCloseToken bracketCloseToken;
 	
 	/**
 	 * The {@link EndToken} represents "".
 	 */
 	private EndToken endToken;
 	
 	/**
 	 * The {@link GreaterSymbolToken} represents ">".
 	 */
 	private GreaterSymbolToken greaterSymbolToken;
 	
 	/**
 	 * The {@link ArrowToken} represents "->".
 	 */
 	private ArrowToken arrowToken;
 	
 	/**
 	 * The {@link CommaToken} represents ",".
 	 */
 	private CommaToken commaToken;
 	
 	/**
 	 * The {@link AbstractToken} represents "abstract".
 	 */
 	private AbstractToken abstractToken;
 	
 	/**
 	 * The {@link DoubleSquareBracketOpenToken} represents "[[".
 	 */
 	private DoubleSquareBracketOpenToken doubleSquareBracketOpenToken;
 	
 	/**
 	 * The {@link DoubleSquareBracketCloseToken} represents "]]".
 	 */
 	private DoubleSquareBracketCloseToken doubleSquareBracketCloseToken;
 	
 	/**
 	 * Creates the most important Tokens.
 	 */
 	@Before
 	public void setUp() {
 		this.stream = SimpleTokenStream.create();
 		this.parser = Parser.create(this.stream);
 		
 		this.colonToken = ColonToken.create(Position.create("", 1, 1, 0));
 		this.groupToken = GroupToken.create(Position.create("", 1, 1, 0));
 		this.equalToken = EqualToken.create(Position.create("", 1, 1, 0));
 		this.squareBracketOpenToken = SquareBracketOpenToken.create(Position.create("", 1, 1, 0));
 		this.squareBracketCloseToken = SquareBracketCloseToken.create(Position.create("", 1, 1, 0));
 		this.bracketOpenToken = BracketOpenToken.create(Position.create("", 1, 1, 0));
 		this.bracketCloseToken = BracketCloseToken.create(Position.create("", 1, 1, 0));
 		this.semicolonToken = SemicolonToken.create(Position.create("", 1, 1, 0));
 		this.classToken = ClassToken.create(Position.create("", 1, 1, 0));
 		this.curlyBracketOpenToken = CurlyBracketOpenToken.create(Position.create("", 1, 1, 0));
 		this.curlyBracketCloseToken = CurlyBracketCloseToken.create(Position.create("", 1, 1, 0));
 		this.endToken = EndToken.create(Position.create("", 1, 1, 0));
 		this.abstractToken = AbstractToken.create(Position.create("", 1, 1, 0));
 		this.greaterSymbolToken = GreaterSymbolToken.create(Position.create("", 1, 1, 0));
 		this.commaToken = CommaToken.create(Position.create("", 1, 1, 0));
 		this.doubleSquareBracketCloseToken = DoubleSquareBracketCloseToken.create(Position.create("", 1, 1, 0));
 		this.doubleSquareBracketOpenToken = DoubleSquareBracketOpenToken.create(Position.create("", 1, 1, 0));
 		this.arrowToken = ArrowToken.create(Position.create("", 1, 1, 0));
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->{}];};]];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testSimpleOperationWithoutParameters() throws Exception {
 		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		this.stream.add(myGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myClass);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.classToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myOperation);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.doubleSquareBracketOpenToken);
 		this.stream.add(this.bracketOpenToken);
 		this.stream.add(this.bracketCloseToken);
 		this.stream.add(this.arrowToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.doubleSquareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.endToken);
 		
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroup);
 		final Group group = Group.create(groupName, groupVector, myGroup);
 		
 		final Name className = groupName.addName(myClass);
 		
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClass,
 						
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
 		
 		final Operation operation =
 				Operation.create("MyOperation", new Vector<OperationModifier>(), product, class1, sum, myOperation);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myGroup);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		assertEquals(0, this.parser.getExceptions().size());
 		assertEquals(expected, actual);
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[(MyParameter:String)->{}]];}; ];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationWithOneSimpleInputParameter() throws Exception {
 		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		final IdentifierToken myParameter = IdentifierToken.create("MyParameter", Position.create("", 1, 1, 0));
 		final IdentifierToken string = IdentifierToken.create("String", Position.create("", 1, 1, 0));
 		this.stream.add(myGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myClass);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.classToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myOperation);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.doubleSquareBracketOpenToken);
 		this.stream.add(this.bracketOpenToken);
 		this.stream.add(myParameter);
 		this.stream.add(this.colonToken);
 		this.stream.add(string);
 		this.stream.add(this.bracketCloseToken);
 		this.stream.add(this.arrowToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.doubleSquareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.endToken);
 		
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroup);
 		final Group group = Group.create(groupName, groupVector, myGroup);
 		
 		final Name className = groupName.addName(myClass);
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClass,
 						
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final ByNameState byName = ByNameState.create(UnqualifiedName.create(string));
 		final TypeProxy typeProxy = TypeProxy.create(string, byName);
 		final ProductElementType element = ProductElementType.create("MyParameter", typeProxy, myParameter);
 		product.addElement(element);
 		
 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
 		final Operation operation =
 				Operation.create("MyOperation", new Vector<OperationModifier>(), product, class1, sum, myOperation);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myGroup);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		
 		assertEquals(expected, actual);
 		assertEquals(0, this.parser.getExceptions().size());
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[(MyParameter1:String, MyParameter2:Integer)->{}]];};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationWithTwoSimpleInputParameter() throws Exception {
 		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		final IdentifierToken myParameter1 = IdentifierToken.create("MyParameter1", Position.create("", 1, 1, 0));
 		final IdentifierToken myParameter2 = IdentifierToken.create("MyParameter2", Position.create("", 1, 1, 0));
 		final IdentifierToken string = IdentifierToken.create("String", Position.create("", 1, 1, 0));
 		final IdentifierToken integer = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
 		this.stream.add(myGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myClass);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.classToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myOperation);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.doubleSquareBracketOpenToken);
 		this.stream.add(this.bracketOpenToken);
 		this.stream.add(myParameter1);
 		this.stream.add(this.colonToken);
 		this.stream.add(string);
 		this.stream.add(this.commaToken);
 		this.stream.add(myParameter2);
 		this.stream.add(this.colonToken);
 		this.stream.add(integer);
 		this.stream.add(this.bracketCloseToken);
 		this.stream.add(this.arrowToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.doubleSquareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.endToken);
 		
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroup);
 		final Group group = Group.create(groupName, groupVector, myGroup);
 		
 		final Name className = groupName.addName(myClass);
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClass,
 						
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final ByNameState byNameString = ByNameState.create(UnqualifiedName.create(string));
 		final TypeProxy typeProxyString = TypeProxy.create(string, byNameString);
 		final ProductElementType element1 = ProductElementType.create("MyParameter1", typeProxyString, myParameter1);
 		product.addElement(element1);
 		
 		final ByNameState byNameInteger = ByNameState.create(UnqualifiedName.create(integer));
 		final TypeProxy typeProxyInteger = TypeProxy.create(string, byNameInteger);
 		final ProductElementType element2 = ProductElementType.create("MyParameter2", typeProxyInteger, myParameter2);
 		product.addElement(element2);
 		
 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
 		final Operation operation =
 				Operation.create("MyOperation", new Vector<OperationModifier>(), product, class1, sum, myOperation);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myGroup);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		assertEquals(expected, actual);
 		assertEquals(0, this.parser.getExceptions().size());
 		
 	}
 	
 	/**
 	 * MyExceptionGroup:group=[MyException:exception={};]; MyGroup:group=[MyClass
 	 * :class={operation:[[()->{MyExceptionGroup>MyException}]];};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationWithException() throws Exception {
 		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
 		final IdentifierToken myExceptionGroup =
 				IdentifierToken.create("MyExceptionGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myException = IdentifierToken.create("MyException", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		final ExceptionToken exception = ExceptionToken.create(Position.create("", 1, 1, 0));
 		
 		this.stream.add(myExceptionGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myException);
 		this.stream.add(this.colonToken);
 		this.stream.add(exception);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(myGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myClass);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.classToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myOperation);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.doubleSquareBracketOpenToken);
 		this.stream.add(this.bracketOpenToken);
 		this.stream.add(this.bracketCloseToken);
 		this.stream.add(this.arrowToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myExceptionGroup);
 		this.stream.add(this.greaterSymbolToken);
 		this.stream.add(myException);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.doubleSquareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.endToken);
 		
 		// --------------------------- MyExceptionGroup
 		// -------------------------------------------------------//
 		final Vector<GroupElement> exceptionGroupVector = new Vector<>();
 		final Name exceptionGroupName = UnqualifiedName.create(myExceptionGroup);
 		final Group exceptionGroup = Group.create(exceptionGroupName, exceptionGroupVector, myExceptionGroup);
 		
 		final Name exceptionClassName = exceptionGroupName.addName(myException);
 		final ClassType exceptionClass =
 				ExceptionClassType.create(
 						exceptionClassName,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						new Vector<Operation>(),
 						new Vector<Constructor>(),
 						myException,
 						new Vector<ClassType>());
 		exceptionGroupVector.add(exceptionClass);
 		
 		// ---------------------------- MyGroup
 		// -------------------------------------------------------------//
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroup);
 		final Group group = Group.create(groupName, groupVector, myGroup);
 		
 		final Name className = groupName.addName(myClass);
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClass,
 						
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		// ------------------------------- empty Product
 		// --------------------------------------------------//
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		
 		// ------------------------------- Sum
 		// ---------------------------------------------------------------//
 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
 		final ByNameState byNameExceptionClass = ByNameState.create(exceptionClassName);
 		final TypeProxy exceptionClassProxy = TypeProxy.create(myException, byNameExceptionClass);
 		sum.add(exceptionClassProxy);
 		
 		// ------------------------------------- Operation
 		// --------------------------------------------------------//
 		final Operation operation =
 				Operation.create("MyOperation", new Vector<OperationModifier>(), product, class1, sum, myOperation);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myExceptionGroup);
 		expected.addGroup(exceptionGroup);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		assertEquals(expected, actual);
 		
 		assertEquals(0, this.parser.getExceptions().size());
 		
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->String]];};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationWithOneOutputParameter() throws Exception {
 		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		final IdentifierToken string = IdentifierToken.create("String", Position.create("", 1, 1, 0));
 		
 		this.stream.add(myGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myClass);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.classToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myOperation);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.doubleSquareBracketOpenToken);
 		this.stream.add(this.bracketOpenToken);
 		this.stream.add(this.bracketCloseToken);
 		this.stream.add(this.arrowToken);
 		this.stream.add(string);
 		this.stream.add(this.doubleSquareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.endToken);
 		
 		// ---------------------------- MyGroup
 		// -------------------------------------------------------------//
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroup);
 		final Group group = Group.create(groupName, groupVector, myGroup);
 		
 		final Name className = groupName.addName(myClass);
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClass,
 						
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		// ------------------------------- empty Product
 		// --------------------------------------------------//
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final ByNameState byNameString = ByNameState.create(UnqualifiedName.create(string));
 		final TypeProxy stringTypeProxy = TypeProxy.create(string, byNameString);
 		
 		// ------------------------------------- Operation
 		// --------------------------------------------------------//
 		final Operation operation =
 				Operation.create(
 						"MyOperation",
 						new Vector<OperationModifier>(),
 						product,
 						class1,
 						stringTypeProxy,
 						myOperation);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myGroup);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		assertEquals(expected, actual);
 		
 		assertEquals(0, this.parser.getExceptions().size());
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[(MyParameter:Integer)->String ]] abstract;};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationWithParameterAndOutputParameterModifier() throws Exception {
 		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		final IdentifierToken myParameter = IdentifierToken.create("MyParameter", Position.create("", 1, 1, 0));
 		final IdentifierToken string = IdentifierToken.create("String", Position.create("", 1, 1, 0));
 		final IdentifierToken integer = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
 		
 		this.stream.add(myGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myClass);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.classToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myOperation);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.doubleSquareBracketOpenToken);
 		this.stream.add(this.bracketOpenToken);
 		this.stream.add(myParameter);
 		this.stream.add(this.colonToken);
 		this.stream.add(integer);
 		this.stream.add(this.bracketCloseToken);
 		this.stream.add(this.arrowToken);
 		this.stream.add(string);
 		this.stream.add(this.doubleSquareBracketCloseToken);
 		this.stream.add(this.abstractToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.endToken);
 		
 		// ---------------------------- MyGroup
 		// -------------------------------------------------------------//
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		final Vector<OperationModifier> operationModifiers = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroup);
 		final Group group = Group.create(groupName, groupVector, myGroup);
 		
 		final Name className = groupName.addName(myClass);
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClass,
 						
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		// ------------------------------- Product
 		// --------------------------------------------------//
 		final ProductType prod = ProductType.create(this.bracketOpenToken);
 		final ByNameState byNameInteger = ByNameState.create(UnqualifiedName.create(integer));
 		final TypeProxy typeProxyInteger = TypeProxy.create(integer, byNameInteger);
 		final ProductElementType element = ProductElementType.create("MyParameter", typeProxyInteger, myParameter);
 		prod.addElement(element);
 		
 		final ByNameState byNameString = ByNameState.create(UnqualifiedName.create(string));
 		final TypeProxy typeProxyString = TypeProxy.create(integer, byNameString);
 		
 		// ------------------------------------- Operation
 		// --------------------------------------------------------//
 		operationModifiers.add(OperationModifierAbstract.create(this.abstractToken));
 		final Operation operation =
 				Operation.create("MyOperation", operationModifiers, prod, class1, typeProxyString, myOperation);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myGroup);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		assertEquals(expected, actual);
 		
 		assertEquals(0, this.parser.getExceptions().size());
 	}
 	
 	/**
 	 * MyOperation:[[()->{}];};]] abstract;.
 	 */
 	@Test
 	public void testAbstractOperation() {
 		final IdentifierToken abs = IdentifierToken.create("abstract", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
 		final Vector<OperationModifier> modifiers = new Vector<>();
 		modifiers.addElement(OperationModifierAbstract.create(abs));
 		
 		final Operation operation = Operation.create("MyOperation", modifiers, product, null, sum, myOperation);
 		
 		assertTrue(operation.isAbstract());
 	}
 	
 	/**
 	 * MyOperation:[[()->{}];};]] abstract;.
 	 */
 	@Test
 	public void testOperationHashCode() {
 		final IdentifierToken abs = IdentifierToken.create("abstract", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final SumType sum = SumType.create(this.curlyBracketOpenToken);
 		final Vector<OperationModifier> modifiers1 = new Vector<>();
 		modifiers1.addElement(OperationModifierAbstract.create(abs));
 		final Operation operation1 = Operation.create("MyOperation", modifiers1, product, null, sum, myOperation);
 		
 		final Vector<OperationModifier> modifiers2 = new Vector<>();
 		modifiers2.addElement(OperationModifierAbstract.create(abs));
 		final Operation operation2 = Operation.create("MyOperation", modifiers2, product, null, sum, myOperation);
 		
 		assertEquals(operation1, operation2);
 		assertEquals(operation1.hashCode(), operation2.hashCode());
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[() -> {}]] abstract;};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationToString() throws Exception {
 		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
 		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
 		final IdentifierToken myOperation = IdentifierToken.create("MyOperation", Position.create("", 1, 1, 0));
 		this.stream.add(myGroup);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.groupToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.squareBracketOpenToken);
 		this.stream.add(myClass);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.classToken);
 		this.stream.add(this.equalToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(myOperation);
 		this.stream.add(this.colonToken);
 		this.stream.add(this.doubleSquareBracketOpenToken);
 		this.stream.add(this.bracketOpenToken);
 		this.stream.add(this.bracketCloseToken);
 		this.stream.add(this.arrowToken);
 		this.stream.add(this.curlyBracketOpenToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.doubleSquareBracketCloseToken);
 		this.stream.add(this.abstractToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.curlyBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.squareBracketCloseToken);
 		this.stream.add(this.semicolonToken);
 		this.stream.add(this.endToken);
 		
 		final String expected =
 				"Model: \n" + "MyGroup:group=[ \n" + "MyGroup>MyClass:class={ \n"
 						+ "MyOperation:[[()->{}]] abstract; \n" + "}; \n" + "]; \n";
 		
 		final Model model = this.parser.parse();
 		assertEquals(expected, model.toString());
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->TestException!]];};TestException:exception={};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationWithoutReturnButThrow() throws Exception {
 		
 		final IdentifierToken myGroupToken = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 1));
 		final IdentifierToken myClassToken = IdentifierToken.create("MyClass", Position.create("", 1, 16, 16));
 		final IdentifierToken myOperationToken = IdentifierToken.create("MyOperation", Position.create("", 1, 31, 31));
 		final IdentifierToken testExceptionReferenceToken =
 				IdentifierToken.create("TestException", Position.create("", 1, 49, 49));
 		final IdentifierToken testExceptionToken =
 				IdentifierToken.create("TestException", Position.create("", 1, 68, 68));
 		
 		this.stream.add(myGroupToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 8, 8)));
 		this.stream.add(GroupToken.create(Position.create("", 1, 9, 9)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 14, 14)));
 		this.stream.add(SquareBracketOpenToken.create(Position.create("", 1, 15, 15)));
 		this.stream.add(myClassToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 23, 23)));
 		this.stream.add(ClassToken.create(Position.create("", 1, 24, 24)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 29, 29)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 30, 30)));
 		this.stream.add(myOperationToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 42, 42)));
 		this.stream.add(DoubleSquareBracketOpenToken.create(Position.create("", 1, 43, 43)));
 		this.stream.add(BracketOpenToken.create(Position.create("", 1, 45, 45)));
 		this.stream.add(BracketCloseToken.create(Position.create("", 1, 46, 46)));
 		this.stream.add(ArrowToken.create(Position.create("", 1, 47, 47)));
 		this.stream.add(testExceptionReferenceToken);
 		this.stream.add(ExclamationToken.create(Position.create("", 1, 62, 62)));
 		this.stream.add(DoubleSquareBracketCloseToken.create(Position.create("", 1, 63, 63)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 65, 65)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 66, 66)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 67, 67)));
 		this.stream.add(testExceptionToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 81, 81)));
 		this.stream.add(ExceptionToken.create(Position.create("", 1, 82, 82)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 91, 91)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 92, 92)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 93, 93)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 94, 94)));
 		this.stream.add(SquareBracketCloseToken.create(Position.create("", 1, 95, 95)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 96, 96)));
 		this.stream.add(EndToken.create(Position.create("", 1, 97, 97)));
 		
 		// ---------------------------- MyGroup
 		// -------------------------------------------------------------//
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		final Vector<OperationModifier> operationModifiers = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroupToken);
 		final Group group = Group.create(groupName, groupVector, myGroupToken);
 		
 		final Name className = groupName.addName(myClassToken);
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClassToken,
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		final Name exceptionName = groupName.addName(testExceptionToken);
 		final ClassType exception1 =
 				ExceptionClassType.create(
 						exceptionName,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						new Vector<Operation>(),
 						new Vector<Constructor>(),
 						testExceptionToken,
 						new Vector<ClassType>());
 		groupVector.add(exception1);
 		
 		// -------------------------------------
 		// --------------------------------------------------------//
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final ByNameState byNameString = ByNameState.create(UnqualifiedName.create(testExceptionReferenceToken));
 		final TypeProxy exceptionTypeProxy = TypeProxy.create(testExceptionReferenceToken, byNameString);
 		final ThrownType thrownType =
 				ThrownType.create(
 						exceptionTypeProxy.getFirstToken(),
 						exceptionTypeProxy,
 						exceptionTypeProxy.getLastToken());
 		
 		// ------------------------------------- Operation
 		// --------------------------------------------------------//
 		final Operation operation =
 				Operation.create("MyOperation", operationModifiers, product, class1, thrownType, myOperationToken);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myGroupToken);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		assertEquals(expected, actual);
 		
 		assertEquals(0, this.parser.getExceptions().size());
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->{TestException}!]];};TestException:exception={};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationWithoutReturnButThrowSumOfException() throws Exception {
 		
 		final IdentifierToken myGroupToken = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 1));
 		final IdentifierToken myClassToken = IdentifierToken.create("MyClass", Position.create("", 1, 16, 16));
 		final IdentifierToken myOperationToken = IdentifierToken.create("MyOperation", Position.create("", 1, 31, 31));
 		final IdentifierToken testExceptionReferenceToken =
 				IdentifierToken.create("TestException", Position.create("", 1, 50, 50));
 		final IdentifierToken testExceptionToken =
 				IdentifierToken.create("TestException", Position.create("", 1, 70, 70));
 		final CurlyBracketOpenToken sumTypeStart = CurlyBracketOpenToken.create(Position.create("", 1, 49, 49));
 		
 		this.stream.add(myGroupToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 8, 8)));
 		this.stream.add(GroupToken.create(Position.create("", 1, 9, 9)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 14, 14)));
 		this.stream.add(SquareBracketOpenToken.create(Position.create("", 1, 15, 15)));
 		this.stream.add(myClassToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 23, 23)));
 		this.stream.add(ClassToken.create(Position.create("", 1, 24, 24)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 29, 29)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 30, 30)));
 		this.stream.add(myOperationToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 42, 42)));
 		this.stream.add(DoubleSquareBracketOpenToken.create(Position.create("", 1, 43, 43)));
 		this.stream.add(BracketOpenToken.create(Position.create("", 1, 45, 45)));
 		this.stream.add(BracketCloseToken.create(Position.create("", 1, 46, 46)));
 		this.stream.add(ArrowToken.create(Position.create("", 1, 47, 47)));
 		this.stream.add(sumTypeStart);
 		this.stream.add(testExceptionReferenceToken);
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 63, 63)));
 		this.stream.add(ExclamationToken.create(Position.create("", 1, 64, 64)));
 		this.stream.add(DoubleSquareBracketCloseToken.create(Position.create("", 1, 65, 65)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 67, 67)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 68, 68)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 69, 69)));
 		this.stream.add(testExceptionToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 83, 83)));
 		this.stream.add(ExceptionToken.create(Position.create("", 1, 84, 84)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 93, 93)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 94, 94)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 95, 95)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 96, 96)));
 		this.stream.add(SquareBracketCloseToken.create(Position.create("", 1, 97, 97)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 98, 98)));
 		this.stream.add(EndToken.create(Position.create("", 1, 99, 99)));
 		
 		// ---------------------------- MyGroup
 		// -------------------------------------------------------------//
 		final Vector<GroupElement> groupVector = new Vector<>();
 		final Vector<Operation> operations = new Vector<>();
 		final Vector<OperationModifier> operationModifiers = new Vector<>();
 		
 		final Name groupName = UnqualifiedName.create(myGroupToken);
 		final Group group = Group.create(groupName, groupVector, myGroupToken);
 		
 		final Name className = groupName.addName(myClassToken);
 		final ClassType class1 =
 				RegularClassType.create(
 						className,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						operations,
 						new Vector<Constructor>(),
 						myClassToken,
 						new Vector<ClassType>());
 		groupVector.add(class1);
 		
 		final Name exceptionName = groupName.addName(testExceptionToken);
 		final ClassType exception1 =
 				ExceptionClassType.create(
 						exceptionName,
 						new Vector<ClassModifier>(),
 						new Vector<Attribute>(),
 						new Vector<Type>(),
 						new Vector<Operation>(),
 						new Vector<Constructor>(),
 						testExceptionToken,
 						new Vector<ClassType>());
 		groupVector.add(exception1);
 		
 		// -------------------------------------
 		// --------------------------------------------------------//
 		final ProductType product = ProductType.create(this.bracketOpenToken);
 		final SumType sum = SumType.create(sumTypeStart);
 		final ByNameState byNameString = ByNameState.create(UnqualifiedName.create(testExceptionReferenceToken));
 		final TypeProxy exceptionTypeProxy = TypeProxy.create(testExceptionReferenceToken, byNameString);
 		sum.add(exceptionTypeProxy);
 		final ThrownType thrownType = ThrownType.create(sum.getFirstToken(), sum, sum.getLastToken());
 		
 		// ------------------------------------- Operation
 		// --------------------------------------------------------//
 		final Operation operation =
 				Operation.create("MyOperation", operationModifiers, product, class1, thrownType, myOperationToken);
 		operations.add(operation);
 		
 		final Model expected = Model.create(myGroupToken);
 		expected.addGroup(group);
 		
 		final Model actual = this.parser.parse();
 		assertEquals(expected, actual);
 		
 		assertEquals(0, this.parser.getExceptions().size());
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->(a:Integer)!]];};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationReturnAProductThatShouldBeThrown() throws Exception {
 		
 		final IdentifierToken myGroupToken = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 1));
 		final IdentifierToken myClassToken = IdentifierToken.create("MyClass", Position.create("", 1, 16, 16));
 		final IdentifierToken myOperationToken = IdentifierToken.create("MyOperation", Position.create("", 1, 31, 31));
 		
 		this.stream.add(myGroupToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 8, 8)));
 		this.stream.add(GroupToken.create(Position.create("", 1, 9, 9)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 14, 14)));
 		this.stream.add(SquareBracketOpenToken.create(Position.create("", 1, 15, 15)));
 		this.stream.add(myClassToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 23, 23)));
 		this.stream.add(ClassToken.create(Position.create("", 1, 24, 24)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 29, 29)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 30, 30)));
 		this.stream.add(myOperationToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 42, 42)));
 		this.stream.add(DoubleSquareBracketOpenToken.create(Position.create("", 1, 43, 43)));
 		this.stream.add(BracketOpenToken.create(Position.create("", 1, 45, 45)));
 		this.stream.add(BracketCloseToken.create(Position.create("", 1, 46, 46)));
 		this.stream.add(ArrowToken.create(Position.create("", 1, 47, 47)));
 		this.stream.add(BracketOpenToken.create(Position.create("", 1, 49, 49)));
 		this.stream.add(IdentifierToken.create("a", Position.create("", 1, 50, 50)));
 		this.stream.add(ColonToken.create(Position.create("", 1, 51, 51)));
 		this.stream.add(IdentifierToken.create("Integer", Position.create("", 1, 52, 52)));
 		this.stream.add(BracketCloseToken.create(Position.create("", 1, 59, 59)));
 		this.stream.add(ExclamationToken.create(Position.create("", 1, 60, 60)));
 		this.stream.add(DoubleSquareBracketCloseToken.create(Position.create("", 1, 61, 61)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 63, 63)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 64, 64)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 65, 65)));
 		this.stream.add(SquareBracketCloseToken.create(Position.create("", 1, 66, 66)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 67, 67)));
 		this.stream.add(EndToken.create(Position.create("", 1, 68, 68)));
 		
 		try {
 			this.parser.parse();
 		} catch (final NoValidTokenStreamException e) {
 			assertTrue(true);
 		}
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->String*!]];};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationReturnAListThatShouldBeThrown() throws Exception {
 		
 		final IdentifierToken myGroupToken = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 1));
 		final IdentifierToken myClassToken = IdentifierToken.create("MyClass", Position.create("", 1, 16, 16));
 		final IdentifierToken myOperationToken = IdentifierToken.create("MyOperation", Position.create("", 1, 31, 31));
 		
 		this.stream.add(myGroupToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 8, 8)));
 		this.stream.add(GroupToken.create(Position.create("", 1, 9, 9)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 14, 14)));
 		this.stream.add(SquareBracketOpenToken.create(Position.create("", 1, 15, 15)));
 		this.stream.add(myClassToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 23, 23)));
 		this.stream.add(ClassToken.create(Position.create("", 1, 24, 24)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 29, 29)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 30, 30)));
 		this.stream.add(myOperationToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 42, 42)));
 		this.stream.add(DoubleSquareBracketOpenToken.create(Position.create("", 1, 43, 43)));
 		this.stream.add(BracketOpenToken.create(Position.create("", 1, 45, 45)));
 		this.stream.add(BracketCloseToken.create(Position.create("", 1, 46, 46)));
 		this.stream.add(ArrowToken.create(Position.create("", 1, 47, 47)));
 		this.stream.add(IdentifierToken.create("String", Position.create("", 1, 49, 49)));
 		this.stream.add(AsteriskToken.create(Position.create("", 1, 55, 55)));
 		this.stream.add(ExclamationToken.create(Position.create("", 1, 56, 56)));
 		this.stream.add(DoubleSquareBracketCloseToken.create(Position.create("", 1, 57, 57)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 59, 59)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 60, 60)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 61, 61)));
 		this.stream.add(SquareBracketCloseToken.create(Position.create("", 1, 62, 62)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 63, 63)));
 		this.stream.add(EndToken.create(Position.create("", 1, 64, 64)));
 		
 		try {
 			this.parser.parse();
 		} catch (final NoValidTokenStreamException e) {
 			assertTrue(true);
 		}
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->String!!]];};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationReturnAThrownTypeThatShouldBeThrown() throws Exception {
 		
 		final IdentifierToken myGroupToken = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 1));
 		final IdentifierToken myClassToken = IdentifierToken.create("MyClass", Position.create("", 1, 16, 16));
 		final IdentifierToken myOperationToken = IdentifierToken.create("MyOperation", Position.create("", 1, 31, 31));
 		
 		this.stream.add(myGroupToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 8, 8)));
 		this.stream.add(GroupToken.create(Position.create("", 1, 9, 9)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 14, 14)));
 		this.stream.add(SquareBracketOpenToken.create(Position.create("", 1, 15, 15)));
 		this.stream.add(myClassToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 23, 23)));
 		this.stream.add(ClassToken.create(Position.create("", 1, 24, 24)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 29, 29)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 30, 30)));
 		this.stream.add(myOperationToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 42, 42)));
 		this.stream.add(DoubleSquareBracketOpenToken.create(Position.create("", 1, 43, 43)));
 		this.stream.add(BracketOpenToken.create(Position.create("", 1, 45, 45)));
 		this.stream.add(BracketCloseToken.create(Position.create("", 1, 46, 46)));
 		this.stream.add(ArrowToken.create(Position.create("", 1, 47, 47)));
 		this.stream.add(IdentifierToken.create("String", Position.create("", 1, 49, 49)));
 		this.stream.add(ExclamationToken.create(Position.create("", 1, 55, 55)));
 		this.stream.add(ExclamationToken.create(Position.create("", 1, 56, 56)));
 		this.stream.add(DoubleSquareBracketCloseToken.create(Position.create("", 1, 57, 57)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 59, 59)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 60, 60)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 61, 61)));
 		this.stream.add(SquareBracketCloseToken.create(Position.create("", 1, 62, 62)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 63, 63)));
 		this.stream.add(EndToken.create(Position.create("", 1, 64, 64)));
 		
 		try {
 			this.parser.parse();
 		} catch (final NoValidTokenStreamException e) {
 			assertTrue(true);
 		}
 	}
 	
 	/**
 	 * MyGroup:group=[MyClass:class={MyOperation:[[()->[String->Integer]!!]];};];.
 	 * 
 	 * @throws Exception
 	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
 	 */
 	@Test
 	public void testOperationReturnAMapThatShouldBeThrown() throws Exception {
 		
 		final IdentifierToken myGroupToken = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 1));
 		final IdentifierToken myClassToken = IdentifierToken.create("MyClass", Position.create("", 1, 16, 16));
 		final IdentifierToken myOperationToken = IdentifierToken.create("MyOperation", Position.create("", 1, 31, 31));
 		
 		this.stream.add(myGroupToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 8, 8)));
 		this.stream.add(GroupToken.create(Position.create("", 1, 9, 9)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 14, 14)));
 		this.stream.add(SquareBracketOpenToken.create(Position.create("", 1, 15, 15)));
 		this.stream.add(myClassToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 23, 23)));
 		this.stream.add(ClassToken.create(Position.create("", 1, 24, 24)));
 		this.stream.add(EqualToken.create(Position.create("", 1, 29, 29)));
 		this.stream.add(CurlyBracketOpenToken.create(Position.create("", 1, 30, 30)));
 		this.stream.add(myOperationToken);
 		this.stream.add(ColonToken.create(Position.create("", 1, 42, 42)));
 		this.stream.add(DoubleSquareBracketOpenToken.create(Position.create("", 1, 43, 43)));
 		this.stream.add(BracketOpenToken.create(Position.create("", 1, 45, 45)));
 		this.stream.add(BracketCloseToken.create(Position.create("", 1, 46, 46)));
 		this.stream.add(ArrowToken.create(Position.create("", 1, 47, 47)));
 		this.stream.add(SquareBracketOpenToken.create(Position.create("", 1, 49, 49)));
 		this.stream.add(IdentifierToken.create("String", Position.create("", 1, 50, 50)));
 		this.stream.add(ArrowToken.create(Position.create("", 1, 56, 56)));
 		this.stream.add(IdentifierToken.create("Integer", Position.create("", 1, 58, 58)));
 		this.stream.add(SquareBracketCloseToken.create(Position.create("", 1, 65, 65)));
 		this.stream.add(ExclamationToken.create(Position.create("", 1, 66, 66)));
 		this.stream.add(DoubleSquareBracketCloseToken.create(Position.create("", 1, 67, 67)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 69, 69)));
 		this.stream.add(CurlyBracketCloseToken.create(Position.create("", 1, 70, 70)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 71, 71)));
 		this.stream.add(SquareBracketCloseToken.create(Position.create("", 1, 72, 72)));
 		this.stream.add(SemicolonToken.create(Position.create("", 1, 73, 73)));
 		this.stream.add(EndToken.create(Position.create("", 1, 74, 74)));
 		
 		try {
 			this.parser.parse();
 		} catch (final NoValidTokenStreamException e) {
 			assertTrue(true);
 		}
 	}
 }