test_intra.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_rpc/client.h>
#include <rve_rpc/server.h>

#include <rve_rpc/TestRequest.h>
#include <rve_rpc/TestResponse.h>

#include <ros/ros.h>

#include <gtest/gtest.h>

#include <boost/thread.hpp>

using namespace rve_rpc;

void doubleCallback(CallHandle<TestRequest, TestResponse>& handle)
{
  TestResponsePtr res(new TestResponse);
  res->value = handle.getRequest()->value * 2;
  handle.respond(res);
}

void tripleCallback(CallHandle<TestRequest, TestResponse>& handle)
{
  TestResponsePtr res(new TestResponse);
  res->value = handle.getRequest()->value * 3;
  handle.respond(res);
}

TEST(Intra, callWithReturn)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  TestResponseConstPtr res = m.call(req);
  EXPECT_EQ(res->value, 10U);
}

TEST(Intra, multipleMethodsWithReturn)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  s.addMethod<TestRequest, TestResponse>("triple", tripleCallback);
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> d = c.addMethod<TestRequest, TestResponse>("double");
  Method<TestRequest, TestResponse> t = c.addMethod<TestRequest, TestResponse>("triple");
  c.connect();

  {
    TestRequestPtr req(new TestRequest);
    req->value = 5;
    TestResponseConstPtr res = d.call(req);
    EXPECT_EQ(res->value, 10U);
  }

  {
    TestRequestPtr req(new TestRequest);
    req->value = 20;
    TestResponseConstPtr res = t.call(req);
    EXPECT_EQ(res->value, 60U);
  }
}

TEST(Intra, callUnknownMethod)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("triple");
  c.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;

  try
  {
    TestResponseConstPtr res = m.call(req);
    FAIL();
  }
  catch (CallException& e)
  {
    ROS_INFO("%s", e.what());
    SUCCEED();
  }
}

TEST(Intra, connectAsync)
{
  ros::NodeHandle nh;
  Server s("test", nh);
  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connectAsync();
  ASSERT_FALSE(c.isConnected());
  while (!c.isConnected())
  {
    ros::spinOnce();
    ros::WallDuration(0.01).sleep();
  }

  ros::AsyncSpinner sp(1);
  sp.start();
  TestRequestPtr req(new TestRequest);
  req->value = 5;
  TestResponseConstPtr res = m.call(req);
  EXPECT_EQ(res->value, 10U);
}

struct NoCopyHelper
{
  void cb(CallHandle<TestRequest, TestResponse>& handle)
  {
    req_ = handle.getRequest();
    res_.reset(new TestResponse);
    res_->value = req_->value * 2;
    handle.respond(res_);
  }

  TestRequestConstPtr req_;
  TestResponsePtr res_;
};

TEST(Intra, noCopy)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  NoCopyHelper h;
  s.addMethod<TestRequest, TestResponse>("double", boost::bind(&NoCopyHelper::cb, &h, _1));
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  TestResponseConstPtr res = m.call(req);
  EXPECT_EQ(res->value, 10U);
  EXPECT_EQ(req, h.req_);
  EXPECT_EQ(res, h.res_);
}

void callThread(Method<TestRequest, TestResponse>& m, volatile bool& done, bool& success, uint32_t start)
{
  while (!done)
  {
    TestRequestPtr req(new TestRequest);
    req->value = start++;
    TestResponseConstPtr res = m.call(req);
    if (res->value != req->value * 2)
    {
      ROS_ERROR("Expected %d but got %d", req->value, res->value);
      success = false;
    }
  }
}

TEST(Intra, multipleCallerThreads)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connect();

  bool done = false;
  bool success = true;
  boost::thread_group tg;
  for (uint32_t i = 0; i < 10; ++i)
  {
    tg.create_thread(boost::bind(callThread, boost::ref(m), boost::ref(done), boost::ref(success), i * 10000));
  }

  ros::WallDuration(5.0).sleep();
  done = true;
  tg.join_all();

  ASSERT_TRUE(success);
}

