mirror of
https://github.com/AppFlowy-IO/AppFlowy.git
synced 2024-08-30 18:12:39 +00:00
322 lines
11 KiB
Rust
322 lines
11 KiB
Rust
use derive_more::Display;
|
|
use flowy_ot::core::*;
|
|
use rand::{prelude::*, Rng as WrappedRng};
|
|
use std::sync::Once;
|
|
|
|
#[derive(Clone, Debug, Display)]
|
|
pub enum TestOp {
|
|
#[display(fmt = "Insert")]
|
|
Insert(usize, &'static str, usize),
|
|
|
|
// delta_i, s, start, length,
|
|
#[display(fmt = "InsertBold")]
|
|
InsertBold(usize, &'static str, Interval),
|
|
|
|
// delta_i, start, length, enable
|
|
#[display(fmt = "Bold")]
|
|
Bold(usize, Interval, bool),
|
|
|
|
#[display(fmt = "Delete")]
|
|
Delete(usize, Interval),
|
|
|
|
#[display(fmt = "Italic")]
|
|
Italic(usize, Interval, bool),
|
|
|
|
#[display(fmt = "Transform")]
|
|
Transform(usize, usize),
|
|
|
|
// invert the delta_a base on the delta_b
|
|
#[display(fmt = "Invert")]
|
|
Invert(usize, usize),
|
|
|
|
#[display(fmt = "AssertStr")]
|
|
AssertStr(usize, &'static str),
|
|
|
|
#[display(fmt = "AssertOpsJson")]
|
|
AssertOpsJson(usize, &'static str),
|
|
}
|
|
|
|
pub struct OpTester {
|
|
deltas: Vec<Delta>,
|
|
}
|
|
|
|
impl OpTester {
|
|
pub fn new() -> Self {
|
|
static INIT: Once = Once::new();
|
|
INIT.call_once(|| {
|
|
std::env::set_var("RUST_LOG", "info");
|
|
env_logger::init();
|
|
});
|
|
|
|
let mut deltas = Vec::with_capacity(2);
|
|
for _ in 0..2 {
|
|
let delta = Delta::default();
|
|
deltas.push(delta);
|
|
}
|
|
Self { deltas }
|
|
}
|
|
|
|
pub fn run_op(&mut self, op: &TestOp) {
|
|
log::debug!("***************** 😈{} *******************", &op);
|
|
match op {
|
|
TestOp::Insert(delta_i, s, index) => {
|
|
self.update_delta_with_insert(*delta_i, s, *index);
|
|
},
|
|
TestOp::Delete(delta_i, interval) => {
|
|
//
|
|
self.update_delta_with_delete(*delta_i, interval);
|
|
},
|
|
TestOp::InsertBold(delta_i, s, _interval) => {
|
|
let attrs = AttrsBuilder::new().bold(true).build();
|
|
let delta = &mut self.deltas[*delta_i];
|
|
delta.insert(s, attrs);
|
|
},
|
|
TestOp::Bold(delta_i, interval, enable) => {
|
|
let attrs = AttrsBuilder::new().bold(*enable).build();
|
|
self.update_delta_with_attribute(*delta_i, attrs, interval);
|
|
},
|
|
TestOp::Italic(delta_i, interval, enable) => {
|
|
let attrs = AttrsBuilder::new().italic(*enable).build();
|
|
self.update_delta_with_attribute(*delta_i, attrs, interval);
|
|
},
|
|
TestOp::Transform(delta_a_i, delta_b_i) => {
|
|
let delta_a = &self.deltas[*delta_a_i];
|
|
let delta_b = &self.deltas[*delta_b_i];
|
|
|
|
let (a_prime, b_prime) = delta_a.transform(delta_b).unwrap();
|
|
log::trace!("a:{:?},b:{:?}", a_prime, b_prime);
|
|
let new_delta_a = delta_a.compose(&b_prime).unwrap();
|
|
let new_delta_b = delta_b.compose(&a_prime).unwrap();
|
|
|
|
self.deltas[*delta_a_i] = new_delta_a;
|
|
self.deltas[*delta_b_i] = new_delta_b;
|
|
},
|
|
TestOp::Invert(delta_a_i, delta_b_i) => {
|
|
let delta_a = &self.deltas[*delta_a_i];
|
|
let delta_b = &self.deltas[*delta_b_i];
|
|
log::debug!("Invert: ");
|
|
log::debug!("a: {}", delta_a.to_json());
|
|
log::debug!("b: {}", delta_b.to_json());
|
|
|
|
let (_, b_prime) = delta_a.transform(delta_b).unwrap();
|
|
let undo = b_prime.invert_delta(&delta_a);
|
|
|
|
let new_delta = delta_a.compose(&b_prime).unwrap();
|
|
log::debug!("new delta: {}", new_delta.to_json());
|
|
log::debug!("undo delta: {}", undo.to_json());
|
|
|
|
let new_delta_after_undo = new_delta.compose(&undo).unwrap();
|
|
|
|
log::debug!("inverted delta a: {}", new_delta_after_undo.to_string());
|
|
|
|
assert_eq!(delta_a, &new_delta_after_undo);
|
|
|
|
self.deltas[*delta_a_i] = new_delta_after_undo;
|
|
},
|
|
TestOp::AssertStr(delta_i, expected) => {
|
|
let s = self.deltas[*delta_i].apply("").unwrap();
|
|
assert_eq!(&s, expected);
|
|
},
|
|
|
|
TestOp::AssertOpsJson(delta_i, expected) => {
|
|
log::debug!("AssertOpsJson: {:?}", self.deltas[*delta_i]);
|
|
let delta_i_json = serde_json::to_string(&self.deltas[*delta_i]).unwrap();
|
|
|
|
let expected_delta: Delta = serde_json::from_str(expected).unwrap();
|
|
let target_delta: Delta = serde_json::from_str(&delta_i_json).unwrap();
|
|
|
|
if expected_delta != target_delta {
|
|
log::error!("✅ expect: {}", expected,);
|
|
log::error!("❌ receive: {}", delta_i_json);
|
|
}
|
|
assert_eq!(target_delta, expected_delta);
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn run_script(&mut self, script: Vec<TestOp>) {
|
|
for (_i, op) in script.iter().enumerate() {
|
|
self.run_op(op);
|
|
}
|
|
}
|
|
|
|
pub fn get_delta(&mut self, index: usize) -> &mut Delta { &mut self.deltas[index] }
|
|
|
|
pub fn update_delta_with_insert(&mut self, delta_index: usize, s: &str, index: usize) {
|
|
let old_delta = &mut self.deltas[delta_index];
|
|
let target_interval = Interval::new(0, old_delta.target_len);
|
|
if old_delta.target_len < index {
|
|
log::error!("{} out of bounds {}", index, target_interval);
|
|
}
|
|
|
|
let mut attributes = old_delta.attributes_in_interval(Interval::new(index, index + 1));
|
|
if attributes == Attributes::Empty {
|
|
attributes = Attributes::Follow;
|
|
}
|
|
let insert = OpBuilder::insert(s).attributes(attributes).build();
|
|
let new_delta = new_delta_with_op(old_delta, insert, Interval::new(index, index));
|
|
self.deltas[delta_index] = new_delta;
|
|
}
|
|
|
|
pub fn update_delta_with_attribute(
|
|
&mut self,
|
|
delta_index: usize,
|
|
mut attributes: Attributes,
|
|
interval: &Interval,
|
|
) {
|
|
let old_delta = &self.deltas[delta_index];
|
|
let old_attributes = old_delta.attributes_in_interval(*interval);
|
|
log::debug!(
|
|
"merge attributes: {:?}, with old: {:?}",
|
|
attributes,
|
|
old_attributes
|
|
);
|
|
let new_attributes = match &mut attributes {
|
|
Attributes::Follow => old_attributes,
|
|
Attributes::Custom(attr_data) => {
|
|
attr_data.merge(old_attributes.data());
|
|
attr_data.clone().into_attributes()
|
|
},
|
|
Attributes::Empty => Attributes::Empty,
|
|
};
|
|
|
|
log::debug!("new attributes: {:?}", new_attributes);
|
|
let retain = OpBuilder::retain(interval.size() as u64)
|
|
.attributes(new_attributes)
|
|
.build();
|
|
|
|
log::debug!(
|
|
"Update delta with new attributes: {:?} at: {:?}",
|
|
retain,
|
|
interval
|
|
);
|
|
|
|
let new_delta = new_delta_with_op(old_delta, retain, *interval);
|
|
self.deltas[delta_index] = new_delta;
|
|
}
|
|
|
|
pub fn update_delta_with_delete(&mut self, delta_index: usize, interval: &Interval) {
|
|
let old_delta = &self.deltas[delta_index];
|
|
let delete = OpBuilder::delete(interval.size() as u64).build();
|
|
let new_delta = new_delta_with_op(old_delta, delete, *interval);
|
|
self.deltas[delta_index] = new_delta;
|
|
}
|
|
}
|
|
|
|
fn new_delta_with_op(delta: &Delta, op: Operation, interval: Interval) -> Delta {
|
|
let mut new_delta = Delta::default();
|
|
let (prefix, interval, suffix) = target_length_split_with_interval(delta.target_len, interval);
|
|
|
|
// prefix
|
|
if prefix.is_empty() == false && prefix != interval {
|
|
let intervals = split_interval_with_delta(delta, &prefix);
|
|
intervals.into_iter().for_each(|p_interval| {
|
|
let attributes = delta.attributes_in_interval(p_interval);
|
|
log::debug!(
|
|
"prefix attribute: {:?}, interval: {:?}",
|
|
attributes,
|
|
p_interval
|
|
);
|
|
new_delta.retain(p_interval.size() as u64, attributes);
|
|
});
|
|
}
|
|
|
|
log::debug!("add new op: {:?}", op);
|
|
new_delta.add(op);
|
|
|
|
// suffix
|
|
if suffix.is_empty() == false {
|
|
let intervals = split_interval_with_delta(delta, &suffix);
|
|
intervals.into_iter().for_each(|s_interval| {
|
|
let attributes = delta.attributes_in_interval(s_interval);
|
|
log::debug!(
|
|
"suffix attribute: {:?}, interval: {:?}",
|
|
attributes,
|
|
s_interval
|
|
);
|
|
new_delta.retain(s_interval.size() as u64, attributes);
|
|
});
|
|
}
|
|
|
|
delta.compose(&new_delta).unwrap()
|
|
}
|
|
|
|
fn split_interval_with_delta(delta: &Delta, interval: &Interval) -> Vec<Interval> {
|
|
let mut start = 0;
|
|
let mut new_intervals = vec![];
|
|
delta.ops.iter().for_each(|op| match op {
|
|
Operation::Delete(_) => {},
|
|
Operation::Retain(_) => {},
|
|
Operation::Insert(insert) => {
|
|
let len = insert.num_chars() as usize;
|
|
let end = start + len;
|
|
let insert_interval = Interval::new(start, end);
|
|
let new_interval = interval.intersect(insert_interval);
|
|
|
|
if !new_interval.is_empty() {
|
|
new_intervals.push(new_interval)
|
|
}
|
|
start += len;
|
|
},
|
|
});
|
|
new_intervals
|
|
}
|
|
|
|
pub fn target_length_split_with_interval(
|
|
length: usize,
|
|
interval: Interval,
|
|
) -> (Interval, Interval, Interval) {
|
|
let original_interval = Interval::new(0, length);
|
|
let prefix = original_interval.prefix(interval);
|
|
let suffix = original_interval.suffix(interval);
|
|
(prefix, interval, suffix)
|
|
}
|
|
|
|
pub fn debug_print_delta(delta: &Delta) {
|
|
eprintln!("😁 {}", serde_json::to_string(delta).unwrap());
|
|
}
|
|
|
|
pub struct Rng(StdRng);
|
|
|
|
impl Default for Rng {
|
|
fn default() -> Self { Rng(StdRng::from_rng(thread_rng()).unwrap()) }
|
|
}
|
|
|
|
impl Rng {
|
|
pub fn from_seed(seed: [u8; 32]) -> Self { Rng(StdRng::from_seed(seed)) }
|
|
|
|
pub fn gen_string(&mut self, len: usize) -> String {
|
|
(0..len).map(|_| self.0.gen::<char>()).collect()
|
|
}
|
|
|
|
pub fn gen_delta(&mut self, s: &str) -> Delta {
|
|
let mut delta = Delta::default();
|
|
loop {
|
|
let left = s.chars().count() - delta.base_len;
|
|
if left == 0 {
|
|
break;
|
|
}
|
|
let i = if left == 1 {
|
|
1
|
|
} else {
|
|
1 + self.0.gen_range(0, std::cmp::min(left - 1, 20))
|
|
};
|
|
match self.0.gen_range(0.0, 1.0) {
|
|
f if f < 0.2 => {
|
|
delta.insert(&self.gen_string(i), Attributes::Empty);
|
|
},
|
|
f if f < 0.4 => {
|
|
delta.delete(i as u64);
|
|
},
|
|
_ => {
|
|
delta.retain(i as u64, Attributes::Empty);
|
|
},
|
|
}
|
|
}
|
|
if self.0.gen_range(0.0, 1.0) < 0.3 {
|
|
delta.insert(&("1".to_owned() + &self.gen_string(10)), Attributes::Empty);
|
|
}
|
|
delta
|
|
}
|
|
}
|