lightsystemdarkgreen
@ e89b7c3
// 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.

#![no_main]
#[macro_use]
extern crate libfuzzer_sys;
extern crate encoding_rs;
extern crate safe_encoding_rs_mem;

fn check_utf8(data: &[u8]) {
    if let Err(_) = ::std::str::from_utf8(data) {
        panic!("Bogus UTF-8.");
    }
}

fn check_utf16(data: &[u16]) {
    let mut prev_was_high_surrogate = false;
    for unit in data {
        if *unit >= 0xD800 && *unit <= 0xDBFF {
            assert!(!prev_was_high_surrogate);
            prev_was_high_surrogate = true;
        } else if *unit >= 0xDC00 && *unit <= 0xDFFF {
            assert!(prev_was_high_surrogate);
            prev_was_high_surrogate = false;
        } else {
            assert!(!prev_was_high_surrogate);
            prev_was_high_surrogate = false;
        }
    }
    assert!(!prev_was_high_surrogate);
}

fn as_u16_slice(data: &[u8]) -> &[u16] {
    unsafe {
        let (_, sixteen, _) = data.align_to::<u16>();
        sixteen
    }
}

trait EigthOrSixteen: Clone {
    fn zero() -> Self;
}

impl EigthOrSixteen for u8 {
    fn zero() -> u8 {
        0
    }
}

impl EigthOrSixteen for u16 {
    fn zero() -> u16 {
        0
    }
}

fn vec_with_len<T: EigthOrSixteen>(len: usize) -> Vec<T> {
    let mut vec: Vec<T> = Vec::with_capacity(len);
    vec.resize(len, T::zero());
    vec
}

fn string_with_len(len: usize) -> String {
    let mut s = String::with_capacity(len);
    for _ in 0..len {
        s.push('\u{0}');
    }
    s
}

fn fuzz_is_ascii(data: &[u8]) {
    assert_eq!(encoding_rs::mem::is_ascii(data), safe_encoding_rs_mem::is_ascii(data));
}

fn fuzz_is_basic_latin(data: &[u16]) {
    assert_eq!(encoding_rs::mem::is_basic_latin(data), safe_encoding_rs_mem::is_basic_latin(data));
}

fn fuzz_is_utf8_latin1(data: &[u8]) {
    assert_eq!(encoding_rs::mem::is_utf8_latin1(data), safe_encoding_rs_mem::is_utf8_latin1(data));
}

fn fuzz_is_str_latin1(data: &[u8]) {
    if let Ok(s) = std::str::from_utf8(data) {
        assert_eq!(encoding_rs::mem::is_str_latin1(s), safe_encoding_rs_mem::is_str_latin1(s));
    }
}

fn fuzz_is_utf16_latin1(data: &[u16]) {
    assert_eq!(encoding_rs::mem::is_utf16_latin1(data), safe_encoding_rs_mem::is_utf16_latin1(data));
}

