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