+ "B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr2.size());
		final Iterator<Type> superTypesAttr2Iterator = supertypesAttr2.iterator();
		assertEquals(clss, HelperUtils.getReferencedType(superTypesAttr2Iterator.next()));
		
		assertEquals(1, model.getInteger().getPrototype().getSuperTypes().size());
		assertEquals(
				attr1Type,
				HelperUtils.getReferencedType(model.getInteger().getPrototype().getSuperTypes().iterator().next()));
		
		assertEquals(1, model.getString().getPrototype().getSuperTypes().size());
		assertEquals(
				attr1Type,
				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{String,C};}; B:class=A+{}; C:class=A+{};
	 * Class:class={};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testContainsInheritanceOverClassInheritance2() throws Exception {

	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)));

						+ "operation : [[(parameter:Integer) -> String ]];}; ];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		Model model = null;
		model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
		referencer.addDependency(doubleChecks);
		cyclicInheritance.addDependency(referencer);
		subtypesFillTask.addDependency(cyclicInheritance);
		prototypesTask.addDependency(subtypesFillTask);
		overloadingCheck.addDependency(prototypesTask);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(7, okResult.size());
		assertEquals(1, failResult.size());
		
		final Exception exception = failResult.iterator().next().getError();
		if (exception instanceof InvalidOverloadingException) {
			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
			assertEquals(Position.create("", 1, 75, 74), ex.getStartPosition());
			assertEquals(Position.create("", 1, 122, 121), ex.getEndPos());
		} else {
			fail();
		}
	}
	
	/**
	 * Group:group=[Klasse:class={operation : [[(parameter:Klasse) -> String ]];operation : [[(parameter:Klasse) ->
	 * String ]];}; ]; .
	 * 
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws NoValidTokenStreamException
	 * @throws CyclicDependencyException
	 * @throws CyclicPartDefinitionException
	 */
	@Test
	public void testTwoEqualOperations2() throws InterruptedException, ExecutionException, NoValidTokenStreamException,

		final SimpleScannerInput input = new SimpleScannerInput("Group1:group=[A:class={s:String;();};];");
		final VerboseTokenStream output = new VerboseTokenStream(SimpleTokenStream.create());
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		
		final IdentifierToken group1IdentifierToken = IdentifierToken.create("Group1", Position.create("", 1, 1, 0));
		final IdentifierToken aIdentifierToken = IdentifierToken.create("A", Position.create("", 1, 1, 0));
		final IdentifierToken sIdentifierToken = IdentifierToken.create("s", Position.create("", 1, 1, 0));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		final Vector<Attribute> attributes = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		final ClassType aClass =
				RegularClassType.create(
						aName,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(aClass);
		
		final ByNameState attributeStringReferenceState =
				ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, attributeStringReferenceState);
		
		attributes.add(Attribute.create("s", stringType, new Vector<AttributeModifier>(), sIdentifierToken));
		
		final ProductType aProduct = ProductType.create(this.bracketOpenToken);
		
		constructors.add(Constructor.create(aProduct, aClass, new Vector<ConstructorReference>(), aIdentifierToken));
		
		final Model expected = Model.create(group1IdentifierToken);
		expected.addGroup(group1);
		
		this.parser = Parser.create(output);
		final Model actual = this.parser.parse();
		
		assertEquals(0, this.parser.getExceptions().size());
		assertEquals(expected, actual);
	}
	
	/**
	 * Group1:group=[A:class={();s:String;};];.
	 * 
	 * @throws Exception
	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
	 */
	@Test
	public void testFirstConstructorThanVariable() throws Exception {

	public void testAttributeWithListOfMapAndProductAsKey() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		final IdentifierToken nameIdentifier = IdentifierToken.create("name", Position.create("", 1, 1, 0));
		final IdentifierToken countIdentifier = IdentifierToken.create("count", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.bracketOpenToken);
		this.stream.add(nameIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.commaToken);
		this.stream.add(countIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.integerIdentifier);
		this.stream.add(this.bracketCloseToken);
		this.stream.add(this.arrowToken);
		this.stream.add(this.integerIdentifier);
		this.stream.add(this.squareBracketCloseToken);
		this.stream.add(this.asteriskToken);
		this.stream.add(this.semicolonToken);

				new SimpleScannerInput("Group1:group=[A:class={op:[[(s:String)->{}]];();s:String;};];");
		final VerboseTokenStream output = new VerboseTokenStream(SimpleTokenStream.create());
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		
		final IdentifierToken group1IdentifierToken = IdentifierToken.create("Group1", Position.create("", 1, 1, 0));
		final IdentifierToken aIdentifierToken = IdentifierToken.create("A", Position.create("", 1, 1, 0));
		final IdentifierToken sIdentifierToken = IdentifierToken.create("s", Position.create("", 1, 1, 1));
		final IdentifierToken op = IdentifierToken.create("op", Position.create("", 1, 1, 0));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		final Vector<Operation> operations = new Vector<>();
		final Vector<Attribute> attributes = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		final ClassType aClass =
				RegularClassType.create(
						aName,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						operations,
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(aClass);
		
		final ProductType aProduct = ProductType.create(this.bracketOpenToken);
		final ProductType sProduct = ProductType.create(this.bracketOpenToken);
		
		final ByNameState attributeStringReferenceState =
				ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, attributeStringReferenceState);
		
		attributes.add(Attribute.create("s", stringType, new Vector<AttributeModifier>(), sIdentifierToken));
		sProduct.addElement(ProductElementType.create("s", stringType, sIdentifierToken));
		constructors.add(Constructor.create(aProduct, aClass, new Vector<ConstructorReference>(), aIdentifierToken));
		
		final Operation operation1 =

	public void testTransitiveInheritanceAndSumSupertypeIsClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{C,D};}; B:class=A+{}; C:class=B+{}; "
						+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(clssB, HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(1, model.getInteger().getPrototype().getSuperTypes().size());
		assertEquals(
				model.getAnything().getPrototype(),
				HelperUtils.getReferencedType(model.getInteger().getPrototype().getSuperTypes().iterator().next()));
		
		assertEquals(1, model.getString().getPrototype().getSuperTypes().size());
		assertEquals(
				model.getAnything().getPrototype(),
				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{B,C}; Attribute2:{D,E,F,G};}; B:class=A+{}; C:class=A+{}; D:class=B+{};
	 * E:class=B+{}; F:class=C+{}; G:class=C+{}; Class:class={};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testTransitiveInheritanceAndSumSupertypeIsClass2() throws Exception {

	public void testOperationModifierAlreadyAddedException() {
		this.stream = SimpleTokenStream.create();
		this.parser = Parser.create(this.stream);
		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.abstractToken);

						+ "operation : [[(parameter:Integer) -> String ]];}; ];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		Model model = null;
		model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
		referencer.addDependency(doubleChecks);
		cyclicInheritance.addDependency(referencer);
		subtypesFillTask.addDependency(cyclicInheritance);
		prototypesTask.addDependency(subtypesFillTask);
		overloadingCheck.addDependency(prototypesTask);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(7, okResult.size());
		assertEquals(1, failResult.size());
		
		final Exception exception = failResult.iterator().next().getError();
		if (exception instanceof InvalidOverloadingException) {
			final InvalidOverloadingException ex = (InvalidOverloadingException) exception;
			assertEquals(Position.create("", 1, 75, 74), ex.getStartPosition());

	public void testOperationModifierAlreadyAddedException() {
		this.stream = SimpleTokenStream.create();
		this.parser = Parser.create(this.stream);
		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);

				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);

		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.semicolonToken);

		final IdentifierToken s2aIdentifierToken = IdentifierToken.create("S2A", Position.create("", 1, 1, 0));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		final Name s1aName = group1Name.addName(s1aIdentifierToken);
		final Name s2aName = group1Name.addName(s2aIdentifierToken);
		
		final Vector<Type> supertypes = new Vector<>();
		supertypes.add(TypeProxy.create(null, ByNameState.create(UnqualifiedName.create(s1aIdentifierToken))));
		supertypes.add(TypeProxy.create(null, ByNameState.create(UnqualifiedName.create(s2aIdentifierToken))));
		
		final ClassType s1aClass =
				RegularClassType.create(
						s1aName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						s1aIdentifierToken,
						
						new Vector<ClassType>());
		
		final ClassType s2aClass =
				RegularClassType.create(
						s2aName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						s2aIdentifierToken,
						
						new Vector<ClassType>());
		
		final ClassType aClass =
				RegularClassType.create(
						aName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						supertypes,
						new Vector<Operation>(),
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(s1aClass);
		group1Vector.add(s2aClass);
		group1Vector.add(aClass);
		
		final ProductType aProduct = ProductType.create(this.bracketOpenToken);

	public void testAttributeWithMapOnProductAsKey() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		final IdentifierToken nameIdentifier = IdentifierToken.create("name", Position.create("", 1, 1, 0));
		final IdentifierToken countIdentifier = IdentifierToken.create("count", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.bracketOpenToken);
		this.stream.add(nameIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.commaToken);
		this.stream.add(countIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.integerIdentifier);
		this.stream.add(this.bracketCloseToken);
		this.stream.add(this.arrowToken);

						+ "Attribute2:{String,Integer};};" + "Class2:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr2.size());
		final Iterator<Type> superTypesAttr2Iterator = supertypesAttr2.iterator();
		assertEquals(attr1Type, superTypesAttr2Iterator.next());
		
		assertEquals(1, model.getInteger().getPrototype().getSuperTypes().size());
		assertEquals(

		this.stream.add(trueIdentifier);
		this.stream.add(this.commaToken);
		this.stream.add(falseIdentifier);
		this.stream.add(this.curlyBracketCloseToken);
		this.stream.add(this.squareBracketCloseToken);
		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(EndToken.create(Position.create("", 1, 1, 0)));
		
		final Model model = Model.create(groupIdentifier);
		final Vector<GroupElement> groupVector = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		model.addGroup(group);
		
		final Name className = groupName.addName(classIdentifier);
		final Collection<Attribute> attributes = new Vector<>();
		final ClassType clazz =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		groupVector.add(clazz);
		
		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy typeProxyString = TypeProxy.create(groupIdentifier, stringByName);
		
		final ByNameState trueByName = ByNameState.create(UnqualifiedName.create(trueIdentifier));
		final TypeProxy typeProxyTrue = TypeProxy.create(groupIdentifier, trueByName);
		
		final ByNameState falseByName = ByNameState.create(UnqualifiedName.create(falseIdentifier));
		final TypeProxy typeProxyFalse = TypeProxy.create(groupIdentifier, falseByName);
		
		final ListType list = ListType.create(this.stringIdentifier, typeProxyString);

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		
		final Iterator<Type> iterator = model.getConstructorCallDependencies().keySet().iterator();
		while (iterator.hasNext()) {
			final Type current = iterator.next();
			
			switch (current.getTypeString()) {
			case "group1>A":
				assertTrue(true);
				assertEquals(0, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>B":
				final Iterator<Type> bIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", bIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>C":
				final Iterator<Type> cIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", cIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>D":
				final Iterator<Type> dIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", dIterator.next().toString());
				assertEquals("group1>B", dIterator.next().toString());
				assertEquals("group1>C", dIterator.next().toString());
				assertEquals(3, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>E":
				final Iterator<Type> eIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>D", eIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());

				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[Class:class={Attribute1:{String,Integer}; Attribute2:{String};};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testNormalContainsInheritance() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[Class:class={Attribute1:{String,Integer,Class}; "
						+ "Attribute2:{String,Integer};};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertTrue(attr1Type == model.getAnything().getPrototype());
		assertEquals(0, supertypesAttr1.size());
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr2.size());
		final Iterator<Type> superTypesAttr2Iterator = supertypesAttr2.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr2Iterator.next()));
		
		assertEquals(1, model.getInteger().getPrototype().getSuperTypes().size());

		final Model model = instance.getModelFromString(input);
		
		// -- should be one group --//
		final Collection<Group> groups = model.getGroups();
		assertEquals(1, groups.size());
		
		// -- should be three groupElements --//
		final Group group1 = groups.iterator().next();
		final Collection<GroupElement> groupElements = group1.getGroupElements();
		assertEquals(3, groupElements.size());
		final Iterator<GroupElement> iterator = groupElements.iterator();
		
		// -- first groupElement should have one attribute --//
		iterator.next().accept(new GroupElementVisitor() {
			
			@Override
			public void handle(final Group group) {
				fail();
			}
			
			@Override
			public void handle(final ClassType clss) {
				assertEquals(1, clss.getAttributes().size());
				assertEquals(0, clss.getOperations().size());
				assertEquals(1, clss.getModifiers().size());
			}
		});
		
		// -- second groupElement should have no attribute --//
		iterator.next().accept(new GroupElementVisitor() {
			
			@Override
			public void handle(final Group group) {
				fail();
			}
			
			@Override
			public void handle(final ClassType clss) {
				assertEquals(0, clss.getAttributes().size());
				assertEquals(0, clss.getOperations().size());
				assertEquals(0, clss.getModifiers().size());
			}
		});
		
		// -- third groupElement should have one attribute --//
		iterator.next().accept(new GroupElementVisitor() {
			
			@Override
			public void handle(final Group group) {
				fail();
			}
			
			@Override
			public void handle(final ClassType clss) {
				assertEquals(1, clss.getAttributes().size());
				assertEquals(0, clss.getOperations().size());
				assertEquals(0, clss.getModifiers().size());
			}
		});
	}
	
	/**
	 * Tests the scanning, parsing, referencing and checks of a model-file.
	 * 
	 * @throws Exception
	 *             {@link java.io.FileNotFoundException}, {@link java.io.IOException}, {@link MultipleCheckExceptions},
	 *             {@link de.fhdw.wtf.common.exception.walker.CyclicDependencyException}, {@link InterruptedException},
	 *             {@link de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException},
	 *             {@link java.util.concurrent.ExecutionException}
	 */
	@Test
	public void testSimpleModelFromFile() 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.semicolonToken);

				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{A,B,C}; Attribute2:{A,B}; Attribute3:{B,C}; Attribute4:{A,C};}; B:class=A+{};
	 * C:class=A+{}; Class:class={};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testNormalContainsInheritance3() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{A,B,C}; Attribute2:{A,B}; Attribute3:{B,C}; "
						+ "Attribute4:{A,C};}; B:class={}; C:class={}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		final Attribute attr3 = attrIterator.next();
		final Attribute attr4 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr2.size());

		this.stream.add(this.squareBracketCloseToken);
		this.stream.add(this.arrowToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.squareBracketCloseToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final ProductElementType nameElement = ProductElementType.create("name", stringType, nameIdentifier);
		final ProductElementType countElement = ProductElementType.create("count", integerType, countIdentifier);
		final ProductType product = ProductType.create(this.bracketOpenToken);
		product.addElement(nameElement);
		product.addElement(countElement);
		
		final MapType mapKey = MapType.create(this.bracketOpenToken, product, integerType);

		final SimpleScannerInput input = new SimpleScannerInput("Group1:group=[A:class={();op:[[(s:String)->{}]];};];");
		final VerboseTokenStream output = new VerboseTokenStream(SimpleTokenStream.create());
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		
		final IdentifierToken group1IdentifierToken = IdentifierToken.create("Group1", Position.create("", 1, 1, 0));
		final IdentifierToken aIdentifierToken = IdentifierToken.create("A", Position.create("", 1, 1, 0));
		final IdentifierToken sParameterIdentifierToken = IdentifierToken.create("s", Position.create("", 1, 1, 1));
		final IdentifierToken op = IdentifierToken.create("op", Position.create("", 1, 1, 0));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		final Vector<Operation> operations = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		
		final ClassType aClass =
				RegularClassType.create(
						aName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						operations,
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(aClass);
		
		final ProductType aProduct = ProductType.create(this.bracketOpenToken);
		final ProductType sProduct = ProductType.create(this.bracketOpenToken);
		
		final ByNameState stringName = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		
		final TypeProxy stringTypeProxy = TypeProxy.create(this.stringIdentifier, stringName);
		
		sProduct.addElement(ProductElementType.create("s", stringTypeProxy, sParameterIdentifierToken));

	public void testContainsInheritanceOverClassInheritanceAndSumSupertypeIsAnClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{B,C};}; "
						+ "B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		
		final Collection<Type> expectedSupertypes = new ArrayList<>();
		expectedSupertypes.add(attr1Type);
		expectedSupertypes.add(clss);

								+ "operation : [[(param1:String,param2:Integer) -> String ]];}; ];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		Model model = null;
		model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final SimpleWalkerTask doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
		final GroupDependencyTask doubleChecks = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask overloadingCheck = OverloadingCheck.create(model, taskmanager);
		doubleChecks.addMembers(doubleGroupcomponent, doubleAttributenameCheck);
		referencer.addDependency(doubleChecks);
		cyclicInheritance.addDependency(referencer);
		subtypesFillTask.addDependency(cyclicInheritance);
		prototypesTask.addDependency(subtypesFillTask);
		overloadingCheck.addDependency(prototypesTask);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(8, okResult.size());
		assertEquals(0, failResult.size());
	}

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		final Group group = model.getGroups().iterator().next();
		final ClassType klasse = (ClassType) group.getGroupElements().iterator().next();
		final SumType sum = (SumType) klasse.getAttributes().iterator().next().getAttrType();
		
		final List<Type> standardizeElements = sum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});
		
		assertEquals(1, standardizeElements.size());
		assertEquals(sum.getElements().get(3), standardizeElements.iterator().next());

		this.stream.add(this.bracketCloseToken);
		this.stream.add(this.squareBracketCloseToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final ProductElementType nameElement = ProductElementType.create("name", stringType, nameIdentifier);
		final ProductElementType countElement = ProductElementType.create("count", integerType, countIdentifier);
		final ProductType product = ProductType.create(this.bracketOpenToken);
		product.addElement(nameElement);
		product.addElement(countElement);
		
		final MapType map = MapType.create(this.stringIdentifier, stringType, product);

		this.stream.add(this.bracketCloseToken);
		this.stream.add(this.arrowToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(trueIdentifier);
		this.stream.add(this.commaToken);
		this.stream.add(falseIdentifier);
		this.stream.add(this.curlyBracketCloseToken);
		this.stream.add(this.squareBracketCloseToken);
		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(EndToken.create(Position.create("", 1, 1, 0)));
		
		final Model model = Model.create(groupIdentifier);
		final Vector<GroupElement> groupVector = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		model.addGroup(group);
		
		final Name className = groupName.addName(classIdentifier);
		final Collection<Attribute> attributes = new Vector<>();
		final ClassType clazz =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		groupVector.add(clazz);
		
		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy typeProxyString = TypeProxy.create(groupIdentifier, stringByName);
		
		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		final Group group = model.getGroups().iterator().next();
		final ClassType klasse = (ClassType) group.getGroupElements().iterator().next();
		final SumType sum = (SumType) klasse.getAttributes().iterator().next().getAttrType();
		
		final List<Type> standardizeElements = sum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});
		
		assertEquals(1, standardizeElements.size());
		assertEquals(sum.getElements().iterator().next(), standardizeElements.iterator().next());

	public void testNoArrowException() {
		this.stream = SimpleTokenStream.create();
		this.parser = Parser.create(this.stream);
		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);

						+ "A:class={();}; B:class=A+{()=A();};];";
		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		final Group group = model.getGroups().iterator().next();
		final ClassType klasse = (ClassType) group.getGroupElements().iterator().next();
		final SumType sum = (SumType) klasse.getAttributes().iterator().next().getAttrType();
		
		final List<Type> standardizeElements = sum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});
		
		assertEquals(2, standardizeElements.size());
	}
	
	/**
	 * A > B. {[Integer->A],[Integer->B]} => {[Integer->A],[Integer->B]}
	 * 
	 * @throws Exception
	 *             {@link de.fhdw.wtf.common.exception.parser.SumIsAnythingException},
	 *             {@link de.fhdw.wtf.common.exception.editor.MultipleCheckExceptions},
	 *             {@link de.fhdw.wtf.common.exception.walker.CyclicDependencyException}, {@link InterruptedException},
	 *             {@link de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException},
	 *             {@link java.util.concurrent.ExecutionException}
	 */
	@Test
	public void testMap3() throws Exception {

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		final Group group = model.getGroups().iterator().next();
		final ClassType klasse = (ClassType) group.getGroupElements().iterator().next();
		final SumType sum = (SumType) klasse.getAttributes().iterator().next().getAttrType();
		
		final List<Type> standardizeElements = sum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});
		
		assertEquals(2, standardizeElements.size());
	}
	
	/**
	 * A > B und A > C. {{A,B},C} => {A}
	 * 
	 * @throws Exception
	 *             {@link de.fhdw.wtf.common.exception.parser.SumIsAnythingException},
	 *             {@link de.fhdw.wtf.common.exception.editor.MultipleCheckExceptions},
	 *             {@link de.fhdw.wtf.common.exception.walker.CyclicDependencyException}, {@link InterruptedException},
	 *             {@link de.fhdw.wtf.common.exception.walker.CyclicPartDefinitionException},
	 *             {@link java.util.concurrent.ExecutionException}
	 */
	@Test
	public void testSum1() throws Exception {

						+ "Attribute2:{String,Integer};};" + "Class2:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr2.size());
		final Iterator<Type> superTypesAttr2Iterator = supertypesAttr2.iterator();
		assertEquals(attr1Type, superTypesAttr2Iterator.next());

		this.stream.add(this.bracketCloseToken);
		this.stream.add(this.squareBracketCloseToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final ProductElementType nameElement = ProductElementType.create("name", stringType, nameIdentifier);
		final ProductElementType countElement = ProductElementType.create("count", integerType, countIdentifier);
		final ProductType product = ProductType.create(this.bracketOpenToken);
		product.addElement(nameElement);
		product.addElement(countElement);
		
		final MapType map = MapType.create(this.stringIdentifier, stringType, product);

				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{B,C};}; B:class=A+{}; C:class=A+{};
	 * Class:class={};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testContainsInheritanceOverClassInheritanceAndSumSupertypeIsAnClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{B,C};}; "
						+ "B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();

				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{C,D,E};}; B:class=A+{}; C:class=A+{};
	 * Class:class={}; D:class=B+{}; E:class=B+{};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testSumSupertypeIsAnClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{B,C};}; "
						+ "B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();

		this.stream.add(this.bracketCloseToken);
		this.stream.add(this.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final ProductElementType nameElement = ProductElementType.create("name", stringType, nameIdentifier);
		final ProductElementType countElement = ProductElementType.create("count", integerType, countIdentifier);
		final ProductType product = ProductType.create(this.bracketOpenToken);
		product.addElement(nameElement);
		product.addElement(countElement);
		
		final ListType list = ListType.create(this.bracketOpenToken, product);

		this.stream.add(this.squareBracketCloseToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final ProductElementType nameElement = ProductElementType.create("name", stringType, nameIdentifier);
		final ProductElementType countElement = ProductElementType.create("count", integerType, countIdentifier);
		final ProductType product = ProductType.create(this.bracketOpenToken);
		product.addElement(nameElement);
		product.addElement(countElement);
		
		final MapType map = MapType.create(this.stringIdentifier, stringType, product);

	public void testNoBracketCloseExceptionAttribute() {
		this.stream = SimpleTokenStream.create();
		this.parser = Parser.create(this.stream);
		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
		final IdentifierToken myClass = IdentifierToken.create("MyClass", Position.create("", 1, 1, 0));
		final IdentifierToken myAttribute = IdentifierToken.create("MyAttribute", Position.create("", 1, 1, 0));
		final IdentifierToken name = IdentifierToken.create("name", 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(myAttribute);
		this.stream.add(this.colonToken);
		this.stream.add(this.bracketOpenToken);
		this.stream.add(name);
		this.stream.add(this.colonToken);
		this.stream.add(string);
		this.stream.add(this.semicolonToken);

								+ "NaturalPerson:class=Person+{}; CorporateBody:class=Person+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		cyclicInheritance.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<OKTaskResult>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<ExceptionalTaskResult>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());
		assertEquals(1, failResult.size());
		
		final Exception exception = failResult.iterator().next().getError();
		if (exception instanceof CyclicInheritanceException) {
			final CyclicInheritanceException ex = (CyclicInheritanceException) exception;
			assertEquals(Position.create("", 1, 116, 115), ex.getStartPosition());
			assertEquals(Position.create("", 1, 122, 121), ex.getEndPos());
		} else {
			fail();
		}
	}
	
	@Test
	public void testCyclicInheritanceOverMoreClassesInSecondSupertype() throws InterruptedException,

						+ "NaturalPerson:class=Person+{}; CorporateBody:class=Person+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		cyclicInheritance.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<OKTaskResult>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<ExceptionalTaskResult>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());
		assertEquals(1, failResult.size());
		
		final Exception exception = failResult.iterator().next().getError();
		if (exception instanceof CyclicInheritanceException) {
			final CyclicInheritanceException ex = (CyclicInheritanceException) exception;
			assertEquals(Position.create("", 1, 92, 91), ex.getStartPosition());
			assertEquals(Position.create("", 1, 98, 97), ex.getEndPos());
		} else {
			fail();
		}
	}
	
	@Test
	public void testInvalidTypeReference() throws InterruptedException, ExecutionException,

	public void testContainsInheritanceOverClassInheritanceAndSumSupertypeIsAnClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{B,C};}; "
						+ "B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();

	public void testSumSupertypeIsAnClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{B,C};}; "
						+ "B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();

				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{}; Attribute2:{String,A}; Attribute3:{Integer,String};}; B:class=A+{};
	 * C:class=A+{}; Class:class={};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testEmptySum() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput(" Group:group=[A:class={Attribute1:{}; Attribute2:{String,A}; "
						+ "Attribute3:{Integer,String};}; B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		final ClassType clssC = (ClassType) iterator.next();
		final ClassType clssClass = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		final Attribute attr3 = attrIterator.next();
		
		final Type attr2Type = ((SumType) attr2.getAttrType()).getPrototype();
		final Type attr3Type = ((SumType) attr3.getAttrType()).getPrototype();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		final Group group = model.getGroups().iterator().next();
		final ClassType klasse = (ClassType) group.getGroupElements().iterator().next();
		final SumType sum = (SumType) klasse.getAttributes().iterator().next().getAttrType();
		
		final List<Type> standardizeElements = sum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});
		
		assertEquals(1, standardizeElements.size());

		this.stream.add(this.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final ProductElementType nameElement = ProductElementType.create("name", stringType, nameIdentifier);
		final ProductElementType countElement = ProductElementType.create("count", integerType, countIdentifier);
		final ProductType product = ProductType.create(this.bracketOpenToken);
		product.addElement(nameElement);
		product.addElement(countElement);
		
		final MapType map = MapType.create(this.bracketOpenToken, product, integerType);

		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(HyphenToken.create(Position.createDummyPosition()));

		this.stream.add(this.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final ProductElementType nameElement = ProductElementType.create("name", stringType, nameIdentifier);
		final ProductElementType countElement = ProductElementType.create("count", integerType, countIdentifier);
		final ProductType product = ProductType.create(this.bracketOpenToken);
		product.addElement(nameElement);
		product.addElement(countElement);
		
		final ListType list = ListType.create(this.bracketOpenToken, product);

		final SimpleScannerInput input = new SimpleScannerInput(stringInput);
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final Vector<GroupElement> groupVector = new Vector<>();
		final Vector<Attribute> attributes = new Vector<>();
		final Vector<ClassModifier> modifiers = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType clazz =
				RegularClassType.create(
						className,
						modifiers,
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
		final TypeProxy typeProxyInteger = TypeProxy.create(integerIdentifier, integerByName);
		
		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(stringIdentifier));
		final TypeProxy typeProxyString = TypeProxy.create(stringIdentifier, stringByName);
		
		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(testIdentifier));
		final TypeProxy typeProxyTest = TypeProxy.create(testIdentifier, testByName);
		
		final SumType sum1 = SumType.create(this.curlyBracketOpenToken);
		sum1.add(typeProxyInteger);
		sum1.add(typeProxyString);

						+ "attributeLong: Integer;" + "};" + "];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		
		referencer.addDependency(doubleGroupcomponent);
		baseTypeInheritanceCheck.addDependency(referencer);
		cyclicInheritance.addDependency(referencer);
		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
		
		doubleAttributenameCheck.addDependency(inheritanceChecker);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(6, okResult.size());
		assertEquals(0, failResult.size());
	}
	
	/**
	 * "" + "group1:group=[" + "class1:class={" + "attributelong: Integer;" + "attribute: Integer;" + "};" + "];" .
	 * 
	 * @throws NoValidTokenStreamException
	 *             NoValidTokenStreamException
	 * @throws CyclicDependencyException
	 *             CyclicDependencyException
	 * @throws InterruptedException
	 *             InterruptedException
	 * @throws ExecutionException
	 *             ExecutionException
	 * @throws CyclicPartDefinitionException
	 *             CyclicPartDefinitionException
	 */
	@Test
	public void testDoubleAttributename2() throws InterruptedException, ExecutionException,

		final ProductType productPrototyp = (ProductType) iterator2.next();
		
		expectedSupertypes = new ArrayList<>();
		final ProductType abstrProductCreated = ProductType.create(DummyToken.getInstance(), DummyToken.getInstance());
		ByReferenceState state = ByReferenceState.create(model.getString(), model.getString().getTypeName());
		TypeProxy typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$1", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(model.getInteger(), model.getInteger().getTypeName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$2", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(clssB, clssB.getName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$3", typeProxy, DummyToken.getInstance()));
		final ByReferenceState state2 = ByReferenceState.create(clss, clss.getName());
		final TypeProxy typeProxy2 = TypeProxy.create(DummyToken.getInstance(), state2);
		abstrProductCreated.addElement(ProductElementType.create("p$4", typeProxy2, DummyToken.getInstance()));
		expectedSupertypes.add(abstrProductCreated);
		expectedSupertypes.add(sum);
		expectedSupertypes.add(model.getAnything().getPrototype());
		
		this.checkSupertypes(expectedSupertypes, productPrototyp.getSuperTypes());

		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.arrowToken);

						+ "attributeLong: Integer;" + "};" + "];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		
		referencer.addDependency(doubleGroupcomponent);
		baseTypeInheritanceCheck.addDependency(referencer);
		cyclicInheritance.addDependency(referencer);
		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
		
		doubleAttributenameCheck.addDependency(inheritanceChecker);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(6, okResult.size());
		assertEquals(0, failResult.size());
	}
	
	/**
	 * "" + "group1:group=[" + "class1:class={" + "attributelong: Integer;" + "attribute: Integer;" + "};" + "];" .
	 * 
	 * @throws NoValidTokenStreamException
	 *             NoValidTokenStreamException
	 * @throws CyclicDependencyException
	 *             CyclicDependencyException
	 * @throws InterruptedException
	 *             InterruptedException
	 * @throws ExecutionException
	 *             ExecutionException
	 * @throws CyclicPartDefinitionException
	 *             CyclicPartDefinitionException
	 */
	@Test
	public void testDoubleAttributename2() throws InterruptedException, ExecutionException,

						+ "class2:class={" + "attribute: Integer;" + "};" + "];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		
		referencer.addDependency(doubleGroupcomponent);
		cyclicInheritance.addDependency(referencer);
		baseTypeInheritanceCheck.addDependency(referencer);
		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
		
		doubleAttributenameCheck.addDependency(inheritanceChecker);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(6, okResult.size());
		assertEquals(0, failResult.size());
	}
	
	/**
	 * group1:group=[class1:class=class2+{attribute: Integer;};class2:class={attribute: Integer;};]; .
	 * 
	 * @throws NoValidTokenStreamException
	 *             NoValidTokenStreamException
	 * @throws CyclicDependencyException
	 *             CyclicDependencyException
	 * @throws InterruptedException
	 *             InterruptedException
	 * @throws ExecutionException
	 *             ExecutionException
	 * @throws CyclicPartDefinitionException
	 *             CyclicPartDefinitionException
	 */
	@Test
	public void testDoubleAttributenameInInheritance1() throws InterruptedException, ExecutionException,

						+ "B:class=A+{}; C:class=A+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final ClassType clss = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		final Iterator<Attribute> attrIterator = clss.getAttributes().iterator();
		final Attribute attr1 = attrIterator.next();
		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr2.size());

						+ "class2:class={" + "attribute: Integer;" + "};" + "];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		
		referencer.addDependency(doubleGroupcomponent);
		cyclicInheritance.addDependency(referencer);
		baseTypeInheritanceCheck.addDependency(referencer);
		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
		
		doubleAttributenameCheck.addDependency(inheritanceChecker);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(6, okResult.size());
		assertEquals(0, failResult.size());
	}

	public void testNoArrowException() {
		this.stream = SimpleTokenStream.create();
		this.parser = Parser.create(this.stream);
		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(this.integerIdentifier);
		this.stream.add(this.arrowToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.squareBracketCloseToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final MapType map = MapType.create(this.integerIdentifier, integerType, stringType);

		final SimpleScannerInput input = new SimpleScannerInput("personGroup:group=[Person:class=Integer+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		baseTypeInheritanceCheck.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());
		assertEquals(1, failResult.size());
		
		final Exception exception = failResult.iterator().next().getError();
		if (exception instanceof BaseTypeInheritanceException) {
			final BaseTypeInheritanceException ex = (BaseTypeInheritanceException) exception;
			assertEquals(Position.create("", 1, 33, 32), ex.getStartPosition());
			assertEquals(Position.create("", 1, 40, 39), ex.getEndPos());

	public void testAttributeWithListOfMap() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.integerIdentifier);
		this.stream.add(this.arrowToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.squareBracketCloseToken);
		this.stream.add(this.asteriskToken);
		this.stream.add(this.semicolonToken);
		this.stream.add(this.curlyBracketCloseToken);

		this.stream.add(PriorToken.create(Position.create("", 0 + 1, 0 + 1, 0)));
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState attributeReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy type = TypeProxy.create(this.stringIdentifier, attributeReferenceState);
		
		final Vector<AttributeModifier> modifiers = new Vector<>();
		modifiers.add(AttributeModifierPrior.create(PriorToken.create(Position.create("", 0, 0, 0))));

	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);

		actualSum.add(TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(a))));
		actualSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b)))));
		
		final List<Type> standardizeElements = actualSum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});
		
		// Prepare Expected
		final SumType expectedSum = SumType.create(dummyToken);
		expectedSum.add(TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(a))));

						+ "attribute: Integer;" + "};" + "];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		
		referencer.addDependency(doubleGroupcomponent);
		cyclicInheritance.addDependency(referencer);
		baseTypeInheritanceCheck.addDependency(referencer);
		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
		
		doubleAttributenameCheck.addDependency(inheritanceChecker);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(5, okResult.size());

		final ProductType productPrototyp = (ProductType) iterator2.next();
		
		expectedSupertypes = new ArrayList<>();
		final ProductType abstrProductCreated = ProductType.create(DummyToken.getInstance(), DummyToken.getInstance());
		ByReferenceState state = ByReferenceState.create(model.getString(), model.getString().getTypeName());
		TypeProxy typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$1", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(model.getInteger(), model.getInteger().getTypeName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$2", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(clssB, clssB.getName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$3", typeProxy, DummyToken.getInstance()));
		final ByReferenceState state2 = ByReferenceState.create(clss, clss.getName());
		final TypeProxy typeProxy2 = TypeProxy.create(DummyToken.getInstance(), state2);
		abstrProductCreated.addElement(ProductElementType.create("p$4", typeProxy2, DummyToken.getInstance()));
		expectedSupertypes.add(abstrProductCreated);
		expectedSupertypes.add(sum);

		final ProductType productPrototyp2 = (ProductType) iterator2.next();
		
		expectedSupertypes = new ArrayList<>();
		final ProductType abstrProductCreated = ProductType.create(DummyToken.getInstance(), DummyToken.getInstance());
		ByReferenceState state = ByReferenceState.create(model.getString(), model.getString().getTypeName());
		TypeProxy typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$1", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(model.getInteger(), model.getInteger().getTypeName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$2", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(clssB, clssB.getName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$3", typeProxy, DummyToken.getInstance()));
		final ByReferenceState state2 = ByReferenceState.create(clss, clss.getName());
		final TypeProxy typeProxy2 = TypeProxy.create(DummyToken.getInstance(), state2);
		abstrProductCreated.addElement(ProductElementType.create("p$4", typeProxy2, DummyToken.getInstance()));
		expectedSupertypes.add(abstrProductCreated);
		expectedSupertypes.add(sum);

		this.stream.add(this.stringIdentifier);
		this.stream.add(this.squareBracketCloseToken);
		this.stream.add(this.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final MapType map = MapType.create(this.integerIdentifier, integerType, stringType);

								+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		iterator.next();
		iterator.next();
		final ClassType clss = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		// Summe
		assertEquals(0, attr1.getAttrType().getSuperTypes().size());
		final Type attr1Type = attr1.getAttrType().getPrototype();
		final Collection<Type> supertypesAttr1 = attr1Type.getSuperTypes();
		
		Collection<Type> expectedSupertypes = new ArrayList<>();
		expectedSupertypes.add(model.getAnything().getPrototype());
		
		this.checkSupertypes(expectedSupertypes, supertypesAttr1);
		
		// Product
		final SumType sum = (SumType) attr1Type;
		final Iterator<Type> iterator2 = sum.getElements().iterator();

		class21SuperTypes.add(class21SuperTypeReference);
		final ByReferenceState class211AttributeTypeReferenceState =
				ByReferenceState.create(class121, class121.getTypeName());
		final TypeProxy class211AttributeTypeReference =
				TypeProxy.create(class121IdentifierToken, class211AttributeTypeReferenceState);
		final IdentifierToken class211AttributeTypeIdentifier =
				IdentifierToken.create("", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken class211AttributeIdentifier =
				IdentifierToken.create("classa", Position.create("", 0 + 1, 0 + 1, 0));
		final Attribute class211Attribute =
				Attribute.create(
						"classa",
						class211AttributeTypeReference,
						new Vector<AttributeModifier>(),
						class211AttributeIdentifier);
		class211Attributes.add(class211Attribute);
		final IdentifierToken group211IdentifierToken =
				IdentifierToken.create("Group1", Position.create("", 0 + 1, 0 + 1, 0));
		final Name group211Name = group21Name.addName(group211IdentifierToken);
		final Collection<GroupElement> group211Elements = new Vector<>();
		final Group group211 = Group.create(group211Name, group211Elements, group211IdentifierToken);
		group21Elements.add(group211);
		final IdentifierToken class2111IdentifierToken =
				IdentifierToken.create("Class1", Position.create("", 0 + 1, 0 + 1, 0));
		final Name class2111Name = group211Name.addName(class2111IdentifierToken);
		final Collection<ClassModifier> class2111Modifiers = new Vector<>();
		final Collection<Attribute> class2111Attributes = new Vector<>();
		final List<Type> class2111SuperTypes = new Vector<>();
		final Collection<Operation> class2111Operations = new Vector<>();

		this.stream.add(this.squareBracketCloseToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState stringReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, stringReferenceState);
		final ByNameState integerReferenceState = ByNameState.create(UnqualifiedName.create(this.integerIdentifier));
		final TypeProxy integerType = TypeProxy.create(this.integerIdentifier, integerReferenceState);
		
		final MapType map = MapType.create(this.integerIdentifier, integerType, stringType);
		
		final Attribute attribute =

	public void testAttributeWithMapOnProduct() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		final IdentifierToken nameIdentifier = IdentifierToken.create("name", Position.create("", 1, 1, 0));
		final IdentifierToken countIdentifier = IdentifierToken.create("count", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.stringIdentifier);

						+ "NaturalPerson:class=Person+{}; CorporateBody:class=Person+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		cyclicInheritance.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<OKTaskResult>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<ExceptionalTaskResult>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());
		assertEquals(1, failResult.size());
		
		final Exception exception = failResult.iterator().next().getError();
		if (exception instanceof CyclicInheritanceException) {
			final CyclicInheritanceException ex = (CyclicInheritanceException) exception;
			assertEquals(Position.create("", 1, 92, 91), ex.getStartPosition());

	public void testAttributeWithListOnProduct() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		final IdentifierToken nameIdentifier = IdentifierToken.create("name", Position.create("", 1, 1, 0));
		final IdentifierToken countIdentifier = IdentifierToken.create("count", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.bracketOpenToken);
		this.stream.add(nameIdentifier);

	public void testAttributeMap() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.integerIdentifier);
		this.stream.add(this.arrowToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.squareBracketCloseToken);
		this.stream.add(this.semicolonToken);

		final Collection<Type> expectedSupertypes = new ArrayList<>();
		final ProductType abstrProductCreated = ProductType.create(DummyToken.getInstance(), DummyToken.getInstance());
		ByReferenceState state = ByReferenceState.create(model.getString(), model.getString().getTypeName());
		TypeProxy typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$1", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(model.getInteger(), model.getInteger().getTypeName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$2", typeProxy, DummyToken.getInstance()));
		state = ByReferenceState.create(clssB, clssB.getName());
		typeProxy = TypeProxy.create(DummyToken.getInstance(), state);
		abstrProductCreated.addElement(ProductElementType.create("p$3", typeProxy, DummyToken.getInstance()));
		final ByReferenceState state2 = ByReferenceState.create(clss, clss.getName());
		final TypeProxy typeProxy2 = TypeProxy.create(DummyToken.getInstance(), state2);
		abstrProductCreated.addElement(ProductElementType.create("p$4", typeProxy2, DummyToken.getInstance()));
		expectedSupertypes.add(abstrProductCreated);

		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(myParameter);

		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));

						"group1 : group = [ class1 : class = {map : [String->Integer];} visitable abstract;];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final Vector<GroupElement> groupVector = new Vector<>();
		final Vector<Attribute> attributes = new Vector<>();
		final Vector<ClassModifier> modifiers = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType clazz =
				RegularClassType.create(
						className,
						modifiers,
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState integerByName = ByNameState.create(UnqualifiedName.create(integerIdentifier));
		final TypeProxy typeProxyInteger = TypeProxy.create(integerIdentifier, integerByName);
		
		final ByNameState stringByName = ByNameState.create(UnqualifiedName.create(stringIdentifier));
		final TypeProxy typeProxyString = TypeProxy.create(stringIdentifier, stringByName);
		final MapType map = MapType.create(mapIdentifier, typeProxyString, typeProxyInteger);

	public void testAttributeWithModifier() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken attributeIdentifier =
				IdentifierToken.create("Attribute", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(PriorToken.create(Position.create("", 0 + 1, 0 + 1, 0)));
		this.stream.add(this.semicolonToken);

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		
		final Iterator<Type> iterator = model.getConstructorCallDependencies().keySet().iterator();
		while (iterator.hasNext()) {
			final Type current = iterator.next();
			
			switch (current.getTypeString()) {
			case "group1>A":
				assertTrue(true);
				assertEquals(0, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>B":
				final Iterator<Type> bIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", bIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>C":
				final Iterator<Type> cIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", cIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>D":
				final Iterator<Type> aIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", aIterator.next().toString());
				assertEquals("group1>B", aIterator.next().toString());

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		
		final Iterator<Type> iterator = model.getConstructorCallDependencies().keySet().iterator();
		while (iterator.hasNext()) {
			final Type current = iterator.next();
			
			switch (current.getTypeString()) {
			case "group1>A":
				assertTrue(true);
				assertEquals(0, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>B":
				final Iterator<Type> bIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", bIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>C":
				final Iterator<Type> cIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", cIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>D":
				final Iterator<Type> dIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", dIterator.next().toString());
				assertEquals("group1>B", dIterator.next().toString());

	public void testAttributeWithMoreListsOnSum() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		final IdentifierToken trueIdentifier = IdentifierToken.create("true", Position.create("", 1, 1, 0));
		final IdentifierToken falseIdentifier = IdentifierToken.create("false", Position.create("", 1, 1, 0));
		
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.curlyBracketOpenToken);

	public void testAttributeWithModifier() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken attributeIdentifier =
				IdentifierToken.create("Attribute", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(PriorToken.create(Position.create("", 0 + 1, 0 + 1, 0)));
		this.stream.add(this.semicolonToken);

						new Vector<Type>(),
						operations,
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(aClass);
		
		final ProductType aProduct = ProductType.create(this.bracketOpenToken);
		final ProductType sProduct = ProductType.create(this.bracketOpenToken);
		
		final ByNameState attributeStringReferenceState =
				ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, attributeStringReferenceState);
		
		attributes.add(Attribute.create("s", stringType, new Vector<AttributeModifier>(), sIdentifierToken));
		sProduct.addElement(ProductElementType.create("s", stringType, sIdentifierToken));
		constructors.add(Constructor.create(aProduct, aClass, new Vector<ConstructorReference>(), aIdentifierToken));
		
		final Operation operation =
				Operation.create(
						"op",
						new Vector<OperationModifier>(),
						sProduct,
						aClass,
						SumType.create(this.curlyBracketOpenToken),
						op);
		operations.add(operation);
		
		final Model expected = Model.create(group1IdentifierToken);
		expected.addGroup(group1);
		
		this.parser = Parser.create(output);
		final Model actual = this.parser.parse();
		
		assertEquals(0, this.parser.getExceptions().size());
		assertEquals(expected, actual);
	}
	
	/**
	 * Group1:group=[SA:class={};A:class=SA+{();op:[[(s:String)->{}]];s:String;};];.
	 * 
	 * @throws Exception
	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}
	 */
	@Test
	public void testConstructorWithoutParameterAndSuperclassWithoutParameter() throws Exception {

		product1.addElement(element13);
		
		final ProductType product2 = ProductType.create(this.bracketOpenToken);
		final ProductElementType element21 =
				ProductElementType.create(
						"int3",
						typeProxyInteger,
						IdentifierToken.create("int3", Position.create("", 1, 1, 0)));
		final ProductElementType element22 =
				ProductElementType.create(
						"int4",
						typeProxyInteger,
						IdentifierToken.create("int4", Position.create("", 1, 1, 0)));
		product2.addElement(element21);
		product2.addElement(element22);
		
		final SumType sum = SumType.create(this.curlyBracketOpenToken);
		sum.add(product1);
		sum.add(typeProxyString);
		sum.add(product2);
		sum.add(typeProxyTest);
		
		final Attribute attribute =
				Attribute.create("attribute", sum, new Vector<AttributeModifier>(), attributeIdentifier);
		attributes.add(attribute);
		
		modifiers.add(ClassModifierService.create(VisitableToken.create(Position.create("", 1, 1, 0))));
		modifiers.add(ClassModifierTransient.create(AbstractToken.create(Position.create("", 1, 1, 0))));
		groupVector.add(clazz);
		final Model expected = Model.create(groupIdentifier);
		expected.addGroup(group);
		assertEquals(expected, model);
	}
	
	/**
	 * group1 : group = [ class1 : class = {attribute : {(sum:{Integer, String}, int42:Integer), String,
	 * (int3:Integer,int4:Integer), Test} ;} service transient;]; .
	 * 
	 * @throws Exception
	 */
	@Test
	public void testProductSum5() throws Exception {

				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b)))));
		
		final List<Type> standardizeElements = actualSum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});
		
		// Prepare Expected
		final SumType expectedSum = SumType.create(dummyToken);
		expectedSum.add(TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(a))));

		final Model model = SyntaxCheck.getInstance().getModelFromString(input);
		
		final Iterator<Type> iterator = model.getConstructorCallDependencies().keySet().iterator();
		while (iterator.hasNext()) {
			final Type current = iterator.next();
			
			switch (current.getTypeString()) {
			case "group1>A":
				assertTrue(true);
				assertEquals(0, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>B":
				final Iterator<Type> bIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", bIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>C":
				final Iterator<Type> cIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", cIterator.next().toString());
				assertEquals(1, model.getConstructorCallDependencies().get(current).size());
				break;
			case "group1>D":
				final Iterator<Type> dIterator = model.getConstructorCallDependencies().get(current).iterator();
				assertEquals("group1>A", dIterator.next().toString());

	public void testAttributeWithList() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken attributeIdentifier =
				IdentifierToken.create("Attribute", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.asteriskToken);
		this.stream.add(this.semicolonToken);

				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{C,D};}; B:class=A+{}; C:class=B+{}; D:class=B+{}; Class:class={};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testTransitiveInheritanceAndSumSupertypeIsClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{C,D};}; B:class=A+{}; C:class=B+{}; "
						+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();

	public void testOneAttribute() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken attributeIdentifier =
				IdentifierToken.create("Attribute", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.semicolonToken);

		this.stream.add(this.stringIdentifier);
		this.stream.add(this.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState attributeReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy attributeType = TypeProxy.create(this.stringIdentifier, attributeReferenceState);
		final ListType listType = ListType.create(this.stringIdentifier, attributeType);

	public void testOneAttribute() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken attributeIdentifier =
				IdentifierToken.create("Attribute", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.semicolonToken);

	public void testAttributeMap() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.integerIdentifier);
		this.stream.add(this.arrowToken);

								+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		iterator.next();
		iterator.next();
		final ClassType clss = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		// Summe
		assertEquals(0, attr1.getAttrType().getSuperTypes().size());
		final Type attr1Type = attr1.getAttrType().getPrototype();
		final Collection<Type> supertypesAttr1 = attr1Type.getSuperTypes();
		
		Collection<Type> expectedSupertypes = new ArrayList<>();

						+ "CorporateBody:class=Person+{}; group2:group=[Person:class={};];];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		cyclicInheritance.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<OKTaskResult>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<ExceptionalTaskResult>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(2, okResult.size());
		assertEquals(0, failResult.size());
	}

		final List<Type> standardizeElements = sum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});

		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(myOperation);

		final List<Type> standardizeElements = sum.standardize().accept(new TypeVisitorReturn<List<Type>>() {
			
			@Override
			public List<Type> handle(final AtomicType atomicType) {
				return new ArrayList<>();
			}
			
			@Override
			public List<Type> handle(final CompositeType compositeType) {
				return compositeType.accept(new CompositeTypeVisitorReturn<List<Type>>() {
					
					@Override
					public List<Type> handle(final ListType list) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final MapType map) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final ProductType product) {
						return new ArrayList<>();
					}
					
					@Override
					public List<Type> handle(final SumType sum2) {
						return sum2.getElements();
					}
					
					@Override
					public List<Type> handle(final ThrownType thrownType) {
						return new ArrayList<>();
					}
				});
			}
			
			@Override
			public List<Type> handle(final TypeProxy typeProxy) {
				return new ArrayList<>();
			}
		});

	public void testOneAttribute() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken attributeIdentifier =
				IdentifierToken.create("Attribute", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);

		final SimpleScannerInput input = new SimpleScannerInput("personGroup:group=[Person:class=Anything+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		baseTypeInheritanceCheck.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(2, okResult.size());
		assertEquals(0, failResult.size());
	}

	public void testTransitiveInheritanceAndSumSupertypeIsClass() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{C,D};}; B:class=A+{}; C:class=B+{}; "
						+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();

	public void testTransitiveInheritanceAndSumSupertypeIsClass3() throws Exception {
		final SimpleScannerInput input =
				new SimpleScannerInput("Group:group=[A:class={Attribute1:{C,D};}; B:class=A+{}; C:class=B+{}; "
						+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();

		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));

		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);

								+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		iterator.next();
		iterator.next();
		final ClassType clss = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		assertEquals(0, attr1.getAttrType().getSuperTypes().size());
		final Type attr1Type = attr1.getAttrType().getPrototype();
		final Collection<Type> supertypesAttr1 = attr1Type.getSuperTypes();

		actualSum.add(TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(a))));
		actualSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b)))));
		
		final ThrownType thrownType = ThrownType.create(DummyToken.getInstance(), actualSum, DummyToken.getInstance());
		
		final Type standardizedType = thrownType.standardize();
		
		// Prepare Expected
		final SumType expectedSum = SumType.create(dummyToken);
		expectedSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(a)))));
		expectedSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b)))));
		
		// Test
		assertTrue(standardizedType instanceof SumType);
		final SumType sum = (SumType) standardizedType;
		assertEquals(2, sum.getElements().size());
		assertEquals(2, expectedSum.getElements().size());
		this.assertEqualsOnlists(sum.getElements(), expectedSum.getElements());
	}
	
	/**
	 * {B!,A}! => Result: {A!,B!}.
	 * 
	 * @throws SumIsAnythingException
	 *             If it contains Anything throw specified Exception
	 */
	@Test
	public void testThrownSumContainsOneThrownTypeSecondAndOneNormalThrownTypesAndDifferentOrder()

		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group1 = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType class1 =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						new Vector<ClassType>());
		
		final ByNameState attributeTypeReferenceState =

		this.stream.add(this.asteriskToken);
		this.stream.add(this.asteriskToken);
		this.stream.add(this.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState attributeReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));

				new SimpleScannerInput("group1 : group = [ class1 : class = {op : [[()->test]];} service transient;];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final Vector<GroupElement> groupVector = new Vector<>();
		final Vector<Operation> operations = new Vector<>();
		final Vector<ClassModifier> modifiers = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, GroupToken.create(Position.create("", 1, 1, 0)));
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType clazz =
				RegularClassType.create(
						className,
						modifiers,
						new Vector<Attribute>(),
						new Vector<Type>(),
						operations,
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ProductType product = ProductType.create(this.bracketOpenToken);
		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(test));

	public void testAttributeWithEmptyProduct() throws Exception {
		final IdentifierToken groupIdentifier = IdentifierToken.create("Group", Position.create("", 1, 1, 0));
		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.bracketOpenToken);

		final IdentifierToken countIdentifier = IdentifierToken.create("count", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.bracketOpenToken);
		this.stream.add(nameIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.commaToken);
		this.stream.add(countIdentifier);

						+ "NaturalPerson:class=Person+{}; CorporateBody:class=Person+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		cyclicInheritance.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<OKTaskResult>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<ExceptionalTaskResult>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(2, okResult.size());

						"Group:group=[Klasse:class={operation : [[(parameter1:Integer,parameter2:String) -> String ]];};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		Model model = null;
		model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		ProductCheck.create(model, taskmanager);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());
		assertEquals(0, failResult.size());
	}
	
	/**
	 * Group:group=[Klasse:class={operation : [[(parameter1:Integer,parameter2:String) -> String ]];};]; .
	 * 
	 * @throws InterruptedException
	 * @throws ExecutionException
	 * @throws NoValidTokenStreamException
	 * @throws CyclicDependencyException
	 */
	@Test
	public void testTwoDifferentNames2() throws InterruptedException, ExecutionException, NoValidTokenStreamException,

						+ "CorporateBody:class=Person+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		cyclicInheritance.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<OKTaskResult>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<ExceptionalTaskResult>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());

		final SimpleScannerInput input = new SimpleScannerInput("personGroup:group=[Person:class=Integer+{};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		baseTypeInheritanceCheck.addDependency(referencer);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());

						"Group:group=[Klasse:class={operation : [[(parameter1:Integer,parameter2:String) -> String ]];};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		Model model = null;
		model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		ProductCheck.create(model, taskmanager);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(1, okResult.size());
		assertEquals(0, failResult.size());
	}

		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr2.size());
		final Iterator<Type> superTypesAttr2Iterator = supertypesAttr2.iterator();
		assertEquals(clss, HelperUtils.getReferencedType(superTypesAttr2Iterator.next()));

		final Attribute attr2 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());
		final Type attr1Type = ((SumType) attr1.getAttrType()).getPrototype();
		final Collection<Type> supertypesAttr1 = ((SumType) attr1Type).getSuperTypes();
		assertEquals(1, supertypesAttr1.size());
		final Iterator<Type> superTypesAttr1Iterator = supertypesAttr1.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(0, ((SumType) attr2.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr2 =
				((SumType) ((SumType) attr2.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(2, supertypesAttr2.size());
		final Iterator<Type> superTypesAttr2Iterator = supertypesAttr2.iterator();
		assertEquals(attr1Type, superTypesAttr2Iterator.next());

		final SimpleScannerInput input = new SimpleScannerInput("Group:group=[Class:class={Attribute1:{Class};};];");
		final Model model = this.getModel(input);
		
		assertTrue(model.getString().getPrototype() == model.getString());
		assertTrue(model.getInteger().getPrototype() == model.getInteger());
		
		final ClassType cls = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		
		assertTrue(cls.getPrototype() == cls);
		
		final Iterator<Attribute> attributes = cls.getAttributes().iterator();
		final Attribute attribute1 = attributes.next();
		
		assertTrue(attribute1.getAttrType() instanceof SumType);
		final SumType sum = (SumType) attribute1.getAttrType();
		
		assertTrue(sum.getPrototype() == cls);
		// String,Integer,Class
		assertEquals(3, ((SumType) model.getAnything().getPrototype()).getElements().size());
	}
	
	/**
	 * Group:group=[Class:class={Attribute1:{{Class}};};]; .
	 * 
	 * @throws Exception
	 *             possible Exception
	 */
	@Test
	public void testSumWithOneElementAtBeginningOneSumWithOneClass() throws Exception {

		this.stream.add(this.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState attributeReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));

		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.asteriskToken);
		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<Attribute> attributes = new Vector<>();
		
		final Name groupName = UnqualifiedName.create(groupIdentifier);
		final Group group = Group.create(groupName, groupVector, groupIdentifier);
		
		final Name className = groupName.addName(classIdentifier);
		final ClassType classModel =
				RegularClassType.create(
						className,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						new Vector<Constructor>(),
						classIdentifier,
						
						new Vector<ClassType>());
		
		final ByNameState attributeReferenceState = ByNameState.create(UnqualifiedName.create(this.stringIdentifier));

		this.stream.add(this.equalToken);
		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 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);

		actualSum.add(TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b))));
		
		final ThrownType thrownType = ThrownType.create(DummyToken.getInstance(), actualSum, DummyToken.getInstance());
		
		final Type standardizedType = thrownType.standardize();
		
		// Prepare Expected
		final SumType expectedSum = SumType.create(dummyToken);
		expectedSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(a)))));
		expectedSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b)))));
		
		// Test
		assertTrue(standardizedType instanceof SumType);
		final SumType sum = (SumType) standardizedType;
		assertEquals(2, sum.getElements().size());
		assertEquals(2, expectedSum.getElements().size());
		this.assertEqualsOnlists(sum.getElements(), expectedSum.getElements());
	}
	
	/**
	 * {A!,B}! => Result: {A!,B!}.
	 * 
	 * @throws SumIsAnythingException
	 *             If it contains Anything throw specified Exception
	 */
	@Test
	public void testThrownSumContainsOneThrownTypeFirstAndOneNormalThrownTypes() throws SumIsAnythingException {

		final Name cName = group1Name.addName(cIdentifierToken);
		
		final ClassType aClass =
				RegularClassType.create(
						aName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						new Vector<Operation>(),
						aConstructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		
		final ClassType bClass =
				RegularClassType.create(
						bName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						new Vector<Operation>(),
						bConstructors,
						
						bIdentifierToken,
						
						new Vector<ClassType>());
		
		final ClassType cClass =
				RegularClassType.create(
						cName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						new Vector<Operation>(),
						cConstructors,
						cIdentifierToken,
						
						new Vector<ClassType>());

		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(myParameter);

						"Group:group=[Klasse:class={operation : [[(parameter:Integer,parameter:String) -> String ]];};];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		Model model = null;
		model = parser.parse();
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		ProductCheck.create(model, taskmanager);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(0, okResult.size());

		final IdentifierToken countIdentifier = IdentifierToken.create("count", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.stringIdentifier);
		this.stream.add(this.arrowToken);
		this.stream.add(this.bracketOpenToken);

		final IdentifierToken sIdentifierToken = IdentifierToken.create("s", Position.create("", 1, 1, 0));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		final Vector<Attribute> attributes = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		final ClassType aClass =
				RegularClassType.create(
						aName,
						new Vector<ClassModifier>(),
						attributes,
						new Vector<Type>(),
						new Vector<Operation>(),
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(aClass);
		
		final ByNameState attributeStringReferenceState =
				ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, attributeStringReferenceState);

		final IdentifierToken op = IdentifierToken.create("op", Position.create("", 1, 1, 0));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		final Vector<Operation> operations = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		
		final ClassType aClass =
				RegularClassType.create(
						aName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						operations,
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(aClass);
		
		final ProductType aProduct = ProductType.create(this.bracketOpenToken);
		final ProductType sProduct = ProductType.create(this.bracketOpenToken);

		final IdentifierToken countIdentifier = IdentifierToken.create("count", Position.create("", 1, 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.bracketOpenToken);
		this.stream.add(nameIdentifier);

		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);

				new SimpleScannerInput("Group:group=[Class:class={Attribute1:{String*}; Attribute2:String*;};];");
		final Model model = this.getModel(input);
		
		assertTrue(model.getString().getPrototype() == model.getString());
		assertTrue(model.getInteger().getPrototype() == model.getInteger());
		
		final ClassType cls = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		
		assertTrue(cls.getPrototype() == cls);
		
		final Iterator<Attribute> attributes = cls.getAttributes().iterator();
		final Attribute attribute1 = attributes.next();
		final Attribute attribute2 = attributes.next();
		
		assertTrue(attribute1.getAttrType() instanceof SumType);
		final SumType sum = (SumType) attribute1.getAttrType();
		
		assertTrue(sum.getPrototype() instanceof ListType);

		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr2Iterator.next()));
		
		assertEquals(0, ((SumType) attr3.getAttrType()).getSuperTypes().size());
		final Collection<Type> supertypesAttr3 =
				((SumType) ((SumType) attr3.getAttrType()).getPrototype()).getSuperTypes();
		assertEquals(1, supertypesAttr3.size());
		final Iterator<Type> superTypesAttr3Iterator = supertypesAttr3.iterator();
		assertEquals(model.getAnything().getPrototype(), HelperUtils.getReferencedType(superTypesAttr3Iterator.next()));
		
		assertEquals(1, model.getInteger().getPrototype().getSuperTypes().size());
		assertEquals(
				attr3Type,
				HelperUtils.getReferencedType(model.getInteger().getPrototype().getSuperTypes().iterator().next()));

	public void testSumTypesManyTimes() throws SumIsAnythingException {
		
		final Token dummyToken = DummyToken.getInstance();
		final Position dummyPosition = DummyToken.getDummyPosition();
		final IdentifierToken b = IdentifierToken.create("B", dummyPosition);
		
		// Prepare Actual
		final SumType actualSum = SumType.create(dummyToken);
		actualSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b)))));
		actualSum.add(TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b))));
		actualSum.add(TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b))));
		actualSum.add(ThrownType.create(
				dummyToken,
				TypeProxy.create(dummyToken, ByNameState.create(UnqualifiedName.create(b)))));
		
		final List<Type> standardizeElements = actualSum.standardize().accept(new TypeVisitorReturn<List<Type>>() {

		final IdentifierToken iParameterIdentifierToken = IdentifierToken.create("i", Position.create("", 1, 1, 1));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		final Name saName = group1Name.addName(saIdentifierToken);
		
		final Vector<Type> supertypes = new Vector<>();
		supertypes.add(TypeProxy.create(null, ByNameState.create(UnqualifiedName.create(saIdentifierToken))));
		
		final ClassType saClass =
				RegularClassType.create(
						saName,
						new Vector<ClassModifier>(),
						new Vector<Attribute>(),
						new Vector<Type>(),
						new Vector<Operation>(),

		AbstractOperationsCheck.create(model, taskmanager);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(0, okResult.size());
		assertEquals(1, failResult.size());
		
		final Exception exception = failResult.iterator().next().getError();
		if (exception instanceof AbstractOperationsException) {

		final SimpleScannerInput input = new SimpleScannerInput("Group:group=[Class:class={Attribute1:{Integer};};];");
		final Model model = this.getModel(input);
		
		assertTrue(model.getString().getPrototype() == model.getString());
		assertTrue(model.getInteger().getPrototype() == model.getInteger());
		
		final ClassType cls = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		
		assertTrue(cls.getPrototype() == cls);
		
		final Iterator<Attribute> attributes = cls.getAttributes().iterator();
		final Attribute attribute1 = attributes.next();
		
		assertTrue(attribute1.getAttrType() instanceof SumType);
		final SumType sum = (SumType) attribute1.getAttrType();
		
		assertTrue(sum.getPrototype() instanceof BaseType);
		final BaseType integer = (BaseType) sum.getPrototype();

		final SumType sum = SumType.create(DummyToken.getInstance());
		sum.add(proxy);
		
		final BaseType string = model.getString();
		classState = ByReferenceState.create(string, string.getTypeName());
		proxy = TypeProxy.create(DummyToken.getInstance(), classState);
		sum.add(proxy);
		
		final BaseType integer = model.getInteger();
		classState = ByReferenceState.create(integer, integer.getTypeName());
		proxy = TypeProxy.create(DummyToken.getInstance(), classState);
		sum.add(proxy);
		
		final Group g = model.getGroups().iterator().next();
		final ClassType c = (ClassType) g.getGroupElements().iterator().next();
		final Attribute a = c.getAttributes().iterator().next();
		final TypeProxy t = (TypeProxy) a.getAttrType();

		final IdentifierToken aIdentifierToken = IdentifierToken.create("A", Position.create("", 1, 1, 0));
		final IdentifierToken sIdentifierToken = IdentifierToken.create("s", Position.create("", 1, 1, 1));
		final IdentifierToken op = IdentifierToken.create("op", Position.create("", 1, 1, 0));
		
		final Vector<GroupElement> group1Vector = new Vector<>();
		final Vector<Constructor> constructors = new Vector<>();
		final Vector<Operation> operations = new Vector<>();
		final Vector<Attribute> attributes = new Vector<>();
		
		final Name group1Name = UnqualifiedName.create(group1IdentifierToken);
		final Group group1 = Group.create(group1Name, group1Vector, group1IdentifierToken);
		
		final Name aName = group1Name.addName(aIdentifierToken);
		final ClassType aClass =

		final ProductType product = ProductType.create(this.bracketOpenToken);
		final ByNameState testByName = ByNameState.create(UnqualifiedName.create(test));
		final TypeProxy testTypeProxy = TypeProxy.create(test, testByName);
		
		final Operation operation =
				Operation.create("op", new Vector<OperationModifier>(), product, clazz, testTypeProxy, op);
		operations.add(operation);
		
		modifiers.add(ClassModifierService.create(ServiceToken.create(Position.create("", 1, 1, 0))));
		modifiers.add(ClassModifierTransient.create(TransientToken.create(Position.create("", 1, 1, 0))));
		groupVector.add(clazz);
		final Model expected = Model.create(groupIdentifier);
		expected.addGroup(group);
		assertEquals(expected, model);
	}
	
	/**
	 * group1 : group = [ class1 : class = {op : [(param:Integer)->test];} service transient;]; .
	 * 
	 * @throws Exception
	 */
	@Test
	public void testSimpleClassOperation2() throws Exception {

		final IdentifierToken attributeIdentifier = IdentifierToken.create("Attribute", Position.create("", 1, 1, 0));
		
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(this.integerIdentifier);

		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 =

		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(myParameter);

	public void testNoCurlyBracketOpenException2() {
		this.stream = SimpleTokenStream.create();
		this.parser = Parser.create(this.stream);
		final IdentifierToken myGroup = IdentifierToken.create("MyGroup", Position.create("", 1, 1, 0));
		final IdentifierToken myClass = IdentifierToken.create("MyClass", 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);

	public void testProductSum1() throws Exception {
		final IdentifierToken classIdentifier = IdentifierToken.create("class1", Position.create("", 1, 1, 0));
		final IdentifierToken groupIdentifier = IdentifierToken.create("group1", Position.create("", 1, 1, 0));
		final IdentifierToken attributeIdentifier = IdentifierToken.create("attribute", Position.create("", 1, 1, 0));
		final IdentifierToken integerIdentifier = IdentifierToken.create("Integer", Position.create("", 1, 1, 0));
		final IdentifierToken stringIdentifier = IdentifierToken.create("String", Position.create("", 1, 1, 0));
		final IdentifierToken testIdentifier = IdentifierToken.create("Test", Position.create("", 1, 1, 0));
		
		final String stringInput =

		final SimpleScannerInput input = new SimpleScannerInput("Group:group=[Class:class={Attribute1:{Integer};};];");
		final Model model = this.getModel(input);
		
		assertTrue(model.getString().getPrototype() == model.getString());
		assertTrue(model.getInteger().getPrototype() == model.getInteger());
		
		final ClassType cls = (ClassType) model.getGroups().iterator().next().getGroupElements().iterator().next();
		
		assertTrue(cls.getPrototype() == cls);
		
		final Iterator<Attribute> attributes = cls.getAttributes().iterator();
		final Attribute attribute1 = attributes.next();
		
		assertTrue(attribute1.getAttrType() instanceof SumType);
		final SumType sum = (SumType) attribute1.getAttrType();
		
		assertTrue(sum.getPrototype() instanceof BaseType);

				ProductElementType.create("sum3", sum2, IdentifierToken.create("sum3", Position.create("", 1, 1, 0)));
		product2.addElement(element21);
		product2.addElement(element22);
		
		final Attribute attribute =
				Attribute.create("attribute", product2, new Vector<AttributeModifier>(), attributeIdentifier);
		attributes.add(attribute);
		
		modifiers.add(ClassModifierService.create(VisitableToken.create(Position.create("", 1, 1, 0))));
		modifiers.add(ClassModifierTransient.create(AbstractToken.create(Position.create("", 1, 1, 0))));
		groupVector.add(clazz);
		final Model expected = Model.create(groupIdentifier);
		expected.addGroup(group);
		assertEquals(expected, model);
	}
	
	/**
	 * group1 : group = [ class1 : class = {attribute : (sum1:{Integer, Test}, sum2:{{Integer, (str1:String,
	 * str2:String)}, (int3:Integer, int4:Integer), Test}) ;} service transient;]; .
	 * 
	 * @throws Exception
	 */
	@Test
	public void testProductSum7() throws Exception {

				IdentifierToken.create("", Position.create("", 0 + 1, 0 + 1, 0));
		final Attribute class2111Attribute =
				Attribute.create(
						"class21",
						class2111AttributeTypeReference,
						new Vector<AttributeModifier>(),
						class2111AttributeIdentifier);
		class2111Attributes.add(class2111Attribute);
		
		final TokenStream output = FilteredTokenStream.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model result = parser.parse();
		
		final TypeReferencerTestReturnValue v = new TypeReferencerTestReturnValue(result);
		
		assertEquals(1, v.getFailResult().size());
		assertEquals(1, v.getTypeReferencer().getExceptions().size());
		assertEquals(0, v.getOkResult().size());
	}
	
	/**
	 * Test the referencing of: Group1:group = [Group2:group = [Class1:class={};];]; Group2:group= [Class1:class=
	 * Group1>Class1 + {}; Group1:group=[Class1:class= Group2>Class1 +{classa:Group1>Group2>Class1;};
	 * Group1:group=[Class1:class = Group2>Group1>Class1 + {class21:Group2>Group1>Class1;};];];];.
	 * 
	 * @throws Exception
	 *             {@link de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException}, {@link InterruptedException}
	 *             , {@link ExecutionException}.
	 */
	@Test
	public void test2GroupsWithClasseHierarchieZyklus() throws Exception {

		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);

				IdentifierToken.create("Attribute3", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);
		this.stream.add(attributeIdentifier1);
		this.stream.add(this.colonToken);
		this.stream.add(this.stringIdentifier);

		cyclicInheritance.addDependency(referencer);
		inheritanceChecker.addMembers(cyclicInheritance, baseTypeInheritanceCheck);
		
		doubleAttributenameCheck.addDependency(inheritanceChecker);
		taskmanager.startAllKnownTasks();
		
		final Collection<OKTaskResult> okResult = new ArrayList<>();
		final Collection<ExceptionalTaskResult> failResult = new ArrayList<>();
		final Collection<TaskResult> results = taskmanager.getResultsAndShutdown();
		for (final TaskResult current : results) {
			current.accept(new TaskResultVisitor() {
				
				@Override
				public void handleOkTaskResult(final OKTaskResult result) {
					okResult.add(result);
				}
				
				@Override
				public void handleExceptionalTaskResult(final ExceptionalTaskResult result) {
					failResult.add(result);
				}
			});
		}
		
		assertEquals(6, okResult.size());
		assertEquals(0, failResult.size());
	}

						new Vector<Type>(),
						operations,
						constructors,
						aIdentifierToken,
						
						new Vector<ClassType>());
		group1Vector.add(aClass);
		
		final ProductType aProduct = ProductType.create(this.bracketOpenToken);
		final ProductType sProduct = ProductType.create(this.bracketOpenToken);
		
		final ByNameState attributeStringReferenceState =
				ByNameState.create(UnqualifiedName.create(this.stringIdentifier));
		final TypeProxy stringType = TypeProxy.create(this.stringIdentifier, attributeStringReferenceState);
		
		attributes.add(Attribute.create("s", stringType, new Vector<AttributeModifier>(), sIdentifierToken));
		sProduct.addElement(ProductElementType.create("s", stringType, sIdentifierToken));
		constructors.add(Constructor.create(aProduct, aClass, new Vector<ConstructorReference>(), aIdentifierToken));
		
		final Operation operation1 =

		assertEquals(clss, HelperUtils.getReferencedType(superTypesAttr1Iterator.next()));
		
		assertEquals(1, model.getInteger().getPrototype().getSuperTypes().size());
		assertEquals(
				model.getAnything().getPrototype(),
				HelperUtils.getReferencedType(model.getInteger().getPrototype().getSuperTypes().iterator().next()));
		
		assertEquals(1, model.getString().getPrototype().getSuperTypes().size());
		assertEquals(
				model.getAnything().getPrototype(),
				HelperUtils.getReferencedType(model.getString().getPrototype().getSuperTypes().iterator().next()));
	}
	
	/**
	 * Group:group=[A:class={Attribute1:{String,Integer,A}; Attribute2:{String,A}; Attribute3:{B,C};}; B:class=A+{};
	 * C:class=A+{}; Class:class={};]; .
	 * 
	 * @throws Exception
	 *             Exception
	 */
	@Test
	public void testTransitiveInheritance() throws Exception {

						+ "D:class=B+{}; Class:class={};];");
		final Model model = this.getModel(input);
		
		assertEquals(0, model.getAnything().getSuperTypes().size());
		assertEquals(0, ((SumType) model.getAnything().getPrototype()).getSuperTypes().size());
		
		final Iterator<GroupElement> iterator = model.getGroups().iterator().next().getGroupElements().iterator();
		final ClassType clssA = (ClassType) iterator.next();
		final ClassType clssB = (ClassType) iterator.next();
		
		final Iterator<Attribute> attrIterator = clssA.getAttributes().iterator();
		
		final Attribute attr1 = attrIterator.next();
		
		assertEquals(0, ((SumType) attr1.getAttrType()).getSuperTypes().size());

		this.stream.add(this.bracketCloseToken);
		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);
		
		try {
			this.parser.parse();
			fail();
		} catch (final NoValidTokenStreamException e) {
			boolean noType = false;
			assertEquals(1, this.parser.getExceptions().size());
			for (final Exception ex : this.parser.getExceptions()) {
				if (ex instanceof NoTypeException) {
					noType = true;
				}
			}
			assertTrue(noType);
		}
	}
	
	/**
	 * MyGroup:group=[MyClass:class={MyAttribute:{String,};};];.
	 */
	@Test
	public void testNoTypeExceptionSum() {

		this.stream.add(string);
		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);
		
		try {
			this.parser.parse();
			fail();
		} catch (final NoValidTokenStreamException e) {
			assertEquals(1, this.parser.getExceptions().size());
			boolean noBracketClose = false;

		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);
		
		try {
			this.parser.parse();
			fail();
		} catch (final NoValidTokenStreamException e) {
			assertEquals(1, this.parser.getExceptions().size());
			boolean noBracketClose = false;
			for (final Exception ex : this.parser.getExceptions()) {
				if (ex instanceof NoBracketCloseException) {
					noBracketClose = true;
				}
			}
			assertTrue(noBracketClose);
		}
	}
	
	/**
	 * MyGroup:group=[MyClass:class={MyOperation:[[(MyParameter:String)->{}]]};];.
	 */
	@Test
	public void testNoSemicolonExceptionOperation() {

		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(this.endToken);
		
		try {
			this.parser.parse();
			fail();
		} catch (final NoValidTokenStreamException e) {
			boolean noEqual = false;
			assertEquals(1, this.parser.getExceptions().size());
			for (final Exception ex : this.parser.getExceptions()) {
				if (ex instanceof NoEqualException) {
					noEqual = true;
				}
			}
			assertTrue(noEqual);
		}
	}
	
	/**
	 * MyGroup:group=[MyClass:class{};];.
	 */
	@Test
	public void testNoEqualsExceptionClass() {

		final IdentifierToken classIdentifier = IdentifierToken.create("Class", Position.create("", 0 + 1, 0 + 1, 0));
		final IdentifierToken attributeIdentifier =
				IdentifierToken.create("Attribute", Position.create("", 0 + 1, 0 + 1, 0));
		this.stream.add(groupIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.groupToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.squareBracketOpenToken);
		this.stream.add(classIdentifier);
		this.stream.add(this.colonToken);
		this.stream.add(this.classToken);
		this.stream.add(this.equalToken);
		this.stream.add(this.curlyBracketOpenToken);

		this.stream.add(this.doubleSquareBracketOpenToken);
		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);

						+ "attribute: Integer;" + "};" + "];");
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		final Model model = parser.parse();
		
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final SimpleWalkerTask doubleGroupcomponent = DoubleGroupcomponentCheck.create(model, taskmanager);
		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final DoubleAttributenameCheck doubleAttributenameCheck = DoubleAttributenameCheck.create(model, taskmanager);
		final GroupDependencyTask inheritanceChecker = GroupDependencyTask.create(taskmanager);
		final SimpleWalkerTask baseTypeInheritanceCheck = BaseTypeInheritanceCheck.create(model, taskmanager);
		
		referencer.addDependency(doubleGroupcomponent);

