LSST Applications  21.0.0-147-g0e635eb1+1acddb5be5,22.0.0+052faf71bd,22.0.0+1ea9a8b2b2,22.0.0+6312710a6c,22.0.0+729191ecac,22.0.0+7589c3a021,22.0.0+9f079a9461,22.0.1-1-g7d6de66+b8044ec9de,22.0.1-1-g87000a6+536b1ee016,22.0.1-1-g8e32f31+6312710a6c,22.0.1-10-gd060f87+016f7cdc03,22.0.1-12-g9c3108e+df145f6f68,22.0.1-16-g314fa6d+c825727ab8,22.0.1-19-g93a5c75+d23f2fb6d8,22.0.1-19-gb93eaa13+aab3ef7709,22.0.1-2-g8ef0a89+b8044ec9de,22.0.1-2-g92698f7+9f079a9461,22.0.1-2-ga9b0f51+052faf71bd,22.0.1-2-gac51dbf+052faf71bd,22.0.1-2-gb66926d+6312710a6c,22.0.1-2-gcb770ba+09e3807989,22.0.1-20-g32debb5+b8044ec9de,22.0.1-23-gc2439a9a+fb0756638e,22.0.1-3-g496fd5d+09117f784f,22.0.1-3-g59f966b+1e6ba2c031,22.0.1-3-g849a1b8+f8b568069f,22.0.1-3-gaaec9c0+c5c846a8b1,22.0.1-32-g5ddfab5d3+60ce4897b0,22.0.1-4-g037fbe1+64e601228d,22.0.1-4-g8623105+b8044ec9de,22.0.1-5-g096abc9+d18c45d440,22.0.1-5-g15c806e+57f5c03693,22.0.1-7-gba73697+57f5c03693,master-g6e05de7fdc+c1283a92b8,master-g72cdda8301+729191ecac,w.2021.39
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 
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 
std::vector< SchemaItem< Flag > > * items

◆ 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: