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