lsst.utils.tests Namespace Reference

Classes
class	MemoryTestCase
	Check for memory leaks since memId0 was allocated. More...
class	TestCase
	Subclass of unittest.TestCase that adds some custom assertions for convenience. More...

Functions
def	init
def	run
	Exit with the status code resulting from running the provided test suite. More...
def	findFileFromRoot
	Find file which is specified as a path relative to the toplevel directory; we start in $cwd and walk up until we find the file (or throw IOError if it doesn't exist) More...
def	getTempFilePath
	Return a path suitable for a temporary file and try to delete the file on success. More...
def	inTestCase
	A decorator to add a free function to our custom TestCase class, while also making it available as a free function. More...
def	assertRaisesLsstCpp
def	debugger
	Decorator to enter the debugger when there's an uncaught exception. More...
def	plotImageDiff
	Plot the comparison of two 2-d NumPy arrays. More...
def	assertClose
	Highly-configurable floating point comparisons for scalars and arrays. More...
def	assertNotClose
	Fail a test if the given floating point values are completely equal to within the given tolerances. More...

Variables
	dafBase = None
int	memId0 = 0
int	nleakPrintMax = 20

Function Documentation

def lsst.utils.tests.assertClose	(		testCase,
			lhs,
			rhs,
			rtol = sys.float_info.epsilon,
			atol = sys.float_info.epsilon,
			relTo = None,
			printFailures = True,
			plotOnFailure = False,
			plotFileName = None,
			invert = False
	)

Highly-configurable floating point comparisons for scalars and arrays.

The test assertion will fail if all elements lhs and rhs are not equal to within the tolerances specified by rtol and atol. More precisely, the comparison is:

abs(lhs - rhs) <= relTo*rtol OR abs(lhs - rhs) <= atol

If rtol or atol is None, that term in the comparison is not performed at all.

When not specified, relTo is the elementwise maximum of the absolute values of lhs and rhs. If set manually, it should usually be set to either lhs or rhs, or a scalar value typical of what is expected.

Parameters

[in]	testCase	unittest.TestCase instance the test is part of
[in]	lhs	LHS value(s) to compare; may be a scalar or a numpy array of any dimension
[in]	rhs	RHS value(s) to compare; may be a scalar or a numpy array of any dimension
[in]	rtol	Relative tolerance for comparison; defaults to double-precision epsilon.
[in]	atol	Absolute tolerance for comparison; defaults to double-precision epsilon.
[in]	relTo	Value to which comparison with rtol is relative.
[in]	printFailures	Upon failure, print all inequal elements as part of the message.
[in]	plotOnFailure	Upon failure, plot the originals and their residual with matplotlib. Only 2-d arrays are supported.
[in]	plotFileName	Filename to save the plot to. If None, the plot will be displayed in a a window.
[in]	invert	If True, invert the comparison and fail only if any elements are equal. Used to implement assertNotClose, which should generally be used instead for clarity.

Definition at line 285 of file tests.py.

                printFailures=True, plotOnFailure=False, plotFileName=None, invert=False):
    """!Highly-configurable floating point comparisons for scalars and arrays.

    The test assertion will fail if all elements lhs and rhs are not equal to within the tolerances
    specified by rtol and atol.  More precisely, the comparison is:

    abs(lhs - rhs) <= relTo*rtol OR abs(lhs - rhs) <= atol

    If rtol or atol is None, that term in the comparison is not performed at all.

    When not specified, relTo is the elementwise maximum of the absolute values of lhs and rhs.  If
    set manually, it should usually be set to either lhs or rhs, or a scalar value typical of what
    is expected.

    @param[in]  testCase       unittest.TestCase instance the test is part of
    @param[in]  lhs            LHS value(s) to compare; may be a scalar or a numpy array of any dimension
    @param[in]  rhs            RHS value(s) to compare; may be a scalar or a numpy array of any dimension
    @param[in]  rtol           Relative tolerance for comparison; defaults to double-precision epsilon.
    @param[in]  atol           Absolute tolerance for comparison; defaults to double-precision epsilon.
    @param[in]  relTo          Value to which comparison with rtol is relative.
    @param[in]  printFailures  Upon failure, print all inequal elements as part of the message.
    @param[in]  plotOnFailure  Upon failure, plot the originals and their residual with matplotlib.
                               Only 2-d arrays are supported.
    @param[in]  plotFileName   Filename to save the plot to.  If None, the plot will be displayed in a
                               a window.
    @param[in]  invert         If True, invert the comparison and fail only if any elements *are* equal.
                               Used to implement assertNotClose, which should generally be used instead
                               for clarity.
    """
    if not numpy.isfinite(lhs).all():
        testCase.fail("Non-finite values in lhs")
    if not numpy.isfinite(rhs).all():
        testCase.fail("Non-finite values in rhs")
    diff = lhs - rhs
    absDiff = numpy.abs(lhs - rhs)
    if rtol is not None:
        if relTo is None:
            relTo = numpy.maximum(numpy.abs(lhs), numpy.abs(rhs))
        else:
            relTo = numpy.abs(relTo)
        bad = absDiff > rtol*relTo
        if atol is not None:
            bad = numpy.logical_and(bad, absDiff > atol)
    else:
        if atol is None:
            raise ValueError("rtol and atol cannot both be None")
        bad = absDiff > atol
    failed = numpy.any(bad)
    if invert:
        failed = not failed
        bad = numpy.logical_not(bad)
        cmpStr = "=="
        failStr = "are the same"
    else:
        cmpStr = "!="
        failStr = "differ"
    msg = []
    if failed:
        if numpy.isscalar(bad):
            msg = ["%s %s %s; diff=%s/%s=%s with rtol=%s, atol=%s"
                   % (lhs, cmpStr, rhs, absDiff, relTo, absDiff/relTo, rtol, atol)]
        else:
            msg = ["%d/%d elements %s with rtol=%s, atol=%s"
                   % (bad.sum(), bad.size, failStr, rtol, atol)]
            if plotOnFailure:
                if len(lhs.shape) != 2 or len(rhs.shape) != 2:
                    raise ValueError("plotOnFailure is only valid for 2-d arrays")
                try:
                    plotImageDiff(lhs, rhs, bad, diff=diff, plotFileName=plotFileName)
                except ImportError:
                    msg.append("Failure plot requested but matplotlib could not be imported.")
            if printFailures:
                # Make sure everything is an array if any of them are, so we can treat
                # them the same (diff and absDiff are arrays if either rhs or lhs is),
                # and we don't get here if neither is.
                if numpy.isscalar(relTo):
                    relTo = numpy.ones(bad.shape, dtype=float) * relTo
                if numpy.isscalar(lhs):
                    lhs = numpy.ones(bad.shape, dtype=float) * lhs
                if numpy.isscalar(rhs):
                    rhs = numpy.ones(bad.shape, dtype=float) * rhs
                for a, b, diff, rel in zip(lhs[bad], rhs[bad], absDiff[bad], relTo[bad]):
                    msg.append("%s %s %s (diff=%s/%s=%s)" % (a, cmpStr, b, diff, rel, diff/rel))
    testCase.assertFalse(failed, msg="\n".join(msg))