1 | // Copyright 2018 Developers of the Rand project. |
---|---|

2 | // Copyright 2017-2018 The Rust Project Developers. |

3 | // |

4 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |

5 | // https://www.apache.org/licenses/LICENSE-2.0> or the MIT license |

6 | // <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your |

7 | // option. This file may not be copied, modified, or distributed |

8 | // except according to those terms. |

9 | |

10 | //! Random number generation traits |

11 | //! |

12 | //! This crate is mainly of interest to crates publishing implementations of |

13 | //! [`RngCore`]. Other users are encouraged to use the [`rand`] crate instead |

14 | //! which re-exports the main traits and error types. |

15 | //! |

16 | //! [`RngCore`] is the core trait implemented by algorithmic pseudo-random number |

17 | //! generators and external random-number sources. |

18 | //! |

19 | //! [`SeedableRng`] is an extension trait for construction from fixed seeds and |

20 | //! other random number generators. |

21 | //! |

22 | //! [`Error`] is provided for error-handling. It is safe to use in `no_std` |

23 | //! environments. |

24 | //! |

25 | //! The [`impls`] and [`le`] sub-modules include a few small functions to assist |

26 | //! implementation of [`RngCore`]. |

27 | //! |

28 | //! [`rand`]: https://docs.rs/rand |

29 | |

30 | #![doc( |

31 | html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png", |

32 | html_favicon_url = "https://www.rust-lang.org/favicon.ico", |

33 | html_root_url = "https://rust-random.github.io/rand/" |

34 | )] |

35 | #![deny(missing_docs)] |

36 | #![deny(missing_debug_implementations)] |

37 | #![doc(test(attr(allow(unused_variables), deny(warnings))))] |

38 | #![cfg_attr(doc_cfg, feature(doc_cfg))] |

39 | #![no_std] |

40 | |

41 | use core::convert::AsMut; |

42 | use core::default::Default; |

43 | |

44 | #[cfg(feature = "std")] extern crate std; |

45 | #[cfg(feature = "alloc")] extern crate alloc; |

46 | #[cfg(feature = "alloc")] use alloc::boxed::Box; |

47 | |

48 | pub use error::Error; |

49 | #[cfg(feature = "getrandom")] pub use os::OsRng; |

50 | |

51 | |

52 | pub mod block; |

53 | mod error; |

54 | pub mod impls; |

55 | pub mod le; |

56 | #[cfg(feature = "getrandom")] mod os; |

57 | |

58 | |

59 | /// The core of a random number generator. |

60 | /// |

61 | /// This trait encapsulates the low-level functionality common to all |

62 | /// generators, and is the "back end", to be implemented by generators. |

63 | /// End users should normally use the `Rng` trait from the [`rand`] crate, |

64 | /// which is automatically implemented for every type implementing `RngCore`. |

65 | /// |

66 | /// Three different methods for generating random data are provided since the |

67 | /// optimal implementation of each is dependent on the type of generator. There |

68 | /// is no required relationship between the output of each; e.g. many |

69 | /// implementations of [`fill_bytes`] consume a whole number of `u32` or `u64` |

70 | /// values and drop any remaining unused bytes. The same can happen with the |

71 | /// [`next_u32`] and [`next_u64`] methods, implementations may discard some |

72 | /// random bits for efficiency. |

73 | /// |

74 | /// The [`try_fill_bytes`] method is a variant of [`fill_bytes`] allowing error |

75 | /// handling; it is not deemed sufficiently useful to add equivalents for |

76 | /// [`next_u32`] or [`next_u64`] since the latter methods are almost always used |

77 | /// with algorithmic generators (PRNGs), which are normally infallible. |

78 | /// |

79 | /// Implementers should produce bits uniformly. Pathological RNGs (e.g. always |

80 | /// returning the same value, or never setting certain bits) can break rejection |

81 | /// sampling used by random distributions, and also break other RNGs when |

82 | /// seeding them via [`SeedableRng::from_rng`]. |

83 | /// |

84 | /// Algorithmic generators implementing [`SeedableRng`] should normally have |

85 | /// *portable, reproducible* output, i.e. fix Endianness when converting values |

86 | /// to avoid platform differences, and avoid making any changes which affect |

