loole 0.4.1

A safe async/sync multi-producer, multi-consumer channel
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

use loole as flume;

use flume::*;

#[async_std::test]
async fn sender() {
    let (sender, receiver) = bounded(1);

    let sender_fut = sender.send_async(());
    assert_eq!(sender.is_closed(), sender_fut.is_closed());
    assert_eq!(sender.is_empty(), sender_fut.is_empty());
    assert_eq!(sender.is_full(), sender_fut.is_full());
    assert_eq!(sender.len(), sender_fut.len());
    assert_eq!(sender.capacity(), sender_fut.capacity());

    let sender_sink = sender.sink();
    assert_eq!(sender.is_closed(), sender_sink.is_closed());
    assert_eq!(sender.is_empty(), sender_sink.is_empty());
    assert_eq!(sender.is_full(), sender_sink.is_full());
    assert_eq!(sender.len(), sender_sink.len());
    assert_eq!(sender.capacity(), sender_sink.capacity());

    let receiver_fut = receiver.recv_async();
    assert_eq!(receiver.is_closed(), receiver_fut.is_closed());
    assert_eq!(receiver.is_empty(), receiver_fut.is_empty());
    assert_eq!(receiver.is_full(), receiver_fut.is_full());
    assert_eq!(receiver.len(), receiver_fut.len());
    assert_eq!(receiver.capacity(), receiver_fut.capacity());

    let receiver_stream = receiver.stream();
    assert_eq!(
        receiver.is_closed(),
        receiver_stream.is_closed()
    );
    assert_eq!(receiver.is_empty(), receiver_stream.is_empty());
    assert_eq!(receiver.is_full(), receiver_stream.is_full());
    assert_eq!(receiver.len(), receiver_stream.len());
    assert_eq!(receiver.capacity(), receiver_stream.capacity());
}