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 <thread>
  
  __BEGIN_NS_SSRC_WISP_TEST
  
  using namespace NS_SSRC_WISP;
  using NS_SSRC_WISP_SERVICE::ServiceEventHandler;
  using NS_SSRC_WISP_SERVICE::Service;
  using NS_SSRC_WISP_UTILITY::make_smart_ptr;
  
  template<typename ProtocolProcessor,
   template <typename PP, typename...> class EH = ServiceEventHandler>
  class TestService : public Service<EH<ProtocolProcessor> > {
   typedef Service<EH<ProtocolProcessor> > super;
  
  public:
  
   explicit TestService(const std::string & connection = "",
   const std::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 std::string & connection = "",
   const std::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 std::shared_ptr<loop_type> loop_ptr;
   typedef std::shared_ptr<std::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(make_smart_ptr<loop_ptr>())
   {
   serv.start(*loop, 300);
   thread =
   thread_ptr(make_smart_ptr<thread_ptr>(std::bind(&loop_type::start,
   loop)));
   while(serv.state() != protocol_processor::Started) {
   std::this_thread::yield();
   }
   }
  
   ~ServiceThread() {
   super::template send<CallStop>(serv.name());
   thread->join();
   }
  };
  
  struct TestOptions {
   std::string connection;
   std::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, typename...> 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