87 | /// output (except by communicating that the release has breaking changes). |

88 | /// |

89 | /// Typically an RNG will implement only one of the methods available |

90 | /// in this trait directly, then use the helper functions from the |

91 | /// [`impls`] module to implement the other methods. |

92 | /// |

93 | /// It is recommended that implementations also implement: |

94 | /// |

95 | /// - `Debug` with a custom implementation which *does not* print any internal |

96 | /// state (at least, [`CryptoRng`]s should not risk leaking state through |

97 | /// `Debug`). |

98 | /// - `Serialize` and `Deserialize` (from Serde), preferably making Serde |

99 | /// support optional at the crate level in PRNG libs. |

100 | /// - `Clone`, if possible. |

101 | /// - *never* implement `Copy` (accidental copies may cause repeated values). |

102 | /// - *do not* implement `Default` for pseudorandom generators, but instead |

103 | /// implement [`SeedableRng`], to guide users towards proper seeding. |

104 | /// External / hardware RNGs can choose to implement `Default`. |

105 | /// - `Eq` and `PartialEq` could be implemented, but are probably not useful. |

106 | /// |

107 | /// # Example |

108 | /// |

109 | /// A simple example, obviously not generating very *random* output: |

110 | /// |

111 | /// ``` |

112 | /// #![allow(dead_code)] |

113 | /// use rand_core::{RngCore, Error, impls}; |

114 | /// |

115 | /// struct CountingRng(u64); |

116 | /// |

117 | /// impl RngCore for CountingRng { |

118 | /// fn next_u32(&mut self) -> u32 { |

119 | /// self.next_u64() as u32 |

120 | /// } |

121 | /// |

122 | /// fn next_u64(&mut self) -> u64 { |

123 | /// self.0 += 1; |

124 | /// self.0 |

125 | /// } |

126 | /// |

127 | /// fn fill_bytes(&mut self, dest: &mut [u8]) { |

128 | /// impls::fill_bytes_via_next(self, dest) |

129 | /// } |

130 | /// |

131 | /// fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> { |

132 | /// Ok(self.fill_bytes(dest)) |

133 | /// } |

134 | /// } |

135 | /// ``` |

136 | /// |

137 | /// [`rand`]: https://docs.rs/rand |

138 | /// [`try_fill_bytes`]: RngCore::try_fill_bytes |

139 | /// [`fill_bytes`]: RngCore::fill_bytes |

140 | /// [`next_u32`]: RngCore::next_u32 |

141 | /// [`next_u64`]: RngCore::next_u64 |

142 | pub trait RngCore { |

143 | /// Return the next random `u32`. |

144 | /// |

145 | /// RNGs must implement at least one method from this trait directly. In |

146 | /// the case this method is not implemented directly, it can be implemented |

147 | /// using `self.next_u64() as u32` or via [`impls::next_u32_via_fill`]. |

148 | fn next_u32(&mut self) -> u32; |

149 | |

150 | /// Return the next random `u64`. |

151 | /// |

152 | /// RNGs must implement at least one method from this trait directly. In |

153 | /// the case this method is not implemented directly, it can be implemented |

154 | /// via [`impls::next_u64_via_u32`] or via [`impls::next_u64_via_fill`]. |

155 | fn next_u64(&mut self) -> u64; |

156 | |

157 | /// Fill `dest` with random data. |

158 | /// |

159 | /// RNGs must implement at least one method from this trait directly. In |

160 | /// the case this method is not implemented directly, it can be implemented |

161 | /// via [`impls::fill_bytes_via_next`] or |

162 | /// via [`RngCore::try_fill_bytes`]; if this generator can |

163 | /// fail the implementation must choose how best to handle errors here |

164 | /// (e.g. panic with a descriptive message or log a warning and retry a few |

165 | /// times). |

166 | /// |

167 | /// This method should guarantee that `dest` is entirely filled |

168 | /// with new data, and may panic if this is impossible |

169 | /// (e.g. reading past the end of a file that is being used as the |

170 | /// source of randomness). |

171 | fn fill_bytes(&mut self, dest: &mut [u8]); |

172 | |

173 | /// Fill `dest` entirely with random data. |

174 | /// |

175 | /// This is the only method which allows an RNG to report errors while |

176 | /// generating random data thus making this the primary method implemented |

177 | /// by external (true) RNGs (e.g. `OsRng`) which can fail. It may be used |

178 | /// directly to generate keys and to seed (infallible) PRNGs. |

179 | /// |

180 | /// Other than error handling, this method is identical to [`RngCore::fill_bytes`]; |

181 | /// thus this may be implemented using `Ok(self.fill_bytes(dest))` or |

182 | /// `fill_bytes` may be implemented with |

183 | /// `self.try_fill_bytes(dest).unwrap()` or more specific error handling. |

184 | fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>; |

185 | } |

