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(dest: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 | |