RPM build fix (reverted CI changes which will need to be un-reverted or made conditional) and vendor Rust dependencies to make builds much faster in any CI system.

zeroidc/vendor/encoding_rs/src/testing.rs

@@ -0,0 +1,262 @@
+// Copyright Mozilla Foundation. See the COPYRIGHT
+// file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use super::*;
+
+pub fn decode(encoding: &'static Encoding, bytes: &[u8], expect: &str) {
+    let mut vec = Vec::with_capacity(bytes.len() + 32);
+    let mut string = String::with_capacity(expect.len() + 32);
+    let range = if cfg!(miri) {
+        0usize..4usize
+    } else {
+        0usize..32usize
+    };
+    for i in range {
+        vec.clear();
+        string.clear();
+        for j in 0usize..i {
+            let c = 0x40u8 + (j as u8);
+            vec.push(c);
+            string.push(c as char);
+        }
+        vec.extend_from_slice(bytes);
+        string.push_str(expect);
+        decode_without_padding_impl(encoding, &vec[..], &string[..], i);
+    }
+}
+
+pub fn decode_without_padding(encoding: &'static Encoding, bytes: &[u8], expect: &str) {
+    decode_without_padding_impl(encoding, bytes, expect, 0);
+}
+
+fn decode_without_padding_impl(
+    encoding: &'static Encoding,
+    bytes: &[u8],
+    expect: &str,
+    padding: usize,
+) {
+    decode_to_utf8_impl(encoding, bytes, expect, padding);
+    decode_to_utf16_impl(encoding, bytes, &utf16_from_utf8(expect)[..], padding);
+    decode_to_string(encoding, bytes, expect);
+}
+
+pub fn encode(encoding: &'static Encoding, str: &str, expect: &[u8]) {
+    let mut vec = Vec::with_capacity(expect.len() + 32);
+    let mut string = String::with_capacity(str.len() + 32);
+    let range = if cfg!(miri) {
+        0usize..4usize
+    } else {
+        0usize..32usize
+    };
+    for i in range {
+        vec.clear();
+        string.clear();
+        for j in 0usize..i {
+            let c = 0x40u8 + (j as u8);
+            vec.push(c);
+            string.push(c as char);
+        }
+        vec.extend_from_slice(expect);
+        string.push_str(str);
+        encode_without_padding(encoding, &string[..], &vec[..]);
+    }
+}
+
+pub fn encode_without_padding(encoding: &'static Encoding, string: &str, expect: &[u8]) {
+    encode_from_utf8(encoding, string, expect);
+    encode_from_utf16(encoding, &utf16_from_utf8(string)[..], expect);
+    encode_to_vec(encoding, string, expect);
+}
+
+pub fn decode_to_utf16(encoding: &'static Encoding, bytes: &[u8], expect: &[u16]) {
+    decode_to_utf16_impl(encoding, bytes, expect, 0);
+}
+
+pub fn decode_to_utf16_impl(
+    encoding: &'static Encoding,
+    bytes: &[u8],
+    expect: &[u16],
+    padding: usize,
+) {
+    for i in padding..bytes.len() {
+        let (head, tail) = bytes.split_at(i);
+        decode_to_utf16_with_boundary(encoding, head, tail, expect);
+    }
+}
+
+pub fn decode_to_utf16_with_boundary(
+    encoding: &'static Encoding,
+    head: &[u8],
+    tail: &[u8],
+    expect: &[u16],
+) {
+    let mut decoder = encoding.new_decoder();
+    let mut dest: Vec<u16> = Vec::with_capacity(
+        decoder
+            .max_utf16_buffer_length(head.len() + tail.len())
+            .unwrap(),
+    );
+    let capacity = dest.capacity();
+    dest.resize(capacity, 0u16);
+    let mut total_read = 0;
+    let mut total_written = 0;
+    {
+        let (complete, read, written, _) = decoder.decode_to_utf16(head, &mut dest, false);
+        match complete {
+            CoderResult::InputEmpty => {}
+            CoderResult::OutputFull => {
+                unreachable!();
+            }
+        }
+        total_read += read;
+        total_written += written;
+    }
+    {
+        let (complete, read, written, _) =
+            decoder.decode_to_utf16(tail, &mut dest[total_written..], true);
+        match complete {
+            CoderResult::InputEmpty => {}
+            CoderResult::OutputFull => {
+                unreachable!();
+            }
+        }
+        total_read += read;
+        total_written += written;
+    }
+    assert_eq!(total_read, head.len() + tail.len());
+    assert_eq!(total_written, expect.len());
+    dest.truncate(total_written);
+    assert_eq!(&dest[..], expect);
+}
+
+pub fn decode_to_utf8(encoding: &'static Encoding, bytes: &[u8], expect: &str) {
+    decode_to_utf8_impl(encoding, bytes, expect, 0);
+}
+
+pub fn decode_to_utf8_impl(
+    encoding: &'static Encoding,
+    bytes: &[u8],
+    expect: &str,
+    padding: usize,
+) {
+    for i in padding..bytes.len() {
+        let (head, tail) = bytes.split_at(i);
+        decode_to_utf8_with_boundary(encoding, head, tail, expect);
+    }
+}
+
+pub fn decode_to_utf8_with_boundary(
+    encoding: &'static Encoding,
+    head: &[u8],
+    tail: &[u8],
+    expect: &str,
+) {
+    let mut decoder = encoding.new_decoder();
+    let mut dest: Vec<u8> = Vec::with_capacity(
+        decoder
+            .max_utf8_buffer_length(head.len() + tail.len())
+            .unwrap(),
+    );
+    let capacity = dest.capacity();
+    dest.resize(capacity, 0u8);
+    let mut total_read = 0;
+    let mut total_written = 0;
+    {
+        let (complete, read, written, _) = decoder.decode_to_utf8(head, &mut dest, false);
+        match complete {
+            CoderResult::InputEmpty => {}
+            CoderResult::OutputFull => {
+                unreachable!();
+            }
+        }
+        total_read += read;
+        total_written += written;
+    }
+    {
+        let (complete, read, written, _) =
+            decoder.decode_to_utf8(tail, &mut dest[total_written..], true);
+        match complete {
+            CoderResult::InputEmpty => {}
+            CoderResult::OutputFull => {
+                unreachable!();
+            }
+        }
+        total_read += read;
+        total_written += written;
+    }
+    assert_eq!(total_read, head.len() + tail.len());
+    assert_eq!(total_written, expect.len());
+    dest.truncate(total_written);
+    assert_eq!(&dest[..], expect.as_bytes());
+}
+
+pub fn decode_to_string(encoding: &'static Encoding, bytes: &[u8], expect: &str) {
+    let (cow, _, _) = encoding.decode(bytes);
+    assert_eq!(&cow[..], expect);
+}
+
+pub fn encode_from_utf8(encoding: &'static Encoding, string: &str, expect: &[u8]) {
+    let mut encoder = encoding.new_encoder();
+    let mut dest: Vec<u8> = Vec::with_capacity(10 * (string.len() + 1)); // 10 is replacement worst case
+    let capacity = dest.capacity();
+    dest.resize(capacity, 0u8);
+    let (complete, read, written, _) = encoder.encode_from_utf8(string, &mut dest, true);
+    match complete {
+        CoderResult::InputEmpty => {}
+        CoderResult::OutputFull => {
+            unreachable!();
+        }
+    }
+    assert_eq!(read, string.len());
+    assert_eq!(written, expect.len());
+    dest.truncate(written);
+    assert_eq!(&dest[..], expect);
+}
+
+pub fn encode_from_utf16(encoding: &'static Encoding, string: &[u16], expect: &[u8]) {
+    let mut encoder = encoding.new_encoder();
+    let mut dest: Vec<u8> = Vec::with_capacity(10 * (string.len() + 1)); // 10 is replacement worst case
+    let capacity = dest.capacity();
+    dest.resize(capacity, 0u8);
+    let (complete, read, written, _) = encoder.encode_from_utf16(string, &mut dest, true);
+    match complete {
+        CoderResult::InputEmpty => {}
+        CoderResult::OutputFull => {
+            unreachable!();
+        }
+    }
+    assert_eq!(read, string.len());
+    // assert_eq!(written, expect.len());
+    dest.truncate(written);
+    assert_eq!(&dest[..], expect);
+}
+
+pub fn encode_to_vec(encoding: &'static Encoding, string: &str, expect: &[u8]) {
+    let (cow, _, _) = encoding.encode(string);
+    assert_eq!(&cow[..], expect);
+}
+
+pub fn utf16_from_utf8(string: &str) -> Vec<u16> {
+    let mut decoder = UTF_8.new_decoder_without_bom_handling();
+    let mut vec = Vec::with_capacity(decoder.max_utf16_buffer_length(string.len()).unwrap());
+    let capacity = vec.capacity();
+    vec.resize(capacity, 0);
+
+    let (result, read, written) =
+        decoder.decode_to_utf16_without_replacement(string.as_bytes(), &mut vec[..], true);
+    match result {
+        DecoderResult::InputEmpty => {
+            debug_assert_eq!(read, string.len());
+            vec.resize(written, 0);
+            vec
+        }
+        DecoderResult::Malformed(_, _) => unreachable!("Malformed"),
+        DecoderResult::OutputFull => unreachable!("Output full"),
+    }
+}