Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
assert.hpp
Go to the documentation of this file.
1#pragma once
2
3#include "barretenberg/common/bb_bench.hpp"
4#include "barretenberg/common/compiler_hints.hpp"
5#include "barretenberg/common/throw_or_abort.hpp"
6#include <cstdint>
7#include <regex>
8#include <sstream>
9
10// Enable this for (VERY SLOW) stats on which asserts are hit the most. Note that the time measured will be very
11// inaccurate, but you can still see what is called too often to be in a release build.
12// #define BB_BENCH_ASSERT(x) BB_BENCH_NAME(x)
13#define BB_BENCH_ASSERT(x)
14
15namespace bb {
16enum class AssertMode : std::uint8_t { ABORT, WARN };
17AssertMode& get_assert_mode();
18void assert_failure(std::string const& err);
19
20// NOTE do not use in threaded contexts!
30} // namespace bb
31
32// NOTE do not use in threaded contexts!
33#define BB_DISABLE_ASSERTS() bb::AssertGuard __bb_assert_guard(bb::AssertMode::WARN)
34
35// NOLINTBEGIN
36// Compiler should optimize this out in release builds, without triggering unused-variable warnings.
37#define DONT_EVALUATE(expression) \
38 { \
39 true ? static_cast<void>(0) : static_cast<void>((expression)); \
40 }
41
42#if NDEBUG
43
44// All assertion macros accept an optional message but do nothing in release.
45#define BB_ASSERT_DEBUG(expression, ...) DONT_EVALUATE((expression))
46
47#else
48#include "barretenberg/common/log.hpp"
49#include <cassert>
50#include <cstdlib>
51#include <iostream>
52#include <string>
53
54// Basic assert with optional error message
55#define BB_ASSERT_DEBUG(expression, ...) BB_ASSERT(expression, __VA_ARGS__)
56#endif // NDEBUG
57
58#ifdef FUZZING_DISABLE_WARNINGS
59#define BB_ASSERT(expression, ...) \
60 do { \
61 BB_BENCH_ASSERT("BB_ASSERT" #expression); \
62 if (!(BB_LIKELY(expression))) { \
63 std::ostringstream oss; \
64 oss << "Assertion failed: (" #expression ")"; \
65 __VA_OPT__(oss << "\nReason : " << __VA_ARGS__;) \
66 bb::assert_failure(oss.str()); \
67 } \
68 } while (0)
69#else
70#define BB_ASSERT(expression, ...) \
71 do { \
72 BB_BENCH_ASSERT("BB_ASSERT" #expression); \
73 if (!(BB_LIKELY(expression))) { \
74 std::ostringstream oss; \
75 oss << "Assertion failed: (" #expression ")"; \
76 __VA_OPT__(oss << "\nReason : " << __VA_ARGS__;) \
77 info(oss.str()); \
78 bb::assert_failure(oss.str()); \
79 } \
80 } while (0)
81#endif
82
83#define BB_ASSERT_EQ(actual, expected, ...) \
84 do { \
85 BB_BENCH_ASSERT("BB_ASSERT_EQ" #actual " == " #expected); \
86 const auto& _actual = (actual); \
87 const auto& _expected = (expected); \
88 if (!(BB_LIKELY(_actual == _expected))) { \
89 std::ostringstream oss; \
90 oss << "Assertion failed: (" #actual " == " #expected ")\n"; \
91 oss << " Actual : " << _actual << "\n"; \
92 oss << " Expected: " << _expected; \
93 __VA_OPT__(oss << "\n Reason : " << __VA_ARGS__;) \
94 bb::assert_failure(oss.str()); \
95 } \
96 } while (0)
97
98#define BB_ASSERT_NEQ(actual, expected, ...) \
99 do { \
100 BB_BENCH_ASSERT("BB_ASSERT_NEQ" #actual " != " #expected); \
101 const auto& _actual = (actual); \
102 const auto& _expected = (expected); \
103 if (!(BB_LIKELY(_actual != _expected))) { \
104 std::ostringstream oss; \
105 oss << "Assertion failed: (" #actual " != " #expected ")\n"; \
106 oss << " Actual : " << _actual << "\n"; \
107 oss << " Not expected: " << _expected; \
108 __VA_OPT__(oss << "\n Reason : " << __VA_ARGS__;) \
109 bb::assert_failure(oss.str()); \
110 } \
111 } while (0)
112
113#define BB_ASSERT_GT(left, right, ...) \
114 do { \
115 BB_BENCH_ASSERT("BB_ASSERT_GT" #left " > " #right); \
116 const auto& _left = (left); \
117 const auto& _right = (right); \
118 if (!(BB_LIKELY(_left > _right))) { \
119 std::ostringstream oss; \
120 oss << "Assertion failed: (" #left " > " #right ")\n"; \
121 oss << " Left : " << _left << "\n"; \
122 oss << " Right : " << _right; \
123 __VA_OPT__(oss << "\n Reason : " << __VA_ARGS__;) \
124 bb::assert_failure(oss.str()); \
125 } \
126 } while (0)
127
128#define BB_ASSERT_GTE(left, right, ...) \
129 do { \
130 BB_BENCH_ASSERT("BB_ASSERT_GTE" #left " >= " #right); \
131 const auto& _left = (left); \
132 const auto& _right = (right); \
133 if (!(BB_LIKELY(_left >= _right))) { \
134 std::ostringstream oss; \
135 oss << "Assertion failed: (" #left " >= " #right ")\n"; \
136 oss << " Left : " << _left << "\n"; \
137 oss << " Right : " << _right; \
138 __VA_OPT__(oss << "\n Reason : " << __VA_ARGS__;) \
139 bb::assert_failure(oss.str()); \
140 } \
141 } while (0)
142
143#define BB_ASSERT_LT(left, right, ...) \
144 do { \
145 BB_BENCH_ASSERT("BB_ASSERT_LT" #left " < " #right); \
146 const auto& _left = (left); \
147 const auto& _right = (right); \
148 if (!(BB_LIKELY(_left < _right))) { \
149 std::ostringstream oss; \
150 oss << "Assertion failed: (" #left " < " #right ")\n"; \
151 oss << " Left : " << _left << "\n"; \
152 oss << " Right : " << _right; \
153 __VA_OPT__(oss << "\n Reason : " << __VA_ARGS__;) \
154 bb::assert_failure(oss.str()); \
155 } \
156 } while (0)
157
158#define BB_ASSERT_LTE(left, right, ...) \
159 do { \
160 BB_BENCH_ASSERT("BB_ASSERT_LTE" #left " <= " #right); \
161 const auto& _left = (left); \
162 const auto& _right = (right); \
163 if (!(BB_LIKELY(_left <= _right))) { \
164 std::ostringstream oss; \
165 oss << "Assertion failed: (" #left " <= " #right ")\n"; \
166 oss << " Left : " << _left << "\n"; \
167 oss << " Right : " << _right; \
168 __VA_OPT__(oss << "\n Reason : " << __VA_ARGS__;) \
169 bb::assert_failure(oss.str()); \
170 } \
171 } while (0)
172
173// BB_ASSERT_NO_WASM: Use this for asserts that are too expensive to run in WASM
174// (e.g., asserts inside hot loops or with expensive computations)
175#ifdef __wasm__
176#define BB_ASSERT_NO_WASM(expression, ...) DONT_EVALUATE((expression))
177#define BB_ASSERT_EQ_NO_WASM(actual, expected, ...) DONT_EVALUATE((actual) == (expected))
178#define BB_ASSERT_LT_NO_WASM(left, right, ...) DONT_EVALUATE((left) < (right))
179#else
180#define BB_ASSERT_NO_WASM(expression, ...) BB_ASSERT(expression, __VA_ARGS__)
181#define BB_ASSERT_EQ_NO_WASM(actual, expected, ...) BB_ASSERT_EQ(actual, expected, __VA_ARGS__)
182#define BB_ASSERT_LT_NO_WASM(left, right, ...) BB_ASSERT_LT(left, right, __VA_ARGS__)
183#endif
184
185// These are used in tests.
186#ifdef BB_NO_EXCEPTIONS
187#define ASSERT_THROW_OR_ABORT(statement, matcher) ASSERT_DEATH(statement, matcher)
188#define EXPECT_THROW_OR_ABORT(statement, matcher) EXPECT_DEATH(statement, matcher)
189#define EXPECT_THROW_WITH_MESSAGE(code, expectedMessage) EXPECT_DEATH(code, expectedMessage)
190#else
191#define ASSERT_THROW_OR_ABORT(statement, matcher) ASSERT_THROW(statement, std::runtime_error)
192#define EXPECT_THROW_OR_ABORT(statement, matcher) EXPECT_THROW(statement, std::runtime_error)
193#define EXPECT_THROW_WITH_MESSAGE(code, expectedMessageRegex) \
194 try { \
195 code; \
196 FAIL() << "Expected exception with message matching: " << expectedMessageRegex; \
197 } catch (const std::exception& e) { \
198 EXPECT_TRUE(std::regex_search(std::string(e.what()), std::regex(expectedMessageRegex))) \
199 << "Exception message: " << e.what() << "\nExpected to match regex: " << expectedMessageRegex; \
200 }
201#endif // BB_NO_EXCEPTIONS
202// NOLINTEND
bb_bench.hpp
compiler_hints.hpp
bb
Entry point for Barretenberg command-line interface.
Definition api.hpp:5
bb::get_assert_mode
AssertMode & get_assert_mode()
Definition assert.cpp:5
bb::assert_failure
void assert_failure(std::string const &err)
Definition assert.cpp:11
bb::AssertMode
AssertMode
Definition assert.hpp:16
std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13
bb::AssertGuard::AssertGuard
AssertGuard(AssertMode mode)
Definition assert.hpp:22
bb::AssertGuard::previous_mode
AssertMode previous_mode
Definition assert.hpp:28
throw_or_abort.hpp