186 | |

187 | /// A marker trait used to indicate that an [`RngCore`] or [`BlockRngCore`] |

188 | /// implementation is supposed to be cryptographically secure. |

189 | /// |

190 | /// *Cryptographically secure generators*, also known as *CSPRNGs*, should |

191 | /// satisfy an additional properties over other generators: given the first |

192 | /// *k* bits of an algorithm's output |

193 | /// sequence, it should not be possible using polynomial-time algorithms to |

194 | /// predict the next bit with probability significantly greater than 50%. |

195 | /// |

196 | /// Some generators may satisfy an additional property, however this is not |

197 | /// required by this trait: if the CSPRNG's state is revealed, it should not be |

198 | /// computationally-feasible to reconstruct output prior to this. Some other |

199 | /// generators allow backwards-computation and are considered *reversible*. |

200 | /// |

201 | /// Note that this trait is provided for guidance only and cannot guarantee |

202 | /// suitability for cryptographic applications. In general it should only be |

203 | /// implemented for well-reviewed code implementing well-regarded algorithms. |

204 | /// |

205 | /// Note also that use of a `CryptoRng` does not protect against other |

206 | /// weaknesses such as seeding from a weak entropy source or leaking state. |

207 | /// |

208 | /// [`BlockRngCore`]: block::BlockRngCore |

209 | pub trait CryptoRng {} |

210 | |

211 | /// An extension trait that is automatically implemented for any type |

212 | /// implementing [`RngCore`] and [`CryptoRng`]. |

213 | /// |

214 | /// It may be used as a trait object, and supports upcasting to [`RngCore`] via |

215 | /// the [`CryptoRngCore::as_rngcore`] method. |

216 | /// |

217 | /// # Example |

218 | /// |

219 | /// ``` |

220 | /// use rand_core::CryptoRngCore; |

221 | /// |

222 | /// #[allow(unused)] |

223 | /// fn make_token(rng: &mut dyn CryptoRngCore) -> [u8; 32] { |

224 | /// let mut buf = [0u8; 32]; |

225 | /// rng.fill_bytes(&mut buf); |

226 | /// buf |

227 | /// } |

228 | /// ``` |

229 | pub trait CryptoRngCore: CryptoRng + RngCore { |

230 | /// Upcast to an [`RngCore`] trait object. |

231 | fn as_rngcore(&mut self) -> &mut dyn RngCore; |

232 | } |

233 | |

234 | impl<T: CryptoRng + RngCore> CryptoRngCore for T { |

235 | fn as_rngcore(&mut self) -> &mut dyn RngCore { |

236 | self |

237 | } |

238 | } |

239 | |

240 | /// A random number generator that can be explicitly seeded. |

241 | /// |

242 | /// This trait encapsulates the low-level functionality common to all |

243 | /// pseudo-random number generators (PRNGs, or algorithmic generators). |

244 | /// |

245 | /// [`rand`]: https://docs.rs/rand |

