Пример #1
0
 def test_numberOfPairs(self):
     """ --numberOfPairs options should produce expected and known output for given inputs
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('numberOfPairs'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = []
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--numberOfPairs=%s' % knownValuesNumberOfPairs[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passedTT = totalTrue == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalTrue')
         passedTF = totalFalse == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalFalse')
         if not (passedTT and passedTF):
             print 'knownValues Test failed on test %d' % i
         self.assertTrue(passedTT and passedTF)
     mtt.removeDir(tmpDir)
Пример #2
0
 def test_memory_3(self):
     """ mafComparator should be memory clean for known values using --near option
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()        
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_3'))
     for maf1, maf2, near, totalTrue, totalFalse in knownValuesNear:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--near=%d' % near, 
                 '--samples=1000', '--logLevel=critical',
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #3
0
 def test_memoryTest_4(self):
     """ --wigglePairs options should be memory clean
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_4'))
     for maf1, maf2, ref, partner, binlen, valuesDictList in knownValuesWiggles:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--wigglePairs=%s:%s' % (ref, partner),
                 '--wiggleBinLength=%d' % binlen,
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
 def testMemory1(self):
     """ If valgrind is installed on the system, check for memory related errors (1).
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     for i in xrange(0, 10):
         shuffledBlocks = []
         expectedOutput = []
         tmpDir = os.path.abspath(mtt.makeTempDir())
         order = [1] * len(g_duplicateBlocks) + [0] * len(g_nonDuplicateBlocks)
         random.shuffle(order)
         random.shuffle(g_duplicateBlocks)
         random.shuffle(g_nonDuplicateBlocks)
         j, k = 0, 0
         for dupBlock in order:
             if dupBlock:
                 shuffledBlocks.append(g_duplicateBlocks[j][0])
                 expectedOutput.append(g_duplicateBlocks[j][1])
                 j += 1
             else:
                 shuffledBlocks.append(g_nonDuplicateBlocks[k])
                 expectedOutput.append(g_nonDuplicateBlocks[k])
                 k += 1
         testMaf = mtt.testFile(os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf')),
                                ''.join(shuffledBlocks), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [valgrind, '--leak-check=full', '--show-reachable=yes', '--track-origins=yes', '--xml=yes', 
                '--xml-file=' + os.path.join(tmpDir, 'valgrind.xml')]
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafBlockDuplicateFilter')), 
                '--maf', os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf'))]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'filtered.maf'))]
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         mtt.removeTempDir()
Пример #5
0
 def test_memory_0(self):
     """ mafComparator should be memory clean for bed parsing examples
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_0'))
     for maf1, maf2, bed, totalTrue, totalTrueInInterval in knownValuesBed:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         testBed = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'bed.bed')), 
                                bed, [''])
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 ]
         if bed != '':
             cmd += ['--bedFiles', os.path.abspath(os.path.join(tmpDir, 'bed.bed'))]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #6
0
 def testFastaStitch(self):
     """ mafToFastaStitcher should produce known output for a given known input
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('fasta'))
     customOpts = mafval.GenericValidationOptions()
     for reference, inMaf, inFaList, outFa, outMaf  in g_knownData:
         testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test.maf')),
                                ''.join(inMaf), g_headers)
         testFaNames = testFasta(os.path.abspath(tmpDir), inFaList)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = []
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafToFastaStitcher')), 
                 '--maf', os.path.abspath(os.path.join(tmpDir, 'test.maf')),
                 '--seqs', testFaNames,
                 '--breakpointPenalty', '6', '--interstitialSequence', '20',
                 '--outMfa', os.path.abspath(os.path.join(tmpDir, 'out.fa')),
                 '--outMaf', os.path.abspath(os.path.join(tmpDir, 'out.maf')),]
         if reference is not None:
             cmd += ['--reference', reference]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         self.assertTrue(fastaIsCorrect(os.path.abspath(os.path.join(tmpDir, 'out.fa')), outFa))
         self.assertTrue(mafIsCorrect(os.path.abspath(os.path.join(tmpDir, 'out.maf')), outMaf))
         self.assertTrue(mafval.validateMaf(os.path.join(tmpDir, 'out.maf'), customOpts))
     mtt.removeDir(tmpDir)
 def testFilter(self):
     """ mafDuplicateFilter should filter out duplicates in blocks according to sequence similarity to the consensus.
     """
     mtt.makeTempDirParent()
     for i in xrange(0, 10):
         shuffledBlocks = []
         expectedOutput = []
         tmpDir = os.path.abspath(mtt.makeTempDir('filter'))
         order = [1] * len(g_duplicateBlocks) + [0] * len(g_nonDuplicateBlocks)
         random.shuffle(order)
         random.shuffle(g_duplicateBlocks)
         random.shuffle(g_nonDuplicateBlocks)
         j, k = 0, 0
         for dupBlock in order:
             if dupBlock:
                 shuffledBlocks.append(g_duplicateBlocks[j][0])
                 expectedOutput.append(g_duplicateBlocks[j][1])
                 j += 1
             else:
                 shuffledBlocks.append(g_nonDuplicateBlocks[k])
                 expectedOutput.append(g_nonDuplicateBlocks[k])
                 k += 1
         testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test.maf')),
                                ''.join(shuffledBlocks), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafDuplicateFilter')), 
                '--maf', os.path.abspath(os.path.join(tmpDir, 'test.maf'))]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'filtered.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mafIsFiltered(os.path.join(tmpDir, 'filtered.maf'), expectedOutput))
         mtt.removeDir(tmpDir)
Пример #8
0
 def testCoverage_0(self):
     """ mafCoverage should output numbers that accurately reflect the coverage between sequences.
 """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('testCoverage_0'))
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     customOpts = mafval.GenericValidationOptions()
     for target, mafSeq, solutionDict in g_knownGood:
         testMaf = mtt.testFile(
             os.path.join(os.path.abspath(tmpDir), 'test.maf'), mafSeq,
             g_headers)
         cmd = [
             os.path.abspath(os.path.join(parent, 'test', 'mafCoverage'))
         ]
         cmd += [
             '--maf',
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), '--species',
             target
         ]
         outpipes = [os.path.join(tmpDir, 'output.txt')]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(
             mafval.validateMaf(os.path.join(tmpDir, 'test.maf'),
                                customOpts))
         self.assertTrue(
             coverageIsCorrect(os.path.join(tmpDir, 'output.txt'),
                               solutionDict))
     mtt.removeDir(tmpDir)
