JAL-1988 JAL-3130 New jlinked JRE in jalview_java2 with modules. Still needs jaxws...
[jalview.git] / test / jalview / analysis / ParsePropertiesTest.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.analysis;
22
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertNull;
25
26 import jalview.datamodel.Alignment;
27 import jalview.datamodel.AlignmentAnnotation;
28 import jalview.datamodel.Sequence;
29 import jalview.datamodel.SequenceI;
30 import jalview.gui.AlignFrame;
31 import jalview.gui.JvOptionPane;
32
33 import java.util.List;
34
35 import org.testng.annotations.BeforeClass;
36 import org.testng.annotations.BeforeMethod;
37 import org.testng.annotations.Test;
38
39 public class ParsePropertiesTest
40 {
41
42   @BeforeClass(alwaysRun = true)
43   public void setUpJvOptionPane()
44   {
45     JvOptionPane.setInteractiveMode(false);
46     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
47   }
48
49   private Alignment al;
50
51   private ParseProperties pp;
52
53   /**
54    * Construct an alignment with 4 sequences with varying description format
55    */
56   @BeforeMethod(alwaysRun = true)
57   public void setUp()
58   {
59     SequenceI[] seqs = new SequenceI[] {
60         new Sequence("sq1", "THISISAPLACEHOLDER"),
61         new Sequence("sq2", "THISISAPLACEHOLDER"),
62         new Sequence("sq3", "THISISAPLACEHOLDER"),
63         new Sequence("sq4", "THISISAPLACEHOLDER") };
64     seqs[0].setDescription("1 mydescription1");
65     seqs[1].setDescription("mydescription2");
66     seqs[2].setDescription("2. 0.1 mydescription+3");
67     seqs[3].setDescription("3 0.01 mydescription4");
68     al = new Alignment(seqs);
69
70     pp = new ParseProperties(al);
71
72   }
73
74   /**
75    * Test with a description pattern that matches any string ending in one or
76    * more 'number characters' (0-9+.), i.e. greedily matches any trailing
77    * numeric part of the string
78    */
79   @Test(groups = { "Functional" })
80   public void testGetScoresFromDescription()
81   {
82     String regex = ".*([-0-9.+]+)";
83     final int count = pp.getScoresFromDescription("my Score",
84             "my Score Description", regex, true);
85     System.out.println("Matched " + count + " for " + regex);
86     assertEquals(4, count);
87
88     /*
89      * Verify values 1/2/3/4 have been parsed from sequence descriptions
90      */
91     AlignmentAnnotation[] anns = al.getSequenceAt(0).getAnnotation();
92     assertEquals(1, anns.length);
93     assertEquals(1d, anns[0].getScore(), 0.001d);
94     assertEquals("my Score Description", anns[0].description);
95     assertEquals("my Score", anns[0].label);
96     anns = al.getSequenceAt(1).getAnnotation();
97     assertEquals(1, anns.length);
98     assertEquals(2d, anns[0].getScore(), 0.001d);
99     assertEquals("my Score Description", anns[0].description);
100     assertEquals("my Score", anns[0].label);
101     anns = al.getSequenceAt(2).getAnnotation();
102     assertEquals(1, anns.length);
103     assertEquals(3d, anns[0].getScore(), 0.001d);
104     anns = al.getSequenceAt(3).getAnnotation();
105     assertEquals(1, anns.length);
106     assertEquals(4d, anns[0].getScore(), 0.001d);
107   }
108
109   /**
110    * Test with a description pattern that matches any string (or none), followed
111    * by a 'number character' (0-9+.), followed by at least one separator
112    * character, followed by at least one 'number character', then any trailing
113    * characters.
114    */
115   @Test(groups = { "Functional" })
116   public void testGetScoresFromDescription_twoScores()
117   {
118     String regex = ".*([-0-9.+]+).+([-0-9.+]+).*";
119     final int count = pp.getScoresFromDescription("my Score",
120             "my Score Description", regex, true);
121     System.out.println("Matched " + count + " for " + regex);
122     assertEquals(3, count);
123
124     /*
125      * Seq1 has two score values parsed out
126      */
127     AlignmentAnnotation[] anns = al.getSequenceAt(0).getAnnotation();
128     assertEquals(2, anns.length);
129     assertEquals(1d, anns[0].getScore(), 0.001d);
130     assertEquals("my Score Description", anns[0].description);
131     assertEquals("my Score", anns[0].label);
132     assertEquals(1d, anns[1].getScore(), 0.001d);
133     assertEquals("my Score Description (column 1)", anns[1].description);
134     assertEquals("my Score_1", anns[1].label);
135
136     /*
137      * Seq2 has no score parsed out (is this right?)
138      */
139     assertNull(al.getSequenceAt(1).getAnnotation());
140
141     /*
142      * Seq3 has two score values parsed out
143      */
144     // TODO parsed values (1.0 and 3.0) look wrong v description
145     // would expect 2.0 and 0.1
146     // undesired 'greedy' behaviour of regex?
147     anns = al.getSequenceAt(2).getAnnotation();
148     assertEquals(2, anns.length);
149     assertEquals(1d, anns[0].getScore(), 0.001d);
150     assertEquals("my Score Description", anns[0].description);
151     assertEquals("my Score", anns[0].label);
152     assertEquals(3d, anns[1].getScore(), 0.001d);
153     assertEquals("my Score Description (column 1)", anns[1].description);
154     assertEquals("my Score_1", anns[1].label);
155
156     /*
157      * Seq3 has two score values parsed out
158      */
159     // TODO parsed values (1.0 and 4.0) look wrong v description
160     // would expect 3 and 0.01
161     anns = al.getSequenceAt(3).getAnnotation();
162     assertEquals(2, anns.length);
163     assertEquals(1d, anns[0].getScore(), 0.001d);
164     assertEquals("my Score Description", anns[0].description);
165     assertEquals("my Score", anns[0].label);
166     assertEquals(4d, anns[1].getScore(), 0.001d);
167     assertEquals("my Score Description (column 1)", anns[1].description);
168     assertEquals("my Score_1", anns[1].label);
169   }
170
171   /**
172    * Test with a regex that looks for numbers separated by words - as currently
173    * used in Jalview (May 2015)
174    * 
175    * @see AlignFrame.extractScores_actionPerformed
176    */
177   @Test(groups = { "Functional" })
178   public void testGetScoresFromDescription_wordBoundaries()
179   {
180     String regex = "\\W*([-+eE0-9.]+)";
181     List<SequenceI> seqs = al.getSequences();
182     seqs.get(0).setDescription("Ferredoxin");
183     seqs.get(1).setDescription(" Ferredoxin-1, chloroplast precursor");
184     seqs.get(2).setDescription("GH28E30p");
185     seqs.get(3).setDescription("At1g10960/T19D16_12");
186     final int count = pp.getScoresFromDescription("description column",
187             "score in description column ", regex, true);
188     assertEquals(3, count);
189
190     /*
191      * No score parsable from seq1 description
192      */
193     AlignmentAnnotation[] anns = al.getSequenceAt(0).getAnnotation();
194     assertNull(anns);
195
196     /*
197      * Seq2 description has a '1' in it
198      */
199     anns = al.getSequenceAt(1).getAnnotation();
200     assertEquals(1, anns.length);
201     assertEquals(1d, anns[0].getScore(), 0.001d);
202
203     /*
204      * Seq3 description has '28E30' in it
205      * 
206      * Note: 1.8E308 or larger would result in 'Infinity'
207      */
208     anns = al.getSequenceAt(2).getAnnotation();
209     assertEquals(1, anns.length);
210     assertEquals(2.8E31d, anns[0].getScore(), 0.001d);
211
212     /*
213      * Seq4 description has several numbers in it
214      */
215     anns = al.getSequenceAt(3).getAnnotation();
216     assertEquals(5, anns.length);
217     assertEquals(1d, anns[0].getScore(), 0.001d);
218     assertEquals(10960d, anns[1].getScore(), 0.001d);
219     assertEquals(19d, anns[2].getScore(), 0.001d);
220     assertEquals(16d, anns[3].getScore(), 0.001d);
221     assertEquals(12d, anns[4].getScore(), 0.001d);
222   }
223 }