gpp-solver 0.2.1

A small hybrid push-pull solver/planner that has the best of both worlds
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::{
    reexported::{test, Box, Vec},
    test::CONCURRENCY,
    FragmentId, Problem, Solver, Status,
};
use async_trait::async_trait;
use void::Void;

struct PanicProblem;

#[async_trait]
impl Problem for PanicProblem {
    type Error = Void;

    async fn direct_dependencies(
        &self,
        _: FragmentId,
        _: &mut Vec<FragmentId>,
    ) {
        unreachable!()
    }

    async fn evaluate(&self, _: FragmentId) -> Result<(), Self::Error> {
        unreachable!()
    }
}

#[test]
async fn empty_solver_status_should_be_done() {
    assert_eq!(Solver::new(()).status().await, Status::Done);
}

#[test]
async fn empty_solver_punted_iter_must_be_empty() {
    assert_eq!(Solver::new(()).punted_iter().await.first(), None);
}

#[test]
async fn non_empty_unexecuted_solver_status_should_be_pending() {
    assert_eq!(
        Solver::new(())
            .enqueue_fragment(0.into())
            .await
            .status()
            .await,
        Status::Pending,
    );
}

#[test]
async fn non_empty_unexecuted_solver_punted_iter_must_be_empty() {
    assert_eq!(
        Solver::new(())
            .enqueue_fragment(0.into())
            .await
            .punted_iter()
            .await
            .first(),
        None,
    );
}

#[test]
async fn stepping_an_empty_solver_must_return_ok_false() {
    assert_eq!(Solver::new(PanicProblem).step().await, Ok(false));
}

#[test]
async fn running_an_empty_solver_must_return_ok_wth_an_empty_iterator() {
    assert_eq!(
        Solver::new(PanicProblem)
            .run(CONCURRENCY)
            .await
            .unwrap()
            .first(),
        None
    );
}