MRMD 0.4.0
Multi Resolution Molecular Dynamics
Loading...
Searching...
No Matches
verbose.hpp
Go to the documentation of this file.
1// Copyright 2024 Sebastian Eibl
2// Copyright 2026 Julian Friedrich Hille
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// https://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
38
39#pragma once
40
41#include <cassert>
42#include <iomanip>
43#include <iostream>
44#include <sstream>
45#include <string>
46
47namespace assumption
48{
49inline void log(const std::string& msg) { std::cout << msg << std::endl; }
50
51template <typename T>
52std::string generateAssertionMessage(const T& lhs,
53 const std::string& lhsExpression,
54 const std::string& opString,
55 const std::string& filename,
56 const int64_t lineno,
57 const std::string& /*function*/)
58{
59 std::stringstream ss;
60 int length = static_cast<int>(lhsExpression.length());
61 ss << "========================================================================\n"
62 << "ASSUMPTION FAILED! (" << filename << ":" << lineno << ")\n\n"
63 << "Expression: " << opString << "( " << lhsExpression << " )\n"
64 << "Value: " << std::setw(length) << std::setfill(' ') << lhsExpression << " = " << lhs;
65 return ss.str();
66}
67
68template <typename T, typename U>
69std::string generateAssertionMessage(const T& lhs,
70 const U& rhs,
71 const std::string& lhsExpression,
72 const std::string& rhsExpression,
73 const std::string& opString,
74 const std::string& filename,
75 const int64_t lineno,
76 const std::string& /*function*/)
77{
78 std::stringstream ss;
79 int length = static_cast<int>(std::max(lhsExpression.length(), rhsExpression.length()));
80 ss << "========================================================================\n"
81 << "ASSUMPTION FAILED! (" << filename << ":" << lineno << ")\n\n"
82 << "Expression: " << lhsExpression << opString << rhsExpression << "\n"
83 << "Values: " << std::setw(length) << std::setfill(' ') << lhsExpression << " = " << lhs
84 << "\n"
85 << " " << std::setw(length) << std::setfill(' ') << rhsExpression << " = " << rhs;
86 return ss.str();
87}
88
89#define LOG(msg) \
90 { \
91 std::stringstream ss; \
92 ss << msg; \
93 assumption::log(ss.str()); \
94 }
95
96// macro overloading (-> https://stackoverflow.com/a/24028231)
97
98#define GLUE(x, y) x y
99
100#define RETURN_ARG_COUNT(_1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, count, ...) count
101#define EXPAND_ARGS(args) RETURN_ARG_COUNT args
102#define COUNT_ARGS_MAX10(...) EXPAND_ARGS((__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
103
104#define OVERLOAD_MACRO2(name, count) name##count
105#define OVERLOAD_MACRO1(name, count) OVERLOAD_MACRO2(name, count)
106#define OVERLOAD_MACRO(name, count) OVERLOAD_MACRO1(name, count)
107
108#define MACRO_OVERLOAD(name, ...) \
109 GLUE(OVERLOAD_MACRO(name, COUNT_ARGS_MAX10(__VA_ARGS__)), (__VA_ARGS__))
110
111#define MRMD_VERBOSE_CHECK_1(X) \
112 { \
113 do \
114 { \
115 if (!((X))) \
116 { \
117 LOG(assumption::generateAssertionMessage( \
118 (X), #X, "", __FILE__, __LINE__, __func__)); \
119 assert(false); \
120 } \
121 } while (0); \
122 }
123#define MRMD_VERBOSE_CHECK_2(X, MSG) \
124 { \
125 do \
126 { \
127 if (!((X))) \
128 { \
129 LOG(assumption::generateAssertionMessage( \
130 (X), #X, "", __FILE__, __LINE__, __func__) \
131 << "\n" \
132 << MSG); \
133 assert(false); \
134 } \
135 } while (0); \
136 }
137
138#define MRMD_VERBOSE_CHECK_NULLPTR_1(X) \
139 { \
140 do \
141 { \
142 if (!((X) == nullptr)) \
143 { \
144 LOG(assumption::generateAssertionMessage( \
145 (X), #X, "nullptr", __FILE__, __LINE__, __func__)); \
146 assert(false); \
147 } \
148 } while (0); \
149 }
150#define MRMD_VERBOSE_CHECK_NULLPTR_2(X, MSG) \
151 { \
152 do \
153 { \
154 if (!((X) == nullptr)) \
155 { \
156 LOG(assumption::generateAssertionMessage( \
157 (X), #X, "nullptr", __FILE__, __LINE__, __func__) \
158 << "\n" \
159 << MSG); \
160 assert(false); \
161 } \
162 } while (0); \
163 }
164
165#define MRMD_VERBOSE_CHECK_NOT_NULLPTR_1(X) \
166 { \
167 do \
168 { \
169 if (!((X) != nullptr)) \
170 { \
171 LOG(assumption::generateAssertionMessage( \
172 (X), #X, "!nullptr", __FILE__, __LINE__, __func__)); \
173 assert(false); \
174 } \
175 } while (0); \
176 }
177#define MRMD_VERBOSE_CHECK_NOT_NULLPTR_2(X, MSG) \
178 { \
179 do \
180 { \
181 if (!((X) != nullptr)) \
182 { \
183 LOG(assumption::generateAssertionMessage( \
184 (X), #X, "!nullptr", __FILE__, __LINE__, __func__) \
185 << "\n" \
186 << MSG); \
187 assert(false); \
188 } \
189 } while (0); \
190 }
191
192#define MRMD_VERBOSE_CHECK_EQUAL_2(X, Y) \
193 { \
194 do \
195 { \
196 if (!((X) == (Y))) \
197 { \
198 LOG(assumption::generateAssertionMessage( \
199 (X), (Y), #X, #Y, " == ", __FILE__, __LINE__, __func__)); \
200 assert(false); \
201 } \
202 } while (0); \
203 }
204#define MRMD_VERBOSE_CHECK_EQUAL_3(X, Y, MSG) \
205 { \
206 do \
207 { \
208 if (!((X) == (Y))) \
209 { \
210 LOG(assumption::generateAssertionMessage( \
211 (X), (Y), #X, #Y, " == ", __FILE__, __LINE__, __func__) \
212 << "\n" \
213 << MSG); \
214 assert(false); \
215 } \
216 } while (0); \
217 }
218
219#define MRMD_VERBOSE_CHECK_FLOAT_EQUAL_2(X, Y) \
220 { \
221 do \
222 { \
223 if (!(isFloatEqual((X), (Y)))) \
224 { \
225 LOG(assumption::generateAssertionMessage( \
226 (X), (Y), #X, #Y, " == ", __FILE__, __LINE__, __func__)); \
227 assert(false); \
228 } \
229 } while (0); \
230 }
231#define MRMD_VERBOSE_CHECK_FLOAT_EQUAL_3(X, Y, MSG) \
232 { \
233 do \
234 { \
235 if (!(isFloatEqual((X), (Y)))) \
236 { \
237 LOG(assumption::generateAssertionMessage( \
238 (X), (Y), #X, #Y, " == ", __FILE__, __LINE__, __func__) \
239 << "\n" \
240 << MSG); \
241 assert(false); \
242 } \
243 } while (0); \
244 }
245
246#define MRMD_VERBOSE_CHECK_NOT_EQUAL_2(X, Y) \
247 { \
248 do \
249 { \
250 if (!((X) != (Y))) \
251 { \
252 LOG(assumption::generateAssertionMessage( \
253 (X), (Y), #X, #Y, " != ", __FILE__, __LINE__, __func__)); \
254 assert(false); \
255 } \
256 } while (0); \
257 }
258#define MRMD_VERBOSE_CHECK_NOT_EQUAL_3(X, Y, MSG) \
259 { \
260 do \
261 { \
262 if (!((X) != (Y))) \
263 { \
264 LOG(assumption::generateAssertionMessage( \
265 (X), (Y), #X, #Y, " != ", __FILE__, __LINE__, __func__) \
266 << "\n" \
267 << MSG); \
268 assert(false); \
269 } \
270 } while (0); \
271 }
272
273#define MRMD_VERBOSE_CHECK_GREATER_2(X, Y) \
274 { \
275 do \
276 { \
277 if (!((X) > (Y))) \
278 { \
279 LOG(assumption::generateAssertionMessage( \
280 (X), (Y), #X, #Y, " > ", __FILE__, __LINE__, __func__)); \
281 assert(false); \
282 } \
283 } while (0); \
284 }
285#define MRMD_VERBOSE_CHECK_GREATER_3(X, Y, MSG) \
286 { \
287 do \
288 { \
289 if (!((X) > (Y))) \
290 { \
291 LOG(assumption::generateAssertionMessage( \
292 (X), (Y), #X, #Y, " > ", __FILE__, __LINE__, __func__) \
293 << "\n" \
294 << MSG); \
295 assert(false); \
296 } \
297 } while (0); \
298 }
299
300#define MRMD_VERBOSE_CHECK_LESS_2(X, Y) \
301 { \
302 do \
303 { \
304 if (!((X) < (Y))) \
305 { \
306 LOG(assumption::generateAssertionMessage( \
307 (X), (Y), #X, #Y, " < ", __FILE__, __LINE__, __func__)); \
308 assert(false); \
309 } \
310 } while (0); \
311 }
312#define MRMD_VERBOSE_CHECK_LESS_3(X, Y, MSG) \
313 { \
314 do \
315 { \
316 if (!((X) < (Y))) \
317 { \
318 LOG(assumption::generateAssertionMessage( \
319 (X), (Y), #X, #Y, " < ", __FILE__, __LINE__, __func__) \
320 << "\n" \
321 << MSG); \
322 assert(false); \
323 } \
324 } while (0); \
325 }
326
327#define MRMD_VERBOSE_CHECK_GREATEREQUAL_2(X, Y) \
328 { \
329 do \
330 { \
331 if (!((X) >= (Y))) \
332 { \
333 LOG(assumption::generateAssertionMessage( \
334 (X), (Y), #X, #Y, " >= ", __FILE__, __LINE__, __func__)); \
335 assert(false); \
336 } \
337 } while (0); \
338 }
339#define MRMD_VERBOSE_CHECK_GREATEREQUAL_3(X, Y, MSG) \
340 { \
341 do \
342 { \
343 if (!((X) >= (Y))) \
344 { \
345 LOG(assumption::generateAssertionMessage( \
346 (X), (Y), #X, #Y, " >= ", __FILE__, __LINE__, __func__) \
347 << "\n" \
348 << MSG); \
349 assert(false); \
350 } \
351 } while (0); \
352 }
353
354#define MRMD_VERBOSE_CHECK_LESSEQUAL_2(X, Y) \
355 { \
356 do \
357 { \
358 if (!((X) <= (Y))) \
359 { \
360 LOG(assumption::generateAssertionMessage( \
361 (X), (Y), #X, #Y, " <= ", __FILE__, __LINE__, __func__)); \
362 assert(false); \
363 } \
364 } while (0); \
365 }
366#define MRMD_VERBOSE_CHECK_LESSEQUAL_3(X, Y, MSG) \
367 { \
368 do \
369 { \
370 if (!((X) <= (Y))) \
371 { \
372 LOG(assumption::generateAssertionMessage( \
373 (X), (Y), #X, #Y, " <= ", __FILE__, __LINE__, __func__) \
374 << "\n" \
375 << MSG); \
376 assert(false); \
377 } \
378 } while (0); \
379 }
380
381#define MRMD_VERBOSE_CHECK(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_, __VA_ARGS__)
382#define MRMD_VERBOSE_CHECK_NULLPTR(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_EQUAL_, __VA_ARGS__)
383#define MRMD_VERBOSE_CHECK_NOT_NULLPTR(...) \
384 MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_NOT_NULLPTR_, __VA_ARGS__)
385#define MRMD_VERBOSE_CHECK_EQUAL(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_EQUAL_, __VA_ARGS__)
386#define MRMD_VERBOSE_CHECK_FLOAT_EQUAL(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_EQUAL_, __VA_ARGS__)
387#define MRMD_VERBOSE_CHECK_NOT_EQUAL(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_NOT_EQUAL_, __VA_ARGS__)
388#define MRMD_VERBOSE_CHECK_GREATER(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_GREATER_, __VA_ARGS__)
389#define MRMD_VERBOSE_CHECK_LESS(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_LESS_, __VA_ARGS__)
390#define MRMD_VERBOSE_CHECK_GREATEREQUAL(...) \
391 MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_GREATEREQUAL_, __VA_ARGS__)
392#define MRMD_VERBOSE_CHECK_LESSEQUAL(...) MACRO_OVERLOAD(MRMD_VERBOSE_CHECK_LESSEQUAL_, __VA_ARGS__)
393
394} // namespace assumption
assumption
Copyright (c) 2020 Sebastian Eibl.
Definition verbose.hpp:48
assumption::log
void log(const std::string &msg)
Definition verbose.hpp:49
assumption::generateAssertionMessage
std::string generateAssertionMessage(const T &lhs, const std::string &lhsExpression, const std::string &opString, const std::string &filename, const int64_t lineno, const std::string &)
Definition verbose.hpp:52