Hide keyboard shortcuts

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# 

23 

24import pickle 

25import unittest 

26 

27import numpy as np 

28 

29import lsst.utils.tests 

30import lsst.daf.base as dafBase 

31import lsst.pex.exceptions as pexExcept 

32 

33 

34class PropertySetTestCase(unittest.TestCase): 

35 """A test case for PropertySet. 

36 """ 

37 

38 def testConstruct(self): 

39 ps = dafBase.PropertySet() 

40 self.assertIsNotNone(ps) 

41 

42 def checkPickle(self, original): 

43 new = pickle.loads(pickle.dumps(original, 4)) 

44 self.assertEqual(new, original) 

45 

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) 

63 

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 

93 self.assertIsNone(ps.getScalar("undef")) 

94 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_Undef) 

95 self.assertIsNone(ps.get("undef")) 

96 

97 self.checkPickle(ps) 

98 

99 # Now replace the undef value with a defined value 

100 ps.set("undef", "not undefined") 

101 self.assertEqual(ps.getScalar("undef"), "not undefined") 

102 self.assertFalse(ps.isUndefined("undef")) 

103 self.assertEqual(ps.typeOf("undef"), dafBase.PropertyList.TYPE_String) 

104 

105 def testNumPyScalars(self): 

106 """Test that we can also pass NumPy array scalars to PropertySet 

107 setters. 

108 """ 

109 ps = dafBase.PropertySet() 

110 ps.setShort("short", np.int16(42)) 

111 ps.setInt("int", np.int32(2008)) 

112 ps.setLongLong("int64_t", np.int64(0xfeeddeadbeef)) 

113 ps.setUnsignedLongLong("uint64_t", np.uint64(0xFFFFFFFFFFFFFFFF)) 

114 ps.setFloat("float", np.float32(3.14159)) 

115 ps.setDouble("double", np.float64(2.718281828459045)) 

116 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short) 

117 self.assertEqual(ps.getShort("short"), 42) 

118 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int) 

119 self.assertEqual(ps.getInt("int"), 2008) 

120 self.assertEqual(ps.typeOf("int64_t"), 

121 dafBase.PropertySet.TYPE_LongLong) 

122 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef) 

123 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong) 

124 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF) 

125 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float) 

126 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6) 

127 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double) 

128 self.assertEqual(ps.getDouble("double"), 2.718281828459045) 

129 self.checkPickle(ps) 

130 

131 def testGetDefault(self): 

132 ps = dafBase.PropertySet() 

133 ps.setInt("int", 42) 

134 self.assertEqual(ps.getInt("int"), 42) 

135 self.assertEqual(ps.getInt("int", 2008), 42) 

136 self.assertEqual(ps.getInt("foo", 2008), 2008) 

137 self.assertEqual(ps.get("int"), 42) 

138 self.assertEqual(ps.get("int", 2008), 42) 

139 self.assertEqual(ps.get("foo", 2008), 2008) 

140 self.assertEqual(ps.get("foo2", default="missing"), "missing") 

141 self.assertIsNone(ps.get("foo")) 

142 self.checkPickle(ps) 

143 

144 def testExists(self): 

145 ps = dafBase.PropertySet() 

146 ps.setInt("int", 42) 

147 self.checkPickle(ps) 

148 self.assertEqual(ps.exists("int"), True) 

149 self.assertEqual(ps.exists("foo"), False) 

150 

151 def testGetVector(self): 

152 ps = dafBase.PropertySet() 

153 v = [42, 2008, 1] 

154 ps.setInt("ints", v) 

155 ps.setInt("ints2", [10, 9, 8]) 

156 w = ps.getArrayInt("ints") 

157 self.assertEqual(len(w), 3) 

158 self.assertEqual(v, w) 

159 self.assertEqual(ps.getInt("ints2"), 8) 

160 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8]) 

161 self.assertEqual(ps.getArray("ints"), v) 

162 self.assertEqual(ps.getScalar("ints"), v[-1]) 

163 self.assertEqual(ps["ints"], v[-1]) 

164 ps.setInt("int", 999) 

165 x = ps.get("int") 

166 self.assertEqual(x, 999) 

167 self.assertEqual(ps.getArray("int"), [999]) 

168 self.assertEqual(ps.getScalar("int"), 999) 

169 self.assertEqual(ps["int"], 999) 

170 self.checkPickle(ps) 

171 

172 def testGetVector2(self): 

173 ps = dafBase.PropertySet() 

174 v = [42, 2008, 1] 

175 ps.setInt("ints", v) 

176 ps.setInt("ints2", [10, 9, 8]) 

177 w = ps.getArrayInt("ints") 

178 self.assertEqual(len(w), 3) 

179 self.assertEqual(v[0], w[0]) 

180 self.assertEqual(v[1], w[1]) 

181 self.assertEqual(v[2], w[2]) 

182 self.assertEqual(ps.getInt("ints2"), 8) 

183 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8]) 

184 self.checkPickle(ps) 

185 

186 def testAddScalar(self): 

187 ps = dafBase.PropertySet() 

188 v = [42, 2008, 1] 

189 ps.setInt("ints", v) 

190 ps.addInt("ints", -999) 

191 ps.add("other", "foo") 

192 ps.add("ints", 13) 

193 w = ps.getArrayInt("ints") 

194 self.assertEqual(len(w), 5) 

195 self.assertEqual(v[0], w[0]) 

196 self.assertEqual(v[1], w[1]) 

197 self.assertEqual(v[2], w[2]) 

198 self.assertEqual(w[3], -999) 

199 self.assertEqual(w[4], 13) 

200 self.assertEqual(ps.getString("other"), "foo") 

201 self.checkPickle(ps) 

202 

203 def testSetAddVector(self): 

204 ps = dafBase.PropertySet() 

205 boolArr = [True, False] 

206 intArr = [1, -1, 2] 

207 floatArr = [1.2, 99.5, -35.1] 

