Inheritance diagram for lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass:

Public Member Functions
def	checkInsertItem (self, mapFactory, contents, msg="")

def	checkSetdefault (self, mapFactory, contents, msg="")

def	checkUpdateMapping (self, mapFactory, contents, msg="")

def	checkUpdatePairs (self, mapFactory, contents, msg="")

def	checkUpdateKwargs (self, mapFactory, contents, msg="")

def	checkReplaceItem (self, genericMap, msg="")

def	checkRemoveItem (self, mapFactory, contents, msg="")

def	checkPop (self, mapFactory, contents, msg="")

def	checkPopitem (self, mapFactory, contents, msg="")

def	checkClear (self, mapFactory, contents, msg="")

def	checkMutableViews (self, mapFactory, contents, msg="")

def	getTestData (cls, keyClass)

def	setUp (self)

def	checkInitMapping (self, mapClass, contents, msg="")

def	checkInitPairs (self, mapClass, contents, msg="")

def	checkInitKwargs (self, mapClass, contents, msg="")

def	checkFromKeysDefault (self, mapClass, keys, msg="")

def	checkFromKeys (self, mapClass, keys, value, msg="")

def	checkContains (self, genericMap, contents, msg="")

def	checkContents (self, genericMap, contents, msg="")

def	checkGet (self, genericMap, contents, msg="")

def	checkIteration (self, genericMap, contents, msg="")

def	checkViews (self, genericMap, contents, msg="")

Static Public Member Functions
def	getValidKeys (mapClass)

Public Attributes
	longMessage

Detailed Description

Base class for unit tests of GenericMap that allow insertion/deletion.

Subclasses must call `MutableGenericMapTestBaseClass.setUp(self)`
if they provide their own version.

Definition at line 367 of file testUtils.py.

Member Function Documentation

◆ checkClear()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkClear	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check erasing a GenericMap.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs initially occupying the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 705 of file testUtils.py.

     def checkClear(self, mapFactory, contents, msg=""):
         """Check erasing a GenericMap.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs initially occupying the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = self._fillMap(mapFactory, contents)
         self.assertTrue(genericMap, msg=msg)
  
         genericMap.clear()
         self.assertFalse(genericMap, msg=msg)
         self.assertEqual(len(genericMap), 0, msg=msg)
         for key in genericMap:
             self.fail(f"Unexpected key: {key}", msg=msg)
  

◆ checkContains()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkContains	(	self,
		genericMap,
		contents,
		msg = `""`
	)

inherited

Check the contents of a GenericMap.

Parameters
----------
genericMap : `lsst.afw.typehandling.GenericMap`
    The map to test.
contents : `Mapping`
    The key-value pairs that should be present in ``genericMap``
msg : `str`
    Error message suffix describing test parameters

Definition at line 262 of file testUtils.py.

     def checkContains(self, genericMap, contents, msg=""):
         """Check the contents of a GenericMap.
  
         Parameters
         ----------
         genericMap : `lsst.afw.typehandling.GenericMap`
             The map to test.
         contents : `Mapping`
             The key-value pairs that should be present in ``genericMap``
         msg : `str`
             Error message suffix describing test parameters
         """
         for key in contents:
             self.assertIn(key, genericMap, msg=msg)
  
         keyType = genericMap.dtype
         for key in range(30):
             if keyType(key) not in contents:
                 self.assertNotIn(keyType(key), genericMap, msg=msg)
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError):
             wrongType(0) in genericMap
  

◆ checkContents()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkContents	(	self,
		genericMap,
		contents,
		msg = `""`
	)

inherited

Check the contents of a GenericMap.

Parameters
----------
genericMap : `lsst.afw.typehandling.GenericMap`
    The map to test.
contents : `Mapping`
    The key-value pairs that should be present in ``genericMap``
msg : `str`
    Error message suffix describing test parameters

Definition at line 286 of file testUtils.py.

     def checkContents(self, genericMap, contents, msg=""):
         """Check the contents of a GenericMap.
  
         Parameters
         ----------
         genericMap : `lsst.afw.typehandling.GenericMap`
             The map to test.
         contents : `Mapping`
             The key-value pairs that should be present in ``genericMap``
         msg : `str`
             Error message suffix describing test parameters
         """
         for key, value in contents.items():
             self.assertEqual(genericMap[key], value, msg=msg)
  
         keyType = genericMap.dtype
         for key in (keyType(key) for key in range(30) if keyType(key) not in contents):
             with self.assertRaises(KeyError, msg=msg):
                 genericMap[key]
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError):
             genericMap[wrongType(0)]
  

◆ checkFromKeys()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkFromKeys	(	self,
		mapClass,
		keys,
		value,
		msg = `""`
	)

inherited

Check initialization using the ``fromkeys`` factory.

Parameters
----------
mapClass: `lsst.afw.typehandling.GenericMap`-type
    The class whose ``fromkeys`` method will be tested.
keys : `iterable`
    The keys to insert into the map.
value
    A legal value for a GenericMap.
msg : `str`
    Error message suffix describing test parameters

Definition at line 244 of file testUtils.py.

     def checkFromKeys(self, mapClass, keys, value, msg=""):
         """Check initialization using the ``fromkeys`` factory.
  
         Parameters
         ----------
         mapClass: `lsst.afw.typehandling.GenericMap`-type
             The class whose ``fromkeys`` method will be tested.
         keys : `iterable`
             The keys to insert into the map.
         value
             A legal value for a GenericMap.
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = mapClass.fromkeys(keys, value)
         self.assertIsInstance(genericMap, mapClass, msg=msg)
         self.checkContents(genericMap, dict.fromkeys(keys, value), msg=msg)
  

