ferroplan 0.9.0

A fast, data-parallel PDDL planner in Rust — FF heuristic with ADL, numeric, derived axioms, PDDL3 preferences, PDDL2.1 temporal, and a goal decomposer
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Public-API + JSON round-trip tests for the smart `solve` surface.

use ferroplan::{solve, Mode, Options, Solution};

const GRID: &str = "(define (domain g)
 (:requirements :strips :typing)
 (:types loc)
 (:predicates (at ?l - loc) (link ?a - loc ?b - loc))
 (:action move :parameters (?a ?b - loc)
   :precondition (and (at ?a) (link ?a ?b)) :effect (and (at ?b) (not (at ?a)))))";

fn prob(goal: &str) -> String {
    format!(
        "(define (problem p) (:domain g) (:objects x y z - loc)
         (:init (at x) (link x y) (link y z))
         (:goal {goal}))"
    )
}

#[test]
fn solve_returns_structured_plan() {
    let sol = solve(GRID, &prob("(at z)"), &Options::default()).unwrap();
    assert!(sol.solved);
    assert_eq!(sol.mode, Mode::Ff); // no preferences -> classic FF
    let plan = sol.plan.unwrap();
    assert_eq!(plan.length, 2);
    assert_eq!(plan.steps[0].action, "MOVE");
    assert_eq!(plan.steps[0].args, vec!["X", "Y"]);
    assert!(sol.statistics.grounded_actions > 0);
}

#[test]
fn solution_json_round_trips() {
    let sol = solve(GRID, &prob("(at z)"), &Options::default()).unwrap();
    let json = serde_json::to_string(&sol).unwrap();
    let back: Solution = serde_json::from_str(&json).unwrap();
    assert_eq!(back.solved, sol.solved);
    assert_eq!(back.plan.unwrap().length, 2);
    // the serialized form carries structured steps
    assert!(json.contains("\"action\":\"MOVE\""));
}

#[test]
fn unsolvable_goal_reports_unsolved() {
    // z has no link back; goal (at x) after forcing? use an unreachable fact
    let p = "(define (problem p) (:domain g) (:objects x y - loc)
             (:init (at x)) (:goal (at y)))"; // no link x->y
    let sol = solve(GRID, p, &Options::default()).unwrap();
    assert!(!sol.solved);
    assert!(sol.plan.is_none());
}

const TRANSPORT: &str = "(define (domain t)
 (:requirements :strips :typing)
 (:types loc pkg)
 (:predicates (truck-at ?l - loc) (pkg-at ?p - pkg ?l - loc) (in ?p - pkg) (road ?a ?b - loc))
 (:action drive :parameters (?a ?b - loc)
   :precondition (and (truck-at ?a) (road ?a ?b)) :effect (and (truck-at ?b) (not (truck-at ?a))))
 (:action load :parameters (?p - pkg ?l - loc)
   :precondition (and (pkg-at ?p ?l) (truck-at ?l)) :effect (and (in ?p) (not (pkg-at ?p ?l))))
 (:action unload :parameters (?p - pkg ?l - loc)
   :precondition (and (in ?p) (truck-at ?l)) :effect (and (pkg-at ?p ?l) (not (in ?p)))))";

#[test]
fn partition_solves_multi_goal_transport() {
    // two packages share one truck — multiple interacting subgoals exercise the
    // partition resolver (interaction-seeded groups + sibling protection).
    let p = "(define (problem p) (:domain t)
        (:objects a b c - loc p1 p2 - pkg)
        (:init (truck-at a) (pkg-at p1 a) (pkg-at p2 b)
               (road a b) (road b a) (road b c) (road c b) (road a c) (road c a))
        (:goal (and (pkg-at p1 c) (pkg-at p2 c))))";
    let sol = solve(
        TRANSPORT,
        p,
        &Options {
            mode: Mode::Partition,
            threads: 1,
            ..Default::default()
        },
    )
    .unwrap();
    assert!(sol.solved, "partition should deliver both packages");
    assert_eq!(sol.mode, Mode::Partition);
    assert!(sol.plan.unwrap().length >= 4); // at least load/drive/unload each pkg
}

#[test]
fn explicit_modes_run() {
    for m in [Mode::Ff, Mode::Partition] {
        let sol = solve(
            GRID,
            &prob("(at z)"),
            &Options {
                mode: m,
                threads: 1,
                ..Default::default()
            },
        )
        .unwrap();
        assert!(sol.solved, "mode {:?} should solve", m);
        assert_eq!(sol.mode, m);
    }
}

#[test]
fn parse_error_is_typed() {
    let err = solve("(define (domain", "(define (problem", &Options::default()).unwrap_err();
    // it's a typed error, not a panic
    assert!(matches!(err, ferroplan::SolveError::DomainParse(_)));
}

#[test]
fn parse_error_reports_line() {
    // bad requirement on line 2 -> ParseError carries line 2
    let dom = "(define (domain d)\n (:requirements :strips :bogus)\n (:predicates (x)))";
    let prob = "(define (problem p) (:domain d) (:init) (:goal (x)))";
    match solve(dom, prob, &Options::default()).unwrap_err() {
        ferroplan::SolveError::DomainParse(pe) => assert_eq!(pe.line, 2, "{}", pe),
        e => panic!("expected DomainParse, got {e:?}"),
    }
}