397 lines
8.3 KiB
Rust
397 lines
8.3 KiB
Rust
mod util;
|
|
|
|
use otvec::Operation;
|
|
use util::{test_transform, test_transform_sym};
|
|
|
|
use rstest::rstest;
|
|
|
|
#[rstest]
|
|
#[case(0, 1, 0, &[1, 2, 3, 4, 5])]
|
|
#[case(0, 1, 1, &[1, 2, 3, 4, 5])]
|
|
#[case(0, 1, 2, &[2, 1, 3, 4, 5])]
|
|
fn apply_mov(#[case] pos: usize, #[case] n: usize, #[case] to: usize, #[case] expect: &[i32]) {
|
|
let mut input = vec![1, 2, 3, 4, 5];
|
|
let op = Operation::Mov { pos, n, to };
|
|
op.apply(&mut input);
|
|
assert_eq!(input, expect);
|
|
}
|
|
|
|
#[test]
|
|
fn print() {
|
|
let input = vec![1, 2, 3, 4, 5];
|
|
|
|
let op = Operation::Mov {
|
|
pos: 1,
|
|
n: 2,
|
|
to: 4,
|
|
};
|
|
op.print_on(&input);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_ins() {
|
|
let a = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![2],
|
|
};
|
|
let b = Operation::Ins {
|
|
pos: 2,
|
|
val: vec![4],
|
|
};
|
|
test_transform_sym(&a, &b, &[1, 3, 5], &[1, 2, 3, 4, 5]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_ins_same_pos() {
|
|
let input = [1, 4];
|
|
|
|
let a = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![2],
|
|
};
|
|
let b = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![3],
|
|
};
|
|
test_transform(&a, &b, &input, &[1, 2, 3, 4]);
|
|
test_transform(&b, &a, &input, &[1, 3, 2, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_ins_mult() {
|
|
let a = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![2, 3],
|
|
};
|
|
let b = Operation::Ins {
|
|
pos: 2,
|
|
val: vec![5, 6, 7],
|
|
};
|
|
test_transform_sym(&a, &b, &[1, 4, 8], &[1, 2, 3, 4, 5, 6, 7, 8]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_del_del() {
|
|
let a = Operation::Del { pos: 1, n: 1 };
|
|
let b = Operation::Del { pos: 3, n: 1 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4, 5], &[1, 3, 5]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_del_del_same_pos() {
|
|
let a = Operation::Del { pos: 1, n: 1 };
|
|
let b = Operation::Del { pos: 1, n: 1 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3], &[1, 3]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_del_del_mult() {
|
|
let a = Operation::Del { pos: 1, n: 2 };
|
|
let b = Operation::Del { pos: 4, n: 3 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6, 7, 8], &[1, 4, 8]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_del_del_overlap() {
|
|
let a = Operation::Del { pos: 1, n: 4 };
|
|
let b = Operation::Del { pos: 3, n: 3 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6, 7, 8], &[1, 7, 8]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_del_del_within() {
|
|
let a = Operation::Del { pos: 1, n: 4 };
|
|
let b = Operation::Del { pos: 2, n: 2 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[1, 6]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_del() {
|
|
let a = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![2],
|
|
};
|
|
let b = Operation::Del { pos: 2, n: 1 };
|
|
test_transform_sym(&a, &b, &[1, 3, 4, 5], &[1, 2, 3, 5]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_del2() {
|
|
let a = Operation::Ins {
|
|
pos: 3,
|
|
val: vec![4],
|
|
};
|
|
let b = Operation::Del { pos: 1, n: 1 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 5], &[1, 3, 4, 5]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_del3() {
|
|
let a = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![4],
|
|
};
|
|
let b = Operation::Del { pos: 1, n: 1 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3], &[1, 4, 3]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_del_mult() {
|
|
let a = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![2, 3, 4],
|
|
};
|
|
let b = Operation::Del { pos: 1, n: 5 };
|
|
test_transform_sym(&a, &b, &[1, 5, 6, 7, 8, 9], &[1, 2, 3, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_del_all() {
|
|
let a = Operation::Ins {
|
|
pos: 0,
|
|
val: vec![2, 3, 4],
|
|
};
|
|
let b = Operation::Del { pos: 0, n: 6 };
|
|
test_transform_sym(&a, &b, &[1, 5, 6, 7, 8, 9], &[2, 3, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_ins_del_all_split() {
|
|
let a = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![2, 3, 4],
|
|
};
|
|
let b = Operation::Del { pos: 0, n: 6 };
|
|
test_transform_sym(&a, &b, &[1, 5, 6, 7, 8, 9], &[2, 3, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_ins() {
|
|
let input = [1, 3, 4, 5];
|
|
|
|
let a = Operation::Mov {
|
|
pos: 3,
|
|
n: 1,
|
|
to: 1,
|
|
};
|
|
let b = Operation::Ins {
|
|
pos: 1,
|
|
val: vec![2],
|
|
};
|
|
test_transform(&a, &b, &input, &[1, 5, 2, 3, 4]);
|
|
test_transform(&b, &a, &input, &[1, 2, 5, 3, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_ins2() {
|
|
let input = [1, 2, 3, 5];
|
|
|
|
let a = Operation::Mov {
|
|
pos: 1,
|
|
n: 1,
|
|
to: 3,
|
|
};
|
|
let b = Operation::Ins {
|
|
pos: 3,
|
|
val: vec![4],
|
|
};
|
|
test_transform(&a, &b, &input, &[1, 3, 2, 4, 5]);
|
|
test_transform(&b, &a, &input, &[1, 3, 4, 2, 5]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del() {
|
|
let a = Operation::Mov {
|
|
pos: 2,
|
|
n: 1,
|
|
to: 0,
|
|
};
|
|
let b = Operation::Del { pos: 2, n: 1 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4], &[1, 2, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del_within_src() {
|
|
// [1, (2), 3, 4, 5, 6] => [1, 3, 4, 5, (2), 6]
|
|
let a = Operation::Mov {
|
|
pos: 1,
|
|
n: 1,
|
|
to: 4,
|
|
};
|
|
// [1, 2, 3, 4, 5, 6] => [3, 4, 5, 6]
|
|
let b = Operation::Del { pos: 0, n: 2 };
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[3, 4, 5, 6]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del_within_dst_r() {
|
|
// [1, (2), 3, 4, 5, 6] => [1, 3, 4, 5, (2), 6]
|
|
let a = Operation::Mov {
|
|
pos: 1,
|
|
n: 1,
|
|
to: 4,
|
|
};
|
|
// [1, 2, 3, 4, 5, 6] => [1, 2, 3]
|
|
let b = Operation::Del { pos: 3, n: 3 };
|
|
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[1, 3, 2]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del_within_dst_l() {
|
|
// [1, 2, 3, 4, (5), 6] => [1, (5), 2, 3, 4, 6]
|
|
let a = Operation::Mov {
|
|
pos: 4,
|
|
n: 1,
|
|
to: 1,
|
|
};
|
|
// [1, 2, 3, 4, 5, 6] => [4, 5, 6]
|
|
let b = Operation::Del { pos: 0, n: 3 };
|
|
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4, 5, 6], &[5, 4, 6]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del_dst_l() {
|
|
// [1, 2, (3), 4] => [(3), 1, 2, 4]
|
|
let a = Operation::Mov {
|
|
pos: 2,
|
|
n: 1,
|
|
to: 0,
|
|
};
|
|
// [1, 2, 3, 4] => [2, 3, 4]
|
|
let b = Operation::Del { pos: 0, n: 1 };
|
|
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4], &[3, 2, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del_dst_r() {
|
|
// [1, (2), 3, 4] => [1, 3, 4, (2)]
|
|
let a = Operation::Mov {
|
|
pos: 1,
|
|
n: 1,
|
|
to: 3,
|
|
};
|
|
// [1, 2, 3, 4] => [1, 2, 3]
|
|
let b = Operation::Del { pos: 3, n: 1 };
|
|
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4], &[1, 3, 2]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del_dst_single_r() {
|
|
// [(1), 2, 3, 4] => [2, 3, 4, (1)]
|
|
let a = Operation::Mov {
|
|
pos: 0,
|
|
n: 1,
|
|
to: 3,
|
|
};
|
|
// [1, 2, (3, 4)] => [1, 2]
|
|
let b = Operation::Del { pos: 2, n: 2 };
|
|
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4], &[2, 1]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_del_dst_single_l() {
|
|
// [1, 2, 3, (4)] => [4, 1, 2, 3]
|
|
let a = Operation::Mov {
|
|
pos: 3,
|
|
n: 1,
|
|
to: 0,
|
|
};
|
|
// [(1, 2), 3, 4] => [3, 4]
|
|
let b = Operation::Del { pos: 0, n: 2 };
|
|
|
|
test_transform_sym(&a, &b, &[1, 2, 3, 4], &[4, 3]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_mov() {
|
|
let input = [1, 2, 3, 4];
|
|
|
|
let a = Operation::Mov {
|
|
pos: 1,
|
|
n: 1,
|
|
to: 0,
|
|
};
|
|
let b = Operation::Mov {
|
|
pos: 1,
|
|
n: 1,
|
|
to: 3,
|
|
};
|
|
test_transform(&a, &b, &input, &[1, 3, 2, 4]);
|
|
test_transform(&b, &a, &input, &[2, 1, 3, 4]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_mov2() {
|
|
let input = [1, 2, 3, 4];
|
|
|
|
let a = Operation::Mov {
|
|
pos: 0,
|
|
n: 1,
|
|
to: 2,
|
|
};
|
|
let b = Operation::Mov {
|
|
pos: 3,
|
|
n: 1,
|
|
to: 2,
|
|
};
|
|
test_transform(&a, &b, &input, &[2, 1, 4, 3]);
|
|
test_transform(&b, &a, &input, &[2, 4, 1, 3]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_mov3() {
|
|
let input = [1, 2, 3, 4];
|
|
|
|
let a = Operation::Mov {
|
|
pos: 2,
|
|
n: 1,
|
|
to: 1,
|
|
};
|
|
let b = Operation::Mov {
|
|
pos: 3,
|
|
n: 1,
|
|
to: 1,
|
|
};
|
|
test_transform(&a, &b, &input, &[1, 3, 4, 2]);
|
|
test_transform(&b, &a, &input, &[1, 4, 3, 2]);
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_mov4() {
|
|
let input = [1, 2, 3, 4];
|
|
|
|
let a = Operation::Mov {
|
|
pos: 0,
|
|
n: 1,
|
|
to: 2,
|
|
};
|
|
let b = Operation::Mov {
|
|
pos: 2,
|
|
n: 1,
|
|
to: 0,
|
|
};
|
|
test_transform(&a, &b, &input, &[3, 2, 1, 4]);
|
|
// test_transform(&b, &a, &input, &[1, 4, 3, 2]); TODO: difference from reference impl
|
|
}
|
|
|
|
#[test]
|
|
fn transform_mov_mov5() {
|
|
let input = [1, 2, 3, 4];
|
|
|
|
let a = Operation::Mov {
|
|
pos: 0,
|
|
n: 1,
|
|
to: 3,
|
|
};
|
|
let b = Operation::Mov {
|
|
pos: 0,
|
|
n: 1,
|
|
to: 3,
|
|
};
|
|
test_transform(&a, &b, &input, &[2, 3, 1, 4]);
|
|
}
|