◆ checkFromKeysDefault()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkFromKeysDefault	(	self,
		mapClass,
		keys,
		msg = `""`
	)

inherited

Check initialization using the ``fromkeys`` factory.

Unlike `checkFromKeys`, this method lets ``fromkeys`` use its default
value (which may give different behavior, in nonconforming
implementations, from explicitly passing `None`).

Parameters
----------
mapClass: `lsst.afw.typehandling.GenericMap`-type
    The class whose ``fromkeys`` method will be tested.
keys : `iterable`
    The keys to insert into the map.
msg : `str`
    Error message suffix describing test parameters

Definition at line 224 of file testUtils.py.

     def checkFromKeysDefault(self, mapClass, keys, msg=""):
         """Check initialization using the ``fromkeys`` factory.
  
         Unlike `checkFromKeys`, this method lets ``fromkeys`` use its default
         value (which may give different behavior, in nonconforming
         implementations, from explicitly passing `None`).
  
         Parameters
         ----------
         mapClass: `lsst.afw.typehandling.GenericMap`-type
             The class whose ``fromkeys`` method will be tested.
         keys : `iterable`
             The keys to insert into the map.
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = mapClass.fromkeys(keys)
         self.assertIsInstance(genericMap, mapClass, msg=msg)
         self.checkContents(genericMap, dict.fromkeys(keys), msg=msg)
  

◆ checkGet()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkGet	(	self,
		genericMap,
		contents,
		msg = `""`
	)

inherited

Check that GenericMap.get works correctly.

Parameters
----------
genericMap : `lsst.afw.typehandling.GenericMap`
    The map to test.
contents : `Mapping`
    The key-value pairs that should be present in ``genericMap``
msg : `str`
    Error message suffix describing test parameters

Definition at line 310 of file testUtils.py.

     def checkGet(self, genericMap, contents, msg=""):
         """Check that GenericMap.get works correctly.
  
         Parameters
         ----------
         genericMap : `lsst.afw.typehandling.GenericMap`
             The map to test.
         contents : `Mapping`
             The key-value pairs that should be present in ``genericMap``
         msg : `str`
             Error message suffix describing test parameters
         """
         default = "Not a default value"
         for key, value in contents.items():
             self.assertEqual(genericMap.get(key), value, msg=msg)
             self.assertEqual(genericMap.get(key, default), value, msg=msg)
  
         keyType = genericMap.dtype
         for key in (keyType(key) for key in range(30) if keyType(key) not in contents):
             self.assertEqual(genericMap.get(key), None, msg=msg)
             self.assertEqual(genericMap.get(key, default), default, msg=msg)
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError):
             genericMap.get(wrongType(0))
  

◆ checkInitKwargs()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkInitKwargs	(	self,
		mapClass,
		contents,
		msg = `""`
	)

inherited

Check bulk insertion from keywords into a GenericMap.

Parameters
----------
mapClass: `lsst.afw.typehandling.GenericMapS`-type
    The class whose ``__init__`` method will be tested.
    Must allow string keys.
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 205 of file testUtils.py.

     def checkInitKwargs(self, mapClass, contents, msg=""):
         """Check bulk insertion from keywords into a GenericMap.
  
         Parameters
         ----------
         mapClass: `lsst.afw.typehandling.GenericMapS`-type
             The class whose ``__init__`` method will be tested.
             Must allow string keys.
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = mapClass(**contents)
         self.checkContents(genericMap, contents, msg=msg)
  
         with self.assertRaises(TypeError, msg=msg):
             mapClass(notAKey=GenericMapTestBaseClass.NotAStorable())
  

