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 erange import Region
  12 from cistematic.genomes import Genome
  13
  14
  15 class TestCommoncode(unittest.TestCase):
  16     logFile = "testLogFile"
  17     celegansChroms = ["I", "II", "III", "IV", "V", "X", "MtDNA"]
  18     genome = Genome("celegans")
  19
  20     def setUp(self):
  21         pass
  22
  23
  24     def tearDown(self):
  25         try:
  26             os.remove(self.logFile)
  27         except OSError:
  28             pass
  29
  30
  31     def testGetReverseComplement(self):
  32         self.assertEquals("T", commoncode.getReverseComplement("A"))
  33         self.assertEquals("A", commoncode.getReverseComplement("T"))
  34         self.assertEquals("C", commoncode.getReverseComplement("G"))
  35         self.assertEquals("G", commoncode.getReverseComplement("C"))
  36         self.assertEquals("N", commoncode.getReverseComplement("N"))
  37         self.assertRaises(KeyError, commoncode.getReverseComplement, "")
  38         self.assertRaises(KeyError, commoncode.getReverseComplement, "B")
  39
  40
  41     def testCountDuplicatesInList(self):
  42         testList = []
  43         self.assertEquals([], commoncode.countDuplicatesInList(testList))
  44
  45         testList = [0, 1]
  46         result = [(0, 1), (1, 1)]
  47         self.assertEquals(result, commoncode.countDuplicatesInList(testList))
  48
  49         testList = [0, 1, 1]
  50         result = [(0, 1), (1, 2)]
  51         self.assertEquals(result, commoncode.countDuplicatesInList(testList))
  52
  53         testList = [0, 1, 2, 1]
  54         result = [(0, 1), (1, 2), (2, 1)]
  55         self.assertEquals(result, commoncode.countDuplicatesInList(testList))
  56
  57
  58     def testWriteLog(self):
  59         messenger = "testMessenger"
  60         message = "testMessage"
  61
  62         commoncode.writeLog(self.logFile, messenger, message)
  63         file = open(self.logFile)
  64         line = file.readline()
  65         fields = line.split()
  66         self.assertEquals(fields[2], "[%s]" % messenger)
  67         self.assertEquals(fields[3], message)
  68         line = file.readline()
  69         self.assertEquals("", line)
  70
  71         messenger2 = "testMessenger2"
  72         message2 = "testMessage2"
  73
  74         commoncode.writeLog(self.logFile, messenger2, message2)
  75         file = open(self.logFile)
  76         line = file.readline()
  77         fields = line.split()
  78         self.assertEquals(fields[2], "[%s]" % messenger)
  79         self.assertEquals(fields[3], message)
  80         line = file.readline()
  81         fields = line.split()
  82         self.assertEquals(fields[2], "[%s]" % messenger2)
  83         self.assertEquals(fields[3], message2)
  84         line = file.readline()
  85         self.assertEquals("", line)
  86
  87         os.remove(self.logFile)
  88
  89         commoncode.writeLog(self.logFile, messenger, message)
  90         file = open(self.logFile)
  91         line = file.readline()
  92         fields = line.split()
  93         self.assertEquals(fields[2], "[%s]" % messenger)
  94         self.assertEquals(fields[3], message)
  95         line = file.readline()
  96         self.assertEquals("", line)
  97
  98         os.remove(self.logFile)
  99
 100         commoncode.writeLog(self.logFile, "", message)
 101         file = open(self.logFile)
 102         line = file.readline()
 103         fields = line.split()
 104         self.assertEquals(fields[2], "[]")
 105         self.assertEquals(fields[3], message)
 106         line = file.readline()
 107         self.assertEquals("", line)
 108
 109         os.remove(self.logFile)
 110
 111         commoncode.writeLog(self.logFile, "", "")
 112         file = open(self.logFile)
 113         line = file.readline()
 114         fields = line.split()
 115         self.assertEquals(fields[2], "[]")
 116         self.assertEquals(3, len(fields))
 117         line = file.readline()
 118         self.assertEquals("", line)
 119
 120
 121     def testGetMergedRegions(self):
 122         testfile = open("regionTestFile", "w")
 123         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 124         testfile.write(regionEntry)
 125         testfile.close()
 126         result = commoncode.getMergedRegions("regionTestFile")
 127         self.assertEquals(10, result["1"][0].start)
 128         self.assertEquals(20, result["1"][0].stop)
 129         self.assertEquals(10, result["1"][0].length)
 130         os.remove("regionTestFile")
 131
 132
 133     def testGetMergedRegionsFromList(self):
 134         self.assertEquals({}, commoncode.getMergedRegionsFromList([]))
 135
 136         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 137         regionList = [regionEntry]
 138         result = commoncode.getMergedRegionsFromList(regionList)
 139         self.assertEquals(10, result["1"][0].start)
 140         self.assertEquals(20, result["1"][0].stop)
 141         self.assertEquals(10, result["1"][0].length)
 142
 143         result = commoncode.getMergedRegionsFromList(regionList, pad=5)
 144         self.assertEquals(5, result["1"][0].start)
 145         self.assertEquals(25, result["1"][0].stop)
 146         self.assertEquals(20, result["1"][0].length)
 147
 148         result = commoncode.getMergedRegionsFromList(regionList, pad=-2)
 149         self.assertEquals(12, result["1"][0].start)
 150         self.assertEquals(18, result["1"][0].stop)
 151         self.assertEquals(6, result["1"][0].length)
 152
 153         result = commoncode.getMergedRegionsFromList(regionList, fullChrom=True)
 154         self.assertEquals(10, result["chr1"][0].start)
 155         self.assertEquals(20, result["chr1"][0].stop)
 156         self.assertEquals(10, result["chr1"][0].length)
 157
 158         regionEntry = string.join(["1", "chr1:10-20", "5"], "\t")
 159         regionList = [regionEntry]
 160         result = commoncode.getMergedRegionsFromList(regionList, compact=True, scoreField=2)
 161         self.assertEquals(10, result["1"][0].start)
 162         self.assertEquals(20, result["1"][0].stop)
 163         self.assertEquals(10, result["1"][0].length)
 164
 165         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 166         regionList = [regionEntry]
 167         regionEntry = string.join(["2", "chr1", "15", "40", "10"], "\t")
 168         regionList.append(regionEntry)
 169         result = commoncode.getMergedRegionsFromList(regionList)
 170         self.assertEquals(10, result["1"][0].start)
 171         self.assertEquals(40, result["1"][0].stop)
 172         self.assertEquals(30, result["1"][0].length)
 173
 174         result = commoncode.getMergedRegionsFromList(regionList, doMerge=False)
 175         self.assertEquals(10, result["1"][0].start)
 176         self.assertEquals(20, result["1"][0].stop)
 177         self.assertEquals(10, result["1"][0].length)
 178         self.assertEquals(15, result["1"][1].start)
 179         self.assertEquals(40, result["1"][1].stop)
 180         self.assertEquals(25, result["1"][1].length)
 181
 182         result = commoncode.getMergedRegionsFromList(regionList, doMerge=False, keepLabel=True)
 183         self.assertEquals(10, result["1"][0].start)
 184         self.assertEquals(20, result["1"][0].stop)
 185         self.assertEquals(10, result["1"][0].length)
 186         self.assertEquals("1", result["1"][0].label)
 187         self.assertEquals(15, result["1"][1].start)
 188         self.assertEquals(40, result["1"][1].stop)
 189         self.assertEquals(25, result["1"][1].length)
 190         self.assertEquals("2", result["1"][1].label)
 191
 192         regionEntry = string.join(["1", "spacer", "chr1", "10", "20", "5"], "\t")
 193         regionList = [regionEntry]
 194         regionEntry = string.join(["2", "spacer2", "chr1", "15", "40", "10"], "\t")
 195         regionList.append(regionEntry)
 196         result = commoncode.getMergedRegionsFromList(regionList, doMerge=False, keepLabel=True, chromField=2)
 197         self.assertEquals(10, result["1"][0].start)
 198         self.assertEquals(20, result["1"][0].stop)
 199         self.assertEquals(10, result["1"][0].length)
 200         self.assertEquals("1\tspacer", result["1"][0].label)
 201         self.assertEquals(15, result["1"][1].start)
 202         self.assertEquals(40, result["1"][1].stop)
 203         self.assertEquals(25, result["1"][1].length)
 204         self.assertEquals("2\tspacer2", result["1"][1].label)
 205
 206         regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
 207         regionList = [regionEntry]
 208         regionEntry = string.join(["2", "chr1", "2030", "2040", "15"], "\t")
 209         regionList.append(regionEntry)
 210         result = commoncode.getMergedRegionsFromList(regionList)
 211         self.assertEquals(10, result["1"][0].start)
 212         self.assertEquals(20, result["1"][0].stop)
 213         self.assertEquals(10, result["1"][0].length)
 214         self.assertEquals(2030, result["1"][1].start)
 215         self.assertEquals(2040, result["1"][1].stop)
 216         self.assertEquals(10, result["1"][1].length)
 217
 218         result = commoncode.getMergedRegionsFromList(regionList, maxDist=3000)
 219         self.assertEquals(10, result["1"][0].start)
 220         self.assertEquals(2040, result["1"][0].stop)
 221         self.assertEquals(2030, result["1"][0].length)
 222
 223         result = commoncode.getMergedRegionsFromList(regionList, minHits=5)
 224         self.assertEquals(10, result["1"][0].start)
 225         self.assertEquals(20, result["1"][0].stop)
 226         self.assertEquals(10, result["1"][0].length)
 227         self.assertEquals(2030, result["1"][1].start)
 228         self.assertEquals(2040, result["1"][1].stop)
 229         self.assertEquals(10, result["1"][1].length)
 230
 231         result = commoncode.getMergedRegionsFromList(regionList, minHits=12)
 232         self.assertEquals(2030, result["1"][0].start)
 233         self.assertEquals(2040, result["1"][0].stop)
 234         self.assertEquals(10, result["1"][0].length)
 235         result = commoncode.getMergedRegionsFromList(regionList, minHits=12)
 236         self.assertEquals(2030, result["1"][0].start)
 237         self.assertEquals(2040, result["1"][0].stop)
 238         self.assertEquals(10, result["1"][0].length)
 239
 240         regionEntry = string.join(["1", "chr1", "10", "20", "+", "5"], "\t")
 241         regionList = [regionEntry]
 242         regionEntry = string.join(["2", "chr2", "15", "40", "+", "15"], "\t")
 243         regionList.append(regionEntry)
 244         result = commoncode.getMergedRegionsFromList(regionList, scoreField=5, minHits=12)
 245         self.assertEquals(15, result["2"][0].start)
 246         self.assertEquals(40, result["2"][0].stop)
 247         self.assertEquals(25, result["2"][0].length)
 248         self.assertRaises(IndexError, commoncode.getMergedRegionsFromList, regionList, scoreField=6, returnTop=1)
 249         self.assertEquals({}, commoncode.getMergedRegionsFromList(regionList, scoreField=6))
 250         self.assertEquals({}, commoncode.getMergedRegionsFromList(regionList, scoreField=1))
 251
 252         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40"], "\t")
 253         regionList = [regionEntry]
 254         result = commoncode.getMergedRegionsFromList(regionList)
 255         self.assertEquals(10, result["1"][0].start)
 256         self.assertEquals(20, result["1"][0].stop)
 257         self.assertEquals(10, result["1"][0].length)
 258
 259         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True)
 260         self.assertEquals(10, result["1"][0].start)
 261         self.assertEquals(20, result["1"][0].stop)
 262         self.assertEquals(10, result["1"][0].length)
 263         self.assertEquals(3, result["1"][0].peakPos)
 264         self.assertEquals(40, result["1"][0].peakHeight)
 265
 266         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True)
 267         self.assertEquals(10, result["1"][0].start)
 268         self.assertEquals(20, result["1"][0].stop)
 269         self.assertEquals(10, result["1"][0].length)
 270         self.assertEquals(3, result["1"][0].peakPos)
 271         self.assertEquals(40, result["1"][0].peakHeight)
 272         self.assertEquals("1", result["1"][0].label)
 273
 274         regionEntry = string.join(["2", "chr2", "15", "40", "32", "17"], "\t")
 275         regionList.append(regionEntry)
 276         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True)
 277         self.assertEquals(10, result["1"][0].start)
 278         self.assertEquals(20, result["1"][0].stop)
 279         self.assertEquals(10, result["1"][0].length)
 280         self.assertEquals(3, result["1"][0].peakPos)
 281         self.assertEquals(40, result["1"][0].peakHeight)
 282         self.assertEquals("1", result["1"][0].label)
 283         self.assertEquals(15, result["2"][0].start)
 284         self.assertEquals(40, result["2"][0].stop)
 285         self.assertEquals(25, result["2"][0].length)
 286         self.assertEquals(32, result["2"][0].peakPos)
 287         self.assertEquals(17, result["2"][0].peakHeight)
 288         self.assertEquals("2", result["2"][0].label)
 289
 290         regionEntry = string.join(["3", "chr1", "15", "40", "32", "17"], "\t")
 291         regionList.append(regionEntry)
 292         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True)
 293         self.assertEquals(10, result["1"][0].start)
 294         self.assertEquals(40, result["1"][0].stop)
 295         self.assertEquals(30, result["1"][0].length)
 296         self.assertEquals(3, result["1"][0].peakPos)
 297         self.assertEquals(40, result["1"][0].peakHeight)
 298         self.assertEquals("3", result["1"][0].label)
 299         self.assertEquals(15, result["2"][0].start)
 300         self.assertEquals(40, result["2"][0].stop)
 301         self.assertEquals(25, result["2"][0].length)
 302         self.assertEquals(32, result["2"][0].peakPos)
 303         self.assertEquals(17, result["2"][0].peakHeight)
 304         self.assertEquals("2", result["2"][0].label)
 305
 306         regionEntry = string.join(["4", "chr2", "65", "88", "72", "7"], "\t")
 307         regionList.append(regionEntry)
 308         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True)
 309         self.assertEquals(10, result["1"][0].start)
 310         self.assertEquals(40, result["1"][0].stop)
 311         self.assertEquals(30, result["1"][0].length)
 312         self.assertEquals(3, result["1"][0].peakPos)
 313         self.assertEquals(40, result["1"][0].peakHeight)
 314         self.assertEquals("3", result["1"][0].label)
 315         self.assertEquals(15, result["2"][0].start)
 316         self.assertEquals(88, result["2"][0].stop)
 317         self.assertEquals(73, result["2"][0].length)
 318         self.assertEquals(32, result["2"][0].peakPos)
 319         self.assertEquals(17, result["2"][0].peakHeight)
 320         self.assertEquals("4", result["2"][0].label)
 321
 322         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True, doMerge=False)
 323         self.assertEquals(10, result["1"][0].start)
 324         self.assertEquals(20, result["1"][0].stop)
 325         self.assertEquals(10, result["1"][0].length)
 326         self.assertEquals(3, result["1"][0].peakPos)
 327         self.assertEquals(40, result["1"][0].peakHeight)
 328         self.assertEquals("1", result["1"][0].label)
 329         self.assertEquals(15, result["1"][1].start)
 330         self.assertEquals(40, result["1"][1].stop)
 331         self.assertEquals(25, result["1"][1].length)
 332         self.assertEquals(32, result["1"][1].peakPos)
 333         self.assertEquals(17, result["1"][1].peakHeight)
 334         self.assertEquals("3", result["1"][1].label)
 335         self.assertEquals(15, result["2"][0].start)
 336         self.assertEquals(40, result["2"][0].stop)
 337         self.assertEquals(25, result["2"][0].length)
 338         self.assertEquals(32, result["2"][0].peakPos)
 339         self.assertEquals(17, result["2"][0].peakHeight)
 340         self.assertEquals("2", result["2"][0].label)
 341         self.assertEquals(65, result["2"][1].start)
 342         self.assertEquals(88, result["2"][1].stop)
 343         self.assertEquals(23, result["2"][1].length)
 344         self.assertEquals(72, result["2"][1].peakPos)
 345         self.assertEquals(7, result["2"][1].peakHeight)
 346         self.assertEquals("4", result["2"][1].label)
 347
 348         regionList = ["# comment"]
 349         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40"], "\t")
 350         regionList.append(regionEntry)
 351         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True)
 352         self.assertEquals(10, result["1"][0].start)
 353         self.assertEquals(20, result["1"][0].stop)
 354         self.assertEquals(10, result["1"][0].length)
 355         self.assertEquals(3, result["1"][0].peakPos)
 356         self.assertEquals(40, result["1"][0].peakHeight)
 357
 358         regionList = ["# pvalue"]
 359         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40", "any value"], "\t")
 360         regionList.append(regionEntry)
 361         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True)
 362         self.assertEquals(10, result["1"][0].start)
 363         self.assertEquals(20, result["1"][0].stop)
 364         self.assertEquals(10, result["1"][0].length)
 365         self.assertEquals(3, result["1"][0].peakPos)
 366         self.assertEquals(40, result["1"][0].peakHeight)
 367
 368         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, returnTop=1)
 369         self.assertEquals(10, result["1"][0].start)
 370         self.assertEquals(20, result["1"][0].stop)
 371         self.assertEquals(10, result["1"][0].length)
 372         self.assertEquals(3, result["1"][0].peakPos)
 373         self.assertEquals(40, result["1"][0].peakHeight)
 374
 375         regionList = ["# readShift"]
 376         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40", "any value"], "\t")
 377         regionList.append(regionEntry)
 378         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True)
 379         self.assertEquals(10, result["1"][0].start)
 380         self.assertEquals(20, result["1"][0].stop)
 381         self.assertEquals(10, result["1"][0].length)
 382         self.assertEquals(3, result["1"][0].peakPos)
 383         self.assertEquals(40, result["1"][0].peakHeight)
 384
 385         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, returnTop=1)
 386         self.assertEquals(10, result["1"][0].start)
 387         self.assertEquals(20, result["1"][0].stop)
 388         self.assertEquals(10, result["1"][0].length)
 389         self.assertEquals(3, result["1"][0].peakPos)
 390         self.assertEquals(40, result["1"][0].peakHeight)
 391
 392         regionList = ["# pvalue readShift"]
 393         regionEntry = string.join(["1", "chr1", "10", "20", "5", "3", "40", "any value", "any shift"], "\t")
 394         regionList.append(regionEntry)
 395         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True)
 396         self.assertEquals(10, result["1"][0].start)
 397         self.assertEquals(20, result["1"][0].stop)
 398         self.assertEquals(10, result["1"][0].length)
 399         self.assertEquals(3, result["1"][0].peakPos)
 400         self.assertEquals(40, result["1"][0].peakHeight)
 401
 402         result = commoncode.getMergedRegionsFromList(regionList, keepPeak=True, returnTop=1)
 403         self.assertEquals(10, result["1"][0].start)
 404         self.assertEquals(20, result["1"][0].stop)
 405         self.assertEquals(10, result["1"][0].length)
 406         self.assertEquals(3, result["1"][0].peakPos)
 407         self.assertEquals(40, result["1"][0].peakHeight)
 408
 409         #Test fails - the header line is required if there are fields after the peak which isn't so good
 410         #self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList[1:], keepPeak=True))
 411
 412
 413     def testRegionsOverlap(self):
 414         self.assertTrue(commoncode.regionsOverlap(100, 200, 1, 300))
 415         self.assertTrue(commoncode.regionsOverlap(100, 200, 150, 300))
 416         self.assertTrue(commoncode.regionsOverlap(100, 500, 1, 300))
 417         self.assertTrue(commoncode.regionsOverlap(100, 200, 110, 160))
 418
 419         self.assertFalse(commoncode.regionsOverlap(100, 200, 250, 300))
 420         self.assertFalse(commoncode.regionsOverlap(100, 200, 1, 60))
 421
 422         self.assertFalse(commoncode.regionsOverlap(-200, -100, 1, 300))
 423         self.assertFalse(commoncode.regionsOverlap(100, 200, -300, -1))
 424
 425         self.assertTrue(commoncode.regionsOverlap(-200, -100, -300, -1))
 426
 427         self.assertTrue(commoncode.regionsOverlap(-100, -200, -300, -1))
 428         self.assertTrue(commoncode.regionsOverlap(-200, -100, -1, -300))
 429         self.assertTrue(commoncode.regionsOverlap(-100, -200, -1, -300))
 430
 431
 432     def testRegionsAreWithinDistance(self):
 433         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 40, 50, 30))
 434         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 1, 5, 5))
 435         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 25, 50, 10))
 436         self.assertTrue(commoncode.regionsAreWithinDistance(10, 20, 1, 5, 5))
 437
 438         self.assertFalse(commoncode.regionsAreWithinDistance(10, 20, 100, 150, 5))
 439         self.assertFalse(commoncode.regionsAreWithinDistance(100, 200, 10, 15, 5))
 440
 441         self.assertTrue(commoncode.regionsAreWithinDistance(20, 10, 30, 150, 10))
 442         self.assertFalse(commoncode.regionsAreWithinDistance(20, 10, 100, 150, 5))
 443         self.assertFalse(commoncode.regionsAreWithinDistance(10, 20, 150, 100, 5))
 444
 445
 446     #TODO: write test
 447     def testFindPeak(self):
 448         hitList = []
 449         result = commoncode.findPeak(hitList, 0, 0)
 450         self.assertEquals([], result.topPos)
 451         self.assertEquals(0.0, result.numHits)
 452         self.assertEquals(array("f"), result.smoothArray)
 453         self.assertEquals(0.0, result.numPlus)
 454
 455         hitList= [{"start": 4, "sense": "+", "weight": 0.5}]
 456         result = commoncode.findPeak(hitList, 0, 10)
 457         self.assertEquals([6, 7], result.topPos)
 458         self.assertEquals(1.0, result.numHits)
 459         self.assertEquals(array("f", [0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.8888888955116272, 1.0, 1.0, 0.0, 0.0]), result.smoothArray)
 460         self.assertEquals(1.0, result.numPlus)
 461
 462         result = commoncode.findPeak(hitList, 0, 10, doWeight=True)
 463         self.assertEquals([6, 7], result.topPos)
 464         self.assertEquals(0.5, result.numHits)
 465         self.assertEquals(array('f', [0.0, 0.0, 0.0555555559694767, 0.1666666716337204, 0.3333333432674408, 0.4444444477558136, 0.5, 0.5, 0.0, 0.0]), result.smoothArray)
 466         self.assertEquals(0.5, result.numPlus)
 467
 468         result = commoncode.findPeak(hitList, 0, 10, shift="auto")
 469         self.assertEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], result.topPos)
 470         self.assertEquals(0.0, result.numHits)
 471         self.assertEquals(array("f", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]), result.smoothArray)
 472         self.assertEquals(0.0, result.numPlus)
 473
 474         result = commoncode.findPeak(hitList, 0, 10, shift="auto")
 475         self.assertEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], result.topPos)
 476         self.assertEquals(0.0, result.numHits)
 477         self.assertEquals(array("f", [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]), result.smoothArray)
 478         self.assertEquals(0.0, result.numPlus)
 479         self.assertEquals(6, result.shift)
 480
 481         hitList= [{"start": 4, "sense": "+", "weight": 0.5}]
 482         result = commoncode.findPeak(hitList, 0, 10, shift=3)
 483         self.assertEquals([7], result.topPos)
 484         self.assertEquals(1.0, result.numHits)
 485         self.assertEquals(array('f', [0.0, 0.0, 0.0, 0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.0, 0.0]), result.smoothArray)
 486         self.assertEquals(1.0, result.numPlus)
 487         self.assertEquals(3, result.shift)
 488
 489         hitList= [{"start": 4, "sense": "+", "weight": 0.5}]
 490         result = commoncode.findPeak(hitList, 0, 10, leftPlus=True)
 491         self.assertEquals([6, 7], result.topPos)
 492         self.assertEquals(1.0, result.numHits)
 493         self.assertEquals(array('f', [0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.8888888955116272, 1.0, 1.0, 0.0, 0.0]), result.smoothArray)
 494         self.assertEquals(1.0, result.numPlus)
 495         self.assertEquals(1.0, result.numLeftPlus)
 496
 497         result = commoncode.findPeak(hitList, 0, 10, leftPlus=True, shift=3)
 498         self.assertEquals([7], result.topPos)
 499         self.assertEquals(1.0, result.numHits)
 500         self.assertEquals(array('f', [0.0, 0.0, 0.0, 0.0, 0.0, 0.1111111119389534, 0.3333333432674408, 0.66666668653488159, 0.0, 0.0]), result.smoothArray)
 501         self.assertEquals(1.0, result.numPlus)
 502         self.assertEquals(1.0, result.numLeftPlus)
 503         self.assertEquals(3, result.shift)
 504
 505
 506     #TODO: write test
 507     def testGetBestShiftForRegion(self):
 508         hitList = [{"start": 14, "sense": "-", "weight": 1.0},
 509                    {"start": 16, "sense": "-", "weight": 1.0},
 510                    {"start": 24, "sense": "+", "weight": 1.0},
 511                    {"start": 26, "sense": "+", "weight": 10.0}
 512         ]
 513         self.assertEquals(74, commoncode.getBestShiftForRegion(hitList, 0, 100))
 514         self.assertEquals(16, commoncode.getBestShiftForRegion(hitList, 0, 100, maxShift=30))
 515         self.assertEquals(0, commoncode.getBestShiftForRegion(hitList, 0, 100, maxShift=10))
 516
 517
 518     #TODO: write test
 519     def testFindPeakSequenceArray(self):
 520         pass
 521
 522
 523     #TODO: write test
 524     def testGetPeakPositionList(self):
 525         pass
 526
 527
 528     #TODO: write test
 529     def testGetFeaturesByChromDict(self):
 530         firstFeatures = {"I": (4123, 4219, "Y74C9A.3", "R", "3UTR"),
 531                          "II": (1866, 1910, "2L52.1", "F", "CDS"),
 532                          "III": (1270, 1506, "cTel54X.1", "R", "CDS"),
 533                          "IV": (694, 1064, "Y38C1AB.4", "F", "CDS"),
 534                          "V": (1479, 1578, "cTel3X.1", "F", "CDS"),
 535                          "X": (3622, 4099, "CE7X_3.1", "F", "CDS"),
 536                          "MtDNA": (112, 543, "MTCE.3", "F", "CDS")
 537         }
 538         featureDict = commoncode.getFeaturesByChromDict(self.genome)
 539         for chrom in featureDict.keys():
 540             self.assertTrue(chrom in self.celegansChroms)
 541             self.assertEquals(firstFeatures[chrom], featureDict[chrom][0])
 542
 543         restrictList = ["almost certainly not a value feature"]
 544         featureDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList)
 545         self.assertEquals({}, featureDict)
 546
 547         restrictList = ["Y74C9A.3"]
 548         featureDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList)
 549         self.assertEquals(["I"], featureDict.keys())
 550         featureDict, complementDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList, regionComplement=True)
 551         result = {"I": [(0, 4123, "nonExon1", "F", "nonExon"),
 552                         (4219, 4220, "nonExon2", "F", "nonExon"),
 553                         (4357, 5194, "nonExon3", "F", "nonExon"),
 554                         (5295, 6036, "nonExon4", "F", "nonExon"),
 555                         (6326, 9726, "nonExon5", "F", "nonExon"),
 556                         (9845, 10094, "nonExon6", "F", "nonExon"),
 557                         (10147, 10148, "nonExon7", "F", "nonExon"),
 558                         (10231, 250000000, "nonExon8", "F", "nonExon")]
 559         }
 560         self.assertEquals(result, complementDict)
 561
 562         additionalRegion = Region.Region(100, 150)
 563         additionalRegion.label = "new feature"
 564         regionDict = {"I": [additionalRegion]}
 565         featureDict = commoncode.getFeaturesByChromDict(self.genome, additionalRegionsDict=regionDict)
 566         result = (100, 150, "new feature", "+", "custom")
 567         self.assertEquals(result, featureDict["I"][0])
 568
 569
 570
 571     def testGetLocusByChromDict(self):
 572         firstLoci = {"I": (4123, 10231, "Y74C9A.3", 6108),
 573                      "II": (1866, 4662, "2L52.1", 2796),
 574                      "III": (1270, 2916, "cTel54X.1", 1646),
 575                      "IV": (694, 14925, "Y38C1AB.4", 14231),
 576                      "V": (1479, 3038, "cTel3X.1", 1559),
 577                      "X": (3622, 7153, "CE7X_3.1", 3531),
 578                      "MtDNA": (112, 548, "MTCE.3", 436)
 579         }
 580
 581         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, useCDS=False))
 582         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=1, downstream=1, useCDS=False))
 583         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=-1, downstream=-1, useCDS=False, lengthCDS=1))
 584         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstreamSpanTSS=True, lengthCDS=1))
 585         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, downstream=1, lengthCDS=1))
 586         self.assertEquals({}, commoncode.getLocusByChromDict(self.genome, upstream=1, lengthCDS=-1))
 587
 588         locusDict = commoncode.getLocusByChromDict(self.genome)
 589         for chrom in locusDict.keys():
 590             self.assertTrue(chrom in self.celegansChroms)
 591             self.assertEquals(firstLoci[chrom], locusDict[chrom][0])
 592
 593         additionalRegion = Region.Region(100, 150)
 594         additionalRegion.label = "new region"
 595         regionDict = {"I": [additionalRegion]}
 596         locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict)
 597         self.assertEquals((100, 150, "new region", 50), locusDict["I"][0])
 598         locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, keepSense=True)
 599         self.assertEquals((100, 150, "new region", 50, "+"), locusDict["I"][0])
 600
 601         # Long Test
 602         #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, upstream=100)
 603         #self.assertEquals((150, 250, "new region", 100), locusDict["I"][0])
 604
 605         # Long Test
 606         #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, downstream=10)
 607         #self.assertEquals((90, 100, "new region", 10), locusDict["I"][0])
 608
 609
 610     def testComputeRegionBins(self):
 611         regionsByChromDict = {}
 612         hitDict = {}
 613         bins = 4
 614         readlen = 10
 615         result = ({}, {})
 616         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 617
 618         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 619         result = ({"regionID": [0.0, 0.0, 0.0, 0.0]}, {})
 620         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 621
 622         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 623         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 624         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 625         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 626
 627         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 628                               "2": [("regionID2", 1, 1000, 1000, "F")]
 629         }
 630         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 631                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 632         }
 633         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 634         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 635
 636         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 637         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 80, "sense": "+", "weight": 0.5}]}
 638         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 639         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 640
 641         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 642         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 80, "sense": "+", "weight": 0.5}, {"start": 15, "sense": "+", "weight": 1.0}]}
 643         result = ({"regionID": [2.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 644         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 645
 646         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 647         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 80, "sense": "+", "weight": 0.5}, {"start": 200, "sense": "+", "weight": 2.0}]}
 648         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 649         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 650
 651         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 652         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 653         regionList = ["regionID"]
 654         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 655         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 656
 657         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 658         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 659         regionList = ["empty region"]
 660         result = ({"empty region": [0.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 661         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 662
 663         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 664                               "2": [("regionID2", 1, 1000, 1000, "F")]
 665         }
 666         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 667                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 668         }
 669         regionList = ["regionID", "regionID2"]
 670         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 671         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 672
 673         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 674                               "2": [("regionID2", 1, 1000, 1000, "F")]
 675         }
 676         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 677                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 678         }
 679         regionList = ["empty region", "regionID2"]
 680         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0], "empty region": [0.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 681         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 682
 683         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
 684                               "2": [("regionID2", 1, 1000, 1000, "F")]
 685         }
 686         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
 687                    "2": [{"start": 1, "sense": "+", "weight": 1.0}]
 688         }
 689         regionList = ["regionID2"]
 690         result = ({"regionID2": [1.0, 0.0, 0.0, 0.0]}, {"regionID2": 1000, "regionID": 100})
 691         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, regionList))
 692
 693         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 694         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 695         result = ({"regionID": [2.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 696         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, normalizedTag=2.0))
 697
 698         regionsByChromDict = {"1": [(1, 100, "regionID", 100, "F")]}
 699         hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}]}
 700         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 701         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, defaultRegionFormat=False))
 702
 703         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 704         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}]}
 705         fixedFirstBin = 20
 706         result = ({"regionID": [1.0, 0.0, 0.0, 0.0]}, {"regionID": 100})
 707         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 708
 709         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 710         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}]}
 711         fixedFirstBin = 5
 712         result = ({"regionID": [0.0, 1.0, 0.0, 0.0]}, {"regionID": 100})
 713         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 714
 715         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 716         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 717         fixedFirstBin = 20
 718         result = ({"regionID": [1.0, 0.5, 0.0, 0.0]}, {"regionID": 100})
 719         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 720
 721         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 722         hitDict = {"1": [{"start": 80, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 723         fixedFirstBin = 5
 724         result = ({"regionID": [0.0, 1.5, 0.0, 0.0]}, {"regionID": 100})
 725         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 726
 727         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 728         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 729         binLength = 25
 730         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 731         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 732
 733         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 734         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 735         binLength = 50
 736         result = ({"regionID": [1.0, 0.5, 0.0, 0.0]}, {"regionID": 100})
 737         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 738
 739         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 740         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
 741         binLength = 15
 742         result = ({"regionID": [1.0, 0.0, 0.0, 0.5]}, {"regionID": 100})
 743         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 744
 745         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
 746         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 40, "sense": "+", "weight": 0.7}, {"start": 85, "sense": "+", "weight": 0.5}]}
 747         binLength = 15
 748         result = ({"regionID": [1.0, 0.0, 0.7, 0.5]}, {"regionID": 100})
 749         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 750
 751         regionsByChromDict = {"1": [("regionID", 1, 100, 100, "R")]}
 752         hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 40, "sense": "+", "weight": 0.7}, {"start": 85, "sense": "+", "weight": 0.5}]}
 753         result = ({"regionID": [0.5, 0.0, 0.7, 1.0]}, {"regionID": 100})
 754         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
 755         result = ({"regionID": [0.5, 0.0, 0.7, 1.0]}, {"regionID": 100})
 756         fixedFirstBin = 10
 757         result = ({"regionID": [0.0, 2.2, 0.0, 0.0]}, {"regionID": 100})
 758         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 759         fixedFirstBin = 20
 760         result = ({"regionID": [0.5, 1.7, 0.0, 0.0]}, {"regionID": 100})
 761         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, fixedFirstBin=fixedFirstBin))
 762         binLength = 50
 763         result = ({"regionID": [0.5, 1.7, 0.0, 0.0]}, {"regionID": 100})
 764         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 765         binLength = 10
 766         result = ({"regionID": [0.0, 0.5, 0.0, 1.7]}, {"regionID": 100})
 767         self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen, binLength=binLength))
 768
 769
 770 def suite():
 771     suite = unittest.TestSuite()
 772     suite.addTest(unittest.makeSuite(TestCommoncode))
 773
 774     return suite
 775
 776
 777 if __name__ == "__main__":
 778     #import sys;sys.argv = ['', 'Test.testName']
 779     unittest.main()