Пример #9
0
 def testMemory0(self):
     """ If valgrind is installed on the system, check for memory related errors (0).
 """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_0'))
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     customOpts = mafval.GenericValidationOptions()
     for target, mafSeq, solutionDict in g_knownGood:
         testMaf = mtt.testFile(
             os.path.join(os.path.abspath(tmpDir), 'test.maf'), mafSeq,
             g_headers)
         cmd = mtt.genericValgrind(tmpDir)
         cmd.append(
             os.path.abspath(os.path.join(parent, 'test', 'mafCoverage')))
         cmd += [
             '--maf',
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), '--species',
             target
         ]
         outpipes = [os.path.join('/dev', 'null')]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(
             mafval.validateMaf(os.path.join(tmpDir, 'test.maf'),
                                customOpts))
         self.assertTrue(
             mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
     mtt.removeDir(tmpDir)
Пример #10
0
 def testExtraction(self):
     """ mafBlockExtractor should output blocks that meet the criteria for extraction. That is they contain the taget sequence and have at least one base in the target range.
     """
     for i in xrange(0, 10):
         shuffledBlocks = []
         tmpDir = os.path.abspath(mtt.makeTempDir())
         order = [1] * len(g_overlappingBlocks) + [0] * len(g_nonOverlappingBlocks)
         random.shuffle(order)
         random.shuffle(g_overlappingBlocks)
         random.shuffle(g_nonOverlappingBlocks)
         j, k = 0, 0
         for isOverlapping in order:
             if isOverlapping:
                 shuffledBlocks.append(g_overlappingBlocks[j])
                 j += 1
             else:
                 shuffledBlocks.append(g_nonOverlappingBlocks[k])
                 k += 1
         testMaf = mtt.testFile(os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf')),
                                ''.join(shuffledBlocks), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafBlockExtractor'))]
         cmd += ['--maf', os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf')),
                 '--seq', g_targetSeq, '--start', '%d' % g_targetRange[0], 
                 '--stop', '%d' % g_targetRange[1]]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'extracted.maf'))]
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mafIsExtracted(os.path.join(tmpDir, 'extracted.maf')))
         mtt.removeTempDir()
Пример #11
0
 def testMemory1(self):
     """ If valgrind is installed on the system, check for memory related errors (1).
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     for i in xrange(0, 10):
         shuffledBlocks = []
         tmpDir = os.path.abspath(mtt.makeTempDir())
         order = [1] * len(g_overlappingBlocks) + [0] * len(g_nonOverlappingBlocks)
         random.shuffle(order)
         random.shuffle(g_overlappingBlocks)
         random.shuffle(g_nonOverlappingBlocks)
         j, k = 0, 0
         for isOverlapping in order:
             if isOverlapping:
                 shuffledBlocks.append(g_overlappingBlocks[j])
                 j += 1
             else:
                 shuffledBlocks.append(g_nonOverlappingBlocks[k])
                 k += 1
         testMaf = mtt.testFile(os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf')),
                                ''.join(shuffledBlocks), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [valgrind, '--leak-check=full', '--show-reachable=yes', '--track-origins=yes', '--xml=yes', 
                '--xml-file=' + os.path.join(tmpDir, 'valgrind.xml')]
         cmd.append(os.path.abspath(os.path.join(parent, 'test', 'mafBlockExtractor')))
         cmd += ['--maf', os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf')),
                 '--seq', g_targetSeq, '--start', '%d' % g_targetRange[0], 
                 '--stop', '%d' % g_targetRange[1]]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'extracted.maf'))]
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         mtt.removeTempDir()
Пример #12
0
 def dtestMemory2(self):
     """ If valgrind is installed on the system, check for memory related errors (2).
     """
     valgrind = mtt.which("valgrind")
     if valgrind is None:
         return
     global g_header
     for i in xrange(0, len(g_nonOverlappingBlocks)):
         tmpDir = os.path.abspath(mtt.makeTempDir())
         testMafPath, g_header = mtt.testFile(
             os.path.abspath(os.path.join(os.curdir, "tempTestDir", "test.maf")),
             "".join(g_nonOverlappingBlocks[i][0]),
             g_headers,
         )
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [
             valgrind,
             "--leak-check=full",
             "show-reachable=yes",
             "--track-origins=yes",
             "--xml=yes",
             "--xml-file=" + os.path.join(tmpDir, "valgrind.xml"),
         ]
         cmd.append(os.path.abspath(os.path.join(parent, "test", "mafBlockFinder")))
         cmd += ["--maf", testMafPath, "--seq", g_targetSeq, "--pos", "%d" % g_nonOverlappingBlocks[i][1]]
         outpipes = [os.path.abspath(os.path.join(tmpDir, "found.txt"))]
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, "valgrind.xml")))
         mtt.removeTempDir()
Пример #13
0
 def testMemory2(self):
     """ If valgrind is installed on the system, check for memory related errors (2).
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     i = -1
     for inblocks, seq, start, stop, outblocks in self.testSet:
         i += 1
         tmpDir = os.path.abspath(mtt.makeTempDir('memory_2'))
         random.shuffle(g_nonOverlappingBlocks)
         testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                                ''.join(map(str, inblocks)), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd.append(os.path.abspath(os.path.join(parent, 'test', 'mafExtractor')))
         cmd += ['--maf', os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                 '--seq', seq, '--start', '%d' % start, 
                 '--stop', '%d' % stop,
                 ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'extracted.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         mtt.removeDir(tmpDir)
Пример #14
0
 def testHardExtraction_0(self):
     """ mafExtractor should output trimmed blocks by default.
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     customOpts = mafval.GenericValidationOptions()
     i = -1
     for inblocks, seq, start, stop, outblocks in self.testSet:
         i += 1
         tmpDir = os.path.abspath(mtt.makeTempDir('hardextraction_0'))
         testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                                ''.join(map(str, inblocks)), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafExtractor'))]
         cmd += ['--maf', os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                 '--seq', seq, '--start', '%d' % start, 
                 '--stop', '%d' % stop,
                 ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'extracted.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mafIsHardExtracted('hardextraction_0_%d' % i, outblocks, 
                                            os.path.join(tmpDir, 'extracted.maf')))
         self.assertTrue(mafval.validateMaf(os.path.join(tmpDir, 'extracted.maf'), customOpts))
         mtt.removeDir(tmpDir)
Пример #15
0
 def test_memoryTest_6(self):
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_6'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--numberOfPairs=%s' % knownValuesNumberOfPairs[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #16
0
 def testFind(self):
     """ mafPositionFinder should report information about matching sequences within blocks.
     """
     global g_header
     mtt.makeTempDirParent()
     for i in xrange(0, len(g_overlappingBlocks)):
         tmpDir = os.path.abspath(mtt.makeTempDir('find'))
         testMafPath, g_header = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')),
             g_overlappingBlocks[i][0], g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = [
             os.path.abspath(
                 os.path.join(parent, 'test', 'mafPositionFinder'))
         ]
         cmd += [
             '--maf', testMafPath, '--seq', g_targetSeq, '--pos',
             '%d' % g_overlappingBlocks[i][1]
         ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'found.txt'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(
             foundLines(g_overlappingBlocks[i][2],
                        os.path.join(tmpDir, 'found.txt'), g_header))
         mtt.removeDir(tmpDir)
Пример #17
0
 def test_bedParsing(self):
     """ mafComparator should parse a bed file and use the intervals for testing
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('bedParsing'))
     for maf1, maf2, bed, totalTrue, totalTrueInInterval in knownValuesBed:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         testBed = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'bed.bed')), 
                                bed, [''])
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                '--samples=1000', '--logLevel=critical',
                ]
         if bed != '':
             cmd += ['--bedFiles', os.path.abspath(os.path.join(tmpDir, 'bed.bed'))]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = xmlBedRegionPassed(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 
                                     totalTrue, totalTrueInInterval)
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #18
0
 def testNonFind(self):
     """ mafPositionFinder should not report any lines when blocks do not match.
     """
     global g_header
     mtt.makeTempDirParent()
     for i in xrange(0, len(g_nonOverlappingBlocks)):
         tmpDir = os.path.abspath(mtt.makeTempDir('nonFind'))
         testMafPath, g_header = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')),
             ''.join(g_nonOverlappingBlocks[i][0]), g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = [
             os.path.abspath(
                 os.path.join(parent, 'test', 'mafPositionFinder'))
         ]
         cmd += [
             '--maf', testMafPath, '--seq', g_targetSeq, '--pos',
             '%d' % g_nonOverlappingBlocks[i][1]
         ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'found.txt'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mtt.fileIsEmpty(os.path.join(tmpDir, 'found.txt')))
         mtt.removeDir(tmpDir)
