Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## ix.iplan
Class PlanTest

    java.lang.Object
      ix.iplan.PlanTest

All Implemented Interfaces:
  java.io.Serializable

Direct Known Subclasses:
  BlockStackingTest, MissionaryTest, PlanTestDefaults, TrainsTest

    public class PlanTest

extends java.lang.Object
implements java.io.Serializable

Specifies a planning test.

A test specifies a domain, a task, a number of plans, and whether or not the test is exhaustive. It also gives the number of randomly reordered simulations to try per plan, and a "step limit" that the planner can use as a limit on how much work it should do.

The task can be specified either by an activity pattern in the `task` field or by a resource name (filename or URL) in the `initialPlan` field. The activity pattern is given as a string without initial and final parens, for example `"test1"` or `"paint block-1 green"`. In some cases, it may make sense to specify both an initial plan and a task.

If the test is exhaustive, the auto-tester will expect to find exactly the specified number of plans, and it will consider the test a failure if it doesn't. If you just want to check the first solution and completely ignore the possibility of replanning, use 1 as the number of plans and don't make the test exhaustive. (That is also the default.) If you want to look at the first k solutions when there are more than k, use k as the number of plans and again make it not exhaustive.

For an exhaustive test, the number of solutions (plans) is also the of replans. An exhaustive test should continue until we run out of alternative plans. So if there are k solutions, we should replan k times (there's the first plan, then k-1 replans to get the k-1 other solutions, then one more replan to get the out-of-alternatives exception). This is a nice coincidence, but may not be exactly what's expected.

Each plan is tested, when found, by running an execution simulator. The plan is first executed in whatever order the simulator naturally selects. That order will always be the same for the same plan. If this PlanTest's `randomSimulations` field has a value greater than zero, the similator will be used to simulate the plan's execution that many more times in a way that randomly permutes the execution order (subject to any ordering constraints). The simulator does this is a way that always generates the same sequence of permutations for the same plan, so that the simulations are repeatable. By default no random simulations will be done.

The PlanTest class is very like O-Plan's plan-test class, and parts of this doc comment are based on the one for O-Plan.

See Also:
  `AutoTester`, `PlanCheckingSimulator`, `PlanCheckingSimulator.setShuffle(boolean)`, Serialized Form

Field Summary
`protected java.lang.String` | `domain`
`protected java.lang.String` | `initialPlan`
`protected boolean` | `isExhaustive`
`protected int` | `plans`
`protected int` | `randomSimulations`
`protected int` | `stepLimit`
`protected java.lang.String` | `task`

Constructor Summary
`PlanTest()`

Method Summary
`java.lang.String` | `getDomain()`
`java.lang.String` | `getInitialPlan()`
`boolean` | `getIsExhaustive()`
`int` | `getPlans()`
`int` | `getRandomSimulations()`
`int` | `getStepLimit()`
`java.lang.String` | `getTask()`
`AutoTester.TestRunner` | `makeTestRunner(AutoTester auto)` Factory method that returns a new TestRunner that should be used to run this test.
`void` | `setDomain(java.lang.String domain)`
`void` | `setInitialPlan(java.lang.String initialPlan)`
`void` | `setIsExhaustive(boolean isExhaustive)`
`void` | `setPlans(int plans)`
`void` | `setRandomSimulations(int randomSimulations)`
`void` | `setStepLimit(int stepLimit)`
`void` | `setTask(java.lang.String task)`
`(package private) void` | `takeDefaults(PlanTest defaults)` Takes field values from the specified PlanTest which will usually be an instance of `PlanTestDefaults`.
`java.lang.String` | `taskDescription()` Returns a short textual description of the task or problem that this test gives to the planner.
`java.lang.String` | `testDescription()` Returns a short textual description of this test.
`java.lang.String` | `toString()`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### domain

    protected java.lang.String domain

### task

    protected java.lang.String task

### initialPlan

    protected java.lang.String initialPlan

### plans

    protected int plans

### isExhaustive

    protected boolean isExhaustive

### randomSimulations

    protected int randomSimulations

### stepLimit

    protected int stepLimit

Constructor Detail

### PlanTest

    public PlanTest()

Method Detail

### getDomain

    public java.lang.String getDomain()

### setDomain

    public void setDomain(java.lang.String domain)

### getTask

    public java.lang.String getTask()

### setTask

    public void setTask(java.lang.String task)

### getInitialPlan

    public java.lang.String getInitialPlan()

### setInitialPlan

    public void setInitialPlan(java.lang.String initialPlan)

### getPlans

    public int getPlans()

### setPlans

    public void setPlans(int plans)

### getIsExhaustive

    public boolean getIsExhaustive()

### setIsExhaustive

    public void setIsExhaustive(boolean isExhaustive)

### getRandomSimulations

    public int getRandomSimulations()

### setRandomSimulations

    public void setRandomSimulations(int randomSimulations)

### getStepLimit

    public int getStepLimit()

### setStepLimit

    public void setStepLimit(int stepLimit)

### takeDefaults

    void takeDefaults(PlanTest defaults)

  Takes field values from the specified PlanTest which will usually be an instance of `PlanTestDefaults`. Only some fields can be defaulted; currently they are `domain`, `randomSimulations`, and `stepLimit`.

### makeTestRunner

    public AutoTester.TestRunner makeTestRunner(AutoTester auto)

  Factory method that returns a new TestRunner that should be used to run this test. This allows PlanTest subclasses to vary the way in which tests are processed.

### testDescription

    public java.lang.String testDescription()

  Returns a short textual description of this test. It should include the domain name and a description of the task or problem. Examples:

         Domain duplicate-effect-test, Task test1
         Domain blocks-pure-htn-1, Problem ca,b-abc

  The method defined by the PlanTest class calls `getDomain()` and `taskDescription()`.

### taskDescription

    public java.lang.String taskDescription()

  Returns a short textual description of the task or problem that this test gives to the planner.

  The method defined by the PlanTest class returns the result of calling `getTask()`, if that is not null, and otherwise calls `getInitialPlan()`. If the initial-plan string begins with this test's domain name, those characters are removed from the description, as are any characters after and including any final ".". For example, if the test has domain "`example`" and initial-plan "`example-init-plan-1.xml`", the result will be "`-init-plan-1`".

  See Also:
    `testDescription()`

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `java.lang.Object`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD