--- /dev/null
+package jalview.io;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNull;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import org.testng.annotations.Test;
+
+public class HMMFileTest {
+
+ HMMFile testFile = new HMMFile("H:/HMMERFile.txt");
+
+ File file = new File("H:/HMMERFile.txt");
+
+ HMMFile testFile2 = new HMMFile("H:/EmptyFile.txt");
+
+ File file2 = new File("H:/EmptyFile.txt");
+
+ HMMFile testFile3 = new HMMFile("H:/HMMERFile2.txt");
+
+ File file3 = new File("H:/HMMERFile2.txt");
+
+ HMMFile testFile4 = new HMMFile("H:/HMMERFile.txt");
+
+ File file4 = new File("H:/HMMERFile.txt");
+
+ @Test
+ public void testParse() throws IOException
+ {
+ HMMFile integrationTestFile = new HMMFile("H:/HMMTutorialExample.hmm");
+ integrationTestFile.parse();
+
+ // file properties
+ assertEquals(integrationTestFile.hmm.getName(), "MADE1");
+ assertEquals(integrationTestFile.hmm.getAccessionNumber(),
+ "DF0000629.2");
+ assertEquals(integrationTestFile.hmm.getDescription(),
+ "MADE1 (MAriner Derived Element 1), a TcMar-Mariner DNA transposon");
+ assertEquals(integrationTestFile.hmm.getLength().intValue(), 80);
+ assertEquals(integrationTestFile.hmm.getMaxInstanceLength().intValue(),
+ 426);
+ assertEquals(integrationTestFile.hmm.getAlphabetType(), "DNA");
+ assertEquals(integrationTestFile.hmm.getReferenceAnnotationFlag(),
+ true);
+ assertEquals(integrationTestFile.hmm.getModelMaskedFlag(), false);
+ assertEquals(
+ integrationTestFile.hmm.getConsensusResidueAnnotationFlag(),
+ true);
+ assertEquals(
+ integrationTestFile.hmm.getConsensusStructureAnnotationFlag(),
+ false);
+ assertEquals(integrationTestFile.hmm.getMapAnnotationFlag(), true);
+ assertEquals(integrationTestFile.hmm.getDate(),
+ "Tue Feb 19 20:33:41 2013");
+ assertNull(integrationTestFile.hmm.getCommandLineLog());
+ assertEquals(integrationTestFile.hmm.getSequenceNumber().intValue(),
+ 1997);
+ assertEquals(integrationTestFile.hmm.getEffectiveSequenceNumber(),
+ 3.911818, 4d);
+ assertEquals(integrationTestFile.hmm.getCheckSum().longValue(),
+ 3015610723l);
+ assertNull(integrationTestFile.hmm.getGatheringThreshold1());
+ assertNull(integrationTestFile.hmm.getGatheringThreshold2());
+ assertNull(integrationTestFile.hmm.getTrustedCutoff1());
+ assertNull(integrationTestFile.hmm.getTrustedCutoff2());
+ assertNull(integrationTestFile.hmm.getNoiseCutoff1());
+ assertNull(integrationTestFile.hmm.getNoiseCutoff2());
+ assertEquals(integrationTestFile.hmm.getSlopeOfDistribution("MSV"),
+ -8.5786, 4d);
+ assertEquals(integrationTestFile.hmm.getSlopeOfDistribution("VITERBI"),
+ -9.3632, 4d);
+ assertEquals(integrationTestFile.hmm.getSlopeOfDistribution("FORWARD"),
+ -3.4823, 4d);
+ assertEquals(integrationTestFile.hmm.getLocationOfDistribution("MSV"),
+ 0.71858, 4d);
+ assertEquals(
+ integrationTestFile.hmm.getLocationOfDistribution("VITERBI"),
+ 0.71858, 4d);
+ assertEquals(
+ integrationTestFile.hmm.getLocationOfDistribution("FORWARD"),
+ 0.71858, 4d);
+
+ List<Character> symbols = new ArrayList<>();
+ symbols.add('A');
+ symbols.add('C');
+ symbols.add('G');
+ symbols.add('T');
+
+ assertEquals(integrationTestFile.hmm.getSymbols(), symbols);
+
+ List<Double> averages = new ArrayList<>();
+ averages.add(1.24257);
+ averages.add(1.59430);
+ averages.add(1.62906);
+ averages.add(1.16413);
+
+ assertEquals(integrationTestFile.hmm
+ .getAverageMatchStateEmissionProbabilities(), averages);
+
+ assertEquals(integrationTestFile.hmm.getInsertZeroEmissions().get(2),
+ 1.38629);
+ assertEquals(integrationTestFile.hmm.getInsertZeroEmissions().get(3),
+ 1.38629);
+
+ assertEquals(integrationTestFile.hmm.getBeginStateTransitions().get(1),
+ 3.94183);
+ assertEquals(integrationTestFile.hmm.getBeginStateTransitions().get(4),
+ 0.26236);
+
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(1).get(1),
+ 2.37873);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(8).get(0),
+ 2.16916);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(12).get(2),
+ 2.32214);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(43).get(3),
+ 2.60783);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(54).get(2),
+ 2.46442);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(23).get(2),
+ 2.50691);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(56).get(1),
+ 2.32720);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(65).get(0),
+ 2.79349);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(21).get(0),
+ 2.54484);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(79).get(3),
+ 2.88183);
+ assertEquals(integrationTestFile.hmm.getMatchEmissions().get(76).get(3),
+ 1.84373);
+
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(23).get(0),
+ 1.35803);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(54).get(3),
+ 1.46331);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(65).get(3),
+ 1.39101);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(57).get(2),
+ 1.38112);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(42).get(1),
+ 1.58747);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(12).get(3),
+ 1.38740);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(6).get(1),
+ 1.38524);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(59).get(0),
+ 1.03649);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(78).get(0),
+ 1.38629);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(17).get(2),
+ 1.39937);
+ assertEquals(integrationTestFile.hmm.getInsertEmissions().get(0).get(2),
+ 1.38629);
+
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(13).get(1),
+ 4.02482);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(64).get(2),
+ 4.03073);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(45).get(6),
+ 0.42814);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(71).get(4),
+ 0.28542);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(32).get(5),
+ 1.18729);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(9).get(0),
+ 0.03536);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(0).get(3),
+ 1.46634);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(31).get(6),
+ 0.44749);
+ assertNull(
+ integrationTestFile.hmm.getStateTransitions().get(79).get(2));
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(3).get(1),
+ 4.05203);
+ assertEquals(
+ integrationTestFile.hmm.getStateTransitions().get(16).get(4),
+ 0.26771);
+
+ assertEquals(integrationTestFile.hmm.getAlignmentColumnIndexes().get(0)
+ .intValue(), 1);
+ assertEquals(integrationTestFile.hmm.getAlignmentColumnIndexes().get(9)
+ .intValue(), 18);
+ assertEquals(integrationTestFile.hmm.getAlignmentColumnIndexes().get(12)
+ .intValue(), 28);
+ assertEquals(integrationTestFile.hmm.getAlignmentColumnIndexes().get(56)
+ .intValue(), 999);
+ assertEquals(integrationTestFile.hmm.getAlignmentColumnIndexes().get(79)
+ .intValue(), 1112);
+
+ assertEquals(integrationTestFile.hmm.getAnnotations().get(0).get("RF")
+ .charValue(), 'x');
+ assertEquals(integrationTestFile.hmm.getAnnotations().get(3).get("CS")
+ .charValue(), '-');
+ assertEquals(integrationTestFile.hmm.getAnnotations().get(65)
+ .get("CONS").charValue(), 't');
+ assertEquals(integrationTestFile.hmm.getAnnotations().get(23).get("MM")
+ .charValue(), '-');
+ assertEquals(integrationTestFile.hmm.getAnnotations().get(56).get("MM")
+ .charValue(), '-');
+ assertEquals(integrationTestFile.hmm.getAnnotations().get(76).get("RF")
+ .charValue(), 'x');
+ assertEquals(integrationTestFile.hmm.getAnnotations().get(79)
+ .get("CONS").charValue(), 'a');
+
+ }
+
+ @Test
+ public void testParseFileProperties() throws IOException
+ {
+ FileReader fr = new FileReader(file);
+ BufferedReader br = new BufferedReader(fr);
+ testFile.parseFileProperties(br);
+ br.close();
+ fr.close();
+ assertEquals(testFile.hmm.getName(), "fn3");
+ assertEquals(testFile.hmm.getAccessionNumber(), "PF00041.13");
+ assertEquals(testFile.hmm.getDescription(),
+ "Fibronectin type III domain");
+ assertEquals(testFile.hmm.getLength().intValue(), 4);
+ assertNull(testFile.hmm.getMaxInstanceLength());
+ assertEquals(testFile.hmm.getAlphabetType(), "amino");
+ assertEquals(testFile.hmm.getReferenceAnnotationFlag(), false);
+ assertEquals(testFile.hmm.getModelMaskedFlag(), false);
+ assertEquals(testFile.hmm.getConsensusResidueAnnotationFlag(), true);
+ assertEquals(testFile.hmm.getConsensusStructureAnnotationFlag(), true);
+ assertEquals(testFile.hmm.getMapAnnotationFlag(), true);
+ assertEquals(testFile.hmm.getDate(), "Fri Feb 15 06:04:13 2013");
+ assertNull(testFile.hmm.getCommandLineLog());
+ assertEquals(testFile.hmm.getSequenceNumber().intValue(), 106);
+ assertEquals(testFile.hmm.getEffectiveSequenceNumber(), 11.415833, 4d);
+ assertEquals(testFile.hmm.getCheckSum().longValue(), 3564431818l);
+ assertEquals(testFile.hmm.getGatheringThreshold1(), 8.00, 2d);
+ assertEquals(testFile.hmm.getGatheringThreshold2(), 7.20, 2d);
+ assertEquals(testFile.hmm.getTrustedCutoff1(), 8.00, 2d);
+ assertEquals(testFile.hmm.getTrustedCutoff2(), 7.20, 2d);
+ assertEquals(testFile.hmm.getNoiseCutoff1(), 7.90, 2d);
+ assertEquals(testFile.hmm.getNoiseCutoff2(), 7.90, 2d);
+ assertEquals(testFile.hmm.getSlopeOfDistribution("MSV"), -9.4043, 4d);
+ assertEquals(testFile.hmm.getSlopeOfDistribution("VITERBI"), -9.7737,
+ 4d);
+ assertEquals(testFile.hmm.getSlopeOfDistribution("FORWARD"), -3.8341,
+ 4d);
+ assertEquals(testFile.hmm.getLocationOfDistribution("MSV"), 0.71847,
+ 4d);
+ assertEquals(testFile.hmm.getLocationOfDistribution("VITERBI"), 0.71847,
+ 4d);
+ assertEquals(testFile.hmm.getLocationOfDistribution("FORWARD"), 0.71847,
+ 4d);
+
+ FileReader fr2 = new FileReader(file2);
+ BufferedReader br2 = new BufferedReader(fr2);
+ testFile2.parseFileProperties(br2);
+ br2.close();
+ fr2.close();
+
+ assertNull(testFile2.hmm.getName());
+ assertNull(testFile2.hmm.getAccessionNumber());
+ assertNull(testFile2.hmm.getDescription());
+ assertNull(testFile2.hmm.getLength());
+ assertNull(testFile2.hmm.getMaxInstanceLength());
+ assertNull(testFile2.hmm.getAlphabetType());
+ assertEquals(testFile2.hmm.getReferenceAnnotationFlag(), false);
+ assertEquals(testFile2.hmm.getModelMaskedFlag(), false);
+ assertEquals(testFile2.hmm.getConsensusResidueAnnotationFlag(), false);
+ assertEquals(testFile2.hmm.getConsensusStructureAnnotationFlag(),
+ false);
+ assertEquals(testFile2.hmm.getMapAnnotationFlag(), false);
+ assertNull(testFile2.hmm.getDate());
+ assertNull(testFile2.hmm.getCommandLineLog());
+ assertNull(testFile2.hmm.getSequenceNumber());
+ assertNull(testFile2.hmm.getEffectiveSequenceNumber());
+ assertNull(testFile2.hmm.getCheckSum());
+ assertNull(testFile2.hmm.getGatheringThreshold1());
+ assertNull(testFile2.hmm.getGatheringThreshold2());
+ assertNull(testFile2.hmm.getTrustedCutoff1());
+ assertNull(testFile2.hmm.getTrustedCutoff2());
+ assertNull(testFile2.hmm.getNoiseCutoff1());
+ assertNull(testFile2.hmm.getNoiseCutoff2());
+ assertNull(testFile2.hmm.getSlopeOfDistribution("MSV"));
+ assertNull(testFile2.hmm.getSlopeOfDistribution("VITERBI"));
+ assertNull(testFile2.hmm.getSlopeOfDistribution("FORWARD"));
+ assertNull(testFile2.hmm.getLocationOfDistribution("MSV"));
+ assertNull(testFile2.hmm.getLocationOfDistribution("VITERBI"));
+ assertNull(testFile2.hmm.getLocationOfDistribution("FORWARD"));
+
+ FileReader fr3 = new FileReader(file3);
+ BufferedReader br3 = new BufferedReader(fr3);
+ testFile3.parseFileProperties(br3);
+ br3.close();
+ fr3.close();
+
+ assertEquals(testFile3.hmm.getName(), "th4");
+ assertEquals(testFile3.hmm.getAccessionNumber(), "PF99041.16");
+ assertEquals(testFile3.hmm.getDescription(),
+ "Fibronectin type I domain");
+ assertEquals(testFile3.hmm.getLength().intValue(), 10);
+ assertEquals(testFile3.hmm.getMaxInstanceLength().intValue(), 6);
+ assertEquals(testFile3.hmm.getAlphabetType(), "amino");
+ assertEquals(testFile3.hmm.getReferenceAnnotationFlag(), true);
+ assertEquals(testFile3.hmm.getModelMaskedFlag(), false);
+ assertEquals(testFile3.hmm.getConsensusResidueAnnotationFlag(), false);
+ assertEquals(testFile3.hmm.getConsensusStructureAnnotationFlag(),
+ false);
+ assertEquals(testFile3.hmm.getMapAnnotationFlag(), false);
+ assertEquals(testFile3.hmm.getDate(), "Tue Jan 01 11:02:59 2000");
+ assertEquals(testFile3.hmm.getCommandLineLog(), "this is the log");
+ assertEquals(testFile3.hmm.getSequenceNumber().intValue(), 567);
+ assertEquals(testFile3.hmm.getEffectiveSequenceNumber(), 15.964683, 4d);
+ assertEquals(testFile3.hmm.getCheckSum().longValue(), 9485949654l);
+ assertEquals(testFile3.hmm.getGatheringThreshold1(), 6.40, 2d);
+ assertEquals(testFile3.hmm.getGatheringThreshold2(), 7.20, 2d);
+ assertEquals(testFile3.hmm.getTrustedCutoff1(), 2.40, 2d);
+ assertEquals(testFile3.hmm.getTrustedCutoff2(), 7.00, 2d);
+ assertNull(testFile3.hmm.getNoiseCutoff1());
+ assertNull(testFile3.hmm.getNoiseCutoff2());
+ assertNull(testFile3.hmm.getSlopeOfDistribution("MSV"));
+ assertNull(testFile3.hmm.getSlopeOfDistribution("VITERBI"));
+ assertNull(testFile3.hmm.getSlopeOfDistribution("FORWARD"));
+ assertNull(testFile3.hmm.getLocationOfDistribution("MSV"));
+ assertNull(testFile3.hmm.getLocationOfDistribution("VITERBI"));
+ assertNull(testFile3.hmm.getLocationOfDistribution("FORWARD"));
+ }
+
+ /**
+ * @Test public void testParseModel() throws IOException { HiddenMarkovModel
+ * hmm = new HiddenMarkovModel(); HMMFile testFile = new HMMFile(hmm,
+ * "H:/HMMERFile.txt"); File file = new File("H:/HMMERFile.txt");
+ * FileReader fr = new FileReader(file); BufferedReader br = new
+ * BufferedReader(fr); testFile.parseFileProperties(br);
+ * testFile.parseModel(br); br.close(); fr.close();
+ *
+ * }
+ **/
+
+ @Test
+ public void testGetTransitionType()
+ {
+
+ assertEquals(testFile.getTransitionType("mm").intValue(), 0);
+ assertEquals(testFile.getTransitionType("mi").intValue(), 1);
+ assertEquals(testFile.getTransitionType("md").intValue(), 2);
+ assertEquals(testFile.getTransitionType("im").intValue(), 3);
+ assertEquals(testFile.getTransitionType("ii").intValue(), 4);
+ assertEquals(testFile.getTransitionType("dm").intValue(), 5);
+ assertEquals(testFile.getTransitionType("dd").intValue(), 6);
+ assertNull(testFile.getTransitionType("df"));
+
+ }
+
+ @Test
+ public void testReadStats()
+ {
+ Scanner scanner = new Scanner("LOCAL MSV 5.6943 6.2313");
+ testFile.readStats(scanner);
+ assertEquals(testFile.hmm.getEValueStatistics().get("MSV")
+ .getAlignmentModeConfiguration(), "LOCAL");
+ assertEquals(
+ testFile.hmm.getEValueStatistics().get("MSV")
+ .getSlopeOfDistribution(),
+ 5.6943, 4d);
+ assertEquals(testFile.hmm.getEValueStatistics().get("MSV")
+ .getLocationOfDistribution(), 6.2313, 4d);
+ scanner.close();
+
+ Scanner scanner2 = new Scanner("GLOBAL VITERBI 3 -0.234");
+ testFile.readStats(scanner2);
+ assertEquals(testFile.hmm.getEValueStatistics().get("VITERBI")
+ .getAlignmentModeConfiguration(), "GLOBAL");
+ assertEquals(testFile.hmm.getEValueStatistics().get("VITERBI")
+ .getSlopeOfDistribution(), 3, 2d);
+ assertEquals(testFile.hmm.getEValueStatistics().get("VITERBI")
+ .getLocationOfDistribution(), -0.234, 4d);
+ scanner.close();
+
+ }
+
+ @Test
+ public void testParseBeginNodeData() throws IOException
+ {
+ FileReader fr = new FileReader(file4);
+ BufferedReader br = new BufferedReader(fr);
+ for (int i = 0; i < 24; i++)
+ {
+ br.readLine(); // this is done to reach the begin node
+ // data in the file
+ }
+
+ testFile4.hmm.fillSymbols("HMM A B C D E F G H I");
+ testFile4.parseBeginNodeData(br);
+ ArrayList<Double> emissions = new ArrayList<>();
+ ArrayList<Double> transitions = new ArrayList<>();
+
+ emissions.add(2.68618);
+ emissions.add(4.42225);
+ emissions.add(2.77519);
+ emissions.add(2.73123);
+ emissions.add(3.46354);
+ emissions.add(2.40513);
+ emissions.add(3.72494);
+ emissions.add(3.29354);
+ emissions.add(3.61503);
+
+ transitions.add(0.00338);
+ transitions.add(6.08833);
+ transitions.add(6.81068);
+ transitions.add(0.61958);
+ transitions.add(0.77255);
+ transitions.add(0.00000);
+ transitions.add(null);
+
+ assertEquals(testFile4.hmm.getInsertZeroEmissions(), emissions);
+ assertEquals(testFile4.hmm.getBeginStateTransitions(), transitions);
+
+ }
+
+ @Test
+ public void testFillList()
+ {
+ Scanner scanner1 = new Scanner("1.3 2.4 5.3 3.9 9.8 4.7 4.3 2.3 6.9");
+ ArrayList<Double> filledArray = new ArrayList<>();
+
+ filledArray.add(1.3);
+ filledArray.add(2.4);
+ filledArray.add(5.3);
+ filledArray.add(3.9);
+ filledArray.add(9.8);
+ filledArray.add(4.7);
+ filledArray.add(4.3);
+ filledArray.add(2.3);
+ filledArray.add(6.9);
+
+ assertEquals(HMMFile.fillList(scanner1, 9), filledArray);
+ filledArray.clear();
+ scanner1.close();
+
+ Scanner scanner2 = new Scanner(
+ "1.346554 5.58756754 35.3523645 12345.3564 1.4");
+ filledArray.add(1.346554);
+ filledArray.add(5.58756754);
+ filledArray.add(35.3523645);
+ filledArray.add(12345.3564);
+ filledArray.add(1.4);
+ assertEquals(HMMFile.fillList(scanner2, 5), filledArray);
+ scanner2.close();
+
+ }
+
+ @Test
+ public void testParseModel() throws IOException
+ {
+ FileReader fr = new FileReader(file);
+ BufferedReader br = new BufferedReader(fr);
+ for (int i = 0; i < 23; i++)
+ {
+ br.readLine(); // this is done to reach the begin node
+ // data in the file
+ }
+
+ testFile.parseModel(br);
+ assertEquals(testFile.hmm.getMatchEmissions().get(0).get(0), 3.16986);
+ assertEquals(testFile.hmm.getMatchEmissions().get(0).get(3), 3.29953);
+ assertEquals(testFile.hmm.getMatchEmissions().get(1).get(2), 2.24744);
+ assertEquals(testFile.hmm.getMatchEmissions().get(1).get(8), 4.25623);
+ assertEquals(testFile.hmm.getMatchEmissions().get(2).get(5), 3.48010);
+ assertEquals(testFile.hmm.getMatchEmissions().get(2).get(6), 4.51877);
+ assertEquals(testFile.hmm.getMatchEmissions().get(3).get(4), 5.26587);
+ assertEquals(testFile.hmm.getMatchEmissions().get(3).get(8), 4.99111);
+ assertEquals(testFile.hmm.getInsertEmissions().get(0).get(3), 2.73088);
+ assertEquals(testFile.hmm.getInsertEmissions().get(0).get(6), 3.72505);
+ assertEquals(testFile.hmm.getInsertEmissions().get(1).get(2), 2.77519);
+ assertEquals(testFile.hmm.getInsertEmissions().get(1).get(8), 3.61503);
+ assertEquals(testFile.hmm.getInsertEmissions().get(2).get(0), 2.68618);
+ assertEquals(testFile.hmm.getInsertEmissions().get(2).get(8), 3.61503);
+ assertEquals(testFile.hmm.getInsertEmissions().get(3).get(2), 2.77519);
+ assertEquals(testFile.hmm.getInsertEmissions().get(3).get(3), 2.73123);
+ }
+
+ @Test
+ public void testParseAnnotations()
+ {
+ testFile4.hmm.setMapAnnotationFlag(true);
+ Scanner scanner = new Scanner("1 t - - -");
+ testFile4.parseAnnotations(scanner, 0);
+
+ assertEquals(
+ testFile4.hmm.getAlignmentColumnIndexes().get(0).intValue(), 1);
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("CONS").charValue(),
+ 't');
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("RF").charValue(),
+ '-');
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("MM").charValue(),
+ '-');
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("CS").charValue(),
+ '-');
+
+ testFile4.hmm.setMapAnnotationFlag(false);
+ testFile4.hmm.getAlignmentColumnIndexes().clear();
+ testFile4.hmm.getAnnotations().clear();
+ Scanner scanner2 = new Scanner("- S g C Y");
+ testFile4.parseAnnotations(scanner2, 0);
+
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("CONS").charValue(),
+ 'S');
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("RF").charValue(),
+ 'g');
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("MM").charValue(),
+ 'C');
+ assertEquals(
+ testFile4.hmm.getAnnotations().get(0).get("CS").charValue(),
+ 'Y');
+ }
+
+ @Test
+ public void testExportFile() throws IOException
+ {
+ HMMFile exportTestFile = new HMMFile("H:/HMMTutorialExample.hmm");
+ exportTestFile.parse();
+ exportTestFile.exportFile("H:/WriteTestFile.hmm");
+
+ }
+}
git://source.jalview.org / jalview.git / commitdiff