TestCenter Reference
Macros.py
Go to the documentation of this file.
1#
2# Copyright 2009, MeVis Medical Solutions AG
3#
4# The user may use this file in accordance with the license agreement provided with
5# the Software or, alternatively, in accordance with the terms contained in a
6# written agreement between the user and MeVis Medical Solutions AG.
7#
8# For further information use the contact form at https://www.mevislab.de/contact
9#
10
11
27
28# -- system imports ----------------------------------------------------------------------------{{{-
29# ----------------------------------------------------------------------------------------------}}}-
30
31# -- local imports -----------------------------------------------------------------------------{{{-
32import os
33
34import sys
35
36from TestSupport.TestHelper import TestHelper, UseStackFrameFromCallerForLogging, CancelTestException
37
38# ----------------------------------------------------------------------------------------------}}}-
39
40# -- class AssertException ---------------------------------------------------------------------{{{-
41# @cond
42
43class AssertException (Exception):
44 # -- def __init__ ----------------------------------------------------------------------------{{{-
45 def __init__ (self, reason):
46 self.__reason = reason
47 # --------------------------------------------------------------------------------------------}}}-
48
49 # -- def getReason ---------------------------------------------------------------------------{{{-
50 def getReason (self):
51 return repr(self.__reason)
52 # --------------------------------------------------------------------------------------------}}}-
53
54 # -- def __str__ -----------------------------------------------------------------------------{{{-
55 def __str__ (self):
56 return repr(self.__reason)
57 # --------------------------------------------------------------------------------------------}}}-
58# @endcond
59# ----------------------------------------------------------------------------------------------}}}-
60
61# -- def ASSERT_TRUE ---------------------------------------------------------------------------{{{-
62
66@UseStackFrameFromCallerForLogging
67def ASSERT_TRUE (expr, msg=None, logOnSuccess=None):
68 if not Base_verifyTrue(expr, comment = msg, logOnSuccess = logOnSuccess):
69 raise AssertException("Expression does not evaluate to true.")
70# ----------------------------------------------------------------------------------------------}}}-
71
72# -- def EXPECT_TRUE ---------------------------------------------------------------------------{{{-
73
78@UseStackFrameFromCallerForLogging
79def EXPECT_TRUE (expr, msg=None, logOnSuccess=None):
80 return Base_verifyTrue(expr, comment = msg, logOnSuccess = logOnSuccess)
81
82# ----------------------------------------------------------------------------------------------}}}-
83
84# -- def ASSERT_FALSE --------------------------------------------------------------------------{{{-
85
89@UseStackFrameFromCallerForLogging
90def ASSERT_FALSE (expr, msg=None, logOnSuccess=None):
91 if not Base_verifyFalse(expr, comment = msg, logOnSuccess = logOnSuccess):
92 raise AssertException("Expression does not evaluate to false.")
93
94# ----------------------------------------------------------------------------------------------}}}-
95
96# -- def EXPECT_FALSE --------------------------------------------------------------------------{{{-
97
102@UseStackFrameFromCallerForLogging
103def EXPECT_FALSE (expr, msg=None, logOnSuccess=None):
104 return Base_verifyFalse(expr, comment = msg, logOnSuccess = logOnSuccess)
105# ----------------------------------------------------------------------------------------------}}}-
106
107# -- def ASSERT_EQ -----------------------------------------------------------------------------{{{-
108
113@UseStackFrameFromCallerForLogging
114def ASSERT_EQ (expected, actual, msg=None, logOnSuccess=None):
115 if not Base_compareEqual(expected, actual, comment = msg, logOnSuccess = logOnSuccess):
116 raise AssertException("Values (%s and %s) are not equal." % (str(expected), str(actual)))
117# ----------------------------------------------------------------------------------------------}}}-
118
119# -- def EXPECT_EQ -----------------------------------------------------------------------------{{{-
120
126@UseStackFrameFromCallerForLogging
127def EXPECT_EQ (expected, actual, msg=None, logOnSuccess=None):
128 return Base_compareEqual(expected, actual, comment = msg, logOnSuccess = logOnSuccess)
129# ----------------------------------------------------------------------------------------------}}}-
130
131# -- def ASSERT_NE -----------------------------------------------------------------------------{{{-
132
137@UseStackFrameFromCallerForLogging
138def ASSERT_NE (expected, actual, msg=None, logOnSuccess=None):
139 if not Base_compareNotEqual(expected, actual, comment = msg, logOnSuccess = logOnSuccess):
140 raise AssertException("Values (%s and %s) are equal." % (str(expected), str(actual)))
141# ----------------------------------------------------------------------------------------------}}}-
142
143# -- def EXPECT_NE -----------------------------------------------------------------------------{{{-
144
150@UseStackFrameFromCallerForLogging
151def EXPECT_NE (expected, actual, msg=None, logOnSuccess=None):
152 return Base_compareNotEqual(expected, actual, comment = msg, logOnSuccess = logOnSuccess)
153# ----------------------------------------------------------------------------------------------}}}-
154
155# -- def ASSERT_GT -----------------------------------------------------------------------------{{{-
156
162@UseStackFrameFromCallerForLogging
163def ASSERT_GT (a, b, msg=None, logOnSuccess=None):
164 if not Base_compareLessThan(b, a, comment = msg, logOnSuccess = logOnSuccess):
165 raise AssertException("Value %s not greater than %s." % (str(a), str(b)))
166# ----------------------------------------------------------------------------------------------}}}-
167
168# -- def EXPECT_GT -----------------------------------------------------------------------------{{{-
169
175@UseStackFrameFromCallerForLogging
176def EXPECT_GT (a, b, msg=None, logOnSuccess=None):
177 return Base_compareLessThan(b, a, comment = msg, logOnSuccess = logOnSuccess)
178# ----------------------------------------------------------------------------------------------}}}-
179
180# -- def ASSERT_GE -----------------------------------------------------------------------------{{{-
181
186@UseStackFrameFromCallerForLogging
187def ASSERT_GE (a, b, msg=None, logOnSuccess=None):
188 if not Base_compareLessThanOrEqual(b, a, comment = msg, logOnSuccess = logOnSuccess):
189 raise AssertException("Value %s not greater than or equal to %s." % (str(a), str(b)))
190# ----------------------------------------------------------------------------------------------}}}-
191
192# -- def EXPECT_GE -----------------------------------------------------------------------------{{{-
193
199@UseStackFrameFromCallerForLogging
200def EXPECT_GE (a, b, msg=None, logOnSuccess=None):
201 return Base_compareLessThanOrEqual(b, a, comment = msg, logOnSuccess = logOnSuccess)
202# ----------------------------------------------------------------------------------------------}}}-
203
204# -- def ASSERT_LT -----------------------------------------------------------------------------{{{-
205
210@UseStackFrameFromCallerForLogging
211def ASSERT_LT (a, b, msg=None, logOnSuccess=None):
212 if not Base_compareLessThan(a, b, comment = msg, logOnSuccess = logOnSuccess):
213 raise AssertException("Value %s not less than %s." % (str(a), str(b)))
214# ----------------------------------------------------------------------------------------------}}}-
215
216# -- def EXPECT_LT -----------------------------------------------------------------------------{{{-
217
223@UseStackFrameFromCallerForLogging
224def EXPECT_LT (a, b, msg=None, logOnSuccess=None):
225 return Base_compareLessThan(a, b, comment = msg, logOnSuccess = logOnSuccess)
226# ----------------------------------------------------------------------------------------------}}}-
227
228# -- def ASSERT_LE -----------------------------------------------------------------------------{{{-
229
234@UseStackFrameFromCallerForLogging
235def ASSERT_LE (a, b, msg=None, logOnSuccess=None):
236 if not Base_compareLessThanOrEqual(a, b, comment = msg, logOnSuccess = logOnSuccess):
237 raise AssertException("Value %s not less than or equal to %s." % (str(a), str(b)))
238# ----------------------------------------------------------------------------------------------}}}-
239
240# -- def EXPECT_LE -----------------------------------------------------------------------------{{{-
241
247@UseStackFrameFromCallerForLogging
248def EXPECT_LE (a, b, msg=None, logOnSuccess=None):
249 return Base_compareLessThanOrEqual(a, b, comment = msg, logOnSuccess = logOnSuccess)
250# ----------------------------------------------------------------------------------------------}}}-
251
252# -- def ASSERT_FLOAT_EQ -----------------------------------------------------------------------{{{-
253
259@UseStackFrameFromCallerForLogging
260def ASSERT_FLOAT_EQ (expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
261 if not Base_compareFloatEqual(expected, actual, msg, epsilon, logOnSuccess):
262 raise AssertException("Values (%s and %s) not equal." % (str(expected), str(actual)))
263# ----------------------------------------------------------------------------------------------}}}-
264
265# -- def EXPECT_FLOAT_EQ -----------------------------------------------------------------------{{{-
266
273@UseStackFrameFromCallerForLogging
274def EXPECT_FLOAT_EQ (expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
275 return Base_compareFloatEqual(expected, actual, msg, epsilon, logOnSuccess)
276# ----------------------------------------------------------------------------------------------}}}-
277
278# -- def ASSERT_FLOAT_NE -----------------------------------------------------------------------{{{-
279
285@UseStackFrameFromCallerForLogging
286def ASSERT_FLOAT_NE (expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
287 if not Base_compareFloatNotEqual(expected, actual, msg, epsilon, logOnSuccess):
288 raise AssertException("Values (%s and %s) equal." % (str(expected), str(actual)))
289# ----------------------------------------------------------------------------------------------}}}-
290
291# -- def EXPECT_FLOAT_NE -----------------------------------------------------------------------{{{-
292
299@UseStackFrameFromCallerForLogging
300def EXPECT_FLOAT_NE (expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None):
301 return Base_compareFloatNotEqual(expected, actual, msg, epsilon, logOnSuccess)
302# ----------------------------------------------------------------------------------------------}}}-
303
304# -- def ASSERT_FLOAT_GT -----------------------------------------------------------------------{{{-
305
310@UseStackFrameFromCallerForLogging
311def ASSERT_FLOAT_GT (a, b, msg=None, logOnSuccess=None):
312 if not Base_compareFloatLessThan(b, a, comment = msg, logOnSuccess = logOnSuccess):
313 raise AssertException("Value %s not greater than %s." % (str(a), str(b)))
314# ----------------------------------------------------------------------------------------------}}}-
315
316# -- def EXPECT_FLOAT_GT -----------------------------------------------------------------------{{{-
317
323@UseStackFrameFromCallerForLogging
324def EXPECT_FLOAT_GT (a, b, msg=None, logOnSuccess=None):
325 return Base_compareFloatLessThan(b, a, comment = msg, logOnSuccess = logOnSuccess)
326# ----------------------------------------------------------------------------------------------}}}-
327
328# -- def ASSERT_FLOAT_GE -----------------------------------------------------------------------{{{-
329
335@UseStackFrameFromCallerForLogging
336def ASSERT_FLOAT_GE (a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
337 if not Base_compareFloatLessThanOrEqual(b, a, msg, epsilon, logOnSuccess):
338 raise AssertException("Value %s not greater than or equal to %s." % (str(a), str(b)))
339# ----------------------------------------------------------------------------------------------}}}-
340
341# -- def EXPECT_FLOAT_GE -----------------------------------------------------------------------{{{-
342
349@UseStackFrameFromCallerForLogging
350def EXPECT_FLOAT_GE (a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
351 return Base_compareFloatLessThanOrEqual(b, a, msg, epsilon, logOnSuccess)
352# ----------------------------------------------------------------------------------------------}}}-
353
354# -- def ASSERT_FLOAT_LT -----------------------------------------------------------------------{{{-
355
360@UseStackFrameFromCallerForLogging
361def ASSERT_FLOAT_LT (a, b, msg=None, logOnSuccess=None):
362 if not Base_compareFloatLessThan(a, b, comment = msg, logOnSuccess = logOnSuccess):
363 raise AssertException("Value %s not less than %s." % (str(a), str(b)))
364# ----------------------------------------------------------------------------------------------}}}-
365
366# -- def EXPECT_FLOAT_LT -----------------------------------------------------------------------{{{-
367
373@UseStackFrameFromCallerForLogging
374def EXPECT_FLOAT_LT (a, b, msg=None, logOnSuccess=None):
375 return Base_compareFloatLessThan(a, b, comment = msg, logOnSuccess = logOnSuccess)
376# ----------------------------------------------------------------------------------------------}}}-
377
378# -- def ASSERT_FLOAT_LE -----------------------------------------------------------------------{{{-
379
385@UseStackFrameFromCallerForLogging
386def ASSERT_FLOAT_LE (a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
387 if not Base_compareFloatLessThanOrEqual(a, b, msg, epsilon, logOnSuccess):
388 raise AssertException("Value %s not less than or equal to %s." % (str(a), str(b)))
389# ----------------------------------------------------------------------------------------------}}}-
390
391# -- def EXPECT_FLOAT_LE -----------------------------------------------------------------------{{{-
392
399@UseStackFrameFromCallerForLogging
400def EXPECT_FLOAT_LE (a, b, msg=None, epsilon=0.0001, logOnSuccess=None):
401 return Base_compareFloatLessThanOrEqual(a, b, msg, epsilon, logOnSuccess)
402# ----------------------------------------------------------------------------------------------}}}-
403
404# -- def EXPECT_EMPTY -----------------------------------------------------------------------{{{-
405
410@UseStackFrameFromCallerForLogging
411def EXPECT_EMPTY ( a, msg=None, logOnSuccess=None):
412 return Base_compareEqual( 0, len( a ), comment = msg, logOnSuccess = logOnSuccess )
413
414# -- def ASSERT_EMPTY -----------------------------------------------------------------------{{{-
415
419@UseStackFrameFromCallerForLogging
420def ASSERT_EMPTY ( a, msg=None, logOnSuccess=None):
421 if not Base_compareEqual( 0, len( a ), comment = msg, logOnSuccess = logOnSuccess ):
422 raise AssertException( "Container %s is not empty." % (str(a)) )
423
424# -- def EXPECT_NOT_EMPTY -----------------------------------------------------------------------{{{-
425
430@UseStackFrameFromCallerForLogging
431def EXPECT_NOT_EMPTY ( a, msg=None, logOnSuccess=None):
432 return Base_compareLessThan( 0, len( a ), comment = msg, logOnSuccess = logOnSuccess )
433
434# -- def ASSERT_NOT_EMPTY -----------------------------------------------------------------------{{{-
435
439@UseStackFrameFromCallerForLogging
440def ASSERT_NOT_EMPTY ( a, msg=None, logOnSuccess=None):
441 if not Base_compareLessThan( 0, len( a ), comment = msg, logOnSuccess = logOnSuccess ):
442 raise AssertException( "Container %s is empty." % (str(a)) )
443
444# -- def EXPECT_SIZE -----------------------------------------------------------------------{{{-
445
451@UseStackFrameFromCallerForLogging
452def EXPECT_SIZE ( a, size, msg=None, logOnSuccess=None):
453 return Base_compareEqual( size, len( a ), comment = msg, logOnSuccess = logOnSuccess )
454
455# -- def ASSERT_SIZE -----------------------------------------------------------------------{{{-
456
461@UseStackFrameFromCallerForLogging
462def ASSERT_SIZE ( a, size, msg=None, logOnSuccess=None):
463 if not Base_compareEqual( size, len( a ), comment = msg, logOnSuccess = logOnSuccess ):
464 raise AssertException( "Container %s size is not %s." % (str(a), str(size)) )
465
466# -- def EXPECT_PATH_EXISTS -----------------------------------------------------------------------{{{-
467
471@UseStackFrameFromCallerForLogging
472def EXPECT_PATH_EXISTS(path, msg=None, logOnSuccess=None):
473 contextMsg = "Path = %s" % path
474 return Base_verifyTrue(os.path.exists(path), comment = msg, msg=contextMsg, logOnSuccess = logOnSuccess)
475
476# -- def EXPECT_PATH_MISSING -----------------------------------------------------------------------{{{-
477
481@UseStackFrameFromCallerForLogging
482def EXPECT_PATH_MISSING(path, msg=None, logOnSuccess=None):
483 contextMsg = "Path = %s" % path
484 return Base_verifyFalse(os.path.exists(path), comment = msg, msg=contextMsg, logOnSuccess = logOnSuccess)
485
486# -- def ASSERT_PATH_EXISTS -----------------------------------------------------------------------{{{-
487
491@UseStackFrameFromCallerForLogging
492def ASSERT_PATH_EXISTS(path, msg=None, logOnSuccess=None):
493 contextMsg = "Path = %s" % path
494 if not Base_verifyTrue(os.path.exists(path), comment = msg, msg=contextMsg, logOnSuccess = logOnSuccess):
495 raise AssertException("Path does not exist: %s" % path)
496
497# -- def ASSERT_PATH_MISSING -----------------------------------------------------------------------{{{-
498
502@UseStackFrameFromCallerForLogging
503def ASSERT_PATH_MISSING(path, msg=None, logOnSuccess=None):
504 contextMsg = "Path = %s" % path
505 if not Base_verifyFalse(os.path.exists(path), comment = msg, msg=contextMsg, logOnSuccess = logOnSuccess):
506 raise AssertException("Path exists: %s" % path)
507
508# -- def INFO ----------------------------------------------------------------------------------{{{-
509
510@UseStackFrameFromCallerForLogging
511def INFO (msg):
512 Logging_info(msg, depth=1)
513# ----------------------------------------------------------------------------------------------}}}-
514
515# -- def WARNING -------------------------------------------------------------------------------{{{-
516
517@UseStackFrameFromCallerForLogging
518def WARNING (msg):
519 Logging_warning(msg, depth=1)
520# ----------------------------------------------------------------------------------------------}}}-
521
522# -- def ERROR ---------------------------------------------------------------------------------{{{-
523
524@UseStackFrameFromCallerForLogging
525def ERROR (msg):
526 Logging_error(msg, depth=1)
527# ----------------------------------------------------------------------------------------------}}}-
528
529# -- def DEBUG_STOP ---------------------------------------------------------------------------------{{{-
530
531@UseStackFrameFromCallerForLogging
532def DEBUG_STOP():
533 Logging_info("Stopping because of DEBUG_STOP()", depth=1)
534 Logging_setStopped(True)
535 raise CancelTestException
536# ----------------------------------------------------------------------------------------------}}}-
537
538from .Base import verifyFalse as Base_verifyFalse, verifyTrue as Base_verifyTrue, \
539 compareEqual as Base_compareEqual, compareNotEqual as Base_compareNotEqual, \
540 compareLessThan as Base_compareLessThan, compareLessThanOrEqual as Base_compareLessThanOrEqual, \
541 compareFloatEqual as Base_compareFloatEqual, compareFloatNotEqual as Base_compareFloatNotEqual, \
542 compareFloatLessThanOrEqual as Base_compareFloatLessThanOrEqual, \
543 compareFloatLessThan as Base_compareFloatLessThan
544from .Logging import error as Logging_error, warning as Logging_warning, info as Logging_info, setStopped as Logging_setStopped
545
TestSupport.Macros.WARNING
WARNING(msg)
Create a warning message.
Definition Macros.py:518
TestSupport.Macros.ASSERT_NOT_EMPTY
ASSERT_NOT_EMPTY(a, msg=None, logOnSuccess=None)
Throw exception if given container is empty.
Definition Macros.py:440
TestSupport.Macros.EXPECT_EMPTY
EXPECT_EMPTY(a, msg=None, logOnSuccess=None)
Expect given container to be empty.
Definition Macros.py:411
TestSupport.Macros.EXPECT_EQ
EXPECT_EQ(expected, actual, msg=None, logOnSuccess=None)
Expect given values to be equal.
Definition Macros.py:127
TestSupport.Macros.EXPECT_FLOAT_LE
EXPECT_FLOAT_LE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None)
Expect first given value to be less than or equal to the second.
Definition Macros.py:400
TestSupport.Macros.EXPECT_TRUE
EXPECT_TRUE(expr, msg=None, logOnSuccess=None)
Expect given expression to evaluate to true.
Definition Macros.py:79
TestSupport.Macros.EXPECT_LT
EXPECT_LT(a, b, msg=None, logOnSuccess=None)
Expect first given value to be less than the second.
Definition Macros.py:224
TestSupport.Macros.EXPECT_SIZE
EXPECT_SIZE(a, size, msg=None, logOnSuccess=None)
Expect given container to have the given size.
Definition Macros.py:452
TestSupport.Macros.ASSERT_PATH_MISSING
ASSERT_PATH_MISSING(path, msg=None, logOnSuccess=None)
Throw exception if given path is not missing, i.e.
Definition Macros.py:503
TestSupport.Macros.EXPECT_FLOAT_LT
EXPECT_FLOAT_LT(a, b, msg=None, logOnSuccess=None)
Expect first given value to be less than the second.
Definition Macros.py:374
TestSupport.Macros.EXPECT_NE
EXPECT_NE(expected, actual, msg=None, logOnSuccess=None)
Expect given values to be not equal.
Definition Macros.py:151
TestSupport.Macros.ERROR
ERROR(msg)
Create an error message.
Definition Macros.py:525
TestSupport.Macros.EXPECT_FLOAT_EQ
EXPECT_FLOAT_EQ(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None)
Expect given values to be equal.
Definition Macros.py:274
TestSupport.Macros.ASSERT_FLOAT_GT
ASSERT_FLOAT_GT(a, b, msg=None, logOnSuccess=None)
Throw exception if first given value is not greater than the second.
Definition Macros.py:311
TestSupport.Macros.ASSERT_PATH_EXISTS
ASSERT_PATH_EXISTS(path, msg=None, logOnSuccess=None)
Throw exception if given path does not exists.
Definition Macros.py:492
TestSupport.Macros.ASSERT_FLOAT_LE
ASSERT_FLOAT_LE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None)
Throw exception if first given value is not less than or equal to the second.
Definition Macros.py:386
TestSupport.Macros.EXPECT_FLOAT_GE
EXPECT_FLOAT_GE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None)
Expect first given value to be greater than or equal to the second.
Definition Macros.py:350
TestSupport.Macros.ASSERT_NE
ASSERT_NE(expected, actual, msg=None, logOnSuccess=None)
Throw exception if given values are equal.
Definition Macros.py:138
TestSupport.Macros.ASSERT_GE
ASSERT_GE(a, b, msg=None, logOnSuccess=None)
Throw exception if first given value is less than the second.
Definition Macros.py:187
TestSupport.Macros.DEBUG_STOP
DEBUG_STOP()
Stops a test immediately for debugging purposes.
Definition Macros.py:532
TestSupport.Macros.ASSERT_LT
ASSERT_LT(a, b, msg=None, logOnSuccess=None)
Throw exception if first given value is not less than the second.
Definition Macros.py:211
TestSupport.Macros.EXPECT_NOT_EMPTY
EXPECT_NOT_EMPTY(a, msg=None, logOnSuccess=None)
Expect given container to be not empty.
Definition Macros.py:431
TestSupport.Macros.ASSERT_EQ
ASSERT_EQ(expected, actual, msg=None, logOnSuccess=None)
Throw exception if given values are not equal.
Definition Macros.py:114
TestSupport.Macros.ASSERT_FALSE
ASSERT_FALSE(expr, msg=None, logOnSuccess=None)
Throw exception if given expression does not evaluate to false.
Definition Macros.py:90
TestSupport.Macros.EXPECT_LE
EXPECT_LE(a, b, msg=None, logOnSuccess=None)
Expect first given value to be less than or equal to the second.
Definition Macros.py:248
TestSupport.Macros.ASSERT_FLOAT_NE
ASSERT_FLOAT_NE(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None)
Throw exception if given values are equal.
Definition Macros.py:286
TestSupport.Macros.ASSERT_LE
ASSERT_LE(a, b, msg=None, logOnSuccess=None)
Throw exception if first given value is not less than or equal to the second.
Definition Macros.py:235
TestSupport.Macros.ASSERT_SIZE
ASSERT_SIZE(a, size, msg=None, logOnSuccess=None)
Throw exception if given container does not have the given size.
Definition Macros.py:462
TestSupport.Macros.ASSERT_FLOAT_EQ
ASSERT_FLOAT_EQ(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None)
Throw exception if given values are not equal.
Definition Macros.py:260
TestSupport.Macros.EXPECT_FALSE
EXPECT_FALSE(expr, msg=None, logOnSuccess=None)
Expect given expression to evaluate to false.
Definition Macros.py:103
TestSupport.Macros.ASSERT_GT
ASSERT_GT(a, b, msg=None, logOnSuccess=None)
Throw exception if first given value is less than or equal to the second.
Definition Macros.py:163
TestSupport.Macros.ASSERT_FLOAT_LT
ASSERT_FLOAT_LT(a, b, msg=None, logOnSuccess=None)
Throw exception if first given value is not less than the second.
Definition Macros.py:361
TestSupport.Macros.INFO
INFO(msg)
Create an info message.
Definition Macros.py:511
TestSupport.Macros.EXPECT_FLOAT_NE
EXPECT_FLOAT_NE(expected, actual, msg=None, epsilon=0.0001, logOnSuccess=None)
Expect given values to be not equal.
Definition Macros.py:300
TestSupport.Macros.EXPECT_GT
EXPECT_GT(a, b, msg=None, logOnSuccess=None)
Expect first given value to be greater than the second.
Definition Macros.py:176
TestSupport.Macros.EXPECT_FLOAT_GT
EXPECT_FLOAT_GT(a, b, msg=None, logOnSuccess=None)
Expect first given value to be greater than the second.
Definition Macros.py:324
TestSupport.Macros.ASSERT_FLOAT_GE
ASSERT_FLOAT_GE(a, b, msg=None, epsilon=0.0001, logOnSuccess=None)
Throw exception if first given value is not greater than or equal to the second.
Definition Macros.py:336
TestSupport.Macros.EXPECT_PATH_EXISTS
EXPECT_PATH_EXISTS(path, msg=None, logOnSuccess=None)
Expect the given path to exist.
Definition Macros.py:472
TestSupport.Macros.ASSERT_EMPTY
ASSERT_EMPTY(a, msg=None, logOnSuccess=None)
Throw exception if given container is not empty.
Definition Macros.py:420
TestSupport.Macros.ASSERT_TRUE
ASSERT_TRUE(expr, msg=None, logOnSuccess=None)
Throw exception if given expression does not evaluate to true.
Definition Macros.py:67
TestSupport.Macros.EXPECT_PATH_MISSING
EXPECT_PATH_MISSING(path, msg=None, logOnSuccess=None)
Expect the given path to be missing, i.e.
Definition Macros.py:482
TestSupport.Macros.EXPECT_GE
EXPECT_GE(a, b, msg=None, logOnSuccess=None)
Expect first given value to be greater than or equal to the second.
Definition Macros.py:200