◆ checkInitMapping()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkInitMapping	(	self,
		mapClass,
		contents,
		msg = `""`
	)

inherited

Check initialization from a mapping.

Parameters
----------
mapClass : `lsst.afw.typehandling.GenericMap`-type
    The class whose ``__init__`` method will be tested.
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 153 of file testUtils.py.

     def checkInitMapping(self, mapClass, contents, msg=""):
         """Check initialization from a mapping.
  
         Parameters
         ----------
         mapClass : `lsst.afw.typehandling.GenericMap`-type
             The class whose ``__init__`` method will be tested.
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         for keyType in self.getValidKeys(mapClass):
             genericMap = mapClass(contents)
             self.checkContents(genericMap, contents, msg=msg)
  
             extraContents = {key: value for key, value in contents.items()}  # contents need not define copy()
             extraKey = keyType(101)
             extraValue = 'Extra value'
             extraContents[extraKey] = extraValue
             genericMap = mapClass(contents, **{keyType(101): extraValue})
             self.checkContents(genericMap, extraContents, msg=msg)
  
             with self.assertRaises(TypeError, msg=msg):
                 mapClass({keyType(0): GenericMapTestBaseClass.NotAStorable()})
  

◆ checkInitPairs()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkInitPairs	(	self,
		mapClass,
		contents,
		msg = `""`
	)

inherited

Check initialization from an iterable of pairs.

Parameters
----------
mapClass: `lsst.afw.typehandling.GenericMap`-type
    The class whose ``__init__`` method will be tested.
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 179 of file testUtils.py.

     def checkInitPairs(self, mapClass, contents, msg=""):
         """Check initialization from an iterable of pairs.
  
         Parameters
         ----------
         mapClass: `lsst.afw.typehandling.GenericMap`-type
             The class whose ``__init__`` method will be tested.
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         for keyType in self.getValidKeys(mapClass):
             genericMap = mapClass(contents.items())
             self.checkContents(genericMap, contents, msg=msg)
  
             extraContents = {key: value for key, value in contents.items()}  # contents need not define copy()
             extraKey = keyType(101)
             extraValue = 'Extra value'
             extraContents[extraKey] = extraValue
             genericMap = mapClass(contents.items(), **{keyType(101): extraValue})
             self.checkContents(genericMap, extraContents, msg=msg)
  
             with self.assertRaises(TypeError, msg=msg):
                 mapClass([(keyType(0), GenericMapTestBaseClass.NotAStorable())])
  