208 strArr = ["this", "is", "some strings"] 

209 ps.set("bools", boolArr) 

210 ps.set("ints", intArr) 

211 ps.set("floats", floatArr) 

212 ps.set("strs", strArr) 

213 self.assertEqual(ps.get("bools"), boolArr[-1]) 

214 self.assertEqual(ps.getArray("bools"), boolArr) 

215 self.assertEqual(ps.getScalar("bools"), boolArr[-1]) 

216 self.assertEqual(ps.get("ints"), intArr[-1]) 

217 self.assertEqual(ps.getArray("ints"), intArr) 

218 self.assertEqual(ps.getScalar("ints"), intArr[-1]) 

219 self.assertEqual(ps.get("floats"), floatArr[-1]) 

220 self.assertEqual(ps.getArray("floats"), floatArr) 

221 self.assertEqual(ps.getScalar("floats"), floatArr[-1]) 

222 self.assertEqual(ps.get("strs"), strArr[-1]) 

223 self.assertEqual(ps.getArray("strs"), strArr) 

224 self.assertEqual(ps.getScalar("strs"), strArr[-1]) 

225 

226 ps.add("bools", list(reversed(boolArr))) 

227 ps.add("ints", list(reversed(intArr))) 

228 ps.add("floats", list(reversed(floatArr))) 

229 ps.add("strs", list(reversed(strArr))) 

230 self.assertEqual(ps.get("bools"), boolArr[0]) 

231 self.assertEqual(ps.getArray("bools"), boolArr + list(reversed(boolArr))) 

232 self.assertEqual(ps.getScalar("bools"), boolArr[0]) 

233 self.assertEqual(ps.get("ints"), intArr[0]) 

234 self.assertEqual(ps.getArray("ints"), intArr + list(reversed(intArr))) 

235 self.assertEqual(ps.getScalar("ints"), intArr[0]) 

236 self.assertEqual(ps.get("floats"), floatArr[0]) 

237 self.assertEqual(ps.getArray("floats"), floatArr + list(reversed(floatArr))) 

238 self.assertEqual(ps.getScalar("floats"), floatArr[0]) 

239 self.assertEqual(ps.get("strs"), strArr[0]) 

240 self.assertEqual(ps.getArray("strs"), strArr + list(reversed(strArr))) 

241 self.assertEqual(ps.getScalar("strs"), strArr[0]) 

242 self.checkPickle(ps) 

243 

244 def testDateTimeToString(self): 

245 ps = dafBase.PropertySet() 

246 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC)) 

247 self.assertEqual(ps.toString(), 

248 "dt = 2009-04-02T07:26:39.314159265Z\n") 

249 self.checkPickle(ps) 

250 

251 def testGetScalarThrow(self): 

252 ps = dafBase.PropertySet() 

253 ps.setBool("bool", True) 

254 ps.setShort("short", 42) 

255 ps.setInt("int", 2008) 

256 with self.assertRaises(KeyError): 

257 ps["foo"] 

258 # This will not throw 

259 self.assertIsNone(ps.get("foo")) 

260 self.checkPickle(ps) 

261 

262 def testSubPS(self): 

263 ps = dafBase.PropertySet() 

264 ps1 = dafBase.PropertySet() 

265 ps1.set("a", 1) 

266 ps.setPropertySet("b", ps1) 

267 self.assertEqual(ps.getArray("b"), ps1) 

268 self.assertEqual(ps.getScalar("b"), ps1) 

269 self.assertEqual(ps.get("b.a"), 1) 

270 self.assertEqual(ps.getArray("b.a"), [1]) 

271 self.assertEqual(ps.getScalar("b.a"), 1) 

272 ps.set("c", ps1) 

273 self.assertEqual(ps.getArray("c"), ps1) 

274 self.assertEqual(ps.getScalar("c"), ps1) 

275 self.assertEqual(ps.get("c.a"), 1) 

276 self.assertEqual(ps.getArray("c.a"), [1]) 

277 self.assertEqual(ps.getScalar("c.a"), 1) 

278 ps.set("c.a", 2) 

279 self.assertEqual(ps.get("b.a"), 2) 

280 self.assertEqual(ps.getArray("b.a"), [2]) 

281 self.assertEqual(ps.getScalar("b.a"), 2) 

282 self.assertEqual(ps.get("b").get("a"), 2) 

283 self.checkPickle(ps) 

284 

285 def testCopy(self): 

286 dest = dafBase.PropertySet() 

287 source = dafBase.PropertySet() 

288 value1 = [1.5, 3.2] 

289 source.set("srcItem1", value1) 

290 dest.copy("destItem1", source, "srcItem1") 

291 self.assertEqual(dest.get("destItem1"), value1[-1]) 

292 self.assertEqual(dest.getArray("destItem1"), value1) 

293 self.assertEqual(dest.getScalar("destItem1"), value1[-1]) 

294 

295 # items are replaced, regardless of type 

296 dest.set("destItem2", "string value") 

297 value2 = [5, -4, 3] 

298 source.set("srcItem2", value2) 

299 dest.copy("destItem2", source, "srcItem2") 

300 self.assertEqual(dest.get("destItem2"), value2[-1]) 

301 self.assertEqual(dest.getArray("destItem2"), value2) 

302 self.assertEqual(dest.getScalar("destItem2"), value2[-1]) 

303 

304 # asScalar copies only the last value 

305 dest.copy("destItem2Scalar", source, "srcItem2", asScalar=True) 

306 self.assertEqual(dest.get("destItem2Scalar"), value2[-1]) 

307 self.assertEqual(dest.getArray("destItem2Scalar"), [value2[-1]]) 

308 self.assertEqual(dest.getScalar("destItem2Scalar"), value2[-1]) 

309 

310 

311class FlatTestCase(unittest.TestCase): 

312 """A test case for flattened PropertySets. 

313 """ 

314 

315 def testConstruct(self): 

