src/test/ui/deriving/deriving-hash.rs

   1 // run-pass
   2 #![allow(dead_code)]
   3 #![allow(unused_imports)]
   4 #![allow(deprecated)]
   5 #![allow(non_camel_case_types)]
   6 #![allow(non_snake_case)]
   7 #![allow(overflowing_literals)]
   8
   9 use std::hash::{Hash, SipHasher, Hasher};
  10 use std::mem::size_of;
  11
  12 #[derive(Hash)]
  13 struct Person {
  14     id: usize,
  15     name: String,
  16     phone: usize,
  17 }
  18
  19 // test for hygiene name collisions
  20 #[derive(Hash)] struct __H__H;
  21 #[derive(Hash)] enum Collision<__H> { __H { __H__H: __H } }
  22
  23 #[derive(Hash)]
  24 enum E { A=1, B }
  25
  26 fn hash<T: Hash>(t: &T) -> u64 {
  27     let mut s = SipHasher::new_with_keys(0, 0);
  28     t.hash(&mut s);
  29     s.finish()
  30 }
  31
  32 struct FakeHasher<'a>(&'a mut Vec<u8>);
  33 impl<'a> Hasher for FakeHasher<'a> {
  34     fn finish(&self) -> u64 {
  35         unimplemented!()
  36     }
  37
  38     fn write(&mut self, bytes: &[u8]) {
  39         self.0.extend(bytes);
  40     }
  41 }
  42
  43 fn fake_hash<A: Hash>(v: &mut Vec<u8>, a: A) {
  44     a.hash(&mut FakeHasher(v));
  45 }
  46
  47 fn main() {
  48     let person1 = Person {
  49         id: 5,
  50         name: "Janet".to_string(),
  51         phone: 555_666_7777
  52     };
  53     let person2 = Person {
  54         id: 5,
  55         name: "Bob".to_string(),
  56         phone: 555_666_7777
  57     };
  58     assert_eq!(hash(&person1), hash(&person1));
  59     assert!(hash(&person1) != hash(&person2));
  60
  61     // test #21714
  62     let mut va = vec![];
  63     let mut vb = vec![];
  64     fake_hash(&mut va, E::A);
  65     fake_hash(&mut vb, E::B);
  66     assert!(va != vb);
  67
  68     // issue #39137: single variant enum hash should not hash discriminant
  69     #[derive(Hash)]
  70     enum SingleVariantEnum {
  71         A(u8),
  72     }
  73     let mut v = vec![];
  74     fake_hash(&mut v, SingleVariantEnum::A(17));
  75     assert_eq!(vec![17], v);
  76 }