gtest_blackboard.cpp

Go to the documentation of this file.

/* Copyright (C) 2018-2023 Davide Faconti, Eurecat - All Rights Reserved
*
*   Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
*   to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
*   and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*   The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
*   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
 
#include <gtest/gtest.h>
#include "behaviortree_cpp/bt_factory.h"
#include "behaviortree_cpp/blackboard.h"
 
#include "../sample_nodes/dummy_nodes.h"
 
using namespace BT;
 
class BB_TestNode : public SyncActionNode
{
public:
  BB_TestNode(const std::string& name, const NodeConfig& config)
    : SyncActionNode(name, config)
  {}
 
  NodeStatus tick()
  {
    int value = 0;
    auto res = getInput<int>("in_port");
    if(!res)
    {
      throw RuntimeError("BB_TestNode needs input: ", res.error());
    }
    value = res.value() * 2;
    if(!setOutput("out_port", value))
    {
      throw RuntimeError("BB_TestNode failed output");
    }
    return NodeStatus::SUCCESS;
  }
 
  static PortsList providedPorts()
  {
    return { BT::InputPort<int>("in_port"), BT::OutputPort<int>("out_port") };
  }
};
 
class BB_TypedTestNode : public SyncActionNode
{
public:
  BB_TypedTestNode(const std::string& name, const NodeConfig& config)
    : SyncActionNode(name, config)
  {}
 
  NodeStatus tick()
  {
    return NodeStatus::SUCCESS;
  }
 
  static PortsList providedPorts()
  {
    return { BT::InputPort("input"),
             BT::InputPort<int>("input_int"),
             BT::InputPort<std::string>("input_string"),
 
             BT::OutputPort("output"),
             BT::OutputPort<int>("output_int"),
             BT::OutputPort<std::string>("output_string") };
  }
};
 
TEST(BlackboardTest, GetInputsFromBlackboard)
{
  auto bb = Blackboard::create();
 
  NodeConfig config;
  assignDefaultRemapping<BB_TestNode>(config);
 
  config.blackboard = bb;
  bb->set("in_port", 11);
 
  BB_TestNode node("good_one", config);
 
  // this should read and write "my_entry" in tick()
  node.executeTick();
 
  ASSERT_EQ(bb->get<int>("out_port"), 22);
}
 
TEST(BlackboardTest, BasicRemapping)
{
  auto bb = Blackboard::create();
 
  NodeConfig config;
 
  config.blackboard = bb;
  config.input_ports["in_port"] = "{my_input_port}";
  config.output_ports["out_port"] = "{my_output_port}";
  bb->set("my_input_port", 11);
 
  BB_TestNode node("good_one", config);
  node.executeTick();
 
  ASSERT_EQ(bb->get<int>("my_output_port"), 22);
}
 
TEST(BlackboardTest, GetInputsFromText)
{
  auto bb = Blackboard::create();
 
  NodeConfig config;
  config.input_ports["in_port"] = "11";
 
  BB_TestNode missing_out("missing_output", config);
  EXPECT_THROW(missing_out.executeTick(), RuntimeError);
 
  config.blackboard = bb;
  config.output_ports["out_port"] = "{=}";
 
  BB_TestNode node("good_one", config);
  node.executeTick();
 
  ASSERT_EQ(bb->get<int>("out_port"), 22);
}
 
TEST(BlackboardTest, SetOutputFromText)
{
  const char* xml_text = R"(
 
     <root BTCPP_format="4" >
         <BehaviorTree ID="MainTree">
            <Sequence>
                <BB_TestNode in_port="11" out_port="{my_port}"/>
                <Script code="my_port=-43" />
            </Sequence>
         </BehaviorTree>
     </root>
    )";
 
  BehaviorTreeFactory factory;
  factory.registerNodeType<BB_TestNode>("BB_TestNode");
 
  auto bb = Blackboard::create();
 
  auto tree = factory.createTreeFromText(xml_text, bb);
  tree.tickWhileRunning();
}
 
TEST(BlackboardTest, WithFactory)
{
  BehaviorTreeFactory factory;
 
  factory.registerNodeType<BB_TestNode>("BB_TestNode");
 
  const std::string xml_text = R"(
 
    <root BTCPP_format="4" >
        <BehaviorTree ID="MainTree">
            <Sequence>
                <BB_TestNode in_port="11"
                             out_port="{my_input_port}"/>
 
                <BB_TestNode in_port="{my_input_port}"
                             out_port="{my_input_port}" />
 
                <BB_TestNode in_port="{my_input_port}"
                             out_port="{my_output_port}" />
            </Sequence>
        </BehaviorTree>
    </root>)";
 
  auto bb = Blackboard::create();
 
  auto tree = factory.createTreeFromText(xml_text, bb);
  NodeStatus status = tree.tickWhileRunning();
 
  ASSERT_EQ(status, NodeStatus::SUCCESS);
  ASSERT_EQ(bb->get<int>("my_input_port"), 44);
  ASSERT_EQ(bb->get<int>("my_output_port"), 88);
}
 
TEST(BlackboardTest, TypoInPortName)
{
  BehaviorTreeFactory factory;
  factory.registerNodeType<BB_TestNode>("BB_TestNode");
 
  const std::string xml_text = R"(
 
    <root BTCPP_format="4" >
        <BehaviorTree ID="MainTree">
             <BB_TestNode inpuuuut_port="{value}" />
        </BehaviorTree>
    </root>)";
 
  ASSERT_THROW(auto tree = factory.createTreeFromText(xml_text), RuntimeError);
}
 
TEST(BlackboardTest, CheckPortType)
{
  BehaviorTreeFactory factory;
  factory.registerNodeType<BB_TypedTestNode>("TypedNode");
 
  //-----------------------------
  std::string good_one = R"(
    <root BTCPP_format="4" >
        <BehaviorTree ID="MainTree">
            <Sequence>
                <TypedNode name = "first"  output_int="{matching}"  output_string="{whatever}" output="{no_problem}" />
                <TypedNode name = "second" input_int="{matching}"   input="{whatever}"         input_string="{no_problem}"  />
            </Sequence>
        </BehaviorTree>
    </root>)";
 
  auto tree = factory.createTreeFromText(good_one);
  ASSERT_NE(tree.rootNode(), nullptr);
  //-----------------------------
  std::string bad_one = R"(
    <root BTCPP_format="4" >
        <BehaviorTree ID="MainTree">
            <Sequence>
                <TypedNode name = "first"  output_int="{value}" />
                <TypedNode name = "second" input_string="{value}" />
            </Sequence>
        </BehaviorTree>
    </root>)";
 
  ASSERT_THROW(auto tree = factory.createTreeFromText(bad_one), RuntimeError);
}
 
class RefCountClass
{
public:
  RefCountClass(std::shared_ptr<int> value) : sptr_(std::move(value))
  {
    std::cout << "Constructor: ref_count " << sptr_.use_count() << std::endl;
  }
 
  RefCountClass(const RefCountClass& from) : sptr_(from.sptr_)
  {
    std::cout << "ctor copy: ref_count " << sptr_.use_count() << std::endl;
  }
 
  RefCountClass& operator=(const RefCountClass& from)
  {
    sptr_ = (from.sptr_);
    std::cout << "equal copied: ref_count " << sptr_.use_count() << std::endl;
    return *this;
  }
 
  virtual ~RefCountClass()
  {
    std::cout << ("Destructor") << std::endl;
  }
 
  int refCount() const
  {
    return sptr_.use_count();
  }
 
private:
  std::shared_ptr<int> sptr_;
};
 
TEST(BlackboardTest, MoveVsCopy)
{
  auto blackboard = Blackboard::create();
 
  RefCountClass test(std::make_shared<int>());
 
  ASSERT_EQ(test.refCount(), 1);
 
  std::cout << ("----- before set -----") << std::endl;
  blackboard->set("testmove", test);
  std::cout << (" ----- after set -----") << std::endl;
 
  ASSERT_EQ(test.refCount(), 2);
 
  RefCountClass other(blackboard->get<RefCountClass>("testmove"));
 
  ASSERT_EQ(test.refCount(), 3);
}
 
TEST(BlackboardTest, CheckTypeSafety)
{
  //TODO check type safety when ports are created.
  // remember that std::string is considered a type erased type.
 
  bool is = std::is_constructible<BT::StringView, char*>::value;
  ASSERT_TRUE(is);
 
  is = std::is_constructible<BT::StringView, std::string>::value;
  ASSERT_TRUE(is);
}
 
TEST(BlackboardTest, AnyPtrLocked)
{
  auto blackboard = Blackboard::create();
  long value = 0;
  long* test_obj = &value;
 
  blackboard->set("testmove", test_obj);
 
  auto const timeout = std::chrono::milliseconds(250);
 
  // Safe way to access a pointer
  {
    std::atomic_llong cycles = 0;
    auto func = [&]() {
      auto start = std::chrono::system_clock::now();
      while((std::chrono::system_clock::now() - start) < timeout)
      {
        auto r1 = blackboard->getAnyLocked("testmove");
        auto value_ptr = (r1.get()->cast<long*>());
        (*value_ptr)++;
        cycles++;
      }
    };
 
    auto t1 = std::thread(func);  // other thread
    func();                       // this thread
    t1.join();
 
    // number of increments and cycles is expected to be the same
    ASSERT_EQ(cycles, value);
  }
  //------------------
  // UNSAFE way to access a pointer
  {
    std::atomic_llong cycles = 0;
    auto func = [&]() {
      auto start = std::chrono::system_clock::now();
      while((std::chrono::system_clock::now() - start) < timeout)
      {
        auto value_ptr = blackboard->get<long*>("testmove");
        (*value_ptr)++;
        cycles++;
      }
    };
 
    auto t1 = std::thread(func);
    func();
    t1.join();
    // since the operation value_ptr++ is not thread safe, cycle and value will unlikely be the same
    ASSERT_NE(cycles, value);
  }
}
 
TEST(BlackboardTest, SetStringView)
{
  auto bb = Blackboard::create();
 
  constexpr BT::StringView string_view_const = "BehaviorTreeCpp";
  bb->set("string_view", string_view_const);
 
  ASSERT_NO_THROW(bb->set("string_view", string_view_const));
}
 
TEST(ParserTest, Issue605_whitespaces)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4" >
    <BehaviorTree ID="MySubtree">
      <Script code=" sub_value:=false " />
    </BehaviorTree>
 
    <BehaviorTree ID="MainTree">
      <Sequence>
        <Script code=" my_value:=true " />
        <SubTree ID="MySubtree" sub_value="{my_value}  "/>
      </Sequence>
    </BehaviorTree>
  </root> )";
 
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
  const auto status = tree.tickWhileRunning();
 
  for(auto const& subtree : tree.subtrees)
  {
    subtree->blackboard->debugMessage();
  }
 
  ASSERT_EQ(status, BT::NodeStatus::SUCCESS);
  ASSERT_EQ(false, tree.rootBlackboard()->get<bool>("my_value"));
}
 
class ComparisonNode : public BT::ConditionNode
{
public:
  ComparisonNode(const std::string& name, const BT::NodeConfiguration& config)
    : BT::ConditionNode(name, config)
  {}
 
  static BT::PortsList providedPorts()
  {
    return { BT::InputPort<int32_t>("first"), BT::InputPort<int32_t>("second"),
             BT::InputPort<std::string>("operator") };
  }
 
  BT::NodeStatus tick() override
  {
    int32_t firstValue = 0;
    int32_t secondValue = 0;
    std::string inputOperator;
    if(!getInput("first", firstValue) || !getInput("second", secondValue) ||
       !getInput("operator", inputOperator))
    {
      throw RuntimeError("can't access input");
    }
    if((inputOperator == "==" && firstValue == secondValue) ||
       (inputOperator == "!=" && firstValue != secondValue) ||
       (inputOperator == "<=" && firstValue <= secondValue) ||
       (inputOperator == ">=" && firstValue >= secondValue) ||
       (inputOperator == "<" && firstValue < secondValue) ||
       (inputOperator == ">" && firstValue > secondValue))
    {
      return BT::NodeStatus::SUCCESS;
    }
    // skipping the rest of the implementation
    return BT::NodeStatus::FAILURE;
  }
};
 
TEST(BlackboardTest, IssueSetBlackboard)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4" >
    <BehaviorTree ID="MySubtree">
      <ComparisonNode first="{value}" second="42" operator="==" />
    </BehaviorTree>
 
    <BehaviorTree ID="MainTree">
      <Sequence>
        <SetBlackboard value="42" output_key="value" />
        <SubTree ID="MySubtree" value="{value}  "/>
      </Sequence>
    </BehaviorTree>
  </root> )";
 
  factory.registerNodeType<ComparisonNode>("ComparisonNode");
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
  const auto status = tree.tickWhileRunning();
 
  ASSERT_EQ(status, BT::NodeStatus::SUCCESS);
  ASSERT_EQ(42, tree.rootBlackboard()->get<int>("value"));
}
 
struct Point
{
  double x;
  double y;
};
 
// Template specialization to converts a string to Point.
namespace BT
{
template <>
[[nodiscard]] Point convertFromString(StringView str)
{
  // We expect real numbers separated by semicolons
  auto parts = splitString(str, ';');
  if(parts.size() != 2)
  {
    throw RuntimeError("invalid input)");
  }
  else
  {
    Point output{ 0.0, 0.0 };
    output.x = convertFromString<double>(parts[0]);
    output.y = convertFromString<double>(parts[1]);
    // std::cout << "Building a position 2d object " << output.x << "; " << output.y << "\n" << std::flush;
    return output;
  }
}
}  // end namespace BT
 
TEST(BlackboardTest, SetBlackboard_Issue725)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4">
    <BehaviorTree ID="MainTree">
      <SetBlackboard value="{first_point}" output_key="other_point" />
    </BehaviorTree>
  </root> )";
 
  factory.registerNodeType<DummyNodes::SaySomething>("SaySomething");
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
  auto& blackboard = tree.subtrees.front()->blackboard;
 
  const Point point = { 2, 7 };
  blackboard->set("first_point", point);
 
  const auto status = tree.tickOnce();
 
  Point other_point = blackboard->get<Point>("other_point");
 
  ASSERT_EQ(status, BT::NodeStatus::SUCCESS);
  ASSERT_EQ(other_point.x, point.x);
  ASSERT_EQ(other_point.y, point.y);
}
 
TEST(BlackboardTest, NullOutputRemapping)
{
  auto bb = Blackboard::create();
 
  NodeConfig config;
 
  config.blackboard = bb;
  config.input_ports["in_port"] = "{my_input_port}";
  config.output_ports["out_port"] = "";
  bb->set("my_input_port", 11);
 
  BB_TestNode node("good_one", config);
 
  // This will throw because setOutput should fail in BB_TestNode::tick()
  ASSERT_ANY_THROW(node.executeTick());
}
 
TEST(BlackboardTest, BlackboardBackup)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4" >
    <BehaviorTree ID="MySubtree">
      <Sequence>
        <Script code=" important_value:= sub_value " />
        <Script code=" my_value=false " />
        <SaySomething message="{message}" />
      </Sequence>
    </BehaviorTree>
    <BehaviorTree ID="MainTree">
      <Sequence>
        <Script code=" my_value:=true; another_value:='hi' " />
        <SubTree ID="MySubtree" sub_value="true" message="{another_value}" _autoremap="true" />
      </Sequence>
    </BehaviorTree>
  </root> )";
 
  factory.registerNodeType<DummyNodes::SaySomething>("SaySomething");
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
 
  // Blackboard Backup
  const auto bb_backup = BlackboardBackup(tree);
 
  std::vector<std::vector<std::string>> expected_keys;
  for(const auto& sub : tree.subtrees)
  {
    std::vector<std::string> keys;
    for(const auto& str_view : sub->blackboard->getKeys())
    {
      keys.push_back(std::string(str_view));
    }
    expected_keys.push_back(keys);
  }
 
  auto status = tree.tickWhileRunning();
 
  ASSERT_EQ(status, BT::NodeStatus::SUCCESS);
 
  // Restore Blackboard
  ASSERT_EQ(bb_backup.size(), tree.subtrees.size());
  BlackboardRestore(bb_backup, tree);
 
  for(size_t i = 0; i < tree.subtrees.size(); i++)
  {
    const auto keys = tree.subtrees[i]->blackboard->getKeys();
    ASSERT_EQ(expected_keys[i].size(), keys.size());
    for(size_t a = 0; a < keys.size(); a++)
    {
      ASSERT_EQ(expected_keys[i][a], keys[a]);
    }
  }
  status = tree.tickWhileRunning();
  ASSERT_EQ(status, BT::NodeStatus::SUCCESS);
}
 
TEST(BlackboardTest, RootBlackboard)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4" >
    <BehaviorTree ID="SubA">
      <Sequence>
        <SubTree ID="SubB" />
        <Script code=" @var3:=3 " />
      </Sequence>
    </BehaviorTree>
 
    <BehaviorTree ID="SubB">
      <Sequence>
        <SaySomething message="{@msg}" />
        <Script code=" @var4:=4 " />
      </Sequence>
    </BehaviorTree>
 
    <BehaviorTree ID="Sub_Issue823">
      <BB_TestNode in_port="2" out_port="{@var5}" />
    </BehaviorTree>
 
    <BehaviorTree ID="MainTree">
      <Sequence>
        <Script code=" msg:='hello' " />
        <SubTree ID="SubA" />
 
        <Script code="@var5:=0" />
        <SubTree ID="Sub_Issue823" />
 
        <Script code=" var1:=1 " />
        <Script code=" @var2:=2 " />
      </Sequence>
    </BehaviorTree>
  </root> )";
 
  factory.registerNodeType<DummyNodes::SaySomething>("SaySomething");
  factory.registerNodeType<BB_TestNode>("BB_TestNode");
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
 
  auto status = tree.tickWhileRunning();
  ASSERT_EQ(status, BT::NodeStatus::SUCCESS);
 
  ASSERT_EQ(1, tree.rootBlackboard()->get<int>("var1"));
  ASSERT_EQ(2, tree.rootBlackboard()->get<int>("var2"));
  ASSERT_EQ(3, tree.rootBlackboard()->get<int>("var3"));
  ASSERT_EQ(4, tree.rootBlackboard()->get<int>("var4"));
  ASSERT_EQ(4, tree.rootBlackboard()->get<int>("var5"));
}
 
TEST(BlackboardTest, TimestampedInterface)
{
  auto bb = BT::Blackboard::create();
 
  // still empty, expected to fail
  int value;
  ASSERT_FALSE(bb->getStamped<int>("value"));
  ASSERT_FALSE(bb->getStamped("value", value));
 
  auto nsec_before = std::chrono::steady_clock::now().time_since_epoch().count();
  bb->set("value", 42);
  auto result = bb->getStamped<int>("value");
  auto stamp_opt = bb->getStamped<int>("value", value);
 
  ASSERT_EQ(result->value, 42);
  ASSERT_EQ(result->stamp.seq, 1);
  ASSERT_GE(result->stamp.time.count(), nsec_before);
 
  ASSERT_EQ(value, 42);
  ASSERT_TRUE(stamp_opt);
  ASSERT_EQ(stamp_opt->seq, 1);
  ASSERT_GE(stamp_opt->time.count(), nsec_before);
 
  //---------------------------------
  nsec_before = std::chrono::steady_clock::now().time_since_epoch().count();
  bb->set("value", 69);
  result = bb->getStamped<int>("value");
  stamp_opt = bb->getStamped<int>("value", value);
 
  ASSERT_EQ(result->value, 69);
  ASSERT_EQ(result->stamp.seq, 2);
  ASSERT_GE(result->stamp.time.count(), nsec_before);
 
  ASSERT_EQ(value, 69);
  ASSERT_TRUE(stamp_opt);
  ASSERT_EQ(stamp_opt->seq, 2);
  ASSERT_GE(stamp_opt->time.count(), nsec_before);
}
 
TEST(BlackboardTest, SetBlackboard_Upd_Ts_SeqId)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4">
    <BehaviorTree ID="MainTree">
      <Sequence>
        <Script code="other_point:=first_point" />
        <Sleep msec="5" />
        <SetBlackboard value="{second_point}" output_key="other_point" />
      </Sequence>
    </BehaviorTree>
  </root> )";
 
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
  auto& blackboard = tree.subtrees.front()->blackboard;
 
  const Point point1 = { 2, 2 };
  const Point point2 = { 3, 3 };
  blackboard->set("first_point", point1);
  blackboard->set("second_point", point2);
 
  tree.tickExactlyOnce();
  const auto entry_ptr = blackboard->getEntry("other_point");
  const auto ts1 = entry_ptr->stamp;
  const auto seq_id1 = entry_ptr->sequence_id;
  tree.tickWhileRunning();
  const auto ts2 = entry_ptr->stamp;
  const auto seq_id2 = entry_ptr->sequence_id;
 
  ASSERT_GT(ts2.count(), ts1.count());
  ASSERT_GT(seq_id2, seq_id1);
}
 
TEST(BlackboardTest, SetBlackboard_ChangeType1)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4">
    <BehaviorTree ID="MainTree">
      <Sequence>
        <SetBlackboard value="{first_point}" output_key="other_point" />
        <Sleep msec="5" />
        <SetBlackboard value="{random_str}" output_key="other_point" />
      </Sequence>
    </BehaviorTree>
  </root> )";
 
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
  auto& blackboard = tree.subtrees.front()->blackboard;
 
  const Point point = { 2, 7 };
  blackboard->set("first_point", point);
  blackboard->set("random_str", "Hello!");
 
  // First tick should succeed
  ASSERT_NO_THROW(tree.tickExactlyOnce());
  const auto entry_ptr = blackboard->getEntry("other_point");
  std::this_thread::sleep_for(std::chrono::milliseconds{ 5 });
  // Second tick should throw due to type mismatch
  EXPECT_THROW({ tree.tickWhileRunning(); }, BT::LogicError);
}
 
TEST(BlackboardTest, SetBlackboard_ChangeType2)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
  <root BTCPP_format="4">
    <BehaviorTree ID="MainTree">
      <Sequence>
        <SetBlackboard value="{first_point}" output_key="other_point" />
        <Sleep msec="5" />
        <SetBlackboard value="{random_num}" output_key="other_point" />
      </Sequence>
    </BehaviorTree>
  </root> )";
 
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
  auto& blackboard = tree.subtrees.front()->blackboard;
 
  const Point point = { 2, 7 };
  blackboard->set("first_point", point);
  blackboard->set("random_num", 57);
 
  // First tick should succeed
  ASSERT_NO_THROW(tree.tickExactlyOnce());
  const auto entry_ptr = blackboard->getEntry("other_point");
  std::this_thread::sleep_for(std::chrono::milliseconds{ 5 });
  // Second tick should throw due to type mismatch
  EXPECT_THROW({ tree.tickWhileRunning(); }, BT::LogicError);
}
 
// Simple Action that updates an instance of Point in the blackboard
class UpdatePosition : public BT::SyncActionNode
{
public:
  UpdatePosition(const std::string& name, const BT::NodeConfig& config)
    : BT::SyncActionNode(name, config)
  {}
 
  BT::NodeStatus tick() override
  {
    const auto in_pos = getInput<Point>("pos_in");
    if(!in_pos.has_value())
      return BT::NodeStatus::FAILURE;
    Point _pos = in_pos.value();
    _pos.x += getInput<double>("x").value_or(0.0);
    _pos.y += getInput<double>("y").value_or(0.0);
    setOutput("pos_out", _pos);
    return BT::NodeStatus::SUCCESS;
  }
 
  static BT::PortsList providedPorts()
  {
    return { BT::InputPort<Point>("pos_in", { 0.0, 0.0 }, "Initial position"),
             BT::InputPort<double>("x"), BT::InputPort<double>("y"),
             BT::OutputPort<Point>("pos_out") };
  }
 
private:
};
 
TEST(BlackboardTest, SetBlackboard_WithPortRemapping)
{
  BT::BehaviorTreeFactory factory;
 
  const std::string xml_text = R"(
    <?xml version="1.0"?>
    <root BTCPP_format="4" main_tree_to_execute="MainTree">
      <BehaviorTree ID="MainTree">
          <Sequence>
              <SetBlackboard output_key="pos" value="0.0;0.0" />
              <Repeat num_cycles="3">
                  <Sequence>
                      <UpdatePosition pos_in="{pos}" x="0.1" y="0.2" pos_out="{pos}"/>
                      <SubTree ID="UpdPosPlus" _autoremap="true" new_pos="2.2;2.4" />
                      <Sleep msec="125"/>
                      <SetBlackboard output_key="pos" value="22.0;22.0" />
                  </Sequence>
              </Repeat>
          </Sequence>
      </BehaviorTree>
      <BehaviorTree ID="UpdPosPlus">
          <Sequence>
              <SetBlackboard output_key="pos" value="3.0;5.0" />
              <SetBlackboard output_key="pos" value="{new_pos}" />
          </Sequence>
      </BehaviorTree>
    </root>
  )";
 
  factory.registerNodeType<UpdatePosition>("UpdatePosition");
  factory.registerBehaviorTreeFromText(xml_text);
  auto tree = factory.createTree("MainTree");
  auto& blackboard = tree.subtrees.front()->blackboard;
 
  // First tick should succeed and update the value within the subtree
  ASSERT_NO_THROW(tree.tickExactlyOnce());
 
  const auto entry_ptr = blackboard->getEntry("pos");
  ASSERT_EQ(entry_ptr->value.type(), typeid(Point));
 
  const auto x = entry_ptr->value.cast<Point>().x;
  const auto y = entry_ptr->value.cast<Point>().y;
  ASSERT_EQ(x, 2.2);
  ASSERT_EQ(y, 2.4);
 
  // Tick till the end with no crashes
  ASSERT_NO_THROW(tree.tickWhileRunning(););
}