316 ps = dafBase.PropertySet(flat=True) 

317 self.assertIsNotNone(ps) 

318 

319 def testScalar(self): 

320 ps = dafBase.PropertySet(flat=True) 

321 ps.setBool("bool", True) 

322 ps.setShort("short", 42) 

323 ps.setInt("int", 2008) 

324 ps.setLongLong("int64_t", 0xfeeddeadbeef) 

325 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF) 

326 ps.setFloat("float", 3.14159) 

327 ps.setDouble("double", 2.718281828459045) 

328 ps.set("char*", "foo") 

329 ps.setString("string", "bar") 

330 ps.set("int2", 2009) 

331 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC)) 

332 ps.set("autobool", True) 

333 

334 self.assertEqual(ps.typeOf("bool"), dafBase.PropertySet.TYPE_Bool) 

335 self.assertIs(ps.getBool("bool"), True) 

336 self.assertIs(ps.get("bool"), True) 

337 self.assertEqual(ps.getArray("bool"), [True]) 

338 self.assertIs(ps.getScalar("bool"), True) 

339 self.assertEqual(ps.typeOf("short"), dafBase.PropertySet.TYPE_Short) 

340 self.assertEqual(ps.getShort("short"), 42) 

341 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int) 

342 self.assertEqual(ps.getInt("int"), 2008) 

343 self.assertEqual(ps.typeOf("int64_t"), 

344 dafBase.PropertySet.TYPE_LongLong) 

345 self.assertEqual(ps.getLongLong("int64_t"), 0xfeeddeadbeef) 

346 self.assertEqual(ps.typeOf("uint64_t"), dafBase.PropertySet.TYPE_UnsignedLongLong) 

347 self.assertEqual(ps.getUnsignedLongLong("uint64_t"), 0xFFFFFFFFFFFFFFFF) 

348 self.assertEqual(ps.typeOf("float"), dafBase.PropertySet.TYPE_Float) 

349 self.assertAlmostEqual(ps.getFloat("float"), 3.14159, 6) 

350 self.assertEqual(ps.typeOf("double"), dafBase.PropertySet.TYPE_Double) 

351 self.assertEqual(ps.getDouble("double"), 2.718281828459045) 

352 self.assertEqual(ps.typeOf("char*"), dafBase.PropertySet.TYPE_String) 

353 self.assertEqual(ps.getString("char*"), "foo") 

354 self.assertEqual(ps.typeOf("string"), dafBase.PropertySet.TYPE_String) 

355 self.assertEqual(ps.getString("string"), "bar") 

356 self.assertEqual(ps.typeOf("int2"), dafBase.PropertySet.TYPE_Int) 

357 self.assertEqual(ps.getInt("int2"), 2009) 

358 self.assertEqual(ps.get("int2"), 2009) 

359 self.assertEqual(ps.getArray("int2"), [2009]) 

360 self.assertEqual(ps.getScalar("int2"), 2009) 

361 self.assertEqual(ps.typeOf("dt"), dafBase.PropertySet.TYPE_DateTime) 

362 self.assertEqual(ps.getDateTime("dt").nsecs(), 1238657233314159265) 

363 self.assertEqual(ps.typeOf("autobool"), dafBase.PropertySet.TYPE_Bool) 

364 self.assertIs(ps.get("autobool"), True) 

365 self.assertEqual(ps.getArray("autobool"), [True]) 

366 self.assertIs(ps.getScalar("autobool"), True) 

367 

368 def testGetDefault(self): 

369 ps = dafBase.PropertySet(flat=True) 

370 ps.setInt("int", 42) 

371 self.assertEqual(ps.getInt("int"), 42) 

372 self.assertEqual(ps.getInt("int", 2008), 42) 

373 self.assertEqual(ps.getInt("foo", 2008), 2008) 

374 

375 def testExists(self): 

376 ps = dafBase.PropertySet(flat=True) 

377 ps.setInt("int", 42) 

378 self.assertEqual(ps.exists("int"), True) 

379 self.assertEqual(ps.exists("foo"), False) 

380 

381 def testGetVector(self): 

382 ps = dafBase.PropertySet(flat=True) 

383 v = [42, 2008, 1] 

384 ps.setInt("ints", v) 

385 ps.setInt("ints2", [10, 9, 8]) 

386 w = ps.getArrayInt("ints") 

387 self.assertEqual(len(w), 3) 

388 self.assertEqual(v, w) 

389 self.assertEqual(ps.getInt("ints2"), 8) 

390 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8]) 

391 self.assertEqual(ps.getArray("ints"), v) 

392 self.assertEqual(ps.getScalar("ints"), v[-1]) 

393 ps.setInt("int", 999) 

394 x = ps.get("int") 

395 self.assertEqual(x, 999) 

396 self.assertEqual(ps.getArray("int"), [999]) 

397 self.assertEqual(ps.getScalar("int"), 999) 

398 

399 def testGetVector2(self): 

400 ps = dafBase.PropertySet(flat=True) 

401 v = [42, 2008, 1] 

402 ps.setInt("ints", v) 

403 ps.setInt("ints2", [10, 9, 8]) 

404 w = ps.getArrayInt("ints") 

405 self.assertEqual(w, v) 

406 self.assertEqual(ps.getInt("ints2"), 8) 

407 self.assertEqual(ps.getArrayInt("ints2"), [10, 9, 8]) 

408 

409 def testAddScalar(self): 

410 ps = dafBase.PropertySet(flat=True) 

411 v = [42, 2008, 1] 

412 ps.setInt("ints", v) 

413 ps.addInt("ints", -999) 

414 ps.add("other", "foo") 

415 ps.add("ints", 13) 

416 w = ps.getArrayInt("ints") 

417 self.assertEqual(len(w), 5) 

418 self.assertEqual(v[0], w[0]) 

419 self.assertEqual(v[1], w[1]) 

420 self.assertEqual(v[2], w[2]) 

