src/libcore/tests/cmp.rs

   1 use core::cmp::{self, Ordering::*};
   2
   3 #[test]
   4 fn test_int_totalord() {
   5     assert_eq!(5.cmp(&10), Less);
   6     assert_eq!(10.cmp(&5), Greater);
   7     assert_eq!(5.cmp(&5), Equal);
   8     assert_eq!((-5).cmp(&12), Less);
   9     assert_eq!(12.cmp(&-5), Greater);
  10 }
  11
  12 #[test]
  13 fn test_bool_totalord() {
  14     assert_eq!(true.cmp(&false), Greater);
  15     assert_eq!(false.cmp(&true), Less);
  16     assert_eq!(true.cmp(&true), Equal);
  17     assert_eq!(false.cmp(&false), Equal);
  18 }
  19
  20 #[test]
  21 fn test_mut_int_totalord() {
  22     assert_eq!((&mut 5).cmp(&&mut 10), Less);
  23     assert_eq!((&mut 10).cmp(&&mut 5), Greater);
  24     assert_eq!((&mut 5).cmp(&&mut 5), Equal);
  25     assert_eq!((&mut -5).cmp(&&mut 12), Less);
  26     assert_eq!((&mut 12).cmp(&&mut -5), Greater);
  27 }
  28
  29 #[test]
  30 fn test_ord_max_min() {
  31     assert_eq!(1.max(2), 2);
  32     assert_eq!(2.max(1), 2);
  33     assert_eq!(1.min(2), 1);
  34     assert_eq!(2.min(1), 1);
  35     assert_eq!(1.max(1), 1);
  36     assert_eq!(1.min(1), 1);
  37 }
  38
  39 #[test]
  40 fn test_ord_min_max_by() {
  41     let f = |x: &i32, y: &i32| x.abs().cmp(&y.abs());
  42     assert_eq!(cmp::min_by(1, -1, f), 1);
  43     assert_eq!(cmp::min_by(1, -2, f), 1);
  44     assert_eq!(cmp::min_by(2, -1, f), -1);
  45     assert_eq!(cmp::max_by(1, -1, f), -1);
  46     assert_eq!(cmp::max_by(1, -2, f), -2);
  47     assert_eq!(cmp::max_by(2, -1, f), 2);
  48 }
  49
  50 #[test]
  51 fn test_ord_min_max_by_key() {
  52     let f = |x: &i32| x.abs();
  53     assert_eq!(cmp::min_by_key(1, -1, f), 1);
  54     assert_eq!(cmp::min_by_key(1, -2, f), 1);
  55     assert_eq!(cmp::min_by_key(2, -1, f), -1);
  56     assert_eq!(cmp::max_by_key(1, -1, f), -1);
  57     assert_eq!(cmp::max_by_key(1, -2, f), -2);
  58     assert_eq!(cmp::max_by_key(2, -1, f), 2);
  59 }
  60
  61 #[test]
  62 fn test_ordering_reverse() {
  63     assert_eq!(Less.reverse(), Greater);
  64     assert_eq!(Equal.reverse(), Equal);
  65     assert_eq!(Greater.reverse(), Less);
  66 }
  67
  68 #[test]
  69 fn test_ordering_order() {
  70     assert!(Less < Equal);
  71     assert_eq!(Greater.cmp(&Less), Greater);
  72 }
  73
  74 #[test]
  75 fn test_ordering_then() {
  76     assert_eq!(Equal.then(Less), Less);
  77     assert_eq!(Equal.then(Equal), Equal);
  78     assert_eq!(Equal.then(Greater), Greater);
  79     assert_eq!(Less.then(Less), Less);
  80     assert_eq!(Less.then(Equal), Less);
  81     assert_eq!(Less.then(Greater), Less);
  82     assert_eq!(Greater.then(Less), Greater);
  83     assert_eq!(Greater.then(Equal), Greater);
  84     assert_eq!(Greater.then(Greater), Greater);
  85 }
  86
  87 #[test]
  88 fn test_ordering_then_with() {
  89     assert_eq!(Equal.then_with(|| Less), Less);
  90     assert_eq!(Equal.then_with(|| Equal), Equal);
  91     assert_eq!(Equal.then_with(|| Greater), Greater);
  92     assert_eq!(Less.then_with(|| Less), Less);
  93     assert_eq!(Less.then_with(|| Equal), Less);
  94     assert_eq!(Less.then_with(|| Greater), Less);
  95     assert_eq!(Greater.then_with(|| Less), Greater);
  96     assert_eq!(Greater.then_with(|| Equal), Greater);
  97     assert_eq!(Greater.then_with(|| Greater), Greater);
  98 }
  99
 100 #[test]
 101 fn test_user_defined_eq() {
 102     // Our type.
 103     struct SketchyNum {
 104         num: isize,
 105     }
 106
 107     // Our implementation of `PartialEq` to support `==` and `!=`.
 108     impl PartialEq for SketchyNum {
 109         // Our custom eq allows numbers which are near each other to be equal! :D
 110         fn eq(&self, other: &SketchyNum) -> bool {
 111             (self.num - other.num).abs() < 5
 112         }
 113     }
 114
 115     // Now these binary operators will work when applied!
 116     assert!(SketchyNum { num: 37 } == SketchyNum { num: 34 });
 117     assert!(SketchyNum { num: 25 } != SketchyNum { num: 57 });
 118 }