Coverage for tests/test_PropertySet_2.py: 6%
872 statements
« prev ^ index » next coverage.py v7.3.1, created at 2023-09-20 10:36 +0000
« prev ^ index » next coverage.py v7.3.1, created at 2023-09-20 10:36 +0000
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 dataclasses
25import pickle
26import unittest
28import numpy as np
30import lsst.utils.tests
31import lsst.daf.base as dafBase
32import lsst.pex.exceptions as pexExcept
35class PropertySetTestCase(unittest.TestCase):
36 """A test case for PropertySet.
37 """
39 def testConstruct(self):
40 ps = dafBase.PropertySet()
41 self.assertIsNotNone(ps)
43 def checkPickle(self, original):
44 new = pickle.loads(pickle.dumps(original, 4))
45 self.assertEqual(new, original)
47 def testScalar(self):
48 ps = dafBase.PropertySet()
49 ps.setBool("bool", True)
50 ps.setShort("short", 42)
51 ps.setInt("int", 2008)
52 ps.setLongLong("int64_t", 0xfeeddeadbeef)
53 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
54 ps.setFloat("float", 3.14159)
55 ps.setDouble("double", 2.718281828459045)
56 ps.set("char*", "foo")
57 ps.setString("string", "bar")
58 ps.set("char*", u"foo")
59 ps.setString("string", u"bar")
60 ps.set("int2", 2009)
61 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
62 ps.set("blank", "")
63 ps.set("undef", None)
65 self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
66 self.assertEqual(ps.getBool("bool"), True)
67 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
68 self.assertEqual(ps.getShort("short"), 42)
69 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
70 self.assertEqual(ps.getInt("int"), 2008)
71 self.assertEqual(ps.typeOf("int64_t"),
72 dafBase.PropertySet.TYPE_LongLong)
73 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
74 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
75 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
76 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
77 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
78 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
79 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
80 self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
81 self.assertEqual(ps.getString("char*"), "foo")
82 self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
83 self.assertEqual(ps.getString("string"), "bar")
84 self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
85 self.assertEqual(ps.getInt("int2"), 2009)
86 self.assertEqual(ps.get("int2"), 2009)
87 self.assertEqual(ps["int2"], 2009)
88 self.assertEqual(ps.getArray("int2"), [2009])
89 self.assertEqual(ps.getScalar("int2"), 2009)
90 self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
91 self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
92 self.assertEqual(ps.getString("blank"), "")
93 self.assertEqual(ps.valueCount(), 13)
95 self.assertIsNone(ps.getScalar("undef"))
96 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_Undef)
97 self.assertIsNone(ps.get("undef"))
99 self.checkPickle(ps)
101 # Now replace the undef value with a defined value
102 ps.set("undef", "not undefined")
103 self.assertEqual(ps.getScalar("undef"), "not undefined")
104 self.assertFalse(ps.isUndefined("undef"))
105 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_String)
107 def testNumPyScalars(self):
108 """Test that we can also pass NumPy array scalars to PropertySet
109 setters.
110 """
111 ps = dafBase.PropertySet()
112 ps.setShort("short", np.int16(42))
113 ps.setInt("int", np.int32(2008))
114 ps.setLongLong("int64_t", np.int64(0xfeeddeadbeef))
115 ps.setUnsignedLongLong("uint64_t", np.uint64(0xFFFFFFFFFFFFFFFF))
116 ps.setFloat("float", np.float32(3.14159))
117 ps.setDouble("double", np.float64(2.718281828459045))
118 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
119 self.assertEqual(ps.getShort("short"), 42)
120 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
121 self.assertEqual(ps.getInt("int"), 2008)
122 self.assertEqual(ps.typeOf("int64_t"),
123 dafBase.PropertySet.TYPE_LongLong)
124 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
125 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
126 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
127 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
128 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
129 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
130 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
131 self.assertEqual(ps.valueCount(), 6)
132 self.checkPickle(ps)
134 def testGetDefault(self):
135 ps = dafBase.PropertySet()
136 ps.setInt("int", 42)
137 self.assertEqual(ps.getInt("int"), 42)
138 self.assertEqual(ps.getInt("int", 2008), 42)
139 self.assertEqual(ps.getInt("foo", 2008), 2008)
140 self.assertEqual(ps.get("int"), 42)
141 self.assertEqual(ps.get("int", 2008), 42)
142 self.assertEqual(ps.get("foo", 2008), 2008)
143 self.assertEqual(ps.get("foo2", default="missing"), "missing")
144 self.assertIsNone(ps.get("foo"))
145 self.checkPickle(ps)
147 def testExists(self):
148 ps = dafBase.PropertySet()
149 ps.setInt("int", 42)
150 self.checkPickle(ps)
151 self.assertEqual(ps.exists("int"), True)
152 self.assertEqual(ps.exists("foo"), False)
154 def testGetVector(self):
155 ps = dafBase.PropertySet()
156 v = [42, 2008, 1]
157 ps.setInt("ints", v)
158 ps.setInt("ints2", [10, 9, 8])
159 w = ps.getArrayInt("ints")
160 self.assertEqual(len(w), 3)
161 self.assertEqual(v, w)
162 self.assertEqual(ps.getInt("ints2"), 8)
163 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
164 self.assertEqual(ps.getArray("ints"), v)
165 self.assertEqual(ps.getScalar("ints"), v[-1])
166 self.assertEqual(ps["ints"], v[-1])
167 self.assertEqual(ps.valueCount(), 6)
168 ps.setInt("int", 999)
169 x = ps.get("int")
170 self.assertEqual(x, 999)
171 self.assertEqual(ps.getArray("int"), [999])
172 self.assertEqual(ps.getScalar("int"), 999)
173 self.assertEqual(ps["int"], 999)
174 self.assertEqual(ps.valueCount(), 7)
175 self.checkPickle(ps)
177 # Check that an empty list does nothing
178 ps.setInt("empty", [])
179 self.assertNotIn("empty", ps)
181 def testGetVector2(self):
182 ps = dafBase.PropertySet()
183 v = [42, 2008, 1]
184 ps.setInt("ints", v)
185 ps.setInt("ints2", [10, 9, 8])
186 w = ps.getArrayInt("ints")
187 self.assertEqual(len(w), 3)
188 self.assertEqual(v[0], w[0])
189 self.assertEqual(v[1], w[1])
190 self.assertEqual(v[2], w[2])
191 self.assertEqual(ps.getInt("ints2"), 8)
192 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
193 self.checkPickle(ps)
195 def testAddScalar(self):
196 ps = dafBase.PropertySet()
197 v = [42, 2008, 1]
198 ps.setInt("ints", v)
199 ps.addInt("ints", -999)
200 ps.add("other", "foo")
201 ps.add("ints", 13)
202 w = ps.getArrayInt("ints")
203 self.assertEqual(len(w), 5)
204 self.assertEqual(v[0], w[0])
205 self.assertEqual(v[1], w[1])
206 self.assertEqual(v[2], w[2])
207 self.assertEqual(w[3], -999)
208 self.assertEqual(w[4], 13)
209 self.assertEqual(ps.getString("other"), "foo")
210 self.assertEqual(ps.valueCount(), 6)
211 self.checkPickle(ps)
213 # Check that an empty list does nothing
214 ps.addInt("ints", [])
215 self.assertEqual(ps.getArrayInt("ints"), w)
217 def testSetAddVector(self):
218 ps = dafBase.PropertySet()
219 boolArr = [True, False]
220 intArr = [1, -1, 2]
221 floatArr = [1.2, 99.5, -35.1]
222 strArr = ["this", "is", "some strings"]
223 ps.set("bools", boolArr)
224 ps.set("ints", intArr)
225 ps.set("floats", floatArr)
226 ps.set("strs", strArr)
227 self.assertEqual(ps.get("bools"), boolArr[-1])
228 self.assertEqual(ps.getArray("bools"), boolArr)
229 self.assertEqual(ps.getScalar("bools"), boolArr[-1])
230 self.assertEqual(ps.get("ints"), intArr[-1])
231 self.assertEqual(ps.getArray("ints"), intArr)
232 self.assertEqual(ps.getScalar("ints"), intArr[-1])
233 self.assertEqual(ps.get("floats"), floatArr[-1])
234 self.assertEqual(ps.getArray("floats"), floatArr)
235 self.assertEqual(ps.getScalar("floats"), floatArr[-1])
236 self.assertEqual(ps.get("strs"), strArr[-1])
237 self.assertEqual(ps.getArray("strs"), strArr)
238 self.assertEqual(ps.getScalar("strs"), strArr[-1])
239 self.assertEqual(ps.valueCount(), 11)
241 ps.add("bools", list(reversed(boolArr)))
242 ps.add("ints", list(reversed(intArr)))
243 ps.add("floats", list(reversed(floatArr)))
244 ps.add("strs", list(reversed(strArr)))
245 self.assertEqual(ps.get("bools"), boolArr[0])
246 self.assertEqual(ps.getArray("bools"), boolArr + list(reversed(boolArr)))
247 self.assertEqual(ps.getScalar("bools"), boolArr[0])
248 self.assertEqual(ps.get("ints"), intArr[0])
249 self.assertEqual(ps.getArray("ints"), intArr + list(reversed(intArr)))
250 self.assertEqual(ps.getScalar("ints"), intArr[0])
251 self.assertEqual(ps.get("floats"), floatArr[0])
252 self.assertEqual(ps.getArray("floats"), floatArr + list(reversed(floatArr)))
253 self.assertEqual(ps.getScalar("floats"), floatArr[0])
254 self.assertEqual(ps.get("strs"), strArr[0])
255 self.assertEqual(ps.getArray("strs"), strArr + list(reversed(strArr)))
256 self.assertEqual(ps.getScalar("strs"), strArr[0])
257 self.assertEqual(ps.valueCount(), 22)
258 self.checkPickle(ps)
260 def testDateTimeToString(self):
261 ps = dafBase.PropertySet()
262 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
263 self.assertEqual(ps.toString(),
264 "dt = 2009-04-02T07:26:39.314159265Z\n")
265 self.checkPickle(ps)
267 def testGetScalarThrow(self):
268 ps = dafBase.PropertySet()
269 ps.setBool("bool", True)
270 ps.setShort("short", 42)
271 ps.setInt("int", 2008)
272 with self.assertRaises(KeyError):
273 ps["foo"]
274 # This will not throw
275 self.assertIsNone(ps.get("foo"))
276 self.checkPickle(ps)
278 def testSubPS(self):
279 ps = dafBase.PropertySet()
280 ps1 = dafBase.PropertySet()
281 ps1.set("a", 1)
282 ps.setPropertySet("b", ps1)
283 self.assertEqual(ps.getArray("b"), ps1)
284 self.assertEqual(ps.getScalar("b"), ps1)
285 self.assertEqual(ps.get("b.a"), 1)
286 self.assertEqual(ps.getArray("b.a"), [1])
287 self.assertEqual(ps.getScalar("b.a"), 1)
288 self.assertEqual(ps.valueCount(), 1)
289 ps.set("c", ps1)
290 self.assertEqual(ps.getArray("c"), ps1)
291 self.assertEqual(ps.getScalar("c"), ps1)
292 self.assertEqual(ps.get("c.a"), 1)
293 self.assertEqual(ps.getArray("c.a"), [1])
294 self.assertEqual(ps.getScalar("c.a"), 1)
295 self.assertEqual(ps.valueCount(), 2)
296 ps.set("c.a", 2)
297 self.assertEqual(ps.get("b.a"), 2)
298 self.assertEqual(ps.getArray("b.a"), [2])
299 self.assertEqual(ps.getScalar("b.a"), 2)
300 self.assertEqual(ps.get("b").get("a"), 2)
301 self.assertEqual(ps.valueCount(), 2)
302 self.checkPickle(ps)
304 def testCopy(self):
305 dest = dafBase.PropertySet()
306 source = dafBase.PropertySet()
307 value1 = [1.5, 3.2]
308 source.set("srcItem1", value1)
309 dest.copy("destItem1", source, "srcItem1")
310 self.assertEqual(dest.get("destItem1"), value1[-1])
311 self.assertEqual(dest.getArray("destItem1"), value1)
312 self.assertEqual(dest.getScalar("destItem1"), value1[-1])
313 self.assertEqual(source.valueCount(), 2)
314 self.assertEqual(dest.valueCount(), 2)
316 # items are replaced, regardless of type
317 dest.set("destItem2", "string value")
318 value2 = [5, -4, 3]
319 source.set("srcItem2", value2)
320 dest.copy("destItem2", source, "srcItem2")
321 self.assertEqual(dest.get("destItem2"), value2[-1])
322 self.assertEqual(dest.getArray("destItem2"), value2)
323 self.assertEqual(dest.getScalar("destItem2"), value2[-1])
324 self.assertEqual(source.valueCount(), 5)
325 self.assertEqual(dest.valueCount(), 5)
327 # asScalar copies only the last value
328 dest.copy("destItem2Scalar", source, "srcItem2", asScalar=True)
329 self.assertEqual(dest.get("destItem2Scalar"), value2[-1])
330 self.assertEqual(dest.getArray("destItem2Scalar"), [value2[-1]])
331 self.assertEqual(dest.getScalar("destItem2Scalar"), value2[-1])
332 self.assertEqual(source.valueCount(), 5)
333 self.assertEqual(dest.valueCount(), 6)
336class FlatTestCase(unittest.TestCase):
337 """A test case for flattened PropertySets.
338 """
340 def testConstruct(self):
341 ps = dafBase.PropertySet(flat=True)
342 self.assertIsNotNone(ps)
344 def testScalar(self):
345 ps = dafBase.PropertySet(flat=True)
346 ps.setBool("bool", True)
347 ps.setShort("short", 42)
348 ps.setInt("int", 2008)
349 ps.setLongLong("int64_t", 0xfeeddeadbeef)
350 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
351 ps.setFloat("float", 3.14159)
352 ps.setDouble("double", 2.718281828459045)
353 ps.set("char*", "foo")
354 ps.setString("string", "bar")
355 ps.set("int2", 2009)
356 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
357 ps.set("autobool", True)
359 self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool)
360 self.assertIs(ps.getBool("bool"), True)
361 self.assertIs(ps.get("bool"), True)
362 self.assertEqual(ps.getArray("bool"), [True])
363 self.assertIs(ps.getScalar("bool"), True)
364 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short)
365 self.assertEqual(ps.getShort("short"), 42)
366 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
367 self.assertEqual(ps.getInt("int"), 2008)
368 self.assertEqual(ps.typeOf("int64_t"),
369 dafBase.PropertySet.TYPE_LongLong)
370 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef)
371 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong)
372 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF)
373 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float)
374 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6)
375 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double)
376 self.assertEqual(ps.getDouble("double"), 2.718281828459045)
377 self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String)
378 self.assertEqual(ps.getString("char*"), "foo")
379 self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String)
380 self.assertEqual(ps.getString("string"), "bar")
381 self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int)
382 self.assertEqual(ps.getInt("int2"), 2009)
383 self.assertEqual(ps.get("int2"), 2009)
384 self.assertEqual(ps.getArray("int2"), [2009])
385 self.assertEqual(ps.getScalar("int2"), 2009)
386 self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime)
387 self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265)
388 self.assertEqual(ps.typeOf("autobool"), dafBase.PropertySet.TYPE_Bool)
389 self.assertIs(ps.get("autobool"), True)
390 self.assertEqual(ps.getArray("autobool"), [True])
391 self.assertIs(ps.getScalar("autobool"), True)
393 def testGetDefault(self):
394 ps = dafBase.PropertySet(flat=True)
395 ps.setInt("int", 42)
396 self.assertEqual(ps.getInt("int"), 42)
397 self.assertEqual(ps.getInt("int", 2008), 42)
398 self.assertEqual(ps.getInt("foo", 2008), 2008)
400 def testExists(self):
401 ps = dafBase.PropertySet(flat=True)
402 ps.setInt("int", 42)
403 self.assertEqual(ps.exists("int"), True)
404 self.assertEqual(ps.exists("foo"), False)
406 def testGetVector(self):
407 ps = dafBase.PropertySet(flat=True)
408 v = [42, 2008, 1]
409 ps.setInt("ints", v)
410 ps.setInt("ints2", [10, 9, 8])
411 w = ps.getArrayInt("ints")
412 self.assertEqual(len(w), 3)
413 self.assertEqual(v, w)
414 self.assertEqual(ps.getInt("ints2"), 8)
415 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
416 self.assertEqual(ps.getArray("ints"), v)
417 self.assertEqual(ps.getScalar("ints"), v[-1])
418 ps.setInt("int", 999)
419 x = ps.get("int")
420 self.assertEqual(x, 999)
421 self.assertEqual(ps.getArray("int"), [999])
422 self.assertEqual(ps.getScalar("int"), 999)
424 def testGetVector2(self):
425 ps = dafBase.PropertySet(flat=True)
426 v = [42, 2008, 1]
427 ps.setInt("ints", v)
428 ps.setInt("ints2", [10, 9, 8])
429 w = ps.getArrayInt("ints")
430 self.assertEqual(w, v)
431 self.assertEqual(ps.getInt("ints2"), 8)
432 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8])
434 def testAddScalar(self):
435 ps = dafBase.PropertySet(flat=True)
436 v = [42, 2008, 1]
437 ps.setInt("ints", v)
438 ps.addInt("ints", -999)
439 ps.add("other", "foo")
440 ps.add("ints", 13)
441 w = ps.getArrayInt("ints")
442 self.assertEqual(len(w), 5)
443 self.assertEqual(v[0], w[0])
444 self.assertEqual(v[1], w[1])
445 self.assertEqual(v[2], w[2])
446 self.assertEqual(w[3], -999)
447 self.assertEqual(w[4], 13)
448 self.assertEqual(ps.getString("other"), "foo")
450 def testDateTimeToString(self):
451 ps = dafBase.PropertySet(flat=True)
452 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
453 self.assertEqual(ps.toString(),
454 "dt = 2009-04-02T07:26:39.314159265Z\n")
456 def testGetScalarThrow(self):
457 ps = dafBase.PropertySet(flat=True)
458 ps.setBool("bool", True)
459 ps.setShort("short", 42)
460 ps.setInt("int", 2008)
461 with self.assertRaises(KeyError):
462 ps["foo"]
463 self.assertIsNone(ps.get("foo"))
465 def testSubPS(self):
466 ps = dafBase.PropertySet(flat=True)
467 ps1 = dafBase.PropertySet()
468 ps1.set("a", 1)
469 ps1.add("a", 2)
470 ps1.set("foo", "bar")
471 ps.setPropertySet("b", ps1)
472 self.assertEqual(ps.exists("b.a"), True)
473 self.assertEqual(ps.get("b.a"), 2)
474 self.assertEqual(ps.getArray("b.a"), [1, 2])
475 self.assertEqual(ps.getScalar("b.a"), 2)
476 self.assertEqual(ps.exists("b"), False)
477 self.assertEqual(ps.exists("b.foo"), True)
478 self.assertEqual(ps.get("b.foo"), "bar")
479 self.assertEqual(ps.getArray("b.foo"), ["bar"])
480 self.assertEqual(ps.getScalar("b.foo"), "bar")
482 ps.set("b.c", 20)
483 self.assertEqual(ps.exists("b.c"), True)
484 self.assertEqual(ps.get("b.c"), 20)
485 self.assertEqual(ps.getArray("b.c"), [20])
486 self.assertEqual(ps.getScalar("b.c"), 20)
487 self.assertEqual(ps.exists("b"), False)
489 def testCombine(self):
490 ps = dafBase.PropertySet()
491 ps.set("ps1.pre", 1)
492 ps.set("ps1.pre", 1)
493 ps.set("ps1.post", 2)
494 ps.set("int", 42)
495 ps.set("double", 3.14)
496 ps.set("ps2.plus", 10.24)
497 ps.set("ps2.minus", -10.24)
498 ps.set("ps3.sub.subsub", "foo")
500 psp = dafBase.PropertySet()
501 psp.set("ps1.pre", 3)
502 psp.add("ps1.pre", 4)
503 psp.set("int", 2008)
504 psp.set("ps2.foo", "bar")
505 psp.set("ps4.top", "bottom")
507 ps.combine(psp)
509 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet)
510 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet)
511 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet)
512 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet)
513 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet)
515 self.assertFalse(ps.isArray("ps1"))
516 self.assertTrue(ps.isArray("ps1.pre"))
517 self.assertFalse(ps.isArray("ps1.post"))
518 self.assertFalse(ps.isArray("ps2"))
519 self.assertFalse(ps.isArray("ps2.plus"))
520 self.assertFalse(ps.isArray("ps2.minus"))
521 self.assertFalse(ps.isArray("ps2.foo"))
522 self.assertFalse(ps.isArray("ps3"))
523 self.assertFalse(ps.isArray("ps3.sub"))
524 self.assertFalse(ps.isArray("ps3.subsub"))
525 self.assertFalse(ps.isArray("ps4"))
526 self.assertFalse(ps.isArray("ps4.top"))
527 self.assertTrue(ps.isArray("int"))
528 self.assertFalse(ps.isArray("double"))
530 self.assertEqual(ps.valueCount("ps1.pre"), 3)
531 self.assertEqual(ps.valueCount("int"), 2)
532 self.assertEqual(ps.valueCount(), 12)
534 v = ps.getArray("ps1.pre")
535 self.assertEqual(v, [1, 3, 4])
536 v = ps.getArray("int")
537 self.assertEqual(v, [42, 2008])
539 def testUpdate(self):
540 ps = dafBase.PropertySet()
541 ps.set("ps1.pre", 1)
542 ps.set("ps1.pre", 1)
543 ps.set("ps1.post", 2)
544 ps.set("int", 42)
545 ps.set("double", 3.14)
546 ps.set("ps2.plus", 10.24)
547 ps.set("ps2.minus", -10.24)
548 ps.set("ps3.sub.subsub", "foo")
550 psp = dafBase.PropertySet()
551 psp.set("ps1.pre", 3)
552 psp.add("ps1.pre", 4)
553 psp.set("int", 2008)
554 psp.set("ps2.foo", "bar")
555 psp.set("ps4.top", "bottom")
557 ps.update(psp)
559 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet)
560 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet)
561 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet)
562 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet)
563 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet)
565 self.assertFalse(ps.isArray("ps1"))
566 self.assertTrue(ps.isArray("ps1.pre"))
567 self.assertFalse(ps.isArray("ps1.post"))
568 self.assertFalse(ps.isArray("ps2"))
569 self.assertFalse(ps.isArray("ps2.plus"))
570 self.assertFalse(ps.isArray("ps2.minus"))
571 self.assertFalse(ps.isArray("ps2.foo"))
572 self.assertFalse(ps.isArray("ps3"))
573 self.assertFalse(ps.isArray("ps3.sub"))
574 self.assertFalse(ps.isArray("ps3.subsub"))
575 self.assertFalse(ps.isArray("ps4"))
576 self.assertFalse(ps.isArray("ps4.top"))
577 self.assertFalse(ps.isArray("int"))
578 self.assertFalse(ps.isArray("double"))
580 self.assertEqual(ps.valueCount("ps1.pre"), 2)
581 self.assertEqual(ps.valueCount("int"), 1)
582 self.assertEqual(ps.valueCount(), 7)
584 v = ps.getArray("ps1.pre")
585 self.assertEqual(v, [3, 4])
586 v = ps.getArray("int")
587 self.assertEqual(v, [2008])
589 psd = {"int": 100, "str": "String", "apl1.foo": 10.5}
590 ps.update(psd)
591 self.assertEqual(ps["int"], psd["int"])
592 self.assertEqual(ps["str"], psd["str"])
593 self.assertEqual(ps["apl1.foo"], psd["apl1.foo"])
594 self.assertEqual(ps["double"], 3.14)
596 def testCombineThrow(self):
597 ps = dafBase.PropertySet()
598 ps.set("int", 42)
600 psp = dafBase.PropertySet()
601 psp.set("int", 3.14159)
603 with self.assertRaises(TypeError):
604 ps.combine(psp)
606 psd = {"bool": True}
607 with self.assertRaises(TypeError):
608 ps.combine(psd)
610 def testToDict(self):
611 ps = dafBase.PropertySet()
612 ps.setBool("bool", True)
613 ps.setShort("short", 42)
614 ps.setInt("int", 2008)
615 ps.setLongLong("int64_t", 0xfeeddeadbeef)
616 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF)
617 ps.setInt("ints", [10, 9, 8])
619 ps2 = dafBase.PropertySet()
620 ps2.set("ps", ps)
621 ps2.setFloat("float", 3.14159)
622 ps2.setDouble("double", 2.718281828459045)
623 ps2.set("char*", "foo")
624 ps2.setString("string", "bar")
625 ps2.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC))
626 ps2.set("undef", None)
628 d = ps2.toDict()
629 self.assertIsInstance(d, dict)
631 self.assertIsInstance(d["float"], float)
632 self.assertAlmostEqual(d["float"], 3.14159, 6)
633 self.assertIsInstance(d["double"], float)
634 self.assertEqual(d["double"], 2.718281828459045)
635 self.assertIsNone(d["undef"])
637 self.assertIsInstance(d["char*"], str)
638 self.assertEqual(d["char*"], "foo")
639 self.assertIsInstance(d["string"], str)
640 self.assertEqual(d["string"], "bar")
641 self.assertIsInstance(d["dt"], dafBase.DateTime)
642 self.assertEqual(d["dt"].nsecs(), 1238657233314159265)
644 # Check round tripping.
645 from_dict = dafBase.PropertySet.from_mapping(d)
647 # The specialist type fields (float, short, uint64_t) will not
648 # round trip properly and so use string equality and remove the
649 # float field because the number of figures changes.
650 # The float field won't round trip so has to be examined separately
651 # because the type will have changed.
652 self.assertAlmostEqual(from_dict["float"], ps2["float"])
653 del ps2["float"]
654 del from_dict["float"]
655 self.assertEqual(str(from_dict), str(ps2))
657 # Test again, but relying on the toDict method of a PropertySet
658 self.assertEqual(str(dafBase.PropertySet.from_mapping(ps2)), str(ps2))
660 with self.assertRaises(ValueError):
661 dafBase.PropertySet.from_mapping([])
663 d2 = d["ps"]
664 self.assertIsInstance(d2, dict)
666 self.assertIsInstance(d2["bool"], bool)
667 self.assertEqual(d2["bool"], True)
668 self.assertIsInstance(d2["short"], (int, int))
669 self.assertEqual(d2["short"], 42)
670 self.assertIsInstance(d2["int"], (int, int))
671 self.assertEqual(d2["int"], 2008)
672 self.assertIsInstance(d2["int64_t"], (int, int))
673 self.assertEqual(d2["int64_t"], 0xfeeddeadbeef)
674 self.assertIsInstance(d2["uint64_t"], (int, int))
675 self.assertEqual(d2["uint64_t"], 0xFFFFFFFFFFFFFFFF)
676 self.assertIsInstance(d2["ints"], list)
677 self.assertIsInstance(d2["ints"][0], (int, int))
678 self.assertEqual(d2["ints"], [10, 9, 8])
680 def testFromDataclass(self):
681 """Test creation of PropertySet from a dataclass."""
683 @dataclasses.dataclass
684 class TestData:
685 string: str
686 number: int
688 t = TestData("test", 42)
689 ps = dafBase.PropertySet.from_mapping(t)
690 self.assertEqual(ps.toDict(), {"string": "test", "number": 42})
692 def testAddVector(self):
693 ps = dafBase.PropertySet()
694 v = [42, 2008, 1]
695 ps.set("ints", v)
697 vv = [-42, -2008, -1]
698 ps.add("ints", vv)
700 w = ps.getArray("ints")
701 self.assertEqual(w, v + vv)
703 def testArrayProperties(self):
704 ps = dafBase.PropertySet()
705 v = [42, 2008, 1]
706 ps.set("ints", v)
707 ps.set("int", 365)
708 ps.set("ints2", -42)
709 ps.add("ints2", -2008)
711 self.assertTrue(ps.isArray("ints"))
712 self.assertFalse(ps.isArray("int"))
713 self.assertTrue(ps.isArray("ints2"))
714 self.assertEqual(ps.valueCount("ints"), 3)
715 self.assertEqual(ps.valueCount("int"), 1)
716 self.assertEqual(ps.valueCount("ints2"), 2)
717 self.assertEqual(ps.valueCount(), 6)
718 self.assertEqual(ps.typeOf("ints"), dafBase.PropertySet.TYPE_Int)
719 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int)
720 self.assertEqual(ps.typeOf("ints2"), dafBase.PropertySet.TYPE_Int)
722 def testHierarchy(self):
723 ps = dafBase.PropertySet()
724 psp = dafBase.PropertySet()
726 psp.set("pre", 1)
727 ps.set("ps1", psp)
728 psp.set("post", 2)
729 ps.set("int", 42)
730 ps.set("ps2", dafBase.PropertySet())
731 ps.getPropertySet("ps2").set("plus", 10.24)
732 ps.set("ps2.minus", -10.24)
733 ps.set("ps3.sub1", "foo")
734 ps.set("ps3.sub2", "bar")
736 self.assertTrue(ps.exists("ps1"))
737 self.assertTrue(ps.exists("ps2"))
738 self.assertTrue(ps.exists("ps3"))
739 self.assertTrue(ps.exists("ps1.pre"))
740 self.assertTrue(ps.exists("ps1.post"))
741 self.assertTrue(ps.exists("ps2.plus"))
742 self.assertTrue(ps.exists("ps2.minus"))
743 self.assertTrue(ps.exists("ps3.sub1"))
744 self.assertTrue(ps.exists("ps3.sub2"))
746 self.assertTrue(ps.isPropertySetPtr("ps1"))
747 self.assertTrue(ps.isPropertySetPtr("ps2"))
748 self.assertTrue(ps.isPropertySetPtr("ps3"))
749 self.assertFalse(ps.isPropertySetPtr("int"))
750 self.assertFalse(ps.isPropertySetPtr("ps1.pre"))
751 self.assertFalse(ps.isPropertySetPtr("ps1.post"))
752 self.assertFalse(ps.isPropertySetPtr("ps2.plus"))
753 self.assertFalse(ps.isPropertySetPtr("ps2.minus"))
754 self.assertFalse(ps.isPropertySetPtr("ps3.sub1"))
755 self.assertFalse(ps.isPropertySetPtr("ps3.sub2"))
757 psp1 = ps.getPropertySet("ps1")
758 psp2 = ps.getPropertySet("ps2")
759 psp3 = ps.getPropertySet("ps3")
760 self.assertIsInstance(psp1, dafBase.PropertySet)
761 self.assertIsInstance(psp2, dafBase.PropertySet)
762 self.assertIsInstance(psp3, dafBase.PropertySet)
763 self.assertEqual(psp1, psp)
764 self.assertTrue(psp1.exists("pre"))
765 self.assertTrue(psp1.exists("post"))
766 self.assertTrue(psp2.exists("plus"))
767 self.assertTrue(psp2.exists("minus"))
768 self.assertTrue(psp3.exists("sub1"))
769 self.assertTrue(psp3.exists("sub2"))
770 self.assertEqual(psp1.getAsInt("pre"), 1)
771 self.assertEqual(psp1.getAsInt("post"), 2)
772 self.assertEqual(psp2.getAsDouble("plus"), 10.24)
773 self.assertEqual(psp2.getAsDouble("minus"), -10.24)
774 self.assertEqual(psp3.getAsString("sub1"), "foo")
775 self.assertEqual(psp3.getAsString("sub2"), "bar")
777 # Make sure checking a subproperty doesn't create it.
778 self.assertFalse(ps.exists("ps2.pre"))
779 self.assertFalse(ps.exists("ps2.pre"))
780 # Make sure checking an element doesn't create it.
781 self.assertFalse(ps.exists("ps4"))
782 self.assertFalse(ps.exists("ps4"))
783 # Make sure checking a subproperty with a nonexistent parent doesn't
784 # create it.
785 self.assertFalse(ps.exists("ps4.sub"))
786 self.assertFalse(ps.exists("ps4.sub"))
787 # Make sure checking a subproperty doesn't create its parent.
788 self.assertFalse(ps.exists("ps4"))
790#
791 def testvariousThrows(self):
792 ps = dafBase.PropertySet()
793 ps.set("int", 42)
794 with self.assertRaises(pexExcept.InvalidParameterError):
795 ps.set("int.sub", "foo")
796 with self.assertRaises(TypeError):
797 ps.getDouble("int")
798 with self.assertRaises(LookupError):
799 ps.getDouble("double")
800 with self.assertRaises(KeyError):
801 ps.getArray("double")
802 with self.assertRaises(LookupError):
803 ps.typeOf("double")
804 with self.assertRaises(TypeError):
805 ps.add("int", 4.2)
807 v = [3.14159, 2.71828]
808 with self.assertRaises(TypeError):
809 ps.add("int", v)
810 ps.remove("foo.bar")
811 ps.remove("int.sub")
813 def testIntegerRanges(self):
814 """Test that the ranges of the various integer types is as expected
815 """
816 ps = dafBase.PropertySet()
817 minI32 = -2**31
818 maxI32 = 2**31 - 1
819 minI64 = -2**63
820 maxI64 = 2**63 - 1
821 minU64 = 0
822 maxU64 = 2**64 - 1
823 # Out of range for the particular type
824 self.assertRaises(TypeError, ps.addInt, "int32", minI32 - 1)
825 self.assertRaises(TypeError, ps.addInt, "int32", maxI32 + 1)
826 self.assertRaises(TypeError, ps.addLongLong, "int64", minI64 - 1)
827 self.assertRaises(TypeError, ps.addLongLong, "int64", maxI64 + 1)
828 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", minU64 - 1)
829 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", maxU64 + 1)
830 # Out of all possible integer ranges
831 self.assertRaises(RuntimeError, ps.add, "number", minI64 - 1)
832 self.assertRaises(RuntimeError, ps.add, "number", maxU64 + 1)
834 def testNames(self):
835 ps = dafBase.PropertySet()
836 ps.set("ps1.pre", 1)
837 ps.set("ps1.post", 2)
838 ps.set("int", 42)
839 ps.set("double", 3.14)
840 ps.set("ps2.plus", 10.24)
841 ps.set("ps2.minus", -10.24)
843 self.assertEqual(ps.nameCount(), 4)
844 self.assertEqual(ps.nameCount(False), 8)
846 v = set(ps.names())
847 self.assertEqual(len(v), 4)
848 self.assertEqual(v, {"double", "int", "ps1", "ps2"})
849 v = set(ps.names(False))
850 self.assertEqual(len(v), 8)
851 self.assertEqual(v, {"double", "int", "ps1", "ps1.post",
852 "ps1.pre", "ps2", "ps2.minus", "ps2.plus"})
854 def testParamNames(self):
855 ps = dafBase.PropertySet()
856 ps.set("ps1.pre", 1)
857 ps.set("ps1.post", 2)
858 ps.set("int", 42)
859 ps.set("double", 3.14)
860 ps.set("ps2.plus", 10.24)
861 ps.set("ps2.minus", -10.24)
863 v = set(ps.paramNames())
864 self.assertEqual(len(v), 2)
865 self.assertEqual(v, {"double", "int"})
866 v = set(ps.paramNames(False))
867 self.assertEqual(len(v), 6)
868 self.assertEqual(v, {"double", "int", "ps1.post", "ps1.pre",
869 "ps2.minus", "ps2.plus"})
871 def testPropertySetNames(self):
872 ps = dafBase.PropertySet()
873 ps.set("ps1.pre", 1)
874 ps.set("ps1.post", 2)
875 ps.set("int", 42)
876 ps.set("double", 3.14)
877 ps.set("ps2.plus", 10.24)
878 ps.set("ps2.minus", -10.24)
879 ps.set("ps3.sub.subsub", "foo")
881 v = set(ps.propertySetNames())
882 self.assertEqual(len(v), 3)
883 self.assertEqual(v, {"ps1", "ps2", "ps3"})
884 v = set(ps.propertySetNames(False))
885 self.assertEqual(len(v), 4)
886 self.assertEqual(v, {"ps1", "ps2", "ps3", "ps3.sub"})
888 def testGetAs(self):
889 ps = dafBase.PropertySet()
890 ps.set("bool", True)
891 ps.setShort("short", 42)
892 ps.set("int", 2008)
893 ps.set("int64_t", 0xfeeddeadbeef)
894 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF)
895 f = 3.14159
896 ps.setFloat("float", f)
897 d = 2.718281828459045
898 ps.setDouble("double", d)
899 ps.setString("char*", "foo")
900 ps.set("char*2", "foo2")
901 ps.set("string", "bar")
902 psp = dafBase.PropertySet()
903 psp.set("bottom", "x")
904 ps.set("top", psp)
906 self.assertIs(ps.getAsBool("bool"), True)
907 self.assertEqual(ps.getAsInt("bool"), 1)
908 self.assertEqual(ps.getAsInt("short"), 42)
909 self.assertEqual(ps.getAsInt("int"), 2008)
910 with self.assertRaises(TypeError):
911 ps.getAsInt("int64_t")
912 with self.assertRaises(TypeError):
913 ps.getAsInt("uint64_t")
914 with self.assertRaises(TypeError):
915 ps.getAsInt64("uint64_t")
916 self.assertEqual(ps.getAsInt64("bool"), 1)
917 self.assertEqual(ps.getAsInt64("short"), 42)
918 self.assertEqual(ps.getAsInt64("int"), 2008)
919 self.assertEqual(ps.getAsInt64("int64_t"), 0xfeeddeadbeef)
920 self.assertEqual(ps.getAsUInt64("uint64_t"), 0xFFFFFFFFFFFFFFFF)
921 with self.assertRaises(TypeError):
922 ps.getAsInt64("float")
923 with self.assertRaises(TypeError):
924 ps.getAsUInt64("float")
925 self.assertEqual(ps.getAsDouble("bool"), 1.0)
926 self.assertEqual(ps.getAsDouble("short"), 42.0)
927 self.assertEqual(ps.getAsDouble("int"), 2008.0)
928 self.assertEqual(ps.getAsDouble("int64_t"),
929 float(0xfeeddeadbeef))
930 self.assertEqual(ps.getAsDouble("uint64_t"),
931 float(0xFFFFFFFFFFFFFFFF))
932 self.assertAlmostEqual(ps.getAsDouble("float"), 3.14159, places=5)
933 self.assertAlmostEqual(ps.getAsDouble("double"), 2.718281828459045, places=15)
934 with self.assertRaises(TypeError):
935 ps.getAsDouble("char*")
936 self.assertEqual(ps.getAsString("char*"), "foo")
937 self.assertEqual(ps.getAsString("char*2"), "foo2")
938 self.assertEqual(ps.getAsString("string"), "bar")
939 with self.assertRaises(TypeError):
940 ps.getAsString("int")
941 self.assertEqual(ps.getAsString("top.bottom"), "x")
942 self.assertEqual(ps.getAsPropertySetPtr("top"), psp)
943 with self.assertRaises(TypeError):
944 ps.getAsPropertySetPtr("top.bottom")
946 def testRemove(self):
947 ps = dafBase.PropertySet()
948 ps.set("int", 42)
949 ps.set("double", 3.14159)
950 ps.set("ps1.plus", 1)
951 ps.set("ps1.minus", -1)
952 ps.set("ps1.zero", 0)
953 self.assertEqual(ps.nameCount(False), 6)
955 ps.remove("int")
956 self.assertFalse(ps.exists("int"))
957 self.assertEqual(ps.getAsDouble("double"), 3.14159)
958 self.assertEqual(ps.getAsInt("ps1.plus"), 1)
959 self.assertEqual(ps.getAsInt("ps1.minus"), -1)
960 self.assertEqual(ps.getAsInt("ps1.zero"), 0)
961 self.assertEqual(ps.nameCount(False), 5)
963 ps.remove("ps1.zero")
964 self.assertFalse(ps.exists("int"))
965 self.assertEqual(ps.getAsDouble("double"), 3.14159)
966 self.assertFalse(ps.exists("ps1.zero"))
967 self.assertEqual(ps.getAsInt("ps1.plus"), 1)
968 self.assertEqual(ps.getAsInt("ps1.minus"), -1)
969 self.assertEqual(ps.nameCount(False), 4)
971 ps.remove("ps1")
972 self.assertFalse(ps.exists("int"))
973 self.assertEqual(ps.getAsDouble("double"), 3.14159)
974 self.assertFalse(ps.exists("ps1"))
975 self.assertFalse(ps.exists("ps1.plus"))
976 self.assertFalse(ps.exists("ps1.minus"))
977 self.assertFalse(ps.exists("ps1.zero"))
978 self.assertEqual(ps.nameCount(False), 1)
980 ps.remove("double")
981 self.assertFalse(ps.exists("int"))
982 self.assertFalse(ps.exists("double"))
983 self.assertFalse(ps.exists("ps1"))
984 self.assertFalse(ps.exists("ps1.plus"))
985 self.assertFalse(ps.exists("ps1.minus"))
986 self.assertFalse(ps.exists("ps1.zero"))
987 self.assertEqual(ps.nameCount(False), 0)
989 def testDeepCopy(self):
990 ps = dafBase.PropertySet()
991 ps.set("int", 42)
992 psp = dafBase.PropertySet()
993 psp.set("bottom", "x")
994 ps.set("top", psp)
996 psp2 = ps.deepCopy()
997 self.assertTrue(psp2.exists("int"))
998 self.assertTrue(psp2.exists("top.bottom"))
999 self.assertEqual(psp2.getAsInt("int"), 42)
1000 self.assertEqual(psp2.getAsString("top.bottom"), "x")
1001 # Make sure it was indeed a deep copy.
1002 ps.set("int", 2008)
1003 ps.set("top.bottom", "y")
1004 self.assertEqual(ps.getAsInt("int"), 2008)
1005 self.assertEqual(ps.getAsString("top.bottom"), "y")
1006 self.assertEqual(psp.getAsString("bottom"), "y")
1007 self.assertEqual(psp2.getAsInt("int"), 42)
1008 self.assertEqual(psp2.getAsString("top.bottom"), "x")
1010 def testToString(self):
1011 ps = dafBase.PropertySet()
1012 ps.set("bool", True)
1013 s = 42
1014 ps.setShort("short", s)
1015 ps.set("int", 2008)
1016 ps.set("int64_t", 0xfeeddeadbeef)
1017 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF)
1018 f = 3.14159
1019 ps.setFloat("float", f)
1020 d = 2.718281828459045
1021 ps.setDouble("double", d)
1022 ps.setString("char*", "foo")
1023 ps.set("char*2", "foo2")
1024 ps.set("string", "bar")
1025 ps.set("ps1.pre", 1)
1026 ps.set("ps1.post", 2)
1027 ps.set("ps2.plus", 10.24)
1028 ps.set("ps2.minus", -10.24)
1029 ps.set("ps3.sub.subsub", "foo")
1030 ps.add("v", 10)
1031 ps.add("v", 9)
1032 ps.add("v", 8)
1034 self.assertEqual(ps.toString(),
1035 "bool = 1\n"
1036 "char* = \"foo\"\n"
1037 "char*2 = \"foo2\"\n"
1038 "double = 2.7182818284590\n"
1039 "float = 3.141590\n"
1040 "int = 2008\n"
1041 "int64_t = 280297596632815\n"
1042 "ps1 = {\n"
1043 "..post = 2\n"
1044 "..pre = 1\n"
1045 "}\n"
1046 "ps2 = {\n"
1047 "..minus = -10.240000000000\n"
1048 "..plus = 10.240000000000\n"
1049 "}\n"
1050 "ps3 = {\n"
1051 "..sub = {\n"
1052 "....subsub = \"foo\"\n"
1053 "..}\n"
1054 "}\n"
1055 "short = 42\n"
1056 "string = \"bar\"\n"
1057 "uint64_t = 18446744073709551615\n"
1058 "v = [ 10, 9, 8 ]\n"
1059 )
1060 self.assertEqual(ps.toString(True),
1061 "bool = 1\n"
1062 "char* = \"foo\"\n"
1063 "char*2 = \"foo2\"\n"
1064 "double = 2.7182818284590\n"
1065 "float = 3.141590\n"
1066 "int = 2008\n"
1067 "int64_t = 280297596632815\n"
1068 "ps1 = { ... }\n"
1069 "ps2 = { ... }\n"
1070 "ps3 = { ... }\n"
1071 "short = 42\n"
1072 "string = \"bar\"\n"
1073 "uint64_t = 18446744073709551615\n"
1074 "v = [ 10, 9, 8 ]\n"
1075 )
1078class TestMemory(lsst.utils.tests.MemoryTestCase):
1079 pass
1082def setup_module(module):
1083 lsst.utils.tests.init()
1086if __name__ == "__main__": 1086 ↛ 1087line 1086 didn't jump to line 1087, because the condition on line 1086 was never true
1087 lsst.utils.tests.init()
1088 unittest.main()