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