tests/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();
  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 struct OnlyOneByteHasher;
  48 impl Hasher for OnlyOneByteHasher {
  49     fn finish(&self) -> u64 {
  50         unreachable!()
  51     }
  52
  53     fn write(&mut self, bytes: &[u8]) {
  54         assert_eq!(bytes.len(), 1);
  55     }
  56 }
  57
  58 fn main() {
  59     let person1 = Person {
  60         id: 5,
  61         name: "Janet".to_string(),
  62         phone: 555_666_7777
  63     };
  64     let person2 = Person {
  65         id: 5,
  66         name: "Bob".to_string(),
  67         phone: 555_666_7777
  68     };
  69     assert_eq!(hash(&person1), hash(&person1));
  70     assert!(hash(&person1) != hash(&person2));
  71
  72     // test #21714
  73     let mut va = vec![];
  74     let mut vb = vec![];
  75     fake_hash(&mut va, E::A);
  76     fake_hash(&mut vb, E::B);
  77     assert!(va != vb);
  78
  79     // issue #39137: single variant enum hash should not hash discriminant
  80     #[derive(Hash)]
  81     enum SingleVariantEnum {
  82         A(u8),
  83     }
  84     let mut v = vec![];
  85     fake_hash(&mut v, SingleVariantEnum::A(17));
  86     assert_eq!(vec![17], v);
  87
  88     // issue #39137
  89     #[repr(u8)]
  90     #[derive(Hash)]
  91     enum E {
  92         A,
  93         B,
  94     }
  95     E::A.hash(&mut OnlyOneByteHasher);
  96 }