LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Classes | Public Member Functions | Static Public Member Functions | Public Attributes | List of all members
lsst.afw.typehandling.testUtils.GenericMapTestBaseClass Class Reference
Inheritance diagram for lsst.afw.typehandling.testUtils.GenericMapTestBaseClass:
lsst.afw.typehandling.testUtils.MutableGenericMapTestBaseClass

Classes

class  ComplexStorable
 
class  NotAStorable
 
class  SimpleStorable
 

Public Member Functions

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.

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

This class is not *quite* a generic Mapping testbed, because it assumes
that the map being tested only accepts keys of a particular type, stored as
the `dtype` member.

Definition at line 33 of file testUtils.py.

Member Function Documentation

◆ checkContains()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 262 of file testUtils.py.

262  def checkContains(self, genericMap, contents, msg=""):
263  """Check the contents of a GenericMap.
264 
265  Parameters
266  ----------
267  genericMap : `lsst.afw.typehandling.GenericMap`
268  The map to test.
269  contents : `Mapping`
270  The key-value pairs that should be present in ``genericMap``
271  msg : `str`
272  Error message suffix describing test parameters
273  """
274  for key in contents:
275  self.assertIn(key, genericMap, msg=msg)
276 
277  keyType = genericMap.dtype
278  for key in range(30):
279  if keyType(key) not in contents:
280  self.assertNotIn(keyType(key), genericMap, msg=msg)
281 
282  wrongType = float if keyType is not float else int
283  with self.assertRaises(TypeError):
284  wrongType(0) in genericMap
285 

◆ checkContents()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 286 of file testUtils.py.

286  def checkContents(self, genericMap, contents, msg=""):
287  """Check the contents of a GenericMap.
288 
289  Parameters
290  ----------
291  genericMap : `lsst.afw.typehandling.GenericMap`
292  The map to test.
293  contents : `Mapping`
294  The key-value pairs that should be present in ``genericMap``
295  msg : `str`
296  Error message suffix describing test parameters
297  """
298  for key, value in contents.items():
299  self.assertEqual(genericMap[key], value, msg=msg)
300 
301  keyType = genericMap.dtype
302  for key in (keyType(key) for key in range(30) if keyType(key) not in contents):
303  with self.assertRaises(KeyError, msg=msg):
304  genericMap[key]
305 
306  wrongType = float if keyType is not float else int
307  with self.assertRaises(TypeError):
308  genericMap[wrongType(0)]
309 

◆ checkFromKeys()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 244 of file testUtils.py.

244  def checkFromKeys(self, mapClass, keys, value, msg=""):
245  """Check initialization using the ``fromkeys`` factory.
246 
247  Parameters
248  ----------
249  mapClass: `lsst.afw.typehandling.GenericMap`-type
250  The class whose ``fromkeys`` method will be tested.
251  keys : `iterable`
252  The keys to insert into the map.
253  value
254  A legal value for a GenericMap.
255  msg : `str`
256  Error message suffix describing test parameters
257  """
258  genericMap = mapClass.fromkeys(keys, value)
259  self.assertIsInstance(genericMap, mapClass, msg=msg)
260  self.checkContents(genericMap, dict.fromkeys(keys, value), msg=msg)
261 

◆ checkFromKeysDefault()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 224 of file testUtils.py.

224  def checkFromKeysDefault(self, mapClass, keys, msg=""):
225  """Check initialization using the ``fromkeys`` factory.
226 
227  Unlike `checkFromKeys`, this method lets ``fromkeys`` use its default
228  value (which may give different behavior, in nonconforming
229  implementations, from explicitly passing `None`).
230 
231  Parameters
232  ----------
233  mapClass: `lsst.afw.typehandling.GenericMap`-type
234  The class whose ``fromkeys`` method will be tested.
235  keys : `iterable`
236  The keys to insert into the map.
237  msg : `str`
238  Error message suffix describing test parameters
239  """
240  genericMap = mapClass.fromkeys(keys)
241  self.assertIsInstance(genericMap, mapClass, msg=msg)
242  self.checkContents(genericMap, dict.fromkeys(keys), msg=msg)
243 

◆ checkGet()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 310 of file testUtils.py.

310  def checkGet(self, genericMap, contents, msg=""):
311  """Check that GenericMap.get works correctly.
312 
313  Parameters
314  ----------
315  genericMap : `lsst.afw.typehandling.GenericMap`
316  The map to test.
317  contents : `Mapping`
318  The key-value pairs that should be present in ``genericMap``
319  msg : `str`
320  Error message suffix describing test parameters
321  """
322  default = "Not a default value"
323  for key, value in contents.items():
324  self.assertEqual(genericMap.get(key), value, msg=msg)
325  self.assertEqual(genericMap.get(key, default), value, msg=msg)
326 
327  keyType = genericMap.dtype
328  for key in (keyType(key) for key in range(30) if keyType(key) not in contents):
329  self.assertEqual(genericMap.get(key), None, msg=msg)
330  self.assertEqual(genericMap.get(key, default), default, msg=msg)
331 
332  wrongType = float if keyType is not float else int
333  with self.assertRaises(TypeError):
334  genericMap.get(wrongType(0))
335 

◆ checkInitKwargs()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 205 of file testUtils.py.

205  def checkInitKwargs(self, mapClass, contents, msg=""):
206  """Check bulk insertion from keywords into a GenericMap.
207 
208  Parameters
209  ----------
210  mapClass: `lsst.afw.typehandling.GenericMapS`-type
211  The class whose ``__init__`` method will be tested.
212  Must allow string keys.
213  contents : `Mapping`
214  The key-value pairs to insert into the map
215  msg : `str`
216  Error message suffix describing test parameters
217  """
218  genericMap = mapClass(**contents)
219  self.checkContents(genericMap, contents, msg=msg)
220 
221  with self.assertRaises(TypeError, msg=msg):
222  mapClass(notAKey=GenericMapTestBaseClass.NotAStorable())
223 

