mirror of
https://github.com/AppFlowy-IO/AppFlowy.git
synced 2024-08-30 18:12:39 +00:00
add frontend folder
This commit is contained in:
appflowy
798
frontend/rust-lib/flowy-document/tests/editor/attribute_test.rs
Normal file
798
frontend/rust-lib/flowy-document/tests/editor/attribute_test.rs
Normal file
@ -0,0 +1,798 @@
|
||||
#![cfg_attr(rustfmt, rustfmt::skip)]
|
||||
use crate::editor::{TestBuilder, TestOp::*};
|
||||
use flowy_document_infra::core::{FlowyDoc, PlainDoc};
|
||||
use lib_ot::core::{Delta, Interval, OperationTransformable, NEW_LINE, WHITESPACE, FlowyStr};
|
||||
use unicode_segmentation::UnicodeSegmentation;
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Bold(0, Interval::new(3, 5), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"123"},
|
||||
{"insert":"45","attributes":{"bold":"true"}},
|
||||
{"insert":"6"}
|
||||
]"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_and_invert_all() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
|
||||
Bold(0, Interval::new(0, 3), false),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_and_invert_partial_suffix() {
|
||||
let ops = vec![
|
||||
Insert(0, "1234", 0),
|
||||
Bold(0, Interval::new(0, 4), true),
|
||||
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
|
||||
Bold(0, Interval::new(2, 4), false),
|
||||
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":"true"}},{"insert":"34"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_and_invert_partial_suffix2() {
|
||||
let ops = vec![
|
||||
Insert(0, "1234", 0),
|
||||
Bold(0, Interval::new(0, 4), true),
|
||||
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
|
||||
Bold(0, Interval::new(2, 4), false),
|
||||
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":"true"}},{"insert":"34"}]"#),
|
||||
Bold(0, Interval::new(2, 4), true),
|
||||
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_with_new_line() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Bold(0, Interval::new(0, 6), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
Insert(0, "\n", 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"},{"insert":"456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
Insert(0, "\n", 4),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n\n"},{"insert":"456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
Insert(0, "a", 4),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\na\n"},{"insert":"456","attributes":{"bold":"true"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_and_invert_partial_prefix() {
|
||||
let ops = vec![
|
||||
Insert(0, "1234", 0),
|
||||
Bold(0, Interval::new(0, 4), true),
|
||||
AssertDocJson(0, r#"[{"insert":"1234","attributes":{"bold":"true"}}]"#),
|
||||
Bold(0, Interval::new(0, 2), false),
|
||||
AssertDocJson(0, r#"[{"insert":"12"},{"insert":"34","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_consecutive() {
|
||||
let ops = vec![
|
||||
Insert(0, "1234", 0),
|
||||
Bold(0, Interval::new(0, 1), true),
|
||||
AssertDocJson(0, r#"[{"insert":"1","attributes":{"bold":"true"}},{"insert":"234"}]"#),
|
||||
Bold(0, Interval::new(1, 2), true),
|
||||
AssertDocJson(0, r#"[{"insert":"12","attributes":{"bold":"true"}},{"insert":"34"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_italic() {
|
||||
let ops = vec![
|
||||
Insert(0, "1234", 0),
|
||||
Bold(0, Interval::new(0, 4), true),
|
||||
Italic(0, Interval::new(0, 4), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1234","attributes":{"italic":"true","bold":"true"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
Insert(0, "5678", 4),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"12345678","attributes":{"bold":"true","italic":"true"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_italic2() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Bold(0, Interval::new(0, 6), true),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Italic(0, Interval::new(0, 2), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
|
||||
{"insert":"3456","attributes":{"bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
Italic(0, Interval::new(4, 6), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true"}},
|
||||
{"insert":"56","attributes":{"italic":"true","bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_italic3() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456789", 0),
|
||||
Bold(0, Interval::new(0, 5), true),
|
||||
Italic(0, Interval::new(0, 2), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"345","attributes":{"bold":"true"}},{"insert":"6789"}]
|
||||
"#,
|
||||
),
|
||||
Italic(0, Interval::new(2, 4), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"1234","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"5","attributes":{"bold":"true"}},
|
||||
{"insert":"6789"}]
|
||||
"#,
|
||||
),
|
||||
Bold(0, Interval::new(7, 9), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"1234","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"5","attributes":{"bold":"true"}},
|
||||
{"insert":"67"},
|
||||
{"insert":"89","attributes":{"bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bold_added_italic_delete() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456789", 0),
|
||||
Bold(0, Interval::new(0, 5), true),
|
||||
Italic(0, Interval::new(0, 2), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
|
||||
{"insert":"345","attributes":{"bold":"true"}},{"insert":"6789"}]
|
||||
"#,
|
||||
),
|
||||
Italic(0, Interval::new(2, 4), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"1234","attributes":{"bold":"true","italic":"true"}}
|
||||
,{"insert":"5","attributes":{"bold":"true"}},{"insert":"6789"}]"#,
|
||||
),
|
||||
Bold(0, Interval::new(7, 9), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"1234","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"5","attributes":{"bold":"true"}},{"insert":"67"},
|
||||
{"insert":"89","attributes":{"bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
Delete(0, Interval::new(0, 5)),
|
||||
AssertDocJson(0, r#"[{"insert":"67"},{"insert":"89","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_merge_inserted_text_with_same_attribute() {
|
||||
let ops = vec![
|
||||
InsertBold(0, "123", Interval::new(0, 3)),
|
||||
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
|
||||
InsertBold(0, "456", Interval::new(3, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_compose_attr_attributes_with_attr_attributes_test() {
|
||||
let ops = vec![
|
||||
InsertBold(0, "123456", Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
InsertBold(1, "7", Interval::new(0, 1)),
|
||||
AssertDocJson(1, r#"[{"insert":"7","attributes":{"bold":"true"}}]"#),
|
||||
Transform(0, 1),
|
||||
AssertDocJson(0, r#"[{"insert":"1234567","attributes":{"bold":"true"}}]"#),
|
||||
AssertDocJson(1, r#"[{"insert":"1234567","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_compose_attr_attributes_with_attr_attributes_test2() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Bold(0, Interval::new(0, 6), true),
|
||||
Italic(0, Interval::new(0, 2), true),
|
||||
Italic(0, Interval::new(4, 6), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true"}},
|
||||
{"insert":"56","attributes":{"italic":"true","bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
InsertBold(1, "7", Interval::new(0, 1)),
|
||||
AssertDocJson(1, r#"[{"insert":"7","attributes":{"bold":"true"}}]"#),
|
||||
Transform(0, 1),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true"}},
|
||||
{"insert":"56","attributes":{"italic":"true","bold":"true"}},
|
||||
{"insert":"7","attributes":{"bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
AssertDocJson(
|
||||
1,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"italic":"true","bold":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true"}},
|
||||
{"insert":"56","attributes":{"italic":"true","bold":"true"}},
|
||||
{"insert":"7","attributes":{"bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_compose_attr_attributes_with_no_attr_attributes_test() {
|
||||
let expected = r#"[{"insert":"123456","attributes":{"bold":"true"}},{"insert":"7"}]"#;
|
||||
|
||||
let ops = vec![
|
||||
InsertBold(0, "123456", Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Insert(1, "7", 0),
|
||||
AssertDocJson(1, r#"[{"insert":"7"}]"#),
|
||||
Transform(0, 1),
|
||||
AssertDocJson(0, expected),
|
||||
AssertDocJson(1, expected),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_replace_heading() {
|
||||
let ops = vec![
|
||||
InsertBold(0, "123456", Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Delete(0, Interval::new(0, 2)),
|
||||
AssertDocJson(0, r#"[{"insert":"3456","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_replace_trailing() {
|
||||
let ops = vec![
|
||||
InsertBold(0, "123456", Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Delete(0, Interval::new(5, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"12345","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_replace_middle() {
|
||||
let ops = vec![
|
||||
InsertBold(0, "123456", Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Delete(0, Interval::new(0, 2)),
|
||||
AssertDocJson(0, r#"[{"insert":"3456","attributes":{"bold":"true"}}]"#),
|
||||
Delete(0, Interval::new(2, 4)),
|
||||
AssertDocJson(0, r#"[{"insert":"34","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_replace_all() {
|
||||
let ops = vec![
|
||||
InsertBold(0, "123456", Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Delete(0, Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_replace_with_text() {
|
||||
let ops = vec![
|
||||
InsertBold(0, "123456", Interval::new(0, 6)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Replace(0, Interval::new(0, 3), "ab"),
|
||||
AssertDocJson(0, r#"[{"insert":"ab"},{"insert":"456","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_header_insert_newline_at_middle() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Header(0, Interval::new(0, 6), 1),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"},{"insert":"\n","attributes":{"header":1}}]"#),
|
||||
Insert(0, "\n", 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n","attributes":{"header":1}},{"insert":"456"},{"insert":"\n","attributes":{"header":1}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_header_insert_double_newline_at_middle() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Header(0, Interval::new(0, 6), 1),
|
||||
Insert(0, "\n", 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n","attributes":{"header":1}},{"insert":"456"},{"insert":"\n","attributes":{"header":1}}]"#,
|
||||
),
|
||||
Insert(0, "\n", 4),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n\n","attributes":{"header":1}},{"insert":"456"},{"insert":"\n","attributes":{"header":1}}]"#,
|
||||
),
|
||||
Insert(0, "\n", 4),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n\n","attributes":{"header":1}},{"insert":"\n456"},{"insert":"\n","attributes":{"header":1}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_header_insert_newline_at_trailing() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Header(0, Interval::new(0, 6), 1),
|
||||
Insert(0, "\n", 6),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456"},{"insert":"\n","attributes":{"header":1}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_header_insert_double_newline_at_trailing() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Header(0, Interval::new(0, 6), 1),
|
||||
Insert(0, "\n", 6),
|
||||
Insert(0, "\n", 7),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456"},{"insert":"\n","attributes":{"header":1}},{"insert":"\n\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_added() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Link(0, Interval::new(0, 6), "https://appflowy.io"),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_format_with_bold() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Link(0, Interval::new(0, 6), "https://appflowy.io"),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"123","attributes":{"bold":"true","link":"https://appflowy.io"}},
|
||||
{"insert":"456","attributes":{"link":"https://appflowy.io"}},
|
||||
{"insert":"\n"}]
|
||||
"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_insert_char_at_head() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Link(0, Interval::new(0, 6), "https://appflowy.io"),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
Insert(0, "a", 0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"a"},{"insert":"123456","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_insert_char_at_middle() {
|
||||
let ops = vec![
|
||||
Insert(0, "1256", 0),
|
||||
Link(0, Interval::new(0, 4), "https://appflowy.io"),
|
||||
Insert(0, "34", 2),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_insert_char_at_trailing() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Link(0, Interval::new(0, 6), "https://appflowy.io"),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
Insert(0, "a", 6),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456","attributes":{"link":"https://appflowy.io"}},{"insert":"a\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_insert_newline_at_middle() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Link(0, Interval::new(0, 6), "https://appflowy.io"),
|
||||
Insert(0, NEW_LINE, 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"},{"insert":"456","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_auto_format() {
|
||||
let site = "https://appflowy.io";
|
||||
let ops = vec![
|
||||
Insert(0, site, 0),
|
||||
AssertDocJson(0, r#"[{"insert":"https://appflowy.io\n"}]"#),
|
||||
Insert(0, WHITESPACE, site.len()),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"https://appflowy.io","attributes":{"link":"https://appflowy.io/"}},{"insert":" \n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_auto_format_exist() {
|
||||
let site = "https://appflowy.io";
|
||||
let ops = vec![
|
||||
Insert(0, site, 0),
|
||||
Link(0, Interval::new(0, site.len()), site),
|
||||
Insert(0, WHITESPACE, site.len()),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"https://appflowy.io","attributes":{"link":"https://appflowy.io/"}},{"insert":" \n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_link_auto_format_exist2() {
|
||||
let site = "https://appflowy.io";
|
||||
let ops = vec![
|
||||
Insert(0, site, 0),
|
||||
Link(0, Interval::new(0, site.len() / 2), site),
|
||||
Insert(0, WHITESPACE, site.len()),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"https://a","attributes":{"link":"https://appflowy.io"}},{"insert":"ppflowy.io \n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bullet_added() {
|
||||
let ops = vec![
|
||||
Insert(0, "12", 0),
|
||||
Bullet(0, Interval::new(0, 1), true),
|
||||
AssertDocJson(0, r#"[{"insert":"12"},{"insert":"\n","attributes":{"list":"bullet"}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bullet_added_2() {
|
||||
let ops = vec![
|
||||
Insert(0, "1", 0),
|
||||
Bullet(0, Interval::new(0, 1), true),
|
||||
AssertDocJson(0, r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}}]"#),
|
||||
Insert(0, NEW_LINE, 1),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Insert(0, "2", 2),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"2"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bullet_remove_partial() {
|
||||
let ops = vec![
|
||||
Insert(0, "1", 0),
|
||||
Bullet(0, Interval::new(0, 1), true),
|
||||
Insert(0, NEW_LINE, 1),
|
||||
Insert(0, "2", 2),
|
||||
Bullet(0, Interval::new(2, 3), false),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"2\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_bullet_auto_exit() {
|
||||
let ops = vec![
|
||||
Insert(0, "1", 0),
|
||||
Bullet(0, Interval::new(0, 1), true),
|
||||
Insert(0, NEW_LINE, 1),
|
||||
Insert(0, NEW_LINE, 2),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_preserve_block_when_insert_newline_inside() {
|
||||
let ops = vec![
|
||||
Insert(0, "12", 0),
|
||||
Bullet(0, Interval::new(0, 2), true),
|
||||
Insert(0, NEW_LINE, 2),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"12"},{"insert":"\n\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Insert(0, "34", 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12"},{"insert":"\n","attributes":{"list":"bullet"}},
|
||||
{"insert":"34"},{"insert":"\n","attributes":{"list":"bullet"}}
|
||||
]"#,
|
||||
),
|
||||
Insert(0, NEW_LINE, 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12"},{"insert":"\n\n","attributes":{"list":"bullet"}},
|
||||
{"insert":"34"},{"insert":"\n","attributes":{"list":"bullet"}}
|
||||
]"#,
|
||||
),
|
||||
Insert(0, "ab", 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12"},{"insert":"\n","attributes":{"list":"bullet"}},
|
||||
{"insert":"ab"},{"insert":"\n","attributes":{"list":"bullet"}},
|
||||
{"insert":"34"},{"insert":"\n","attributes":{"list":"bullet"}}
|
||||
]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_preserve_header_format_on_merge() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Header(0, Interval::new(0, 6), 1),
|
||||
Insert(0, NEW_LINE, 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n","attributes":{"header":1}},{"insert":"456"},{"insert":"\n","attributes":{"header":1}}]"#,
|
||||
),
|
||||
Delete(0, Interval::new(3, 4)),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"},{"insert":"\n","attributes":{"header":1}}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_format_emoji() {
|
||||
let emoji_s = "👋 ";
|
||||
let s: FlowyStr = emoji_s.into();
|
||||
let len = s.count_utf16_code_units();
|
||||
assert_eq!(3, len);
|
||||
assert_eq!(2, s.graphemes(true).count());
|
||||
let ops = vec![
|
||||
Insert(0, emoji_s, 0),
|
||||
AssertDocJson(0, r#"[{"insert":"👋 \n"}]"#),
|
||||
Header(0, Interval::new(0, len), 1),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"👋 "},{"insert":"\n","attributes":{"header":1}}]"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_preserve_list_format_on_merge() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Bullet(0, Interval::new(0, 6), true),
|
||||
Insert(0, NEW_LINE, 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"456"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Delete(0, Interval::new(3, 4)),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_compose() {
|
||||
let mut delta = Delta::from_json(r#"[{"insert":"\n"}]"#).unwrap();
|
||||
let deltas = vec![
|
||||
Delta::from_json(r#"[{"retain":1,"attributes":{"list":"unchecked"}}]"#).unwrap(),
|
||||
Delta::from_json(r#"[{"insert":"a"}]"#).unwrap(),
|
||||
Delta::from_json(r#"[{"retain":1},{"insert":"\n","attributes":{"list":"unchecked"}}]"#).unwrap(),
|
||||
Delta::from_json(r#"[{"retain":2},{"retain":1,"attributes":{"list":""}}]"#).unwrap(),
|
||||
];
|
||||
|
||||
for d in deltas {
|
||||
delta = delta.compose(&d).unwrap();
|
||||
}
|
||||
assert_eq!(
|
||||
delta.to_json(),
|
||||
r#"[{"insert":"a"},{"insert":"\n","attributes":{"list":"unchecked"}},{"insert":"\n"}]"#
|
||||
);
|
||||
|
||||
let ops = vec![
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
Insert(0, "a", 0),
|
||||
AssertDocJson(0, r#"[{"insert":"a\n"}]"#),
|
||||
Bullet(0, Interval::new(0, 1), true),
|
||||
AssertDocJson(0, r#"[{"insert":"a"},{"insert":"\n","attributes":{"list":"bullet"}}]"#),
|
||||
Insert(0, NEW_LINE, 1),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"a"},{"insert":"\n\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Insert(0, NEW_LINE, 2),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"a"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
323
frontend/rust-lib/flowy-document/tests/editor/mod.rs
Normal file
323
frontend/rust-lib/flowy-document/tests/editor/mod.rs
Normal file
@ -0,0 +1,323 @@
|
||||
mod attribute_test;
|
||||
mod op_test;
|
||||
mod serde_test;
|
||||
mod undo_redo_test;
|
||||
|
||||
use derive_more::Display;
|
||||
use flowy_document_infra::core::{CustomDocument, Document};
|
||||
use lib_ot::core::*;
|
||||
use rand::{prelude::*, Rng as WrappedRng};
|
||||
use std::{sync::Once, time::Duration};
|
||||
|
||||
const LEVEL: &'static str = "debug";
|
||||
|
||||
#[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 = "Replace")]
|
||||
Replace(usize, Interval, &'static str),
|
||||
|
||||
#[display(fmt = "Italic")]
|
||||
Italic(usize, Interval, bool),
|
||||
|
||||
#[display(fmt = "Header")]
|
||||
Header(usize, Interval, usize),
|
||||
|
||||
#[display(fmt = "Link")]
|
||||
Link(usize, Interval, &'static str),
|
||||
|
||||
#[display(fmt = "Bullet")]
|
||||
Bullet(usize, Interval, bool),
|
||||
|
||||
#[display(fmt = "Transform")]
|
||||
Transform(usize, usize),
|
||||
|
||||
#[display(fmt = "TransformPrime")]
|
||||
TransformPrime(usize, usize),
|
||||
|
||||
// invert the delta_a base on the delta_b
|
||||
#[display(fmt = "Invert")]
|
||||
Invert(usize, usize),
|
||||
|
||||
#[display(fmt = "Undo")]
|
||||
Undo(usize),
|
||||
|
||||
#[display(fmt = "Redo")]
|
||||
Redo(usize),
|
||||
|
||||
#[display(fmt = "Wait")]
|
||||
Wait(usize),
|
||||
|
||||
#[display(fmt = "AssertStr")]
|
||||
AssertStr(usize, &'static str),
|
||||
|
||||
#[display(fmt = "AssertDocJson")]
|
||||
AssertDocJson(usize, &'static str),
|
||||
|
||||
#[display(fmt = "AssertPrimeJson")]
|
||||
AssertPrimeJson(usize, &'static str),
|
||||
|
||||
#[display(fmt = "DocComposeDelta")]
|
||||
DocComposeDelta(usize, usize),
|
||||
|
||||
#[display(fmt = "ApplyPrimeDelta")]
|
||||
DocComposePrime(usize, usize),
|
||||
}
|
||||
|
||||
pub struct TestBuilder {
|
||||
documents: Vec<Document>,
|
||||
deltas: Vec<Option<Delta>>,
|
||||
primes: Vec<Option<Delta>>,
|
||||
}
|
||||
|
||||
impl TestBuilder {
|
||||
pub fn new() -> Self {
|
||||
static INIT: Once = Once::new();
|
||||
INIT.call_once(|| {
|
||||
color_eyre::install().unwrap();
|
||||
std::env::set_var("RUST_LOG", LEVEL);
|
||||
env_logger::init();
|
||||
});
|
||||
|
||||
Self {
|
||||
documents: vec![],
|
||||
deltas: vec![],
|
||||
primes: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
fn run_op(&mut self, op: &TestOp) {
|
||||
tracing::trace!("***************** 😈{} *******************", &op);
|
||||
match op {
|
||||
TestOp::Insert(delta_i, s, index) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let delta = document.insert(*index, s).unwrap();
|
||||
tracing::debug!("Insert delta: {}", delta.to_json());
|
||||
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::Delete(delta_i, iv) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let delta = document.replace(*iv, "").unwrap();
|
||||
tracing::trace!("Delete delta: {}", delta.to_json());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::Replace(delta_i, iv, s) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let delta = document.replace(*iv, s).unwrap();
|
||||
tracing::trace!("Replace delta: {}", delta.to_json());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::InsertBold(delta_i, s, iv) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
document.insert(iv.start, s).unwrap();
|
||||
document.format(*iv, Attribute::Bold(true)).unwrap();
|
||||
},
|
||||
TestOp::Bold(delta_i, iv, enable) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = Attribute::Bold(*enable);
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Bold delta: {}", delta.to_json());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::Italic(delta_i, iv, enable) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = match *enable {
|
||||
true => Attribute::Italic(true),
|
||||
false => Attribute::Italic(false),
|
||||
};
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Italic delta: {}", delta.to_json());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::Header(delta_i, iv, level) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = Attribute::Header(*level);
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Header delta: {}", delta.to_json());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::Link(delta_i, iv, link) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = Attribute::Link(link.to_owned());
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Link delta: {}", delta.to_json());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::Bullet(delta_i, iv, enable) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = Attribute::Bullet(*enable);
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::debug!("Bullet delta: {}", delta.to_json());
|
||||
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
},
|
||||
TestOp::Transform(delta_a_i, delta_b_i) => {
|
||||
let (a_prime, b_prime) = self.documents[*delta_a_i]
|
||||
.delta()
|
||||
.transform(&self.documents[*delta_b_i].delta())
|
||||
.unwrap();
|
||||
tracing::trace!("a:{:?},b:{:?}", a_prime, b_prime);
|
||||
|
||||
let data_left = self.documents[*delta_a_i].delta().compose(&b_prime).unwrap();
|
||||
let data_right = self.documents[*delta_b_i].delta().compose(&a_prime).unwrap();
|
||||
|
||||
self.documents[*delta_a_i].set_delta(data_left);
|
||||
self.documents[*delta_b_i].set_delta(data_right);
|
||||
},
|
||||
TestOp::TransformPrime(a_doc_index, b_doc_index) => {
|
||||
let (prime_left, prime_right) = self.documents[*a_doc_index]
|
||||
.delta()
|
||||
.transform(&self.documents[*b_doc_index].delta())
|
||||
.unwrap();
|
||||
|
||||
self.primes.insert(*a_doc_index, Some(prime_left));
|
||||
self.primes.insert(*b_doc_index, Some(prime_right));
|
||||
},
|
||||
TestOp::Invert(delta_a_i, delta_b_i) => {
|
||||
let delta_a = &self.documents[*delta_a_i].delta();
|
||||
let delta_b = &self.documents[*delta_b_i].delta();
|
||||
tracing::debug!("Invert: ");
|
||||
tracing::debug!("a: {}", delta_a.to_json());
|
||||
tracing::debug!("b: {}", delta_b.to_json());
|
||||
|
||||
let (_, b_prime) = delta_a.transform(delta_b).unwrap();
|
||||
let undo = b_prime.invert(&delta_a);
|
||||
|
||||
let new_delta = delta_a.compose(&b_prime).unwrap();
|
||||
tracing::debug!("new delta: {}", new_delta.to_json());
|
||||
tracing::debug!("undo delta: {}", undo.to_json());
|
||||
|
||||
let new_delta_after_undo = new_delta.compose(&undo).unwrap();
|
||||
|
||||
tracing::debug!("inverted delta a: {}", new_delta_after_undo.to_string());
|
||||
|
||||
assert_eq!(delta_a, &&new_delta_after_undo);
|
||||
|
||||
self.documents[*delta_a_i].set_delta(new_delta_after_undo);
|
||||
},
|
||||
TestOp::Undo(delta_i) => {
|
||||
self.documents[*delta_i].undo().unwrap();
|
||||
},
|
||||
TestOp::Redo(delta_i) => {
|
||||
self.documents[*delta_i].redo().unwrap();
|
||||
},
|
||||
TestOp::Wait(mills_sec) => {
|
||||
std::thread::sleep(Duration::from_millis(*mills_sec as u64));
|
||||
},
|
||||
TestOp::AssertStr(delta_i, expected) => {
|
||||
assert_eq!(&self.documents[*delta_i].to_plain_string(), expected);
|
||||
},
|
||||
|
||||
TestOp::AssertDocJson(delta_i, expected) => {
|
||||
let delta_json = self.documents[*delta_i].to_json();
|
||||
let expected_delta: Delta = serde_json::from_str(expected).unwrap();
|
||||
let target_delta: Delta = serde_json::from_str(&delta_json).unwrap();
|
||||
|
||||
if expected_delta != target_delta {
|
||||
log::error!("✅ expect: {}", expected,);
|
||||
log::error!("❌ receive: {}", delta_json);
|
||||
}
|
||||
assert_eq!(target_delta, expected_delta);
|
||||
},
|
||||
|
||||
TestOp::AssertPrimeJson(doc_i, expected) => {
|
||||
let prime_json = self.primes[*doc_i].as_ref().unwrap().to_json();
|
||||
let expected_prime: Delta = serde_json::from_str(expected).unwrap();
|
||||
let target_prime: Delta = serde_json::from_str(&prime_json).unwrap();
|
||||
|
||||
if expected_prime != target_prime {
|
||||
log::error!("✅ expect prime: {}", expected,);
|
||||
log::error!("❌ receive prime: {}", prime_json);
|
||||
}
|
||||
assert_eq!(target_prime, expected_prime);
|
||||
},
|
||||
TestOp::DocComposeDelta(doc_index, delta_i) => {
|
||||
let delta = self.deltas.get(*delta_i).unwrap().as_ref().unwrap();
|
||||
self.documents[*doc_index].compose_delta(delta.clone()).unwrap();
|
||||
},
|
||||
TestOp::DocComposePrime(doc_index, prime_i) => {
|
||||
let delta = self
|
||||
.primes
|
||||
.get(*prime_i)
|
||||
.expect("Must call TransformPrime first")
|
||||
.as_ref()
|
||||
.unwrap();
|
||||
let new_delta = self.documents[*doc_index].delta().compose(delta).unwrap();
|
||||
self.documents[*doc_index].set_delta(new_delta);
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run_script<C: CustomDocument>(mut self, script: Vec<TestOp>) {
|
||||
self.documents = vec![Document::new::<C>(), Document::new::<C>()];
|
||||
self.primes = vec![None, None];
|
||||
self.deltas = vec![None, None];
|
||||
for (_i, op) in script.iter().enumerate() {
|
||||
self.run_op(op);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Rng(StdRng);
|
||||
|
||||
impl Default for Rng {
|
||||
fn default() -> Self { Rng(StdRng::from_rng(thread_rng()).unwrap()) }
|
||||
}
|
||||
|
||||
impl Rng {
|
||||
#[allow(dead_code)]
|
||||
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(|_| {
|
||||
let c = self.0.gen::<char>();
|
||||
format!("{:x}", c as u32)
|
||||
})
|
||||
.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::default());
|
||||
},
|
||||
f if f < 0.4 => {
|
||||
delta.delete(i);
|
||||
},
|
||||
_ => {
|
||||
delta.retain(i, Attributes::default());
|
||||
},
|
||||
}
|
||||
}
|
||||
if self.0.gen_range(0.0, 1.0) < 0.3 {
|
||||
delta.insert(&("1".to_owned() + &self.gen_string(10)), Attributes::default());
|
||||
}
|
||||
delta
|
||||
}
|
||||
}
|
||||
728
frontend/rust-lib/flowy-document/tests/editor/op_test.rs
Normal file
728
frontend/rust-lib/flowy-document/tests/editor/op_test.rs
Normal file
@ -0,0 +1,728 @@
|
||||
use crate::editor::{Rng, TestBuilder, TestOp::*};
|
||||
use flowy_document_infra::core::{FlowyDoc, PlainDoc};
|
||||
use lib_ot::core::*;
|
||||
|
||||
#[test]
|
||||
fn attributes_insert_text() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(0, "456", 3),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_insert_text_at_head() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(0, "456", 0),
|
||||
AssertDocJson(0, r#"[{"insert":"456123"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_insert_text_at_middle() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(0, "456", 1),
|
||||
AssertDocJson(0, r#"[{"insert":"145623"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_1() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("123").build();
|
||||
let insert_b = OpBuilder::insert("4").build();
|
||||
|
||||
delta.add(insert_a.clone());
|
||||
delta.add(insert_b.clone());
|
||||
|
||||
let mut iterator = DeltaIter::from_interval(&delta, Interval::new(0, 4));
|
||||
assert_eq!(iterator.ops(), delta.ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_2() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("123").build();
|
||||
let insert_b = OpBuilder::insert("4").build();
|
||||
let insert_c = OpBuilder::insert("5").build();
|
||||
let retain_a = OpBuilder::retain(3).build();
|
||||
|
||||
delta.add(insert_a.clone());
|
||||
delta.add(retain_a.clone());
|
||||
delta.add(insert_b.clone());
|
||||
delta.add(insert_c.clone());
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(0, 2)).ops(),
|
||||
vec![OpBuilder::insert("12").build()]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(1, 3)).ops(),
|
||||
vec![OpBuilder::insert("23").build()]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(0, 3)).ops(),
|
||||
vec![insert_a.clone()]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(0, 4)).ops(),
|
||||
vec![insert_a.clone(), OpBuilder::retain(1).build()]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(0, 6)).ops(),
|
||||
vec![insert_a.clone(), retain_a.clone()]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(0, 7)).ops(),
|
||||
vec![insert_a.clone(), retain_a.clone(), insert_b.clone()]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_3() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("123456").build();
|
||||
delta.add(insert_a.clone());
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(3, 5)).ops(),
|
||||
vec![OpBuilder::insert("45").build()]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_4() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("12").build();
|
||||
let insert_b = OpBuilder::insert("34").build();
|
||||
let insert_c = OpBuilder::insert("56").build();
|
||||
|
||||
delta.ops.push(insert_a.clone());
|
||||
delta.ops.push(insert_b.clone());
|
||||
delta.ops.push(insert_c.clone());
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(0, 2)).ops(),
|
||||
vec![insert_a]
|
||||
);
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(2, 4)).ops(),
|
||||
vec![insert_b]
|
||||
);
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(4, 6)).ops(),
|
||||
vec![insert_c]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(2, 5)).ops(),
|
||||
vec![OpBuilder::insert("34").build(), OpBuilder::insert("5").build()]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_5() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("123456").build();
|
||||
let insert_b = OpBuilder::insert("789").build();
|
||||
delta.ops.push(insert_a.clone());
|
||||
delta.ops.push(insert_b.clone());
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(4, 8)).ops(),
|
||||
vec![OpBuilder::insert("56").build(), OpBuilder::insert("78").build()]
|
||||
);
|
||||
|
||||
// assert_eq!(
|
||||
// DeltaIter::from_interval(&delta, Interval::new(8, 9)).ops(),
|
||||
// vec![Builder::insert("9").build()]
|
||||
// );
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_6() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("12345678").build();
|
||||
delta.add(insert_a.clone());
|
||||
assert_eq!(
|
||||
DeltaIter::from_interval(&delta, Interval::new(4, 6)).ops(),
|
||||
vec![OpBuilder::insert("56").build()]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_7() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("12345").build();
|
||||
let retain_a = OpBuilder::retain(3).build();
|
||||
|
||||
delta.add(insert_a.clone());
|
||||
delta.add(retain_a.clone());
|
||||
|
||||
let mut iter_1 = DeltaIter::from_offset(&delta, 2);
|
||||
assert_eq!(iter_1.next_op().unwrap(), OpBuilder::insert("345").build());
|
||||
assert_eq!(iter_1.next_op().unwrap(), OpBuilder::retain(3).build());
|
||||
|
||||
let mut iter_2 = DeltaIter::new(&delta);
|
||||
assert_eq!(iter_2.next_op_with_len(2).unwrap(), OpBuilder::insert("12").build());
|
||||
assert_eq!(iter_2.next_op().unwrap(), OpBuilder::insert("345").build());
|
||||
|
||||
assert_eq!(iter_2.next_op().unwrap(), OpBuilder::retain(3).build());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_seek_1() {
|
||||
let mut delta = Delta::default();
|
||||
let insert_a = OpBuilder::insert("12345").build();
|
||||
let retain_a = OpBuilder::retain(3).build();
|
||||
delta.add(insert_a.clone());
|
||||
delta.add(retain_a.clone());
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
iter.seek::<OpMetric>(1);
|
||||
assert_eq!(iter.next_op().unwrap(), OpBuilder::retain(3).build());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_seek_2() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("12345").build());
|
||||
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
assert_eq!(iter.next_op_with_len(1).unwrap(), OpBuilder::insert("1").build());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_seek_3() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("12345").build());
|
||||
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("12").build());
|
||||
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("34").build());
|
||||
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("5").build());
|
||||
|
||||
assert_eq!(iter.next_op_with_len(1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_seek_4() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("12345").build());
|
||||
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
iter.seek::<CharMetric>(3);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("45").build());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_seek_5() {
|
||||
let mut delta = Delta::default();
|
||||
let attributes = AttributeBuilder::new()
|
||||
.add(Attribute::Bold(true))
|
||||
.add(Attribute::Italic(true))
|
||||
.build();
|
||||
|
||||
delta.add(OpBuilder::insert("1234").attributes(attributes.clone()).build());
|
||||
delta.add(OpBuilder::insert("\n").build());
|
||||
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
iter.seek::<CharMetric>(0);
|
||||
|
||||
assert_eq!(
|
||||
iter.next_op_with_len(4).unwrap(),
|
||||
OpBuilder::insert("1234").attributes(attributes).build(),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_len_test() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("12345").build());
|
||||
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
iter.seek::<CharMetric>(3);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 2);
|
||||
assert_eq!(iter.next_op_with_len(1).unwrap(), OpBuilder::insert("4").build());
|
||||
assert_eq!(iter.next_op_len().unwrap(), 1);
|
||||
assert_eq!(iter.next_op().unwrap(), OpBuilder::insert("5").build());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_len_test2() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("12345").build());
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
|
||||
assert_eq!(iter.next_op_len().unwrap(), 5);
|
||||
assert_eq!(iter.next_op_with_len(5).unwrap(), OpBuilder::insert("12345").build());
|
||||
assert_eq!(iter.next_op_len(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_with_len_zero() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("12345").build());
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
assert_eq!(iter.next_op_with_len(0), None,);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_with_len_cross_op_return_last() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("12345").build());
|
||||
delta.add(OpBuilder::retain(1).build());
|
||||
delta.add(OpBuilder::insert("678").build());
|
||||
|
||||
let mut iter = DeltaIter::new(&delta);
|
||||
iter.seek::<CharMetric>(4);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 1);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::retain(1).build());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lengths() {
|
||||
let mut delta = Delta::default();
|
||||
assert_eq!(delta.base_len, 0);
|
||||
assert_eq!(delta.target_len, 0);
|
||||
delta.retain(5, Attributes::default());
|
||||
assert_eq!(delta.base_len, 5);
|
||||
assert_eq!(delta.target_len, 5);
|
||||
delta.insert("abc", Attributes::default());
|
||||
assert_eq!(delta.base_len, 5);
|
||||
assert_eq!(delta.target_len, 8);
|
||||
delta.retain(2, Attributes::default());
|
||||
assert_eq!(delta.base_len, 7);
|
||||
assert_eq!(delta.target_len, 10);
|
||||
delta.delete(2);
|
||||
assert_eq!(delta.base_len, 9);
|
||||
assert_eq!(delta.target_len, 10);
|
||||
}
|
||||
#[test]
|
||||
fn sequence() {
|
||||
let mut delta = Delta::default();
|
||||
delta.retain(5, Attributes::default());
|
||||
delta.retain(0, Attributes::default());
|
||||
delta.insert("appflowy", Attributes::default());
|
||||
delta.insert("", Attributes::default());
|
||||
delta.delete(3);
|
||||
delta.delete(0);
|
||||
assert_eq!(delta.ops.len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_1000() {
|
||||
for _ in 0..1 {
|
||||
let mut rng = Rng::default();
|
||||
let s: FlowyStr = rng.gen_string(50).into();
|
||||
let delta = rng.gen_delta(&s);
|
||||
assert_eq!(s.count_utf16_code_units(), delta.base_len);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply() {
|
||||
let s = "hello world,".to_owned();
|
||||
let mut delta_a = Delta::default();
|
||||
delta_a.insert(&s, Attributes::default());
|
||||
|
||||
let mut delta_b = Delta::default();
|
||||
delta_b.retain(s.len(), Attributes::default());
|
||||
delta_b.insert("appflowy", Attributes::default());
|
||||
|
||||
let after_a = delta_a.apply("").unwrap();
|
||||
let after_b = delta_b.apply(&after_a).unwrap();
|
||||
assert_eq!("hello world,appflowy", &after_b);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn base_len_test() {
|
||||
let mut delta_a = Delta::default();
|
||||
delta_a.insert("a", Attributes::default());
|
||||
delta_a.insert("b", Attributes::default());
|
||||
delta_a.insert("c", Attributes::default());
|
||||
|
||||
let s = "hello world,".to_owned();
|
||||
delta_a.delete(s.len());
|
||||
let after_a = delta_a.apply(&s).unwrap();
|
||||
|
||||
delta_a.insert("d", Attributes::default());
|
||||
assert_eq!("abc", &after_a);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invert() {
|
||||
for _ in 0..1000 {
|
||||
let mut rng = Rng::default();
|
||||
let s = rng.gen_string(50);
|
||||
let delta_a = rng.gen_delta(&s);
|
||||
let delta_b = delta_a.invert_str(&s);
|
||||
assert_eq!(delta_a.base_len, delta_b.target_len);
|
||||
assert_eq!(delta_a.target_len, delta_b.base_len);
|
||||
assert_eq!(delta_b.apply(&delta_a.apply(&s).unwrap()).unwrap(), s);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_ops() {
|
||||
let mut delta = Delta::default();
|
||||
delta.retain(0, Attributes::default());
|
||||
delta.insert("", Attributes::default());
|
||||
delta.delete(0);
|
||||
assert_eq!(delta.ops.len(), 0);
|
||||
}
|
||||
#[test]
|
||||
fn eq() {
|
||||
let mut delta_a = Delta::default();
|
||||
delta_a.delete(1);
|
||||
delta_a.insert("lo", Attributes::default());
|
||||
delta_a.retain(2, Attributes::default());
|
||||
delta_a.retain(3, Attributes::default());
|
||||
let mut delta_b = Delta::default();
|
||||
delta_b.delete(1);
|
||||
delta_b.insert("l", Attributes::default());
|
||||
delta_b.insert("o", Attributes::default());
|
||||
delta_b.retain(5, Attributes::default());
|
||||
assert_eq!(delta_a, delta_b);
|
||||
delta_a.delete(1);
|
||||
delta_b.retain(1, Attributes::default());
|
||||
assert_ne!(delta_a, delta_b);
|
||||
}
|
||||
#[test]
|
||||
fn ops_merging() {
|
||||
let mut delta = Delta::default();
|
||||
assert_eq!(delta.ops.len(), 0);
|
||||
delta.retain(2, Attributes::default());
|
||||
assert_eq!(delta.ops.len(), 1);
|
||||
assert_eq!(delta.ops.last(), Some(&OpBuilder::retain(2).build()));
|
||||
delta.retain(3, Attributes::default());
|
||||
assert_eq!(delta.ops.len(), 1);
|
||||
assert_eq!(delta.ops.last(), Some(&OpBuilder::retain(5).build()));
|
||||
delta.insert("abc", Attributes::default());
|
||||
assert_eq!(delta.ops.len(), 2);
|
||||
assert_eq!(delta.ops.last(), Some(&OpBuilder::insert("abc").build()));
|
||||
delta.insert("xyz", Attributes::default());
|
||||
assert_eq!(delta.ops.len(), 2);
|
||||
assert_eq!(delta.ops.last(), Some(&OpBuilder::insert("abcxyz").build()));
|
||||
delta.delete(1);
|
||||
assert_eq!(delta.ops.len(), 3);
|
||||
assert_eq!(delta.ops.last(), Some(&OpBuilder::delete(1).build()));
|
||||
delta.delete(1);
|
||||
assert_eq!(delta.ops.len(), 3);
|
||||
assert_eq!(delta.ops.last(), Some(&OpBuilder::delete(2).build()));
|
||||
}
|
||||
#[test]
|
||||
fn is_noop() {
|
||||
let mut delta = Delta::default();
|
||||
assert!(delta.is_noop());
|
||||
delta.retain(5, Attributes::default());
|
||||
assert!(delta.is_noop());
|
||||
delta.retain(3, Attributes::default());
|
||||
assert!(delta.is_noop());
|
||||
delta.insert("lorem", Attributes::default());
|
||||
assert!(!delta.is_noop());
|
||||
}
|
||||
#[test]
|
||||
fn compose() {
|
||||
for _ in 0..1000 {
|
||||
let mut rng = Rng::default();
|
||||
let s = rng.gen_string(20);
|
||||
let a = rng.gen_delta(&s);
|
||||
let after_a: FlowyStr = a.apply(&s).unwrap().into();
|
||||
assert_eq!(a.target_len, after_a.count_utf16_code_units());
|
||||
|
||||
let b = rng.gen_delta(&after_a);
|
||||
let after_b: FlowyStr = b.apply(&after_a).unwrap().into();
|
||||
assert_eq!(b.target_len, after_b.count_utf16_code_units());
|
||||
|
||||
let ab = a.compose(&b).unwrap();
|
||||
assert_eq!(ab.target_len, b.target_len);
|
||||
let after_ab: FlowyStr = ab.apply(&s).unwrap().into();
|
||||
assert_eq!(after_b, after_ab);
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn transform_random_delta() {
|
||||
for _ in 0..1000 {
|
||||
let mut rng = Rng::default();
|
||||
let s = rng.gen_string(20);
|
||||
let a = rng.gen_delta(&s);
|
||||
let b = rng.gen_delta(&s);
|
||||
let (a_prime, b_prime) = a.transform(&b).unwrap();
|
||||
let ab_prime = a.compose(&b_prime).unwrap();
|
||||
let ba_prime = b.compose(&a_prime).unwrap();
|
||||
assert_eq!(ab_prime, ba_prime);
|
||||
|
||||
let after_ab_prime = ab_prime.apply(&s).unwrap();
|
||||
let after_ba_prime = ba_prime.apply(&s).unwrap();
|
||||
assert_eq!(after_ab_prime, after_ba_prime);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transform_with_two_delta_test() {
|
||||
let mut a = Delta::default();
|
||||
let mut a_s = String::new();
|
||||
a.insert("123", AttributeBuilder::new().add(Attribute::Bold(true)).build());
|
||||
a_s = a.apply(&a_s).unwrap();
|
||||
assert_eq!(&a_s, "123");
|
||||
|
||||
let mut b = Delta::default();
|
||||
let mut b_s = String::new();
|
||||
b.insert("456", Attributes::default());
|
||||
b_s = b.apply(&b_s).unwrap();
|
||||
assert_eq!(&b_s, "456");
|
||||
|
||||
let (a_prime, b_prime) = a.transform(&b).unwrap();
|
||||
assert_eq!(
|
||||
r#"[{"insert":"123","attributes":{"bold":true}},{"retain":3}]"#,
|
||||
serde_json::to_string(&a_prime).unwrap()
|
||||
);
|
||||
assert_eq!(
|
||||
r#"[{"retain":3,"attributes":{"bold":true}},{"insert":"456"}]"#,
|
||||
serde_json::to_string(&b_prime).unwrap()
|
||||
);
|
||||
|
||||
let new_a = a.compose(&b_prime).unwrap();
|
||||
let new_b = b.compose(&a_prime).unwrap();
|
||||
assert_eq!(
|
||||
r#"[{"insert":"123","attributes":{"bold":true}},{"insert":"456"}]"#,
|
||||
serde_json::to_string(&new_a).unwrap()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
r#"[{"insert":"123","attributes":{"bold":true}},{"insert":"456"}]"#,
|
||||
serde_json::to_string(&new_b).unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transform_two_plain_delta_test() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(1, "456", 0),
|
||||
Transform(0, 1),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
|
||||
AssertDocJson(1, r#"[{"insert":"123456"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transform_two_plain_delta_test2() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(1, "456", 0),
|
||||
TransformPrime(0, 1),
|
||||
DocComposePrime(0, 1),
|
||||
DocComposePrime(1, 0),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
|
||||
AssertDocJson(1, r#"[{"insert":"123456"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transform_two_non_seq_delta() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(1, "456", 0),
|
||||
TransformPrime(0, 1),
|
||||
AssertPrimeJson(0, r#"[{"insert":"123"},{"retain":3}]"#),
|
||||
AssertPrimeJson(1, r#"[{"retain":3},{"insert":"456"}]"#),
|
||||
DocComposePrime(0, 1),
|
||||
Insert(1, "78", 3),
|
||||
Insert(1, "9", 5),
|
||||
DocComposePrime(1, 0),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
|
||||
AssertDocJson(1, r#"[{"insert":"123456789"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transform_two_conflict_non_seq_delta() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(1, "456", 0),
|
||||
TransformPrime(0, 1),
|
||||
DocComposePrime(0, 1),
|
||||
Insert(1, "78", 0),
|
||||
DocComposePrime(1, 0),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
|
||||
AssertDocJson(1, r#"[{"insert":"12378456"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_no_attribute_delta() {
|
||||
let mut delta = Delta::default();
|
||||
delta.add(OpBuilder::insert("123").build());
|
||||
|
||||
let mut change = Delta::default();
|
||||
change.add(OpBuilder::retain(3).build());
|
||||
change.add(OpBuilder::insert("456").build());
|
||||
let undo = change.invert(&delta);
|
||||
|
||||
let new_delta = delta.compose(&change).unwrap();
|
||||
let delta_after_undo = new_delta.compose(&undo).unwrap();
|
||||
|
||||
assert_eq!(delta_after_undo, delta);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_no_attribute_delta2() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(1, "4567", 0),
|
||||
Invert(0, 1),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_attribute_delta_with_no_attribute_delta() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
|
||||
Insert(1, "4567", 0),
|
||||
Invert(0, 1),
|
||||
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_attribute_delta_with_no_attribute_delta2() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Insert(0, "456", 3),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"123456","attributes":{"bold":"true"}}]
|
||||
"#,
|
||||
),
|
||||
Italic(0, Interval::new(2, 4), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"bold":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"56","attributes":{"bold":"true"}}
|
||||
]"#,
|
||||
),
|
||||
Insert(1, "abc", 0),
|
||||
Invert(0, 1),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"bold":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"56","attributes":{"bold":"true"}}
|
||||
]"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_no_attribute_delta_with_attribute_delta() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(1, "4567", 0),
|
||||
Bold(1, Interval::new(0, 3), true),
|
||||
AssertDocJson(1, r#"[{"insert":"456","attributes":{"bold":"true"}},{"insert":"7"}]"#),
|
||||
Invert(0, 1),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_no_attribute_delta_with_attribute_delta2() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
Insert(1, "abc", 0),
|
||||
Bold(1, Interval::new(0, 3), true),
|
||||
Insert(1, "d", 3),
|
||||
Italic(1, Interval::new(1, 3), true),
|
||||
AssertDocJson(
|
||||
1,
|
||||
r#"[{"insert":"a","attributes":{"bold":"true"}},{"insert":"bc","attributes":{"bold":"true","italic":"true"}},{"insert":"d","attributes":{"bold":"true"}}]"#,
|
||||
),
|
||||
Invert(0, 1),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_attribute_delta_with_attribute_delta() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Insert(0, "456", 3),
|
||||
AssertDocJson(0, r#"[{"insert":"123456","attributes":{"bold":"true"}}]"#),
|
||||
Italic(0, Interval::new(2, 4), true),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"bold":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"56","attributes":{"bold":"true"}}
|
||||
]"#,
|
||||
),
|
||||
Insert(1, "abc", 0),
|
||||
Bold(1, Interval::new(0, 3), true),
|
||||
Insert(1, "d", 3),
|
||||
Italic(1, Interval::new(1, 3), true),
|
||||
AssertDocJson(
|
||||
1,
|
||||
r#"[
|
||||
{"insert":"a","attributes":{"bold":"true"}},
|
||||
{"insert":"bc","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"d","attributes":{"bold":"true"}}
|
||||
]"#,
|
||||
),
|
||||
Invert(0, 1),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"12","attributes":{"bold":"true"}},
|
||||
{"insert":"34","attributes":{"bold":"true","italic":"true"}},
|
||||
{"insert":"56","attributes":{"bold":"true"}}
|
||||
]"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn delta_compose_with_missing_delta() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(0, "4", 3),
|
||||
DocComposeDelta(1, 0),
|
||||
AssertDocJson(0, r#"[{"insert":"1234\n"}]"#),
|
||||
AssertStr(1, r#"4\n"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
110
frontend/rust-lib/flowy-document/tests/editor/serde_test.rs
Normal file
110
frontend/rust-lib/flowy-document/tests/editor/serde_test.rs
Normal file
@ -0,0 +1,110 @@
|
||||
use flowy_document_infra::core::{Document, PlainDoc};
|
||||
use lib_ot::core::*;
|
||||
|
||||
#[test]
|
||||
fn operation_insert_serialize_test() {
|
||||
let attributes = AttributeBuilder::new()
|
||||
.add(Attribute::Bold(true))
|
||||
.add(Attribute::Italic(true))
|
||||
.build();
|
||||
let operation = OpBuilder::insert("123").attributes(attributes).build();
|
||||
let json = serde_json::to_string(&operation).unwrap();
|
||||
eprintln!("{}", json);
|
||||
|
||||
let insert_op: Operation = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(insert_op, operation);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn operation_retain_serialize_test() {
|
||||
let operation = Operation::Retain(12.into());
|
||||
let json = serde_json::to_string(&operation).unwrap();
|
||||
eprintln!("{}", json);
|
||||
let insert_op: Operation = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(insert_op, operation);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn operation_delete_serialize_test() {
|
||||
let operation = Operation::Delete(2);
|
||||
let json = serde_json::to_string(&operation).unwrap();
|
||||
let insert_op: Operation = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(insert_op, operation);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_serialize_test() {
|
||||
let attributes = AttributeBuilder::new()
|
||||
.add(Attribute::Bold(true))
|
||||
.add(Attribute::Italic(true))
|
||||
.build();
|
||||
let retain = OpBuilder::insert("123").attributes(attributes).build();
|
||||
|
||||
let json = serde_json::to_string(&retain).unwrap();
|
||||
eprintln!("{}", json);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_serialize_multi_attribute_test() {
|
||||
let mut delta = Delta::default();
|
||||
|
||||
let attributes = AttributeBuilder::new()
|
||||
.add(Attribute::Bold(true))
|
||||
.add(Attribute::Italic(true))
|
||||
.build();
|
||||
let retain = OpBuilder::insert("123").attributes(attributes).build();
|
||||
|
||||
delta.add(retain);
|
||||
delta.add(Operation::Retain(5.into()));
|
||||
delta.add(Operation::Delete(3));
|
||||
|
||||
let json = serde_json::to_string(&delta).unwrap();
|
||||
eprintln!("{}", json);
|
||||
|
||||
let delta_from_json = Delta::from_json(&json).unwrap();
|
||||
assert_eq!(delta_from_json, delta);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_deserialize_test() {
|
||||
let json = r#"[
|
||||
{"retain":2,"attributes":{"italic":true}},
|
||||
{"retain":2,"attributes":{"italic":123}},
|
||||
{"retain":2,"attributes":{"italic":"true","bold":"true"}},
|
||||
{"retain":2,"attributes":{"italic":true,"bold":true}}
|
||||
]"#;
|
||||
let delta = Delta::from_json(json).unwrap();
|
||||
eprintln!("{}", delta);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_deserialize_null_test() {
|
||||
let json = r#"[
|
||||
{"retain":7,"attributes":{"bold":null}}
|
||||
]"#;
|
||||
let delta1 = Delta::from_json(json).unwrap();
|
||||
|
||||
let mut attribute = Attribute::Bold(true);
|
||||
attribute.value = AttributeValue(None);
|
||||
let delta2 = DeltaBuilder::new().retain_with_attributes(7, attribute.into()).build();
|
||||
|
||||
assert_eq!(delta2.to_json(), r#"[{"retain":7,"attributes":{"bold":""}}]"#);
|
||||
assert_eq!(delta1, delta2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_serde_null_test() {
|
||||
let mut attribute = Attribute::Bold(true);
|
||||
attribute.value = AttributeValue(None);
|
||||
assert_eq!(attribute.to_json(), r#"{"bold":""}"#);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn document_insert_serde_test() {
|
||||
let mut document = Document::new::<PlainDoc>();
|
||||
document.insert(0, "\n").unwrap();
|
||||
document.insert(0, "123").unwrap();
|
||||
let json = document.to_json();
|
||||
assert_eq!(r#"[{"insert":"123\n"}]"#, json);
|
||||
assert_eq!(r#"[{"insert":"123\n"}]"#, Document::from_json(&json).unwrap().to_json());
|
||||
}
|
||||
372
frontend/rust-lib/flowy-document/tests/editor/undo_redo_test.rs
Normal file
372
frontend/rust-lib/flowy-document/tests/editor/undo_redo_test.rs
Normal file
@ -0,0 +1,372 @@
|
||||
use crate::editor::{TestBuilder, TestOp::*};
|
||||
use flowy_document_infra::core::{FlowyDoc, PlainDoc, RECORD_THRESHOLD};
|
||||
use lib_ot::core::{Interval, NEW_LINE, WHITESPACE};
|
||||
|
||||
#[test]
|
||||
fn history_insert_undo() {
|
||||
let ops = vec![Insert(0, "123", 0), Undo(0), AssertDocJson(0, r#"[{"insert":"\n"}]"#)];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_insert_undo_with_lagging() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Insert(0, "456", 0),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_insert_redo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
Redo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_insert_redo_with_lagging() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Insert(0, "456", 3),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
AssertStr(0, "123456\n"),
|
||||
AssertDocJson(0, r#"[{"insert":"123456\n"}]"#),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
|
||||
Redo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123456\n"}]"#),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_bold_undo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_bold_undo_with_lagging() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_bold_redo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
Redo(0),
|
||||
AssertDocJson(0, r#" [{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_bold_redo_with_lagging() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123\n"}]"#),
|
||||
Redo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_delete_undo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
Delete(0, Interval::new(0, 3)),
|
||||
AssertDocJson(0, r#"[]"#),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<PlainDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_delete_undo_2() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Delete(0, Interval::new(0, 1)),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"23","attributes":{"bold":"true"}},
|
||||
{"insert":"\n"}]
|
||||
"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_delete_undo_with_lagging() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Delete(0, Interval::new(0, 1)),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"23","attributes":{"bold":"true"}},
|
||||
{"insert":"\n"}]
|
||||
"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"123","attributes":{"bold":"true"}},
|
||||
{"insert":"\n"}]
|
||||
"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_delete_redo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Delete(0, Interval::new(0, 3)),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
Undo(0),
|
||||
Redo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_replace_undo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Replace(0, Interval::new(0, 2), "ab"),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"ab"},
|
||||
{"insert":"3","attributes":{"bold":"true"}},{"insert":"\n"}]
|
||||
"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_replace_undo_with_lagging() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Replace(0, Interval::new(0, 2), "ab"),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"ab"},
|
||||
{"insert":"3","attributes":{"bold":"true"}},{"insert":"\n"}]
|
||||
"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123","attributes":{"bold":"true"}},{"insert":"\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_replace_redo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Bold(0, Interval::new(0, 3), true),
|
||||
Replace(0, Interval::new(0, 2), "ab"),
|
||||
Undo(0),
|
||||
Redo(0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[
|
||||
{"insert":"ab"},
|
||||
{"insert":"3","attributes":{"bold":"true"}},{"insert":"\n"}]
|
||||
"#,
|
||||
),
|
||||
];
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_header_added_undo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Header(0, Interval::new(0, 6), 1),
|
||||
Insert(0, "\n", 3),
|
||||
Insert(0, "\n", 4),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
Redo(0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n\n","attributes":{"header":1}},{"insert":"456"},{"insert":"\n","attributes":{"header":1}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_link_added_undo() {
|
||||
let site = "https://appflowy.io";
|
||||
let ops = vec![
|
||||
Insert(0, site, 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Link(0, Interval::new(0, site.len()), site),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"https://appflowy.io\n"}]"#),
|
||||
Redo(0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"https://appflowy.io","attributes":{"link":"https://appflowy.io"}},{"insert":"\n"}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_link_auto_format_undo_with_lagging() {
|
||||
let site = "https://appflowy.io";
|
||||
let ops = vec![
|
||||
Insert(0, site, 0),
|
||||
AssertDocJson(0, r#"[{"insert":"https://appflowy.io\n"}]"#),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Insert(0, WHITESPACE, site.len()),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"https://appflowy.io","attributes":{"link":"https://appflowy.io/"}},{"insert":" \n"}]"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"https://appflowy.io\n"}]"#),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_bullet_undo() {
|
||||
let ops = vec![
|
||||
Insert(0, "1", 0),
|
||||
Bullet(0, Interval::new(0, 1), true),
|
||||
Insert(0, NEW_LINE, 1),
|
||||
Insert(0, "2", 2),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"2"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
Redo(0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"2"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_bullet_undo_with_lagging() {
|
||||
let ops = vec![
|
||||
Insert(0, "1", 0),
|
||||
Bullet(0, Interval::new(0, 1), true),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Insert(0, NEW_LINE, 1),
|
||||
Insert(0, "2", 2),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"2"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}}]"#),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"\n"}]"#),
|
||||
Redo(0),
|
||||
Redo(0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"1"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"2"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_undo_attribute_on_merge_between_line() {
|
||||
let ops = vec![
|
||||
Insert(0, "123456", 0),
|
||||
Bullet(0, Interval::new(0, 6), true),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
Insert(0, NEW_LINE, 3),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"456"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Delete(0, Interval::new(3, 4)), // delete the newline
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123456"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
Undo(0),
|
||||
AssertDocJson(
|
||||
0,
|
||||
r#"[{"insert":"123"},{"insert":"\n","attributes":{"list":"bullet"}},{"insert":"456"},{"insert":"\n","attributes":{"list":"bullet"}}]"#,
|
||||
),
|
||||
];
|
||||
|
||||
TestBuilder::new().run_script::<FlowyDoc>(ops);
|
||||
}
|
||||
1
frontend/rust-lib/flowy-document/tests/main.rs
Normal file
1
frontend/rust-lib/flowy-document/tests/main.rs
Normal file
@ -0,0 +1 @@
|
||||
mod editor;
|
||||
Reference in New Issue
Block a user