summaryrefslogtreecommitdiffstats
path: root/third_party/rust/bytes-0.4.12/tests/test_bytes.rs
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/bytes-0.4.12/tests/test_bytes.rs')
-rw-r--r--third_party/rust/bytes-0.4.12/tests/test_bytes.rs773
1 files changed, 773 insertions, 0 deletions
diff --git a/third_party/rust/bytes-0.4.12/tests/test_bytes.rs b/third_party/rust/bytes-0.4.12/tests/test_bytes.rs
new file mode 100644
index 0000000000..4cf340e6a1
--- /dev/null
+++ b/third_party/rust/bytes-0.4.12/tests/test_bytes.rs
@@ -0,0 +1,773 @@
+extern crate bytes;
+
+use bytes::{Bytes, BytesMut, BufMut, IntoBuf};
+
+const LONG: &'static [u8] = b"mary had a little lamb, little lamb, little lamb";
+const SHORT: &'static [u8] = b"hello world";
+
+fn inline_cap() -> usize {
+ use std::mem;
+ 4 * mem::size_of::<usize>() - 1
+}
+
+fn is_sync<T: Sync>() {}
+fn is_send<T: Send>() {}
+
+#[test]
+fn test_bounds() {
+ is_sync::<Bytes>();
+ is_sync::<BytesMut>();
+ is_send::<Bytes>();
+ is_send::<BytesMut>();
+}
+
+#[test]
+fn from_slice() {
+ let a = Bytes::from(&b"abcdefgh"[..]);
+ assert_eq!(a, b"abcdefgh"[..]);
+ assert_eq!(a, &b"abcdefgh"[..]);
+ assert_eq!(a, Vec::from(&b"abcdefgh"[..]));
+ assert_eq!(b"abcdefgh"[..], a);
+ assert_eq!(&b"abcdefgh"[..], a);
+ assert_eq!(Vec::from(&b"abcdefgh"[..]), a);
+
+ let a = BytesMut::from(&b"abcdefgh"[..]);
+ assert_eq!(a, b"abcdefgh"[..]);
+ assert_eq!(a, &b"abcdefgh"[..]);
+ assert_eq!(a, Vec::from(&b"abcdefgh"[..]));
+ assert_eq!(b"abcdefgh"[..], a);
+ assert_eq!(&b"abcdefgh"[..], a);
+ assert_eq!(Vec::from(&b"abcdefgh"[..]), a);
+}
+
+#[test]
+fn fmt() {
+ let a = format!("{:?}", Bytes::from(&b"abcdefg"[..]));
+ let b = "b\"abcdefg\"";
+
+ assert_eq!(a, b);
+
+ let a = format!("{:?}", BytesMut::from(&b"abcdefg"[..]));
+ assert_eq!(a, b);
+}
+
+#[test]
+fn fmt_write() {
+ use std::fmt::Write;
+ use std::iter::FromIterator;
+ let s = String::from_iter((0..10).map(|_| "abcdefg"));
+
+ let mut a = BytesMut::with_capacity(64);
+ write!(a, "{}", &s[..64]).unwrap();
+ assert_eq!(a, s[..64].as_bytes());
+
+
+ let mut b = BytesMut::with_capacity(64);
+ write!(b, "{}", &s[..32]).unwrap();
+ write!(b, "{}", &s[32..64]).unwrap();
+ assert_eq!(b, s[..64].as_bytes());
+
+
+ let mut c = BytesMut::with_capacity(64);
+ write!(c, "{}", s).unwrap_err();
+ assert!(c.is_empty());
+}
+
+#[test]
+fn len() {
+ let a = Bytes::from(&b"abcdefg"[..]);
+ assert_eq!(a.len(), 7);
+
+ let a = BytesMut::from(&b"abcdefg"[..]);
+ assert_eq!(a.len(), 7);
+
+ let a = Bytes::from(&b""[..]);
+ assert!(a.is_empty());
+
+ let a = BytesMut::from(&b""[..]);
+ assert!(a.is_empty());
+}
+
+#[test]
+fn index() {
+ let a = Bytes::from(&b"hello world"[..]);
+ assert_eq!(a[0..5], *b"hello");
+}
+
+#[test]
+fn slice() {
+ let a = Bytes::from(&b"hello world"[..]);
+
+ let b = a.slice(3, 5);
+ assert_eq!(b, b"lo"[..]);
+
+ let b = a.slice(0, 0);
+ assert_eq!(b, b""[..]);
+
+ let b = a.slice(3, 3);
+ assert_eq!(b, b""[..]);
+
+ let b = a.slice(a.len(), a.len());
+ assert_eq!(b, b""[..]);
+
+ let b = a.slice_to(5);
+ assert_eq!(b, b"hello"[..]);
+
+ let b = a.slice_from(3);
+ assert_eq!(b, b"lo world"[..]);
+}
+
+#[test]
+#[should_panic]
+fn slice_oob_1() {
+ let a = Bytes::from(&b"hello world"[..]);
+ a.slice(5, inline_cap() + 1);
+}
+
+#[test]
+#[should_panic]
+fn slice_oob_2() {
+ let a = Bytes::from(&b"hello world"[..]);
+ a.slice(inline_cap() + 1, inline_cap() + 5);
+}
+
+#[test]
+fn split_off() {
+ let mut hello = Bytes::from(&b"helloworld"[..]);
+ let world = hello.split_off(5);
+
+ assert_eq!(hello, &b"hello"[..]);
+ assert_eq!(world, &b"world"[..]);
+
+ let mut hello = BytesMut::from(&b"helloworld"[..]);
+ let world = hello.split_off(5);
+
+ assert_eq!(hello, &b"hello"[..]);
+ assert_eq!(world, &b"world"[..]);
+}
+
+#[test]
+#[should_panic]
+fn split_off_oob() {
+ let mut hello = Bytes::from(&b"helloworld"[..]);
+ hello.split_off(inline_cap() + 1);
+}
+
+#[test]
+fn split_off_uninitialized() {
+ let mut bytes = BytesMut::with_capacity(1024);
+ let other = bytes.split_off(128);
+
+ assert_eq!(bytes.len(), 0);
+ assert_eq!(bytes.capacity(), 128);
+
+ assert_eq!(other.len(), 0);
+ assert_eq!(other.capacity(), 896);
+}
+
+#[test]
+fn split_off_to_loop() {
+ let s = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+ for i in 0..(s.len() + 1) {
+ {
+ let mut bytes = Bytes::from(&s[..]);
+ let off = bytes.split_off(i);
+ assert_eq!(i, bytes.len());
+ let mut sum = Vec::new();
+ sum.extend(&bytes);
+ sum.extend(&off);
+ assert_eq!(&s[..], &sum[..]);
+ }
+ {
+ let mut bytes = BytesMut::from(&s[..]);
+ let off = bytes.split_off(i);
+ assert_eq!(i, bytes.len());
+ let mut sum = Vec::new();
+ sum.extend(&bytes);
+ sum.extend(&off);
+ assert_eq!(&s[..], &sum[..]);
+ }
+ {
+ let mut bytes = Bytes::from(&s[..]);
+ let off = bytes.split_to(i);
+ assert_eq!(i, off.len());
+ let mut sum = Vec::new();
+ sum.extend(&off);
+ sum.extend(&bytes);
+ assert_eq!(&s[..], &sum[..]);
+ }
+ {
+ let mut bytes = BytesMut::from(&s[..]);
+ let off = bytes.split_to(i);
+ assert_eq!(i, off.len());
+ let mut sum = Vec::new();
+ sum.extend(&off);
+ sum.extend(&bytes);
+ assert_eq!(&s[..], &sum[..]);
+ }
+ }
+}
+
+#[test]
+fn split_to_1() {
+ // Inline
+ let mut a = Bytes::from(SHORT);
+ let b = a.split_to(4);
+
+ assert_eq!(SHORT[4..], a);
+ assert_eq!(SHORT[..4], b);
+
+ // Allocated
+ let mut a = Bytes::from(LONG);
+ let b = a.split_to(4);
+
+ assert_eq!(LONG[4..], a);
+ assert_eq!(LONG[..4], b);
+
+ let mut a = Bytes::from(LONG);
+ let b = a.split_to(30);
+
+ assert_eq!(LONG[30..], a);
+ assert_eq!(LONG[..30], b);
+}
+
+#[test]
+fn split_to_2() {
+ let mut a = Bytes::from(LONG);
+ assert_eq!(LONG, a);
+
+ let b = a.split_to(1);
+
+ assert_eq!(LONG[1..], a);
+ drop(b);
+}
+
+#[test]
+#[should_panic]
+fn split_to_oob() {
+ let mut hello = Bytes::from(&b"helloworld"[..]);
+ hello.split_to(inline_cap() + 1);
+}
+
+#[test]
+#[should_panic]
+fn split_to_oob_mut() {
+ let mut hello = BytesMut::from(&b"helloworld"[..]);
+ hello.split_to(inline_cap() + 1);
+}
+
+#[test]
+fn split_to_uninitialized() {
+ let mut bytes = BytesMut::with_capacity(1024);
+ let other = bytes.split_to(128);
+
+ assert_eq!(bytes.len(), 0);
+ assert_eq!(bytes.capacity(), 896);
+
+ assert_eq!(other.len(), 0);
+ assert_eq!(other.capacity(), 128);
+}
+
+#[test]
+fn split_off_to_at_gt_len() {
+ fn make_bytes() -> Bytes {
+ let mut bytes = BytesMut::with_capacity(100);
+ bytes.put_slice(&[10, 20, 30, 40]);
+ bytes.freeze()
+ }
+
+ use std::panic;
+
+ make_bytes().split_to(4);
+ make_bytes().split_off(4);
+
+ assert!(panic::catch_unwind(move || {
+ make_bytes().split_to(5);
+ }).is_err());
+
+ assert!(panic::catch_unwind(move || {
+ make_bytes().split_off(5);
+ }).is_err());
+}
+
+#[test]
+fn fns_defined_for_bytes_mut() {
+ let mut bytes = BytesMut::from(&b"hello world"[..]);
+
+ bytes.as_ptr();
+ bytes.as_mut_ptr();
+
+ // Iterator
+ let v: Vec<u8> = bytes.iter().map(|b| *b).collect();
+ assert_eq!(&v[..], bytes);
+}
+
+#[test]
+fn mut_into_buf() {
+ let mut v = vec![0, 0, 0, 0];
+ let s = &mut v[..];
+ s.into_buf().put_u32_le(42);
+}
+
+#[test]
+fn reserve_convert() {
+ // Inline -> Vec
+ let mut bytes = BytesMut::with_capacity(8);
+ bytes.put("hello");
+ bytes.reserve(40);
+ assert_eq!(bytes.capacity(), 45);
+ assert_eq!(bytes, "hello");
+
+ // Inline -> Inline
+ let mut bytes = BytesMut::with_capacity(inline_cap());
+ bytes.put("abcdefghijkl");
+
+ let a = bytes.split_to(10);
+ bytes.reserve(inline_cap() - 3);
+ assert_eq!(inline_cap(), bytes.capacity());
+
+ assert_eq!(bytes, "kl");
+ assert_eq!(a, "abcdefghij");
+
+ // Vec -> Vec
+ let mut bytes = BytesMut::from(LONG);
+ bytes.reserve(64);
+ assert_eq!(bytes.capacity(), LONG.len() + 64);
+
+ // Arc -> Vec
+ let mut bytes = BytesMut::from(LONG);
+ let a = bytes.split_to(30);
+
+ bytes.reserve(128);
+ assert!(bytes.capacity() >= bytes.len() + 128);
+
+ drop(a);
+}
+
+#[test]
+fn reserve_growth() {
+ let mut bytes = BytesMut::with_capacity(64);
+ bytes.put("hello world");
+ let _ = bytes.take();
+
+ bytes.reserve(65);
+ assert_eq!(bytes.capacity(), 128);
+}
+
+#[test]
+fn reserve_allocates_at_least_original_capacity() {
+ let mut bytes = BytesMut::with_capacity(1024);
+
+ for i in 0..1020 {
+ bytes.put(i as u8);
+ }
+
+ let _other = bytes.take();
+
+ bytes.reserve(16);
+ assert_eq!(bytes.capacity(), 1024);
+}
+
+#[test]
+fn reserve_max_original_capacity_value() {
+ const SIZE: usize = 128 * 1024;
+
+ let mut bytes = BytesMut::with_capacity(SIZE);
+
+ for _ in 0..SIZE {
+ bytes.put(0u8);
+ }
+
+ let _other = bytes.take();
+
+ bytes.reserve(16);
+ assert_eq!(bytes.capacity(), 64 * 1024);
+}
+
+// Without either looking at the internals of the BytesMut or doing weird stuff
+// with the memory allocator, there's no good way to automatically verify from
+// within the program that this actually recycles memory. Instead, just exercise
+// the code path to ensure that the results are correct.
+#[test]
+fn reserve_vec_recycling() {
+ let mut bytes = BytesMut::from(Vec::with_capacity(16));
+ assert_eq!(bytes.capacity(), 16);
+ bytes.put("0123456789012345");
+ bytes.advance(10);
+ assert_eq!(bytes.capacity(), 6);
+ bytes.reserve(8);
+ assert_eq!(bytes.capacity(), 16);
+}
+
+#[test]
+fn reserve_in_arc_unique_does_not_overallocate() {
+ let mut bytes = BytesMut::with_capacity(1000);
+ bytes.take();
+
+ // now bytes is Arc and refcount == 1
+
+ assert_eq!(1000, bytes.capacity());
+ bytes.reserve(2001);
+ assert_eq!(2001, bytes.capacity());
+}
+
+#[test]
+fn reserve_in_arc_unique_doubles() {
+ let mut bytes = BytesMut::with_capacity(1000);
+ bytes.take();
+
+ // now bytes is Arc and refcount == 1
+
+ assert_eq!(1000, bytes.capacity());
+ bytes.reserve(1001);
+ assert_eq!(2000, bytes.capacity());
+}
+
+#[test]
+fn reserve_in_arc_nonunique_does_not_overallocate() {
+ let mut bytes = BytesMut::with_capacity(1000);
+ let _copy = bytes.take();
+
+ // now bytes is Arc and refcount == 2
+
+ assert_eq!(1000, bytes.capacity());
+ bytes.reserve(2001);
+ assert_eq!(2001, bytes.capacity());
+}
+
+#[test]
+fn inline_storage() {
+ let mut bytes = BytesMut::with_capacity(inline_cap());
+ let zero = [0u8; 64];
+
+ bytes.put(&zero[0..inline_cap()]);
+ assert_eq!(*bytes, zero[0..inline_cap()]);
+}
+
+#[test]
+fn extend_mut() {
+ let mut bytes = BytesMut::with_capacity(0);
+ bytes.extend(LONG);
+ assert_eq!(*bytes, LONG[..]);
+}
+
+#[test]
+fn extend_shr() {
+ let mut bytes = Bytes::new();
+ bytes.extend(LONG);
+ assert_eq!(*bytes, LONG[..]);
+}
+
+#[test]
+fn extend_from_slice_mut() {
+ for &i in &[3, 34] {
+ let mut bytes = BytesMut::new();
+ bytes.extend_from_slice(&LONG[..i]);
+ bytes.extend_from_slice(&LONG[i..]);
+ assert_eq!(LONG[..], *bytes);
+ }
+}
+
+#[test]
+fn extend_from_slice_shr() {
+ for &i in &[3, 34] {
+ let mut bytes = Bytes::new();
+ bytes.extend_from_slice(&LONG[..i]);
+ bytes.extend_from_slice(&LONG[i..]);
+ assert_eq!(LONG[..], *bytes);
+ }
+}
+
+#[test]
+fn from_static() {
+ let mut a = Bytes::from_static(b"ab");
+ let b = a.split_off(1);
+
+ assert_eq!(a, b"a"[..]);
+ assert_eq!(b, b"b"[..]);
+}
+
+#[test]
+fn advance_inline() {
+ let mut a = Bytes::from(&b"hello world"[..]);
+ a.advance(6);
+ assert_eq!(a, &b"world"[..]);
+}
+
+#[test]
+fn advance_static() {
+ let mut a = Bytes::from_static(b"hello world");
+ a.advance(6);
+ assert_eq!(a, &b"world"[..]);
+}
+
+#[test]
+fn advance_vec() {
+ let mut a = BytesMut::from(b"hello world boooo yah world zomg wat wat".to_vec());
+ a.advance(16);
+ assert_eq!(a, b"o yah world zomg wat wat"[..]);
+
+ a.advance(4);
+ assert_eq!(a, b"h world zomg wat wat"[..]);
+
+ // Reserve some space.
+ a.reserve(1024);
+ assert_eq!(a, b"h world zomg wat wat"[..]);
+
+ a.advance(6);
+ assert_eq!(a, b"d zomg wat wat"[..]);
+}
+
+#[test]
+#[should_panic]
+fn advance_past_len() {
+ let mut a = BytesMut::from(b"hello world".to_vec());
+ a.advance(20);
+}
+
+#[test]
+// Only run these tests on little endian systems. CI uses qemu for testing
+// little endian... and qemu doesn't really support threading all that well.
+#[cfg(target_endian = "little")]
+fn stress() {
+ // Tests promoting a buffer from a vec -> shared in a concurrent situation
+ use std::sync::{Arc, Barrier};
+ use std::thread;
+
+ const THREADS: usize = 8;
+ const ITERS: usize = 1_000;
+
+ for i in 0..ITERS {
+ let data = [i as u8; 256];
+ let buf = Arc::new(Bytes::from(&data[..]));
+
+ let barrier = Arc::new(Barrier::new(THREADS));
+ let mut joins = Vec::with_capacity(THREADS);
+
+ for _ in 0..THREADS {
+ let c = barrier.clone();
+ let buf = buf.clone();
+
+ joins.push(thread::spawn(move || {
+ c.wait();
+ let buf: Bytes = (*buf).clone();
+ drop(buf);
+ }));
+ }
+
+ for th in joins {
+ th.join().unwrap();
+ }
+
+ assert_eq!(*buf, data[..]);
+ }
+}
+
+#[test]
+fn partial_eq_bytesmut() {
+ let bytes = Bytes::from(&b"The quick red fox"[..]);
+ let bytesmut = BytesMut::from(&b"The quick red fox"[..]);
+ assert!(bytes == bytesmut);
+ assert!(bytesmut == bytes);
+ let bytes2 = Bytes::from(&b"Jumped over the lazy brown dog"[..]);
+ assert!(bytes2 != bytesmut);
+ assert!(bytesmut != bytes2);
+}
+
+#[test]
+fn unsplit_basic() {
+ let mut buf = BytesMut::with_capacity(64);
+ buf.extend_from_slice(b"aaabbbcccddd");
+
+ let splitted = buf.split_off(6);
+ assert_eq!(b"aaabbb", &buf[..]);
+ assert_eq!(b"cccddd", &splitted[..]);
+
+ buf.unsplit(splitted);
+ assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_empty_other() {
+ let mut buf = BytesMut::with_capacity(64);
+ buf.extend_from_slice(b"aaabbbcccddd");
+
+ // empty other
+ let other = BytesMut::new();
+
+ buf.unsplit(other);
+ assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_empty_self() {
+ // empty self
+ let mut buf = BytesMut::new();
+
+ let mut other = BytesMut::with_capacity(64);
+ other.extend_from_slice(b"aaabbbcccddd");
+
+ buf.unsplit(other);
+ assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_inline_arc() {
+ let mut buf = BytesMut::with_capacity(8); //inline
+ buf.extend_from_slice(b"aaaabbbb");
+
+ let mut buf2 = BytesMut::with_capacity(64);
+ buf2.extend_from_slice(b"ccccddddeeee");
+
+ buf2.split_off(8); //arc
+
+ buf.unsplit(buf2);
+ assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_arc_inline() {
+ let mut buf = BytesMut::with_capacity(64);
+ buf.extend_from_slice(b"aaaabbbbeeee");
+
+ buf.split_off(8); //arc
+
+ let mut buf2 = BytesMut::with_capacity(8); //inline
+ buf2.extend_from_slice(b"ccccdddd");
+
+ buf.unsplit(buf2);
+ assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+
+}
+
+#[test]
+fn unsplit_both_inline() {
+ let mut buf = BytesMut::with_capacity(16); //inline
+ buf.extend_from_slice(b"aaaabbbbccccdddd");
+
+ let splitted = buf.split_off(8); // both inline
+ assert_eq!(b"aaaabbbb", &buf[..]);
+ assert_eq!(b"ccccdddd", &splitted[..]);
+
+ buf.unsplit(splitted);
+ assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+
+#[test]
+fn unsplit_arc_different() {
+ let mut buf = BytesMut::with_capacity(64);
+ buf.extend_from_slice(b"aaaabbbbeeee");
+
+ buf.split_off(8); //arc
+
+ let mut buf2 = BytesMut::with_capacity(64);
+ buf2.extend_from_slice(b"ccccddddeeee");
+
+ buf2.split_off(8); //arc
+
+ buf.unsplit(buf2);
+ assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_arc_non_contiguous() {
+ let mut buf = BytesMut::with_capacity(64);
+ buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
+
+ let mut buf2 = buf.split_off(8); //arc
+
+ let buf3 = buf2.split_off(4); //arc
+
+ buf.unsplit(buf3);
+ assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_two_split_offs() {
+ let mut buf = BytesMut::with_capacity(64);
+ buf.extend_from_slice(b"aaaabbbbccccdddd");
+
+ let mut buf2 = buf.split_off(8); //arc
+ let buf3 = buf2.split_off(4); //arc
+
+ buf2.unsplit(buf3);
+ buf.unsplit(buf2);
+ assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn from_iter_no_size_hint() {
+ use std::iter;
+
+ let mut expect = vec![];
+
+ let actual: Bytes = iter::repeat(b'x')
+ .scan(100, |cnt, item| {
+ if *cnt >= 1 {
+ *cnt -= 1;
+ expect.push(item);
+ Some(item)
+ } else {
+ None
+ }
+ })
+ .collect();
+
+ assert_eq!(&actual[..], &expect[..]);
+}
+
+fn test_slice_ref(bytes: &Bytes, start: usize, end: usize, expected: &[u8]) {
+ let slice = &(bytes.as_ref()[start..end]);
+ let sub = bytes.slice_ref(&slice);
+ assert_eq!(&sub[..], expected);
+}
+
+#[test]
+fn slice_ref_works() {
+ let bytes = Bytes::from(&b"012345678"[..]);
+
+ test_slice_ref(&bytes, 0, 0, b"");
+ test_slice_ref(&bytes, 0, 3, b"012");
+ test_slice_ref(&bytes, 2, 6, b"2345");
+ test_slice_ref(&bytes, 7, 9, b"78");
+ test_slice_ref(&bytes, 9, 9, b"");
+}
+
+
+#[test]
+fn slice_ref_empty() {
+ let bytes = Bytes::from(&b""[..]);
+ let slice = &(bytes.as_ref()[0..0]);
+
+ let sub = bytes.slice_ref(&slice);
+ assert_eq!(&sub[..], b"");
+}
+
+#[test]
+#[should_panic]
+fn slice_ref_catches_not_a_subset() {
+ let bytes = Bytes::from(&b"012345678"[..]);
+ let slice = &b"012345"[0..4];
+
+ bytes.slice_ref(slice);
+}
+
+#[test]
+#[should_panic]
+fn slice_ref_catches_not_an_empty_subset() {
+ let bytes = Bytes::from(&b"012345678"[..]);
+ let slice = &b""[0..0];
+
+ bytes.slice_ref(slice);
+}
+
+#[test]
+#[should_panic]
+fn empty_slice_ref_catches_not_an_empty_subset() {
+ let bytes = Bytes::from(&b""[..]);
+ let slice = &b""[0..0];
+
+ bytes.slice_ref(slice);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-04 11:50:48 +0000