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 OtherFields
impl Arbitrary<'_> for OtherFields
fn arbitrary(u: &mut Unstructured<'_>) -> Result<OtherFields, 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 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 BlobTransactionSidecar
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for BlobTransactionSidecar
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<BlobTransactionSidecar, Error>
§impl<'a> Arbitrary<'a> for Chain
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for Chain
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<Chain, Error>
§impl<'a> Arbitrary<'a> for PrimitiveSignature
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for PrimitiveSignature
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<PrimitiveSignature, Error>
§impl<'a> Arbitrary<'a> for Signature
Available on crate feature arbitrary
only.
impl<'a> Arbitrary<'a> for Signature
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<Signature, Error>
§impl<'a> Arbitrary<'a> for SignedAuthorization
Available on crate features arbitrary
and k256
only.
impl<'a> Arbitrary<'a> for SignedAuthorization
arbitrary
and k256
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<SignedAuthorization, Error>
§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> Arbitrary<'a> for ReceiptEnvelope<T>where
T: Arbitrary<'a>,
Available on crate feature arbitrary
only.
impl<'a, T> Arbitrary<'a> for ReceiptEnvelope<T>where
T: Arbitrary<'a>,
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<ReceiptEnvelope<T>, Error>
§impl<'a, T> Arbitrary<'a> for ReceiptWithBloom<T>where
T: Arbitrary<'a>,
Available on crate feature arbitrary
only.
impl<'a, T> Arbitrary<'a> for ReceiptWithBloom<T>where
T: Arbitrary<'a>,
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<ReceiptWithBloom<T>, Error>
§impl<'a, T> Arbitrary<'a> for Sealed<T>where
T: for<'b> Arbitrary<'b> + Sealable,
Available on crate feature arbitrary
only.
impl<'a, T> Arbitrary<'a> for Sealed<T>where
T: for<'b> Arbitrary<'b> + Sealable,
arbitrary
only.fn arbitrary(u: &mut Unstructured<'a>) -> Result<Sealed<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>
§impl<'arbitrary> Arbitrary<'arbitrary> for AccessList
impl<'arbitrary> Arbitrary<'arbitrary> for AccessList
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<AccessList, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<AccessList, 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 AccessListItem
impl<'arbitrary> Arbitrary<'arbitrary> for AccessListItem
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<AccessListItem, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<AccessListItem, 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 Account
impl<'arbitrary> Arbitrary<'arbitrary> for Account
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Account, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Account, 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 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 BaseFeeParams
impl<'arbitrary> Arbitrary<'arbitrary> for BaseFeeParams
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<BaseFeeParams, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<BaseFeeParams, 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 Parity
impl<'arbitrary> Arbitrary<'arbitrary> for Parity
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Parity, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Parity, 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 TransactionInput
impl<'arbitrary> Arbitrary<'arbitrary> for TransactionInput
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<TransactionInput, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<TransactionInput, 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 TransactionRequest
impl<'arbitrary> Arbitrary<'arbitrary> for TransactionRequest
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<TransactionRequest, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<TransactionRequest, 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 TxKind
impl<'arbitrary> Arbitrary<'arbitrary> for TxKind
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<TxKind, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<TxKind, 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>
§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>
§impl<'arbitrary> Arbitrary<'arbitrary> for Withdrawals
impl<'arbitrary> Arbitrary<'arbitrary> for Withdrawals
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Withdrawals, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Withdrawals, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary, H> Arbitrary<'arbitrary> for Header<H>where
H: Arbitrary<'arbitrary>,
impl<'arbitrary, H> Arbitrary<'arbitrary> for Header<H>where
H: Arbitrary<'arbitrary>,
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Header<H>, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Header<H>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary, T> Arbitrary<'arbitrary> for Log<T>where
T: Arbitrary<'arbitrary>,
impl<'arbitrary, T> Arbitrary<'arbitrary> for Log<T>where
T: Arbitrary<'arbitrary>,
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Log<T>, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Log<T>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary, T> Arbitrary<'arbitrary> for Receipt<T>where
T: Arbitrary<'arbitrary>,
impl<'arbitrary, T> Arbitrary<'arbitrary> for Receipt<T>where
T: Arbitrary<'arbitrary>,
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Receipt<T>, Error>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Receipt<T>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary, T> Arbitrary<'arbitrary> for TransactionReceipt<T>where
T: Arbitrary<'arbitrary>,
impl<'arbitrary, T> Arbitrary<'arbitrary> for TransactionReceipt<T>where
T: Arbitrary<'arbitrary>,
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<TransactionReceipt<T>, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<TransactionReceipt<T>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary, T> Arbitrary<'arbitrary> for WithOtherFields<T>where
T: Arbitrary<'arbitrary>,
impl<'arbitrary, T> Arbitrary<'arbitrary> for WithOtherFields<T>where
T: Arbitrary<'arbitrary>,
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<WithOtherFields<T>, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<WithOtherFields<T>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary, const BITS: usize, const LIMBS: usize> Arbitrary<'arbitrary> for Signed<BITS, LIMBS>
impl<'arbitrary, const BITS: usize, const LIMBS: usize> Arbitrary<'arbitrary> for Signed<BITS, LIMBS>
fn arbitrary( u: &mut Unstructured<'arbitrary>, ) -> Result<Signed<BITS, LIMBS>, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<Signed<BITS, LIMBS>, Error>
fn size_hint(depth: usize) -> (usize, Option<usize>)
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
§impl<'arbitrary, const N: usize> Arbitrary<'arbitrary> for FixedBytes<N>
impl<'arbitrary, const N: usize> Arbitrary<'arbitrary> for FixedBytes<N>
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<FixedBytes<N>, Error>
fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<FixedBytes<N>, 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<'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, H, B> Arbitrary<'a> for SealedBlock<H, B>
arbitrary
only.