ServiceTestCase.h

Go to the documentation of this file.

/*
 * Copyright 2006-2008 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WISP_TEST_SERVICE_TEST_CASE_H
#define __SSRC_WISP_TEST_SERVICE_TEST_CASE_H

#include <ssrc/wisp/service/service.h>
#include <ssrc/wisp/utility/service_main.h>
#include <ssrc/wisp/test/test_main.h>

#include <boost/bind.hpp>
#include <boost/thread/thread.hpp>

__BEGIN_NS_SSRC_WISP_TEST

using namespace NS_SSRC_WISP;
using NS_SSRC_WISP_SERVICE::ServiceEventHandler;
using NS_SSRC_WISP_SERVICE::Service;

template<typename ProtocolProcessor,
         template <typename PP> class EH = ServiceEventHandler>
class TestService : public Service<EH<ProtocolProcessor> > {
  typedef Service<EH<ProtocolProcessor> > super;

public:

  explicit TestService(const string & connection = "",
                       const string & name = "", 
                       const unsigned int message_capacity =
                       NS_SSRC_SPREAD::Message::DefaultCapacity) :
    super(connection, name, message_capacity)
  { }

  template<typename Initializer>
  explicit TestService(const Initializer & initializer,
                       const string & connection = "",
                       const string & name = "", 
                       const unsigned int message_capacity =
                       NS_SSRC_SPREAD::Message::DefaultCapacity) :
    super(initializer, connection, name, message_capacity)
  { }

  using super::protocol;
};

// Destructor fires on cppunit exception to terminate thread.
template<typename service_type, typename CallStop>
struct ServiceThread : public service_type::caller_type {
  typedef typename service_type::caller_type super;
  typedef NS_SSRC_WISP_SERVICE::EventLoop loop_type;
  typedef boost::shared_ptr<loop_type> loop_ptr;
  typedef boost::shared_ptr<boost::thread> thread_ptr;

  WISP_IMPORT_T(service_type, protocol_processor);

  service_type & serv;
  thread_ptr thread;
  loop_ptr loop;

  ServiceThread(service_type & serv) :
    super(WISP_SPREAD_DAEMON),
    serv(serv), thread(), loop(new loop_type)
  {
    serv.start(*loop, 300);
    thread =
      thread_ptr(new boost::thread(boost::bind(&loop_type::start, loop)));
    while(serv.state() != protocol_processor::Started)
      boost::thread::yield();    
  }

  ~ServiceThread() {
    super::template send<CallStop>(serv.name());
    thread->join();
  }
};

struct TestOptions {
  string connection;
  string name;
  unsigned int capacity;

  TestOptions() :
    connection(WISP_SPREAD_DAEMON), name(),
    capacity(NS_SSRC_SPREAD::Message::DefaultCapacity)
  { }
};

template<typename ProtocolProcessor,
         typename CallStop,
         template <typename PP> class EH = ServiceEventHandler,
         typename Options = TestOptions,
         bool has_initializer = false>
class ServiceTestCase : public TestCase {
protected:
  typedef ProtocolProcessor protocol_processor;
  //typedef EH<protocol_processor> event_handler;
  typedef TestService<protocol_processor, EH> service_type;
  typedef ServiceThread<service_type, CallStop> service_thread;
  typedef
  utility::ServiceFactory<service_type, Options, has_initializer>
  service_factory;

  Options options;
  service_factory new_service;
  typename service_factory::service_ptr serv;

public:

  virtual void setUp() {
    serv = new_service(options);
  }

  virtual void tearDown() {
    serv.reset();
  }
};

__END_NS_SSRC_WISP_TEST

#endif