fn write_multi(rng: &mut SmallRng, state: &mut GeneratorState) -> Req {
        // MultiWriteHandle and atomic_write both gracefully handle duplication,
        // so we can simply generate some number of normal writes to perform
        // atomically.
        //
        // NB: We generate up to state.streams.len() writes to apply atomically,
        // but, again, this doesn't mean they are distinct streams. It's just a
        // convenient way to make this scale up proportionally to the number of
        // streams (which may stop being hardcoded in the future).
        let writes = (0..state.streams.len())
            .map(|_| ReqGenerator::write_unsealed(rng, state))
            .collect();
        Req::Write(WriteReq::Multi(WriteReqMulti { writes }))
    }
// NB: Unlike WriteReqSingle, this is always generated so that the timestamp
// will not be sealed. We already cover that error case with write_sealed
// and, given that a single write ends up being mapped to the same code path
// by the time it gets to the Runtime barrier, it's not interesting to also
// test it here.
Unlike WriteReqSingle, this is always generated so that the timestamp
will not be sealed. We already cover that error case with write_sealed
and, given that a single write ends up being mapped to the same code path
by the time it gets to the Runtime barrier, it's not interesting to also
test it here.
Unlike WriteReqSingle this is always generated so that the timestamp will not be sealed . We already cover that error case with write_sealed and given that a single write ends up being mapped to the same code path by the time it gets to the Runtime barrier it ' s not interesting to also test it here .
fn write_multi(rng: &mut SmallRng, state: &mut GeneratorState) -> Req {
        // MultiWriteHandle and atomic_write both gracefully handle duplication,
        // so we can simply generate some number of normal writes to perform
        // atomically.
        //
        // NB: We generate up to state.streams.len() writes to apply atomically,
        // but, again, this doesn't mean they are distinct streams. It's just a
        // convenient way to make this scale up proportionally to the number of
        // streams (which may stop being hardcoded in the future).
        let writes = (0..state.streams.len())
            .map(|_| ReqGenerator::write_unsealed(rng, state))
            .collect();
        Req::Write(WriteReq::Multi(WriteReqMulti { writes }))
    }
fn write_multi ( rng : & mut SmallRng , state : & mut GeneratorState ) -> Req { // MultiWriteHandle and atomic_write both gracefully handle duplication, // so we can simply generate some number of normal writes to perform // atomically. // // NB: We generate up to state.streams.len() writes to apply atomically, // but, again, this doesn't mean they are distinct streams. It's just a // convenient way to make this scale up proportionally to the number of // streams (which may stop being hardcoded in the future). let writes = ( 0 .. state . streams . len ( ) ) . map ( | _ | ReqGenerator :: write_unsealed ( rng , state ) ) . collect ( ) ; Req :: Write ( WriteReq :: Multi ( WriteReqMulti { writes } ) ) }
NB: Unlike WriteReqSingle, this is always generated so that the timestamp
will not be sealed.
NB : Unlike WriteReqSingle this is always generated so that the timestamp will not be sealed .
rng
&mut SmallRng
state
&mut GeneratorState
rng
&mut SmallRng
state
&mut GeneratorState