Trait Arbitrary
pub trait Arbitrary<'a>: Sized {
// Required method
fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, Error>;
// Provided methods
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error> { ... }
fn size_hint(depth: usize) -> (usize, Option<usize>) { ... }
fn try_size_hint(
depth: usize,
) -> Result<(usize, Option<usize>), MaxRecursionReached> { ... }
}
Expand description
Generate arbitrary structured values from raw, unstructured data.
The Arbitrary
trait allows you to generate valid structured values, like
HashMap
s, or ASTs, or MyTomlConfig
, or any other data structure from
raw, unstructured bytes provided by a fuzzer.
§Deriving Arbitrary
Automatically deriving the Arbitrary
trait is the recommended way to
implement Arbitrary
for your types.
Using the custom derive requires that you enable the "derive"
cargo
feature in your Cargo.toml
:
[dependencies]
arbitrary = { version = "1", features = ["derive"] }
Then, you add the #[derive(Arbitrary)]
annotation to your struct
or
enum
type definition:
use arbitrary::Arbitrary;
use std::collections::HashSet;
#[derive(Arbitrary)]
pub struct AddressBook {
friends: HashSet<Friend>,
}
#[derive(Arbitrary, Hash, Eq, PartialEq)]
pub enum Friend {
Buddy { name: String },
Pal { age: usize },
}
Every member of the struct
or enum
must also implement Arbitrary
.
It is also possible to change the default bounds added by the derive:
use arbitrary::Arbitrary;
trait Trait {
type Assoc: for<'a> Arbitrary<'a>;
}
#[derive(Arbitrary)]
// The bounds are used verbatim, so any existing trait bounds will need to be repeated.
#[arbitrary(bound = "T: Trait")]
struct Point<T: Trait> {
x: T::Assoc,
}
§Implementing Arbitrary
By Hand
Implementing Arbitrary
mostly involves nested calls to other Arbitrary
arbitrary implementations for each of your struct
or enum
’s members. But
sometimes you need some amount of raw data, or you need to generate a
variably-sized collection type, or something of that sort. The
Unstructured
type helps you with these tasks.
use arbitrary::{Arbitrary, Result, Unstructured};
impl<'a, T> Arbitrary<'a> for MyCollection<T>
where
T: Arbitrary<'a>,
{
fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
// Get an iterator of arbitrary `T`s.
let iter = u.arbitrary_iter::<T>()?;
// And then create a collection!
let mut my_collection = MyCollection::new();
for elem_result in iter {
let elem = elem_result?;
my_collection.insert(elem);
}
Ok(my_collection)
}
}
§A Note On Output Distributions
There is no requirement for a particular distribution of the values. For
example, it is not required that every value appears with the same
probability. That being said, the main use for Arbitrary
is for fuzzing,
so in many cases a uniform distribution will make the most sense in order to
provide the best coverage of the domain. In other cases this is not
desirable or even possible, for example when sampling from a uniform
distribution is computationally expensive or in the case of collections that
may grow indefinitely.
Required Methods§
fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, Error>
fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, Error>
Generate an arbitrary value of Self
from the given unstructured data.
Calling Arbitrary::arbitrary
requires that you have some raw data,
perhaps given to you by a fuzzer like AFL or libFuzzer. You wrap this
raw data in an Unstructured
, and then you can call <MyType as Arbitrary>::arbitrary
to construct an arbitrary instance of MyType
from that unstructured data.
Implementations may return an error if there is not enough data to
construct a full instance of Self
, or they may fill out the rest of
Self
with dummy values. Using dummy values when the underlying data is
exhausted can help avoid accidentally “defeating” some of the fuzzer’s
mutations to the underlying byte stream that might otherwise lead to
interesting runtime behavior or new code coverage if only we had just a
few more bytes. However, it also requires that implementations for
recursive types (e.g. struct Foo(Option<Box<Foo>>)
) avoid infinite
recursion when the underlying data is exhausted.
use arbitrary::{Arbitrary, Unstructured};
#[derive(Arbitrary)]
pub struct MyType {
// ...
}
// Get the raw data from the fuzzer or wherever else.
let raw_data: &[u8] = get_raw_data_from_fuzzer();
// Wrap that raw data in an `Unstructured`.
let mut unstructured = Unstructured::new(raw_data);
// Generate an arbitrary instance of `MyType` and do stuff with it.
if let Ok(value) = MyType::arbitrary(&mut unstructured) {
do_stuff(value);
}
See also the documentation for Unstructured
.
Provided Methods§
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>
Generate an arbitrary value of Self
from the entirety of the given
unstructured data.
This is similar to Arbitrary::arbitrary, however it assumes that it is
the last consumer of the given data, and is thus able to consume it all
if it needs. See also the documentation for
Unstructured
.
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn size_hint(depth: usize) -> (usize, Option<usize>)
Get a size hint for how many bytes out of an Unstructured
this type
needs to construct itself.
This is useful for determining how many elements we should insert when creating an arbitrary collection.
The return value is similar to Iterator::size_hint
: it returns a
tuple where the first element is a lower bound on the number of bytes
required, and the second element is an optional upper bound.
The default implementation return (0, None)
which is correct for any
type, but not ultimately that useful. Using #[derive(Arbitrary)]
will
create a better implementation. If you are writing an Arbitrary
implementation by hand, and your type can be part of a dynamically sized
collection (such as Vec
), you are strongly encouraged to override this
default with a better implementation, and also override
try_size_hint
.
§How to implement this
If the size hint calculation is a trivial constant and does not recurse
into any other size_hint
call, you should implement it in size_hint
:
use arbitrary::{size_hint, Arbitrary, Result, Unstructured};
struct SomeStruct(u8);
impl<'a> Arbitrary<'a> for SomeStruct {
fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
let buf = &mut [0];
u.fill_buffer(buf)?;
Ok(SomeStruct(buf[0]))
}
#[inline]
fn size_hint(depth: usize) -> (usize, Option<usize>) {
let _ = depth;
(1, Some(1))
}
}
Otherwise, it should instead be implemented in try_size_hint
,
and the size_hint
implementation should forward to it:
use arbitrary::{size_hint, Arbitrary, MaxRecursionReached, Result, Unstructured};
struct SomeStruct<A, B> {
a: A,
b: B,
}
impl<'a, A: Arbitrary<'a>, B: Arbitrary<'a>> Arbitrary<'a> for SomeStruct<A, B> {
fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> {
// ...
}
fn size_hint(depth: usize) -> (usize, Option<usize>) {
// Return the value of try_size_hint
//
// If the recursion fails, return the default, always valid `(0, None)`
Self::try_size_hint(depth).unwrap_or_default()
}
fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), MaxRecursionReached> {
// Protect against potential infinite recursion with
// `try_recursion_guard`.
size_hint::try_recursion_guard(depth, |depth| {
// If we aren't too deep, then `recursion_guard` calls
// this closure, which implements the natural size hint.
// Don't forget to use the new `depth` in all nested
// `try_size_hint` calls! We recommend shadowing the
// parameter, like what is done here, so that you can't
// accidentally use the wrong depth.
Ok(size_hint::and(
<A as Arbitrary>::try_size_hint(depth)?,
<B as Arbitrary>::try_size_hint(depth)?,
))
})
}
}
§Invariant
It must be possible to construct every possible output using only inputs
of lengths bounded by these parameters. This applies to both
Arbitrary::arbitrary
and Arbitrary::arbitrary_take_rest
.
This is trivially true for (0, None)
. To restrict this further, it
must be proven that all inputs that are now excluded produced redundant
outputs which are still possible to produce using the reduced input
space.
fn try_size_hint(
depth: usize,
) -> Result<(usize, Option<usize>), MaxRecursionReached>
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Get a size hint for how many bytes out of an Unstructured
this type
needs to construct itself.
Unlike size_hint
, this function keeps the information that the
recursion limit was reached. This is required to “short circuit” the
calculation and avoid exponential blowup with recursive structures.
If you are implementing size_hint
for a struct that could be
recursive, you should implement try_size_hint
and call the
try_size_hint
when recursing
The return value is similar to core::iter::Iterator::size_hint
: it
returns a tuple where the first element is a lower bound on the number
of bytes required, and the second element is an optional upper bound.
The default implementation returns the value of size_hint
which is
correct for any type, but might lead to exponential blowup when dealing
with recursive types.
§Invariant
It must be possible to construct every possible output using only inputs
of lengths bounded by these parameters. This applies to both
Arbitrary::arbitrary
and Arbitrary::arbitrary_take_rest
.
This is trivially true for (0, None)
. To restrict this further, it
must be proven that all inputs that are now excluded produced redundant
outputs which are still possible to produce using the reduced input
space.
§When to implement try_size_hint
If you 100% know that the type you are implementing Arbitrary
for is
not a recursive type, or your implementation is not transitively calling
any other size_hint
methods, you may implement size_hint
, and the
default try_size_hint
implementation will use it.
Note that if you are implementing Arbitrary
for a generic type, you
cannot guarantee the lack of type recursion!
Otherwise, when there is possible type recursion, you should implement
try_size_hint
instead.
§The depth
parameter
When implementing try_size_hint
, you need to use
arbitrary::size_hint::try_recursion_guard(depth)
to prevent potential infinite recursion when calculating size hints for
potentially recursive types:
use arbitrary::{size_hint, Arbitrary, MaxRecursionReached, Unstructured};
// This can potentially be a recursive type if `L` or `R` contain
// something like `Box<Option<MyEither<L, R>>>`!
enum MyEither<L, R> {
Left(L),
Right(R),
}
impl<'a, L, R> Arbitrary<'a> for MyEither<L, R>
where
L: Arbitrary<'a>,
R: Arbitrary<'a>,
{
fn arbitrary(u: &mut Unstructured) -> arbitrary::Result<Self> {
// ...
}
fn size_hint(depth: usize) -> (usize, Option<usize>) {
// Return the value of `try_size_hint`
//
// If the recursion fails, return the default `(0, None)` range,
// which is always valid.
Self::try_size_hint(depth).unwrap_or_default()
}
fn try_size_hint(depth: usize) -> Result<(usize, Option<usize>), MaxRecursionReached> {
// Protect against potential infinite recursion with
// `try_recursion_guard`.
size_hint::try_recursion_guard(depth, |depth| {
// If we aren't too deep, then `recursion_guard` calls
// this closure, which implements the natural size hint.
// Don't forget to use the new `depth` in all nested
// `try_size_hint` calls! We recommend shadowing the
// parameter, like what is done here, so that you can't
// accidentally use the wrong depth.
Ok(size_hint::or(
<L as Arbitrary>::try_size_hint(depth)?,
<R as Arbitrary>::try_size_hint(depth)?,
))
})
}
}
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
Implementations on Foreign Types§
§impl Arbitrary<'_> for OpTxType
Available on crate feature arbitrary
only.
impl Arbitrary<'_> for OpTxType
arbitrary
only.fn arbitrary(u: &mut Unstructured<'_>) -> Result<OpTxType, Error>
§impl Arbitrary<'_> for TxType
Available on crate feature arbitrary
only.
impl Arbitrary<'_> for TxType
arbitrary
only.fn arbitrary(u: &mut Unstructured<'_>) -> Result<TxType, Error>
§impl<'a> Arbitrary<'a> for SocketAddr
impl<'a> Arbitrary<'a> for SocketAddr
Source§impl<'a> Arbitrary<'a> for AddressStorageKey
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for AddressStorageKey
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<AddressStorageKey, Error>
Source§impl<'a> Arbitrary<'a> for BlockNumberAddress
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for BlockNumberAddress
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<BlockNumberAddress, Error>
Source§impl<'a> Arbitrary<'a> for Capability
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for Capability
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<Capability, Error>
Source§impl<'a> Arbitrary<'a> for IntegerList
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for IntegerList
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<IntegerList, Error>
§impl<'a> Arbitrary<'a> for PhantomPinned
impl<'a> Arbitrary<'a> for PhantomPinned
§impl<'a> Arbitrary<'a> for SocketAddrV4
impl<'a> Arbitrary<'a> for SocketAddrV4
§impl<'a> Arbitrary<'a> for SocketAddrV6
impl<'a> Arbitrary<'a> for SocketAddrV6
§impl<'a> Arbitrary<'a> for AtomicBool
impl<'a> Arbitrary<'a> for AtomicBool
§impl<'a> Arbitrary<'a> for AtomicIsize
impl<'a> Arbitrary<'a> for AtomicIsize
§impl<'a> Arbitrary<'a> for AtomicUsize
impl<'a> Arbitrary<'a> for AtomicUsize
§impl<'a> Arbitrary<'a> for TxEip4844
Available on crate feature test-utils
only.
impl<'a> Arbitrary<'a> for TxEip4844
test-utils
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<TxEip4844, Error>
§impl<'a, A> Arbitrary<'a> for BinaryHeap<A>
impl<'a, A> Arbitrary<'a> for BinaryHeap<A>
fn arbitrary(u: &mut Unstructured<'a>) -> Result<BinaryHeap<A>, Error>
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<BinaryHeap<A>, Error>
fn size_hint(_depth: usize) -> (usize, Option<usize>)
§impl<'a, A> Arbitrary<'a> for LinkedList<A>where
A: Arbitrary<'a>,
impl<'a, A> Arbitrary<'a> for LinkedList<A>where
A: Arbitrary<'a>,
fn arbitrary(u: &mut Unstructured<'a>) -> Result<LinkedList<A>, Error>
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<LinkedList<A>, Error>
fn size_hint(_depth: usize) -> (usize, Option<usize>)
§impl<'a, A> Arbitrary<'a> for UnsafeCell<A>where
A: Arbitrary<'a>,
impl<'a, A> Arbitrary<'a> for UnsafeCell<A>where
A: Arbitrary<'a>,
fn arbitrary(u: &mut Unstructured<'a>) -> Result<UnsafeCell<A>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, A> Arbitrary<'a> for PhantomData<A>where
A: ?Sized,
impl<'a, A> Arbitrary<'a> for PhantomData<A>where
A: ?Sized,
§impl<'a, A> Arbitrary<'a> for RangeInclusive<A>
impl<'a, A> Arbitrary<'a> for RangeInclusive<A>
fn arbitrary(u: &mut Unstructured<'a>) -> Result<RangeInclusive<A>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, A> Arbitrary<'a> for RangeToInclusive<A>
impl<'a, A> Arbitrary<'a> for RangeToInclusive<A>
fn arbitrary(u: &mut Unstructured<'a>) -> Result<RangeToInclusive<A>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A> Arbitrary<'a> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A)where
B: Arbitrary<'a>,
C: Arbitrary<'a>,
D: Arbitrary<'a>,
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
A: Arbitrary<'a>,
impl<'a, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A> Arbitrary<'a> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A)where
B: Arbitrary<'a>,
C: Arbitrary<'a>,
D: Arbitrary<'a>,
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
A: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B> Arbitrary<'a> for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B)where
C: Arbitrary<'a>,
D: Arbitrary<'a>,
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
B: Arbitrary<'a>,
impl<'a, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B> Arbitrary<'a> for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B)where
C: Arbitrary<'a>,
D: Arbitrary<'a>,
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
B: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, B), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C> Arbitrary<'a> for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C)where
D: Arbitrary<'a>,
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
C: Arbitrary<'a>,
impl<'a, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C> Arbitrary<'a> for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C)where
D: Arbitrary<'a>,
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
C: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, C), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D> Arbitrary<'a> for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D)where
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
D: Arbitrary<'a>,
impl<'a, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D> Arbitrary<'a> for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D)where
E: Arbitrary<'a>,
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
D: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, D), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E> Arbitrary<'a> for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E)where
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
E: Arbitrary<'a>,
impl<'a, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E> Arbitrary<'a> for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E)where
F: Arbitrary<'a>,
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
E: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, E), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F> Arbitrary<'a> for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F)where
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
F: Arbitrary<'a>,
impl<'a, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F> Arbitrary<'a> for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F)where
G: Arbitrary<'a>,
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
F: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, F), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G> Arbitrary<'a> for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G)where
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
G: Arbitrary<'a>,
impl<'a, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G> Arbitrary<'a> for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G)where
H: Arbitrary<'a>,
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
G: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, G), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H> Arbitrary<'a> for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H)where
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
H: Arbitrary<'a>,
impl<'a, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H> Arbitrary<'a> for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H)where
I: Arbitrary<'a>,
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
H: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, H), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I> Arbitrary<'a> for (J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I)where
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
I: Arbitrary<'a>,
impl<'a, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I> Arbitrary<'a> for (J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I)where
J: Arbitrary<'a>,
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
I: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, I), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J> Arbitrary<'a> for (K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J)where
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
J: Arbitrary<'a>,
impl<'a, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J> Arbitrary<'a> for (K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J)where
K: Arbitrary<'a>,
L: Arbitrary<'a>,
M: Arbitrary<'a>,
N: Arbitrary<'a>,
O: Arbitrary<'a>,
P: Arbitrary<'a>,
Q: Arbitrary<'a>,
R: Arbitrary<'a>,
S: Arbitrary<'a>,
T: Arbitrary<'a>,
U: Arbitrary<'a>,
V: Arbitrary<'a>,
W: Arbitrary<'a>,
X: Arbitrary<'a>,
Y: Arbitrary<'a>,
Z: Arbitrary<'a>,
J: Arbitrary<'a>,
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, J), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K> Arbitrary<'a> for (L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K)
impl<'a, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K> Arbitrary<'a> for (L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, K), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L> Arbitrary<'a> for (M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L)
impl<'a, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L> Arbitrary<'a> for (M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, L), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M> Arbitrary<'a> for (N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M)
impl<'a, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M> Arbitrary<'a> for (N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(N, O, P, Q, R, S, T, U, V, W, X, Y, Z, M), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, O, P, Q, R, S, T, U, V, W, X, Y, Z, N> Arbitrary<'a> for (O, P, Q, R, S, T, U, V, W, X, Y, Z, N)
impl<'a, O, P, Q, R, S, T, U, V, W, X, Y, Z, N> Arbitrary<'a> for (O, P, Q, R, S, T, U, V, W, X, Y, Z, N)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(O, P, Q, R, S, T, U, V, W, X, Y, Z, N), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(O, P, Q, R, S, T, U, V, W, X, Y, Z, N), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, P, Q, R, S, T, U, V, W, X, Y, Z, O> Arbitrary<'a> for (P, Q, R, S, T, U, V, W, X, Y, Z, O)
impl<'a, P, Q, R, S, T, U, V, W, X, Y, Z, O> Arbitrary<'a> for (P, Q, R, S, T, U, V, W, X, Y, Z, O)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(P, Q, R, S, T, U, V, W, X, Y, Z, O), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(P, Q, R, S, T, U, V, W, X, Y, Z, O), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, Q, R, S, T, U, V, W, X, Y, Z, P> Arbitrary<'a> for (Q, R, S, T, U, V, W, X, Y, Z, P)
impl<'a, Q, R, S, T, U, V, W, X, Y, Z, P> Arbitrary<'a> for (Q, R, S, T, U, V, W, X, Y, Z, P)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(Q, R, S, T, U, V, W, X, Y, Z, P), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(Q, R, S, T, U, V, W, X, Y, Z, P), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, R, S, T, U, V, W, X, Y, Z, Q> Arbitrary<'a> for (R, S, T, U, V, W, X, Y, Z, Q)
impl<'a, R, S, T, U, V, W, X, Y, Z, Q> Arbitrary<'a> for (R, S, T, U, V, W, X, Y, Z, Q)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(R, S, T, U, V, W, X, Y, Z, Q), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(R, S, T, U, V, W, X, Y, Z, Q), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, S, T, U, V, W, X, Y, Z, R> Arbitrary<'a> for (S, T, U, V, W, X, Y, Z, R)
impl<'a, S, T, U, V, W, X, Y, Z, R> Arbitrary<'a> for (S, T, U, V, W, X, Y, Z, R)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(S, T, U, V, W, X, Y, Z, R), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(S, T, U, V, W, X, Y, Z, R), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, T> Arbitrary<'a> for OpDepositReceipt<T>where
T: Arbitrary<'a>,
Available on crate feature arbitrary
only.
impl<'a, T> Arbitrary<'a> for OpDepositReceipt<T>where
T: Arbitrary<'a>,
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<OpDepositReceipt<T>, Error>
§impl<'a, T> Arbitrary<'a> for OpDepositReceiptWithBloom<T>where
T: Arbitrary<'a>,
Available on crate feature arbitrary
only.
impl<'a, T> Arbitrary<'a> for OpDepositReceiptWithBloom<T>where
T: Arbitrary<'a>,
arbitrary
only.fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<OpDepositReceiptWithBloom<T>, Error>
§impl<'a, T, U, V, W, X, Y, Z, S> Arbitrary<'a> for (T, U, V, W, X, Y, Z, S)
impl<'a, T, U, V, W, X, Y, Z, S> Arbitrary<'a> for (T, U, V, W, X, Y, Z, S)
fn arbitrary( u: &mut Unstructured<'a>, ) -> Result<(T, U, V, W, X, Y, Z, S), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(T, U, V, W, X, Y, Z, S), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, U, V, W, X, Y, Z, T> Arbitrary<'a> for (U, V, W, X, Y, Z, T)
impl<'a, U, V, W, X, Y, Z, T> Arbitrary<'a> for (U, V, W, X, Y, Z, T)
fn arbitrary(u: &mut Unstructured<'a>) -> Result<(U, V, W, X, Y, Z, T), Error>
fn arbitrary_take_rest( u: Unstructured<'a>, ) -> Result<(U, V, W, X, Y, Z, T), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, V, W, X, Y, Z, U> Arbitrary<'a> for (V, W, X, Y, Z, U)
impl<'a, V, W, X, Y, Z, U> Arbitrary<'a> for (V, W, X, Y, Z, U)
fn arbitrary(u: &mut Unstructured<'a>) -> Result<(V, W, X, Y, Z, U), Error>
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<(V, W, X, Y, Z, U), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, W, X, Y, Z, V> Arbitrary<'a> for (W, X, Y, Z, V)
impl<'a, W, X, Y, Z, V> Arbitrary<'a> for (W, X, Y, Z, V)
fn arbitrary(u: &mut Unstructured<'a>) -> Result<(W, X, Y, Z, V), Error>
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<(W, X, Y, Z, V), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'a, X, Y, Z, W> Arbitrary<'a> for (X, Y, Z, W)
impl<'a, X, Y, Z, W> Arbitrary<'a> for (X, Y, Z, W)
fn arbitrary(u: &mut Unstructured<'a>) -> Result<(X, Y, Z, W), Error>
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<(X, Y, Z, W), Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for P2PMessage
impl<'arbitrary> Arbitrary<'arbitrary> for P2PMessage
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<P2PMessage, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<P2PMessage, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for HeadersDirection
impl<'arbitrary> Arbitrary<'arbitrary> for HeadersDirection
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<HeadersDirection, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HeadersDirection, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for EthVersion
impl<'arbitrary> Arbitrary<'arbitrary> for EthVersion
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<EthVersion, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<EthVersion, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for ProtocolVersion
impl<'arbitrary> Arbitrary<'arbitrary> for ProtocolVersion
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<ProtocolVersion, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<ProtocolVersion, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for PruneMode
impl<'arbitrary> Arbitrary<'arbitrary> for PruneMode
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<PruneMode, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<PruneMode, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StageUnitCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for StageUnitCheckpoint
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StageUnitCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StageUnitCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockOmmers
impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockOmmers
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredBlockOmmers, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredBlockOmmers, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for CompactClientVersion
impl<'arbitrary> Arbitrary<'arbitrary> for CompactClientVersion
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<CompactClientVersion, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<CompactClientVersion, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for CompactU64
impl<'arbitrary> Arbitrary<'arbitrary> for CompactU64
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<CompactU64, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<CompactU64, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for CompactU256
impl<'arbitrary> Arbitrary<'arbitrary> for CompactU256
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<CompactU256, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<CompactU256, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for AccountBeforeTx
impl<'arbitrary> Arbitrary<'arbitrary> for AccountBeforeTx
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<AccountBeforeTx, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<AccountBeforeTx, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockBodyIndices
impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockBodyIndices
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredBlockBodyIndices, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredBlockBodyIndices, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockWithdrawals
impl<'arbitrary> Arbitrary<'arbitrary> for StoredBlockWithdrawals
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredBlockWithdrawals, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredBlockWithdrawals, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for ClientVersion
impl<'arbitrary> Arbitrary<'arbitrary> for ClientVersion
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<ClientVersion, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<ClientVersion, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for HelloMessage
impl<'arbitrary> Arbitrary<'arbitrary> for HelloMessage
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<HelloMessage, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HelloMessage, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for GetBlockBodies
impl<'arbitrary> Arbitrary<'arbitrary> for GetBlockBodies
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetBlockBodies, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetBlockBodies, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for GetBlockHeaders
impl<'arbitrary> Arbitrary<'arbitrary> for GetBlockHeaders
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetBlockHeaders, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetBlockHeaders, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for BlockHashNumber
impl<'arbitrary> Arbitrary<'arbitrary> for BlockHashNumber
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BlockHashNumber, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlockHashNumber, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for NewBlockHashes
impl<'arbitrary> Arbitrary<'arbitrary> for NewBlockHashes
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<NewBlockHashes, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<NewBlockHashes, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for NewPooledTransactionHashes66
impl<'arbitrary> Arbitrary<'arbitrary> for NewPooledTransactionHashes66
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<NewPooledTransactionHashes66, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<NewPooledTransactionHashes66, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<SharedTransactions, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<SharedTransactions, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for Transactions
impl<'arbitrary> Arbitrary<'arbitrary> for Transactions
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Transactions, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Transactions, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for GetReceipts
impl<'arbitrary> Arbitrary<'arbitrary> for GetReceipts
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetReceipts, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetReceipts, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for Receipts
impl<'arbitrary> Arbitrary<'arbitrary> for Receipts
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Receipts, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Receipts, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for GetNodeData
impl<'arbitrary> Arbitrary<'arbitrary> for GetNodeData
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GetNodeData, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetNodeData, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for NodeData
impl<'arbitrary> Arbitrary<'arbitrary> for NodeData
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<NodeData, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<NodeData, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for Status
impl<'arbitrary> Arbitrary<'arbitrary> for Status
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Status, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Status, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for GetPooledTransactions
impl<'arbitrary> Arbitrary<'arbitrary> for GetPooledTransactions
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<GetPooledTransactions, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GetPooledTransactions, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for PruneCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for PruneCheckpoint
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<PruneCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<PruneCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for AccountHashingCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for AccountHashingCheckpoint
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<AccountHashingCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<AccountHashingCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for CheckpointBlockRange
impl<'arbitrary> Arbitrary<'arbitrary> for CheckpointBlockRange
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<CheckpointBlockRange, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<CheckpointBlockRange, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for EntitiesCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for EntitiesCheckpoint
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<EntitiesCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<EntitiesCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for ExecutionCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for ExecutionCheckpoint
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<ExecutionCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<ExecutionCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for HeadersCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for HeadersCheckpoint
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<HeadersCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HeadersCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for IndexHistoryCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for IndexHistoryCheckpoint
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<IndexHistoryCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<IndexHistoryCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StageCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for StageCheckpoint
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<StageCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StageCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StorageHashingCheckpoint
impl<'arbitrary> Arbitrary<'arbitrary> for StorageHashingCheckpoint
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StorageHashingCheckpoint, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StorageHashingCheckpoint, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for HashBuilderState
impl<'arbitrary> Arbitrary<'arbitrary> for HashBuilderState
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<HashBuilderState, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HashBuilderState, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StoredNibbles
impl<'arbitrary> Arbitrary<'arbitrary> for StoredNibbles
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<StoredNibbles, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredNibbles, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary> Arbitrary<'arbitrary> for StoredNibblesSubKey
impl<'arbitrary> Arbitrary<'arbitrary> for StoredNibblesSubKey
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<StoredNibblesSubKey, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<StoredNibblesSubKey, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for AnyHeader
impl<'arbitrary> Arbitrary<'arbitrary> for AnyHeader
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<AnyHeader, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<AnyHeader, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for Authorization
impl<'arbitrary> Arbitrary<'arbitrary> for Authorization
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Authorization, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Authorization, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for Eip658Value
impl<'arbitrary> Arbitrary<'arbitrary> for Eip658Value
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Eip658Value, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Eip658Value, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for GenesisAccount
impl<'arbitrary> Arbitrary<'arbitrary> for GenesisAccount
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<GenesisAccount, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<GenesisAccount, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for HashOrNumber
impl<'arbitrary> Arbitrary<'arbitrary> for HashOrNumber
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<HashOrNumber, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<HashOrNumber, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for Header
impl<'arbitrary> Arbitrary<'arbitrary> for Header
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Header, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Header, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for HeaderExt
impl<'arbitrary> Arbitrary<'arbitrary> for HeaderExt
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<HeaderExt, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<HeaderExt, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for Nibbles
impl<'arbitrary> Arbitrary<'arbitrary> for Nibbles
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Nibbles, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Nibbles, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for OpTypedTransaction
impl<'arbitrary> Arbitrary<'arbitrary> for OpTypedTransaction
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<OpTypedTransaction, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<OpTypedTransaction, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for Requests
impl<'arbitrary> Arbitrary<'arbitrary> for Requests
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Requests, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Requests, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TrieMask
impl<'arbitrary> Arbitrary<'arbitrary> for TrieMask
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TrieMask, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TrieMask, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxDeposit
impl<'arbitrary> Arbitrary<'arbitrary> for TxDeposit
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxDeposit, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxDeposit, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxDeposit
impl<'arbitrary> Arbitrary<'arbitrary> for TxDeposit
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxDeposit, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxDeposit, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip1559
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip1559
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip1559, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip1559, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip1559
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip1559
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip1559, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip1559, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip2930
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip2930
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip2930, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip2930, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip2930
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip2930
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip2930, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip2930, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip4844, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip4844, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip7702
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip7702
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip7702, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip7702, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip7702
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip7702
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxEip7702, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxEip7702, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844Variant
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844Variant
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<TxEip4844Variant, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<TxEip4844Variant, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844WithSidecar
impl<'arbitrary> Arbitrary<'arbitrary> for TxEip4844WithSidecar
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<TxEip4844WithSidecar, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<TxEip4844WithSidecar, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxLegacy
impl<'arbitrary> Arbitrary<'arbitrary> for TxLegacy
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxLegacy, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxLegacy, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for TxLegacy
impl<'arbitrary> Arbitrary<'arbitrary> for TxLegacy
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxLegacy, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxLegacy, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary> Arbitrary<'arbitrary> for Withdrawal
impl<'arbitrary> Arbitrary<'arbitrary> for Withdrawal
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Withdrawal, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Withdrawal, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary, B> Arbitrary<'arbitrary> for BlockBodies<B>where
B: Arbitrary<'arbitrary>,
impl<'arbitrary, B> Arbitrary<'arbitrary> for BlockBodies<B>where
B: Arbitrary<'arbitrary>,
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BlockBodies<B>, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlockBodies<B>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary, B> Arbitrary<'arbitrary> for NewBlock<B>where
B: Arbitrary<'arbitrary>,
impl<'arbitrary, B> Arbitrary<'arbitrary> for NewBlock<B>where
B: Arbitrary<'arbitrary>,
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<NewBlock<B>, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<NewBlock<B>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Source§impl<'arbitrary, H> Arbitrary<'arbitrary> for BlockHeaders<H>where
H: Arbitrary<'arbitrary>,
impl<'arbitrary, H> Arbitrary<'arbitrary> for BlockHeaders<H>where
H: Arbitrary<'arbitrary>,
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BlockHeaders<H>, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BlockHeaders<H>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'u> Arbitrary<'u> for HashBuilderValue
Available on crate feature arbitrary
only.
impl<'u> Arbitrary<'u> for HashBuilderValue
arbitrary
only.fn arbitrary(g: &mut Unstructured<'u>) -> Result<HashBuilderValue, Error>
§impl<'u> Arbitrary<'u> for RlpNode
Available on crate feature arbitrary
only.
impl<'u> Arbitrary<'u> for RlpNode
arbitrary
only.fn arbitrary(g: &mut Unstructured<'u>) -> Result<RlpNode, Error>
Implementors§
impl Arbitrary<'_> for OtherFields
impl<'a> Arbitrary<'a> for PooledTransactionsElement
arbitrary
only.impl<'a> Arbitrary<'a> for Transaction
arbitrary
only.impl<'a> Arbitrary<'a> for Block
arbitrary
only.impl<'a> Arbitrary<'a> for BlockBody
arbitrary
only.impl<'a> Arbitrary<'a> for reth::primitives::Header
arbitrary
only.impl<'a> Arbitrary<'a> for reth::primitives::Receipt
arbitrary
only.impl<'a> Arbitrary<'a> for SealedBlockWithSenders
arbitrary
only.impl<'a> Arbitrary<'a> for SealedHeader
arbitrary
only.impl<'a> Arbitrary<'a> for TransactionSigned
arbitrary
only.impl<'a> Arbitrary<'a> for TransactionSignedNoHash
arbitrary
only.impl<'a> Arbitrary<'a> for Bloom
impl<'a> Arbitrary<'a> for Function
impl<'a> Arbitrary<'a> for PrimitiveSignature
arbitrary
only.impl<'a> Arbitrary<'a> for Signature
arbitrary
only.impl<'a> Arbitrary<'a> for SignedAuthorization
arbitrary
and k256
only.impl<'a> Arbitrary<'a> for Address
impl<'a> Arbitrary<'a> for Bytes
arbitrary
only.impl<'a> Arbitrary<'a> for BlobTransactionSidecar
arbitrary
only.impl<'a> Arbitrary<'a> for Chain
arbitrary
only.impl<'a, A, S> Arbitrary<'a> for HashSet<A, S>
impl<'a, H, B> Arbitrary<'a> for SealedBlock<H, B>
arbitrary
only.impl<'a, K, V, S> Arbitrary<'a> for HashMap<K, V, S>
impl<'a, T> Arbitrary<'a> for ReceiptEnvelope<T>where
T: Arbitrary<'a>,
arbitrary
only.impl<'a, T> Arbitrary<'a> for Sealed<T>
arbitrary
only.impl<'a, T> Arbitrary<'a> for reth::rpc::types::ReceiptWithBloom<T>where
T: Arbitrary<'a>,
arbitrary
only.