1 package jalview.datamodel;
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;
12 import jalview.analysis.Conservation;
13 import jalview.schemes.NucleotideColourScheme;
14 import jalview.schemes.PIDColourScheme;
16 import java.awt.Color;
17 import java.util.ArrayList;
18 import java.util.Collections;
20 import java.util.List;
22 import org.testng.annotations.Test;
24 import junit.extensions.PA;
26 public class SequenceGroupTest
28 @Test(groups={"Functional"})
29 public void testAddSequence()
31 SequenceGroup sg = new SequenceGroup();
32 assertTrue(sg.getSequences().isEmpty());
34 SequenceI seq1 = new Sequence("seq1", "abc");
35 SequenceI seq2 = new Sequence("seq2", "abc");
36 SequenceI seq3 = new Sequence(seq1);
38 sg.addSequence(null, false);
39 assertTrue(sg.getSequences().isEmpty());
40 sg.addSequence(seq1, false);
41 assertEquals(sg.getSequences().size(), 1);
42 assertTrue(sg.getSequences().contains(seq1));
43 // adding the same sequence again does nothing
44 sg.addSequence(seq1, false);
45 assertEquals(sg.getSequences().size(), 1);
46 assertTrue(sg.getSequences().contains(seq1));
47 sg.addSequence(seq2, false);
48 sg.addSequence(seq2, false);
49 sg.addSequence(seq3, false);
50 assertEquals(sg.getSequences().size(), 3);
51 assertTrue(sg.getSequences().contains(seq1));
52 assertTrue(sg.getSequences().contains(seq2));
53 assertTrue(sg.getSequences().contains(seq3));
56 @Test(groups={"Functional"})
57 public void testAddOrRemove()
59 SequenceGroup sg = new SequenceGroup();
60 assertTrue(sg.getSequences().isEmpty());
62 SequenceI seq1 = new Sequence("seq1", "abc");
63 SequenceI seq2 = new Sequence("seq2", "abc");
64 SequenceI seq3 = new Sequence(seq1);
66 sg.addOrRemove(seq1, false);
67 assertEquals(sg.getSequences().size(), 1);
68 sg.addOrRemove(seq2, false);
69 assertEquals(sg.getSequences().size(), 2);
70 sg.addOrRemove(seq3, false);
71 assertEquals(sg.getSequences().size(), 3);
72 assertTrue(sg.getSequences().contains(seq1));
73 assertTrue(sg.getSequences().contains(seq2));
74 assertTrue(sg.getSequences().contains(seq3));
75 sg.addOrRemove(seq1, false);
76 assertEquals(sg.getSequences().size(), 2);
77 assertFalse(sg.getSequences().contains(seq1));
80 @Test(groups={"Functional"})
81 public void testGetColourScheme()
83 SequenceGroup sg = new SequenceGroup();
84 assertNotNull(sg.getGroupColourScheme());
85 assertNull(sg.getColourScheme());
87 sg.setGroupColourScheme(null);
88 assertNull(sg.getColourScheme());
90 NucleotideColourScheme scheme = new NucleotideColourScheme();
91 sg.setColourScheme(scheme);
92 assertSame(scheme, sg.getColourScheme());
95 @Test(groups={"Functional"})
96 public void testSetContext()
98 SequenceGroup sg1 = new SequenceGroup();
99 SequenceGroup sg2 = new SequenceGroup();
100 SequenceGroup sg3 = new SequenceGroup();
101 assertNull(sg1.getContext());
102 sg1.setContext(null);
103 assertNull(sg1.getContext());
106 sg1.setContext(sg1); // self-reference :-O
107 fail("Expected exception");
108 } catch (IllegalArgumentException e)
111 assertNull(sg1.getContext());
114 assertSame(sg2, sg1.getContext());
118 sg3.setContext(sg1); // circular reference :-O
119 fail("Expected exception");
120 } catch (IllegalArgumentException e)
123 assertNull(sg3.getContext());
127 * use PrivilegedAccessor to 'force' a SequenceGroup with
128 * a circular context reference
130 PA.setValue(sg2, "context", sg2);
133 sg3.setContext(sg2, false); // circular reference in sg2
134 fail("Expected exception");
135 } catch (IllegalArgumentException e)
138 assertNull(sg3.getContext());
141 // test isDefined setting behaviour
142 sg2 = new SequenceGroup();
143 sg1.setContext(null, false);
144 assertFalse(sg1.isDefined());
146 sg1.setContext(sg2, false);
147 assertFalse(sg1.isDefined());
149 sg1.setContext(sg2, true);
150 assertTrue(sg1.isDefined());
152 // setContext without defined parameter does not change isDefined
153 sg1.setContext(null);
154 assertTrue(sg1.isDefined());
156 sg1.setContext(null, false);
158 assertFalse(sg1.isDefined());
161 @Test(groups = { "Functional" })
162 public void testContains()
165 * essentially the same tests as AlignmentI.findGroup
166 * but from a particular group's perspective
169 SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
170 SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
171 AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
173 * add a group consisting of just "DEF"
175 SequenceGroup sg1 = new SequenceGroup();
176 sg1.addSequence(seq1, false);
181 * test sequence membership
183 assertTrue(sg1.contains(seq1));
184 assertFalse(sg1.contains(seq2));
187 * test sequence+position
190 assertFalse(sg1.contains(seq1, 2)); // position not in group
191 assertFalse(sg1.contains(seq1, 6)); // position not in group
192 assertFalse(sg1.contains(seq2, 5)); // sequence not in group
193 assertTrue(sg1.contains(seq1, 3)); // yes
194 assertTrue(sg1.contains(seq1, 4));
195 assertTrue(sg1.contains(seq1, 5));
198 * add a group consisting of
202 SequenceGroup sg2 = new SequenceGroup();
203 sg2.addSequence(seq1, false);
204 sg2.addSequence(seq2, false);
210 * if a residue is in more than one group, method returns
211 * the first found (in order groups were added)
213 assertTrue(sg2.contains(seq1, 4));
214 assertTrue(sg2.contains(seq1, 5));
217 * seq2 only belongs to the second group
219 assertTrue(sg2.contains(seq2, 4));
220 assertTrue(sg2.contains(seq2, 5));
221 assertTrue(sg2.contains(seq2, 6));
222 assertTrue(sg2.contains(seq2, 7));
223 assertFalse(sg2.contains(seq2, 3));
224 assertFalse(sg2.contains(seq2, 8));
226 assertTrue(sg2.contains(seq2, 8));
227 sg2.deleteSequence(seq2, false);
228 assertFalse(sg2.contains(seq2));
231 @Test(groups = { "Functional" })
232 public void testCopyConstructor()
234 SequenceI seq = new Sequence("seq", "ABC");
235 SequenceGroup sg = new SequenceGroup();
236 sg.addSequence(seq, false);
238 sg.setDescription("desc");
239 sg.setColourScheme(new PIDColourScheme());
240 Conservation cons = new Conservation("Cons", 2,
241 Collections.<SequenceI> emptyList(), 3, 12);
242 PA.setValue(cons, "consSequence", new Sequence("s", "abc"));
243 sg.getGroupColourScheme().setConservation(cons);
244 sg.getGroupColourScheme().setConsensus(new Profiles(null));
245 sg.setDisplayBoxes(false);
246 sg.setDisplayText(false);
247 sg.setColourText(true);
248 PA.setValue(sg, "isDefined", true);
249 sg.setShowNonconserved(true);
250 sg.setOutlineColour(Color.red);
251 sg.setIdColour(Color.blue);
252 sg.thresholdTextColour = 1;
253 sg.textColour = Color.orange;
254 sg.textColour2 = Color.yellow;
255 sg.setIgnoreGapsConsensus(false);
256 sg.setshowSequenceLogo(true);
257 sg.setNormaliseSequenceLogo(true);
258 sg.setHidereps(true);
259 sg.setHideCols(true);
260 sg.setShowConsensusHistogram(true);
261 sg.setContext(new SequenceGroup());
263 SequenceGroup sg2 = new SequenceGroup(sg);
264 assertEquals(sg2.getName(), sg.getName());
265 assertEquals(sg2.getDescription(), sg.getDescription());
266 assertNotSame(sg2.getGroupColourScheme(), sg.getGroupColourScheme());
267 assertSame(sg2.getColourScheme(), sg.getColourScheme());
268 assertSame(PA.getValue(sg2.getGroupColourScheme(), "consensus"),
269 PA.getValue(sg.getGroupColourScheme(), "consensus"));
270 assertSame(PA.getValue(sg2.getGroupColourScheme(), "conservation"),
271 PA.getValue(sg.getGroupColourScheme(), "conservation"));
272 assertEquals(sg2.getDisplayBoxes(), sg.getDisplayBoxes());
273 assertEquals(sg2.getDisplayText(), sg.getDisplayText());
274 assertEquals(sg2.getColourText(), sg.getColourText());
275 assertEquals(sg2.getShowNonconserved(), sg.getShowNonconserved());
276 assertEquals(sg2.getOutlineColour(), sg.getOutlineColour());
277 assertEquals(sg2.getIdColour(), sg.getIdColour());
278 assertEquals(sg2.thresholdTextColour, sg.thresholdTextColour);
279 assertEquals(sg2.textColour, sg.textColour);
280 assertEquals(sg2.textColour2, sg.textColour2);
281 assertEquals(sg2.isIgnoreGapsConsensus(), sg.isIgnoreGapsConsensus());
282 assertEquals(sg2.isShowSequenceLogo(), sg.isShowSequenceLogo());
283 assertEquals(sg2.isNormaliseSequenceLogo(),
284 sg.isNormaliseSequenceLogo());
285 assertEquals(sg2.isHidereps(), sg.isHidereps());
286 assertEquals(sg2.isHideCols(), sg.isHideCols());
287 assertEquals(sg2.isShowConsensusHistogram(),
288 sg.isShowConsensusHistogram());
293 assertNotSame(sg2.getSequences(), sg.getSequences());
294 assertEquals(sg2.getSequences(), sg.getSequences());
297 * isDefined should only be set true when a new group is added to
298 * an alignment, not in the copy constructor
300 assertFalse(sg2.isDefined());
303 * context should be set explicitly, not by copy
305 assertNull(sg2.getContext());
308 @Test(groups = { "Functional" })
309 public void testConstructor_list()
311 SequenceI s1 = new Sequence("abcde", "fg");
312 SequenceI s2 = new Sequence("foo", "bar");
313 List<SequenceI> seqs = new ArrayList<SequenceI>();
316 SequenceGroup sg = new SequenceGroup(seqs);
319 * verify sg has a copy of the original list
321 List<SequenceI> sgList = sg.getSequences();
322 assertNotSame(sgList, seqs);
323 assertEquals(sgList, seqs);
326 * add to sgList, original is unchanged
328 sg.addSequence(new Sequence("bar", "foo"), false);
329 assertEquals(sgList.size(), 3);
330 assertEquals(seqs.size(), 2);
333 * delete from original, sgList is unchanged
336 assertEquals(sgList.size(), 3);
337 assertEquals(seqs.size(), 1);