Test IntoAsciiStr and fix bug

Author: tormol

src/ascii_str.rs

@@ -359,7 +359,7 @@ impl<'a> AsciiCast<'a> for str {
 
 
 /// Error returned by IntoAsciiStr
-#[derive(PartialEq)]// allows assert_eq!
+#[derive(Clone,Copy)]
 pub struct IntoAsciiStrError {
     index: usize,
     /// If less than 128, it was a byte >= 128
@@ -498,11 +498,11 @@ impl IntoAsciiStr for str {
 }
 impl IntoMutAsciiStr for str {
     fn into_ascii_mut(&mut self) -> Result<&mut AsciiStr,IntoAsciiStrError> {
-        match self.bytes().enumerate().find(|&(_,b)| b > 127 ) {
-            Some((index, byte)) => Err(IntoAsciiStrError{
-                                            index: index,
-                                            not_ascii: (byte - 128) as char,
-                                        }),
+        match self.bytes().position(|b| b > 127 ) {
+            Some(index) => Err(IntoAsciiStrError{
+                                   index: index,
+                                   not_ascii: self[index..].chars().next().unwrap(),
+                               }),
             None => unsafe{ Ok(self.into_ascii_mut_unchecked()) },
         }
     }
@@ -516,15 +516,38 @@ impl IntoMutAsciiStr for str {
 #[cfg(test)]
 mod tests {
     use {AsciiCast,Ascii};
-    use super::{AsciiStr,IntoAsciiStr,IntoAsciiStrError};
+    use super::{AsciiStr,IntoAsciiStr,IntoMutAsciiStr,IntoAsciiStrError};
+
+    pub fn tuplify<T>(r: Result<T,IntoAsciiStrError>) -> Result<T,(usize,char)> {
+        r.map_err(|e| (e.index, e.not_ascii) )
+    }
 
     #[test]
-    fn into_ascii() {
+    fn generic_into_ascii() {
         fn generic<C:IntoAsciiStr+?Sized>(c: &C) -> Result<&AsciiStr,IntoAsciiStrError> {
             c.into_ascii()
         }
-        assert_eq!(generic("A"), Ok([Ascii::A].as_ref().into()));
-        assert_eq!(generic(&b"A"[..]), Ok([Ascii::A].as_ref().into()));
+        let arr = [Ascii::A];
+        let ascii_str = arr.as_ref().into();
+        assert_eq!(tuplify(generic("A")), Ok(ascii_str));
+        assert_eq!(tuplify(generic(&b"A"[..])), Ok(ascii_str));
+        //assert_eq!(generic(ascii_str), Ok(ascii_str));
+    }
+    #[test]
+    fn into_ascii() {
+        let mut s: String = "abčd".to_string();
+        let mut b: Vec<u8> = s.clone().into();
+        assert_eq!(tuplify(s.as_str().into_ascii()), Err((2,'č')));
+        assert_eq!(tuplify(s.as_mut_str().into_ascii_mut()), Err((2,'č')));
+        let c = (b[2]-128) as char;
+        assert_eq!(tuplify(b.as_slice().into_ascii()), Err((2,c)));
+        assert_eq!(tuplify(b.as_mut_slice().into_ascii_mut()), Err((2,c)));
+        let mut a = [Ascii::a, Ascii::b];
+        assert_eq!(tuplify((&s[..2]).into_ascii()), Ok((&a[..]).into()));
+        assert_eq!(tuplify((&b[..2]).into_ascii()), Ok((&a[..]).into()));
+        let a = Ok((&mut a[..]).into());
+        assert_eq!(tuplify((&mut s[..2]).into_ascii_mut()), a);
+        assert_eq!(tuplify((&mut b[..2]).into_ascii_mut()), a);
     }
 
     #[test]