2 Created on Aug 30, 2010
9 from array import array
10 from erange import commoncode
11 from cistematic.genomes import Genome
14 class TestCommoncode(unittest.TestCase):
15 logFile = "testLogFile"
16 celegansChroms = ["I", "II", "III", "IV", "V", "X", "MtDNA"]
17 genome = Genome("celegans")
25 os.remove(self.logFile)
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")
40 def testCountDuplicatesInList(self):
42 self.assertEquals([], commoncode.countDuplicatesInList(testList))
45 result = [(0, 1), (1, 1)]
46 self.assertEquals(result, commoncode.countDuplicatesInList(testList))
49 result = [(0, 1), (1, 2)]
50 self.assertEquals(result, commoncode.countDuplicatesInList(testList))
52 testList = [0, 1, 2, 1]
53 result = [(0, 1), (1, 2), (2, 1)]
54 self.assertEquals(result, commoncode.countDuplicatesInList(testList))
57 def testWriteLog(self):
58 messenger = "testMessenger"
59 message = "testMessage"
61 commoncode.writeLog(self.logFile, messenger, message)
62 file = open(self.logFile)
63 line = file.readline()
65 self.assertEquals(fields[2], "[%s]" % messenger)
66 self.assertEquals(fields[3], message)
67 line = file.readline()
68 self.assertEquals("", line)
70 messenger2 = "testMessenger2"
71 message2 = "testMessage2"
73 commoncode.writeLog(self.logFile, messenger2, message2)
74 file = open(self.logFile)
75 line = file.readline()
77 self.assertEquals(fields[2], "[%s]" % messenger)
78 self.assertEquals(fields[3], message)
79 line = file.readline()
81 self.assertEquals(fields[2], "[%s]" % messenger2)
82 self.assertEquals(fields[3], message2)
83 line = file.readline()
84 self.assertEquals("", line)
86 os.remove(self.logFile)
88 commoncode.writeLog(self.logFile, messenger, message)
89 file = open(self.logFile)
90 line = file.readline()
92 self.assertEquals(fields[2], "[%s]" % messenger)
93 self.assertEquals(fields[3], message)
94 line = file.readline()
95 self.assertEquals("", line)
97 os.remove(self.logFile)
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)
108 os.remove(self.logFile)
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)
120 def testGetMergedRegions(self):
121 testfile = open("regionTestFile", "w")
122 regionEntry = string.join(["1", "chr1", "10", "20", "5"], "\t")
123 testfile.write(regionEntry)
125 result = {"1": [(10, 20, 10)]}
126 self.assertEquals(result, commoncode.getMergedRegions("regionTestFile"))
127 os.remove("regionTestFile")
130 def testGetMergedRegionsFromList(self):
131 self.assertEquals({}, commoncode.getMergedRegionsFromList([]))
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))
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))
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))
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))
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))
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))
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)]
214 self.assertEquals(result, commoncode.getMergedRegionsFromList(regionList, keepPeak=True, keepLabel=True, doMerge=False))
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))
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))
247 self.assertFalse(commoncode.regionsOverlap(100, 200, 250, 300))
248 self.assertFalse(commoncode.regionsOverlap(100, 200, 1, 60))
250 self.assertFalse(commoncode.regionsOverlap(-200, -100, 1, 300))
251 self.assertFalse(commoncode.regionsOverlap(100, 200, -300, -1))
253 self.assertTrue(commoncode.regionsOverlap(-200, -100, -300, -1))
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))
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))
266 self.assertFalse(commoncode.regionsAreWithinDistance(10, 20, 100, 150, 5))
267 self.assertFalse(commoncode.regionsAreWithinDistance(100, 200, 10, 15, 5))
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))
275 def testFindPeak(self):
277 result = ([], 0.0, array("f"), 0.0)
278 self.assertEquals(result, commoncode.findPeak(hitList, 0, 0))
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))
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))
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))
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}
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))
314 def testFindPeakSequenceArray(self):
319 def testGetPeakPositionList(self):
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")
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])
338 restrictList = ["almost certainly not a value feature"]
339 featureDict = commoncode.getFeaturesByChromDict(self.genome, restrictList=restrictList)
340 self.assertEquals({}, featureDict)
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")]
355 self.assertEquals(result, complementDict)
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])
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)
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))
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])
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])
392 #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, upstream=100)
393 #self.assertEquals((150, 250, "new region", 100), locusDict["I"][0])
396 #locusDict = commoncode.getLocusByChromDict(self.genome, additionalRegionsDict=regionDict, useCDS=False, downstream=10)
397 #self.assertEquals((90, 100, "new region", 10), locusDict["I"][0])
400 def testComputeRegionBins(self):
401 regionsByChromDict = {}
406 self.assertEquals(result, commoncode.computeRegionBins(regionsByChromDict, hitDict, bins, readlen))
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))
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))
417 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
418 "2": [("regionID2", 1, 1000, 1000, "F")]
420 hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
421 "2": [{"start": 1, "sense": "+", "weight": 1.0}]
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))
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))
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))
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))
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))
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))
453 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
454 "2": [("regionID2", 1, 1000, 1000, "F")]
456 hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
457 "2": [{"start": 1, "sense": "+", "weight": 1.0}]
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))
463 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
464 "2": [("regionID2", 1, 1000, 1000, "F")]
466 hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
467 "2": [{"start": 1, "sense": "+", "weight": 1.0}]
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))
473 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")],
474 "2": [("regionID2", 1, 1000, 1000, "F")]
476 hitDict = {"1": [{"start": 1, "sense": "+", "weight": 1.0}],
477 "2": [{"start": 1, "sense": "+", "weight": 1.0}]
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))
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))
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))
493 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
494 hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}]}
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))
499 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
500 hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}]}
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))
505 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
506 hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
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))
511 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
512 hitDict = {"1": [{"start": 80, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.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))
517 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
518 hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
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))
523 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
524 hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
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))
529 regionsByChromDict = {"1": [("regionID", 1, 100, 100, "F")]}
530 hitDict = {"1": [{"start": 10, "sense": "+", "weight": 1.0}, {"start": 85, "sense": "+", "weight": 0.5}]}
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))
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}]}
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))
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})
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))
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))
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))
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))
561 suite = unittest.TestSuite()
562 suite.addTest(unittest.makeSuite(TestCommoncode))
567 if __name__ == "__main__":
568 #import sys;sys.argv = ['', 'Test.testName']