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