diff --git a/AlgebraicDataflowArchitectureModel/.classpath b/AlgebraicDataflowArchitectureModel/.classpath new file mode 100644 index 0000000..2023f26 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/AlgebraicDataflowArchitectureModel/.gitignore b/AlgebraicDataflowArchitectureModel/.gitignore new file mode 100644 index 0000000..ae3c172 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/AlgebraicDataflowArchitectureModel/.project b/AlgebraicDataflowArchitectureModel/.project new file mode 100644 index 0000000..15e3364 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/.project @@ -0,0 +1,17 @@ + + + AlgebraicDataflowArchitectureModel + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/AlgebraicDataflowArchitectureModel/.settings/org.eclipse.jdt.core.prefs b/AlgebraicDataflowArchitectureModel/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..838bd9d --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,11 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.7 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.7 diff --git a/AlgebraicDataflowArchitectureModel/src/models/DirectedGraph.java b/AlgebraicDataflowArchitectureModel/src/models/DirectedGraph.java new file mode 100644 index 0000000..3b9d1d3 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/DirectedGraph.java @@ -0,0 +1,67 @@ +package models; + +import java.util.HashSet; +import java.util.Set; + +public class DirectedGraph { + private Set nodes = null; + private Set edges = null; + + public DirectedGraph() { + nodes = new HashSet<>(); + edges = new HashSet<>(); + } + + public Set getNodes() { + return nodes; + } + + public void setNodes(Set nodes) { + this.nodes = nodes; + } + + public void addNode(Node node) { + nodes.add(node); + } + + public void removeNode(Node node) { + nodes.remove(node); + node.clearInEdges(); + node.clearOutEdges(); + for (Edge edge: edges) { + if (edge.getSource().equals(node)) { + edges.remove(edge); + } else if (edge.getDestination().equals(node)) { + edges.remove(edge); + } + } + } + + public Set getEdges() { + return edges; + } + + public void setEdges(Set edges) { + this.edges = edges; + for (Edge edge: edges) { + if (!nodes.contains(edge.getSource())) nodes.add(edge.getSource()); + if (!nodes.contains(edge.getDestination())) nodes.add(edge.getDestination()); + edge.getSource().addOutEdge(edge); + edge.getDestination().addInEdge(edge); + } + } + + public void addEdge(Edge edge) { + edges.add(edge); + if (!nodes.contains(edge.getSource())) nodes.add(edge.getSource()); + if (!nodes.contains(edge.getDestination())) nodes.add(edge.getDestination()); + edge.getSource().addOutEdge(edge); + edge.getDestination().addInEdge(edge); + } + + public void removeEdge(Edge edge) { + edges.remove(edge); + edge.getSource().removeOutEdge(edge); + edge.getDestination().removeInEdge(edge); + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/Edge.java b/AlgebraicDataflowArchitectureModel/src/models/Edge.java new file mode 100644 index 0000000..219b645 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/Edge.java @@ -0,0 +1,27 @@ +package models; + +public class Edge { + protected Node source; + protected Node destination; + + public Edge(Node src, Node dst) { + source = src; + destination = dst; + } + + public Node getSource() { + return source; + } + + public void setSource(Node source) { + this.source = source; + } + + public Node getDestination() { + return destination; + } + + public void setDestination(Node destination) { + this.destination = destination; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/Node.java b/AlgebraicDataflowArchitectureModel/src/models/Node.java new file mode 100644 index 0000000..53d7f69 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/Node.java @@ -0,0 +1,78 @@ +package models; + +import java.util.HashSet; +import java.util.Set; + +public class Node implements Cloneable { + private Set inEdges = null; + private Set outEdges = null; + + public Node() { + inEdges = new HashSet<>(); + outEdges = new HashSet<>(); + } + + public Set getInEdges() { + return inEdges; + } + + public void setInEdges(Set inEdges) { + this.inEdges = inEdges; + } + + public Set getOutEdges() { + return outEdges; + } + + public void setOutEdges(Set outEdges) { + this.outEdges = outEdges; + } + + public void addInEdge(Edge edge) { + inEdges.add(edge); + } + + public void addOutEdge(Edge edge) { + outEdges.add(edge); + } + + public void removeInEdge(Edge edge) { + inEdges.remove(edge); + } + + public void removeOutEdge(Edge edge) { + outEdges.remove(edge); + } + + public void clearInEdges() { + inEdges.clear(); + } + + public void clearOutEdges() { + outEdges.clear(); + } + + public int getIndegree() { + return inEdges.size(); + } + + public int getOutdegree() { + return outEdges.size(); + } + + public Set getPredecessors() { + Set predecessors = new HashSet(); + for (Edge edge: inEdges) { + predecessors.add(edge.getSource()); + } + return predecessors; + } + + public Set getSuccessors() { + Set successors = new HashSet(); + for (Edge edge: outEdges) { + successors.add(edge.getDestination()); + } + return successors; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelGenerator.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelGenerator.java new file mode 100644 index 0000000..ba04f70 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelGenerator.java @@ -0,0 +1,76 @@ +package models.dataConstraintModel; + +import java.util.HashSet; +import java.util.Set; + +public class ChannelGenerator { + protected Set groupSelectors = null; + protected Set channelSelectors = null; + protected Set channelMembers = null; + + public ChannelGenerator() { + groupSelectors = new HashSet<>(); + channelSelectors = new HashSet<>(); + channelMembers = new HashSet<>(); + } + + public Set getGroupSelectors() { + return groupSelectors; + } + + public void setGroupSelectors(Set groupSelectors) { + this.groupSelectors = groupSelectors; + } + + public void addGroupSelector(GroupSelector groupSelector) { + groupSelectors.add(groupSelector); + } + + public Set getChannelSelectors() { + return channelSelectors; + } + + public void setChannelSelectors(Set channelSelectors) { + this.channelSelectors = channelSelectors; + } + + public void addChannelSelector(ChannelSelector channelSelector) { + channelSelectors.add(channelSelector); + } + + public void addSelector(Selector selector) { + if (selector instanceof GroupSelector) { + groupSelectors.add((GroupSelector)selector); + } else if (selector instanceof ChannelSelector) { + channelSelectors.add((ChannelSelector)selector); + } + } + + public Set getChannelMembers() { + return channelMembers; + } + + public void setChannelMembers(Set channelMembers) { + this.channelMembers = channelMembers; + for (ChannelMember channelMember: channelMembers) { + for (Selector selector: channelMember.getSelectors()) { + addSelector(selector); + } + } + } + + public void addChannelMember(ChannelMember channelMember) { + channelMembers.add(channelMember); + for (Selector selector: channelMember.getSelectors()) { + addSelector(selector); + } + } + + public Set getIdentifierTemplates() { + Set identifierTemplates = new HashSet<>(); + for (ChannelMember member: channelMembers) { + identifierTemplates.add(member.getIdentifierTemplate()); + } + return identifierTemplates; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelMember.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelMember.java new file mode 100644 index 0000000..645b649 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelMember.java @@ -0,0 +1,35 @@ +package models.dataConstraintModel; + +import java.util.ArrayList; +import java.util.List; + +public class ChannelMember { + private IdentifierTemplate identifierTemplate = null; + private List selectors = null; + + public ChannelMember(IdentifierTemplate identifierTemplate) { + this.identifierTemplate = identifierTemplate; + selectors = new ArrayList<>(); + } + + public IdentifierTemplate getIdentifierTemplate() { + return identifierTemplate; + } + + public void setIdentifierTemplate(IdentifierTemplate identifierTemplate) { + this.identifierTemplate = identifierTemplate; + } + + public List getSelectors() { + return selectors; + } + + public void setSelectors(List selectors) { + this.selectors = selectors; + } + + public ChannelMember addSelector(Selector selector) { + selectors.add(selector); + return this; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelSelector.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelSelector.java new file mode 100644 index 0000000..daa5ec5 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/ChannelSelector.java @@ -0,0 +1,5 @@ +package models.dataConstraintModel; + +public class ChannelSelector extends Selector { + +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/DataConstraintModel.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/DataConstraintModel.java new file mode 100644 index 0000000..24b264b --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/DataConstraintModel.java @@ -0,0 +1,57 @@ +package models.dataConstraintModel; + +import java.util.HashSet; +import java.util.Set; + +public class DataConstraintModel { + protected Set identifierTemplates = null; + protected Set channelGenerators = null; + protected Set ioChannelGenerators = null; + + public DataConstraintModel() { + identifierTemplates = new HashSet<>(); + channelGenerators = new HashSet<>(); + ioChannelGenerators = new HashSet<>(); + } + + public Set getIdentifierTemplates() { + return identifierTemplates; + } + + public void setIdentifierTemplates(Set identifierTemplates) { + this.identifierTemplates = identifierTemplates; + } + + public Set getChannelGenerators() { + return channelGenerators; + } + + public void setChannelGenerators(Set channelGenerators) { + this.channelGenerators = channelGenerators; + for (ChannelGenerator g: channelGenerators) { + identifierTemplates.addAll(g.getIdentifierTemplates()); + + } + } + + public void addChannelGenerator(ChannelGenerator channelGenerator) { + channelGenerators.add(channelGenerator); + identifierTemplates.addAll(channelGenerator.getIdentifierTemplates()); + } + + public Set getIOChannelGenerators() { + return ioChannelGenerators; + } + + public void setIOChannelGenerators(Set ioChannelGenerators) { + this.ioChannelGenerators = ioChannelGenerators; + for (ChannelGenerator g: ioChannelGenerators) { + identifierTemplates.addAll(g.getIdentifierTemplates()); + } + } + + public void addIOChannelGenerator(ChannelGenerator ioChannelGenerator) { + ioChannelGenerators.add(ioChannelGenerator); + identifierTemplates.addAll(ioChannelGenerator.getIdentifierTemplates()); + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/GroupSelector.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/GroupSelector.java new file mode 100644 index 0000000..66e5731 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/GroupSelector.java @@ -0,0 +1,5 @@ +package models.dataConstraintModel; + +public class GroupSelector extends Selector { + +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/IdentifierTemplate.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/IdentifierTemplate.java new file mode 100644 index 0000000..9658a11 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/IdentifierTemplate.java @@ -0,0 +1,13 @@ +package models.dataConstraintModel; + +public class IdentifierTemplate { + int numParameters = 0; + + public IdentifierTemplate(int numParameters) { + this.numParameters =numParameters; + } + + public int getNumberOfParameters() { + return numParameters; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/Selector.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/Selector.java new file mode 100644 index 0000000..1794428 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/Selector.java @@ -0,0 +1,5 @@ +package models.dataConstraintModel; + +abstract public class Selector { + +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataFlowModel.java b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataFlowModel.java new file mode 100644 index 0000000..1d56e40 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataFlowModel.java @@ -0,0 +1,24 @@ +package models.dataFlowModel; + +import java.util.Set; + +import models.dataConstraintModel.ChannelGenerator; +import models.dataConstraintModel.DataConstraintModel; +import models.dataConstraintModel.IdentifierTemplate; + +public class DataFlowModel extends DataConstraintModel { + public ResourceDependencyGraph getResourceDependencyGraph() { + ResourceDependencyGraph resourceDependencyGraph = new ResourceDependencyGraph(); + for (ChannelGenerator channelGen: channelGenerators) { + DataflowChannelGenerator dfChannelGen = (DataflowChannelGenerator)channelGen; + Set inputResources = dfChannelGen.getInputIdentifierTemplates(); + Set outputResources = dfChannelGen.getOutputIdentifierTemplates(); + for (IdentifierTemplate in: inputResources) { + for (IdentifierTemplate out: outputResources) { + resourceDependencyGraph.addEdge(in ,out, dfChannelGen); + } + } + } + return resourceDependencyGraph; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataflowChannelGenerator.java b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataflowChannelGenerator.java new file mode 100644 index 0000000..5058708 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataflowChannelGenerator.java @@ -0,0 +1,66 @@ +package models.dataFlowModel; + +import java.util.HashSet; +import java.util.Set; + +import models.dataConstraintModel.*; + +public class DataflowChannelGenerator extends ChannelGenerator { + protected Set inputChannelMembers = null; + protected Set outputChannelMembers = null; + + public DataflowChannelGenerator() { + inputChannelMembers = new HashSet<>(); + outputChannelMembers = new HashSet<>(); + } + + public Set getInputChannelMembers() { + return inputChannelMembers; + } + + public void setInputChannelMembers(Set inputChannelMembers) { + this.inputChannelMembers = inputChannelMembers; + } + + public void addInputChannelMember(ChannelMember inputChannelMember) { + inputChannelMembers.add(inputChannelMember); + } + + public Set getOutputChannelMembers() { + return outputChannelMembers; + } + + public void setOutputChannelMembers(Set outputChannelMembers) { + this.outputChannelMembers = outputChannelMembers; + } + + public void addOutputChannelMember(ChannelMember outputChannelMember) { + outputChannelMembers.add(outputChannelMember); + } + + public void addChannelMemberAsInput(ChannelMember groupDependentResource) { + addChannelMember(groupDependentResource); + addInputChannelMember(groupDependentResource); + } + + public void addChannelMemberAsOutput(ChannelMember groupDependentResource) { + addChannelMember(groupDependentResource); + addOutputChannelMember(groupDependentResource); + } + + public Set getInputIdentifierTemplates() { + Set inputIdentifierTemplates = new HashSet<>(); + for (ChannelMember member: inputChannelMembers) { + inputIdentifierTemplates.add(member.getIdentifierTemplate()); + } + return inputIdentifierTemplates; + } + + public Set getOutputIdentifierTemplates() { + Set outputIdentifierTemplates = new HashSet<>(); + for (ChannelMember member: outputChannelMembers) { + outputIdentifierTemplates.add(member.getIdentifierTemplate()); + } + return outputIdentifierTemplates; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceDependency.java b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceDependency.java new file mode 100644 index 0000000..63adf94 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceDependency.java @@ -0,0 +1,16 @@ +package models.dataFlowModel; + +import models.*; + +public class ResourceDependency extends Edge { + protected DataflowChannelGenerator channelGenerator = null; + + public ResourceDependency(ResourceNode src, ResourceNode dst, DataflowChannelGenerator channelGenerator) { + super(src, dst); + this.channelGenerator = channelGenerator; + } + + public DataflowChannelGenerator getChannelGenerator() { + return channelGenerator; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceDependencyGraph.java b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceDependencyGraph.java new file mode 100644 index 0000000..0d00839 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceDependencyGraph.java @@ -0,0 +1,32 @@ +package models.dataFlowModel; + +import java.util.HashMap; +import java.util.Map; + +import models.DirectedGraph; +import models.dataConstraintModel.IdentifierTemplate; + +public class ResourceDependencyGraph extends DirectedGraph { + protected Map nodeMap = null; + + public ResourceDependencyGraph() { + super(); + nodeMap = new HashMap<>(); + } + + public void addEdge(IdentifierTemplate in, IdentifierTemplate out, DataflowChannelGenerator dfChannelGen) { + ResourceNode srcNode = nodeMap.get(in); + if (srcNode == null) { + srcNode = new ResourceNode(in); + addNode(srcNode); + nodeMap.put(in, srcNode); + } + ResourceNode dstNode = nodeMap.get(out); + if (dstNode == null) { + dstNode = new ResourceNode(out); + addNode(dstNode); + nodeMap.put(out, dstNode); + } + addEdge(new ResourceDependency(srcNode, dstNode, dfChannelGen)); + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceNode.java b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceNode.java new file mode 100644 index 0000000..4097971 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/ResourceNode.java @@ -0,0 +1,22 @@ +package models.dataFlowModel; + +import models.Node; +import models.dataConstraintModel.IdentifierTemplate; + +public class ResourceNode extends Node { + protected IdentifierTemplate identifierTemplate = null; + + public ResourceNode(IdentifierTemplate identifierTemplate) { + this.identifierTemplate = identifierTemplate; + } + + public IdentifierTemplate getIdentifierTemplate() { + return identifierTemplate; + } + + public boolean equals(Object another) { + if (this == another) return true; + if (!(another instanceof ResourceNode)) return false; + return identifierTemplate.equals(((ResourceNode)another).identifierTemplate); + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/tests/DataConstraintModelTest.java b/AlgebraicDataflowArchitectureModel/src/tests/DataConstraintModelTest.java new file mode 100644 index 0000000..264ccdf --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/tests/DataConstraintModelTest.java @@ -0,0 +1,59 @@ +package tests; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import models.dataConstraintModel.*; + +public class DataConstraintModelTest { + + @Test + public void test() { + // Construct a data constraint architecture model. + DataConstraintModel model = new DataConstraintModel(); + IdentifierTemplate customer_off = new IdentifierTemplate(1); + IdentifierTemplate customer_add = new IdentifierTemplate(1); + IdentifierTemplate company_add = new IdentifierTemplate(1); + + ChannelGenerator gin_1 = new ChannelGenerator(); // set customer's office + GroupSelector x1 = new GroupSelector(); + ChannelMember customer_off_1 = new ChannelMember(customer_off); + customer_off_1.addSelector(x1); + gin_1.addChannelMember(customer_off_1); + assertEquals(customer_off.getNumberOfParameters(), customer_off_1.getSelectors().size()); + + ChannelGenerator gin_2 = new ChannelGenerator(); // set companie's address + GroupSelector x2 = new GroupSelector(); + ChannelMember company_add_1 = new ChannelMember(company_add); + company_add_1.addSelector(x2); + gin_2.addChannelMember(company_add_1); + assertEquals(company_add.getNumberOfParameters(), company_add_1.getSelectors().size()); + + ChannelGenerator g = new ChannelGenerator(); // update customer's address + GroupSelector x3 = new GroupSelector(); + ChannelSelector y = new ChannelSelector(); + ChannelMember customer_off_2 = new ChannelMember(customer_off); + ChannelMember company_add_2 = new ChannelMember(company_add); + ChannelMember customer_add_2 = new ChannelMember(customer_add); + customer_off_2.addSelector(x3); + company_add_2.addSelector(y); + customer_add_2.addSelector(x3); + g.addChannelMember(customer_off_2); + g.addChannelMember(customer_add_2); + g.addChannelMember(company_add_2); + assertEquals(customer_off.getNumberOfParameters(), customer_off_2.getSelectors().size()); + assertEquals(customer_add.getNumberOfParameters(), customer_add_2.getSelectors().size()); + assertEquals(company_add.getNumberOfParameters(), company_add_2.getSelectors().size()); + + model.addIOChannelGenerator(gin_1); + model.addIOChannelGenerator(gin_2); + model.addChannelGenerator(g); + + // Check the model. + assertEquals(3, model.getIdentifierTemplates().size()); + assertEquals(2, model.getIOChannelGenerators().size()); + assertEquals(1, model.getChannelGenerators().size()); + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/tests/DataFlowModelTest.java b/AlgebraicDataflowArchitectureModel/src/tests/DataFlowModelTest.java new file mode 100644 index 0000000..d2b8e9d --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/tests/DataFlowModelTest.java @@ -0,0 +1,71 @@ +package tests; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import models.*; +import models.dataConstraintModel.*; +import models.dataFlowModel.*; + +public class DataFlowModelTest { + + @Test + public void test() { + // Construct a dataflow architecture model. + DataFlowModel model = new DataFlowModel(); + IdentifierTemplate customer_off = new IdentifierTemplate(1); + IdentifierTemplate customer_add = new IdentifierTemplate(1); + IdentifierTemplate company_add = new IdentifierTemplate(1); + + DataflowChannelGenerator gin_1 = new DataflowChannelGenerator(); // set customer's office + GroupSelector x1 = new GroupSelector(); + ChannelMember customer_off_1 = new ChannelMember(customer_off); + customer_off_1.addSelector(x1); + gin_1.addChannelMember(customer_off_1); + assertEquals(customer_off.getNumberOfParameters(), customer_off_1.getSelectors().size()); + + DataflowChannelGenerator gin_2 = new DataflowChannelGenerator(); // set companie's address + GroupSelector x2 = new GroupSelector(); + ChannelMember company_add_1 = new ChannelMember(company_add); + company_add_1.addSelector(x2); + gin_2.addChannelMember(company_add_1); + assertEquals(company_add.getNumberOfParameters(), company_add_1.getSelectors().size()); + + DataflowChannelGenerator g = new DataflowChannelGenerator(); // update customer's address + GroupSelector x3 = new GroupSelector(); + ChannelSelector y = new ChannelSelector(); + ChannelMember customer_off_2 = new ChannelMember(customer_off); + ChannelMember company_add_2 = new ChannelMember(company_add); + ChannelMember customer_add_2 = new ChannelMember(customer_add); + customer_off_2.addSelector(x3); + company_add_2.addSelector(y); + customer_add_2.addSelector(x3); + g.addChannelMemberAsInput(customer_off_2); + g.addChannelMemberAsInput(customer_add_2); + g.addChannelMemberAsOutput(company_add_2); + assertEquals(customer_off.getNumberOfParameters(), customer_off_2.getSelectors().size()); + assertEquals(customer_add.getNumberOfParameters(), customer_add_2.getSelectors().size()); + assertEquals(company_add.getNumberOfParameters(), company_add_2.getSelectors().size()); + + model.addIOChannelGenerator(gin_1); + model.addIOChannelGenerator(gin_2); + model.addChannelGenerator(g); + + // Check the model. + assertEquals(3, model.getIdentifierTemplates().size()); + assertEquals(2, model.getIOChannelGenerators().size()); + assertEquals(1, model.getChannelGenerators().size()); + + // Extract the resource dependency graph. + ResourceDependencyGraph resourceDependencyGraph = model.getResourceDependencyGraph(); + + // Check the graph. + assertEquals(3, resourceDependencyGraph.getNodes().size()); + assertEquals(2, resourceDependencyGraph.getEdges().size()); + for (Edge e: resourceDependencyGraph.getEdges()) { + System.out.println(e.getSource() + "->" + e.getDestination()); + } + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/tests/DirectedGraphTest.java b/AlgebraicDataflowArchitectureModel/src/tests/DirectedGraphTest.java new file mode 100644 index 0000000..4f6db8e --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/tests/DirectedGraphTest.java @@ -0,0 +1,60 @@ +package tests; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import models.*; + +public class DirectedGraphTest { + + @Test + public void test() { + // Build a directed graph. + DirectedGraph g = new DirectedGraph(); + Node n1 = new Node(); + Node n2 = new Node(); + Node n3 = new Node(); + Node n4 = new Node(); + Edge e1 = new Edge(n1, n2); + Edge e2 = new Edge(n2, n3); + Edge e3 = new Edge(n3, n4); + Edge e4 = new Edge(n4, n1); + Edge e5 = new Edge(n1, n3); + g.addEdge(e1); + g.addEdge(e2); + g.addEdge(e3); + g.addEdge(e4); + g.addEdge(e5); + // Check the number of nodes. + assertEquals(4, g.getNodes().size()); + // Check the number of edges. + assertEquals(5, g.getEdges().size()); + // Check indegrees and outdegrees. + assertEquals(1, n1.getIndegree()); + assertEquals(2, n1.getOutdegree()); + assertEquals(1, n2.getIndegree()); + assertEquals(1, n2.getOutdegree()); + assertEquals(2, n3.getIndegree()); + assertEquals(1, n3.getOutdegree()); + assertEquals(1, n4.getIndegree()); + assertEquals(1, n4.getOutdegree()); + + // Remove an edge. + g.removeEdge(e5); + // Re-check the number of nodes. + assertEquals(4, g.getNodes().size()); + // Re-check the number of edges. + assertEquals(4, g.getEdges().size()); + // Re-check indegrees and outdegrees. + assertEquals(1, n1.getIndegree()); + assertEquals(1, n1.getOutdegree()); + assertEquals(1, n2.getIndegree()); + assertEquals(1, n2.getOutdegree()); + assertEquals(1, n3.getIndegree()); + assertEquals(1, n3.getOutdegree()); + assertEquals(1, n4.getIndegree()); + assertEquals(1, n4.getOutdegree()); + } + +}