246 | pub trait SeedableRng: Sized { |

247 | /// Seed type, which is restricted to types mutably-dereferenceable as `u8` |

248 | /// arrays (we recommend `[u8; N]` for some `N`). |

249 | /// |

250 | /// It is recommended to seed PRNGs with a seed of at least circa 100 bits, |

251 | /// which means an array of `[u8; 12]` or greater to avoid picking RNGs with |

252 | /// partially overlapping periods. |

253 | /// |

254 | /// For cryptographic RNG's a seed of 256 bits is recommended, `[u8; 32]`. |

255 | /// |

256 | /// |

257 | /// # Implementing `SeedableRng` for RNGs with large seeds |

258 | /// |

259 | /// Note that the required traits `core::default::Default` and |

260 | /// `core::convert::AsMut<u8>` are not implemented for large arrays |

261 | /// `[u8; N]` with `N` > 32. To be able to implement the traits required by |

262 | /// `SeedableRng` for RNGs with such large seeds, the newtype pattern can be |

263 | /// used: |

264 | /// |

265 | /// ``` |

266 | /// use rand_core::SeedableRng; |

267 | /// |

268 | /// const N: usize = 64; |

269 | /// pub struct MyRngSeed(pub [u8; N]); |

270 | /// pub struct MyRng(MyRngSeed); |

271 | /// |

272 | /// impl Default for MyRngSeed { |

273 | /// fn default() -> MyRngSeed { |

274 | /// MyRngSeed([0; N]) |

275 | /// } |

276 | /// } |

277 | /// |

278 | /// impl AsMut<[u8]> for MyRngSeed { |

279 | /// fn as_mut(&mut self) -> &mut [u8] { |

280 | /// &mut self.0 |

281 | /// } |

282 | /// } |

283 | /// |

284 | /// impl SeedableRng for MyRng { |

285 | /// type Seed = MyRngSeed; |

286 | /// |

287 | /// fn from_seed(seed: MyRngSeed) -> MyRng { |

288 | /// MyRng(seed) |

289 | /// } |

290 | /// } |

291 | /// ``` |

292 | type Seed: Sized + Default + AsMut<[u8]>; |

293 | |

294 | /// Create a new PRNG using the given seed. |

295 | /// |

296 | /// PRNG implementations are allowed to assume that bits in the seed are |

297 | /// well distributed. That means usually that the number of one and zero |

298 | /// bits are roughly equal, and values like 0, 1 and (size - 1) are unlikely. |

299 | /// Note that many non-cryptographic PRNGs will show poor quality output |

300 | /// if this is not adhered to. If you wish to seed from simple numbers, use |

301 | /// `seed_from_u64` instead. |

302 | /// |

303 | /// All PRNG implementations should be reproducible unless otherwise noted: |

304 | /// given a fixed `seed`, the same sequence of output should be produced |

305 | /// on all runs, library versions and architectures (e.g. check endianness). |

306 | /// Any "value-breaking" changes to the generator should require bumping at |

307 | /// least the minor version and documentation of the change. |

308 | /// |

309 | /// It is not required that this function yield the same state as a |

310 | /// reference implementation of the PRNG given equivalent seed; if necessary |

311 | /// another constructor replicating behaviour from a reference |

312 | /// implementation can be added. |

313 | /// |

314 | /// PRNG implementations should make sure `from_seed` never panics. In the |

315 | /// case that some special values (like an all zero seed) are not viable |

316 | /// seeds it is preferable to map these to alternative constant value(s), |

317 | /// for example `0xBAD5EEDu32` or `0x0DDB1A5E5BAD5EEDu64` ("odd biases? bad |

318 | /// seed"). This is assuming only a small number of values must be rejected. |

319 | fn from_seed(seed: Self::Seed) -> Self; |

320 | |

321 | /// Create a new PRNG using a `u64` seed. |

322 | /// |

323 | /// This is a convenience-wrapper around `from_seed` to allow construction |

324 | /// of any `SeedableRng` from a simple `u64` value. It is designed such that |

325 | /// low Hamming Weight numbers like 0 and 1 can be used and should still |

326 | /// result in good, independent seeds to the PRNG which is returned. |

327 | /// |

328 | /// This **is not suitable for cryptography**, as should be clear given that |

329 | /// the input size is only 64 bits. |

330 | /// |

331 | /// Implementations for PRNGs *may* provide their own implementations of |

332 | /// this function, but the default implementation should be good enough for |

333 | /// all purposes. *Changing* the implementation of this function should be |

334 | /// considered a value-breaking change. |

335 | fn seed_from_u64(mut state: u64) -> Self { |

336 | // We use PCG32 to generate a u32 sequence, and copy to the seed |

337 | fn pcg32(state: &mut u64) -> [u8; 4] { |

338 | const MUL: u64 = 6364136223846793005; |

339 | const INC: u64 = 11634580027462260723; |

340 | |

341 | // We advance the state first (to get away from the input value, |

342 | // in case it has low Hamming Weight). |

343 | *state = state.wrapping_mul(MUL).wrapping_add(INC); |

344 | let state = *state; |

345 | |

346 | // Use PCG output function with to_le to generate x: |

347 | let xorshifted = (((state >> 18) ^ state) >> 27) as u32; |

348 | let rot = (state >> 59) as u32; |

349 | let x = xorshifted.rotate_right(rot); |

350 | x.to_le_bytes() |

351 | } |

352 | |

353 | let mut seed = Self::Seed::default(); |

354 | let mut iter = seed.as_mut().chunks_exact_mut(4); |

355 | for chunk in &mut iter { |

356 | chunk.copy_from_slice(&pcg32(&mut state)); |

357 | } |

358 | let rem = iter.into_remainder(); |

359 | if !rem.is_empty() { |

360 | rem.copy_from_slice(&pcg32(&mut state)[..rem.len()]); |

361 | } |

362 | |

363 | Self::from_seed(seed) |

364 | } |

365 | |

366 | /// Create a new PRNG seeded from another `Rng`. |

367 | /// |

368 | /// This may be useful when needing to rapidly seed many PRNGs from a master |

369 | /// PRNG, and to allow forking of PRNGs. It may be considered deterministic. |

370 | /// |

371 | /// The master PRNG should be at least as high quality as the child PRNGs. |

372 | /// When seeding non-cryptographic child PRNGs, we recommend using a |

373 | /// different algorithm for the master PRNG (ideally a CSPRNG) to avoid |

374 | /// correlations between the child PRNGs. If this is not possible (e.g. |

375 | /// forking using small non-crypto PRNGs) ensure that your PRNG has a good |

376 | /// mixing function on the output or consider use of a hash function with |

377 | /// `from_seed`. |

378 | /// |

379 | /// Note that seeding `XorShiftRng` from another `XorShiftRng` provides an |

380 | /// extreme example of what can go wrong: the new PRNG will be a clone |

381 | /// of the parent. |

382 | /// |

383 | /// PRNG implementations are allowed to assume that a good RNG is provided |

384 | /// for seeding, and that it is cryptographically secure when appropriate. |

385 | /// As of `rand` 0.7 / `rand_core` 0.5, implementations overriding this |

386 | /// method should ensure the implementation satisfies reproducibility |

387 | /// (in prior versions this was not required). |

388 | /// |

389 | /// [`rand`]: https://docs.rs/rand |

390 | fn from_rng<R: RngCore>(mut rng: R) -> Result<Self, Error> { |

391 | let mut seed = Self::Seed::default(); |

392 | rng.try_fill_bytes(seed.as_mut())?; |

393 | Ok(Self::from_seed(seed)) |

394 | } |

395 | |

396 | /// Creates a new instance of the RNG seeded via [`getrandom`]. |

397 | /// |

398 | /// This method is the recommended way to construct non-deterministic PRNGs |

399 | /// since it is convenient and secure. |

400 | /// |

401 | /// In case the overhead of using [`getrandom`] to seed *many* PRNGs is an |

402 | /// issue, one may prefer to seed from a local PRNG, e.g. |

403 | /// `from_rng(thread_rng()).unwrap()`. |

404 | /// |

405 | /// # Panics |

406 | /// |

407 | /// If [`getrandom`] is unable to provide secure entropy this method will panic. |

408 | /// |

409 | /// [`getrandom`]: https://docs.rs/getrandom |

410 | #[cfg(feature = "getrandom")] |

411 | #[cfg_attr(doc_cfg, doc(cfg(feature = "getrandom")))] |

412 | fn from_entropy() -> Self { |

413 | let mut seed = Self::Seed::default(); |

414 | if let Err(err) = getrandom::getrandom(seed.as_mut()) { |

415 | panic!("from_entropy failed: {}", err); |

416 | } |

417 | Self::from_seed(seed) |

418 | } |

419 | } |

