1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
|
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#pragma once
#include <Progmasoft/Catch3/AssertionInfo.hpp>
#include <Progmasoft/Catch3/Internal/Decomposer.hpp>
#include <string>
namespace Catch {
class RunContext;
struct AssertionReaction {
bool shouldDebugBreak = false;
bool shouldThrow = false;
bool shouldSkip = false;
};
class AssertionHandler {
AssertionInfo m_assertionInfo;
AssertionReaction m_reaction;
bool m_completed = false;
// Since all uses are hidden in the .cpp file, we can directly use
// the final type and avoid going through virtual dispatch, without
// massive compilation time overhead.
RunContext& m_resultCapture;
void finishIncomplete();
public:
AssertionHandler
( StringRef macroName,
SourceLineInfo const& lineInfo,
StringRef capturedExpression,
ResultDisposition::Flags resultDisposition );
~AssertionHandler() {
// We want the common fast path inlinable, and the virtual
// dispatch in a function in single TU.
if ( !m_completed ) { finishIncomplete(); }
}
template<typename T>
constexpr void handleExpr( ExprLhs<T> const& expr ) {
handleExpr( expr.makeUnaryExpr() );
}
void handleExpr( ITransientExpression const& expr );
void handleMessage(ResultWas::OfType resultType, std::string&& message);
void handleExceptionThrownAsExpected();
void handleUnexpectedExceptionNotThrown();
void handleExceptionNotThrownAsExpected();
void handleThrowingCallSkipped();
// Marking this as `noexcept` gives us measurable improvement
// in optimized compilation times. Making it `noexcept` changes
// what happens if the underlying code throws, **but** the only
// way this can throw is if the reporter itself throws from
// `assertionEnded`. However, in such case the process is going
// to abort anyway, because we will enter `assertionEnded` again
// from the (noexcept) destructor of `AssertionHandler` above.
// In the future, all reporter event handlers will be marked
// `noexcept` to make this limitation explicit.
void handleUnexpectedInflightException() noexcept;
// Ideally we could extend the logic above to more of the handle*
// function, but right now it would worsen the behaviour of
// preexisting custom reporters that throw from event handlers.
void complete();
// query
auto allowThrows() const -> bool;
};
void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
} // namespace Catch
|