Scale Stack 0.3 Developer Documentation

scalestack/kernel/test.h

Go to the documentation of this file.

/*
 * Scale Stack
 *
 * Copyright 2010 Eric Day
 *
 * 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.apache.org/licenses/LICENSE-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 SCALESTACK_KERNEL_TEST_H
#define SCALESTACK_KERNEL_TEST_H

#include <cassert>
#include <exception>
#include <functional>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

#include <scalestack/kernel/core.h>
#include <scalestack/kernel/macros.h>

namespace scalestack
{
namespace kernel
{

template <class T>
class test_suite
{
public:

  test_suite(int argc, const char** argv);

  virtual ~test_suite();

  virtual void setup(void);

  virtual void teardown(void);

  void run(void);

  void add_default_threading_service(void);

  void add_default_event_service(void);

  typedef std::vector<std::pair<std::string, std::mem_fun_t<void, T> > >
    test_cases;

protected:

  kernel::core* core;
  test_cases _test_cases;

private:

  test_suite(const test_suite&);

  test_suite& operator=(const test_suite&);

  int _argc;
  const char** _argv;
};

template <class T>
inline test_suite<T>::test_suite(int argc, const char** argv):
  core(),
  _test_cases(),
  _argc(argc),
  _argv(argv)
{
}

template <class T>
inline test_suite<T>::~test_suite()
{
}

template <class T>
inline void test_suite<T>::setup(void)
{
}

template <class T>
inline void test_suite<T>::teardown(void)
{
}

template <class T>
inline void test_suite<T>::run(void)
{
  for (typename test_cases::iterator test = _test_cases.begin();
       test != _test_cases.end(); ++test)
  {
    std::cout << "+++ " << test->first << std::endl;
    core = new kernel::core;
    core->parse_arguments(_argc, _argv);
    core->add_module_option_value("path", "", "scalestack/.libs");
    setup();
    test->second.operator()(static_cast<T*>(this));
    teardown();
    size_t verbose = core->get_threshold();
    delete core;
    if (verbose > 0)
      std::cout << "--- " << test->first << std::endl << std::endl;
  }
}

template <class T>
inline void test_suite<T>::add_default_threading_service(void)
{
  core->add_module_option_value("threading::service", "",
                                "threading::pthreads");
}

template <class T>
inline void test_suite<T>::add_default_event_service(void)
{
  core->add_module_option_value("event::service", "", "event::libevent");
}

#define test_case(_name) \
 _test_cases.push_back(std::make_pair(SCALESTACK_QUOTE(_name), \
                                      std::mem_fun(&_name)))

#define assert_exception(_method) \
do \
{ \
  bool _test_exception = false; \
  try \
  { \
    _method; \
  } \
  catch (std::exception&) \
  { \
    _test_exception = true; \
  } \
  assert(_test_exception); \
} \
while (false)

} /* namespace kernel */
} /* namespace scalestack */

#endif /* SCALESTACK_KERNEL_TEST_H */

---