gtest_skipping.cpp

#include <gtest/gtest.h>
#include <string>
#include "behaviortree_cpp/basic_types.h"
#include "behaviortree_cpp/bt_factory.h"
#include "test_helper.hpp"
#include "action_test_node.h"

using namespace BT;

TEST(SkippingLogic, Sequence)
{
  BehaviorTreeFactory factory;
  std::array<int, 2> counters;
  RegisterTestTick(factory, "Test", counters);

  const std::string xml_text = R"(

    <root BTCPP_format="4" >
        <BehaviorTree ID="MainTree">
            <Sequence>
                <Script code = "A:=1"/>
                <TestA _successIf="A==2" _failureIf="A!=1" _skipIf="A==1"/>
                <TestB/>
            </Sequence>
        </BehaviorTree>
    </root>)";

  auto tree = factory.createTreeFromText(xml_text);
  const auto status = tree.tickWhileRunning();
  ASSERT_EQ(status, NodeStatus::SUCCESS);
  ASSERT_EQ(counters[0], 0);
  ASSERT_EQ(counters[1], 1);
}

TEST(SkippingLogic, Order)
{
  BehaviorTreeFactory factory;
  std::array<int, 3> counters;
  RegisterTestTick(factory, "Test", counters);

  const std::string xml_text = R"(

    <root BTCPP_format="4" >
        <BehaviorTree ID="MainTree">
            <Sequence>
                <Script code = "A:=1"/>
                <TestA _onlyIf="A==1" _skipIf="A==1"/>
                <TestB _onlyIf="A==0" _skipIf="A==0"/>
                <TestC _successIf="A==1" _onlyIf="A==1"/>
            </Sequence>
        </BehaviorTree>
    </root>)";

  auto tree = factory.createTreeFromText(xml_text);
  const auto status = tree.tickWhileRunning();
  ASSERT_EQ(status, NodeStatus::SUCCESS);
  ASSERT_EQ(counters[0], 1);
  ASSERT_EQ(counters[1], 0);
  ASSERT_EQ(counters[2], 0);
}

TEST(SkippingLogic, SkipAll)
{
  BehaviorTreeFactory factory;
  std::array<int, 3> counters;
  RegisterTestTick(factory, "Test", counters);

  const std::string xml_text = R"(

    <root BTCPP_format="4" >
        <BehaviorTree ID="MainTree">
            <Sequence>
                <TestA _skipIf="A==1"/>
                <TestB _skipIf="A<2"/>
                <TestC _skipIf="A>0"/>
            </Sequence>
        </BehaviorTree>
    </root>)";

  auto tree = factory.createTreeFromText(xml_text);
  tree.rootBlackboard()->set("A", 1);

  const auto status = tree.tickWhileRunning();
  ASSERT_EQ(counters[0], 0);
  ASSERT_EQ(counters[1], 0);
  ASSERT_EQ(counters[2], 0);
  ASSERT_EQ(status, NodeStatus::SKIPPED);
}

TEST(SkippingLogic, SkipSubtree)
{
  BehaviorTreeFactory factory;
  std::array<int, 3> counters;
  RegisterTestTick(factory, "Test", counters);

  const std::string xml_text = R"(

    <root BTCPP_format="4" >
        <BehaviorTree ID="main">
            <Sequence>
                <TestA/>
                <Script code=" data:=true "/>
                <SubTree ID="sub" _skipIf="data"/>
            </Sequence>
        </BehaviorTree>

        <BehaviorTree ID="sub">
            <TestB/>
        </BehaviorTree>
    </root>)";

  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("main");

  tree.rootBlackboard()->set("A", 1);

  const auto status = tree.tickWhileRunning();
  ASSERT_EQ(counters[0], 1);
  ASSERT_EQ(counters[1], 0);
  ASSERT_EQ(status, NodeStatus::SUCCESS);
}

TEST(SkippingLogic, ReactiveSingleChild)
{
  static const char* xml_text = R"(
    <root BTCPP_format="4">
      <BehaviorTree ID="Untitled">
        <ReactiveSequence>
          <AlwaysSuccess _skipIf="flag"/>
        </ReactiveSequence>
      </BehaviorTree>
    </root>
 )";

  BT::BehaviorTreeFactory factory;
  auto root_blackboard = BT::Blackboard::create();
  root_blackboard->set<bool>("flag", true);

  auto tree = factory.createTreeFromText(xml_text, root_blackboard);

  tree.tickWhileRunning();
}

TEST(SkippingLogic, SkippingReactiveSequence)
{
  BehaviorTreeFactory factory;
  std::array<int, 2> counters;
  RegisterTestTick(factory, "Test", counters);

  const std::string xml_text_noskip = R"(
    <root BTCPP_format="4" >
       <BehaviorTree>
          <ReactiveSequence>
            <Script code=" value:=50 "/>
            <TestA _skipIf="value < 25"/>
            <AsyncActionTest/>
          </ReactiveSequence>
       </BehaviorTree>
    </root>)";

  const std::string xml_text_skip = R"(
    <root BTCPP_format="4" >
       <BehaviorTree>
          <ReactiveSequence>
            <Script code=" value:=10 "/>
            <TestB _skipIf="value < 25"/>
            <AsyncActionTest/>
          </ReactiveSequence>
       </BehaviorTree>
    </root>)";

  factory.registerNodeType<AsyncActionTest>("AsyncActionTest");

  int expected_test_A_ticks = 0;

  for(auto const* xml_text : { &xml_text_noskip, &xml_text_skip })
  {
    auto tree = factory.createTreeFromText(*xml_text);

    for(int repeat = 0; repeat < 3; repeat++)
    {
      NodeStatus status = NodeStatus::IDLE;
      while(!isStatusCompleted(status))
      {
        status = tree.tickOnce();

        if(xml_text == &xml_text_noskip)
        {
          expected_test_A_ticks++;
        }

        tree.sleep(std::chrono::milliseconds{ 15 });
      }
      ASSERT_EQ(status, NodeStatus::SUCCESS);
    }
  }
  // counters[0] contains the number ot times TestA was ticked
  ASSERT_EQ(counters[0], expected_test_A_ticks);

  // counters[1] contains the number ot times TestB was ticked
  ASSERT_EQ(counters[1], 0);
}

TEST(SkippingLogic, WhileSkip)
{
  BehaviorTreeFactory factory;
  std::array<int, 2> counters;
  RegisterTestTick(factory, "Test", counters);

  const std::string xml_text_noskip = R"(
    <root BTCPP_format="4" >
       <BehaviorTree>
          <Sequence>
            <Script code=" doit:=true "/>
            <Sequence>
              <TestA _while="doit"/>
            </Sequence>
          </Sequence>
       </BehaviorTree>
    </root>)";

  const std::string xml_text_skip = R"(
    <root BTCPP_format="4" >
       <BehaviorTree>
          <Sequence>
            <Script code=" doit:=false "/>
            <Sequence>
              <TestB _while="doit"/>
            </Sequence>
          </Sequence>
       </BehaviorTree>
    </root>)";

  for(auto const* xml_text : { &xml_text_noskip, &xml_text_skip })
  {
    auto tree = factory.createTreeFromText(*xml_text);
    NodeStatus status = tree.tickWhileRunning();
    ASSERT_EQ(status, NodeStatus::SUCCESS);
  }
  // counters[0] contains the number ot times TestA was ticked
  ASSERT_EQ(counters[0], 1);

  // counters[1] contains the number ot times TestB was ticked
  ASSERT_EQ(counters[1], 0);
}