◆ checkInsertItem()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkInsertItem	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check element insertion in a GenericMap.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 430 of file testUtils.py.

     def checkInsertItem(self, mapFactory, contents, msg=""):
         """Check element insertion in a GenericMap.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = mapFactory()
  
         for length, (key, value) in enumerate(contents.items()):
             loopMsg = f"{msg} Inserting {key!r}={value!r}"
             genericMap[key] = value
             self.assertEqual(len(genericMap), length+1, msg=loopMsg)
             self.assertEqual(genericMap[key], value, msg=loopMsg)
  
         self.assertEqual(dict(genericMap), dict(contents), msg=msg)
  
         keyType = genericMap.dtype
         with self.assertRaises(TypeError, msg=msg):
             genericMap[keyType(0)] = GenericMapTestBaseClass.NotAStorable()
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError):
             genericMap[wrongType(0)] = 0
  

◆ checkIteration()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkIteration	(	self,
		genericMap,
		contents,
		msg = `""`
	)

inherited

Check the result of iterating over a GenericMap.

Parameters
----------
genericMap : `lsst.afw.typehandling.GenericMap`
    The map to test.
contents : `Mapping`
    The key-value pairs that should be present in ``genericMap``
msg : `str`
    Error message suffix describing test parameters

Definition at line 336 of file testUtils.py.

     def checkIteration(self, genericMap, contents, msg=""):
         """Check the result of iterating over a GenericMap.
  
         Parameters
         ----------
         genericMap : `lsst.afw.typehandling.GenericMap`
             The map to test.
         contents : `Mapping`
             The key-value pairs that should be present in ``genericMap``
         msg : `str`
             Error message suffix describing test parameters
         """
         self.assertEqual({key: genericMap[key] for key in genericMap}, dict(contents), msg=msg)
  

◆ checkMutableViews()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkMutableViews	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check that the views of a GenericMap update automatically.

This test supersedes `GenericMapTestBaseClass.checkViews`.

Parameters
----------
genericMap : `lsst.afw.typehandling.GenericMap`
    The map to test.
contents : `Mapping`
    The key-value pairs that should be present in ``genericMap``
msg : `str`
    Error message suffix describing test parameters

Definition at line 727 of file testUtils.py.

     def checkMutableViews(self, mapFactory, contents, msg=""):
         """Check that the views of a GenericMap update automatically.
  
         This test supersedes `GenericMapTestBaseClass.checkViews`.
  
         Parameters
         ----------
         genericMap : `lsst.afw.typehandling.GenericMap`
             The map to test.
         contents : `Mapping`
             The key-value pairs that should be present in ``genericMap``
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = mapFactory()
         keyView = genericMap.keys()
         valueView = genericMap.values()
         itemView = genericMap.items()
  
         for view in (keyView, valueView, itemView):
             self.assertEqual(len(view), len(genericMap), msg=msg)
         # is initial state correct?
         self.checkViews(genericMap, {}, msg)
  
         for key, value in contents.items():
             genericMap[key] = value
  
         for view in (keyView, valueView, itemView):
             self.assertEqual(len(view), len(genericMap), msg=msg)
         # is final state correct?
         self.checkViews(genericMap, contents, msg)

◆ checkPop()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkPop	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check that GenericMap.pop works correctly.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs initially occupying the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 642 of file testUtils.py.

     def checkPop(self, mapFactory, contents, msg=""):
         """Check that GenericMap.pop works correctly.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs initially occupying the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = self._fillMap(mapFactory, contents)
  
         keyType = genericMap.dtype
         with self.assertRaises(KeyError, msg=msg):
             genericMap.pop(keyType(2019))
  
         default = "This is a default"
         result = genericMap.pop(keyType(2019), default)
         self.assertEqual(dict(genericMap), dict(contents), msg=msg)
         self.assertEqual(result, default)
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError):
             genericMap.pop(wrongType(0))
  
         itemsToRemove = list(contents.items())
         np.random.shuffle(itemsToRemove)
         for numPrevious, (rawKey, value) in enumerate(itemsToRemove):
             key = keyType(rawKey)
             loopMsg = f"{msg} Popping {key}={value}"
             result = genericMap.pop(key)
             self.assertEqual(len(genericMap), len(contents)-numPrevious-1, msg=loopMsg)
             self.assertNotIn(key, genericMap, msg=loopMsg)
             self.assertEqual(result, value, msg=loopMsg)
  

◆ checkPopitem()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkPopitem	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check that GenericMap.popitem works correctly.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs initially occupying the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 680 of file testUtils.py.

     def checkPopitem(self, mapFactory, contents, msg=""):
         """Check that GenericMap.popitem works correctly.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs initially occupying the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = self._fillMap(mapFactory, contents)
  
         for numPrevious in range(len(genericMap)):
             key, value = genericMap.popitem()
             loopMsg = f"{msg} Popping {key}={value}"
             self.assertIn((key, value), contents.items(), msg=loopMsg)
             self.assertEqual(len(genericMap), len(contents)-numPrevious-1, msg=loopMsg)
             self.assertNotIn(key, genericMap, msg=loopMsg)
  
         with self.assertRaises(KeyError, msg=msg):
             genericMap.popitem()
  

