def _runFlankSegmentsTest(self, starts, ends, expStarts, expEnds,
nrBP, after=True, before=True):
"""
Run a test on the creation of a Flank track from a segmented track.
The test expects there to only to be segments in chr1,
All other chromosomes need to be of size zero.
:param startsA: Arrays of starts in track.
:param endsA: Array of ends in track.
:param expStarts: Expected starts of flanks.
:param expEnds: Expected ends of flanks.
:parap nrBP: INT. Size of flank i base pairs.
:param after: Boolean. Flanks from the starts.
:param before: Boolean. Flanks form the ends.
:return:
"""
track = self._createTrackContent(starts, ends)
f = Flank(track)
# Result track type is Segments as default
f.setFlankSize(nrBP)
f.setAfter(after)
f.setBefore(before)
tc = f()
for (k, v) in tc.getTrackViews().items():
print expStarts
print v.startsAsNumpyArray()
print expEnds
print v.endsAsNumpyArray()
if cmp(k, self.chr1) == 0:
# All test tracks are in chr1
self.assertTrue(np.array_equal(v.startsAsNumpyArray(),
expStarts))
self.assertTrue(np.array_equal(v.endsAsNumpyArray(), expEnds))
else:
# Tests if all tracks no in chr1 have a size of 0.
self.assertEqual(v.startsAsNumpyArray().size, 0)
self.assertEqual(v.endsAsNumpyArray().size, 0)
def _runTest(self, starts=None, ends=None, values=None, strands=None,
ids=None, edges=None, weights=None, extras=None,
expStarts=None, expEnds=None, expValues=None,
expStrands=None, expIds=None, expEdges=None,
expWeights=None, expExtras=None, customChrLength=None,
resultAllowOverlap=False, upstream=None, downstream=None,
both=None, useFraction=False, useStrands=True,
treatMissingAsNegative=False, debug=False,
expTrackFormatType=None):
track = createSimpleTestTrackContent(startList=starts, endList=ends,
valList=values,
strandList=strands,
idList=ids, edgeList=edges,
weightsList=weights,
extraLists=extras,
customChrLength=customChrLength)
if both is not None:
self.assertTrue((downstream is None and upstream is None))
else:
self.assertTrue((downstream is not None or upstream is not None))
f = Flank(track, both=both, downstream=downstream, upstream=upstream,
resultAllowOverlap=resultAllowOverlap,
useStrands=useStrands, useFraction=useFraction,
treatMissingAsNegative=treatMissingAsNegative,
debug=debug)
self.assertTrue((f is not None))
result = f.calculate()
resFound = False
for (k, v) in result.getTrackViews().items():
if cmp(k, self.chr1) == 0 or cmp(k, self.chr1Small) == 0:
# All test tracks are in chr1
resFound = True
newStarts = v.startsAsNumpyArray()
newEnds = v.endsAsNumpyArray()
newValues = v.valsAsNumpyArray()
newStrands = v.strandsAsNumpyArray()
newIds = v.idsAsNumpyArray()
newEdges = v.edgesAsNumpyArray()
newWeights = v.weightsAsNumpyArray()
newExtras = v.allExtrasAsDictOfNumpyArrays()
if debug:
print("newStarts: {}".format(newStarts))
print("expStarts: {}".format(expStarts))
print("newEnds: {}".format(newEnds))
print("expEnds: {}".format(expEnds))
print("newStrands: {}".format(newStrands))
print("expStrands: {}".format(expStrands))
print("newIds: {}".format(newIds))
print("expIds: {}".format(expIds))
print("newEdges: {}".format(newEdges))
print("expEdges: {}".format(expEdges))
if expTrackFormatType is not None:
# Check that the track is of the expected type.
self.assertTrue(v.trackFormat.getFormatName() ==
expTrackFormatType)
if expEnds is None:
# Assuming a point type track. Creating the expected ends.
expEnds = np.array(expStarts) + 1
if expStarts is not None:
self.assertTrue(newStarts is not None)
self.assertTrue(np.array_equal(newStarts, expStarts))
else:
self.assertTrue(newStarts is None)
if expEnds is not None:
self.assertTrue(newEnds is not None)
self.assertTrue(np.array_equal(newEnds, expEnds))
else:
self.assertTrue(newEnds is None)
if expValues is not None:
self.assertTrue(newValues is not None)
self.assertTrue(np.array_equal(newValues, expValues))
else:
self.assertTrue(newValues is None)
if expStrands is not None:
self.assertTrue(newStrands is not None)
self.assertTrue(np.array_equal(newStrands, expStrands))
else:
self.assertTrue(newStrands is None)
if expIds is not None:
self.assertTrue(newIds is not None)
self.assertTrue(np.array_equal(newIds, expIds))
else:
self.assertTrue(newIds is None)
if expEdges is not None:
self.assertTrue(newEdges is not None)
self.assertTrue(np.array_equal(newEdges, expEdges))
else:
self.assertTrue(newEdges is None)
if expWeights is not None:
self.assertTrue(newWeights is not None)
self.assertTrue(np.array_equal(newWeights, expWeights))
else:
self.assertTrue(newWeights is None)
if expExtras is not None:
for key in expExtras.keys():
self.assertTrue(v.hasExtra(key))
expExtra = expExtras[key]
newExtra = newExtras[key]
self.assertTrue(np.array_equal(newExtra, expExtra))
else:
self.assertTrue(len(newExtras) == 0)
else:
# Tests if all tracks no in chr1 have a size of 0.
self.assertEqual(v.size, 0)
self.assertTrue(resFound)
