Inheritance diagram for astshim.test.MappingTestCase:

Public Member Functions
	checkRoundTrip (self, amap, poslist, rtol=1e-05, atol=1e-08)

	checkBasicSimplify (self, amap)

	checkMappingPersistence (self, amap, poslist)

	checkMemoryForCompoundObject (self, obj1, obj2, cmpObj, isSeries)

Detailed Description

Base class for unit tests of mappings

Definition at line 88 of file test.py.

Member Function Documentation

◆ checkBasicSimplify()

astshim.test.MappingTestCase.checkBasicSimplify	(		self,
			amap )

Check basic simplfication for a reversible mapping

Check the following:
- A compound mapping of a amap and its inverse simplifies to
  a unit amap.
- A compound mapping of a amap and a unit amap simplifies to
  the original amap.

Definition at line 131 of file test.py.

    def checkBasicSimplify(self, amap):
        """Check basic simplfication for a reversible mapping
 
        Check the following:
        - A compound mapping of a amap and its inverse simplifies to
          a unit amap.
        - A compound mapping of a amap and a unit amap simplifies to
          the original amap.
        """
        amapinv = amap.inverted()
        cmp1 = amap.then(amapinv)
        unit1 = cmp1.simplified()
        self.assertEqual(unit1.className, "UnitMap")
        self.assertEqual(amap.nIn, cmp1.nIn)
        self.assertEqual(amap.nIn, cmp1.nOut)
        self.assertEqual(cmp1.nIn, unit1.nIn)
        self.assertEqual(cmp1.nOut, unit1.nOut)
 
        cmp2 = amapinv.then(amap)
        unit2 = cmp2.simplified()
        self.assertEqual(unit2.className, "UnitMap")
        self.assertEqual(amapinv.nIn, cmp2.nIn)
        self.assertEqual(amapinv.nIn, cmp2.nOut)
        self.assertEqual(cmp2.nIn, unit2.nIn)
        self.assertEqual(cmp2.nOut, unit2.nOut)
 
        for ma, mb, desmap3 in (
            (unit1, amap, amap),
            (amap, unit2, amap),
            (unit2, amapinv, amapinv),
            (amapinv, unit1, amapinv),
        ):
            cmp3 = ma.then(mb)
            cmp3simp = cmp3.simplified()
            self.assertEqual(cmp3simp.className, amap.simplified().className)
            self.assertEqual(ma.nIn, cmp3.nIn)
            self.assertEqual(mb.nOut, cmp3.nOut)
            self.assertEqual(cmp3.nIn, cmp3simp.nIn)
            self.assertEqual(cmp3.nOut, cmp3simp.nOut)
 

◆ checkMappingPersistence()

astshim.test.MappingTestCase.checkMappingPersistence	(	self,
		amap,
		poslist )

Check that a mapping gives identical answers to unpersisted copy

poslist is a list of input position for a forward transform
    (if it exists), or the inverse transform (if not).
    A numpy array with shape [nAxes, num points]
    or collection that can be cast to same

Checks each direction, if present. However, for generality,
does not check that the two directions are inverses of each other;
call checkRoundTrip for that.

Does everything checkPersistence does, so no need to call both.

Definition at line 171 of file test.py.

    def checkMappingPersistence(self, amap, poslist):
        """Check that a mapping gives identical answers to unpersisted copy
 
        poslist is a list of input position for a forward transform
            (if it exists), or the inverse transform (if not).
            A numpy array with shape [nAxes, num points]
            or collection that can be cast to same
 
        Checks each direction, if present. However, for generality,
        does not check that the two directions are inverses of each other;
        call checkRoundTrip for that.
 
        Does everything checkPersistence does, so no need to call both.
        """
        for channelType, options in (
            (Channel, ""),
            (FitsChan, "Encoding=Native"),
            (XmlChan, ""),
        ):
            ss = StringStream()
            chan = Channel(ss)
            chan.write(amap)
            ss.sinkToSource()
            amap_copy = chan.read()
            self.assertEqual(amap.className, amap_copy.className)
            self.assertEqual(amap.show(), amap_copy.show())
            self.assertEqual(str(amap), str(amap_copy))
            self.assertEqual(repr(amap), repr(amap_copy))
 
            if amap.hasForward:
                outPoslist = amap.applyForward(poslist)
                assert_array_equal(outPoslist, amap_copy.applyForward(poslist))
 
                if amap.hasInverse:
                    assert_array_equal(amap.applyInverse(outPoslist),
                                       amap_copy.applyInverse(outPoslist))
 
            elif amap.hasInverse:
                assert_array_equal(amap.applyInverse(poslist),
                                   amap_copy.applyInverse(poslist))
 
            else:
                raise RuntimeError("mapping has neither forward nor inverse transform")
 

◆ checkMemoryForCompoundObject()

astshim.test.MappingTestCase.checkMemoryForCompoundObject	(	self,
		obj1,
		obj2,
		cmpObj,
		isSeries )

Check the memory usage for a compoundObject

