test_property_value.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_value.h>

using namespace rve_properties;

struct Foo
{
  uint64_t a;
  uint64_t b;
  uint64_t c;
  uint64_t d;

  bool operator==(const Foo& rhs) const
  {
    return a == rhs.a && b == rhs.b && c == rhs.c && d == rhs.d;
  }
};

namespace rve_properties
{

static uint32_t g_foo_to_stream_count = 0;

template<>
struct ValueTraits<Foo>
{
  inline static const char* typeName() { return "Foo"; }

  inline static std::string toString(void* mem)
  {
    ++g_foo_to_stream_count;
    Foo* f = reinterpret_cast<Foo*>(mem);
    std::ostringstream os;
    os << f->a << " " << f->b << " " << f->c << " " << f->d;
    return os.str();
  }

  inline static void fromString(void* mem, const std::string& str)
  {
    Foo* f = reinterpret_cast<Foo*>(mem);
    std::istringstream is(str);
    is >> f->a;
    is.ignore();
    is >> f->b;
    is.ignore();
    is >> f->c;
    is.ignore();
    is >> f->d;
  }
};

}

TEST(PropertyValue, setThenGetSameType)
{
  PropertyValue pv;
  uint32_t val = 5;
  pv.set(val);
  val = 10;
  val = pv.get<uint32_t>();
  EXPECT_EQ(val, 5U);
}

TEST(PropertyValue, setIntThenGetFloat)
{
  PropertyValue pv;
  pv.set<uint32_t>(25);
  float val = pv.get<float>();
  EXPECT_EQ(val, 25.0f);
}

std::istream& operator>>(std::istream& is, Foo& foo)
{
  is >> foo.a;
  is.ignore();
  is >> foo.b;
  is.ignore();
  is >> foo.c;
  is.ignore();
  is >> foo.d;
  return is;
}

TEST(PropertyValue, setThenGetSamelargeStruct)
{
  g_foo_to_stream_count = 0;

  Foo f;
  f.a = 10;
  f.b = 100;
  f.c = 1000;
  f.d = 10000;
  PropertyValue pv;
  pv.set(f);
  f = pv.get<Foo>();

  EXPECT_EQ(f.a, 10U);
  EXPECT_EQ(f.b, 100U);
  EXPECT_EQ(f.c, 1000U);
  EXPECT_EQ(f.d, 10000U);
  EXPECT_EQ(g_foo_to_stream_count, 0U);
}

TEST(PropertyValue, setLargeStructThenGetString)
{
  g_foo_to_stream_count = 0;

  Foo f;
  f.a = 10;
  f.b = 100;
  f.c = 1000;
  f.d = 10000;
  PropertyValue pv;
  pv.set(f);
  std::string str;
  pv.get(str);

  EXPECT_STREQ(str.c_str(), "10 100 1000 10000");

  EXPECT_EQ(g_foo_to_stream_count, 1U);
}

TEST(PropertyValue, setThenGetString)
{
  PropertyValue pv;
  pv.set(std::string("foo bar baz"));
  std::string s;
  pv.get(s);
  EXPECT_STREQ(s.c_str(), "foo bar baz");
}

TEST(PropertyValue, setCharStarThenGetString)
{
  PropertyValue pv;
  pv.set("foo bar baz");
  std::string s;
  pv.get(s);
  EXPECT_STREQ(s.c_str(), "foo bar baz");
}

bool g_destructor_called = false;
struct Bar
{
  ~Bar()
  {
    g_destructor_called = true;
  }
};

std::ostream& operator<<(std::ostream& os, const Bar& bar)
{
  return os;
}

std::istream& operator>>(std::istream& is, Bar& bar)
{
  return is;
}

TEST(PropertyValue, destructor)
{
  PropertyValue pv;
  pv.set(Bar());
  // temporaries will be destroyed
  g_destructor_called = false;

  pv.set(5);
  EXPECT_TRUE(g_destructor_called);
}

TEST(PropertyValue, copySmall)
{
  PropertyValue pv;
  pv.set(5);
  PropertyValue pv2;
  pv2 = pv;
  EXPECT_EQ(pv2.get<uint32_t>(), 5U);
}

TEST(PropertyValue, copyLarge)
{
  Foo foo;
  foo.a = 10;
  foo.b = 100;
  foo.c = 1000;
  foo.d = 10000;
  PropertyValue pv;
  pv.set(foo);
  PropertyValue pv2;
  pv2 = pv;
  EXPECT_TRUE(pv2.get<Foo>() == foo);
}

int main(int argc, char** argv)
{
  std::cout << "sizeof(PropertyValue): " << sizeof(PropertyValue) << "\n";
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}