Coverage for tests/test_PropertySet_2.py: 6%

855 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2022-12-01 19:51 +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# 

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 self.assertEqual(ps.valueCount(), 13) 

93 

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

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

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

97 

98 self.checkPickle(ps) 

99 

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) 

105 

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) 

132 

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) 

145 

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) 

152 

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) 

175 

176 # Check that an empty list does nothing 

177 ps.setInt("empty", []) 

178 self.assertNotIn("empty", ps) 

179 

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) 

193 

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) 

211 

212 # Check that an empty list does nothing 

213 ps.addInt("ints", []) 

214 self.assertEqual(ps.getArrayInt("ints"), w) 

215 

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) 

239 

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) 

258 

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) 

265 

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) 

276 

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) 

302 

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) 

314 

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) 

325 

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) 

333 

334 

335class FlatTestCase(unittest.TestCase): 

336 """A test case for flattened PropertySets. 

337 """ 

338 

339 def testConstruct(self): 

340 ps = dafBase.PropertySet(flat=True) 

341 self.assertIsNotNone(ps) 

342 

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) 

357 

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) 

391 

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) 

398 

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) 

404 

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) 

422 

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]) 

432 

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") 

448 

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") 

454 

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")) 

463 

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") 

480 

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) 

487 

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") 

498 

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") 

505 

506 ps.combine(psp) 

507 

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) 

513 

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")) 

528 

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

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

531 self.assertEqual(ps.valueCount(), 12) 

532 

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

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

535 v = ps.getArray("int") 

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

537 

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") 

548 

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") 

555 

556 ps.update(psp) 

557 

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) 

563 

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")) 

578 

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

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

581 self.assertEqual(ps.valueCount(), 7) 

582 

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

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

585 v = ps.getArray("int") 

586 self.assertEqual(v, [2008]) 

587 

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) 

594 

595 def testCombineThrow(self): 

596 ps = dafBase.PropertySet() 

597 ps.set("int", 42) 

598 

599 psp = dafBase.PropertySet() 

600 psp.set("int", 3.14159) 

601 

602 with self.assertRaises(TypeError): 

603 ps.combine(psp) 

604 

605 psd = {"bool": True} 

606 with self.assertRaises(TypeError): 

607 ps.combine(psd) 

608 

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]) 

617 

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) 

626 

627 d = ps2.toDict() 

628 self.assertIsInstance(d, dict) 

629 

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"]) 

635 

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) 

642 

643 d2 = d["ps"] 

644 self.assertIsInstance(d2, dict) 

645 

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]) 

659 

660 def testAddVector(self): 

661 ps = dafBase.PropertySet() 

662 v = [42, 2008, 1] 

663 ps.set("ints", v) 

664 

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

666 ps.add("ints", vv) 

667 

668 w = ps.getArray("ints") 

669 self.assertEqual(w, v + vv) 

670 

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) 

678 

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) 

689 

690 def testHierarchy(self): 

691 ps = dafBase.PropertySet() 

692 psp = dafBase.PropertySet() 

693 

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") 

703 

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")) 

713 

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")) 

724 

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") 

744 

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")) 

757 

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) 

774 

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") 

780 

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) 

801 

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) 

810 

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

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

813 

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"}) 

821 

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) 

830 

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"}) 

838 

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") 

848 

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"}) 

855 

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) 

873 

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") 

913 

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) 

922 

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) 

930 

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) 

938 

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) 

947 

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) 

956 

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) 

963 

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") 

977 

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) 

1001 

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 ) 

1044 

1045 

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

1047 pass 

1048 

1049 

1050def setup_module(module): 

1051 lsst.utils.tests.init() 

1052 

1053 

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()