Пример #19
0
 def testorder(self):
     """ mafRowOrderer should order blocks according to user input
     """
     global g_header
     mtt.makeTempDirParent()
     customOpts = mafval.GenericValidationOptions()
     for i in xrange(0, len(g_blocks)):
         tmpDir = os.path.abspath(mtt.makeTempDir('order'))
         testMafPath, g_header = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')),
             g_blocks[i][0], g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = []
         cmd.append(
             os.path.abspath(os.path.join(parent, 'test', 'mafRowOrderer')))
         cmd += ['--maf', testMafPath, '--order', '%s' % g_order]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'ordered.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         ordered = mafIsOrdered(os.path.join(tmpDir, 'ordered.maf'),
                                g_blocks[i][1], g_header)
         self.assertTrue(
             mafval.validateMaf(os.path.join(tmpDir, 'ordered.maf'),
                                customOpts))
         self.assertTrue(ordered)
         if ordered:
             mtt.removeDir(tmpDir)
Пример #20
0
 def testMemory2(self):
     """ If valgrind is installed on the system, check for memory related errors (2).
     """
     mtt.makeTempDirParent()
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     global g_header
     for i in xrange(0, len(g_nonOverlappingBlocks)):
         tmpDir = os.path.abspath(mtt.makeTempDir('memory2'))
         testMafPath, g_header = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')),
             ''.join(g_nonOverlappingBlocks[i][0]), g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd.append(
             os.path.abspath(
                 os.path.join(parent, 'test', 'mafPositionFinder')))
         cmd += [
             '--maf', testMafPath, '--seq', g_targetSeq, '--pos',
             '%d' % g_nonOverlappingBlocks[i][1]
         ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'found.txt'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(
             mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         mtt.removeDir(tmpDir)
Пример #21
0
 def testMemory1(self):
     """ If valgrind is installed on the system, check for memory related errors (1).
     """
     mtt.makeTempDirParent()
     valgrind = mtt.which("valgrind")
     if valgrind is None:
         return
     shuffledTargets = list(g_targetBlocks)
     for i in xrange(0, 20):
         tmpDir = os.path.abspath(mtt.makeTempDir("memory1"))
         random.shuffle(g_nonTargetBlocks)
         random.shuffle(shuffledTargets)
         shuffledBlocks = list(shuffledTargets)
         lower = 0
         for j in xrange(0, len(g_nonTargetBlocks)):
             # randomly insert the non target blocks, but keep a record
             # of their relative order.
             index = random.randint(lower, len(shuffledBlocks))
             shuffledBlocks.insert(index, g_nonTargetBlocks[j])
             lower = index + 1
         testMaf = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, "test.maf")), "".join(shuffledBlocks), g_headers
         )
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd.append(os.path.abspath(os.path.join(parent, "test", "mafSorter")))
         cmd += ["--maf", os.path.abspath(os.path.join(tmpDir, "test.maf")), "--seq", "hg18.chr7"]
         outpipes = [os.path.abspath(os.path.join(tmpDir, "sorted.maf"))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, "valgrind.xml")))
         mtt.removeDir(tmpDir)
