Coverage for tests/test_PropertySet_2.py : 6%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1#
2# LSST Data Management System
3#
4# Copyright 2008-2017 AURA/LSST.
5#
6# This product includes software developed by the
7# LSST Project (http://www.lsst.org/).
8#
9# This program is free software: you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation, either version 3 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the LSST License Statement and
20# the GNU General Public License along with this program. If not,
21# see <http://www.lsstcorp.org/LegalNotices/>.
22#
24import pickle
25import unittest
27import numpy as np
29import lsst.utils.tests
30import lsst.daf.base as dafBase
31import lsst.pex.exceptions as pexExcept
34class PropertySetTestCase(unittest.TestCase):
35 """A test case for PropertySet.
36 """
38 def testConstruct(self):
39 ps = dafBase.PropertySet()
40 self.assertIsNotNone(ps)
42 def checkPickle(self, original):
43 new = pickle.loads(pickle.dumps(original, 4))
44 self.assertEqual(new, original)
46 def testScalar(self):
47 ps = dafBase.PropertySet()
48 ps.setBool("bool", True)
49 ps.setShort("short", 42)
50 ps.setInt("int", 2008)
51 ps.setLongLong("int64_t", 0xfeeddeadbeef)
52 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
53 ps.setFloat("float", 3.14159)
54 ps.setDouble("double", 2.718281828459045)
55 ps.set("char*", "foo")
56 ps.setString("string", "bar")
57 ps.set("char*", u"foo")
58 ps.setString("string", u"bar")
59 ps.set("int2", 2009)
60 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
61 ps.set("blank", "")
62 ps.set("undef", None)
64 self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
65 self.assertEqual(ps.getBool("bool"), True)
66 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
67 self.assertEqual(ps.getShort("short"), 42)
68 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
69 self.assertEqual(ps.getInt("int"), 2008)
70 self.assertEqual(ps.typeOf("int64_t"),
71 dafBase.PropertySet.TYPE_LongLong)
72 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
73 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
74 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
75 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
76 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
77 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
78 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
79 self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
80 self.assertEqual(ps.getString("char*"), "foo")
81 self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
82 self.assertEqual(ps.getString("string"), "bar")
83 self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
84 self.assertEqual(ps.getInt("int2"), 2009)
85 self.assertEqual(ps.get("int2"), 2009)
86 self.assertEqual(ps["int2"], 2009)
87 self.assertEqual(ps.getArray("int2"), [2009])
88 self.assertEqual(ps.getScalar("int2"), 2009)
89 self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
90 self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
91 self.assertEqual(ps.getString("blank"), "")
92 self.assertEqual(ps.valueCount(), 13)
94 self.assertIsNone(ps.getScalar("undef"))
95 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_Undef)
96 self.assertIsNone(ps.get("undef"))
98 self.checkPickle(ps)
100 # Now replace the undef value with a defined value
101 ps.set("undef", "not undefined")
102 self.assertEqual(ps.getScalar("undef"), "not undefined")
103 self.assertFalse(ps.isUndefined("undef"))
104 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_String)
106 def testNumPyScalars(self):
107 """Test that we can also pass NumPy array scalars to PropertySet
108 setters.
109 """
110 ps = dafBase.PropertySet()
111 ps.setShort("short", np.int16(42))
112 ps.setInt("int", np.int32(2008))
113 ps.setLongLong("int64_t", np.int64(0xfeeddeadbeef))
114 ps.setUnsignedLongLong("uint64_t", np.uint64(0xFFFFFFFFFFFFFFFF))
115 ps.setFloat("float", np.float32(3.14159))
116 ps.setDouble("double", np.float64(2.718281828459045))
117 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
118 self.assertEqual(ps.getShort("short"), 42)
119 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
120 self.assertEqual(ps.getInt("int"), 2008)
121 self.assertEqual(ps.typeOf("int64_t"),
122 dafBase.PropertySet.TYPE_LongLong)
123 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
124 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
125 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
126 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
127 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
128 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
129 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
130 self.assertEqual(ps.valueCount(), 6)
131 self.checkPickle(ps)
133 def testGetDefault(self):
134 ps = dafBase.PropertySet()
135 ps.setInt("int", 42)
136 self.assertEqual(ps.getInt("int"), 42)
137 self.assertEqual(ps.getInt("int", 2008), 42)
138 self.assertEqual(ps.getInt("foo", 2008), 2008)
139 self.assertEqual(ps.get("int"), 42)
140 self.assertEqual(ps.get("int", 2008), 42)
141 self.assertEqual(ps.get("foo", 2008), 2008)
142 self.assertEqual(ps.get("foo2", default="missing"), "missing")
143 self.assertIsNone(ps.get("foo"))
144 self.checkPickle(ps)
146 def testExists(self):
147 ps = dafBase.PropertySet()
148 ps.setInt("int", 42)
149 self.checkPickle(ps)
150 self.assertEqual(ps.exists("int"), True)
151 self.assertEqual(ps.exists("foo"), False)
153 def testGetVector(self):
154 ps = dafBase.PropertySet()
155 v = [42, 2008, 1]
156 ps.setInt("ints", v)
157 ps.setInt("ints2", [10, 9, 8])
158 w = ps.getArrayInt("ints")
159 self.assertEqual(len(w), 3)
160 self.assertEqual(v, w)
161 self.assertEqual(ps.getInt("ints2"), 8)
162 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
163 self.assertEqual(ps.getArray("ints"), v)
164 self.assertEqual(ps.getScalar("ints"), v[-1])
165 self.assertEqual(ps["ints"], v[-1])
166 self.assertEqual(ps.valueCount(), 6)
167 ps.setInt("int", 999)
168 x = ps.get("int")
169 self.assertEqual(x, 999)
170 self.assertEqual(ps.getArray("int"), [999])
171 self.assertEqual(ps.getScalar("int"), 999)
172 self.assertEqual(ps["int"], 999)
173 self.assertEqual(ps.valueCount(), 7)
174 self.checkPickle(ps)
176 def testGetVector2(self):
177 ps = dafBase.PropertySet()
178 v = [42, 2008, 1]
179 ps.setInt("ints", v)
180 ps.setInt("ints2", [10, 9, 8])
181 w = ps.getArrayInt("ints")
182 self.assertEqual(len(w), 3)
183 self.assertEqual(v[0], w[0])
184 self.assertEqual(v[1], w[1])
185 self.assertEqual(v[2], w[2])
186 self.assertEqual(ps.getInt("ints2"), 8)
187 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
188 self.checkPickle(ps)
190 def testAddScalar(self):
191 ps = dafBase.PropertySet()
192 v = [42, 2008, 1]
193 ps.setInt("ints", v)
194 ps.addInt("ints", -999)
195 ps.add("other", "foo")
196 ps.add("ints", 13)
197 w = ps.getArrayInt("ints")
198 self.assertEqual(len(w), 5)
199 self.assertEqual(v[0], w[0])
200 self.assertEqual(v[1], w[1])
201 self.assertEqual(v[2], w[2])
202 self.assertEqual(w[3], -999)
203 self.assertEqual(w[4], 13)
204 self.assertEqual(ps.getString("other"), "foo")
205 self.assertEqual(ps.valueCount(), 6)
206 self.checkPickle(ps)
208 def testSetAddVector(self):
209 ps = dafBase.PropertySet()
210 boolArr = [True, False]
211 intArr = [1, -1, 2]
212 floatArr = [1.2, 99.5, -35.1]
213 strArr = ["this", "is", "some strings"]
214 ps.set("bools", boolArr)
215 ps.set("ints", intArr)
216 ps.set("floats", floatArr)
217 ps.set("strs", strArr)
218 self.assertEqual(ps.get("bools"), boolArr[-1])
219 self.assertEqual(ps.getArray("bools"), boolArr)
220 self.assertEqual(ps.getScalar("bools"), boolArr[-1])
221 self.assertEqual(ps.get("ints"), intArr[-1])
222 self.assertEqual(ps.getArray("ints"), intArr)
223 self.assertEqual(ps.getScalar("ints"), intArr[-1])
224 self.assertEqual(ps.get("floats"), floatArr[-1])
225 self.assertEqual(ps.getArray("floats"), floatArr)
226 self.assertEqual(ps.getScalar("floats"), floatArr[-1])
227 self.assertEqual(ps.get("strs"), strArr[-1])
228 self.assertEqual(ps.getArray("strs"), strArr)
229 self.assertEqual(ps.getScalar("strs"), strArr[-1])
230 self.assertEqual(ps.valueCount(), 11)
232 ps.add("bools", list(reversed(boolArr)))
233 ps.add("ints", list(reversed(intArr)))
234 ps.add("floats", list(reversed(floatArr)))
235 ps.add("strs", list(reversed(strArr)))
236 self.assertEqual(ps.get("bools"), boolArr[0])
237 self.assertEqual(ps.getArray("bools"), boolArr + list(reversed(boolArr)))
238 self.assertEqual(ps.getScalar("bools"), boolArr[0])
239 self.assertEqual(ps.get("ints"), intArr[0])
240 self.assertEqual(ps.getArray("ints"), intArr + list(reversed(intArr)))
241 self.assertEqual(ps.getScalar("ints"), intArr[0])
242 self.assertEqual(ps.get("floats"), floatArr[0])
243 self.assertEqual(ps.getArray("floats"), floatArr + list(reversed(floatArr)))
244 self.assertEqual(ps.getScalar("floats"), floatArr[0])
245 self.assertEqual(ps.get("strs"), strArr[0])
246 self.assertEqual(ps.getArray("strs"), strArr + list(reversed(strArr)))
247 self.assertEqual(ps.getScalar("strs"), strArr[0])
248 self.assertEqual(ps.valueCount(), 22)
249 self.checkPickle(ps)
251 def testDateTimeToString(self):
252 ps = dafBase.PropertySet()
253 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
254 self.assertEqual(ps.toString(),
255 "dt = 2009-04-02T07:26:39.314159265Z\n")
256 self.checkPickle(ps)
258 def testGetScalarThrow(self):
259 ps = dafBase.PropertySet()
260 ps.setBool("bool", True)
261 ps.setShort("short", 42)
262 ps.setInt("int", 2008)
263 with self.assertRaises(KeyError):
264 ps["foo"]
265 # This will not throw
266 self.assertIsNone(ps.get("foo"))
267 self.checkPickle(ps)
269 def testSubPS(self):
270 ps = dafBase.PropertySet()
271 ps1 = dafBase.PropertySet()
272 ps1.set("a", 1)
273 ps.setPropertySet("b", ps1)
274 self.assertEqual(ps.getArray("b"), ps1)
275 self.assertEqual(ps.getScalar("b"), ps1)
276 self.assertEqual(ps.get("b.a"), 1)
277 self.assertEqual(ps.getArray("b.a"), [1])
278 self.assertEqual(ps.getScalar("b.a"), 1)
279 self.assertEqual(ps.valueCount(), 1)
280 ps.set("c", ps1)
281 self.assertEqual(ps.getArray("c"), ps1)
282 self.assertEqual(ps.getScalar("c"), ps1)
283 self.assertEqual(ps.get("c.a"), 1)
284 self.assertEqual(ps.getArray("c.a"), [1])
285 self.assertEqual(ps.getScalar("c.a"), 1)
286 self.assertEqual(ps.valueCount(), 2)
287 ps.set("c.a", 2)
288 self.assertEqual(ps.get("b.a"), 2)
289 self.assertEqual(ps.getArray("b.a"), [2])
290 self.assertEqual(ps.getScalar("b.a"), 2)
291 self.assertEqual(ps.get("b").get("a"), 2)
292 self.assertEqual(ps.valueCount(), 2)
293 self.checkPickle(ps)
295 def testCopy(self):
296 dest = dafBase.PropertySet()
297 source = dafBase.PropertySet()
298 value1 = [1.5, 3.2]
299 source.set("srcItem1", value1)
300 dest.copy("destItem1", source, "srcItem1")
301 self.assertEqual(dest.get("destItem1"), value1[-1])
302 self.assertEqual(dest.getArray("destItem1"), value1)
303 self.assertEqual(dest.getScalar("destItem1"), value1[-1])
304 self.assertEqual(source.valueCount(), 2)
305 self.assertEqual(dest.valueCount(), 2)
307 # items are replaced, regardless of type
308 dest.set("destItem2", "string value")
309 value2 = [5, -4, 3]
310 source.set("srcItem2", value2)
311 dest.copy("destItem2", source, "srcItem2")
312 self.assertEqual(dest.get("destItem2"), value2[-1])
313 self.assertEqual(dest.getArray("destItem2"), value2)
314 self.assertEqual(dest.getScalar("destItem2"), value2[-1])
315 self.assertEqual(source.valueCount(), 5)
316 self.assertEqual(dest.valueCount(), 5)
318 # asScalar copies only the last value
319 dest.copy("destItem2Scalar", source, "srcItem2", asScalar=True)
320 self.assertEqual(dest.get("destItem2Scalar"), value2[-1])
321 self.assertEqual(dest.getArray("destItem2Scalar"), [value2[-1]])
322 self.assertEqual(dest.getScalar("destItem2Scalar"), value2[-1])
323 self.assertEqual(source.valueCount(), 5)
324 self.assertEqual(dest.valueCount(), 6)
327class FlatTestCase(unittest.TestCase):
328 """A test case for flattened PropertySets.
329 """
331 def testConstruct(self):
332 ps = dafBase.PropertySet(flat=True)
333 self.assertIsNotNone(ps)
335 def testScalar(self):
336 ps = dafBase.PropertySet(flat=True)
337 ps.setBool("bool", True)
338 ps.setShort("short", 42)
339 ps.setInt("int", 2008)
340 ps.setLongLong("int64_t", 0xfeeddeadbeef)
341 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
342 ps.setFloat("float", 3.14159)
343 ps.setDouble("double", 2.718281828459045)
344 ps.set("char*", "foo")
345 ps.setString("string", "bar")
346 ps.set("int2", 2009)
347 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
348 ps.set("autobool", True)
350 self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
351 self.assertIs(ps.getBool("bool"), True)
352 self.assertIs(ps.get("bool"), True)
353 self.assertEqual(ps.getArray("bool"), [True])
354 self.assertIs(ps.getScalar("bool"), True)
355 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
356 self.assertEqual(ps.getShort("short"), 42)
357 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
358 self.assertEqual(ps.getInt("int"), 2008)
359 self.assertEqual(ps.typeOf("int64_t"),
360 dafBase.PropertySet.TYPE_LongLong)
361 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
362 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
363 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
364 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
365 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
366 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
367 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
368 self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
369 self.assertEqual(ps.getString("char*"), "foo")
370 self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
371 self.assertEqual(ps.getString("string"), "bar")
372 self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
373 self.assertEqual(ps.getInt("int2"), 2009)
374 self.assertEqual(ps.get("int2"), 2009)
375 self.assertEqual(ps.getArray("int2"), [2009])
376 self.assertEqual(ps.getScalar("int2"), 2009)
377 self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
378 self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
379 self.assertEqual(ps.typeOf("autobool"), dafBase.PropertySet.TYPE_Bool)
380 self.assertIs(ps.get("autobool"), True)
381 self.assertEqual(ps.getArray("autobool"), [True])
382 self.assertIs(ps.getScalar("autobool"), True)
384 def testGetDefault(self):
385 ps = dafBase.PropertySet(flat=True)
386 ps.setInt("int", 42)
387 self.assertEqual(ps.getInt("int"), 42)
388 self.assertEqual(ps.getInt("int", 2008), 42)
389 self.assertEqual(ps.getInt("foo", 2008), 2008)
391 def testExists(self):
392 ps = dafBase.PropertySet(flat=True)
393 ps.setInt("int", 42)
394 self.assertEqual(ps.exists("int"), True)
395 self.assertEqual(ps.exists("foo"), False)
397 def testGetVector(self):
398 ps = dafBase.PropertySet(flat=True)
399 v = [42, 2008, 1]
400 ps.setInt("ints", v)
401 ps.setInt("ints2", [10, 9, 8])
402 w = ps.getArrayInt("ints")
403 self.assertEqual(len(w), 3)
404 self.assertEqual(v, w)
405 self.assertEqual(ps.getInt("ints2"), 8)
406 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
407 self.assertEqual(ps.getArray("ints"), v)
408 self.assertEqual(ps.getScalar("ints"), v[-1])
409 ps.setInt("int", 999)
410 x = ps.get("int")
411 self.assertEqual(x, 999)
412 self.assertEqual(ps.getArray("int"), [999])
413 self.assertEqual(ps.getScalar("int"), 999)
415 def testGetVector2(self):
416 ps = dafBase.PropertySet(flat=True)
417 v = [42, 2008, 1]
418 ps.setInt("ints", v)
419 ps.setInt("ints2", [10, 9, 8])
420 w = ps.getArrayInt("ints")
421 self.assertEqual(w, v)
422 self.assertEqual(ps.getInt("ints2"), 8)
423 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
425 def testAddScalar(self):
426 ps = dafBase.PropertySet(flat=True)
427 v = [42, 2008, 1]
428 ps.setInt("ints", v)
429 ps.addInt("ints", -999)
430 ps.add("other", "foo")
431 ps.add("ints", 13)
432 w = ps.getArrayInt("ints")
433 self.assertEqual(len(w), 5)
434 self.assertEqual(v[0], w[0])
435 self.assertEqual(v[1], w[1])
436 self.assertEqual(v[2], w[2])
437 self.assertEqual(w[3], -999)
438 self.assertEqual(w[4], 13)
439 self.assertEqual(ps.getString("other"), "foo")
441 def testDateTimeToString(self):
442 ps = dafBase.PropertySet(flat=True)
443 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
444 self.assertEqual(ps.toString(),
445 "dt = 2009-04-02T07:26:39.314159265Z\n")
447 def testGetScalarThrow(self):
448 ps = dafBase.PropertySet(flat=True)
449 ps.setBool("bool", True)
450 ps.setShort("short", 42)
451 ps.setInt("int", 2008)
452 with self.assertRaises(KeyError):
453 ps["foo"]
454 self.assertIsNone(ps.get("foo"))
456 def testSubPS(self):
457 ps = dafBase.PropertySet(flat=True)
458 ps1 = dafBase.PropertySet()
459 ps1.set("a", 1)
460 ps1.add("a", 2)
461 ps1.set("foo", "bar")
462 ps.setPropertySet("b", ps1)
463 self.assertEqual(ps.exists("b.a"), True)
464 self.assertEqual(ps.get("b.a"), 2)
465 self.assertEqual(ps.getArray("b.a"), [1, 2])
466 self.assertEqual(ps.getScalar("b.a"), 2)
467 self.assertEqual(ps.exists("b"), False)
468 self.assertEqual(ps.exists("b.foo"), True)
469 self.assertEqual(ps.get("b.foo"), "bar")
470 self.assertEqual(ps.getArray("b.foo"), ["bar"])
471 self.assertEqual(ps.getScalar("b.foo"), "bar")
473 ps.set("b.c", 20)
474 self.assertEqual(ps.exists("b.c"), True)
475 self.assertEqual(ps.get("b.c"), 20)
476 self.assertEqual(ps.getArray("b.c"), [20])
477 self.assertEqual(ps.getScalar("b.c"), 20)
478 self.assertEqual(ps.exists("b"), False)
480 def testCombine(self):
481 ps = dafBase.PropertySet()
482 ps.set("ps1.pre", 1)
483 ps.set("ps1.pre", 1)
484 ps.set("ps1.post", 2)
485 ps.set("int", 42)
486 ps.set("double", 3.14)
487 ps.set("ps2.plus", 10.24)
488 ps.set("ps2.minus", -10.24)
489 ps.set("ps3.sub.subsub", "foo")
491 psp = dafBase.PropertySet()
492 psp.set("ps1.pre", 3)
493 psp.add("ps1.pre", 4)
494 psp.set("int", 2008)
495 psp.set("ps2.foo", "bar")
496 psp.set("ps4.top", "bottom")
498 ps.combine(psp)
500 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet)
501 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet)
502 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet)
503 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet)
504 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet)
506 self.assertFalse(ps.isArray("ps1"))
507 self.assertTrue(ps.isArray("ps1.pre"))
508 self.assertFalse(ps.isArray("ps1.post"))
509 self.assertFalse(ps.isArray("ps2"))
510 self.assertFalse(ps.isArray("ps2.plus"))
511 self.assertFalse(ps.isArray("ps2.minus"))
512 self.assertFalse(ps.isArray("ps2.foo"))
513 self.assertFalse(ps.isArray("ps3"))
514 self.assertFalse(ps.isArray("ps3.sub"))
515 self.assertFalse(ps.isArray("ps3.subsub"))
516 self.assertFalse(ps.isArray("ps4"))
517 self.assertFalse(ps.isArray("ps4.top"))
518 self.assertTrue(ps.isArray("int"))
519 self.assertFalse(ps.isArray("double"))
521 self.assertEqual(ps.valueCount("ps1.pre"), 3)
522 self.assertEqual(ps.valueCount("int"), 2)
523 self.assertEqual(ps.valueCount(), 12)
525 v = ps.getArray("ps1.pre")
526 self.assertEqual(v, [1, 3, 4])
527 v = ps.getArray("int")
528 self.assertEqual(v, [42, 2008])
530 def testUpdate(self):
531 ps = dafBase.PropertySet()
532 ps.set("ps1.pre", 1)
533 ps.set("ps1.pre", 1)
534 ps.set("ps1.post", 2)
535 ps.set("int", 42)
536 ps.set("double", 3.14)
537 ps.set("ps2.plus", 10.24)
538 ps.set("ps2.minus", -10.24)
539 ps.set("ps3.sub.subsub", "foo")
541 psp = dafBase.PropertySet()
542 psp.set("ps1.pre", 3)
543 psp.add("ps1.pre", 4)
544 psp.set("int", 2008)
545 psp.set("ps2.foo", "bar")
546 psp.set("ps4.top", "bottom")
548 ps.update(psp)
550 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet)
551 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet)
552 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet)
553 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet)
554 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet)
556 self.assertFalse(ps.isArray("ps1"))
557 self.assertTrue(ps.isArray("ps1.pre"))
558 self.assertFalse(ps.isArray("ps1.post"))
559 self.assertFalse(ps.isArray("ps2"))
560 self.assertFalse(ps.isArray("ps2.plus"))
561 self.assertFalse(ps.isArray("ps2.minus"))
562 self.assertFalse(ps.isArray("ps2.foo"))
563 self.assertFalse(ps.isArray("ps3"))
564 self.assertFalse(ps.isArray("ps3.sub"))
565 self.assertFalse(ps.isArray("ps3.subsub"))
566 self.assertFalse(ps.isArray("ps4"))
567 self.assertFalse(ps.isArray("ps4.top"))
568 self.assertFalse(ps.isArray("int"))
569 self.assertFalse(ps.isArray("double"))
571 self.assertEqual(ps.valueCount("ps1.pre"), 2)
572 self.assertEqual(ps.valueCount("int"), 1)
573 self.assertEqual(ps.valueCount(), 7)
575 v = ps.getArray("ps1.pre")
576 self.assertEqual(v, [3, 4])
577 v = ps.getArray("int")
578 self.assertEqual(v, [2008])
580 psd = {"int": 100, "str": "String", "apl1.foo": 10.5}
581 ps.update(psd)
582 self.assertEqual(ps["int"], psd["int"])
583 self.assertEqual(ps["str"], psd["str"])
584 self.assertEqual(ps["apl1.foo"], psd["apl1.foo"])
585 self.assertEqual(ps["double"], 3.14)
587 def testCombineThrow(self):
588 ps = dafBase.PropertySet()
589 ps.set("int", 42)
591 psp = dafBase.PropertySet()
592 psp.set("int", 3.14159)
594 with self.assertRaises(TypeError):
595 ps.combine(psp)
597 psd = {"bool": True}
598 with self.assertRaises(TypeError):
599 ps.combine(psd)
601 def testToDict(self):
602 ps = dafBase.PropertySet()
603 ps.setBool("bool", True)
604 ps.setShort("short", 42)
605 ps.setInt("int", 2008)
606 ps.setLongLong("int64_t", 0xfeeddeadbeef)
607 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
608 ps.setInt("ints", [10, 9, 8])
610 ps2 = dafBase.PropertySet()
611 ps2.set("ps", ps)
612 ps2.setFloat("float", 3.14159)
613 ps2.setDouble("double", 2.718281828459045)
614 ps2.set("char*", "foo")
615 ps2.setString("string", "bar")
616 ps2.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
617 ps2.set("undef", None)
619 d = ps2.toDict()
620 self.assertIsInstance(d, dict)
622 self.assertIsInstance(d["float"], float)
623 self.assertAlmostEqual(d["float"], 3.14159, 6)
624 self.assertIsInstance(d["double"], float)
625 self.assertEqual(d["double"], 2.718281828459045)
626 self.assertIsNone(d["undef"])
628 self.assertIsInstance(d["char*"], str)
629 self.assertEqual(d["char*"], "foo")
630 self.assertIsInstance(d["string"], str)
631 self.assertEqual(d["string"], "bar")
632 self.assertIsInstance(d["dt"], dafBase.DateTime)
633 self.assertEqual(d["dt"].nsecs(), 1238657233314159265)
635 d2 = d["ps"]
636 self.assertIsInstance(d2, dict)
638 self.assertIsInstance(d2["bool"], bool)
639 self.assertEqual(d2["bool"], True)
640 self.assertIsInstance(d2["short"], (int, int))
641 self.assertEqual(d2["short"], 42)
642 self.assertIsInstance(d2["int"], (int, int))
643 self.assertEqual(d2["int"], 2008)
644 self.assertIsInstance(d2["int64_t"], (int, int))
645 self.assertEqual(d2["int64_t"], 0xfeeddeadbeef)
646 self.assertIsInstance(d2["uint64_t"], (int, int))
647 self.assertEqual(d2["uint64_t"], 0xFFFFFFFFFFFFFFFF)
648 self.assertIsInstance(d2["ints"], list)
649 self.assertIsInstance(d2["ints"][0], (int, int))
650 self.assertEqual(d2["ints"], [10, 9, 8])
652 def testAddVector(self):
653 ps = dafBase.PropertySet()
654 v = [42, 2008, 1]
655 ps.set("ints", v)
657 vv = [-42, -2008, -1]
658 ps.add("ints", vv)
660 w = ps.getArray("ints")
661 self.assertEqual(w, v + vv)
663 def testArrayProperties(self):
664 ps = dafBase.PropertySet()
665 v = [42, 2008, 1]
666 ps.set("ints", v)
667 ps.set("int", 365)
668 ps.set("ints2", -42)
669 ps.add("ints2", -2008)
671 self.assertTrue(ps.isArray("ints"))
672 self.assertFalse(ps.isArray("int"))
673 self.assertTrue(ps.isArray("ints2"))
674 self.assertEqual(ps.valueCount("ints"), 3)
675 self.assertEqual(ps.valueCount("int"), 1)
676 self.assertEqual(ps.valueCount("ints2"), 2)
677 self.assertEqual(ps.valueCount(), 6)
678 self.assertEqual(ps.typeOf("ints"), dafBase.PropertySet.TYPE_Int)
679 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
680 self.assertEqual(ps.typeOf("ints2"), dafBase.PropertySet.TYPE_Int)
682 def testHierarchy(self):
683 ps = dafBase.PropertySet()
684 psp = dafBase.PropertySet()
686 psp.set("pre", 1)
687 ps.set("ps1", psp)
688 psp.set("post", 2)
689 ps.set("int", 42)
690 ps.set("ps2", dafBase.PropertySet())
691 ps.getPropertySet("ps2").set("plus", 10.24)
692 ps.set("ps2.minus", -10.24)
693 ps.set("ps3.sub1", "foo")
694 ps.set("ps3.sub2", "bar")
696 self.assertTrue(ps.exists("ps1"))
697 self.assertTrue(ps.exists("ps2"))
698 self.assertTrue(ps.exists("ps3"))
699 self.assertTrue(ps.exists("ps1.pre"))
700 self.assertTrue(ps.exists("ps1.post"))
701 self.assertTrue(ps.exists("ps2.plus"))
702 self.assertTrue(ps.exists("ps2.minus"))
703 self.assertTrue(ps.exists("ps3.sub1"))
704 self.assertTrue(ps.exists("ps3.sub2"))
706 self.assertTrue(ps.isPropertySetPtr("ps1"))
707 self.assertTrue(ps.isPropertySetPtr("ps2"))
708 self.assertTrue(ps.isPropertySetPtr("ps3"))
709 self.assertFalse(ps.isPropertySetPtr("int"))
710 self.assertFalse(ps.isPropertySetPtr("ps1.pre"))
711 self.assertFalse(ps.isPropertySetPtr("ps1.post"))
712 self.assertFalse(ps.isPropertySetPtr("ps2.plus"))
713 self.assertFalse(ps.isPropertySetPtr("ps2.minus"))
714 self.assertFalse(ps.isPropertySetPtr("ps3.sub1"))
715 self.assertFalse(ps.isPropertySetPtr("ps3.sub2"))
717 psp1 = ps.getPropertySet("ps1")
718 psp2 = ps.getPropertySet("ps2")
719 psp3 = ps.getPropertySet("ps3")
720 self.assertIsInstance(psp1, dafBase.PropertySet)
721 self.assertIsInstance(psp2, dafBase.PropertySet)
722 self.assertIsInstance(psp3, dafBase.PropertySet)
723 self.assertEqual(psp1, psp)
724 self.assertTrue(psp1.exists("pre"))
725 self.assertTrue(psp1.exists("post"))
726 self.assertTrue(psp2.exists("plus"))
727 self.assertTrue(psp2.exists("minus"))
728 self.assertTrue(psp3.exists("sub1"))
729 self.assertTrue(psp3.exists("sub2"))
730 self.assertEqual(psp1.getAsInt("pre"), 1)
731 self.assertEqual(psp1.getAsInt("post"), 2)
732 self.assertEqual(psp2.getAsDouble("plus"), 10.24)
733 self.assertEqual(psp2.getAsDouble("minus"), -10.24)
734 self.assertEqual(psp3.getAsString("sub1"), "foo")
735 self.assertEqual(psp3.getAsString("sub2"), "bar")
737 # Make sure checking a subproperty doesn't create it.
738 self.assertFalse(ps.exists("ps2.pre"))
739 self.assertFalse(ps.exists("ps2.pre"))
740 # Make sure checking an element doesn't create it.
741 self.assertFalse(ps.exists("ps4"))
742 self.assertFalse(ps.exists("ps4"))
743 # Make sure checking a subproperty with a nonexistent parent doesn't
744 # create it.
745 self.assertFalse(ps.exists("ps4.sub"))
746 self.assertFalse(ps.exists("ps4.sub"))
747 # Make sure checking a subproperty doesn't create its parent.
748 self.assertFalse(ps.exists("ps4"))
750#
751 def testvariousThrows(self):
752 ps = dafBase.PropertySet()
753 ps.set("int", 42)
754 with self.assertRaises(pexExcept.InvalidParameterError):
755 ps.set("int.sub", "foo")
756 with self.assertRaises(TypeError):
757 ps.getDouble("int")
758 with self.assertRaises(LookupError):
759 ps.getDouble("double")
760 with self.assertRaises(KeyError):
761 ps.getArray("double")
762 with self.assertRaises(LookupError):
763 ps.typeOf("double")
764 with self.assertRaises(TypeError):
765 ps.add("int", 4.2)
767 v = [3.14159, 2.71828]
768 with self.assertRaises(TypeError):
769 ps.add("int", v)
770 ps.remove("foo.bar")
771 ps.remove("int.sub")
773 def testIntegerRanges(self):
774 """Test that the ranges of the various integer types is as expected
775 """
776 ps = dafBase.PropertySet()
777 minI32 = -2**31
778 maxI32 = 2**31 - 1
779 minI64 = -2**63
780 maxI64 = 2**63 - 1
781 minU64 = 0
782 maxU64 = 2**64 - 1
783 # Out of range for the particular type
784 self.assertRaises(TypeError, ps.addInt, "int32", minI32 - 1)
785 self.assertRaises(TypeError, ps.addInt, "int32", maxI32 + 1)
786 self.assertRaises(TypeError, ps.addLongLong, "int64", minI64 - 1)
787 self.assertRaises(TypeError, ps.addLongLong, "int64", maxI64 + 1)
788 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", minU64 - 1)
789 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", maxU64 + 1)
790 # Out of all possible integer ranges
791 self.assertRaises(RuntimeError, ps.add, "number", minI64 - 1)
792 self.assertRaises(RuntimeError, ps.add, "number", maxU64 + 1)
794 def testNames(self):
795 ps = dafBase.PropertySet()
796 ps.set("ps1.pre", 1)
797 ps.set("ps1.post", 2)
798 ps.set("int", 42)
799 ps.set("double", 3.14)
800 ps.set("ps2.plus", 10.24)
801 ps.set("ps2.minus", -10.24)
803 self.assertEqual(ps.nameCount(), 4)
804 self.assertEqual(ps.nameCount(False), 8)
806 v = set(ps.names())
807 self.assertEqual(len(v), 4)
808 self.assertEqual(v, {"double", "int", "ps1", "ps2"})
809 v = set(ps.names(False))
810 self.assertEqual(len(v), 8)
811 self.assertEqual(v, {"double", "int", "ps1", "ps1.post",
812 "ps1.pre", "ps2", "ps2.minus", "ps2.plus"})
814 def testParamNames(self):
815 ps = dafBase.PropertySet()
816 ps.set("ps1.pre", 1)
817 ps.set("ps1.post", 2)
818 ps.set("int", 42)
819 ps.set("double", 3.14)
820 ps.set("ps2.plus", 10.24)
821 ps.set("ps2.minus", -10.24)
823 v = set(ps.paramNames())
824 self.assertEqual(len(v), 2)
825 self.assertEqual(v, {"double", "int"})
826 v = set(ps.paramNames(False))
827 self.assertEqual(len(v), 6)
828 self.assertEqual(v, {"double", "int", "ps1.post", "ps1.pre",
829 "ps2.minus", "ps2.plus"})
831 def testPropertySetNames(self):
832 ps = dafBase.PropertySet()
833 ps.set("ps1.pre", 1)
834 ps.set("ps1.post", 2)
835 ps.set("int", 42)
836 ps.set("double", 3.14)
837 ps.set("ps2.plus", 10.24)
838 ps.set("ps2.minus", -10.24)
839 ps.set("ps3.sub.subsub", "foo")
841 v = set(ps.propertySetNames())
842 self.assertEqual(len(v), 3)
843 self.assertEqual(v, {"ps1", "ps2", "ps3"})
844 v = set(ps.propertySetNames(False))
845 self.assertEqual(len(v), 4)
846 self.assertEqual(v, {"ps1", "ps2", "ps3", "ps3.sub"})
848 def testGetAs(self):
849 ps = dafBase.PropertySet()
850 ps.set("bool", True)
851 ps.setShort("short", 42)
852 ps.set("int", 2008)
853 ps.set("int64_t", 0xfeeddeadbeef)
854 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF)
855 f = 3.14159
856 ps.setFloat("float", f)
857 d = 2.718281828459045
858 ps.setDouble("double", d)
859 ps.setString("char*", "foo")
860 ps.set("char*2", "foo2")
861 ps.set("string", "bar")
862 psp = dafBase.PropertySet()
863 psp.set("bottom", "x")
864 ps.set("top", psp)
866 self.assertIs(ps.getAsBool("bool"), True)
867 self.assertEqual(ps.getAsInt("bool"), 1)
868 self.assertEqual(ps.getAsInt("short"), 42)
869 self.assertEqual(ps.getAsInt("int"), 2008)
870 with self.assertRaises(TypeError):
871 ps.getAsInt("int64_t")
872 with self.assertRaises(TypeError):
873 ps.getAsInt("uint64_t")
874 with self.assertRaises(TypeError):
875 ps.getAsInt64("uint64_t")
876 self.assertEqual(ps.getAsInt64("bool"), 1)
877 self.assertEqual(ps.getAsInt64("short"), 42)
878 self.assertEqual(ps.getAsInt64("int"), 2008)
879 self.assertEqual(ps.getAsInt64("int64_t"), 0xfeeddeadbeef)
880 self.assertEqual(ps.getAsUInt64("uint64_t"), 0xFFFFFFFFFFFFFFFF)
881 with self.assertRaises(TypeError):
882 ps.getAsInt64("float")
883 with self.assertRaises(TypeError):
884 ps.getAsUInt64("float")
885 self.assertEqual(ps.getAsDouble("bool"), 1.0)
886 self.assertEqual(ps.getAsDouble("short"), 42.0)
887 self.assertEqual(ps.getAsDouble("int"), 2008.0)
888 self.assertEqual(ps.getAsDouble("int64_t"),
889 float(0xfeeddeadbeef))
890 self.assertEqual(ps.getAsDouble("uint64_t"),
891 float(0xFFFFFFFFFFFFFFFF))
892 self.assertAlmostEqual(ps.getAsDouble("float"), 3.14159, places=5)
893 self.assertAlmostEqual(ps.getAsDouble("double"), 2.718281828459045, places=15)
894 with self.assertRaises(TypeError):
895 ps.getAsDouble("char*")
896 self.assertEqual(ps.getAsString("char*"), "foo")
897 self.assertEqual(ps.getAsString("char*2"), "foo2")
898 self.assertEqual(ps.getAsString("string"), "bar")
899 with self.assertRaises(TypeError):
900 ps.getAsString("int")
901 self.assertEqual(ps.getAsString("top.bottom"), "x")
902 self.assertEqual(ps.getAsPropertySetPtr("top"), psp)
903 with self.assertRaises(TypeError):
904 ps.getAsPropertySetPtr("top.bottom")
906 def testRemove(self):
907 ps = dafBase.PropertySet()
908 ps.set("int", 42)
909 ps.set("double", 3.14159)
910 ps.set("ps1.plus", 1)
911 ps.set("ps1.minus", -1)
912 ps.set("ps1.zero", 0)
913 self.assertEqual(ps.nameCount(False), 6)
915 ps.remove("int")
916 self.assertFalse(ps.exists("int"))
917 self.assertEqual(ps.getAsDouble("double"), 3.14159)
918 self.assertEqual(ps.getAsInt("ps1.plus"), 1)
919 self.assertEqual(ps.getAsInt("ps1.minus"), -1)
920 self.assertEqual(ps.getAsInt("ps1.zero"), 0)
921 self.assertEqual(ps.nameCount(False), 5)
923 ps.remove("ps1.zero")
924 self.assertFalse(ps.exists("int"))
925 self.assertEqual(ps.getAsDouble("double"), 3.14159)
926 self.assertFalse(ps.exists("ps1.zero"))
927 self.assertEqual(ps.getAsInt("ps1.plus"), 1)
928 self.assertEqual(ps.getAsInt("ps1.minus"), -1)
929 self.assertEqual(ps.nameCount(False), 4)
931 ps.remove("ps1")
932 self.assertFalse(ps.exists("int"))
933 self.assertEqual(ps.getAsDouble("double"), 3.14159)
934 self.assertFalse(ps.exists("ps1"))
935 self.assertFalse(ps.exists("ps1.plus"))
936 self.assertFalse(ps.exists("ps1.minus"))
937 self.assertFalse(ps.exists("ps1.zero"))
938 self.assertEqual(ps.nameCount(False), 1)
940 ps.remove("double")
941 self.assertFalse(ps.exists("int"))
942 self.assertFalse(ps.exists("double"))
943 self.assertFalse(ps.exists("ps1"))
944 self.assertFalse(ps.exists("ps1.plus"))
945 self.assertFalse(ps.exists("ps1.minus"))
946 self.assertFalse(ps.exists("ps1.zero"))
947 self.assertEqual(ps.nameCount(False), 0)
949 def testDeepCopy(self):
950 ps = dafBase.PropertySet()
951 ps.set("int", 42)
952 psp = dafBase.PropertySet()
953 psp.set("bottom", "x")
954 ps.set("top", psp)
956 psp2 = ps.deepCopy()
957 self.assertTrue(psp2.exists("int"))
958 self.assertTrue(psp2.exists("top.bottom"))
959 self.assertEqual(psp2.getAsInt("int"), 42)
960 self.assertEqual(psp2.getAsString("top.bottom"), "x")
961 # Make sure it was indeed a deep copy.
962 ps.set("int", 2008)
963 ps.set("top.bottom", "y")
964 self.assertEqual(ps.getAsInt("int"), 2008)
965 self.assertEqual(ps.getAsString("top.bottom"), "y")
966 self.assertEqual(psp.getAsString("bottom"), "y")
967 self.assertEqual(psp2.getAsInt("int"), 42)
968 self.assertEqual(psp2.getAsString("top.bottom"), "x")
970 def testToString(self):
971 ps = dafBase.PropertySet()
972 ps.set("bool", True)
973 s = 42
974 ps.setShort("short", s)
975 ps.set("int", 2008)
976 ps.set("int64_t", 0xfeeddeadbeef)
977 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF)
978 f = 3.14159
979 ps.setFloat("float", f)
980 d = 2.718281828459045
981 ps.setDouble("double", d)
982 ps.setString("char*", "foo")
983 ps.set("char*2", "foo2")
984 ps.set("string", "bar")
985 ps.set("ps1.pre", 1)
986 ps.set("ps1.post", 2)
987 ps.set("ps2.plus", 10.24)
988 ps.set("ps2.minus", -10.24)
989 ps.set("ps3.sub.subsub", "foo")
990 ps.add("v", 10)
991 ps.add("v", 9)
992 ps.add("v", 8)
994 self.assertEqual(ps.toString(),
995 "bool = 1\n"
996 "char* = \"foo\"\n"
997 "char*2 = \"foo2\"\n"
998 "double = 2.7182818284590\n"
999 "float = 3.141590\n"
1000 "int = 2008\n"
1001 "int64_t = 280297596632815\n"
1002 "ps1 = {\n"
1003 "..post = 2\n"
1004 "..pre = 1\n"
1005 "}\n"
1006 "ps2 = {\n"
1007 "..minus = -10.240000000000\n"
1008 "..plus = 10.240000000000\n"
1009 "}\n"
1010 "ps3 = {\n"
1011 "..sub = {\n"
1012 "....subsub = \"foo\"\n"
1013 "..}\n"
1014 "}\n"
1015 "short = 42\n"
1016 "string = \"bar\"\n"
1017 "uint64_t = 18446744073709551615\n"
1018 "v = [ 10, 9, 8 ]\n"
1019 )
1020 self.assertEqual(ps.toString(True),
1021 "bool = 1\n"
1022 "char* = \"foo\"\n"
1023 "char*2 = \"foo2\"\n"
1024 "double = 2.7182818284590\n"
1025 "float = 3.141590\n"
1026 "int = 2008\n"
1027 "int64_t = 280297596632815\n"
1028 "ps1 = { ... }\n"
1029 "ps2 = { ... }\n"
1030 "ps3 = { ... }\n"
1031 "short = 42\n"
1032 "string = \"bar\"\n"
1033 "uint64_t = 18446744073709551615\n"
1034 "v = [ 10, 9, 8 ]\n"
1035 )
1038class TestMemory(lsst.utils.tests.MemoryTestCase):
1039 pass
1042def setup_module(module):
1043 lsst.utils.tests.init()
1046if __name__ == "__main__": 1046 ↛ 1047line 1046 didn't jump to line 1047, because the condition on line 1046 was never true
1047 lsst.utils.tests.init()
1048 unittest.main()