/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package de.crowdcode.kissmda.cartridges.simplejava;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Iterator;
import javax.inject.Inject;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.UniqueEList;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.uml2.uml.Association;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.Enumeration;
import org.eclipse.uml2.uml.EnumerationLiteral;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Slot;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.ValueSpecification;
import org.jukito.JukitoRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
/**
* Test Enum Generator.
*
* @author Lofi Dewanto
* @version 1.0.0
* @since 1.0.0
*/
@RunWith(JukitoRunner.class)
public class EnumGeneratorTest {
@Inject
private EnumGenerator enumGenerator;
private Class clazz;
@Before
public void setUp() throws Exception {
setUpMocks();
}
public void setUpMocks() throws Exception {
String fullQualifiedName = "de::crowdcode::kissmda::testapp::components::Company";
clazz = mock(Class.class);
when(clazz.getQualifiedName()).thenReturn(fullQualifiedName);
when(clazz.getName()).thenReturn("Company");
when(clazz.getAssociations())
.thenReturn(new UniqueEList<Association>());
when(clazz.getImplementedInterfaces()).thenReturn(
new UniqueEList<Interface>());
}
@Test
public void testGeneratePackage() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
enumGenerator.generatePackage(clazz, ast, cu);
String onlyPackage = cu.toString();
String expectedResult = "package de.crowdcode.kissmda.testapp.components;\n";
boolean isInside = onlyPackage.contains(expectedResult);
assertTrue(isInside);
}
@Test
public void testGenerateEnum() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
enumGenerator.generateEnum(clazz, ast, cu);
assertEquals("public enum Company {}\n", cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstantsIntegerWithNoParamNames() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
Enumeration enumeration = mock(Enumeration.class);
EList<EnumerationLiteral> enumLiterals = mock(EList.class);
Iterator<EnumerationLiteral> enumIter = mock(Iterator.class);
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots = mock(EList.class);
Iterator<Slot> slotIter = mock(Iterator.class);
Slot slot = mock(Slot.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
EList<ValueSpecification> valueSpecifications = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter = mock(Iterator.class);
ValueSpecification valueSpecification = mock(ValueSpecification.class);
when(enumeration.getOwnedLiterals()).thenReturn(enumLiterals);
when(enumLiterals.iterator()).thenReturn(enumIter);
when(enumIter.hasNext()).thenReturn(true).thenReturn(false);
when(enumIter.next()).thenReturn(enumLiteral);
when(enumLiteral.getName()).thenReturn("Home");
when(enumLiteral.getSlots()).thenReturn(slots);
when(slots.iterator()).thenReturn(slotIter);
when(slotIter.hasNext()).thenReturn(true).thenReturn(false);
when(slotIter.next()).thenReturn(slot);
when(slot.getDefiningFeature()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(type.getName()).thenReturn("Integer");
when(slot.getValues()).thenReturn(valueSpecifications);
when(valueSpecifications.iterator()).thenReturn(valueSpecificationIter);
when(valueSpecificationIter.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter.next()).thenReturn(valueSpecification);
when(valueSpecification.integerValue()).thenReturn(0);
enumGenerator.generateConstants(enumeration, ast, ed);
assertEquals("public enum Company {HOME(0)}\n", ed.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstantsStringWithNoParamNames() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
Enumeration enumeration = mock(Enumeration.class);
EList<EnumerationLiteral> enumLiterals = mock(EList.class);
Iterator<EnumerationLiteral> enumIter = mock(Iterator.class);
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots = mock(EList.class);
Iterator<Slot> slotIter = mock(Iterator.class);
Slot slot = mock(Slot.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
EList<ValueSpecification> valueSpecifications = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter = mock(Iterator.class);
ValueSpecification valueSpecification = mock(ValueSpecification.class);
when(enumeration.getOwnedLiterals()).thenReturn(enumLiterals);
when(enumLiterals.iterator()).thenReturn(enumIter);
when(enumIter.hasNext()).thenReturn(true).thenReturn(false);
when(enumIter.next()).thenReturn(enumLiteral);
when(enumLiteral.getName()).thenReturn("Home");
when(enumLiteral.getSlots()).thenReturn(slots);
when(slots.iterator()).thenReturn(slotIter);
when(slotIter.hasNext()).thenReturn(true).thenReturn(false);
when(slotIter.next()).thenReturn(slot);
when(slot.getDefiningFeature()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(type.getName()).thenReturn("String");
when(slot.getValues()).thenReturn(valueSpecifications);
when(valueSpecifications.iterator()).thenReturn(valueSpecificationIter);
when(valueSpecificationIter.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter.next()).thenReturn(valueSpecification);
when(valueSpecification.stringValue()).thenReturn("Home");
enumGenerator.generateConstants(enumeration, ast, ed);
assertEquals("public enum Company {HOME(\"Home\")}\n", ed.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstantsLongWithNoParamNames() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
Enumeration enumeration = mock(Enumeration.class);
EList<EnumerationLiteral> enumLiterals = mock(EList.class);
Iterator<EnumerationLiteral> enumIter = mock(Iterator.class);
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots = mock(EList.class);
Iterator<Slot> slotIter = mock(Iterator.class);
Slot slot = mock(Slot.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
EList<ValueSpecification> valueSpecifications = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter = mock(Iterator.class);
ValueSpecification valueSpecification = mock(ValueSpecification.class);
when(enumeration.getOwnedLiterals()).thenReturn(enumLiterals);
when(enumLiterals.iterator()).thenReturn(enumIter);
when(enumIter.hasNext()).thenReturn(true).thenReturn(false);
when(enumIter.next()).thenReturn(enumLiteral);
when(enumLiteral.getName()).thenReturn("Home");
when(enumLiteral.getSlots()).thenReturn(slots);
when(slots.iterator()).thenReturn(slotIter);
when(slotIter.hasNext()).thenReturn(true).thenReturn(false);
when(slotIter.next()).thenReturn(slot);
when(slot.getDefiningFeature()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(type.getName()).thenReturn("Long");
when(slot.getValues()).thenReturn(valueSpecifications);
when(valueSpecifications.iterator()).thenReturn(valueSpecificationIter);
when(valueSpecificationIter.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter.next()).thenReturn(valueSpecification);
when(valueSpecification.integerValue()).thenReturn(1);
enumGenerator.generateConstants(enumeration, ast, ed);
assertEquals("public enum Company {HOME(1L)}\n", ed.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstantsBooleanWithNoParamNames() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
Enumeration enumeration = mock(Enumeration.class);
EList<EnumerationLiteral> enumLiterals = mock(EList.class);
Iterator<EnumerationLiteral> enumIter = mock(Iterator.class);
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots = mock(EList.class);
Iterator<Slot> slotIter = mock(Iterator.class);
Slot slot = mock(Slot.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
EList<ValueSpecification> valueSpecifications = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter = mock(Iterator.class);
ValueSpecification valueSpecification = mock(ValueSpecification.class);
when(enumeration.getOwnedLiterals()).thenReturn(enumLiterals);
when(enumLiterals.iterator()).thenReturn(enumIter);
when(enumIter.hasNext()).thenReturn(true).thenReturn(false);
when(enumIter.next()).thenReturn(enumLiteral);
when(enumLiteral.getName()).thenReturn("Home");
when(enumLiteral.getSlots()).thenReturn(slots);
when(slots.iterator()).thenReturn(slotIter);
when(slotIter.hasNext()).thenReturn(true).thenReturn(false);
when(slotIter.next()).thenReturn(slot);
when(slot.getDefiningFeature()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(type.getName()).thenReturn("boolean");
when(slot.getValues()).thenReturn(valueSpecifications);
when(valueSpecifications.iterator()).thenReturn(valueSpecificationIter);
when(valueSpecificationIter.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter.next()).thenReturn(valueSpecification);
when(valueSpecification.booleanValue()).thenReturn(true);
enumGenerator.generateConstants(enumeration, ast, ed);
assertEquals("public enum Company {HOME(true)}\n", ed.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateGetterMethod() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
EList<Property> properties = mock(EList.class);
Iterator<Property> propertyIter = mock(Iterator.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
String name = "type";
EList<Comment> comments = mock(EList.class,
Answers.RETURNS_DEEP_STUBS.get());
when(clazz.getAttributes()).thenReturn(properties);
when(properties.iterator()).thenReturn(propertyIter);
when(propertyIter.hasNext()).thenReturn(true).thenReturn(false);
when(propertyIter.next()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(property.getName()).thenReturn(name);
when(property.getUpper()).thenReturn(1);
when(property.getLower()).thenReturn(1);
when(property.getOwnedComments()).thenReturn(comments);
when(type.getName()).thenReturn("String");
when(type.getQualifiedName()).thenReturn("String");
enumGenerator.generateGetterMethod(clazz, ast, ed);
assertEquals(
"public enum Company {; public String getType(){\n return type;\n}\n}\n",
cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateGetterMethodWithSourceDirectoryPackageNameWrong() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
EList<Property> properties = mock(EList.class);
Iterator<Property> propertyIter = mock(Iterator.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
String name = "type";
EList<Comment> comments = mock(EList.class,
Answers.RETURNS_DEEP_STUBS.get());
when(clazz.getAttributes()).thenReturn(properties);
when(properties.iterator()).thenReturn(propertyIter);
when(propertyIter.hasNext()).thenReturn(true).thenReturn(false);
when(propertyIter.next()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(property.getName()).thenReturn(name);
when(property.getUpper()).thenReturn(1);
when(property.getLower()).thenReturn(1);
when(property.getOwnedComments()).thenReturn(comments);
when(type.getName()).thenReturn("Data::String");
when(type.getQualifiedName()).thenReturn("Data::String");
enumGenerator.generateGetterMethod(clazz, ast, ed);
assertEquals(
"public enum Company {; public Data.String getType(){\n return type;\n}\n}\n",
cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateGetterMethodWithSourceDirectoryPackageNameCorrect() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
EList<Property> properties = mock(EList.class);
Iterator<Property> propertyIter = mock(Iterator.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
String name = "type";
EList<Comment> comments = mock(EList.class,
Answers.RETURNS_DEEP_STUBS.get());
when(clazz.getAttributes()).thenReturn(properties);
when(properties.iterator()).thenReturn(propertyIter);
when(propertyIter.hasNext()).thenReturn(true).thenReturn(false);
when(propertyIter.next()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(property.getName()).thenReturn(name);
when(property.getUpper()).thenReturn(1);
when(property.getLower()).thenReturn(1);
when(property.getOwnedComments()).thenReturn(comments);
when(type.getName()).thenReturn("Data::String");
when(type.getQualifiedName()).thenReturn("Data::String");
enumGenerator.generateGetterMethod(clazz, ast, ed, "Data");
assertEquals(
"public enum Company {; public String getType(){\n return type;\n}\n}\n",
cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateAttribute() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
EList<Property> properties = mock(EList.class);
Iterator<Property> propertyIter = mock(Iterator.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
String name = "type";
EList<Comment> comments = mock(EList.class,
Answers.RETURNS_DEEP_STUBS.get());
when(clazz.getAttributes()).thenReturn(properties);
when(properties.iterator()).thenReturn(propertyIter);
when(propertyIter.hasNext()).thenReturn(true).thenReturn(false);
when(propertyIter.next()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(property.getName()).thenReturn(name);
when(property.getUpper()).thenReturn(1);
when(property.getLower()).thenReturn(1);
when(property.getOwnedComments()).thenReturn(comments);
when(type.getName()).thenReturn("String");
when(type.getQualifiedName()).thenReturn("String");
enumGenerator.generateAttributes(clazz, ast, ed);
assertEquals("public enum Company {; String type;\n}\n", cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstructorWithOneParameter() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
EList<Property> firstProperties = mock(EList.class);
Iterator<Property> firstPropertyIter = mock(Iterator.class);
EList<Property> secondProperties = mock(EList.class);
Iterator<Property> secondPropertyIter = mock(Iterator.class);
Property property = mock(Property.class);
Type type = mock(Type.class);
String name = "type";
EList<Comment> comments = mock(EList.class,
Answers.RETURNS_DEEP_STUBS.get());
when(clazz.getAttributes()).thenReturn(firstProperties).thenReturn(
secondProperties);
when(firstProperties.iterator()).thenReturn(firstPropertyIter);
when(firstPropertyIter.hasNext()).thenReturn(true).thenReturn(false);
when(firstPropertyIter.next()).thenReturn(property);
when(secondProperties.iterator()).thenReturn(secondPropertyIter);
when(secondPropertyIter.hasNext()).thenReturn(true).thenReturn(false);
when(secondPropertyIter.next()).thenReturn(property);
when(property.getType()).thenReturn(type);
when(property.getName()).thenReturn(name);
when(property.getUpper()).thenReturn(1);
when(property.getLower()).thenReturn(1);
when(property.getOwnedComments()).thenReturn(comments);
when(type.getName()).thenReturn("String");
when(type.getQualifiedName()).thenReturn("String");
enumGenerator.generateConstructor(clazz, ast, ed);
assertEquals(
"public enum Company {; private Company(String type){\n this.type=type;\n}\n}\n",
cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstructorWithTwoParameters() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
EList<Property> firstProperties = mock(EList.class);
Iterator<Property> firstPropertyIter = mock(Iterator.class);
EList<Property> secondProperties = mock(EList.class);
Iterator<Property> secondPropertyIter = mock(Iterator.class);
Property firstProperty = mock(Property.class);
Type firstType = mock(Type.class);
String firstName = "type";
Property secondProperty = mock(Property.class);
Type secondType = mock(Type.class);
String secondName = "count";
EList<Comment> comments = mock(EList.class,
Answers.RETURNS_DEEP_STUBS.get());
when(clazz.getAttributes()).thenReturn(firstProperties).thenReturn(
secondProperties);
when(firstProperties.iterator()).thenReturn(firstPropertyIter);
when(firstPropertyIter.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(firstPropertyIter.next()).thenReturn(firstProperty).thenReturn(
secondProperty);
when(secondProperties.iterator()).thenReturn(secondPropertyIter);
when(secondPropertyIter.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(secondPropertyIter.next()).thenReturn(firstProperty).thenReturn(
secondProperty);
when(firstProperty.getType()).thenReturn(firstType);
when(firstProperty.getName()).thenReturn(firstName);
when(firstProperty.getUpper()).thenReturn(1);
when(firstProperty.getLower()).thenReturn(1);
when(firstProperty.getOwnedComments()).thenReturn(comments);
when(firstType.getName()).thenReturn("String");
when(firstType.getQualifiedName()).thenReturn("String");
when(secondProperty.getType()).thenReturn(secondType);
when(secondProperty.getName()).thenReturn(secondName);
when(secondProperty.getUpper()).thenReturn(1);
when(secondProperty.getLower()).thenReturn(1);
when(secondProperty.getOwnedComments()).thenReturn(comments);
when(secondType.getName()).thenReturn("Integer");
when(secondType.getQualifiedName()).thenReturn("Integer");
enumGenerator.generateConstructor(clazz, ast, ed);
assertEquals(
"public enum Company {; private Company(String type,Integer count){\n this.type=type;\n this.count=count;\n}\n}\n",
cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateContructorParameters() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
MethodDeclaration md = ast.newMethodDeclaration();
md.setConstructor(true);
md.setName(ast.newSimpleName(clazz.getName()));
md.modifiers().add(
ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
EList<Property> properties = mock(EList.class);
Iterator<Property> propertyIter = mock(Iterator.class);
Property propertyName = mock(Property.class);
String name = "name";
Type typeName = mock(Type.class);
Property propertyCount = mock(Property.class);
String count = "count";
Type typeCount = mock(Type.class);
EList<Comment> comments = mock(EList.class,
Answers.RETURNS_DEEP_STUBS.get());
when(clazz.getAttributes()).thenReturn(properties);
when(properties.iterator()).thenReturn(propertyIter);
when(propertyIter.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(propertyIter.next()).thenReturn(propertyName).thenReturn(
propertyCount);
when(propertyName.getType()).thenReturn(typeName);
when(propertyName.getName()).thenReturn(name);
when(propertyName.getUpper()).thenReturn(1);
when(propertyName.getLower()).thenReturn(1);
when(propertyName.getOwnedComments()).thenReturn(comments);
when(typeName.getName()).thenReturn("String");
when(typeName.getQualifiedName()).thenReturn("String");
when(propertyCount.getType()).thenReturn(typeCount);
when(propertyCount.getName()).thenReturn(count);
when(propertyCount.getUpper()).thenReturn(1);
when(propertyCount.getLower()).thenReturn(1);
when(propertyCount.getOwnedComments()).thenReturn(comments);
when(typeCount.getName()).thenReturn("Integer");
when(typeCount.getQualifiedName()).thenReturn("Integer");
enumGenerator.generateContructorParameters(clazz, ast, md);
ed.bodyDeclarations().add(md);
assertEquals(
"public enum Company {; private Company(String name,Integer count);\n}\n",
cu.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testFindSlotByNameFoundIt() {
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots = mock(EList.class, Answers.RETURNS_DEEP_STUBS.get());
Iterator<Slot> slotIter = mock(Iterator.class);
Slot slot1 = mock(Slot.class);
Slot slot2 = mock(Slot.class);
Property property1 = mock(Property.class);
Property property2 = mock(Property.class);
when(enumLiteral.getSlots()).thenReturn(slots);
when(slots.iterator()).thenReturn(slotIter);
when(slotIter.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(slotIter.next()).thenReturn(slot1).thenReturn(slot2);
when(slot1.getDefiningFeature()).thenReturn(property1);
when(slot2.getDefiningFeature()).thenReturn(property2);
when(property1.getName()).thenReturn("test1");
when(property2.getName()).thenReturn("test2");
Slot slotResult = enumGenerator.findSlotByName("test1", enumLiteral);
assertEquals(slot1, slotResult);
}
@SuppressWarnings("unchecked")
@Test
public void testFindSlotByNameNotFound() {
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots = mock(EList.class, Answers.RETURNS_DEEP_STUBS.get());
Iterator<Slot> slotIter = mock(Iterator.class);
Slot slot1 = mock(Slot.class);
Slot slot2 = mock(Slot.class);
Property property1 = mock(Property.class);
Property property2 = mock(Property.class);
when(enumLiteral.getSlots()).thenReturn(slots);
when(slots.iterator()).thenReturn(slotIter);
when(slotIter.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(slotIter.next()).thenReturn(slot1).thenReturn(slot2);
when(slot1.getDefiningFeature()).thenReturn(property1);
when(slot2.getDefiningFeature()).thenReturn(property2);
when(property1.getName()).thenReturn("test1");
when(property2.getName()).thenReturn("test2");
Slot slotResult = enumGenerator.findSlotByName("test3", enumLiteral);
assertEquals(null, slotResult);
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstantsWithConstructorParameterNamesAndWithFoundSlot() {
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
Enumeration enumeration = mock(Enumeration.class);
EList<EnumerationLiteral> enumLiterals = mock(EList.class);
Iterator<EnumerationLiteral> enumIter = mock(Iterator.class);
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots = mock(EList.class);
Iterator<Slot> slotIter = mock(Iterator.class);
Slot slot1 = mock(Slot.class);
Slot slot2 = mock(Slot.class);
Property property1 = mock(Property.class);
Property property2 = mock(Property.class);
Type type1 = mock(Type.class);
Type type2 = mock(Type.class);
EList<ValueSpecification> valueSpecifications1 = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter1 = mock(Iterator.class);
EList<ValueSpecification> valueSpecifications2 = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter2 = mock(Iterator.class);
ValueSpecification valueSpecification1 = mock(ValueSpecification.class);
ValueSpecification valueSpecification2 = mock(ValueSpecification.class);
when(enumeration.getOwnedLiterals()).thenReturn(enumLiterals);
when(enumLiterals.iterator()).thenReturn(enumIter);
when(enumIter.hasNext()).thenReturn(true).thenReturn(false);
when(enumIter.next()).thenReturn(enumLiteral);
when(enumLiteral.getName()).thenReturn("Home");
when(enumLiteral.getSlots()).thenReturn(slots);
when(slots.iterator()).thenReturn(slotIter);
when(slotIter.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(slotIter.next()).thenReturn(slot1).thenReturn(slot2);
when(slot1.getDefiningFeature()).thenReturn(property1);
when(slot2.getDefiningFeature()).thenReturn(property2);
when(property1.getType()).thenReturn(type1);
when(property2.getType()).thenReturn(type2);
when(property1.getName()).thenReturn("type");
when(property2.getName()).thenReturn("name");
when(type1.getName()).thenReturn("boolean");
when(type2.getName()).thenReturn("String");
when(slot1.getValues()).thenReturn(valueSpecifications1);
when(slot2.getValues()).thenReturn(valueSpecifications2);
when(valueSpecifications1.iterator()).thenReturn(
valueSpecificationIter1);
when(valueSpecifications2.iterator()).thenReturn(
valueSpecificationIter2);
when(valueSpecificationIter1.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter2.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter1.next()).thenReturn(valueSpecification1);
when(valueSpecificationIter2.next()).thenReturn(valueSpecification2);
when(valueSpecification1.booleanValue()).thenReturn(true);
when(valueSpecification2.stringValue()).thenReturn("Lofi");
ArrayList<String> constructorParameterNames = new ArrayList<String>();
constructorParameterNames.add("type");
constructorParameterNames.add("name");
enumGenerator.setConstructorParameterNames(constructorParameterNames);
enumGenerator.generateConstants(enumeration, ast, ed);
assertEquals("public enum Company {HOME(true,\"Lofi\")}\n",
ed.toString());
}
@SuppressWarnings("unchecked")
@Test
public void testGenerateConstantsWithConstructorParameterNamesAndWithSlotNotFound() {
// TODO
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
EnumDeclaration ed = enumGenerator.generateEnum(clazz, ast, cu);
Enumeration enumeration = mock(Enumeration.class);
EList<EnumerationLiteral> enumLiterals = mock(EList.class);
Iterator<EnumerationLiteral> enumIter = mock(Iterator.class);
EnumerationLiteral enumLiteral = mock(EnumerationLiteral.class);
EList<Slot> slots1 = mock(EList.class);
EList<Slot> slots2 = mock(EList.class);
Iterator<Slot> slotIter1 = mock(Iterator.class);
Iterator<Slot> slotIter2 = mock(Iterator.class);
Slot slot1 = mock(Slot.class);
Slot slot2 = mock(Slot.class);
Property property1 = mock(Property.class);
Property property2 = mock(Property.class);
Type type1 = mock(Type.class);
Type type2 = mock(Type.class);
EList<ValueSpecification> valueSpecifications1 = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter1 = mock(Iterator.class);
EList<ValueSpecification> valueSpecifications2 = mock(EList.class);
Iterator<ValueSpecification> valueSpecificationIter2 = mock(Iterator.class);
ValueSpecification valueSpecification1 = mock(ValueSpecification.class);
ValueSpecification valueSpecification2 = mock(ValueSpecification.class);
when(enumeration.getOwnedLiterals()).thenReturn(enumLiterals);
when(enumLiterals.iterator()).thenReturn(enumIter);
when(enumIter.hasNext()).thenReturn(true).thenReturn(false);
when(enumIter.next()).thenReturn(enumLiteral);
when(enumLiteral.getName()).thenReturn("Home");
when(enumLiteral.getSlots()).thenReturn(slots1).thenReturn(slots2);
when(slots1.iterator()).thenReturn(slotIter1);
when(slots2.iterator()).thenReturn(slotIter2);
when(slotIter1.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(slotIter2.hasNext()).thenReturn(true).thenReturn(true)
.thenReturn(false);
when(slotIter1.next()).thenReturn(slot1).thenReturn(slot2);
when(slotIter2.next()).thenReturn(slot1).thenReturn(slot2);
when(slot1.getDefiningFeature()).thenReturn(property1);
when(slot2.getDefiningFeature()).thenReturn(property2);
when(property1.getType()).thenReturn(type1);
when(property2.getType()).thenReturn(type2);
when(property1.getName()).thenReturn("type");
when(property2.getName()).thenReturn("name");
when(type1.getName()).thenReturn("boolean");
when(type2.getName()).thenReturn("String");
when(slot1.getValues()).thenReturn(valueSpecifications1);
when(slot2.getValues()).thenReturn(valueSpecifications2);
when(valueSpecifications1.iterator()).thenReturn(
valueSpecificationIter1);
when(valueSpecifications2.iterator()).thenReturn(
valueSpecificationIter2);
when(valueSpecificationIter1.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter2.hasNext()).thenReturn(true).thenReturn(
false);
when(valueSpecificationIter1.next()).thenReturn(valueSpecification1);
when(valueSpecificationIter2.next()).thenReturn(valueSpecification2);
when(valueSpecification1.booleanValue()).thenReturn(true);
when(valueSpecification2.stringValue()).thenReturn("Lofi");
// Cannot find the parameter name of the constructor!
ArrayList<String> constructorParameterNames = new ArrayList<String>();
constructorParameterNames.add("typeX");
constructorParameterNames.add("nameY");
enumGenerator.setConstructorParameterNames(constructorParameterNames);
enumGenerator.generateConstants(enumeration, ast, ed);
assertEquals("public enum Company {HOME(true,\"Lofi\")}\n",
ed.toString());
}
}