◆ checkRemoveItem()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkRemoveItem	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check element removal from a GenericMap.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs initially occupying the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 610 of file testUtils.py.

     def checkRemoveItem(self, mapFactory, contents, msg=""):
         """Check element removal from a GenericMap.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs initially occupying the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = self._fillMap(mapFactory, contents)
  
         keyType = genericMap.dtype
         with self.assertRaises(KeyError, msg=msg):
             del genericMap[keyType(2019)]
  
         keysToRemove = list(contents.keys())
         np.random.shuffle(keysToRemove)
         for numPrevious, rawKey in enumerate(keysToRemove):
             key = keyType(rawKey)
             loopMsg = f"{msg} Deleting {key!r}"
             del genericMap[key]
             self.assertEqual(len(genericMap), len(contents)-numPrevious-1, msg=loopMsg)
             self.assertNotIn(key, genericMap, msg=loopMsg)
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError):
             del genericMap[wrongType(0)]
  

◆ checkReplaceItem()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkReplaceItem	(	self,
		genericMap,
		msg = `""`
	)

Check element replacement in a GenericMap.

Parameters
----------
genericMap : `lsst.afw.typehandling.GenericMap`
    The map to test. Must be empty.
msg : `str`
    Error message suffix describing test parameters

Definition at line 585 of file testUtils.py.

     def checkReplaceItem(self, genericMap, msg=""):
         """Check element replacement in a GenericMap.
  
         Parameters
         ----------
         genericMap : `lsst.afw.typehandling.GenericMap`
             The map to test. Must be empty.
         msg : `str`
             Error message suffix describing test parameters
         """
         self.assertFalse(genericMap, msg=msg)
         keyType = genericMap.dtype
         key = keyType(42)
  
         for value in self.getTestData(keyType).values():
             loopMsg = f"{msg} Inserting {key!r}={value!r}"
             genericMap[key] = value  # value may be of a different type
             self.assertEqual(len(genericMap), 1, msg=loopMsg)
             self.assertEqual(genericMap[key], value, msg=loopMsg)
  
         self.assertEqual(dict(genericMap), {key: value}, msg=msg)
  
         with self.assertRaises(TypeError, msg=msg):
             genericMap[key] = GenericMapTestBaseClass.NotAStorable()
  

◆ checkSetdefault()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkSetdefault	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check that GenericMap.setdefault works correctly.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 461 of file testUtils.py.

     def checkSetdefault(self, mapFactory, contents, msg=""):
         """Check that GenericMap.setdefault works correctly.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = mapFactory()
  
         keyType = genericMap.dtype
         result = genericMap.setdefault(keyType(0))
         self.assertEqual(len(genericMap), 1, msg=msg)
         self.assertIsNone(result, msg=msg)
         self.assertIsNone(genericMap[keyType(0)], msg=msg)
         del genericMap[keyType(0)]
  
         default = "This is a default"
         for length, (key, _) in enumerate(contents.items()):
             loopMsg = f"{msg} Defaulting {key!r}"
             result = genericMap.setdefault(key, default)
             self.assertEqual(len(genericMap), length+1, msg=loopMsg)
             self.assertEqual(result, default, msg=loopMsg)
             self.assertEqual(genericMap[key], default, msg=loopMsg)
  
         self.assertEqual(genericMap.keys(), contents.keys(), msg=msg)
  
         with self.assertRaises(TypeError, msg=msg):
             genericMap.setdefault(keyType(100), GenericMapTestBaseClass.NotAStorable())
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError):
             genericMap.setdefault(wrongType(0), default)
  
         genericMap = self._fillMap(mapFactory, contents)
         for length, (key, value) in enumerate(contents.items()):
             loopMsg = f"{msg} Defaulting existing {key!r}={value!r}"
             result = genericMap.setdefault(key, default)
             self.assertEqual(len(genericMap), len(contents), msg=loopMsg)
             self.assertEqual(result, contents[key], msg=loopMsg)
             self.assertEqual(genericMap[key], contents[key], msg=loopMsg)
  

