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