testManager.h

Go to the documentation of this file.

#ifndef TESTMANAGER_INCLUDED
#define TESTMANAGER_INCLUDED

#include <iostream>
#include <fstream>
#include <cmath>
#include <string>
#include <vector>
#include <map>

#include "defs.h"
#include "communicator.h"
#include "commonParameters.h"
#include "test.h"

#include "bridgeIO.h"
using Bridge::vout;

// typedef Functor<int> Test_function;
typedef int (*Test_function)(void);

// null function
int DoNothing();

#if 0
// debug
void hook_preexec();
void hook_postexec();
#endif


class TestManager
{
 public:
  static const std::string class_name;

 public:
  void interactive();
  void batch(const std::string& arg);
  void batch_recursive(const std::string& arg = "");
  void batch_recursive(const int argc, char **argv);

  bool registerTest(const std::string& key, const Test_function func);

  void list();

  static TestManager& Instance();

  static bool RegisterTest(const std::string& key, const Test_function func)
  { return Instance().registerTest(key, func); }

  // for test result verification
  int getCheckPrecision() const
  { return m_precision; }

 private:
  // singleton
  TestManager();

  TestManager(const TestManager&);            // not implemented
  TestManager& operator=(const TestManager&); // not implemented

  ~TestManager();

  static void CreateInstance();

  static TestManager *s_instance;

  // bi-directional tree representation of key
  struct Node
  {
    Node                *m_prev;
    std::vector<Node *> m_next;
    std::string         m_name;     // key
    Test_function       m_function; // payload

    Node(const std::string& name, Node *const prev = 0)
      : m_prev(prev), m_next(), m_name(name), m_function(DoNothing) {}
    ~Node()
    {
      for (size_t i = 0; i < m_next.size(); ++i) { delete m_next[i]; }
    }
  };

  Node *find_node(Node *p, const std::vector<std::string>& v);
  Node *append_key(Node *p, const std::vector<std::string>& v);
  Node *append_key(Node *p, int argc, char **argv);

  // statistics
  struct Stat
  {
    int                      m_num_tests;
    int                      m_num_success;
    int                      m_num_failure;
    int                      m_num_skip;
    std::vector<std::string> m_list_failure;
    std::vector<std::string> m_list_skip;

    void                     reset();
    void                     success(const std::string& test_name);
    void                     failure(const std::string& test_name);
    void                     skip(const std::string& test_name);
  };

  void stat_report() const;

  std::string find_fullpath(const Node *p, const std::string& path = "");

  void interactive_master();
  void interactive_slave();

  void run(const Node *p);
  void run_traversal(const Node *p);

  bool menu(const Node *p, const bool is_top = false);
  void banner();

  void set_precision();

  void list_traverse(const Node *p, const std::string& prefix);

  // for debug
  void traverse(const Node *p, const std::string& indent = "");


  Bridge::VerboseLevel m_vl;

  Node m_root_node;

  // for test result verification
  int m_precision;

  // for statistics report
  Stat m_stat;
};
#endif // TEST_MANAGER_H