pub fn do_fuzz_one(&mut self, shared: &mut[u8]) -> Result<(), String> {
        if self.info.total > self.limit {
            return Err(format!("[state] out of fuzzing limit total : {:?} > limit : {:?}",
                    self.info.total, self.limit))
        }
        self.info.total += 1;
        let fd = self.info.fd.clone();
        let mut dead = false;

        let bananaq = &self.info.bananaq;

        let mut i = 0;
        for _ in 0u32.. {
            i += 1;
            if !bananaq::is_active(&self.info.bananaq())? {
                break
            }

            self.ccache.1 = rand::thread_rng().gen_range(0..self.groups[self.ccache.0].len());
            if !self.call_view().dead(self.dead_ratio) 
                && self.groups[self.ccache.0][self.ccache.1]
                    .do_call(&bananaq, &fd.data(), shared) 
            { return Ok(()) }

            thread::sleep(Duration::from_nanos(1));

            if self.groups[self.ccache.0]
                .iter()
                .any(|ref call| !call.dead(self.dead_ratio)) { continue }
            dead = true;
            break 
        }
        self.call_dtor(shared);

        Err(format!("[state] end of fuzzing cycle for this object <{:?}::{:?}>, is dead : {:?}; fuzzing attempts for this round : {:?}, total fuzzed calls : {:?} -> {}\n\t==> w/ shared<{:?}>", self.info.name, fd.data(), dead, i, self.info.total, if self.ccache.0 < self.groups.len() && self.ccache.1 < self.groups[self.ccache.0].len() { self.call_view().name() } else { "no-call-yet" }, &shared))
    }
/// select random one from current level
///
/// - maybe intercorporate some ranking of OK syscalls - aka prefer some syscalls at current level
///     - heatmaps, reinforcement learning, other algorithm
///     - currently is opt-ed to do it via modules, but it is perf overkill
///     - therefore if once decide for particular algorithm should be implemented here and
///     switched by config
/// - also some blacklisting of too often rejected call - very OK by modules
/// - and maybe tracking uniformity of selection globaly per State - forbid prefering one syscall by thread_rng ?
///     - in general this can be crucial part of fuzzer which i neglected to tinker with yet..
select random one from current level
maybe intercorporate some ranking of OK syscalls - aka prefer some syscalls at current level
heatmaps, reinforcement learning, other algorithm
currently is opt-ed to do it via modules, but it is perf overkill
therefore if once decide for particular algorithm should be implemented here and
switched by config
also some blacklisting of too often rejected call - very OK by modules
and maybe tracking uniformity of selection globaly per State - forbid prefering one syscall by thread_rng .
in general this can be crucial part of fuzzer which i neglected to tinker with yet
select random one from current level maybe intercorporate some ranking of OK syscalls - aka prefer some syscalls at current level heatmaps reinforcement learning other algorithm currently is opt - ed to do it via modules but it is perf overkill therefore if once decide for particular algorithm should be implemented here and switched by config also some blacklisting of too often rejected call - very OK by modules and maybe tracking uniformity of selection globaly per State - forbid prefering one syscall by thread_rng . in general this can be crucial part of fuzzer which i neglected to tinker with yet
pub fn do_fuzz_one(&mut self, shared: &mut[u8]) -> Result<(), String> {
        if self.info.total > self.limit {
            return Err(format!("[state] out of fuzzing limit total : {:?} > limit : {:?}",
                    self.info.total, self.limit))
        }
        self.info.total += 1;
        let fd = self.info.fd.clone();
        let mut dead = false;
        let bananaq = &self.info.bananaq;
        let mut i = 0;
        for _ in 0u32.. {
            i += 1;
            if !bananaq::is_active(&self.info.bananaq())? {
                break
            }
            self.ccache.1 = rand::thread_rng().gen_range(0..self.groups[self.ccache.0].len());
            if !self.call_view().dead(self.dead_ratio) 
                && self.groups[self.ccache.0][self.ccache.1]
                    .do_call(&bananaq, &fd.data(), shared) 
            { return Ok(()) }
            thread::sleep(Duration::from_nanos(1));
            if self.groups[self.ccache.0]
                .iter()
                .any(|ref call| !call.dead(self.dead_ratio)) { continue }
            dead = true;
            break 
        }
        self.call_dtor(shared);
        Err(format!("[state] end of fuzzing cycle for this object <{:?}::{:?}>, is dead : {:?}; fuzzing attempts for this round : {:?}, total fuzzed calls : {:?} -> {}\n\t==> w/ shared<{:?}>", self.info.name, fd.data(), dead, i, self.info.total, if self.ccache.0 < self.groups.len() && self.ccache.1 < self.groups[self.ccache.0].len() { self.call_view().name() } else { "no-call-yet" }, &shared))
    }
pub fn do_fuzz_one ( & mut self , shared : & mut [ u8 ] ) -> Result < ( ) , String > { if self . info . total > self . limit { return Err ( format ! ( " " self info total self limit ) ) } self . info . total += 1 ; let fd = self . info . fd . clone ( ) ; let mut dead = false ; let bananaq = & self . info . bananaq ; let mut i = 0 ; for _ in 0u32 .. { i += 1 ; if ! bananaq :: is_active ( & self . info . bananaq ( ) ) ? { break } self . ccache . 1 = rand :: thread_rng ( ) . gen_range ( 0 .. self . groups [ self . ccache . 0 ] . len ( ) ) ; if ! self . call_view ( ) . dead ( self . dead_ratio ) && self . groups [ self . ccache . 0 ] [ self . ccache . 1 ] . do_call ( & bananaq , & fd . data ( ) , shared ) { return Ok ( ( ) ) } thread :: sleep ( Duration :: from_nanos ( 1 ) ) ; if self . groups [ self . ccache . 0 ] . iter ( ) . any ( | ref call | ! call . dead ( self . dead_ratio ) ) { continue } dead = true ; break } self . call_dtor ( shared ) ; Err ( format ! ( " \n \t " self info name fd data ( ) dead i self info total if self ccache 0 self groups len ( ) self ccache 1 self groups [ self ccache 0 ] len ( ) { self call_view ( ) name ( ) } else { " " } shared ) ) }
select random one from current level
 maybe intercorporate some ranking of OK syscalls - aka prefer some syscalls at current level
 heatmaps, reinforcement learning, other algorithm
 currently is opt-ed to do it via modules, but it is perf overkill
 therefore if once decide for particular algorithm should be implemented here and
switched by config
 also some blacklisting of too often rejected call - very OK by modules
 and maybe tracking uniformity of selection globaly per State - forbid prefering one syscall by thread_rng ?
select random one from current level maybe intercorporate some ranking of OK syscalls - aka prefer some syscalls at current level heatmaps reinforcement learning other algorithm currently is opt - ed to do it via modules but it is perf overkill therefore if once decide for particular algorithm should be implemented here and switched by config also some blacklisting of too often rejected call - very OK by modules and maybe tracking uniformity of selection globaly per State - forbid prefering one syscall by thread_rng ?
&mut self
shared
&mut[u8]
&mut self
shared
&mut[u8]