mirror of
https://github.com/AppFlowy-IO/AppFlowy.git
synced 2024-08-30 18:12:39 +00:00
Refactor/rename crate (#1275)
This commit is contained in:
Nathan.fooo
GitHub
2
frontend/rust-lib/flowy-document/tests/document/mod.rs
Normal file
2
frontend/rust-lib/flowy-document/tests/document/mod.rs
Normal file
@ -0,0 +1,2 @@
|
||||
mod script;
|
||||
mod text_block_test;
|
||||
89
frontend/rust-lib/flowy-document/tests/document/script.rs
Normal file
89
frontend/rust-lib/flowy-document/tests/document/script.rs
Normal file
@ -0,0 +1,89 @@
|
||||
use flowy_document::editor::DocumentEditor;
|
||||
use flowy_document::TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS;
|
||||
use flowy_revision::disk::RevisionState;
|
||||
use flowy_test::{helper::ViewTest, FlowySDKTest};
|
||||
use lib_ot::{core::Interval, text_delta::TextOperations};
|
||||
use std::sync::Arc;
|
||||
use tokio::time::{sleep, Duration};
|
||||
|
||||
pub enum EditorScript {
|
||||
InsertText(&'static str, usize),
|
||||
Delete(Interval),
|
||||
Replace(Interval, &'static str),
|
||||
|
||||
AssertRevisionState(i64, RevisionState),
|
||||
AssertNextSyncRevId(Option<i64>),
|
||||
AssertCurrentRevId(i64),
|
||||
AssertJson(&'static str),
|
||||
}
|
||||
|
||||
pub struct DocumentEditorTest {
|
||||
pub sdk: FlowySDKTest,
|
||||
pub editor: Arc<DocumentEditor>,
|
||||
}
|
||||
|
||||
impl DocumentEditorTest {
|
||||
pub async fn new() -> Self {
|
||||
let sdk = FlowySDKTest::default();
|
||||
let _ = sdk.init_user().await;
|
||||
let test = ViewTest::new_text_block_view(&sdk).await;
|
||||
let editor = sdk
|
||||
.text_block_manager
|
||||
.open_document_editor(&test.view.id)
|
||||
.await
|
||||
.unwrap();
|
||||
Self { sdk, editor }
|
||||
}
|
||||
|
||||
pub async fn run_scripts(mut self, scripts: Vec<EditorScript>) {
|
||||
for script in scripts {
|
||||
self.run_script(script).await;
|
||||
}
|
||||
}
|
||||
|
||||
async fn run_script(&mut self, script: EditorScript) {
|
||||
let rev_manager = self.editor.rev_manager();
|
||||
let cache = rev_manager.revision_cache().await;
|
||||
let _user_id = self.sdk.user_session.user_id().unwrap();
|
||||
|
||||
match script {
|
||||
EditorScript::InsertText(s, offset) => {
|
||||
self.editor.insert(offset, s).await.unwrap();
|
||||
}
|
||||
EditorScript::Delete(interval) => {
|
||||
self.editor.delete(interval).await.unwrap();
|
||||
}
|
||||
EditorScript::Replace(interval, s) => {
|
||||
self.editor.replace(interval, s).await.unwrap();
|
||||
}
|
||||
EditorScript::AssertRevisionState(rev_id, state) => {
|
||||
let record = cache.get(rev_id).await.unwrap();
|
||||
assert_eq!(record.state, state);
|
||||
}
|
||||
EditorScript::AssertCurrentRevId(rev_id) => {
|
||||
assert_eq!(self.editor.rev_manager().rev_id(), rev_id);
|
||||
}
|
||||
EditorScript::AssertNextSyncRevId(rev_id) => {
|
||||
let next_revision = rev_manager.next_sync_revision().await.unwrap();
|
||||
if rev_id.is_none() {
|
||||
assert!(next_revision.is_none(), "Next revision should be None");
|
||||
return;
|
||||
}
|
||||
let next_revision = next_revision.unwrap();
|
||||
let mut notify = rev_manager.ack_notify();
|
||||
let _ = notify.recv().await;
|
||||
assert_eq!(next_revision.rev_id, rev_id.unwrap());
|
||||
}
|
||||
EditorScript::AssertJson(expected) => {
|
||||
let expected_delta: TextOperations = serde_json::from_str(expected).unwrap();
|
||||
let delta = self.editor.document_operations().await.unwrap();
|
||||
if expected_delta != delta {
|
||||
eprintln!("✅ expect: {}", expected,);
|
||||
eprintln!("❌ receive: {}", delta.json_str());
|
||||
}
|
||||
assert_eq!(expected_delta, delta);
|
||||
}
|
||||
}
|
||||
sleep(Duration::from_millis(TEXT_BLOCK_SYNC_INTERVAL_IN_MILLIS)).await;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,105 @@
|
||||
use crate::document::script::{EditorScript::*, *};
|
||||
use flowy_revision::disk::RevisionState;
|
||||
use lib_ot::core::{count_utf16_code_units, Interval};
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_current_rev_id_check() {
|
||||
let scripts = vec![
|
||||
InsertText("1", 0),
|
||||
AssertCurrentRevId(1),
|
||||
InsertText("2", 1),
|
||||
AssertCurrentRevId(2),
|
||||
InsertText("3", 2),
|
||||
AssertCurrentRevId(3),
|
||||
AssertNextSyncRevId(None),
|
||||
AssertJson(r#"[{"insert":"123\n"}]"#),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_state_check() {
|
||||
let scripts = vec![
|
||||
InsertText("1", 0),
|
||||
InsertText("2", 1),
|
||||
InsertText("3", 2),
|
||||
AssertRevisionState(1, RevisionState::Ack),
|
||||
AssertRevisionState(2, RevisionState::Ack),
|
||||
AssertRevisionState(3, RevisionState::Ack),
|
||||
AssertJson(r#"[{"insert":"123\n"}]"#),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_insert_test() {
|
||||
let scripts = vec![
|
||||
InsertText("1", 0),
|
||||
InsertText("2", 1),
|
||||
InsertText("3", 2),
|
||||
AssertJson(r#"[{"insert":"123\n"}]"#),
|
||||
AssertNextSyncRevId(None),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_insert_in_chinese() {
|
||||
let s = "好".to_owned();
|
||||
let offset = count_utf16_code_units(&s);
|
||||
let scripts = vec![
|
||||
InsertText("你", 0),
|
||||
InsertText("好", offset),
|
||||
AssertJson(r#"[{"insert":"你好\n"}]"#),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_insert_with_emoji() {
|
||||
let s = "😁".to_owned();
|
||||
let offset = count_utf16_code_units(&s);
|
||||
let scripts = vec![
|
||||
InsertText("😁", 0),
|
||||
InsertText("☺️", offset),
|
||||
AssertJson(r#"[{"insert":"😁☺️\n"}]"#),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_delete_in_english() {
|
||||
let scripts = vec![
|
||||
InsertText("1", 0),
|
||||
InsertText("2", 1),
|
||||
InsertText("3", 2),
|
||||
Delete(Interval::new(0, 2)),
|
||||
AssertJson(r#"[{"insert":"3\n"}]"#),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_delete_in_chinese() {
|
||||
let s = "好".to_owned();
|
||||
let offset = count_utf16_code_units(&s);
|
||||
let scripts = vec![
|
||||
InsertText("你", 0),
|
||||
InsertText("好", offset),
|
||||
Delete(Interval::new(0, offset)),
|
||||
AssertJson(r#"[{"insert":"好\n"}]"#),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn text_block_sync_replace_test() {
|
||||
let scripts = vec![
|
||||
InsertText("1", 0),
|
||||
InsertText("2", 1),
|
||||
InsertText("3", 2),
|
||||
Replace(Interval::new(0, 3), "abc"),
|
||||
AssertJson(r#"[{"insert":"abc\n"}]"#),
|
||||
];
|
||||
DocumentEditorTest::new().await.run_scripts(scripts).await;
|
||||
}
|
||||
800
frontend/rust-lib/flowy-document/tests/editor/attribute_test.rs
Normal file
800
frontend/rust-lib/flowy-document/tests/editor/attribute_test.rs
Normal file
@ -0,0 +1,800 @@
|
||||
#![cfg_attr(rustfmt, rustfmt::skip)]
|
||||
use crate::editor::{TestBuilder, TestOp::*};
|
||||
use flowy_sync::client_document::{NewlineDoc, EmptyDoc};
|
||||
use lib_ot::core::{Interval, OperationTransform, NEW_LINE, WHITESPACE, OTString};
|
||||
use unicode_segmentation::UnicodeSegmentation;
|
||||
use lib_ot::text_delta::TextOperations;
|
||||
|
||||
#[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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<NewlineDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<NewlineDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_format_emoji() {
|
||||
let emoji_s = "👋 ";
|
||||
let s: OTString = emoji_s.into();
|
||||
let len = s.utf16_len();
|
||||
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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_compose() {
|
||||
let mut delta = TextOperations::from_json(r#"[{"insert":"\n"}]"#).unwrap();
|
||||
let deltas = vec![
|
||||
TextOperations::from_json(r#"[{"retain":1,"attributes":{"list":"unchecked"}}]"#).unwrap(),
|
||||
TextOperations::from_json(r#"[{"insert":"a"}]"#).unwrap(),
|
||||
TextOperations::from_json(r#"[{"retain":1},{"insert":"\n","attributes":{"list":"unchecked"}}]"#).unwrap(),
|
||||
TextOperations::from_json(r#"[{"retain":2},{"retain":1,"attributes":{"list":""}}]"#).unwrap(),
|
||||
];
|
||||
|
||||
for d in deltas {
|
||||
delta = delta.compose(&d).unwrap();
|
||||
}
|
||||
assert_eq!(
|
||||
delta.json_str(),
|
||||
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_scripts::<NewlineDoc>(ops);
|
||||
}
|
||||
330
frontend/rust-lib/flowy-document/tests/editor/mod.rs
Normal file
330
frontend/rust-lib/flowy-document/tests/editor/mod.rs
Normal file
@ -0,0 +1,330 @@
|
||||
#![allow(clippy::module_inception)]
|
||||
mod attribute_test;
|
||||
mod op_test;
|
||||
mod serde_test;
|
||||
mod undo_redo_test;
|
||||
|
||||
use derive_more::Display;
|
||||
use flowy_sync::client_document::{ClientDocument, InitialDocument};
|
||||
use lib_ot::{
|
||||
core::*,
|
||||
text_delta::{BuildInTextAttribute, TextOperations},
|
||||
};
|
||||
use rand::{prelude::*, Rng as WrappedRng};
|
||||
use std::{sync::Once, time::Duration};
|
||||
|
||||
#[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<ClientDocument>,
|
||||
deltas: Vec<Option<TextOperations>>,
|
||||
primes: Vec<Option<TextOperations>>,
|
||||
}
|
||||
|
||||
impl TestBuilder {
|
||||
pub fn new() -> Self {
|
||||
static INIT: Once = Once::new();
|
||||
INIT.call_once(|| {
|
||||
let _ = color_eyre::install();
|
||||
// let subscriber = FmtSubscriber::builder().with_max_level(Level::INFO).finish();
|
||||
// tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
|
||||
});
|
||||
|
||||
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.json_str());
|
||||
|
||||
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.json_str());
|
||||
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.json_str());
|
||||
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, BuildInTextAttribute::Bold(true)).unwrap();
|
||||
}
|
||||
TestOp::Bold(delta_i, iv, enable) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = BuildInTextAttribute::Bold(*enable);
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Bold delta: {}", delta.json_str());
|
||||
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 => BuildInTextAttribute::Italic(true),
|
||||
false => BuildInTextAttribute::Italic(false),
|
||||
};
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Italic delta: {}", delta.json_str());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
}
|
||||
TestOp::Header(delta_i, iv, level) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = BuildInTextAttribute::Header(*level);
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Header delta: {}", delta.json_str());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
}
|
||||
TestOp::Link(delta_i, iv, link) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = BuildInTextAttribute::Link(link.to_owned());
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::trace!("Link delta: {}", delta.json_str());
|
||||
self.deltas.insert(*delta_i, Some(delta));
|
||||
}
|
||||
TestOp::Bullet(delta_i, iv, enable) => {
|
||||
let document = &mut self.documents[*delta_i];
|
||||
let attribute = BuildInTextAttribute::Bullet(*enable);
|
||||
let delta = document.format(*iv, attribute).unwrap();
|
||||
tracing::debug!("Bullet delta: {}", delta.json_str());
|
||||
|
||||
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]
|
||||
.get_operations()
|
||||
.transform(self.documents[*delta_b_i].get_operations())
|
||||
.unwrap();
|
||||
tracing::trace!("a:{:?},b:{:?}", a_prime, b_prime);
|
||||
|
||||
let data_left = self.documents[*delta_a_i].get_operations().compose(&b_prime).unwrap();
|
||||
let data_right = self.documents[*delta_b_i].get_operations().compose(&a_prime).unwrap();
|
||||
|
||||
self.documents[*delta_a_i].set_operations(data_left);
|
||||
self.documents[*delta_b_i].set_operations(data_right);
|
||||
}
|
||||
TestOp::TransformPrime(a_doc_index, b_doc_index) => {
|
||||
let (prime_left, prime_right) = self.documents[*a_doc_index]
|
||||
.get_operations()
|
||||
.transform(self.documents[*b_doc_index].get_operations())
|
||||
.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].get_operations();
|
||||
let delta_b = &self.documents[*delta_b_i].get_operations();
|
||||
tracing::debug!("Invert: ");
|
||||
tracing::debug!("a: {}", delta_a.json_str());
|
||||
tracing::debug!("b: {}", delta_b.json_str());
|
||||
|
||||
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.json_str());
|
||||
tracing::debug!("undo delta: {}", undo.json_str());
|
||||
|
||||
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_operations(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_content(), expected);
|
||||
}
|
||||
|
||||
TestOp::AssertDocJson(delta_i, expected) => {
|
||||
let delta_json = self.documents[*delta_i].get_operations_json();
|
||||
let expected_delta: TextOperations = serde_json::from_str(expected).unwrap();
|
||||
let target_delta: TextOperations = 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().json_str();
|
||||
let expected_prime: TextOperations = serde_json::from_str(expected).unwrap();
|
||||
let target_prime: TextOperations = 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_operations(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].get_operations().compose(delta).unwrap();
|
||||
self.documents[*doc_index].set_operations(new_delta);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run_scripts<C: InitialDocument>(mut self, scripts: Vec<TestOp>) {
|
||||
self.documents = vec![ClientDocument::new::<C>(), ClientDocument::new::<C>()];
|
||||
self.primes = vec![None, None];
|
||||
self.deltas = vec![None, None];
|
||||
for (_i, op) in scripts.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) -> TextOperations {
|
||||
let mut delta = TextOperations::default();
|
||||
let s = OTString::from(s);
|
||||
loop {
|
||||
let left = s.utf16_len() - delta.utf16_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), AttributeHashMap::default());
|
||||
}
|
||||
f if f < 0.4 => {
|
||||
delta.delete(i);
|
||||
}
|
||||
_ => {
|
||||
delta.retain(i, AttributeHashMap::default());
|
||||
}
|
||||
}
|
||||
}
|
||||
if self.0.gen_range(0.0..1.0) < 0.3 {
|
||||
delta.insert(&("1".to_owned() + &self.gen_string(10)), AttributeHashMap::default());
|
||||
}
|
||||
delta
|
||||
}
|
||||
}
|
||||
750
frontend/rust-lib/flowy-document/tests/editor/op_test.rs
Normal file
750
frontend/rust-lib/flowy-document/tests/editor/op_test.rs
Normal file
@ -0,0 +1,750 @@
|
||||
#![allow(clippy::all)]
|
||||
use crate::editor::{Rng, TestBuilder, TestOp::*};
|
||||
use flowy_sync::client_document::{EmptyDoc, NewlineDoc};
|
||||
use lib_ot::text_delta::TextOperationBuilder;
|
||||
use lib_ot::{core::Interval, core::*, text_delta::TextOperations};
|
||||
|
||||
#[test]
|
||||
fn attributes_insert_text() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Insert(0, "456", 3),
|
||||
AssertDocJson(0, r#"[{"insert":"123456"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_1() {
|
||||
let operations = OperationsBuilder::new().insert("123").insert("4").build();
|
||||
let delta = TextOperationBuilder::from_operations(operations);
|
||||
|
||||
let mut iterator = OperationIterator::from_interval(&delta, Interval::new(0, 4));
|
||||
assert_eq!(iterator.ops(), delta.ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_2() {
|
||||
let mut delta = TextOperations::default();
|
||||
let insert_a = DeltaOperation::insert("123");
|
||||
let insert_b = DeltaOperation::insert("4");
|
||||
let insert_c = DeltaOperation::insert("5");
|
||||
let retain_a = DeltaOperation::retain(3);
|
||||
|
||||
delta.add(insert_a.clone());
|
||||
delta.add(retain_a.clone());
|
||||
delta.add(insert_b.clone());
|
||||
delta.add(insert_c.clone());
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(0, 2)).ops(),
|
||||
vec![DeltaOperation::insert("12")]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(1, 3)).ops(),
|
||||
vec![DeltaOperation::insert("23")]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(0, 3)).ops(),
|
||||
vec![insert_a.clone()]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(0, 4)).ops(),
|
||||
vec![insert_a.clone(), DeltaOperation::retain(1)]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(0, 6)).ops(),
|
||||
vec![insert_a.clone(), retain_a.clone()]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::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 = TextOperations::default();
|
||||
let insert_a = DeltaOperation::insert("123456");
|
||||
delta.add(insert_a.clone());
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(3, 5)).ops(),
|
||||
vec![DeltaOperation::insert("45")]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_4() {
|
||||
let mut delta = TextOperations::default();
|
||||
let insert_a = DeltaOperation::insert("12");
|
||||
let insert_b = DeltaOperation::insert("34");
|
||||
let insert_c = DeltaOperation::insert("56");
|
||||
|
||||
delta.ops.push(insert_a.clone());
|
||||
delta.ops.push(insert_b.clone());
|
||||
delta.ops.push(insert_c.clone());
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(0, 2)).ops(),
|
||||
vec![insert_a]
|
||||
);
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(2, 4)).ops(),
|
||||
vec![insert_b]
|
||||
);
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(4, 6)).ops(),
|
||||
vec![insert_c]
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(2, 5)).ops(),
|
||||
vec![DeltaOperation::insert("34"), DeltaOperation::insert("5")]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_5() {
|
||||
let mut delta = TextOperations::default();
|
||||
let insert_a = DeltaOperation::insert("123456");
|
||||
let insert_b = DeltaOperation::insert("789");
|
||||
delta.ops.push(insert_a.clone());
|
||||
delta.ops.push(insert_b.clone());
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(4, 8)).ops(),
|
||||
vec![DeltaOperation::insert("56"), DeltaOperation::insert("78")]
|
||||
);
|
||||
|
||||
// assert_eq!(
|
||||
// DeltaIter::from_interval(&delta, Interval::new(8, 9)).ops(),
|
||||
// vec![Builder::insert("9")]
|
||||
// );
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_6() {
|
||||
let mut delta = TextOperations::default();
|
||||
let insert_a = DeltaOperation::insert("12345678");
|
||||
delta.add(insert_a.clone());
|
||||
assert_eq!(
|
||||
OperationIterator::from_interval(&delta, Interval::new(4, 6)).ops(),
|
||||
vec![DeltaOperation::insert("56")]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_get_ops_in_interval_7() {
|
||||
let mut delta = TextOperations::default();
|
||||
let insert_a = DeltaOperation::insert("12345");
|
||||
let retain_a = DeltaOperation::retain(3);
|
||||
|
||||
delta.add(insert_a.clone());
|
||||
delta.add(retain_a.clone());
|
||||
|
||||
let mut iter_1 = OperationIterator::from_offset(&delta, 2);
|
||||
assert_eq!(iter_1.next_op().unwrap(), DeltaOperation::insert("345"));
|
||||
assert_eq!(iter_1.next_op().unwrap(), DeltaOperation::retain(3));
|
||||
|
||||
let mut iter_2 = OperationIterator::new(&delta);
|
||||
assert_eq!(iter_2.next_op_with_len(2).unwrap(), DeltaOperation::insert("12"));
|
||||
assert_eq!(iter_2.next_op().unwrap(), DeltaOperation::insert("345"));
|
||||
|
||||
assert_eq!(iter_2.next_op().unwrap(), DeltaOperation::retain(3));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_op_seek() {
|
||||
let mut delta = TextOperations::default();
|
||||
let insert_a = DeltaOperation::insert("12345");
|
||||
let retain_a = DeltaOperation::retain(3);
|
||||
delta.add(insert_a.clone());
|
||||
delta.add(retain_a.clone());
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
iter.seek::<OpMetric>(1);
|
||||
assert_eq!(iter.next_op().unwrap(), retain_a);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_utf16_code_unit_seek() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("12345"));
|
||||
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
iter.seek::<Utf16CodeUnitMetric>(3);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("45"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_utf16_code_unit_seek_with_attributes() {
|
||||
let mut delta = TextOperations::default();
|
||||
let attributes = AttributeBuilder::new()
|
||||
.insert("bold", true)
|
||||
.insert("italic", true)
|
||||
.build();
|
||||
|
||||
delta.add(DeltaOperation::insert_with_attributes("1234", attributes.clone()));
|
||||
delta.add(DeltaOperation::insert("\n"));
|
||||
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
iter.seek::<Utf16CodeUnitMetric>(0);
|
||||
|
||||
assert_eq!(
|
||||
iter.next_op_with_len(4).unwrap(),
|
||||
DeltaOperation::insert_with_attributes("1234", attributes),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_len() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("12345"));
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("12"));
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("34"));
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("5"));
|
||||
assert_eq!(iter.next_op_with_len(1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_len_with_chinese() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("你好"));
|
||||
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 2);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("你好"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_len_with_english() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("ab"));
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 2);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::insert("ab"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_len_after_seek() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("12345"));
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 5);
|
||||
iter.seek::<Utf16CodeUnitMetric>(3);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 2);
|
||||
assert_eq!(iter.next_op_with_len(1).unwrap(), DeltaOperation::insert("4"));
|
||||
assert_eq!(iter.next_op_len().unwrap(), 1);
|
||||
assert_eq!(iter.next_op().unwrap(), DeltaOperation::insert("5"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_len_none() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("12345"));
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
|
||||
assert_eq!(iter.next_op_len().unwrap(), 5);
|
||||
assert_eq!(iter.next_op_with_len(5).unwrap(), DeltaOperation::insert("12345"));
|
||||
assert_eq!(iter.next_op_len(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_next_op_with_len_zero() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("12345"));
|
||||
let mut iter = OperationIterator::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 = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("12345"));
|
||||
delta.add(DeltaOperation::retain(1));
|
||||
delta.add(DeltaOperation::insert("678"));
|
||||
|
||||
let mut iter = OperationIterator::new(&delta);
|
||||
iter.seek::<Utf16CodeUnitMetric>(4);
|
||||
assert_eq!(iter.next_op_len().unwrap(), 1);
|
||||
assert_eq!(iter.next_op_with_len(2).unwrap(), DeltaOperation::retain(1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lengths() {
|
||||
let mut delta = TextOperations::default();
|
||||
assert_eq!(delta.utf16_base_len, 0);
|
||||
assert_eq!(delta.utf16_target_len, 0);
|
||||
delta.retain(5, AttributeHashMap::default());
|
||||
assert_eq!(delta.utf16_base_len, 5);
|
||||
assert_eq!(delta.utf16_target_len, 5);
|
||||
delta.insert("abc", AttributeHashMap::default());
|
||||
assert_eq!(delta.utf16_base_len, 5);
|
||||
assert_eq!(delta.utf16_target_len, 8);
|
||||
delta.retain(2, AttributeHashMap::default());
|
||||
assert_eq!(delta.utf16_base_len, 7);
|
||||
assert_eq!(delta.utf16_target_len, 10);
|
||||
delta.delete(2);
|
||||
assert_eq!(delta.utf16_base_len, 9);
|
||||
assert_eq!(delta.utf16_target_len, 10);
|
||||
}
|
||||
#[test]
|
||||
fn sequence() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.retain(5, AttributeHashMap::default());
|
||||
delta.retain(0, AttributeHashMap::default());
|
||||
delta.insert("appflowy", AttributeHashMap::default());
|
||||
delta.insert("", AttributeHashMap::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: OTString = rng.gen_string(50).into();
|
||||
let delta = rng.gen_delta(&s);
|
||||
assert_eq!(s.utf16_len(), delta.utf16_base_len);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_test() {
|
||||
let s = "hello";
|
||||
let delta_a = DeltaBuilder::new().insert(s).build();
|
||||
let delta_b = DeltaBuilder::new().retain(s.len()).insert(", AppFlowy").build();
|
||||
|
||||
let after_a = delta_a.content().unwrap();
|
||||
let after_b = delta_b.apply(&after_a).unwrap();
|
||||
assert_eq!("hello, AppFlowy", &after_b);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn base_len_test() {
|
||||
let mut delta_a = TextOperations::default();
|
||||
delta_a.insert("a", AttributeHashMap::default());
|
||||
delta_a.insert("b", AttributeHashMap::default());
|
||||
delta_a.insert("c", AttributeHashMap::default());
|
||||
|
||||
let s = "hello world,".to_owned();
|
||||
delta_a.delete(s.len());
|
||||
let after_a = delta_a.apply(&s).unwrap();
|
||||
|
||||
delta_a.insert("d", AttributeHashMap::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.utf16_base_len, delta_b.utf16_target_len);
|
||||
assert_eq!(delta_a.utf16_target_len, delta_b.utf16_base_len);
|
||||
assert_eq!(delta_b.apply(&delta_a.apply(&s).unwrap()).unwrap(), s);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invert_test() {
|
||||
let s = "hello world";
|
||||
let delta = DeltaBuilder::new().insert(s).build();
|
||||
let invert_delta = delta.invert_str("");
|
||||
assert_eq!(delta.utf16_base_len, invert_delta.utf16_target_len);
|
||||
assert_eq!(delta.utf16_target_len, invert_delta.utf16_base_len);
|
||||
|
||||
assert_eq!(invert_delta.apply(s).unwrap(), "")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_ops() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.retain(0, AttributeHashMap::default());
|
||||
delta.insert("", AttributeHashMap::default());
|
||||
delta.delete(0);
|
||||
assert_eq!(delta.ops.len(), 0);
|
||||
}
|
||||
#[test]
|
||||
fn eq() {
|
||||
let mut delta_a = TextOperations::default();
|
||||
delta_a.delete(1);
|
||||
delta_a.insert("lo", AttributeHashMap::default());
|
||||
delta_a.retain(2, AttributeHashMap::default());
|
||||
delta_a.retain(3, AttributeHashMap::default());
|
||||
let mut delta_b = TextOperations::default();
|
||||
delta_b.delete(1);
|
||||
delta_b.insert("l", AttributeHashMap::default());
|
||||
delta_b.insert("o", AttributeHashMap::default());
|
||||
delta_b.retain(5, AttributeHashMap::default());
|
||||
assert_eq!(delta_a, delta_b);
|
||||
delta_a.delete(1);
|
||||
delta_b.retain(1, AttributeHashMap::default());
|
||||
assert_ne!(delta_a, delta_b);
|
||||
}
|
||||
#[test]
|
||||
fn ops_merging() {
|
||||
let mut delta = TextOperations::default();
|
||||
assert_eq!(delta.ops.len(), 0);
|
||||
delta.retain(2, AttributeHashMap::default());
|
||||
assert_eq!(delta.ops.len(), 1);
|
||||
assert_eq!(delta.ops.last(), Some(&DeltaOperation::retain(2)));
|
||||
delta.retain(3, AttributeHashMap::default());
|
||||
assert_eq!(delta.ops.len(), 1);
|
||||
assert_eq!(delta.ops.last(), Some(&DeltaOperation::retain(5)));
|
||||
delta.insert("abc", AttributeHashMap::default());
|
||||
assert_eq!(delta.ops.len(), 2);
|
||||
assert_eq!(delta.ops.last(), Some(&DeltaOperation::insert("abc")));
|
||||
delta.insert("xyz", AttributeHashMap::default());
|
||||
assert_eq!(delta.ops.len(), 2);
|
||||
assert_eq!(delta.ops.last(), Some(&DeltaOperation::insert("abcxyz")));
|
||||
delta.delete(1);
|
||||
assert_eq!(delta.ops.len(), 3);
|
||||
assert_eq!(delta.ops.last(), Some(&DeltaOperation::delete(1)));
|
||||
delta.delete(1);
|
||||
assert_eq!(delta.ops.len(), 3);
|
||||
assert_eq!(delta.ops.last(), Some(&DeltaOperation::delete(2)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn is_noop() {
|
||||
let mut delta = TextOperations::default();
|
||||
assert!(delta.is_noop());
|
||||
delta.retain(5, AttributeHashMap::default());
|
||||
assert!(delta.is_noop());
|
||||
delta.retain(3, AttributeHashMap::default());
|
||||
assert!(delta.is_noop());
|
||||
delta.insert("lorem", AttributeHashMap::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: OTString = a.apply(&s).unwrap().into();
|
||||
assert_eq!(a.utf16_target_len, after_a.utf16_len());
|
||||
|
||||
let b = rng.gen_delta(&after_a);
|
||||
let after_b: OTString = b.apply(&after_a).unwrap().into();
|
||||
assert_eq!(b.utf16_target_len, after_b.utf16_len());
|
||||
|
||||
let ab = a.compose(&b).unwrap();
|
||||
assert_eq!(ab.utf16_target_len, b.utf16_target_len);
|
||||
let after_ab: OTString = 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() {
|
||||
let mut a = TextOperations::default();
|
||||
let mut a_s = String::new();
|
||||
a.insert("123", AttributeBuilder::new().insert("bold", true).build());
|
||||
a_s = a.apply(&a_s).unwrap();
|
||||
assert_eq!(&a_s, "123");
|
||||
|
||||
let mut b = TextOperations::default();
|
||||
let mut b_s = String::new();
|
||||
b.insert("456", AttributeHashMap::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() {
|
||||
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_scripts::<EmptyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transform_two_plain_delta2() {
|
||||
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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_invert_no_attribute_delta() {
|
||||
let mut delta = TextOperations::default();
|
||||
delta.add(DeltaOperation::insert("123"));
|
||||
|
||||
let mut change = TextOperations::default();
|
||||
change.add(DeltaOperation::retain(3));
|
||||
change.add(DeltaOperation::insert("456"));
|
||||
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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(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_scripts::<EmptyDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_compose_str() {
|
||||
let ops = vec![
|
||||
Insert(0, "1", 0),
|
||||
Insert(0, "2", 1),
|
||||
AssertDocJson(0, r#"[{"insert":"12\n"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(ops);
|
||||
}
|
||||
113
frontend/rust-lib/flowy-document/tests/editor/serde_test.rs
Normal file
113
frontend/rust-lib/flowy-document/tests/editor/serde_test.rs
Normal file
@ -0,0 +1,113 @@
|
||||
use flowy_sync::client_document::{ClientDocument, EmptyDoc};
|
||||
use lib_ot::text_delta::TextOperation;
|
||||
use lib_ot::{
|
||||
core::*,
|
||||
text_delta::{BuildInTextAttribute, TextOperations},
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn operation_insert_serialize_test() {
|
||||
let attributes = AttributeBuilder::new()
|
||||
.insert("bold", true)
|
||||
.insert("italic", true)
|
||||
.build();
|
||||
let operation = DeltaOperation::insert_with_attributes("123", attributes);
|
||||
let json = serde_json::to_string(&operation).unwrap();
|
||||
eprintln!("{}", json);
|
||||
|
||||
let insert_op: TextOperation = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(insert_op, operation);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn operation_retain_serialize_test() {
|
||||
let operation = DeltaOperation::Retain(12.into());
|
||||
let json = serde_json::to_string(&operation).unwrap();
|
||||
eprintln!("{}", json);
|
||||
let insert_op: TextOperation = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(insert_op, operation);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn operation_delete_serialize_test() {
|
||||
let operation = TextOperation::Delete(2);
|
||||
let json = serde_json::to_string(&operation).unwrap();
|
||||
let insert_op: TextOperation = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(insert_op, operation);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_serialize_test() {
|
||||
let attributes = AttributeBuilder::new()
|
||||
.insert_entry(BuildInTextAttribute::Bold(true))
|
||||
.insert_entry(BuildInTextAttribute::Italic(true))
|
||||
.build();
|
||||
let retain = DeltaOperation::insert_with_attributes("123", attributes);
|
||||
|
||||
let json = serde_json::to_string(&retain).unwrap();
|
||||
eprintln!("{}", json);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_serialize_multi_attribute_test() {
|
||||
let mut delta = DeltaOperations::default();
|
||||
|
||||
let attributes = AttributeBuilder::new()
|
||||
.insert_entry(BuildInTextAttribute::Bold(true))
|
||||
.insert_entry(BuildInTextAttribute::Italic(true))
|
||||
.build();
|
||||
let retain = DeltaOperation::insert_with_attributes("123", attributes);
|
||||
|
||||
delta.add(retain);
|
||||
delta.add(DeltaOperation::Retain(5.into()));
|
||||
delta.add(DeltaOperation::Delete(3));
|
||||
|
||||
let json = serde_json::to_string(&delta).unwrap();
|
||||
eprintln!("{}", json);
|
||||
|
||||
let delta_from_json = DeltaOperations::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 = TextOperations::from_json(json).unwrap();
|
||||
eprintln!("{}", delta);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_deserialize_null_test() {
|
||||
let json = r#"[
|
||||
{"retain":7,"attributes":{"bold":null}}
|
||||
]"#;
|
||||
let delta1 = TextOperations::from_json(json).unwrap();
|
||||
|
||||
let mut attribute = BuildInTextAttribute::Bold(true);
|
||||
attribute.remove_value();
|
||||
|
||||
let delta2 = OperationBuilder::new()
|
||||
.retain_with_attributes(7, attribute.into())
|
||||
.build();
|
||||
|
||||
assert_eq!(delta2.json_str(), r#"[{"retain":7,"attributes":{"bold":null}}]"#);
|
||||
assert_eq!(delta1, delta2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn document_insert_serde_test() {
|
||||
let mut document = ClientDocument::new::<EmptyDoc>();
|
||||
document.insert(0, "\n").unwrap();
|
||||
document.insert(0, "123").unwrap();
|
||||
let json = document.get_operations_json();
|
||||
assert_eq!(r#"[{"insert":"123\n"}]"#, json);
|
||||
assert_eq!(
|
||||
r#"[{"insert":"123\n"}]"#,
|
||||
ClientDocument::from_json(&json).unwrap().get_operations_json()
|
||||
);
|
||||
}
|
||||
373
frontend/rust-lib/flowy-document/tests/editor/undo_redo_test.rs
Normal file
373
frontend/rust-lib/flowy-document/tests/editor/undo_redo_test.rs
Normal file
@ -0,0 +1,373 @@
|
||||
use crate::editor::{TestBuilder, TestOp::*};
|
||||
use flowy_sync::client_document::{EmptyDoc, NewlineDoc, 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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(ops);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn history_delete_undo() {
|
||||
let ops = vec![
|
||||
Insert(0, "123", 0),
|
||||
Wait(RECORD_THRESHOLD),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
Delete(0, Interval::new(0, 3)),
|
||||
AssertDocJson(0, r#"[]"#),
|
||||
Undo(0),
|
||||
AssertDocJson(0, r#"[{"insert":"123"}]"#),
|
||||
];
|
||||
TestBuilder::new().run_scripts::<EmptyDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(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_scripts::<NewlineDoc>(ops);
|
||||
}
|
||||
2
frontend/rust-lib/flowy-document/tests/main.rs
Normal file
2
frontend/rust-lib/flowy-document/tests/main.rs
Normal file
@ -0,0 +1,2 @@
|
||||
mod document;
|
||||
mod editor;
|
||||
Reference in New Issue
Block a user