public void testRemoveMulti() throws Exception {
try (TestDirectory td = new TestDirectory()) {
final File f =
FileHelper.resourceToGzFile(
"com/rtg/vcf/resources/vcfsubset.vcf", new File(td, "vcf.vcf.gz"));
final File out = new File(td, "out.vcf");
checkMainInitOk(
"-i",
f.getPath(),
"-o",
out.getPath(),
"--remove-samples",
"--keep-info",
"AN",
"--keep-info",
"AC",
"--keep-filter",
"YEA",
"-Z");
final String content = FileHelper.fileToString(out);
final String editedContent =
StringUtils.grepMinusV(StringUtils.grepMinusV(content, "^##RUN-ID"), "^##CL");
mNano.check("vcfsubset-multi.vcf", editedContent);
}
}
public void testExplosion() throws Exception {
try (TestDirectory td = new TestDirectory()) {
final File f =
FileHelper.resourceToGzFile(
"com/rtg/vcf/resources/vcfsubset.vcf", new File(td, "vcf.vcf.gz"));
final File out = new File(td, "out.vcf");
assertEquals(
"Records skipped due to invalid or incompatible sample fields: 1" + StringUtils.LS,
checkMainInitWarn(
"-i",
f.getPath(),
"-o",
out.getPath(),
"--remove-format",
"GT",
"--remove-format",
"DS",
"-Z"));
final String content = FileHelper.fileToString(out);
final String nonheader = StringUtils.grepMinusV(content, "^#");
assertTrue(nonheader.startsWith("X\t60052"));
}
}
public static void makeTestTaxonSdf(File dest) throws IOException {
final String sequences =
FileHelper.resourceToString("com/rtg/reader/resources/sequences.fasta");
ReaderTestUtils.getReaderDNA(sequences, dest, null).close();
// cp taxonomy files to sdf
final File taxonomy = new File(dest, "taxonomy.tsv");
FileHelper.resourceToFile("com/rtg/reader/resources/taxonomy.tsv", taxonomy);
final File taxonomyLookup = new File(dest, "taxonomy_lookup.tsv");
FileHelper.resourceToFile("com/rtg/reader/resources/taxonomy_lookup.tsv", taxonomyLookup);
}
public void testMissingSample() throws Exception {
try (TestDirectory td = new TestDirectory()) {
final File f =
FileHelper.resourceToGzFile(
"com/rtg/vcf/resources/vcfsubset.vcf", new File(td, "vcf.vcf.gz"));
final File out = new File(td, "out.vcf");
assertEquals(
"Error: Sample fields not contained in VCF header: BL RJ" + StringUtils.LS,
checkMainInitBadFlags(
"-i",
f.getPath(),
"-o",
out.getPath(),
"--keep-sample",
"HG00097",
"--keep-sample",
"HG00099",
"--keep-sample",
"BL",
"--keep-sample",
"RJ",
"-Z"));
}
}
public void testTaxonomySDF() throws IOException {
try (final TestDirectory dir = new TestDirectory("sdfstats")) {
// One without tax
final File smallSdf = ReaderTestUtils.getDNADir(dir);
final String err =
checkMainInitBadFlags("-i", smallSdf.getPath(), "-o", "-", "--taxons", "41431");
TestUtils.containsAll(err, "does not contain taxonomy");
// One with tax
final File fullSdf = new File(dir, "sdf_full");
final File faOut = new File(dir, "ex.fasta.gz");
makeTestTaxonSdf(fullSdf);
checkMainInitOk("-i", fullSdf.getPath(), "-o", faOut.getPath(), "--taxons", "41431");
final String faout = FileHelper.gzFileToString(faOut);
TestUtils.containsAll(
faout,
"gi|218169684|gb|CP001289.1|",
"gi|218165370|gb|CP001287.1|",
"gi|218169729|gb|CP001290.1|",
"gi|218169631|gb|CP001288.1|");
}
}
public void testInputAsFile() throws IOException {
final File que = File.createTempFile("p2f", "flag");
final String err = checkMainInitBadFlags("-o", "testFile", "-i", que.getPath());
assertTrue(
err.contains("Error: The specified file, \"" + que.getPath() + "\", is not an SDF."));
assertTrue(FileHelper.deleteAll(que));
}
public void testFullName() throws IOException {
try (TestDirectory dir = new TestDirectory("sdf2fasta")) {
final File sdf = ReaderTestUtils.getDNADir(FULL_NAME_DATA, new File(dir, "sdf"));
final File fasta = new File(dir, "fs.fasta.gz");
checkMainInitOk("-i", sdf.getPath(), "-o", fasta.getPath());
assertEquals(FULL_NAME_DATA, FileHelper.gzFileToString(fasta));
}
}
public void testToString() throws InvalidParamsException, IOException {
final AbstractKappa kappa;
kappa = getKappa();
// System.out.println(kappa.toString());
final String exp =
FileHelper.resourceToString("com/rtg/variant/bayes/complex/resources/kappamemotest0.txt");
assertTrue(TestUtils.sameLines(exp, kappa.toString(), false));
}
@Override
public void testEquals() throws IOException {
final File dir = FileHelper.createTempDirectory(mDir);
final File otherDir = FileHelper.createTempDirectory(mDir);
ReaderTestUtils.getReaderDNAFastq("", dir, false).close();
ReaderTestUtils.getReaderDNAFastq("", otherDir, false).close();
final CompressedMemorySequencesReader cmsr =
new CompressedMemorySequencesReader(
dir, new IndexFile(dir), 5, true, false, new LongRange(0, 0));
final CompressedMemorySequencesReader other =
new CompressedMemorySequencesReader(
otherDir, new IndexFile(dir), 5, true, false, new LongRange(0, 0));
assertTrue(cmsr.equals(cmsr));
assertFalse(cmsr.equals(null));
assertFalse(cmsr.equals(other));
assertFalse(cmsr.equals("FDSA"));
}
public void testFencePost() throws IOException {
final File dir = FileUtils.createTempDir("cmsrt", "fencepost");
try {
randomSDF(dir, 256, 8200, 2L * 1024 * 1024);
final CompressedMemorySequencesReader reader =
(CompressedMemorySequencesReader)
CompressedMemorySequencesReader.createSequencesReader(
dir, true, false, LongRange.NONE);
assertTrue(reader.checkChecksums());
} finally {
assertTrue(FileHelper.deleteAll(dir));
}
}
public void testKeepSamples() throws Exception {
try (TestDirectory td = new TestDirectory()) {
final File f =
FileHelper.resourceToGzFile(
"com/rtg/vcf/resources/vcfsubset.vcf", new File(td, "vcf.vcf.gz"));
final File out = new File(td, "out.vcf");
checkMainInitOk(
"-i",
f.getPath(),
"-o",
out.getPath(),
"--keep-sample",
"HG00096",
"--keep-sample",
"HG00100",
"-Z");
final String content = FileHelper.fileToString(out);
final String editedContent =
StringUtils.grepMinusV(StringUtils.grepMinusV(content, "^##RUN-ID"), "^##CL");
mNano.check("vcfsubset-keepsamples.vcf", editedContent);
}
}
public void testValidUse() throws Exception {
try (TestDirectory dir = new TestDirectory("sdf2fasta")) {
createPreread(">x" + StringUtils.LS + "actgn" + StringUtils.LS, dir);
final String pathpr = dir.getPath();
try {
runCommandWithNamedOutput(JUNITOUT, pathpr, "ACTGN");
runCommandWithNamedOutput(JUNITOUT + ".FA", pathpr, "ACTGN");
runCommandWithNamedOutput(JUNITOUT + ".fasta", pathpr, "ACTGN");
runCommandLineLength2(pathpr);
} finally {
FileHelper.deleteAll(dir);
}
createPrereadProtein(dir);
runCommandWithNamedOutput(JUNITOUT, pathpr, "X*ARNDCQEGHILKMFPSTWYV");
}
}
/**
* Read the contents of a zip file and turn it into a string
*
* @param file to be read
* @return contents of file
* @throws java.io.IOException if an IO error occurs
*/
public static String zipFileToString(final File file) throws IOException {
try (Reader reader =
new InputStreamReader(GzipUtils.createGzipInputStream(new FileInputStream(file)))) {
return FileHelper.readerToString(reader);
}
}
@Override
public void tearDown() {
assertTrue(FileHelper.deleteAll(mDir));
mDir = null;
}
public void testValidation() throws Exception {
try (TestDirectory main = new TestDirectory()) {
final File in =
FileHelper.resourceToGzFile(
"com/rtg/vcf/resources/vcfsubset.vcf", new File(main, "vcf.vcf.gz"));
final File foo = new File(main, "foo");
final File out = new File(main, "out.vcf.gz");
final File out2 = new File(main, "out.vcf");
String err = checkHandleFlagsErr("-i", foo.getPath(), "-o", out.getPath());
TestUtils.containsAll(TestUtils.unwrap(err), "Given file ", " does not exist.");
err = checkHandleFlagsErr("-i", main.getPath(), "-o", out.getPath());
TestUtils.containsAll(TestUtils.unwrap(err), main.getPath() + "\" is a directory");
assertTrue(out.createNewFile());
err = checkHandleFlagsErr("-i", in.getPath(), "-o", new File(main, "out.vcf").getPath());
TestUtils.containsAll(
TestUtils.unwrap(err), "The file \"" + out.getPath() + "\" already exists");
assertTrue(out2.createNewFile());
err = checkHandleFlagsErr("-i", in.getPath(), "-o", out2.getPath(), "--no-gzip");
TestUtils.containsAll(
TestUtils.unwrap(err), "The file \"" + out2.getPath() + "\" already exists");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-infos",
"--remove-info",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-infos, --remove-info, or --keep-info can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-infos",
"--keep-info",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-infos, --remove-info, or --keep-info can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-info",
"feh",
"--keep-info",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-infos, --remove-info, or --keep-info can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-filters",
"--remove-filter",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-filters, --remove-filter, or --keep-filter can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-filters",
"--keep-filter",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-filters, --remove-filter, or --keep-filter can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-filter",
"feh",
"--keep-filter",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-filters, --remove-filter, or --keep-filter can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-samples",
"--remove-sample",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-samples, --remove-sample, or --keep-sample can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-samples",
"--keep-sample",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-samples, --remove-sample, or --keep-sample can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-sample",
"feh",
"--keep-sample",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err),
"Only one of --remove-samples, --remove-sample, or --keep-sample can be set");
err =
checkHandleFlagsErr(
"-i",
in.getPath(),
"-o",
new File(main, "newout.gz").getPath(),
"--remove-format",
"feh",
"--keep-format",
"blah");
TestUtils.containsAll(
TestUtils.unwrap(err), "Only one of --remove-format or --keep-format can be set");
}
}
@Override
public void setUp() throws IOException {
Diagnostic.setLogStream();
mDir = FileHelper.createTempDirectory();
}
/**
* Convenience method for turning a resource into a file that can be used as input.
*
* @param resource name (classpath) of the resource.
* @param file a <code>File</code> to write to
* @return a <code>File</code> containing the string content (same as <code>file</code>).
* @throws IOException if an error occurs
*/
public static File resourceToFile(final String resource, final File file) throws IOException {
try (InputStream stream = Resources.getResourceAsStream(resource)) {
return FileHelper.streamToFile(stream, file);
}
}
public void testFilterUnmated() throws IOException {
final ByteArrayOutputStream log = new ByteArrayOutputStream();
try (PrintStream prLog = new PrintStream(log)) {
Diagnostic.setLogStream(prLog);
final int numReads = 100;
final MapQScoringReadBlocker blocker = new MapQScoringReadBlocker(numReads, 2);
blocker.increment(1, 3);
blocker.increment(20, 4);
blocker.increment(20, 4);
blocker.increment(20, 4); // read 20 is blocked for score=4
blocker.increment(3, 1);
blocker.increment(3, 1);
blocker.increment(3, 1); // read 3 is blocked for score=1
blocker.increment(3, 0);
blocker.increment(3, 0); // read 3 is just not blocked for score=0
final File dir = FileUtils.createTempDir("test", "unmatedSamFilter");
OutputStream out = null;
try {
final File in1 = File.createTempFile("sam", "_1.gz", dir);
writeTempFile(in1);
final File outFile = File.createTempFile("out", ".gz", dir);
out = new GZIPOutputStream(new FileOutputStream(outFile));
final StatusListener listener = new StatusListener(numReads);
final ReadBlocker freqBlocker = new ReadBlocker(numReads, 2);
freqBlocker.increment(66);
freqBlocker.increment(66);
final MockSequencesReader msr =
new MockSequencesReader(SequenceType.DNA) {
@Override
public PrereadType getPrereadType() {
return PrereadType.UNKNOWN;
}
@Override
public boolean hasQualityData() {
return true;
}
@Override
public int read(long sequenceIndex, byte[] dataOut) {
dataOut[0] = 1;
if (sequenceIndex == 3) {
dataOut[1] = 3;
dataOut[2] = 3;
} else {
dataOut[1] = 3;
dataOut[2] = 2;
}
dataOut[3] = 4;
return 4;
}
@Override
public int readQuality(final long sequenceIndex, final byte[] dest) {
dest[0] = dest[1] = dest[2] = dest[3] = '<' - 33;
return 4;
}
};
final SingleEndSamResultsFilter filter =
new SingleEndSamResultsFilter(blocker, freqBlocker, listener, 0, msr, null, false);
assertEquals("Alignment", filter.getName());
filter.filterConcat(makeHeader(), out, null, null, mTemplateReader, false, in1);
out.close();
final String contents = FileHelper.gzFileToString(outFile);
// System.out.println("contents=" + contents);
assertTrue(
TestUtils.sameLines(SAM_UNMATED_EXPECTED, TestUtils.stripSAMHeader(contents), false));
// now check that the listener has been updated correctly.
for (int read = 0; read < numReads; read++) {
final int expect;
switch (read) {
case 1:
case 3:
expect = ReadStatusTracker.UNMATED_FIRST;
break;
default:
expect = 0;
break;
}
assertEquals("readId=" + read, expect, listener.getStatus(read));
}
} finally {
if (out != null) {
out.close();
}
assertTrue(FileHelper.deleteAll(dir));
}
} finally {
Diagnostic.setLogStream();
}
final String logString = log.toString();
// System.err.println(logString);
TestUtils.containsAll(logString, "Alignment SAM filter outputs 2/5 records");
}
public void testValidator() throws IOException {
Diagnostic.setLogStream();
final MemoryPrintStream err = new MemoryPrintStream();
final CliDiagnosticListener listener = new CliDiagnosticListener(err.printStream());
Diagnostic.addListener(listener);
final File tempDir = FileHelper.createTempDirectory();
try {
final CFlags flags =
new CFlags("PhyloTest", TestUtils.getNullPrintStream(), err.printStream());
SimilarityCli.initFlags(flags);
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", "ba", "-i", "humbug"},
err,
"Only set one of --input or --input-list-file");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-i", "humbug"},
err,
"The specified SDF, \"humbug\", does not exist.");
final File fakePaired = new File(tempDir, "fakePaired");
assertTrue(fakePaired.mkdir());
final File left = new File(fakePaired, "left");
assertTrue(left.mkdir());
assertTrue(new File(fakePaired, "right").mkdir());
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-i", fakePaired.getPath()},
err,
"The specified SDF, \"" + fakePaired.getPath() + "\", is a paired end SDF.");
checkErrorMessage(
flags, new String[] {"-o", "blah"}, err, "Must set one of --input or --input-list-file");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", "ba"},
err,
"The specified list file, \"ba\", does not exist.");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", fakePaired.getPath()},
err,
"The specified list file,",
"\"" + fakePaired.getPath() + "\",",
"directory.");
final File fakeList = new File(tempDir, "fakeList.txt");
assertTrue(fakeList.createNewFile());
checkErrorMessage(
flags,
new String[] {"-o", fakePaired.getPath(), "-I", fakeList.getPath()},
err,
"The directory",
"\"" + fakePaired.getPath() + "\"",
"already exists.");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", fakeList.getPath(), "-w", "-1"},
err,
"The specified flag \"--word\" has invalid value \"-1\". It should be greater than or equal to \"1\".");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", fakeList.getPath(), "-w", "0"},
err,
"The specified flag \"--word\" has invalid value \"0\". It should be greater than or equal to \"1\".");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", fakeList.getPath(), "-w", "33"},
err,
"The specified flag \"--word\" has invalid value \"33\". It should be less than or equal to \"32\".");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", fakeList.getPath(), "--max-reads", "0"},
err,
"The --max-reads must be greater than 0");
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-I", fakeList.getPath(), "-w", "20", "-s", "20"},
err);
checkErrorMessage(
flags,
new String[] {"-o", "blah", "-i", left.getPath(), "--max-reads", "1"},
err,
"Only set --max-reads when using --input-list-file");
checkErrorMessage(flags, new String[] {"-o", "blah", "-i", left.getPath()}, err);
} finally {
Diagnostic.removeListener(listener);
err.close();
assertTrue(FileHelper.deleteAll(tempDir));
}
}
