1use super::{network::Network, *};
2use clock::ReplicaId;
3use rand::prelude::*;
4use std::{
5 cmp::Ordering,
6 env,
7 iter::Iterator,
8 time::{Duration, Instant},
9};
10
11#[cfg(test)]
12#[ctor::ctor]
13fn init_logger() {
14 zlog::init_test();
15}
16
17#[gpui::test]
18fn test_edit(cx: &mut gpui::TestAppContext) {
19 let mut buffer = Buffer::new(
20 ReplicaId::LOCAL,
21 BufferId::new(1).unwrap(),
22 "abc",
23 cx.background_executor(),
24 );
25 assert_eq!(buffer.text(), "abc");
26 buffer.edit([(3..3, "def")], cx.background_executor());
27 assert_eq!(buffer.text(), "abcdef");
28 buffer.edit([(0..0, "ghi")], cx.background_executor());
29 assert_eq!(buffer.text(), "ghiabcdef");
30 buffer.edit([(5..5, "jkl")], cx.background_executor());
31 assert_eq!(buffer.text(), "ghiabjklcdef");
32 buffer.edit([(6..7, "")], cx.background_executor());
33 assert_eq!(buffer.text(), "ghiabjlcdef");
34 buffer.edit([(4..9, "mno")], cx.background_executor());
35 assert_eq!(buffer.text(), "ghiamnoef");
36}
37
38#[gpui::test(iterations = 100)]
39fn test_random_edits(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
40 let operations = env::var("OPERATIONS")
41 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
42 .unwrap_or(10);
43
44 let reference_string_len = rng.random_range(0..3);
45 let mut reference_string = RandomCharIter::new(&mut rng)
46 .take(reference_string_len)
47 .collect::<String>();
48 let mut buffer = Buffer::new(
49 ReplicaId::LOCAL,
50 BufferId::new(1).unwrap(),
51 reference_string.clone(),
52 cx.background_executor(),
53 );
54 LineEnding::normalize(&mut reference_string);
55
56 buffer.set_group_interval(Duration::from_millis(rng.random_range(0..=200)));
57 let mut buffer_versions = Vec::new();
58 log::info!(
59 "buffer text {:?}, version: {:?}",
60 buffer.text(),
61 buffer.version()
62 );
63
64 for _i in 0..operations {
65 let (edits, _) = buffer.randomly_edit(&mut rng, 5, cx.background_executor());
66 for (old_range, new_text) in edits.iter().rev() {
67 reference_string.replace_range(old_range.clone(), new_text);
68 }
69
70 assert_eq!(buffer.text(), reference_string);
71 log::info!(
72 "buffer text {:?}, version: {:?}",
73 buffer.text(),
74 buffer.version()
75 );
76
77 if rng.random_bool(0.25) {
78 buffer.randomly_undo_redo(&mut rng);
79 reference_string = buffer.text();
80 log::info!(
81 "buffer text {:?}, version: {:?}",
82 buffer.text(),
83 buffer.version()
84 );
85 }
86
87 let range = buffer.random_byte_range(0, &mut rng);
88 assert_eq!(
89 buffer.text_summary_for_range::<TextSummary, _>(range.clone()),
90 TextSummary::from(&reference_string[range])
91 );
92
93 buffer.check_invariants();
94
95 if rng.random_bool(0.3) {
96 buffer_versions.push((buffer.clone(), buffer.subscribe()));
97 }
98 }
99
100 for (old_buffer, subscription) in buffer_versions {
101 let edits = buffer
102 .edits_since::<usize>(&old_buffer.version)
103 .collect::<Vec<_>>();
104
105 log::info!(
106 "applying edits since version {:?} to old text: {:?}: {:?}",
107 old_buffer.version(),
108 old_buffer.text(),
109 edits,
110 );
111
112 let mut text = old_buffer.visible_text.clone();
113 for edit in edits {
114 let new_text: String = buffer.text_for_range(edit.new.clone()).collect();
115 text.replace(
116 edit.new.start..edit.new.start + edit.old.len(),
117 &new_text,
118 cx.background_executor(),
119 );
120 }
121 assert_eq!(text.to_string(), buffer.text());
122
123 assert_eq!(
124 buffer.rope_for_version(old_buffer.version()).to_string(),
125 old_buffer.text()
126 );
127
128 for _ in 0..5 {
129 let end_ix =
130 old_buffer.clip_offset(rng.random_range(0..=old_buffer.len()), Bias::Right);
131 let start_ix = old_buffer.clip_offset(rng.random_range(0..=end_ix), Bias::Left);
132 let range = old_buffer.anchor_before(start_ix)..old_buffer.anchor_after(end_ix);
133 let mut old_text = old_buffer.text_for_range(range.clone()).collect::<String>();
134 let edits = buffer
135 .edits_since_in_range::<usize>(&old_buffer.version, range.clone())
136 .collect::<Vec<_>>();
137 log::info!(
138 "applying edits since version {:?} to old text in range {:?}: {:?}: {:?}",
139 old_buffer.version(),
140 start_ix..end_ix,
141 old_text,
142 edits,
143 );
144
145 let new_text = buffer.text_for_range(range).collect::<String>();
146 for edit in edits {
147 old_text.replace_range(
148 edit.new.start..edit.new.start + edit.old_len(),
149 &new_text[edit.new],
150 );
151 }
152 assert_eq!(old_text, new_text);
153 }
154
155 assert_eq!(
156 buffer.has_edits_since(&old_buffer.version),
157 buffer
158 .edits_since::<usize>(&old_buffer.version)
159 .next()
160 .is_some(),
161 );
162
163 let subscription_edits = subscription.consume();
164 log::info!(
165 "applying subscription edits since version {:?} to old text: {:?}: {:?}",
166 old_buffer.version(),
167 old_buffer.text(),
168 subscription_edits,
169 );
170
171 let mut text = old_buffer.visible_text.clone();
172 for edit in subscription_edits.into_inner() {
173 let new_text: String = buffer.text_for_range(edit.new.clone()).collect();
174 text.replace(
175 edit.new.start..edit.new.start + edit.old.len(),
176 &new_text,
177 cx.background_executor(),
178 );
179 }
180 assert_eq!(text.to_string(), buffer.text());
181 }
182}
183
184#[gpui::test]
185fn test_line_endings(cx: &mut gpui::TestAppContext) {
186 assert_eq!(LineEnding::detect(&"🍐✅\n".repeat(1000)), LineEnding::Unix);
187 assert_eq!(LineEnding::detect(&"abcd\n".repeat(1000)), LineEnding::Unix);
188 assert_eq!(
189 LineEnding::detect(&"🍐✅\r\n".repeat(1000)),
190 LineEnding::Windows
191 );
192 assert_eq!(
193 LineEnding::detect(&"abcd\r\n".repeat(1000)),
194 LineEnding::Windows
195 );
196
197 let mut buffer = Buffer::new(
198 ReplicaId::LOCAL,
199 BufferId::new(1).unwrap(),
200 "one\r\ntwo\rthree",
201 cx.background_executor(),
202 );
203 assert_eq!(buffer.text(), "one\ntwo\nthree");
204 assert_eq!(buffer.line_ending(), LineEnding::Windows);
205 buffer.check_invariants();
206
207 buffer.edit(
208 [(buffer.len()..buffer.len(), "\r\nfour")],
209 cx.background_executor(),
210 );
211 buffer.edit([(0..0, "zero\r\n")], cx.background_executor());
212 assert_eq!(buffer.text(), "zero\none\ntwo\nthree\nfour");
213 assert_eq!(buffer.line_ending(), LineEnding::Windows);
214 buffer.check_invariants();
215}
216
217#[gpui::test]
218fn test_line_len(cx: &mut gpui::TestAppContext) {
219 let mut buffer = Buffer::new(
220 ReplicaId::LOCAL,
221 BufferId::new(1).unwrap(),
222 "",
223 cx.background_executor(),
224 );
225 buffer.edit([(0..0, "abcd\nefg\nhij")], cx.background_executor());
226 buffer.edit([(12..12, "kl\nmno")], cx.background_executor());
227 buffer.edit([(18..18, "\npqrs\n")], cx.background_executor());
228 buffer.edit([(18..21, "\nPQ")], cx.background_executor());
229
230 assert_eq!(buffer.line_len(0), 4);
231 assert_eq!(buffer.line_len(1), 3);
232 assert_eq!(buffer.line_len(2), 5);
233 assert_eq!(buffer.line_len(3), 3);
234 assert_eq!(buffer.line_len(4), 4);
235 assert_eq!(buffer.line_len(5), 0);
236}
237
238#[gpui::test]
239fn test_common_prefix_at_position(cx: &mut gpui::TestAppContext) {
240 let text = "a = str; b = δα";
241 let buffer = Buffer::new(
242 ReplicaId::LOCAL,
243 BufferId::new(1).unwrap(),
244 text,
245 cx.background_executor(),
246 );
247
248 let offset1 = offset_after(text, "str");
249 let offset2 = offset_after(text, "δα");
250
251 // the preceding word is a prefix of the suggestion
252 assert_eq!(
253 buffer.common_prefix_at(offset1, "string"),
254 range_of(text, "str"),
255 );
256 // a suffix of the preceding word is a prefix of the suggestion
257 assert_eq!(
258 buffer.common_prefix_at(offset1, "tree"),
259 range_of(text, "tr"),
260 );
261 // the preceding word is a substring of the suggestion, but not a prefix
262 assert_eq!(
263 buffer.common_prefix_at(offset1, "astro"),
264 empty_range_after(text, "str"),
265 );
266
267 // prefix matching is case insensitive.
268 assert_eq!(
269 buffer.common_prefix_at(offset1, "Strαngε"),
270 range_of(text, "str"),
271 );
272 assert_eq!(
273 buffer.common_prefix_at(offset2, "ΔΑΜΝ"),
274 range_of(text, "δα"),
275 );
276
277 fn offset_after(text: &str, part: &str) -> usize {
278 text.find(part).unwrap() + part.len()
279 }
280
281 fn empty_range_after(text: &str, part: &str) -> Range<usize> {
282 let offset = offset_after(text, part);
283 offset..offset
284 }
285
286 fn range_of(text: &str, part: &str) -> Range<usize> {
287 let start = text.find(part).unwrap();
288 start..start + part.len()
289 }
290}
291
292#[gpui::test]
293fn test_text_summary_for_range(cx: &mut gpui::TestAppContext) {
294 let buffer = Buffer::new(
295 ReplicaId::LOCAL,
296 BufferId::new(1).unwrap(),
297 "ab\nefg\nhklm\nnopqrs\ntuvwxyz",
298 cx.background_executor(),
299 );
300 assert_eq!(
301 buffer.text_summary_for_range::<TextSummary, _>(0..2),
302 TextSummary {
303 len: 2,
304 chars: 2,
305 len_utf16: OffsetUtf16(2),
306 lines: Point::new(0, 2),
307 first_line_chars: 2,
308 last_line_chars: 2,
309 last_line_len_utf16: 2,
310 longest_row: 0,
311 longest_row_chars: 2,
312 }
313 );
314 assert_eq!(
315 buffer.text_summary_for_range::<TextSummary, _>(1..3),
316 TextSummary {
317 len: 2,
318 chars: 2,
319 len_utf16: OffsetUtf16(2),
320 lines: Point::new(1, 0),
321 first_line_chars: 1,
322 last_line_chars: 0,
323 last_line_len_utf16: 0,
324 longest_row: 0,
325 longest_row_chars: 1,
326 }
327 );
328 assert_eq!(
329 buffer.text_summary_for_range::<TextSummary, _>(1..12),
330 TextSummary {
331 len: 11,
332 chars: 11,
333 len_utf16: OffsetUtf16(11),
334 lines: Point::new(3, 0),
335 first_line_chars: 1,
336 last_line_chars: 0,
337 last_line_len_utf16: 0,
338 longest_row: 2,
339 longest_row_chars: 4,
340 }
341 );
342 assert_eq!(
343 buffer.text_summary_for_range::<TextSummary, _>(0..20),
344 TextSummary {
345 len: 20,
346 chars: 20,
347 len_utf16: OffsetUtf16(20),
348 lines: Point::new(4, 1),
349 first_line_chars: 2,
350 last_line_chars: 1,
351 last_line_len_utf16: 1,
352 longest_row: 3,
353 longest_row_chars: 6,
354 }
355 );
356 assert_eq!(
357 buffer.text_summary_for_range::<TextSummary, _>(0..22),
358 TextSummary {
359 len: 22,
360 chars: 22,
361 len_utf16: OffsetUtf16(22),
362 lines: Point::new(4, 3),
363 first_line_chars: 2,
364 last_line_chars: 3,
365 last_line_len_utf16: 3,
366 longest_row: 3,
367 longest_row_chars: 6,
368 }
369 );
370 assert_eq!(
371 buffer.text_summary_for_range::<TextSummary, _>(7..22),
372 TextSummary {
373 len: 15,
374 chars: 15,
375 len_utf16: OffsetUtf16(15),
376 lines: Point::new(2, 3),
377 first_line_chars: 4,
378 last_line_chars: 3,
379 last_line_len_utf16: 3,
380 longest_row: 1,
381 longest_row_chars: 6,
382 }
383 );
384}
385
386#[gpui::test]
387fn test_chars_at(cx: &mut gpui::TestAppContext) {
388 let mut buffer = Buffer::new(
389 ReplicaId::LOCAL,
390 BufferId::new(1).unwrap(),
391 "",
392 cx.background_executor(),
393 );
394 buffer.edit([(0..0, "abcd\nefgh\nij")], cx.background_executor());
395 buffer.edit([(12..12, "kl\nmno")], cx.background_executor());
396 buffer.edit([(18..18, "\npqrs")], cx.background_executor());
397 buffer.edit([(18..21, "\nPQ")], cx.background_executor());
398
399 let chars = buffer.chars_at(Point::new(0, 0));
400 assert_eq!(chars.collect::<String>(), "abcd\nefgh\nijkl\nmno\nPQrs");
401
402 let chars = buffer.chars_at(Point::new(1, 0));
403 assert_eq!(chars.collect::<String>(), "efgh\nijkl\nmno\nPQrs");
404
405 let chars = buffer.chars_at(Point::new(2, 0));
406 assert_eq!(chars.collect::<String>(), "ijkl\nmno\nPQrs");
407
408 let chars = buffer.chars_at(Point::new(3, 0));
409 assert_eq!(chars.collect::<String>(), "mno\nPQrs");
410
411 let chars = buffer.chars_at(Point::new(4, 0));
412 assert_eq!(chars.collect::<String>(), "PQrs");
413
414 // Regression test:
415 let mut buffer = Buffer::new(
416 ReplicaId::LOCAL,
417 BufferId::new(1).unwrap(),
418 "",
419 cx.background_executor(),
420 );
421 buffer.edit([(0..0, "[workspace]\nmembers = [\n \"xray_core\",\n \"xray_server\",\n \"xray_cli\",\n \"xray_wasm\",\n]\n")], cx.background_executor());
422 buffer.edit([(60..60, "\n")], cx.background_executor());
423
424 let chars = buffer.chars_at(Point::new(6, 0));
425 assert_eq!(chars.collect::<String>(), " \"xray_wasm\",\n]\n");
426}
427
428#[gpui::test]
429fn test_anchors(cx: &mut gpui::TestAppContext) {
430 let mut buffer = Buffer::new(
431 ReplicaId::LOCAL,
432 BufferId::new(1).unwrap(),
433 "",
434 cx.background_executor(),
435 );
436 buffer.edit([(0..0, "abc")], cx.background_executor());
437 let left_anchor = buffer.anchor_before(2);
438 let right_anchor = buffer.anchor_after(2);
439
440 buffer.edit([(1..1, "def\n")], cx.background_executor());
441 assert_eq!(buffer.text(), "adef\nbc");
442 assert_eq!(left_anchor.to_offset(&buffer), 6);
443 assert_eq!(right_anchor.to_offset(&buffer), 6);
444 assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
445 assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 });
446
447 buffer.edit([(2..3, "")], cx.background_executor());
448 assert_eq!(buffer.text(), "adf\nbc");
449 assert_eq!(left_anchor.to_offset(&buffer), 5);
450 assert_eq!(right_anchor.to_offset(&buffer), 5);
451 assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
452 assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 1 });
453
454 buffer.edit([(5..5, "ghi\n")], cx.background_executor());
455 assert_eq!(buffer.text(), "adf\nbghi\nc");
456 assert_eq!(left_anchor.to_offset(&buffer), 5);
457 assert_eq!(right_anchor.to_offset(&buffer), 9);
458 assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 });
459 assert_eq!(right_anchor.to_point(&buffer), Point { row: 2, column: 0 });
460
461 buffer.edit([(7..9, "")], cx.background_executor());
462 assert_eq!(buffer.text(), "adf\nbghc");
463 assert_eq!(left_anchor.to_offset(&buffer), 5);
464 assert_eq!(right_anchor.to_offset(&buffer), 7);
465 assert_eq!(left_anchor.to_point(&buffer), Point { row: 1, column: 1 },);
466 assert_eq!(right_anchor.to_point(&buffer), Point { row: 1, column: 3 });
467
468 // Ensure anchoring to a point is equivalent to anchoring to an offset.
469 assert_eq!(
470 buffer.anchor_before(Point { row: 0, column: 0 }),
471 buffer.anchor_before(0)
472 );
473 assert_eq!(
474 buffer.anchor_before(Point { row: 0, column: 1 }),
475 buffer.anchor_before(1)
476 );
477 assert_eq!(
478 buffer.anchor_before(Point { row: 0, column: 2 }),
479 buffer.anchor_before(2)
480 );
481 assert_eq!(
482 buffer.anchor_before(Point { row: 0, column: 3 }),
483 buffer.anchor_before(3)
484 );
485 assert_eq!(
486 buffer.anchor_before(Point { row: 1, column: 0 }),
487 buffer.anchor_before(4)
488 );
489 assert_eq!(
490 buffer.anchor_before(Point { row: 1, column: 1 }),
491 buffer.anchor_before(5)
492 );
493 assert_eq!(
494 buffer.anchor_before(Point { row: 1, column: 2 }),
495 buffer.anchor_before(6)
496 );
497 assert_eq!(
498 buffer.anchor_before(Point { row: 1, column: 3 }),
499 buffer.anchor_before(7)
500 );
501 assert_eq!(
502 buffer.anchor_before(Point { row: 1, column: 4 }),
503 buffer.anchor_before(8)
504 );
505
506 // Comparison between anchors.
507 let anchor_at_offset_0 = buffer.anchor_before(0);
508 let anchor_at_offset_1 = buffer.anchor_before(1);
509 let anchor_at_offset_2 = buffer.anchor_before(2);
510
511 assert_eq!(
512 anchor_at_offset_0.cmp(&anchor_at_offset_0, &buffer),
513 Ordering::Equal
514 );
515 assert_eq!(
516 anchor_at_offset_1.cmp(&anchor_at_offset_1, &buffer),
517 Ordering::Equal
518 );
519 assert_eq!(
520 anchor_at_offset_2.cmp(&anchor_at_offset_2, &buffer),
521 Ordering::Equal
522 );
523
524 assert_eq!(
525 anchor_at_offset_0.cmp(&anchor_at_offset_1, &buffer),
526 Ordering::Less
527 );
528 assert_eq!(
529 anchor_at_offset_1.cmp(&anchor_at_offset_2, &buffer),
530 Ordering::Less
531 );
532 assert_eq!(
533 anchor_at_offset_0.cmp(&anchor_at_offset_2, &buffer),
534 Ordering::Less
535 );
536
537 assert_eq!(
538 anchor_at_offset_1.cmp(&anchor_at_offset_0, &buffer),
539 Ordering::Greater
540 );
541 assert_eq!(
542 anchor_at_offset_2.cmp(&anchor_at_offset_1, &buffer),
543 Ordering::Greater
544 );
545 assert_eq!(
546 anchor_at_offset_2.cmp(&anchor_at_offset_0, &buffer),
547 Ordering::Greater
548 );
549}
550
551#[gpui::test]
552fn test_anchors_at_start_and_end(cx: &mut gpui::TestAppContext) {
553 let mut buffer = Buffer::new(
554 ReplicaId::LOCAL,
555 BufferId::new(1).unwrap(),
556 "",
557 cx.background_executor(),
558 );
559 let before_start_anchor = buffer.anchor_before(0);
560 let after_end_anchor = buffer.anchor_after(0);
561
562 buffer.edit([(0..0, "abc")], cx.background_executor());
563 assert_eq!(buffer.text(), "abc");
564 assert_eq!(before_start_anchor.to_offset(&buffer), 0);
565 assert_eq!(after_end_anchor.to_offset(&buffer), 3);
566
567 let after_start_anchor = buffer.anchor_after(0);
568 let before_end_anchor = buffer.anchor_before(3);
569
570 buffer.edit([(3..3, "def")], cx.background_executor());
571 buffer.edit([(0..0, "ghi")], cx.background_executor());
572 assert_eq!(buffer.text(), "ghiabcdef");
573 assert_eq!(before_start_anchor.to_offset(&buffer), 0);
574 assert_eq!(after_start_anchor.to_offset(&buffer), 3);
575 assert_eq!(before_end_anchor.to_offset(&buffer), 6);
576 assert_eq!(after_end_anchor.to_offset(&buffer), 9);
577}
578
579#[gpui::test]
580fn test_undo_redo(cx: &mut gpui::TestAppContext) {
581 let mut buffer = Buffer::new(
582 ReplicaId::LOCAL,
583 BufferId::new(1).unwrap(),
584 "1234",
585 cx.background_executor(),
586 );
587 // Set group interval to zero so as to not group edits in the undo stack.
588 buffer.set_group_interval(Duration::from_secs(0));
589
590 buffer.edit([(1..1, "abx")], cx.background_executor());
591 buffer.edit([(3..4, "yzef")], cx.background_executor());
592 buffer.edit([(3..5, "cd")], cx.background_executor());
593 assert_eq!(buffer.text(), "1abcdef234");
594
595 let entries = buffer.history.undo_stack.clone();
596 assert_eq!(entries.len(), 3);
597
598 buffer.undo_or_redo(entries[0].transaction.clone());
599 assert_eq!(buffer.text(), "1cdef234");
600 buffer.undo_or_redo(entries[0].transaction.clone());
601 assert_eq!(buffer.text(), "1abcdef234");
602
603 buffer.undo_or_redo(entries[1].transaction.clone());
604 assert_eq!(buffer.text(), "1abcdx234");
605 buffer.undo_or_redo(entries[2].transaction.clone());
606 assert_eq!(buffer.text(), "1abx234");
607 buffer.undo_or_redo(entries[1].transaction.clone());
608 assert_eq!(buffer.text(), "1abyzef234");
609 buffer.undo_or_redo(entries[2].transaction.clone());
610 assert_eq!(buffer.text(), "1abcdef234");
611
612 buffer.undo_or_redo(entries[2].transaction.clone());
613 assert_eq!(buffer.text(), "1abyzef234");
614 buffer.undo_or_redo(entries[0].transaction.clone());
615 assert_eq!(buffer.text(), "1yzef234");
616 buffer.undo_or_redo(entries[1].transaction.clone());
617 assert_eq!(buffer.text(), "1234");
618}
619
620#[gpui::test]
621fn test_history(cx: &mut gpui::TestAppContext) {
622 let mut now = Instant::now();
623 let mut buffer = Buffer::new(
624 ReplicaId::LOCAL,
625 BufferId::new(1).unwrap(),
626 "123456",
627 cx.background_executor(),
628 );
629 buffer.set_group_interval(Duration::from_millis(300));
630
631 let transaction_1 = buffer.start_transaction_at(now).unwrap();
632 buffer.edit([(2..4, "cd")], cx.background_executor());
633 buffer.end_transaction_at(now);
634 assert_eq!(buffer.text(), "12cd56");
635
636 buffer.start_transaction_at(now);
637 buffer.edit([(4..5, "e")], cx.background_executor());
638 buffer.end_transaction_at(now).unwrap();
639 assert_eq!(buffer.text(), "12cde6");
640
641 now += buffer.transaction_group_interval() + Duration::from_millis(1);
642 buffer.start_transaction_at(now);
643 buffer.edit([(0..1, "a")], cx.background_executor());
644 buffer.edit([(1..1, "b")], cx.background_executor());
645 buffer.end_transaction_at(now).unwrap();
646 assert_eq!(buffer.text(), "ab2cde6");
647
648 // Last transaction happened past the group interval, undo it on its own.
649 buffer.undo();
650 assert_eq!(buffer.text(), "12cde6");
651
652 // First two transactions happened within the group interval, undo them together.
653 buffer.undo();
654 assert_eq!(buffer.text(), "123456");
655
656 // Redo the first two transactions together.
657 buffer.redo();
658 assert_eq!(buffer.text(), "12cde6");
659
660 // Redo the last transaction on its own.
661 buffer.redo();
662 assert_eq!(buffer.text(), "ab2cde6");
663
664 buffer.start_transaction_at(now);
665 assert!(buffer.end_transaction_at(now).is_none());
666 buffer.undo();
667 assert_eq!(buffer.text(), "12cde6");
668
669 // Redo stack gets cleared after performing an edit.
670 buffer.start_transaction_at(now);
671 buffer.edit([(0..0, "X")], cx.background_executor());
672 buffer.end_transaction_at(now);
673 assert_eq!(buffer.text(), "X12cde6");
674 buffer.redo();
675 assert_eq!(buffer.text(), "X12cde6");
676 buffer.undo();
677 assert_eq!(buffer.text(), "12cde6");
678 buffer.undo();
679 assert_eq!(buffer.text(), "123456");
680
681 // Transactions can be grouped manually.
682 buffer.redo();
683 buffer.redo();
684 assert_eq!(buffer.text(), "X12cde6");
685 buffer.group_until_transaction(transaction_1);
686 buffer.undo();
687 assert_eq!(buffer.text(), "123456");
688 buffer.redo();
689 assert_eq!(buffer.text(), "X12cde6");
690}
691
692#[gpui::test]
693fn test_finalize_last_transaction(cx: &mut gpui::TestAppContext) {
694 let now = Instant::now();
695 let mut buffer = Buffer::new(
696 ReplicaId::LOCAL,
697 BufferId::new(1).unwrap(),
698 "123456",
699 cx.background_executor(),
700 );
701 buffer.history.group_interval = Duration::from_millis(1);
702
703 buffer.start_transaction_at(now);
704 buffer.edit([(2..4, "cd")], cx.background_executor());
705 buffer.end_transaction_at(now);
706 assert_eq!(buffer.text(), "12cd56");
707
708 buffer.finalize_last_transaction();
709 buffer.start_transaction_at(now);
710 buffer.edit([(4..5, "e")], cx.background_executor());
711 buffer.end_transaction_at(now).unwrap();
712 assert_eq!(buffer.text(), "12cde6");
713
714 buffer.start_transaction_at(now);
715 buffer.edit([(0..1, "a")], cx.background_executor());
716 buffer.edit([(1..1, "b")], cx.background_executor());
717 buffer.end_transaction_at(now).unwrap();
718 assert_eq!(buffer.text(), "ab2cde6");
719
720 buffer.undo();
721 assert_eq!(buffer.text(), "12cd56");
722
723 buffer.undo();
724 assert_eq!(buffer.text(), "123456");
725
726 buffer.redo();
727 assert_eq!(buffer.text(), "12cd56");
728
729 buffer.redo();
730 assert_eq!(buffer.text(), "ab2cde6");
731}
732
733#[gpui::test]
734fn test_edited_ranges_for_transaction(cx: &mut gpui::TestAppContext) {
735 let now = Instant::now();
736 let mut buffer = Buffer::new(
737 ReplicaId::LOCAL,
738 BufferId::new(1).unwrap(),
739 "1234567",
740 cx.background_executor(),
741 );
742
743 buffer.start_transaction_at(now);
744 buffer.edit([(2..4, "cd")], cx.background_executor());
745 buffer.edit([(6..6, "efg")], cx.background_executor());
746 buffer.end_transaction_at(now);
747 assert_eq!(buffer.text(), "12cd56efg7");
748
749 let tx = buffer.finalize_last_transaction().unwrap().clone();
750 assert_eq!(
751 buffer
752 .edited_ranges_for_transaction::<usize>(&tx)
753 .collect::<Vec<_>>(),
754 [2..4, 6..9]
755 );
756
757 buffer.edit([(5..5, "hijk")], cx.background_executor());
758 assert_eq!(buffer.text(), "12cd5hijk6efg7");
759 assert_eq!(
760 buffer
761 .edited_ranges_for_transaction::<usize>(&tx)
762 .collect::<Vec<_>>(),
763 [2..4, 10..13]
764 );
765
766 buffer.edit([(4..4, "l")], cx.background_executor());
767 assert_eq!(buffer.text(), "12cdl5hijk6efg7");
768 assert_eq!(
769 buffer
770 .edited_ranges_for_transaction::<usize>(&tx)
771 .collect::<Vec<_>>(),
772 [2..4, 11..14]
773 );
774}
775
776#[gpui::test]
777fn test_concurrent_edits(cx: &mut gpui::TestAppContext) {
778 let text = "abcdef";
779
780 let mut buffer1 = Buffer::new(
781 ReplicaId::new(1),
782 BufferId::new(1).unwrap(),
783 text,
784 cx.background_executor(),
785 );
786 let mut buffer2 = Buffer::new(
787 ReplicaId::new(2),
788 BufferId::new(1).unwrap(),
789 text,
790 cx.background_executor(),
791 );
792 let mut buffer3 = Buffer::new(
793 ReplicaId::new(3),
794 BufferId::new(1).unwrap(),
795 text,
796 cx.background_executor(),
797 );
798
799 let buf1_op = buffer1.edit([(1..2, "12")], cx.background_executor());
800 assert_eq!(buffer1.text(), "a12cdef");
801 let buf2_op = buffer2.edit([(3..4, "34")], cx.background_executor());
802 assert_eq!(buffer2.text(), "abc34ef");
803 let buf3_op = buffer3.edit([(5..6, "56")], cx.background_executor());
804 assert_eq!(buffer3.text(), "abcde56");
805
806 buffer1.apply_op(buf2_op.clone(), Some(cx.background_executor()));
807 buffer1.apply_op(buf3_op.clone(), Some(cx.background_executor()));
808 buffer2.apply_op(buf1_op.clone(), Some(cx.background_executor()));
809 buffer2.apply_op(buf3_op, Some(cx.background_executor()));
810 buffer3.apply_op(buf1_op, Some(cx.background_executor()));
811 buffer3.apply_op(buf2_op, Some(cx.background_executor()));
812
813 assert_eq!(buffer1.text(), "a12c34e56");
814 assert_eq!(buffer2.text(), "a12c34e56");
815 assert_eq!(buffer3.text(), "a12c34e56");
816}
817
818#[gpui::test(iterations = 100)]
819fn test_random_concurrent_edits(mut rng: StdRng, cx: &mut gpui::TestAppContext) {
820 let peers = env::var("PEERS")
821 .map(|i| i.parse().expect("invalid `PEERS` variable"))
822 .unwrap_or(5);
823 let operations = env::var("OPERATIONS")
824 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
825 .unwrap_or(10);
826
827 let base_text_len = rng.random_range(0..10);
828 let base_text = RandomCharIter::new(&mut rng)
829 .take(base_text_len)
830 .collect::<String>();
831 let mut replica_ids = Vec::new();
832 let mut buffers = Vec::new();
833 let mut network = Network::new(rng.clone());
834
835 for i in 0..peers {
836 let mut buffer = Buffer::new(
837 ReplicaId::new(i as u16),
838 BufferId::new(1).unwrap(),
839 base_text.clone(),
840 cx.background_executor(),
841 );
842 buffer.history.group_interval = Duration::from_millis(rng.random_range(0..=200));
843 buffers.push(buffer);
844 replica_ids.push(ReplicaId::new(i as u16));
845 network.add_peer(ReplicaId::new(i as u16));
846 }
847
848 log::info!("initial text: {:?}", base_text);
849
850 let mut mutation_count = operations;
851 loop {
852 let replica_index = rng.random_range(0..peers);
853 let replica_id = replica_ids[replica_index];
854 let buffer = &mut buffers[replica_index];
855 match rng.random_range(0..=100) {
856 0..=50 if mutation_count != 0 => {
857 let op = buffer
858 .randomly_edit(&mut rng, 5, cx.background_executor())
859 .1;
860 network.broadcast(buffer.replica_id, vec![op]);
861 log::info!("buffer {:?} text: {:?}", buffer.replica_id, buffer.text());
862 mutation_count -= 1;
863 }
864 51..=70 if mutation_count != 0 => {
865 let ops = buffer.randomly_undo_redo(&mut rng);
866 network.broadcast(buffer.replica_id, ops);
867 mutation_count -= 1;
868 }
869 71..=100 if network.has_unreceived(replica_id) => {
870 let ops = network.receive(replica_id);
871 if !ops.is_empty() {
872 log::info!(
873 "peer {:?} applying {} ops from the network.",
874 replica_id,
875 ops.len()
876 );
877 buffer.apply_ops(ops, Some(cx.background_executor()));
878 }
879 }
880 _ => {}
881 }
882 buffer.check_invariants();
883
884 if mutation_count == 0 && network.is_idle() {
885 break;
886 }
887 }
888
889 let first_buffer = &buffers[0];
890 for buffer in &buffers[1..] {
891 assert_eq!(
892 buffer.text(),
893 first_buffer.text(),
894 "Replica {:?} text != Replica 0 text",
895 buffer.replica_id
896 );
897 buffer.check_invariants();
898 }
899}