Deleted vendor folder

4 files changed, 0 insertions, 697 deletions

diff --git a/vendor/encode_unicode/tests/errs.rs b/vendor/encode_unicode/tests/errs.rs
deleted file mode 100644
index 9c8747b..0000000
--- a/vendor/encode_unicode/tests/errs.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-/* Copyright 2016 The encode_unicode Developers
- *
- * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
- * http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
- * http://opensource.org/licenses/MIT>, at your option. This file may not be
- * copied, modified, or distributed except according to those terms.
- */
-
-//! Test that methods gives the correct error.
-//! Some also test a bit more because it's easy.
-
-extern crate core;
-use core::char;
-extern crate encode_unicode;
-use encode_unicode::*;
-use encode_unicode::error::*;
-use encode_unicode::error::InvalidUtf8Array as a;
-use encode_unicode::error::InvalidUtf8Slice as s;
-use encode_unicode::error::InvalidCodepoint::*;
-use encode_unicode::error::InvalidUtf8::*;
-use encode_unicode::error::InvalidUtf8FirstByte::*;
-
-
-#[test]
-fn from_u32() {
-    for c in 0xd800..0xe000 {
-        assert_eq!(char::from_u32_detailed(c),  Err(Utf16Reserved));
-    }
-    let mut c = 0x11_00_00;
-    loop {
-        assert_eq!(char::from_u32_detailed(c),  Err(TooHigh));
-        // Don't test every value. (Range.step_by() is unstable)
-        match c.checked_add(0x10_11_11) {
-            Some(next) => c = next,
-            None => break,
-        }
-    }
-}
-
-#[test]
-fn utf8_extra_bytes() {
-    for c in 0..256 {
-        assert_eq!( (c as u8).extra_utf8_bytes(), match c {
-            0b_1000_0000...0b_1011_1111 => Err(ContinuationByte),
-            0b_1111_1000...0b_1111_1111 => Err(TooLongSeqence),
-            0b_0000_0000...0b_0111_1111 => Ok(0),
-            0b_1100_0000...0b_1101_1111 => Ok(1),
-            0b_1110_0000...0b_1110_1111 => Ok(2),
-            0b_1111_0000...0b_1111_0111 => Ok(3),
-                         _              => unreachable!(),
-        });
-    }
-}
-
-#[test]
-fn utf16_extra_unit() {
-    for c in 0..0x1_00_00 {
-        assert_eq!( (c as u16).utf16_needs_extra_unit(), match c {
-            0b_0000_0000_0000_0000...0b_1101_0111_1111_1111 => Ok(false),
-            0b_1101_1000_0000_0000...0b_1101_1011_1111_1111 => Ok(true),
-            0b_1101_1100_0000_0000...0b_1101_1111_1111_1111 => Err(InvalidUtf16FirstUnit),
-            0b_1110_0000_0000_0000...0b_1111_1111_1111_1111 => Ok(false),
-                                   _                        => unreachable!(),
-        });
-    }
-}
-
-
-#[test]
-fn from_utf16_tuple() {
-    use encode_unicode::error::InvalidUtf16Tuple::*;
-    for u in 0xdc00..0xe000 {
-        let close = if u%3==0 {u-100} else {u+100};
-        let doesnt_matter = if u%2==0 {Some(close)} else {None};
-        assert_eq!(char::from_utf16_tuple((u,doesnt_matter)), Err(FirstIsTrailingSurrogate));
-    }
-    for u in (0..0xd800).chain(0xe000..0x10000) {
-        assert_eq!(
-            char::from_utf16_tuple((u as u16, Some((0x100+u) as u16))),
-            Err(SuperfluousSecond)
-        );
-    }
-    for u in 0xd800..0xdc00 {
-        assert_eq!(char::from_utf16_tuple((u,None)), Err(MissingSecond));
-        assert_eq!(char::from_utf16_tuple((u,Some(u - 0x2ff))), Err(InvalidSecond));
-    }
-}
-
-#[test]
-fn from_utf16_slice_start() {
-    use encode_unicode::error::InvalidUtf16Slice::*;
-    assert_eq!(char::from_utf16_slice_start(&[]), Err(EmptySlice));
-    let mut buf = [0; 6];
-    for u in 0xd800..0xdc00 {
-        buf[0] = u;
-        assert_eq!(char::from_utf16_slice_start(&buf[..1]), Err(MissingSecond));
-        buf[1] = u;
-        let pass = 2 + (u as usize % (buf.len()-2));
-        assert_eq!(char::from_utf16_slice_start(&buf[..pass]), Err(SecondNotLowSurrogate));
-    }
-    for u in 0xdc00..0xe000 {
-        buf[0] = u;
-        let close = if u%3==0 {u-100} else {u+100};
-        let pass = 1 + (u as usize % (buf.len()-1));
-        buf[pass] = close;
-        assert_eq!(char::from_utf16_slice_start(&buf[..pass]), Err(FirstLowSurrogate));
-    }
-}
-
-#[test]
-fn utf8_overlong() {
-    let overlongs = [
-        [0xf0,0x8f], [0xf0,0x87], [0xf0,0x80], // 4-byte
-        [0xe0,0x9f], [0xe0,0x8f], [0xe0,0x80], // 3-byte
-        [0xc1,0xbf], [0xc1,0x92], [0xc1,0x80], // 2-byte
-        [0xc0,0xbf], [0xc0,0x9f], [0xc0,0x80], // 2-byte
-    ];
-    for o in overlongs.iter() {
-        for &last in &[0x80, 0xbf] {
-            let arr = [o[0], o[1], last, last];
-            assert_eq!(char::from_utf8_slice_start(&arr), Err(InvalidUtf8Slice::Utf8(OverLong)));
-            assert_eq!(char::from_utf8_array(arr), Err(InvalidUtf8Array::Utf8(OverLong)));
-            assert_eq!(Utf8Char::from_slice_start(&arr), Err(InvalidUtf8Slice::Utf8(OverLong)));
-            assert_eq!(Utf8Char::from_array(arr), Err(InvalidUtf8Array::Utf8(OverLong)));
-        }
-    }
-}
-
-#[test]
-fn from_str_start() {
-    assert_eq!(Utf8Char::from_str_start(""), Err(EmptyStrError));
-    assert_eq!(Utf16Char::from_str_start(""), Err(EmptyStrError));
-}
-
-#[test] fn utf8_codepoint_is_too_high() {
-    assert_eq!(Utf8Char::from_array([0xf4, 0x90, 0x80, 0x80]), Err(a::Codepoint(TooHigh)));
-    assert_eq!(char::from_utf8_array([0xf4, 0x90, 0x80, 0x80]), Err(a::Codepoint(TooHigh)));
-    assert_eq!(Utf8Char::from_slice_start(&[0xf4, 0x90, 0x80, 0x80]), Err(s::Codepoint(TooHigh)));
-    assert_eq!(char::from_utf8_slice_start(&[0xf4, 0x90, 0x80, 0x80]), Err(s::Codepoint(TooHigh)));
-
-    assert_eq!(Utf8Char::from_array([0xf5, 0x88, 0x99, 0xaa]), Err(a::Codepoint(TooHigh)));
-    assert_eq!(char::from_utf8_array([0xf5, 0xaa, 0xbb, 0x88]), Err(a::Codepoint(TooHigh)));
-    assert_eq!(Utf8Char::from_slice_start(&[0xf5, 0x99, 0xaa, 0xbb]), Err(s::Codepoint(TooHigh)));
-    assert_eq!(char::from_utf8_slice_start(&[0xf5, 0xbb, 0x88, 0x99]), Err(s::Codepoint(TooHigh)));
-}
-
-#[test] fn utf8_codepoint_is_utf16_reserved() {
-    assert_eq!(Utf8Char::from_array([0xed, 0xa0, 0x80, 0xff]), Err(a::Codepoint(Utf16Reserved)));
-    assert_eq!(char::from_utf8_array([0xed, 0xa0, 0x8f, 0x00]), Err(a::Codepoint(Utf16Reserved)));
-    assert_eq!(Utf8Char::from_slice_start(&[0xed, 0xa0, 0xbe, 0xa5]), Err(s::Codepoint(Utf16Reserved)));
-    assert_eq!(char::from_utf8_slice_start(&[0xed, 0xa0, 0xbf]), Err(s::Codepoint(Utf16Reserved)));
-    assert_eq!(Utf8Char::from_array([0xed, 0xbf, 0x80, 0xff]), Err(a::Codepoint(Utf16Reserved)));
-    assert_eq!(char::from_utf8_array([0xed, 0xbf, 0x8f, 0x00]), Err(a::Codepoint(Utf16Reserved)));
-    assert_eq!(Utf8Char::from_slice_start(&[0xed, 0xbf, 0xbe, 0xa5]), Err(s::Codepoint(Utf16Reserved)));
-    assert_eq!(char::from_utf8_slice_start(&[0xed, 0xbf, 0xbf]), Err(s::Codepoint(Utf16Reserved)));
-}
-
-#[test] fn utf8_first_is_continuation_byte() {
-    for first in 0x80..0xc0 {
-        let arr = [first, first<<2, first<<4, first<<6];
-        assert_eq!(Utf8Char::from_array(arr), Err(a::Utf8(FirstByte(ContinuationByte))));
-        assert_eq!(char::from_utf8_array(arr), Err(a::Utf8(FirstByte(ContinuationByte))));
-        let len = (1 + first%3) as usize;
-        assert_eq!(Utf8Char::from_slice_start(&arr[..len]), Err(s::Utf8(FirstByte(ContinuationByte))));
-        assert_eq!(char::from_utf8_slice_start(&arr[..len]), Err(s::Utf8(FirstByte(ContinuationByte))));
-    }
-}
-
-#[test] fn utf8_too_long() {
-    for first in 0xf8..0x100 {
-        let arr = [first as u8, 0x88, 0x80, 0x80];
-        assert_eq!(Utf8Char::from_array(arr), Err(a::Utf8(FirstByte(TooLongSeqence))));
-        assert_eq!(char::from_utf8_array(arr), Err(a::Utf8(FirstByte(TooLongSeqence))));
-        let arr = [first as u8, 0x88, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80];
-        let slice = &arr[..if first&1 == 0 {1} else {8}];
-        assert_eq!(Utf8Char::from_slice_start(slice), Err(s::Utf8(FirstByte(TooLongSeqence))));
-        assert_eq!(char::from_utf8_slice_start(slice), Err(s::Utf8(FirstByte(TooLongSeqence))));
-    }
-}
-
-#[test] fn utf8_not_continuation_byte() {
-    for first in 0xc2..0xf4 {
-        let mut arr = [first, 0x90, 0xa0, 0xb0];
-        let extra = first.extra_utf8_bytes().unwrap();
-        for corrupt in (1..extra).rev() {
-            let expected = NotAContinuationByte(corrupt);
-            for &bad in &[0x00, 0x3f,  0x40, 0x7f,  0xc0, 0xff] {
-                arr[corrupt] = bad;
-                assert_eq!(Utf8Char::from_array(arr), Err(a::Utf8(expected)), "{:?}", arr);
-                assert_eq!(char::from_utf8_array(arr), Err(a::Utf8(expected)));
-                let slice = if first&1 == 0 {&arr[..1+extra]} else {&arr};
-                assert_eq!(Utf8Char::from_slice_start(slice), Err(s::Utf8(expected)), "{:?}", slice);
-                assert_eq!(char::from_utf8_slice_start(slice), Err(s::Utf8(expected)));
-            }
-        }
-    }
-}
diff --git a/vendor/encode_unicode/tests/exhaustive.rs b/vendor/encode_unicode/tests/exhaustive.rs
deleted file mode 100644
index ce60c6b..0000000
--- a/vendor/encode_unicode/tests/exhaustive.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-/* Copyright 2018 The encode_unicode Developers
- *
- * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
- * http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
- * http://opensource.org/licenses/MIT>, at your option. This file may not be
- * copied, modified, or distributed except according to those terms.
- */
-
-//! Tests that try all possible values for at least one parameter / byte / unit
-//! of the tested function.
-
-use std::char;
-extern crate encode_unicode;
-use encode_unicode::*;
-
-#[test]
-fn from_ascii() {
-    for cp in 0u32..256 {
-        assert_eq!(Utf8Char::from_ascii(cp as u8).is_ok(), cp & 0x80 == 0);
-        if let Ok(u8c) = Utf8Char::from_ascii(cp as u8) {
-            assert_eq!(u8c, Utf8Char::from(cp as u8 as char));
-        }
-    }
-}
-
-#[test]
-fn from_bmp() {
-    for cp in 0u32..0x1_00_00 {
-        assert_eq!(
-            Utf16Char::from_bmp(cp as u16).ok(),
-            char::from_u32(cp).map(|u32c| Utf16Char::from(u32c) )
-        );
-    }
-}
diff --git a/vendor/encode_unicode/tests/iterators.rs b/vendor/encode_unicode/tests/iterators.rs
deleted file mode 100644
index 2a4c006..0000000
--- a/vendor/encode_unicode/tests/iterators.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-/* Copyright 2018 The encode_unicode Developers
- *
- * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
- * http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
- * http://opensource.org/licenses/MIT>, at your option. This file may not be
- * copied, modified, or distributed except according to those terms.
- */
-
-//! Iterator tests
-
-#![cfg(feature="std")]
-
-extern crate encode_unicode;
-
-use encode_unicode::{IterExt, SliceExt, CharExt};
-use encode_unicode::iterator::Utf8CharSplitter;
-use encode_unicode::error::InvalidUtf8Slice::*;
-use encode_unicode::error::InvalidUtf8::*;
-use encode_unicode::error::InvalidUtf8FirstByte::*;
-use encode_unicode::error::InvalidCodepoint::*;
-use encode_unicode::error::Utf16PairError::*;
-use std::io::Read;
-use std::cmp::min;
-
-#[test] fn utf8charmerger() {
-    let slice = b"\xf0\xa1\x92X\xcc\xbb";
-    let mut iter = slice.iter().to_utf8chars();
-    assert_eq!(iter.size_hint(), (1, Some(6)));
-    assert_eq!(format!("{:?}", &iter),
-               format!("Utf8CharMerger {{ buffered: [], inner: {:?} }}", slice.iter()));
-
-    assert_eq!(iter.next(), Some(Err(Utf8(NotAContinuationByte(3)))));
-    assert_eq!(iter.size_hint(), (0, Some(5)));
-    assert_eq!(
-        format!("{:?}", &iter),
-        format!("Utf8CharMerger {{ buffered: [161, 146, 88], inner: {:?} }}", slice[4..].iter())
-    );
-
-    assert_eq!(iter.next(), Some(Err(Utf8(FirstByte(ContinuationByte)))));
-    assert_eq!(iter.into_inner().next(), Some(&b'\xcc'));
-}
-
-#[test] fn utf8chardecoder() {
-    let slice = b"\xf4\xbf\x80\x80XY\xcc\xbbZ_";
-    let mut iter = slice.utf8char_indices();
-    assert_eq!(iter.size_hint(), (2, Some(10)));
-    assert_eq!(
-        format!("{:?}", &iter),
-        format!("Utf8CharDecoder {{ bytes[0..]: {:?} }}", &slice)
-    );
-
-    assert_eq!(iter.next(), Some((0, Err(Codepoint(TooHigh)), 1)));
-    assert_eq!(
-        format!("{:?}", &iter),
-        format!("Utf8CharDecoder {{ bytes[1..]: {:?} }}", &slice[1..])
-    );
-    assert_eq!(iter.size_hint(), (2, Some(9)));
-    assert_eq!(iter.count(), 8);
-}
-
-#[test] fn utf16charmerger() {
-    let slice = [0xd800, 'x' as u16, 0xd900, 0xdfff, 'λ' as u16];
-    let mut iter = slice.iter().to_utf16chars();
-    assert_eq!(iter.size_hint(), (2, Some(5)));
-    assert_eq!(format!("{:?}", &iter),
-               format!("Utf16CharMerger {{ buffered: None, inner: {:?} }}", slice.iter()));
-
-    assert_eq!(iter.next(), Some(Err(UnmatchedLeadingSurrogate)));
-    assert_eq!(iter.size_hint(), (1, Some(4)));
-    assert_eq!(
-        format!("{:?}", &iter),
-        format!("Utf16CharMerger {{ buffered: Some(120), inner: {:?} }}", slice[2..].iter())
-    );
-
-    assert_eq!(iter.into_inner().next(), Some(&0xd900));
-}
-
-#[test] fn utf16chardecoder() {
-    let slice = [0xd800, 'x' as u16, 0xd900, 0xdfff, 'λ' as u16];
-    let mut iter = slice.utf16char_indices();
-    assert_eq!(iter.size_hint(), (2, Some(5)));
-    assert_eq!(
-        format!("{:?}", &iter),
-        format!("Utf16CharDecoder {{ units[0..]: {:?} }}", &slice)
-    );
-
-    assert_eq!(iter.next(), Some((0, Err(UnmatchedLeadingSurrogate), 1)));
-    assert_eq!(
-        format!("{:?}", &iter),
-        format!("Utf16CharDecoder {{ units[1..]: {:?} }}", &slice[1..])
-    );
-    assert_eq!(iter.size_hint(), (2, Some(4)));
-    assert_eq!(iter.count(), 3);
-}
-
-
-
-/// Tests for ensuring that iterators which also implement Read support
-/// interleaving calls of `read()` and `next()`, and that they implement Read
-/// correctly (support any buffer size at any time).
-
-#[test] fn read_single_ascii() {
-    let uc = 'a'.to_utf8();
-    assert_eq!(uc.len(), 1);
-    for chunk in 1..5 {
-        let mut buf = [b'E'; 6];
-        let mut iter = uc.into_iter();
-        let mut written = 0;
-        for _ in 0..4 {
-            assert_eq!(iter.read(&mut buf[..0]).unwrap(), 0);
-            let wrote = iter.read(&mut buf[written..written+chunk]).unwrap();
-            assert_eq!(wrote, min(1-written, chunk));
-            written += wrote;
-            for &b in &buf[written..] {assert_eq!(b, b'E');}
-            assert_eq!(buf[..written], AsRef::<[u8]>::as_ref(&uc)[..written]);
-        }
-        assert_eq!(written, 1);
-    }
-}
-
-#[test] fn read_single_nonascii() {
-    let uc = 'ä'.to_utf8();
-    assert_eq!(uc.len(), 2);
-    for chunk in 1..5 {
-        let mut buf = [b'E'; 6];
-        let mut iter = uc.into_iter();
-        let mut written = 0;
-        for _ in 0..4 {
-            assert_eq!(iter.read(&mut buf[..0]).unwrap(), 0);
-            let wrote = iter.read(&mut buf[written..written+chunk]).unwrap();
-            assert_eq!(wrote, min(2-written, chunk));
-            written += wrote;
-            for &b in &buf[written..] {assert_eq!(b, b'E');}
-            assert_eq!(buf[..written], AsRef::<[u8]>::as_ref(&uc)[..written]);
-        }
-        assert_eq!(written, 2);
-    }
-}
-
-
-#[test] fn utf8charsplitter_read_all_sizes() {
-    let s = "1111\u{104444}\u{222}1\u{833}1111\u{100004}";
-    assert!(s.len()%3 == 1);
-    let mut buf = vec![b'E'; s.len()+6];
-    for size in 2..6 {//s.len()+4 {
-        let mut reader = Utf8CharSplitter::from(s.chars().map(|c| c.to_utf8() ));
-        for (offset, part) in s.as_bytes().chunks(size).enumerate() {
-            let read_to = if part.len() == size {(offset+1)*size} else {buf.len()};
-            assert_eq!(reader.read(&mut buf[offset*size..read_to]).unwrap(), part.len());
-            assert_eq!(&buf[..offset*size+part.len()], &s.as_bytes()[..offset*size+part.len()]);
-        }
-        assert_eq!(reader.read(&mut buf[..]).unwrap(), 0);
-        assert!(buf[s.len()..].iter().all(|&b| b==b'E' ));
-    }
-}
-
-#[test] fn utf8charsplitter_alternate_iter_read() {
-    let s = "1111\u{104444}\u{222}1\u{833}1111\u{100004}";
-    let mut buf = [b'0'; 10];
-    for n in 0..2 {
-        // need to collect to test size_hint()
-        // because chars().size_hint() returns ((bytes+3)/4, Some(bytes))
-        let u8chars = s.chars().map(|c| c.to_utf8() ).collect::<Vec<_>>();
-        let mut iter: Utf8CharSplitter<_,_> = u8chars.into_iter().into();
-        for (i, byte) in s.bytes().enumerate() {
-            let until_next = s.as_bytes()[i..].iter().take_while(|&b| (b>>6)==0b10u8 ).count();
-            let remaining_chars = s[i+until_next..].chars().count();
-            println!("{}. run: byte {:02} of {}, remaining: {:02}+{}: 0b{:08b} = {:?}",
-                     n, i, s.len(), remaining_chars, until_next, byte, byte as char);
-            assert_eq!(iter.read(&mut[][..]).unwrap(), 0);
-            if i % 2 == n {
-                assert_eq!(iter.next(), Some(byte));
-            } else {
-                assert_eq!(iter.read(&mut buf[..1]).unwrap(), 1);
-                assert_eq!(buf[0], byte);
-            }
-        }
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-        assert_eq!(iter.next(), None);
-        assert_eq!(iter.read(&mut buf[..]).unwrap(), 0);
-    }
-}
diff --git a/vendor/encode_unicode/tests/oks.rs b/vendor/encode_unicode/tests/oks.rs
deleted file mode 100644
index 8bab37f..0000000
--- a/vendor/encode_unicode/tests/oks.rs
+++ /dev/null
@@ -1,284 +0,0 @@
-/* Copyright 2016 The encode_unicode Developers
- *
- * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
- * http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
- * http://opensource.org/licenses/MIT>, at your option. This file may not be
- * copied, modified, or distributed except according to those terms.
- */
-
-//! Test that every method gives the correct result for valid values.
-//! Except iterators, which are stateful.
-
-use std::char;
-use std::str::{self,FromStr};
-use std::cmp::Ordering;
-use std::hash::{Hash,Hasher};
-use std::collections::hash_map::DefaultHasher;
-#[allow(deprecated,unused)]
-use std::ascii::AsciiExt;
-use std::iter::FromIterator;
-extern crate encode_unicode;
-use encode_unicode::*;
-
-
-#[test]
-fn equal_defaults() {
-    assert_eq!(Utf8Char::default().to_char(), char::default());
-    assert_eq!(Utf16Char::default().to_char(), char::default());
-}
-
-#[test]
-fn same_size_as_char() {
-    use std::mem::size_of;
-    assert_eq!(size_of::<Utf8Char>(), size_of::<char>());
-    assert_eq!(size_of::<Utf16Char>(), size_of::<char>());
-}
-
-#[test]
-fn utf16chars_to_string() {
-    let s = "aå\u{10ffff}‽\u{100000}\u{fee1}";
-    let u16cs = s.chars().map(|c| Utf16Char::from(c) ).collect::<Vec<Utf16Char>>();
-
-    let mut from_refs: String = u16cs.iter().collect();
-    assert_eq!(&from_refs, s);
-    from_refs.extend(&u16cs);
-    assert_eq!(&from_refs[s.len()..], s);
-
-    let mut from_vals: String = u16cs.iter().cloned().collect();
-    assert_eq!(&from_vals, s);
-    from_vals.extend(u16cs);
-    assert_eq!(&from_vals[s.len()..], s);
-}
-
-
-const EDGES_AND_BETWEEN: [char;19] = [
-    '\u{0}',// min
-    '\u{3b}',// middle ASCII
-    'A',// min ASCII uppercase
-    'N',// middle ASCII uppercase
-    'Z',// max ASCII uppercase
-    'a',// min ASCII lowercase
-    'm',// middle ASCII lowercase
-    'z',// max ASCII lowercase
-    '\u{7f}',// max ASCII and 1-byte UTF-8
-    '\u{80}',// min 2-byte UTF-8
-    '\u{111}',// middle
-    '\u{7ff}',// max 2-byte UTF-8
-    '\u{800}',// min 3-byte UTF-8
-    '\u{d7ff}',// before reserved
-    '\u{e000}',// after reserved
-    '\u{ffff}',// max UTF-16 single and 3-byte UTF-8
-    '\u{10000}',// min UTF-16 surrogate and 4-byte UTF-8
-    '\u{abcde}',// middle
-    '\u{10ffff}',// max
-];
-
-fn eq_cmp_hash(c: char) -> (Utf8Char, Utf16Char) {
-    fn hash<T:Hash>(v: T) -> u64 {
-        #[allow(deprecated)]
-        let mut hasher = DefaultHasher::new();
-        v.hash(&mut hasher);
-        hasher.finish()
-    }
-    let u8c = c.to_utf8();
-    assert_eq!(u8c.to_char(), c);
-    assert_eq!(u8c, u8c);
-    assert_eq!(hash(u8c), hash(u8c));
-    assert_eq!(u8c.cmp(&u8c), Ordering::Equal);
-    assert!(u8c.eq_ignore_ascii_case(&u8c));
-    let u16c = c.to_utf16();
-    assert_eq!(u16c.to_char(), c);
-    assert_eq!(u16c, u16c);
-    assert_eq!(hash(u16c), hash(c));
-    assert_eq!(u16c.cmp(&u16c), Ordering::Equal);
-    assert!(u16c.eq_ignore_ascii_case(&u16c));
-
-    assert_eq!(u8c, c);
-    assert_eq!(c, u8c);
-    assert_eq!(u16c, c);
-    assert_eq!(c, u16c);
-    assert_eq!(u8c, u16c);
-    assert_eq!(u16c, u8c);
-    assert_eq!(u8c == c as u8,  c <= '\u{7F}');
-    assert_eq!(u16c == c as u8,  c <= '\u{FF}');
-    assert_eq!(u16c == c as u16,  c <= '\u{FFFF}');
-
-    assert_eq!(u8c.partial_cmp(&c), Some(Ordering::Equal));
-    assert_eq!(c.partial_cmp(&u8c), Some(Ordering::Equal));
-    assert_eq!(u16c.partial_cmp(&c), Some(Ordering::Equal));
-    assert_eq!(c.partial_cmp(&u16c), Some(Ordering::Equal));
-    assert_eq!(u8c.partial_cmp(&u16c), Some(Ordering::Equal));
-    assert_eq!(u16c.partial_cmp(&u8c), Some(Ordering::Equal));
-
-
-    for &other in &EDGES_AND_BETWEEN {
-        let u8other = other.to_utf8();
-        assert_eq!(u8c == u8other,  c == other);
-        assert_eq!(hash(u8c)==hash(u8other),  hash(c)==hash(other));
-        assert_eq!(u8c.cmp(&u8other), c.cmp(&other));
-        assert_eq!(u8c.eq_ignore_ascii_case(&u8other), c.eq_ignore_ascii_case(&other));
-        assert_eq!(u8c.partial_cmp(&other), c.partial_cmp(&other));
-        assert_eq!(c.partial_cmp(&u8other), c.partial_cmp(&other));
-        assert_eq!(u8other.partial_cmp(&c), other.partial_cmp(&c));
-        assert_eq!(other.partial_cmp(&u8c), other.partial_cmp(&c));
-        assert_eq!(u8c == other as u8,  other as u8 <= 127 && c == other as u8 as char);
-
-        let u16other = other.to_utf16();
-        assert_eq!(u16c == u16other,  c == other);
-        assert_eq!(hash(u16c)==hash(u16other),  hash(c)==hash(other));
-        assert_eq!(u16c.cmp(&u16other), c.cmp(&other));
-        assert_eq!(u16c.eq_ignore_ascii_case(&u16other), c.eq_ignore_ascii_case(&other));
-        assert_eq!(u16c.partial_cmp(&other), c.partial_cmp(&other));
-        assert_eq!(c.partial_cmp(&u16other), c.partial_cmp(&other));
-        assert_eq!(u16other.partial_cmp(&c), other.partial_cmp(&c));
-        assert_eq!(other.partial_cmp(&u16c), other.partial_cmp(&c));
-        assert_eq!(u16c == other as u8,  c == other as u8 as char);
-        assert_eq!(u16c == other as u16,  c as u32 == other as u16 as u32);
-
-        assert_eq!(u8c == u16other,  c == other);
-        assert_eq!(u16c == u8other,  c == other);
-        assert_eq!(u8c.partial_cmp(&u16other),  c.partial_cmp(&other));
-        assert_eq!(u16c.partial_cmp(&u8other),  c.partial_cmp(&other));
-        assert_eq!(u8other.partial_cmp(&u16c),  other.partial_cmp(&c));
-        assert_eq!(u16other.partial_cmp(&u8c),  other.partial_cmp(&c));
-    }
-    (u8c, u16c)
-}
-
-fn iterators(c: char) {
-    let mut iter = c.iter_utf8_bytes();
-    let mut buf = [0; 4];
-    let mut iter_ref = c.encode_utf8(&mut buf[..]).as_bytes().iter();
-    for _ in 0..6 {
-        assert_eq!(iter.size_hint(), iter_ref.size_hint());
-        assert_eq!(format!("{:?}", iter), format!("{:?}", iter_ref.as_slice()));
-        assert_eq!(iter.next(), iter_ref.next().cloned());
-    }
-
-    let mut iter = c.iter_utf16_units();
-    let mut buf = [0; 2];
-    let mut iter_ref = c.encode_utf16(&mut buf[..]).iter();
-    for _ in 0..4 {
-        assert_eq!(iter.size_hint(), iter_ref.size_hint());
-        assert_eq!(format!("{:?}", iter), format!("{:?}", iter_ref.as_slice()));
-        assert_eq!(iter.next(), iter_ref.next().cloned());
-    }
-}
-
-fn test(c: char) {
-    assert_eq!(char::from_u32(c as u32), Some(c));
-    assert_eq!(char::from_u32_detailed(c as u32), Ok(c));
-    assert_eq!(unsafe{ char::from_u32_unchecked(c as u32) }, c);
-    let (u8c, u16c) = eq_cmp_hash(c);
-    iterators(c);
-    assert_eq!(Utf16Char::from(u8c), u16c);
-    assert_eq!(Utf8Char::from(u16c), u8c);
-    let utf8_len = c.len_utf8();
-    let utf16_len = c.len_utf16();
-    let mut as_str = c.to_string();
-
-    // UTF-8
-    let mut buf = [0; 4];
-    let reference = c.encode_utf8(&mut buf[..]).as_bytes();
-    let len = reference.len(); // short name because it is used in many places.
-    assert_eq!(len, utf8_len);
-    assert_eq!(reference[0].extra_utf8_bytes(), Ok(len-1));
-    assert_eq!(reference[0].extra_utf8_bytes_unchecked(), len-1);
-    assert_eq!(AsRef::<[u8]>::as_ref(&u8c), reference);
-
-    let (arr,arrlen) = u8c.to_array();
-    assert_eq!(arrlen, len);
-    assert_eq!(Utf8Char::from_array(arr), Ok(u8c));
-    assert_eq!(c.to_utf8_array(),  (arr, len));
-
-    let str_ = str::from_utf8(reference).unwrap();
-    let ustr = Utf8Char::from_str(str_).unwrap();
-    assert_eq!(ustr.to_array().0, arr);// bitwise equality
-    assert_eq!(char::from_utf8_array(arr), Ok(c));
-    let mut longer = [0xff; 5]; // 0xff is never valid
-    longer[..len].copy_from_slice(reference);
-    assert_eq!(char::from_utf8_slice_start(reference), Ok((c,len)));
-    assert_eq!(char::from_utf8_slice_start(&longer), Ok((c,len)));
-    assert_eq!(Utf8Char::from_slice_start(reference), Ok((u8c,len)));
-    assert_eq!(Utf8Char::from_slice_start(&longer), Ok((u8c,len)));
-    for other in &mut longer[len..] {*other = b'?'}
-    assert_eq!(Utf8Char::from_str(str_), Ok(u8c));
-    assert_eq!(Utf8Char::from_str_start(str_), Ok((u8c,len)));
-    assert_eq!(Utf8Char::from_str_start(str::from_utf8(&longer).unwrap()), Ok((u8c,len)));
-    unsafe {
-        // Hopefully make bugs easier to catch by making reads into unallocated memory by filling
-        // a jemalloc bin. See table on http://jemalloc.net/jemalloc.3.html for bin sizes.
-        // I have no idea whether this works.
-        let mut boxed = Box::new([0xffu8; 16]);
-        let start = boxed.len()-len; // reach the end
-        boxed[start..].copy_from_slice(reference);
-        let slice = &boxed[start..start]; // length of slice should be ignored.
-        assert_eq!(Utf8Char::from_slice_start_unchecked(slice), (u8c,len));
-    }
-    assert_eq!(&Vec::<u8>::from_iter(Some(u8c))[..], reference);
-    assert_eq!(&String::from_iter(Some(u8c))[..], str_);
-    assert_eq!(format!("{:?}", u8c), format!("{:?}", c));
-    assert_eq!(format!("{}", u8c), format!("{}", c));
-    assert_eq!(u8c.is_ascii(), c.is_ascii());
-    assert_eq!(u8c.to_ascii_lowercase().to_char(), c.to_ascii_lowercase());
-    assert_eq!(u8c.to_ascii_uppercase().to_char(), c.to_ascii_uppercase());
-
-    // UTF-16
-    let mut buf = [0; 2];
-    let reference = c.encode_utf16(&mut buf[..]);
-    let len = reference.len();
-    assert_eq!(len, utf16_len);
-    assert_eq!(reference[0].utf16_needs_extra_unit(), Ok(len==2));
-    assert_eq!(reference[0].is_utf16_leading_surrogate(), len==2);
-    assert_eq!(u16c.as_ref(), reference);
-    let mut longer = [0; 3];
-    longer[..len].copy_from_slice(reference);
-    assert_eq!(char::from_utf16_slice_start(reference), Ok((c,len)));
-    assert_eq!(char::from_utf16_slice_start(&longer), Ok((c,len)));
-    assert_eq!(Utf16Char::from_slice_start(reference), Ok((u16c,len)));
-    assert_eq!(Utf16Char::from_slice_start(&longer), Ok((u16c,len)));
-    assert_eq!(Utf16Char::from_str(&as_str), Ok(u16c));
-    as_str.push(c);
-    assert_eq!(Utf16Char::from_str_start(&as_str), Ok((u16c,utf8_len)));
-    unsafe {
-        // Hopefully make bugs easier to catch by making reads into unallocated memory by filling
-        // a jemalloc bin. See table on http://jemalloc.net/jemalloc.3.html for bin sizes.
-        // I have no idea whether this works.
-        let mut boxed = Box::new([0u16; 8]);
-        let start = boxed.len()-len; // reach the end
-        boxed[start..].copy_from_slice(reference);
-        let slice = &boxed[start..start]; // length of slice should be ignored.
-        assert_eq!(Utf16Char::from_slice_start_unchecked(slice), (u16c,len));
-    }
-    let array = c.to_utf16_array();
-    let tuple = c.to_utf16_tuple();
-    assert_eq!(&array[..reference.len()], reference);
-    assert_eq!(tuple, (reference[0],reference.get(1).cloned()));
-    assert_eq!(char::from_utf16_array(array), Ok(c));
-    assert_eq!(char::from_utf16_tuple(tuple), Ok(c));
-    assert_eq!(c.to_utf16().to_char(), c);
-    assert_eq!(&Vec::<u16>::from_iter(Some(u16c))[..], reference);
-    assert_eq!(format!("{:?}", u16c), format!("{:?}", c));
-    assert_eq!(format!("{}", u16c), format!("{}", c));
-    assert_eq!(u16c.is_ascii(), c.is_ascii());
-    assert_eq!(u16c.to_ascii_lowercase().to_char(), c.to_ascii_lowercase());
-    assert_eq!(u16c.to_ascii_uppercase().to_char(), c.to_ascii_uppercase());
-}
-
-
-#[test]
-fn edges_middle() {
-    for &c in &EDGES_AND_BETWEEN {
-        test(c);
-    }
-}
-
-
-#[test]
-#[ignore]
-fn all() {
-    for cp in std::iter::Iterator::chain(0..0xd800, 0xe000..0x110000) {
-        let c = char::from_u32(cp).expect("not a valid char");
-        test(c);
-    }
-}