diff --git a/build.xml b/build.xml
index 80627fae0..068c69316 100644
--- a/build.xml
+++ b/build.xml
@@ -981,6 +981,7 @@
+
diff --git a/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffEngineUnitTest.java b/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffEngineUnitTest.java
new file mode 100644
index 000000000..cd6c3598a
--- /dev/null
+++ b/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffEngineUnitTest.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2011, The Broad Institute
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// our package
+package org.broadinstitute.sting.gatk.walkers.diffengine;
+
+
+// the imports for unit testing.
+
+import org.broadinstitute.sting.BaseTest;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.*;
+
+/**
+ * Basic unit test for DifferableReaders in reduced reads
+ */
+public class DiffEngineUnitTest extends BaseTest {
+ DiffEngine engine;
+
+ @BeforeClass(enabled = true)
+ public void createDiffEngine() {
+ engine = new DiffEngine();
+ }
+
+ // --------------------------------------------------------------------------------
+ //
+ // Difference testing routines
+ //
+ // --------------------------------------------------------------------------------
+
+ private class DifferenceTest extends TestDataProvider {
+ public DiffElement tree1, tree2;
+ public List differences;
+
+ private DifferenceTest(String tree1, String tree2) {
+ this(tree1, tree2, Collections.emptyList());
+ }
+
+ private DifferenceTest(String tree1, String tree2, String difference) {
+ this(tree1, tree2, Arrays.asList(difference));
+ }
+
+ private DifferenceTest(String tree1, String tree2, List differences) {
+ super(DifferenceTest.class);
+ this.tree1 = DiffNode.fromString(tree1);
+ this.tree2 = DiffNode.fromString(tree2);
+ this.differences = differences;
+ }
+
+ public String toString() {
+ return String.format("tree1=%s tree2=%s diff=%s",
+ tree1.toOneLineString(), tree2.toOneLineString(), differences);
+ }
+ }
+
+ @DataProvider(name = "trees")
+ public Object[][] createTrees() {
+ new DifferenceTest("A=X", "A=X");
+ new DifferenceTest("A=X", "A=Y", "A:X!=Y");
+ new DifferenceTest("A=X", "B=X", Arrays.asList("A:X!=MISSING", "B:MISSING!=X"));
+ new DifferenceTest("A=(X=1)", "B=(X=1)", Arrays.asList("A:(X=1)!=MISSING", "B:MISSING!=(X=1)"));
+ new DifferenceTest("A=(X=1)", "A=(X=1)");
+ new DifferenceTest("A=(X=1 Y=2)", "A=(X=1 Y=2)");
+ new DifferenceTest("A=(X=1 Y=2 B=(Z=3))", "A=(X=1 Y=2 B=(Z=3))");
+ new DifferenceTest("A=(X=1)", "A=(X=2)", "A.X:1!=2");
+ new DifferenceTest("A=(X=1 Y=2 B=(Z=3))", "A=(X=1 Y=2 B=(Z=4))", "A.B.Z:3!=4");
+ new DifferenceTest("A=(X=1)", "A=(X=1 Y=2)", "A.Y:MISSING!=2");
+ new DifferenceTest("A=(X=1 Y=2 B=(Z=3))", "A=(X=1 Y=2)", "A.B:(Z=3)!=MISSING");
+ return DifferenceTest.getTests(DifferenceTest.class);
+ }
+
+ @Test(enabled = true, dataProvider = "trees")
+ public void testDiffs(DifferenceTest test) {
+ logger.warn("Test tree1: " + test.tree1.toOneLineString());
+ logger.warn("Test tree2: " + test.tree2.toOneLineString());
+
+ List diffs = engine.diff(test.tree1, test.tree2);
+ logger.warn("Test expected diff : " + test.differences);
+ logger.warn("Observed diffs : " + diffs);
+ }
+
+ // --------------------------------------------------------------------------------
+ //
+ // Low-level routines for summarizing differences
+ //
+ // --------------------------------------------------------------------------------
+
+ @Test(enabled = true)
+ public void testLongestCommonPostfix() {
+ testLongestCommonPostfixHelper("A", "A", 1);
+ testLongestCommonPostfixHelper("A", "B", 0);
+ testLongestCommonPostfixHelper("A.B", "A.B", 2);
+ testLongestCommonPostfixHelper("A.B.C", "A.B.C", 3);
+ testLongestCommonPostfixHelper("A.B.C", "X.B.C", 2);
+ testLongestCommonPostfixHelper("A.B.C", "X.Y.C", 1);
+ testLongestCommonPostfixHelper("A.B.C", "X.Y.Z", 0);
+ testLongestCommonPostfixHelper("A.B.C", "A.X.C", 1);
+ testLongestCommonPostfixHelper("A.B.C", "A.X.Z", 0);
+ testLongestCommonPostfixHelper("A.B.C", "A.B.Z", 0);
+ }
+
+ public void testLongestCommonPostfixHelper(String p1, String p2, int expected) {
+ String[] parts1 = p1.split("\\.");
+ String[] parts2 = p2.split("\\.");
+ int obs = DiffEngine.longestCommonPostfix(parts1, parts2);
+ Assert.assertEquals(obs, expected, "p1=" + p1 + " p2=" + p2 + " failed");
+ }
+
+ @Test(enabled = true, dependsOnMethods = "testLongestCommonPostfix")
+ public void testSummarizePath() {
+ testSummarizePathHelper("A", "A", "A");
+ testSummarizePathHelper("A", "B", "*");
+ testSummarizePathHelper("A.B", "A.B", "A.B");
+ testSummarizePathHelper("A.B", "X.B", "*.B");
+ testSummarizePathHelper("A.B", "X.Y", "*.*");
+ testSummarizePathHelper("A.B.C", "A.B.C", "A.B.C");
+ testSummarizePathHelper("A.B.C", "X.B.C", "*.B.C");
+ testSummarizePathHelper("A.B.C", "X.Y.C", "*.*.C");
+ testSummarizePathHelper("A.B.C", "X.Y.Z", "*.*.*");
+ testSummarizePathHelper("A.B.C", "A.X.C", "*.*.C");
+ testSummarizePathHelper("A.B.C", "A.X.Z", "*.*.*");
+ testSummarizePathHelper("A.B.C", "A.B.Z", "*.*.*");
+ }
+
+ public void testSummarizePathHelper(String p1, String p2, String expected) {
+ String[] parts1 = DiffEngine.diffNameToPath(p1);
+ String[] parts2 = DiffEngine.diffNameToPath(p2);
+ int obs = DiffEngine.longestCommonPostfix(parts1, parts2);
+ String path = DiffEngine.summarizedPath(parts2, obs);
+ Assert.assertEquals(path, expected, "p1=" + p1 + " p2=" + p2 + " failed");
+ }
+
+ // --------------------------------------------------------------------------------
+ //
+ // High-level difference summary
+ //
+ // --------------------------------------------------------------------------------
+
+ private class SummarizeDifferenceTest extends TestDataProvider {
+ List diffs = new ArrayList();
+ List expecteds = new ArrayList();
+
+ public SummarizeDifferenceTest() { super(SummarizeDifferenceTest.class); }
+
+ public SummarizeDifferenceTest addDiff(String... diffsToAdd) {
+ diffs.addAll(Arrays.asList(diffsToAdd));
+ return this;
+ }
+
+ public SummarizeDifferenceTest addSummary(String... expectedSummary) {
+ expecteds.addAll(Arrays.asList(expectedSummary));
+ return this;
+ }
+
+ public String toString() {
+ return String.format("diffs=%s => expected=%s", diffs, expecteds);
+ }
+
+ public void test() {
+ List diffPaths = new ArrayList(diffs.size());
+ for ( String diff : diffs ) { diffPaths.add(DiffEngine.diffNameToPath(diff)); }
+
+ List sumDiffs = engine.summarizedDifferencesOfPaths(diffPaths);
+
+ Assert.assertEquals(sumDiffs.size(), expecteds.size(), "Unexpected number of summarized differences: " + sumDiffs);
+
+ for ( int i = 0; i < sumDiffs.size(); i++ ) {
+ DiffEngine.SummarizedDifference sumDiff = sumDiffs.get(i);
+ String expected = expecteds.get(i);
+ String[] pathCount = expected.split(":");
+ String path = pathCount[0];
+ int count = Integer.valueOf(pathCount[1]);
+ Assert.assertEquals(sumDiff.getPath(), path, "Unexpected path at: " + expected + " obs=" + sumDiff + " all=" + sumDiffs);
+ Assert.assertEquals(sumDiff.getCount(), count, "Unexpected counts at: " + expected + " obs=" + sumDiff + " all=" + sumDiffs);
+ }
+ }
+ }
+
+ @DataProvider(name = "summaries")
+ public Object[][] createSummaries() {
+ new SummarizeDifferenceTest().addDiff("A", "A").addSummary("A:2");
+ new SummarizeDifferenceTest().addDiff("A", "B").addSummary("A:1", "B:1");
+ new SummarizeDifferenceTest().addDiff("A", "A", "A").addSummary("A:3");
+ new SummarizeDifferenceTest().addDiff("A", "A", "A", "B").addSummary("A:3", "B:1");
+ new SummarizeDifferenceTest().addDiff("A", "A", "A", "B", "B").addSummary("A:3", "B:2");
+ new SummarizeDifferenceTest().addDiff("A", "A", "A", "B", "B", "C").addSummary("A:3", "B:2", "C:1");
+ new SummarizeDifferenceTest().addDiff("A.X", "A.X").addSummary("A.X:2");
+ new SummarizeDifferenceTest().addDiff("A.X", "A.X", "B.X").addSummary("*.X:3", "A.X:2", "B.X:1");
+ new SummarizeDifferenceTest().addDiff("A.X", "A.X", "B.X", "B.X").addSummary("*.X:4", "A.X:2", "B.X:2");
+ new SummarizeDifferenceTest().addDiff("A.B.C", "X.B.C").addSummary("*.B.C:2", "A.B.C:1", "X.B.C:1");
+ new SummarizeDifferenceTest().addDiff("A.B.C", "X.Y.C", "X.Y.C").addSummary("*.*.C:3", "X.Y.C:2", "A.B.C:1");
+ new SummarizeDifferenceTest().addDiff("A.B.C", "A.X.C", "X.Y.C").addSummary("*.*.C:3", "A.B.C:1", "A.X.C:1", "X.Y.C:1");
+ new SummarizeDifferenceTest().addDiff("A.B.C", "A.X.C", "B.X.C").addSummary("*.*.C:3", "*.X.C:2", "A.B.C:1", "A.X.C:1", "B.X.C:1");
+ new SummarizeDifferenceTest().addDiff("A.B.C", "A.X.C", "B.X.C", "B.X.C").addSummary("*.*.C:4", "*.X.C:3", "B.X.C:2", "A.B.C:1", "A.X.C:1");
+
+ return SummarizeDifferenceTest.getTests(SummarizeDifferenceTest.class);
+ }
+
+
+ @Test(enabled = true, dependsOnMethods = "testSummarizePath", dataProvider = "summaries")
+ public void testSummarizeDifferences(SummarizeDifferenceTest test) {
+ test.test();
+ }
+}
\ No newline at end of file
diff --git a/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffNodeUnitTest.java b/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffNodeUnitTest.java
new file mode 100644
index 000000000..534416d29
--- /dev/null
+++ b/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffNodeUnitTest.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2011, The Broad Institute
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// our package
+package org.broadinstitute.sting.gatk.walkers.diffengine;
+
+
+// the imports for unit testing.
+
+
+import org.broadinstitute.sting.BaseTest;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.*;
+
+/**
+ * Basic unit test for DifferableReaders in reduced reads
+ */
+public class DiffNodeUnitTest extends BaseTest {
+ // Data is:
+ // MY_ROOT
+ // fields: A=A, B=B
+ // nodes: C, D
+ // C: fields: E=E, nodes: none
+ // D: fields: F=F, G=G, nodes: none
+ static DiffNode MY_ROOT = DiffNode.rooted("MY_ROOT");
+ static DiffValue Value_A = new DiffValue("A", MY_ROOT, "A");
+ static DiffValue Value_B = new DiffValue("B", MY_ROOT, "B");
+ static DiffNode NODE_C = DiffNode.empty("C", MY_ROOT);
+ static DiffNode NODE_D = DiffNode.empty("D", MY_ROOT);
+ static DiffValue Value_E = new DiffValue("E", NODE_C, "E");
+ static DiffValue Value_F = new DiffValue("F", NODE_D, "F");
+ static DiffValue Value_G = new DiffValue("G", NODE_D, "G");
+
+ static {
+ MY_ROOT.add(Value_A);
+ MY_ROOT.add(Value_B);
+ MY_ROOT.add(NODE_C);
+ MY_ROOT.add(NODE_D);
+ NODE_C.add(Value_E);
+ NODE_D.add(Value_F);
+ NODE_D.add(Value_G);
+ }
+
+
+ // --------------------------------------------------------------------------------
+ //
+ // Element testing routines
+ //
+ // --------------------------------------------------------------------------------
+
+ private class ElementTest extends TestDataProvider {
+ public DiffElement elt;
+ public String name;
+ public String fullName;
+ public DiffElement parent;
+
+ private ElementTest(DiffValue elt, DiffValue parent, String name, String fullName) {
+ this(elt.getBinding(), parent.getBinding(), name, fullName);
+ }
+
+ private ElementTest(DiffElement elt, DiffElement parent, String name, String fullName) {
+ super(ElementTest.class);
+ this.elt = elt;
+ this.name = name;
+ this.fullName = fullName;
+ this.parent = parent;
+ }
+
+ public String toString() {
+ return String.format("ElementTest elt=%s name=%s fullName=%s parent=%s",
+ elt.toOneLineString(), name, fullName, parent.getName());
+ }
+ }
+
+ @DataProvider(name = "elementdata")
+ public Object[][] createElementData() {
+ new ElementTest(MY_ROOT.getBinding(), DiffElement.ROOT, "MY_ROOT", "MY_ROOT");
+ new ElementTest(NODE_C, MY_ROOT, "C", "MY_ROOT.C");
+ new ElementTest(NODE_D, MY_ROOT, "D", "MY_ROOT.D");
+ new ElementTest(Value_A, MY_ROOT, "A", "MY_ROOT.A");
+ new ElementTest(Value_B, MY_ROOT, "B", "MY_ROOT.B");
+ new ElementTest(Value_E, NODE_C, "E", "MY_ROOT.C.E");
+ new ElementTest(Value_F, NODE_D, "F", "MY_ROOT.D.F");
+ new ElementTest(Value_G, NODE_D, "G", "MY_ROOT.D.G");
+ return TestDataProvider.getTests(ElementTest.class);
+ }
+
+ @Test(enabled = true, dataProvider = "elementdata")
+ public void testElementMethods(ElementTest test) {
+ Assert.assertNotNull(test.elt.getName());
+ Assert.assertNotNull(test.elt.getParent());
+ Assert.assertEquals(test.elt.getName(), test.name);
+ Assert.assertEquals(test.elt.getParent(), test.parent);
+ Assert.assertEquals(test.elt.fullyQualifiedName(), test.fullName);
+ }
+
+ // --------------------------------------------------------------------------------
+ //
+ // DiffValue testing routines
+ //
+ // --------------------------------------------------------------------------------
+
+ private class LeafTest extends TestDataProvider {
+ public DiffValue diffvalue;
+ public Object value;
+
+ private LeafTest(DiffValue diffvalue, Object value) {
+ super(LeafTest.class);
+ this.diffvalue = diffvalue;
+ this.value = value;
+ }
+
+ public String toString() {
+ return String.format("LeafTest diffvalue=%s value=%s", diffvalue.toOneLineString(), value);
+ }
+ }
+
+ @DataProvider(name = "leafdata")
+ public Object[][] createLeafData() {
+ new LeafTest(Value_A, "A");
+ new LeafTest(Value_B, "B");
+ new LeafTest(Value_E, "E");
+ new LeafTest(Value_F, "F");
+ new LeafTest(Value_G, "G");
+ return TestDataProvider.getTests(LeafTest.class);
+ }
+
+ @Test(enabled = true, dataProvider = "leafdata")
+ public void testLeafMethods(LeafTest test) {
+ Assert.assertNotNull(test.diffvalue.getValue());
+ Assert.assertEquals(test.diffvalue.getValue(), test.value);
+ }
+
+ // --------------------------------------------------------------------------------
+ //
+ // Node testing routines
+ //
+ // --------------------------------------------------------------------------------
+
+ private class NodeTest extends TestDataProvider {
+ public DiffNode node;
+ public Set fields;
+ public Set subnodes;
+ public Set allNames;
+
+ private NodeTest(DiffNode node, List fields, List subnodes) {
+ super(NodeTest.class);
+ this.node = node;
+ this.fields = new HashSet(fields);
+ this.subnodes = new HashSet(subnodes);
+ this.allNames = new HashSet(fields);
+ allNames.addAll(subnodes);
+ }
+
+ public String toString() {
+ return String.format("NodeTest node=%s fields=%s subnodes=%s",
+ node.toOneLineString(), fields, subnodes);
+ }
+ }
+
+ @DataProvider(name = "nodedata")
+ public Object[][] createData1() {
+ new NodeTest(MY_ROOT, Arrays.asList("A", "B"), Arrays.asList("C", "D"));
+ new NodeTest(NODE_C, Arrays.asList("E"), Collections.emptyList());
+ new NodeTest(NODE_D, Arrays.asList("F", "G"), Collections.emptyList());
+ return TestDataProvider.getTests(NodeTest.class);
+ }
+
+ @Test(enabled = true, dataProvider = "nodedata")
+ public void testNodeAccessors(NodeTest test) {
+ Assert.assertNotNull(test.node.getElements());
+
+ for ( String name : test.allNames ) {
+ DiffElement elt = test.node.getElement(name);
+ Assert.assertNotNull(elt, "Failed to find field " + elt + " in " + test.node);
+ Assert.assertEquals(elt.getName(), name);
+ Assert.assertEquals(elt.getValue().isAtomic(), test.fields.contains(name), "Failed atomic/compound expectation: " + test.node);
+ }
+ }
+
+ // NOTE: add routines are being implicitly tested by the creation of the data structures
+
+ @Test(enabled = true, dataProvider = "nodedata")
+ public void testCounts(NodeTest test) {
+ Assert.assertEquals(test.node.getElements().size(), test.allNames.size());
+ Assert.assertEquals(test.node.getElementNames(), test.allNames);
+ }
+
+ // --------------------------------------------------------------------------------
+ //
+ // fromString testing routines
+ //
+ // --------------------------------------------------------------------------------
+
+ private class FromStringTest extends TestDataProvider {
+ public String string;
+ public DiffElement expected;
+
+ private FromStringTest(String string, DiffElement expected) {
+ super(FromStringTest.class);
+ this.string = string;
+ this.expected = expected;
+ }
+
+ public String toString() {
+ return String.format("FromStringTest string=%s expected=%s", string, expected.toOneLineString());
+ }
+ }
+
+ @DataProvider(name = "fromstringdata")
+ public Object[][] createFromData() {
+ new FromStringTest("A=A", Value_A.getBinding());
+ new FromStringTest("B=B", Value_B.getBinding());
+ new FromStringTest("C=(E=E)", NODE_C.getBinding());
+ new FromStringTest("D=(F=F G=G)", NODE_D.getBinding());
+ return TestDataProvider.getTests(FromStringTest.class);
+ }
+
+ @Test(enabled = true, dataProvider = "fromstringdata")
+ public void parseFromString(FromStringTest test) {
+ logger.warn("Testing from string: " + test.string);
+ DiffElement elt = DiffNode.fromString(test.string);
+ Assert.assertEquals(elt.toOneLineString(), test.expected.toOneLineString());
+ }
+}
\ No newline at end of file
diff --git a/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffableReaderUnitTest.java b/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffableReaderUnitTest.java
new file mode 100644
index 000000000..5738b643f
--- /dev/null
+++ b/public/java/test/org/broadinstitute/sting/gatk/walkers/diffengine/DiffableReaderUnitTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2011, The Broad Institute
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// our package
+package org.broadinstitute.sting.gatk.walkers.diffengine;
+
+
+// the imports for unit testing.
+
+
+import net.sf.samtools.SAMRecord;
+import org.broadinstitute.sting.BaseTest;
+import org.broadinstitute.sting.utils.variantcontext.Allele;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.io.File;
+import java.util.*;
+
+/**
+ * Basic unit test for DifferableReaders in reduced reads
+ */
+public class DiffableReaderUnitTest extends BaseTest {
+ DiffEngine engine;
+
+ File vcfFile = new File(testDir + "diffTestMaster.vcf");
+ File bamFile = new File(testDir + "exampleBAM.bam");
+
+ @BeforeClass(enabled = true)
+ public void createDiffEngine() {
+ engine = new DiffEngine();
+ }
+
+ @Test(enabled = true)
+ public void testPluggableDiffableReaders() {
+ logger.warn("testPluggableDiffableReaders");
+ Map readers = engine.getReaders();
+ Assert.assertNotNull(readers);
+ Assert.assertTrue(readers.size() > 0);
+ Assert.assertNotNull(readers.get("VCF"));
+ for ( Map.Entry e : engine.getReaders().entrySet() ) {
+ logger.warn("Found diffable reader: " + e.getKey());
+ Assert.assertEquals(e.getValue().getName(), e.getKey());
+ Assert.assertEquals(e.getValue(), engine.getReader(e.getKey()));
+ }
+ }
+
+ private static void testLeaf(DiffNode rec, String field, Object expected) {
+ DiffElement value = rec.getElement(field);
+ Assert.assertNotNull(value, "Expected to see leaf named " + field + " in rec " + rec);
+ Assert.assertEquals(value.getValue().getValue(), expected, "Expected to leaf named " + field + " to have value " + expected + " in rec " + rec);
+ }
+
+ @Test(enabled = true, dependsOnMethods = "testPluggableDiffableReaders")
+ public void testVCF1() {
+ logger.warn("testVCF1");
+ DiffableReader vcfReader = engine.getReader("VCF");
+ Assert.assertTrue(vcfReader.canRead(vcfFile));
+ Assert.assertFalse(vcfReader.canRead(bamFile));
+
+ DiffElement diff = vcfReader.readFromFile(vcfFile);
+ Assert.assertNotNull(diff);
+
+ Assert.assertEquals(diff.getName(), vcfFile.getName());
+ Assert.assertSame(diff.getParent(), DiffElement.ROOT);
+
+ DiffNode node = diff.getValueAsNode();
+ Assert.assertEquals(node.getElements().size(), 9);
+
+ // chr1 2646 rs62635284 G A 0.15 PASS AC=2;AF=1.00;AN=2 GT:AD:DP:GL:GQ 1/1:53,75:3:-12.40,-0.90,-0.00:9.03
+ DiffNode rec1 = node.getElement("chr1:2646").getValueAsNode();
+ testLeaf(rec1, "CHROM", "chr1");
+ testLeaf(rec1, "POS", 2646);
+ testLeaf(rec1, "ID", "rs62635284");
+ testLeaf(rec1, "REF", Allele.create("G", true));
+ testLeaf(rec1, "ALT", new HashSet(Arrays.asList(Allele.create("A"))));
+ testLeaf(rec1, "QUAL", 0.15);
+ testLeaf(rec1, "FILTER", Collections.