JAL-1782 refactored test to ensure it passes in TestNG
[jalview.git] / test / jalview / analysis / AnnotationSorterTest.java
1 package jalview.analysis;
2
3 import static org.testng.AssertJUnit.assertEquals;
4
5 import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
6 import jalview.datamodel.Alignment;
7 import jalview.datamodel.AlignmentAnnotation;
8 import jalview.datamodel.Sequence;
9 import jalview.datamodel.SequenceI;
10
11 import java.util.ArrayList;
12 import java.util.List;
13 import java.util.Random;
14
15 import org.testng.annotations.BeforeMethod;
16 import org.testng.annotations.Test;
17
18 public class AnnotationSorterTest
19 {
20   private static final int NUM_SEQS = 6;
21
22   private static final int NUM_ANNS = 7;
23
24   private static final String SS = "secondary structure";
25
26   AlignmentAnnotation[] anns = new AlignmentAnnotation[0];
27
28   Alignment al = null;
29
30   /*
31    * Set up 6 sequences and 7 annotations.
32    */
33   @BeforeMethod
34   public void setUp()
35   {
36     al = buildAlignment(NUM_SEQS);
37     anns = buildAnnotations(NUM_ANNS);
38   }
39
40   /**
41    * Construct an array of numAnns annotations
42    * 
43    * @param numAnns
44    * 
45    * @return
46    */
47   protected AlignmentAnnotation[] buildAnnotations(int numAnns)
48   {
49     List<AlignmentAnnotation> annlist = new ArrayList<AlignmentAnnotation>();
50     for (int i = 0; i < numAnns; i++)
51     {
52       AlignmentAnnotation ann = new AlignmentAnnotation(SS + i, "", 0);
53       annlist.add(ann);
54     }
55     return annlist.toArray(anns);
56   }
57
58   /**
59    * Make an alignment with numSeqs sequences in it.
60    * 
61    * @param numSeqs
62    * 
63    * @return
64    */
65   private Alignment buildAlignment(int numSeqs)
66   {
67     SequenceI[] seqs = new Sequence[numSeqs];
68     for (int i = 0; i < numSeqs; i++)
69     {
70       seqs[i] = new Sequence("Sequence" + i, "axrdkfp");
71     }
72     return new Alignment(seqs);
73   }
74
75   /**
76    * Test sorting by annotation type (label) within sequence order, including
77    * <ul>
78    * <li>annotations with no sequence reference - sort to end keeping mutual
79    * ordering</li>
80    * <li>annotations with sequence ref = sort in sequence order</li>
81    * <li>multiple annotations for same sequence ref - sort by label
82    * non-case-specific</li>
83    * <li>annotations with reference to sequence not in alignment - treat like no
84    * sequence ref</li>
85    * </ul>
86    */
87   @Test
88   public void testSortBySequenceAndType_autocalcLast()
89   {
90     // @formatter:off
91     anns[0].sequenceRef = al.getSequenceAt(1); anns[0].label = "label0";
92     anns[1].sequenceRef = al.getSequenceAt(3); anns[1].label = "structure";
93     anns[2].sequenceRef = al.getSequenceAt(3); anns[2].label = "iron";
94     anns[3].sequenceRef = null;                anns[3].label = "Quality";
95     anns[4].sequenceRef = null;                anns[4].label = "Consensus";
96     anns[5].sequenceRef = al.getSequenceAt(0); anns[5].label = "label5";
97     anns[6].sequenceRef = al.getSequenceAt(3); anns[6].label = "IRP";
98     // @formatter:on
99
100     AnnotationSorter testee = new AnnotationSorter(al, false);
101     testee.sort(anns, SequenceAnnotationOrder.SEQUENCE_AND_LABEL);
102     assertEquals("label5", anns[0].label); // for sequence 0
103     assertEquals("label0", anns[1].label); // for sequence 1
104     assertEquals("iron", anns[2].label); // sequence 3 /iron
105     assertEquals("IRP", anns[3].label); // sequence 3/IRP
106     assertEquals("structure", anns[4].label); // sequence 3/structure
107     assertEquals("Quality", anns[5].label); // non-sequence annotations
108     assertEquals("Consensus", anns[6].label); // retain ordering
109   }
110
111   /**
112    * Variant with autocalculated annotations sorting to front
113    */
114   @Test
115   public void testSortBySequenceAndType_autocalcFirst()
116   {
117     // @formatter:off
118     anns[0].sequenceRef = al.getSequenceAt(1); anns[0].label = "label0";
119     anns[1].sequenceRef = al.getSequenceAt(3); anns[1].label = "structure";
120     anns[2].sequenceRef = al.getSequenceAt(3); anns[2].label = "iron";
121     anns[3].sequenceRef = null;                anns[3].label = "Quality";
122     anns[4].sequenceRef = null;                anns[4].label = "Consensus";
123     anns[5].sequenceRef = al.getSequenceAt(0); anns[5].label = "label5";
124     anns[6].sequenceRef = al.getSequenceAt(3); anns[6].label = "IRP";
125     // @formatter:on
126
127     AnnotationSorter testee = new AnnotationSorter(al, true);
128     testee.sort(anns, SequenceAnnotationOrder.SEQUENCE_AND_LABEL);
129     assertEquals("Quality", anns[0].label); // non-sequence annotations
130     assertEquals("Consensus", anns[1].label); // retain ordering
131     assertEquals("label5", anns[2].label); // for sequence 0
132     assertEquals("label0", anns[3].label); // for sequence 1
133     assertEquals("iron", anns[4].label); // sequence 3 /iron
134     assertEquals("IRP", anns[5].label); // sequence 3/IRP
135     assertEquals("structure", anns[6].label); // sequence 3/structure
136   }
137
138   /**
139    * Test sorting by annotation type (label) within sequence order, including
140    * <ul>
141    * <li>annotations with no sequence reference - sort to end keeping mutual
142    * ordering</li>
143    * <li>annotations with sequence ref = sort in sequence order</li>
144    * <li>multiple annotations for same sequence ref - sort by label
145    * non-case-specific</li>
146    * <li>annotations with reference to sequence not in alignment - treat like no
147    * sequence ref</li>
148    * </ul>
149    */
150   @Test
151   public void testSortByTypeAndSequence_autocalcLast()
152   {
153     // @formatter:off
154     anns[0].sequenceRef = al.getSequenceAt(1); anns[0].label = "label0";
155     anns[1].sequenceRef = al.getSequenceAt(3); anns[1].label = "structure";
156     anns[2].sequenceRef = al.getSequenceAt(3); anns[2].label = "iron";
157     anns[3].sequenceRef = null;                anns[3].label = "Quality";
158     anns[4].sequenceRef = null;                anns[4].label = "Consensus";
159     anns[5].sequenceRef = al.getSequenceAt(0); anns[5].label = "IRON";
160     anns[6].sequenceRef = al.getSequenceAt(2); anns[6].label = "Structure";
161     // @formatter:on
162
163     AnnotationSorter testee = new AnnotationSorter(al, false);
164     testee.sort(anns, SequenceAnnotationOrder.LABEL_AND_SEQUENCE);
165     assertEquals("IRON", anns[0].label); // IRON / sequence 0
166     assertEquals("iron", anns[1].label); // iron / sequence 3
167     assertEquals("label0", anns[2].label); // label0 / sequence 1
168     assertEquals("Structure", anns[3].label); // Structure / sequence 2
169     assertEquals("structure", anns[4].label); // structure / sequence 3
170     assertEquals("Quality", anns[5].label); // non-sequence annotations
171     assertEquals("Consensus", anns[6].label); // retain ordering
172   }
173
174   /**
175    * Variant of test with autocalculated annotations sorted to front
176    */
177   @Test
178   public void testSortByTypeAndSequence_autocalcFirst()
179   {
180     // @formatter:off
181     anns[0].sequenceRef = al.getSequenceAt(1); anns[0].label = "label0";
182     anns[1].sequenceRef = al.getSequenceAt(3); anns[1].label = "structure";
183     anns[2].sequenceRef = al.getSequenceAt(3); anns[2].label = "iron";
184     anns[3].sequenceRef = null;                anns[3].label = "Quality";
185     anns[4].sequenceRef = null;                anns[4].label = "Consensus";
186     anns[5].sequenceRef = al.getSequenceAt(0); anns[5].label = "IRON";
187     anns[6].sequenceRef = al.getSequenceAt(2); anns[6].label = "Structure";
188     // @formatter:on
189
190     AnnotationSorter testee = new AnnotationSorter(al, true);
191     testee.sort(anns, SequenceAnnotationOrder.LABEL_AND_SEQUENCE);
192     assertEquals("Quality", anns[0].label); // non-sequence annotations
193     assertEquals("Consensus", anns[1].label); // retain ordering
194     assertEquals("IRON", anns[2].label); // IRON / sequence 0
195     assertEquals("iron", anns[3].label); // iron / sequence 3
196     assertEquals("label0", anns[4].label); // label0 / sequence 1
197     assertEquals("Structure", anns[5].label); // Structure / sequence 2
198     assertEquals("structure", anns[6].label); // structure / sequence 3
199   }
200
201   /**
202    * Variant of test with autocalculated annotations sorted to front but
203    * otherwise no change.
204    */
205   @Test
206   public void testNoSort_autocalcFirst()
207   {
208     // @formatter:off
209     anns[0].sequenceRef = al.getSequenceAt(1); anns[0].label = "label0";
210     anns[1].sequenceRef = al.getSequenceAt(3); anns[1].label = "structure";
211     anns[2].sequenceRef = al.getSequenceAt(3); anns[2].label = "iron";
212     anns[3].sequenceRef = null;                anns[3].label = "Quality";
213     anns[4].sequenceRef = null;                anns[4].label = "Consensus";
214     anns[5].sequenceRef = al.getSequenceAt(0); anns[5].label = "IRON";
215     anns[6].sequenceRef = al.getSequenceAt(2); anns[6].label = "Structure";
216     // @formatter:on
217
218     AnnotationSorter testee = new AnnotationSorter(al, true);
219     testee.sort(anns, SequenceAnnotationOrder.NONE);
220     assertEquals("Quality", anns[0].label); // non-sequence annotations
221     assertEquals("Consensus", anns[1].label); // retain ordering
222     assertEquals("label0", anns[2].label);
223     assertEquals("structure", anns[3].label);
224     assertEquals("iron", anns[4].label);
225     assertEquals("IRON", anns[5].label);
226     assertEquals("Structure", anns[6].label);
227   }
228
229   @Test
230   public void testSort_timingPresorted()
231   {
232     testTiming_presorted(50, 100);
233     testTiming_presorted(500, 1000);
234     testTiming_presorted(5000, 10000);
235   }
236
237   /**
238    * Test timing to sort annotations already in the sort order.
239    * 
240    * @param numSeqs
241    * @param numAnns
242    */
243   private void testTiming_presorted(final int numSeqs, final int numAnns)
244   {
245     Alignment alignment = buildAlignment(numSeqs);
246     AlignmentAnnotation[] annotations = buildAnnotations(numAnns);
247
248     /*
249      * Set the annotations presorted by label
250      */
251     Random r = new Random();
252     final SequenceI[] sequences = alignment.getSequencesArray();
253     for (int i = 0; i < annotations.length; i++)
254     {
255       SequenceI randomSequenceRef = sequences[r.nextInt(sequences.length)];
256       annotations[i].sequenceRef = randomSequenceRef;
257       annotations[i].label = "label" + i;
258     }
259     long startTime = System.currentTimeMillis();
260     AnnotationSorter testee = new AnnotationSorter(alignment, false);
261     testee.sort(annotations, SequenceAnnotationOrder.LABEL_AND_SEQUENCE);
262     long endTime = System.currentTimeMillis();
263     final long elapsed = endTime - startTime;
264     System.out.println("Timing test for presorted " + numSeqs
265             + " sequences and "
266             + numAnns + " annotations took " + elapsed + "ms");
267   }
268
269   /**
270    * Timing tests for sorting randomly sorted annotations for various sizes.
271    */
272   @Test
273   public void testSort_timingUnsorted()
274   {
275     testTiming_unsorted(50, 100);
276     testTiming_unsorted(500, 1000);
277     testTiming_unsorted(5000, 10000);
278   }
279
280   /**
281    * Generate annotations randomly sorted with respect to sequences, and time
282    * sorting.
283    * 
284    * @param numSeqs
285    * @param numAnns
286    */
287   private void testTiming_unsorted(final int numSeqs, final int numAnns)
288   {
289     Alignment alignment = buildAlignment(numSeqs);
290     AlignmentAnnotation[] annotations = buildAnnotations(numAnns);
291
292     /*
293      * Set the annotations in random order with respect to the sequences
294      */
295     Random r = new Random();
296     final SequenceI[] sequences = alignment.getSequencesArray();
297     for (int i = 0; i < annotations.length; i++)
298     {
299       SequenceI randomSequenceRef = sequences[r.nextInt(sequences.length)];
300       annotations[i].sequenceRef = randomSequenceRef;
301       annotations[i].label = "label" + i;
302     }
303     long startTime = System.currentTimeMillis();
304     AnnotationSorter testee = new AnnotationSorter(alignment, false);
305     testee.sort(annotations, SequenceAnnotationOrder.SEQUENCE_AND_LABEL);
306     long endTime = System.currentTimeMillis();
307     final long elapsed = endTime - startTime;
308     System.out.println("Timing test for unsorted " + numSeqs
309             + " sequences and "
310             + numAnns + " annotations took " + elapsed + "ms");
311   }
312
313   /**
314    * Timing test for sorting annotations with a limited range of types (labels).
315    */
316   @Test
317   public void testSort_timingSemisorted()
318   {
319     testTiming_semiSorted(50, 100);
320     testTiming_semiSorted(500, 1000);
321     testTiming_semiSorted(5000, 10000);
322   }
323
324   /**
325    * Mimic 'semi-sorted' annotations:
326    * <ul>
327    * <li>set up in sequence order, with randomly assigned labels from a limited
328    * range</li>
329    * <li>sort by label and sequence order, report timing</li>
330    * <li>resort by sequence and label, report timing</li>
331    * <li>resort by label and sequence, report timing</li>
332    * </ul>
333    * 
334    * @param numSeqs
335    * @param numAnns
336    */
337   private void testTiming_semiSorted(final int numSeqs, final int numAnns)
338   {
339     Alignment alignment = buildAlignment(numSeqs);
340     AlignmentAnnotation[] annotations = buildAnnotations(numAnns);
341
342     String[] labels = new String[]
343     { "label1", "label2", "label3", "label4", "label5", "label6" };
344
345     /*
346      * Set the annotations in sequence order with randomly assigned labels.
347      */
348     Random r = new Random();
349     final SequenceI[] sequences = alignment.getSequencesArray();
350     for (int i = 0; i < annotations.length; i++)
351     {
352       SequenceI sequenceRef = sequences[i % sequences.length];
353       annotations[i].sequenceRef = sequenceRef;
354       annotations[i].label = labels[r.nextInt(labels.length)];
355     }
356     long startTime = System.currentTimeMillis();
357     AnnotationSorter testee = new AnnotationSorter(alignment, false);
358     testee.sort(annotations, SequenceAnnotationOrder.LABEL_AND_SEQUENCE);
359     long endTime = System.currentTimeMillis();
360     long elapsed = endTime - startTime;
361     System.out.println("Sort by label for semisorted " + numSeqs
362             + " sequences and "
363             + numAnns + " annotations took " + elapsed + "ms");
364
365     // now resort by sequence
366     startTime = System.currentTimeMillis();
367     testee.sort(annotations, SequenceAnnotationOrder.SEQUENCE_AND_LABEL);
368     endTime = System.currentTimeMillis();
369     elapsed = endTime - startTime;
370     System.out.println("Resort by sequence for semisorted " + numSeqs
371             + " sequences and " + numAnns + " annotations took " + elapsed
372             + "ms");
373
374     // now resort by label
375     startTime = System.currentTimeMillis();
376     testee.sort(annotations, SequenceAnnotationOrder.LABEL_AND_SEQUENCE);
377     endTime = System.currentTimeMillis();
378     elapsed = endTime - startTime;
379     System.out.println("Resort by label for semisorted " + numSeqs
380             + " sequences and " + numAnns + " annotations took " + elapsed
381             + "ms");
382   }
383 }