TEST(Intra, addMethodLater)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  s.ready();

  Client c("test", nh);
  c.connect();

  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  TestResponseConstPtr res = m.call(req);
  EXPECT_EQ(res->value, 10U);
}

TEST(Intra, multipleClientsSingleServer)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  s.ready();

  Client c1("test", nh);
  Method<TestRequest, TestResponse> m1 = c1.addMethod<TestRequest, TestResponse>("double");
  c1.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  TestResponseConstPtr res = m1.call(req);
  EXPECT_EQ(res->value, 10U);

  Client c2("test", nh);
  Method<TestRequest, TestResponse> m2 = c2.addMethod<TestRequest, TestResponse>("double");
  c2.connect();

  res = m2.call(req);
  EXPECT_EQ(res->value, 10U);
}

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

  void cb(const MethodResponse<TestResponse>& res)
  {
    mr = res;
    response = res.response;
    received = true;
  }

  MethodResponse<TestResponse> mr;
  TestResponseConstPtr response;
  bool received;
};

TEST(Intra, callAsyncWithReturn)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  s.addMethod<TestRequest, TestResponse>("double", doubleCallback);
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  AsyncCallHelper h;
  m.callAsync(req, boost::bind(&AsyncCallHelper::cb, &h, _1));

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

  EXPECT_EQ(h.response->value, 10U);
}

struct AsyncResponseHelper
{
  void cb(CallHandle<TestRequest, TestResponse>& handle)
  {
    handle_ = handle;
  }

  CallHandle<TestRequest, TestResponse> handle_;
};

TEST(Intra, callWithAsyncResponse)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  AsyncResponseHelper arh;
  s.addMethod<TestRequest, TestResponse>("double", boost::bind(&AsyncResponseHelper::cb, &arh, _1));
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  AsyncCallHelper h;
  m.callAsync(req, boost::bind(&AsyncCallHelper::cb, &h, _1));

  while (!arh.handle_)
  {
    ros::WallDuration(0.01).sleep();
  }

  TestResponsePtr res(new TestResponse);
  res->value = arh.handle_.getRequest()->value * 2;
  arh.handle_.respond(res);

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

  EXPECT_EQ(h.response->value, 10U);
}

TEST(Intra, callWithAsyncException)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  AsyncResponseHelper arh;
  s.addMethod<TestRequest, TestResponse>("double", boost::bind(&AsyncResponseHelper::cb, &arh, _1));
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  AsyncCallHelper h;
  m.callAsync(req, boost::bind(&AsyncCallHelper::cb, &h, _1));

  while (!arh.handle_)
  {
    ros::WallDuration(0.01).sleep();
  }

  arh.handle_.except("blah");

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

  EXPECT_EQ(h.mr.error_code, Response::EXCEPTION);
}

TEST(Intra, callWithNoResponse)
{
  ros::AsyncSpinner sp(1);
  sp.start();
  ros::NodeHandle nh;
  Server s("test", nh);
  AsyncResponseHelper arh;
  s.addMethod<TestRequest, TestResponse>("double", boost::bind(&AsyncResponseHelper::cb, &arh, _1));
  s.ready();

  Client c("test", nh);
  Method<TestRequest, TestResponse> m = c.addMethod<TestRequest, TestResponse>("double");
  c.connect();

  TestRequestPtr req(new TestRequest);
  req->value = 5;
  AsyncCallHelper h;
  m.callAsync(req, boost::bind(&AsyncCallHelper::cb, &h, _1));

  while (!arh.handle_)
  {
    ros::WallDuration(0.01).sleep();
  }

  arh = AsyncResponseHelper();

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

  EXPECT_EQ(h.mr.error_code, Response::EXCEPTION);
}

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

  return RUN_ALL_TESTS();
}