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