def test_chain_sorted__mixed_contents():
sequence_a = (3, 4, 8)
sequence_c = (0, 1, 6)
sequence_b = (2, 5, 7)
expected = (0, 1, 2, 3, 4, 5, 6, 7, 8)
result = tuple(utils.chain_sorted(sequence_a, sequence_b, sequence_c))
assert_equal(expected, result)
def test_chain_sorted__mixed_length_contents():
sequence_a = (1, )
sequence_c = (0, 2)
sequence_b = ()
expected = (0, 1, 2)
result = tuple(utils.chain_sorted(sequence_a, sequence_b, sequence_c))
assert_equal(expected, result)
def test_chain_sorted__stable_sort():
object_a = [1]
object_b = [1]
object_c = [2]
object_d = [2]
seq_a = [object_a, object_c]
seq_b = [object_b, object_d]
expected = (object_a, object_b, object_c, object_d)
result = tuple(utils.chain_sorted(seq_a, seq_b))
assert_equal(expected, result)
assert (all(a is b for (a, b) in zip(expected, result)))
expected = (object_b, object_a, object_d, object_c)
result = tuple(utils.chain_sorted(seq_b, seq_a))
assert_equal(expected, result)
assert (all(a is b for (a, b) in zip(expected, result)))
def test_chain_sorted__identical_objects_are_preserved():
object_a = [1]
object_b = [1]
assert object_a is not object_b
expected = (object_a, object_b)
result = tuple(utils.chain_sorted([object_a], [object_b]))
assert_equal(expected, result)
assert (object_a is result[0] or object_a is result[1])
assert (object_b is result[0] or object_b is result[1])
def _open_samfiles(handles, filenames):
sequences = []
for filename in filenames:
handle = pysam.AlignmentFile(filename)
handles.append(handle)
sequences.append(_read_samfile(handle, filename))
return chain_sorted(*sequences, key=_key_by_tid_pos)
def _open_samfiles(cls, handles, filenames):
sequences = []
for filename in filenames:
handle = pysam.Samfile(filename)
handles.append(handle)
sequences.append(cls._read_samfile(handle, filename))
return chain_sorted(*sequences, key=cls._key_by_tid_pos)
def test_chain_sorted__runs_of_values():
object_a = [1]
object_b = [1]
object_c = [2]
object_d = [2]
seq_a = [object_a, object_b]
seq_b = [object_c, object_d]
expected = (object_a, object_b, object_c, object_d)
result = tuple(utils.chain_sorted(seq_a, seq_b))
assert_equal(expected, result)
assert (all(a is b for (a, b) in zip(expected, result)))
def test_chain_sorted__invalid_keywords():
assert_raises(TypeError, tuple, utils.chain_sorted((1, 2, 3), foobar=None))
def test_chain_sorted__mixed_contents__key():
sequence_a = (-2, -3, -5)
sequence_b = (0, -1, -4)
expected = (0, -1, -2, -3, -4, -5)
result = tuple(utils.chain_sorted(sequence_a, sequence_b, key=abs))
assert_equal(expected, result)
def _sequential_contents(seq_a, seq_b):
expected = (1, 2, 3, 4, 5, 6)
result = tuple(utils.chain_sorted(seq_a, seq_b))
assert_equal(expected, result)
def test_chain_sorted__single_sequence():
sequence = (1, 2, 3)
result = tuple(utils.chain_sorted(sequence))
assert_equal(sequence, result)
def test_chain_sorted__no_sequences():
expected = ()
result = tuple(utils.chain_sorted())
assert_equal(expected, result)
def test_chain_sorted__invalid_keywords():
with pytest.raises(TypeError):
tuple(utils.chain_sorted((1, 2, 3), foobar=None))
def test_chain_sorted__sequential_contents(seq_a, seq_b):
expected = (1, 2, 3, 4, 5, 6)
result = tuple(utils.chain_sorted(seq_a, seq_b))
assert expected == result