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