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.."