1// Written in 2012 by Dmitry Chestnykh. 2// 3// To the extent possible under law, the author have dedicated all copyright 4// and related and neighboring rights to this software to the public domain 5// worldwide. This software is distributed without any warranty. 6// http://creativecommons.org/publicdomain/zero/1.0/ 7 8package siphash 9 10import ( 11 "bytes" 12 "encoding/binary" 13 "testing" 14) 15 16var zeroKey = make([]byte, 16) 17 18var golden = []struct { 19 k []byte 20 m []byte 21 r uint64 22}{ 23 { 24 []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f}, 25 []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e}, 26 0xa129ca6149be45e5, 27 }, 28 { 29 zeroKey, 30 []byte("Hello world"), 31 0xc9e8a3021f3822d9, 32 }, 33 { 34 zeroKey, 35 []byte{}, // zero-length message 36 0x1e924b9d737700d7, 37 }, 38 { 39 zeroKey, 40 []byte("12345678123"), 41 0xf95d77ccdb0649f, 42 }, 43 { 44 zeroKey, 45 make([]byte, 8), 46 0xe849e8bb6ffe2567, 47 }, 48 { 49 zeroKey, 50 make([]byte, 1535), 51 0xe74d1c0ab64b2afa, 52 }, 53} 54 55// Test vectors from reference implementation. 56// 57// SipHash-2-4 output with 58// k = 00 01 02 ... 59// and 60// in = (empty string) 61// in = 00 (1 byte) 62// in = 00 01 (2 bytes) 63// in = 00 01 02 (3 bytes) 64// ... 65// in = 00 01 02 ... 3e (63 bytes) 66var goldenRef = [][]byte{ 67 {0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72}, 68 {0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74}, 69 {0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d}, 70 {0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85}, 71 {0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf}, 72 {0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18}, 73 {0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb}, 74 {0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab}, 75 {0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93}, 76 {0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e}, 77 {0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a}, 78 {0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4}, 79 {0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75}, 80 {0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14}, 81 {0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7}, 82 {0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1}, 83 {0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f}, 84 {0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69}, 85 {0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b}, 86 {0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb}, 87 {0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe}, 88 {0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0}, 89 {0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93}, 90 {0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8}, 91 {0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8}, 92 {0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc}, 93 {0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17}, 94 {0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f}, 95 {0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde}, 96 {0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6}, 97 {0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad}, 98 {0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32}, 99 {0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71}, 100 {0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7}, 101 {0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12}, 102 {0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15}, 103 {0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31}, 104 {0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02}, 105 {0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca}, 106 {0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a}, 107 {0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e}, 108 {0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad}, 109 {0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18}, 110 {0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4}, 111 {0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9}, 112 {0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9}, 113 {0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb}, 114 {0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0}, 115 {0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6}, 116 {0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7}, 117 {0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee}, 118 {0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1}, 119 {0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a}, 120 {0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81}, 121 {0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f}, 122 {0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24}, 123 {0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7}, 124 {0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea}, 125 {0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60}, 126 {0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66}, 127 {0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c}, 128 {0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f}, 129 {0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5}, 130 {0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95}, 131} 132 133var goldenRef128 = [][]byte{ 134 {0xa3, 0x81, 0x7f, 0x04, 0xba, 0x25, 0xa8, 0xe6, 0x6d, 0xf6, 0x72, 0x14, 0xc7, 0x55, 0x02, 0x93}, 135 {0xda, 0x87, 0xc1, 0xd8, 0x6b, 0x99, 0xaf, 0x44, 0x34, 0x76, 0x59, 0x11, 0x9b, 0x22, 0xfc, 0x45}, 136 {0x81, 0x77, 0x22, 0x8d, 0xa4, 0xa4, 0x5d, 0xc7, 0xfc, 0xa3, 0x8b, 0xde, 0xf6, 0x0a, 0xff, 0xe4}, 137 {0x9c, 0x70, 0xb6, 0x0c, 0x52, 0x67, 0xa9, 0x4e, 0x5f, 0x33, 0xb6, 0xb0, 0x29, 0x85, 0xed, 0x51}, 138 {0xf8, 0x81, 0x64, 0xc1, 0x2d, 0x9c, 0x8f, 0xaf, 0x7d, 0x0f, 0x6e, 0x7c, 0x7b, 0xcd, 0x55, 0x79}, 139 {0x13, 0x68, 0x87, 0x59, 0x80, 0x77, 0x6f, 0x88, 0x54, 0x52, 0x7a, 0x07, 0x69, 0x0e, 0x96, 0x27}, 140 {0x14, 0xee, 0xca, 0x33, 0x8b, 0x20, 0x86, 0x13, 0x48, 0x5e, 0xa0, 0x30, 0x8f, 0xd7, 0xa1, 0x5e}, 141 {0xa1, 0xf1, 0xeb, 0xbe, 0xd8, 0xdb, 0xc1, 0x53, 0xc0, 0xb8, 0x4a, 0xa6, 0x1f, 0xf0, 0x82, 0x39}, 142 {0x3b, 0x62, 0xa9, 0xba, 0x62, 0x58, 0xf5, 0x61, 0x0f, 0x83, 0xe2, 0x64, 0xf3, 0x14, 0x97, 0xb4}, 143 {0x26, 0x44, 0x99, 0x06, 0x0a, 0xd9, 0xba, 0xab, 0xc4, 0x7f, 0x8b, 0x02, 0xbb, 0x6d, 0x71, 0xed}, 144 {0x00, 0x11, 0x0d, 0xc3, 0x78, 0x14, 0x69, 0x56, 0xc9, 0x54, 0x47, 0xd3, 0xf3, 0xd0, 0xfb, 0xba}, 145 {0x01, 0x51, 0xc5, 0x68, 0x38, 0x6b, 0x66, 0x77, 0xa2, 0xb4, 0xdc, 0x6f, 0x81, 0xe5, 0xdc, 0x18}, 146 {0xd6, 0x26, 0xb2, 0x66, 0x90, 0x5e, 0xf3, 0x58, 0x82, 0x63, 0x4d, 0xf6, 0x85, 0x32, 0xc1, 0x25}, 147 {0x98, 0x69, 0xe2, 0x47, 0xe9, 0xc0, 0x8b, 0x10, 0xd0, 0x29, 0x93, 0x4f, 0xc4, 0xb9, 0x52, 0xf7}, 148 {0x31, 0xfc, 0xef, 0xac, 0x66, 0xd7, 0xde, 0x9c, 0x7e, 0xc7, 0x48, 0x5f, 0xe4, 0x49, 0x49, 0x02}, 149 {0x54, 0x93, 0xe9, 0x99, 0x33, 0xb0, 0xa8, 0x11, 0x7e, 0x08, 0xec, 0x0f, 0x97, 0xcf, 0xc3, 0xd9}, 150 {0x6e, 0xe2, 0xa4, 0xca, 0x67, 0xb0, 0x54, 0xbb, 0xfd, 0x33, 0x15, 0xbf, 0x85, 0x23, 0x05, 0x77}, 151 {0x47, 0x3d, 0x06, 0xe8, 0x73, 0x8d, 0xb8, 0x98, 0x54, 0xc0, 0x66, 0xc4, 0x7a, 0xe4, 0x77, 0x40}, 152 {0xa4, 0x26, 0xe5, 0xe4, 0x23, 0xbf, 0x48, 0x85, 0x29, 0x4d, 0xa4, 0x81, 0xfe, 0xae, 0xf7, 0x23}, 153 {0x78, 0x01, 0x77, 0x31, 0xcf, 0x65, 0xfa, 0xb0, 0x74, 0xd5, 0x20, 0x89, 0x52, 0x51, 0x2e, 0xb1}, 154 {0x9e, 0x25, 0xfc, 0x83, 0x3f, 0x22, 0x90, 0x73, 0x3e, 0x93, 0x44, 0xa5, 0xe8, 0x38, 0x39, 0xeb}, 155 {0x56, 0x8e, 0x49, 0x5a, 0xbe, 0x52, 0x5a, 0x21, 0x8a, 0x22, 0x14, 0xcd, 0x3e, 0x07, 0x1d, 0x12}, 156 {0x4a, 0x29, 0xb5, 0x45, 0x52, 0xd1, 0x6b, 0x9a, 0x46, 0x9c, 0x10, 0x52, 0x8e, 0xff, 0x0a, 0xae}, 157 {0xc9, 0xd1, 0x84, 0xdd, 0xd5, 0xa9, 0xf5, 0xe0, 0xcf, 0x8c, 0xe2, 0x9a, 0x9a, 0xbf, 0x69, 0x1c}, 158 {0x2d, 0xb4, 0x79, 0xae, 0x78, 0xbd, 0x50, 0xd8, 0x88, 0x2a, 0x8a, 0x17, 0x8a, 0x61, 0x32, 0xad}, 159 {0x8e, 0xce, 0x5f, 0x04, 0x2d, 0x5e, 0x44, 0x7b, 0x50, 0x51, 0xb9, 0xea, 0xcb, 0x8d, 0x8f, 0x6f}, 160 {0x9c, 0x0b, 0x53, 0xb4, 0xb3, 0xc3, 0x07, 0xe8, 0x7e, 0xae, 0xe0, 0x86, 0x78, 0x14, 0x1f, 0x66}, 161 {0xab, 0xf2, 0x48, 0xaf, 0x69, 0xa6, 0xea, 0xe4, 0xbf, 0xd3, 0xeb, 0x2f, 0x12, 0x9e, 0xeb, 0x94}, 162 {0x06, 0x64, 0xda, 0x16, 0x68, 0x57, 0x4b, 0x88, 0xb9, 0x35, 0xf3, 0x02, 0x73, 0x58, 0xae, 0xf4}, 163 {0xaa, 0x4b, 0x9d, 0xc4, 0xbf, 0x33, 0x7d, 0xe9, 0x0c, 0xd4, 0xfd, 0x3c, 0x46, 0x7c, 0x6a, 0xb7}, 164 {0xea, 0x5c, 0x7f, 0x47, 0x1f, 0xaf, 0x6b, 0xde, 0x2b, 0x1a, 0xd7, 0xd4, 0x68, 0x6d, 0x22, 0x87}, 165 {0x29, 0x39, 0xb0, 0x18, 0x32, 0x23, 0xfa, 0xfc, 0x17, 0x23, 0xde, 0x4f, 0x52, 0xc4, 0x3d, 0x35}, 166 {0x7c, 0x39, 0x56, 0xca, 0x5e, 0xea, 0xfc, 0x3e, 0x36, 0x3e, 0x9d, 0x55, 0x65, 0x46, 0xeb, 0x68}, 167 {0x77, 0xc6, 0x07, 0x71, 0x46, 0xf0, 0x1c, 0x32, 0xb6, 0xb6, 0x9d, 0x5f, 0x4e, 0xa9, 0xff, 0xcf}, 168 {0x37, 0xa6, 0x98, 0x6c, 0xb8, 0x84, 0x7e, 0xdf, 0x09, 0x25, 0xf0, 0xf1, 0x30, 0x9b, 0x54, 0xde}, 169 {0xa7, 0x05, 0xf0, 0xe6, 0x9d, 0xa9, 0xa8, 0xf9, 0x07, 0x24, 0x1a, 0x2e, 0x92, 0x3c, 0x8c, 0xc8}, 170 {0x3d, 0xc4, 0x7d, 0x1f, 0x29, 0xc4, 0x48, 0x46, 0x1e, 0x9e, 0x76, 0xed, 0x90, 0x4f, 0x67, 0x11}, 171 {0x0d, 0x62, 0xbf, 0x01, 0xe6, 0xfc, 0x0e, 0x1a, 0x0d, 0x3c, 0x47, 0x51, 0xc5, 0xd3, 0x69, 0x2b}, 172 {0x8c, 0x03, 0x46, 0x8b, 0xca, 0x7c, 0x66, 0x9e, 0xe4, 0xfd, 0x5e, 0x08, 0x4b, 0xbe, 0xe7, 0xb5}, 173 {0x52, 0x8a, 0x5b, 0xb9, 0x3b, 0xaf, 0x2c, 0x9c, 0x44, 0x73, 0xcc, 0xe5, 0xd0, 0xd2, 0x2b, 0xd9}, 174 {0xdf, 0x6a, 0x30, 0x1e, 0x95, 0xc9, 0x5d, 0xad, 0x97, 0xae, 0x0c, 0xc8, 0xc6, 0x91, 0x3b, 0xd8}, 175 {0x80, 0x11, 0x89, 0x90, 0x2c, 0x85, 0x7f, 0x39, 0xe7, 0x35, 0x91, 0x28, 0x5e, 0x70, 0xb6, 0xdb}, 176 {0xe6, 0x17, 0x34, 0x6a, 0xc9, 0xc2, 0x31, 0xbb, 0x36, 0x50, 0xae, 0x34, 0xcc, 0xca, 0x0c, 0x5b}, 177 {0x27, 0xd9, 0x34, 0x37, 0xef, 0xb7, 0x21, 0xaa, 0x40, 0x18, 0x21, 0xdc, 0xec, 0x5a, 0xdf, 0x89}, 178 {0x89, 0x23, 0x7d, 0x9d, 0xed, 0x9c, 0x5e, 0x78, 0xd8, 0xb1, 0xc9, 0xb1, 0x66, 0xcc, 0x73, 0x42}, 179 {0x4a, 0x6d, 0x80, 0x91, 0xbf, 0x5e, 0x7d, 0x65, 0x11, 0x89, 0xfa, 0x94, 0xa2, 0x50, 0xb1, 0x4c}, 180 {0x0e, 0x33, 0xf9, 0x60, 0x55, 0xe7, 0xae, 0x89, 0x3f, 0xfc, 0x0e, 0x3d, 0xcf, 0x49, 0x29, 0x02}, 181 {0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1, 0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63, 0x15, 0x1b}, 182 {0xf7, 0xe5, 0xae, 0xf5, 0x49, 0xf7, 0x82, 0xcf, 0x37, 0x90, 0x55, 0xa6, 0x08, 0x26, 0x9b, 0x16}, 183 {0x43, 0x8d, 0x03, 0x0f, 0xd0, 0xb7, 0xa5, 0x4f, 0xa8, 0x37, 0xf2, 0xad, 0x20, 0x1a, 0x64, 0x03}, 184 {0xa5, 0x90, 0xd3, 0xee, 0x4f, 0xbf, 0x04, 0xe3, 0x24, 0x7e, 0x0d, 0x27, 0xf2, 0x86, 0x42, 0x3f}, 185 {0x5f, 0xe2, 0xc1, 0xa1, 0x72, 0xfe, 0x93, 0xc4, 0xb1, 0x5c, 0xd3, 0x7c, 0xae, 0xf9, 0xf5, 0x38}, 186 {0x2c, 0x97, 0x32, 0x5c, 0xbd, 0x06, 0xb3, 0x6e, 0xb2, 0x13, 0x3d, 0xd0, 0x8b, 0x3a, 0x01, 0x7c}, 187 {0x92, 0xc8, 0x14, 0x22, 0x7a, 0x6b, 0xca, 0x94, 0x9f, 0xf0, 0x65, 0x9f, 0x00, 0x2a, 0xd3, 0x9e}, 188 {0xdc, 0xe8, 0x50, 0x11, 0x0b, 0xd8, 0x32, 0x8c, 0xfb, 0xd5, 0x08, 0x41, 0xd6, 0x91, 0x1d, 0x87}, 189 {0x67, 0xf1, 0x49, 0x84, 0xc7, 0xda, 0x79, 0x12, 0x48, 0xe3, 0x2b, 0xb5, 0x92, 0x25, 0x83, 0xda}, 190 {0x19, 0x38, 0xf2, 0xcf, 0x72, 0xd5, 0x4e, 0xe9, 0x7e, 0x94, 0x16, 0x6f, 0xa9, 0x1d, 0x2a, 0x36}, 191 {0x74, 0x48, 0x1e, 0x96, 0x46, 0xed, 0x49, 0xfe, 0x0f, 0x62, 0x24, 0x30, 0x16, 0x04, 0x69, 0x8e}, 192 {0x57, 0xfc, 0xa5, 0xde, 0x98, 0xa9, 0xd6, 0xd8, 0x00, 0x64, 0x38, 0xd0, 0x58, 0x3d, 0x8a, 0x1d}, 193 {0x9f, 0xec, 0xde, 0x1c, 0xef, 0xdc, 0x1c, 0xbe, 0xd4, 0x76, 0x36, 0x74, 0xd9, 0x57, 0x53, 0x59}, 194 {0xe3, 0x04, 0x0c, 0x00, 0xeb, 0x28, 0xf1, 0x53, 0x66, 0xca, 0x73, 0xcb, 0xd8, 0x72, 0xe7, 0x40}, 195 {0x76, 0x97, 0x00, 0x9a, 0x6a, 0x83, 0x1d, 0xfe, 0xcc, 0xa9, 0x1c, 0x59, 0x93, 0x67, 0x0f, 0x7a}, 196 {0x58, 0x53, 0x54, 0x23, 0x21, 0xf5, 0x67, 0xa0, 0x05, 0xd5, 0x47, 0xa4, 0xf0, 0x47, 0x59, 0xbd}, 197 {0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a, 0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c}, 198} 199 200func TestSum64(t *testing.T) { 201 for i, v := range golden { 202 h := New(v.k) 203 h.Write(v.m) 204 if sum := h.Sum64(); sum != v.r { 205 t.Errorf(`%d: expected "%x", got "%x"`, i, v.r, sum) 206 } 207 } 208} 209 210func TestSum(t *testing.T) { 211 var r [8]byte 212 for i, v := range golden { 213 binary.LittleEndian.PutUint64(r[:], v.r) 214 h := New(v.k) 215 h.Write(v.m) 216 if sum := h.Sum(nil); !bytes.Equal(sum, r[:]) { 217 t.Errorf(`%d: expected "%x", got "%x"`, i, r, sum) 218 } 219 } 220 221 var k [16]byte 222 var in [64]byte 223 for i := range k { 224 k[i] = byte(i) 225 } 226 227 for i := 0; i < 64; i++ { 228 in[i] = byte(i) 229 h := New(k[:]) 230 h.Write(in[:i]) 231 if sum := h.Sum(nil); !bytes.Equal(sum, goldenRef[i]) { 232 t.Errorf(`%d: expected "%x", got "%x"`, i, goldenRef[i], sum) 233 } 234 } 235} 236 237func TestSumUnaligned(t *testing.T) { 238 const align = 8 239 var k [16]byte 240 var in [64 + align]byte 241 for i := range k { 242 k[i] = byte(i) 243 } 244 245 for a := 1; a < align; a++ { 246 for i := 0; i < 64; i++ { 247 in[a+i] = byte(i) 248 h := New(k[:]) 249 h.Write(in[a : a+i]) 250 if sum := h.Sum(nil); !bytes.Equal(sum, goldenRef[i]) { 251 t.Errorf(`%d: expected "%x", got "%x"`, i, goldenRef[i], sum) 252 } 253 } 254 } 255} 256 257func TestSum128(t *testing.T) { 258 var k [16]byte 259 var in [64]byte 260 for i := range k { 261 k[i] = byte(i) 262 } 263 264 for i := 0; i < 64; i++ { 265 in[i] = byte(i) 266 h := New128(k[:]) 267 h.Write(in[:i]) 268 if sum := h.Sum(nil); !bytes.Equal(sum, goldenRef128[i]) { 269 t.Errorf(`%d: expected "%x", got "%x"`, i, goldenRef128[i], sum) 270 } 271 } 272} 273 274func TestHash(t *testing.T) { 275 var k0, k1 uint64 276 for i, v := range golden { 277 k0 = binary.LittleEndian.Uint64(v.k[0:8]) 278 k1 = binary.LittleEndian.Uint64(v.k[8:16]) 279 if sum := Hash(k0, k1, v.m); sum != v.r { 280 t.Errorf(`%d: expected "%x", got "%x"`, i, v.r, sum) 281 } 282 } 283 284 var k [16]byte 285 var in [64]byte 286 for i := range k { 287 k[i] = byte(i) 288 } 289 k0 = binary.LittleEndian.Uint64(k[0:8]) 290 k1 = binary.LittleEndian.Uint64(k[8:16]) 291 292 for i := 0; i < 64; i++ { 293 in[i] = byte(i) 294 ref := binary.LittleEndian.Uint64(goldenRef[i]) 295 if sum := Hash(k0, k1, in[:i]); sum != ref { 296 t.Errorf(`%d: expected "%x", got "%x"`, i, ref, sum) 297 } 298 } 299} 300 301func TestHashUnaligned(t *testing.T) { 302 const align = 8 303 var k0, k1 uint64 304 var k [16]byte 305 var in [64 + align]byte 306 307 for i := range k { 308 k[i] = byte(i) 309 } 310 k0 = binary.LittleEndian.Uint64(k[0:8]) 311 k1 = binary.LittleEndian.Uint64(k[8:16]) 312 313 for a := 1; a < align; a++ { 314 for i := 0; i < 64; i++ { 315 in[a+i] = byte(i) 316 ref := binary.LittleEndian.Uint64(goldenRef[i]) 317 if sum := Hash(k0, k1, in[a:a+i]); sum != ref { 318 t.Errorf(`%d: expected "%x", got "%x"`, i, ref, sum) 319 } 320 } 321 } 322} 323 324func TestHash128(t *testing.T) { 325 var k0, k1 uint64 326 327 var k [16]byte 328 var in [64]byte 329 for i := range k { 330 k[i] = byte(i) 331 } 332 k0 = binary.LittleEndian.Uint64(k[0:8]) 333 k1 = binary.LittleEndian.Uint64(k[8:16]) 334 335 for i := 0; i < 64; i++ { 336 in[i] = byte(i) 337 ref0 := binary.LittleEndian.Uint64(goldenRef128[i][0:]) 338 ref1 := binary.LittleEndian.Uint64(goldenRef128[i][8:]) 339 if sum0, sum1 := Hash128(k0, k1, in[:i]); sum0 != ref0 || sum1 != ref1 { 340 t.Errorf(`%d: expected "%x, %x", got "%x, %x"`, i, ref0, ref1, sum0, sum1) 341 } 342 } 343} 344 345var ( 346 key = zeroKey 347 key0, key1 uint64 348 bench = New(key) 349 bench128 = New128(key) 350 buf = make([]byte, 8<<10) 351) 352 353func BenchmarkHash8(b *testing.B) { 354 b.SetBytes(8) 355 for i := 0; i < b.N; i++ { 356 Hash(key0, key1, buf[:8]) 357 } 358} 359 360func BenchmarkHash16(b *testing.B) { 361 b.SetBytes(16) 362 for i := 0; i < b.N; i++ { 363 Hash(key0, key1, buf[:16]) 364 } 365} 366 367func BenchmarkHash40(b *testing.B) { 368 b.SetBytes(40) 369 for i := 0; i < b.N; i++ { 370 Hash(key0, key1, buf[:40]) 371 } 372} 373 374func BenchmarkHash64(b *testing.B) { 375 b.SetBytes(64) 376 for i := 0; i < b.N; i++ { 377 Hash(key0, key1, buf[:64]) 378 } 379} 380 381func BenchmarkHash128(b *testing.B) { 382 b.SetBytes(128) 383 for i := 0; i < b.N; i++ { 384 Hash(key0, key1, buf[:128]) 385 } 386} 387 388func BenchmarkHash1K(b *testing.B) { 389 b.SetBytes(1024) 390 for i := 0; i < b.N; i++ { 391 Hash(key0, key1, buf[:1024]) 392 } 393} 394 395func BenchmarkHash1Kunaligned(b *testing.B) { 396 b.SetBytes(1024) 397 for i := 0; i < b.N; i++ { 398 Hash(key0, key1, buf[1:1025]) 399 } 400} 401 402func BenchmarkHash8K(b *testing.B) { 403 b.SetBytes(int64(len(buf))) 404 for i := 0; i < b.N; i++ { 405 Hash(key0, key1, buf) 406 } 407} 408 409func BenchmarkHash128_8(b *testing.B) { 410 b.SetBytes(8) 411 for i := 0; i < b.N; i++ { 412 Hash128(key0, key1, buf[:8]) 413 } 414} 415 416func BenchmarkHash128_16(b *testing.B) { 417 b.SetBytes(16) 418 for i := 0; i < b.N; i++ { 419 Hash128(key0, key1, buf[:16]) 420 } 421} 422 423func BenchmarkHash128_40(b *testing.B) { 424 b.SetBytes(40) 425 for i := 0; i < b.N; i++ { 426 Hash128(key0, key1, buf[:40]) 427 } 428} 429 430func BenchmarkHash128_64(b *testing.B) { 431 b.SetBytes(64) 432 for i := 0; i < b.N; i++ { 433 Hash128(key0, key1, buf[:64]) 434 } 435} 436 437func BenchmarkHash128_128(b *testing.B) { 438 b.SetBytes(128) 439 for i := 0; i < b.N; i++ { 440 Hash128(key0, key1, buf[:128]) 441 } 442} 443 444func BenchmarkHash128_1K(b *testing.B) { 445 b.SetBytes(1024) 446 for i := 0; i < b.N; i++ { 447 Hash128(key0, key1, buf[:1024]) 448 } 449} 450 451func BenchmarkHash128_8K(b *testing.B) { 452 b.SetBytes(int64(len(buf))) 453 for i := 0; i < b.N; i++ { 454 Hash128(key0, key1, buf) 455 } 456} 457 458func BenchmarkFull8(b *testing.B) { 459 b.SetBytes(8) 460 for i := 0; i < b.N; i++ { 461 bench.Reset() 462 bench.Write(buf[:8]) 463 bench.Sum64() 464 } 465} 466 467func BenchmarkFull16(b *testing.B) { 468 b.SetBytes(16) 469 for i := 0; i < b.N; i++ { 470 bench.Reset() 471 bench.Write(buf[:16]) 472 bench.Sum64() 473 } 474} 475 476func BenchmarkFull40(b *testing.B) { 477 b.SetBytes(24) 478 for i := 0; i < b.N; i++ { 479 bench.Reset() 480 bench.Write(buf[:16]) 481 bench.Sum64() 482 } 483} 484 485func BenchmarkFull64(b *testing.B) { 486 b.SetBytes(64) 487 for i := 0; i < b.N; i++ { 488 bench.Reset() 489 bench.Write(buf[:64]) 490 bench.Sum64() 491 } 492} 493 494func BenchmarkFull128(b *testing.B) { 495 b.SetBytes(128) 496 for i := 0; i < b.N; i++ { 497 bench.Reset() 498 bench.Write(buf[:64]) 499 bench.Sum64() 500 } 501} 502 503func BenchmarkFull1K(b *testing.B) { 504 b.SetBytes(1024) 505 for i := 0; i < b.N; i++ { 506 bench.Reset() 507 bench.Write(buf[:1024]) 508 bench.Sum64() 509 } 510} 511 512func BenchmarkFull1Kunaligned(b *testing.B) { 513 b.SetBytes(1024) 514 for i := 0; i < b.N; i++ { 515 bench.Reset() 516 bench.Write(buf[1:1025]) 517 bench.Sum64() 518 } 519} 520 521func BenchmarkFull8K(b *testing.B) { 522 b.SetBytes(int64(len(buf))) 523 for i := 0; i < b.N; i++ { 524 bench.Reset() 525 bench.Write(buf) 526 bench.Sum64() 527 } 528} 529 530func BenchmarkFull128_8(b *testing.B) { 531 b.SetBytes(8) 532 for i := 0; i < b.N; i++ { 533 bench128.Reset() 534 bench128.Write(buf[:8]) 535 bench128.Sum(nil) 536 } 537} 538 539func BenchmarkFull128_16(b *testing.B) { 540 b.SetBytes(16) 541 for i := 0; i < b.N; i++ { 542 bench128.Reset() 543 bench128.Write(buf[:16]) 544 bench128.Sum(nil) 545 } 546} 547 548func BenchmarkFull128_40(b *testing.B) { 549 b.SetBytes(24) 550 for i := 0; i < b.N; i++ { 551 bench128.Reset() 552 bench128.Write(buf[:16]) 553 bench128.Sum(nil) 554 } 555} 556 557func BenchmarkFull128_64(b *testing.B) { 558 b.SetBytes(64) 559 for i := 0; i < b.N; i++ { 560 bench128.Reset() 561 bench128.Write(buf[:64]) 562 bench128.Sum(nil) 563 } 564} 565 566func BenchmarkFull128_128(b *testing.B) { 567 b.SetBytes(128) 568 for i := 0; i < b.N; i++ { 569 bench128.Reset() 570 bench128.Write(buf[:64]) 571 bench128.Sum(nil) 572 } 573} 574 575func BenchmarkFull128_1K(b *testing.B) { 576 b.SetBytes(1024) 577 for i := 0; i < b.N; i++ { 578 bench128.Reset() 579 bench128.Write(buf[:1024]) 580 bench128.Sum(nil) 581 } 582} 583 584func BenchmarkFull128_8K(b *testing.B) { 585 b.SetBytes(int64(len(buf))) 586 for i := 0; i < b.N; i++ { 587 bench128.Reset() 588 bench128.Write(buf) 589 bench128.Sum(nil) 590 } 591} 592