b0af5c8721e7b7c0ff426aadfc2db9f3a6bafaa2
[jalview.git] / SequenceGroupTest.java
1 package jalview.datamodel;
2
3 import static org.testng.Assert.assertEquals;
4 import static org.testng.Assert.assertFalse;
5 import static org.testng.Assert.assertNotNull;
6 import static org.testng.Assert.assertNotSame;
7 import static org.testng.Assert.assertNull;
8 import static org.testng.Assert.assertSame;
9 import static org.testng.Assert.assertTrue;
10 import static org.testng.Assert.fail;
11
12 import jalview.analysis.Conservation;
13 import jalview.schemes.NucleotideColourScheme;
14 import jalview.schemes.PIDColourScheme;
15
16 import java.awt.Color;
17 import java.util.Collections;
18
19 import junit.extensions.PA;
20
21 import org.testng.annotations.Test;
22
23 public class SequenceGroupTest
24 {
25   @Test(groups={"Functional"})
26   public void testAddSequence()
27   {
28     SequenceGroup sg = new SequenceGroup();
29     assertTrue(sg.getSequences().isEmpty());
30
31     SequenceI seq1 = new Sequence("seq1", "abc");
32     SequenceI seq2 = new Sequence("seq2", "abc");
33     SequenceI seq3 = new Sequence(seq1);
34
35     sg.addSequence(null, false);
36     assertTrue(sg.getSequences().isEmpty());
37     sg.addSequence(seq1, false);
38     assertEquals(sg.getSequences().size(), 1);
39     assertTrue(sg.getSequences().contains(seq1));
40     // adding the same sequence again does nothing
41     sg.addSequence(seq1, false);
42     assertEquals(sg.getSequences().size(), 1);
43     assertTrue(sg.getSequences().contains(seq1));
44     sg.addSequence(seq2, false);
45     sg.addSequence(seq2, false);
46     sg.addSequence(seq3, false);
47     assertEquals(sg.getSequences().size(), 3);
48     assertTrue(sg.getSequences().contains(seq1));
49     assertTrue(sg.getSequences().contains(seq2));
50     assertTrue(sg.getSequences().contains(seq3));
51   }
52
53   @Test(groups={"Functional"})
54   public void testAddOrRemove()
55   {
56     SequenceGroup sg = new SequenceGroup();
57     assertTrue(sg.getSequences().isEmpty());
58   
59     SequenceI seq1 = new Sequence("seq1", "abc");
60     SequenceI seq2 = new Sequence("seq2", "abc");
61     SequenceI seq3 = new Sequence(seq1);
62   
63     sg.addOrRemove(seq1, false);
64     assertEquals(sg.getSequences().size(), 1);
65     sg.addOrRemove(seq2, false);
66     assertEquals(sg.getSequences().size(), 2);
67     sg.addOrRemove(seq3, false);
68     assertEquals(sg.getSequences().size(), 3);
69     assertTrue(sg.getSequences().contains(seq1));
70     assertTrue(sg.getSequences().contains(seq2));
71     assertTrue(sg.getSequences().contains(seq3));
72     sg.addOrRemove(seq1, false);
73     assertEquals(sg.getSequences().size(), 2);
74     assertFalse(sg.getSequences().contains(seq1));
75   }
76
77   @Test(groups={"Functional"})
78   public void testGetColourScheme()
79   {
80     SequenceGroup sg = new SequenceGroup();
81     assertNotNull(sg.getGroupColourScheme());
82     assertNull(sg.getColourScheme());
83
84     sg.setGroupColourScheme(null);
85     assertNull(sg.getColourScheme());
86
87     NucleotideColourScheme scheme = new NucleotideColourScheme();
88     sg.setColourScheme(scheme);
89     assertSame(scheme, sg.getColourScheme());
90   }
91
92   @Test(groups={"Functional"})
93   public void testSetContext()
94   {
95     SequenceGroup sg1 = new SequenceGroup();
96     SequenceGroup sg2 = new SequenceGroup();
97     SequenceGroup sg3 = new SequenceGroup();
98     assertNull(sg1.getContext());
99     sg1.setContext(null);
100     assertNull(sg1.getContext());
101     try
102     {
103       sg1.setContext(sg1); // self-reference :-O
104       fail("Expected exception");
105     } catch (IllegalArgumentException e)
106     {
107       // expected
108       assertNull(sg1.getContext());
109     }
110     sg1.setContext(sg2);
111     assertSame(sg2, sg1.getContext());
112     sg2.setContext(sg3);
113     try
114     {
115       sg3.setContext(sg1); // circular reference :-O
116       fail("Expected exception");
117     } catch (IllegalArgumentException e)
118     {
119       // expected
120       assertNull(sg3.getContext());
121     }
122
123     /*
124      * use PrivilegedAccessor to 'force' a SequenceGroup with
125      * a circular context reference
126      */
127     PA.setValue(sg2, "context", sg2);
128     try
129     {
130       sg3.setContext(sg2, false); // circular reference in sg2
131       fail("Expected exception");
132     } catch (IllegalArgumentException e)
133     {
134       // expected
135       assertNull(sg3.getContext());
136     }
137
138     // test isDefined setting behaviour
139     sg2 = new SequenceGroup();
140     sg1.setContext(null, false);
141     assertFalse(sg1.isDefined());
142
143     sg1.setContext(sg2, false);
144     assertFalse(sg1.isDefined());
145
146     sg1.setContext(sg2, true);
147     assertTrue(sg1.isDefined());
148
149     // setContext without defined parameter does not change isDefined
150     sg1.setContext(null);
151     assertTrue(sg1.isDefined());
152
153     sg1.setContext(null, false);
154     sg1.setContext(sg2);
155     assertFalse(sg1.isDefined());
156   }
157
158   @Test(groups = { "Functional" })
159   public void testContains()
160   {
161     /* 
162      * essentially the same tests as AlignmentI.findGroup 
163      * but from a particular group's perspective
164      */
165
166     SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
167     SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
168     AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
169     /*
170      * add a group consisting of just "DEF"
171      */
172     SequenceGroup sg1 = new SequenceGroup();
173     sg1.addSequence(seq1, false);
174     sg1.setStartRes(3);
175     sg1.setEndRes(5);
176
177     /*
178      * test sequence membership
179      */
180     assertTrue(sg1.contains(seq1));
181     assertFalse(sg1.contains(seq2));
182
183     /*
184      * test sequence+position
185      */
186
187     assertFalse(sg1.contains(seq1, 2)); // position not in group
188     assertFalse(sg1.contains(seq1, 6)); // position not in group
189     assertFalse(sg1.contains(seq2, 5)); // sequence not in group
190     assertTrue(sg1.contains(seq1, 3)); // yes
191     assertTrue(sg1.contains(seq1, 4));
192     assertTrue(sg1.contains(seq1, 5));
193
194     /*
195      * add a group consisting of 
196      * EF--
197      * KLMN
198      */
199     SequenceGroup sg2 = new SequenceGroup();
200     sg2.addSequence(seq1, false);
201     sg2.addSequence(seq2, false);
202     sg2.setStartRes(4);
203     sg2.setEndRes(7);
204     a.addGroup(sg2);
205
206     /*
207      * if a residue is in more than one group, method returns
208      * the first found (in order groups were added)
209      */
210     assertTrue(sg2.contains(seq1, 4));
211     assertTrue(sg2.contains(seq1, 5));
212
213     /*
214      * seq2 only belongs to the second group
215      */
216     assertTrue(sg2.contains(seq2, 4));
217     assertTrue(sg2.contains(seq2, 5));
218     assertTrue(sg2.contains(seq2, 6));
219     assertTrue(sg2.contains(seq2, 7));
220     assertFalse(sg2.contains(seq2, 3));
221     assertFalse(sg2.contains(seq2, 8));
222     sg2.setEndRes(8);
223     assertTrue(sg2.contains(seq2, 8));
224     sg2.deleteSequence(seq2, false);
225     assertFalse(sg2.contains(seq2));
226   }
227
228   @Test(groups = { "Functional" })
229   public void testCopyConstructor()
230   {
231     SequenceI seq = new Sequence("seq", "ABC");
232     SequenceGroup sg = new SequenceGroup();
233     sg.addSequence(seq, false);
234     sg.setName("g1");
235     sg.setDescription("desc");
236     sg.setColourScheme(new PIDColourScheme());
237     Conservation cons = new Conservation("Cons", 2,
238             Collections.<SequenceI> emptyList(), 3, 12);
239     PA.setValue(cons, "consSequence", new Sequence("s", "abc"));
240     sg.getGroupColourScheme().setConservation(cons);
241     sg.getGroupColourScheme().setConsensus(new Profiles(null));
242     sg.setDisplayBoxes(false);
243     sg.setDisplayText(false);
244     sg.setColourText(true);
245     sg.isDefined = true;
246     sg.setShowNonconserved(true);
247     sg.setOutlineColour(Color.red);
248     sg.setIdColour(Color.blue);
249     sg.thresholdTextColour = 1;
250     sg.textColour = Color.orange;
251     sg.textColour2 = Color.yellow;
252     sg.setIgnoreGapsConsensus(false);
253     sg.setshowSequenceLogo(true);
254     sg.setNormaliseSequenceLogo(true);
255     sg.setHidereps(true);
256     sg.setHideCols(true);
257     sg.setShowConsensusHistogram(true);
258     sg.setContext(new SequenceGroup());
259
260     SequenceGroup sg2 = new SequenceGroup(sg);
261     assertEquals(sg2.getName(), sg.getName());
262     assertEquals(sg2.getDescription(), sg.getDescription());
263     assertNotSame(sg2.getGroupColourScheme(), sg.getGroupColourScheme());
264     assertSame(sg2.getColourScheme(), sg.getColourScheme());
265     assertSame(PA.getValue(sg2.getGroupColourScheme(), "consensus"),
266             PA.getValue(sg.getGroupColourScheme(), "consensus"));
267     assertSame(PA.getValue(sg2.getGroupColourScheme(), "conservation"),
268             PA.getValue(sg.getGroupColourScheme(), "conservation"));
269     assertEquals(sg2.getDisplayBoxes(), sg.getDisplayBoxes());
270     assertEquals(sg2.getDisplayText(), sg.getDisplayText());
271     assertEquals(sg2.getColourText(), sg.getColourText());
272     assertEquals(sg2.getShowNonconserved(), sg.getShowNonconserved());
273     assertEquals(sg2.getOutlineColour(), sg.getOutlineColour());
274     assertEquals(sg2.getIdColour(), sg.getIdColour());
275     assertEquals(sg2.thresholdTextColour, sg.thresholdTextColour);
276     assertEquals(sg2.textColour, sg.textColour);
277     assertEquals(sg2.textColour2, sg.textColour2);
278     assertEquals(sg2.getIgnoreGapsConsensus(), sg.getIgnoreGapsConsensus());
279     assertEquals(sg2.isShowSequenceLogo(), sg.isShowSequenceLogo());
280     assertEquals(sg2.isNormaliseSequenceLogo(),
281             sg.isNormaliseSequenceLogo());
282     assertEquals(sg2.isHidereps(), sg.isHidereps());
283     assertEquals(sg2.isHideCols(), sg.isHideCols());
284     assertEquals(sg2.isShowConsensusHistogram(),
285             sg.isShowConsensusHistogram());
286
287     /*
288      * copy of sequences
289      */
290     assertNotSame(sg2.getSequences(), sg.getSequences());
291     assertEquals(sg2.getSequences(), sg.getSequences());
292
293     /*
294      * isDefined should only be set true when a new group is added to
295      * an alignment, not in the copy constructor
296      */
297     assertFalse(sg2.isDefined());
298
299     /*
300      * context should be set explicitly, not by copy
301      */
302     assertNull(sg2.getContext());
303   }
304 }