Пример #22
0
 def testCoercion(self):
     """ mafStrander should coerce blocks into strandedness based on user input
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('coercion'))
     customOpts = mafval.GenericValidationOptions()
     for a, expected, strand in g_blocks:
         testMaf = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), ''.join(a),
             g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = [
             os.path.abspath(os.path.join(parent, 'test',
                                          'mafStrander')), '--maf',
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), '--seq',
             'target.chr0', '--strand', strand
         ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'coerced.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(
             mafIsCoerced(os.path.join(tmpDir, 'coerced.maf'), expected))
         self.assertTrue(
             mafval.validateMaf(os.path.join(tmpDir, 'coerced.maf'),
                                customOpts))
     mtt.removeDir(tmpDir)
Пример #23
0
 def test_bedParsing(self):
     """ mafComparator should parse a bed file and use the intervals for testing
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('bedParsing'))
     for maf1, maf2, bed, totalTrue, totalTrueInInterval in knownValuesBed:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         testBed = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'bed.bed')), 
                                bed, [''])
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                '--samples=1000', '--logLevel=critical',
                ]
         if bed != '':
             cmd += ['--bedFiles', os.path.abspath(os.path.join(tmpDir, 'bed.bed'))]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = xmlBedRegionPassed(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 
                                     totalTrue, totalTrueInInterval)
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #24
0
 def testMemory1(self):
     """ If valgrind is installed on the system, check for memory related errors (1).
     """
     mtt.makeTempDirParent()
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     tmpDir = os.path.abspath(mtt.makeTempDir('memeory1'))
     customOpts = mafval.GenericValidationOptions()
     for a, expected, strand in g_blocks:
         testMaf = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), ''.join(a),
             g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [
             os.path.abspath(os.path.join(parent, 'test',
                                          'mafStrander')), '--maf',
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), '--seq',
             'target', '--strand', strand
         ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'coerced.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(
             mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         self.assertTrue(
             mafval.validateMaf(os.path.join(tmpDir, 'coerced.maf'),
                                customOpts))
     mtt.removeDir(tmpDir)
Пример #25
0
 def test_memory_1(self):
     """ mafComparator should be memory clean for seed testing examples
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_1'))
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     for maf1, maf2  in knownValuesSeed:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.join(tmpDir, 'output.xml'),
                 '--samples=10', '--logLevel=critical']
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         for i in xrange(0, 4):
             mtt.recordCommands([cmd], tmpDir)
             mtt.runCommandsS([cmd], tmpDir)
             self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
     mtt.removeDir(tmpDir)
Пример #26
0
 def test_memory_1(self):
     """ mafComparator should be memory clean for seed testing examples
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_1'))
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     for maf1, maf2  in knownValuesSeed:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.join(tmpDir, 'output.xml'),
                 '--samples=10', '--logLevel=critical']
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         for i in xrange(0, 4):
             mtt.recordCommands([cmd], tmpDir)
             mtt.runCommandsS([cmd], tmpDir)
             self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
     mtt.removeDir(tmpDir)
Пример #27
0
    def testNonExtraction1(self):
        """ mafExtractor should not extract blocks when they do not match.
        """
        customOpts = mafval.GenericValidationOptions()
        mtt.makeTempDirParent()
        tmpDir = os.path.abspath(mtt.makeTempDir('nonExtraction_1'))
        block = '''a degree=4
s simChimp.chrA     15393341 348 + 53121445 ATATTGAGGAGCAGGATGGGTATAGAGGCCCTGACCCATTAATGTGTAAGCACTAGGCAGCTGGGAGATACCCCAGAGGGCGGGGTCACTGAATTCACTGGCCCACCACTGTAAATACATTCTAACCAGTGGGTTTAGGGCTCTGTGCATTAGAACCACTCTGAAGAAGTGTAACACACCACCTAGTGAGCTGCCGGGCCGCCAGCAACTTCTTTTTCCCACATGACCCATGCAAGCCCGTGATTTCTCCCTGGTACATGATATTTGGGATTCCAGGGACCTAATGGAGCATGCTATTCCTGTGTTAGTTATCACTTCGAAGGGGGTGCAAGAGTGTAAGTAATGGGT
s simGorilla.chrA   15595743 348 + 53120926 ATATTGAGGAGCAGGATGGGTATAGAAGCCCTGACCCATTAATGTGTAAGCACTAGGCAGCTGGGAGATACTCCAGAGGGAGGGGTCACTGAATTCACTGGCCCACCACTGTAAATACATTCTAACCAGTGGGTTTAGGGCTCGGTGCATTAGAACCACCCTGAAGAAGTGTAACGCACCACCTAGTGAGCTGCCGGGCCGCCAGCAACTTCTTTTTCCCACATGACCCATGCATGCCCGTGATTTCTCCCTGGTACATGGTTTTTGGGATTCCAGGGACCTAATGGAGCATACTATTCCTGTGTTAGTTATCACTTCGAAGGGGGTGCGAGAGTGTAAGTAATGGGT
s simHuman.chrA     36713600 348 - 53106993 ATATTGAGGAGCAGGATGGGTATAGAAGCCCTGACCTATTAATGTGTAAGCACTAGGCAGCTGGGCGATACCCCAGAGGGAGGGGTCACTGAATTCACTGGCCCACCACTGTAAATACATTCTAACCAGTGGGTTTAGGGCTCTGTGCATTAGAACCACCCTGAAGAAGAGTAACGCACCACCTAGTGAGCTGCCGGGCCGCCAGCAAGTTCTTTTTCCCACATGACCCATGCAAGCCCGTGATTTCTCCCTGGTACATGATATTTGGGATTCCAGGGACCTAATGGAGCATGCTATTCCTGTGTTAGTTATCACTTCGAAGGGGGTGCAAGAGTGTAAGTAATGGGT
s simOrang.chrE       126390 348 + 37692687 ATTTTGAGGAGCAGGATGGGTATAGAAGCCCTGACCCATTAATGTGTGAGCTCTAGGCAGCTTGGAGATACTGCAGAGGGAGGGGTCACTGAATTCACTGGCCCACCACTGTAAATACATACTAACCGGTGGGTTTAGGGCTCTGTGCATTAGAACCACCCTGAGGAAGTGTAACGCACCACCTAGTGAGCTGCCGGGCCACCAGCAACTTCTTTTTCCCACATGACCCATGCAAGCCCGTGATTTCTCCCTGGTACATGATCTTTGGGATTCCAGGGACCTAATGGCGGATGCTATTCCTGTGTTAGTTATCACTTCGAAGGGGGCGCAAGAGTGTAAGTAATGGGT
s target.chr0       36713600 348 - 53106993 ATATTGAGGAGCAGGATGGGTATAGAAGCCCTGACCTATTAATGTGTAAGCACTAGGCAGCTGGGCGATACCCCAGAGGGAGGGGTCACTGAATTCACTGGCCCACCACTGTAAATACATTCTAACCAGTGGGTTTAGGGCTCTGTGCATTAGAACCACCCTGAAGAAGAGTAACGCACCACCTAGTGAGCTGCCGGGCCGCCAGCAAGTTCTTTTTCCCACATGACCCATGCAAGCCCGTGATTTCTCCCTGGTACATGATATTTGGGATTCCAGGGACCTAATGGAGCATGCTATTCCTGTGTTAGTTATCACTTCGAAGGGGGTGCAAGAGTGTAAGTAATGGGT

'''
        testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test.maf')),
                               block, g_headers)
        parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafExtractor'))]
        cmd += ['--maf', os.path.abspath(os.path.join(tmpDir, 'test.maf')),
                '--seq', 'simHuman.chrA', '--start', '%d' % 29953315, 
                '--stop', '%d' % 29953315,
                '--soft']
        outpipes = [os.path.abspath(os.path.join(tmpDir, 'extracted.maf'))]
        mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
        mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
        self.assertTrue(mtt.mafIsEmpty(os.path.join(tmpDir, 'extracted.maf'), g_headers))
        self.assertTrue(mafval.validateMaf(os.path.join(tmpDir, 'extracted.maf'), customOpts))
        mtt.removeDir(tmpDir)
