src/libcollectionstest/enum_set.rs

   1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use std::mem;
  12
  13 use collections::enum_set::{CLike, EnumSet};
  14
  15 use self::Foo::*;
  16
  17 #[derive(Copy, Clone, PartialEq, Debug)]
  18 #[repr(usize)]
  19 enum Foo {
  20     A, B, C
  21 }
  22
  23 impl CLike for Foo {
  24     fn to_usize(&self) -> usize {
  25         *self as usize
  26     }
  27
  28     fn from_usize(v: usize) -> Foo {
  29         unsafe { mem::transmute(v) }
  30     }
  31 }
  32
  33 #[test]
  34 fn test_new() {
  35     let e: EnumSet<Foo> = EnumSet::new();
  36     assert!(e.is_empty());
  37 }
  38
  39 #[test]
  40 fn test_show() {
  41     let mut e = EnumSet::new();
  42     assert!(format!("{:?}", e) == "{}");
  43     e.insert(A);
  44     assert!(format!("{:?}", e) == "{A}");
  45     e.insert(C);
  46     assert!(format!("{:?}", e) == "{A, C}");
  47 }
  48
  49 #[test]
  50 fn test_len() {
  51     let mut e = EnumSet::new();
  52     assert_eq!(e.len(), 0);
  53     e.insert(A);
  54     e.insert(B);
  55     e.insert(C);
  56     assert_eq!(e.len(), 3);
  57     e.remove(&A);
  58     assert_eq!(e.len(), 2);
  59     e.clear();
  60     assert_eq!(e.len(), 0);
  61 }
  62
  63 ///////////////////////////////////////////////////////////////////////////
  64 // intersect
  65
  66 #[test]
  67 fn test_two_empties_do_not_intersect() {
  68     let e1: EnumSet<Foo> = EnumSet::new();
  69     let e2: EnumSet<Foo> = EnumSet::new();
  70     assert!(e1.is_disjoint(&e2));
  71 }
  72
  73 #[test]
  74 fn test_empty_does_not_intersect_with_full() {
  75     let e1: EnumSet<Foo> = EnumSet::new();
  76
  77     let mut e2: EnumSet<Foo> = EnumSet::new();
  78     e2.insert(A);
  79     e2.insert(B);
  80     e2.insert(C);
  81
  82     assert!(e1.is_disjoint(&e2));
  83 }
  84
  85 #[test]
  86 fn test_disjoint_intersects() {
  87     let mut e1: EnumSet<Foo> = EnumSet::new();
  88     e1.insert(A);
  89
  90     let mut e2: EnumSet<Foo> = EnumSet::new();
  91     e2.insert(B);
  92
  93     assert!(e1.is_disjoint(&e2));
  94 }
  95
  96 #[test]
  97 fn test_overlapping_intersects() {
  98     let mut e1: EnumSet<Foo> = EnumSet::new();
  99     e1.insert(A);
 100
 101     let mut e2: EnumSet<Foo> = EnumSet::new();
 102     e2.insert(A);
 103     e2.insert(B);
 104
 105     assert!(!e1.is_disjoint(&e2));
 106 }
 107
 108 ///////////////////////////////////////////////////////////////////////////
 109 // contains and contains_elem
 110
 111 #[test]
 112 fn test_superset() {
 113     let mut e1: EnumSet<Foo> = EnumSet::new();
 114     e1.insert(A);
 115
 116     let mut e2: EnumSet<Foo> = EnumSet::new();
 117     e2.insert(A);
 118     e2.insert(B);
 119
 120     let mut e3: EnumSet<Foo> = EnumSet::new();
 121     e3.insert(C);
 122
 123     assert!(e1.is_subset(&e2));
 124     assert!(e2.is_superset(&e1));
 125     assert!(!e3.is_superset(&e2));
 126     assert!(!e2.is_superset(&e3))
 127 }
 128
 129 #[test]
 130 fn test_contains() {
 131     let mut e1: EnumSet<Foo> = EnumSet::new();
 132     e1.insert(A);
 133     assert!(e1.contains(&A));
 134     assert!(!e1.contains(&B));
 135     assert!(!e1.contains(&C));
 136
 137     e1.insert(A);
 138     e1.insert(B);
 139     assert!(e1.contains(&A));
 140     assert!(e1.contains(&B));
 141     assert!(!e1.contains(&C));
 142 }
 143
 144 ///////////////////////////////////////////////////////////////////////////
 145 // iter
 146
 147 #[test]
 148 fn test_iterator() {
 149     let mut e1: EnumSet<Foo> = EnumSet::new();
 150
 151     let elems: Vec<Foo> = e1.iter().collect();
 152     assert!(elems.is_empty());
 153
 154     e1.insert(A);
 155     let elems: Vec<_> = e1.iter().collect();
 156     assert_eq!(elems, [A]);
 157
 158     e1.insert(C);
 159     let elems: Vec<_> = e1.iter().collect();
 160     assert_eq!(elems, [A,C]);
 161
 162     e1.insert(C);
 163     let elems: Vec<_> = e1.iter().collect();
 164     assert_eq!(elems, [A,C]);
 165
 166     e1.insert(B);
 167     let elems: Vec<_> = e1.iter().collect();
 168     assert_eq!(elems, [A,B,C]);
 169 }
 170
 171 ///////////////////////////////////////////////////////////////////////////
 172 // operators
 173
 174 #[test]
 175 fn test_operators() {
 176     let mut e1: EnumSet<Foo> = EnumSet::new();
 177     e1.insert(A);
 178     e1.insert(C);
 179
 180     let mut e2: EnumSet<Foo> = EnumSet::new();
 181     e2.insert(B);
 182     e2.insert(C);
 183
 184     let e_union = e1 | e2;
 185     let elems: Vec<_> = e_union.iter().collect();
 186     assert_eq!(elems, [A,B,C]);
 187
 188     let e_intersection = e1 & e2;
 189     let elems: Vec<_> = e_intersection.iter().collect();
 190     assert_eq!(elems, [C]);
 191
 192     // Another way to express intersection
 193     let e_intersection = e1 - (e1 - e2);
 194     let elems: Vec<_> = e_intersection.iter().collect();
 195     assert_eq!(elems, [C]);
 196
 197     let e_subtract = e1 - e2;
 198     let elems: Vec<_> = e_subtract.iter().collect();
 199     assert_eq!(elems, [A]);
 200
 201     // Bitwise XOR of two sets, aka symmetric difference
 202     let e_symmetric_diff = e1 ^ e2;
 203     let elems: Vec<_> = e_symmetric_diff.iter().collect();
 204     assert_eq!(elems, [A,B]);
 205
 206     // Another way to express symmetric difference
 207     let e_symmetric_diff = (e1 - e2) | (e2 - e1);
 208     let elems: Vec<_> = e_symmetric_diff.iter().collect();
 209     assert_eq!(elems, [A,B]);
 210
 211     // Yet another way to express symmetric difference
 212     let e_symmetric_diff = (e1 | e2) - (e1 & e2);
 213     let elems: Vec<_> = e_symmetric_diff.iter().collect();
 214     assert_eq!(elems, [A,B]);
 215 }
 216
 217 #[test]
 218 #[should_panic]
 219 fn test_overflow() {
 220     #[allow(dead_code)]
 221     #[derive(Copy, Clone)]
 222     #[repr(usize)]
 223     enum Bar {
 224         V00, V01, V02, V03, V04, V05, V06, V07, V08, V09,
 225         V10, V11, V12, V13, V14, V15, V16, V17, V18, V19,
 226         V20, V21, V22, V23, V24, V25, V26, V27, V28, V29,
 227         V30, V31, V32, V33, V34, V35, V36, V37, V38, V39,
 228         V40, V41, V42, V43, V44, V45, V46, V47, V48, V49,
 229         V50, V51, V52, V53, V54, V55, V56, V57, V58, V59,
 230         V60, V61, V62, V63, V64, V65, V66, V67, V68, V69,
 231     }
 232
 233     impl CLike for Bar {
 234         fn to_usize(&self) -> usize {
 235             *self as usize
 236         }
 237
 238         fn from_usize(v: usize) -> Bar {
 239             unsafe { mem::transmute(v) }
 240         }
 241     }
 242     let mut set = EnumSet::new();
 243     set.insert(Bar::V64);
 244 }
 245
 246 #[test]
 247 fn test_extend_ref() {
 248     let mut a = EnumSet::new();
 249     a.insert(A);
 250
 251     a.extend(&[A, C]);
 252
 253     assert_eq!(a.len(), 2);
 254     assert!(a.contains(&A));
 255     assert!(a.contains(&C));
 256
 257     let mut b = EnumSet::new();
 258     b.insert(B);
 259
 260     a.extend(&b);
 261
 262     assert_eq!(a.len(), 3);
 263     assert!(a.contains(&A));
 264     assert!(a.contains(&B));
 265     assert!(a.contains(&C));
 266 }