1 /* 2 * Jalview - A Sequence Alignment Editor and Viewer (2.11.1.4) 3 * Copyright (C) 2021 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.datamodel; 22 23 import static org.testng.AssertJUnit.assertEquals; 24 import static org.testng.AssertJUnit.assertFalse; 25 import static org.testng.AssertJUnit.assertNotNull; 26 import static org.testng.AssertJUnit.assertNull; 27 import static org.testng.AssertJUnit.assertSame; 28 import static org.testng.AssertJUnit.assertTrue; 29 import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals; 30 31 import java.util.Arrays; 32 import java.util.List; 33 34 import org.testng.annotations.BeforeClass; 35 import org.testng.annotations.Test; 36 37 import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping; 38 import jalview.gui.JvOptionPane; 39 import jalview.util.MapList; 40 41 public class AlignedCodonFrameTest 42 { 43 44 @BeforeClass(alwaysRun = true) setUpJvOptionPane()45 public void setUpJvOptionPane() 46 { 47 JvOptionPane.setInteractiveMode(false); 48 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); 49 } 50 51 /** 52 * Test the method that locates the first aligned sequence that has a mapping. 53 */ 54 @Test(groups = { "Functional" }) testFindAlignedSequence()55 public void testFindAlignedSequence() 56 { 57 AlignmentI cdna = new Alignment(new SequenceI[] {}); 58 final Sequence seq1 = new Sequence("Seq1", "C-G-TA-GC"); 59 seq1.createDatasetSequence(); 60 cdna.addSequence(seq1); 61 final Sequence seq2 = new Sequence("Seq2", "-TA-GG-GG"); 62 seq2.createDatasetSequence(); 63 cdna.addSequence(seq2); 64 65 AlignmentI aa = new Alignment(new SequenceI[] {}); 66 final Sequence aseq1 = new Sequence("Seq1", "-P-R"); 67 aseq1.createDatasetSequence(); 68 aa.addSequence(aseq1); 69 final Sequence aseq2 = new Sequence("Seq2", "-LY-"); 70 aseq2.createDatasetSequence(); 71 aa.addSequence(aseq2); 72 73 /* 74 * Mapping from first DNA sequence to second AA sequence. 75 */ 76 AlignedCodonFrame acf = new AlignedCodonFrame(); 77 78 assertNull(acf.findAlignedSequence(seq1, aa)); 79 80 MapList map = new MapList(new int[] { 1, 6 }, new int[] { 1, 2 }, 3, 1); 81 acf.addMap(seq1.getDatasetSequence(), aseq2.getDatasetSequence(), map); 82 83 /* 84 * DNA seq1 maps to AA seq2 85 */ 86 assertEquals(aa.getSequenceAt(1), acf.findAlignedSequence(cdna 87 .getSequenceAt(0).getDatasetSequence(), aa)); 88 // can also find this from the dna aligned sequence 89 assertEquals(aa.getSequenceAt(1), 90 acf.findAlignedSequence(cdna.getSequenceAt(0), aa)); 91 92 assertEquals(cdna.getSequenceAt(0), acf.findAlignedSequence(aa 93 .getSequenceAt(1).getDatasetSequence(), cdna)); 94 } 95 96 /** 97 * Test the method that locates the mapped codon for a protein position. 98 */ 99 @Test(groups = { "Functional" }) testGetMappedRegion()100 public void testGetMappedRegion() 101 { 102 // introns lower case, exons upper case 103 final Sequence dna1 = new Sequence("Seq1/10-18", "c-G-TA-gC-gT-T"); 104 dna1.createDatasetSequence(); 105 final Sequence dna2 = new Sequence("Seq2/20-28", "-TA-gG-Gg-CG-a"); 106 dna2.createDatasetSequence(); 107 108 final Sequence pep1 = new Sequence("Seq1/3-4", "-P-R"); 109 pep1.createDatasetSequence(); 110 final Sequence pep2 = new Sequence("Seq2/7-9", "-LY-Q"); 111 pep2.createDatasetSequence(); 112 113 /* 114 * First with no mappings 115 */ 116 AlignedCodonFrame acf = new AlignedCodonFrame(); 117 118 assertNull(acf.getMappedRegion(dna1, pep1, 3)); 119 120 /* 121 * Set up the mappings for the exons (upper-case bases) 122 * Note residue Q is unmapped 123 */ 124 MapList map1 = new MapList(new int[] { 11, 13, 15, 15, 17, 18 }, new int[] { 125 3, 4 }, 3, 1); 126 acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map1); 127 MapList map2 = new MapList(new int[] { 20, 21, 23, 24, 26, 27 }, new int[] { 7, 9 }, 128 3, 1); 129 acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map2); 130 131 /* 132 * get codon positions for peptide position 133 */ 134 assertArrayEquals(new int[] { 11, 13 }, 135 acf.getMappedRegion(dna1, pep1, 3)); 136 assertArrayEquals(new int[] { 15, 15, 17, 18 }, 137 acf.getMappedRegion(dna1, pep1, 4)); 138 assertArrayEquals(new int[] { 20, 21, 23, 23 }, 139 acf.getMappedRegion(dna2, pep2, 7)); 140 assertArrayEquals(new int[] { 24, 24, 26, 27 }, 141 acf.getMappedRegion(dna2, pep2, 8)); 142 143 /* 144 * No mapping from dna2 to Q 145 */ 146 assertNull(acf.getMappedRegion(dna2, pep2, 9)); 147 148 /* 149 * No mapping from dna1 to pep2 150 */ 151 assertNull(acf.getMappedRegion(dna1, pep2, 7)); 152 153 /* 154 * get peptide position for codon position 155 */ 156 assertArrayEquals(new int[] { 3, 3 }, 157 acf.getMappedRegion(pep1, dna1, 11)); 158 assertArrayEquals(new int[] { 3, 3 }, 159 acf.getMappedRegion(pep1, dna1, 12)); 160 assertArrayEquals(new int[] { 3, 3 }, 161 acf.getMappedRegion(pep1, dna1, 13)); 162 assertNull(acf.getMappedRegion(pep1, dna1, 14)); // intron base, not mapped 163 164 } 165 166 @Test(groups = { "Functional" }) testGetMappedCodons()167 public void testGetMappedCodons() 168 { 169 final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); 170 seq1.createDatasetSequence(); 171 final Sequence aseq1 = new Sequence("Seq1", "-V-L"); 172 aseq1.createDatasetSequence(); 173 174 /* 175 * First with no mappings 176 */ 177 AlignedCodonFrame acf = new AlignedCodonFrame(); 178 179 assertNull(acf.getMappedCodons(seq1.getDatasetSequence(), 0)); 180 181 /* 182 * Set up the mappings for the exons (upper-case bases) 183 */ 184 MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { 185 1, 2 }, 3, 1); 186 acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); 187 188 assertEquals(1, acf.getMappedCodons(aseq1.getDatasetSequence(), 1) 189 .size()); 190 assertEquals( 191 "[G, T, A]", 192 Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), 193 1).get(0))); 194 assertEquals( 195 "[C, T, T]", 196 Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), 197 2).get(0))); 198 } 199 200 /** 201 * Test for the case where there is more than one variant of the DNA mapping 202 * to a protein sequence 203 */ 204 @Test(groups = { "Functional" }) testGetMappedCodons_dnaVariants()205 public void testGetMappedCodons_dnaVariants() 206 { 207 final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); 208 seq1.createDatasetSequence(); 209 final Sequence seq2 = new Sequence("Seq2", "c-G-TT-gT-gT-A"); 210 seq2.createDatasetSequence(); 211 final Sequence aseq1 = new Sequence("Seq1", "-V-L"); 212 aseq1.createDatasetSequence(); 213 214 AlignedCodonFrame acf = new AlignedCodonFrame(); 215 216 /* 217 * Set up the mappings for the exons (upper-case bases) 218 */ 219 MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { 220 1, 2 }, 3, 1); 221 acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); 222 acf.addMap(seq2.getDatasetSequence(), aseq1.getDatasetSequence(), map); 223 224 assertEquals(2, acf.getMappedCodons(aseq1.getDatasetSequence(), 1) 225 .size()); 226 List<char[]> codonsForV = acf.getMappedCodons( 227 aseq1.getDatasetSequence(), 1); 228 assertEquals("[G, T, A]", Arrays.toString(codonsForV.get(0))); 229 assertEquals("[G, T, T]", Arrays.toString(codonsForV.get(1))); 230 List<char[]> codonsForL = acf.getMappedCodons( 231 aseq1.getDatasetSequence(), 2); 232 assertEquals("[C, T, T]", Arrays.toString(codonsForL.get(0))); 233 assertEquals("[T, T, A]", Arrays.toString(codonsForL.get(1))); 234 } 235 236 /** 237 * Test for the case where sequences have start > 1 238 */ 239 @Test(groups = { "Functional" }) testGetMappedCodons_forSubSequences()240 public void testGetMappedCodons_forSubSequences() 241 { 242 final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T", 27, 35); 243 seq1.createDatasetSequence(); 244 245 final Sequence aseq1 = new Sequence("Seq1", "-V-L", 12, 13); 246 aseq1.createDatasetSequence(); 247 248 /* 249 * Set up the mappings for the exons (upper-case bases) 250 */ 251 AlignedCodonFrame acf = new AlignedCodonFrame(); 252 MapList map = new MapList(new int[] { 28, 30, 32, 32, 34, 35 }, 253 new int[] { 12, 13 }, 3, 1); 254 acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); 255 256 assertEquals( 257 "[G, T, A]", 258 Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), 259 12).get(0))); 260 assertEquals( 261 "[C, T, T]", 262 Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), 263 13).get(0))); 264 } 265 266 @Test(groups = { "Functional" }) testCouldReplaceSequence()267 public void testCouldReplaceSequence() 268 { 269 SequenceI seq1 = new Sequence("Seq1/10-21", "aaacccgggttt"); 270 SequenceI seq1proxy = new SequenceDummy("Seq1"); 271 272 // map to region within sequence is ok 273 assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, 274 17)); 275 // map to region overlapping sequence is ok 276 assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 5, 277 10)); 278 assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 21, 279 26)); 280 // map to region before sequence is not ok 281 assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 4, 282 9)); 283 // map to region after sequence is not ok 284 assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 22, 285 27)); 286 287 /* 288 * test should fail if name doesn't match 289 */ 290 seq1proxy.setName("Seq1a"); 291 assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, 292 17)); 293 seq1proxy.setName("Seq1"); 294 seq1.setName("Seq1a"); 295 assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, 296 17)); 297 298 /* 299 * a dummy sequence can't replace a real one 300 */ 301 assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1, seq1proxy, 12, 302 17)); 303 304 /* 305 * a dummy sequence can't replace a dummy sequence 306 */ 307 SequenceI seq1proxy2 = new SequenceDummy("Seq1"); 308 assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, 309 seq1proxy2, 12, 17)); 310 311 /* 312 * a real sequence can't replace a real one 313 */ 314 SequenceI seq1a = new Sequence("Seq1/10-21", "aaacccgggttt"); 315 assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1, seq1a, 12, 17)); 316 } 317 318 /** 319 * Tests for the method that tests whether any mapping to a dummy sequence can 320 * be 'realised' to a given real sequence 321 */ 322 @Test(groups = { "Functional" }) testIsRealisableWith()323 public void testIsRealisableWith() 324 { 325 SequenceI seq1 = new Sequence("Seq1", "tttaaaCCCGGGtttaaa"); 326 SequenceI seq2 = new Sequence("Seq2", "PG"); 327 SequenceI seq1proxy = new SequenceDummy("Seq1"); 328 seq1.createDatasetSequence(); 329 seq2.createDatasetSequence(); 330 MapList mapList = new MapList(new int[] { 7, 12 }, new int[] { 2, 3 }, 331 3, 1); 332 AlignedCodonFrame acf = new AlignedCodonFrame(); 333 acf.addMap(seq1proxy, seq2, mapList); 334 335 /* 336 * Seq2 is mapped to SequenceDummy seq1proxy bases 4-9 337 * This is 'realisable' from real sequence Seq1 338 */ 339 assertTrue(acf.isRealisableWith(seq1)); 340 341 /* 342 * test should fail if name doesn't match 343 */ 344 seq1proxy.setName("Seq1a"); 345 assertFalse(acf.isRealisableWith(seq1)); 346 seq1proxy.setName("Seq1"); 347 348 SequenceI seq1ds = seq1.getDatasetSequence(); 349 seq1ds.setName("Seq1a"); 350 assertFalse(acf.isRealisableWith(seq1)); 351 seq1ds.setName("Seq1"); 352 353 /* 354 * test should fail if no sequence overlap with mapping of bases 7-12 355 * use artificial start/end values to test this 356 */ 357 seq1ds.setStart(1); 358 seq1ds.setEnd(6); 359 // seq1 precedes mapped region: 360 assertFalse(acf.isRealisableWith(seq1)); 361 seq1ds.setEnd(7); 362 // seq1 includes first mapped base: 363 assertTrue(acf.isRealisableWith(seq1)); 364 seq1ds.setStart(13); 365 seq1ds.setEnd(18); 366 // seq1 follows mapped region: 367 assertFalse(acf.isRealisableWith(seq1)); 368 seq1ds.setStart(12); 369 // seq1 includes last mapped base: 370 assertTrue(acf.isRealisableWith(seq1)); 371 } 372 373 /** 374 * Tests for the method that converts mappings to a dummy sequence to mappings 375 * to a compatible real sequence 376 */ 377 @Test(groups = { "Functional" }) testRealiseWith()378 public void testRealiseWith() 379 { 380 SequenceI seq1 = new Sequence("Seq1", "tttCAACCCGGGtttaaa"); 381 SequenceI seq2 = new Sequence("Seq2", "QPG"); 382 SequenceI seq2a = new Sequence("Seq2a", "QPG"); 383 SequenceI seq1proxy = new SequenceDummy("Seq1"); 384 seq1.createDatasetSequence(); 385 seq2.createDatasetSequence(); 386 seq2a.createDatasetSequence(); 387 388 /* 389 * Make mappings from Seq2 and Seq2a peptides to dummy sequence Seq1 390 */ 391 AlignedCodonFrame acf = new AlignedCodonFrame(); 392 393 // map PG to codons 7-12 (CCCGGG) 394 MapList mapping1 = new MapList(new int[] { 7, 12 }, new int[] { 2, 3 }, 395 3, 1); 396 acf.addMap(seq1proxy, seq2, mapping1); 397 acf.addMap(seq1proxy, seq2a, mapping1); 398 399 // map QP to codons 4-9 (CAACCC) 400 MapList mapping2 = new MapList(new int[] { 4, 9 }, new int[] { 1, 2 }, 401 3, 1); 402 acf.addMap(seq1proxy, seq2, mapping2); 403 acf.addMap(seq1proxy, seq2a, mapping2); 404 405 /* 406 * acf now has two mappings one from Seq1 to Seq2, one from Seq1 to Seq2a 407 */ 408 assertEquals(2, acf.getdnaSeqs().length); 409 assertSame(seq1proxy, acf.getdnaSeqs()[0]); 410 assertSame(seq1proxy, acf.getdnaSeqs()[1]); 411 assertEquals(2, acf.getProtMappings().length); 412 413 // 'realise' these mappings with the compatible sequence seq1 414 // two mappings should be updated: 415 assertEquals(2, acf.realiseWith(seq1)); 416 assertSame(seq1.getDatasetSequence(), acf.getdnaSeqs()[0]); 417 assertSame(seq1.getDatasetSequence(), acf.getdnaSeqs()[1]); 418 } 419 420 /** 421 * Test the method that locates the mapped codon for a protein position. 422 */ 423 @Test(groups = { "Functional" }) testGetMappedRegion_eitherWay()424 public void testGetMappedRegion_eitherWay() 425 { 426 final Sequence seq1 = new Sequence("Seq1", "AAACCCGGGTTT"); 427 seq1.createDatasetSequence(); 428 final Sequence seq2 = new Sequence("Seq2", "KPGF"); 429 seq2.createDatasetSequence(); 430 final Sequence seq3 = new Sequence("Seq3", "QYKPGFSW"); 431 seq3.createDatasetSequence(); 432 433 /* 434 * map Seq1 to all of Seq2 and part of Seq3 435 */ 436 AlignedCodonFrame acf = new AlignedCodonFrame(); 437 MapList map = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 }, 3, 1); 438 acf.addMap(seq1.getDatasetSequence(), seq2.getDatasetSequence(), map); 439 map = new MapList(new int[] { 1, 12 }, new int[] { 3, 6 }, 3, 1); 440 acf.addMap(seq1.getDatasetSequence(), seq3.getDatasetSequence(), map); 441 442 /* 443 * map part of Seq3 to Seq2 444 */ 445 map = new MapList(new int[] { 3, 6 }, new int[] { 1, 4 }, 1, 1); 446 acf.addMap(seq3.getDatasetSequence(), seq2.getDatasetSequence(), map); 447 448 /* 449 * original case - locate mapped codon for protein position 450 */ 451 assertArrayEquals(new int[] { 4, 6 }, 452 acf.getMappedRegion(seq1, seq2, 2)); 453 assertArrayEquals(new int[] { 7, 9 }, 454 acf.getMappedRegion(seq1, seq3, 5)); 455 assertNull(acf.getMappedRegion(seq1, seq3, 1)); 456 457 /* 458 * locate mapped protein for protein position 459 */ 460 assertArrayEquals(new int[] { 4, 4 }, 461 acf.getMappedRegion(seq3, seq2, 2)); 462 463 /* 464 * reverse location protein-to-protein 465 */ 466 assertArrayEquals(new int[] { 2, 2 }, 467 acf.getMappedRegion(seq2, seq3, 4)); 468 469 /* 470 * reverse location protein-from-nucleotide 471 * any of codon [4, 5, 6] positions map to seq2/2 472 */ 473 assertArrayEquals(new int[] { 2, 2 }, 474 acf.getMappedRegion(seq2, seq1, 4)); 475 assertArrayEquals(new int[] { 2, 2 }, 476 acf.getMappedRegion(seq2, seq1, 5)); 477 assertArrayEquals(new int[] { 2, 2 }, 478 acf.getMappedRegion(seq2, seq1, 6)); 479 } 480 481 /** 482 * Tests for addMap. See also tests for MapList.addMapList 483 */ 484 @Test(groups = { "Functional" }) testAddMap()485 public void testAddMap() 486 { 487 final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); 488 seq1.createDatasetSequence(); 489 final Sequence aseq1 = new Sequence("Seq1", "-V-L"); 490 aseq1.createDatasetSequence(); 491 492 AlignedCodonFrame acf = new AlignedCodonFrame(); 493 MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { 494 1, 2 }, 3, 1); 495 acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); 496 assertEquals(1, acf.getMappingsFromSequence(seq1).size()); 497 Mapping before = acf.getMappingsFromSequence(seq1).get(0); 498 499 /* 500 * add the same map again, verify it doesn't get duplicated 501 */ 502 acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); 503 assertEquals(1, acf.getMappingsFromSequence(seq1).size()); 504 assertSame(before, acf.getMappingsFromSequence(seq1).get(0)); 505 } 506 507 @Test(groups = { "Functional" }) testGetCoveringMapping()508 public void testGetCoveringMapping() 509 { 510 SequenceI dna = new Sequence("dna", "acttcaATGGCGGACtaattt"); 511 SequenceI cds = new Sequence("cds/7-15", "ATGGCGGAC"); 512 cds.setDatasetSequence(dna); 513 SequenceI pep = new Sequence("pep", "MAD"); 514 515 /* 516 * with null argument or no mappings 517 */ 518 AlignedCodonFrame acf = new AlignedCodonFrame(); 519 assertNull(acf.getCoveringMapping(null, null)); 520 assertNull(acf.getCoveringMapping(dna, null)); 521 assertNull(acf.getCoveringMapping(null, pep)); 522 assertNull(acf.getCoveringMapping(dna, pep)); 523 524 /* 525 * with a non-covering mapping e.g. overlapping exon 526 */ 527 MapList map = new MapList(new int[] { 7, 9 }, new int[] { 528 1, 1 }, 3, 1); 529 acf.addMap(dna, pep, map); 530 assertNull(acf.getCoveringMapping(dna, pep)); 531 532 acf = new AlignedCodonFrame(); 533 MapList map2 = new MapList(new int[] { 13, 18 }, new int[] { 534 2, 2 }, 3, 1); 535 acf.addMap(dna, pep, map2); 536 assertNull(acf.getCoveringMapping(dna, pep)); 537 538 /* 539 * with a covering mapping from CDS (dataset) to protein 540 */ 541 acf = new AlignedCodonFrame(); 542 MapList map3 = new MapList(new int[] { 7, 15 }, new int[] { 543 1, 3 }, 3, 1); 544 acf.addMap(dna, pep, map3); 545 assertNull(acf.getCoveringMapping(dna, pep)); 546 SequenceToSequenceMapping mapping = acf.getCoveringMapping(cds, pep); 547 assertNotNull(mapping); 548 549 /* 550 * with a mapping that extends to stop codon 551 */ 552 acf = new AlignedCodonFrame(); 553 MapList map4 = new MapList(new int[] { 7, 18 }, new int[] { 554 1, 3 }, 3, 1); 555 acf.addMap(dna, pep, map4); 556 assertNull(acf.getCoveringMapping(dna, pep)); 557 assertNull(acf.getCoveringMapping(cds, pep)); 558 SequenceI cds2 = new Sequence("cds/7-18", "ATGGCGGACtaa"); 559 cds2.setDatasetSequence(dna); 560 mapping = acf.getCoveringMapping(cds2, pep); 561 assertNotNull(mapping); 562 } 563 564 /** 565 * Test the method that adds mapped positions to SearchResults 566 */ 567 @Test(groups = { "Functional" }) testMarkMappedRegion()568 public void testMarkMappedRegion() 569 { 570 // introns lower case, exons upper case 571 final Sequence dna1 = new Sequence("Seq1/10-18", "c-G-TA-gC-gT-T"); 572 dna1.createDatasetSequence(); 573 final Sequence dna2 = new Sequence("Seq2/20-28", "-TA-gG-Gg-CG-a"); 574 dna2.createDatasetSequence(); 575 576 final Sequence pep1 = new Sequence("Seq1/3-4", "-P-R"); 577 pep1.createDatasetSequence(); 578 final Sequence pep2 = new Sequence("Seq2/7-9", "-LY-Q"); 579 pep2.createDatasetSequence(); 580 581 /* 582 * First with no mappings 583 */ 584 AlignedCodonFrame acf = new AlignedCodonFrame(); 585 SearchResults sr = new SearchResults(); 586 acf.markMappedRegion(dna1, 12, sr); 587 assertTrue(sr.isEmpty()); 588 589 /* 590 * Set up the mappings for the exons (upper-case bases) 591 * Note residue Q is unmapped 592 */ 593 MapList map1 = new MapList(new int[] { 11, 13, 15, 15, 17, 18 }, new int[] { 594 3, 4 }, 3, 1); 595 acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map1); 596 MapList map2 = new MapList(new int[] { 20, 21, 23, 24, 26, 27 }, new int[] { 7, 8 }, 597 3, 1); 598 acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map2); 599 600 /* 601 * intron bases are not mapped 602 */ 603 acf.markMappedRegion(dna1, 10, sr); 604 assertTrue(sr.isEmpty()); 605 606 /* 607 * Q is not mapped 608 */ 609 acf.markMappedRegion(pep2, 9, sr); 610 assertTrue(sr.isEmpty()); 611 612 /* 613 * mark peptide position for exon position (of aligned sequence) 614 */ 615 acf.markMappedRegion(dna1, 11, sr); 616 SearchResults expected = new SearchResults(); 617 expected.addResult(pep1.getDatasetSequence(), 3, 3); 618 assertEquals(sr, expected); 619 620 /* 621 * mark peptide position for exon position of dataset sequence - same result 622 */ 623 sr = new SearchResults(); 624 acf.markMappedRegion(dna1.getDatasetSequence(), 11, sr); 625 assertEquals(sr, expected); 626 627 /* 628 * marking the same position a second time should not create a duplicate match 629 */ 630 acf.markMappedRegion(dna1.getDatasetSequence(), 12, sr); 631 assertEquals(sr, expected); 632 633 /* 634 * mark exon positions for peptide position (of aligned sequence) 635 */ 636 sr = new SearchResults(); 637 acf.markMappedRegion(pep2, 7, sr); // codon positions 20, 21, 23 638 expected = new SearchResults(); 639 expected.addResult(dna2.getDatasetSequence(), 20, 21); 640 expected.addResult(dna2.getDatasetSequence(), 23, 23); 641 assertEquals(sr, expected); 642 643 /* 644 * add another codon to the same SearchResults 645 */ 646 acf.markMappedRegion(pep1.getDatasetSequence(), 4, sr); // codon positions 15, 17, 18 647 expected.addResult(dna1.getDatasetSequence(), 15, 15); 648 expected.addResult(dna1.getDatasetSequence(), 17, 18); 649 assertEquals(sr, expected); 650 } 651 652 @Test(groups = { "Functional" }) testGetCoveringCodonMapping()653 public void testGetCoveringCodonMapping() 654 { 655 SequenceI dna = new Sequence("dna/10-30", "acttcaATGGCGGACtaattt"); 656 // CDS sequence with its own dataset sequence (JAL-3763) 657 SequenceI cds = new Sequence("cds/1-9", "-A--TGGC-GGAC"); 658 cds.createDatasetSequence(); 659 SequenceI pep = new Sequence("pep/1-3", "MAD"); 660 661 /* 662 * with null argument or no mappings 663 */ 664 AlignedCodonFrame acf = new AlignedCodonFrame(); 665 assertNull(acf.getCoveringCodonMapping(null)); 666 assertNull(acf.getCoveringCodonMapping(dna)); 667 assertNull(acf.getCoveringCodonMapping(pep)); 668 669 /* 670 * with a non-covering mapping e.g. overlapping exon 671 */ 672 MapList map = new MapList(new int[] { 16, 18 }, new int[] { 673 1, 1 }, 3, 1); 674 acf.addMap(dna, pep, map); 675 assertNull(acf.getCoveringCodonMapping(dna)); 676 assertNull(acf.getCoveringCodonMapping(pep)); 677 678 acf = new AlignedCodonFrame(); 679 MapList map2 = new MapList(new int[] { 13, 18 }, new int[] { 680 2, 2 }, 3, 1); 681 acf.addMap(dna, pep, map2); 682 assertNull(acf.getCoveringCodonMapping(dna)); 683 assertNull(acf.getCoveringCodonMapping(pep)); 684 685 /* 686 * with a covering mapping from CDS (dataset) to protein 687 */ 688 acf = new AlignedCodonFrame(); 689 MapList map3 = new MapList(new int[] { 1, 9 }, new int[] { 690 1, 3 }, 3, 1); 691 acf.addMap(cds.getDatasetSequence(), pep, map3); 692 assertNull(acf.getCoveringCodonMapping(dna)); 693 SequenceToSequenceMapping mapping = acf.getCoveringCodonMapping(pep); 694 assertNotNull(mapping); 695 SequenceToSequenceMapping mapping2 = acf.getCoveringCodonMapping(cds.getDatasetSequence()); 696 assertSame(mapping, mapping2); 697 698 /* 699 * with a mapping that extends to stop codon 700 * (EMBL CDS location often includes the stop codon) 701 * - getCoveringCodonMapping is lenient (doesn't require exact length match) 702 */ 703 SequenceI cds2 = new Sequence("cds/1-12", "-A--TGGC-GGACTAA"); 704 cds2.createDatasetSequence(); 705 acf = new AlignedCodonFrame(); 706 MapList map4 = new MapList(new int[] { 1, 12 }, new int[] { 707 1, 3 }, 3, 1); 708 acf.addMap(cds2, pep, map4); 709 mapping = acf.getCoveringCodonMapping(cds2.getDatasetSequence()); 710 assertNotNull(mapping); 711 mapping2 = acf.getCoveringCodonMapping(pep); 712 assertSame(mapping, mapping2); 713 } 714 } 715