Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 281 insertions, 0 deletions

diff --git a/third_party/rust/line-wrap/src/tests.rs b/third_party/rust/line-wrap/src/tests.rs
new file mode 100644
index 0000000000..6793e10968
--- /dev/null
+++ b/third_party/rust/line-wrap/src/tests.rs
@@ -0,0 +1,281 @@
+extern crate rand;
+
+
+use super::*;
+use self::rand::distributions::{Distribution, Range};
+use self::rand::{Rng, FromEntropy};
+
+#[test]
+fn line_params_perfect_multiple_of_line_length_lf() {
+    let params = line_wrap_parameters(100, 20, lf().len());
+
+    assert_eq!(
+        LineWrapParameters {
+            line_with_ending_len: 21,
+            lines_with_endings: 4,
+            last_line_len: 20,
+            total_full_wrapped_lines_len: 84,
+            total_len: 104,
+            total_line_endings_len: 4,
+        },
+        params
+    );
+}
+
+#[test]
+fn line_params_partial_last_line_crlf() {
+    let params = line_wrap_parameters(103, 20, crlf().len());
+
+    assert_eq!(
+        LineWrapParameters {
+            line_with_ending_len: 22,
+            lines_with_endings: 5,
+            last_line_len: 3,
+            total_full_wrapped_lines_len: 110,
+            total_len: 113,
+            total_line_endings_len: 10,
+        },
+        params
+    );
+}
+
+#[test]
+fn line_params_line_len_1_crlf() {
+    let params = line_wrap_parameters(100, 1, crlf().len());
+
+    assert_eq!(
+        LineWrapParameters {
+            line_with_ending_len: 3,
+            lines_with_endings: 99,
+            last_line_len: 1,
+            total_full_wrapped_lines_len: 99 * 3,
+            total_len: 99 * 3 + 1,
+            total_line_endings_len: 99 * 2,
+        },
+        params
+    );
+}
+
+#[test]
+fn line_params_line_len_longer_than_input_crlf() {
+    let params = line_wrap_parameters(100, 200, crlf().len());
+
+    assert_eq!(
+        LineWrapParameters {
+            line_with_ending_len: 202,
+            lines_with_endings: 0,
+            last_line_len: 100,
+            total_full_wrapped_lines_len: 0,
+            total_len: 100,
+            total_line_endings_len: 0,
+        },
+        params
+    );
+}
+
+#[test]
+fn line_params_line_len_same_as_input_crlf() {
+    let params = line_wrap_parameters(100, 100, crlf().len());
+
+    assert_eq!(
+        LineWrapParameters {
+            line_with_ending_len: 102,
+            lines_with_endings: 0,
+            last_line_len: 100,
+            total_full_wrapped_lines_len: 0,
+            total_len: 100,
+            total_line_endings_len: 0,
+        },
+        params
+    );
+}
+
+
+#[test]
+fn line_wrap_length_1_lf() {
+    let mut buf = vec![0x1, 0x2, 0x3, 0x4];
+
+    assert_eq!(3, do_line_wrap(&mut buf, 1, &lf()));
+
+    assert_eq!(vec![0x1, 0xA, 0x2, 0xA, 0x3, 0xA, 0x4], buf);
+}
+
+#[test]
+fn line_wrap_length_1_crlf() {
+    let mut buf = vec![0x1, 0x2, 0x3, 0x4];
+
+    assert_eq!(6, do_line_wrap(&mut buf, 1, &crlf()));
+
+    assert_eq!(vec![0x1, 0xD, 0xA, 0x2, 0xD, 0xA, 0x3, 0xD, 0xA, 0x4], buf);
+}
+
+#[test]
+fn line_wrap_length_2_lf_full_lines() {
+    let mut buf = vec![0x1, 0x2, 0x3, 0x4];
+
+    assert_eq!(1, do_line_wrap(&mut buf, 2, &lf()));
+
+    assert_eq!(vec![0x1, 0x2, 0xA, 0x3, 0x4], buf);
+}
+
+#[test]
+fn line_wrap_length_2_crlf_full_lines() {
+    let mut buf = vec![0x1, 0x2, 0x3, 0x4];
+
+    assert_eq!(2, do_line_wrap(&mut buf, 2, &crlf()));
+
+    assert_eq!(vec![0x1, 0x2, 0xD, 0xA, 0x3, 0x4], buf);
+}
+
+#[test]
+fn line_wrap_length_2_lf_partial_line() {
+    let mut buf = vec![0x1, 0x2, 0x3, 0x4, 0x5];
+
+    assert_eq!(2, do_line_wrap(&mut buf, 2, &lf()));
+
+    assert_eq!(vec![0x1, 0x2, 0xA, 0x3, 0x4, 0xA, 0x5], buf);
+}
+
+#[test]
+fn line_wrap_length_2_crlf_partial_line() {
+    let mut buf = vec![0x1, 0x2, 0x3, 0x4, 0x5];
+
+    assert_eq!(4, do_line_wrap(&mut buf, 2, &crlf()));
+
+    assert_eq!(vec![0x1, 0x2, 0xD, 0xA, 0x3, 0x4, 0xD, 0xA, 0x5], buf);
+}
+
+#[test]
+fn line_wrap_random_slice() {
+    let mut buf: Vec<u8> = Vec::new();
+    let buf_range = Range::new(10, 1000);
+    let line_range = Range::new(10, 100);
+    let mut rng = rand::rngs::SmallRng::from_entropy();
+    let mut line_ending_bytes: Vec<u8> = Vec::new();
+
+    for _ in 0..10_000 {
+        buf.clear();
+        line_ending_bytes.clear();
+
+        let buf_len = buf_range.sample(&mut rng);
+        let line_len = line_range.sample(&mut rng);
+
+        for _ in 0..buf_len {
+            buf.push(rng.gen());
+        }
+
+        line_ending_bytes.clear();
+        for _ in 0..rng.gen_range(1, 11) {
+            line_ending_bytes.push(rng.gen());
+        }
+        let line_ending = SliceLineEnding::new(&line_ending_bytes);
+
+        let _ = do_line_wrap(&mut buf, line_len, &line_ending);
+    }
+}
+
+#[test]
+fn line_wrap_random_single_byte() {
+    let mut buf: Vec<u8> = Vec::new();
+    let buf_range = Range::new(10, 1000);
+    let line_range = Range::new(10, 100);
+    let mut rng = rand::rngs::SmallRng::from_entropy();
+
+    for _ in 0..10_000 {
+        buf.clear();
+
+        let buf_len = buf_range.sample(&mut rng);
+        let line_len = line_range.sample(&mut rng);
+
+        for _ in 0..buf_len {
+            buf.push(rng.gen());
+        }
+
+        let line_ending = ByteLineEnding::new(rng.gen());
+
+        let _ = do_line_wrap(&mut buf, line_len, &line_ending);
+    }
+}
+
+#[test]
+fn line_wrap_random_two_bytes() {
+    let mut buf: Vec<u8> = Vec::new();
+    let buf_range = Range::new(10, 1000);
+    let line_range = Range::new(10, 100);
+    let mut rng = rand::rngs::SmallRng::from_entropy();
+
+    for _ in 0..10_000 {
+        buf.clear();
+
+        let buf_len = buf_range.sample(&mut rng);
+        let line_len = line_range.sample(&mut rng);
+
+        for _ in 0..buf_len {
+            buf.push(rng.gen());
+        }
+
+        let line_ending = TwoByteLineEnding::new(rng.gen(), rng.gen());
+
+        let _ = do_line_wrap(&mut buf, line_len, &line_ending);
+    }
+}
+
+fn do_line_wrap<L: LineEnding>(buf: &mut Vec<u8>, line_len: usize, line_ending: &L) -> usize {
+    let mut rng = rand::rngs::SmallRng::from_entropy();
+
+    let orig_len = buf.len();
+    let orig_buf = buf.to_vec();
+
+    // Add on extra bytes so we'll have sentinel bytes at the end that shouldn't get changed.
+    for _ in 0..(1000 + line_ending.len() * orig_len) {
+        buf.push(rng.gen());
+    }
+
+    let before_line_wrap = buf.to_vec();
+
+    let params = line_wrap_parameters(orig_len, line_len, line_ending.len());
+
+    let bytes_written = line_wrap::<L>(&mut buf[..], orig_len, line_len, line_ending);
+
+    assert_eq!(params.total_line_endings_len, bytes_written);
+    assert_eq!(params.lines_with_endings * line_ending.len(), bytes_written);
+    assert_eq!(params.total_len, orig_len + bytes_written);
+
+    // make sure line_wrap didn't touch anything beyond what it should
+    assert_eq!(before_line_wrap[params.total_len..], buf[params.total_len..]);
+
+    {
+        // also make sure that line wrapping will fit into a slice no bigger than what it should
+        // need
+        let mut buf_strict = before_line_wrap.to_vec();
+        buf_strict.truncate(orig_len);
+        // fill in some fresh random garbage
+        while buf_strict.len() < params.total_len {
+            buf_strict.push(rng.gen());
+        }
+        let bytes_written_precise_fit = line_wrap::<L>(
+            &mut buf_strict,
+            orig_len,
+            line_len,
+            line_ending,
+        );
+        assert_eq!(params.total_len, buf_strict.len());
+        assert_eq!(bytes_written, bytes_written_precise_fit);
+        assert_eq!(&buf[0..(params.total_len)], &buf_strict[..]);
+
+        // since we have a copy of the wrapped bytes lying around, remove the endings and see
+        // if we get the original
+        for line_ending_num in 0..params.lines_with_endings {
+            let line_ending_offset = (line_ending_num + 1) * line_len;
+
+            for _ in 0..line_ending.len() {
+                let _ = buf_strict.remove(line_ending_offset);
+            }
+        }
+        assert_eq!(orig_buf, buf_strict);
+    }
+
+    buf.truncate(params.total_len);
+
+    bytes_written
+}
\ No newline at end of file