test_interface.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 <rve_interface_gen/Foo.h>
#include <rve_interface_gen/Foo_multipleReturnRequest.h>
#include <rve_interface_gen/Foo_multipleReturnResponse.h>
#include <rve_rpc/call_handle.h>
#include <rve_rpc/method_response.h>
#include <rve_rpc/server.h>
#include <rve_rpc/client.h>

#include <gtest/gtest.h>

#include <ros/ros.h>

using namespace rve_interface_gen;

class MyFooServer : public FooServer
{
public:
  MyFooServer(rve_rpc::Server& server)
  : FooServer(server)
  , async_call_done(false)
  , async_fastcall_done(false)
  {}

  virtual void triple( uint32_t val ,  uint32_t& out_val )
  {
    out_val = val * 3;
  }

  virtual void blockFor( const ros::Duration& d )
  {
    d.sleep();
  }

  virtual void noBlock( )
  {
    async_call_done = false;
    ros::Duration(1.0).sleep();
    async_call_done = true;
  }

  virtual void complex( const std_msgs::String& name ,  float val ,  std_msgs::String& out_ret )
  {
    std::stringstream ss;
    ss << name << val;
    out_ret.data = ss.str();
  }

  virtual void multipleReturn(multipleReturnHandle& handle)
  {
    multipleReturnResponsePtr res(new multipleReturnResponse);
    res->val = handle.getRequest()->val;
    res->val_doubled = res->val * 2;
    handle.respond(res);
  }

  virtual void withString(const std::string& str)
  {

  }

  bool async_call_done;
  bool async_fastcall_done;
};

class Interfaces : public ::testing::Test
{
public:
  Interfaces()
  : spinner_(1)
  {
    spinner_.start();
  }

  virtual void SetUp()
  {
    rpc_server_ = new rve_rpc::Server("test", nh_);
    rpc_client_ = new rve_rpc::Client("test", nh_);
    server_ = new MyFooServer(*rpc_server_);
    proxy_ = new FooProxy(*rpc_client_);

    rpc_server_->ready();
    rpc_client_->connect();
  }

  virtual void TearDown()
  {
    delete rpc_server_;
    delete rpc_client_;
    delete proxy_;
    delete server_;

  }

  ros::NodeHandle nh_;
  ros::AsyncSpinner spinner_;
  rve_rpc::Server* rpc_server_;
  rve_rpc::Client* rpc_client_;
  MyFooServer* server_;
  FooProxy* proxy_;
};

TEST_F(Interfaces, callWithReturn)
{
  uint32_t ret = 0;
  proxy_->triple(5, ret);
  EXPECT_EQ(ret, 15U);
}

TEST_F(Interfaces, blockingCall)
{
  ros::Time start = ros::Time::now();
  proxy_->blockFor(ros::Duration(1.0));
  ros::Time end = ros::Time::now();
  EXPECT_GE(end, start + ros::Duration(1.0));
}

TEST_F(Interfaces, asyncCall)
{
  proxy_->noBlockAsync();
  EXPECT_FALSE(server_->async_call_done);
}

TEST_F(Interfaces, multipleReturn)
{
  uint32_t ret1 = 0;
  uint32_t ret2 = 0;
  proxy_->multipleReturn(5, ret1, ret2);
  EXPECT_EQ(ret1, 5U);
  EXPECT_EQ(ret2, 10U);
}

TEST_F(Interfaces, fastcallWithReturn)
{
  Foo::multipleReturnRequestPtr req(new Foo::multipleReturnRequest);
  req->val = 5;
  Foo::multipleReturnResponseConstPtr res = proxy_->multipleReturn(req);
  EXPECT_EQ(res->val, 5U);
  EXPECT_EQ(res->val_doubled, 10U);
}

struct AsyncHelper
{
  AsyncHelper()
  : received(false)
  {}

  void cb(const Foo::multipleReturnMethodResponse& mr)
  {
    this->mr = mr;
    received = true;
  }

  Foo::multipleReturnMethodResponse mr;
  bool received;
};

TEST_F(Interfaces, callAsyncReturn)
{
  AsyncHelper ah;
  proxy_->multipleReturnAsync(5, boost::bind(&AsyncHelper::cb, &ah, _1));

  while (!ah.received)
  {
    ros::WallDuration(0.01).sleep();
  }

  EXPECT_EQ(ah.mr.response->val, 5U);
  EXPECT_EQ(ah.mr.response->val_doubled, 10U);
}

TEST_F(Interfaces, fastcallAsyncReturn)
{
  Foo::multipleReturnRequestPtr req(new Foo::multipleReturnRequest);
  req->val = 5;
  AsyncHelper ah;
  proxy_->multipleReturnAsync(req, boost::bind(&AsyncHelper::cb, &ah, _1));

  while (!ah.received)
  {
    ros::WallDuration(0.01).sleep();
  }

  EXPECT_EQ(ah.mr.response->val, 5U);
  EXPECT_EQ(ah.mr.response->val_doubled, 10U);
}


int main(int argc, char** argv)
{
  testing::InitGoogleTest(&argc, argv);
  ros::init(argc, argv, "test_interface");
  ros::NodeHandle nh;

  return RUN_ALL_TESTS();
}