def test_statics1(): """ A static predicate is a predicate, which doesn't occur in an effect of an action. """ type_object = Type("object", None) type_car = Type("car", type_vehicle) type_city = Type("city", type_object) type_country = Type("country", type_object) types = {"object": type_object, "car": type_car, "city": type_city, "country": type_country} predicate_orig = Predicate("at", [("car", types["car"]), ("dest", types["city"])]) predicate_dest = Predicate("at", [("car", types["car"]), ("orig", types["city"])]) predicate_in = Predicate("in", [("city", types["city"]), ("country", types["country"])]) action_drive_car = get_action("DRIVE-CAR", [("car", [types["car"]]), ("loc-orig", [types["city"]]), ("loc-dest", [types["city"]])], [predicate_orig], [predicate_dest], [predicate_orig]) expected = [("in", grounding._get_statics([predicate_in], [action_drive_car]), True), ("dest", grounding._get_statics([predicate_dest], [action_drive_car]), False), ("orig", grounding._get_statics([predicate_orig], [action_drive_car]), False)] for pre, statics, element in expected: yield in_statics, pre, statics, element
def test_statics2(): type_object = Type("object", None) predicate_a = Predicate("a", []) predicate_b = Predicate("b", []) the_action = get_action("the-action", [], [predicate_a], [predicate_b], []) statics = grounding._get_statics([predicate_a, predicate_b], [the_action]) assert predicate_a.name in statics and predicate_b.name not in statics
def test_statics1(): """ A static predicate is a predicate, which doesn't occur in an effect of an action. """ type_object = Type("object", None) type_car = Type("car", type_vehicle) type_city = Type("city", type_object) type_country = Type("country", type_object) types = { "object": type_object, "car": type_car, "city": type_city, "country": type_country, } predicate_orig = Predicate("at", [("car", types["car"]), ("dest", types["city"])]) predicate_dest = Predicate("at", [("car", types["car"]), ("orig", types["city"])]) predicate_in = Predicate("in", [("city", types["city"]), ("country", types["country"])]) action_drive_car = get_action( "DRIVE-CAR", [ ("car", [types["car"]]), ("loc-orig", [types["city"]]), ("loc-dest", [types["city"]]), ], [predicate_orig], [predicate_dest], [predicate_orig], ) assert "in" in grounding._get_statics([predicate_in], [action_drive_car]) assert "dest" not in grounding._get_statics([predicate_dest], [action_drive_car]) assert "orig" not in grounding._get_statics([predicate_orig], [action_drive_car])
def test_statics1(): """ A static predicate is a predicate, which doesn't occur in an effect of an action. """ type_object = Type("object", None) type_car = Type("car", type_vehicle) type_city = Type("city", type_object) type_country = Type("country", type_object) types = { "object": type_object, "car": type_car, "city": type_city, "country": type_country } predicate_orig = Predicate("at", [("car", types["car"]), ("dest", types["city"])]) predicate_dest = Predicate("at", [("car", types["car"]), ("orig", types["city"])]) predicate_in = Predicate("in", [("city", types["city"]), ("country", types["country"])]) action_drive_car = get_action("DRIVE-CAR", [("car", [types["car"]]), ("loc-orig", [types["city"]]), ("loc-dest", [types["city"]])], [predicate_orig], [predicate_dest], [predicate_orig]) expected = [ ("in", grounding._get_statics([predicate_in], [action_drive_car]), True), ("dest", grounding._get_statics([predicate_dest], [action_drive_car]), False), ("orig", grounding._get_statics([predicate_orig], [action_drive_car]), False) ] for pre, statics, element in expected: yield in_statics, pre, statics, element
def test_create_operator(): statics = grounding._get_statics(standard_domain.predicates.values(), [action_drive_car]) initial_state = [Predicate("at", [("ford", types["car"]), ("freiburg", types["city"])])] operator = grounding._create_operator( action_drive_car, {"car": "ford", "dest": "berlin", "orig": "freiburg"}, [], initial_state) assert operator.name == "(DRIVE-CAR ford freiburg berlin)" assert operator.preconditions == {'(at ford berlin)'} assert operator.add_effects == {'(at ford freiburg)'} assert operator.del_effects == {'(at ford berlin)'}
def test_create_operator(): statics = grounding._get_statics(standard_domain.predicates.values(), [action_drive_car]) initial_state = [ Predicate("at", [("ford", types["car"]), ("freiburg", types["city"])]) ] operator = grounding._create_operator(action_drive_car, { "car": "ford", "dest": "berlin", "orig": "freiburg" }, [], initial_state) assert operator.name == "(DRIVE-CAR ford freiburg berlin)" assert operator.preconditions == {'(at ford berlin)'} assert operator.add_effects == {'(at ford freiburg)'} assert operator.del_effects == {'(at ford berlin)'}
def test_add_del_effects(): parser = Parser("") def parse_problem(domain, problem): parser.domInput = domain parser.probInput = problem domain = parser.parse_domain(False) return parser.parse_problem(domain, False) dom_pddl = """ (define (domain dom) (:requirements :typing) (:predicates (ok ?v - object)) (:action theaction :parameters (?x - object) :precondition {0} :effect {1} ) ) """ prob_pddl = """ ;; See domain file for description of this test. (define (problem prob) (:domain dom) (:objects y - object) (:init) (:goal (ok y))) """ tests = [ # Only add effect ("(and)", "(ok ?x)", set(), {"(ok y)"}, set()), # Only delete effect ("(and)", "(and (not (ok ?x)))", set(), set(), {"(ok y)"}), # Both add and delete effect ("(and)", "(and (ok ?x) (not (ok ?x)))", set(), {"(ok y)"}, set()), # Precondition and add effect ("(and (ok ?x))", "(ok ?x)", {"(ok y)"}, set(), set()), # Precondition and delete effect ("(and (ok ?x))", "(and (not (ok ?x)))", {"(ok y)"}, set(), {"(ok y)"} ), # Precondition and both add and delete effect ("(and (ok ?x))", "(and (ok ?x) (not (ok ?x)))", {"(ok y)"}, set(), set()), ] for pre_in, eff_in, pre_exp, add_exp, del_exp in tests: dom = dom_pddl.format(pre_in, eff_in) problem = parse_problem(dom, prob_pddl) domain = problem.domain actions = domain.actions.values() predicates = domain.predicates.values() # Objects objects = problem.objects objects.update(domain.constants) # Get the names of the static predicates statics = grounding._get_statics(predicates, actions) # Create a map from types to objects type_map = grounding._create_type_map(objects) # Transform initial state into a specific init = grounding._get_partial_state(problem.initial_state) # Ground actions operators = grounding._ground_actions(actions, type_map, statics, init) assert len(operators) == 1 op = operators[0] assert op.preconditions == pre_exp assert op.add_effects == add_exp assert op.del_effects == del_exp
def test_add_del_effects(): parser = Parser('') def parse_problem(domain, problem): parser.domInput = domain parser.probInput = problem domain = parser.parse_domain(False) return parser.parse_problem(domain, False) dom_pddl = """ (define (domain dom) (:requirements :typing) (:predicates (ok ?v - object)) (:action theaction :parameters (?x - object) :precondition {0} :effect {1} ) ) """ prob_pddl = """ ;; See domain file for description of this test. (define (problem prob) (:domain dom) (:objects y - object) (:init) (:goal (ok y))) """ tests = [ # Only add effect ('(and)', '(ok ?x)', set(), {'(ok y)'}, set()), # Only delete effect ('(and)', '(and (not (ok ?x)))', set(), set(), {'(ok y)'}), # Both add and delete effect ('(and)', '(and (ok ?x) (not (ok ?x)))', set(), {'(ok y)'}, set()), # Precondition and add effect ('(and (ok ?x))', '(ok ?x)', {'(ok y)'}, set(), set()), # Precondition and delete effect ('(and (ok ?x))', '(and (not (ok ?x)))', {'(ok y)'}, set(), {'(ok y)'}), # Precondition and both add and delete effect ('(and (ok ?x))', '(and (ok ?x) (not (ok ?x)))', {'(ok y)'}, set(), set()), ] for pre_in, eff_in, pre_exp, add_exp, del_exp in tests: dom = dom_pddl.format(pre_in, eff_in) problem = parse_problem(dom, prob_pddl) domain = problem.domain actions = domain.actions.values() predicates = domain.predicates.values() # Objects objects = problem.objects objects.update(domain.constants) # Get the names of the static predicates statics = grounding._get_statics(predicates, actions) # Create a map from types to objects type_map = grounding._create_type_map(objects) # Transform initial state into a specific init = grounding._get_partial_state(problem.initial_state) # Ground actions operators = grounding._ground_actions(actions, type_map, statics, init) yield assert_equal, len(operators), 1 op = operators[0] yield assert_equal, op.preconditions, pre_exp yield assert_equal, op.add_effects, add_exp yield assert_equal, op.del_effects, del_exp