drivers/test_driver.hh

// This file is a part of Catsfoot.
// Copyright (C) 2011  Uni Research
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser Public License for more details.
//
// You should have received a copy of the GNU Lesser Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __TEST_DRIVER_HH
# define __TEST_DRIVER_HH

# include <memory>
# include "../dataset/dataset.hh"
# include <iostream>
# include "../axioms/axioms.hh"
# include "../utils/type_to_string.hh"
# include "../type_traits/always_false.hh"
# include "../type_traits/identity.hh"

namespace catsfoot {

  template <typename T, typename U>
  struct printable;

  namespace details {
    template <
      typename Stream,
      typename T,
      ENABLE_IF(printable<Stream&, T>)>
    void print_if_printable(Stream& s, T&& t) {
      s << t;
    }

    template <
      typename Stream,
      typename T,
      ENABLE_IF_NOT(printable<Stream&, T>),
      typename = void>
    void print_if_printable(Stream& s, T&&) {
      s << "Values of type " << type_to_string<T>() << " are not printable";
    }

    void display_values() {
    }

    template <typename T, typename... U>
    void display_values(T&& t, U&&... u) {
      std::cerr << " * ";
      if (std::is_same<typename std::remove_reference<T>::type, T&&>::value) {
        std::cerr << "Moved variable not printable.";
      }
      else
        print_if_printable(std::cerr, std::forward<T>(t));
      std::cerr << std::endl;
      display_values(std::forward<U>(u)...);
    }

    template <typename... T>
    struct tester;

    template <>
    struct tester<> {
      template <typename Generator, typename Fun, typename... Params,
                typename Stream>
      static bool call_gen_final(Stream& s,
                                 Generator&, Fun f, Params&&... values) {
        try {
          f((std::forward<Params>(values))...);
          return true;
        } catch (axiom_failure af) {
          s << "-----------------------------------------"
            "---------------------------------------" << std::endl;
          s << af.msg() << std::endl;
          s << "Values were: " << std::endl;
          display_values(std::forward<Params>(values)...);
          s << std::endl;
          return false;
        }
      }
      template <typename Generator, typename Fun, typename... Params,
                typename Stream>
      static bool call_gen(Stream& s,
                           Generator& g, Fun f, Params&&... values) {
        return call_gen_final(s, g, f, *std::forward<Params>(values)...);
      }
    };

    //FIXME: We should verify that g.get(selector<T>{}) is callable.
    template <typename T, typename... U>
    struct tester<T, U...> {
      template <typename Generator, typename Fun, typename... Params,
                typename Stream>
      static bool call_gen(Stream& s, Generator& g, Fun f,
                           Params&&... values) {
        auto container = g.get(selector<T>{});
        bool ret = true;
        for (auto i = container.begin();
             i != container.end(); ++i) {
          bool ret2 =
            tester<U...>::call_gen(s, g,
                                   f,
                                   std::forward<Params>(values)...,
                                   i);
          ret = ret && ret2;
        }
        return ret;
      }
    };
  }

  template <typename Generator,
            typename... T, typename Stream = decltype(std::cerr)>
  bool test(Generator& g,
            void f(T...),
            std::string name = "<unknown>",
            Stream& s = std::cerr) {
    if (details::tester<T...>::call_gen(s, g, f)) {
      s << name << ": passed." << std::endl;
      return true;
    } else {
      s << name << ": failed." << std::endl;
      return false;
    }
  }

  template <typename Fun, typename... Params>
  bool catch_errors(Fun f, Params&&... values) {
    default_generator d;
    return details::tester<>::call_gen_final(std::cerr,
                                             d,
                                             f,
                                             std::forward<Params>(values)...);
  }
}

#endif