test/jalview/analysis/ConservationTest.java

   1 package jalview.analysis;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertTrue;
   5
   6 import jalview.datamodel.Sequence;
   7 import jalview.datamodel.SequenceI;
   8 import jalview.gui.JvOptionPane;
   9
  10 import java.util.ArrayList;
  11 import java.util.HashMap;
  12 import java.util.List;
  13 import java.util.Map;
  14
  15 import org.testng.annotations.BeforeClass;
  16 import org.testng.annotations.Test;
  17
  18 public class ConservationTest
  19 {
  20
  21   @BeforeClass(alwaysRun = true)
  22   public void setUpJvOptionPane()
  23   {
  24     JvOptionPane.setInteractiveMode(false);
  25     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  26   }
  27
  28   @Test(groups = "Functional")
  29   public void testRecordConservation()
  30   {
  31     Map<String, Integer> resultMap = new HashMap<String, Integer>();
  32
  33     // V is hydrophobic, aliphatic, small
  34     Conservation.recordConservation(resultMap, "V");
  35     assertEquals(resultMap.get("hydrophobic").intValue(), 1);
  36     assertEquals(resultMap.get("aliphatic").intValue(), 1);
  37     assertEquals(resultMap.get("small").intValue(), 1);
  38     assertEquals(resultMap.get("tiny").intValue(), 0);
  39     assertEquals(resultMap.get("polar").intValue(), 0);
  40     assertEquals(resultMap.get("charged").intValue(), 0);
  41
  42     // now add S: not hydrophobic, small, tiny, polar, not aliphatic
  43     Conservation.recordConservation(resultMap, "s");
  44     assertEquals(resultMap.get("hydrophobic").intValue(), -1);
  45     assertEquals(resultMap.get("aliphatic").intValue(), -1);
  46     assertEquals(resultMap.get("small").intValue(), 1);
  47     assertEquals(resultMap.get("tiny").intValue(), -1);
  48     assertEquals(resultMap.get("polar").intValue(), -1);
  49     assertEquals(resultMap.get("charged").intValue(), 0);
  50   }
  51
  52   @Test(groups = "Functional")
  53   public void testCountConservationAndGaps()
  54   {
  55     List<SequenceI> seqs = new ArrayList<SequenceI>();
  56     seqs.add(new Sequence("seq1", "VGnY")); // not case sensitive
  57     seqs.add(new Sequence("seq2", "-G-y"));
  58     seqs.add(new Sequence("seq3", "VG-Y"));
  59     seqs.add(new Sequence("seq4", "VGNW"));
  60
  61     Conservation cons = new Conservation("", seqs, 0, 50);
  62     int[] counts = cons.countConservationAndGaps(0);
  63     assertEquals(counts[0], 1); // conserved
  64     assertEquals(counts[1], 1); // gap count
  65     counts = cons.countConservationAndGaps(1);
  66     assertEquals(counts[0], 1);
  67     assertEquals(counts[1], 0);
  68     counts = cons.countConservationAndGaps(2);
  69     assertEquals(counts[0], 1);
  70     assertEquals(counts[1], 2);
  71     counts = cons.countConservationAndGaps(3);
  72     assertEquals(counts[0], 0); // not conserved
  73     assertEquals(counts[1], 0);
  74   }
  75
  76   @Test(groups = "Functional")
  77   public void testCalculate_noThreshold()
  78   {
  79     List<SequenceI> seqs = new ArrayList<SequenceI>();
  80     seqs.add(new Sequence("seq1", "VGIV-N"));
  81     seqs.add(new Sequence("seq2", "V-iL-N")); // not case sensitive
  82     seqs.add(new Sequence("seq3", "V-IW-N"));
  83     seqs.add(new Sequence("seq4", "VGLH-L"));
  84
  85     Conservation cons = new Conservation("", 0, seqs, 0, 5);
  86     cons.calculate();
  87
  88     /*
  89      * column 0: all V (hydrophobic/aliphatic/small)
  90      */
  91     Map<String, Integer> colCons = cons.total[0];
  92     assertEquals(colCons.get("hydrophobic").intValue(), 1);
  93     assertEquals(colCons.get("aliphatic").intValue(), 1);
  94     assertEquals(colCons.get("small").intValue(), 1);
  95     assertEquals(colCons.get("tiny").intValue(), 0);
  96     assertEquals(colCons.get("proline").intValue(), 0);
  97     assertEquals(colCons.get("charged").intValue(), 0);
  98     assertEquals(colCons.get("negative").intValue(), 0);
  99     assertEquals(colCons.get("polar").intValue(), 0);
 100     assertEquals(colCons.get("positive").intValue(), 0);
 101     assertEquals(colCons.get("aromatic").intValue(), 0);
 102
 103     /*
 104      * column 1: all G (hydrophobic/small/tiny)
 105      * gaps take default value of property present
 106      */
 107     colCons = cons.total[1];
 108     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 109     assertEquals(colCons.get("aliphatic").intValue(), -1);
 110     assertEquals(colCons.get("small").intValue(), 1);
 111     assertEquals(colCons.get("tiny").intValue(), 1);
 112     assertEquals(colCons.get("proline").intValue(), -1);
 113     assertEquals(colCons.get("charged").intValue(), -1);
 114     assertEquals(colCons.get("negative").intValue(), -1);
 115     assertEquals(colCons.get("polar").intValue(), -1);
 116     assertEquals(colCons.get("positive").intValue(), -1);
 117     assertEquals(colCons.get("aromatic").intValue(), -1);
 118
 119     /*
 120      * column 2: I/L (aliphatic/hydrophobic), all others negatively conserved
 121      */
 122     colCons = cons.total[2];
 123     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 124     assertEquals(colCons.get("aliphatic").intValue(), 1);
 125     assertEquals(colCons.get("small").intValue(), 0);
 126     assertEquals(colCons.get("tiny").intValue(), 0);
 127     assertEquals(colCons.get("proline").intValue(), 0);
 128     assertEquals(colCons.get("charged").intValue(), 0);
 129     assertEquals(colCons.get("negative").intValue(), 0);
 130     assertEquals(colCons.get("polar").intValue(), 0);
 131     assertEquals(colCons.get("positive").intValue(), 0);
 132     assertEquals(colCons.get("aromatic").intValue(), 0);
 133
 134     /*
 135      * column 3: VLWH all hydrophobic, none is tiny, negative or proline
 136      */
 137     colCons = cons.total[3];
 138     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 139     assertEquals(colCons.get("aliphatic").intValue(), -1);
 140     assertEquals(colCons.get("small").intValue(), -1);
 141     assertEquals(colCons.get("tiny").intValue(), 0);
 142     assertEquals(colCons.get("proline").intValue(), 0);
 143     assertEquals(colCons.get("charged").intValue(), -1);
 144     assertEquals(colCons.get("negative").intValue(), 0);
 145     assertEquals(colCons.get("polar").intValue(), -1);
 146     assertEquals(colCons.get("positive").intValue(), -1);
 147     assertEquals(colCons.get("aromatic").intValue(), -1);
 148
 149     /*
 150      * column 4: all gaps - counted as having all properties
 151      */
 152     colCons = cons.total[4];
 153     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 154     assertEquals(colCons.get("aliphatic").intValue(), 1);
 155     assertEquals(colCons.get("small").intValue(), 1);
 156     assertEquals(colCons.get("tiny").intValue(), 1);
 157     assertEquals(colCons.get("proline").intValue(), 1);
 158     assertEquals(colCons.get("charged").intValue(), 1);
 159     assertEquals(colCons.get("negative").intValue(), 1);
 160     assertEquals(colCons.get("polar").intValue(), 1);
 161     assertEquals(colCons.get("positive").intValue(), 1);
 162     assertEquals(colCons.get("aromatic").intValue(), 1);
 163
 164     /*
 165      * column 5: N (small polar) and L (aliphatic hydrophobic)
 166      * have nothing in common!
 167      */
 168     colCons = cons.total[5];
 169     assertEquals(colCons.get("hydrophobic").intValue(), -1);
 170     assertEquals(colCons.get("aliphatic").intValue(), -1);
 171     assertEquals(colCons.get("small").intValue(), -1);
 172     assertEquals(colCons.get("tiny").intValue(), 0);
 173     assertEquals(colCons.get("proline").intValue(), 0);
 174     assertEquals(colCons.get("charged").intValue(), 0);
 175     assertEquals(colCons.get("negative").intValue(), 0);
 176     assertEquals(colCons.get("polar").intValue(), -1);
 177     assertEquals(colCons.get("positive").intValue(), 0);
 178     assertEquals(colCons.get("aromatic").intValue(), 0);
 179   }
 180
 181   /**
 182    * Test for the case whether the number of non-gapped sequences in a column
 183    * has to be above a threshold
 184    */
 185   @Test(groups = "Functional")
 186   public void testCalculate_threshold()
 187   {
 188     List<SequenceI> seqs = new ArrayList<SequenceI>();
 189     seqs.add(new Sequence("seq1", "VGIV-"));
 190     seqs.add(new Sequence("seq2", "V-iL-")); // not case sensitive
 191     seqs.add(new Sequence("seq3", "V-IW-"));
 192     seqs.add(new Sequence("seq4", "VGLH-"));
 193     seqs.add(new Sequence("seq5", "VGLH-"));
 194
 195     /*
 196      * threshold 50% means a residue has to occur 3 or more times
 197      * in a column to be counted for conservation
 198      */
 199     // TODO: ConservationThread uses a value of 3
 200     // calculateConservation states it is the minimum number of sequences
 201     // but it is treated as percentage threshold in calculate() ?
 202     Conservation cons = new Conservation("", 50, seqs, 0, 4);
 203     cons.calculate();
 204
 205     /*
 206      * column 0: all V (hydrophobic/aliphatic/small)
 207      */
 208     Map<String, Integer> colCons = cons.total[0];
 209     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 210     assertEquals(colCons.get("aliphatic").intValue(), 1);
 211     assertEquals(colCons.get("small").intValue(), 1);
 212     assertEquals(colCons.get("tiny").intValue(), 0);
 213     assertEquals(colCons.get("proline").intValue(), 0);
 214     assertEquals(colCons.get("charged").intValue(), 0);
 215     assertEquals(colCons.get("negative").intValue(), 0);
 216     assertEquals(colCons.get("polar").intValue(), 0);
 217     assertEquals(colCons.get("positive").intValue(), 0);
 218     assertEquals(colCons.get("aromatic").intValue(), 0);
 219
 220     /*
 221      * column 1: all G (hydrophobic/small/tiny)
 222      * gaps are ignored as not above threshold
 223      */
 224     colCons = cons.total[1];
 225     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 226     assertEquals(colCons.get("aliphatic").intValue(), 0);
 227     assertEquals(colCons.get("small").intValue(), 1);
 228     assertEquals(colCons.get("tiny").intValue(), 1);
 229     assertEquals(colCons.get("proline").intValue(), 0);
 230     assertEquals(colCons.get("charged").intValue(), 0);
 231     assertEquals(colCons.get("negative").intValue(), 0);
 232     assertEquals(colCons.get("polar").intValue(), 0);
 233     assertEquals(colCons.get("positive").intValue(), 0);
 234     assertEquals(colCons.get("aromatic").intValue(), 0);
 235
 236     /*
 237      * column 2: I/L (aliphatic/hydrophobic), all others negatively conserved
 238      */
 239     colCons = cons.total[2];
 240     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 241     assertEquals(colCons.get("aliphatic").intValue(), 1);
 242     assertEquals(colCons.get("small").intValue(), 0);
 243     assertEquals(colCons.get("tiny").intValue(), 0);
 244     assertEquals(colCons.get("proline").intValue(), 0);
 245     assertEquals(colCons.get("charged").intValue(), 0);
 246     assertEquals(colCons.get("negative").intValue(), 0);
 247     assertEquals(colCons.get("polar").intValue(), 0);
 248     assertEquals(colCons.get("positive").intValue(), 0);
 249     assertEquals(colCons.get("aromatic").intValue(), 0);
 250
 251     /*
 252      * column 3: nothing above threshold
 253      */
 254     colCons = cons.total[3];
 255     assertTrue(colCons.isEmpty());
 256
 257     /*
 258      * column 4: all gaps - counted as having all properties
 259      */
 260     colCons = cons.total[4];
 261     assertEquals(colCons.get("hydrophobic").intValue(), 1);
 262     assertEquals(colCons.get("aliphatic").intValue(), 1);
 263     assertEquals(colCons.get("small").intValue(), 1);
 264     assertEquals(colCons.get("tiny").intValue(), 1);
 265     assertEquals(colCons.get("proline").intValue(), 1);
 266     assertEquals(colCons.get("charged").intValue(), 1);
 267     assertEquals(colCons.get("negative").intValue(), 1);
 268     assertEquals(colCons.get("polar").intValue(), 1);
 269     assertEquals(colCons.get("positive").intValue(), 1);
 270     assertEquals(colCons.get("aromatic").intValue(), 1);
 271   }
 272
 273   /**
 274    * Test the method that derives the conservation 'sequence' and the mouseover
 275    * tooltips from the computed conservation
 276    */
 277   @Test(groups = "Functional")
 278   public void testVerdict()
 279   {
 280     List<SequenceI> seqs = new ArrayList<SequenceI>();
 281     seqs.add(new Sequence("seq1", "VGIVV-H"));
 282     seqs.add(new Sequence("seq2", "VGILL-H"));
 283     seqs.add(new Sequence("seq3", "VGIW--R"));
 284     seqs.add(new Sequence("seq4", "VGLHH--"));
 285     seqs.add(new Sequence("seq5", "VGLHH-R"));
 286     seqs.add(new Sequence("seq6", "VGLHH--"));
 287     seqs.add(new Sequence("seq7", "VGLHH-R"));
 288     seqs.add(new Sequence("seq8", "VGLHH-R"));
 289
 290     // calculate with no threshold
 291     Conservation cons = new Conservation("", 0, seqs, 0, 6);
 292     cons.calculate();
 293     // positive and negative conservation where <25% gaps in columns
 294     cons.verdict(false, 25);
 295
 296     /*
 297      * verify conservation 'sequence'
 298      * cols 0 fully conserved and above threshold (*)
 299      * col 2 properties fully conserved (+)
 300      * col 3 VLWH 1 positively and 3 negatively conserved properties
 301      * col 4 has 1 positively conserved property, but because gap contributes a
 302      * 'positive' for all properties, no negative conservation is counted
 303      * col 5 is all gaps
 304      * col 6 has 25% gaps so fails threshold test
 305      */
 306     assertEquals(cons.getConsSequence().getSequenceAsString(), "**+41--");
 307
 308     /*
 309      * verify tooltips; conserved properties are sorted alphabetically within
 310      * positive followed by negative
 311      */
 312     assertEquals(
 313             cons.getTooltip(0),
 314             "aliphatic hydrophobic small !aromatic !charged !negative !polar !positive !proline !tiny");
 315     assertEquals(
 316             cons.getTooltip(1),
 317             "hydrophobic small tiny !aliphatic !aromatic !charged !negative !polar !positive !proline");
 318     assertEquals(
 319             cons.getTooltip(2),
 320             "aliphatic hydrophobic !aromatic !charged !negative !polar !positive !proline !small !tiny");
 321     assertEquals(cons.getTooltip(3), "hydrophobic !negative !proline !tiny");
 322     assertEquals(cons.getTooltip(4), "hydrophobic");
 323     assertEquals(cons.getTooltip(5), "");
 324     assertEquals(cons.getTooltip(6), "");
 325   }
 326 }