◆ checkInitMapping()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 153 of file testUtils.py.

153  def checkInitMapping(self, mapClass, contents, msg=""):
154  """Check initialization from a mapping.
155 
156  Parameters
157  ----------
158  mapClass : `lsst.afw.typehandling.GenericMap`-type
159  The class whose ``__init__`` method will be tested.
160  contents : `Mapping`
161  The key-value pairs to insert into the map
162  msg : `str`
163  Error message suffix describing test parameters
164  """
165  for keyType in self.getValidKeys(mapClass):
166  genericMap = mapClass(contents)
167  self.checkContents(genericMap, contents, msg=msg)
168 
169  extraContents = {key: value for key, value in contents.items()} # contents need not define copy()
170  extraKey = keyType(101)
171  extraValue = 'Extra value'
172  extraContents[extraKey] = extraValue
173  genericMap = mapClass(contents, **{keyType(101): extraValue})
174  self.checkContents(genericMap, extraContents, msg=msg)
175 
176  with self.assertRaises(TypeError, msg=msg):
177  mapClass({keyType(0): GenericMapTestBaseClass.NotAStorable()})
178 

◆ checkInitPairs()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 179 of file testUtils.py.

179  def checkInitPairs(self, mapClass, contents, msg=""):
180  """Check initialization from an iterable of pairs.
181 
182  Parameters
183  ----------
184  mapClass: `lsst.afw.typehandling.GenericMap`-type
185  The class whose ``__init__`` method will be tested.
186  contents : `Mapping`
187  The key-value pairs to insert into the map
188  msg : `str`
189  Error message suffix describing test parameters
190  """
191  for keyType in self.getValidKeys(mapClass):
192  genericMap = mapClass(contents.items())
193  self.checkContents(genericMap, contents, msg=msg)
194 
195  extraContents = {key: value for key, value in contents.items()} # contents need not define copy()
196  extraKey = keyType(101)
197  extraValue = 'Extra value'
198  extraContents[extraKey] = extraValue
199  genericMap = mapClass(contents.items(), **{keyType(101): extraValue})
200  self.checkContents(genericMap, extraContents, msg=msg)
201 
202  with self.assertRaises(TypeError, msg=msg):
203  mapClass([(keyType(0), GenericMapTestBaseClass.NotAStorable())])
204 

◆ checkIteration()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 336 of file testUtils.py.

336  def checkIteration(self, genericMap, contents, msg=""):
337  """Check the result of iterating over a GenericMap.
338 
339  Parameters
340  ----------
341  genericMap : `lsst.afw.typehandling.GenericMap`
342  The map to test.
343  contents : `Mapping`
344  The key-value pairs that should be present in ``genericMap``
345  msg : `str`
346  Error message suffix describing test parameters
347  """
348  self.assertEqual({key: genericMap[key] for key in genericMap}, dict(contents), msg=msg)
349 

◆ checkViews()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.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

Definition at line 350 of file testUtils.py.

350  def checkViews(self, genericMap, contents, msg=""):
351  """Check the views provided by a GenericMap.
352 
353  Parameters
354  ----------
355  genericMap : `lsst.afw.typehandling.GenericMap`
356  The map to test.
357  contents : `Mapping`
358  The key-value pairs that should be present in ``genericMap``
359  msg : `str`
360  Error message suffix describing test parameters
361  """
362  self.assertEqual(set(genericMap.keys()), set(contents.keys()), msg=msg)
363  self.assertEqual(Counter(genericMap.values()), Counter(contents.values()), msg=msg)
364  self.assertEqual(Counter(genericMap.items()), Counter(contents.items()), msg=msg)
365 
366 
set
daf::base::PropertySet * set
Definition: fits.cc:912

◆ getTestData()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.getTestData (   cls,
  keyClass 
) 
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.

96  def getTestData(cls, keyClass):
97  """Generic dataset for testing GenericMap classes that can handle it.
98 
99  Parameters
100  ----------
101  keyClass : `type`
102  The type of key expected by the GenericMap.
103  """
104  return {keyClass(key): value for key, value in cls._testData.items()}
105 
items
std::vector< SchemaItem< Flag > > * items
Definition: BaseColumnView.cc:142

◆ getValidKeys()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.getValidKeys (   mapClass)
static 
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.

107  def getValidKeys(mapClass):
108  """Return all keys suitable for a GenericMap.
109 
110  Parameters
111  ----------
112  mapClass : `type`
113  A type object for a subclass of either `GenericMap` or a
114  key-specific specialization.
115 
116  Returns
117  -------
118  keyTypes: `set` [`type`]
119  The types that can be used as keys. If ``mapClass`` is a
120  key-specific specialization, this set will contain exactly
121  one type.
122  """
123  try:
124  return {mapClass.dtype}
125  except AttributeError:
126  return {cls.dtype for cls in mapClass.__subclasses__()}
127 

◆ setUp()

def lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.setUp (   self) 
Set up a test

Subclasses must call this method if they override setUp.

Definition at line 128 of file testUtils.py.

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

Member Data Documentation

◆ longMessage

lsst.afw.typehandling.testUtils.GenericMapTestBaseClass.longMessage

Definition at line 136 of file testUtils.py.

The documentation for this class was generated from the following file:
Generated on Fri Nov 26 2021 10:16:17 for LSST Applications by doxygen 1.9.1