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."""
37 def testConstruct(self):
38 ps = dafBase.PropertySet()
39 self.assertIsNotNone(ps)
41 def checkPickle(self, original):
42 new = pickle.loads(pickle.dumps(original, 4))
43 self.assertEqual(new, original)
45 def testScalar(self):
46 ps = dafBase.PropertySet()
47 ps.setBool("bool", True)
48 ps.setShort("short", 42)
49 ps.setInt("int", 2008)
50 ps.setLongLong("int64_t", 0xfeeddeadbeef)
51 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
52 ps.setFloat("float", 3.14159)
53 ps.setDouble("double", 2.718281828459045)
54 ps.set("char*", "foo")
55 ps.setString("string", "bar")
56 ps.set("char*", u"foo")
57 ps.setString("string", u"bar")
58 ps.set("int2", 2009)
59 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
60 ps.set("blank", "")
61 ps.set("undef", None)
63 self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
64 self.assertEqual(ps.getBool("bool"), True)
65 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
66 self.assertEqual(ps.getShort("short"), 42)
67 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
68 self.assertEqual(ps.getInt("int"), 2008)
69 self.assertEqual(ps.typeOf("int64_t"),
70 dafBase.PropertySet.TYPE_LongLong)
71 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
72 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
73 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
74 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
75 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
76 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
77 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
78 self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
79 self.assertEqual(ps.getString("char*"), "foo")
80 self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
81 self.assertEqual(ps.getString("string"), "bar")
82 self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
83 self.assertEqual(ps.getInt("int2"), 2009)
84 self.assertEqual(ps.get("int2"), 2009)
85 self.assertEqual(ps["int2"], 2009)
86 self.assertEqual(ps.getArray("int2"), [2009])
87 self.assertEqual(ps.getScalar("int2"), 2009)
88 self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
89 self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
90 self.assertEqual(ps.getString("blank"), "")
92 self.assertIsNone(ps.getScalar("undef"))
93 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_Undef)
94 self.assertIsNone(ps.get("undef"))
96 self.checkPickle(ps)
98 # Now replace the undef value with a defined value
99 ps.set("undef", "not undefined")
100 self.assertEqual(ps.getScalar("undef"), "not undefined")
101 self.assertFalse(ps.isUndefined("undef"))
102 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_String)
104 def testNumPyScalars(self):
105 """Test that we can also pass NumPy array scalars to PropertySet
106 setters.
107 """
108 ps = dafBase.PropertySet()
109 ps.setShort("short", np.int16(42))
110 ps.setInt("int", np.int32(2008))
111 ps.setLongLong("int64_t", np.int64(0xfeeddeadbeef))
112 ps.setUnsignedLongLong("uint64_t", np.uint64(0xFFFFFFFFFFFFFFFF))
113 ps.setFloat("float", np.float32(3.14159))
114 ps.setDouble("double", np.float64(2.718281828459045))
115 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
116 self.assertEqual(ps.getShort("short"), 42)
117 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
118 self.assertEqual(ps.getInt("int"), 2008)
119 self.assertEqual(ps.typeOf("int64_t"),
120 dafBase.PropertySet.TYPE_LongLong)
121 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
122 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
123 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
124 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
125 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
126 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
127 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
128 self.checkPickle(ps)
130 def testGetDefault(self):
131 ps = dafBase.PropertySet()
132 ps.setInt("int", 42)
133 self.assertEqual(ps.getInt("int"), 42)
134 self.assertEqual(ps.getInt("int", 2008), 42)
135 self.assertEqual(ps.getInt("foo", 2008), 2008)
136 self.assertEqual(ps.get("int"), 42)
137 self.assertEqual(ps.get("int", 2008), 42)
138 self.assertEqual(ps.get("foo", 2008), 2008)
139 self.assertEqual(ps.get("foo2", default="missing"), "missing")
140 self.assertIsNone(ps.get("foo"))
141 self.checkPickle(ps)
143 def testExists(self):
144 ps = dafBase.PropertySet()
145 ps.setInt("int", 42)
146 self.checkPickle(ps)
147 self.assertEqual(ps.exists("int"), True)
148 self.assertEqual(ps.exists("foo"), False)
150 def testGetVector(self):
151 ps = dafBase.PropertySet()
152 v = [42, 2008, 1]
153 ps.setInt("ints", v)
154 ps.setInt("ints2", [10, 9, 8])
155 w = ps.getArrayInt("ints")
156 self.assertEqual(len(w), 3)
157 self.assertEqual(v, w)
158 self.assertEqual(ps.getInt("ints2"), 8)
159 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
160 self.assertEqual(ps.getArray("ints"), v)
161 self.assertEqual(ps.getScalar("ints"), v[-1])
162 self.assertEqual(ps["ints"], v[-1])
163 ps.setInt("int", 999)
164 x = ps.get("int")
165 self.assertEqual(x, 999)
166 self.assertEqual(ps.getArray("int"), [999])
167 self.assertEqual(ps.getScalar("int"), 999)
168 self.assertEqual(ps["int"], 999)
169 self.checkPickle(ps)
171 def testGetVector2(self):
172 ps = dafBase.PropertySet()
173 v = [42, 2008, 1]
174 ps.setInt("ints", v)
175 ps.setInt("ints2", [10, 9, 8])
176 w = ps.getArrayInt("ints")
177 self.assertEqual(len(w), 3)
178 self.assertEqual(v[0], w[0])
179 self.assertEqual(v[1], w[1])
180 self.assertEqual(v[2], w[2])
181 self.assertEqual(ps.getInt("ints2"), 8)
182 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
183 self.checkPickle(ps)
185 def testAddScalar(self):
186 ps = dafBase.PropertySet()
187 v = [42, 2008, 1]
188 ps.setInt("ints", v)
189 ps.addInt("ints", -999)
190 ps.add("other", "foo")
191 ps.add("ints", 13)
192 w = ps.getArrayInt("ints")
193 self.assertEqual(len(w), 5)
194 self.assertEqual(v[0], w[0])
195 self.assertEqual(v[1], w[1])
196 self.assertEqual(v[2], w[2])
197 self.assertEqual(w[3], -999)
198 self.assertEqual(w[4], 13)
199 self.assertEqual(ps.getString("other"), "foo")
200 self.checkPickle(ps)
202 def testSetAddVector(self):
203 ps = dafBase.PropertySet()
204 boolArr = [True, False]
205 intArr = [1, -1, 2]
206 floatArr = [1.2, 99.5, -35.1]
207 strArr = ["this", "is", "some strings"]
208 ps.set("bools", boolArr)
209 ps.set("ints", intArr)
210 ps.set("floats", floatArr)
211 ps.set("strs", strArr)
212 self.assertEqual(ps.get("bools"), boolArr[-1])
213 self.assertEqual(ps.getArray("bools"), boolArr)
214 self.assertEqual(ps.getScalar("bools"), boolArr[-1])
215 self.assertEqual(ps.get("ints"), intArr[-1])
216 self.assertEqual(ps.getArray("ints"), intArr)
217 self.assertEqual(ps.getScalar("ints"), intArr[-1])
218 self.assertEqual(ps.get("floats"), floatArr[-1])
219 self.assertEqual(ps.getArray("floats"), floatArr)
220 self.assertEqual(ps.getScalar("floats"), floatArr[-1])
221 self.assertEqual(ps.get("strs"), strArr[-1])
222 self.assertEqual(ps.getArray("strs"), strArr)
223 self.assertEqual(ps.getScalar("strs"), strArr[-1])
225 ps.add("bools", list(reversed(boolArr)))
226 ps.add("ints", list(reversed(intArr)))
227 ps.add("floats", list(reversed(floatArr)))
228 ps.add("strs", list(reversed(strArr)))
229 self.assertEqual(ps.get("bools"), boolArr[0])
230 self.assertEqual(ps.getArray("bools"), boolArr + list(reversed(boolArr)))
231 self.assertEqual(ps.getScalar("bools"), boolArr[0])
232 self.assertEqual(ps.get("ints"), intArr[0])
233 self.assertEqual(ps.getArray("ints"), intArr + list(reversed(intArr)))
234 self.assertEqual(ps.getScalar("ints"), intArr[0])
235 self.assertEqual(ps.get("floats"), floatArr[0])
236 self.assertEqual(ps.getArray("floats"), floatArr + list(reversed(floatArr)))
237 self.assertEqual(ps.getScalar("floats"), floatArr[0])
238 self.assertEqual(ps.get("strs"), strArr[0])
239 self.assertEqual(ps.getArray("strs"), strArr + list(reversed(strArr)))
240 self.assertEqual(ps.getScalar("strs"), strArr[0])
241 self.checkPickle(ps)
243 def testDateTimeToString(self):
244 ps = dafBase.PropertySet()
245 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
246 self.assertEqual(ps.toString(),
247 "dt = 2009-04-02T07:26:39.314159265Z\n")
248 self.checkPickle(ps)
250 def testGetScalarThrow(self):
251 ps = dafBase.PropertySet()
252 ps.setBool("bool", True)
253 ps.setShort("short", 42)
254 ps.setInt("int", 2008)
255 with self.assertRaises(KeyError):
256 ps["foo"]
257 # This will not throw
258 self.assertIsNone(ps.get("foo"))
259 self.checkPickle(ps)
261 def testSubPS(self):
262 ps = dafBase.PropertySet()
263 ps1 = dafBase.PropertySet()
264 ps1.set("a", 1)
265 ps.setPropertySet("b", ps1)
266 self.assertEqual(ps.getArray("b"), ps1)
267 self.assertEqual(ps.getScalar("b"), ps1)
268 self.assertEqual(ps.get("b.a"), 1)
269 self.assertEqual(ps.getArray("b.a"), [1])
270 self.assertEqual(ps.getScalar("b.a"), 1)
271 ps.set("c", ps1)
272 self.assertEqual(ps.getArray("c"), ps1)
273 self.assertEqual(ps.getScalar("c"), ps1)
274 self.assertEqual(ps.get("c.a"), 1)
275 self.assertEqual(ps.getArray("c.a"), [1])
276 self.assertEqual(ps.getScalar("c.a"), 1)
277 ps.set("c.a", 2)
278 self.assertEqual(ps.get("b.a"), 2)
279 self.assertEqual(ps.getArray("b.a"), [2])
280 self.assertEqual(ps.getScalar("b.a"), 2)
281 self.assertEqual(ps.get("b").get("a"), 2)
282 self.checkPickle(ps)
284 def testCopy(self):
285 dest = dafBase.PropertySet()
286 source = dafBase.PropertySet()
287 value1 = [1.5, 3.2]
288 source.set("srcItem1", value1)
289 dest.copy("destItem1", source, "srcItem1")
290 self.assertEqual(dest.get("destItem1"), value1[-1])
291 self.assertEqual(dest.getArray("destItem1"), value1)
292 self.assertEqual(dest.getScalar("destItem1"), value1[-1])
294 # items are replaced, regardless of type
295 dest.set("destItem2", "string value")
296 value2 = [5, -4, 3]
297 source.set("srcItem2", value2)
298 dest.copy("destItem2", source, "srcItem2")
299 self.assertEqual(dest.get("destItem2"), value2[-1])
300 self.assertEqual(dest.getArray("destItem2"), value2)
301 self.assertEqual(dest.getScalar("destItem2"), value2[-1])
303 # asScalar copies only the last value
304 dest.copy("destItem2Scalar", source, "srcItem2", asScalar=True)
305 self.assertEqual(dest.get("destItem2Scalar"), value2[-1])
306 self.assertEqual(dest.getArray("destItem2Scalar"), [value2[-1]])
307 self.assertEqual(dest.getScalar("destItem2Scalar"), value2[-1])
310class FlatTestCase(unittest.TestCase):
311 """A test case for flattened PropertySets."""
313 def testConstruct(self):
314 ps = dafBase.PropertySet(flat=True)
315 self.assertIsNotNone(ps)
317 def testScalar(self):
318 ps = dafBase.PropertySet(flat=True)
319 ps.setBool("bool", True)
320 ps.setShort("short", 42)
321 ps.setInt("int", 2008)
322 ps.setLongLong("int64_t", 0xfeeddeadbeef)
323 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
324 ps.setFloat("float", 3.14159)
325 ps.setDouble("double", 2.718281828459045)
326 ps.set("char*", "foo")
327 ps.setString("string", "bar")
328 ps.set("int2", 2009)
329 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
330 ps.set("autobool", True)
332 self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
333 self.assertIs(ps.getBool("bool"), True)
334 self.assertIs(ps.get("bool"), True)
335 self.assertEqual(ps.getArray("bool"), [True])
336 self.assertIs(ps.getScalar("bool"), True)
337 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
338 self.assertEqual(ps.getShort("short"), 42)
339 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
340 self.assertEqual(ps.getInt("int"), 2008)
341 self.assertEqual(ps.typeOf("int64_t"),
342 dafBase.PropertySet.TYPE_LongLong)
343 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
344 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
345 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
346 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
347 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
348 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
349 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
350 self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
351 self.assertEqual(ps.getString("char*"), "foo")
352 self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
353 self.assertEqual(ps.getString("string"), "bar")
354 self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
355 self.assertEqual(ps.getInt("int2"), 2009)
356 self.assertEqual(ps.get("int2"), 2009)
357 self.assertEqual(ps.getArray("int2"), [2009])
358 self.assertEqual(ps.getScalar("int2"), 2009)
359 self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
360 self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
361 self.assertEqual(ps.typeOf("autobool"), dafBase.PropertySet.TYPE_Bool)
362 self.assertIs(ps.get("autobool"), True)
363 self.assertEqual(ps.getArray("autobool"), [True])
364 self.assertIs(ps.getScalar("autobool"), True)
366 def testGetDefault(self):
367 ps = dafBase.PropertySet(flat=True)
368 ps.setInt("int", 42)
369 self.assertEqual(ps.getInt("int"), 42)
370 self.assertEqual(ps.getInt("int", 2008), 42)
371 self.assertEqual(ps.getInt("foo", 2008), 2008)
373 def testExists(self):
374 ps = dafBase.PropertySet(flat=True)
375 ps.setInt("int", 42)
376 self.assertEqual(ps.exists("int"), True)
377 self.assertEqual(ps.exists("foo"), False)
379 def testGetVector(self):
380 ps = dafBase.PropertySet(flat=True)
381 v = [42, 2008, 1]
382 ps.setInt("ints", v)
383 ps.setInt("ints2", [10, 9, 8])
384 w = ps.getArrayInt("ints")
385 self.assertEqual(len(w), 3)
386 self.assertEqual(v, w)
387 self.assertEqual(ps.getInt("ints2"), 8)
388 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
389 self.assertEqual(ps.getArray("ints"), v)
390 self.assertEqual(ps.getScalar("ints"), v[-1])
391 ps.setInt("int", 999)
392 x = ps.get("int")
393 self.assertEqual(x, 999)
394 self.assertEqual(ps.getArray("int"), [999])
395 self.assertEqual(ps.getScalar("int"), 999)
397 def testGetVector2(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(w, v)
404 self.assertEqual(ps.getInt("ints2"), 8)
405 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
407 def testAddScalar(self):
408 ps = dafBase.PropertySet(flat=True)
409 v = [42, 2008, 1]
410 ps.setInt("ints", v)
411 ps.addInt("ints", -999)
412 ps.add("other", "foo")
413 ps.add("ints", 13)
414 w = ps.getArrayInt("ints")
415 self.assertEqual(len(w), 5)
416 self.assertEqual(v[0], w[0])
417 self.assertEqual(v[1], w[1])
418 self.assertEqual(v[2], w[2])
419 self.assertEqual(w[3], -999)
420 self.assertEqual(w[4], 13)
421 self.assertEqual(ps.getString("other"), "foo")
423 def testDateTimeToString(self):
424 ps = dafBase.PropertySet(flat=True)
425 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
426 self.assertEqual(ps.toString(),
427 "dt = 2009-04-02T07:26:39.314159265Z\n")
429 def testGetScalarThrow(self):
430 ps = dafBase.PropertySet(flat=True)
431 ps.setBool("bool", True)
432 ps.setShort("short", 42)
433 ps.setInt("int", 2008)
434 with self.assertRaises(KeyError):
435 ps["foo"]
436 self.assertIsNone(ps.get("foo"))
438 def testSubPS(self):
439 ps = dafBase.PropertySet(flat=True)
440 ps1 = dafBase.PropertySet()
441 ps1.set("a", 1)
442 ps1.add("a", 2)
443 ps1.set("foo", "bar")
444 ps.setPropertySet("b", ps1)
445 self.assertEqual(ps.exists("b.a"), True)
446 self.assertEqual(ps.get("b.a"), 2)
447 self.assertEqual(ps.getArray("b.a"), [1, 2])
448 self.assertEqual(ps.getScalar("b.a"), 2)
449 self.assertEqual(ps.exists("b"), False)
450 self.assertEqual(ps.exists("b.foo"), True)
451 self.assertEqual(ps.get("b.foo"), "bar")
452 self.assertEqual(ps.getArray("b.foo"), ["bar"])
453 self.assertEqual(ps.getScalar("b.foo"), "bar")
455 ps.set("b.c", 20)
456 self.assertEqual(ps.exists("b.c"), True)
457 self.assertEqual(ps.get("b.c"), 20)
458 self.assertEqual(ps.getArray("b.c"), [20])
459 self.assertEqual(ps.getScalar("b.c"), 20)
460 self.assertEqual(ps.exists("b"), False)
462 def testCombine(self):
463 ps = dafBase.PropertySet()
464 ps.set("ps1.pre", 1)
465 ps.set("ps1.pre", 1)
466 ps.set("ps1.post", 2)
467 ps.set("int", 42)
468 ps.set("double", 3.14)
469 ps.set("ps2.plus", 10.24)
470 ps.set("ps2.minus", -10.24)
471 ps.set("ps3.sub.subsub", "foo")
473 psp = dafBase.PropertySet()
474 psp.set("ps1.pre", 3)
475 psp.add("ps1.pre", 4)
476 psp.set("int", 2008)
477 psp.set("ps2.foo", "bar")
478 psp.set("ps4.top", "bottom")
480 ps.combine(psp)
482 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet)
483 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet)
484 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet)
485 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet)
486 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet)
488 self.assertFalse(ps.isArray("ps1"))
489 self.assertTrue(ps.isArray("ps1.pre"))
490 self.assertFalse(ps.isArray("ps1.post"))
491 self.assertFalse(ps.isArray("ps2"))
492 self.assertFalse(ps.isArray("ps2.plus"))
493 self.assertFalse(ps.isArray("ps2.minus"))
494 self.assertFalse(ps.isArray("ps2.foo"))
495 self.assertFalse(ps.isArray("ps3"))
496 self.assertFalse(ps.isArray("ps3.sub"))
497 self.assertFalse(ps.isArray("ps3.subsub"))
498 self.assertFalse(ps.isArray("ps4"))
499 self.assertFalse(ps.isArray("ps4.top"))
500 self.assertTrue(ps.isArray("int"))
501 self.assertFalse(ps.isArray("double"))
503 self.assertEqual(ps.valueCount("ps1.pre"), 3)
504 self.assertEqual(ps.valueCount("int"), 2)
506 v = ps.getArray("ps1.pre")
507 self.assertEqual(v, [1, 3, 4])
508 v = ps.getArray("int")
509 self.assertEqual(v, [42, 2008])
511 def testUpdate(self):
512 ps = dafBase.PropertySet()
513 ps.set("ps1.pre", 1)
514 ps.set("ps1.pre", 1)
515 ps.set("ps1.post", 2)
516 ps.set("int", 42)
517 ps.set("double", 3.14)
518 ps.set("ps2.plus", 10.24)
519 ps.set("ps2.minus", -10.24)
520 ps.set("ps3.sub.subsub", "foo")
522 psp = dafBase.PropertySet()
523 psp.set("ps1.pre", 3)
524 psp.add("ps1.pre", 4)
525 psp.set("int", 2008)
526 psp.set("ps2.foo", "bar")
527 psp.set("ps4.top", "bottom")
529 ps.update(psp)
531 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet)
532 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet)
533 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet)
534 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet)
535 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet)
537 self.assertFalse(ps.isArray("ps1"))
538 self.assertTrue(ps.isArray("ps1.pre"))
539 self.assertFalse(ps.isArray("ps1.post"))
540 self.assertFalse(ps.isArray("ps2"))
541 self.assertFalse(ps.isArray("ps2.plus"))
542 self.assertFalse(ps.isArray("ps2.minus"))
543 self.assertFalse(ps.isArray("ps2.foo"))
544 self.assertFalse(ps.isArray("ps3"))
545 self.assertFalse(ps.isArray("ps3.sub"))
546 self.assertFalse(ps.isArray("ps3.subsub"))
547 self.assertFalse(ps.isArray("ps4"))
548 self.assertFalse(ps.isArray("ps4.top"))
549 self.assertFalse(ps.isArray("int"))
550 self.assertFalse(ps.isArray("double"))
552 self.assertEqual(ps.valueCount("ps1.pre"), 2)
553 self.assertEqual(ps.valueCount("int"), 1)
555 v = ps.getArray("ps1.pre")
556 self.assertEqual(v, [3, 4])
557 v = ps.getArray("int")
558 self.assertEqual(v, [2008])
560 psd = {"int": 100, "str": "String", "apl1.foo": 10.5}
561 ps.update(psd)
562 self.assertEqual(ps["int"], psd["int"])
563 self.assertEqual(ps["str"], psd["str"])
564 self.assertEqual(ps["apl1.foo"], psd["apl1.foo"])
565 self.assertEqual(ps["double"], 3.14)
567 def testCombineThrow(self):
568 ps = dafBase.PropertySet()
569 ps.set("int", 42)
571 psp = dafBase.PropertySet()
572 psp.set("int", 3.14159)
574 with self.assertRaises(TypeError):
575 ps.combine(psp)
577 psd = {"bool": True}
578 with self.assertRaises(TypeError):
579 ps.combine(psd)
581 def testToDict(self):
582 ps = dafBase.PropertySet()
583 ps.setBool("bool", True)
584 ps.setShort("short", 42)
585 ps.setInt("int", 2008)
586 ps.setLongLong("int64_t", 0xfeeddeadbeef)
587 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
588 ps.setInt("ints", [10, 9, 8])
590 ps2 = dafBase.PropertySet()
591 ps2.set("ps", ps)
592 ps2.setFloat("float", 3.14159)
593 ps2.setDouble("double", 2.718281828459045)
594 ps2.set("char*", "foo")
595 ps2.setString("string", "bar")
596 ps2.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
597 ps2.set("undef", None)
599 d = ps2.toDict()
600 self.assertIsInstance(d, dict)
602 self.assertIsInstance(d["float"], float)
603 self.assertAlmostEqual(d["float"], 3.14159, 6)
604 self.assertIsInstance(d["double"], float)
605 self.assertEqual(d["double"], 2.718281828459045)
606 self.assertIsNone(d["undef"])
608 self.assertIsInstance(d["char*"], str)
609 self.assertEqual(d["char*"], "foo")
610 self.assertIsInstance(d["string"], str)
611 self.assertEqual(d["string"], "bar")
612 self.assertIsInstance(d["dt"], dafBase.DateTime)
613 self.assertEqual(d["dt"].nsecs(), 1238657233314159265)
615 d2 = d["ps"]
616 self.assertIsInstance(d2, dict)
618 self.assertIsInstance(d2["bool"], bool)
619 self.assertEqual(d2["bool"], True)
620 self.assertIsInstance(d2["short"], (int, int))
621 self.assertEqual(d2["short"], 42)
622 self.assertIsInstance(d2["int"], (int, int))
623 self.assertEqual(d2["int"], 2008)
624 self.assertIsInstance(d2["int64_t"], (int, int))
625 self.assertEqual(d2["int64_t"], 0xfeeddeadbeef)
626 self.assertIsInstance(d2["uint64_t"], (int, int))
627 self.assertEqual(d2["uint64_t"], 0xFFFFFFFFFFFFFFFF)
628 self.assertIsInstance(d2["ints"], list)
629 self.assertIsInstance(d2["ints"][0], (int, int))
630 self.assertEqual(d2["ints"], [10, 9, 8])
632 def testAddVector(self):
633 ps = dafBase.PropertySet()
634 v = [42, 2008, 1]
635 ps.set("ints", v)
637 vv = [-42, -2008, -1]
638 ps.add("ints", vv)
640 w = ps.getArray("ints")
641 self.assertEqual(w, v + vv)
643 def testArrayProperties(self):
644 ps = dafBase.PropertySet()
645 v = [42, 2008, 1]
646 ps.set("ints", v)
647 ps.set("int", 365)
648 ps.set("ints2", -42)
649 ps.add("ints2", -2008)
651 self.assertTrue(ps.isArray("ints"))
652 self.assertFalse(ps.isArray("int"))
653 self.assertTrue(ps.isArray("ints2"))
654 self.assertEqual(ps.valueCount("ints"), 3)
655 self.assertEqual(ps.valueCount("int"), 1)
656 self.assertEqual(ps.valueCount("ints2"), 2)
657 self.assertEqual(ps.typeOf("ints"), dafBase.PropertySet.TYPE_Int)
658 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
659 self.assertEqual(ps.typeOf("ints2"), dafBase.PropertySet.TYPE_Int)
661 def testHierarchy(self):
662 ps = dafBase.PropertySet()
663 psp = dafBase.PropertySet()
665 psp.set("pre", 1)
666 ps.set("ps1", psp)
667 psp.set("post", 2)
668 ps.set("int", 42)
669 ps.set("ps2", dafBase.PropertySet())
670 ps.getPropertySet("ps2").set("plus", 10.24)
671 ps.set("ps2.minus", -10.24)
672 ps.set("ps3.sub1", "foo")
673 ps.set("ps3.sub2", "bar")
675 self.assertTrue(ps.exists("ps1"))
676 self.assertTrue(ps.exists("ps2"))
677 self.assertTrue(ps.exists("ps3"))
678 self.assertTrue(ps.exists("ps1.pre"))
679 self.assertTrue(ps.exists("ps1.post"))
680 self.assertTrue(ps.exists("ps2.plus"))
681 self.assertTrue(ps.exists("ps2.minus"))
682 self.assertTrue(ps.exists("ps3.sub1"))
683 self.assertTrue(ps.exists("ps3.sub2"))
685 self.assertTrue(ps.isPropertySetPtr("ps1"))
686 self.assertTrue(ps.isPropertySetPtr("ps2"))
687 self.assertTrue(ps.isPropertySetPtr("ps3"))
688 self.assertFalse(ps.isPropertySetPtr("int"))
689 self.assertFalse(ps.isPropertySetPtr("ps1.pre"))
690 self.assertFalse(ps.isPropertySetPtr("ps1.post"))
691 self.assertFalse(ps.isPropertySetPtr("ps2.plus"))
692 self.assertFalse(ps.isPropertySetPtr("ps2.minus"))
693 self.assertFalse(ps.isPropertySetPtr("ps3.sub1"))
694 self.assertFalse(ps.isPropertySetPtr("ps3.sub2"))
696 psp1 = ps.getPropertySet("ps1")
697 psp2 = ps.getPropertySet("ps2")
698 psp3 = ps.getPropertySet("ps3")
699 self.assertIsInstance(psp1, dafBase.PropertySet)
700 self.assertIsInstance(psp2, dafBase.PropertySet)
701 self.assertIsInstance(psp3, dafBase.PropertySet)
702 self.assertEqual(psp1, psp)
703 self.assertTrue(psp1.exists("pre"))
704 self.assertTrue(psp1.exists("post"))
705 self.assertTrue(psp2.exists("plus"))
706 self.assertTrue(psp2.exists("minus"))
707 self.assertTrue(psp3.exists("sub1"))
708 self.assertTrue(psp3.exists("sub2"))
709 self.assertEqual(psp1.getAsInt("pre"), 1)
710 self.assertEqual(psp1.getAsInt("post"), 2)
711 self.assertEqual(psp2.getAsDouble("plus"), 10.24)
712 self.assertEqual(psp2.getAsDouble("minus"), -10.24)
713 self.assertEqual(psp3.getAsString("sub1"), "foo")
714 self.assertEqual(psp3.getAsString("sub2"), "bar")
716 # Make sure checking a subproperty doesn't create it.
717 self.assertFalse(ps.exists("ps2.pre"))
718 self.assertFalse(ps.exists("ps2.pre"))
719 # Make sure checking an element doesn't create it.
720 self.assertFalse(ps.exists("ps4"))
721 self.assertFalse(ps.exists("ps4"))
722 # Make sure checking a subproperty with a nonexistent parent doesn't
723 # create it.
724 self.assertFalse(ps.exists("ps4.sub"))
725 self.assertFalse(ps.exists("ps4.sub"))
726 # Make sure checking a subproperty doesn't create its parent.
727 self.assertFalse(ps.exists("ps4"))
729#
730 def testvariousThrows(self):
731 ps = dafBase.PropertySet()
732 ps.set("int", 42)
733 with self.assertRaises(pexExcept.InvalidParameterError):
734 ps.set("int.sub", "foo")
735 with self.assertRaises(TypeError):
736 ps.getDouble("int")
737 with self.assertRaises(LookupError):
738 ps.getDouble("double")
739 with self.assertRaises(KeyError):
740 ps.getArray("double")
741 with self.assertRaises(LookupError):
742 ps.typeOf("double")
743 with self.assertRaises(TypeError):
744 ps.add("int", 4.2)
746 v = [3.14159, 2.71828]
747 with self.assertRaises(TypeError):
748 ps.add("int", v)
749 ps.remove("foo.bar")
750 ps.remove("int.sub")
752 def testIntegerRanges(self):
753 """Test that the ranges of the various integer types is as expected"""
754 ps = dafBase.PropertySet()
755 minI32 = -2**31
756 maxI32 = 2**31 - 1
757 minI64 = -2**63
758 maxI64 = 2**63 - 1
759 minU64 = 0
760 maxU64 = 2**64 - 1
761 # Out of range for the particular type
762 self.assertRaises(TypeError, ps.addInt, "int32", minI32 - 1)
763 self.assertRaises(TypeError, ps.addInt, "int32", maxI32 + 1)
764 self.assertRaises(TypeError, ps.addLongLong, "int64", minI64 - 1)
765 self.assertRaises(TypeError, ps.addLongLong, "int64", maxI64 + 1)
766 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", minU64 - 1)
767 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", maxU64 + 1)
768 # Out of all possible integer ranges
769 self.assertRaises(RuntimeError, ps.add, "number", minI64 - 1)
770 self.assertRaises(RuntimeError, ps.add, "number", maxU64 + 1)
772 def testNames(self):
773 ps = dafBase.PropertySet()
774 ps.set("ps1.pre", 1)
775 ps.set("ps1.post", 2)
776 ps.set("int", 42)
777 ps.set("double", 3.14)
778 ps.set("ps2.plus", 10.24)
779 ps.set("ps2.minus", -10.24)
781 self.assertEqual(ps.nameCount(), 4)
782 self.assertEqual(ps.nameCount(False), 8)
784 v = set(ps.names())
785 self.assertEqual(len(v), 4)
786 self.assertEqual(v, {"double", "int", "ps1", "ps2"})
787 v = set(ps.names(False))
788 self.assertEqual(len(v), 8)
789 self.assertEqual(v, {"double", "int", "ps1", "ps1.post",
790 "ps1.pre", "ps2", "ps2.minus", "ps2.plus"})
792 def testParamNames(self):
793 ps = dafBase.PropertySet()
794 ps.set("ps1.pre", 1)
795 ps.set("ps1.post", 2)
796 ps.set("int", 42)
797 ps.set("double", 3.14)
798 ps.set("ps2.plus", 10.24)
799 ps.set("ps2.minus", -10.24)
801 v = set(ps.paramNames())
802 self.assertEqual(len(v), 2)
803 self.assertEqual(v, {"double", "int"})
804 v = set(ps.paramNames(False))
805 self.assertEqual(len(v), 6)
806 self.assertEqual(v, {"double", "int", "ps1.post", "ps1.pre",
807 "ps2.minus", "ps2.plus"})
809 def testPropertySetNames(self):
810 ps = dafBase.PropertySet()
811 ps.set("ps1.pre", 1)
812 ps.set("ps1.post", 2)
813 ps.set("int", 42)
814 ps.set("double", 3.14)
815 ps.set("ps2.plus", 10.24)
816 ps.set("ps2.minus", -10.24)
817 ps.set("ps3.sub.subsub", "foo")
819 v = set(ps.propertySetNames())
820 self.assertEqual(len(v), 3)
821 self.assertEqual(v, {"ps1", "ps2", "ps3"})
822 v = set(ps.propertySetNames(False))
823 self.assertEqual(len(v), 4)
824 self.assertEqual(v, {"ps1", "ps2", "ps3", "ps3.sub"})
826 def testGetAs(self):
827 ps = dafBase.PropertySet()
828 ps.set("bool", True)
829 ps.setShort("short", 42)
830 ps.set("int", 2008)
831 ps.set("int64_t", 0xfeeddeadbeef)
832 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF)
833 f = 3.14159
834 ps.setFloat("float", f)
835 d = 2.718281828459045
836 ps.setDouble("double", d)
837 ps.setString("char*", "foo")
838 ps.set("char*2", "foo2")
839 ps.set("string", "bar")
840 psp = dafBase.PropertySet()
841 psp.set("bottom", "x")
842 ps.set("top", psp)
844 self.assertIs(ps.getAsBool("bool"), True)
845 self.assertEqual(ps.getAsInt("bool"), 1)
846 self.assertEqual(ps.getAsInt("short"), 42)
847 self.assertEqual(ps.getAsInt("int"), 2008)
848 with self.assertRaises(TypeError):
849 ps.getAsInt("int64_t")
850 with self.assertRaises(TypeError):
851 ps.getAsInt("uint64_t")
852 with self.assertRaises(TypeError):
853 ps.getAsInt64("uint64_t")
854 self.assertEqual(ps.getAsInt64("bool"), 1)
855 self.assertEqual(ps.getAsInt64("short"), 42)
856 self.assertEqual(ps.getAsInt64("int"), 2008)
857 self.assertEqual(ps.getAsInt64("int64_t"), 0xfeeddeadbeef)
858 self.assertEqual(ps.getAsUInt64("uint64_t"), 0xFFFFFFFFFFFFFFFF)
859 with self.assertRaises(TypeError):
860 ps.getAsInt64("float")
861 with self.assertRaises(TypeError):
862 ps.getAsUInt64("float")
863 self.assertEqual(ps.getAsDouble("bool"), 1.0)
864 self.assertEqual(ps.getAsDouble("short"), 42.0)
865 self.assertEqual(ps.getAsDouble("int"), 2008.0)
866 self.assertEqual(ps.getAsDouble("int64_t"),
867 float(0xfeeddeadbeef))
868 self.assertEqual(ps.getAsDouble("uint64_t"),
869 float(0xFFFFFFFFFFFFFFFF))
870 self.assertAlmostEqual(ps.getAsDouble("float"), 3.14159, places=5)
871 self.assertAlmostEqual(ps.getAsDouble("double"), 2.718281828459045, places=15)
872 with self.assertRaises(TypeError):
873 ps.getAsDouble("char*")
874 self.assertEqual(ps.getAsString("char*"), "foo")
875 self.assertEqual(ps.getAsString("char*2"), "foo2")
876 self.assertEqual(ps.getAsString("string"), "bar")
877 with self.assertRaises(TypeError):
878 ps.getAsString("int")
879 self.assertEqual(ps.getAsString("top.bottom"), "x")
880 self.assertEqual(ps.getAsPropertySetPtr("top"), psp)
881 with self.assertRaises(TypeError):
882 ps.getAsPropertySetPtr("top.bottom")
884 def testRemove(self):
885 ps = dafBase.PropertySet()
886 ps.set("int", 42)
887 ps.set("double", 3.14159)
888 ps.set("ps1.plus", 1)
889 ps.set("ps1.minus", -1)
890 ps.set("ps1.zero", 0)
891 self.assertEqual(ps.nameCount(False), 6)
893 ps.remove("int")
894 self.assertFalse(ps.exists("int"))
895 self.assertEqual(ps.getAsDouble("double"), 3.14159)
896 self.assertEqual(ps.getAsInt("ps1.plus"), 1)
897 self.assertEqual(ps.getAsInt("ps1.minus"), -1)
898 self.assertEqual(ps.getAsInt("ps1.zero"), 0)
899 self.assertEqual(ps.nameCount(False), 5)
901 ps.remove("ps1.zero")
902 self.assertFalse(ps.exists("int"))
903 self.assertEqual(ps.getAsDouble("double"), 3.14159)
904 self.assertFalse(ps.exists("ps1.zero"))
905 self.assertEqual(ps.getAsInt("ps1.plus"), 1)
906 self.assertEqual(ps.getAsInt("ps1.minus"), -1)
907 self.assertEqual(ps.nameCount(False), 4)
909 ps.remove("ps1")
910 self.assertFalse(ps.exists("int"))
911 self.assertEqual(ps.getAsDouble("double"), 3.14159)
912 self.assertFalse(ps.exists("ps1"))
913 self.assertFalse(ps.exists("ps1.plus"))
914 self.assertFalse(ps.exists("ps1.minus"))
915 self.assertFalse(ps.exists("ps1.zero"))
916 self.assertEqual(ps.nameCount(False), 1)
918 ps.remove("double")
919 self.assertFalse(ps.exists("int"))
920 self.assertFalse(ps.exists("double"))
921 self.assertFalse(ps.exists("ps1"))
922 self.assertFalse(ps.exists("ps1.plus"))
923 self.assertFalse(ps.exists("ps1.minus"))
924 self.assertFalse(ps.exists("ps1.zero"))
925 self.assertEqual(ps.nameCount(False), 0)
927 def testDeepCopy(self):
928 ps = dafBase.PropertySet()
929 ps.set("int", 42)
930 psp = dafBase.PropertySet()
931 psp.set("bottom", "x")
932 ps.set("top", psp)
934 psp2 = ps.deepCopy()
935 self.assertTrue(psp2.exists("int"))
936 self.assertTrue(psp2.exists("top.bottom"))
937 self.assertEqual(psp2.getAsInt("int"), 42)
938 self.assertEqual(psp2.getAsString("top.bottom"), "x")
939 # Make sure it was indeed a deep copy.
940 ps.set("int", 2008)
941 ps.set("top.bottom", "y")
942 self.assertEqual(ps.getAsInt("int"), 2008)
943 self.assertEqual(ps.getAsString("top.bottom"), "y")
944 self.assertEqual(psp.getAsString("bottom"), "y")
945 self.assertEqual(psp2.getAsInt("int"), 42)
946 self.assertEqual(psp2.getAsString("top.bottom"), "x")
948 def testToString(self):
949 ps = dafBase.PropertySet()
950 ps.set("bool", True)
951 s = 42
952 ps.setShort("short", s)
953 ps.set("int", 2008)
954 ps.set("int64_t", 0xfeeddeadbeef)
955 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF)
956 f = 3.14159
957 ps.setFloat("float", f)
958 d = 2.718281828459045
959 ps.setDouble("double", d)
960 ps.setString("char*", "foo")
961 ps.set("char*2", "foo2")
962 ps.set("string", "bar")
963 ps.set("ps1.pre", 1)
964 ps.set("ps1.post", 2)
965 ps.set("ps2.plus", 10.24)
966 ps.set("ps2.minus", -10.24)
967 ps.set("ps3.sub.subsub", "foo")
968 ps.add("v", 10)
969 ps.add("v", 9)
970 ps.add("v", 8)
972 self.assertEqual(ps.toString(),
973 "bool = 1\n"
974 "char* = \"foo\"\n"
975 "char*2 = \"foo2\"\n"
976 "double = 2.7182818284590\n"
977 "float = 3.141590\n"
978 "int = 2008\n"
979 "int64_t = 280297596632815\n"
980 "ps1 = {\n"
981 "..post = 2\n"
982 "..pre = 1\n"
983 "}\n"
984 "ps2 = {\n"
985 "..minus = -10.240000000000\n"
986 "..plus = 10.240000000000\n"
987 "}\n"
988 "ps3 = {\n"
989 "..sub = {\n"
990 "....subsub = \"foo\"\n"
991 "..}\n"
992 "}\n"
993 "short = 42\n"
994 "string = \"bar\"\n"
995 "uint64_t = 18446744073709551615\n"
996 "v = [ 10, 9, 8 ]\n"
997 )
998 self.assertEqual(ps.toString(True),
999 "bool = 1\n"
1000 "char* = \"foo\"\n"
1001 "char*2 = \"foo2\"\n"
1002 "double = 2.7182818284590\n"
1003 "float = 3.141590\n"
1004 "int = 2008\n"
1005 "int64_t = 280297596632815\n"
1006 "ps1 = { ... }\n"
1007 "ps2 = { ... }\n"
1008 "ps3 = { ... }\n"
1009 "short = 42\n"
1010 "string = \"bar\"\n"
1011 "uint64_t = 18446744073709551615\n"
1012 "v = [ 10, 9, 8 ]\n"
1013 )
1016class TestMemory(lsst.utils.tests.MemoryTestCase):
1017 pass
1020def setup_module(module):
1021 lsst.utils.tests.init()
1024if __name__ == "__main__": 1024 ↛ 1025line 1024 didn't jump to line 1025, because the condition on line 1024 was never true
1025 lsst.utils.tests.init()
1026 unittest.main()