public class TestSupertypesCleanInheritanceTask {
	
	/**
	 * Entsprechende Task laufen und erzeugen das Model.
	 * 
	 * @param input
	 *            SimpleScannerInput
	 * @return Model
	 * @throws CyclicDependencyException
	 *             CyclicDependencyException
	 * @throws InterruptedException
	 *             InterruptedException
	 * @throws ExecutionException
	 *             ExecutionException
	 * @throws NoValidTokenStreamException
	 *             NoValidTokenStreamException
	 */
	private Model getModel(final SimpleScannerInput input) throws CyclicDependencyException, InterruptedException,
			ExecutionException, NoValidTokenStreamException {
		final TokenStream output = FilteredTokenStream.create();
		final Scanner scanner = ModelDslScanner.create();
		scanner.scan(input, output);
		final Parser parser = Parser.create(output);
		Model model = null;
		model = parser.parse();
		assertEquals(0, parser.getExceptions().size());
		
		final TaskExecutorFixed taskmanager = TaskExecutorFixed.create();
		final TypeReferencer referencer = TypeReferencer.create(model, taskmanager);
		final SimpleWalkerTask prototypesTask = PrototypesTask.create(model, taskmanager);
		final SimpleWalkerTask subtypesFillTask = SubtypesFillTask.create(model, taskmanager);
		final SimpleWalkerTask cyclicInheritance = CyclicInheritanceCheck.create(model, taskmanager);
		final SupertypesFillTask supertypesFillTask = SupertypesFillTask.create(model, taskmanager);

		final IdentifierToken name = IdentifierToken.create("name", 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(myAttribute);
		this.stream.add(this.colonToken);
		this.stream.add(this.bracketOpenToken);