obj1: first object in compound object
obj2: second object in compound object
cmpObj: compound object (SeriesMap, ParallelMap, CmpMap or CmpFrame)
isSeries: is compound object in series? None to not test
  (e.g. CmpFrame)

Definition at line 215 of file test.py.

    def checkMemoryForCompoundObject(self, obj1, obj2, cmpObj, isSeries):
        """Check the memory usage for a compoundObject
 
        obj1: first object in compound object
        obj2: second object in compound object
        cmpObj: compound object (SeriesMap, ParallelMap, CmpMap or CmpFrame)
        isSeries: is compound object in series? None to not test
          (e.g. CmpFrame)
        """
        # if obj1 and obj2 are the same type then copying the compound object
        # will increase the NObject of each by 2, otherwise 1
        deltaObj = 2 if type(obj1) is type(obj2) else 1
 
        initialNumObj1 = obj1.getNObject()
        initialNumObj2 = obj2.getNObject()
        initialNumCmpObj = cmpObj.getNObject()
        initialRefCountObj1 = obj1.getRefCount()
        initialRefCountObj2 = obj2.getRefCount()
        initialRefCountCmpObj = cmpObj.getRefCount()
        self.assertEqual(obj1.getNObject(), initialNumObj1)
        self.assertEqual(obj2.getNObject(), initialNumObj2)
        if isSeries is not None:
            if isSeries is True:
                self.assertTrue(cmpObj.series)
            elif isSeries is False:
                self.assertFalse(cmpObj.series)
 
        # Making a deep copy should increase the object count of the contained
        # objects but should not affect the reference count.
        cp = cmpObj.copy()
        self.assertEqual(cmpObj.getRefCount(), initialRefCountCmpObj)
        self.assertEqual(cmpObj.getNObject(), initialNumCmpObj + 1)
        self.assertEqual(obj1.getRefCount(), initialRefCountObj1)
        self.assertEqual(obj2.getRefCount(), initialRefCountObj2)
        self.assertEqual(obj1.getNObject(), initialNumObj1 + deltaObj)
        self.assertEqual(obj2.getNObject(), initialNumObj2 + deltaObj)
 
        # deleting the deep copy should restore ref count and nobject
        del cp
        self.assertEqual(cmpObj.getRefCount(), initialRefCountCmpObj)
        self.assertEqual(cmpObj.getNObject(), initialNumCmpObj)
        self.assertEqual(obj1.getRefCount(), initialRefCountObj1)
        self.assertEqual(obj1.getNObject(), initialNumObj1)
        self.assertEqual(obj2.getRefCount(), initialRefCountObj2)
        self.assertEqual(obj2.getNObject(), initialNumObj2)
 
 

◆ checkRoundTrip()

astshim.test.MappingTestCase.checkRoundTrip	(	self,
		amap,
		poslist,
		rtol = 1e-05,
		atol = 1e-08 )

Check that a mapping's reverse transform is the opposite of forward

amap is the mapping to test
poslist is a list of input position for a forward transform;
    a numpy array with shape [nin, num points]
    or collection that can be cast to same
rtol is the relative tolerance for numpy.testing.assert_allclose
atol is the absolute tolerance for numpy.testing.assert_allclose

Definition at line 93 of file test.py.

    def checkRoundTrip(self, amap, poslist, rtol=1e-05, atol=1e-08):
        """Check that a mapping's reverse transform is the opposite of forward
 
        amap is the mapping to test
        poslist is a list of input position for a forward transform;
            a numpy array with shape [nin, num points]
            or collection that can be cast to same
        rtol is the relative tolerance for numpy.testing.assert_allclose
        atol is the absolute tolerance for numpy.testing.assert_allclose
        """
        poslist = np.array(poslist, dtype=float)
        if len(poslist.shape) == 1:
            # supplied data was a single list of points
            poslist.shape = (1, len(poslist))
        # forward with applyForward, inverse with applyInverse
        to_poslist = amap.applyForward(poslist)
        rt_poslist = amap.applyInverse(to_poslist)
        assert_allclose(poslist, rt_poslist, rtol=rtol, atol=atol)
 
        # forward with applyForward, inverse with inverted().applyForward
        amapinv = amap.inverted()
        rt2_poslist = amapinv.applyForward(to_poslist)
        assert_allclose(poslist, rt2_poslist, rtol=rtol, atol=atol)
 
        # forward and inverse with a compound map of amap.then(amap.inverted())
        acmp = amap.then(amapinv)
        assert_allclose(poslist, acmp.applyForward(poslist), rtol=rtol, atol=atol)
 
        # test vector versions of forward and inverse
        posvec = list(poslist.flat)
        to_posvec = amap.applyForward(posvec)
        # cast to_poslist to np.array because if poslist has 1 axis then
        # a list is returned, which has no `flat` attribute
        assert_allclose(to_posvec, list(to_poslist.flat), rtol=rtol, atol=atol)
 
        rt_posvec = amap.applyInverse(to_posvec)
        assert_allclose(posvec, rt_posvec, rtol=rtol, atol=atol)
 

The documentation for this class was generated from the following file: