test_property_node.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2010, Willow Garage, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Willow Garage, Inc. nor the names of its
 *       contributors may be used to endorse or promote products derived from
 *       this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <gtest/gtest.h>

#include <rve_properties/property_node.h>
#include <ros/console.h>

#include <boost/bind.hpp>

using namespace rve_properties;

TEST(PropertyNode, setThenGetValue)
{
  PropertyNodePtr pn(new PropertyNode);
  uint32_t val = 5;
  pn->set(val);
  val = pn->get<uint32_t>();
  EXPECT_EQ(val, 5U);
}

TEST(PropertyNode, setThenGetChildren)
{
  PropertyNodePtr pn(new PropertyNode);
  pn->set<uint32_t>("foo", 5);
  pn->set<uint32_t>("bar", 10);
  pn->set<uint32_t>("baz", 15);
  pn->set<uint32_t>("a", 10);
  pn->set<uint32_t>("a/b", 100);
  pn->set<uint32_t>("a/b/c", 1000);
  pn->set<uint32_t>("a/b/c/d", 10000);

  EXPECT_EQ(pn->get<uint32_t>("foo"), 5U);
  EXPECT_EQ(pn->get<uint32_t>("bar"), 10U);
  EXPECT_EQ(pn->get<uint32_t>("baz"), 15U);
  EXPECT_EQ(pn->get<uint32_t>("a"), 10U);
  EXPECT_EQ(pn->get<uint32_t>("a/b"), 100U);
  EXPECT_EQ(pn->get<uint32_t>("a/b/c"), 1000U);
  EXPECT_EQ(pn->get<uint32_t>("a/b/c/d"), 10000U);
}

TEST(PropertyNode, getNode)
{
  PropertyNodePtr pn(new PropertyNode);
  pn->set<uint32_t>("a/b/c", 5);
  PropertyNodePtr child = pn->getNode("a/b/c");
  EXPECT_EQ(child->get<uint32_t>(), 5U);
}

TEST(PropertyNode, getNonexistentWithoutDefault)
{
  PropertyNodePtr pn(new PropertyNode);
  try
  {
    pn->get<uint32_t>();
    FAIL();
  }
  catch (std::bad_cast&)
  {
    SUCCEED();
  }
}

TEST(PropertyNode, getNonexistentWithDefault)
{
  PropertyNodePtr pn(new PropertyNode);
  try
  {
    uint32_t foo = 5;
    pn->get(foo, 10U);
    EXPECT_EQ(foo, 10U);
  }
  catch (std::bad_cast&)
  {
    FAIL();
  }
}

TEST(PropertyNode, exists)
{
  PropertyNodePtr pn(new PropertyNode);
  pn->set("a/b/c", 5);
  EXPECT_TRUE(pn->exists("a"));
  EXPECT_TRUE(pn->exists("a/b"));
  EXPECT_TRUE(pn->exists("a/b/c"));
  EXPECT_FALSE(pn->exists("b"));
  EXPECT_FALSE(pn->exists("b/c"));
  EXPECT_FALSE(pn->exists("a/c"));
  EXPECT_FALSE(pn->exists("a/b/d"));
}

TEST(PropertyNode, removeNode)
{
  PropertyNodePtr pn(new PropertyNode);
  pn->set("a/b/c", 5);
  pn->set("x/y/z", 10);
  pn->removeNode("a/b/c");
  EXPECT_TRUE(pn->exists("a"));
  EXPECT_TRUE(pn->exists("a/b"));
  EXPECT_TRUE(pn->exists("x/y/z"));
  EXPECT_FALSE(pn->exists("a/b/c"));

  pn->removeNode("x");
  EXPECT_TRUE(pn->exists("a"));
  EXPECT_TRUE(pn->exists("a/b"));
  EXPECT_FALSE(pn->exists("x/y/z"));
  EXPECT_FALSE(pn->exists("x/y"));
  EXPECT_FALSE(pn->exists("x"));
}

TEST(PropertyNode, parenting)
{
  PropertyNodePtr pn(new PropertyNode);
  pn->set("a/b/c/d/e/f", 5);
  EXPECT_EQ(pn->getNode("a/b/c/d/e/f")->getParent(), pn->getNode("a/b/c/d/e"));
  EXPECT_EQ(pn->getNode("a/b/c/d/e")->getParent(), pn->getNode("a/b/c/d"));
  EXPECT_EQ(pn->getNode("a/b/c/d")->getParent(), pn->getNode("a/b/c"));
  EXPECT_EQ(pn->getNode("a/b/c")->getParent(), pn->getNode("a/b"));
  EXPECT_EQ(pn->getNode("a/b")->getParent(), pn->getNode("a"));
  EXPECT_EQ(pn->getNode("a")->getParent(), pn);
  EXPECT_FALSE(pn->getParent());
}

struct ChangeHelper
{
  void cb(const PropertyNodePtr& n, const std::string& p, PropertyChangeType t)
  {
    //ROS_INFO_STREAM(p);
    node = n;
    path = p;
    type = t;
  }

  void reset()
  {
    path.clear();
    node.reset();
  }

  std::string path;
  PropertyNodePtr node;
  PropertyChangeType type;
};

TEST(PropertyNode, propertyChanged)
{
  PropertyNodePtr pn(new PropertyNode);
  ChangeHelper h;
  pn->set("a/b/c", 5);
  pn->addChangeCallback(boost::bind(&ChangeHelper::cb, &h, _1, _2, _3), &h, 0);

  pn->set("a/b/c", 10);
  EXPECT_STREQ(h.path.c_str(), "a/b/c");
  EXPECT_EQ(h.type, PropertyChanged);
  EXPECT_EQ(h.node, pn->getNode("a/b/c"));

  h.reset();
  pn->set("a/b", 55);
  EXPECT_STREQ(h.path.c_str(), "a/b");
  EXPECT_EQ(h.type, PropertyChanged);
  EXPECT_EQ(h.node, pn->getNode("a/b"));

  h.reset();
  pn->set("a", 55);
  EXPECT_STREQ(h.path.c_str(), "a");
  EXPECT_EQ(h.type, PropertyChanged);
  EXPECT_EQ(h.node, pn->getNode("a"));

  h.reset();
  pn->set(55);
  EXPECT_STREQ(h.path.c_str(), "");
  EXPECT_EQ(h.type, PropertyChanged);
  EXPECT_EQ(h.node, pn);
}

struct MultiChangeHelper
{
  void cb(const PropertyNodePtr& n, const std::string& p, PropertyChangeType t)
  {
    //ROS_INFO_STREAM(p << "  " << (uint32_t)t);
    Change c;
    c.node = n;
    c.path = p;
    c.type = t;
    changes.push_back(c);
  }

  void reset()
  {
    changes.clear();
  }

  struct Change
  {
    std::string path;
    PropertyNodePtr node;
    PropertyChangeType type;
  };
  std::vector<Change> changes;
};

TEST(PropertyNode, propertyAdded)
{
  PropertyNodePtr pn(new PropertyNode);
  MultiChangeHelper h;
  pn->addChangeCallback(boost::bind(&MultiChangeHelper::cb, &h, _1, _2, _3), &h, 0);

  pn->set("a/b/c", 5);
  ASSERT_EQ(h.changes.size(), 4U);
  EXPECT_STREQ(h.changes[0].path.c_str(), "a");
  EXPECT_EQ(h.changes[0].type, PropertyAdded);
  EXPECT_STREQ(h.changes[1].path.c_str(), "a/b");
  EXPECT_EQ(h.changes[1].type, PropertyAdded);
  EXPECT_STREQ(h.changes[2].path.c_str(), "a/b/c");
  EXPECT_EQ(h.changes[2].type, PropertyAdded);
  EXPECT_STREQ(h.changes[3].path.c_str(), "a/b/c");
  EXPECT_EQ(h.changes[3].type, PropertyChanged);
}

struct PropertyVisitor
{
  PropertyVisitor()
  : inserted_twice(false)
  {}

  void operator()(const std::string& path, const PropertyNodePtr& node)
  {
    //ROS_INFO("%s\n", path.c_str());
    if (!nodes.insert(std::make_pair(path, node)).second)
    {
      inserted_twice = true;
    }
  }

  std::map<std::string, PropertyNodePtr> nodes;
  bool inserted_twice;
};

TEST(PropertyNode, visitChildrenRecursive)
{
  PropertyNodePtr pn(new PropertyNode);
  pn->set("a/b/c/d/e/f/g/h", 5);

  PropertyVisitor pv;
  pn->visitChildren(pv);
  ASSERT_FALSE(pv.nodes.find("a") == pv.nodes.end());
  ASSERT_FALSE(pv.nodes.find("a/b") == pv.nodes.end());
  ASSERT_FALSE(pv.nodes.find("a/b/c") == pv.nodes.end());
  ASSERT_FALSE(pv.nodes.find("a/b/c/d") == pv.nodes.end());
  ASSERT_FALSE(pv.nodes.find("a/b/c/d/e") == pv.nodes.end());
  ASSERT_FALSE(pv.nodes.find("a/b/c/d/e/f") == pv.nodes.end());
  ASSERT_FALSE(pv.nodes.find("a/b/c/d/e/f/g") == pv.nodes.end());

  EXPECT_EQ(pv.nodes["a"], pn->getNode("a"));
  EXPECT_EQ(pv.nodes["a/b"], pn->getNode("a/b"));
  EXPECT_EQ(pv.nodes["a/b/c"], pn->getNode("a/b/c"));
  EXPECT_EQ(pv.nodes["a/b/c/d"], pn->getNode("a/b/c/d"));
  EXPECT_EQ(pv.nodes["a/b/c/d/e"], pn->getNode("a/b/c/d/e"));
  EXPECT_EQ(pv.nodes["a/b/c/d/e/f"], pn->getNode("a/b/c/d/e/f"));
  EXPECT_EQ(pv.nodes["a/b/c/d/e/f/g"], pn->getNode("a/b/c/d/e/f/g"));
}

TEST(PropertyNode, visitChildrenNonRecursive)
{
  PropertyNodePtr pn(new PropertyNode);
  pn->set("a/b/c/d/e/f/g/h", 5);
  pn->set("z/b/c/d/e/f/g/h", 5);

  PropertyVisitor pv;
  pn->visitChildren(pv, false);
  ASSERT_FALSE(pv.nodes.find("a") == pv.nodes.end());
  ASSERT_FALSE(pv.nodes.find("z") == pv.nodes.end());
  ASSERT_TRUE(pv.nodes.find("a/b") == pv.nodes.end());
  ASSERT_TRUE(pv.nodes.find("a/b/c") == pv.nodes.end());
  ASSERT_TRUE(pv.nodes.find("a/b/c/d") == pv.nodes.end());
  ASSERT_TRUE(pv.nodes.find("a/b/c/d/e") == pv.nodes.end());
  ASSERT_TRUE(pv.nodes.find("a/b/c/d/e/f") == pv.nodes.end());
  ASSERT_TRUE(pv.nodes.find("a/b/c/d/e/f/g") == pv.nodes.end());

  EXPECT_EQ(pv.nodes["a"], pn->getNode("a"));
  EXPECT_EQ(pv.nodes["z"], pn->getNode("z"));
}

int main(int argc, char** argv)
{
  std::cout << "sizeof(PropertyNode): " << sizeof(PropertyNode) << "\n";

  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}