Пример #28
0
 def test_memory_3(self):
     """ mafComparator should be memory clean for known values using --near option
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()        
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_3'))
     for maf1, maf2, near, totalTrue, totalFalse in knownValuesNear:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--near=%d' % near, 
                 '--samples=1000', '--logLevel=critical',
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #29
0
 def test_legitSequencesFail(self):
     """ --legitSequences options should fail when sequence length numbers differ from input files
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('legitSequencesFail'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = []
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--legitSequences=%s' % knownValuesLegitFail[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         passed = False
         try:
             # we supress the normal stderr output here for the sake of sparing users confusion
             mtt.runCommandsS([cmd], tmpDir, errPipes=[subprocess.PIPE])
         except RuntimeError:
             passed = True
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #30
0
 def test_validXmlOutput_(self):
     """ xml output file should be valid xml.
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('validateXmlOutput'))
     # test 1
     maf1, maf2, totalTrue, totalFalse = knownValues[0]
     testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                             maf1, g_headers)
     testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                             maf2, g_headers)
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
            '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
            '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
            '--out', os.path.abspath(os.path.join(tmpDir, 'outputVanilla.xml')),
            '--samples=1000', '--logLevel=critical',
            ]
     mtt.recordCommands([cmd], tmpDir)
     mtt.runCommandsS([cmd], tmpDir)
     passed = validXml(os.path.abspath(os.path.join(tmpDir, 'outputVanilla.xml')))
     self.assertTrue(passed)
     self.assertFalse(validXml(os.path.abspath(os.path.join(tmpDir, 'maf1.maf'))))
     # test 2
     maf1, maf2, bed, totalTrue, totalTrueInInterval = knownValuesBed[2]
     testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                             maf1, g_headers)
     testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                             maf2, g_headers)
     testBed = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'bed.bed')), 
                            bed, [''])
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
            '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
            '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
            '--out', os.path.abspath(os.path.join(tmpDir, 'outputBed.xml')),
            '--samples=1000', '--logLevel=critical',
            ]
     cmd += ['--bedFiles', os.path.abspath(os.path.join(tmpDir, 'bed.bed'))]
     mtt.recordCommands([cmd], tmpDir)
     mtt.runCommandsS([cmd], tmpDir)
     passed = validXml(os.path.abspath(os.path.join(tmpDir, 'outputBed.xml')))
     # test 3
     maf1, maf2, totalTrue, totalFalse = knownValues[0]
     testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                             maf1, g_headers)
     testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                             maf2, g_headers)
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
            '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
            '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
            '--out', os.path.abspath(os.path.join(tmpDir, 'outputWiggles.xml')),
            '--samples=1000', '--logLevel=critical', '--wigglePairs=A:B', 'wiggleBinLength=2'
            ]
     mtt.recordCommands([cmd], tmpDir)
     mtt.runCommandsS([cmd], tmpDir)
     passed = validXml(os.path.abspath(os.path.join(tmpDir, 'outputWiggles.xml')))
     self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #31
0
 def test_numberOfPairsFail(self):
     """ --numberOfPairs options should fail for bad input values
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('numberOfPairsFail'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = []
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--numberOfPairs=%s' % knownValuesNumberOfPairsFail[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         passed = False
         try:
             mtt.runCommandsS([cmd], tmpDir, errPipes=[subprocess.PIPE])
         except RuntimeError:
             passed = True
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #32
0
 def test_memoryTest_4(self):
     """ --wigglePairs options should be memory clean
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_4'))
     for maf1, maf2, ref, partner, binlen, valuesDictList in knownValuesWiggles:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--wigglePairs=%s:%s' % (ref, partner),
                 '--wiggleBinLength=%d' % binlen,
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #33
0
 def test_knownValues(self):
     """ mafComparator should return correct results for hand-calculable problems
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('knownValues'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                '--samples=1000', '--logLevel=critical',
                ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passedTT = totalTrue == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalTrue')
         passedTF = totalFalse == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalFalse')
         if not (passedTT and passedTF):
             print 'knownValues Test failed on test %d' % i
         self.assertTrue(passedTT and passedTF)
     mtt.removeDir(tmpDir)
Пример #34
0
 def test_legitSequencesFail(self):
     """ --legitSequences options should fail when sequence length numbers differ from input files
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('legitSequencesFail'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = []
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--legitSequences=%s' % knownValuesLegitFail[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         passed = False
         try:
             # we supress the normal stderr output here for the sake of sparing users confusion
             mtt.runCommandsS([cmd], tmpDir, errPipes=[subprocess.PIPE])
         except RuntimeError:
             passed = True
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #35
0
 def test_memory_0(self):
     """ mafComparator should be memory clean for bed parsing examples
     """
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_0'))
     for maf1, maf2, bed, totalTrue, totalTrueInInterval in knownValuesBed:
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         testBed = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'bed.bed')), 
                                bed, [''])
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 ]
         if bed != '':
             cmd += ['--bedFiles', os.path.abspath(os.path.join(tmpDir, 'bed.bed'))]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #36
0
 def test_numberOfPairs(self):
     """ --numberOfPairs options should produce expected and known output for given inputs
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('numberOfPairs'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = []
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--numberOfPairs=%s' % knownValuesNumberOfPairs[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passedTT = totalTrue == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalTrue')
         passedTF = totalFalse == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalFalse')
         if not (passedTT and passedTF):
             print 'knownValues Test failed on test %d' % i
         self.assertTrue(passedTT and passedTF)
     mtt.removeDir(tmpDir)
Пример #37
0
 def testMemory1(self):
     """ If valgrind is installed on the system, check for memory related errors (1).
     """
     mtt.makeTempDirParent()
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     tmpDir = os.path.abspath(mtt.makeTempDir('memory1'))
     customOpts = mafval.GenericValidationOptions()
     for reference, inMaf, inFaList, outFa, outMaf  in g_knownData:
         testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test.maf')),
                                ''.join(inMaf), g_headers)
         testFaNames = testFasta(os.path.abspath(tmpDir), inFaList)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafToFastaStitcher')), 
                 '--maf', os.path.abspath(os.path.join(tmpDir, 'test.maf')),
                 '--seqs', testFaNames,
                 '--breakpointPenalty', '6', '--interstitialSequence', '20',
                 '--outMfa', os.path.abspath(os.path.join(tmpDir, 'out.fa')),
                 '--outMaf', os.path.abspath(os.path.join(tmpDir, 'out.maf')),]
         if reference is not None:
             cmd += ['--reference', reference]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
     mtt.removeDir(tmpDir)
Пример #38
0
 def test_numberOfPairsFail(self):
     """ --numberOfPairs options should fail for bad input values
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('numberOfPairsFail'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = []
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--numberOfPairs=%s' % knownValuesNumberOfPairsFail[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         passed = False
         try:
             mtt.runCommandsS([cmd], tmpDir, errPipes=[subprocess.PIPE])
         except RuntimeError:
             passed = True
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #39
0
 def testMemory1(self):
     """ If valgrind is installed on the system, check for memory related errors (1).
     """
     mtt.makeTempDirParent()
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     global g_header
     customOpts = mafval.GenericValidationOptions()
     for i in xrange(0, len(g_blocks)):
         tmpDir = os.path.abspath(mtt.makeTempDir('memory1'))
         testMafPath, g_header = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')),
             g_blocks[i][0], g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd.append(
             os.path.abspath(os.path.join(parent, 'test', 'mafRowOrderer')))
         cmd += ['--maf', testMafPath, '--order', '%s' % g_order]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'ordered.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(
             mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
         self.assertTrue(
             mafval.validateMaf(os.path.join(tmpDir, 'ordered.maf'),
                                customOpts))
         mtt.removeDir(tmpDir)
Пример #40
0
 def test_memoryTest_6(self):
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_6'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                 '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                 '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                 '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                 '--samples=1000', '--logLevel=critical',
                 '--numberOfPairs=%s' % knownValuesNumberOfPairs[i],
                 ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #41
0
 def testSorting(self):
     """ Blocks should be sorted by the start field of the target sequence, blocks that do not contain the target sequence should appear in the output at the start of the file, in the same order they appear in the input.
     """
     mtt.makeTempDirParent()
     shuffledTargets = list(g_targetBlocks)
     for i in xrange(0, 200):
         tmpDir = os.path.abspath(mtt.makeTempDir("sorting"))
         random.shuffle(g_nonTargetBlocks)
         random.shuffle(shuffledTargets)
         shuffledBlocks = list(shuffledTargets)
         lower = 0
         for j in xrange(0, len(g_nonTargetBlocks)):
             # randomly insert the non target blocks, but keep a record
             # of their relative order.
             index = random.randint(lower, len(shuffledBlocks))
             shuffledBlocks.insert(index, g_nonTargetBlocks[j])
             lower = index + 1
         testMaf = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, "test.maf")), "".join(shuffledBlocks), g_headers
         )
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, "test", "mafSorter"))]
         cmd += ["--maf", os.path.abspath(os.path.join(tmpDir, "test.maf")), "--seq", "hg18.chr7"]
         outpipes = [os.path.abspath(os.path.join(tmpDir, "sorted.maf"))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mafIsSorted(os.path.join(tmpDir, "sorted.maf")))
         mtt.removeDir(tmpDir)
Пример #42
0
 def test_knownValues(self):
     """ mafComparator should return correct results for hand-calculable problems
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('knownValues'))
     i = -1
     for maf1, maf2, totalTrue, totalFalse in knownValues:
         i += 1
         testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                 maf1, g_headers)
         testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                 maf2, g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
                '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                '--samples=1000', '--logLevel=critical',
                ]
         mtt.recordCommands([cmd], tmpDir)
         mtt.runCommandsS([cmd], tmpDir)
         passedTT = totalTrue == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalTrue')
         passedTF = totalFalse == getAggregateResult(os.path.abspath(os.path.join(tmpDir, 'output.xml')), 'totalFalse')
         if not (passedTT and passedTF):
             print 'knownValues Test failed on test %d' % i
         self.assertTrue(passedTT and passedTF)
     mtt.removeDir(tmpDir)
 def testFilter(self):
     """ mafBlockDuplicateFilter should filter out duplicates in blocks according to sequence similarity to the consensus.
     """
     for i in xrange(0, 10):
         shuffledBlocks = []
         expectedOutput = []
         tmpDir = os.path.abspath(mtt.makeTempDir())
         order = [1] * len(g_duplicateBlocks) + [0] * len(g_nonDuplicateBlocks)
         random.shuffle(order)
         random.shuffle(g_duplicateBlocks)
         random.shuffle(g_nonDuplicateBlocks)
         j, k = 0, 0
         for dupBlock in order:
             if dupBlock:
                 shuffledBlocks.append(g_duplicateBlocks[j][0])
                 expectedOutput.append(g_duplicateBlocks[j][1])
                 j += 1
             else:
                 shuffledBlocks.append(g_nonDuplicateBlocks[k])
                 expectedOutput.append(g_nonDuplicateBlocks[k])
                 k += 1
         testMaf = mtt.testFile(os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf')),
                                ''.join(shuffledBlocks), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafBlockDuplicateFilter')), 
                '--maf', os.path.abspath(os.path.join(os.curdir, 'tempTestDir', 'test.maf'))]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'filtered.maf'))]
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mafIsFiltered(os.path.join(tmpDir, 'filtered.maf'), expectedOutput))
         mtt.removeTempDir()
