OpenMS
Loading...
Searching...
No Matches
ClassTest.h
Go to the documentation of this file.
1// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
2// SPDX-License-Identifier: BSD-3-Clause
3//
4// --------------------------------------------------------------------------
5// $Maintainer: Timo Sachsenberg $
6// $Authors: Marc Sturm, Clemens Groepl, Chris Bielow, Timo Sachsenberg $
7// --------------------------------------------------------------------------
8
9#pragma once
10
11// Std-only: no libOpenMS or third-party headers, so tests of every OpenMS library
12// (incl. ones that don't link libOpenMS, like OpenSwathAlgo) can use it and
13// recompiles stay cheap. Utilities are its own (ClassTestUtils.h); OpenMS behavior
14// is registered by the OpenMSTestSupport target (src/tests/class_tests), which
15// every class test of a libOpenMS-linking project links.
16#include <OpenMS/CONCEPT/ClassTestUtils.h>
17#include <OpenMS/CONCEPT/MacrosTest.h>
18
19#include <fstream>
20#include <iostream>
21#include <string>
22#include <vector>
23#include <type_traits>
24
25using XMLCh = char16_t; // Xerces-C++ uses char16_t for UTF-16 strings that we need to output in tests
26
27// Empty declaration to avoid problems in case the namespace is not
28// yet defined (e.g. TEST/ClassTest_test.cpp)
29
31#ifndef stdcout
32#define stdcout std::cout
33#endif
34
35namespace OpenMS
36{
37 namespace Internal
38 {
40 namespace ClassTest
41 {
42
44 std::string
45 createTmpFileName(const std::string& file, int line, const std::string& extension = "");
46
47 // isRealType() and writtenDigits() -- used by #TEST_REAL_SIMILAR -- are provided
48 // by ClassTestUtils.h. They classify by convertibility to double, so the framework
49 // does not need to know library value types (DataValue, ParamValue, ...) by name.
50
56 void
57 testRealSimilar(const char* file, int line, long double number_1,
58 const char* number_1_stringified,
59 bool number_1_is_realtype, int number_1_written_digits,
60 long double number_2, const char* number_2_stringified,
61 bool /* number_2_is_realtype */, int number_2_written_digits);
62
64 bool
65 isRealSimilar(long double number_1, long double number_2);
66
74 void
75 testStringSimilar(const char* file, int line,
76 const std::string& string_1,
77 const char* string_1_stringified,
78 const std::string& string_2,
79 const char* string_2_stringified);
80
82 void
83 testStringEqual(const char* file, int line,
84 const std::string& string_1,
85 const char* string_1_stringified,
86 const std::string& string_2,
87 const char* string_2_stringified);
88
94 bool
95 isFileSimilar(const std::string& filename_1,
96 const std::string& filename_2);
97
99 void
100 initialNewline();
101
103 void
104 printWithPrefix(const std::string& text, const int marked = -1);
105
115 void mainInit(const char* version, const char* class_name, int argc, const char* argv0);
116
126 void filesEqual(int line, const char* filename, const char* templatename, const char* filename_stringified, const char* templatename_stringified);
127
129 void removeTempFiles();
130
132 void
133 setWhitelist(const char* const /* file */, const int line,
134 const std::string& whitelist);
135
137 extern double ratio_max_allowed;
138
140 extern double ratio_max;
141
143 extern double ratio;
144
146 extern double absdiff_max_allowed;
147
149 extern double absdiff_max;
150
152 extern double absdiff;
153
154 extern int line_num_1_max;
155 extern int line_num_2_max;
156
158 extern int verbose;
159
161 extern bool all_tests;
162
164 extern bool test;
165
167 extern bool this_test;
168
170 extern int exception;
171
173 extern std::string exception_name;
174
176 extern std::string exception_message;
177
179 extern std::string test_name;
180
182 extern int start_section_line;
183
185 extern int test_line;
186
188 extern const char* version_string;
189
191 extern std::vector<std::string> tmp_file_list;
192
194 extern std::vector<unsigned int> failed_lines_list;
195
197 extern std::ifstream infile;
198
200 extern std::ifstream templatefile;
201
203 extern bool equal_files;
204
206 extern char line_buffer[65536];
207
209 extern int test_count;
210
212 extern std::string add_message;
213
218 extern std::string fuzzy_message;
219
221 extern bool newline;
222
223 template <typename T1, typename T2>
224 void
225 testEqual(const char* /*file*/, int line, const T1& expression_1,
226 const char* expression_1_stringified,
227 const T2& expression_2,
228 const char* expression_2_stringified)
229 {
230 ++test_count;
231 test_line = line;
232 // For std::string targets, stringify the comparison value rather than
233 // constructing std::string(expression_2): the old OpenMS::String had
234 // numeric/char converting constructors (e.g. String(114) == "114") that
235 // std::string lacks. detail::toString reproduces that behavior (and must
236 // format numbers exactly like StringUtils::toStr, see ClassTestUtils.h).
237 if constexpr (std::is_same_v<T1, std::string>)
238 {
239 this_test = bool(expression_1 == detail::toString(expression_2));
240 }
241 else
242 {
243 this_test = bool(expression_1 == T1(expression_2));
244 }
245 test &= this_test;
246 {
247 initialNewline();
248 if (!this_test || verbose > 1)
249 {
250 stdcout << ' ' << (this_test ? '+' : '-') << " line " << line << " : TEST_EQUAL(" << expression_1_stringified << ','
251 << expression_2_stringified << "): got '";
252
253 // we can't print wide chars directly using operator<< so we need to test for it
254 if constexpr (std::is_same_v<std::remove_cv_t<T1>, XMLCh*> || std::is_same_v<std::remove_cv_t<T2>, XMLCh*>)
255 {
256 stdcout << (expression_1 == nullptr ? "(null)" : "(XMLCh*)") << "', expected '"
257 << (expression_2 == nullptr ? "(null)" : "(XMLCh*)") << "'\n";
258 }
259 else if constexpr (std::is_enum_v<T1> && std::is_enum_v<T2>)
260 {
261 stdcout << static_cast<int>(expression_1) << "', expected '" << static_cast<int>(expression_2) << "'\n";
262 }
263 else
264 {
265 detail::printValue(stdcout, expression_1);
266 stdcout << "', expected '";
267 detail::printValue(stdcout, expression_2);
268 stdcout << "'\n";
269 }
270 }
271 if (!this_test)
272 {
273 failed_lines_list.push_back(line);
274 }
275 }
276 }
277
278 inline void testTrue(const char* /*file*/, int line, const bool expression_1, const char* expression_1_stringified)
279 {
280 ++test_count;
281 test_line = line;
282 this_test = expression_1;
283 test &= this_test;
284 {
285 initialNewline();
286 if (this_test)
287 {
288 if (verbose > 1)
289 {
290 stdcout << " + line " << line << ": TEST_TRUE(" << expression_1_stringified << "): ok\n";
291 }
292 }
293 else
294 {
295 stdcout << " - line " << line << ": TEST_TRUE(" << expression_1_stringified << "): failed\n";
296 failed_lines_list.push_back(line);
297 }
298 }
299 }
300
301 inline void testFalse(const char* /*file*/, int line, const bool expression_1, const char* expression_1_stringified)
302 {
303 ++test_count;
304 test_line = line;
305 this_test = !expression_1;
306 test &= this_test;
307 {
308 initialNewline();
309 if (this_test)
310 {
311 if (verbose > 1)
312 {
313 stdcout << " + line " << line << ": TEST_FALSE(" << expression_1_stringified << "): ok\n";
314 }
315 }
316 else
317 {
318 stdcout << " - line " << line << ": TEST_FALSE(" << expression_1_stringified << "): failed\n";
319 failed_lines_list.push_back(line);
320 }
321 }
322 }
323
324 template <typename T1, typename T2>
325 void
326 testNotEqual(const char* /*file*/, int line, const T1& expression_1,
327 const char* expression_1_stringified,
328 const T2& expression_2,
329 const char* expression_2_stringified)
330 {
331 ++test_count;
332 test_line = line;
333 this_test = !(expression_1 == T1(expression_2));
334 test &= this_test;
335 {
336 initialNewline();
337 if (!this_test || verbose > 1)
338 {
339 stdcout << ' ' << (this_test ? '+' : '-') << " line " << line << " : TEST_NOT_EQUAL(" << expression_1_stringified << ','
340 << expression_2_stringified << "): got '";
341 if constexpr (std::is_enum_v<T1> && std::is_enum_v<T2>)
342 {
343 stdcout << static_cast<int>(expression_1) << "', forbidden is '" << static_cast<int>(expression_2) << "'\n";
344 }
345 else
346 {
347 detail::printValue(stdcout, expression_1);
348 stdcout << "', forbidden is '";
349 detail::printValue(stdcout, expression_2);
350 stdcout << "'\n";
351 }
352 }
353 if (!this_test)
354 {
355 failed_lines_list.push_back(line);
356 }
357 }
358 }
359
360
375 using ExceptionTranslator = bool (*)(std::string& description);
376
378 void registerExceptionTranslator(ExceptionTranslator translator);
379
384 bool preconditionTestsEnabled();
385
387 void setPreconditionTestsEnabled(bool enabled);
388
391 std::string describeCaughtException();
392
393 void printLastException(std::ostream& out);
394
395 int endTestPostProcess(std::ostream& out);
396
397 void endSectionPostProcess(std::ostream& out, const int line);
398 }
399 }
400}
401
402// A namespace alias - apparently these cannot be documented using doxygen (?)
403namespace TEST = OpenMS::Internal::ClassTest;
404
488#define START_TEST(class_name, version) \
489 int main(int argc, char** argv) \
490 { \
491 TEST::mainInit(version, #class_name, argc, argv[0]); \
492 try {
493
505#define END_TEST \
506 /* global try block */ \
507 } \
508 catch (...) \
509 { \
510 TEST::printLastException(stdcout); \
511 } \
512 return TEST::endTestPostProcess(stdcout); \
513 }
514
536#define START_SECTION(name_of_test) \
537 TEST::test = true; \
538 TEST::newline = false; \
539 TEST::test_name = # name_of_test; \
540 TEST::test_count = 0; \
541 TEST::start_section_line = __LINE__; \
542 stdcout << "checking " << TEST::test_name << " ... " << std::flush; \
543 try \
544 { \
545 while (true) \
546 {
547
573#define END_SECTION \
574 break; \
575 } \
576 } \
577 catch (...) \
578 { \
579 TEST::printLastException(stdcout);\
580 } \
581 TEST::endSectionPostProcess(stdcout, __LINE__);
582
583
603#define TEST_EQUAL(a, b) TEST::testEqual(__FILE__, __LINE__, (a), (# a), (b), (# b));
604
614#define TEST_TRUE(a) TEST::testTrue(__FILE__, __LINE__, (a), (#a));
615
625#define TEST_FALSE(a) TEST::testFalse(__FILE__, __LINE__, (a), (#a));
626
627
639#define TEST_NOT_EQUAL(a, b) TEST::testNotEqual(__FILE__, __LINE__, (a), (# a), (b), (# b));
640
653#define TEST_STRING_EQUAL(a, b) TEST::testStringEqual(__FILE__, __LINE__, (a), (# a), (b), (# b));
654
669#define TEST_FILE_EQUAL(filename, templatename) \
670 { \
671 TEST::filesEqual(__LINE__, filename, templatename, #filename, #templatename); \
672 }
673
689#define TEST_REAL_SIMILAR(a, b) TEST::testRealSimilar(__FILE__, __LINE__, (a), (# a), TEST::isRealType(a), TEST::writtenDigits(a), (b), (# b), TEST::isRealType(b), TEST::writtenDigits(b));
690
706#define TEST_STRING_SIMILAR(a, b) TEST::testStringSimilar(__FILE__, __LINE__, (a), (# a), (b), (# b));
707
722#define TEST_FILE_SIMILAR(a, b) \
723 { \
724 ++TEST::test_count; \
725 TEST::test_line = __LINE__; \
726 TEST::this_test = TEST::isFileSimilar((a), (b)); \
727 TEST::test = TEST::test && TEST::this_test; \
728 { \
729 TEST::initialNewline(); \
730 if (TEST::this_test) \
731 { \
732 if (TEST::verbose > 1) \
733 { \
734 stdcout << " + line " << __LINE__ \
735 << ": TEST_FILE_SIMILAR(" # a "," # b "): absolute: " \
736 << TEST::precisionWrapper(TEST::absdiff) \
737 << " (" \
738 << TEST::precisionWrapper(TEST::absdiff_max_allowed) \
739 << "), relative: " \
740 << TEST::precisionWrapper(TEST::ratio) \
741 << " (" \
742 << TEST::precisionWrapper(TEST::ratio_max_allowed) \
743 << ")\n"; \
744 stdcout << "message: \n"; \
745 stdcout << TEST::fuzzy_message; \
746 } \
747 } \
748 else \
749 { \
750 stdcout << " - line " << TEST::test_line << \
751 ": TEST_FILE_SIMILAR(" # a "," # b ") ... -\n"; \
752 stdcout << "message: \n"; \
753 stdcout << TEST::fuzzy_message; \
754 TEST::failed_lines_list.push_back(TEST::test_line); \
755 } \
756 } \
757 }
758
771#define TOLERANCE_RELATIVE(a) \
772 TEST::ratio_max_allowed = (a); \
773 { \
774 TEST::initialNewline(); \
775 if (TEST::verbose > 1) \
776 { \
777 stdcout << " + line " << __LINE__ << \
778 ": TOLERANCE_RELATIVE(" << TEST::ratio_max_allowed << \
779 ") (\"" # a "\")\n"; \
780 } \
781 }
782
794#define TOLERANCE_ABSOLUTE(a) \
795 TEST::absdiff_max_allowed = (a); \
796 { \
797 TEST::initialNewline(); \
798 if (TEST::verbose > 1) \
799 { \
800 stdcout << " + line " << __LINE__ << \
801 ": TOLERANCE_ABSOLUTE(" << TEST::absdiff_max_allowed << \
802 ") (\"" # a "\")\n"; \
803 } \
804 }
805
811#define WHITELIST(a) TEST::setWhitelist(__FILE__, __LINE__, (a));
812
825#define TEST_EXCEPTION(exception_type, command) \
826 { \
827 ++TEST::test_count; \
828 TEST::test_line = __LINE__; \
829 TEST::exception = 0; \
830 try \
831 { \
832 command; \
833 } \
834 catch (exception_type&) \
835 { \
836 TEST::exception = 1; \
837 } \
838 catch (...) \
839 { \
840 /* the framework knows only std::exception; registered translators (see */ \
841 /* OpenMSTestSupport.cpp) describe library exception types by name */ \
842 TEST::exception = 2; \
843 TEST::exception_name = TEST::describeCaughtException(); \
844 } \
845 TEST::this_test = (TEST::exception == 1); \
846 TEST::test = TEST::test && TEST::this_test; \
847 { \
848 TEST::initialNewline(); \
849 switch (TEST::exception) \
850 { \
851 case 0: \
852 stdcout << " - line " << TEST::test_line << \
853 ": TEST_EXCEPTION(" # exception_type "," # command \
854 "): no exception thrown!\n"; \
855 TEST::failed_lines_list.push_back(TEST::test_line); \
856 break; \
857 case 1: \
858 if (TEST::verbose > 1) \
859 { \
860 stdcout << " + line " << TEST::test_line << \
861 ": TEST_EXCEPTION(" # exception_type "," # command \
862 "): OK\n"; \
863 } \
864 break; \
865 case 2: \
866 stdcout << " - line " << TEST::test_line << \
867 ": TEST_EXCEPTION(" # exception_type "," # command \
868 "): wrong exception thrown! \"" \
869 << TEST::exception_name << "\"\n"; \
870 TEST::failed_lines_list.push_back(TEST::test_line); \
871 break; \
872 } \
873 } \
874 }
875
889#define TEST_PRECONDITION_VIOLATED(command) \
890 { \
891 if (TEST::preconditionTestsEnabled()) \
892 { \
893 TEST_EXCEPTION(Exception::Precondition, command); \
894 } \
895 else \
896 { \
897 STATUS("TEST_PRECONDITION_VIOLATED(" # command ") - skipped"); \
898 } \
899 }
900
912#define TEST_POSTCONDITION_VIOLATED(command) \
913 { \
914 if (TEST::preconditionTestsEnabled()) \
915 { \
916 TEST_EXCEPTION(Exception::Postcondition, command); \
917 } \
918 else \
919 { \
920 STATUS("TEST_POSTCONDITION_VIOLATED(" # command ") - skipped"); \
921 } \
922 }
923
924
941#define TEST_EXCEPTION_WITH_MESSAGE(exception_type, command, message) \
942 { \
943 ++TEST::test_count; \
944 TEST::test_line = __LINE__; \
945 TEST::exception = 0; \
946 try \
947 { \
948 command; \
949 } \
950 catch (exception_type& et) \
951 { \
952 if (std::string(et.what()) != std::string(message)) \
953 { \
954 TEST::exception = 4; \
955 TEST::exception_message = et.what(); \
956 } \
957 else TEST::exception = 1; \
958 } \
959 catch (...) \
960 { \
961 TEST::exception = 2; \
962 TEST::exception_name = TEST::describeCaughtException(); \
963 } \
964 TEST::this_test = (TEST::exception == 1); \
965 TEST::test = TEST::test && TEST::this_test; \
966 \
967 { \
968 TEST::initialNewline(); \
969 switch (TEST::exception) \
970 { \
971 case 0: \
972 stdcout << " - line " << TEST::test_line << \
973 ": TEST_EXCEPTION_WITH_MESSAGE(" # exception_type "," # command ", " # message \
974 "): no exception thrown!\n"; \
975 TEST::failed_lines_list.push_back(TEST::test_line); \
976 break; \
977 case 1: \
978 if (TEST::verbose > 1) \
979 { \
980 /* this is actually what we want to get: */ \
981 stdcout << " + line " << TEST::test_line << \
982 ": TEST_EXCEPTION_WITH_MESSAGE(" # exception_type "," # command ", " # message \
983 "): OK\n"; \
984 } \
985 break; \
986 case 2: \
987 stdcout << " - line " << TEST::test_line << \
988 ": TEST_EXCEPTION_WITH_MESSAGE(" # exception_type "," # command ", " # message \
989 "): wrong exception thrown! \"" << \
990 TEST::exception_name << "\"\n"; \
991 TEST::failed_lines_list.push_back(TEST::test_line); \
992 break; \
993 case 4: \
994 stdcout << " - line " << TEST::test_line << \
995 ": TEST_EXCEPTION_WITH_MESSAGE(" # exception_type "," # command ", " # message \
996 "): exception has wrong message: got '" << \
997 TEST::exception_message << \
998 "', expected '" << \
999 (message) << "'\n"; \
1000 TEST::failed_lines_list.push_back(TEST::test_line); \
1001 break; \
1002 } \
1003 } \
1004 }
1005
1019#define NEW_TMP_FILE_EXT(filename, extension) filename = TEST::createTmpFileName(__FILE__, __LINE__, extension);
1020
1021
1022#define NEW_TMP_FILE(filename) filename = TEST::createTmpFileName(__FILE__, __LINE__);
1023
1024
1032#define ABORT_IF(condition) \
1033 if (condition) \
1034 { \
1035 { \
1036 TEST::test_line = __LINE__; \
1037 TEST::this_test = false; \
1038 TEST::test = TEST::test && TEST::this_test; \
1039 TEST::failed_lines_list.push_back(TEST::test_line); \
1040 TEST::initialNewline(); \
1041 stdcout << " - line " << TEST::test_line << \
1042 ": ABORT_IF(" # condition "): TEST ABORTED\n"; \
1043 } \
1044 break; \
1045 }
1046
1064#define STATUS(message) \
1065 { \
1066 TEST::initialNewline(); \
1067 stdcout << " line " \
1068 << __LINE__ \
1069 << ": status: " \
1070 << message \
1071 << "\n"; \
1072 }
1073
1083#define ADD_MESSAGE(message) \
1084 TEST::add_message = message;
1085
1095#define NOT_TESTABLE \
1096 TEST::test_count = 1;
1097
// end of defgroup ClassTest
XMLCh
char16_t XMLCh
Definition ClassTest.h:25
stdcout
#define stdcout
Provide a point of redirection for testing the test macros, see ClassTest_test.cpp.
Definition ClassTest.h:32
OpenMS::Internal::ClassTest::detail::toString
std::string toString(const std::string &s)
Definition ClassTestUtils.h:222
OpenMS::Internal::ClassTest::detail::printValue
void printValue(std::ostream &os, const T &v)
Definition ClassTestUtils.h:259
OpenMS::Internal::ClassTest
Namespace for class tests.
Definition ClassTest.h:41
OpenMS::Internal::ClassTest::ratio_max
double ratio_max
Maximum ratio of numbers observed so far, see TOLERANCE_RELATIVE.
OpenMS::Internal::ClassTest::verbose
int verbose
Verbosity level ( "-v" is 1 and "-V" is 2 )
OpenMS::Internal::ClassTest::setPreconditionTestsEnabled
void setPreconditionTestsEnabled(bool enabled)
See preconditionTestsEnabled().
OpenMS::Internal::ClassTest::testEqual
void testEqual(const char *, int line, const T1 &expression_1, const char *expression_1_stringified, const T2 &expression_2, const char *expression_2_stringified)
Definition ClassTest.h:225
OpenMS::Internal::ClassTest::test_count
int test_count
Counter for the number of elementary tests within the current subsection.
OpenMS::Internal::ClassTest::testStringSimilar
void testStringSimilar(const char *file, int line, const std::string &string_1, const char *string_1_stringified, const std::string &string_2, const char *string_2_stringified)
Compare strings using absdiff_max_allowed and ratio_max_allowed.
OpenMS::Internal::ClassTest::testFalse
void testFalse(const char *, int line, const bool expression_1, const char *expression_1_stringified)
Definition ClassTest.h:301
OpenMS::Internal::ClassTest::isRealSimilar
bool isRealSimilar(long double number_1, long double number_2)
used by testRealSimilar()
OpenMS::Internal::ClassTest::ExceptionTranslator
bool(*)(std::string &description) ExceptionTranslator
Translator producing a description of the currently handled exception.
Definition ClassTest.h:375
OpenMS::Internal::ClassTest::test_line
int test_line
Line of current elementary test.
OpenMS::Internal::ClassTest::absdiff
double absdiff
Recent absolute difference of numbers, see TOLERANCE_ABSOLUTE.
OpenMS::Internal::ClassTest::line_buffer
char line_buffer[65536]
(A buffer for one line from a file. Used by TEST_FILE_EQUAL.)
OpenMS::Internal::ClassTest::add_message
std::string add_message
See ADD_MESSAGE.
OpenMS::Internal::ClassTest::endSectionPostProcess
void endSectionPostProcess(std::ostream &out, const int line)
OpenMS::Internal::ClassTest::fuzzy_message
std::string fuzzy_message
Last message from a fuzzy comparison. Written by isRealSimilar(), testStringSimilar(),...
OpenMS::Internal::ClassTest::initialNewline
void initialNewline()
make sure we have a newline before results from first subtest
OpenMS::Internal::ClassTest::all_tests
bool all_tests
Status of the whole test.
OpenMS::Internal::ClassTest::exception_message
std::string exception_message
(Used by various macros. Stores the "message" of the exception, if applicable.)
OpenMS::Internal::ClassTest::test_name
std::string test_name
Name of current subsection.
OpenMS::Internal::ClassTest::registerExceptionTranslator
void registerExceptionTranslator(ExceptionTranslator translator)
Register an exception translator (idempotent; bounded, first-come first-served).
OpenMS::Internal::ClassTest::testRealSimilar
void testRealSimilar(const char *file, int line, long double number_1, const char *number_1_stringified, bool number_1_is_realtype, int number_1_written_digits, long double number_2, const char *number_2_stringified, bool, int number_2_written_digits)
Compare floating point numbers using absdiff_max_allowed and ratio_max_allowed.
OpenMS::Internal::ClassTest::testNotEqual
void testNotEqual(const char *, int line, const T1 &expression_1, const char *expression_1_stringified, const T2 &expression_2, const char *expression_2_stringified)
Definition ClassTest.h:326
OpenMS::Internal::ClassTest::absdiff_max
double absdiff_max
Maximum difference of numbers observed so far, see TOLERANCE_ABSOLUTE.
OpenMS::Internal::ClassTest::newline
bool newline
(Flags whether a new line is in place, depending on context and verbosity setting....
OpenMS::Internal::ClassTest::filesEqual
void filesEqual(int line, const char *filename, const char *templatename, const char *filename_stringified, const char *templatename_stringified)
Test if two files are exactly equal (used in TEST_FILE_EQUAL macro)
OpenMS::Internal::ClassTest::test
bool test
Status of the current subsection.
OpenMS::Internal::ClassTest::absdiff_max_allowed
double absdiff_max_allowed
Maximum absolute difference of numbers allowed, see TOLERANCE_ABSOLUTE.
OpenMS::Internal::ClassTest::describeCaughtException
std::string describeCaughtException()
OpenMS::Internal::ClassTest::testStringEqual
void testStringEqual(const char *file, int line, const std::string &string_1, const char *string_1_stringified, const std::string &string_2, const char *string_2_stringified)
used by TEST_STRING_EQUAL
OpenMS::Internal::ClassTest::version_string
const char * version_string
Version string supplied with START_TEST.
OpenMS::Internal::ClassTest::infile
std::ifstream infile
Questionable file tested by TEST_FILE_EQUAL.
OpenMS::Internal::ClassTest::endTestPostProcess
int endTestPostProcess(std::ostream &out)
OpenMS::Internal::ClassTest::exception_name
std::string exception_name
(Used by various macros. Stores the "name" of the exception, if applicable.)
OpenMS::Internal::ClassTest::mainInit
void mainInit(const char *version, const char *class_name, int argc, const char *argv0)
Set up some classtest variables as obtained from the 'START_TEST' macro and check that no additional ...
OpenMS::Internal::ClassTest::ratio
double ratio
Recent ratio of numbers, see TOLERANCE_RELATIVE.
OpenMS::Internal::ClassTest::removeTempFiles
void removeTempFiles()
removed all temporary files created with the NEW_TMP_FILE macro
OpenMS::Internal::ClassTest::tmp_file_list
std::vector< std::string > tmp_file_list
List of tmp file names (these will be cleaned up, see NEW_TMP_FILE)
OpenMS::Internal::ClassTest::isFileSimilar
bool isFileSimilar(const std::string &filename_1, const std::string &filename_2)
Compare files using absdiff_max_allowed and ratio_max_allowed.
OpenMS::Internal::ClassTest::this_test
bool this_test
Status of last elementary test.
OpenMS::Internal::ClassTest::printLastException
void printLastException(std::ostream &out)
OpenMS::Internal::ClassTest::createTmpFileName
std::string createTmpFileName(const std::string &file, int line, const std::string &extension="")
Creates a temporary file name from the test name and the line with the specified extension.
OpenMS::Internal::ClassTest::templatefile
std::ifstream templatefile
Template (correct) file used by TEST_FILE_EQUAL.
OpenMS::Internal::ClassTest::testTrue
void testTrue(const char *, int line, const bool expression_1, const char *expression_1_stringified)
Definition ClassTest.h:278
OpenMS::Internal::ClassTest::ratio_max_allowed
double ratio_max_allowed
Maximum ratio of numbers allowed, see TOLERANCE_RELATIVE.
OpenMS::Internal::ClassTest::printWithPrefix
void printWithPrefix(const std::string &text, const int marked=-1)
print the text, each line gets a prefix, the marked line number gets a special prefix
OpenMS::Internal::ClassTest::equal_files
bool equal_files
(A variable used by TEST_FILE_EQUAL)
OpenMS::Internal::ClassTest::failed_lines_list
std::vector< unsigned int > failed_lines_list
List of all failed lines for summary at the end of the test.
OpenMS::Internal::ClassTest::start_section_line
int start_section_line
Line where current subsection started.
OpenMS::Internal::ClassTest::exception
int exception
(Used by various macros. Indicates a rough category of the exception being caught....
OpenMS::Internal::ClassTest::setWhitelist
void setWhitelist(const char *const, const int line, const std::string &whitelist)
set the whitelist_
OpenMS
Main OpenMS namespace.
Definition openswathalgo/include/OpenMS/OPENSWATHALGO/DATAACCESS/ISpectrumAccess.h:19