421 self.assertEqual(w[3], -999) 

422 self.assertEqual(w[4], 13) 

423 self.assertEqual(ps.getString("other"), "foo") 

424 

425 def testDateTimeToString(self): 

426 ps = dafBase.PropertySet(flat=True) 

427 ps.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC)) 

428 self.assertEqual(ps.toString(), 

429 "dt = 2009-04-02T07:26:39.314159265Z\n") 

430 

431 def testGetScalarThrow(self): 

432 ps = dafBase.PropertySet(flat=True) 

433 ps.setBool("bool", True) 

434 ps.setShort("short", 42) 

435 ps.setInt("int", 2008) 

436 with self.assertRaises(KeyError): 

437 ps["foo"] 

438 self.assertIsNone(ps.get("foo")) 

439 

440 def testSubPS(self): 

441 ps = dafBase.PropertySet(flat=True) 

442 ps1 = dafBase.PropertySet() 

443 ps1.set("a", 1) 

444 ps1.add("a", 2) 

445 ps1.set("foo", "bar") 

446 ps.setPropertySet("b", ps1) 

447 self.assertEqual(ps.exists("b.a"), True) 

448 self.assertEqual(ps.get("b.a"), 2) 

449 self.assertEqual(ps.getArray("b.a"), [1, 2]) 

450 self.assertEqual(ps.getScalar("b.a"), 2) 

451 self.assertEqual(ps.exists("b"), False) 

452 self.assertEqual(ps.exists("b.foo"), True) 

453 self.assertEqual(ps.get("b.foo"), "bar") 

454 self.assertEqual(ps.getArray("b.foo"), ["bar"]) 

455 self.assertEqual(ps.getScalar("b.foo"), "bar") 

456 

457 ps.set("b.c", 20) 

458 self.assertEqual(ps.exists("b.c"), True) 

459 self.assertEqual(ps.get("b.c"), 20) 

460 self.assertEqual(ps.getArray("b.c"), [20]) 

461 self.assertEqual(ps.getScalar("b.c"), 20) 

462 self.assertEqual(ps.exists("b"), False) 

463 

464 def testCombine(self): 

465 ps = dafBase.PropertySet() 

466 ps.set("ps1.pre", 1) 

467 ps.set("ps1.pre", 1) 

468 ps.set("ps1.post", 2) 

469 ps.set("int", 42) 

470 ps.set("double", 3.14) 

471 ps.set("ps2.plus", 10.24) 

472 ps.set("ps2.minus", -10.24) 

473 ps.set("ps3.sub.subsub", "foo") 

474 

475 psp = dafBase.PropertySet() 

476 psp.set("ps1.pre", 3) 

477 psp.add("ps1.pre", 4) 

478 psp.set("int", 2008) 

479 psp.set("ps2.foo", "bar") 

480 psp.set("ps4.top", "bottom") 

481 

482 ps.combine(psp) 

483 

484 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet) 

485 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet) 

486 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet) 

487 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet) 

488 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet) 

489 

490 self.assertFalse(ps.isArray("ps1")) 

491 self.assertTrue(ps.isArray("ps1.pre")) 

492 self.assertFalse(ps.isArray("ps1.post")) 

493 self.assertFalse(ps.isArray("ps2")) 

494 self.assertFalse(ps.isArray("ps2.plus")) 

495 self.assertFalse(ps.isArray("ps2.minus")) 

496 self.assertFalse(ps.isArray("ps2.foo")) 

497 self.assertFalse(ps.isArray("ps3")) 

498 self.assertFalse(ps.isArray("ps3.sub")) 

499 self.assertFalse(ps.isArray("ps3.subsub")) 

500 self.assertFalse(ps.isArray("ps4")) 

501 self.assertFalse(ps.isArray("ps4.top")) 

502 self.assertTrue(ps.isArray("int")) 

503 self.assertFalse(ps.isArray("double")) 

504 

505 self.assertEqual(ps.valueCount("ps1.pre"), 3) 

506 self.assertEqual(ps.valueCount("int"), 2) 

507 

508 v = ps.getArray("ps1.pre") 

509 self.assertEqual(v, [1, 3, 4]) 

510 v = ps.getArray("int") 

511 self.assertEqual(v, [42, 2008]) 

512 

513 def testUpdate(self): 

514 ps = dafBase.PropertySet() 

515 ps.set("ps1.pre", 1) 

516 ps.set("ps1.pre", 1) 

517 ps.set("ps1.post", 2) 

518 ps.set("int", 42) 

519 ps.set("double", 3.14) 

520 ps.set("ps2.plus", 10.24) 

521 ps.set("ps2.minus", -10.24) 

522 ps.set("ps3.sub.subsub", "foo") 

523 

524 psp = dafBase.PropertySet() 

525 psp.set("ps1.pre", 3) 

526 psp.add("ps1.pre", 4) 

527 psp.set("int", 2008) 

528 psp.set("ps2.foo", "bar") 

529 psp.set("ps4.top", "bottom") 

530 

531 ps.update(psp) 

532 

533 self.assertIsInstance(ps.getScalar("ps1"), dafBase.PropertySet) 

534 self.assertIsInstance(ps.getScalar("ps2"), dafBase.PropertySet) 

535 self.assertIsInstance(ps.getScalar("ps3"), dafBase.PropertySet) 

536 self.assertIsInstance(ps.getScalar("ps3.sub"), dafBase.PropertySet) 

537 self.assertIsInstance(ps.getScalar("ps4"), dafBase.PropertySet) 

538 

539 self.assertFalse(ps.isArray("ps1")) 

540 self.assertTrue(ps.isArray("ps1.pre")) 

541 self.assertFalse(ps.isArray("ps1.post")) 

542 self.assertFalse(ps.isArray("ps2")) 

543 self.assertFalse(ps.isArray("ps2.plus")) 

544 self.assertFalse(ps.isArray("ps2.minus")) 

