< Summary - Igor Pro Universal Testing Framework

Information
Class: procedures.igortest-assertion-wrappers
Assembly: procedures
File(s): /builds/mirror/igortest/procedures/igortest-assertion-wrappers.ipf
Tag: 74147b3
Line coverage
14%
Covered lines: 81
Uncovered lines: 474
Coverable lines: 555
Total lines: 1094
Line coverage: 14.5%
Branch coverage
59%
Covered branches: 19
Total branches: 32
Branch coverage: 59.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
IUTF_Wrapper#INFO_WRAPPER()100%276.92%
IUTF_Wrapper#CDF_EMPTY_WRAPPER()100%20%
IUTF_Wrapper#TRUE_WRAPPER()50%288.89%
IUTF_Wrapper#NULL_STR_WRAPPER()100%20%
IUTF_Wrapper#EMPTY_STR_WRAPPER()100%20%
IUTF_Wrapper#NON_NULL_STR_WRAPPER()100%20%
IUTF_Wrapper#NON_EMPTY_STR_WRAPPER()100%20%
IUTF_Wrapper#PROPER_STR_WRAPPER()100%20%
IUTF_Wrapper#NEQ_VAR_WRAPPER()100%20%
IUTF_Wrapper#NEQ_STR_WRAPPER()100%40%
IUTF_Wrapper#CLOSE_VAR_WRAPPER()100%40%
IUTF_Wrapper#CLOSE_CMPLX_WRAPPER()100%50%
IUTF_Wrapper#CLOSE_INT64_WRAPPER()100%30%
IUTF_Wrapper#CLOSE_UINT64_WRAPPER()100%30%
IUTF_Wrapper#SMALL_VAR_WRAPPER()100%30%
IUTF_Wrapper#SMALL_CMPLX_WRAPPER()100%30%
IUTF_Wrapper#SMALL_INT64_WRAPPER()100%30%
IUTF_Wrapper#SMALL_UINT64_WRAPPER()100%30%
IUTF_Wrapper#EQUAL_STR_WRAPPER()100%565.38%
IUTF_Wrapper#TEST_WAVE_WRAPPER()100%60%
IUTF_Wrapper#EQUAL_VAR_WRAPPER()100%292.31%
IUTF_Wrapper#EQUAL_INT64_WRAPPER()100%20%
IUTF_Wrapper#EQUAL_UINT64_WRAPPER()100%20%
IUTF_Wrapper#NEQ_INT64_WRAPPER()100%20%
IUTF_Wrapper#NEQ_UINT64_WRAPPER()100%20%
IUTF_Wrapper#EQUAL_WAVE_WRAPPER()100%150%
IUTF_Wrapper#LESS_EQUAL_VAR_WRAPPER()100%20%
IUTF_Wrapper#LESS_THAN_VAR_WRAPPER()100%20%
IUTF_Wrapper#GREATER_EQUAL_VAR_WRAPPER()100%20%
IUTF_Wrapper#GREATER_THAN_VAR_WRAPPER()100%20%
IUTF_Wrapper#RTE2String()100%30%
IUTF_Wrapper#RTE_WRAPPER()100%20%
IUTF_Wrapper#ANY_RTE_WRAPPER()100%20%
IUTF_Wrapper#NO_RTE_WRAPPER()100%10%
IUTF_Wrapper#COMPILATION_WRAPPER()100%1283.33%
IUTF_Wrapper#NO_COMPILATION_WRAPPER()100%460%

File(s)

/builds/mirror/igortest/procedures/igortest-assertion-wrappers.ipf

