rustupolis 0.0.2

An implementation of the tuple space data structure in Rust.
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#[macro_use]
extern crate rustupolis;
use futures::executor;
use rustupolis::space::Space;
use rustupolis::store::SimpleStore;
use rustupolis::tuple::E;

// extern crate futures;
// use std::future::task::Unpark;
// use std::future::Async;
// use std::future::Future;

/// This test is faulty for now and results in a infinite loop when run with Travis CI.
// #[ignore]
#[test]
fn test_in() {
    pretty_env_logger::init();

    // Tests insertion and retrieval of tuples into/from a SimpleStore space.
    // create new space
    let mut sp = Space::new(SimpleStore::new());

    // insert tuple 1
    let tuple1 = tuple![E::str("foo"), E::I(42)];
    let out_future1 = sp.tuple_out(tuple1);
    let out_result1 = executor::block_on(out_future1);

    if let Err(e) = out_result1 {
        assert!(false, "{:?}", e)
    }

    // match insertion_result {
    //     Match::Done(Err(e)) => assert!(false, "{:?}", e),
    //     Match::Pending(_) => {}
    // }

    // insert tuple 2
    let tuple2 = tuple![E::I(41)];
    let out_future2 = sp.tuple_out(tuple2);
    let out_result2 = executor::block_on(out_future2);

    if let Err(e) = out_result2 {
        assert!(false, "{:?}", e)
    }

    // retrieve tuple 1 and 2
    let retrieval_future = sp.tuple_in(tuple![E::str("foo"), E::Any]);
    let retrieval_result = executor::block_on(retrieval_future);

    match retrieval_result {
        Some(ref t) => assert_eq!(t, &tuple![E::str("foo"), E::I(42)]),
        a => assert!(false, "{:?}", a),
    };
}