545 self.assertFalse(ps.isArray("ps2.foo")) 

546 self.assertFalse(ps.isArray("ps3")) 

547 self.assertFalse(ps.isArray("ps3.sub")) 

548 self.assertFalse(ps.isArray("ps3.subsub")) 

549 self.assertFalse(ps.isArray("ps4")) 

550 self.assertFalse(ps.isArray("ps4.top")) 

551 self.assertFalse(ps.isArray("int")) 

552 self.assertFalse(ps.isArray("double")) 

553 

554 self.assertEqual(ps.valueCount("ps1.pre"), 2) 

555 self.assertEqual(ps.valueCount("int"), 1) 

556 

557 v = ps.getArray("ps1.pre") 

558 self.assertEqual(v, [3, 4]) 

559 v = ps.getArray("int") 

560 self.assertEqual(v, [2008]) 

561 

562 psd = {"int": 100, "str": "String", "apl1.foo": 10.5} 

563 ps.update(psd) 

564 self.assertEqual(ps["int"], psd["int"]) 

565 self.assertEqual(ps["str"], psd["str"]) 

566 self.assertEqual(ps["apl1.foo"], psd["apl1.foo"]) 

567 self.assertEqual(ps["double"], 3.14) 

568 

569 def testCombineThrow(self): 

570 ps = dafBase.PropertySet() 

571 ps.set("int", 42) 

572 

573 psp = dafBase.PropertySet() 

574 psp.set("int", 3.14159) 

575 

576 with self.assertRaises(TypeError): 

577 ps.combine(psp) 

578 

579 psd = {"bool": True} 

580 with self.assertRaises(TypeError): 

581 ps.combine(psd) 

582 

583 def testToDict(self): 

584 ps = dafBase.PropertySet() 

585 ps.setBool("bool", True) 

586 ps.setShort("short", 42) 

587 ps.setInt("int", 2008) 

588 ps.setLongLong("int64_t", 0xfeeddeadbeef) 

589 ps.setUnsignedLongLong("uint64_t", 0xFFFFFFFFFFFFFFFF) 

590 ps.setInt("ints", [10, 9, 8]) 

591 

592 ps2 = dafBase.PropertySet() 

593 ps2.set("ps", ps) 

594 ps2.setFloat("float", 3.14159) 

595 ps2.setDouble("double", 2.718281828459045) 

596 ps2.set("char*", "foo") 

597 ps2.setString("string", "bar") 

598 ps2.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC)) 

599 ps2.set("undef", None) 

600 

601 d = ps2.toDict() 

602 self.assertIsInstance(d, dict) 

603 

604 self.assertIsInstance(d["float"], float) 

605 self.assertAlmostEqual(d["float"], 3.14159, 6) 

606 self.assertIsInstance(d["double"], float) 

607 self.assertEqual(d["double"], 2.718281828459045) 

608 self.assertIsNone(d["undef"]) 

609 

610 self.assertIsInstance(d["char*"], str) 

611 self.assertEqual(d["char*"], "foo") 

612 self.assertIsInstance(d["string"], str) 

613 self.assertEqual(d["string"], "bar") 

614 self.assertIsInstance(d["dt"], dafBase.DateTime) 

615 self.assertEqual(d["dt"].nsecs(), 1238657233314159265) 

616 

617 d2 = d["ps"] 

618 self.assertIsInstance(d2, dict) 

619 

620 self.assertIsInstance(d2["bool"], bool) 

621 self.assertEqual(d2["bool"], True) 

622 self.assertIsInstance(d2["short"], (int, int)) 

623 self.assertEqual(d2["short"], 42) 

624 self.assertIsInstance(d2["int"], (int, int)) 

625 self.assertEqual(d2["int"], 2008) 

626 self.assertIsInstance(d2["int64_t"], (int, int)) 

627 self.assertEqual(d2["int64_t"], 0xfeeddeadbeef) 

628 self.assertIsInstance(d2["uint64_t"], (int, int)) 

629 self.assertEqual(d2["uint64_t"], 0xFFFFFFFFFFFFFFFF) 

630 self.assertIsInstance(d2["ints"], list) 

631 self.assertIsInstance(d2["ints"][0], (int, int)) 

632 self.assertEqual(d2["ints"], [10, 9, 8]) 

633 

634 def testAddVector(self): 

635 ps = dafBase.PropertySet() 

636 v = [42, 2008, 1] 

637 ps.set("ints", v) 

638 

639 vv = [-42, -2008, -1] 

640 ps.add("ints", vv) 

641 

642 w = ps.getArray("ints") 

643 self.assertEqual(w, v + vv) 

644 

645 def testArrayProperties(self): 

646 ps = dafBase.PropertySet() 

647 v = [42, 2008, 1] 

648 ps.set("ints", v) 

649 ps.set("int", 365) 

650 ps.set("ints2", -42) 

651 ps.add("ints2", -2008) 

652 

653 self.assertTrue(ps.isArray("ints")) 

654 self.assertFalse(ps.isArray("int")) 

655 self.assertTrue(ps.isArray("ints2")) 

656 self.assertEqual(ps.valueCount("ints"), 3) 

657 self.assertEqual(ps.valueCount("int"), 1) 

658 self.assertEqual(ps.valueCount("ints2"), 2) 

659 self.assertEqual(ps.typeOf("ints"), dafBase.PropertySet.TYPE_Int) 

660 self.assertEqual(ps.typeOf("int"), dafBase.PropertySet.TYPE_Int) 

661 self.assertEqual(ps.typeOf("ints2"), dafBase.PropertySet.TYPE_Int) 

662 

663 def testHierarchy(self): 

664 ps = dafBase.PropertySet() 

665 psp = dafBase.PropertySet() 

666 

667 psp.set("pre", 1) 

668 ps.set("ps1", psp) 

669 psp.set("post", 2) 

670 ps.set("int", 42) 

