Merge pull request #1244 from black-puppydog/cow-rework

refactor(cow1):  replace main with tests

exercises/smart_pointers/cow1.rs

@@ -4,6 +4,9 @@
 // Cow is a clone-on-write smart pointer.
 // It can enclose and provide immutable access to borrowed data, and clone the data lazily when mutation or ownership is required.
 // The type is designed to work with general borrowed data via the Borrow trait.
+//
+// This exercise is meant to show you what to expect when passing data to Cow.
+// Fix the unit tests by checking for Cow::Owned(_) and Cow::Borrowed(_) at the TODO markers.
 
 // I AM NOT DONE
 
@@ -20,29 +23,52 @@ fn abs_all<'a, 'b>(input: &'a mut Cow<'b, [i32]>) -> &'a mut Cow<'b, [i32]> {
     input
 }
 
-fn main() {
-    // No clone occurs because `input` doesn't need to be mutated.
-    let slice = [0, 1, 2];
-    let mut input = Cow::from(&slice[..]);
-    match abs_all(&mut input) {
-        Cow::Borrowed(_) => println!("I borrowed the slice!"),
-        _ => panic!("expected borrowed value"),
-    }
+#[cfg(test)]
+mod tests {
+    use super::*;
 
+    #[test]
+    fn reference_mutation() -> Result<(), &'static str> {
         // Clone occurs because `input` needs to be mutated.
         let slice = [-1, 0, 1];
         let mut input = Cow::from(&slice[..]);
         match abs_all(&mut input) {
-        Cow::Owned(_) => println!("I modified the slice and now own it!"),
-        _ => panic!("expected owned value"),
+            Cow::Owned(_) => Ok(()),
+            _ => Err("Expected owned value"),
+        }
     }
 
-    // No clone occurs because `input` is already owned.
+    #[test]
+    fn reference_no_mutation() -> Result<(), &'static str> {
+        // No clone occurs because `input` doesn't need to be mutated.
+        let slice = [0, 1, 2];
+        let mut input = Cow::from(&slice[..]);
+        match abs_all(&mut input) {
+            // TODO
+        }
+    }
+
+    #[test]
+    fn owned_no_mutation() -> Result<(), &'static str> {
+        // We can also pass `slice` without `&` so Cow owns it directly.
+        // In this case no mutation occurs and thus also no clone,
+        // but the result is still owned because it always was.
+        let slice = vec![0, 1, 2];
+        let mut input = Cow::from(slice);
+        match abs_all(&mut input) {
+            // TODO
+        }
+    }
+
+    #[test]
+    fn owned_mutation() -> Result<(), &'static str> {
+        // Of course this is also the case if a mutation does occur.
+        // In this case the call to `to_mut()` returns a reference to
+        // the same data as before.
         let slice = vec![-1, 0, 1];
         let mut input = Cow::from(slice);
         match abs_all(&mut input) {
             // TODO
-        Cow::Borrowed(_) => println!("I own this slice!"),
-        _ => panic!("expected borrowed value"),
+        }
     }
 }

info.toml

@@ -1010,9 +1010,9 @@ https://doc.rust-lang.org/stable/book/ch16-00-concurrency.html
 [[exercises]]
 name = "cow1"
 path = "exercises/smart_pointers/cow1.rs"
-mode = "compile"
+mode = "test"
 hint = """
-Since the vector is already owned, the `Cow` type doesn't need to clone it.
+If Cow already owns the data it doesn't need to clone it when to_mut() is called.
 
 Check out https://doc.rust-lang.org/std/borrow/enum.Cow.html for documentation
 on the `Cow` type.