test/testCommoncode.py

   1 '''
   2 Created on Aug 30, 2010
   3
   4 @author: sau
   5 '''
   6 import unittest
   7 import os
   8 import string
   9 from array import array
  10 from Erange import commoncode
  11 from cistematic.genomes import Genome
  12
  13
  14 class TestCommoncode(unittest.TestCase):
  15     logFile = "testLogFile"
  16     celegansChroms = ["I", "II", "III", "IV", "V", "X", "MtDNA"]
  17     genome = Genome("celegans")
  18
  19     def setUp(self):
  20         pass
  21
  22
  23     def tearDown(self):
  24         try:
  25             os.remove(self.logFile)
  26         except OSError:
  27             pass
  28
  29
  30     def testGetReverseComplement(self):
  31         self.assertEquals("T", commoncode.getReverseComplement("A"))
  32         self.assertEquals("A", commoncode.getReverseComplement("T"))
  33         self.assertEquals("C", commoncode.getReverseComplement("G"))
  34         self.assertEquals("G", commoncode.getReverseComplement("C"))
  35         self.assertEquals("N", commoncode.getReverseComplement("N"))
  36         self.assertRaises(KeyError, commoncode.getReverseComplement, "")
  37         self.assertRaises(KeyError, commoncode.getReverseComplement, "B")
  38
  39
  40     def testCountDuplicatesInList(self):
  41         testList = []
  42         self.assertEquals([], commoncode.countDuplicatesInList(testList))
  43
  44         testList = [0, 1]
  45         result = [(0, 1), (1, 1)]
  46         self.assertEquals(result, commoncode.countDuplicatesInList(testList))
  47
  48         testList = [0, 1, 1]
  49         result = [(0, 1), (1, 2)]
  50         self.assertEquals(result, commoncode.countDuplicatesInList(testList))
  51
  52         testList = [0, 1, 2, 1]
  53         result = [(0, 1), (1, 2), (2, 1)]
  54         self.assertEquals(result, commoncode.countDuplicatesInList(testList))
  55
  56
  57     def testWriteLog(self):
  58         messenger = "testMessenger"
  59         message = "testMessage"
  60
  61         commoncode.writeLog(self.logFile, messenger, message)
  62         file = open(self.logFile)
  63         line = file.readline()
  64         fields = line.split()
  65         self.assertEquals(fields[2], "[%s]" % messenger)
  66         self.assertEquals(fields[3], message)
  67         line = file.readline()
  68         self.assertEquals("", line)
  69
  70         messenger2 = "testMessenger2"
  71         message2 = "testMessage2"
  72
  73         commoncode.writeLog(self.logFile, messenger2, message2)
  74         file = open(self.logFile)
  75         line = file.readline()
  76         fields = line.split()
  77         self.assertEquals(fields[2], "[%s]" % messenger)
  78         self.assertEquals(fields[3], message)
  79         line = file.readline()
  80         fields = line.split()
  81         self.assertEquals(fields[2], "[%s]" % messenger2)
  82         self.assertEquals(fields[3], message2)
  83         line = file.readline()
  84         self.assertEquals("", line)
  85
  86         os.remove(self.logFile)
  87
  88         commoncode.writeLog(self.logFile, messenger, message)
  89         file = open(self.logFile)
  90         line = file.readline()
  91         fields = line.split()
  92         self.assertEquals(fields[2], "[%s]" % messenger)
  93         self.assertEquals(fields[3], message)
  94         line = file.readline()
  95         self.assertEquals("", line)
  96
  97         os.remove(self.logFile)
  98
  99         commoncode.writeLog(self.logFile, "", message)
 100         file = open(self.logFile)
 101         line = file.readline()
 102         fields = line.split()
 103         self.assertEquals(fields[2], "[]")
 104         self.assertEquals(fields[3], message)
 105         line = file.readline()
 106         self.assertEquals("", line)
 107
 108         os.remove(self.logFile)
 109
 110         commoncode.writeLog(self.logFile, "", "")
 111         file = open(self.logFile)
 112         line = file.readline()
 113         fields = line.split()
 114         self.assertEquals(fields[2], "[]")
 115         self.assertEquals(3, len(fields))
 116         line = file.readline()
 117         self.assertEquals("", line)
 118
 119
 120     def testGetMergedRegions(self):
 121         testfile = open("regionTestFile", "w")
 122         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 123         testfile.write(regionEntry)
 124         testfile.close()
 125         result = {"1": [(10, 20, 10)]}
 126         self.assertEquals(result, commoncode.getMergedRegions("regionTestFile"))
 127         os.remove("regionTestFile")
 128
 129
 130     def testGetMergedRegionsFromList(self):
 131         self.assertEquals({}, commoncode.getMergedRegionsFromList([]))
 132
 133         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 134         regionList = [regionEntry]
 135         result = {"1": [(10, 20, 10)]}
 136         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList))
 137         result = {"1": [(5, 25, 20)]}
 138         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, pad=5))
 139         result = {"1": [(12, 18, 6)]}
 140         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, pad=-2))
 141         result = {"chr1": [(10, 20, 10)]}
 142         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, fullChrom=True))
 143
 144         regionEntry = string.join(["1", "chr1:10-20", "5"], "\t")
 145         regionList = [regionEntry]
 146         result = {"1": [(10, 20, 10)]}
 147         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, compact=True, scoreField=2))
 148
 149         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 150         regionList = [regionEntry]
 151         regionEntry = string.join(["2", "chr1", "15", "40", "10"], "\t")
 152         regionList.append(regionEntry)
 153         result = {"1": [(10, 40, 30)]}
 154         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList))
 155         result = {"1": [(10, 20, 10), (15, 40, 25)]}
 156         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, doMerge=False))
 157         result = {"1": [("1", 10, 20, 10), ("2", 15, 40, 25)]}
 158         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, doMerge=False, keepLabel=True))
 159
 160         regionEntry = string.join(["1", "spacer", "chr1", "10", "20", "5"], "\t")
 161         regionList = [regionEntry]
 162         regionEntry = string.join(["2", "spacer2", "chr1", "15", "40", "10"], "\t")
 163         regionList.append(regionEntry)
 164         result = {"1": [("1\tspacer", 10, 20, 10), ("2\tspacer2", 15, 40, 25)]}
 165         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, doMerge=False, keepLabel=True, chromField=2))
 166
 167         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 168         regionList = [regionEntry]
 169         regionEntry = string.join(["2", "chr1", "2030", "2040", "15"], "\t")
 170         regionList.append(regionEntry)
 171         result = {"1": [(10, 20, 10), (2030, 2040, 10)]}
 172         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList))
 173         result = {"1": [(10, 2040, 2030)]}
 174         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, maxDist=3000))
 175         result = {"1": [(10, 20, 10), (2030, 2040, 10)]}
 176         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, minHits=5))
 177         result = {"1": [(2030, 2040, 10)]}
 178         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, minHits=12))
 179         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, returnTop=1))
 180
 181         regionEntry = string.join(["1", "chr1", "10", "20", "+", "5"], "\t")
 182         regionList = [regionEntry]
 183         regionEntry = string.join(["2", "chr2", "15", "40", "+", "15"], "\t")
 184         regionList.append(regionEntry)
 185         result = {"2": [(15, 40, 25)]}
 186         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, scoreField=5, minHits=12))
 187         self.assertRaises(IndexError, commoncode.getMergedRegionsFromList, regionList, scoreField=6, returnTop=1)
 188         self.assertEquals({}, commoncode.getMergedRegionsFromList(regionList, scoreField=6))
 189         self.assertEquals({}, commoncode.getMergedRegionsFromList(regionList, scoreField=1))
 190
 191         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40"], "\t")
 192         regionList = [regionEntry]
 193         result = {"1": [(10, 20, 10)]}
 194         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList))
 195         result = {"1": [(10, 20, 10, 3, 40)]}
 196         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True))
 197         result = {"1": [("1", 10, 20, 10, 3, 40)]}
 198         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True))
 199         regionEntry = string.join(["2", "chr2", "15", "40", "32", "17"], "\t")
 200         regionList.append(regionEntry)
 201         result = {"1": [("1", 10, 20, 10, 3, 40)], "2": [("2", 15, 40, 25, 32, 17)]}
 202         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True))
 203         regionEntry = string.join(["3", "chr1", "15", "40", "32", "17"], "\t")
 204         regionList.append(regionEntry)
 205         result = {"1": [("3", 10, 40, 30, 3, 40)], "2": [("2", 15, 40, 25, 32, 17)]}
 206         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True))
 207         regionEntry = string.join(["4", "chr2", "65", "88", "72", "7"], "\t")
 208         regionList.append(regionEntry)
 209         result = {"1": [("3", 10, 40, 30, 3, 40)], "2": [("4", 15, 88, 73, 32, 17)]}
 210         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True))
 211         result = {"1": [("1", 10, 20, 10, 3, 40), ("3", 15, 40, 25, 32, 17)],
 212                   "2": [("2", 15, 40, 25, 32, 17), ("4", 65, 88, 23, 72, 7)]
 213         }
 214         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True, doMerge=False))
 215
 216         regionList = ["# comment"]
 217         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40"], "\t")
 218         regionList.append(regionEntry)
 219         result = {"1": [(10, 20, 10, 3, 40)]}
 220         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True))
 221         regionList = ["# pvalue"]
 222         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40", "any value"], "\t")
 223         regionList.append(regionEntry)
 224         result = {"1": [(10, 20, 10, 3, 40)]}
 225         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True))
 226         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, returnTop=1))
 227         regionList = ["# readShift"]
 228         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40", "any value"], "\t")
 229         regionList.append(regionEntry)
 230         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True))
 231         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, returnTop=1))
 232         regionList = ["# pvalue readShift"]
 233         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40", "any value", "any shift"], "\t")
 234         regionList.append(regionEntry)
 235         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True))
 236         self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, returnTop=1))
 237         #Test fails - the header line is required if there are fields after the peak which isn't so good
 238         #self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList[1:], keepPeak=True))
 239
 240
 241     def testRegionsOverlap(self):
 242         self.assertTrue(commoncode.regionsOverlap(100, 200, 1, 300))
 243         self.assertTrue(commoncode.regionsOverlap(100, 200, 150, 300))
 244         self.assertTrue(commoncode.regionsOverlap(100, 500, 1, 300))
 245         self.assertTrue(commoncode.regionsOverlap(100, 200, 110, 160))
 246
 247         self.assertFalse(commoncode.regionsOverlap(100, 200, 250, 300))
 248         self.assertFalse(commoncode.regionsOverlap(100, 200, 1, 60))
 249
 250         self.assertFalse(commoncode.regionsOverlap(-200, -100, 1, 300))
 251         self.assertFalse(commoncode.regionsOverlap(100, 200, -300, -1))
 252
 253         self.assertTrue(commoncode.regionsOverlap(-200, -100, -300, -1))
 254
 255         self.assertTrue(commoncode.regionsOverlap(-100, -200, -300, -1))
 256         self.assertTrue(commoncode.regionsOverlap(-200, -100, -1, -300))
 257         self.assertTrue(commoncode.regionsOverlap(-100, -200, -1, -300))
 258
 259
 260     def testRegionsAreWithinDistance(self):
 261         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 40, 50, 30))
 262         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 1, 5, 5))
 263         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 25, 50, 10))
 264         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 1, 5, 5))
 265
 266         self.assertFalse(commoncode.regionsAreWithinDistance(10, 20, 100, 150, 5))
 267         self.assertFalse(commoncode.regionsAreWithinDistance(100, 200, 10, 15, 5))
 268
 269         self.assertTrue(commoncode.regionsAreWithinDistance(20, 10, 30, 150, 10))
 270         self.assertFalse(commoncode.regionsAreWithinDistance(20, 10, 100, 150, 5))
 271         self.assertFalse(commoncode.regionsAreWithinDistance(10, 20, 150, 100, 5))
 272
 273
 274     #TODO: write test
 275     def testFindPeak(self):
 276         hitList = []
 277         result = ([], 0.0, array("f"), 0.0)
 278         self.assertEquals(result, commoncode.findPeak(hitList, 0, 0))
 279
 280         hitList= [[4, "+", 0.5]]
 281         result = ([6, 7], 1.0, array("f", [0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.8888888955116272, 1.0, 1.0, 0.0, 0.0]), 1.0)
 282         self.assertEquals(result, commoncode.findPeak(hitList, 0, 10))
 283         result = ([6, 7], 0.5, array('f', [0.0, 0.0, 0.0555555559694767, 0.1666666716337204, 0.3333333432674408, 0.4444444477558136, 0.5, 0.5, 0.0, 0.0]), 0.5)
 284         self.assertEquals(result, commoncode.findPeak(hitList, 0, 10, doWeight=True))
 285         result = ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 0.0, array("f", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]), 0.0)
 286         self.assertEquals(result, commoncode.findPeak(hitList, 0, 10, shift="auto"))
 287         result = ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 0.0, array("f", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]), 0.0, 6)
 288         self.assertEquals(result, commoncode.findPeak(hitList, 0, 10, shift="auto", returnShift=True))
 289
 290         hitList= [[4, "+", 0.5]]
 291         result = ([7], 1.0, array('f', [0.0, 0.0, 0.0, 0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.0, 0.0]), 1.0, 3)
 292         self.assertEquals(result, commoncode.findPeak(hitList, 0, 10, shift=3, returnShift=True))
 293
 294         hitList= [[4, "+", 0.5]]
 295         result = ([6, 7], 1.0, array('f', [0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.8888888955116272, 1.0, 1.0, 0.0, 0.0]), 1.0, 1.0)
 296         self.assertEquals(result, commoncode.findPeak(hitList, 0, 10, leftPlus=True))
 297         result = ([7], 1.0, array('f', [0.0, 0.0, 0.0, 0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.0, 0.0]), 1.0, 1.0, 3)
 298         self.assertEquals(result, commoncode.findPeak(hitList, 0, 10, leftPlus=True, shift=3, returnShift=True))
 299
 300
 301     #TODO: write test
 302     def testGetBestShiftForRegion(self):
 303         hitList = [[14, "-", 1.0], [16, "-", 1.0], [24, "+", 1.0],  [26, "+", 10.0]]
 304         self.assertEquals(74, commoncode.getBestShiftForRegion(hitList, 0, 100))
 305         self.assertEquals(16, commoncode.getBestShiftForRegion(hitList, 0, 100, maxShift=30))
 306         self.assertEquals(0, commoncode.getBestShiftForRegion(hitList, 0, 100, maxShift=10))
 307
 308
 309     #TODO: write test
 310     def testGetFeaturesByChromDict(self):
 311         firstFeatures = {"I": (4123, 4219, "Y74C9A.3", "R", "3UTR"),
 312                          "II": (1866, 1910, "2L52.1", "F", "CDS"),
 313                          "III": (1270, 1506, "cTel54X.1", "R", "CDS"),
 314                          "IV": (694, 1064, "Y38C1AB.4", "F", "CDS"),
 315                          "V": (1479, 1578, "cTel3X.1", "F", "CDS"),
 316                          "X": (3622, 4099, "CE7X_3.1", "F", "CDS"),
 317                          "MtDNA": (112, 543, "MTCE.3", "F", "CDS")
 318         }
 319         featureDict = commoncode.getFeaturesByChromDict(self.genome)
 320         for chrom in featureDict.keys():
 321             self.assertTrue(chrom in self.celegansChroms)
 322             self.assertEquals(firstFeatures[chrom], featureDict[chrom][0])
 323
 324         restrictList = ["almost certainly not a value feature"]
 325         featureDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList)
 326         self.assertEquals({}, featureDict)
 327
 328         restrictList = ["Y74C9A.3"]
 329         featureDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList)
 330         self.assertEquals(["I"], featureDict.keys())
 331         featureDict, complementDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList, regionComplement=True)
 332         result = {"I": [(0, 4123, "nonExon1", "F", "nonExon"),
 333                         (4219, 4220, "nonExon2", "F", "nonExon"),
 334                         (4357, 5194, "nonExon3", "F", "nonExon"),
 335                         (5295, 6036, "nonExon4", "F", "nonExon"),
 336                         (6326, 9726, "nonExon5", "F", "nonExon"),
 337                         (9845, 10094, "nonExon6", "F", "nonExon"),
 338                         (10147, 10148, "nonExon7", "F", "nonExon"),
 339                         (10231, 250000000, "nonExon8", "F", "nonExon")]
 340         }
 341         self.assertEquals(result, complementDict)
 342
 343         regionDict = {"I": [("new feature", 100, 150, 50)]}
 344         featureDict = commoncode.getFeaturesByChromDict(self.genome, additionalRegionsDict=regionDict)
 345         result = (100, 150, "new feature", "+", "custom")
 346         self.assertEquals(result, featureDict["I"][0])
 347
 348
 349     def testGetLocusByChromDict(self):
 350         firstLoci = {"I": (4123, 10231, "Y74C9A.3", 6108),
 351                      "II": (1866, 4662, "2L52.1", 2796),
 352                      "III": (1270, 2916, "cTel54X.1", 1646),
 353                      "IV": (694, 14925, "Y38C1AB.4", 14231),
 354                      "V": (1479, 3038, "cTel3X.1", 1559),
 355                      "X": (3622, 7153, "CE7X_3.1", 3531),
 356                      "MtDNA": (112, 548, "MTCE.3", 436)
 357         }
 358
 359         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, useCDS=False))
 360         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=1, downstream=1, useCDS=False))
 361         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=-1, downstream=-1, useCDS=False, lengthCDS=1))
 362         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstreamSpanTSS=True, lengthCDS=1))
 363         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, downstream=1, lengthCDS=1))
 364         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=1, lengthCDS=-1))
 365
 366         locusDict = commoncode.getLocusByChromDict(self.genome)
 367         for chrom in locusDict.keys():
 368             self.assertTrue(chrom in self.celegansChroms)
 369             self.assertEquals(firstLoci[chrom], locusDict[chrom][0])
 370
 371         regionDict = {"I": [("new region", 100, 150, 50)]}
 372         locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict)
 373         self.assertEquals((100, 150, "new region", 50), locusDict["I"][0])
 374         locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, keepSense=True)
 375         self.assertEquals((100, 150, "new region", 50, "+"), locusDict["I"][0])
 376
 377         # Long Test
 378         #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, upstream=100)
 379         #self.assertEquals((150, 250, "new region", 100), locusDict["I"][0])
 380
 381         # Long Test
 382         #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, downstream=10)
 383         #self.assertEquals((90, 100, "new region", 10), locusDict["I"][0])
 384
 385
 386     def testComputeRegionBins(self):
 387         regionsByChromDict = {}
 388         hitDict = {}
 389         bins = 4
 390         readlen = 10
 391         result = ({}, {})
 392         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 393
 394         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 395         result = ({"regionID": [0.0, 0.0, 0.0, 0.0]}, {})
 396         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 397
 398         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 399         hitDict = {"1": [[1, "+", 1.0]]}
 400         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 401         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 402
 403         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 404                               "2": [("regionID2", 1, 1000, 1000, "F")]
 405         }
 406         hitDict = {"1": [[1, "+", 1.0]],
 407                    "2": [[1, "+", 1.0]]
 408         }
 409         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 410         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 411
 412         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 413         hitDict = {"1": [[10, "+", 1.0], [80, "+", 0.5]]}
 414         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 415         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 416
 417         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 418         hitDict = {"1": [[10, "+", 1.0], [80, "+", 0.5], [15, "+", 1.0]]}
 419         result = ({"regionID": [2.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 420         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 421
 422         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 423         hitDict = {"1": [[10, "+", 1.0], [80, "+", 0.5], [200, "+", 2.0]]}
 424         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 425         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 426
 427         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 428         hitDict = {"1": [[1, "+", 1.0]]}
 429         regionList = ["regionID"]
 430         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 431         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 432
 433         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 434         hitDict = {"1": [[1, "+", 1.0]]}
 435         regionList = ["empty region"]
 436         result = ({"empty region": [0.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 437         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 438
 439         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 440                               "2": [("regionID2", 1, 1000, 1000, "F")]
 441         }
 442         hitDict = {"1": [[1, "+", 1.0]],
 443                    "2": [[1, "+", 1.0]]
 444         }
 445         regionList = ["regionID", "regionID2"]
 446         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 447         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 448
 449         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 450                               "2": [("regionID2", 1, 1000, 1000, "F")]
 451         }
 452         hitDict = {"1": [[1, "+", 1.0]],
 453                    "2": [[1, "+", 1.0]]
 454         }
 455         regionList = ["empty region", "regionID2"]
 456         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "empty region": [0.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 457         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 458
 459         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 460                               "2": [("regionID2", 1, 1000, 1000, "F")]
 461         }
 462         hitDict = {"1": [[1, "+", 1.0]],
 463                    "2": [[1, "+", 1.0]]
 464         }
 465         regionList = ["regionID2"]
 466         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 467         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 468
 469         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 470         hitDict = {"1": [[1, "+", 1.0]]}
 471         result = ({"regionID": [2.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 472         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, normalizedTag=2.0))
 473
 474         regionsByChromDict = {"1": [(1, 100, "regionID", 100, "F")]}
 475         hitDict = {"1": [[1, "+", 1.0]]}
 476         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 477         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, defaultRegionFormat=False))
 478
 479         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 480         hitDict = {"1": [[10, "+", 1.0]]}
 481         fixedFirstBin = 20
 482         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 483         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 484
 485         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 486         hitDict = {"1": [[10, "+", 1.0]]}
 487         fixedFirstBin = 5
 488         result = ({"regionID": [0.0, 1.0, 0.0, 0.0]}, {"regionID": 100})
 489         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 490
 491         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 492         hitDict = {"1": [[10, "+", 1.0], [85, "+", 0.5]]}
 493         fixedFirstBin = 20
 494         result = ({"regionID": [1.0, 0.5, 0.0, 0.0]}, {"regionID": 100})
 495         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 496
 497         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 498         hitDict = {"1": [[80, "+", 1.0], [85, "+", 0.5]]}
 499         fixedFirstBin = 5
 500         result = ({"regionID": [0.0, 1.5, 0.0, 0.0]}, {"regionID": 100})
 501         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 502
 503         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 504         hitDict = {"1": [[10, "+", 1.0], [85, "+", 0.5]]}
 505         binLength = 25
 506         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 507         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 508
 509         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 510         hitDict = {"1": [[10, "+", 1.0], [85, "+", 0.5]]}
 511         binLength = 50
 512         result = ({"regionID": [1.0, 0.5, 0.0, 0.0]}, {"regionID": 100})
 513         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 514
 515         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 516         hitDict = {"1": [[10, "+", 1.0], [85, "+", 0.5]]}
 517         binLength = 15
 518         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 519         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 520
 521         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 522         hitDict = {"1": [[10, "+", 1.0], [40, "+", 0.7], [85, "+", 0.5]]}
 523         binLength = 15
 524         result = ({"regionID": [1.0, 0.0, 0.7, 0.5]}, {"regionID": 100})
 525         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 526
 527         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "R")]}
 528         hitDict = {"1": [[10, "+", 1.0], [40, "+", 0.7], [85, "+", 0.5]]}
 529         result = ({"regionID": [0.5, 0.0, 0.7, 1.0]}, {"regionID": 100})
 530         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 531         result = ({"regionID": [0.5, 0.0, 0.7, 1.0]}, {"regionID": 100})
 532         fixedFirstBin = 10
 533         result = ({"regionID": [0.0, 2.2, 0.0, 0.0]}, {"regionID": 100})
 534         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 535         fixedFirstBin = 20
 536         result = ({"regionID": [0.5, 1.7, 0.0, 0.0]}, {"regionID": 100})
 537         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 538         binLength = 50
 539         result = ({"regionID": [0.5, 1.7, 0.0, 0.0]}, {"regionID": 100})
 540         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 541         binLength = 10
 542         result = ({"regionID": [0.0, 0.5, 0.0, 1.7]}, {"regionID": 100})
 543         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 544
 545
 546 def suite():
 547     suite = unittest.TestSuite()
 548     suite.addTest(unittest.makeSuite(TestCommoncode))
 549
 550     return suite
 551
 552
 553 if __name__ == "__main__":
 554     #import sys;sys.argv = ['', 'Test.testName']
 555     unittest.main()