fn fuzz_convert_utf8_to_utf16(data: &[u8]) {
    let needed = data.len() + 1;
    let mut dst = vec_with_len::<u16>(needed);
    let mut safe_dst = vec_with_len::<u16>(needed);
    let len = encoding_rs::mem::convert_utf8_to_utf16(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::convert_utf8_to_utf16(data, &mut safe_dst[..]);
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
    check_utf16(&dst[..]);
}

fn fuzz_convert_str_to_utf16(data: &[u8]) {
    if let Ok(s) = std::str::from_utf8(data) {
        let needed = s.len();
        let mut dst = vec_with_len::<u16>(needed);
        let mut safe_dst = vec_with_len::<u16>(needed);
        let len = encoding_rs::mem::convert_str_to_utf16(s, &mut dst[..]);
        let safe_len = safe_encoding_rs_mem::convert_str_to_utf16(s, &mut safe_dst[..]);
        dst.truncate(len);
        safe_dst.truncate(safe_len);
        assert_eq!(len, safe_len);
        assert_eq!(dst, safe_dst);
        check_utf16(&dst[..]);
    }
}

fn fuzz_convert_utf16_to_utf8(data: &[u16]) {
    let needed = data.len() * 3;
    let mut dst = vec_with_len::<u8>(needed);
    let mut safe_dst = vec_with_len::<u8>(needed);
    let len = encoding_rs::mem::convert_utf16_to_utf8(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::convert_utf16_to_utf8(data, &mut safe_dst[..]);
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
    check_utf8(&dst[..]);
}

fn fuzz_convert_utf16_to_str(data: &[u16]) {
    let needed = data.len() * 3;
    let mut dst = string_with_len(needed);
    let mut safe_dst = string_with_len(needed);
    let len = encoding_rs::mem::convert_utf16_to_str(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::convert_utf16_to_str(data, &mut safe_dst[..]);
    check_utf8(dst.as_bytes());
    check_utf8(safe_dst.as_bytes());
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
}

fn fuzz_convert_latin1_to_utf16(data: &[u8]) {
    let needed = data.len();
    let mut dst = vec_with_len::<u16>(needed);
    let mut safe_dst = vec_with_len::<u16>(needed);
    encoding_rs::mem::convert_latin1_to_utf16(data, &mut dst[..]);
    safe_encoding_rs_mem::convert_latin1_to_utf16(data, &mut safe_dst[..]);
    assert_eq!(dst, safe_dst);
    check_utf16(&dst[..]);
}

fn fuzz_convert_latin1_to_utf8(data: &[u8]) {
    let needed = data.len() * 2;
    let mut dst = vec_with_len::<u8>(needed);
    let mut safe_dst = vec_with_len::<u8>(needed);
    let len = encoding_rs::mem::convert_latin1_to_utf8(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::convert_latin1_to_utf8(data, &mut safe_dst[..]);
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
    check_utf8(&dst[..]);
}

fn fuzz_convert_latin1_to_str(data: &[u8]) {
    let needed = data.len() * 2;
    let mut dst = string_with_len(needed);
    let mut safe_dst = string_with_len(needed);
    let len = encoding_rs::mem::convert_latin1_to_str(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::convert_latin1_to_str(data, &mut safe_dst[..]);
    check_utf8(dst.as_bytes());
    check_utf8(safe_dst.as_bytes());
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
}

fn fuzz_convert_utf8_to_latin1_lossy(data: &[u8]) {
    let needed = data.len();
    let mut dst = vec_with_len::<u8>(needed);
    let mut safe_dst = vec_with_len::<u8>(needed);
    let len = encoding_rs::mem::convert_utf8_to_latin1_lossy(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::convert_utf8_to_latin1_lossy(data, &mut safe_dst[..]);
    if safe_encoding_rs_mem::is_utf8_latin1(data) {
        dst.truncate(len);
        safe_dst.truncate(safe_len);
        assert_eq!(len, safe_len);
        assert_eq!(dst, safe_dst);
    }
}

fn fuzz_convert_utf16_to_latin1_lossy(data: &[u16]) {
    let needed = data.len();
    let mut dst = vec_with_len::<u8>(needed);
    let mut safe_dst = vec_with_len::<u8>(needed);
    encoding_rs::mem::convert_utf16_to_latin1_lossy(data, &mut dst[..]);
    safe_encoding_rs_mem::convert_utf16_to_latin1_lossy(data, &mut safe_dst[..]);
    if safe_encoding_rs_mem::is_utf16_latin1(data) {
        assert_eq!(dst, safe_dst);
    }
}

fn fuzz_utf16_valid_up_to(data: &[u16]) {
    let up_to = encoding_rs::mem::utf16_valid_up_to(data);
    let safe_up_to = safe_encoding_rs_mem::utf16_valid_up_to(data);
    assert_eq!(up_to, safe_up_to);
}

fn fuzz_ensure_utf16_validity(data: &[u16]) {
    let needed = data.len();
    let mut dst = vec_with_len::<u16>(needed);
    let mut safe_dst = vec_with_len::<u16>(needed);
    dst.copy_from_slice(data);
    safe_dst.copy_from_slice(data);
    encoding_rs::mem::ensure_utf16_validity(&mut dst[..]);
    safe_encoding_rs_mem::ensure_utf16_validity(&mut safe_dst[..]);
    assert_eq!(dst, safe_dst);
    check_utf16(&dst[..]);
}

fn fuzz_copy_ascii_to_ascii(data: &[u8]) {
    let needed = data.len();
    let mut dst = vec_with_len::<u8>(needed);
    let mut safe_dst = vec_with_len::<u8>(needed);
    let len = encoding_rs::mem::copy_ascii_to_ascii(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::copy_ascii_to_ascii(data, &mut safe_dst[..]);
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
}

fn fuzz_copy_ascii_to_basic_latin(data: &[u8]) {
    let needed = data.len();
    let mut dst = vec_with_len::<u16>(needed);
    let mut safe_dst = vec_with_len::<u16>(needed);
    let len = encoding_rs::mem::copy_ascii_to_basic_latin(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::copy_ascii_to_basic_latin(data, &mut safe_dst[..]);
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
}

fn fuzz_copy_basic_latin_to_ascii(data: &[u16]) {
    let needed = data.len();
    let mut dst = vec_with_len::<u8>(needed);
    let mut safe_dst = vec_with_len::<u8>(needed);
    let len = encoding_rs::mem::copy_basic_latin_to_ascii(data, &mut dst[..]);
    let safe_len = safe_encoding_rs_mem::copy_basic_latin_to_ascii(data, &mut safe_dst[..]);
    dst.truncate(len);
    safe_dst.truncate(safe_len);
    assert_eq!(len, safe_len);
    assert_eq!(dst, safe_dst);
}

fn fuzz_is_utf8_bidi(data: &[u8]) {
    assert_eq!(encoding_rs::mem::is_utf8_bidi(data), safe_encoding_rs_mem::is_utf8_bidi(data));
}

fn fuzz_is_str_bidi(data: &[u8]) {
    if let Ok(s) = std::str::from_utf8(data) {
        assert_eq!(encoding_rs::mem::is_str_bidi(s), safe_encoding_rs_mem::is_str_bidi(s));
    }
}

fn fuzz_is_utf16_bidi(data: &[u16]) {
    assert_eq!(encoding_rs::mem::is_utf16_bidi(data), safe_encoding_rs_mem::is_utf16_bidi(data));
}

// is_char_bidi() and is_utf16_code_unit_bidi() are tested exhaustively, so no need to fuzz them.as_u16_slice

fn fuzz_check_utf8_for_latin1_and_bidi(data: &[u8]) {
    assert_eq!(encoding_rs::mem::check_utf8_for_latin1_and_bidi(data), safe_encoding_rs_mem::check_utf8_for_latin1_and_bidi(data));
}

fn fuzz_check_str_for_latin1_and_bidi(data: &[u8]) {
    if let Ok(s) = std::str::from_utf8(data) {
        assert_eq!(encoding_rs::mem::check_str_for_latin1_and_bidi(s), safe_encoding_rs_mem::check_str_for_latin1_and_bidi(s));
    }
}

fn fuzz_check_utf16_for_latin1_and_bidi(data: &[u16]) {
    assert_eq!(encoding_rs::mem::check_utf16_for_latin1_and_bidi(data), safe_encoding_rs_mem::check_utf16_for_latin1_and_bidi(data));
}

fuzz_target!(
    |data: &[u8]| {
        if let Some(first) = data.first() {
            match *first {
                0 => fuzz_is_ascii(&data[1..]),
                1 => fuzz_is_basic_latin(as_u16_slice(&data[1..])),
                2 => fuzz_is_utf8_latin1(&data[1..]),
                3 => fuzz_is_str_latin1(&data[1..]),
                4 => fuzz_is_utf16_latin1(as_u16_slice(&data[1..])),
                5 => fuzz_convert_utf8_to_utf16(&data[1..]),
                6 => fuzz_convert_str_to_utf16(&data[1..]),
                7 => fuzz_convert_utf16_to_utf8(as_u16_slice(&data[1..])),
                8 => fuzz_convert_utf16_to_str(as_u16_slice(&data[1..])),
                9 => fuzz_convert_latin1_to_utf16(&data[1..]),
                10 => fuzz_convert_latin1_to_utf8(&data[1..]),
                11 => fuzz_convert_latin1_to_str(&data[1..]),
                12 => fuzz_convert_utf8_to_latin1_lossy(&data[1..]),
                13 => fuzz_convert_utf16_to_latin1_lossy(as_u16_slice(&data[1..])),
                14 => fuzz_utf16_valid_up_to(as_u16_slice(&data[1..])),
                15 => fuzz_ensure_utf16_validity(as_u16_slice(&data[1..])),
                16 => fuzz_copy_ascii_to_ascii(&data[1..]),
                17 => fuzz_copy_ascii_to_basic_latin(&data[1..]),
                18 => fuzz_copy_basic_latin_to_ascii(as_u16_slice(&data[1..])),
                19 => fuzz_is_utf8_bidi(&data[1..]),
                20 => fuzz_is_str_bidi(&data[1..]),
                21 => fuzz_is_utf16_bidi(as_u16_slice(&data[1..])),
                22 => fuzz_check_utf8_for_latin1_and_bidi(&data[1..]),
                23 => fuzz_check_str_for_latin1_and_bidi(&data[1..]),
                24 => fuzz_check_utf16_for_latin1_and_bidi(as_u16_slice(&data[1..])),
                _ => return,
            }
        }
        // Comment to make rustfmt not introduce a compilation error
    }
);