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