21 #include "clips_test.h"
37 string logfile = tmpnam(
nullptr);
38 env.evaluate(
"(open \"" + logfile +
"\" error \"w\")");
39 LoadCLIPSFiles(clips_files);
45 vector<string> clips_files = {
"../../../clips/clips/utils.clp",
"../plan.clp",
"../domain.clp"};
56 clips_files.push_back(
"blocksworld.clp");
68 EXPECT_TRUE(has_fact(
"((?p domain-precondition))",
69 "(and (eq ?p:name neg-on-table) (eq ?p:is-satisfied TRUE))"));
78 env.assert_fact(
"(domain-fact (name ontable) (param-values b1))");
80 EXPECT_TRUE(has_fact(
"((?p domain-precondition))",
81 "(and (eq ?p:name neg-on-table) (eq ?p:is-satisfied FALSE))"));
82 EXPECT_FALSE(has_fact(
"((?p domain-precondition))",
83 "(and (eq ?p:name neg-on-table) (eq ?p:is-satisfied TRUE))"));
84 EXPECT_TRUE(has_fact(
"((?p domain-precondition))",
85 "(and (eq ?p:name pick-up-precond) (eq ?p:is-satisfied FALSE))"));
86 EXPECT_FALSE(has_fact(
"((?p domain-precondition))",
87 "(and (eq ?p:name pick-up-precond) (eq ?p:is-satisfied TRUE))"));
93 env.assert_fact(
"(domain-operator (name disjunctive-op))");
94 env.assert_fact(
"(domain-precondition (name pre) (type disjunction)"
95 " (part-of disjunctive-op))");
96 env.assert_fact(
"(plan-action (id 1) (goal-id g0) (plan-id p0) "
97 "(action-name disjunctive-op))");
99 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable FALSE))"));
100 env.assert_fact(
"(domain-predicate (name p))");
101 env.assert_fact(
"(domain-atomic-precondition (part-of pre) (predicate p))");
103 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable FALSE))"));
104 env.assert_fact(
"(domain-fact (name p))");
106 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable TRUE))"));
107 env.assert_fact(
"(domain-predicate (name q))");
108 env.assert_fact(
"(domain-atomic-precondition (part-of pre) (predicate q))");
110 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable TRUE))"));
118 env.assert_fact(
"(domain-operator (name op))");
119 env.assert_fact(
"(domain-precondition (name p1) (part-of op)"
122 env.assert_fact(
"(domain-precondition (name p11) (part-of p1)"
125 EXPECT_EQ(
"TRUE", env.evaluate(
"(domain-is-precond-negative p11)")[0].as_string());
126 env.assert_fact(
"(domain-precondition (name p111) (part-of p11)"
129 EXPECT_EQ(
"FALSE", env.evaluate(
"(domain-is-precond-negative p111)")[0].as_string());
130 env.assert_fact(
"(domain-precondition (name p1111) (part-of p111)"
133 EXPECT_EQ(
"FALSE", env.evaluate(
"(domain-is-precond-negative p1111)")[0].as_string());
134 env.assert_fact(
"(domain-precondition (name p11111) (part-of p1111)"
137 EXPECT_EQ(
"TRUE", env.evaluate(
"(domain-is-precond-negative p11111)")[0].as_string());
147 EXPECT_TRUE(has_fact(
"((?p domain-atomic-precondition))",
148 "(and (eq ?p:predicate on) "
149 "(eq ?p:grounded TRUE) "
150 "(eq ?p:param-values (create$ b1 b2)))"));
151 EXPECT_TRUE(has_fact(
"((?p domain-precondition))",
152 "(and (eq ?p:name unstack-precond) (eq ?p:is-satisfied TRUE))"));
161 env.assert_fact(
"(domain-object (name thing))");
162 env.assert_fact(
"(domain-object-type (name moveable-obj))");
163 env.assert_fact(
"(domain-object-type (name cup) (super-type moveable-obj))");
164 env.assert_fact(
"(domain-object (name c1) (type cup))");
166 EXPECT_TRUE(has_ordered_fact(
"domain-obj-is-of-type", {
"thing",
"object"}));
167 EXPECT_TRUE(has_ordered_fact(
"domain-obj-is-of-type", {
"c1",
"cup"}));
168 EXPECT_TRUE(has_ordered_fact(
"domain-obj-is-of-type", {
"c1",
"moveable-obj"}));
169 EXPECT_TRUE(has_ordered_fact(
"domain-obj-is-of-type", {
"c1",
"object"}));
177 EXPECT_FALSE(has_fact(
"((?error domain-error))"));
181 TEST_F(
DomainTest, ErrorIfPreconditionHasNoOperator)
184 env.assert_fact(
"(domain-precondition (name foo))");
186 EXPECT_TRUE(has_fact(
"((?e domain-error))",
"(eq ?e:error-type precondition-without-parent)"));
190 TEST_F(
DomainTest, ErrorIfOperatorOfPreconditionDoesNotExist)
193 env.assert_fact(
"(domain-precondition (name foo) (part-of op))");
195 EXPECT_TRUE(has_fact(
"((?e domain-error))",
"(eq ?e:error-type precondition-without-parent)"));
199 TEST_F(
DomainTest, ErrorIfObjTypeDoesNotExist)
202 env.assert_fact(
"(domain-object (name o1) (type t1))");
204 EXPECT_TRUE(has_fact(
"((?e domain-error))",
"(eq ?e:error-type type-of-object-does-not-exist)"));
208 TEST_F(
DomainTest, ErrorIfSuperTypeDoesNotExist)
211 env.assert_fact(
"(domain-object-type (name t2) (super-type t1))");
213 EXPECT_TRUE(has_fact(
"((?e domain-error))",
"(eq ?e:error-type super-type-does-not-exist)"));
224 has_fact(
"((?a plan-action))",
"(and (eq ?a:action-name pick-up) (eq ?a:executable TRUE))"));
226 has_fact(
"((?a plan-action))",
"(and (eq ?a:action-name unstack) (eq ?a:executable TRUE))"));
235 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name holding) (eq ?p:param-values (create$ b1)))"));
236 EXPECT_TRUE(has_fact(
"((?p domain-fact))",
"(eq ?p:name handempty)"));
238 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name clear) (eq ?p:param-values (create$ b1)))"));
239 env.assert_fact(
"(apply-action g0 p0 1)");
242 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name holding) (eq ?p:param-values (create$ b1)))"));
243 EXPECT_FALSE(has_fact(
"((?p domain-fact))",
"(eq ?p:name handempty)"));
245 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name clear) (eq ?p:param-values (create$ b1)))"));
257 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name clear) (eq ?p:param-values (create$ b1)))"));
259 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name clear) (eq ?p:param-values (create$ b2)))"));
260 env.assert_fact(
"(apply-action g0 p0 2)");
263 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name clear) (eq ?p:param-values (create$ b1)))"));
265 has_fact(
"((?p domain-fact))",
"(and (eq ?p:name clear) (eq ?p:param-values (create$ b2)))"));
274 env.assert_fact(
"(domain-operator (name drop))");
275 env.assert_fact(
"(domain-operator-parameter"
280 env.assert_fact(
"(domain-predicate"
285 env.assert_fact(
"(domain-predicate"
289 env.assert_fact(
"(domain-effect"
291 " (part-of drop) (predicate holding) (param-names o)"
293 env.assert_fact(
"(domain-effect"
294 " (part-of drop) (predicate on-ground) (param-names o)"
296 env.assert_fact(
"(domain-object (name obj1))");
297 env.assert_fact(
"(domain-fact (name holding) (param-values obj1))");
298 env.assert_fact(
"(plan-action"
299 " (goal-id g0) (plan-id p0)"
301 " (state EXECUTION-SUCCEEDED)"
302 " (action-name drop)"
304 " (param-values obj1))");
306 EXPECT_FALSE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:state FINAL))"));
308 has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:state SENSED-EFFECTS-HOLD))"));
310 has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:state SENSED-EFFECTS-WAIT))"));
311 EXPECT_FALSE(has_fact(
"((?f domain-fact))",
312 "(and (eq ?f:name on-ground) (eq ?f:param-values (create$ obj1)))"));
313 env.evaluate(
"(delayed-do-for-all-facts ((?df domain-fact)) "
314 " (and (eq ?df:name holding) (eq ?df:param-values (create$ obj1))) "
318 EXPECT_TRUE(has_fact(
"((?f domain-fact))",
319 "(and (eq ?f:name on-ground) (eq ?f:param-values (create$ obj1)))"));
320 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:state FINAL))"));
324 TEST_F(
DomainTest, OnlyWaitForEffectsIfWaitSensedIsTRUE)
327 env.assert_fact(
"(domain-operator (name drop) (wait-sensed FALSE))");
328 env.assert_fact(
"(domain-operator-parameter"
333 env.assert_fact(
"(domain-predicate"
338 env.assert_fact(
"(domain-predicate"
342 env.assert_fact(
"(domain-effect"
344 " (part-of drop) (predicate holding) (param-names o)"
346 env.assert_fact(
"(domain-effect"
347 " (part-of drop) (predicate on-ground) (param-names o)"
349 env.assert_fact(
"(domain-object (name obj1))");
350 env.assert_fact(
"(domain-fact (name holding) (param-values obj1))");
351 env.assert_fact(
"(plan-action"
353 " (goal-id g0) (plan-id p0)"
354 " (state EXECUTION-SUCCEEDED)"
355 " (action-name drop)"
357 " (param-values obj1))");
359 EXPECT_TRUE(has_fact(
"((?f domain-fact))",
360 "(and (eq ?f:name on-ground) (eq ?f:param-values (create$ obj1)))"));
361 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:state FINAL))"));
368 env.assert_fact(
"(domain-predicate"
373 env.assert_fact(
"(domain-operator (name drop) (exogenous TRUE))");
374 env.assert_fact(
"(domain-operator-parameter"
379 env.assert_fact(
"(domain-precondition"
383 env.assert_fact(
"(domain-atomic-precondition (part-of drop-cond) "
384 " (predicate holding)"
387 env.assert_fact(
"(domain-effect"
389 " (part-of drop) (predicate holding) (param-names o)"
391 env.assert_fact(
"(domain-object (name obj1))");
392 env.assert_fact(
"(plan-action"
394 " (goal-id g0) (plan-id p0)"
395 " (action-name drop)"
397 " (param-values obj1))");
401 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable TRUE))"));
407 TEST_F(
DomainTest, ApplyCondtradictingEffectsWithSameParams)
410 env.assert_fact(
"(domain-operator (name op1))");
411 env.assert_fact(
"(domain-operator-parameter (name x) (operator op1))");
412 env.assert_fact(
"(domain-predicate (name p) (param-names x))");
413 env.assert_fact(
"(plan-action"
415 " (state EXECUTION-SUCCEEDED)"
418 " (param-values a))");
419 env.assert_fact(
"(domain-effect"
425 env.assert_fact(
"(domain-effect"
431 env.assert_fact(
"(domain-effect"
439 has_fact(
"((?f domain-fact))",
"(and (eq ?f:name p) (eq ?f:param-values (create$ a)))"));
446 env.assert_fact(
"(plan-action"
448 " (goal-id g0) (plan-id p0)"
451 " (param-values b))");
452 env.assert_fact(
"(domain-precondition (name p1) (part-of op1))");
453 env.assert_fact(
"(domain-atomic-precondition"
458 " (param-constants a))");
460 EXPECT_FALSE(has_fact(
"((?p domain-atomic-precondition))",
461 "(and (eq ?p:name ap1) (eq ?p:is-satisfied TRUE))"));
463 has_fact(
"((?p domain-precondition))",
"(and (eq ?p:name p1) (eq ?p:is-satisfied TRUE))"));
464 EXPECT_FALSE(has_fact(
"((?a plan-action))",
"(and (eq a:?id 1) (eq ?a:executable TRUE))"));
465 env.assert_fact(
"(domain-fact (name pred1) (param-values a b))");
467 EXPECT_TRUE(has_fact(
"((?p domain-atomic-precondition))",
468 "(and (eq ?p:name ap1) (eq ?p:is-satisfied TRUE))"));
470 has_fact(
"((?p domain-precondition))",
"(and (eq ?p:name p1) (eq ?p:is-satisfied TRUE))"));
471 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable TRUE))"));
477 TEST_F(
DomainTest, PreconditionWithConstantInSecondSlot)
480 env.assert_fact(
"(plan-action"
482 " (goal-id g0) (plan-id p0)"
485 " (param-values b))");
486 env.assert_fact(
"(domain-precondition (name p1) (part-of op1))");
487 env.assert_fact(
"(domain-atomic-precondition"
492 " (param-constants nil a))");
494 EXPECT_FALSE(has_fact(
"((?p domain-atomic-precondition))",
495 "(and (eq ?p:name ap1) (eq ?p:is-satisfied TRUE))"));
497 has_fact(
"((?p domain-precondition))",
"(and (eq ?p:name p1) (eq ?p:is-satisfied TRUE))"));
498 EXPECT_FALSE(has_fact(
"((?a plan-action))",
"(and (eq a:?id 1) (eq ?a:executable TRUE))"));
499 env.assert_fact(
"(domain-fact (name pred1) (param-values b a))");
501 EXPECT_TRUE(has_fact(
"((?p domain-atomic-precondition))",
502 "(and (eq ?p:name ap1) (eq ?p:is-satisfied TRUE))"));
504 has_fact(
"((?p domain-precondition))",
"(and (eq ?p:name p1) (eq ?p:is-satisfied TRUE))"));
505 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable TRUE))"));
512 env.assert_fact(
"(plan-action"
515 " (goal-id g0) (plan-id p0)"
518 " (param-values b b))");
519 env.assert_fact(
"(domain-precondition (name p1) (part-of op1))");
520 env.assert_fact(
"(domain-atomic-precondition"
527 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 1) (eq ?a:executable TRUE))"));
528 env.assert_fact(
"(plan-action"
531 " (goal-id g0) (plan-id p0)"
534 " (param-values b c))");
536 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(and (eq ?a:id 2) (eq ?a:executable FALSE))"));
543 env.assert_fact(
"(domain-atomic-precondition"
550 EXPECT_TRUE(has_fact(
"((?e domain-error))",
551 "(eq ?e:error-type equality-must-have-exactly-two-parameters)"));
553 env.assert_fact(
"(domain-atomic-precondition"
557 " (param-names x y z)"
560 EXPECT_TRUE(has_fact(
"((?e domain-error))",
561 "(eq ?e:error-type equality-must-have-exactly-two-parameters)"));
563 env.assert_fact(
"(domain-atomic-precondition"
572 has_fact(
"((?e domain-error))",
"(eq ?e:error-type precondition-with-equality-and-predicate)"));
574 env.assert_fact(
"(domain-atomic-precondition"
580 EXPECT_TRUE(has_fact(
"((?e domain-error))",
581 "(eq ?e:error-type precondition-must-have-predicate-or-be-equality)"));
587 TEST_F(
DomainTest, PreconditionWithUnknownParameter)
590 env.assert_fact(
"(plan-action"
592 " (goal-id g0) (plan-id p0)"
595 " (param-values b))");
596 env.assert_fact(
"(domain-precondition (name p1) (part-of op1))");
597 env.assert_fact(
"(domain-atomic-precondition"
602 " (param-constants nil a))");
604 EXPECT_TRUE(has_fact(
"((?e domain-error))",
"(eq ?e:error-type unknown-parameter)"));
611 env.assert_fact(
"(plan-action (action-name doesn-not-exist))");
614 has_fact(
"((?e domain-error))",
"(eq ?e:error-type operator-of-action-does-not-exist)"));
618 TEST_F(
DomainTest, ValuePredicatesHaveUniqueValues)
621 env.assert_fact(
"(domain-predicate (name p) (value-predicate TRUE))");
622 env.assert_fact(
"(domain-fact (name p) (param-values a b c 1))");
623 env.assert_fact(
"(domain-fact (name p) (param-values a b d 1))");
626 has_fact(
"((?e domain-error))",
"(eq ?e:error-type value-predicate-with-multiple-values)"));
627 env.assert_fact(
"(domain-fact (name p) (param-values a b c 2))");
630 has_fact(
"((?e domain-error))",
"(eq ?e:error-type value-predicate-with-multiple-values)"));
631 env.evaluate(
"(do-for-fact ((?f domain-fact)) "
632 "(and (eq ?f:name p) (eq ?f:param-values (create$ a b c 2)))"
637 has_fact(
"((?e domain-error))",
"(eq ?e:error-type value-predicate-with-multiple-values)"));
645 has_fact(
"((?e domain-error))",
"(eq ?e:error-type value-predicate-without-paired-effect)"));
646 env.evaluate(
"(do-for-fact ((?p domain-predicate)) "
647 "(eq ?p:name holding) "
648 "(duplicate ?p (value-predicate TRUE))"
653 has_fact(
"((?e domain-error))",
"(eq ?e:error-type value-predicate-without-paired-effect)"));
663 env.assert_fact(
"(plan-action (id 1) (goal-id g0) (plan-id p1)"
664 " (action-name stack)"
665 " (param-names x y) (param-values b1 b2))");
666 env.assert_fact(
"(plan-action (id 1) (goal-id g1) (plan-id p0)"
667 " (action-name stack)"
668 " (param-names x y) (param-values b1 b2))");
673 EXPECT_TRUE(has_fact(
"((?a plan-action))",
674 "(and (eq ?a:id 1) (eq ?a:goal-id g0) (eq ?a:plan-id p0)"
675 " (eq ?a:executable TRUE))"));
676 EXPECT_TRUE(has_fact(
"((?a plan-action))",
677 "(and (eq ?a:id 1) (eq ?a:goal-id g0) (eq ?a:plan-id p1)"
678 " (eq ?a:executable FALSE))"));
679 EXPECT_TRUE(has_fact(
"((?a plan-action))",
680 "(and (eq ?a:id 1) (eq ?a:goal-id g0) (eq ?a:plan-id p0)"
681 " (eq ?a:executable TRUE))"));
682 EXPECT_TRUE(has_fact(
"((?a plan-action))",
683 "(and (eq ?a:id 1) (eq ?a:goal-id g1) (eq ?a:plan-id p0)"
684 " (eq ?a:executable FALSE))"));
695 clips_files.push_back(
"conditional_say.clp");
704 env.assert_fact(
"(plan-action"
706 " (goal-id g0) (plan-id p0)"
709 " (param-values front_speaker hello)"
711 env.assert_fact(
"(apply-action g0 p0 1)");
713 EXPECT_FALSE(has_fact(
"((?fact domain-fact))",
714 "(and (eq ?fact:name said) (eq ?fact:param-values (create$ hello)))"));
721 env.assert_fact(
"(plan-action"
723 " (goal-id g0) (plan-id p0)"
726 " (param-values front_speaker hello)"
728 env.assert_fact(
"(apply-action g0 p0 1)");
729 env.assert_fact(
"(domain-fact (name speaker-ready) (param-values front_speaker))");
731 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(eq ?a:state FINAL)"));
732 EXPECT_TRUE(has_fact(
"((?fact domain-fact))",
733 "(and (eq ?fact:name said) (eq ?fact:param-values (create$ hello)))"));
740 TEST_F(
DomainTest, ExogenousActionWithNonValuePredicatePrecondition)
743 env.assert_fact(
"(domain-operator (name put) (exogenous TRUE)"
744 " (param-names mps wp)"
746 env.assert_fact(
"(domain-operator-parameter (name mps) (operator put)"
749 env.assert_fact(
"(domain-operator-parameter (name wp) (operator put)"
752 env.assert_fact(
"(domain-predicate (name wp-at) (sensed TRUE)"
753 " (param-names mps wp) (param-types object object)"
755 env.assert_fact(
"(domain-precondition (operator put) (part-of put)"
756 " (name put-precond) (type conjunction)"
758 env.assert_fact(
"(domain-precondition (operator put) (part-of put-precond)"
759 " (name put-precond1) (type negation)"
761 env.assert_fact(
"(domain-atomic-precondition (operator put)"
762 " (name put-precond11)"
763 " (part-of put-precond1) (predicate wp-at) (param-names mps wp)"
765 env.assert_fact(
"(domain-effect (part-of put) (predicate wp-at)"
766 " (param-names mps wp)"
768 env.assert_fact(
"(plan-action (id 1) (goal-id g0) (plan-id p0)"
769 " (state FORMULATED)"
770 " (action-name put) (param-names mps wp) (param-values C-CS wp1)"
773 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(eq ?a:executable TRUE)"));
780 TEST_F(
DomainTest, ExogenousActionWithValuePredicatePrecondition)
783 env.assert_fact(
"(domain-operator (name dispense) (exogenous TRUE)"
786 env.assert_fact(
"(domain-operator-parameter (name mps) (operator dispense)"
789 env.assert_fact(
"(domain-predicate (name mps-state) (sensed TRUE)"
790 " (param-names mps state) (param-types object object)"
791 " (value-predicate TRUE)"
793 env.assert_fact(
"(domain-precondition (operator dispense) (part-of dispense)"
794 " (name dispense-precond) (type conjunction)"
796 env.assert_fact(
"(domain-atomic-precondition (operator dispense)"
797 " (part-of dispense-precond) (predicate mps-state) (param-names mps c)"
798 " (param-constants nil PROCESSING)"
800 env.assert_fact(
"(domain-effect (part-of dispense) (predicate mps-state)"
801 " (param-names mps c) (param-constants nil READY-AT-OUTPUT)"
803 env.assert_fact(
"(domain-effect (part-of dispense) (predicate mps-state)"
805 " (param-names mps c) (param-constants nil PROCESSING)"
807 env.assert_fact(
"(plan-action (id 1) (goal-id g0) (plan-id p0)"
808 " (state FORMULATED)"
809 " (action-name dispense) (param-names mps) (param-values C-CS)"
812 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(eq ?a:executable FALSE)"));
813 env.assert_fact(
"(domain-fact (name mps-state)"
814 " (param-values C-CS READY-AT-OUTPUT)"
817 EXPECT_TRUE(has_fact(
"((?a plan-action))",
"(eq ?a:executable TRUE)"));
Test with the blocksworld domain.
virtual void SetUp()
Set up the test environment.
Base class for unit testing with CLIPS.
Test with the conditional-say domain.
virtual void SetUp()
Set up the test environment.
Test setup for domain tests.
virtual void SetUp()
Set up the test environment.