test.h 5.36 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
// Licensed under the MIT License:
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

22
#pragma once
23 24 25 26 27 28

#if defined(__GNUC__) && !KJ_HEADER_WARNINGS
#pragma GCC system_header
#endif

#include "debug.h"
Kenton Varda's avatar
Kenton Varda committed
29
#include "vector.h"
30
#include "function.h"
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

namespace kj {

class TestRunner;

class TestCase {
public:
  TestCase(const char* file, uint line, const char* description);
  ~TestCase();

  virtual void run() = 0;

private:
  const char* file;
  uint line;
  const char* description;
  TestCase* next;
  TestCase** prev;
Kenton Varda's avatar
Kenton Varda committed
49
  bool matchedFilter;
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

  friend class TestRunner;
};

#define KJ_TEST(description) \
  /* Make sure the linker fails if tests are not in anonymous namespaces. */ \
  extern int KJ_CONCAT(YouMustWrapTestsInAnonymousNamespace, __COUNTER__) KJ_UNUSED; \
  class KJ_UNIQUE_NAME(TestCase): public ::kj::TestCase { \
  public: \
    KJ_UNIQUE_NAME(TestCase)(): ::kj::TestCase(__FILE__, __LINE__, description) {} \
    void run() override; \
  } KJ_UNIQUE_NAME(testCase); \
  void KJ_UNIQUE_NAME(TestCase)::run()

#if _MSC_VER
65
#define KJ_INDIRECT_EXPAND(m, vargs) m vargs
66
#define KJ_FAIL_EXPECT(...) \
67
  KJ_INDIRECT_EXPAND(KJ_LOG, (ERROR , __VA_ARGS__));
68
#define KJ_EXPECT(cond, ...) \
69
  if (cond); else KJ_INDIRECT_EXPAND(KJ_FAIL_EXPECT, ("failed: expected " #cond , __VA_ARGS__))
70 71 72 73 74 75 76
#else
#define KJ_FAIL_EXPECT(...) \
  KJ_LOG(ERROR, ##__VA_ARGS__);
#define KJ_EXPECT(cond, ...) \
  if (cond); else KJ_FAIL_EXPECT("failed: expected " #cond, ##__VA_ARGS__)
#endif

77
#define KJ_EXPECT_THROW_RECOVERABLE(type, code) \
78 79 80 81 82 83 84 85 86
  do { \
    KJ_IF_MAYBE(e, ::kj::runCatchingExceptions([&]() { code; })) { \
      KJ_EXPECT(e->getType() == ::kj::Exception::Type::type, \
          "code threw wrong exception type: " #code, e->getType()); \
    } else { \
      KJ_FAIL_EXPECT("code did not throw: " #code); \
    } \
  } while (false)

87
#define KJ_EXPECT_THROW_RECOVERABLE_MESSAGE(message, code) \
88 89 90 91 92 93 94 95 96
  do { \
    KJ_IF_MAYBE(e, ::kj::runCatchingExceptions([&]() { code; })) { \
      KJ_EXPECT(::kj::_::hasSubstring(e->getDescription(), message), \
          "exception description didn't contain expected substring", e->getDescription()); \
    } else { \
      KJ_FAIL_EXPECT("code did not throw: " #code); \
    } \
  } while (false)

97 98 99 100 101 102 103 104 105 106 107 108 109 110
#if KJ_NO_EXCEPTIONS
#define KJ_EXPECT_THROW(type, code) \
  do { \
    KJ_EXPECT(::kj::_::expectFatalThrow(type, nullptr, [&]() { code; })); \
  } while (false)
#define KJ_EXPECT_THROW_MESSAGE(message, code) \
  do { \
    KJ_EXPECT(::kj::_::expectFatalThrow(nullptr, kj::StringPtr(message), [&]() { code; })); \
  } while (false)
#else
#define KJ_EXPECT_THROW KJ_EXPECT_THROW_RECOVERABLE
#define KJ_EXPECT_THROW_MESSAGE KJ_EXPECT_THROW_RECOVERABLE_MESSAGE
#endif

111 112 113 114 115
#define KJ_EXPECT_LOG(level, substring) \
  ::kj::_::LogExpectation KJ_UNIQUE_NAME(_kjLogExpectation)(::kj::LogSeverity::level, substring)
// Expects that a log message with the given level and substring text will be printed within
// the current scope. This message will not cause the test to fail, even if it is an error.

Kenton Varda's avatar
Kenton Varda committed
116 117 118 119
// =======================================================================================

namespace _ {  // private

120 121
bool hasSubstring(kj::StringPtr haystack, kj::StringPtr needle);

122 123 124 125 126 127 128 129
#if KJ_NO_EXCEPTIONS
bool expectFatalThrow(Maybe<Exception::Type> type, Maybe<StringPtr> message,
                      Function<void()> code);
// Expects that the given code will throw a fatal exception matching the given type and/or message.
// Since exceptions are disabled, the test will fork() and run in a subprocess. On Windows, where
// fork() is not available, this always returns true.
#endif

130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
class LogExpectation: public ExceptionCallback {
public:
  LogExpectation(LogSeverity severity, StringPtr substring);
  ~LogExpectation();

  void logMessage(LogSeverity severity, const char* file, int line, int contextDepth,
                  String&& text) override;

private:
  LogSeverity severity;
  StringPtr substring;
  bool seen;
  UnwindDetector unwindDetector;
};

Kenton Varda's avatar
Kenton Varda committed
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
class GlobFilter {
  // Implements glob filters for the --filter flag.
  //
  // Exposed in header only for testing.

public:
  explicit GlobFilter(const char* pattern);
  explicit GlobFilter(ArrayPtr<const char> pattern);

  bool matches(StringPtr name);

private:
  String pattern;
  Vector<uint> states;

  void applyState(char c, int state);
};

}  // namespace _ (private)
164
}  // namespace kj