Class |
Line # |
Actions |
|||
---|---|---|---|---|---|
JSONFileTest | 58 | 231 | 57 |
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.io; | |
22 | ||
23 | import static org.testng.AssertJUnit.assertNotNull; | |
24 | ||
25 | import jalview.api.AlignExportSettingsI; | |
26 | import jalview.datamodel.AlignExportSettingsAdapter; | |
27 | import jalview.datamodel.Alignment; | |
28 | import jalview.datamodel.AlignmentAnnotation; | |
29 | import jalview.datamodel.AlignmentI; | |
30 | import jalview.datamodel.Annotation; | |
31 | import jalview.datamodel.HiddenColumns; | |
32 | import jalview.datamodel.Sequence; | |
33 | import jalview.datamodel.SequenceFeature; | |
34 | import jalview.datamodel.SequenceGroup; | |
35 | import jalview.datamodel.SequenceI; | |
36 | import jalview.datamodel.features.SequenceFeatures; | |
37 | import jalview.gui.AlignFrame; | |
38 | import jalview.gui.JvOptionPane; | |
39 | import jalview.json.binding.biojson.v1.ColourSchemeMapper; | |
40 | import jalview.schemes.ColourSchemeI; | |
41 | import jalview.schemes.ResidueColourScheme; | |
42 | ||
43 | import java.io.IOException; | |
44 | import java.util.ArrayList; | |
45 | import java.util.HashMap; | |
46 | import java.util.Iterator; | |
47 | import java.util.List; | |
48 | import java.util.Map; | |
49 | ||
50 | import org.testng.Assert; | |
51 | import org.testng.AssertJUnit; | |
52 | import org.testng.annotations.AfterTest; | |
53 | import org.testng.annotations.BeforeClass; | |
54 | import org.testng.annotations.BeforeMethod; | |
55 | import org.testng.annotations.BeforeTest; | |
56 | import org.testng.annotations.Test; | |
57 | ||
58 | public class JSONFileTest | |
59 | { | |
60 | ||
61 | 1 | @BeforeClass(alwaysRun = true) |
62 | public void setUpJvOptionPane() | |
63 | { | |
64 | 1 | JvOptionPane.setInteractiveMode(false); |
65 | 1 | JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
66 | } | |
67 | ||
68 | private int TEST_SEQ_HEIGHT = 0; | |
69 | ||
70 | private int TEST_GRP_HEIGHT = 0; | |
71 | ||
72 | private int TEST_ANOT_HEIGHT = 0; | |
73 | ||
74 | private int TEST_CS_HEIGHT = 0; | |
75 | ||
76 | private String TEST_JSON_FILE = "examples/example.json"; | |
77 | ||
78 | private Alignment alignment; | |
79 | ||
80 | private HashMap<String, SequenceI> expectedSeqs = new HashMap<>(); | |
81 | ||
82 | private HashMap<String, AlignmentAnnotation> expectedAnnots = new HashMap<>(); | |
83 | ||
84 | private HashMap<String, SequenceGroup> expectedGrps = new HashMap<>(); | |
85 | ||
86 | private HiddenColumns expectedColSel = new HiddenColumns(); | |
87 | ||
88 | private SequenceI[] expectedHiddenSeqs = new SequenceI[1]; | |
89 | ||
90 | private AlignmentI testAlignment; | |
91 | ||
92 | private int passedCount; | |
93 | ||
94 | private JSONFile testJsonFile; | |
95 | ||
96 | private JSONFile jf; | |
97 | ||
98 | private AlignExportSettingsI exportSettings; | |
99 | ||
100 | 4 | @BeforeTest(alwaysRun = true) |
101 | public void setup() throws Exception | |
102 | { | |
103 | /* | |
104 | * construct expected values | |
105 | * nb this have to match the data in examples/example.json | |
106 | */ | |
107 | // create and add sequences | |
108 | 4 | Sequence[] seqs = new Sequence[5]; |
109 | 4 | seqs[0] = new Sequence("FER_CAPAN", |
110 | "SVSATMISTSFMPRKPAVTSL-KPIPNVGE--ALF", 3, 34); | |
111 | 4 | seqs[1] = new Sequence("FER1_SOLLC", |
112 | "SISGTMISTSFLPRKPAVTSL-KAISNVGE--ALF", 3, 34); | |
113 | 4 | seqs[2] = new Sequence("Q93XJ9_SOLTU", |
114 | "SISGTMISTSFLPRKPVVTSL-KAISNVGE--ALF", 3, 34); | |
115 | 4 | seqs[3] = new Sequence("FER1_PEA", |
116 | "ALYGTAVSTSFLRTQPMPMSV-TTTKAFSN--GFL", 6, 37); | |
117 | 4 | seqs[4] = new Sequence("Q7XA98_TRIPR", |
118 | "ALYGTAVSTSFMRRQPVPMSV-ATTTTTKAFPSGF", 6, 39); | |
119 | ||
120 | 4 | SequenceI hiddenSeq = new Sequence("FER_TOCH", |
121 | "FILGTMISKSFLFRKPAVTSL-KAISNVGE--ALF", 3, 34); | |
122 | 4 | expectedHiddenSeqs[0] = hiddenSeq; |
123 | ||
124 | // create and add sequence features | |
125 | 4 | SequenceFeature seqFeature2 = new SequenceFeature("feature_x", |
126 | "theDesc", 6, 15, "Jalview"); | |
127 | 4 | SequenceFeature seqFeature3 = new SequenceFeature("feature_x", |
128 | "theDesc", 9, 18, "Jalview"); | |
129 | 4 | SequenceFeature seqFeature4 = new SequenceFeature("feature_x", |
130 | "theDesc", 9, 18, "Jalview"); | |
131 | // non-positional feature: | |
132 | 4 | SequenceFeature seqFeature5 = new SequenceFeature("Domain", |
133 | "My description", 0, 0, "Pfam"); | |
134 | 4 | seqs[2].addSequenceFeature(seqFeature2); |
135 | 4 | seqs[3].addSequenceFeature(seqFeature3); |
136 | 4 | seqs[4].addSequenceFeature(seqFeature4); |
137 | 4 | seqs[2].addSequenceFeature(seqFeature5); |
138 | ||
139 | 4 | for (Sequence seq : seqs) |
140 | { | |
141 | 20 | seq.createDatasetSequence(); |
142 | 20 | expectedSeqs.put(seq.getName(), seq); |
143 | } | |
144 | ||
145 | // create and add a sequence group | |
146 | 4 | List<SequenceI> grpSeqs = new ArrayList<>(); |
147 | 4 | grpSeqs.add(seqs[1]); |
148 | 4 | grpSeqs.add(seqs[2]); |
149 | 4 | grpSeqs.add(seqs[3]); |
150 | 4 | grpSeqs.add(seqs[4]); |
151 | 4 | SequenceGroup seqGrp = new SequenceGroup(grpSeqs, "JGroup:1883305585", |
152 | null, true, true, false, 21, 29); | |
153 | 4 | ColourSchemeI scheme = ColourSchemeMapper |
154 | .getJalviewColourScheme("zappo", seqGrp); | |
155 | 4 | seqGrp.cs.setColourScheme(scheme); |
156 | 4 | seqGrp.setShowNonconserved(false); |
157 | 4 | seqGrp.setDescription(null); |
158 | ||
159 | 4 | expectedGrps.put(seqGrp.getName(), seqGrp); |
160 | ||
161 | // create and add annotation | |
162 | 4 | Annotation[] annot = new Annotation[35]; |
163 | 4 | annot[0] = new Annotation("", "", '\u0000', 0); |
164 | 4 | annot[1] = new Annotation("", "", '\u0000', 0); |
165 | 4 | annot[2] = new Annotation("α", "", 'H', 0); |
166 | 4 | annot[3] = new Annotation("α", "", 'H', 0); |
167 | 4 | annot[4] = new Annotation("α", "", 'H', 0); |
168 | 4 | annot[5] = new Annotation("", "", '\u0000', 0); |
169 | 4 | annot[6] = new Annotation("", "", '\u0000', 0); |
170 | 4 | annot[7] = new Annotation("", "", '\u0000', 0); |
171 | 4 | annot[8] = new Annotation("β", "", 'E', 0); |
172 | 4 | annot[9] = new Annotation("β", "", 'E', 0); |
173 | 4 | annot[10] = new Annotation("β", "", 'E', 0); |
174 | 4 | annot[11] = new Annotation("β", "", 'E', 0); |
175 | 4 | annot[12] = new Annotation("β", "", 'E', 0); |
176 | 4 | annot[13] = new Annotation("β", "", 'E', 0); |
177 | 4 | annot[14] = new Annotation("β", "", 'E', 0); |
178 | 4 | annot[15] = new Annotation("β", "", 'E', 0); |
179 | 4 | annot[16] = new Annotation("", "", '\u0000', 0); |
180 | 4 | annot[17] = new Annotation("", "", '\u0000', 0); |
181 | 4 | annot[18] = new Annotation("", "", '\u0000', 0); |
182 | 4 | annot[19] = new Annotation("", "", '\u0000', 0); |
183 | 4 | annot[20] = new Annotation("", "", '\u0000', 0); |
184 | 4 | annot[21] = new Annotation("", "", '\u0000', 0); |
185 | 4 | annot[22] = new Annotation("", "", '\u0000', 0); |
186 | 4 | annot[23] = new Annotation("", "", '\u0000', 0); |
187 | 4 | annot[24] = new Annotation("", "", '\u0000', 0); |
188 | 4 | annot[25] = new Annotation("", "", '\u0000', 0); |
189 | 4 | annot[26] = new Annotation("α", "", 'H', 0); |
190 | 4 | annot[27] = new Annotation("α", "", 'H', 0); |
191 | 4 | annot[28] = new Annotation("α", "", 'H', 0); |
192 | 4 | annot[29] = new Annotation("α", "", 'H', 0); |
193 | 4 | annot[30] = new Annotation("α", "", 'H', 0); |
194 | 4 | annot[31] = new Annotation("", "", '\u0000', 0); |
195 | 4 | annot[32] = new Annotation("", "", '\u0000', 0); |
196 | 4 | annot[33] = new Annotation("", "", '\u0000', 0); |
197 | 4 | annot[34] = new Annotation("", "", '\u0000', 0); |
198 | ||
199 | 4 | AlignmentAnnotation alignAnnot = new AlignmentAnnotation( |
200 | "Secondary Structure", "New description", annot); | |
201 | 4 | expectedAnnots.put(alignAnnot.label, alignAnnot); |
202 | ||
203 | 4 | expectedColSel.hideColumns(32, 33); |
204 | 4 | expectedColSel.hideColumns(34, 34); |
205 | ||
206 | 4 | TEST_SEQ_HEIGHT = expectedSeqs.size(); |
207 | 4 | TEST_GRP_HEIGHT = expectedGrps.size(); |
208 | 4 | TEST_ANOT_HEIGHT = expectedAnnots.size(); |
209 | 4 | TEST_CS_HEIGHT = expectedColSel.getNumberOfRegions(); |
210 | ||
211 | 4 | exportSettings = new AlignExportSettingsAdapter(true); |
212 | ||
213 | 4 | AppletFormatAdapter formatAdapter = new AppletFormatAdapter(); |
214 | 4 | try |
215 | { | |
216 | 4 | alignment = (Alignment) formatAdapter.readFile(TEST_JSON_FILE, |
217 | DataSourceType.FILE, FileFormat.Json); | |
218 | 4 | jf = (JSONFile) formatAdapter.getAlignFile(); |
219 | ||
220 | 4 | AlignFrame af = new AlignFrame(alignment, jf.getHiddenSequences(), |
221 | jf.getHiddenColumns(), AlignFrame.DEFAULT_WIDTH, | |
222 | AlignFrame.DEFAULT_HEIGHT); | |
223 | 4 | af.getViewport().setShowSequenceFeatures(jf.isShowSeqFeatures()); |
224 | 4 | String colourSchemeName = jf.getGlobalColourScheme(); |
225 | 4 | ColourSchemeI cs = ColourSchemeMapper |
226 | .getJalviewColourScheme(colourSchemeName, alignment); | |
227 | 4 | af.changeColour(cs); |
228 | 4 | af.getViewport().setFeaturesDisplayed(jf.getDisplayedFeatures()); |
229 | ||
230 | 4 | formatAdapter = new AppletFormatAdapter(af.alignPanel, |
231 | exportSettings); | |
232 | 4 | String jsonOutput = formatAdapter.formatSequences(FileFormat.Json, |
233 | af.alignPanel.getAlignment(), false); | |
234 | ||
235 | 4 | formatAdapter = new AppletFormatAdapter(); |
236 | 4 | testAlignment = formatAdapter.readFile(jsonOutput, |
237 | DataSourceType.PASTE, FileFormat.Json); | |
238 | 4 | testJsonFile = (JSONFile) formatAdapter.getAlignFile(); |
239 | 4 | System.out.println(jsonOutput); |
240 | } catch (IOException e) | |
241 | { | |
242 | 0 | e.printStackTrace(); |
243 | } | |
244 | ||
245 | } | |
246 | ||
247 | 10 | @BeforeMethod(alwaysRun = true) |
248 | public void methodSetup() | |
249 | { | |
250 | 10 | passedCount = 0; |
251 | } | |
252 | ||
253 | 4 | @AfterTest(alwaysRun = true) |
254 | public void tearDown() throws Exception | |
255 | { | |
256 | 4 | testJsonFile = null; |
257 | 4 | alignment = null; |
258 | 4 | expectedSeqs = null; |
259 | 4 | expectedAnnots = null; |
260 | 4 | expectedGrps = null; |
261 | 4 | testAlignment = null; |
262 | 4 | jf = null; |
263 | } | |
264 | ||
265 | 1 | @Test(groups = { "Functional" }) |
266 | public void roundTripTest() | |
267 | { | |
268 | 1 | assertNotNull("JSON roundtrip test failed!", testJsonFile); |
269 | } | |
270 | ||
271 | 1 | @Test(groups = { "Functional" }) |
272 | public void testSeqParsed() | |
273 | { | |
274 | 1 | assertNotNull("Couldn't read supplied alignment data.", testAlignment); |
275 | 1 | Assert.assertNotNull(testAlignment.getSequences()); |
276 | 1 | for (SequenceI seq : testAlignment.getSequences()) |
277 | { | |
278 | 5 | SequenceI expectedSeq = expectedSeqs.get(seq.getName()); |
279 | 5 | AssertJUnit.assertTrue( |
280 | "Failed Sequence Test for >>> " + seq.getName(), | |
281 | isSeqMatched(expectedSeq, seq)); | |
282 | 5 | passedCount++; |
283 | } | |
284 | 1 | AssertJUnit.assertEquals("Some Sequences did not pass the test", |
285 | TEST_SEQ_HEIGHT, passedCount); | |
286 | } | |
287 | ||
288 | 1 | @Test(groups = { "Functional" }) |
289 | public void hiddenColsTest() | |
290 | { | |
291 | 1 | HiddenColumns cs = testJsonFile.getHiddenColumns(); |
292 | 1 | Assert.assertNotNull(cs); |
293 | ||
294 | 1 | Iterator<int[]> it = cs.iterator(); |
295 | 1 | Iterator<int[]> colselit = expectedColSel.iterator(); |
296 | 1 | Assert.assertTrue(it.hasNext()); |
297 | 1 | Assert.assertEquals(cs.getNumberOfRegions(), TEST_CS_HEIGHT); |
298 | 1 | Assert.assertEquals(it.next(), colselit.next(), |
299 | "Mismatched hidden columns!"); | |
300 | } | |
301 | ||
302 | 1 | @Test(groups = { "Functional" }) |
303 | public void hiddenSeqsTest() | |
304 | { | |
305 | 1 | Assert.assertNotNull(testJsonFile.getHiddenSequences(), |
306 | "Hidden sequence Expected but found Null"); | |
307 | 1 | Assert.assertEquals(jf.getHiddenSequences().length, 1, |
308 | "Hidden sequence"); | |
309 | } | |
310 | ||
311 | 1 | @Test(groups = { "Functional" }) |
312 | public void colorSchemeTest() | |
313 | { | |
314 | 1 | Assert.assertNotNull(testJsonFile.getGlobalColourScheme(), |
315 | "Colourscheme is null, parsing failed!"); | |
316 | 1 | Assert.assertEquals(testJsonFile.getGlobalColourScheme(), "Zappo", |
317 | "Zappo colour scheme expected!"); | |
318 | } | |
319 | ||
320 | /** | |
321 | * Test for bug JAL-2489, NPE when exporting BioJSON with global colour | |
322 | * scheme, and a group colour scheme, set as 'None' | |
323 | */ | |
324 | 1 | @Test(groups = { "Functional" }) |
325 | public void testBioJSONRoundTripWithColourSchemeNone() | |
326 | { | |
327 | 1 | AppletFormatAdapter formatAdapter = new AppletFormatAdapter(); |
328 | ||
329 | 1 | Alignment _alignment; |
330 | 1 | try |
331 | { | |
332 | // load example BioJSON file | |
333 | 1 | _alignment = (Alignment) formatAdapter.readFile(TEST_JSON_FILE, |
334 | DataSourceType.FILE, FileFormat.Json); | |
335 | 1 | JSONFile bioJsonFile = (JSONFile) formatAdapter.getAlignFile(); |
336 | 1 | AlignFrame alignFrame = new AlignFrame(_alignment, |
337 | bioJsonFile.getHiddenSequences(), | |
338 | bioJsonFile.getHiddenColumns(), AlignFrame.DEFAULT_WIDTH, | |
339 | AlignFrame.DEFAULT_HEIGHT); | |
340 | ||
341 | /* | |
342 | * Create a group on the alignment; | |
343 | * Change global and group colour scheme to 'None' and perform round trip | |
344 | */ | |
345 | 1 | SequenceGroup sg = new SequenceGroup(); |
346 | 1 | sg.addSequence(_alignment.getSequenceAt(0), false); |
347 | 1 | sg.setColourScheme(null); |
348 | 1 | ColourSchemeI cs = ColourSchemeMapper |
349 | .getJalviewColourScheme(ResidueColourScheme.NONE, _alignment); | |
350 | 1 | alignFrame.changeColour(cs); |
351 | 1 | alignFrame.getViewport() |
352 | .setFeaturesDisplayed(bioJsonFile.getDisplayedFeatures()); | |
353 | 1 | formatAdapter = new AppletFormatAdapter(alignFrame.alignPanel, |
354 | exportSettings); | |
355 | // export BioJSON string | |
356 | 1 | String jsonOutput = formatAdapter.formatSequences(FileFormat.Json, |
357 | alignFrame.alignPanel.getAlignment(), false); | |
358 | // read back Alignment from BioJSON string | |
359 | 1 | formatAdapter = new AppletFormatAdapter(); |
360 | 1 | formatAdapter.readFile(jsonOutput, DataSourceType.PASTE, |
361 | FileFormat.Json); | |
362 | // assert 'None' colour scheme is retained after round trip | |
363 | 1 | JSONFile _bioJsonFile = (JSONFile) formatAdapter.getAlignFile(); |
364 | 1 | Assert.assertEquals(_bioJsonFile.getGlobalColourScheme(), |
365 | ResidueColourScheme.NONE); | |
366 | } catch (IOException e) | |
367 | { | |
368 | 0 | e.printStackTrace(); |
369 | } | |
370 | } | |
371 | ||
372 | 1 | @Test(groups = { "Functional" }) |
373 | public void isShowSeqFeaturesSet() | |
374 | { | |
375 | 1 | Assert.assertTrue(testJsonFile.isShowSeqFeatures(), |
376 | "Sequence feature isDisplayed setting expected to be true"); | |
377 | } | |
378 | ||
379 | 1 | @Test(groups = { "Functional" }) |
380 | public void testGrpParsed() | |
381 | { | |
382 | 1 | Assert.assertNotNull(testAlignment.getGroups()); |
383 | 1 | for (SequenceGroup seqGrp : testAlignment.getGroups()) |
384 | { | |
385 | 1 | SequenceGroup expectedGrp = expectedGrps.get(seqGrp.getName()); |
386 | 1 | AssertJUnit.assertTrue( |
387 | "Failed SequenceGroup Test for >>> " + seqGrp.getName(), | |
388 | isGroupMatched(expectedGrp, seqGrp)); | |
389 | 1 | passedCount++; |
390 | } | |
391 | 1 | AssertJUnit.assertEquals("Some SequenceGroups did not pass the test", |
392 | TEST_GRP_HEIGHT, passedCount); | |
393 | } | |
394 | ||
395 | 1 | @Test(groups = { "Functional" }) |
396 | public void testAnnotationParsed() | |
397 | { | |
398 | 1 | Assert.assertNotNull(testAlignment.getAlignmentAnnotation()); |
399 | 1 | for (AlignmentAnnotation annot : testAlignment.getAlignmentAnnotation()) |
400 | { | |
401 | 1 | AlignmentAnnotation expectedAnnot = expectedAnnots.get(annot.label); |
402 | 1 | AssertJUnit.assertTrue( |
403 | "Failed AlignmentAnnotation Test for >>> " + annot.label, | |
404 | isAnnotationMatched(expectedAnnot, annot)); | |
405 | 1 | passedCount++; |
406 | } | |
407 | 1 | AssertJUnit.assertEquals("Some Sequences did not pass the test", |
408 | TEST_ANOT_HEIGHT, passedCount); | |
409 | } | |
410 | ||
411 | 1 | public boolean isAnnotationMatched(AlignmentAnnotation eAnnot, |
412 | AlignmentAnnotation annot) | |
413 | { | |
414 | 1 | if (!eAnnot.label.equals(annot.label) |
415 | || !eAnnot.description.equals(annot.description) | |
416 | || eAnnot.annotations.length != annot.annotations.length) | |
417 | { | |
418 | 0 | return false; |
419 | } | |
420 | ||
421 | 36 | for (int x = 0; x < annot.annotations.length; x++) |
422 | { | |
423 | 35 | Annotation y = annot.annotations[x]; |
424 | 35 | Annotation z = annot.annotations[x]; |
425 | ||
426 | 35 | if (!y.displayCharacter.equals(z.displayCharacter) |
427 | || y.value != z.value | |
428 | || y.secondaryStructure != z.secondaryStructure) | |
429 | { | |
430 | 0 | return false; |
431 | } | |
432 | } | |
433 | 1 | return true; |
434 | } | |
435 | ||
436 | 5 | boolean isSeqMatched(SequenceI expectedSeq, SequenceI actualSeq) |
437 | { | |
438 | 5 | System.out.println("Testing >>> " + actualSeq.getName()); |
439 | ||
440 | 5 | if (expectedSeq.getName().equals(actualSeq.getName()) |
441 | && expectedSeq.getSequenceAsString() | |
442 | .equals(actualSeq.getSequenceAsString()) | |
443 | && expectedSeq.getStart() == actualSeq.getStart() | |
444 | && expectedSeq.getEnd() == actualSeq.getEnd() | |
445 | && featuresMatched(expectedSeq, actualSeq)) | |
446 | { | |
447 | 5 | return true; |
448 | } | |
449 | 0 | return false; |
450 | } | |
451 | ||
452 | 2 | public boolean isGroupMatched(SequenceGroup expectedGrp, |
453 | SequenceGroup actualGrp) | |
454 | { | |
455 | ||
456 | 2 | System.out.println("Testing >>> " + actualGrp.getName()); |
457 | 2 | System.out.println(expectedGrp.getName() + " | " + actualGrp.getName()); |
458 | 2 | System.out.println(expectedGrp.getColourText() + " | " |
459 | + actualGrp.getColourText()); | |
460 | 2 | System.out.println(expectedGrp.getDisplayBoxes() + " | " |
461 | + actualGrp.getDisplayBoxes()); | |
462 | 2 | System.out.println(expectedGrp.getIgnoreGapsConsensus() + " | " |
463 | + actualGrp.getIgnoreGapsConsensus()); | |
464 | 2 | System.out.println(expectedGrp.getSequences().size() + " | " |
465 | + actualGrp.getSequences().size()); | |
466 | 2 | System.out.println( |
467 | expectedGrp.getStartRes() + " | " + actualGrp.getStartRes()); | |
468 | 2 | System.out.println( |
469 | expectedGrp.getEndRes() + " | " + actualGrp.getEndRes()); | |
470 | 2 | System.out.println(expectedGrp.cs.getColourScheme() + " | " |
471 | + actualGrp.cs.getColourScheme()); | |
472 | ||
473 | 2 | boolean colourSchemeMatches = (expectedGrp.cs.getColourScheme() == null |
474 | && actualGrp.cs.getColourScheme() == null) | |
475 | || expectedGrp.cs.getColourScheme().getClass() | |
476 | .equals(actualGrp.cs.getColourScheme().getClass()); | |
477 | 2 | if (expectedGrp.getName().equals(actualGrp.getName()) |
478 | && expectedGrp.getColourText() == actualGrp.getColourText() | |
479 | && expectedGrp.getDisplayBoxes() == actualGrp.getDisplayBoxes() | |
480 | && expectedGrp.getIgnoreGapsConsensus() == actualGrp | |
481 | .getIgnoreGapsConsensus() | |
482 | && colourSchemeMatches | |
483 | && expectedGrp.getSequences().size() == actualGrp.getSequences() | |
484 | .size() | |
485 | && expectedGrp.getStartRes() == actualGrp.getStartRes() | |
486 | && expectedGrp.getEndRes() == actualGrp.getEndRes()) | |
487 | { | |
488 | 2 | return true; |
489 | } | |
490 | 0 | return false; |
491 | } | |
492 | ||
493 | 5 | private boolean featuresMatched(SequenceI seq1, SequenceI seq2) |
494 | { | |
495 | 5 | try |
496 | { | |
497 | 5 | if (seq1 == null && seq2 == null) |
498 | { | |
499 | 0 | return true; |
500 | } | |
501 | ||
502 | 5 | List<SequenceFeature> inFeature = seq1.getFeatures().getAllFeatures(); |
503 | 5 | List<SequenceFeature> outFeature = seq2.getFeatures() |
504 | .getAllFeatures(); | |
505 | ||
506 | 5 | if (inFeature.size() != outFeature.size()) |
507 | { | |
508 | 0 | System.err.println("Feature count in: " + inFeature.size() |
509 | + ", out: " + outFeature.size()); | |
510 | 0 | return false; |
511 | } | |
512 | ||
513 | 5 | SequenceFeatures.sortFeatures(inFeature, true); |
514 | 5 | SequenceFeatures.sortFeatures(outFeature, true); |
515 | 5 | int i = 0; |
516 | 5 | for (SequenceFeature in : inFeature) |
517 | { | |
518 | 4 | SequenceFeature out = outFeature.get(i); |
519 | /* | |
520 | System.out.println(out.getType() + " | " + in.getType()); | |
521 | System.out.println(out.getBegin() + " | " + in.getBegin()); | |
522 | System.out.println(out.getEnd() + " | " + in.getEnd()); | |
523 | */ | |
524 | 4 | if (!in.equals(out)) |
525 | { | |
526 | 0 | System.err.println( |
527 | "Mismatch of " + in.toString() + " " + out.toString()); | |
528 | 0 | return false; |
529 | } | |
530 | /* | |
531 | if (in.getBegin() == out.getBegin() && in.getEnd() == out.getEnd() | |
532 | && in.getScore() == out.getScore() | |
533 | && in.getFeatureGroup().equals(out.getFeatureGroup()) | |
534 | && in.getType().equals(out.getType()) | |
535 | && mapsMatch(in.otherDetails, out.otherDetails)) | |
536 | { | |
537 | } | |
538 | else | |
539 | { | |
540 | System.err.println("Feature[" + i + "] mismatch, in: " | |
541 | + in.toString() + ", out: " | |
542 | + outFeature.get(i).toString()); | |
543 | return false; | |
544 | } | |
545 | */ | |
546 | 4 | i++; |
547 | } | |
548 | } catch (Exception e) | |
549 | { | |
550 | 0 | e.printStackTrace(); |
551 | } | |
552 | // System.out.println(">>>>>>>>>>>>>> features matched : " + matched); | |
553 | 5 | return true; |
554 | } | |
555 | ||
556 | 0 | boolean mapsMatch(Map<String, Object> m1, Map<String, Object> m2) |
557 | { | |
558 | 0 | if (m1 == null || m2 == null) |
559 | { | |
560 | 0 | if (m1 != null || m2 != null) |
561 | { | |
562 | 0 | System.err.println( |
563 | "only one SequenceFeature.otherDetails is not null"); | |
564 | 0 | return false; |
565 | } | |
566 | else | |
567 | { | |
568 | 0 | return true; |
569 | } | |
570 | } | |
571 | 0 | if (m1.size() != m2.size()) |
572 | { | |
573 | 0 | System.err.println("otherDetails map different sizes"); |
574 | 0 | return false; |
575 | } | |
576 | 0 | for (String key : m1.keySet()) |
577 | { | |
578 | 0 | if (!m2.containsKey(key)) |
579 | { | |
580 | 0 | System.err.println(key + " in only one otherDetails"); |
581 | 0 | return false; |
582 | } | |
583 | 0 | if (m1.get(key) == null && m2.get(key) != null |
584 | || m1.get(key) != null && m2.get(key) == null | |
585 | || !m1.get(key).equals(m2.get(key))) | |
586 | { | |
587 | 0 | System.err.println(key + " values in otherDetails don't match"); |
588 | 0 | return false; |
589 | } | |
590 | } | |
591 | 0 | return true; |
592 | } | |
593 | ||
594 | /** | |
595 | * Test group roundtrip with null (None) group colour scheme | |
596 | * | |
597 | * @throws IOException | |
598 | */ | |
599 | 1 | @Test(groups = { "Functional" }) |
600 | public void testGrpParsed_colourNone() throws IOException | |
601 | { | |
602 | 1 | AlignmentI copy = new Alignment(testAlignment); |
603 | 1 | SequenceGroup sg = testAlignment.getGroups().get(0); |
604 | 1 | SequenceGroup copySg = new SequenceGroup(new ArrayList<SequenceI>(), |
605 | sg.getName(), null, sg.getDisplayBoxes(), sg.getDisplayText(), | |
606 | sg.getColourText(), sg.getStartRes(), sg.getEndRes()); | |
607 | 1 | for (SequenceI seq : sg.getSequences()) |
608 | { | |
609 | 4 | int seqIndex = testAlignment.findIndex(seq); |
610 | 4 | copySg.addSequence(copy.getSequenceAt(seqIndex), false); |
611 | } | |
612 | 1 | copy.addGroup(copySg); |
613 | ||
614 | 1 | AlignFrame af = new AlignFrame(copy, copy.getWidth(), copy.getHeight()); |
615 | 1 | AppletFormatAdapter formatAdapter = new AppletFormatAdapter( |
616 | af.alignPanel); | |
617 | 1 | String jsonOutput = formatAdapter.formatSequences(FileFormat.Json, copy, |
618 | false); | |
619 | 1 | formatAdapter = new AppletFormatAdapter(); |
620 | 1 | AlignmentI newAlignment = formatAdapter.readFile(jsonOutput, |
621 | DataSourceType.PASTE, FileFormat.Json); | |
622 | ||
623 | 1 | Assert.assertNotNull(newAlignment.getGroups()); |
624 | 1 | for (SequenceGroup seqGrp : newAlignment.getGroups()) |
625 | { | |
626 | 1 | SequenceGroup expectedGrp = copySg; |
627 | 1 | AssertJUnit.assertTrue( |
628 | "Failed SequenceGroup Test for >>> " + seqGrp.getName(), | |
629 | isGroupMatched(expectedGrp, seqGrp)); | |
630 | 1 | passedCount++; |
631 | } | |
632 | 1 | AssertJUnit.assertEquals("Some SequenceGroups did not pass the test", |
633 | TEST_GRP_HEIGHT, passedCount); | |
634 | } | |
635 | } |