#LineLine coverage
 1#pragma rtGlobals=3
 2#pragma rtFunctionErrors=1
 3#pragma version=1.10
 4#pragma TextEncoding="UTF-8"
 5#pragma ModuleName=IUTF_Wrapper
 6
 7static Constant RTE_NULL_STRING = 185
 8
 9/// @class INFO_DOCU
 10/// Append information to the next assertion to print if failed
 19511static Function INFO_WRAPPER(format, strings, numbers, flags)
 12  string   format
 13  WAVE/T   strings
 14  WAVE     numbers
 15  variable flags
 16
 19517  variable err, index
 19518  string msg
 19519  WAVE/T wvInfoMsg = IUTF_Reporting#GetInfoMsg()
 20
 19521  msg = IUTF_Utils_Strings#UserPrintF(format, strings, numbers, err)
 19522  if(err)
 023    sprintf msg, "PrintF error \"%s\"", msg
 024    EvaluateResults(0, msg, flags, cleanupInfo = 0)
 025    return NaN
 19526  endif
 27
 19528  index            = IUTF_Utils_Vector#AddRow(wvInfoMsg)
 19529  wvInfoMsg[index] = msg
 19530End
 31
 32/// @class CDF_EMPTY_DOCU
 33/// Tests if the current data folder is empty
 34///
 35/// Counted are objects with type waves, strings, variables and folders
 036static Function CDF_EMPTY_WRAPPER(flags)
 37  variable flags
 38
 039  variable result
 40
 041  IUTF_Reporting#incrAssert()
 42
 043  if(shouldDoAbort())
 044    return NaN
 045  endif
 46
 047  result = IUTF_Checks#IsDataFolderEmpty(":")
 048  EvaluateResults(result, "Assumption that the current data folder is empty is", flags)
 049End
 50
 51/// @class TRUE_DOCU
 52/// Tests if var is non-zero and not "Not a Number" (NaN).
 53///
 54/// @param var variable to test
 2155static Function TRUE_WRAPPER(var, flags)
 56  variable var
 57  variable flags
 58
 2159  variable result
 60
 2161  IUTF_Reporting#incrAssert()
 62
 2163  if(shouldDoAbort())
 064    return NaN
 2165  endif
 66
 2167  result = IUTF_Checks#IsTrue(var)
 2168  EvaluateResults(result, num2istr(var), flags)
 2169End
 70
 71/// @class NULL_STR_DOCU
 72/// Tests if str is null.
 73///
 74/// An empty string is never null.
 75/// @param str    string to test
 076static Function NULL_STR_WRAPPER(str, flags)
 77  string  &str
 78  variable flags
 79
 080  variable result
 81
 082  IUTF_Reporting#incrAssert()
 83
 084  if(shouldDoAbort())
 085    return NaN
 086  endif
 87
 088  result = IUTF_Checks#IsNullString(str)
 089  EvaluateResults(result, "Assumption that str is null is", flags)
 090End
 91
 92/// @class EMPTY_STR_DOCU
 93/// Tests if str is empty.
 94///
 95/// A null string is never empty.
 96/// @param str  string to test
 097static Function EMPTY_STR_WRAPPER(str, flags)
 98  string  &str
 99  variable flags
 100
 0101  variable result
 102
 0103  IUTF_Reporting#incrAssert()
 104
 0105  if(shouldDoAbort())
 0106    return NaN
 0107  endif
 108
 0109  result = IUTF_Checks#IsEmptyString(str)
 0110  EvaluateResults(result, "Assumption that the string is empty is", flags)
 0111End
 112
 113/// @class NON_NULL_STR_DOCU
 114/// Tests if str is not null.
 115///
 116/// An empty string is always non null.
 117/// @param str    string to test
 0118static Function NON_NULL_STR_WRAPPER(str, flags)
 119  string  &str
 120  variable flags
 121
 0122  variable result
 123
 0124  IUTF_Reporting#incrAssert()
 125
 0126  if(shouldDoAbort())
 0127    return NaN
 0128  endif
 129
 0130  result = !IUTF_Checks#IsNullString(str)
 0131  EvaluateResults(result, "Assumption of the string being non null is", flags)
 0132End
 133
 134/// @class NON_EMPTY_STR_DOCU
 135/// Tests if str is not empty.
 136///
 137/// A null string is a non empty string too.
 138/// @param str  string to test
 0139static Function NON_EMPTY_STR_WRAPPER(str, flags)
 140  string  &str
 141  variable flags
 142
 0143  variable result
 144
 0145  IUTF_Reporting#incrAssert()
 146
 0147  if(shouldDoAbort())
 0148    return NaN
 0149  endif
 150
 0151  result = !IUTF_Checks#IsEmptyString(str)
 0152  EvaluateResults(result, "Assumption that the string is non empty is", flags)
 0153End
 154
 155/// @class PROPER_STR_DOCU
 156/// Tests if str is a "proper" string, i.e. a string with a length larger than
 157/// zero.
 158///
 159/// Neither null strings nor empty strings are proper strings.
 160/// @param str  string to test
 0161static Function PROPER_STR_WRAPPER(str, flags)
 162  string  &str
 163  variable flags
 164
 0165  variable result
 166
 0167  IUTF_Reporting#incrAssert()
 168
 0169  if(shouldDoAbort())
 0170    return NaN
 0171  endif
 172
 0173  result = IUTF_Checks#IsProperString(str)
 0174  EvaluateResults(result, "Assumption that the string is a proper string is", flags)
 0175End
 176
 177/// @class NEQ_VAR_DOCU
 178/// Tests two variables for inequality
 179///
 180/// @param var1    first variable
 181/// @param var2    second variable
 0182static Function NEQ_VAR_WRAPPER(var1, var2, flags)
 183  variable var1, var2
 184  variable flags
 185
 0186  variable result
 0187  string str, tmpStr1, tmpStr2
 188
 0189  IUTF_Reporting#incrAssert()
 190
 0191  if(shouldDoAbort())
 0192    return NaN
 0193  endif
 194
 0195  result  = !IUTF_Checks#AreVariablesEqual(var1, var2)
 0196  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var1, isDouble = 1)
 0197  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(var2, isDouble = 1)
 0198  sprintf str, "%s != %s", tmpStr1, tmpStr2
 0199  EvaluateResults(result, str, flags)
 0200End
 201
 202/// @class NEQ_STR_DOCU
 203/// Compares two strings for unequality
 204///
 205/// This doesn't check if one of the two string are null. If this function is called with a null
 206/// string this will throw a check assertion error. The same will happen if you call this function
 207/// and there is a pending code 185 runtime error.
 208///
 209/// @param str1            first string
 210/// @param str2            second string
 211/// @param case_sensitive  (optional) should the comparison be done case sensitive (1) or case insensitive (0, the defau
 0212static Function NEQ_STR_WRAPPER(str1, str2, flags, [case_sensitive])
 213  string &str1, &str2
 214  variable case_sensitive
 215  variable flags
 216
 0217  variable result
 0218  string str, tmpStr1, tmpStr2
 219
 0220  IUTF_Reporting#incrAssert()
 221
 0222  if(shouldDoAbort())
 0223    return NaN
 0224  endif
 225
 0226  if(ParamIsDefault(case_sensitive))
 0227    case_sensitive = 1
 0228  endif
 229
 0230  if(GetRTError(0) == RTE_NULL_STRING)
 0231    IUTF_Basics#ClearRTError()
 0232    str = "Null string error: One of the provided arguments could be an unsupported null string."
 0233    EvaluateResults(0, str, CHECK_MODE)
 0234    return NaN
 0235  endif
 236
 0237  result  = !IUTF_Checks#AreStringsEqual(str1, str2, case_sensitive)
 0238  tmpStr1 = IUTF_Utils#IUTF_PrepareStringForOut(str1)
 0239  tmpStr2 = IUTF_Utils#IUTF_PrepareStringForOut(str2)
 0240  sprintf str, "\"%s\" != \"%s\" %s case", tmpStr1, tmpStr2, SelectString(case_sensitive, "not respecting", "respecting"
 241
 0242  EvaluateResults(result, str, flags)
 0243End
 244
 245/// @class CLOSE_VAR_DOCU
 246/// Compares two variables and determines if they are close.
 247///
 248/// Based on the implementation of "Floating-point comparison algorithms" in the C++ Boost unit testing framework.
 249///
 250/// Literature:<br>
 251/// The art of computer programming (Vol II). Donald. E. Knuth. 0-201-89684-2. Addison-Wesley Professional;
 252/// 3 edition, page 234 equation (34) and (35).
 253///
 254/// @param var1   first variable
 255/// @param var2   second variable
 256/// @param tol    (optional) tolerance, defaults to 1e-8
 257/// @param strong (optional) type of condition, can be 0 for weak or 1 for strong (default)
 0258static Function CLOSE_VAR_WRAPPER(var1, var2, flags, [tol, strong])
 259  variable var1, var2
 260  variable flags
 261  variable tol
 262  variable strong
 263
 0264  variable result
 0265  string str, tmpStr1, tmpStr2, tmpStr3
 266
 0267  IUTF_Reporting#incrAssert()
 268
 0269  if(shouldDoAbort())
 0270    return NaN
 0271  endif
 272
 0273  if(ParamIsDefault(strong))
 0274    strong = CLOSE_COMPARE_STRONG
 0275  endif
 276
 0277  if(ParamIsDefault(tol))
 0278    tol = DEFAULT_TOLERANCE
 0279  endif
 280
 0281  result  = IUTF_Checks#AreVariablesClose(var1, var2, tol, strong)
 0282  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var1, isDouble = 1)
 0283  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(var2, isDouble = 1)
 0284  tmpStr3 = IUTF_Utils#GetNiceStringForNumber(tol, isDouble = 1)
 0285  sprintf str, "%s ~ %s with %s check and tol %s", tmpStr1, tmpStr2, SelectString(strong, "weak", "strong"), tmpStr3
 0286  EvaluateResults(result, str, flags)
 0287End
 288
 289/// @class CLOSE_CMPLX_DOCU
 290/// @copydoc CLOSE_VAR_DOCU
 291///
 292/// Variant for complex numbers.
 0293static Function CLOSE_CMPLX_WRAPPER(var1, var2, flags, [tol, strong])
 294  variable/C var1, var2
 295  variable flags
 296  variable tol
 297  variable strong
 298
 0299  variable result
 0300  string str, tmpStr1, tmpStr2, tmpStr3, tmpStr4, tmpStr5
 301
 0302  IUTF_Reporting#incrAssert()
 303
 0304  if(shouldDoAbort())
 0305    return NaN
 0306  endif
 307
 0308  if(ParamIsDefault(strong))
 0309    strong = CLOSE_COMPARE_STRONG
 0310  endif
 311
 0312  if(ParamIsDefault(tol))
 0313    tol = DEFAULT_TOLERANCE
 0314  endif
 315
 0316  result  = IUTF_Checks#AreVariablesClose(real(var1), real(var2), tol, strong) && IUTF_Checks#AreVariablesClose(imag(var
 0317  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(real(var1), isDouble = 1)
 0318  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(imag(var1), isDouble = 1)
 0319  tmpStr3 = IUTF_Utils#GetNiceStringForNumber(real(var2), isDouble = 1)
 0320  tmpStr4 = IUTF_Utils#GetNiceStringForNumber(imag(var2), isDouble = 1)
 0321  tmpStr5 = IUTF_Utils#GetNiceStringForNumber(tol, isDouble = 1)
 0322  sprintf str, "(%s, %s) ~ (%s, %s) with %s check and tol %s", tmpStr1, tmpStr2, tmpStr3, tmpStr4, SelectString(strong, 
 0323  EvaluateResults(result, str, flags)
 0324End
 325
 326/// @cond HIDDEN_SYMBOL
 327#if IgorVersion() >= 7.0
 328/// @endcond
 329
 330/// @class CLOSE_INT64_DOCU
 331/// Compares two int64 and determines if they are close.
 332///
 333/// @param var1   first int64 variable
 334/// @param var2   second int64 variable
 335/// @param tol    (optional) int64 tolerance, defaults to 16
 0336static Function CLOSE_INT64_WRAPPER(int64 var1, int64 var2, variable flags, [int64 tol])
 0337  variable result
 0338  string   str
 339
 0340  IUTF_Reporting#incrAssert()
 341
 0342  if(shouldDoAbort())
 0343    return NaN
 0344  endif
 345
 0346  if(ParamIsDefault(tol))
 0347    tol = DEFAULT_TOLERANCE_INT
 0348  endif
 349
 0350  result = IUTF_Checks#AreINT64Close(var1, var2, tol)
 0351  sprintf str, "%d ~ %d with tol %d", var1, var2, tol
 0352  EvaluateResults(result, str, flags)
 0353End
 354
 355/// @class CLOSE_UINT64_DOCU
 356/// Compares two uint64 and determines if they are close.
 357///
 358/// @param var1   first uint64 variable
 359/// @param var2   second uint64 variable
 360/// @param tol    (optional) uint64 tolerance, defaults to 16
 0361static Function CLOSE_UINT64_WRAPPER(uint64 var1, uint64 var2, variable flags, [uint64 tol])
 0362  variable result
 0363  string   str
 364
 0365  IUTF_Reporting#incrAssert()
 366
 0367  if(shouldDoAbort())
 0368    return NaN
 0369  endif
 370
 0371  if(ParamIsDefault(tol))
 0372    tol = DEFAULT_TOLERANCE_INT
 0373  endif
 374
 0375  result = IUTF_Checks#AreUINT64Close(var1, var2, tol)
 0376  sprintf str, "%d ~ %d with tol %d", var1, var2, tol
 0377  EvaluateResults(result, str, flags)
 0378End
 379
 380/// @cond HIDDEN_SYMBOL
 381#endif
 382/// @endcond
 383
 384/// @class SMALL_VAR_DOCU
 385/// Tests if a variable is small using the inequality @f$  | var | < | tol |  @f$
 386///
 387/// @param var        variable
 388/// @param tol        (optional) tolerance, defaults to 1e-8
 0389static Function SMALL_VAR_WRAPPER(var, flags, [tol])
 390  variable var
 391  variable flags
 392  variable tol
 393
 0394  variable result
 0395  string str, tmpStr1, tmpStr2
 396
 0397  IUTF_Reporting#incrAssert()
 398
 0399  if(shouldDoAbort())
 0400    return NaN
 0401  endif
 402
 0403  if(ParamIsDefault(tol))
 0404    tol = DEFAULT_TOLERANCE
 0405  endif
 406
 0407  result  = IUTF_Checks#IsVariableSmall(var, tol)
 0408  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var, isDouble = 1)
 0409  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(tol, isDouble = 1)
 410
 0411  sprintf str, "%s ~ 0 with tol %s", tmpStr1, tmpStr2
 0412  EvaluateResults(result, str, flags)
 0413End
 414
 415/// @class SMALL_CMPLX_DOCU
 416/// @copydoc SMALL_VAR_DOCU
 417///
 418/// Variant for complex numbers
 0419static Function SMALL_CMPLX_WRAPPER(var, flags, [tol])
 420  variable/C var
 421  variable   flags
 422  variable   tol
 423
 0424  variable result
 0425  string str, tmpStr1, tmpStr2, tmpStr3
 426
 0427  IUTF_Reporting#incrAssert()
 428
 0429  if(shouldDoAbort())
 0430    return NaN
 0431  endif
 432
 0433  if(ParamIsDefault(tol))
 0434    tol = DEFAULT_TOLERANCE
 0435  endif
 436
 0437  result  = IUTF_Checks#IsVariableSmall(cabs(var), tol)
 0438  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(real(var), isDouble = 1)
 0439  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(imag(var), isDouble = 1)
 0440  tmpStr3 = IUTF_Utils#GetNiceStringForNumber(tol, isDouble = 1)
 0441  sprintf str, "(%s, %s) ~ 0 with tol %s", tmpStr1, tmpStr2, tmpStr3
 0442  EvaluateResults(result, str, flags)
 0443End
 444
 445/// @cond HIDDEN_SYMBOL
 446#if IgorVersion() >= 7.0
 447/// @endcond
 448
 449/// @class SMALL_INT64_DOCU
 450/// Tests if a int64 variable is small using the inequality @f$  | var | < | tol |  @f$
 451///
 452/// @param var        int64 variable
 453/// @param tol        (optional) int64 tolerance, defaults to 16
 0454static Function SMALL_INT64_WRAPPER(int64 var, variable flags, [int64 tol])
 0455  variable result
 0456  string   str
 457
 0458  IUTF_Reporting#incrAssert()
 459
 0460  if(shouldDoAbort())
 0461    return NaN
 0462  endif
 463
 0464  if(ParamIsDefault(tol))
 0465    tol = DEFAULT_TOLERANCE_INT
 0466  endif
 467
 0468  result = IUTF_Checks#IsINT64Small(var, tol)
 0469  sprintf str, "%d ~ 0 with tol %g", var, tol
 0470  EvaluateResults(result, str, flags)
 0471End
 472
 473/// @class SMALL_UINT64_DOCU
 474/// Tests if a uint64 variable is small using the inequality @f$  var < tol  @f$
 475///
 476/// @param var        uint64 variable
 477/// @param tol        (optional) uint64 tolerance, defaults to 16
 0478static Function SMALL_UINT64_WRAPPER(uint64 var, variable flags, [uint64 tol])
 0479  variable result
 0480  string   str
 481
 0482  IUTF_Reporting#incrAssert()
 483
 0484  if(shouldDoAbort())
 0485    return NaN
 0486  endif
 487
 0488  if(ParamIsDefault(tol))
 0489    tol = DEFAULT_TOLERANCE_INT
 0490  endif
 491
 0492  result = IUTF_Checks#IsUINT64Small(var, tol)
 0493  sprintf str, "%d ~ 0 with tol %g", var, tol
 0494  EvaluateResults(result, str, flags)
 0495End
 496
 497/// @cond HIDDEN_SYMBOL
 498#endif
 499/// @endcond
 500
 501/// @class EQUAL_STR_DOCU
 502/// Compares two strings for byte-wise equality. (no encoding considered, no unicode normalization).
 503///
 504/// This doesn't check if one of the two string are null. If this function is called with a null
 505/// string this will throw a check assertion error. The same will happen if you call this function
 506/// and there is a pending code 185 runtime error.
 507///
 508/// @param str1           first string
 509/// @param str2           second string
 510/// @param case_sensitive (optional) should the comparison be done case sensitive (1) or case insensitive (1, the defaul
 160511static Function EQUAL_STR_WRAPPER(str1, str2, flags, [case_sensitive])
 512  string &str1, &str2
 513  variable case_sensitive
 514  variable flags
 515
 160516  variable result
 160517  string str, tmpStr1, tmpStr2
 160518  STRUCT IUTF_StringDiffResult diffResult
 519
 160520  IUTF_Reporting#incrAssert()
 521
 160522  if(shouldDoAbort())
 0523    return NaN
 160524  endif
 525
 160526  if(ParamIsDefault(case_sensitive))
 160527    case_sensitive = 1
 160528  endif
 529
 160530  if(GetRTError(0) == RTE_NULL_STRING)
 0531    IUTF_Basics#ClearRTError()
 0532    str = "Null string error: One of the provided arguments could be an unsupported null string."
 0533    EvaluateResults(0, str, CHECK_MODE)
 0534    IUTF_Reporting#CleanupInfoMsg()
 0535    return NaN
 160536  endif
 537
 160538  result = IUTF_Checks#AreStringsEqual(str1, str2, case_sensitive)
 160539  if(!result)
 0540    IUTF_Utils#DiffString(str1, str2, diffResult, case_sensitive = case_sensitive)
 0541    sprintf str, "String mismatch (case %ssensitive):\rstr1: %s\rstr2: %s\r", SelectString(case_sensitive, "in", ""), di
 0542    EvaluateResults(result, str, flags)
 160543  endif
 544
 160545  IUTF_Reporting#CleanupInfoMsg()
 160546End
 547
 548/// @class WAVE_DOCU
 549/// Tests a wave for existence and its type
 550///
 551/// @param wv         wave reference
 552/// @param majorType  major wave type
 553/// @param minorType  (optional) minor wave type
 554///
 555/// @verbatim embed:rst:leading-slashes
 556/// See also :ref:`flags_testwave`.
 557/// @endverbatim
 558///
 0559static Function TEST_WAVE_WRAPPER(wv, majorType, flags, [minorType])
 560  WAVE/Z wv
 561  variable majorType, minorType
 562  variable flags
 563
 0564  variable result, type
 0565  string str, str1, str2
 566
 0567  IUTF_Reporting#incrAssert()
 568
 0569  if(shouldDoAbort())
 0570    return NaN
 0571  endif
 572
 0573  if(!(majorType & (NULL_WAVE | NUMERIC_WAVE | TEXT_WAVE | DATAFOLDER_WAVE | WAVE_WAVE | NORMAL_WAVE | FREE_WAVE)))
 0574    EvaluateResults(0, "Valid major type check", flags)
 0575    return NaN
 0576  elseif(!ParamIsDefault(minorType) && !(minorType & (NULL_WAVE | NON_NUMERIC_WAVE | COMPLEX_WAVE | FLOAT_WAVE | DOUBLE_
 0577    EvaluateResults(0, "Valid minor type check", flags)
 0578    return NaN
 0579  endif
 580
 0581  result = IUTF_Checks#HasWaveMajorType(wv, majorType)
 0582  type   = IUTF_Checks#GetWaveMajorType(wv)
 0583  str1   = IUTF_Checks#GetWaveMajorTypeString(majorType)
 0584  str2   = IUTF_Checks#GetWaveMajorTypeString(type)
 0585  sprintf str, "Expect wave's main type to be '%s' but got '%s'", str1, str2
 0586  EvaluateResults(result, str, flags, cleanupInfo = 0)
 587
 0588  if(!ParamIsDefault(minorType))
 0589    result = IUTF_Checks#HasWaveMinorType(wv, minorType)
 0590    type   = IUTF_Checks#GetWaveMinorType(wv)
 0591    str1   = IUTF_Checks#GetWaveMinorTypeString(minorType)
 0592    str2   = IUTF_Checks#GetWaveMinorTypeString(type)
 0593    sprintf str, "Expect wave's sub type to be '%s' but got '%s'", str1, str2
 0594    EvaluateResults(result, str, flags, cleanupInfo = 0)
 0595  endif
 596
 0597  IUTF_Reporting#CleanupInfoMsg()
 0598End
 599
 600/// @class EQUAL_VAR_DOCU
 601/// Tests two variables for equality.
 602///
 603/// For variables holding floating point values it is often more desirable use
 604/// CHECK_CLOSE_VAR instead. To fullfill semantic correctness this assertion
 605/// treats two variables with both holding NaN as equal.
 606///
 607/// @param var1   first variable
 608/// @param var2   second variable
 330609static Function EQUAL_VAR_WRAPPER(var1, var2, flags)
 610  variable var1, var2
 611  variable flags
 612
 330613  variable result
 330614  string str, tmpStr1, tmpStr2
 615
 330616  IUTF_Reporting#incrAssert()
 617
 330618  if(shouldDoAbort())
 0619    return NaN
 330620  endif
 621
 330622  result  = IUTF_Checks#AreVariablesEqual(var1, var2)
 330623  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var1, isDouble = 1)
 330624  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(var2, isDouble = 1)
 330625  sprintf str, "%s == %s", tmpStr1, tmpStr2
 330626  EvaluateResults(result, str, flags)
 330627End
 628
 629/// @cond HIDDEN_SYMBOL
 630#if IgorVersion() >= 7.00
 631/// @endcond
 632
 633/// @class EQUAL_INT64_DOCU
 634/// Tests two int64 for equality.
 635///
 636/// @param var1   first variable
 637/// @param var2   second variable
 0638static Function EQUAL_INT64_WRAPPER(int64 var1, int64 var2, variable flags)
 0639  variable result
 0640  string   str
 641
 0642  IUTF_Reporting#incrAssert()
 643
 0644  if(shouldDoAbort())
 0645    return NaN
 0646  endif
 647
 0648  result = IUTF_Checks#AreInt64Equal(var1, var2)
 0649  sprintf str, "%d == %d", var1, var2
 0650  EvaluateResults(result, str, flags)
 0651End
 652
 653/// @class EQUAL_UINT64_DOCU
 654/// Tests two uint64 for equality.
 655///
 656/// @param var1   first variable
 657/// @param var2   second variable
 0658static Function EQUAL_UINT64_WRAPPER(uint64 var1, uint64 var2, variable flags)
 0659  variable result
 0660  string   str
 661
 0662  IUTF_Reporting#incrAssert()
 663
 0664  if(shouldDoAbort())
 0665    return NaN
 0666  endif
 667
 0668  result = IUTF_Checks#AreUInt64Equal(var1, var2)
 0669  sprintf str, "%u == %u", var1, var2
 0670  EvaluateResults(result, str, flags)
 0671End
 672
 673/// @class NEQ_INT64_DOCU
 674/// Tests two int64 for unequality.
 675///
 676/// @param var1   first variable
 677/// @param var2   second variable
 0678static Function NEQ_INT64_WRAPPER(int64 var1, int64 var2, variable flags)
 0679  variable result
 0680  string   str
 681
 0682  IUTF_Reporting#incrAssert()
 683
 0684  if(shouldDoAbort())
 0685    return NaN
 0686  endif
 687
 0688  result = !IUTF_Checks#AreInt64Equal(var1, var2)
 0689  sprintf str, "%d == %d", var1, var2
 0690  EvaluateResults(result, str, flags)
 0691End
 692
 693/// @class NEQ_UINT64_DOCU
 694/// Tests two uint64 for unequality.
 695///
 696/// @param var1   first variable
 697/// @param var2   second variable
 0698static Function NEQ_UINT64_WRAPPER(uint64 var1, uint64 var2, variable flags)
 0699  variable result
 0700  string   str
 701
 0702  IUTF_Reporting#incrAssert()
 703
 0704  if(shouldDoAbort())
 0705    return NaN
 0706  endif
 707
 0708  result = !IUTF_Checks#AreUInt64Equal(var1, var2)
 0709  sprintf str, "%u == %u", var1, var2
 0710  EvaluateResults(result, str, flags)
 0711End
 712
 713/// @cond HIDDEN_SYMBOL
 714#endif
 715/// @endcond
 716
 717/// @class EQUAL_WAVE_DOCU
 718/// Tests two waves for equality.
 719/// If one wave has a zero size and the other one does not then properties like DIMENSION_UNITS are compared to unequal 
 720/// non-existing dimension is always unequal to a property of an existing dimension.
 721/// This function won't throw an assert if both waves have the same reference, because they are considered as equal.
 722///
 723/// @param wv1    first wave
 724/// @param wv2    second wave
 725/// @param mode   (optional) features of the waves to compare, defaults to all modes
 726/// @param tol    (optional) tolerance for comparison, by default 0.0 which does byte-by-byte comparison (relevant only 
 727///
 728/// @verbatim embed:rst:leading-slashes
 729/// See also :ref:`flags_equalwave`.
 730/// @endverbatim
 731///
 0732static Function EQUAL_WAVE_WRAPPER(wv1, wv2, flags, [mode, tol])
 733  WAVE/Z wv1, wv2
 734  variable flags
 735  variable mode, tol
 736
 0737  variable i, result
 0738  string detailedMsg, name1, name2
 0739  string str = ""
 740
 0741  IUTF_Reporting#incrAssert()
 742
 0743  if(shouldDoAbort())
 0744    return NaN
 0745  endif
 746
 0747  result = WaveExists(wv1)
 748
 0749  if(!result)
 0750    EvaluateResults(0, "Assumption that the first wave (wv1) exists", flags)
 0751    return NaN
 0752  endif
 753
 0754  result = WaveExists(wv2)
 755
 0756  if(!result)
 0757    EvaluateResults(0, "Assumption that the second wave (wv2) exists", flags)
 0758    return NaN
 0759  endif
 760
 0761  Make/FREE validModes = {WAVE_DATA, WAVE_DATA_TYPE, WAVE_SCALING, DATA_UNITS, DIMENSION_UNITS, DIMENSION_LABELS, WAVE_N
 762
 0763  if(ParamIsDefault(mode))
 0764    WAVE modes = validModes
 0765  else
 0766    if(!IUTF_Utils#IsFinite(mode))
 0767      EvaluateResults(0, "Valid mode for EQUAL_WAVE check.", flags)
 0768      return NaN
 0769    elseif(!(mode & (WAVE_DATA | WAVE_DATA_TYPE | WAVE_SCALING | DATA_UNITS | DIMENSION_UNITS | DIMENSION_LABELS | WAVE_
 0770      EvaluateResults(0, "Valid mode for EQUAL_WAVE check.", flags)
 0771      return NaN
 0772    endif
 773
 0774    // mode can be a bit pattern, split into separate entities for better debugging
 0775    Duplicate/FREE validModes, modes
 776
 0777    modes[] = (validModes[p] == (validModes[p] & mode)) ? validModes[p] : NaN
 0778    WaveTransform/O zapNaNs, modes
 779
 0780    if(!DimSize(modes, 0))
 0781      EvaluateResults(0, "Valid mode for EQUAL_WAVE check.", flags)
 0782      return NaN
 0783    endif
 0784  endif
 785
 0786  if(ParamIsDefault(tol))
 0787    tol = 0.0
 0788  elseif(IUTF_Utils#IsNaN(tol))
 0789    EvaluateResults(0, "Valid tolerance for EQUAL_WAVE check.", flags)
 0790    return NaN
 0791  elseif(tol < 0)
 0792    EvaluateResults(0, "Valid tolerance for EQUAL_WAVE check.", flags)
 0793    return NaN
 0794  endif
 795
 0796  for(i = 0; i < DimSize(modes, 0); i += 1)
 0797    mode   = modes[i]
 0798    result = IUTF_Checks#AreWavesEqual(wv1, wv2, mode, tol, detailedMsg)
 799
 0800    if(!result)
 0801      name1 = IUTF_Utils#GetWaveNameInDFStr(wv1)
 0802      name2 = IUTF_Utils#GetWaveNameInDFStr(wv2)
 0803      sprintf str, "Assuming equality using mode %s for waves %s and %s", EqualWavesModeToString(mode), name1, name2
 804
 0805      if(!IUTF_Utils#IsEmpty(detailedMsg))
 0806        str += "; detailed: " + detailedMsg
 0807      endif
 0808    endif
 809
 0810    EvaluateResults(result, str, flags, cleanupInfo = 0)
 0811  endfor
 812
 0813  IUTF_Reporting#CleanupInfoMsg()
 0814End
 815
 816/// @class LESS_EQUAL_VAR_DOCU
 817/// Tests that var1 is less or equal than var2
 818///
 819/// @param var1 first variable
 820/// @param var2 second variable
 0821static Function LESS_EQUAL_VAR_WRAPPER(var1, var2, flags)
 822  variable var1, var2, flags
 823
 0824  variable result
 0825  string str, tmpStr1, tmpStr2
 826
 0827  IUTF_Reporting#incrAssert()
 828
 0829  if(shouldDoAbort())
 0830    return NaN
 0831  endif
 832
 0833  result  = IUTF_Checks#IsLessOrEqual(var1, var2)
 0834  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var1, isDouble = 1)
 0835  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(var2, isDouble = 1)
 0836  sprintf str, "%s <= %s", tmpStr1, tmpStr2
 0837  EvaluateResults(result, str, flags)
 0838End
 839
 840/// @class LESS_THAN_VAR_DOCU
 841/// Tests that var1 is less than var2
 842///
 843/// @param var1 first variable
 844/// @param var2 second variable
 0845static Function LESS_THAN_VAR_WRAPPER(var1, var2, flags)
 846  variable var1, var2, flags
 847
 0848  variable result
 0849  string str, tmpStr1, tmpStr2
 850
 0851  IUTF_Reporting#incrAssert()
 852
 0853  if(shouldDoAbort())
 0854    return NaN
 0855  endif
 856
 0857  result  = IUTF_Checks#IsLess(var1, var2)
 0858  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var1, isDouble = 1)
 0859  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(var2, isDouble = 1)
 0860  sprintf str, "%s < %s", tmpStr1, tmpStr2
 0861  EvaluateResults(result, str, flags)
 0862End
 863
 864/// @class GREATER_EQUAL_VAR_DOCU
 865/// Tests that var1 is greather or equal than var2
 866///
 867/// @param var1 first variable
 868/// @param var2 second variable
 0869static Function GREATER_EQUAL_VAR_WRAPPER(var1, var2, flags)
 870  variable var1, var2, flags
 871
 0872  variable result
 0873  string str, tmpStr1, tmpStr2
 874
 0875  IUTF_Reporting#incrAssert()
 876
 0877  if(shouldDoAbort())
 0878    return NaN
 0879  endif
 880
 0881  result  = IUTF_Checks#IsLessOrEqual(var2, var1)
 0882  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var1, isDouble = 1)
 0883  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(var2, isDouble = 1)
 0884  sprintf str, "%s >= %s", tmpStr1, tmpStr2
 0885  EvaluateResults(result, str, flags)
 0886End
 887
 888/// @class GREATER_THAN_VAR_DOCU
 889/// Tests that var1 is greather than var2
 890///
 891/// @param var1 first variable
 892/// @param var2 second variable
 0893static Function GREATER_THAN_VAR_WRAPPER(var1, var2, flags)
 894  variable var1, var2, flags
 895
 0896  variable result
 0897  string str, tmpStr1, tmpStr2
 898
 0899  IUTF_Reporting#incrAssert()
 900
 0901  if(shouldDoAbort())
 0902    return NaN
 0903  endif
 904
 0905  result  = IUTF_Checks#IsLess(var2, var1)
 0906  tmpStr1 = IUTF_Utils#GetNiceStringForNumber(var1, isDouble = 1)
 0907  tmpStr2 = IUTF_Utils#GetNiceStringForNumber(var2, isDouble = 1)
 0908  sprintf str, "%s > %s", tmpStr1, tmpStr2
 0909  EvaluateResults(result, str, flags)
 0910End
 911
 0912static Function/S RTE2String(code, [msg])
 913  variable code
 914  string   msg
 915
 0916  string result
 917
 0918  if(code)
 0919    if(ParamIsDefault(msg))
 0920      sprintf result, "RTE %d", code
 0921    else
 0922      sprintf result, "RTE %d \"%s\"", code, msg
 0923    endif
 0924    return result
 0925  else
 0926    return "no RTE"
 0927  endif
 0928End
 929
 930/// @class RTE_DOCU
 931/// Tests if a RTE with the specified code was thrown. This assertion will clear any pending RTEs.
 932///
 933/// Hint: You have to add INFO() statements before the statement that is tested. INFO() won't do
 934/// something if a pending RTE exists.
 935///
 936/// @param code the code that is expected to be thrown
 0937static Function RTE_WRAPPER(code, flags)
 938  variable code, flags
 939
 0940  variable result, err
 0941  string str, msg
 942
 0943  IUTF_Reporting#incrAssert()
 944
 0945  if(shouldDoAbort())
 0946    return NaN
 0947  endif
 948
 0949  result = IUTF_Checks#HasRTE(code)
 0950  msg    = GetRTErrMessage()
 0951  err    = GetRTError(1)
 952
 0953  sprintf str, "Expecting %s but got %s", RTE2String(code), RTE2String(err, msg = msg)
 0954  EvaluateResults(result, str, flags)
 0955End
 956
 957/// @class ANY_RTE_DOCU
 958/// Tests if any RTE was thrown. This assertion will clear any pending RTEs.
 959///
 960/// Hint: You have to add INFO() statements before the statement that is tested. INFO() won't do
 961/// something if a pending RTE exists.
 0962static Function ANY_RTE_WRAPPER(flags)
 963  variable flags
 964
 0965  variable result, err
 0966  string str
 967
 0968  IUTF_Reporting#incrAssert()
 969
 0970  if(shouldDoAbort())
 0971    return NaN
 0972  endif
 973
 0974  result = IUTF_Checks#HasAnyRTE()
 0975  err    = GetRTError(1)
 976
 0977  sprintf str, "Expecting any RTE but got nothing"
 0978  EvaluateResults(result, str, flags)
 0979End
 980
 981/// @class NO_RTE_DOCU
 982/// Tests if no RTEs are thrown. This assertion will clear any pending RTEs.
 983///
 984/// Hint: You have to add INFO() statements before the statement that is tested. INFO() won't do
 985/// something if a pending RTE exists.
 0986static Function NO_RTE_WRAPPER(flags)
 987  variable flags
 988
 0989  RTE_WRAPPER(0, flags)
 0990End
 991
 992/// @class COMPILATION_DOCU
 993/// Tests if the specified Igor Pro file can be compiled with the list of defines. This assertion
 994/// can only be used if IUTF is located inside an independent module. This assertion needs to be the
 995/// last assertion of the current test case. If you want to continue your test case after this
 996/// assertion try to split your test case into multiple functions and specify the next part in the
 997/// optional parameter reentry.
 998///
 999/// It is recommended to start Igor with the <tt>/CompErrNoDialog</tt> (alternatively
 1000/// <tt>/UNATTENDED</tt> since Igor 9) command line argument to prevent error pop-ups when a single
 1001/// compilation failed.
 1002///
 1003/// @param file     The Igor Pro procedure file that should be tested. This must be a valid path
 1004///                 that can be used in the <tt>\#include "file"</tt> syntax.
 1005/// @param defines  (optional) A text wave which contains globally defined flags that are
 1006///                 used for conditional compilation. If this parameter is not set it will be
 1007///                 treated as if an empty wave was provided and won't set any flags.
 1008/// @param reentry  (optional) The full function name of the reentry function that will be executed
 1009///                 after this assertion finished. If this parameter is not used the test case will
 1010//                  be finished after this assertion.
 41011static Function COMPILATION_WRAPPER(file, flags, [defines, reentry, noCompile])
 1012  string   file
 1013  variable flags
 1014  WAVE/Z/T defines
 1015  string   reentry
 1016  variable noCompile
 1017
 41018  variable tmpVar
 1019
 41020  noCompile = ParamIsDefault(noCompile) ? 0 : !!noCompile
 1021
 41022  IUTF_Reporting#incrAssert()
 1023
 41024  if(shouldDoAbort())
 01025    return NaN
 41026  endif
 1027
 41028  if(!CmpStr(GetIndependentModuleName(), "ProcGlobal"))
 01029    IUTF_Reporting#ReportErrorAndAbort("This assertion is only allowed to be called in an independent module")
 41030  endif
 1031
 41032  if(!ParamIsDefault(reentry))
 11033    if(IUTF_Utils#IsEmpty(reentry))
 01034      IUTF_Reporting#ReportErrorAndAbort("Reentry parameter is an empty string")
 11035    endif
 1036
 11037    if(GrepString(reentry, PROCNAME_NOT_REENTRY))
 01038      IUTF_Reporting#ReportErrorAndAbort("Name of Reentry function must end with _REENTRY")
 11039    endif
 11040    FUNCREF TEST_CASE_PROTO    rFuncRef    = $reentry
 11041    FUNCREF TEST_CASE_PROTO_MD rFuncRefMMD = $reentry
 11042    if(!IUTF_FuncRefIsAssigned(FuncRefInfo(rFuncRef)) && !IUTF_FuncRefIsAssigned(FuncRefInfo(rFuncRefMMD)) && !IUTF_Test
 01043      IUTF_Reporting#ReportErrorAndAbort("Specified reentry procedure has wrong format. The format must be function_REEN
 11044    endif
 31045  else
 31046    reentry = ""
 41047  endif
 1048
 41049  if(ParamIsDefault(defines) || !WaveExists(defines))
 31050    Make/FREE/N=0/T defines
 41051  endif
 1052
 41053  IUTF_Test_Compilation#TestCompilation(file, flags, defines, reentry, noCompile)
 41054End
 1055
 1056/// @class NO_COMPILATION_DOCU
 1057/// Tests if the specified Igor Pro file cannot be compiled with the list of defines. This assertion
 1058/// can only be used if IUTF is located inside an independent module. This assertion needs to be the
 1059/// last assertion of the current test case. If you want to continue your test case after this
 1060/// assertion try to split your test case into multiple functions and specify the next part in the
 1061/// optional parameter reentry.
 1062///
 1063/// It is recommended to start Igor with the <tt>/CompErrNoDialog</tt> (alternatively
 1064/// <tt>/UNATTENDED</tt> since Igor 9) command line argument to prevent error pop-ups when a single
 1065/// compilation failed.
 1066///
 1067/// @param file     The Igor Pro procedure file that should be tested. This must be a valid path
 1068///                 that can be used in the <tt>\#include "file"</tt> syntax.
 1069/// @param defines  (optional) A text wave which contains globally defined flags that are
 1070///                 used for conditional compilation. If this parameter is not set it will be
 1071///                 treated as if an empty wave was provided and won't set any flags.
 1072/// @param reentry  (optional) The full function name of the reentry function that will be executed
 1073///                 after this assertion finished. If this parameter is not used the test case will
 1074//                  be finished after this assertion.
 21075static Function NO_COMPILATION_WRAPPER(file, flags, [defines, reentry])
 1076  string   file
 1077  variable flags
 1078  WAVE/Z/T defines
 1079  string   reentry
 1080
 21081  if(ParamIsDefault(defines))
 21082    if(ParamIsDefault(reentry))
 11083      COMPILATION_WRAPPER(file, flags, noCompile = 1)
 11084    else
 11085      COMPILATION_WRAPPER(file, flags, reentry = reentry, noCompile = 1)
 21086    endif
 01087  else
 01088    if(ParamIsDefault(reentry))
 01089      COMPILATION_WRAPPER(file, flags, defines = defines, noCompile = 1)
 01090    else
 01091      COMPILATION_WRAPPER(file, flags, defines = defines, reentry = reentry, noCompile = 1)
 01092    endif
 21093  endif
 21094End
Generated by: ReportGenerator 5.1.17.0
06/01/2025 - 18:50:51
GitHub | reportgenerator.io

Methods/Properties

IUTF_Wrapper#INFO_WRAPPER()
IUTF_Wrapper#CDF_EMPTY_WRAPPER()
IUTF_Wrapper#TRUE_WRAPPER()
IUTF_Wrapper#NULL_STR_WRAPPER()
IUTF_Wrapper#EMPTY_STR_WRAPPER()
IUTF_Wrapper#NON_NULL_STR_WRAPPER()
IUTF_Wrapper#NON_EMPTY_STR_WRAPPER()
IUTF_Wrapper#PROPER_STR_WRAPPER()
IUTF_Wrapper#NEQ_VAR_WRAPPER()
IUTF_Wrapper#NEQ_STR_WRAPPER()
IUTF_Wrapper#CLOSE_VAR_WRAPPER()
IUTF_Wrapper#CLOSE_CMPLX_WRAPPER()
IUTF_Wrapper#CLOSE_INT64_WRAPPER()
IUTF_Wrapper#CLOSE_UINT64_WRAPPER()
IUTF_Wrapper#SMALL_VAR_WRAPPER()
IUTF_Wrapper#SMALL_CMPLX_WRAPPER()
IUTF_Wrapper#SMALL_INT64_WRAPPER()
IUTF_Wrapper#SMALL_UINT64_WRAPPER()
IUTF_Wrapper#EQUAL_STR_WRAPPER()
IUTF_Wrapper#TEST_WAVE_WRAPPER()
IUTF_Wrapper#EQUAL_VAR_WRAPPER()
IUTF_Wrapper#EQUAL_INT64_WRAPPER()
IUTF_Wrapper#EQUAL_UINT64_WRAPPER()
IUTF_Wrapper#NEQ_INT64_WRAPPER()
IUTF_Wrapper#NEQ_UINT64_WRAPPER()
IUTF_Wrapper#EQUAL_WAVE_WRAPPER()
IUTF_Wrapper#LESS_EQUAL_VAR_WRAPPER()
IUTF_Wrapper#LESS_THAN_VAR_WRAPPER()
IUTF_Wrapper#GREATER_EQUAL_VAR_WRAPPER()
IUTF_Wrapper#GREATER_THAN_VAR_WRAPPER()
IUTF_Wrapper#RTE2String()
IUTF_Wrapper#RTE_WRAPPER()
IUTF_Wrapper#ANY_RTE_WRAPPER()
IUTF_Wrapper#NO_RTE_WRAPPER()
IUTF_Wrapper#COMPILATION_WRAPPER()
IUTF_Wrapper#NO_COMPILATION_WRAPPER()