ceph/src/seastar/src/testing/seastar_test.cc

   1 /*
   2  * This file is open source software, licensed to you under the terms
   3  * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
   4  * distributed with this work for additional information regarding copyright
   5  * ownership.  You may not use this file except in compliance with the License.
   6  *
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing,
  12  * software distributed under the License is distributed on an
  13  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14  * KIND, either express or implied.  See the License for the
  15  * specific language governing permissions and limitations
  16  * under the License.
  17  */
  18
  19 /*
  20  * Copyright (C) 2015 Cloudius Systems, Ltd.
  21  */
  22
  23 #include <thread>
  24 #include <iostream>
  25
  26 #include <seastar/testing/entry_point.hh>
  27 #include <seastar/testing/seastar_test.hh>
  28 #include <seastar/testing/test_runner.hh>
  29 #include <seastar/core/future.hh>
  30 #include <seastar/core/on_internal_error.hh>
  31 #include <seastar/core/app-template.hh>
  32 #include <seastar/testing/on_internal_error.hh>
  33
  34 namespace seastar {
  35
  36 namespace testing {
  37
  38 exchanger_base::exchanger_base() { }
  39 exchanger_base::~exchanger_base() { }
  40
  41 void seastar_test::run() {
  42     // HACK: please see https://github.com/cloudius-systems/seastar/issues/10
  43     BOOST_REQUIRE(true);
  44
  45     // HACK: please see https://github.com/cloudius-systems/seastar/issues/10
  46     boost::program_options::variables_map()["dummy"];
  47
  48     set_abort_on_internal_error(true);
  49
  50     global_test_runner().run_sync([this] {
  51         return run_test_case();
  52     });
  53 }
  54
  55 // We store a pointer because tests are registered from dynamic initializers,
  56 // so we must ensure that 'tests' is initialized before any dynamic initializer.
  57 // I use a primitive type, which is guaranteed to be initialized before any
  58 // dynamic initializer and lazily allocate the factor.
  59
  60 static std::vector<seastar_test*>* tests = nullptr;
  61
  62 const std::vector<seastar_test*>& known_tests() {
  63     if (!tests) {
  64         throw std::runtime_error("No tests registered");
  65     }
  66     return *tests;
  67 }
  68
  69 seastar_test::seastar_test() {
  70     if (!tests) {
  71         tests = new std::vector<seastar_test*>();
  72     }
  73     tests->push_back(this);
  74 }
  75
  76 namespace exception_predicate {
  77
  78 std::function<bool(const std::exception&)> message_equals(std::string_view expected_message) {
  79     return [expected_message] (const std::exception& e) {
  80         std::string error = e.what();
  81         if (error == expected_message) {
  82             return true;
  83         } else {
  84             std::cerr << "Expected \"" << expected_message << "\" but got \"" << error << '"' << std::endl;
  85             return false;
  86         }
  87     };
  88 }
  89
  90 std::function<bool(const std::exception&)> message_contains(std::string_view expected_message) {
  91     return [expected_message] (const std::exception& e) {
  92         std::string error = e.what();
  93         if (error.find(expected_message.data()) != std::string::npos) {
  94             return true;
  95         } else {
  96             std::cerr << "Expected \"" << expected_message << "\" but got \"" << error << '"' << std::endl;
  97             return false;
  98         }
  99     };
 100 }
 101
 102 } // exception_predicate
 103
 104 scoped_no_abort_on_internal_error::scoped_no_abort_on_internal_error() noexcept
 105     : _prev(set_abort_on_internal_error(false))
 106 {
 107 }
 108
 109 scoped_no_abort_on_internal_error::~scoped_no_abort_on_internal_error() {
 110     set_abort_on_internal_error(_prev);
 111 }
 112
 113 }
 114
 115 }