src/librustc_data_structures/sip128.rs

   1 // Copyright 2012-2015 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 //! This is a copy of `core::hash::sip` adapted to providing 128 bit hashes.
  12
  13 use std::cmp;
  14 use std::hash::Hasher;
  15 use std::slice;
  16 use std::ptr;
  17 use std::mem;
  18
  19 #[derive(Debug, Clone)]
  20 pub struct SipHasher128 {
  21     k0: u64,
  22     k1: u64,
  23     length: usize, // how many bytes we've processed
  24     state: State, // hash State
  25     tail: u64, // unprocessed bytes le
  26     ntail: usize, // how many bytes in tail are valid
  27 }
  28
  29 #[derive(Debug, Clone, Copy)]
  30 #[repr(C)]
  31 struct State {
  32     // v0, v2 and v1, v3 show up in pairs in the algorithm,
  33     // and simd implementations of SipHash will use vectors
  34     // of v02 and v13. By placing them in this order in the struct,
  35     // the compiler can pick up on just a few simd optimizations by itself.
  36     v0: u64,
  37     v2: u64,
  38     v1: u64,
  39     v3: u64,
  40 }
  41
  42 macro_rules! compress {
  43     ($state:expr) => ({
  44         compress!($state.v0, $state.v1, $state.v2, $state.v3)
  45     });
  46     ($v0:expr, $v1:expr, $v2:expr, $v3:expr) =>
  47     ({
  48         $v0 = $v0.wrapping_add($v1); $v1 = $v1.rotate_left(13); $v1 ^= $v0;
  49         $v0 = $v0.rotate_left(32);
  50         $v2 = $v2.wrapping_add($v3); $v3 = $v3.rotate_left(16); $v3 ^= $v2;
  51         $v0 = $v0.wrapping_add($v3); $v3 = $v3.rotate_left(21); $v3 ^= $v0;
  52         $v2 = $v2.wrapping_add($v1); $v1 = $v1.rotate_left(17); $v1 ^= $v2;
  53         $v2 = $v2.rotate_left(32);
  54     });
  55 }
  56
  57 /// Load an integer of the desired type from a byte stream, in LE order. Uses
  58 /// `copy_nonoverlapping` to let the compiler generate the most efficient way
  59 /// to load it from a possibly unaligned address.
  60 ///
  61 /// Unsafe because: unchecked indexing at i..i+size_of(int_ty)
  62 macro_rules! load_int_le {
  63     ($buf:expr, $i:expr, $int_ty:ident) =>
  64     ({
  65        debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());
  66        let mut data = 0 as $int_ty;
  67        ptr::copy_nonoverlapping($buf.get_unchecked($i),
  68                                 &mut data as *mut _ as *mut u8,
  69                                 mem::size_of::<$int_ty>());
  70        data.to_le()
  71     });
  72 }
  73
  74 /// Load an u64 using up to 7 bytes of a byte slice.
  75 ///
  76 /// Unsafe because: unchecked indexing at start..start+len
  77 #[inline]
  78 unsafe fn u8to64_le(buf: &[u8], start: usize, len: usize) -> u64 {
  79     debug_assert!(len < 8);
  80     let mut i = 0; // current byte index (from LSB) in the output u64
  81     let mut out = 0;
  82     if i + 3 < len {
  83         out = load_int_le!(buf, start + i, u32) as u64;
  84         i += 4;
  85     }
  86     if i + 1 < len {
  87         out |= (load_int_le!(buf, start + i, u16) as u64) << (i * 8);
  88         i += 2
  89     }
  90     if i < len {
  91         out |= (*buf.get_unchecked(start + i) as u64) << (i * 8);
  92         i += 1;
  93     }
  94     debug_assert_eq!(i, len);
  95     out
  96 }
  97
  98
  99 impl SipHasher128 {
 100     #[inline]
 101     pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher128 {
 102         let mut state = SipHasher128 {
 103             k0: key0,
 104             k1: key1,
 105             length: 0,
 106             state: State {
 107                 v0: 0,
 108                 v1: 0,
 109                 v2: 0,
 110                 v3: 0,
 111             },
 112             tail: 0,
 113             ntail: 0,
 114         };
 115         state.reset();
 116         state
 117     }
 118
 119     #[inline]
 120     fn reset(&mut self) {
 121         self.length = 0;
 122         self.state.v0 = self.k0 ^ 0x736f6d6570736575;
 123         self.state.v1 = self.k1 ^ 0x646f72616e646f6d;
 124         self.state.v2 = self.k0 ^ 0x6c7967656e657261;
 125         self.state.v3 = self.k1 ^ 0x7465646279746573;
 126         self.ntail = 0;
 127
 128         // This is only done in the 128 bit version:
 129         self.state.v1 ^= 0xee;
 130     }
 131
 132     // Specialized write function that is only valid for buffers with len <= 8.
 133     // It's used to force inlining of write_u8 and write_usize, those would normally be inlined
 134     // except for composite types (that includes slices and str hashing because of delimiter).
 135     // Without this extra push the compiler is very reluctant to inline delimiter writes,
 136     // degrading performance substantially for the most common use cases.
 137     #[inline]
 138     fn short_write(&mut self, msg: &[u8]) {
 139         debug_assert!(msg.len() <= 8);
 140         let length = msg.len();
 141         self.length += length;
 142
 143         let needed = 8 - self.ntail;
 144         let fill = cmp::min(length, needed);
 145         if fill == 8 {
 146             self.tail = unsafe { load_int_le!(msg, 0, u64) };
 147         } else {
 148             self.tail |= unsafe { u8to64_le(msg, 0, fill) } << (8 * self.ntail);
 149             if length < needed {
 150                 self.ntail += length;
 151                 return;
 152             }
 153         }
 154         self.state.v3 ^= self.tail;
 155         Sip24Rounds::c_rounds(&mut self.state);
 156         self.state.v0 ^= self.tail;
 157
 158         // Buffered tail is now flushed, process new input.
 159         self.ntail = length - needed;
 160         self.tail = unsafe { u8to64_le(msg, needed, self.ntail) };
 161     }
 162
 163     #[inline(always)]
 164     fn short_write_gen<T>(&mut self, x: T) {
 165         let bytes = unsafe {
 166             slice::from_raw_parts(&x as *const T as *const u8, mem::size_of::<T>())
 167         };
 168         self.short_write(bytes);
 169     }
 170
 171     #[inline]
 172     pub fn finish128(mut self) -> (u64, u64) {
 173         let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail;
 174
 175         self.state.v3 ^= b;
 176         Sip24Rounds::c_rounds(&mut self.state);
 177         self.state.v0 ^= b;
 178
 179         self.state.v2 ^= 0xee;
 180         Sip24Rounds::d_rounds(&mut self.state);
 181         let _0 = self.state.v0 ^ self.state.v1 ^ self.state.v2 ^ self.state.v3;
 182
 183         self.state.v1 ^= 0xdd;
 184         Sip24Rounds::d_rounds(&mut self.state);
 185         let _1 = self.state.v0 ^ self.state.v1 ^ self.state.v2 ^ self.state.v3;
 186         (_0, _1)
 187     }
 188 }
 189
 190 impl Hasher for SipHasher128 {
 191     #[inline]
 192     fn write_u8(&mut self, i: u8) {
 193         self.short_write_gen(i);
 194     }
 195
 196     #[inline]
 197     fn write_u16(&mut self, i: u16) {
 198         self.short_write_gen(i);
 199     }
 200
 201     #[inline]
 202     fn write_u32(&mut self, i: u32) {
 203         self.short_write_gen(i);
 204     }
 205
 206     #[inline]
 207     fn write_u64(&mut self, i: u64) {
 208         self.short_write_gen(i);
 209     }
 210
 211     #[inline]
 212     fn write_usize(&mut self, i: usize) {
 213         self.short_write_gen(i);
 214     }
 215
 216     #[inline]
 217     fn write_i8(&mut self, i: i8) {
 218         self.short_write_gen(i);
 219     }
 220
 221     #[inline]
 222     fn write_i16(&mut self, i: i16) {
 223         self.short_write_gen(i);
 224     }
 225
 226     #[inline]
 227     fn write_i32(&mut self, i: i32) {
 228         self.short_write_gen(i);
 229     }
 230
 231     #[inline]
 232     fn write_i64(&mut self, i: i64) {
 233         self.short_write_gen(i);
 234     }
 235
 236     #[inline]
 237     fn write_isize(&mut self, i: isize) {
 238         self.short_write_gen(i);
 239     }
 240
 241     #[inline]
 242     fn write(&mut self, msg: &[u8]) {
 243         let length = msg.len();
 244         self.length += length;
 245
 246         let mut needed = 0;
 247
 248         if self.ntail != 0 {
 249             needed = 8 - self.ntail;
 250             self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << 8 * self.ntail;
 251             if length < needed {
 252                 self.ntail += length;
 253                 return
 254             } else {
 255                 self.state.v3 ^= self.tail;
 256                 Sip24Rounds::c_rounds(&mut self.state);
 257                 self.state.v0 ^= self.tail;
 258                 self.ntail = 0;
 259             }
 260         }
 261
 262         // Buffered tail is now flushed, process new input.
 263         let len = length - needed;
 264         let left = len & 0x7;
 265
 266         let mut i = needed;
 267         while i < len - left {
 268             let mi = unsafe { load_int_le!(msg, i, u64) };
 269
 270             self.state.v3 ^= mi;
 271             Sip24Rounds::c_rounds(&mut self.state);
 272             self.state.v0 ^= mi;
 273
 274             i += 8;
 275         }
 276
 277         self.tail = unsafe { u8to64_le(msg, i, left) };
 278         self.ntail = left;
 279     }
 280
 281     fn finish(&self) -> u64 {
 282         panic!("SipHasher128 cannot provide valid 64 bit hashes")
 283     }
 284 }
 285
 286 #[derive(Debug, Clone, Default)]
 287 struct Sip24Rounds;
 288
 289 impl Sip24Rounds {
 290     #[inline]
 291     fn c_rounds(state: &mut State) {
 292         compress!(state);
 293         compress!(state);
 294     }
 295
 296     #[inline]
 297     fn d_rounds(state: &mut State) {
 298         compress!(state);
 299         compress!(state);
 300         compress!(state);
 301         compress!(state);
 302     }
 303 }
 304
 305 #[cfg(test)]
 306 mod test {
 307     use std::hash::{Hash, Hasher};
 308     use std::{slice, mem};
 309     use super::SipHasher128;
 310
 311     // Hash just the bytes of the slice, without length prefix
 312     struct Bytes<'a>(&'a [u8]);
 313
 314     impl<'a> Hash for Bytes<'a> {
 315         #[allow(unused_must_use)]
 316         fn hash<H: Hasher>(&self, state: &mut H) {
 317             for byte in self.0 {
 318                 state.write_u8(*byte);
 319             }
 320         }
 321     }
 322
 323     fn hash_with<T: Hash>(mut st: SipHasher128, x: &T) -> (u64, u64) {
 324         x.hash(&mut st);
 325         st.finish128()
 326     }
 327
 328     fn hash<T: Hash>(x: &T) -> (u64, u64) {
 329         hash_with(SipHasher128::new_with_keys(0, 0), x)
 330     }
 331
 332     const TEST_VECTOR : [[u8; 16]; 64] = [
 333         [0xa3,0x81,0x7f,0x04,0xba,0x25,0xa8,0xe6,0x6d,0xf6,0x72,0x14,0xc7,0x55,0x02,0x93],
 334         [0xda,0x87,0xc1,0xd8,0x6b,0x99,0xaf,0x44,0x34,0x76,0x59,0x11,0x9b,0x22,0xfc,0x45],
 335         [0x81,0x77,0x22,0x8d,0xa4,0xa4,0x5d,0xc7,0xfc,0xa3,0x8b,0xde,0xf6,0x0a,0xff,0xe4],
 336         [0x9c,0x70,0xb6,0x0c,0x52,0x67,0xa9,0x4e,0x5f,0x33,0xb6,0xb0,0x29,0x85,0xed,0x51],
 337         [0xf8,0x81,0x64,0xc1,0x2d,0x9c,0x8f,0xaf,0x7d,0x0f,0x6e,0x7c,0x7b,0xcd,0x55,0x79],
 338         [0x13,0x68,0x87,0x59,0x80,0x77,0x6f,0x88,0x54,0x52,0x7a,0x07,0x69,0x0e,0x96,0x27],
 339         [0x14,0xee,0xca,0x33,0x8b,0x20,0x86,0x13,0x48,0x5e,0xa0,0x30,0x8f,0xd7,0xa1,0x5e],
 340         [0xa1,0xf1,0xeb,0xbe,0xd8,0xdb,0xc1,0x53,0xc0,0xb8,0x4a,0xa6,0x1f,0xf0,0x82,0x39],
 341         [0x3b,0x62,0xa9,0xba,0x62,0x58,0xf5,0x61,0x0f,0x83,0xe2,0x64,0xf3,0x14,0x97,0xb4],
 342         [0x26,0x44,0x99,0x06,0x0a,0xd9,0xba,0xab,0xc4,0x7f,0x8b,0x02,0xbb,0x6d,0x71,0xed],
 343         [0x00,0x11,0x0d,0xc3,0x78,0x14,0x69,0x56,0xc9,0x54,0x47,0xd3,0xf3,0xd0,0xfb,0xba],
 344         [0x01,0x51,0xc5,0x68,0x38,0x6b,0x66,0x77,0xa2,0xb4,0xdc,0x6f,0x81,0xe5,0xdc,0x18],
 345         [0xd6,0x26,0xb2,0x66,0x90,0x5e,0xf3,0x58,0x82,0x63,0x4d,0xf6,0x85,0x32,0xc1,0x25],
 346         [0x98,0x69,0xe2,0x47,0xe9,0xc0,0x8b,0x10,0xd0,0x29,0x93,0x4f,0xc4,0xb9,0x52,0xf7],
 347         [0x31,0xfc,0xef,0xac,0x66,0xd7,0xde,0x9c,0x7e,0xc7,0x48,0x5f,0xe4,0x49,0x49,0x02],
 348         [0x54,0x93,0xe9,0x99,0x33,0xb0,0xa8,0x11,0x7e,0x08,0xec,0x0f,0x97,0xcf,0xc3,0xd9],
 349         [0x6e,0xe2,0xa4,0xca,0x67,0xb0,0x54,0xbb,0xfd,0x33,0x15,0xbf,0x85,0x23,0x05,0x77],
 350         [0x47,0x3d,0x06,0xe8,0x73,0x8d,0xb8,0x98,0x54,0xc0,0x66,0xc4,0x7a,0xe4,0x77,0x40],
 351         [0xa4,0x26,0xe5,0xe4,0x23,0xbf,0x48,0x85,0x29,0x4d,0xa4,0x81,0xfe,0xae,0xf7,0x23],
 352         [0x78,0x01,0x77,0x31,0xcf,0x65,0xfa,0xb0,0x74,0xd5,0x20,0x89,0x52,0x51,0x2e,0xb1],
 353         [0x9e,0x25,0xfc,0x83,0x3f,0x22,0x90,0x73,0x3e,0x93,0x44,0xa5,0xe8,0x38,0x39,0xeb],
 354         [0x56,0x8e,0x49,0x5a,0xbe,0x52,0x5a,0x21,0x8a,0x22,0x14,0xcd,0x3e,0x07,0x1d,0x12],
 355         [0x4a,0x29,0xb5,0x45,0x52,0xd1,0x6b,0x9a,0x46,0x9c,0x10,0x52,0x8e,0xff,0x0a,0xae],
 356         [0xc9,0xd1,0x84,0xdd,0xd5,0xa9,0xf5,0xe0,0xcf,0x8c,0xe2,0x9a,0x9a,0xbf,0x69,0x1c],
 357         [0x2d,0xb4,0x79,0xae,0x78,0xbd,0x50,0xd8,0x88,0x2a,0x8a,0x17,0x8a,0x61,0x32,0xad],
 358         [0x8e,0xce,0x5f,0x04,0x2d,0x5e,0x44,0x7b,0x50,0x51,0xb9,0xea,0xcb,0x8d,0x8f,0x6f],
 359         [0x9c,0x0b,0x53,0xb4,0xb3,0xc3,0x07,0xe8,0x7e,0xae,0xe0,0x86,0x78,0x14,0x1f,0x66],
 360         [0xab,0xf2,0x48,0xaf,0x69,0xa6,0xea,0xe4,0xbf,0xd3,0xeb,0x2f,0x12,0x9e,0xeb,0x94],
 361         [0x06,0x64,0xda,0x16,0x68,0x57,0x4b,0x88,0xb9,0x35,0xf3,0x02,0x73,0x58,0xae,0xf4],
 362         [0xaa,0x4b,0x9d,0xc4,0xbf,0x33,0x7d,0xe9,0x0c,0xd4,0xfd,0x3c,0x46,0x7c,0x6a,0xb7],
 363         [0xea,0x5c,0x7f,0x47,0x1f,0xaf,0x6b,0xde,0x2b,0x1a,0xd7,0xd4,0x68,0x6d,0x22,0x87],
 364         [0x29,0x39,0xb0,0x18,0x32,0x23,0xfa,0xfc,0x17,0x23,0xde,0x4f,0x52,0xc4,0x3d,0x35],
 365         [0x7c,0x39,0x56,0xca,0x5e,0xea,0xfc,0x3e,0x36,0x3e,0x9d,0x55,0x65,0x46,0xeb,0x68],
 366         [0x77,0xc6,0x07,0x71,0x46,0xf0,0x1c,0x32,0xb6,0xb6,0x9d,0x5f,0x4e,0xa9,0xff,0xcf],
 367         [0x37,0xa6,0x98,0x6c,0xb8,0x84,0x7e,0xdf,0x09,0x25,0xf0,0xf1,0x30,0x9b,0x54,0xde],
 368         [0xa7,0x05,0xf0,0xe6,0x9d,0xa9,0xa8,0xf9,0x07,0x24,0x1a,0x2e,0x92,0x3c,0x8c,0xc8],
 369         [0x3d,0xc4,0x7d,0x1f,0x29,0xc4,0x48,0x46,0x1e,0x9e,0x76,0xed,0x90,0x4f,0x67,0x11],
 370         [0x0d,0x62,0xbf,0x01,0xe6,0xfc,0x0e,0x1a,0x0d,0x3c,0x47,0x51,0xc5,0xd3,0x69,0x2b],
 371         [0x8c,0x03,0x46,0x8b,0xca,0x7c,0x66,0x9e,0xe4,0xfd,0x5e,0x08,0x4b,0xbe,0xe7,0xb5],
 372         [0x52,0x8a,0x5b,0xb9,0x3b,0xaf,0x2c,0x9c,0x44,0x73,0xcc,0xe5,0xd0,0xd2,0x2b,0xd9],
 373         [0xdf,0x6a,0x30,0x1e,0x95,0xc9,0x5d,0xad,0x97,0xae,0x0c,0xc8,0xc6,0x91,0x3b,0xd8],
 374         [0x80,0x11,0x89,0x90,0x2c,0x85,0x7f,0x39,0xe7,0x35,0x91,0x28,0x5e,0x70,0xb6,0xdb],
 375         [0xe6,0x17,0x34,0x6a,0xc9,0xc2,0x31,0xbb,0x36,0x50,0xae,0x34,0xcc,0xca,0x0c,0x5b],
 376         [0x27,0xd9,0x34,0x37,0xef,0xb7,0x21,0xaa,0x40,0x18,0x21,0xdc,0xec,0x5a,0xdf,0x89],
 377         [0x89,0x23,0x7d,0x9d,0xed,0x9c,0x5e,0x78,0xd8,0xb1,0xc9,0xb1,0x66,0xcc,0x73,0x42],
 378         [0x4a,0x6d,0x80,0x91,0xbf,0x5e,0x7d,0x65,0x11,0x89,0xfa,0x94,0xa2,0x50,0xb1,0x4c],
 379         [0x0e,0x33,0xf9,0x60,0x55,0xe7,0xae,0x89,0x3f,0xfc,0x0e,0x3d,0xcf,0x49,0x29,0x02],
 380         [0xe6,0x1c,0x43,0x2b,0x72,0x0b,0x19,0xd1,0x8e,0xc8,0xd8,0x4b,0xdc,0x63,0x15,0x1b],
 381         [0xf7,0xe5,0xae,0xf5,0x49,0xf7,0x82,0xcf,0x37,0x90,0x55,0xa6,0x08,0x26,0x9b,0x16],
 382         [0x43,0x8d,0x03,0x0f,0xd0,0xb7,0xa5,0x4f,0xa8,0x37,0xf2,0xad,0x20,0x1a,0x64,0x03],
 383         [0xa5,0x90,0xd3,0xee,0x4f,0xbf,0x04,0xe3,0x24,0x7e,0x0d,0x27,0xf2,0x86,0x42,0x3f],
 384         [0x5f,0xe2,0xc1,0xa1,0x72,0xfe,0x93,0xc4,0xb1,0x5c,0xd3,0x7c,0xae,0xf9,0xf5,0x38],
 385         [0x2c,0x97,0x32,0x5c,0xbd,0x06,0xb3,0x6e,0xb2,0x13,0x3d,0xd0,0x8b,0x3a,0x01,0x7c],
 386         [0x92,0xc8,0x14,0x22,0x7a,0x6b,0xca,0x94,0x9f,0xf0,0x65,0x9f,0x00,0x2a,0xd3,0x9e],
 387         [0xdc,0xe8,0x50,0x11,0x0b,0xd8,0x32,0x8c,0xfb,0xd5,0x08,0x41,0xd6,0x91,0x1d,0x87],
 388         [0x67,0xf1,0x49,0x84,0xc7,0xda,0x79,0x12,0x48,0xe3,0x2b,0xb5,0x92,0x25,0x83,0xda],
 389         [0x19,0x38,0xf2,0xcf,0x72,0xd5,0x4e,0xe9,0x7e,0x94,0x16,0x6f,0xa9,0x1d,0x2a,0x36],
 390         [0x74,0x48,0x1e,0x96,0x46,0xed,0x49,0xfe,0x0f,0x62,0x24,0x30,0x16,0x04,0x69,0x8e],
 391         [0x57,0xfc,0xa5,0xde,0x98,0xa9,0xd6,0xd8,0x00,0x64,0x38,0xd0,0x58,0x3d,0x8a,0x1d],
 392         [0x9f,0xec,0xde,0x1c,0xef,0xdc,0x1c,0xbe,0xd4,0x76,0x36,0x74,0xd9,0x57,0x53,0x59],
 393         [0xe3,0x04,0x0c,0x00,0xeb,0x28,0xf1,0x53,0x66,0xca,0x73,0xcb,0xd8,0x72,0xe7,0x40],
 394         [0x76,0x97,0x00,0x9a,0x6a,0x83,0x1d,0xfe,0xcc,0xa9,0x1c,0x59,0x93,0x67,0x0f,0x7a],
 395         [0x58,0x53,0x54,0x23,0x21,0xf5,0x67,0xa0,0x05,0xd5,0x47,0xa4,0xf0,0x47,0x59,0xbd],
 396         [0x51,0x50,0xd1,0x77,0x2f,0x50,0x83,0x4a,0x50,0x3e,0x06,0x9a,0x97,0x3f,0xbd,0x7c],
 397     ];
 398
 399     // Test vector from reference implementation
 400     #[test]
 401     fn test_siphash_2_4_test_vector() {
 402         let k0 = 0x_07_06_05_04_03_02_01_00;
 403         let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
 404
 405         let mut input: Vec<u8> = Vec::new();
 406
 407         for i in 0 .. 64 {
 408             let out = hash_with(SipHasher128::new_with_keys(k0, k1),
 409                                 &Bytes(&input[..]));
 410             let expected = (
 411                 ((TEST_VECTOR[i][0] as u64) <<  0) |
 412                 ((TEST_VECTOR[i][1] as u64) <<  8) |
 413                 ((TEST_VECTOR[i][2] as u64) << 16) |
 414                 ((TEST_VECTOR[i][3] as u64) << 24) |
 415                 ((TEST_VECTOR[i][4] as u64) << 32) |
 416                 ((TEST_VECTOR[i][5] as u64) << 40) |
 417                 ((TEST_VECTOR[i][6] as u64) << 48) |
 418                 ((TEST_VECTOR[i][7] as u64) << 56),
 419
 420                 ((TEST_VECTOR[i][8] as u64) <<  0) |
 421                 ((TEST_VECTOR[i][9] as u64) <<  8) |
 422                 ((TEST_VECTOR[i][10] as u64) << 16) |
 423                 ((TEST_VECTOR[i][11] as u64) << 24) |
 424                 ((TEST_VECTOR[i][12] as u64) << 32) |
 425                 ((TEST_VECTOR[i][13] as u64) << 40) |
 426                 ((TEST_VECTOR[i][14] as u64) << 48) |
 427                 ((TEST_VECTOR[i][15] as u64) << 56),
 428             );
 429
 430             assert_eq!(out, expected);
 431             input.push(i as u8);
 432         }
 433     }
 434
 435     #[test] #[cfg(target_arch = "arm")]
 436     fn test_hash_usize() {
 437         let val = 0xdeadbeef_deadbeef_u64;
 438         assert!(hash(&(val as u64)) != hash(&(val as usize)));
 439         assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
 440     }
 441     #[test] #[cfg(target_arch = "x86_64")]
 442     fn test_hash_usize() {
 443         let val = 0xdeadbeef_deadbeef_u64;
 444         assert_eq!(hash(&(val as u64)), hash(&(val as usize)));
 445         assert!(hash(&(val as u32)) != hash(&(val as usize)));
 446     }
 447     #[test] #[cfg(target_arch = "x86")]
 448     fn test_hash_usize() {
 449         let val = 0xdeadbeef_deadbeef_u64;
 450         assert!(hash(&(val as u64)) != hash(&(val as usize)));
 451         assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
 452     }
 453
 454     #[test]
 455     fn test_hash_idempotent() {
 456         let val64 = 0xdeadbeef_deadbeef_u64;
 457         assert_eq!(hash(&val64), hash(&val64));
 458         let val32 = 0xdeadbeef_u32;
 459         assert_eq!(hash(&val32), hash(&val32));
 460     }
 461
 462     #[test]
 463     fn test_hash_no_bytes_dropped_64() {
 464         let val = 0xdeadbeef_deadbeef_u64;
 465
 466         assert!(hash(&val) != hash(&zero_byte(val, 0)));
 467         assert!(hash(&val) != hash(&zero_byte(val, 1)));
 468         assert!(hash(&val) != hash(&zero_byte(val, 2)));
 469         assert!(hash(&val) != hash(&zero_byte(val, 3)));
 470         assert!(hash(&val) != hash(&zero_byte(val, 4)));
 471         assert!(hash(&val) != hash(&zero_byte(val, 5)));
 472         assert!(hash(&val) != hash(&zero_byte(val, 6)));
 473         assert!(hash(&val) != hash(&zero_byte(val, 7)));
 474
 475         fn zero_byte(val: u64, byte: usize) -> u64 {
 476             assert!(byte < 8);
 477             val & !(0xff << (byte * 8))
 478         }
 479     }
 480
 481     #[test]
 482     fn test_hash_no_bytes_dropped_32() {
 483         let val = 0xdeadbeef_u32;
 484
 485         assert!(hash(&val) != hash(&zero_byte(val, 0)));
 486         assert!(hash(&val) != hash(&zero_byte(val, 1)));
 487         assert!(hash(&val) != hash(&zero_byte(val, 2)));
 488         assert!(hash(&val) != hash(&zero_byte(val, 3)));
 489
 490         fn zero_byte(val: u32, byte: usize) -> u32 {
 491             assert!(byte < 4);
 492             val & !(0xff << (byte * 8))
 493         }
 494     }
 495
 496     #[test]
 497     fn test_hash_no_concat_alias() {
 498         let s = ("aa", "bb");
 499         let t = ("aabb", "");
 500         let u = ("a", "abb");
 501
 502         assert!(s != t && t != u);
 503         assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
 504
 505         let u = [1, 0, 0, 0];
 506         let v = (&u[..1], &u[1..3], &u[3..]);
 507         let w = (&u[..], &u[4..4], &u[4..4]);
 508
 509         assert!(v != w);
 510         assert!(hash(&v) != hash(&w));
 511     }
 512
 513     #[test]
 514     fn test_write_short_works() {
 515         let test_usize = 0xd0c0b0a0usize;
 516         let mut h1 = SipHasher128::new_with_keys(0, 0);
 517         h1.write_usize(test_usize);
 518         h1.write(b"bytes");
 519         h1.write(b"string");
 520         h1.write_u8(0xFFu8);
 521         h1.write_u8(0x01u8);
 522         let mut h2 = SipHasher128::new_with_keys(0, 0);
 523         h2.write(unsafe {
 524             slice::from_raw_parts(&test_usize as *const _ as *const u8,
 525                                   mem::size_of::<usize>())
 526         });
 527         h2.write(b"bytes");
 528         h2.write(b"string");
 529         h2.write(&[0xFFu8, 0x01u8]);
 530         assert_eq!(h1.finish128(), h2.finish128());
 531     }
 532
 533 }