Coverage for tests/test_PropertyList.py : 7%

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 lsst.utils.tests
28import lsst.daf.base as dafBase
31class FloatSubClass(float):
32 """Intended to be something like numpy.float64, without introducing a
33 dependency on numpy
34 """
35 pass
38class PropertyListTestCase(unittest.TestCase):
39 """A test case for PropertyList.
40 """
42 def testConstruct(self):
43 apl = dafBase.PropertyList()
44 self.assertIsNotNone(apl)
46 def checkPickle(self, original):
47 new = pickle.loads(pickle.dumps(original, 2))
48 self.assertEqual(new, original)
49 return new
51 def testScalar(self):
52 apl = dafBase.PropertyList()
53 apl.setBool("bool", True)
54 apl.setShort("short", 42)
55 apl.setInt("int", 2008)
56 apl.setLongLong("int64_t", 0xfeeddeadbeef)
57 apl.setFloat("float", 3.14159)
58 apl.setDouble("double", 2.718281828459045)
59 apl.set("char*", "foo")
60 apl.setString("string", "bar")
61 apl.set("int2", 2009)
62 apl.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
63 apl.set("subclass", FloatSubClass(1.23456789))
64 apl.set("undef", None)
66 self.assertTrue(apl.isUndefined("undef"))
67 self.assertFalse(apl.isUndefined("string"))
68 self.assertEqual(apl.typeOf("bool"), dafBase.PropertyList.TYPE_Bool)
69 self.assertEqual(apl.getBool("bool"), True)
70 self.assertEqual(apl.typeOf("short"), dafBase.PropertyList.TYPE_Short)
71 self.assertEqual(apl.getShort("short"), 42)
72 self.assertEqual(apl.typeOf("int"), dafBase.PropertyList.TYPE_Int)
73 self.assertEqual(apl.getInt("int"), 2008)
74 self.assertEqual(apl.typeOf("int64_t"),
75 dafBase.PropertyList.TYPE_LongLong)
76 self.assertEqual(apl.getLongLong("int64_t"), 0xfeeddeadbeef)
77 self.assertEqual(apl.typeOf("float"), dafBase.PropertyList.TYPE_Float)
78 self.assertAlmostEqual(apl.getFloat("float"), 3.14159, 6)
79 self.assertEqual(apl.typeOf("double"), dafBase.PropertyList.TYPE_Double)
80 self.assertEqual(apl.getDouble("double"), 2.718281828459045)
81 self.assertEqual(apl.typeOf("char*"), dafBase.PropertyList.TYPE_String)
82 self.assertEqual(apl.getString("char*"), "foo")
83 self.assertEqual(apl.typeOf("string"), dafBase.PropertyList.TYPE_String)
84 self.assertEqual(apl.getString("string"), "bar")
85 self.assertEqual(apl.typeOf("int2"), dafBase.PropertyList.TYPE_Int)
86 self.assertEqual(apl.getInt("int2"), 2009)
87 self.assertEqual(apl.get("int2"), 2009)
88 self.assertEqual(apl.getArray("int2"), [2009])
89 self.assertEqual(apl.getScalar("int2"), 2009)
90 self.assertEqual(apl.typeOf("dt"), dafBase.PropertyList.TYPE_DateTime)
91 self.assertEqual(apl.getDateTime("dt").nsecs(), 1238657233314159265)
92 self.assertEqual(apl.getDouble("subclass"), 1.23456789)
93 self.assertEqual(apl["int2"], 2009)
95 self.assertIsNone(apl.getScalar("undef"))
96 self.assertEqual(apl.typeOf("undef"), dafBase.PropertyList.TYPE_Undef)
97 self.assertIsNone(apl.get("undef"))
98 self.assertIsNone(apl["undef"])
99 self.checkPickle(apl)
101 # Now replace the undef value with a defined value
102 apl.set("undef", "not undefined")
103 self.assertEqual(apl.getScalar("undef"), "not undefined")
104 self.assertFalse(apl.isUndefined("undef"))
105 self.assertEqual(apl.typeOf("undef"), dafBase.PropertyList.TYPE_String)
107 def testGetDefault(self):
108 apl = dafBase.PropertyList()
109 apl.setInt("int", 42)
110 self.assertEqual(apl.getInt("int"), 42)
111 self.assertEqual(apl.getInt("int", 2008), 42)
112 self.assertEqual(apl.getInt("foo", 2008), 2008)
113 self.assertEqual(apl.get("int"), 42)
114 self.assertEqual(apl.get("int", 2008), 42)
115 self.assertEqual(apl.get("foo", 2008), 2008)
116 self.assertEqual(apl.get("foo2", default="missing"), "missing")
117 self.assertIsNone(apl.get("foo"))
119 def testExists(self):
120 apl = dafBase.PropertyList()
121 apl.setInt("int", 42)
122 self.assertEqual(apl.exists("int"), True)
123 self.assertEqual(apl.exists("foo"), False)
125 def testGetVector(self):
126 apl = dafBase.PropertyList()
127 v = [42, 2008, 1]
128 apl.setInt("ints", v)
129 apl.setInt("ints2", [10, 9, 8])
130 w = apl.getArrayInt("ints")
131 self.assertEqual(len(w), 3)
132 self.assertEqual(v, w)
133 self.assertEqual(apl.getInt("ints2"), 8)
134 self.assertEqual(apl.getArrayInt("ints2"), [10, 9, 8])
135 w = apl.get("ints")
136 self.assertIsInstance(w, int)
137 self.assertEqual(v[-1], w)
138 self.assertEqual(apl["ints"], v[-1])
139 self.assertEqual(apl.getArray("ints"), v)
140 self.assertEqual(apl.getScalar("ints"), v[-1])
141 apl.setInt("int", 999)
142 x = apl.get("int")
143 self.assertEqual(x, 999)
144 self.assertEqual(apl.getArray("int"), [999])
145 self.assertEqual(apl.getScalar("int"), 999)
146 self.assertEqual(apl["int"], 999)
148 self.checkPickle(apl)
150 def testGetVector2(self):
151 apl = dafBase.PropertyList()
152 v = [42, 2008, 1]
153 apl.setInt("ints", v)
154 apl.setInt("ints2", [10, 9, 8])
155 w = apl.getArrayInt("ints")
156 self.assertEqual(len(w), 3)
157 self.assertEqual(v[0], w[0])
158 self.assertEqual(v[1], w[1])
159 self.assertEqual(v[2], w[2])
160 self.assertEqual(apl.getInt("ints2"), 8)
161 self.assertEqual(apl.getArrayInt("ints2"), [10, 9, 8])
163 self.checkPickle(apl)
165 def testAddScalar(self):
166 apl = dafBase.PropertyList()
167 v = [42, 2008, 1]
168 apl.setInt("ints", v)
169 apl.addInt("ints", -999)
170 apl.add("other", "foo")
171 apl.add("ints", 13)
172 apl.add("subclass", FloatSubClass(1.23456789))
173 w = apl.getArrayInt("ints")
174 self.assertEqual(len(w), 5)
175 self.assertEqual(v[0], w[0])
176 self.assertEqual(v[1], w[1])
177 self.assertEqual(v[2], w[2])
178 self.assertEqual(w[3], -999)
179 self.assertEqual(w[4], 13)
180 self.assertEqual(apl.getString("other"), "foo")
181 self.assertEqual(apl.get("subclass"), 1.23456789)
182 self.assertEqual(apl.getArray("subclass"), [1.23456789])
183 self.assertEqual(apl.getScalar("subclass"), 1.23456789)
185 def testDateTimeToString(self):
186 apl = dafBase.PropertyList()
187 apl.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
188 self.assertEqual(apl.toString(),
189 "dt = 2009-04-02T07:26:39.314159265Z\n")
191 def testGetScalarThrow(self):
192 apl = dafBase.PropertyList()
193 apl.setBool("bool", True)
194 apl.setShort("short", 42)
195 apl.setInt("int", 2008)
196 apl.setLongLong("int64_t", 0xfeeddeadbeef)
197 apl.setFloat("float", 3.14159)
198 apl.setDouble("double", 2.718281828459045)
199 apl.setString("string", "bar")
201 with self.assertRaises(KeyError):
202 apl["foo"]
203 with self.assertRaises(TypeError):
204 apl.getBool("short")
205 with self.assertRaises(TypeError):
206 apl.getBool("int")
207 with self.assertRaises(TypeError):
208 apl.getShort("int")
209 with self.assertRaises(TypeError):
210 apl.getInt("short")
211 with self.assertRaises(TypeError):
212 apl.getInt("bool")
213 with self.assertRaises(TypeError):
214 apl.getDouble("float")
215 with self.assertRaises(TypeError):
216 apl.getFloat("double")
217 with self.assertRaises(TypeError):
218 apl.getString("int")
220 def testAddVector(self):
221 apl = dafBase.PropertyList()
222 v = [42, 2008, 1]
223 apl.set("ints", v)
224 apl.add("ints", [-42, -2008, -1])
225 subclass = [FloatSubClass(1.23), FloatSubClass(4.56), FloatSubClass(7.89)]
226 apl.add("subclass", subclass)
227 self.assertEqual(apl.getArrayInt("ints"),
228 [42, 2008, 1, -42, -2008, -1])
229 self.assertEqual(apl.get("subclass"), subclass[-1])
230 self.assertEqual(apl.getArray("subclass"), subclass)
231 self.assertEqual(apl.getScalar("subclass"), subclass[-1])
233 def testComment(self):
234 apl = dafBase.PropertyList()
235 apl.set("NAXIS", 2, "two-dimensional")
236 self.assertEqual(apl.get("NAXIS"), 2)
237 self.assertEqual(apl.getArray("NAXIS"), [2])
238 self.assertEqual(apl.getScalar("NAXIS"), 2)
239 self.assertEqual(apl.getComment("NAXIS"), "two-dimensional")
240 apl.set("NAXIS", 3, "three-dimensional")
241 self.assertEqual(apl.get("NAXIS"), 3)
242 self.assertEqual(apl.getArray("NAXIS"), [3])
243 self.assertEqual(apl.getScalar("NAXIS"), 3)
244 self.assertEqual(apl.getComment("NAXIS"), "three-dimensional")
246 def testOrder(self):
247 apl = dafBase.PropertyList()
248 apl.set("SIMPLE", True)
249 apl.set("BITPIX", -32)
250 apl.set("NAXIS", 2)
251 apl.set("COMMENT", "This is a test")
252 apl.add("COMMENT", "This is a test line 2")
253 apl.set("RA", 3.14159, "decimal degrees")
254 apl.set("DEC", 2.71828, "decimal radians")
255 correct = [
256 ("SIMPLE", True, ""),
257 ("BITPIX", -32, ""),
258 ("NAXIS", 2, ""),
259 ("COMMENT", "This is a test", ""),
260 ("COMMENT", "This is a test line 2", ""),
261 ("RA", 3.14159, "decimal degrees"),
262 ("DEC", 2.71828, "decimal radians"),
263 ]
264 self.assertEqual(apl.toList(), correct)
265 apl.set("NAXIS1", 513, "length of data axis 1")
266 correct.append(("NAXIS1", 513, "length of data axis 1"))
267 self.assertEqual(apl.toList(), correct)
268 apl.set("RA", 1.414)
269 correct[5] = ("RA", 1.414, "decimal degrees")
270 self.assertEqual(apl.toList(), correct)
271 apl.set("DEC", 1.732)
272 correct[6] = ("DEC", 1.732, "decimal radians")
273 self.assertEqual(apl.toList(), correct)
274 apl.set("DEC", -6.28, "")
275 correct[6] = ("DEC", -6.28, "")
276 self.assertEqual(apl.toList(), correct)
277 apl.add("COMMENT", "This is a test line 3", "")
278 correct.insert(5, ("COMMENT", "This is a test line 3", ""))
279 self.assertEqual(apl.toList(), correct)
281 self.checkPickle(apl)
283 def testToOrderedDict(self):
284 from collections import OrderedDict
286 apl = dafBase.PropertyList()
287 apl.set("SIMPLE", True)
288 apl.set("BITPIX", -32)
289 apl.set("NAXIS", 2)
290 apl.set("RA", 3.14159)
291 apl.set("DEC", 2.71828)
292 apl.set("FILTER", None)
293 apl.set("COMMENT", "This is a test")
294 apl.add("COMMENT", "This is a test line 2")
295 correct = OrderedDict([
296 ("SIMPLE", True),
297 ("BITPIX", -32),
298 ("NAXIS", 2),
299 ("RA", 3.14159),
300 ("DEC", 2.71828),
301 ("FILTER", None),
302 ("COMMENT", ["This is a test", "This is a test line 2"])
303 ])
304 self.assertEqual(apl.toOrderedDict(), correct)
306 apl.set("NAXIS1", 513)
307 correct["NAXIS1"] = 513
308 self.assertEqual(apl.toOrderedDict(), correct)
309 apl.set("RA", 1.414)
310 correct["RA"] = 1.414
311 self.assertEqual(apl.toOrderedDict(), correct)
312 apl.set("DEC", 1.732)
313 correct["DEC"] = 1.732
314 self.assertEqual(apl.toOrderedDict(), correct)
315 apl.set("DEC", -6.28)
316 correct["DEC"] = -6.28
317 self.assertEqual(apl.toOrderedDict(), correct)
318 apl.add("COMMENT", "This is a test line 3")
319 correct["COMMENT"] = correct["COMMENT"] + ["This is a test line 3", ]
320 self.assertEqual(apl.toOrderedDict(), correct)
322 def testHierarchy(self):
323 apl = dafBase.PropertyList()
324 apl.set("CURRENT", 49.5)
325 apl.set("CURRENT.foo", -32)
326 apl.set("CURRENT.bar", 2)
327 self.assertEqual(apl.get("CURRENT"), 49.5)
328 self.assertEqual(apl.getArray("CURRENT"), [49.5])
329 self.assertEqual(apl.getScalar("CURRENT"), 49.5)
330 self.assertEqual(apl.get("CURRENT.foo"), -32)
331 self.assertEqual(apl.getArray("CURRENT.foo"), [-32])
332 self.assertEqual(apl.getScalar("CURRENT.foo"), -32)
333 self.assertEqual(apl.get("CURRENT.bar"), 2)
334 self.assertEqual(apl.getArray("CURRENT.bar"), [2])
335 self.assertEqual(apl.getScalar("CURRENT.bar"), 2)
337 aps = dafBase.PropertySet()
338 aps.set("bottom", "x")
339 aps.set("sibling", 42)
340 apl.set("top", aps)
341 self.assertEqual(apl.get("top.bottom"), "x")
342 self.assertEqual(apl.getArray("top.bottom"), ["x"])
343 self.assertEqual(apl.getScalar("top.bottom"), "x")
344 self.assertEqual(apl.get("top.sibling"), 42)
345 self.assertEqual(apl.getArray("top.sibling"), [42])
346 self.assertEqual(apl.getScalar("top.sibling"), 42)
347 with self.assertRaises(KeyError):
348 apl["top"]
349 self.assertEqual(apl.toString(),
350 'CURRENT = 49.500000000000\nCURRENT.foo = -32\nCURRENT.bar = 2\n'
351 'top.sibling = 42\ntop.bottom = "x"\n')
353 self.checkPickle(apl)
355 # Check that a PropertyList (with comment) can go in a PropertySet
356 apl.set("INT", 45, "an integer")
357 aps = dafBase.PropertySet()
358 aps.set("bottom", "x")
359 aps.set("apl", apl)
360 new = self.checkPickle(aps)
361 self.assertIsInstance(new, dafBase.PropertySet)
362 self.assertIsInstance(new.getScalar("apl"), dafBase.PropertyList)
363 self.assertEqual(new.getScalar("apl").getComment("INT"), "an integer")
365 def testCombineHierarchical(self):
366 # Test that we can perform a deep copy of a PropertyList containing a
367 # hierarchical (contains a '.') key.
368 # This was a segfault prior to addressing DM-882.
369 pl1 = dafBase.PropertyList()
370 pl1.set("a.b", 1)
371 pl2 = pl1.deepCopy() # should not segfault
372 self.assertEqual(pl1.get("a.b"), pl2.get("a.b"))
373 self.assertEqual(pl1.getArray("a.b"), pl2.getArray("a.b"))
374 self.assertEqual(pl1.getScalar("a.b"), pl2.getScalar("a.b"))
375 self.checkPickle(pl1)
377 def testCopy(self):
378 dest = dafBase.PropertyList()
379 source = dafBase.PropertyList()
380 value1 = [1.5, 3.2]
381 source.set("srcItem1", value1)
382 dest.copy("destItem1", source, "srcItem1")
383 self.assertEqual(dest.get("destItem1"), value1[-1])
384 self.assertEqual(dest.getArray("destItem1"), value1)
385 self.assertEqual(dest.getScalar("destItem1"), value1[-1])
387 # items are replaced, regardless of type
388 dest.set("destItem2", "string value")
389 value2 = [5, -4, 3]
390 source.set("srcItem2", value2)
391 dest.copy("destItem2", source, "srcItem2")
392 self.assertEqual(dest.get("destItem2"), value2[-1])
393 self.assertEqual(dest.getArray("destItem2"), value2)
394 self.assertEqual(dest.getScalar("destItem2"), value2[-1])
396 # asScalar copies only the last value
397 dest.copy("destItem2Scalar", source, "srcItem2", asScalar=True)
398 self.assertEqual(dest.get("destItem2Scalar"), value2[-1])
399 self.assertEqual(dest.getArray("destItem2Scalar"), [value2[-1]])
400 self.assertEqual(dest.getScalar("destItem2Scalar"), value2[-1])
402 def testArrayProperties(self):
403 apl = dafBase.PropertyList()
404 v = [42, 2008, 1]
405 apl.set("ints", v)
406 apl.set("int", 365)
407 apl.set("ints2", -42)
408 apl.add("ints2", -2008)
410 self.assertTrue(apl.isArray("ints"))
411 self.assertFalse(apl.isArray("int"))
412 self.assertTrue(apl.isArray("ints2"))
413 self.assertEqual(apl.valueCount("ints"), 3)
414 self.assertEqual(apl.valueCount("int"), 1)
415 self.assertEqual(apl.valueCount("ints2"), 2)
416 self.assertEqual(apl.typeOf("ints"), dafBase.PropertyList.TYPE_Int)
417 self.assertEqual(apl.typeOf("int"), dafBase.PropertyList.TYPE_Int)
418 self.assertEqual(apl.typeOf("ints2"), dafBase.PropertyList.TYPE_Int)
420 def testHierarchy2(self):
421 apl = dafBase.PropertyList()
422 aplp = dafBase.PropertyList()
424 aplp.set("pre", 1)
425 apl.set("apl1", aplp)
427 # Python will not see this, aplp is disconnected
428 aplp.set("post", 2)
429 self.assertFalse(apl.exists("apl1.post"))
431 apl.set("int", 42)
433 # Setting an empty PropertyList has no effect
434 apl.set("apl2", dafBase.PropertyList())
435 self.assertFalse(apl.exists("apl2"))
437 apl.set("apl2.plus", 10.24)
438 apl.set("apl2.minus", -10.24)
439 apl.set("apl3.sub1", "foo")
440 apl.set("apl3.sub2", "bar")
442 self.assertTrue(apl.exists("apl1.pre"))
443 self.assertTrue(apl.exists("apl2.plus"))
444 self.assertTrue(apl.exists("apl2.minus"))
445 self.assertTrue(apl.exists("apl3.sub1"))
446 self.assertTrue(apl.exists("apl3.sub2"))
448 # Make sure checking a subproperty doesn't create it.
449 self.assertFalse(apl.exists("apl2.pre"))
450 self.assertFalse(apl.exists("apl2.pre"))
451 # Make sure checking an element doesn't create it.
452 self.assertFalse(apl.exists("apl4"))
453 self.assertFalse(apl.exists("apl4"))
454 # Make sure checking a subproperty with a nonexistent parent doesn't
455 # create it.
456 self.assertFalse(apl.exists("apl4.sub"))
457 self.assertFalse(apl.exists("apl4.sub"))
458 # Make sure checking a subproperty doesn't create its parent.
459 self.assertFalse(apl.exists("apl4"))
461 def testvariousThrows(self):
462 apl = dafBase.PropertyList()
463 apl.set("int", 42)
465 # This raises an exception in C++ test but works in Python
466 apl.set("int.sub", "foo")
468 with self.assertRaises(TypeError):
469 apl.getDouble("int")
470 with self.assertRaises(LookupError):
471 apl.getDouble("double"),
472 with self.assertRaises(LookupError):
473 apl.getArrayDouble("double")
474 with self.assertRaises(LookupError):
475 apl.typeOf("double")
476 with self.assertRaises(TypeError):
477 apl.add("int", 4.2),
479 v = [3.14159, 2.71828]
480 with self.assertRaises(TypeError):
481 apl.add("int", v)
482 apl.remove("foo.bar")
483 apl.remove("int.sub")
485 def testNames(self):
486 apl = dafBase.PropertyList()
487 apl.set("apl1.pre", 1)
488 apl.set("apl1.post", 2)
489 apl.set("int", 42)
490 apl.set("double", 3.14)
491 apl.set("apl2.plus", 10.24)
492 apl.set("apl2.minus", -10.24)
494 # Hierarchy is always flat
495 self.assertEqual(apl.nameCount(), 6)
496 self.assertEqual(apl.nameCount(False), 6)
498 v = set(apl.names())
499 self.assertEqual(len(v), 6)
500 self.assertEqual(v, {"double", "int", "apl1.post",
501 "apl1.pre", "apl2.minus", "apl2.plus"})
503 def testParamNames(self):
504 apl = dafBase.PropertyList()
505 apl.set("apl1.pre", 1)
506 apl.set("apl1.post", 2)
507 apl.set("int", 42)
508 apl.set("double", 3.14)
509 apl.set("apl2.plus", 10.24)
510 apl.set("apl2.minus", -10.24)
512 v = set(apl.paramNames())
513 self.assertEqual(len(v), 6)
514 self.assertEqual(v, {"double", "int", "apl1.post", "apl1.pre",
515 "apl2.minus", "apl2.plus"})
517 def testPropertySetNames(self):
518 apl = dafBase.PropertyList()
519 apl.set("apl1.pre", 1)
520 apl.set("apl1.post", 2)
521 apl.set("int", 42)
522 apl.set("double", 3.14)
523 apl.set("apl2.plus", 10.24)
524 apl.set("apl2.minus", -10.24)
525 apl.set("apl3.sub.subsub", "foo")
527 # There are no PropertySets inside flattened PropertyList
528 v = set(apl.propertySetNames())
529 self.assertEqual(len(v), 0)
531 def testGetAs(self):
532 apl = dafBase.PropertyList()
533 apl.set("bool", True)
534 s = 42
535 apl.setShort("short", s)
536 apl.set("int", 2008)
537 apl.set("int64_t", 0xfeeddeadbeef)
538 f = 3.14159
539 apl.setFloat("float", f)
540 d = 2.718281828459045
541 apl.setDouble("double", d)
542 apl.setString("char*", "foo")
543 apl.set("char*2", "foo2")
544 apl.set("string", "bar")
545 aplp = dafBase.PropertyList()
546 aplp.set("bottom", "x")
547 apl.set("top", aplp)
549 self.assertEqual(apl.getAsBool("bool"), True)
550 self.assertEqual(apl.getAsInt("bool"), 1)
551 self.assertEqual(apl.getAsInt("short"), 42)
552 self.assertEqual(apl.getAsInt("int"), 2008)
553 with self.assertRaises(TypeError):
554 apl.getAsInt("int64_t")
555 self.assertEqual(apl.getAsInt64("bool"), 1)
556 self.assertEqual(apl.getAsInt64("short"), 42)
557 self.assertEqual(apl.getAsInt64("int"), 2008)
558 self.assertEqual(apl.getAsInt64("int64_t"), 0xfeeddeadbeef)
559 with self.assertRaises(TypeError):
560 apl.getAsInt64("float")
561 self.assertEqual(apl.getAsDouble("bool"), 1.0)
562 self.assertEqual(apl.getAsDouble("short"), 42.0)
563 self.assertEqual(apl.getAsDouble("int"), 2008.0)
564 self.assertEqual(apl.getAsDouble("int64_t"), float(0xfeeddeadbeef))
565 self.assertAlmostEqual(apl.getAsDouble("float"), 3.14159, places=5)
566 self.assertEqual(apl.getAsDouble("double"), 2.718281828459045)
567 with self.assertRaises(TypeError):
568 apl.getAsDouble("char*")
569 self.assertEqual(apl.getAsString("char*"), "foo")
570 self.assertEqual(apl.getAsString("char*2"), "foo2")
571 self.assertEqual(apl.getAsString("string"), "bar")
572 with self.assertRaises(TypeError):
573 apl.getAsString("int")
574 self.assertEqual(apl.getAsString("top.bottom"), "x")
576 def testCombine(self):
577 apl = dafBase.PropertyList()
578 apl.set("apl1.pre", 1)
579 apl.set("apl1.post", 2)
580 apl.set("int", 42)
581 apl.set("double", 3.14)
582 apl.set("apl2.plus", 10.24)
583 apl.set("apl2.minus", -10.24)
584 apl.set("apl3.sub.subsub", "foo")
586 aplp = dafBase.PropertyList()
587 aplp.set("apl1.pre", 3)
588 aplp.add("apl1.pre", 4)
589 aplp.set("int", 2008)
590 aplp.set("apl2.foo", "bar")
591 aplp.set("apl4.top", "bottom")
593 apl.combine(aplp)
595 self.assertFalse(apl.isArray("apl1"))
596 self.assertTrue(apl.isArray("apl1.pre"))
597 self.assertFalse(apl.isArray("apl1.post"))
598 self.assertFalse(apl.isArray("apl2"))
599 self.assertFalse(apl.isArray("apl2.plus"))
600 self.assertFalse(apl.isArray("apl2.minus"))
601 self.assertFalse(apl.isArray("apl2.foo"))
602 self.assertFalse(apl.isArray("apl3"))
603 self.assertFalse(apl.isArray("apl3.sub"))
604 self.assertFalse(apl.isArray("apl3.subsub"))
605 self.assertFalse(apl.isArray("apl4"))
606 self.assertFalse(apl.isArray("apl4.top"))
607 self.assertTrue(apl.isArray("int"))
608 self.assertFalse(apl.isArray("double"))
609 self.assertEqual(apl.valueCount("apl1.pre"), 3)
610 self.assertEqual(apl.valueCount("int"), 2)
611 v = apl.getArray("apl1.pre")
612 self.assertEqual(v, [1, 3, 4])
613 v = apl.getArray("int")
614 self.assertEqual(v, [42, 2008])
616 def testUpdate(self):
617 apl = dafBase.PropertyList()
618 apl.set("apl1.pre", 1)
619 apl.set("apl1.post", 2)
620 apl.set("int", 42)
621 apl.set("double", 3.14)
622 apl.set("apl2.plus", 10.24)
623 apl.set("apl2.minus", -10.24)
624 apl.set("apl3.sub.subsub", "foo")
626 aplp = dafBase.PropertyList()
627 aplp.set("apl1.pre", 3)
628 aplp.add("apl1.pre", 4)
629 aplp.set("int", 2008)
630 aplp.set("apl2.foo", "bar")
631 aplp.set("apl4.top", "bottom")
633 apl.update(aplp)
635 self.assertFalse(apl.isArray("apl1"))
636 self.assertTrue(apl.isArray("apl1.pre"))
637 self.assertFalse(apl.isArray("apl1.post"))
638 self.assertFalse(apl.isArray("apl2"))
639 self.assertFalse(apl.isArray("apl2.plus"))
640 self.assertFalse(apl.isArray("apl2.minus"))
641 self.assertFalse(apl.isArray("apl2.foo"))
642 self.assertFalse(apl.isArray("apl3"))
643 self.assertFalse(apl.isArray("apl3.sub"))
644 self.assertFalse(apl.isArray("apl3.subsub"))
645 self.assertFalse(apl.isArray("apl4"))
646 self.assertFalse(apl.isArray("apl4.top"))
647 self.assertFalse(apl.isArray("int"))
648 self.assertFalse(apl.isArray("double"))
649 self.assertEqual(apl.valueCount("apl1.pre"), 2)
650 self.assertEqual(apl.valueCount("int"), 1)
651 v = apl.getArray("apl1.pre")
652 self.assertEqual(v, [3, 4])
653 v = apl.getArray("int")
654 self.assertEqual(v, [2008])
656 apld = {"int": 100, "str": "String", "apl1.foo": 10.5}
657 apl.update(apld)
658 self.assertEqual(apl["int"], apld["int"])
659 self.assertEqual(apl["str"], apld["str"])
660 self.assertEqual(apl["apl1.foo"], apld["apl1.foo"])
661 self.assertEqual(apl["double"], 3.14)
663 def testCombineThrow(self):
664 apl = dafBase.PropertyList()
665 apl.set("int", 42)
667 aplp = dafBase.PropertyList()
668 aplp.set("int", 3.14159)
670 with self.assertRaises(TypeError):
671 apl.combine(aplp)
673 psd = {"bool": True}
674 with self.assertRaises(TypeError):
675 apl.combine(psd)
677 def testremove(self):
678 apl = dafBase.PropertyList()
679 apl.set("int", 42)
680 apl.set("double", 3.14159)
681 apl.set("apl1.plus", 1)
682 apl.set("apl1.minus", -1)
683 apl.set("apl1.zero", 0)
684 self.assertEqual(apl.nameCount(False), 5)
686 apl.remove("int")
687 self.assertFalse(apl.exists("int"))
688 self.assertEqual(apl.getAsDouble("double"), 3.14159)
689 self.assertEqual(apl.getAsInt("apl1.plus"), 1)
690 self.assertEqual(apl.getAsInt("apl1.minus"), -1)
691 self.assertEqual(apl.getAsInt("apl1.zero"), 0)
692 self.assertEqual(apl.nameCount(False), 4)
694 apl.remove("apl1.zero")
695 self.assertFalse(apl.exists("int"))
696 self.assertEqual(apl.getAsDouble("double"), 3.14159)
697 self.assertFalse(apl.exists("apl1.zero"))
698 self.assertEqual(apl.getAsInt("apl1.plus"), 1)
699 self.assertEqual(apl.getAsInt("apl1.minus"), -1)
700 self.assertEqual(apl.nameCount(False), 3)
702 # Removing a non-existent key (flattened) has no effect
703 self.assertFalse(apl.exists("apl1"))
704 apl.remove("apl1")
705 self.assertFalse(apl.exists("int"))
706 self.assertEqual(apl.getAsDouble("double"), 3.14159)
707 self.assertFalse(apl.exists("apl1"))
708 self.assertTrue(apl.exists("apl1.plus"))
709 self.assertTrue(apl.exists("apl1.minus"))
710 self.assertFalse(apl.exists("apl1.zero"))
711 self.assertEqual(apl.nameCount(False), 3)
713 apl.remove("double")
714 self.assertFalse(apl.exists("int"))
715 self.assertFalse(apl.exists("double"))
716 self.assertFalse(apl.exists("apl1"))
717 self.assertTrue(apl.exists("apl1.plus"))
718 self.assertTrue(apl.exists("apl1.minus"))
719 self.assertFalse(apl.exists("apl1.zero"))
720 self.assertEqual(apl.nameCount(False), 2)
722 apl.remove("apl1.plus")
723 apl.remove("apl1.minus")
724 self.assertEqual(apl.nameCount(False), 0)
726 def testdeepCopy(self):
727 apl = dafBase.PropertyList()
728 apl.set("int", 42)
729 aplp = dafBase.PropertyList()
730 aplp.set("bottom", "x")
731 apl.set("top", aplp)
733 aplp2 = apl.deepCopy()
734 self.assertTrue(aplp2.exists("int"))
735 self.assertTrue(aplp2.exists("top.bottom"))
736 self.assertEqual(aplp2.getAsInt("int"), 42)
737 self.assertEqual(aplp2.getAsString("top.bottom"), "x")
738 # Make sure it was indeed a deep copy.
739 apl.set("int", 2008)
740 apl.set("top.bottom", "z")
741 self.assertEqual(apl.getAsInt("int"), 2008)
742 self.assertEqual(apl.getAsString("top.bottom"), "z")
743 self.assertEqual(aplp2.getAsInt("int"), 42)
744 self.assertEqual(aplp2.getAsString("top.bottom"), "x")
746 def testToString(self):
747 apl = dafBase.PropertyList()
748 apl.set("bool", True)
749 s = 42
750 apl.setShort("short", s)
751 apl.set("int", 2008)
752 apl.set("int64_t", 0xfeeddeadbeef)
753 f = 3.14159
754 apl.setFloat("float", f)
755 d = 2.718281828459045
756 apl.setDouble("double", d)
757 apl.setString("char*", "foo")
758 apl.set("char*2", "foo2")
759 apl.set("string", "bar")
760 apl.set("apl1.pre", 1)
761 apl.set("apl1.post", 2)
762 apl.set("apl2.plus", 10.24)
763 apl.set("apl2.minus", -10.24)
764 apl.set("apl3.sub.subsub", "foo")
765 apl.add("v", 10)
766 apl.add("v", 9)
767 apl.add("v", 8)
769 # Check that the keys returned for this PropertyList match
770 # the order they were set
771 order = ['bool', 'short', 'int', 'int64_t', 'float', 'double', 'char*', 'char*2',
772 'string', 'apl1.pre', 'apl1.post', 'apl2.plus', 'apl2.minus', 'apl3.sub.subsub', 'v']
773 self.assertEqual(apl.getOrderedNames(), order)
775 # Argument to toString has no effect for flattened hierarchy
776 self.assertEqual(apl.toString(),
777 "bool = 1\n"
778 "short = 42\n"
779 "int = 2008\n"
780 "int64_t = 280297596632815\n"
781 "float = 3.141590\n"
782 "double = 2.7182818284590\n"
783 "char* = \"foo\"\n"
784 "char*2 = \"foo2\"\n"
785 "string = \"bar\"\n"
786 "apl1.pre = 1\n"
787 "apl1.post = 2\n"
788 "apl2.plus = 10.240000000000\n"
789 "apl2.minus = -10.240000000000\n"
790 "apl3.sub.subsub = \"foo\"\n"
791 "v = [ 10, 9, 8 ]\n"
792 )
793 self.assertEqual(apl.toString(True),
794 "bool = 1\n"
795 "short = 42\n"
796 "int = 2008\n"
797 "int64_t = 280297596632815\n"
798 "float = 3.141590\n"
799 "double = 2.7182818284590\n"
800 "char* = \"foo\"\n"
801 "char*2 = \"foo2\"\n"
802 "string = \"bar\"\n"
803 "apl1.pre = 1\n"
804 "apl1.post = 2\n"
805 "apl2.plus = 10.240000000000\n"
806 "apl2.minus = -10.240000000000\n"
807 "apl3.sub.subsub = \"foo\"\n"
808 "v = [ 10, 9, 8 ]\n"
809 )
812class TestMemory(lsst.utils.tests.MemoryTestCase):
813 pass
816def setup_module(module):
817 lsst.utils.tests.init()
820if __name__ == "__main__": 820 ↛ 821line 820 didn't jump to line 821, because the condition on line 820 was never true
821 lsst.utils.tests.init()
822 unittest.main()