async fn try_next_request(&mut self) -> Option<ResponseSender<Request, Response, Error>> {
        loop {
            match timeout(self.max_request_delay, self.receiver.recv()).await {
                Ok(Ok(item)) => {
                    if let Some(proxy_item) = item.lock().await.take() {
                        return Some(proxy_item);
                    }
                }
                Ok(Err(RecvError::Lagged(_))) => continue,
                Ok(Err(RecvError::Closed)) => unreachable!("Sender is never closed"),
                Err(_timeout) => return None,
            }
        }
    }
/// Try to get the next request received.
///
/// Returns the next element in the queue. If the queue is empty, waits at most the max request
/// delay configured by [`MockServiceBuilder::with_max_request_delay`] for a request, and
/// returns it.
///
/// If no request is received, returns `None`.
///
/// If too many requests are received and the queue fills up, the oldest requests are dropped
/// and ignored. This means that calling this may not receive the next request if the queue is
/// not dimensioned properly with the [`MockServiceBuilder::with_proxy_channel_size`] method.
Try to get the next request received.
Returns the next element in the queue. If the queue is empty, waits at most the max request
delay configured by [`MockServiceBuilder::with_max_request_delay`] for a request, and
returns it.

If no request is received, returns `None`.

If too many requests are received and the queue fills up, the oldest requests are dropped
and ignored. This means that calling this may not receive the next request if the queue is
not dimensioned properly with the [`MockServiceBuilder::with_proxy_channel_size`] method.
Try to get the next request received . Returns the next element in the queue . If the queue is empty waits at most the max request delay configured by [ ` MockServiceBuilder :: with_max_request_delay ` ] for a request and returns it . If no request is received returns ` None ` . If too many requests are received and the queue fills up the oldest requests are dropped and ignored . This means that calling this may not receive the next request if the queue is not dimensioned properly with the [ ` MockServiceBuilder :: with_proxy_channel_size ` ] method .
async fn try_next_request(&mut self) -> Option<ResponseSender<Request, Response, Error>> {
        loop {
            match timeout(self.max_request_delay, self.receiver.recv()).await {
                Ok(Ok(item)) => {
                    if let Some(proxy_item) = item.lock().await.take() {
                        return Some(proxy_item);
                    }
                }
                Ok(Err(RecvError::Lagged(_))) => continue,
                Ok(Err(RecvError::Closed)) => unreachable!("Sender is never closed"),
                Err(_timeout) => return None,
            }
        }
    }
async fn try_next_request ( & mut self ) -> Option < ResponseSender < Request , Response , Error > > { loop { match timeout ( self . max_request_delay , self . receiver . recv ( ) ) . await { Ok ( Ok ( item ) ) => { if let Some ( proxy_item ) = item . lock ( ) . await . take ( ) { return Some ( proxy_item ) ; } } Ok ( Err ( RecvError :: Lagged ( _ ) ) ) => continue , Ok ( Err ( RecvError :: Closed ) ) => unreachable ! ( " " ) , Err ( _timeout ) => return None , } } }
Try to get the next request received.
Try to get the next request received .
&mut self