cessen/led
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Change encoding/decoding function naming.

Browse Source 
I think this makes it more obvious at-a-glance what they do.
This commit is contained in:
Nathan Vegdahl 2018-08-22 15:05:38 -07:00
parent 37acbba36a
commit 006b578318
9 changed files with 131 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sub_crates/text_encoding/src/latin1.rs
View File

@ -8,7 +8,7 @@
use core; use core;
use {DecodeResult, EncodeError, EncodeResult}; use {DecodeResult, EncodeError, EncodeResult};
pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> { pub fn encode_from_str<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> {
// Do the encode. // Do the encode.
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -41,7 +41,7 @@ pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'
Ok((input_i, &output[..output_i])) Ok((input_i, &output[..output_i]))
} }
pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> { pub fn decode_to_str<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> {
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
for &byte in input.iter() { for &byte in input.iter() {

32
sub_crates/text_encoding/src/lib.rs
View File

@ -13,36 +13,36 @@ mod utils;
mod windows1252; mod windows1252;
/// Encodes text from utf8 to a destination encoding. /// Encodes text from utf8 to a destination encoding.
pub fn encode_from_utf8<'a>( pub fn encode_from_str<'a>(
output_encoding: Encoding, output_encoding: Encoding,
input: &str, input: &str,
output: &'a mut [u8], output: &'a mut [u8],
) -> EncodeResult<'a> { ) -> EncodeResult<'a> {
match output_encoding { match output_encoding {
Encoding::Utf8 => utf8::encode_from_utf8(input, output), Encoding::Utf8 => utf8::encode_from_str(input, output),
Encoding::Utf16BE => utf16_be::encode_from_utf8(input, output), Encoding::Utf16BE => utf16_be::encode_from_str(input, output),
Encoding::Utf16LE => utf16_le::encode_from_utf8(input, output), Encoding::Utf16LE => utf16_le::encode_from_str(input, output),
Encoding::Utf32BE => utf32_be::encode_from_utf8(input, output), Encoding::Utf32BE => utf32_be::encode_from_str(input, output),
Encoding::Utf32LE => utf32_le::encode_from_utf8(input, output), Encoding::Utf32LE => utf32_le::encode_from_str(input, output),
Encoding::Latin1 => latin1::encode_from_utf8(input, output), Encoding::Latin1 => latin1::encode_from_str(input, output),
Encoding::Windows1252 => windows1252::encode_from_utf8(input, output), Encoding::Windows1252 => windows1252::encode_from_str(input, output),
} }
} }
/// Decodes text from a source encoding to utf8. /// Decodes text from a source encoding to utf8.
pub fn decode_to_utf8<'a>( pub fn decode_to_str<'a>(
input_encoding: Encoding, input_encoding: Encoding,
input: &[u8], input: &[u8],
output: &'a mut [u8], output: &'a mut [u8],
) -> DecodeResult<'a> { ) -> DecodeResult<'a> {
match input_encoding { match input_encoding {
Encoding::Utf8 => utf8::decode_to_utf8(input, output), Encoding::Utf8 => utf8::decode_to_str(input, output),
Encoding::Utf16BE => utf16_be::decode_to_utf8(input, output), Encoding::Utf16BE => utf16_be::decode_to_str(input, output),
Encoding::Utf16LE => utf16_le::decode_to_utf8(input, output), Encoding::Utf16LE => utf16_le::decode_to_str(input, output),
Encoding::Utf32BE => utf32_be::decode_to_utf8(input, output), Encoding::Utf32BE => utf32_be::decode_to_str(input, output),
Encoding::Utf32LE => utf32_le::decode_to_utf8(input, output), Encoding::Utf32LE => utf32_le::decode_to_str(input, output),
Encoding::Latin1 => latin1::decode_to_utf8(input, output), Encoding::Latin1 => latin1::decode_to_str(input, output),
Encoding::Windows1252 => windows1252::decode_to_utf8(input, output), Encoding::Windows1252 => windows1252::decode_to_str(input, output),
} }
} }

46
sub_crates/text_encoding/src/utf16_be.rs
View File

@ -8,7 +8,7 @@ use core;
use utils::{from_big_endian_u16, to_big_endian_u16}; use utils::{from_big_endian_u16, to_big_endian_u16};
use {DecodeError, DecodeResult, EncodeResult}; use {DecodeError, DecodeResult, EncodeResult};
pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> { pub fn encode_from_str<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> {
// Do the encode. // Do the encode.
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -53,7 +53,7 @@ pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'
Ok((input_i, &output[..output_i])) Ok((input_i, &output[..output_i]))
} }
pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> { pub fn decode_to_str<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> {
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -127,7 +127,7 @@ mod tests {
fn encode_01() { fn encode_01() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 1]; let mut buf = [0u8; 1];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -136,7 +136,7 @@ mod tests {
fn encode_02() { fn encode_02() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x30, 0x53]); assert_eq!(encoded, &[0x30, 0x53]);
} }
@ -145,7 +145,7 @@ mod tests {
fn encode_03() { fn encode_03() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x30, 0x53]); assert_eq!(encoded, &[0x30, 0x53]);
} }
@ -154,7 +154,7 @@ mod tests {
fn encode_04() { fn encode_04() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -163,7 +163,7 @@ mod tests {
fn encode_05() { fn encode_05() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0xD8, 0x3D, 0xDE, 0x3A]); assert_eq!(encoded, &[0xD8, 0x3D, 0xDE, 0x3A]);
} }
@ -172,7 +172,7 @@ mod tests {
fn encode_06() { fn encode_06() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0xD8, 0x3D, 0xDE, 0x3A]); assert_eq!(encoded, &[0xD8, 0x3D, 0xDE, 0x3A]);
} }
@ -183,7 +183,7 @@ mod tests {
0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01, 0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -194,7 +194,7 @@ mod tests {
0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01, 0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 2); assert_eq!(consumed_count, 2);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -205,7 +205,7 @@ mod tests {
0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01, 0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 5]; let mut buf = [0u8; 5];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 2); assert_eq!(consumed_count, 2);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -214,7 +214,7 @@ mod tests {
fn decode_04() { fn decode_04() {
let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE, 0x3C]; // "😺😼" let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE, 0x3C]; // "😺😼"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -223,7 +223,7 @@ mod tests {
fn decode_05() { fn decode_05() {
let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE, 0x3C]; // "😺😼" let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE, 0x3C]; // "😺😼"
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -232,7 +232,7 @@ mod tests {
fn decode_06() { fn decode_06() {
let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE, 0x3C]; // "😺😼" let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE, 0x3C]; // "😺😼"
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -241,7 +241,7 @@ mod tests {
fn decode_07() { fn decode_07() {
let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D]; // "😺😼" with last codepoint chopped off. let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D]; // "😺😼" with last codepoint chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -250,7 +250,7 @@ mod tests {
fn decode_08() { fn decode_08() {
let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE]; // "😺😼" with last byte chopped off. let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8, 0x3D, 0xDE]; // "😺😼" with last byte chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -259,7 +259,7 @@ mod tests {
fn decode_09() { fn decode_09() {
let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8]; // "😺😼" with last 3 bytes chopped off. let data = [0xD8, 0x3D, 0xDE, 0x3A, 0xD8]; // "😺😼" with last 3 bytes chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -270,7 +270,7 @@ mod tests {
0xDE, 0x3A, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01, 0xDE, 0x3A, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" with an error on the first char (end surrogate) ]; // "こんにちは！" with an error on the first char (end surrogate)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -286,7 +286,7 @@ mod tests {
0x30, 0x53, 0xDE, 0x3A, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01, 0x30, 0x53, 0xDE, 0x3A, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" with an error on the second char (end surrogate) ]; // "こんにちは！" with an error on the second char (end surrogate)
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -302,7 +302,7 @@ mod tests {
0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0xDE, 0x3A, 0x30, 0x6F, 0xFF, 0x01, 0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0xDE, 0x3A, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" with an error on the fourth char (end surrogate) ]; // "こんにちは！" with an error on the fourth char (end surrogate)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -318,7 +318,7 @@ mod tests {
0xD8, 0x3D, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01, 0xD8, 0x3D, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" with an error on the first char (start surrogate) ]; // "こんにちは！" with an error on the first char (start surrogate)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -334,7 +334,7 @@ mod tests {
0x30, 0x53, 0xD8, 0x3D, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01, 0x30, 0x53, 0xD8, 0x3D, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" with an error on the second char (start surrogate) ]; // "こんにちは！" with an error on the second char (start surrogate)
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -350,7 +350,7 @@ mod tests {
0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0xD8, 0x3D, 0x30, 0x6F, 0xFF, 0x01, 0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0xD8, 0x3D, 0x30, 0x6F, 0xFF, 0x01,
]; // "こんにちは！" with an error on the fourth char (start surrogate) ]; // "こんにちは！" with an error on the fourth char (start surrogate)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {

46
sub_crates/text_encoding/src/utf16_le.rs
View File

@ -8,7 +8,7 @@ use core;
use utils::{from_little_endian_u16, to_little_endian_u16}; use utils::{from_little_endian_u16, to_little_endian_u16};
use {DecodeError, DecodeResult, EncodeResult}; use {DecodeError, DecodeResult, EncodeResult};
pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> { pub fn encode_from_str<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> {
// Do the encode. // Do the encode.
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -53,7 +53,7 @@ pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'
Ok((input_i, &output[..output_i])) Ok((input_i, &output[..output_i]))
} }
pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> { pub fn decode_to_str<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> {
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -127,7 +127,7 @@ mod tests {
fn encode_01() { fn encode_01() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 1]; let mut buf = [0u8; 1];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -136,7 +136,7 @@ mod tests {
fn encode_02() { fn encode_02() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x53, 0x30]); assert_eq!(encoded, &[0x53, 0x30]);
} }
@ -145,7 +145,7 @@ mod tests {
fn encode_03() { fn encode_03() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x53, 0x30]); assert_eq!(encoded, &[0x53, 0x30]);
} }
@ -154,7 +154,7 @@ mod tests {
fn encode_04() { fn encode_04() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -163,7 +163,7 @@ mod tests {
fn encode_05() { fn encode_05() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0x3D, 0xD8, 0x3A, 0xDE]); assert_eq!(encoded, &[0x3D, 0xD8, 0x3A, 0xDE]);
} }
@ -172,7 +172,7 @@ mod tests {
fn encode_06() { fn encode_06() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0x3D, 0xD8, 0x3A, 0xDE]); assert_eq!(encoded, &[0x3D, 0xD8, 0x3A, 0xDE]);
} }
@ -183,7 +183,7 @@ mod tests {
0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -194,7 +194,7 @@ mod tests {
0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 2); assert_eq!(consumed_count, 2);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -205,7 +205,7 @@ mod tests {
0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 5]; let mut buf = [0u8; 5];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 2); assert_eq!(consumed_count, 2);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -214,7 +214,7 @@ mod tests {
fn decode_04() { fn decode_04() {
let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C, 0xDE]; // "😺😼" let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C, 0xDE]; // "😺😼"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -223,7 +223,7 @@ mod tests {
fn decode_05() { fn decode_05() {
let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C, 0xDE]; // "😺😼" let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C, 0xDE]; // "😺😼"
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -232,7 +232,7 @@ mod tests {
fn decode_06() { fn decode_06() {
let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C, 0xDE]; // "😺😼" let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C, 0xDE]; // "😺😼"
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -241,7 +241,7 @@ mod tests {
fn decode_07() { fn decode_07() {
let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8]; // "😺😼" with last codepoint chopped off. let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8]; // "😺😼" with last codepoint chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -250,7 +250,7 @@ mod tests {
fn decode_08() { fn decode_08() {
let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C]; // "😺😼" with last byte chopped off. let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D, 0xD8, 0x3C]; // "😺😼" with last byte chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -259,7 +259,7 @@ mod tests {
fn decode_09() { fn decode_09() {
let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D]; // "😺😼" with last 3 bytes chopped off. let data = [0x3D, 0xD8, 0x3A, 0xDE, 0x3D]; // "😺😼" with last 3 bytes chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -270,7 +270,7 @@ mod tests {
0x3A, 0xDE, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF, 0x3A, 0xDE, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" with an error on the first char (end surrogate) ]; // "こんにちは！" with an error on the first char (end surrogate)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -286,7 +286,7 @@ mod tests {
0x53, 0x30, 0x3A, 0xDE, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF, 0x53, 0x30, 0x3A, 0xDE, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" with an error on the second char (end surrogate) ]; // "こんにちは！" with an error on the second char (end surrogate)
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -302,7 +302,7 @@ mod tests {
0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x3A, 0xDE, 0x6F, 0x30, 0x01, 0xFF, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x3A, 0xDE, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" with an error on the fourth char (end surrogate) ]; // "こんにちは！" with an error on the fourth char (end surrogate)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -318,7 +318,7 @@ mod tests {
0x3D, 0xD8, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF, 0x3D, 0xD8, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" with an error on the first char (start surrogate) ]; // "こんにちは！" with an error on the first char (start surrogate)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -334,7 +334,7 @@ mod tests {
0x53, 0x30, 0x3D, 0xD8, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF, 0x53, 0x30, 0x3D, 0xD8, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" with an error on the second char (start surrogate) ]; // "こんにちは！" with an error on the second char (start surrogate)
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {
@ -350,7 +350,7 @@ mod tests {
0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x3D, 0xD8, 0x6F, 0x30, 0x01, 0xFF, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x3D, 0xD8, 0x6F, 0x30, 0x01, 0xFF,
]; // "こんにちは！" with an error on the fourth char (start surrogate) ]; // "こんにちは！" with an error on the fourth char (start surrogate)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let error = decode_to_utf8(&data, &mut buf); let error = decode_to_str(&data, &mut buf);
assert_eq!( assert_eq!(
error, error,
Err(DecodeError { Err(DecodeError {

46
sub_crates/text_encoding/src/utf32_be.rs
View File

@ -8,7 +8,7 @@ use core;
use utils::{from_big_endian_u32, to_big_endian_u32}; use utils::{from_big_endian_u32, to_big_endian_u32};
use {DecodeError, DecodeResult, EncodeResult}; use {DecodeError, DecodeResult, EncodeResult};
pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> { pub fn encode_from_str<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> {
// Do the encode. // Do the encode.
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -38,7 +38,7 @@ pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'
Ok((input_i, &output[..output_i])) Ok((input_i, &output[..output_i]))
} }
pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> { pub fn decode_to_str<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> {
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -86,7 +86,7 @@ mod tests {
fn encode_01() { fn encode_01() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -95,7 +95,7 @@ mod tests {
fn encode_02() { fn encode_02() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x00, 0x00, 0x30, 0x53]); assert_eq!(encoded, &[0x00, 0x00, 0x30, 0x53]);
} }
@ -104,7 +104,7 @@ mod tests {
fn encode_03() { fn encode_03() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x00, 0x00, 0x30, 0x53]); assert_eq!(encoded, &[0x00, 0x00, 0x30, 0x53]);
} }
@ -113,7 +113,7 @@ mod tests {
fn encode_04() { fn encode_04() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -122,7 +122,7 @@ mod tests {
fn encode_05() { fn encode_05() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0x00, 0x01, 0xF6, 0x3A]); assert_eq!(encoded, &[0x00, 0x01, 0xF6, 0x3A]);
} }
@ -131,7 +131,7 @@ mod tests {
fn encode_06() { fn encode_06() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0x00, 0x01, 0xF6, 0x3A]); assert_eq!(encoded, &[0x00, 0x01, 0xF6, 0x3A]);
} }
@ -143,7 +143,7 @@ mod tests {
0x30, 0x61, 0x00, 0x00, 0x30, 0x6F, 0x00, 0x00, 0xFF, 0x01, 0x30, 0x61, 0x00, 0x00, 0x30, 0x6F, 0x00, 0x00, 0xFF, 0x01,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -155,7 +155,7 @@ mod tests {
0x30, 0x61, 0x00, 0x00, 0x30, 0x6F, 0x00, 0x00, 0xFF, 0x01, 0x30, 0x61, 0x00, 0x00, 0x30, 0x6F, 0x00, 0x00, 0xFF, 0x01,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -167,7 +167,7 @@ mod tests {
0x30, 0x61, 0x00, 0x00, 0x30, 0x6F, 0x00, 0x00, 0xFF, 0x01, 0x30, 0x61, 0x00, 0x00, 0x30, 0x6F, 0x00, 0x00, 0xFF, 0x01,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 5]; let mut buf = [0u8; 5];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -176,7 +176,7 @@ mod tests {
fn decode_04() { fn decode_04() {
let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6, 0x3C]; // "😺😼" let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6, 0x3C]; // "😺😼"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -185,7 +185,7 @@ mod tests {
fn decode_05() { fn decode_05() {
let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6, 0x3C]; // "😺😼" let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6, 0x3C]; // "😺😼"
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -194,7 +194,7 @@ mod tests {
fn decode_06() { fn decode_06() {
let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6, 0x3C]; // "😺😼" let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6, 0x3C]; // "😺😼"
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -203,7 +203,7 @@ mod tests {
fn decode_07() { fn decode_07() {
let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6]; // "😺😼" with last byte chopped off. let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01, 0xF6]; // "😺😼" with last byte chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -212,7 +212,7 @@ mod tests {
fn decode_08() { fn decode_08() {
let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01]; // "😺😼" with last 2 bytes chopped off. let data = [0x00, 0x01, 0xF6, 0x3A, 0x00, 0x01]; // "😺😼" with last 2 bytes chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -221,7 +221,7 @@ mod tests {
fn decode_09() { fn decode_09() {
let data = [0x00, 0x01, 0xF6, 0x3A, 0x00]; // "😺😼" with last 3 bytes chopped off. let data = [0x00, 0x01, 0xF6, 0x3A, 0x00]; // "😺😼" with last 3 bytes chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -234,7 +234,7 @@ mod tests {
]; // "こんにちは！" with an error on the first char (value out of range) ]; // "こんにちは！" with an error on the first char (value out of range)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (0, 4), error_range: (0, 4),
output_bytes_written: 0, output_bytes_written: 0,
@ -250,7 +250,7 @@ mod tests {
]; // "こんにちは！" with an error on the first char (value in surrogate range) ]; // "こんにちは！" with an error on the first char (value in surrogate range)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (0, 4), error_range: (0, 4),
output_bytes_written: 0, output_bytes_written: 0,
@ -266,7 +266,7 @@ mod tests {
]; // "こんにちは！" with an error on the first char (value in surrogate range) ]; // "こんにちは！" with an error on the first char (value in surrogate range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (0, 4), error_range: (0, 4),
output_bytes_written: 0, output_bytes_written: 0,
@ -282,7 +282,7 @@ mod tests {
]; // "こんにちは！" with an error on the second char (value out of range) ]; // "こんにちは！" with an error on the second char (value out of range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (4, 8), error_range: (4, 8),
output_bytes_written: 3, output_bytes_written: 3,
@ -299,7 +299,7 @@ mod tests {
]; // "こんにちは！" with an error on the second char (value in surrogate range) ]; // "こんにちは！" with an error on the second char (value in surrogate range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (4, 8), error_range: (4, 8),
output_bytes_written: 3, output_bytes_written: 3,
@ -316,7 +316,7 @@ mod tests {
]; // "こんにちは！" with an error on the second char (value in surrogate range) ]; // "こんにちは！" with an error on the second char (value in surrogate range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (4, 8), error_range: (4, 8),
output_bytes_written: 3, output_bytes_written: 3,

46
sub_crates/text_encoding/src/utf32_le.rs
View File

@ -8,7 +8,7 @@ use core;
use utils::{from_little_endian_u32, to_little_endian_u32}; use utils::{from_little_endian_u32, to_little_endian_u32};
use {DecodeError, DecodeResult, EncodeResult}; use {DecodeError, DecodeResult, EncodeResult};
pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> { pub fn encode_from_str<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> {
// Do the encode. // Do the encode.
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -38,7 +38,7 @@ pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'
Ok((input_i, &output[..output_i])) Ok((input_i, &output[..output_i]))
} }
pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> { pub fn decode_to_str<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> {
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -86,7 +86,7 @@ mod tests {
fn encode_01() { fn encode_01() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -95,7 +95,7 @@ mod tests {
fn encode_02() { fn encode_02() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x53, 0x30, 0x00, 0x00]); assert_eq!(encoded, &[0x53, 0x30, 0x00, 0x00]);
} }
@ -104,7 +104,7 @@ mod tests {
fn encode_03() { fn encode_03() {
let text = "こんにちは！"; let text = "こんにちは！";
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 3); assert_eq!(consumed_count, 3);
assert_eq!(encoded, &[0x53, 0x30, 0x00, 0x00]); assert_eq!(encoded, &[0x53, 0x30, 0x00, 0x00]);
} }
@ -113,7 +113,7 @@ mod tests {
fn encode_04() { fn encode_04() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(encoded, &[]); assert_eq!(encoded, &[]);
} }
@ -122,7 +122,7 @@ mod tests {
fn encode_05() { fn encode_05() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0x3A, 0xF6, 0x01, 0x00]); assert_eq!(encoded, &[0x3A, 0xF6, 0x01, 0x00]);
} }
@ -131,7 +131,7 @@ mod tests {
fn encode_06() { fn encode_06() {
let text = "😺😼"; let text = "😺😼";
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, encoded) = encode_from_utf8(text, &mut buf).unwrap(); let (consumed_count, encoded) = encode_from_str(text, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(encoded, &[0x3A, 0xF6, 0x01, 0x00]); assert_eq!(encoded, &[0x3A, 0xF6, 0x01, 0x00]);
} }
@ -143,7 +143,7 @@ mod tests {
0x00, 0x00, 0x6F, 0x30, 0x00, 0x00, 0x01, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x6F, 0x30, 0x00, 0x00, 0x01, 0xFF, 0x00, 0x00,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -155,7 +155,7 @@ mod tests {
0x00, 0x00, 0x6F, 0x30, 0x00, 0x00, 0x01, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x6F, 0x30, 0x00, 0x00, 0x01, 0xFF, 0x00, 0x00,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -167,7 +167,7 @@ mod tests {
0x00, 0x00, 0x6F, 0x30, 0x00, 0x00, 0x01, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x6F, 0x30, 0x00, 0x00, 0x01, 0xFF, 0x00, 0x00,
]; // "こんにちは！" ]; // "こんにちは！"
let mut buf = [0u8; 5]; let mut buf = [0u8; 5];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "こ"); assert_eq!(decoded, "こ");
} }
@ -176,7 +176,7 @@ mod tests {
fn decode_04() { fn decode_04() {
let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01, 0x00]; // "😺😼" let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01, 0x00]; // "😺😼"
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 0); assert_eq!(consumed_count, 0);
assert_eq!(decoded, ""); assert_eq!(decoded, "");
} }
@ -185,7 +185,7 @@ mod tests {
fn decode_05() { fn decode_05() {
let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01, 0x00]; // "😺😼" let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01, 0x00]; // "😺😼"
let mut buf = [0u8; 4]; let mut buf = [0u8; 4];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -194,7 +194,7 @@ mod tests {
fn decode_06() { fn decode_06() {
let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01, 0x00]; // "😺😼" let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01, 0x00]; // "😺😼"
let mut buf = [0u8; 7]; let mut buf = [0u8; 7];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -203,7 +203,7 @@ mod tests {
fn decode_07() { fn decode_07() {
let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01]; // "😺😼" with last byte chopped off. let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6, 0x01]; // "😺😼" with last byte chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -212,7 +212,7 @@ mod tests {
fn decode_08() { fn decode_08() {
let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6]; // "😺😼" with last 2 bytes chopped off. let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C, 0xF6]; // "😺😼" with last 2 bytes chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -221,7 +221,7 @@ mod tests {
fn decode_09() { fn decode_09() {
let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C]; // "😺😼" with last 3 bytes chopped off. let data = [0x3A, 0xF6, 0x01, 0x00, 0x3C]; // "😺😼" with last 3 bytes chopped off.
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
let (consumed_count, decoded) = decode_to_utf8(&data, &mut buf).unwrap(); let (consumed_count, decoded) = decode_to_str(&data, &mut buf).unwrap();
assert_eq!(consumed_count, 4); assert_eq!(consumed_count, 4);
assert_eq!(decoded, "😺"); assert_eq!(decoded, "😺");
} }
@ -234,7 +234,7 @@ mod tests {
]; // "こんにちは！" with an error on the first char (value out of range) ]; // "こんにちは！" with an error on the first char (value out of range)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (0, 4), error_range: (0, 4),
output_bytes_written: 0, output_bytes_written: 0,
@ -250,7 +250,7 @@ mod tests {
]; // "こんにちは！" with an error on the first char (value in surrogate range) ]; // "こんにちは！" with an error on the first char (value in surrogate range)
let mut buf = [0u8; 2]; let mut buf = [0u8; 2];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (0, 4), error_range: (0, 4),
output_bytes_written: 0, output_bytes_written: 0,
@ -266,7 +266,7 @@ mod tests {
]; // "こんにちは！" with an error on the first char (value in surrogate range) ]; // "こんにちは！" with an error on the first char (value in surrogate range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (0, 4), error_range: (0, 4),
output_bytes_written: 0, output_bytes_written: 0,
@ -282,7 +282,7 @@ mod tests {
]; // "こんにちは！" with an error on the second char (value out of range) ]; // "こんにちは！" with an error on the second char (value out of range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (4, 8), error_range: (4, 8),
output_bytes_written: 3, output_bytes_written: 3,
@ -299,7 +299,7 @@ mod tests {
]; // "こんにちは！" with an error on the second char (value in surrogate range) ]; // "こんにちは！" with an error on the second char (value in surrogate range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (4, 8), error_range: (4, 8),
output_bytes_written: 3, output_bytes_written: 3,
@ -316,7 +316,7 @@ mod tests {
]; // "こんにちは！" with an error on the second char (value in surrogate range) ]; // "こんにちは！" with an error on the second char (value in surrogate range)
let mut buf = [0u8; 64]; let mut buf = [0u8; 64];
assert_eq!( assert_eq!(
decode_to_utf8(&data, &mut buf), decode_to_str(&data, &mut buf),
Err(DecodeError { Err(DecodeError {
error_range: (4, 8), error_range: (4, 8),
output_bytes_written: 3, output_bytes_written: 3,

8
sub_crates/text_encoding/src/utf8.rs
View File

@ -1,12 +1,12 @@
//! These functions are essentially redundant, since they're supposedly //! These functions are essentially redundant, since they're supposedly
//! encoding/decoding between utf8 and... utf8. However, `decode_to_utf8()` //! encoding/decoding between utf8 and... utf8. However, `decode_to_str()`
//! is still useful for validating unknown input. And they allow a uniform //! is still useful for validating unknown input. And they allow a uniform
//! API for all encodings. //! API for all encodings.
use core; use core;
use {DecodeError, DecodeResult, EncodeResult}; use {DecodeError, DecodeResult, EncodeResult};
pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> { pub fn encode_from_str<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> {
let copy_len = { let copy_len = {
if output.len() >= input.len() { if output.len() >= input.len() {
input.len() input.len()
@ -24,7 +24,7 @@ pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'
Ok((copy_len, &output[..copy_len])) Ok((copy_len, &output[..copy_len]))
} }
pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> { pub fn decode_to_str<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> {
let valid_up_to = match core::str::from_utf8(input) { let valid_up_to = match core::str::from_utf8(input) {
Ok(text) => text.len(), Ok(text) => text.len(),
Err(e) => { Err(e) => {
@ -39,7 +39,7 @@ pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a
} }
}; };
let (in_consumed, out_slice) = encode_from_utf8( let (in_consumed, out_slice) = encode_from_str(
unsafe { core::str::from_utf8_unchecked(&input[..valid_up_to]) }, unsafe { core::str::from_utf8_unchecked(&input[..valid_up_to]) },
output, output,
).unwrap(); ).unwrap();

4
sub_crates/text_encoding/src/windows1252.rs
View File

@ -3,7 +3,7 @@
use core; use core;
use {DecodeError, DecodeResult, EncodeError, EncodeResult}; use {DecodeError, DecodeResult, EncodeError, EncodeResult};
pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> { pub fn encode_from_str<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'a> {
// Do the encode. // Do the encode.
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
@ -37,7 +37,7 @@ pub fn encode_from_utf8<'a>(input: &str, output: &'a mut [u8]) -> EncodeResult<'
Ok((input_i, &output[..output_i])) Ok((input_i, &output[..output_i]))
} }
pub fn decode_to_utf8<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> { pub fn decode_to_str<'a>(input: &[u8], output: &'a mut [u8]) -> DecodeResult<'a> {
let mut input_i = 0; let mut input_i = 0;
let mut output_i = 0; let mut output_i = 0;
for &byte in input.iter() { for &byte in input.iter() {

30
sub_crates/text_encoding/tests/property_tests.rs
View File

@ -4,7 +4,7 @@ extern crate text_encoding;
use proptest::collection::vec; use proptest::collection::vec;
use proptest::test_runner::Config; use proptest::test_runner::Config;
use text_encoding::{decode_to_utf8, encode_from_utf8, Encoding}; use text_encoding::{decode_to_str, encode_from_str, Encoding};
proptest! { proptest! {
#![proptest_config(Config::with_cases(512))] #![proptest_config(Config::with_cases(512))]
@ -18,7 +18,7 @@ proptest! {
// Encode to utf8 // Encode to utf8
let mut tmp = &text[..]; let mut tmp = &text[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, encoded)) = encode_from_utf8(Encoding::Utf8, tmp, &mut buf) { if let Ok((n, encoded)) = encode_from_str(Encoding::Utf8, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8_encoded.extend_from_slice(encoded); utf8_encoded.extend_from_slice(encoded);
} else { } else {
@ -29,7 +29,7 @@ proptest! {
// Decode back from utf8 // Decode back from utf8
let mut tmp = &utf8_encoded[..]; let mut tmp = &utf8_encoded[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, decoded)) = decode_to_utf8(Encoding::Utf8, tmp, &mut buf) { if let Ok((n, decoded)) = decode_to_str(Encoding::Utf8, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8.extend(decoded.chars()); utf8.extend(decoded.chars());
} else { } else {
@ -51,7 +51,7 @@ proptest! {
// Encode to utf16 big endian // Encode to utf16 big endian
let mut tmp = &text[..]; let mut tmp = &text[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, encoded)) = encode_from_utf8(Encoding::Utf16BE, tmp, &mut buf) { if let Ok((n, encoded)) = encode_from_str(Encoding::Utf16BE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf16.extend_from_slice(encoded); utf16.extend_from_slice(encoded);
} else { } else {
@ -62,7 +62,7 @@ proptest! {
// Decode back from utf16 big endian // Decode back from utf16 big endian
let mut tmp = &utf16[..]; let mut tmp = &utf16[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, decoded)) = decode_to_utf8(Encoding::Utf16BE, tmp, &mut buf) { if let Ok((n, decoded)) = decode_to_str(Encoding::Utf16BE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8.extend(decoded.chars()); utf8.extend(decoded.chars());
} else { } else {
@ -82,7 +82,7 @@ proptest! {
// Encode to utf16 little endian // Encode to utf16 little endian
let mut tmp = &text[..]; let mut tmp = &text[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, encoded)) = encode_from_utf8(Encoding::Utf16LE, tmp, &mut buf) { if let Ok((n, encoded)) = encode_from_str(Encoding::Utf16LE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf16.extend_from_slice(encoded); utf16.extend_from_slice(encoded);
} else { } else {
@ -93,7 +93,7 @@ proptest! {
// Decode back from utf16 big endian // Decode back from utf16 big endian
let mut tmp = &utf16[..]; let mut tmp = &utf16[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, decoded)) = decode_to_utf8(Encoding::Utf16LE, tmp, &mut buf) { if let Ok((n, decoded)) = decode_to_str(Encoding::Utf16LE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8.extend(decoded.chars()); utf8.extend(decoded.chars());
} else { } else {
@ -113,7 +113,7 @@ proptest! {
// Encode to utf32 big endian // Encode to utf32 big endian
let mut tmp = &text[..]; let mut tmp = &text[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, encoded)) = encode_from_utf8(Encoding::Utf32BE, tmp, &mut buf) { if let Ok((n, encoded)) = encode_from_str(Encoding::Utf32BE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf32.extend_from_slice(encoded); utf32.extend_from_slice(encoded);
} else { } else {
@ -124,7 +124,7 @@ proptest! {
// Decode back from utf32 big endian // Decode back from utf32 big endian
let mut tmp = &utf32[..]; let mut tmp = &utf32[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, decoded)) = decode_to_utf8(Encoding::Utf32BE, tmp, &mut buf) { if let Ok((n, decoded)) = decode_to_str(Encoding::Utf32BE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8.extend(decoded.chars()); utf8.extend(decoded.chars());
} else { } else {
@ -144,7 +144,7 @@ proptest! {
// Encode to utf32 little endian // Encode to utf32 little endian
let mut tmp = &text[..]; let mut tmp = &text[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, encoded)) = encode_from_utf8(Encoding::Utf32LE, tmp, &mut buf) { if let Ok((n, encoded)) = encode_from_str(Encoding::Utf32LE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf32.extend_from_slice(encoded); utf32.extend_from_slice(encoded);
} else { } else {
@ -155,7 +155,7 @@ proptest! {
// Decode back from utf32 little endian // Decode back from utf32 little endian
let mut tmp = &utf32[..]; let mut tmp = &utf32[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, decoded)) = decode_to_utf8(Encoding::Utf32LE, tmp, &mut buf) { if let Ok((n, decoded)) = decode_to_str(Encoding::Utf32LE, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8.extend(decoded.chars()); utf8.extend(decoded.chars());
} else { } else {
@ -175,7 +175,7 @@ proptest! {
// Decode from latin1 to utf8 // Decode from latin1 to utf8
let mut tmp = &data[..]; let mut tmp = &data[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, decoded)) = decode_to_utf8(Encoding::Latin1, tmp, &mut buf) { if let Ok((n, decoded)) = decode_to_str(Encoding::Latin1, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8.extend(decoded.chars()); utf8.extend(decoded.chars());
} else { } else {
@ -186,7 +186,7 @@ proptest! {
// Encode to from utf8 back to latin1 // Encode to from utf8 back to latin1
let mut tmp = &utf8[..]; let mut tmp = &utf8[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, encoded)) = encode_from_utf8(Encoding::Latin1, tmp, &mut buf) { if let Ok((n, encoded)) = encode_from_str(Encoding::Latin1, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
latin1.extend_from_slice(encoded); latin1.extend_from_slice(encoded);
} else { } else {
@ -213,7 +213,7 @@ proptest! {
// Decode from windows-1252 to utf8 // Decode from windows-1252 to utf8
let mut tmp = &data[..]; let mut tmp = &data[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, decoded)) = decode_to_utf8(Encoding::Windows1252, tmp, &mut buf) { if let Ok((n, decoded)) = decode_to_str(Encoding::Windows1252, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
utf8.extend(decoded.chars()); utf8.extend(decoded.chars());
} else { } else {
@ -224,7 +224,7 @@ proptest! {
// Encode to from utf8 back to w1252 // Encode to from utf8 back to w1252
let mut tmp = &utf8[..]; let mut tmp = &utf8[..];
while !tmp.is_empty() { while !tmp.is_empty() {
if let Ok((n, encoded)) = encode_from_utf8(Encoding::Windows1252, tmp, &mut buf) { if let Ok((n, encoded)) = encode_from_str(Encoding::Windows1252, tmp, &mut buf) {
tmp = &tmp[n..]; tmp = &tmp[n..];
w1252.extend_from_slice(encoded); w1252.extend_from_slice(encoded);
} else { } else {