671 ps.set("ps2", dafBase.PropertySet()) 

672 ps.getPropertySet("ps2").set("plus", 10.24) 

673 ps.set("ps2.minus", -10.24) 

674 ps.set("ps3.sub1", "foo") 

675 ps.set("ps3.sub2", "bar") 

676 

677 self.assertTrue(ps.exists("ps1")) 

678 self.assertTrue(ps.exists("ps2")) 

679 self.assertTrue(ps.exists("ps3")) 

680 self.assertTrue(ps.exists("ps1.pre")) 

681 self.assertTrue(ps.exists("ps1.post")) 

682 self.assertTrue(ps.exists("ps2.plus")) 

683 self.assertTrue(ps.exists("ps2.minus")) 

684 self.assertTrue(ps.exists("ps3.sub1")) 

685 self.assertTrue(ps.exists("ps3.sub2")) 

686 

687 self.assertTrue(ps.isPropertySetPtr("ps1")) 

688 self.assertTrue(ps.isPropertySetPtr("ps2")) 

689 self.assertTrue(ps.isPropertySetPtr("ps3")) 

690 self.assertFalse(ps.isPropertySetPtr("int")) 

691 self.assertFalse(ps.isPropertySetPtr("ps1.pre")) 

692 self.assertFalse(ps.isPropertySetPtr("ps1.post")) 

693 self.assertFalse(ps.isPropertySetPtr("ps2.plus")) 

694 self.assertFalse(ps.isPropertySetPtr("ps2.minus")) 

695 self.assertFalse(ps.isPropertySetPtr("ps3.sub1")) 

696 self.assertFalse(ps.isPropertySetPtr("ps3.sub2")) 

697 

698 psp1 = ps.getPropertySet("ps1") 

699 psp2 = ps.getPropertySet("ps2") 

700 psp3 = ps.getPropertySet("ps3") 

701 self.assertIsInstance(psp1, dafBase.PropertySet) 

702 self.assertIsInstance(psp2, dafBase.PropertySet) 

703 self.assertIsInstance(psp3, dafBase.PropertySet) 

704 self.assertEqual(psp1, psp) 

705 self.assertTrue(psp1.exists("pre")) 

706 self.assertTrue(psp1.exists("post")) 

707 self.assertTrue(psp2.exists("plus")) 

708 self.assertTrue(psp2.exists("minus")) 

709 self.assertTrue(psp3.exists("sub1")) 

710 self.assertTrue(psp3.exists("sub2")) 

711 self.assertEqual(psp1.getAsInt("pre"), 1) 

712 self.assertEqual(psp1.getAsInt("post"), 2) 

713 self.assertEqual(psp2.getAsDouble("plus"), 10.24) 

714 self.assertEqual(psp2.getAsDouble("minus"), -10.24) 

715 self.assertEqual(psp3.getAsString("sub1"), "foo") 

716 self.assertEqual(psp3.getAsString("sub2"), "bar") 

717 

718 # Make sure checking a subproperty doesn't create it. 

719 self.assertFalse(ps.exists("ps2.pre")) 

720 self.assertFalse(ps.exists("ps2.pre")) 

721 # Make sure checking an element doesn't create it. 

722 self.assertFalse(ps.exists("ps4")) 

723 self.assertFalse(ps.exists("ps4")) 

724 # Make sure checking a subproperty with a nonexistent parent doesn't 

725 # create it. 

726 self.assertFalse(ps.exists("ps4.sub")) 

727 self.assertFalse(ps.exists("ps4.sub")) 

728 # Make sure checking a subproperty doesn't create its parent. 

729 self.assertFalse(ps.exists("ps4")) 

730 

731# 

732 def testvariousThrows(self): 

733 ps = dafBase.PropertySet() 

734 ps.set("int", 42) 

735 with self.assertRaises(pexExcept.InvalidParameterError): 

736 ps.set("int.sub", "foo") 

737 with self.assertRaises(TypeError): 

738 ps.getDouble("int") 

739 with self.assertRaises(LookupError): 

740 ps.getDouble("double") 

741 with self.assertRaises(KeyError): 

742 ps.getArray("double") 

743 with self.assertRaises(LookupError): 

744 ps.typeOf("double") 

745 with self.assertRaises(TypeError): 

746 ps.add("int", 4.2) 

747 

748 v = [3.14159, 2.71828] 

749 with self.assertRaises(TypeError): 

750 ps.add("int", v) 

751 ps.remove("foo.bar") 

752 ps.remove("int.sub") 

753 

754 def testIntegerRanges(self): 

755 """Test that the ranges of the various integer types is as expected 

756 """ 

757 ps = dafBase.PropertySet() 

758 minI32 = -2**31 

759 maxI32 = 2**31 - 1 

760 minI64 = -2**63 

761 maxI64 = 2**63 - 1 

762 minU64 = 0 

763 maxU64 = 2**64 - 1 

764 # Out of range for the particular type 

765 self.assertRaises(TypeError, ps.addInt, "int32", minI32 - 1) 

766 self.assertRaises(TypeError, ps.addInt, "int32", maxI32 + 1) 

767 self.assertRaises(TypeError, ps.addLongLong, "int64", minI64 - 1) 

768 self.assertRaises(TypeError, ps.addLongLong, "int64", maxI64 + 1) 

769 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", minU64 - 1) 

770 self.assertRaises(TypeError, ps.addUnsignedLongLong, "uint64", maxU64 + 1) 

771 # Out of all possible integer ranges 

772 self.assertRaises(RuntimeError, ps.add, "number", minI64 - 1) 

773 self.assertRaises(RuntimeError, ps.add, "number", maxU64 + 1) 

774 

775 def testNames(self): 

776 ps = dafBase.PropertySet() 

777 ps.set("ps1.pre", 1) 

778 ps.set("ps1.post", 2) 

779 ps.set("int", 42) 

780 ps.set("double", 3.14) 

781 ps.set("ps2.plus", 10.24) 

