import static org.junit.Assert.assertTrue;
import java.util.List;
import java.util.Set;
import javax.naming.InvalidNameException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import easysm.calculators.Generator;
import easysm.datatypes.Action;
import easysm.datatypes.Expr;
import easysm.datatypes.Name;
import easysm.datatypes.information.*;
import easysm.executors.Main;
import easysm.factories.ListFactory;
import easysm.factories.SetFactory;
import easysm.stores.*;
import easysm.stores.Class;
/**
* @author Federica Lupi
* @author Marta Semeria
*/
public class GeneratorTests
{
Main main;
Name cPine;
Name cIffy;
Name cGino;
Name cBobb;
Name cTupe;
@Before
public void setUp()
{
main = new Main(false);
Name name = null;
try {
name = new Name("Test");
cPine = new Name("Pine");
cIffy = new Name("Iffy");
cGino = new Name("Gino");
cBobb = new Name("Bobb");
cTupe = new Name("Tupe");
} catch (InvalidNameException e) {
//
}
ProjectInfo projectInfo = new ProjectInfo(name, "Test", "Test");
main.doNewProject(projectInfo);
}
@After
public void tearDown()
{
main = null;
}
/*
*
* Generator.generateBasicSO()
*
*/
@Test
public void Generator_generateBasicSO_OneValidSO()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class cl = new Class(new ClassInfo(cPine));
cd.addCDElement(cl);
Attribute a = new Attribute(new AttributeInfo(cIffy, cl, Type.INTEGER));
cd.addCDElement(a);
cd.changeContext(cl);
Set<StateObserver> soSet = Generator.generateBasicSO(cd);
assertTrue(soSet.size() == 1);
for (StateObserver so : soSet) {
assertTrue(so.name().equals(cIffy));
assertTrue(so.type().equals(Type.INTEGER));
assertTrue(so.invariant().equals(Expr.EMPTY));
}
}
@Test
public void Generator_generateBasicSO_TwoClasses_OneValidSO()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class c1 = new Class(new ClassInfo(cPine));
cd.addCDElement(c1);
Class c2 = new Class(new ClassInfo(cGino));
cd.addCDElement(c2);
Attribute a2 = new Attribute(new AttributeInfo(cGino, c2, Type.BOOLEAN));
cd.addCDElement(a2);
Attribute a1 = new Attribute(new AttributeInfo(cIffy, c1, Type.INTEGER));
cd.addCDElement(a1);
cd.changeContext(c1);
Set<StateObserver> soSet = Generator.generateBasicSO(cd);
assertTrue(soSet.size() == 1);
for (StateObserver so : soSet) {
assertTrue(so.name().equals(cIffy));
assertTrue(so.type().equals(Type.INTEGER));
assertTrue(so.invariant().equals(Expr.EMPTY));
}
}
@Test
public void Generator_generateBasicSO_OneValidSO_WithOneClass_WithTwoAttributes()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class cl = new Class(new ClassInfo(cPine));
cd.addCDElement(cl);
Attribute a1 = new Attribute(new AttributeInfo(cIffy, cl, Type.INTEGER));
Attribute a2 = new Attribute(new AttributeInfo(cGino, cl, Type.INTEGER));
cd.addCDElement(a1);
cd.addCDElement(a2);
cd.changeContext(cl);
Set<StateObserver> soSet = Generator.generateBasicSO(cd);
assertTrue(soSet.size() == 2);
for (StateObserver so : soSet) {
assertTrue(so.name().equals(cIffy) || so.name().equals(cGino));
assertTrue(so.type().equals(Type.INTEGER));
assertTrue(so.invariant().equals(Expr.EMPTY));
}
}
/*
*
* Generator.generateStateTable()
*
*/
@Test
public void Generator_generateStateTable_EmptySet()
{
List<StateObserver> soUsedSet = ListFactory.createList(StateObserver.class);
List<Row> rows = Generator.generateStateTable(soUsedSet);
assertTrue(rows.isEmpty());
}
@Test
public void Generator_generateStateTable_WithTwoSo_NotDiscreteSo()
{
List<StateObserver> soUsedSet = ListFactory.createList(StateObserver.class);
soUsedSet.add(new StateObserver(new StateObserverInfo(cGino, Type.INTEGER, null)));
soUsedSet.add(new StateObserver(new StateObserverInfo(cPine, Type.BOOLEAN, null)));
List<Row> rows = Generator.generateStateTable(soUsedSet);
assertTrue(rows.isEmpty());
}
/*
*
* Generator.generateBasicEvents()
*
*/
@Test
public void Generator_generateBasicEvent_WithOneOperation_WithReturnType()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class cl = new Class(new ClassInfo(cPine));
cd.addCDElement(cl);
Operation op = new Operation(new OperationInfo(cPine, cl, null, Type.INTEGER));
cd.addCDElement(op);
cd.changeContext(cl);
Set<Event> eventSet = Generator.generateBasicEvents(cd);
assertTrue(eventSet.size() == 0);
}
@Test
public void Generator_generateBasicEvent_WithOneOperation_WithoutReturnType()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class cl = new Class(new ClassInfo(cPine));
cd.addCDElement(cl);
Operation op = new Operation(new OperationInfo(cIffy, cl, null, null));
cd.addCDElement(op);
cd.changeContext(cl);
Set<Event> eventSet = Generator.generateBasicEvents(cd);
assertTrue(eventSet.size() == 1);
for (Event e : eventSet) {
assertTrue(e.name().equals(cIffy));
assertTrue(e.parameters().size() == 0);
}
}
@Test
public void Generator_generateBasicEvent_WithOneOperation_WithoutReturnTypeAndParameters()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class cl = new Class(new ClassInfo(cPine));
cd.addCDElement(cl);
Set<ParameterInfo> params = SetFactory.createSet(ParameterInfo.class);
ParameterInfo pInfo = new ParameterInfo(cGino, Type.INTEGER);
params.add(pInfo);
Operation op = new Operation(new OperationInfo(cIffy, cl, params, null));
cd.addCDElement(op);
cd.changeContext(cl);
Set<Event> eventSet = Generator.generateBasicEvents(cd);
assertTrue(eventSet.size() == 1);
for (Event e : eventSet) {
assertTrue(e.name().equals(cIffy));
assertTrue(e.parameters().size() == 1);
for (Parameter p : e.parameters()) {
assertTrue(p.name().equals(cGino));
assertTrue(p.type().equals(Type.INTEGER));
}
}
}
/*
*
* Generator.generateTransition()
*
*/
@Test
public void Generator_generateTransition_OneValidTransition()
{
State source = new State(cPine, true);
State target = new State(cTupe, false);
CondReactInfo condReactInfo = new CondReactInfo(null, null);
CondReact cr = new CondReact(condReactInfo);
Expr cond = new Expr("cond");
Action react = new Action("react");
cr.changeRemCond(cond);
cr.changeRemReact(react);
EventInfo eInfo = new EventInfo(cGino, null);
Event e = new Event(eInfo);
Transition t = Generator.generateTransition(source, target, e, cr);
assertTrue(t.source().equals(source));
assertTrue(t.target().equals(target));
assertTrue(t.cond().equals(cr.remCond()));
assertTrue(t.react().equals(cr.remReact()));
assertTrue(t.trigger().toString().equals(e.toString()));
}
@Test
public void Generator_generateTransition_OneValidTransition_WithCreated()
{
State source = new State(cPine, true);
State target = new State(cTupe, false);
CondReactInfo condReactInfo = new CondReactInfo(null, null);
CondReact cr = new CondReact(condReactInfo);
Expr cond = new Expr("cond");
Action react = new Action("react");
cr.changeRemCond(cond);
cr.changeRemReact(react);
Transition t = Generator.generateTransition(source, target, Event.CREATED, cr);
assertTrue(t.source().equals(source));
assertTrue(t.target().equals(target));
assertTrue(t.cond().equals(cr.remCond()));
assertTrue(t.react().equals(cr.remReact()));
assertTrue(t.trigger().toString().equals(""));
}
/*
*
* Generator.generateStates()
*
*/
@Test
public void Generator_generateStates_STWithNoStates()
{
StateTable stateTable = new StateTable(new StateTableInfo());
List<Row> rows = Generator.generateStateTable(stateTable.usedSO());
stateTable.changeRows(rows);
List<State> states = Generator.generateStates(stateTable);
// "states" should contain only the initial state
assertTrue(states.size() == 1);
assertTrue(states.get(0).equals(State.INITIAL) && states.get(0).isInitial() && !states.get(0).isFinal());
}
@Test
public void Generator_generateStates_STWithOneFinalState()
{
StateTable stateTable = new StateTable(new StateTableInfo());
List<Row> rows = Generator.generateStateTable(stateTable.usedSO());
stateTable.changeRows(rows);
stateTable.defineState(rows.get(0), cPine);
List<State> states = Generator.generateStates(stateTable);
// "states" should contain the initial state, plus the final state "cPine"
assertTrue(states.size() == 2);
assertTrue(states.get(0).equals(State.INITIAL) && states.get(0).isInitial() && !states.get(0).isFinal());
assertTrue(states.get(1).name().equals(cPine) && states.get(1).isFinal() && !states.get(1).isInitial());
}
@Test
public void Generator_generateStates_STWithOneNormalState()
{
StateTable stateTable = new StateTable(new StateTableInfo());
List<Row> rows = Generator.generateStateTable(stateTable.usedSO());
stateTable.changeRows(rows);
stateTable.defineState(rows.get(1), cPine);
List<State> states = Generator.generateStates(stateTable);
// "states" should contain the initial state, plus the normal state "cPine"
assertTrue(states.size() == 2);
assertTrue(states.get(0).equals(State.INITIAL) && states.get(0).isInitial() && !states.get(0).isFinal());
assertTrue(states.get(1).name().equals(cPine) && !states.get(1).isInitial() && !states.get(1).isFinal());
}
@Test
public void Generator_generateStates_STWithFourDefinedStates()
{
StateTable stateTable = new StateTable(new StateTableInfo());
StateObserverInfo soInfo = new StateObserverInfo(cIffy, Type.BOOLEAN, null);
StateObserver finiteSO = new StateObserver(soInfo);
stateTable.usedSO().add(finiteSO);
List<Row> rows = Generator.generateStateTable(stateTable.usedSO());
stateTable.changeRows(rows);
stateTable.defineState(rows.get(0), cPine);
stateTable.defineState(rows.get(1), cGino);
stateTable.defineState(rows.get(2), cBobb);
stateTable.defineState(rows.get(3), cTupe);
List<State> states = Generator.generateStates(stateTable);
// "states" should contain the initial state, plus:
// - The final states "cPine" and "cGino"
// - The normal states "cBobb" and "cTupe"
assertTrue(states.size() == 5);
assertTrue(states.get(0).equals(State.INITIAL) && states.get(0).isInitial() && !states.get(0).isFinal());
assertTrue(states.get(1).name().equals(cPine) && states.get(1).isFinal() && !states.get(1).isInitial());
assertTrue(states.get(2).name().equals(cGino) && states.get(2).isFinal() && !states.get(2).isInitial());
assertTrue(states.get(3).name().equals(cBobb) && !states.get(3).isInitial() && !states.get(3).isFinal());
assertTrue(states.get(4).name().equals(cTupe) && !states.get(4).isInitial() && !states.get(4).isFinal());
}
/*
*
* Generator.generateOutputCD()
*
*/
@Test
public void Generator_generateOutputCD_NoEvent()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class cl = new Class(new ClassInfo(cPine));
cd.addCDElement(cl);
cd.changeContext(cl);
StateObserverInfo soInfo = new StateObserverInfo(cGino, Type.INTEGER, null);
StateObservers so = new StateObservers(new StateObserversInfo());
so.addStateObserver(new StateObserver(soInfo));
List<StateObserver> soList = so.soList();
Events e = new Events(new EventsInfo());
List<Event> eSet = e.eventList();
cd = Generator.generateOutputCD(cd, soList, eSet);
assertTrue(cd.context().attributes().size() == 1);
Name attrName = cd.context().attributes().get(0).name();
Type attrType = cd.context().attributes().get(0).type();
assertTrue(attrName.equals(cGino));
assertTrue(attrType.equals(Type.INTEGER));
}
@Test
public void Generator_generateOutputCD_NoStateObserver()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class cl = new Class(new ClassInfo(cPine));
cd.addCDElement(cl);
cd.changeContext(cl);
StateObservers so = new StateObservers(new StateObserversInfo());
List<StateObserver> soSet = so.soList();
Set<ParameterInfo> parInfo = SetFactory.createSet(ParameterInfo.class);
Events e = new Events(new EventsInfo());
e.addEvent(new Event(new EventInfo(cGino, parInfo)));
List<Event> eSet = e.eventList();
cd = Generator.generateOutputCD(cd, soSet, eSet);
assertTrue(cd.context().attributes().size() == 0);
Name opName = cd.context().operations().get(0).name();
Type opReturnType = cd.context().operations().get(0).returnType();
List<Parameter> opParams = cd.context().operations().get(0).parameters();
assertTrue(opName.equals(cGino));
assertTrue(opReturnType == null);
assertTrue(opParams.isEmpty());
}
@Test
public void Generator_generateOutputCD_TwoClass()
{
ClassDiagram cd = new ClassDiagram(new ClassDiagramInfo());
Class c1 = new Class(new ClassInfo(cPine));
cd.addCDElement(c1);
cd.changeContext(c1);
Class c2 = new Class(new ClassInfo(cGino));
cd.addCDElement(c2);
StateObserverInfo soInfo = new StateObserverInfo(cBobb, Type.INTEGER, null);
StateObservers so = new StateObservers(new StateObserversInfo());
so.addStateObserver(new StateObserver(soInfo));
List<StateObserver> soSet = so.soList();
Set<ParameterInfo> parInfo = SetFactory.createSet(ParameterInfo.class);
Events ev = new Events(new EventsInfo());
ev.addEvent(new Event(new EventInfo(cIffy, parInfo)));
List<Event> eSet = ev.eventList();
cd = Generator.generateOutputCD(cd, soSet, eSet);
assertTrue(cd.classes().size() == 2);
assertTrue(cd.context().attributes().size() == 1);
assertTrue(cd.context().operations().size() == 1);
Name attrName = cd.context().attributes().get(0).name();
Type attrType = cd.context().attributes().get(0).type();
assertTrue(attrName.equals(cBobb));
assertTrue(attrType.equals(Type.INTEGER));
Name opName = cd.context().operations().get(0).name();
Type opReturnType = cd.context().operations().get(0).returnType();
List<Parameter> opParams = cd.context().operations().get(0).parameters();
assertTrue(opName.equals(cIffy));
assertTrue(opReturnType == null);
assertTrue(opParams.isEmpty());
}
}