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