package net.sf.taverna.t2.workbench.file.importworkflow; | |
import static org.junit.Assert.assertEquals; | |
import static org.junit.Assert.assertNotNull; | |
import static org.junit.Assert.assertTrue; | |
import java.io.InputStream; | |
import java.util.HashSet; | |
import java.util.List; | |
import java.util.Set; | |
import org.junit.Before; | |
import uk.org.taverna.scufl2.api.common.Scufl2Tools; | |
import uk.org.taverna.scufl2.api.container.WorkflowBundle; | |
import uk.org.taverna.scufl2.api.core.BlockingControlLink; | |
import uk.org.taverna.scufl2.api.core.ControlLink; | |
import uk.org.taverna.scufl2.api.core.DataLink; | |
import uk.org.taverna.scufl2.api.core.Processor; | |
import uk.org.taverna.scufl2.api.core.Workflow; | |
import uk.org.taverna.scufl2.api.io.WorkflowBundleIO; | |
import uk.org.taverna.scufl2.api.port.InputWorkflowPort; | |
import uk.org.taverna.scufl2.api.port.OutputWorkflowPort; | |
import uk.org.taverna.scufl2.api.port.ProcessorPort; | |
import uk.org.taverna.scufl2.api.port.ReceiverPort; | |
import uk.org.taverna.scufl2.api.port.SenderPort; | |
public abstract class AbstractTestHelper { | |
private static final String Q_T2FLOW = "/q.t2flow"; | |
private static final String ABC_T2FLOW = "/abc.t2flow"; | |
private static final String P_T2FLOW = "/p.t2flow"; | |
private WorkflowBundleIO workflowBundleIO = new WorkflowBundleIO(); | |
protected Scufl2Tools scufl2Tools = new Scufl2Tools(); | |
protected Workflow abc; | |
protected Workflow p; | |
protected Workflow q; | |
protected void assertHasConditionals(Workflow dataflow, | |
String... expectedConditionalDef) { | |
Set<String> expectedConditionals = new HashSet<String>(); | |
for (String expected : expectedConditionalDef) { | |
expectedConditionals.add(expected); | |
} | |
Set<String> foundConditionals = new HashSet<String>(); | |
for (ControlLink c : dataflow.getControlLinks()) { | |
if (c instanceof BlockingControlLink) { | |
BlockingControlLink bcl = (BlockingControlLink) c; | |
foundConditionals.add(bcl.getUntilFinished().getName() + ";" | |
+ bcl.getBlock().getName()); | |
} | |
} | |
Set<String> extras = new HashSet<String>(foundConditionals); | |
extras.removeAll(expectedConditionals); | |
assertTrue("Unexpected conditional " + extras, extras.isEmpty()); | |
Set<String> missing = new HashSet<String>(expectedConditionals); | |
missing.removeAll(foundConditionals); | |
assertTrue("Could not find conditional " + missing, missing.isEmpty()); | |
} | |
protected void assertHasDatalinks(Workflow dataflow, | |
String... expectedLinkDef) { | |
Set<String> expectedLinks = new HashSet<String>(); | |
for (String expected : expectedLinkDef) { | |
expectedLinks.add(expected); | |
} | |
Set<String> foundLinks = new HashSet<String>(); | |
for (DataLink link : dataflow.getDataLinks()) { | |
StringBuilder linkRef = new StringBuilder(); | |
SenderPort source = link.getReceivesFrom(); | |
if (source instanceof ProcessorPort) { | |
linkRef.append(((ProcessorPort) source).getParent() | |
.getName()); | |
linkRef.append('.'); | |
} | |
linkRef.append(source.getName()); | |
linkRef.append("->"); | |
ReceiverPort sink = link.getSendsTo(); | |
if (sink instanceof ProcessorPort) { | |
linkRef.append(((ProcessorPort) sink).getParent() | |
.getName()); | |
linkRef.append('.'); | |
} | |
linkRef.append(sink.getName()); | |
String linkStr = linkRef.toString(); | |
foundLinks.add(linkStr); | |
} | |
Set<String> extras = new HashSet<String>(foundLinks); | |
extras.removeAll(expectedLinks); | |
assertTrue("Unexpected links " + extras, extras.isEmpty()); | |
Set<String> missing = new HashSet<String>(expectedLinks); | |
missing.removeAll(foundLinks); | |
assertTrue("Could not find links " + missing, missing.isEmpty()); | |
} | |
protected void assertHasInputPorts(Workflow dataflow, | |
String... expectedInputPorts) { | |
Set<String> expectedNames = new HashSet<String>(); | |
for (String expected : expectedInputPorts) { | |
expectedNames.add(expected); | |
} | |
Set<String> foundNames = new HashSet<String>(); | |
for (InputWorkflowPort port : dataflow.getInputPorts()) { | |
String name = port.getName(); | |
foundNames.add(name); | |
} | |
Set<String> extras = new HashSet<String>(foundNames); | |
extras.removeAll(expectedNames); | |
assertTrue("Unexpected input port " + extras, extras.isEmpty()); | |
Set<String> missing = new HashSet<String>(expectedNames); | |
missing.removeAll(foundNames); | |
assertTrue("Could not find input port " + missing, missing.isEmpty()); | |
} | |
protected void assertHasOutputPorts(Workflow dataflow, | |
String... expectedOutputPorts) { | |
Set<String> expectedNames = new HashSet<String>(); | |
for (String expected : expectedOutputPorts) { | |
expectedNames.add(expected); | |
} | |
Set<String> foundNames = new HashSet<String>(); | |
for (OutputWorkflowPort port : dataflow.getOutputPorts()) { | |
String name = port.getName(); | |
foundNames.add(name); | |
} | |
Set<String> extras = new HashSet<String>(foundNames); | |
extras.removeAll(expectedNames); | |
assertTrue("Unexpected output port " + extras, extras.isEmpty()); | |
Set<String> missing = new HashSet<String>(expectedNames); | |
missing.removeAll(foundNames); | |
assertTrue("Could not find output port " + missing, missing.isEmpty()); | |
} | |
protected void assertHasProcessors(Workflow dataflow, | |
String... expectedProcessors) { | |
Set<String> expectedNames = new HashSet<String>(); | |
for (String expected : expectedProcessors) { | |
expectedNames.add(expected); | |
} | |
Set<String> foundNames = new HashSet<String>(); | |
for (Processor proc : dataflow.getProcessors()) { | |
String processorName = proc.getName(); | |
foundNames.add(processorName); | |
} | |
Set<String> extras = new HashSet<String>(foundNames); | |
extras.removeAll(expectedNames); | |
assertTrue("Unexpected processor " + extras, extras.isEmpty()); | |
Set<String> missing = new HashSet<String>(expectedNames); | |
missing.removeAll(foundNames); | |
assertTrue("Could not find processor " + missing, missing.isEmpty()); | |
} | |
protected void checkAbc() throws Exception { | |
assertHasProcessors(abc, "A", "B", "C"); | |
assertHasInputPorts(abc, "in1", "in2"); | |
assertHasOutputPorts(abc, "a", "b", "c"); | |
assertHasDatalinks(abc, "in2->B.inputlist", "in1->A.string1", | |
"in2->A.string2", "Merge0:Merge0_output->C.inputlist", | |
"A.output->a", "B.outputlist->b", | |
"B.outputlist->Merge0:outputlistToMerge0_input0", | |
"A.output->Merge0:outputToMerge0_input0", "C.outputlist->c"); | |
assertHasConditionals(abc, "A;B"); | |
} | |
protected void checkP() throws Exception { | |
assertHasProcessors(p, "P"); | |
assertHasInputPorts(p, "i"); | |
assertHasOutputPorts(p, "o"); | |
assertHasDatalinks(p, "i->P.inputlist", "P.outputlist->o"); | |
assertHasConditionals(p); | |
} | |
protected void checkQ() throws Exception { | |
assertHasProcessors(q, "Q"); | |
assertHasInputPorts(q, "p"); | |
assertHasOutputPorts(q, "p", "q"); | |
assertHasDatalinks(q, "p->Q.inputlist", "Q.outputlist->q", "p->p"); | |
assertHasConditionals(q); | |
List<DataLink> datalinksTo = scufl2Tools.datalinksTo(findOutputPort(q, "p")); | |
assertEquals(1, datalinksTo.size()); | |
SenderPort source = datalinksTo.get(0).getReceivesFrom(); | |
assertEquals("out port P not linked to input P", source, findInputPort(q, "p")); | |
} | |
protected Workflow loadAbc() throws Exception { | |
return openWorkflow(getClass().getResourceAsStream(ABC_T2FLOW)); | |
} | |
protected Workflow loadP() throws Exception { | |
return openWorkflow(getClass().getResourceAsStream(P_T2FLOW)); | |
} | |
protected Workflow loadQ() throws Exception { | |
return openWorkflow(getClass().getResourceAsStream(Q_T2FLOW)); | |
} | |
@Before | |
public void loadWorkflows() throws Exception { | |
abc = loadAbc(); | |
p = loadP(); | |
q = loadQ(); | |
} | |
protected Workflow openWorkflow(InputStream workflowXMLstream) throws Exception { | |
assertNotNull(workflowXMLstream); | |
WorkflowBundle workflowBundle = workflowBundleIO.readBundle(workflowXMLstream, "application/vnd.taverna.t2flow+xml"); | |
return workflowBundle.getMainWorkflow(); | |
} | |
protected InputWorkflowPort findInputPort(Workflow wf, String name) { | |
for (InputWorkflowPort inp : wf.getInputPorts()) { | |
if (inp.getName().equals(name)) { | |
return inp; | |
} | |
} | |
throw new IllegalArgumentException("Unknown input port: " + name); | |
} | |
protected OutputWorkflowPort findOutputPort(Workflow wf, String name) { | |
for (OutputWorkflowPort outp : wf.getOutputPorts()) { | |
if (outp.getName().equals(name)) { | |
return outp; | |
} | |
} | |
throw new IllegalArgumentException("Unknown output port: " + name); | |
} | |
protected Processor findProcessor(Workflow wf, String name) { | |
for (Processor proc : wf.getProcessors()) { | |
if (proc.getName().equals(name)) { | |
return proc; | |
} | |
} | |
throw new IllegalArgumentException("Unknown processor: " + name); | |
} | |
} |