#[cfg(test)]
#[cfg(feature = "channel")]
mod tests {
    use rspc::transport::{channel, ClientTransporter, ServerTransporter};

    pub struct MyStruct {
        my_vec: Vec<String>,
    }

    #[rspc::service]
    impl MyStruct {
        pub fn len(&self) -> usize {
            self.my_vec.len()
        }

        pub fn push(&mut self, val: String) {
            self.my_vec.push(val)
        }

        pub fn pop(&mut self) -> Option<String> {
            self.my_vec.pop()
        }
    }

    #[tokio::test]
    async fn test() {
        let my_data = MyStruct { my_vec: Vec::new() };
        let (c, s) = channel::new_sync();

        let srv_thread = tokio::spawn(async move {
            let mut server = MyStructServer::from(my_data);
            server.listen(s).await
        });

        let client = MyStructClient::new(c);
        assert_eq!(client.len().await.unwrap(), 0);
        client.push("Hello world!".to_string()).await.unwrap();
        assert_eq!(client.len().await.unwrap(), 1);
        assert_eq!(
            client.pop().await.unwrap(),
            Some("Hello world!".to_string())
        );
        client.stop().await.unwrap();
        srv_thread.await.unwrap().unwrap();
    }
}