◆ checkUpdateKwargs()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkUpdateKwargs	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check bulk insertion from keywords into a GenericMap.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
    Must allow string keys.
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 562 of file testUtils.py.

     def checkUpdateKwargs(self, mapFactory, contents, msg=""):
         """Check bulk insertion from keywords into a GenericMap.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
             Must allow string keys.
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = self._fillPartialMap(mapFactory, dict.fromkeys(contents, 0), len(contents)/2)
         self.assertLess(len(genericMap), len(contents), msg=msg)
  
         genericMap.update(**contents)
         self.assertEqual(dict(genericMap), dict(contents), msg=msg)
  
         with self.assertRaises(TypeError, msg=msg):
             genericMap.update(notAKey=GenericMapTestBaseClass.NotAStorable())
  

◆ checkUpdateMapping()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkUpdateMapping	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check bulk insertion from a mapping into a GenericMap.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 508 of file testUtils.py.

     def checkUpdateMapping(self, mapFactory, contents, msg=""):
         """Check bulk insertion from a mapping into a GenericMap.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = self._fillPartialMap(mapFactory, dict.fromkeys(contents, 0), len(contents)/2)
         self.assertLess(len(genericMap), len(contents), msg=msg)
  
         genericMap.update(contents)
         self.assertEqual(dict(genericMap), dict(contents), msg=msg)
  
         keyType = genericMap.dtype
         with self.assertRaises(TypeError, msg=msg):
             genericMap.update({keyType(0): GenericMapTestBaseClass.NotAStorable()})
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError, msg=msg):
             genericMap.update({wrongType(0): 0})
  

◆ checkUpdatePairs()

def lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass.checkUpdatePairs	(	self,
		mapFactory,
		contents,
		msg = `""`
	)

Check bulk insertion from an iterable of pairs into a GenericMap.

Parameters
----------
mapFactory : callable
    A zero-argument callable that creates an empty
    `lsst.afw.typehandling.GenericMap` object of the type to be tested
contents : `Mapping`
    The key-value pairs to insert into the map
msg : `str`
    Error message suffix describing test parameters

Definition at line 535 of file testUtils.py.

     def checkUpdatePairs(self, mapFactory, contents, msg=""):
         """Check bulk insertion from an iterable of pairs into a GenericMap.
  
         Parameters
         ----------
         mapFactory : callable
             A zero-argument callable that creates an empty
             `lsst.afw.typehandling.GenericMap` object of the type to be tested
         contents : `Mapping`
             The key-value pairs to insert into the map
         msg : `str`
             Error message suffix describing test parameters
         """
         genericMap = self._fillPartialMap(mapFactory, dict.fromkeys(contents, 0), len(contents)/2)
         self.assertLess(len(genericMap), len(contents), msg=msg)
  
         genericMap.update(contents.items())
         self.assertEqual(dict(genericMap), dict(contents), msg=msg)
  
         keyType = genericMap.dtype
         with self.assertRaises(TypeError, msg=msg):
             genericMap.update([(keyType(0), GenericMapTestBaseClass.NotAStorable())])
  
         wrongType = float if keyType is not float else int
         with self.assertRaises(TypeError, msg=msg):
             genericMap.update([(wrongType(0), 0)])
  