Пример #44
0
 def test_validXmlOutput_(self):
     """ xml output file should be valid xml.
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('validateXmlOutput'))
     # test 1
     maf1, maf2, totalTrue, totalFalse = knownValues[0]
     testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                             maf1, g_headers)
     testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                             maf2, g_headers)
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
            '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
            '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
            '--out', os.path.abspath(os.path.join(tmpDir, 'outputVanilla.xml')),
            '--samples=1000', '--logLevel=critical',
            ]
     mtt.recordCommands([cmd], tmpDir)
     mtt.runCommandsS([cmd], tmpDir)
     passed = validXml(os.path.abspath(os.path.join(tmpDir, 'outputVanilla.xml')))
     self.assertTrue(passed)
     self.assertFalse(validXml(os.path.abspath(os.path.join(tmpDir, 'maf1.maf'))))
     # test 2
     maf1, maf2, bed, totalTrue, totalTrueInInterval = knownValuesBed[2]
     testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                             maf1, g_headers)
     testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                             maf2, g_headers)
     testBed = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'bed.bed')), 
                            bed, [''])
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
            '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
            '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
            '--out', os.path.abspath(os.path.join(tmpDir, 'outputBed.xml')),
            '--samples=1000', '--logLevel=critical',
            ]
     cmd += ['--bedFiles', os.path.abspath(os.path.join(tmpDir, 'bed.bed'))]
     mtt.recordCommands([cmd], tmpDir)
     mtt.runCommandsS([cmd], tmpDir)
     passed = validXml(os.path.abspath(os.path.join(tmpDir, 'outputBed.xml')))
     # test 3
     maf1, maf2, totalTrue, totalFalse = knownValues[0]
     testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                             maf1, g_headers)
     testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                             maf2, g_headers)
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafComparator')),
            '--maf1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
            '--maf2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
            '--out', os.path.abspath(os.path.join(tmpDir, 'outputWiggles.xml')),
            '--samples=1000', '--logLevel=critical', '--wigglePairs=A:B', 'wiggleBinLength=2'
            ]
     mtt.recordCommands([cmd], tmpDir)
     mtt.runCommandsS([cmd], tmpDir)
     passed = validXml(os.path.abspath(os.path.join(tmpDir, 'outputWiggles.xml')))
     self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #45
0
 def _testMemory1(self):
   """ If valgrind is installed on the system, check for memory related errors (0).
   """
   valgrind = mtt.which('valgrind')
   if valgrind is None:
     return
   mtt.makeTempDirParent()
   for i in xrange(0, 10):
     shuffledBlocks = []
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_1'))
     order = [1] * len(g_overlappingBlocks) + [0] * len(g_nonOverlappingBlocks)
     random.shuffle(order)
     random.shuffle(g_overlappingBlocks)
     random.shuffle(g_nonOverlappingBlocks)
     j, k = 0, 0
     for isOverlapping in order:
       if isOverlapping:
         shuffledBlocks.append(g_overlappingBlocks[j][0])
         j += 1
       else:
         shuffledBlocks.append(g_nonOverlappingBlocks[k][0])
         k += 1
     testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                            ''.join(shuffledBlocks), g_headers)
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = mtt.genericValgrind(tmpDir)
     cmd.append(os.path.abspath(os.path.join(parent, 'test', 'mafPairCoverage')))
     cmd += ['--maf', os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
             '--seq1', 'target.*', '--seq2', g_targetSeq2,
             ]
     outpipes = [os.path.join('/dev', 'null')]
     mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
     mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
     self.assertTrue(mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml')))
     mtt.removeDir(tmpDir)
Пример #46
0
 def testCoverageBed_0(self):
   """ mafPairCoverage should be able to get the correct output given bed-based region intervals
   """
   mtt.makeTempDirParent()
   for i in xrange(0, 10):
     shuffledBlocks = []
     tmpDir = os.path.abspath(mtt.makeTempDir('bed_0'))
     order = [1] * len(g_overlappingBlocks) + [0] * len(g_nonOverlappingBlocks)
     random.shuffle(order)
     random.shuffle(g_overlappingBlocks)
     random.shuffle(g_nonOverlappingBlocks)
     j, k = 0, 0
     total = 0
     for isOverlapping in order:
       if isOverlapping:
         shuffledBlocks.append(g_overlappingBlocks[j][0])
         total += g_overlappingBlocks[j][1]
         j += 1
       else:
         shuffledBlocks.append(g_nonOverlappingBlocks[k][0])
         k += 1
     testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                            ''.join(shuffledBlocks), g_headers)
     testBed = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'intervals.bed')), g_bedString)
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafPairCoverage'))]
     cmd += ['--maf', os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
             '--seq1', 'target.*', '--seq2', g_targetSeq2, '--bed',
             os.path.abspath(os.path.join(tmpDir, 'intervals.bed'))
             ]
     outpipes = [os.path.abspath(os.path.join(tmpDir, 'coverage.txt'))]
     mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
     mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
     self.assertTrue(coverageIsCorrect(os.path.join(tmpDir, 'coverage.txt'), g_coverageLinesWildBed))
     mtt.removeDir(tmpDir)
Пример #47
0
 def testExtraction(self):
     """ mafExtractor should output blocks that meet the criteria for extraction. That is they contain the target sequence and have at least one base in the target range.
     """
     mtt.makeTempDirParent()
     customOpts = mafval.GenericValidationOptions()
     for i in xrange(0, 10):
         shuffledBlocks = []
         tmpDir = os.path.abspath(mtt.makeTempDir('extraction'))
         order = [1] * len(g_overlappingBlocks) + [0] * len(g_nonOverlappingBlocks)
         random.shuffle(order)
         random.shuffle(g_overlappingBlocks)
         random.shuffle(g_nonOverlappingBlocks)
         j, k = 0, 0
         for isOverlapping in order:
             if isOverlapping:
                 shuffledBlocks.append(g_overlappingBlocks[j])
                 j += 1
             else:
                 shuffledBlocks.append(g_nonOverlappingBlocks[k])
                 k += 1
         testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                                ''.join(shuffledBlocks), g_headers)
         parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
         cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafExtractor'))]
         cmd += ['--maf', os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                 '--seq', g_targetSeq, '--start', '%d' % g_targetRange[0], 
                 '--stop', '%d' % g_targetRange[1],
                 '--soft'
                 ]
         outpipes = [os.path.abspath(os.path.join(tmpDir, 'extracted.maf'))]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         self.assertTrue(mafIsExtracted(os.path.join(tmpDir, 'extracted.maf')))
         self.assertTrue(mafval.validateMaf(os.path.join(tmpDir, 'extracted.maf'), customOpts))
         mtt.removeDir(tmpDir)
 def testMemory_3(self):
     """ mafTransitiveClosure should be memory clean.
     """
     mtt.makeTempDirParent()
     valgrind = mtt.which('valgrind')
     if valgrind is None:
         return
     tmpDir = os.path.abspath(mtt.makeTempDir('memory_3'))
     for inMaf, outList in self.knownResults:
         testMaf = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), inMaf,
             g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = mtt.genericValgrind(tmpDir)
         cmd += [
             os.path.abspath(
                 os.path.join(parent, 'test', 'mafTransitiveClosure')),
             '--maf',
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), '--sort'
         ]
         outpipes = [
             os.path.abspath(os.path.join(tmpDir, 'transitiveClosure.maf'))
         ]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         passed = mtt.noMemoryErrors(os.path.join(tmpDir, 'valgrind.xml'))
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
Пример #49
0
 def testCoverage_1(self):
   """ mafPairCoverage should output numbers that accurately reflect the coverage between sequences.
   """
   mtt.makeTempDirParent()
   for i in xrange(0, 10):
     shuffledBlocks = []
     tmpDir = os.path.abspath(mtt.makeTempDir('coverage_1'))
     order = [1] * len(g_overlappingBlocks) + [0] * len(g_nonOverlappingBlocks)
     random.shuffle(order)
     random.shuffle(g_overlappingBlocks)
     random.shuffle(g_nonOverlappingBlocks)
     j, k = 0, 0
     total = 0
     for isOverlapping in order:
       if isOverlapping:
         shuffledBlocks.append(g_overlappingBlocks[j][0])
         total += g_overlappingBlocks[j][1]
         j += 1
       else:
         shuffledBlocks.append(g_nonOverlappingBlocks[k][0])
         k += 1
     testMaf = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
                            ''.join(shuffledBlocks), g_headers)
     parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
     cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafPairCoverage'))]
     cmd += ['--maf', os.path.abspath(os.path.join(tmpDir, 'test_%d.maf' % i)),
             '--seq1', 'target.*', '--seq2', g_targetSeq2,
             ]
     outpipes = [os.path.abspath(os.path.join(tmpDir, 'coverage.txt'))]
     mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
     mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
     self.assertTrue(coverageIsCorrect(os.path.join(tmpDir, 'coverage.txt'), g_coverageLinesWild))
     mtt.removeDir(tmpDir)
 def testKnownInOut_2(self):
     """ mafTransitiveClosure should compute the transitive closure of a maf built by pairwise alignment to a reference sequence, testing the --sort option.
     """
     mtt.makeTempDirParent()
     tmpDir = os.path.abspath(mtt.makeTempDir('knownInOut_2'))
     for inMaf, outList in self.knownResults:
         testMaf = mtt.testFile(
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), inMaf,
             g_headers)
         parent = os.path.dirname(os.path.dirname(
             os.path.abspath(__file__)))
         cmd = [
             os.path.abspath(
                 os.path.join(parent, 'test', 'mafTransitiveClosure')),
             '--maf',
             os.path.abspath(os.path.join(tmpDir, 'test.maf')), '--sort'
         ]
         outpipes = [
             os.path.abspath(os.path.join(tmpDir, 'transitiveClosure.maf'))
         ]
         mtt.recordCommands([cmd], tmpDir, outPipes=outpipes)
         mtt.runCommandsS([cmd], tmpDir, outPipes=outpipes)
         passed = mafIsClosed(os.path.join(tmpDir, 'transitiveClosure.maf'),
                              outList)
         self.assertTrue(passed)
     mtt.removeDir(tmpDir)
    def test_coalescences_knownValues_withAncestors(self):
        """Test phylogeny comparison using coalescences, on MAFs that only have alignments for ancestors and leaves."""
        mtt.makeTempDirParent()
        tmpDir = os.path.abspath(mtt.makeTempDir("coalescencesWithAncestors"))
        for i, (maf1, maf2, earlyCoalescences, lateCoalescences, identicalCoalescences) in enumerate(knownValues):
            testMaf1 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf1.maf')), 
                                    maf1, g_headers)
            testMaf2 = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'maf2.maf')), 
                                    maf2, g_headers)
            parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
            cmd = [os.path.abspath(os.path.join(parent, 'test', 'mafPhyloComparator')),
                   '--mafFile1', os.path.abspath(os.path.join(tmpDir, 'maf1.maf')),
                   '--mafFile2', os.path.abspath(os.path.join(tmpDir, 'maf2.maf')),
                   '--out', os.path.abspath(os.path.join(tmpDir, 'output.xml')),
                   '--numSamples=10000', '--logLevel=critical',
                   "--speciesTree=%s" % g_speciesTree,
                   ]
            mtt.recordCommands([cmd], tmpDir)
            mtt.runCommandsS([cmd], tmpDir)

            outputFile = os.path.abspath(os.path.join(tmpDir, 'output.xml'))
            self.assertEqual(getAggregateCoalescenceResult(outputFile, 'earlyCoalescences'), earlyCoalescences, "early coalescences don't match on test %d" % (i + 1))
            self.assertEqual(getAggregateCoalescenceResult(outputFile, 'lateCoalescences'), lateCoalescences, "late coalescences don't match on test %d" % (i + 1))
            self.assertEqual(getAggregateCoalescenceResult(outputFile, 'identicalCoalescences'), identicalCoalescences, "identical coalescences don't match on test %d" % (i + 1))
        mtt.removeDir(tmpDir)
Пример #52
0
 def testDuplicateColumns(self):
     """ mafValidator should fail when a column is duplicated
     """
     tmpDir = mtt.makeTempDir('duplicateColumns')
     for g in self.badMafs:
         mafFile, header = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test.maf')), g, g_headers)
         self.assertRaises(mafval.DuplicateColumnError, mafval.validateMaf, mafFile, options)
     mtt.removeDir(tmpDir)
Пример #53
0
 def testELines(self):
     """mafValidator should fail when "e" lines are malformed
     """
     tmpDir = mtt.makeTempDir('eLines')
     for b in self.badBlocks:
         mafFile, header = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test.maf')), b, g_headers)
         self.assertRaises(mafval.ELineFormatError, mafval.validateMaf, mafFile, options)
     mtt.removeDir(tmpDir)
Пример #54
0
 def testSequenceRanges(self):
     """mafValidator should fail when sequences ranges go outside of source length
     """
     tmpDir = mtt.makeTempDir('sequenceRanges')
     for i, b in enumerate(self.badRanges, 0):
         mafFile, header = mtt.testFile(os.path.abspath(os.path.join(tmpDir, 'test.maf')), b, g_headers)
         self.assertRaises(mafval.OutOfRangeError, mafval.validateMaf, mafFile, options)
     mtt.removeDir(tmpDir)