Coverage for tests/test_PropertySet_2.py : 6%

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