782 ps.set("ps2.minus", -10.24) 

783 

784 self.assertEqual(ps.nameCount(), 4) 

785 self.assertEqual(ps.nameCount(False), 8) 

786 

787 v = set(ps.names()) 

788 self.assertEqual(len(v), 4) 

789 self.assertEqual(v, {"double", "int", "ps1", "ps2"}) 

790 v = set(ps.names(False)) 

791 self.assertEqual(len(v), 8) 

792 self.assertEqual(v, {"double", "int", "ps1", "ps1.post", 

793 "ps1.pre", "ps2", "ps2.minus", "ps2.plus"}) 

794 

795 def testParamNames(self): 

796 ps = dafBase.PropertySet() 

797 ps.set("ps1.pre", 1) 

798 ps.set("ps1.post", 2) 

799 ps.set("int", 42) 

800 ps.set("double", 3.14) 

801 ps.set("ps2.plus", 10.24) 

802 ps.set("ps2.minus", -10.24) 

803 

804 v = set(ps.paramNames()) 

805 self.assertEqual(len(v), 2) 

806 self.assertEqual(v, {"double", "int"}) 

807 v = set(ps.paramNames(False)) 

808 self.assertEqual(len(v), 6) 

809 self.assertEqual(v, {"double", "int", "ps1.post", "ps1.pre", 

810 "ps2.minus", "ps2.plus"}) 

811 

812 def testPropertySetNames(self): 

813 ps = dafBase.PropertySet() 

814 ps.set("ps1.pre", 1) 

815 ps.set("ps1.post", 2) 

816 ps.set("int", 42) 

817 ps.set("double", 3.14) 

818 ps.set("ps2.plus", 10.24) 

819 ps.set("ps2.minus", -10.24) 

820 ps.set("ps3.sub.subsub", "foo") 

821 

822 v = set(ps.propertySetNames()) 

823 self.assertEqual(len(v), 3) 

824 self.assertEqual(v, {"ps1", "ps2", "ps3"}) 

825 v = set(ps.propertySetNames(False)) 

826 self.assertEqual(len(v), 4) 

827 self.assertEqual(v, {"ps1", "ps2", "ps3", "ps3.sub"}) 

828 

829 def testGetAs(self): 

830 ps = dafBase.PropertySet() 

831 ps.set("bool", True) 

832 ps.setShort("short", 42) 

833 ps.set("int", 2008) 

834 ps.set("int64_t", 0xfeeddeadbeef) 

835 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF) 

836 f = 3.14159 

837 ps.setFloat("float", f) 

838 d = 2.718281828459045 

839 ps.setDouble("double", d) 

840 ps.setString("char*", "foo") 

841 ps.set("char*2", "foo2") 

842 ps.set("string", "bar") 

843 psp = dafBase.PropertySet() 

844 psp.set("bottom", "x") 

845 ps.set("top", psp) 

846 

847 self.assertIs(ps.getAsBool("bool"), True) 

848 self.assertEqual(ps.getAsInt("bool"), 1) 

849 self.assertEqual(ps.getAsInt("short"), 42) 

850 self.assertEqual(ps.getAsInt("int"), 2008) 

851 with self.assertRaises(TypeError): 

852 ps.getAsInt("int64_t") 

853 with self.assertRaises(TypeError): 

854 ps.getAsInt("uint64_t") 

855 with self.assertRaises(TypeError): 

856 ps.getAsInt64("uint64_t") 

857 self.assertEqual(ps.getAsInt64("bool"), 1) 

858 self.assertEqual(ps.getAsInt64("short"), 42) 

859 self.assertEqual(ps.getAsInt64("int"), 2008) 

860 self.assertEqual(ps.getAsInt64("int64_t"), 0xfeeddeadbeef) 

861 self.assertEqual(ps.getAsUInt64("uint64_t"), 0xFFFFFFFFFFFFFFFF) 

862 with self.assertRaises(TypeError): 

863 ps.getAsInt64("float") 

864 with self.assertRaises(TypeError): 

865 ps.getAsUInt64("float") 

866 self.assertEqual(ps.getAsDouble("bool"), 1.0) 

867 self.assertEqual(ps.getAsDouble("short"), 42.0) 

868 self.assertEqual(ps.getAsDouble("int"), 2008.0) 

869 self.assertEqual(ps.getAsDouble("int64_t"), 

870 float(0xfeeddeadbeef)) 

871 self.assertEqual(ps.getAsDouble("uint64_t"), 

872 float(0xFFFFFFFFFFFFFFFF)) 

873 self.assertAlmostEqual(ps.getAsDouble("float"), 3.14159, places=5) 

874 self.assertAlmostEqual(ps.getAsDouble("double"), 2.718281828459045, places=15) 

875 with self.assertRaises(TypeError): 

876 ps.getAsDouble("char*") 

877 self.assertEqual(ps.getAsString("char*"), "foo") 

878 self.assertEqual(ps.getAsString("char*2"), "foo2") 

879 self.assertEqual(ps.getAsString("string"), "bar") 

880 with self.assertRaises(TypeError): 

881 ps.getAsString("int") 

882 self.assertEqual(ps.getAsString("top.bottom"), "x") 

883 self.assertEqual(ps.getAsPropertySetPtr("top"), psp) 

884 with self.assertRaises(TypeError): 

885 ps.getAsPropertySetPtr("top.bottom") 

886 

887 def testRemove(self): 

888 ps = dafBase.PropertySet() 

889 ps.set("int", 42) 

890 ps.set("double", 3.14159) 

891 ps.set("ps1.plus", 1) 

892 ps.set("ps1.minus", -1) 

893 ps.set("ps1.zero", 0) 

894 self.assertEqual(ps.nameCount(False), 6) 

895 

896 ps.remove("int") 

897 self.assertFalse(ps.exists("int")) 

898 self.assertEqual(ps.getAsDouble("double"), 3.14159) 

