Changeset 16254

Show
Ignore:
Timestamp:
17/07/08 17:34:40 (1 month ago)
Author:
kmr
Message:

Fixed fasta exporter so that extra FASTA header fields can be configured by
adding to the select list.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/bio/webapp/src/org/intermine/bio/web/export/GFF3Exporter.java

    r15326 r16254  
    2828import org.intermine.web.logic.export.ExportHelper; 
    2929import org.intermine.web.logic.export.Exporter; 
     30import org.intermine.web.logic.results.Column; 
    3031import org.intermine.web.logic.results.ResultElement; 
    3132 
    3233/** 
    33  * Exports LocatedSequenceFeature objects in GFF3 format.  
     34 * Exports LocatedSequenceFeature objects in GFF3 format. 
    3435 * @author Kim Rutherford 
    3536 * @author Jakub Kulaviak 
    …… 
    6061     * {@inheritDoc} 
    6162     */ 
    62     public void export(List<List<ResultElement>> results) { 
     63    public void export(List<List<ResultElement>> results, 
     64                       @SuppressWarnings("unused") List<Column> columns) { 
    6365        if (featureIndexes.size() == 0) { 
    6466            throw new ExportException("No columns with sequence."); 
    …… 
    7577    } 
    7678 
    77     private void exportRow(List<ResultElement> row) throws ObjectStoreException,  
     79    private void exportRow(List<ResultElement> row) 
     80        throws ObjectStoreException, 
    7881        IllegalAccessException { 
    7982        ResultElement el = getResultElement(row); 
    …… 
    8386 
    8487        LocatedSequenceFeature lsf = (LocatedSequenceFeature) el.getInterMineObject(); 
    85          
     88 
    8689        if (exportedIds.contains(lsf.getId())) { 
    8790            return; 
    88         }  
    89          
     91        } 
     92 
    9093        Map<String, List<String>> extraAttributes = new HashMap<String, List<String>>(); 
    9194 
    …… 
    116119            headerPrinted = true; 
    117120        } 
    118          
     121 
    119122        out.println(gff3Record.toGFF3()); 
    120123        exportedIds.add(lsf.getId()); 
    …… 
    139142        return canExportStatic(clazzes); 
    140143    } 
    141      
    142     /* Method must have different name than canExport because canExport() method  
     144 
     145    /* Method must have different name than canExport because canExport() method 
    143146     * is  inherited from Exporter interface */ 
    144147    /** 
    145148     * @param clazzes classes of result row 
    146      * @return true if this exporter can export result composed of specified classes  
    147      */     
     149     * @return true if this exporter can export result composed of specified classes 
     150     */ 
    148151    public static boolean canExportStatic(List<Class> clazzes) { 
    149152        return ExportHelper.getClassIndex(clazzes, LocatedSequenceFeature.class) >= 0; 
    …… 
    155158    public int getWrittenResultsCount() { 
    156159        return writtenResultsCount; 
    157     }     
     160    } 
    158161} 

  • trunk/bio/webapp/src/org/intermine/bio/web/export/GFF3HttpExporter.java

    r15326 r16254  
    3434 
    3535/** 
    36  * An implementation of TableHttpExporter that exports LocatedSequenceFeature  
     36 * An implementation of TableHttpExporter that exports LocatedSequenceFeature 
    3737 * objects in GFF3 format. 
    3838 * 
    …… 
    6161 
    6262        setGFF3Header(response); 
    63          
    64         List<Integer> indexes = ExportHelper.getClassIndexes(ExportHelper.getColumnClasses(pt),  
     63 
     64        List<Integer> indexes = ExportHelper.getClassIndexes(ExportHelper.getColumnClasses(pt), 
    6565                LocatedSequenceFeature.class); 
    66          
     66 
    6767        Exporter exporter; 
    6868        try { 
    6969            PrintWriter writer = HttpExportUtil. 
    7070                getPrintWriterForClient(request, response.getOutputStream()); 
    71             exporter = new GFF3Exporter(writer,  
     71            exporter = new GFF3Exporter(writer, 
    7272                    indexes, getSoClassNames(servletContext)); 
    7373        } catch (Exception e) { 
    7474            throw new ExportException("Export failed.", e); 
    75         }  
    76         exporter.export(pt.getRearrangedResults()); 
     75        } 
     76        exporter.export(pt.getRearrangedResults(), pt.getColumns()); 
    7777        if (exporter.getWrittenResultsCount() == 0) { 
    7878            throw new ExportException("Nothing was found for export."); 

  • trunk/bio/webapp/src/org/intermine/bio/web/export/SequenceExporter.java

    r16185 r16254  
    1111 */ 
    1212 
    13 import java.io.OutputStream; 
    1413import java.util.Iterator; 
    1514import java.util.List; 
    1615 
    17 import org.biojava.bio.Annotation; 
    18 import org.biojava.bio.seq.io.FastaFormat; 
    19 import org.biojava.bio.seq.io.SeqIOTools; 
    20 import org.biojava.bio.symbol.IllegalSymbolException; 
    21 import org.flymine.model.genomic.BioEntity; 
    22 import org.flymine.model.genomic.Gene; 
    23 import org.flymine.model.genomic.LocatedSequenceFeature; 
    24 import org.flymine.model.genomic.Protein; 
    25 import org.flymine.model.genomic.Sequence; 
    26 import org.flymine.model.genomic.Translation; 
    27 import org.flymine.model.genomic.Location; 
    2816import org.intermine.bio.web.biojava.BioSequence; 
    2917import org.intermine.bio.web.biojava.BioSequenceFactory; 
    …… 
    3725import org.intermine.web.logic.export.ExportHelper; 
    3826import org.intermine.web.logic.export.Exporter; 
     27import org.intermine.web.logic.results.Column; 
    3928import org.intermine.web.logic.results.ResultElement; 
     29 
     30import org.flymine.model.genomic.BioEntity; 
     31import org.flymine.model.genomic.Gene; 
     32import org.flymine.model.genomic.LocatedSequenceFeature; 
     33import org.flymine.model.genomic.Location; 
     34import org.flymine.model.genomic.Protein; 
     35import org.flymine.model.genomic.Sequence; 
     36import org.flymine.model.genomic.Translation; 
     37 
     38import java.io.OutputStream; 
     39 
     40import org.biojava.bio.Annotation; 
     41import org.biojava.bio.seq.io.FastaFormat; 
     42import org.biojava.bio.seq.io.SeqIOTools; 
     43import org.biojava.bio.symbol.IllegalSymbolException; 
    4044 
    4145 
    …… 
    5862     * @param os object store used for fetching sequence for  exported object 
    5963     * @param outputStream output stream 
    60      * @param featureIndex index of cell in row that contains object to be exported  
     64     * @param featureIndex index of cell in row that contains object to be exported 
    6165     */ 
    6266    public SequenceExporter(ObjectStore os, OutputStream outputStream, 
    …… 
    6670        this.featureIndex = featureIndex; 
    6771    } 
    68      
     72 
    6973    /** 
    7074     * {@inheritDoc} 
    …… 
    7377        return writtenResultsCount; 
    7478    } 
    75      
     79 
    7680    /** 
    7781     * {@inheritDoc} 
    78      * Lines are always separated with \n because third party tool writeFasta  
    79      * is used for writing sequence.  
    80      */ 
    81     public void export(List<List<ResultElement>> results) { 
     82     * Lines are always separated with \n because third party tool writeFasta 
     83     * is used for writing sequence. 
     84     */ 
     85    public void export(List<List<ResultElement>> results, List<Column> columns) { 
    8286        // IDs of the features we have successfully output - used to avoid duplicates 
    8387        IntPresentSet exportedIDs = new IntPresentSet(); 
    84          
     88 
    8589        try { 
    8690            for (int rowIndex = 0; rowIndex < results.size(); rowIndex++) { 
    …… 
    104108 
    105109                if (object instanceof LocatedSequenceFeature) { 
    106                     bioSequence = createLocatedSequenceFeature(header, object); 
     110                    bioSequence = createLocatedSequenceFeature(header, object, row, columns); 
    107111                } else if (object instanceof Protein) { 
    108112                    bioSequence = createProtein(header, object); 
    …… 
    123127                String headerString = header.toString(); 
    124128 
    125                 if (row.size() > 1 && headerString.length() > 0) { 
     129                if (headerString.length() > 0) { 
    126130                    annotation.setProperty(FastaFormat.PROPERTY_DESCRIPTIONLINE, headerString); 
    127131                } else { 
    …… 
    148152 
    149153    private BioSequence createTranslation(StringBuffer header, Object object, 
    150             Model model) throws IllegalSymbolException { 
     154                                          Model model) throws IllegalSymbolException { 
    151155        BioSequence bioSequence; 
    152156        ClassDescriptor cld = model.getClassDescriptorByName(model.getPackageName() 
    …… 
    189193            header.append(protein.getName()); 
    190194        } 
    191         Iterator iter = protein.getGenes().iterator(); 
     195        Iterator<Gene> iter = protein.getGenes().iterator(); 
    192196        while (iter.hasNext()) { 
    193             Gene gene = (Gene) iter.next(); 
     197            Gene gene = iter.next(); 
    194198            String geneIdentifier = gene.getPrimaryIdentifier(); 
    195199            if (geneIdentifier != null) { 
    …… 
    204208 
    205209    private BioSequence createLocatedSequenceFeature(StringBuffer header, 
    206             Object object) throws IllegalSymbolException { 
     210                                                     Object object, List<ResultElement> row, 
     211                                                     List<Column> columns) 
     212        throws IllegalSymbolException { 
    207213        BioSequence bioSequence; 
    208214        LocatedSequenceFeature feature = (LocatedSequenceFeature) object; 
    209215        bioSequence = BioSequenceFactory.make(feature); 
    210216        if (feature.getPrimaryIdentifier() == null) { 
    211             if (feature instanceof Gene) { 
    212                 header.append(((Gene) feature).getPrimaryIdentifier()); 
    213             } else { 
    214                 header.append("[unknown_identifier]"); 
    215             } 
     217            header.append("[unknown_identifier]"); 
    216218        } else { 
    217219            header.append(feature.getPrimaryIdentifier()); 
    218220        } 
    219221        header.append(' '); 
    220         if (feature.getName() == null) { 
    221             header.append("[unknown_name]"); 
    222         } else { 
    223             header.append(feature.getName()); 
    224         } 
     222        header.append(getHeadersFromColumns(row, columns)); 
    225223 
    226224        Location chromosomeLoc = feature.getChromosomeLocation(); 
    227          
     225 
    228226        if (chromosomeLoc != null) { 
    229227            header.append(' ').append(chromosomeLoc.getObject().getPrimaryIdentifier()); 
    …… 
    247245 
    248246    /** 
     247     * Look at the Columns and the current row and return a String containing all the elements of 
     248     * the row except the primaryIdentifier (if any). 
     249     */ 
     250    private String getHeadersFromColumns(List<ResultElement> row, List<Column> columns) { 
     251        StringBuffer sb = new StringBuffer(); 
     252 
     253        for (int i = 0; i < row.size(); i++) { 
     254            Column column = columns.get(i); 
     255            if (!column.getPath().getEndFieldDescriptor().getName().equals("primaryIdentifier")) { 
     256                ResultElement resultElement = row.get(i); 
     257                Object rawField = resultElement.getField(); 
     258                String field; 
     259                if (rawField == null) { 
     260                    field = "-"; 
     261                } else { 
     262                    field = rawField.toString(); 
     263                } 
     264                sb.append(field).append(' '); 
     265            } 
     266        } 
     267 
     268        return sb.toString(); 
     269    } 
     270 
     271    /** 
    249272     * {@inheritDoc} 
    250273     */ 
    …… 
    253276    } 
    254277 
    255     /* Method must have different name than canExport because canExport() method  
     278    /* Method must have different name than canExport because canExport() method 
    256279     * is  inherited from Exporter interface */ 
    257280    /** 
    258281     * @param clazzes classes of result 
    259      * @return true if this exporter can export result composed of specified classes  
    260      */ 
    261     public static boolean canExportStatic(List<Class> clazzes) {         
     282     * @return true if this exporter can export result composed of specified classes 
     283     */ 
     284    public static boolean canExportStatic(List<Class> clazzes) { 
    262285        return ( 
    263                 ExportHelper.getClassIndex(clazzes, LocatedSequenceFeature.class) >= 0  
     286                ExportHelper.getClassIndex(clazzes, LocatedSequenceFeature.class) >= 0 
    264287                || ExportHelper.getClassIndex(clazzes, Protein.class) >= 0 
    265288                || ExportHelper.getClassIndex(clazzes, Translation.class) >= 0 

  • trunk/bio/webapp/src/org/intermine/bio/web/export/SequenceHttpExporter.java

    r14800 r16254  
    5757    public void export(PagedTable pt, HttpServletRequest request, 
    5858                                HttpServletResponse response) { 
    59          
     59 
    6060        HttpSession session = request.getSession(); 
    6161        ObjectStore os = 
    …… 
    6565        OutputStream outputStream = null; 
    6666        try { 
    67             outputStream = response.getOutputStream();     
     67            outputStream = response.getOutputStream(); 
    6868        } catch (IOException e) { 
    6969            throw new ExportException("Export failed.", e); 
    7070        } 
    71          
     71 
    7272        // the first column that contains exportable features 
    7373        int realFeatureIndex = getFeatureColumnIndex(pt); 
    7474 
    75         SequenceExporter exporter = new SequenceExporter(os, outputStream,  
     75        SequenceExporter exporter = new SequenceExporter(os, outputStream, 
    7676                realFeatureIndex); 
    77          
    78         exporter.export(pt.getRearrangedResults()); 
     77 
     78        exporter.export(pt.getRearrangedResults(), pt.getColumns()); 
    7979        if (exporter.getWrittenResultsCount() == 0) { 
    8080            throw new ExportException("Nothing was found for export."); 
    …… 
    8282    } 
    8383 
    84      
     84 
    8585    private int getFeatureColumnIndex(PagedTable pt) { 
    8686        List<Class> clazzes = ExportHelper.getColumnClasses(pt); 

  • trunk/intermine/web/main/src/org/intermine/web/logic/export/ExcelExporter.java

    r14810 r16254  
    1010 * 
    1111 */ 
     12import java.util.Date; 
     13import java.util.List; 
     14 
     15import org.intermine.web.logic.results.Column; 
     16import org.intermine.web.logic.results.ResultElement; 
     17 
    1218import java.io.IOException; 
    1319import java.io.OutputStream; 
    14 import java.util.Date; 
    15 import java.util.List; 
    1620 
    1721import org.apache.poi.hssf.usermodel.HSSFRow; 
    1822import org.apache.poi.hssf.usermodel.HSSFSheet; 
    1923import org.apache.poi.hssf.usermodel.HSSFWorkbook; 
    20 import org.intermine.web.logic.results.ResultElement; 
    2124 
    2225 
    …… 
    2730public class ExcelExporter implements Exporter 
    2831{ 
    29      
     32 
    3033    private OutputStream out; 
    3134    private int writtenResultsCount; 
    …… 
    3841        this.out = out; 
    3942    } 
    40      
     43 
    4144    /** 
    42      * Exports results. 
    43      * @param results results to be exported 
     45     * {@inheritDoc} 
    4446     */ 
    45     public void export(List<List<ResultElement>> results) { 
     47    public void export(List<List<ResultElement>> results, 
     48                       @SuppressWarnings("unused") List<Column> columns) { 
    4649        try { 
    4750            HSSFWorkbook wb = new HSSFWorkbook(); 
    4851            HSSFSheet sheet = wb.createSheet("results"); 
    4952            ResultElementConverter converter = new ResultElementConverter(); 
    50              
     53 
    5154            for (int rowIndex = 0; rowIndex < results.size(); rowIndex++) { 
    52                  
     55 
    5356                HSSFRow excelRow = sheet.createRow((short) rowIndex); 
    5457                List<Object> row = converter.convert(results.get(rowIndex)); 
    55                  
     58 
    5659                for (short colIndex = 0; colIndex < row.size(); colIndex++) { 
    5760                    Object obj = row.get(colIndex); 

  • trunk/intermine/web/main/src/org/intermine/web/logic/export/Exporter.java

    r15326 r16254  
    1212import java.util.List; 
    1313 
     14import org.intermine.web.logic.results.Column; 
    1415import org.intermine.web.logic.results.ResultElement; 
    1516 
    1617 
    1718/** 
    18  * Simple exporter interface. Objects implementing this interface are  
     19 * Simple exporter interface. Objects implementing this interface are 
    1920 * able to make export. 
    2021 * @author Jakub Kulaviak 
    …… 
    2324{ 
    2425    /** Windows line separator  CR+LF **/ 
    25     public static final String WINDOWS_SEPARATOR = "\r\n";  
    26      
     26    public static final String WINDOWS_SEPARATOR = "\r\n"; 
     27 
    2728    /** Windows line separator  only LF **/ 
    2829    public static final String UNIX_SEPARATOR = "\n"; 
    …… 
    3132     * Do export. 
    3233     * @param results to be exported 
     34     * @param columns the columns descriptions 
    3335     */ 
    34     public void export(List<List<ResultElement>> results); 
    35   
     36    public void export(List<List<ResultElement>> results, List<Column> columns); 
     37 
    3638    /** 
    37      * This method finds out if result row composed from instances of these  
    38      * classes can be exported with actual implementation of exporter.   
     39     * This method finds out if result row composed from instances of these 
     40     * classes can be exported with actual implementation of exporter. 
    3941     * @param clazzes classes in row 
    4042     * @return true if result row can be exported or false 
    4143     */ 
    4244    public boolean canExport(List<Class> clazzes); 
    43      
     45 
    4446    /** 
    4547     * @return count of written results 

  • trunk/intermine/web/main/src/org/intermine/web/logic/export/ExporterImpl.java

    r15326 r16254  
    1111 */ 
    1212 
    13 import java.io.OutputStream; 
    14 import java.io.PrintWriter; 
    1513import java.util.Iterator; 
    1614import java.util.List; 
    1715 
    1816import org.intermine.objectstore.flatouterjoins.ReallyFlatIterator; 
     17import org.intermine.web.logic.results.Column; 
    1918import org.intermine.web.logic.results.ResultElement; 
     19 
     20import java.io.OutputStream; 
     21import java.io.PrintWriter; 
    2022 
    2123 
    2224/** 
    23  * Simple exporter exporting data as tab separated, comma separated  
     25 * Simple exporter exporting data as tab separated, comma separated 
    2426 * and so. It depends at used row formatter. 
    2527 * @author Jakub Kulaviak 
    …… 
    2931 
    3032    private PrintWriter out; 
    31      
     33 
    3234    private RowFormatter rowFormatter; 
    33      
     35 
    3436    private int writtenResultsCount = 0; 
    35      
     37 
    3638    /** 
    3739     * Constructor. 
    …… 
    6365     * @param results results to be exported 
    6466     */ 
    65     public void export(List<List<ResultElement>> results) { 
     67    public void export(List<List<ResultElement>> results, List<Column> columns) { 
    6668        try { 
    6769            ResultElementConverter converter = new ResultElementConverter(); 
    …… 
    8486        return writtenResultsCount; 
    8587    } 
    86      
     88 
    8789    /** 
    8890     * {@inheritDoc} 
    89      * Universal exporter.  
     91     * Universal exporter. 
    9092     * @return always true 
    9193     */ 

  • trunk/intermine/web/main/src/org/intermine/web/logic/export/http/HttpExporterBase.java

    r15326 r16254  
    2828 * Abstract class that implements basic functionality common for exporters 
    2929 * exporting table with results in simple format like comma separated format. 
    30  * The business logic of export is performed with exporter obtained via  
     30 * The business logic of export is performed with exporter obtained via 
    3131 * getExport() method and so each subclass can redefine it overwriting this method. 
    3232 * @author Jakub Kulaviak 
    …… 
    3939     */ 
    4040    public HttpExporterBase() { } 
    41          
     41 
    4242    /** 
    4343     * @param pt PagedTable 
    …… 
    5454     * @param response response 
    5555     */ 
    56     public void export(PagedTable pt, HttpServletRequest request,  
     56    public void export(PagedTable pt, HttpServletRequest request, 
    5757            HttpServletResponse response) { 
    5858 
    …… 
    7373        } 
    7474        Exporter exporter = getExporter(out, separator); 
    75         exporter.export(results); 
     75        exporter.export(results, pt.getColumns()); 
    7676        if (exporter.getWrittenResultsCount() == 0) { 
    7777            throw new ExportException("Nothing was found for export."); 
    …… 
    8282     * @param out output stream 
    8383     * @param separator line separator 
    84      * @return exporter that will perform the business logic of export.  
     84     * @return exporter that will perform the business logic of export. 
    8585     */ 
    8686    protected abstract Exporter getExporter(OutputStream out, String separator); 
    87      
     87 
    8888    /** 
    8989     * Sets header and content type of result in response. 
    …… 
    9191     */ 
    9292    protected abstract void setResponseHeader(HttpServletResponse response); 
    93      
     93 
    9494} 

  • trunk/intermine/web/main/src/org/intermine/web/logic/results/PagedTable.java

    r16194 r16254  
    793793     * @return a List of rows, each of which is a List 
    794794     */ 
    795     public List getRearrangedResults() { 
     795    public List<List<ResultElement>> getRearrangedResults() { 
    796796        return new RearrangedList(); 
    797797    } 

  • trunk/intermine/web/test/src/org/intermine/web/logic/export/ExcelExporterTest.java

    r14685 r16254  
    1515import org.apache.poi.hssf.usermodel.HSSFSheet; 
    1616import org.apache.poi.hssf.usermodel.HSSFWorkbook; 
     17 
     18import org.intermine.metadata.Model; 
     19import org.intermine.path.Path; 
     20import org.intermine.web.logic.results.Column; 
    1721import org.intermine.web.logic.results.ResultElement; 
    1822 
    …… 
    3539    public void testExport() throws IOException { 
    3640        List<List<ResultElement>> input = new ArrayList<List<ResultElement>>(); 
    37         input.add(ExportTestUtil.getRow(10, "1", "true", "EmployeeA1")); 
    38         input.add(ExportTestUtil.getRow(20, "2", "true", "EmployeeA2")); 
     41        input.add(ExportTestUtil.getRow(10, "1", true, "EmployeeA1")); 
     42        input.add(ExportTestUtil.getRow(20, "2", false, "EmployeeA2")); 
    3943        Date date = new Date(); 
    4044        input.add(getDateRow(date)); 
    41          
     45 
     46        Model model = Model.getInstanceByName("testmodel"); 
     47 
     48        List<Column> columns = new ArrayList<Column>(); 
     49        columns.add(new Column(new Path(model, "Employee.age"), "age", 0, Integer.class)); 
     50        columns.add(new Column(new Path(model, "Employee.end"), "end", 1, String.class)); 
     51        columns.add(new Column(new Path(model, "Employee.fullTime"), "fullTime", 2, Boolean.class)); 
     52        columns.add(new Column(new Path(model, "Employee.name"), "name", 3, String.class)); 
     53 
    4254        ByteArrayOutputStream out = new ByteArrayOutputStream(); 
    4355        Exporter exporter = new ExcelExporter(out); 
    44         exporter.export(input); 
     56        exporter.export(input, columns); 
    4557        InputStream is = new ByteArrayInputStream(out.toByteArray()); 
    4658        HSSFWorkbook wb = new HSSFWorkbook(is); 
    4759        HSSFSheet sheet = wb.getSheet("results"); 
    48       
    49         HSSFRow row = sheet.getRow(0);         
     60 
     61        HSSFRow row = sheet.getRow(0); 
    5062        assertEquals(10.0, row.getCell((short) 0).getNumericCellValue()); 
    5163        assertEquals(HSSFCell.CELL_TYPE_NUMERIC, row.getCell((short) 0).getCellType()); 
    …… 
    5466        assertEquals("EmployeeA1", row.getCell((short) 3).getStringCellValue()); 
    5567 
    56         row = sheet.getRow(1);         
     68        row = sheet.getRow(1); 
    5769        assertEquals(20.0, row.getCell((short) 0).getNumericCellValue()); 
    5870        assertEquals("2", row.getCell((short) 1).getStringCellValue()); 
    59         assertEquals("true", row.getCell((short) 2).getStringCellValue()); 
     71        assertEquals("false", row.getCell((short) 2).getStringCellValue()); 
    6072        assertEquals("EmployeeA2", row.getCell((short) 3).getStringCellValue()); 
    61          
     73 
    6274        // test that date was added with exporter as date - it is numeric format in excel 
    6375        row = sheet.getRow(2); 
    …… 
    6981        assertEquals(HSSFCell.CELL_TYPE_NUMERIC, row.getCell((short) 0).getCellType()); 
    7082    } 
    71      
     83 
    7284    private List<ResultElement> getDateRow(Date date) { 
    7385        List<ResultElement> ret = new ArrayList<ResultElement>(); 

  • trunk/intermine/web/test/src/org/intermine/web/logic/export/ExportTestUtil.java

    r14685 r16254  
    2222{ 
    2323 
    24     static List<ResultElement> getRow(int i, String string, String string2, 
    25             String string3) { 
     24    static List<ResultElement> getRow(int i, String string, boolean bool1, 
     25            String string2) { 
    2626        List<ResultElement> ret = new ArrayList<ResultElement>(); 
    2727        ret.add(new ResultElement(i)); 
    2828        ret.add(new ResultElement(string)); 
     29        ret.add(new ResultElement(bool1)); 
    2930        ret.add(new ResultElement(string2)); 
    30         ret.add(new ResultElement(string3)); 
    3131        return ret; 
    3232    } 

  • trunk/intermine/web/test/src/org/intermine/web/logic/export/ExporterImplTest.java

    r14780 r16254  
    88import junit.framework.TestCase; 
    99 
     10import org.intermine.web.logic.results.Column; 
    1011import org.intermine.web.logic.results.ResultElement; 
    1112 
    …… 
    3132        RowFormatter formatter = new RowFormatterImpl(",", true); 
    3233        ExporterImpl exporter = new ExporterImpl(out, formatter); 
    33         exporter.export(input); 
     34        exporter.export(input, new ArrayList<Column>()); 
    3435        assertEquals(getExpected(), out.toString()); 
    3536    } 
    3637 
    3738    private String getExpected() { 
    38         return  
    39         "10,\"1\",\"true\",\"EmployeeA1\"\n" +  
     39        return 
     40        "10,\"1\",\"true\",\"EmployeeA1\"\n" + 
    4041        "20,\"2\",\"true\",\"EmployeeA2\"\n" + 
    4142        "30,\"3\",\"false\",\"EmployeeA3\"\n" + 
    4243        "40,\"4\",\"true\",\"EmployeeB1\"\n" + 
    4344        "50,\"5\",\"true\",\"EmployeeB2\"\n" + 
    44         "60,\"6\",\"true\",\"EmployeeB3\"\n";     
     45        "60,\"6\",\"true\",\"EmployeeB3\"\n"; 
    4546    } 
    4647 
    4748    static List<List<ResultElement>> getInput() { 
    4849        List<List<ResultElement>> input = new ArrayList<List<ResultElement>>(); 
    49         input.add(ExportTestUtil.getRow(10, "1", "true", "EmployeeA1")); 
    50         input.add(ExportTestUtil.getRow(20, "2", "true", "EmployeeA2")); 
    51         input.add(ExportTestUtil.getRow(30, "3", "false", "EmployeeA3")); 
    52         input.add(ExportTestUtil.getRow(40, "4", "true", "EmployeeB1")); 
    53         input.add(ExportTestUtil.getRow(50, "5", "true", "EmployeeB2")); 
    54         input.add(ExportTestUtil.getRow(60, "6", "true", "EmployeeB3")); 
     50        input.add(ExportTestUtil.getRow(10, "1", true, "EmployeeA1")); 
     51        input.add(ExportTestUtil.getRow(20, "2", true, "EmployeeA2")); 
     52        input.add(ExportTestUtil.getRow(30, "3", false, "EmployeeA3")); 
     53        input.add(ExportTestUtil.getRow(40, "4", true, "EmployeeB1")); 
     54        input.add(ExportTestUtil.getRow(50, "5", true, "EmployeeB2")); 
     55        input.add(ExportTestUtil.getRow(60, "6", true, "EmployeeB3")); 
    5556        return input; 
    5657    }