420 | |

421 | // Implement `RngCore` for references to an `RngCore`. |

422 | // Force inlining all functions, so that it is up to the `RngCore` |

423 | // implementation and the optimizer to decide on inlining. |

424 | impl<'a, R: RngCore + ?Sized> RngCore for &'a mut R { |

425 | #[inline(always)] |

426 | fn next_u32(&mut self) -> u32 { |

427 | (**self).next_u32() |

428 | } |

429 | |

430 | #[inline(always)] |

431 | fn next_u64(&mut self) -> u64 { |

432 | (**self).next_u64() |

433 | } |

434 | |

435 | #[inline(always)] |

436 | fn fill_bytes(&mut self, dest: &mut [u8]) { |

437 | (**self).fill_bytes(dest) |

438 | } |

439 | |

440 | #[inline(always)] |

441 | fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> { |

442 | (**self).try_fill_bytes(dest) |

443 | } |

444 | } |

445 | |

446 | // Implement `RngCore` for boxed references to an `RngCore`. |

447 | // Force inlining all functions, so that it is up to the `RngCore` |

448 | // implementation and the optimizer to decide on inlining. |

449 | #[cfg(feature = "alloc")] |

450 | impl<R: RngCore + ?Sized> RngCore for Box<R> { |

451 | #[inline(always)] |

452 | fn next_u32(&mut self) -> u32 { |

453 | (**self).next_u32() |

454 | } |

455 | |

456 | #[inline(always)] |

457 | fn next_u64(&mut self) -> u64 { |

458 | (**self).next_u64() |

459 | } |

460 | |

461 | #[inline(always)] |

462 | fn fill_bytes(&mut self, dest: &mut [u8]) { |

463 | (**self).fill_bytes(dest) |

464 | } |

465 | |

466 | #[inline(always)] |

467 | fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> { |

468 | (**self).try_fill_bytes(dest) |

469 | } |

470 | } |

