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/src/org/broadinstitute/sting/gatk/walkers/diffengine/BAMDiffableReader.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/BAMDiffableReader.java
index f7a395d9d..a5ebf27bb 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/BAMDiffableReader.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/BAMDiffableReader.java
@@ -51,12 +51,11 @@ import java.util.zip.GZIPInputStream;
* Class implementing diffnode reader for VCF
*/
public class BAMDiffableReader implements DiffableReader {
- private final static int MAX_RECORDS_TO_READ = 1000;
@Override
public String getName() { return "BAM"; }
@Override
- public DiffElement readFromFile(File file) {
+ public DiffElement readFromFile(File file, int maxElementsToRead) {
final SAMFileReader reader = new SAMFileReader(file, null); // null because we don't want it to look for the index
reader.setValidationStringency(SAMFileReader.ValidationStringency.SILENT);
@@ -65,7 +64,7 @@ public class BAMDiffableReader implements DiffableReader {
int count = 0;
while ( iterator.hasNext() ) {
- if ( count++ > MAX_RECORDS_TO_READ )
+ if ( count++ > maxElementsToRead && maxElementsToRead != -1)
break;
final SAMRecord record = iterator.next();
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffElement.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffElement.java
index eff24bb88..4c3f7bd95 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffElement.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffElement.java
@@ -115,4 +115,8 @@ public class DiffElement {
else
throw new ReviewedStingException("Illegal request conversion of a DiffValue into a DiffNode: " + this);
}
+
+ public int size() {
+ return 1 + getValue().size();
+ }
}
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffEngine.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffEngine.java
index ba2713bff..6d85df71d 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffEngine.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffEngine.java
@@ -24,11 +24,9 @@
package org.broadinstitute.sting.gatk.walkers.diffengine;
-import com.google.java.contract.Requires;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.gatk.report.GATKReport;
import org.broadinstitute.sting.gatk.report.GATKReportTable;
-import org.broadinstitute.sting.gatk.walkers.varianteval.stratifications.VariantStratifier;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.classloader.PluginManager;
import org.broadinstitute.sting.utils.exceptions.ReviewedStingException;
@@ -60,7 +58,7 @@ public class DiffEngine {
//
// --------------------------------------------------------------------------------
- public List diff(DiffElement master, DiffElement test) {
+ public List diff(DiffElement master, DiffElement test) {
DiffValue masterValue = master.getValue();
DiffValue testValue = test.getValue();
@@ -70,14 +68,14 @@ public class DiffEngine {
return diff(masterValue, testValue);
} else {
// structural difference in types. one is node, other is leaf
- return Arrays.asList(new Difference(master, test));
+ return Arrays.asList(new SpecificDifference(master, test));
}
}
- public List diff(DiffNode master, DiffNode test) {
+ public List diff(DiffNode master, DiffNode test) {
Set allNames = new HashSet(master.getElementNames());
allNames.addAll(test.getElementNames());
- List diffs = new ArrayList();
+ List diffs = new ArrayList();
for ( String name : allNames ) {
DiffElement masterElt = master.getElement(name);
@@ -86,7 +84,7 @@ public class DiffEngine {
throw new ReviewedStingException("BUG: unexceptedly got two null elements for field: " + name);
} else if ( masterElt == null || testElt == null ) { // if either is null, we are missing a value
// todo -- should one of these be a special MISSING item?
- diffs.add(new Difference(masterElt, testElt));
+ diffs.add(new SpecificDifference(masterElt, testElt));
} else {
diffs.addAll(diff(masterElt, testElt));
}
@@ -95,11 +93,11 @@ public class DiffEngine {
return diffs;
}
- public List diff(DiffValue master, DiffValue test) {
+ public List diff(DiffValue master, DiffValue test) {
if ( master.getValue().equals(test.getValue()) ) {
return Collections.emptyList();
} else {
- return Arrays.asList(new Difference(master.getBinding(), test.getBinding()));
+ return Arrays.asList(new SpecificDifference(master.getBinding(), test.getBinding()));
}
}
@@ -147,64 +145,68 @@ public class DiffEngine {
* @param params determines how we display the items
* @param diffs
*/
- public void reportSummarizedDifferences(List diffs, SummaryReportParams params ) {
+ public void reportSummarizedDifferences(List diffs, SummaryReportParams params ) {
printSummaryReport(summarizeDifferences(diffs), params );
}
- public List summarizeDifferences(List diffs) {
- List diffPaths = new ArrayList(diffs.size());
-
- for ( Difference diff1 : diffs ) {
- diffPaths.add(diffNameToPath(diff1.getFullyQualifiedName()));
- }
-
- return summarizedDifferencesOfPaths(diffPaths);
+ public List summarizeDifferences(List diffs) {
+ return summarizedDifferencesOfPaths(diffs);
}
final protected static String[] diffNameToPath(String diffName) {
return diffName.split("\\.");
}
- protected List summarizedDifferencesOfPaths(List diffPaths) {
- Map summaries = new HashMap();
+ protected List summarizedDifferencesOfPathsFromString(List singletonDiffs) {
+ List diffs = new ArrayList();
+
+ for ( String diff : singletonDiffs ) {
+ diffs.add(new Difference(diff));
+ }
+
+ return summarizedDifferencesOfPaths(diffs);
+ }
+
+ protected List summarizedDifferencesOfPaths(List singletonDiffs) {
+ Map summaries = new HashMap();
// create the initial set of differences
- for ( int i = 0; i < diffPaths.size(); i++ ) {
+ for ( int i = 0; i < singletonDiffs.size(); i++ ) {
for ( int j = 0; j <= i; j++ ) {
- String[] diffPath1 = diffPaths.get(i);
- String[] diffPath2 = diffPaths.get(j);
- if ( diffPath1.length == diffPath2.length ) {
- int lcp = longestCommonPostfix(diffPath1, diffPath2);
- String path = lcp > 0 ? summarizedPath(diffPath2, lcp) : Utils.join(".", diffPath2);
+ Difference diffPath1 = singletonDiffs.get(i);
+ Difference diffPath2 = singletonDiffs.get(j);
+ if ( diffPath1.length() == diffPath2.length() ) {
+ int lcp = longestCommonPostfix(diffPath1.getParts(), diffPath2.getParts());
+ String path = lcp > 0 ? summarizedPath(diffPath2.getParts(), lcp) : diffPath2.getPath();
addSummary(summaries, path, true);
}
}
}
// count differences
- for ( String[] diffPath : diffPaths ) {
- for ( SummarizedDifference sumDiff : summaries.values() ) {
- if ( sumDiff.matches(diffPath) )
+ for ( Difference diffPath : singletonDiffs ) {
+ for ( Difference sumDiff : summaries.values() ) {
+ if ( sumDiff.matches(diffPath.getParts()) )
addSummary(summaries, sumDiff.getPath(), false);
}
}
- List sortedSummaries = new ArrayList(summaries.values());
+ List sortedSummaries = new ArrayList(summaries.values());
Collections.sort(sortedSummaries);
return sortedSummaries;
}
- private static void addSummary(Map summaries, String path, boolean onlyCatalog) {
+ private static void addSummary(Map summaries, String path, boolean onlyCatalog) {
if ( summaries.containsKey(path) ) {
if ( ! onlyCatalog )
summaries.get(path).incCount();
} else {
- SummarizedDifference sumDiff = new SummarizedDifference(path);
+ Difference sumDiff = new Difference(path);
summaries.put(sumDiff.getPath(), sumDiff);
}
}
- protected void printSummaryReport(List sortedSummaries, SummaryReportParams params ) {
+ protected void printSummaryReport(List sortedSummaries, SummaryReportParams params ) {
GATKReport report = new GATKReport();
final String tableName = "diffences";
report.addTable(tableName, "Summarized differences between the master and test files.\nSee http://www.broadinstitute.org/gsa/wiki/index.php/DiffObjectsWalker_and_SummarizedDifferences for more information");
@@ -213,7 +215,7 @@ public class DiffEngine {
table.addColumn("NumberOfOccurrences", 0);
int count = 0, count1 = 0;
- for ( SummarizedDifference diff : sortedSummaries ) {
+ for ( Difference diff : sortedSummaries ) {
if ( diff.getCount() < params.minSumDiffToShow )
// in order, so break as soon as the count is too low
break;
@@ -261,76 +263,6 @@ public class DiffEngine {
return Utils.join(".", parts);
}
- /**
- * TODO -- all of the algorithms above should use SummarizedDifference instead
- * TODO -- of some SummarizedDifferences and some low-level String[]
- */
- public static class SummarizedDifference implements Comparable {
- final String path; // X.Y.Z
- final String[] parts;
- int count = 0;
-
- public SummarizedDifference(String path) {
- this.path = path;
- this.parts = diffNameToPath(path);
- }
-
- public void incCount() { count++; }
-
- public int getCount() {
- return count;
- }
-
- /**
- * The fully qualified path object A.B.C etc
- * @return
- */
- public String getPath() {
- return path;
- }
-
- /**
- * @return the length of the parts of this summary
- */
- public int length() {
- return this.parts.length;
- }
-
- /**
- * Returns true if the string parts matches this summary. Matches are
- * must be equal() everywhere where this summary isn't *.
- * @param otherParts
- * @return
- */
- public boolean matches(String[] otherParts) {
- if ( otherParts.length != length() )
- return false;
-
- // TODO optimization: can start at right most non-star element
- for ( int i = 0; i < length(); i++ ) {
- String part = parts[i];
- if ( ! part.equals("*") && ! part.equals(otherParts[i]) )
- return false;
- }
-
- return true;
- }
-
- @Override
- public String toString() {
- return String.format("%s:%d", getPath(), getCount());
- }
-
- @Override
- public int compareTo(SummarizedDifference other) {
- // sort first highest to lowest count, then by lowest to highest path
- int countCmp = Integer.valueOf(count).compareTo(other.count);
- return countCmp != 0 ? -1 * countCmp : path.compareTo(other.path);
- }
-
-
- }
-
// --------------------------------------------------------------------------------
//
// plugin manager
@@ -385,12 +317,17 @@ public class DiffEngine {
return findReaderForFile(file) != null;
}
+
public DiffElement createDiffableFromFile(File file) {
+ return createDiffableFromFile(file, -1);
+ }
+
+ public DiffElement createDiffableFromFile(File file, int maxElementsToRead) {
DiffableReader reader = findReaderForFile(file);
if ( reader == null )
throw new UserException("Unsupported file type: " + file);
else
- return reader.readFromFile(file);
+ return reader.readFromFile(file, maxElementsToRead);
}
public static boolean simpleDiffFiles(File masterFile, File testFile, DiffEngine.SummaryReportParams params) {
@@ -399,7 +336,7 @@ public class DiffEngine {
if ( diffEngine.canRead(masterFile) && diffEngine.canRead(testFile) ) {
DiffElement master = diffEngine.createDiffableFromFile(masterFile);
DiffElement test = diffEngine.createDiffableFromFile(testFile);
- List diffs = diffEngine.diff(master, test);
+ List diffs = diffEngine.diff(master, test);
diffEngine.reportSummarizedDifferences(diffs, params);
return true;
} else {
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffNode.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffNode.java
index 0720e18c0..2f48de2d3 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffNode.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffNode.java
@@ -107,11 +107,13 @@ public class DiffNode extends DiffValue {
return getElements(false);
}
+ /**
+ * Returns the element bound to name, or null if no such binding exists
+ * @param name
+ * @return
+ */
public DiffElement getElement(String name) {
- for ( DiffElement elt : getElements() )
- if ( elt.getName().equals(name) )
- return elt;
- return null;
+ return getElementMap().get(name);
}
/**
@@ -151,6 +153,13 @@ public class DiffNode extends DiffValue {
add(new DiffElement(name, this.getBinding(), new DiffValue(value)));
}
+ public int size() {
+ int count = 0;
+ for ( DiffElement value : getElements() )
+ count += value.size();
+ return count;
+ }
+
// ---------------------------------------------------------------------------
//
// toString
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffObjectsWalker.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffObjectsWalker.java
index a08108db2..ecb836af9 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffObjectsWalker.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffObjectsWalker.java
@@ -24,7 +24,6 @@
package org.broadinstitute.sting.gatk.walkers.diffengine;
-import org.apache.xmlbeans.impl.tool.Diff;
import org.broadinstitute.sting.commandline.Argument;
import org.broadinstitute.sting.commandline.Output;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
@@ -48,11 +47,14 @@ public class DiffObjectsWalker extends RodWalker {
@Output(doc="File to which results should be written",required=true)
protected PrintStream out;
- @Argument(fullName="maxRecords", shortName="M", doc="Max. number of records to process", required=false)
- int MAX_RECORDS = 0;
+ @Argument(fullName="maxObjectsToRead", shortName="motr", doc="Max. number of objects to read from the files. -1 [default] means unlimited", required=false)
+ int MAX_OBJECTS_TO_READ = -1;
- @Argument(fullName="maxCount1Records", shortName="M1", doc="Max. number of records occuring exactly once in the file to process", required=false)
- int MAX_COUNT1_RECORDS = 0;
+ @Argument(fullName="maxDiffs", shortName="M", doc="Max. number of diffs to process", required=false)
+ int MAX_DIFFS = 0;
+
+ @Argument(fullName="maxCount1Diffs", shortName="M1", doc="Max. number of diffs occuring exactly once in the file to process", required=false)
+ int MAX_COUNT1_DIFFS = 0;
@Argument(fullName="minCountForDiff", shortName="MCFD", doc="Min number of observations for a records to display", required=false)
int minCountForDiff = 1;
@@ -91,23 +93,25 @@ public class DiffObjectsWalker extends RodWalker {
@Override
public void onTraversalDone(Integer sum) {
out.printf("Reading master file %s%n", masterFile);
- DiffElement master = diffEngine.createDiffableFromFile(masterFile);
+ DiffElement master = diffEngine.createDiffableFromFile(masterFile, MAX_OBJECTS_TO_READ);
+ out.printf(" Read %d objects%n", master.size());
out.printf("Reading test file %s%n", testFile);
- DiffElement test = diffEngine.createDiffableFromFile(testFile);
+ DiffElement test = diffEngine.createDiffableFromFile(testFile, MAX_OBJECTS_TO_READ);
+ out.printf(" Read %d objects%n", test.size());
// out.printf("Master diff objects%n");
// out.println(master.toString());
// out.printf("Test diff objects%n");
// out.println(test.toString());
- List diffs = diffEngine.diff(master, test);
+ List diffs = diffEngine.diff(master, test);
if ( showItemizedDifferences ) {
out.printf("Itemized results%n");
- for ( Difference diff : diffs )
+ for ( SpecificDifference diff : diffs )
out.printf("DIFF: %s%n", diff.toString());
}
- DiffEngine.SummaryReportParams params = new DiffEngine.SummaryReportParams(out, MAX_RECORDS, MAX_COUNT1_RECORDS, minCountForDiff);
+ DiffEngine.SummaryReportParams params = new DiffEngine.SummaryReportParams(out, MAX_DIFFS, MAX_COUNT1_DIFFS, minCountForDiff);
diffEngine.reportSummarizedDifferences(diffs, params);
}
}
\ No newline at end of file
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffValue.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffValue.java
index 7245e9e8d..3750496a1 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffValue.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffValue.java
@@ -87,4 +87,5 @@ public class DiffValue {
public boolean isAtomic() { return true; }
public boolean isCompound() { return ! isAtomic(); }
+ public int size() { return 1; }
}
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffableReader.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffableReader.java
index 84c2eed10..af5771c55 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffableReader.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/DiffableReader.java
@@ -43,7 +43,7 @@ public interface DiffableReader {
@Ensures("result != null")
@Requires("file != null")
- public DiffElement readFromFile(File file);
+ public DiffElement readFromFile(File file, int maxElementsToRead);
@Requires("file != null")
public boolean canRead(File file);
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/Difference.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/Difference.java
index 6627a4cc5..efc6ef160 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/Difference.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/Difference.java
@@ -24,35 +24,72 @@
package org.broadinstitute.sting.gatk.walkers.diffengine;
-/**
- * Created by IntelliJ IDEA.
- * User: depristo
- * Date: 7/4/11
- * Time: 12:53 PM
- *
- * Represents a specific difference between two specific DiffElements
- */
-public class Difference {
- DiffElement master, test;
+public class Difference implements Comparable {
+ final String path; // X.Y.Z
+ final String[] parts;
+ int count = 0;
- public Difference(DiffElement master, DiffElement test) {
- if ( master == null && test == null ) throw new IllegalArgumentException("Master and test both cannot be null");
- this.master = master;
- this.test = test;
+ public Difference(String path) {
+ this.path = path;
+ this.parts = DiffEngine.diffNameToPath(path);
}
+ public String[] getParts() {
+ return parts;
+ }
+
+ public void incCount() { count++; }
+
+ public int getCount() {
+ return count;
+ }
+
+ /**
+ * The fully qualified path object A.B.C etc
+ * @return
+ */
+ public String getPath() {
+ return path;
+ }
+
+ /**
+ * @return the length of the parts of this summary
+ */
+ public int length() {
+ return this.parts.length;
+ }
+
+ /**
+ * Returns true if the string parts matches this summary. Matches are
+ * must be equal() everywhere where this summary isn't *.
+ * @param otherParts
+ * @return
+ */
+ public boolean matches(String[] otherParts) {
+ if ( otherParts.length != length() )
+ return false;
+
+ // TODO optimization: can start at right most non-star element
+ for ( int i = 0; i < length(); i++ ) {
+ String part = parts[i];
+ if ( ! part.equals("*") && ! part.equals(otherParts[i]) )
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
public String toString() {
- return String.format("%s:%s!=%s",
- getFullyQualifiedName(),
- getOneLineString(master),
- getOneLineString(test));
+ return String.format("%s:%d", getPath(), getCount());
}
- public String getFullyQualifiedName() {
- return (master == null ? test : master).fullyQualifiedName();
+ @Override
+ public int compareTo(Difference other) {
+ // sort first highest to lowest count, then by lowest to highest path
+ int countCmp = Integer.valueOf(count).compareTo(other.count);
+ return countCmp != 0 ? -1 * countCmp : path.compareTo(other.path);
}
- private static String getOneLineString(DiffElement elt) {
- return elt == null ? "MISSING" : elt.getValue().toOneLineString();
- }
+
}
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/SpecificDifference.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/SpecificDifference.java
new file mode 100644
index 000000000..2fe9b47f8
--- /dev/null
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/SpecificDifference.java
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+package org.broadinstitute.sting.gatk.walkers.diffengine;
+
+/**
+ * Created by IntelliJ IDEA.
+ * User: depristo
+ * Date: 7/4/11
+ * Time: 12:53 PM
+ *
+ * Represents a specific difference between two specific DiffElements
+ */
+public class SpecificDifference extends Difference {
+ DiffElement master, test;
+
+ public SpecificDifference(DiffElement master, DiffElement test) {
+ super(createName(master, test));
+ if ( master == null && test == null ) throw new IllegalArgumentException("Master and test both cannot be null");
+ this.master = master;
+ this.test = test;
+ }
+
+ public String toString() {
+ return String.format("%s:%s!=%s",
+ getPath(),
+ getOneLineString(master),
+ getOneLineString(test));
+ }
+
+ private static String createName(DiffElement master, DiffElement test) {
+ return (master == null ? test : master).fullyQualifiedName();
+ }
+
+ private static String getOneLineString(DiffElement elt) {
+ return elt == null ? "MISSING" : elt.getValue().toOneLineString();
+ }
+}
diff --git a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/VCFDiffableReader.java b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/VCFDiffableReader.java
index 743178538..06d14366f 100644
--- a/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/VCFDiffableReader.java
+++ b/public/java/src/org/broadinstitute/sting/gatk/walkers/diffengine/VCFDiffableReader.java
@@ -51,15 +51,21 @@ public class VCFDiffableReader implements DiffableReader {
public String getName() { return "VCF"; }
@Override
- public DiffElement readFromFile(File file) {
+ public DiffElement readFromFile(File file, int maxElementsToRead) {
DiffNode root = DiffNode.rooted(file.getName());
try {
LineReader lineReader = new AsciiLineReader(new FileInputStream(file));
VCFCodec vcfCodec = new VCFCodec();
- VCFHeader header = (VCFHeader)vcfCodec.readHeader(lineReader);
+
+ // must be read as state is stored in reader itself
+ vcfCodec.readHeader(lineReader);
String line = lineReader.readLine();
+ int count = 0;
while ( line != null ) {
+ if ( count++ > maxElementsToRead && maxElementsToRead != -1)
+ break;
+
VariantContext vc = (VariantContext)vcfCodec.decode(line);
String name = vc.getChr() + ":" + vc.getStart();
DiffNode vcRoot = DiffNode.empty(name, root);
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..96dfec6e8
--- /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.summarizedDifferencesOfPathsFromString(diffs);
+
+ Assert.assertEquals(sumDiffs.size(), expecteds.size(), "Unexpected number of summarized differences: " + sumDiffs);
+
+ for ( int i = 0; i < sumDiffs.size(); i++ ) {
+ Difference 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..baa2f0383
--- /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, -1);
+ 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.