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= [{"start": 4, "sense": "+", "weight": 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= [{"start": 4, "sense": "+", "weight": 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= [{"start": 4, "sense": "+", "weight": 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 = [{"start": 14, "sense": "-", "weight": 1.0},
 304                    {"start": 16, "sense": "-", "weight": 1.0},
 305                    {"start": 24, "sense": "+", "weight": 1.0},
 306                    {"start": 26, "sense": "+", "weight": 10.0}
 307         ]
 308         self.assertEquals(74, commoncode.getBestShiftForRegion(hitList, 0, 100))
 309         self.assertEquals(16, commoncode.getBestShiftForRegion(hitList, 0, 100, maxShift=30))
 310         self.assertEquals(0, commoncode.getBestShiftForRegion(hitList, 0, 100, maxShift=10))
 311
 312
 313     #TODO: write test
 314     def testFindPeakSequenceArray(self):
 315         pass
 316
 317
 318     #TODO: write test
 319     def testGetPeakPositionList(self):
 320         pass
 321
 322
 323     #TODO: write test
 324     def testGetFeaturesByChromDict(self):
 325         firstFeatures = {"I": (4123, 4219, "Y74C9A.3", "R", "3UTR"),
 326                          "II": (1866, 1910, "2L52.1", "F", "CDS"),
 327                          "III": (1270, 1506, "cTel54X.1", "R", "CDS"),
 328                          "IV": (694, 1064, "Y38C1AB.4", "F", "CDS"),
 329                          "V": (1479, 1578, "cTel3X.1", "F", "CDS"),
 330                          "X": (3622, 4099, "CE7X_3.1", "F", "CDS"),
 331                          "MtDNA": (112, 543, "MTCE.3", "F", "CDS")
 332         }
 333         featureDict = commoncode.getFeaturesByChromDict(self.genome)
 334         for chrom in featureDict.keys():
 335             self.assertTrue(chrom in self.celegansChroms)
 336             self.assertEquals(firstFeatures[chrom], featureDict[chrom][0])
 337
 338         restrictList = ["almost certainly not a value feature"]
 339         featureDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList)
 340         self.assertEquals({}, featureDict)
 341
 342         restrictList = ["Y74C9A.3"]
 343         featureDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList)
 344         self.assertEquals(["I"], featureDict.keys())
 345         featureDict, complementDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList, regionComplement=True)
 346         result = {"I": [(0, 4123, "nonExon1", "F", "nonExon"),
 347                         (4219, 4220, "nonExon2", "F", "nonExon"),
 348                         (4357, 5194, "nonExon3", "F", "nonExon"),
 349                         (5295, 6036, "nonExon4", "F", "nonExon"),
 350                         (6326, 9726, "nonExon5", "F", "nonExon"),
 351                         (9845, 10094, "nonExon6", "F", "nonExon"),
 352                         (10147, 10148, "nonExon7", "F", "nonExon"),
 353                         (10231, 250000000, "nonExon8", "F", "nonExon")]
 354         }
 355         self.assertEquals(result, complementDict)
 356
 357         regionDict = {"I": [("new feature", 100, 150, 50)]}
 358         featureDict = commoncode.getFeaturesByChromDict(self.genome, additionalRegionsDict=regionDict)
 359         result = (100, 150, "new feature", "+", "custom")
 360         self.assertEquals(result, featureDict["I"][0])
 361
 362
 363     def testGetLocusByChromDict(self):
 364         firstLoci = {"I": (4123, 10231, "Y74C9A.3", 6108),
 365                      "II": (1866, 4662, "2L52.1", 2796),
 366                      "III": (1270, 2916, "cTel54X.1", 1646),
 367                      "IV": (694, 14925, "Y38C1AB.4", 14231),
 368                      "V": (1479, 3038, "cTel3X.1", 1559),
 369                      "X": (3622, 7153, "CE7X_3.1", 3531),
 370                      "MtDNA": (112, 548, "MTCE.3", 436)
 371         }
 372
 373         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, useCDS=False))
 374         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=1, downstream=1, useCDS=False))
 375         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=-1, downstream=-1, useCDS=False, lengthCDS=1))
 376         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstreamSpanTSS=True, lengthCDS=1))
 377         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, downstream=1, lengthCDS=1))
 378         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=1, lengthCDS=-1))
 379
 380         locusDict = commoncode.getLocusByChromDict(self.genome)
 381         for chrom in locusDict.keys():
 382             self.assertTrue(chrom in self.celegansChroms)
 383             self.assertEquals(firstLoci[chrom], locusDict[chrom][0])
 384
 385         regionDict = {"I": [("new region", 100, 150, 50)]}
 386         locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict)
 387         self.assertEquals((100, 150, "new region", 50), locusDict["I"][0])
 388         locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, keepSense=True)
 389         self.assertEquals((100, 150, "new region", 50, "+"), locusDict["I"][0])
 390
 391         # Long Test
 392         #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, upstream=100)
 393         #self.assertEquals((150, 250, "new region", 100), locusDict["I"][0])
 394
 395         # Long Test
 396         #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, downstream=10)
 397         #self.assertEquals((90, 100, "new region", 10), locusDict["I"][0])
 398
 399
 400     def testComputeRegionBins(self):
 401         regionsByChromDict = {}
 402         hitDict = {}
 403         bins = 4
 404         readlen = 10
 405         result = ({}, {})
 406         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 407
 408         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 409         result = ({"regionID": [0.0, 0.0, 0.0, 0.0]}, {})
 410         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 411
 412         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 413         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 414         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 415         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 416
 417         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 418                               "2": [("regionID2", 1, 1000, 1000, "F")]
 419         }
 420         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 421                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 422         }
 423         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 424         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 425
 426         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 427         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 80, "sense": "+", "weight": 0.5}]}
 428         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 429         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 430
 431         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 432         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 80, "sense": "+", "weight": 0.5}, {"start": 15, "sense": "+", "weight": 1.0}]}
 433         result = ({"regionID": [2.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 434         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 435
 436         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 437         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 80, "sense": "+", "weight": 0.5}, {"start": 200, "sense": "+", "weight": 2.0}]}
 438         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 439         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 440
 441         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 442         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 443         regionList = ["regionID"]
 444         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 445         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 446
 447         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 448         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 449         regionList = ["empty region"]
 450         result = ({"empty region": [0.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 451         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 452
 453         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 454                               "2": [("regionID2", 1, 1000, 1000, "F")]
 455         }
 456         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 457                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 458         }
 459         regionList = ["regionID", "regionID2"]
 460         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 461         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 462
 463         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 464                               "2": [("regionID2", 1, 1000, 1000, "F")]
 465         }
 466         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 467                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 468         }
 469         regionList = ["empty region", "regionID2"]
 470         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "empty region": [0.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 471         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 472
 473         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 474                               "2": [("regionID2", 1, 1000, 1000, "F")]
 475         }
 476         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 477                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 478         }
 479         regionList = ["regionID2"]
 480         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 481         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 482
 483         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 484         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 485         result = ({"regionID": [2.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 486         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, normalizedTag=2.0))
 487
 488         regionsByChromDict = {"1": [(1, 100, "regionID", 100, "F")]}
 489         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 490         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 491         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, defaultRegionFormat=False))
 492
 493         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 494         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}]}
 495         fixedFirstBin = 20
 496         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 497         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 498
 499         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 500         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}]}
 501         fixedFirstBin = 5
 502         result = ({"regionID": [0.0, 1.0, 0.0, 0.0]}, {"regionID": 100})
 503         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 504
 505         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 506         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 507         fixedFirstBin = 20
 508         result = ({"regionID": [1.0, 0.5, 0.0, 0.0]}, {"regionID": 100})
 509         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 510
 511         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 512         hitDict = {"1": [{"start": 80, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 513         fixedFirstBin = 5
 514         result = ({"regionID": [0.0, 1.5, 0.0, 0.0]}, {"regionID": 100})
 515         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 516
 517         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 518         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 519         binLength = 25
 520         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 521         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 522
 523         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 524         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 525         binLength = 50
 526         result = ({"regionID": [1.0, 0.5, 0.0, 0.0]}, {"regionID": 100})
 527         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 528
 529         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 530         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 531         binLength = 15
 532         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 533         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 534
 535         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 536         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 40, "sense": "+", "weight": 0.7}, {"start": 85, "sense": "+", "weight": 0.5}]}
 537         binLength = 15
 538         result = ({"regionID": [1.0, 0.0, 0.7, 0.5]}, {"regionID": 100})
 539         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 540
 541         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "R")]}
 542         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 40, "sense": "+", "weight": 0.7}, {"start": 85, "sense": "+", "weight": 0.5}]}
 543         result = ({"regionID": [0.5, 0.0, 0.7, 1.0]}, {"regionID": 100})
 544         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 545         result = ({"regionID": [0.5, 0.0, 0.7, 1.0]}, {"regionID": 100})
 546         fixedFirstBin = 10
 547         result = ({"regionID": [0.0, 2.2, 0.0, 0.0]}, {"regionID": 100})
 548         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 549         fixedFirstBin = 20
 550         result = ({"regionID": [0.5, 1.7, 0.0, 0.0]}, {"regionID": 100})
 551         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 552         binLength = 50
 553         result = ({"regionID": [0.5, 1.7, 0.0, 0.0]}, {"regionID": 100})
 554         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 555         binLength = 10
 556         result = ({"regionID": [0.0, 0.5, 0.0, 1.7]}, {"regionID": 100})
 557         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 558
 559
 560 def suite():
 561     suite = unittest.TestSuite()
 562     suite.addTest(unittest.makeSuite(TestCommoncode))
 563
 564     return suite
 565
 566
 567 if __name__ == "__main__":
 568     #import sys;sys.argv = ['', 'Test.testName']
 569     unittest.main()