◆ checkViews()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.checkViews	(	self,
		genericMap,
		contents,
		msg = `""`
	)

inherited

Check the views provided by a GenericMap.

Parameters
----------
genericMap : `lsst.afw.typehandling.GenericMap`
    The map to test.
contents : `Mapping`
    The key-value pairs that should be present in ``genericMap``
msg : `str`
    Error message suffix describing test parameters

Definition at line 350 of file testUtils.py.

     def checkViews(self, genericMap, contents, msg=""):
         """Check the views provided by a GenericMap.
  
         Parameters
         ----------
         genericMap : `lsst.afw.typehandling.GenericMap`
             The map to test.
         contents : `Mapping`
             The key-value pairs that should be present in ``genericMap``
         msg : `str`
             Error message suffix describing test parameters
         """
         self.assertEqual(set(genericMap.keys()), set(contents.keys()), msg=msg)
         self.assertEqual(Counter(genericMap.values()), Counter(contents.values()), msg=msg)
         self.assertEqual(Counter(genericMap.items()), Counter(contents.items()), msg=msg)
  
  

◆ getTestData()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.getTestData	(	cls,
		keyClass
	)

inherited

Generic dataset for testing GenericMap classes that can handle it.

Parameters
----------
keyClass : `type`
    The type of key expected by the GenericMap.

Definition at line 96 of file testUtils.py.

     def getTestData(cls, keyClass):
         """Generic dataset for testing GenericMap classes that can handle it.
  
         Parameters
         ----------
         keyClass : `type`
             The type of key expected by the GenericMap.
         """
         return {keyClass(key): value for key, value in cls._testData.items()}
  

◆ getValidKeys()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.getValidKeys ( mapClass )

staticinherited

Return all keys suitable for a GenericMap.

Parameters
----------
mapClass : `type`
    A type object for a subclass of either `GenericMap` or a
    key-specific specialization.

Returns
-------
keyTypes: `set` [`type`]
    The types that can be used as keys. If ``mapClass`` is a
    key-specific specialization, this set will contain exactly
    one type.

Definition at line 107 of file testUtils.py.

     def getValidKeys(mapClass):
         """Return all keys suitable for a GenericMap.
  
         Parameters
         ----------
         mapClass : `type`
             A type object for a subclass of either `GenericMap` or a
             key-specific specialization.
  
         Returns
         -------
         keyTypes: `set` [`type`]
             The types that can be used as keys. If ``mapClass`` is a
             key-specific specialization, this set will contain exactly
             one type.
         """
         try:
             return {mapClass.dtype}
         except AttributeError:
             return {cls.dtype for cls in mapClass.__subclasses__()}
  

◆ setUp()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.setUp ( self )

inherited

Set up a test

Subclasses must call this method if they override setUp.

Definition at line 128 of file testUtils.py.

     def setUp(self):
         """Set up a test
  
         Subclasses must call this method if they override setUp.
         """
         super().setUp()
         # tell unittest to use the msg argument of asserts as a supplement
         # to the error message, rather than as the whole error message
         self.longMessage = True
  

Member Data Documentation

◆ longMessage

lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.longMessage

inherited

Definition at line 136 of file testUtils.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-32-g5ddfab5d3+60ce4897b0/python/lsst/afw/typehandling/testUtils.py

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ checkClear()

◆ checkContains()

◆ checkContents()

◆ checkFromKeys()

◆ checkFromKeysDefault()

◆ checkGet()

◆ checkInitKwargs()

◆ checkInitMapping()

◆ checkInitPairs()

◆ checkInsertItem()

◆ checkIteration()

◆ checkMutableViews()

◆ checkPop()

◆ checkPopitem()

◆ checkRemoveItem()

◆ checkReplaceItem()

◆ checkSetdefault()

◆ checkUpdateKwargs()

◆ checkUpdateMapping()

◆ checkUpdatePairs()

◆ checkViews()

◆ getTestData()

◆ getValidKeys()

◆ setUp()

Member Data Documentation

◆ longMessage