899 self.assertEqual(ps.getAsInt("ps1.plus"), 1) 

900 self.assertEqual(ps.getAsInt("ps1.minus"), -1) 

901 self.assertEqual(ps.getAsInt("ps1.zero"), 0) 

902 self.assertEqual(ps.nameCount(False), 5) 

903 

904 ps.remove("ps1.zero") 

905 self.assertFalse(ps.exists("int")) 

906 self.assertEqual(ps.getAsDouble("double"), 3.14159) 

907 self.assertFalse(ps.exists("ps1.zero")) 

908 self.assertEqual(ps.getAsInt("ps1.plus"), 1) 

909 self.assertEqual(ps.getAsInt("ps1.minus"), -1) 

910 self.assertEqual(ps.nameCount(False), 4) 

911 

912 ps.remove("ps1") 

913 self.assertFalse(ps.exists("int")) 

914 self.assertEqual(ps.getAsDouble("double"), 3.14159) 

915 self.assertFalse(ps.exists("ps1")) 

916 self.assertFalse(ps.exists("ps1.plus")) 

917 self.assertFalse(ps.exists("ps1.minus")) 

918 self.assertFalse(ps.exists("ps1.zero")) 

919 self.assertEqual(ps.nameCount(False), 1) 

920 

921 ps.remove("double") 

922 self.assertFalse(ps.exists("int")) 

923 self.assertFalse(ps.exists("double")) 

924 self.assertFalse(ps.exists("ps1")) 

925 self.assertFalse(ps.exists("ps1.plus")) 

926 self.assertFalse(ps.exists("ps1.minus")) 

927 self.assertFalse(ps.exists("ps1.zero")) 

928 self.assertEqual(ps.nameCount(False), 0) 

929 

930 def testDeepCopy(self): 

931 ps = dafBase.PropertySet() 

932 ps.set("int", 42) 

933 psp = dafBase.PropertySet() 

934 psp.set("bottom", "x") 

935 ps.set("top", psp) 

936 

937 psp2 = ps.deepCopy() 

938 self.assertTrue(psp2.exists("int")) 

939 self.assertTrue(psp2.exists("top.bottom")) 

940 self.assertEqual(psp2.getAsInt("int"), 42) 

941 self.assertEqual(psp2.getAsString("top.bottom"), "x") 

942 # Make sure it was indeed a deep copy. 

943 ps.set("int", 2008) 

944 ps.set("top.bottom", "y") 

945 self.assertEqual(ps.getAsInt("int"), 2008) 

946 self.assertEqual(ps.getAsString("top.bottom"), "y") 

947 self.assertEqual(psp.getAsString("bottom"), "y") 

948 self.assertEqual(psp2.getAsInt("int"), 42) 

949 self.assertEqual(psp2.getAsString("top.bottom"), "x") 

950 

951 def testToString(self): 

952 ps = dafBase.PropertySet() 

953 ps.set("bool", True) 

954 s = 42 

955 ps.setShort("short", s) 

956 ps.set("int", 2008) 

957 ps.set("int64_t", 0xfeeddeadbeef) 

958 ps.set("uint64_t", 0xFFFFFFFFFFFFFFFF) 

959 f = 3.14159 

960 ps.setFloat("float", f) 

961 d = 2.718281828459045 

962 ps.setDouble("double", d) 

963 ps.setString("char*", "foo") 

964 ps.set("char*2", "foo2") 

965 ps.set("string", "bar") 

966 ps.set("ps1.pre", 1) 

967 ps.set("ps1.post", 2) 

968 ps.set("ps2.plus", 10.24) 

969 ps.set("ps2.minus", -10.24) 

970 ps.set("ps3.sub.subsub", "foo") 

971 ps.add("v", 10) 

972 ps.add("v", 9) 

973 ps.add("v", 8) 

974 

975 self.assertEqual(ps.toString(), 

976 "bool = 1\n" 

977 "char* = \"foo\"\n" 

978 "char*2 = \"foo2\"\n" 

979 "double = 2.7182818284590\n" 

980 "float = 3.141590\n" 

981 "int = 2008\n" 

982 "int64_t = 280297596632815\n" 

983 "ps1 = {\n" 

984 "..post = 2\n" 

985 "..pre = 1\n" 

986 "}\n" 

987 "ps2 = {\n" 

988 "..minus = -10.240000000000\n" 

989 "..plus = 10.240000000000\n" 

990 "}\n" 

991 "ps3 = {\n" 

992 "..sub = {\n" 

993 "....subsub = \"foo\"\n" 

994 "..}\n" 

995 "}\n" 

996 "short = 42\n" 

997 "string = \"bar\"\n" 

998 "uint64_t = 18446744073709551615\n" 

999 "v = [ 10, 9, 8 ]\n" 

1000 ) 

1001 self.assertEqual(ps.toString(True), 

1002 "bool = 1\n" 

1003 "char* = \"foo\"\n" 

1004 "char*2 = \"foo2\"\n" 

1005 "double = 2.7182818284590\n" 

1006 "float = 3.141590\n" 

1007 "int = 2008\n" 

1008 "int64_t = 280297596632815\n" 

1009 "ps1 = { ... }\n" 

1010 "ps2 = { ... }\n" 

1011 "ps3 = { ... }\n" 

1012 "short = 42\n" 

1013 "string = \"bar\"\n" 

1014 "uint64_t = 18446744073709551615\n" 

1015 "v = [ 10, 9, 8 ]\n" 

1016 ) 

1017 

1018 

1019class TestMemory(lsst.utils.tests.MemoryTestCase): 

1020 pass 

1021 

1022 

1023def setup_module(module): 

1024 lsst.utils.tests.init() 

1025 

1026 

1027if __name__ == "__main__": 1027 ↛ 1028line 1027 didn't jump to line 1028, because the condition on line 1027 was never true

1028 lsst.utils.tests.init() 

1029 unittest.main()