471 | |

472 | #[cfg(feature = "std")] |

473 | impl std::io::Read for dyn RngCore { |

474 | fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> { |

475 | self.try_fill_bytes(buf)?; |

476 | Ok(buf.len()) |

477 | } |

478 | } |

479 | |

480 | // Implement `CryptoRng` for references to a `CryptoRng`. |

481 | impl<'a, R: CryptoRng + ?Sized> CryptoRng for &'a mut R {} |

482 | |

483 | // Implement `CryptoRng` for boxed references to a `CryptoRng`. |

484 | #[cfg(feature = "alloc")] |

485 | impl<R: CryptoRng + ?Sized> CryptoRng for Box<R> {} |

486 | |

487 | #[cfg(test)] |

488 | mod test { |

489 | use super::*; |

490 | |

491 | #[test] |

492 | fn test_seed_from_u64() { |

493 | struct SeedableNum(u64); |

494 | impl SeedableRng for SeedableNum { |

495 | type Seed = [u8; 8]; |

496 | |

497 | fn from_seed(seed: Self::Seed) -> Self { |

498 | let mut x = [0u64; 1]; |

499 | le::read_u64_into(&seed, &mut x); |

500 | SeedableNum(x[0]) |

501 | } |

502 | } |

503 | |

504 | const N: usize = 8; |

505 | const SEEDS: [u64; N] = [0u64, 1, 2, 3, 4, 8, 16, -1i64 as u64]; |

506 | let mut results = [0u64; N]; |

507 | for (i, seed) in SEEDS.iter().enumerate() { |

508 | let SeedableNum(x) = SeedableNum::seed_from_u64(*seed); |

509 | results[i] = x; |

510 | } |

511 | |

512 | for (i1, r1) in results.iter().enumerate() { |

513 | let weight = r1.count_ones(); |

514 | // This is the binomial distribution B(64, 0.5), so chance of |

515 | // weight < 20 is binocdf(19, 64, 0.5) = 7.8e-4, and same for |

516 | // weight > 44. |

517 | assert!((20..=44).contains(&weight)); |

518 | |

519 | for (i2, r2) in results.iter().enumerate() { |

520 | if i1 == i2 { |

521 | continue; |

522 | } |

523 | let diff_weight = (r1 ^ r2).count_ones(); |

524 | assert!(diff_weight >= 20); |

525 | } |

526 | } |

527 | |

528 | // value-breakage test: |

529 | assert_eq!(results[0], 5029875928683246316); |

530 | } |

531 | } |

532 |