2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
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.
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.
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.
21 package jalview.datamodel;
23 import static org.testng.Assert.assertEquals;
24 import static org.testng.Assert.assertFalse;
25 import static org.testng.Assert.assertNotNull;
26 import static org.testng.Assert.assertNotSame;
27 import static org.testng.Assert.assertNull;
28 import static org.testng.Assert.assertSame;
29 import static org.testng.Assert.assertTrue;
30 import static org.testng.Assert.fail;
32 import jalview.analysis.Conservation;
33 import jalview.schemes.NucleotideColourScheme;
34 import jalview.schemes.PIDColourScheme;
36 import java.awt.Color;
37 import java.util.ArrayList;
38 import java.util.Collections;
39 import java.util.List;
41 import org.testng.annotations.Test;
43 import junit.extensions.PA;
45 public class SequenceGroupTest
47 @Test(groups = { "Functional" })
48 public void testAddSequence()
50 SequenceGroup sg = new SequenceGroup();
51 assertTrue(sg.getSequences().isEmpty());
53 SequenceI seq1 = new Sequence("seq1", "abc");
54 SequenceI seq2 = new Sequence("seq2", "abc");
55 SequenceI seq3 = new Sequence(seq1);
57 sg.addSequence(null, false);
58 assertTrue(sg.getSequences().isEmpty());
59 sg.addSequence(seq1, false);
60 assertEquals(sg.getSequences().size(), 1);
61 assertTrue(sg.getSequences().contains(seq1));
62 // adding the same sequence again does nothing
63 sg.addSequence(seq1, false);
64 assertEquals(sg.getSequences().size(), 1);
65 assertTrue(sg.getSequences().contains(seq1));
66 sg.addSequence(seq2, false);
67 sg.addSequence(seq2, false);
68 sg.addSequence(seq3, false);
69 assertEquals(sg.getSequences().size(), 3);
70 assertTrue(sg.getSequences().contains(seq1));
71 assertTrue(sg.getSequences().contains(seq2));
72 assertTrue(sg.getSequences().contains(seq3));
75 @Test(groups = { "Functional" })
76 public void testAddOrRemove()
78 SequenceGroup sg = new SequenceGroup();
79 assertTrue(sg.getSequences().isEmpty());
81 SequenceI seq1 = new Sequence("seq1", "abc");
82 SequenceI seq2 = new Sequence("seq2", "abc");
83 SequenceI seq3 = new Sequence(seq1);
85 sg.addOrRemove(seq1, false);
86 assertEquals(sg.getSequences().size(), 1);
87 sg.addOrRemove(seq2, false);
88 assertEquals(sg.getSequences().size(), 2);
89 sg.addOrRemove(seq3, false);
90 assertEquals(sg.getSequences().size(), 3);
91 assertTrue(sg.getSequences().contains(seq1));
92 assertTrue(sg.getSequences().contains(seq2));
93 assertTrue(sg.getSequences().contains(seq3));
94 sg.addOrRemove(seq1, false);
95 assertEquals(sg.getSequences().size(), 2);
96 assertFalse(sg.getSequences().contains(seq1));
99 @Test(groups = { "Functional" })
100 public void testGetColourScheme()
102 SequenceGroup sg = new SequenceGroup();
103 assertNotNull(sg.getGroupColourScheme());
104 assertNull(sg.getColourScheme());
106 sg.setGroupColourScheme(null);
107 assertNull(sg.getColourScheme());
109 NucleotideColourScheme scheme = new NucleotideColourScheme();
110 sg.setColourScheme(scheme);
111 assertSame(scheme, sg.getColourScheme());
114 @Test(groups = { "Functional" })
115 public void testSetContext()
117 SequenceGroup sg1 = new SequenceGroup();
118 SequenceGroup sg2 = new SequenceGroup();
119 SequenceGroup sg3 = new SequenceGroup();
120 assertNull(sg1.getContext());
121 sg1.setContext(null);
122 assertNull(sg1.getContext());
125 sg1.setContext(sg1); // self-reference :-O
126 fail("Expected exception");
127 } catch (IllegalArgumentException e)
130 assertNull(sg1.getContext());
133 assertSame(sg2, sg1.getContext());
137 sg3.setContext(sg1); // circular reference :-O
138 fail("Expected exception");
139 } catch (IllegalArgumentException e)
142 assertNull(sg3.getContext());
146 * use PrivilegedAccessor to 'force' a SequenceGroup with
147 * a circular context reference
149 PA.setValue(sg2, "context", sg2);
152 sg3.setContext(sg2, false); // circular reference in sg2
153 fail("Expected exception");
154 } catch (IllegalArgumentException e)
157 assertNull(sg3.getContext());
160 // test isDefined setting behaviour
161 sg2 = new SequenceGroup();
162 sg1.setContext(null, false);
163 assertFalse(sg1.isDefined());
165 sg1.setContext(sg2, false);
166 assertFalse(sg1.isDefined());
168 sg1.setContext(sg2, true);
169 assertTrue(sg1.isDefined());
171 // setContext without defined parameter does not change isDefined
172 sg1.setContext(null);
173 assertTrue(sg1.isDefined());
175 sg1.setContext(null, false);
177 assertFalse(sg1.isDefined());
180 @Test(groups = { "Functional" })
181 public void testContains()
184 * essentially the same tests as AlignmentI.findGroup
185 * but from a particular group's perspective
188 SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
189 SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
190 AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
192 * add a group consisting of just "DEF"
194 SequenceGroup sg1 = new SequenceGroup();
195 sg1.addSequence(seq1, false);
200 * test sequence membership
202 assertTrue(sg1.contains(seq1));
203 assertFalse(sg1.contains(seq2));
206 * test sequence+position
209 assertFalse(sg1.contains(seq1, 2)); // position not in group
210 assertFalse(sg1.contains(seq1, 6)); // position not in group
211 assertFalse(sg1.contains(seq2, 5)); // sequence not in group
212 assertTrue(sg1.contains(seq1, 3)); // yes
213 assertTrue(sg1.contains(seq1, 4));
214 assertTrue(sg1.contains(seq1, 5));
217 * add a group consisting of
221 SequenceGroup sg2 = new SequenceGroup();
222 sg2.addSequence(seq1, false);
223 sg2.addSequence(seq2, false);
229 * if a residue is in more than one group, method returns
230 * the first found (in order groups were added)
232 assertTrue(sg2.contains(seq1, 4));
233 assertTrue(sg2.contains(seq1, 5));
236 * seq2 only belongs to the second group
238 assertTrue(sg2.contains(seq2, 4));
239 assertTrue(sg2.contains(seq2, 5));
240 assertTrue(sg2.contains(seq2, 6));
241 assertTrue(sg2.contains(seq2, 7));
242 assertFalse(sg2.contains(seq2, 3));
243 assertFalse(sg2.contains(seq2, 8));
245 assertTrue(sg2.contains(seq2, 8));
246 sg2.deleteSequence(seq2, false);
247 assertFalse(sg2.contains(seq2));
250 @Test(groups = { "Functional" })
251 public void testCopyConstructor()
253 SequenceI seq = new Sequence("seq", "ABC");
254 SequenceGroup sg = new SequenceGroup();
255 sg.addSequence(seq, false);
257 sg.setDescription("desc");
258 sg.setColourScheme(new PIDColourScheme());
259 Conservation cons = new Conservation("Cons", 2,
260 Collections.<SequenceI> emptyList(), 3, 12);
261 PA.setValue(cons, "consSequence", new Sequence("s", "abc"));
262 sg.getGroupColourScheme().setConservation(cons);
263 sg.getGroupColourScheme().setConsensus(new Profiles(null));
264 sg.setDisplayBoxes(false);
265 sg.setDisplayText(false);
266 sg.setColourText(true);
267 PA.setValue(sg, "isDefined", true);
268 sg.setShowNonconserved(true);
269 sg.setOutlineColour(Color.red);
270 sg.setIdColour(Color.blue);
271 sg.thresholdTextColour = 1;
272 sg.textColour = Color.orange;
273 sg.textColour2 = Color.yellow;
274 sg.setIgnoreGapsConsensus(false);
275 sg.setshowSequenceLogo(true);
276 sg.setNormaliseSequenceLogo(true);
277 sg.setHidereps(true);
278 sg.setHideCols(true);
279 sg.setShowConsensusHistogram(true);
280 sg.setContext(new SequenceGroup());
282 SequenceGroup sg2 = new SequenceGroup(sg);
283 assertEquals(sg2.getName(), sg.getName());
284 assertEquals(sg2.getDescription(), sg.getDescription());
285 assertNotSame(sg2.getGroupColourScheme(), sg.getGroupColourScheme());
286 assertSame(sg2.getColourScheme(), sg.getColourScheme());
287 assertSame(PA.getValue(sg2.getGroupColourScheme(), "consensus"),
288 PA.getValue(sg.getGroupColourScheme(), "consensus"));
289 assertSame(PA.getValue(sg2.getGroupColourScheme(), "conservation"),
290 PA.getValue(sg.getGroupColourScheme(), "conservation"));
291 assertEquals(sg2.getDisplayBoxes(), sg.getDisplayBoxes());
292 assertEquals(sg2.getDisplayText(), sg.getDisplayText());
293 assertEquals(sg2.getColourText(), sg.getColourText());
294 assertEquals(sg2.getShowNonconserved(), sg.getShowNonconserved());
295 assertEquals(sg2.getOutlineColour(), sg.getOutlineColour());
296 assertEquals(sg2.getIdColour(), sg.getIdColour());
297 assertEquals(sg2.thresholdTextColour, sg.thresholdTextColour);
298 assertEquals(sg2.textColour, sg.textColour);
299 assertEquals(sg2.textColour2, sg.textColour2);
300 assertEquals(sg2.getIgnoreGapsConsensus(), sg.getIgnoreGapsConsensus());
301 assertEquals(sg2.isShowSequenceLogo(), sg.isShowSequenceLogo());
302 assertEquals(sg2.isNormaliseSequenceLogo(),
303 sg.isNormaliseSequenceLogo());
304 assertEquals(sg2.isHidereps(), sg.isHidereps());
305 assertEquals(sg2.isHideCols(), sg.isHideCols());
306 assertEquals(sg2.isShowConsensusHistogram(),
307 sg.isShowConsensusHistogram());
312 assertNotSame(sg2.getSequences(), sg.getSequences());
313 assertEquals(sg2.getSequences(), sg.getSequences());
316 * isDefined should only be set true when a new group is added to
317 * an alignment, not in the copy constructor
319 assertFalse(sg2.isDefined());
322 * context should be set explicitly, not by copy
324 assertNull(sg2.getContext());
327 @Test(groups = { "Functional" })
328 public void testConstructor_list()
330 SequenceI s1 = new Sequence("abcde", "fg");
331 SequenceI s2 = new Sequence("foo", "bar");
332 List<SequenceI> seqs = new ArrayList<>();
335 SequenceGroup sg = new SequenceGroup(seqs);
338 * verify sg has a copy of the original list
340 List<SequenceI> sgList = sg.getSequences();
341 assertNotSame(sgList, seqs);
342 assertEquals(sgList, seqs);
345 * add to sgList, original is unchanged
347 sg.addSequence(new Sequence("bar", "foo"), false);
348 assertEquals(sgList.size(), 3);
349 assertEquals(seqs.size(), 2);
352 * delete from original, sgList is unchanged
355 assertEquals(sgList.size(), 3);
356 assertEquals(seqs.size(), 1);