def test_deglitcher_single2():
# threshold=1, no modification
input_ = testing.makeSimpleTrack('input', testing.shortcodeToSegiter("A."))
# input: A.
# result: A.
r = core.deglitcher(input_)
assert testing.segiterToShortcode(r) == "A."
def test_tester_longreps():
input_ = testing.makeSimpleTrack(
'input', testing.shortcodeToSegiter("0000000000000000"))
# input: 0000000000000000
# result: 0...............
r = core.cleaner(input_)
assert testing.segiterToShortcode(r) == "0..............."
def test_replacer_example2(input_):
# input: ABCA.B.C.A..B..C..A...
# result: ABCAnBnCnAn.Bn.Cn.An..
# split segments into two, conserving duration
r = core.replacer(input_, lambda dur, _: (dur >= 2), lambda dur, v:
((1, v), (dur - 1, n)))
assert testing.segiterToShortcode(r) == "ABCAnBnCnAn.Bn.Cn.An.."
def test_replacer_example3(input_):
# input: ABCA.B.C.A..B..C..A...
# result: ABn.CA.B.n.C.A..B..n.C..A...
# insert a special segment after each matching one
r = core.replacer(input_, lambda _, v: (v == B), lambda dur, v: ((dur, v),
(2, n)))
assert testing.segiterToShortcode(r) == "ABn.CA.B.n.C.A..B..n.C..A..."
def test_regionselector_allrun():
# input: R.....................
# result: R.....................
input_ = testing.makeSimpleTrack(
'input', testing.shortcodeToSegiter("R....................."))
r = core.transitionGenerator(input_, 0, d, u, 1, 1)
assert testing.segiterToShortcode(r) == "R....................."
def test_tester_long_and_invert():
input_ = testing.makeSimpleTrack(
'input', testing.shortcodeToSegiter("00000000000000001"))
# input: 00000000000000001
# result: 0...............1
r = core.cleaner(input_)
assert testing.segiterToShortcode(r) == "0...............1"
def test_deglitcher_trailingshort():
# threshold=1, trailing should be unmodified
input_ = testing.makeSimpleTrack('input',
testing.shortcodeToSegiter("AB.A"))
# input: AB.A
# result: B..A
r = core.deglitcher(input_)
assert testing.segiterToShortcode(r) == "B..A"
def test_replacer_example5(input_):
# input: ABCA.B.C.A..B..C..A...
# result: ABCn.B.C.A..B..C..n...
# replace every second matching segment
def repEverySecond(dur, _):
global counter
counter += 1
if counter % 2 == 0:
# do not modify segment
return core.VALUE_PASSTHROUGH
return ((dur, n), )
r = core.replacer(input_, lambda _, v: (v == A), repEverySecond)
assert testing.segiterToShortcode(r) == "ABCn.B.C.A..B..C..n..."
def test_replacer_example4(input_):
# input: ABCA.B.C.A..B..C..A...
# result: BCB.C.B..C..
# remove segments with specific value
r = core.replacer(input_, lambda _, v: (v == A), lambda *_: tuple())
assert testing.segiterToShortcode(r) == "BCB.C.B..C.."
def test_regionselector_nonempty_mid3(input_):
# input: ABCD.E.F.G..H..I..
# result: G..
r = core.regionSelector(input_, 9, 12)
assert testing.segiterToShortcode(r) == "G.."
def test_tester_passthrough_negative(input_):
# input: ABCA.B.C.A..B..C..
# result4: ABCY.Y.Y.A..B..C..
r = core.tester(input_, lambda dur, v: (dur == 2),
(Y, core.VALUE_PASSTHROUGH))
assert testing.segiterToShortcode(r) == "ABCY.Y.Y.A..B..C.."
def test_tester_passthrough_positive(input_):
# input: ABCA.B.C.A..B..C..
# result3: nnnA.B.C.n..n..n..
r = core.tester(input_, lambda dur, v: (dur == 2),
(core.VALUE_PASSTHROUGH, n))
assert testing.segiterToShortcode(r) == "nnnA.B.C.n..n..n.."
def test_replacer_set_dur_to_one(input_):
# input: ABCA.B.C.A..B..C..A...
# result: ABCABCABCA
r = core.replacer(input_, core.FILTER_ALWAYS_TRUE, lambda _, v: ((1, v), ))
assert testing.segiterToShortcode(r) == "ABCABCABCA"
def test_replacer_always_false_filter(input_):
# input: ABCA.B.C.A..B..C..A...
# result: ABCA.B.C.A..B..C..A...
r = core.replacer(input_, core.FILTER_ALWAYS_FALSE, lambda _, v:
((1, v), ))
assert testing.segiterToShortcode(r) == "ABCA.B.C.A..B..C..A..."
def test_regionselector_example1(input_):
# input: 0.R0R0.R0..R0...R0....
# result: duR0RduRd0uRd0.uRd0..u
# equal-weight, minimum durations
r = core.transitionGenerator(input_, 0, d, u, 1, 1)
assert testing.segiterToShortcode(r) == "duR0RduRd0uRd0.uRd0..u"
def test_deglitcher_all_under_threshold(input_):
# input: ABC.D.E..F..G...H..I...
# result: I......................
r = core.deglitcher(input_, 4)
assert testing.segiterToShortcode(r) == "I......................"
def test_tester_plain_replace(input_):
# input: ABCA.B.C.A..B..C..
# result2: nnnn.Y.n.n..n..n..
r = core.tester(input_, lambda dur, v: (v == B and dur == 2), (Y, n))
assert testing.segiterToShortcode(r) == "nnnn.Y.n.n..n..n.."
def test_regionselector_example2(input_):
# input: 0.R0R0.R0..R0...R0....
# result: duR0RduRdu.Rd0u.Rd0.u.
# post-duration is twice as long as pre
r = r2 = core.transitionGenerator(input_, 0, d, u, 1, 2)
assert testing.segiterToShortcode(r) == "duR0RduRdu.Rd0u.Rd0.u."
def test_regionselector_example3(input_):
# input: 0.R0R0.R0..R0...R0....
# result: duR0RduRdu.Rd.u.Rd.0u.
# equal weights, but longer ones, latter will win in odd-tie ins
r = core.transitionGenerator(input_, 0, d, u, 2, 2)
assert testing.segiterToShortcode(r) == "duR0RduRdu.Rd.u.Rd.0u."
def test_cleaner_plain(input_):
# input: 00110.1.0.01.111100000101
# result: 0.1.0.1.0..1.....0....101
r = core.cleaner(input_)
assert testing.segiterToShortcode(r) == "0.1.0.1.0..1.....0....101"
def test_regionselector_empty(input_):
# input: ABCD.E.F.G..H..I..
# result:
r = core.regionSelector(input_, 0, 0)
assert testing.segiterToShortcode(r) == ""
def test_regionselector_example5(input_):
# input: ABCD.E.F.G..H..I..
# result: I
r = core.regionSelector(input_, 17, 100)
assert testing.segiterToShortcode(r) == "I"
def test_regionselector_example2(input_):
# input: ABCD.E.F.G..H..I..
# result: DE
r = core.regionSelector(input_, 4, 6)
assert testing.segiterToShortcode(r) == "DE"
def test_tester_short2():
input_ = testing.makeSimpleTrack('input', testing.shortcodeToSegiter("0."))
# input: 0.
# result: 0.
r = core.cleaner(input_)
assert testing.segiterToShortcode(r) == "0."
def test_deglicher_zero(input_):
# input: ABC.D.E..F..G...H..I...
# result: ABC.D.E..F..G...H..I...
r = core.deglitcher(input_, 0)
assert testing.segiterToShortcode(r) == "ABC.D.E..F..G...H..I..."
def test_deglitcher_default(input_):
# threshold=1, A and B will be merged forward into C
# input: ABC.D.E..F..G...H..I...
# result: C...D.E..F..G...H..I...
r = core.deglitcher(input_)
assert testing.segiterToShortcode(r) == "C...D.E..F..G...H..I..."
def test_tester_plain(input_):
# input: ABCA.B.C.A..B..C..
# result1: 0000.1.0.0..0..0..
r = core.tester(input_, lambda dur, v: (v == B and dur == 2))
assert testing.segiterToShortcode(r) == "0000.1.0.0..0..0.."
