Changeset 7439


Ignore:
Timestamp:
12/17/10 16:20:26 (9 years ago)
Author:
aivar
Message:

Renamed XMLTest to SerializeDeserializeTest. Made TestComponent really read/write XML.

Location:
branches/maven/projects/deep-zoom-plugin/src/test/java/loci/workflow
Files:
1 deleted
3 edited

Legend:

Unmodified
Added
Removed
  • branches/maven/projects/deep-zoom-plugin/src/test/java/loci/workflow/SerializeDeserializeTest.java

    r7436 r7439  
    4040     * Round trip to/from XML. 
    4141     */ 
    42     public void testXML() 
     42    public void testSerialization() 
    4343    { 
    4444        TestComponent testComponentA = new TestComponent(); 
     
    4646        testComponentA.setInputNames(new String[] { "ONE", "TWO" }); 
    4747        testComponentA.setOutputNames(new String[] { Output.DEFAULT }); 
    48         testComponentA.setXML(XML_A); 
    4948        TestComponent testComponentB = new TestComponent(); 
    5049        testComponentB.setName("B"); 
    5150        testComponentB.setInputNames(new String[] { Input.DEFAULT } ); 
    5251        testComponentB.setOutputNames(new String[] { Output.DEFAULT }); 
    53         testComponentB.setXML(XML_B); 
    5452 
    55         TestComponentFactory componentFactory = new TestComponentFactory(); 
    56         componentFactory.set(XML_A, testComponentA); 
    57         componentFactory.set(XML_B, testComponentB); 
     53        TestComponentFactory componentFactory = TestComponentFactory.getInstance(); 
    5854 
    5955        WorkFlow workFlow1 = new WorkFlow(); 
    6056        workFlow1.setName("workFlow1"); 
    6157        workFlow1.setComponentFactory(componentFactory); 
    62         System.out.println("just set component factory"); 
    6358        workFlow1.add(testComponentA); 
    6459        workFlow1.add(testComponentB); 
     
    6964 
    7065        String xml1 = workFlow1.toXML(); 
    71         System.out.println("workFlow1 XML:\n" + xml1); 
     66        System.out.println("workFlow1 XML [\n" + xml1 + "]"); 
    7267 
    7368        WorkFlow workFlow2 = new WorkFlow(); 
     
    7570        String xml2 = workFlow2.toXML(); 
    7671 
    77         System.out.println("workFlow2 XML:\n" + xml2); 
     72        System.out.println("workFlow2 XML [\n" + xml2 + "]"); 
    7873 
    7974        assertTrue(xml1.equals(xml2)); 
  • branches/maven/projects/deep-zoom-plugin/src/test/java/loci/workflow/TestComponent.java

    r7430 r7439  
    66package loci.workflow; 
    77 
    8 import junit.framework.Assert; 
    9 import junit.framework.Test; 
    10 import junit.framework.TestCase; 
    11 import junit.framework.TestSuite; 
     8import java.util.ArrayList; 
     9import java.util.List; 
     10 
    1211 
    1312import loci.plugin.ImageWrapper; 
     13import loci.plugin.annotations.Input; 
     14import loci.plugin.annotations.Output; 
     15import loci.util.xmllight.XMLException; 
     16import loci.util.xmllight.XMLParser; 
     17import loci.util.xmllight.XMLTag; 
     18import loci.util.xmllight.XMLWriter; 
    1419 
    1520/** 
     
    1823 */ 
    1924public class TestComponent implements IComponent { 
     25    public static final String TESTCOMPONENT = "testcomponent"; 
    2026    String m_name; 
    21     String m_xml; 
    22     String[] m_inputNames; 
    23     String[] m_outputNames; 
    24  
    25     // TEST SETUP METHODS 
    26  
    27     public void setXML(String xml) { 
    28         m_xml = xml; 
    29     } 
     27    List<String> m_inputNames = new ArrayList<String>(); 
     28    List<String> m_outputNames = new ArrayList<String>(); 
    3029 
    3130    public void setInputNames(String[] inputNames) { 
    32         m_inputNames = inputNames; 
     31        for (String name: inputNames) { 
     32            m_inputNames.add(name); 
     33        } 
    3334    } 
    3435 
    3536    public void setOutputNames(String[] outputNames) { 
    36         m_outputNames = outputNames; 
     37        for (String name: outputNames) { 
     38            m_outputNames.add(name); 
     39        } 
    3740    } 
    3841 
     
    6164     */ 
    6265    public String toXML() { 
    63         return m_xml; 
     66        StringBuilder xmlBuilder = new StringBuilder(); 
     67        XMLWriter xmlHelper = new XMLWriter(xmlBuilder); 
     68 
     69        // add workflow tag and name 
     70        xmlHelper.addTag(TESTCOMPONENT); 
     71        xmlHelper.addTagWithContent(WorkFlow.NAME, getName()); 
     72 
     73        // add inputs 
     74        xmlHelper.addTag(WorkFlow.INPUTS); 
     75        for (String name : m_inputNames) { 
     76            xmlHelper.addTag(WorkFlow.INPUT); 
     77            xmlHelper.addTagWithContent(WorkFlow.NAME, name); 
     78            xmlHelper.addEndTag(WorkFlow.INPUT); 
     79        } 
     80        xmlHelper.addEndTag(WorkFlow.INPUTS); 
     81 
     82        // add outputs 
     83        xmlHelper.addTag(WorkFlow.OUTPUTS); 
     84        for (String name : m_outputNames) { 
     85            xmlHelper.addTag(WorkFlow.OUTPUT); 
     86            xmlHelper.addTagWithContent(WorkFlow.NAME, name); 
     87            xmlHelper.addEndTag(WorkFlow.OUTPUT); 
     88        } 
     89        xmlHelper.addEndTag(WorkFlow.OUTPUTS); 
     90 
     91        // end workflow 
     92        xmlHelper.addEndTag(TESTCOMPONENT); 
     93 
     94        return xmlBuilder.toString(); 
    6495    } 
    6596 
     
    71102     */ 
    72103    public boolean fromXML(String xml) { 
    73         boolean success = xml.equals(m_xml); 
    74         Assert.assertTrue(success); 
     104        boolean success = false; 
     105        XMLParser xmlHelper = new XMLParser(); 
     106 
     107        try { 
     108            // handle test tag and name 
     109            // 
     110            // <testcomponent> 
     111            //   <name>A</name> 
     112 
     113            XMLTag tag = xmlHelper.getNextTag(xml); 
     114            if (!TESTCOMPONENT.equals(tag.getName())) { 
     115                throw new XMLException("Missing <testcomponent> tag"); 
     116            } 
     117            xml = tag.getContent(); 
     118            tag = xmlHelper.getNextTag(xml); 
     119            if (!WorkFlow.NAME.equals(tag.getName())) { 
     120                throw new XMLException("Missing <name> for <workflow>"); 
     121            } 
     122            setName(tag.getContent()); 
     123            xml = tag.getRemainder(); 
     124 
     125            // handle inputs 
     126            // 
     127            //  <inputs> 
     128            //    <input> 
     129            //      <name>RED</name> 
     130            //   </input> 
     131            // </inputs> 
     132 
     133            tag = xmlHelper.getNextTag(xml); 
     134            if (!WorkFlow.INPUTS.equals(tag.getName())) { 
     135                throw new XMLException("Missing <inputs> within <testcomponent>"); 
     136            } 
     137            String inputsXML = tag.getContent(); 
     138            xml = tag.getRemainder(); 
     139            while (!inputsXML.isEmpty()) { 
     140                tag = xmlHelper.getNextTag(inputsXML); 
     141                inputsXML = tag.getRemainder(); 
     142 
     143                if (tag.getName().isEmpty()) { //TODO don't think these are necessary 
     144                    break; 
     145                } 
     146 
     147                if (!WorkFlow.INPUT.equals(tag.getName())) { 
     148                    throw new XMLException("Missing <input> within <inputs"); 
     149                } 
     150                String inputXML = tag.getContent(); 
     151 
     152                tag = xmlHelper.getNextTag(inputXML); 
     153                inputXML = tag.getRemainder(); 
     154 
     155                if (!WorkFlow.NAME.equals(tag.getName())) { 
     156                    throw new XMLException("Missing <name> within <input>"); 
     157                } 
     158                String inName = tag.getContent(); 
     159 
     160                m_inputNames.add(inName); 
     161            } 
     162 
     163 
     164            // handle outputs 
     165            //  <outputs> 
     166            //    <output> 
     167            //      <name>OUTPUT</name> 
     168            //    </output> 
     169            //  </outputs> 
     170            tag = xmlHelper.getNextTag(xml); 
     171            if (!WorkFlow.OUTPUTS.equals(tag.getName())) { 
     172                throw new XMLException("Missing <outputs> within <testcomponent>"); 
     173            } 
     174            String outputsXML = tag.getContent(); 
     175            xml = tag.getRemainder(); 
     176            while (!outputsXML.isEmpty()) { 
     177                tag = xmlHelper.getNextTag(outputsXML); 
     178                outputsXML = tag.getRemainder(); 
     179 
     180                if (tag.getName().isEmpty()) { //TODO don't think these are necessary 
     181                    break; 
     182                } 
     183 
     184                if (!WorkFlow.OUTPUT.equals(tag.getName())) { 
     185                    throw new XMLException("Missing <output> within <outputs>"); 
     186                } 
     187                String outputXML = tag.getContent(); 
     188 
     189                tag = xmlHelper.getNextTag(outputXML); 
     190                outputXML = tag.getRemainder(); 
     191 
     192                if (!WorkFlow.NAME.equals(tag.getName())) { 
     193                    throw new XMLException("Missing <name> within <output>"); 
     194                } 
     195                String outName = tag.getContent(); 
     196                m_outputNames.add(outName); 
     197            } 
     198            success = true; 
     199        } 
     200        catch (XMLException e) { 
     201            System.out.println("XML Exception"); 
     202        } 
    75203        return success; 
    76204    } 
     
    82210     */ 
    83211    public String[] getInputNames() { 
    84         return m_inputNames; 
     212        return m_inputNames.toArray(new String[0]); 
    85213    } 
    86214 
     
    91219     */ 
    92220    public String[] getOutputNames() { 
    93         return m_outputNames; 
    94     } 
    95  
    96     /** 
     221        return m_outputNames.toArray(new String[0]); 
     222    } 
     223 
     224   /** 
    97225     * Furnish input image 
    98226     * 
    99227     * @param image 
     228     */ 
     229    public void input(ImageWrapper image) { 
     230        input(image, Input.DEFAULT); 
     231    } 
     232 
     233    /** 
     234     * Furnish input image 
     235     * 
     236     * @param image 
    100237     * @param name 
    101238     */ 
    102239    public void input(ImageWrapper image, String name) { 
    103  
     240        //TODO 
    104241    } 
    105242 
     
    110247     * @param listener 
    111248     */ 
     249    public void setOutputListener(IOutputListener listener) { 
     250        setOutputListener(Output.DEFAULT, listener); 
     251    } 
     252    /** 
     253     * Listen for output image. 
     254     * 
     255     * @param name 
     256     * @param listener 
     257     */ 
    112258    public void setOutputListener(String name, IOutputListener listener) { 
    113          
    114     } 
    115  
     259        //TODO 
     260    } 
    116261} 
  • branches/maven/projects/deep-zoom-plugin/src/test/java/loci/workflow/TestComponentFactory.java

    r7437 r7439  
    66package loci.workflow; 
    77 
    8 import loci.util.xml.XMLParser; 
    9 import loci.util.xml.XMLException; 
    10 import loci.util.xml.XMLTag; 
    11 import java.util.HashMap; 
    12 import java.util.Map; 
     8import loci.util.xmllight.XMLParser; 
     9import loci.util.xmllight.XMLException; 
     10import loci.util.xmllight.XMLTag; 
    1311 
    1412/** 
    1513 * 
    16  * @author aivar 
     14 * @author Aivar Grislis 
    1715 */ 
    1816public class TestComponentFactory implements IComponentFactory { 
    19     private static Map<String, IComponent> s_map = new HashMap<String, IComponent>(); 
     17    private static TestComponentFactory s_instance = null; 
     18     
     19    private TestComponentFactory() { 
     20    } 
     21 
     22    public static synchronized TestComponentFactory getInstance() { 
     23        if (null == s_instance) { 
     24            s_instance = new TestComponentFactory(); 
     25        } 
     26        return s_instance; 
     27    } 
    2028 
    2129    public IComponent create(String xml) throws XMLException { 
    2230        IComponent component = null; 
    2331        XMLParser xmlHelper = new XMLParser(); 
    24         XMLTag tag = xmlHelper.getNextTagInclusive(xml); 
     32        XMLTag tag = xmlHelper.getNextTag(xml); 
    2533        if (WorkFlow.WORKFLOW.equals(tag.getName())) { 
    26             component = WorkFlowFactory.create(tag.getContent()); 
     34            component = WorkFlowFactory.getInstance().create(xml); 
    2735 
    2836        } 
    29         else { //TODO if (WorkFlow.COMPONENT.equals(tag.getName())) { 
    30             component = s_map.get(xml); 
     37        else if (TestComponent.TESTCOMPONENT.equals(tag.getName())) { 
     38            component = new TestComponent(); 
     39            component.fromXML(xml); 
    3140        } 
    32         //else { 
    33         //    throw new XMLException("Invalid tag " + tag.getName()); 
    34         //} 
     41        else { 
     42            throw new XMLException("Invalid tag " + tag.getName()); 
     43        } 
    3544        return component; 
    3645    } 
    37  
    38     void set(String xml, IComponent component) { 
    39         System.out.println("put [" + xml + "] " + component.getName()); 
    40         s_map.put(xml, component); 
    41     } 
    4246} 
Note: See TracChangeset for help on using the changeset viewer.