misc: add more tests

Author: tinycedar

tests/channel.rs

@@ -0,0 +1,32 @@
+mod tests {
+    use std::ops::Add;
+    use std::sync::mpsc;
+    use std::thread;
+
+    #[test]
+    fn test_channel() {
+        let (tx1, rx) = mpsc::channel();
+        let tx2 = mpsc::Sender::clone(&tx1);
+
+        thread::spawn(move || {
+            for i in 0..4 {
+                tx1.send(String::from("hi => ").add(i.to_string().as_str()))
+                    .unwrap();
+            }
+        });
+
+        thread::spawn(move || {
+            tx2.send(String::from("other")).unwrap();
+        });
+
+        loop {
+            match rx.recv() {
+                Ok(str) => println!("{}", str),
+                Err(_) => {
+                    // println!("none: {}", rec_err.to_string());
+                    break;
+                }
+            }
+        }
+    }
+}

tests/closure.rs

@@ -0,0 +1,8 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_add() {
+        let s = |x| x;
+        println!("{}", s(1234));
+    }
+}

tests/generator.rs

@@ -10,9 +10,9 @@ mod tests {
     #[test]
     fn test_generator() {
         let mut generator = || {
-            println!("2");
-            yield;
-            println!("4");
+            println!("generator_2");
+            yield "ss";
+            println!("generator_4");
         };
 
         println!("1");

tests/lifetime.rs

@@ -0,0 +1,44 @@
+use std::fmt::Display;
+
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+    if x.len() > y.len() {
+        x
+    } else {
+        y
+    }
+}
+
+fn longest_2<'a>(x: &'a str, y: &str) -> &'a str {
+    println!("{}", y);
+    x
+}
+
+fn smaller_size(x: &str, y: &str) -> usize {
+    if x.len() > y.len() {
+        x.len()
+    } else {
+        y.len()
+    }
+}
+
+fn longest_with_an_announcement<'a, T: Display>(x: &'a str, y: &'a str, ann: T) -> &'a str {
+    println!("Announcement! {}", ann);
+    if x.len() > y.len() {
+        x
+    } else {
+        y
+    }
+}
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_lifetime() {
+        let longest: &str = longest("1", "123");
+        println!("{}", longest);
+        println!("{}", longest_2("1", "123"));
+        println!("{}", smaller_size("1", "123"));
+        println!("{}", longest_with_an_announcement("a", "abc", 1));
+    }
+}

tests/mutex.rs

@@ -0,0 +1,17 @@
+use std::sync::Mutex;
+
+fn mutex() {
+    let m = Mutex::new(5);
+    let mut num = m.lock().unwrap();
+    *num = 1;
+    println!("{}", num);
+}
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mutex() {
+        mutex();
+    }
+}

tests/thread.rs

@@ -0,0 +1,34 @@
+use std::thread;
+use std::time::Duration;
+
+fn test() {
+    println!("in main thread");
+
+    let _ = thread::spawn(|| {
+        thread::sleep(Duration::from_millis(100));
+        println!("in a thread");
+    })
+    .join();
+}
+
+fn test_move() {
+    let v = vec![1, 2, 3];
+
+    let handle = thread::spawn(move || {
+        println!("Here's a vector: {:?}", v);
+    });
+
+    // println!("In main: {:?}", v); value borrowed here after move
+
+    handle.join().unwrap();
+}
+
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_thread() {
+        test();
+        test_move();
+    }
+}

tests/trait.rs

@@ -1,3 +1,5 @@
+use std::fmt::{Display, Error, Formatter};
+
 struct Duck;
 
 struct Pig;
@@ -12,16 +14,45 @@ impl Fly for Duck {
     }
 }
 
+impl Display for Duck {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.write_str(self.fly().to_string().as_str())
+    }
+}
+
 impl Fly for Pig {
     fn fly(&self) -> bool {
         false
     }
 }
 
-fn fly_static<T: Fly>(s: T) -> bool {
+impl Display for Pig {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        f.write_str(self.fly().to_string().as_str())
+    }
+}
+
+fn fly_static<T: Fly + Display>(s: T) -> bool {
+    s.fly()
+}
+
+// syntax sugar for fly_static
+fn fly_static_1(s: impl Fly + Display) -> bool {
+    s.fly()
+}
+
+fn fly_static_2(s: &(impl Fly + Display)) -> bool {
     s.fly()
 }
 
+fn fly_static_3<T, U>(t: &T, u: &U) -> bool
+where
+    T: Fly + Display,
+    U: Fly + Display,
+{
+    t.fly() && u.fly()
+}
+
 fn fly_dyn(s: &dyn Fly) -> bool {
     s.fly()
 }
@@ -34,8 +65,11 @@ mod tests {
     fn test_trait() {
         let pig = Pig;
         assert_eq!(fly_static::<Pig>(pig), false);
+        assert_eq!(fly_static_1(Pig {}), false);
+        assert_eq!(fly_static_2(&Pig {}), false);
+        assert_eq!(fly_static_3(&Pig {}, &Pig {}), false);
 
         let duck = Duck;
         assert_eq!(fly_dyn(&duck), true);
     }
-}
+}

tests/traits_2.rs

@@ -0,0 +1,37 @@
+use std::fmt::Display;
+
+struct Pair<T> {
+    x: T,
+    y: T,
+}
+
+impl<T> Pair<T> {
+    fn new(x: T, y: T) -> Self {
+        Self { x, y }
+    }
+}
+
+impl<T: Display + PartialOrd> Pair<T> {
+    fn cmp_display(&self) {
+        if self.x >= self.y {
+            println!("The larger member is x = {}", self.x);
+        } else {
+            println!("The larger member is y = {}", self.y);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_trait_2() {
+        let p = Pair::new(1, 2);
+        println!("Pair x: {}", p.x);
+        p.cmp_display();
+
+        let pp = Pair::new(&p, &p);
+        // pp.cmp_display(); trait bounds were not satisfied
+    }
+}