Coverage for tests/test_PropertySet_2.py: 7%

872 statements  

« prev     ^ index     » next       coverage.py v6.4.2, created at 2022-08-04 02:15 -0700

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 dataclasses 

25import pickle 

26import unittest 

27 

28import numpy as np 

29 

30import lsst.utils.tests 

31import lsst.daf.base as dafBase 

32import lsst.pex.exceptions as pexExcept 

33 

34 

35class PropertySetTestCase(unittest.TestCase): 

36 """A test case for PropertySet. 

37 """ 

38 

39 def testConstruct(self): 

40 ps = dafBase.PropertySet() 

41 self.assertIsNotNone(ps) 

42 

43 def checkPickle(self, original): 

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

45 self.assertEqual(new, original) 

46 

47 def testScalar(self): 

48 ps = dafBase.PropertySet() 

49 ps.setBool("bool", True) 

50 ps.setShort("short", 42) 

51 ps.setInt("int", 2008) 

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

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

54 ps.setFloat("float", 3.14159) 

55 ps.setDouble("double", 2.718281828459045) 

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

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

58 ps.set("char*", u"foo") 

59 ps.setString("string", u"bar") 

60 ps.set("int2", 2009) 

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

62 ps.set("blank", "") 

63 ps.set("undef", None) 

64 

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

66 self.assertEqual(ps.getBool("bool"), True) 

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

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

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

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

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

72 dafBase.PropertySet.TYPE_LongLong) 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

92 self.assertEqual(ps.getString("blank"), "") 

93 self.assertEqual(ps.valueCount(), 13) 

94 

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

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

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

98 

99 self.checkPickle(ps) 

100 

101 # Now replace the undef value with a defined value 

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

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

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

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

106 

107 def testNumPyScalars(self): 

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

109 setters. 

110 """ 

111 ps = dafBase.PropertySet() 

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

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

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

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

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

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

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

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

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

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

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

123 dafBase.PropertySet.TYPE_LongLong) 

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

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

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

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

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

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

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

131 self.assertEqual(ps.valueCount(), 6) 

132 self.checkPickle(ps) 

133 

134 def testGetDefault(self): 

135 ps = dafBase.PropertySet() 

136 ps.setInt("int", 42) 

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

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

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

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

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

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

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

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

145 self.checkPickle(ps) 

146 

147 def testExists(self): 

148 ps = dafBase.PropertySet() 

149 ps.setInt("int", 42) 

150 self.checkPickle(ps) 

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

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

153 

154 def testGetVector(self): 

155 ps = dafBase.PropertySet() 

156 v = [42, 2008, 1] 

157 ps.setInt("ints", v) 

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

159 w = ps.getArrayInt("ints") 

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

161 self.assertEqual(v, w) 

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

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

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

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

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

167 self.assertEqual(ps.valueCount(), 6) 

168 ps.setInt("int", 999) 

169 x = ps.get("int") 

170 self.assertEqual(x, 999) 

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

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

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

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

175 self.checkPickle(ps) 

176 

177 # Check that an empty list does nothing 

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

179 self.assertNotIn("empty", ps) 

180 

181 def testGetVector2(self): 

182 ps = dafBase.PropertySet() 

183 v = [42, 2008, 1] 

184 ps.setInt("ints", v) 

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

186 w = ps.getArrayInt("ints") 

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

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

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

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

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

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

193 self.checkPickle(ps) 

194 

195 def testAddScalar(self): 

196 ps = dafBase.PropertySet() 

197 v = [42, 2008, 1] 

198 ps.setInt("ints", v) 

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

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

201 ps.add("ints", 13) 

202 w = ps.getArrayInt("ints") 

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

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

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

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

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

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

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

210 self.assertEqual(ps.valueCount(), 6) 

211 self.checkPickle(ps) 

212 

213 # Check that an empty list does nothing 

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

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

216 

217 def testSetAddVector(self): 

218 ps = dafBase.PropertySet() 

219 boolArr = [True, False] 

220 intArr = [1, -1, 2] 

221 floatArr = [1.2, 99.5, -35.1] 

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

223 ps.set("bools", boolArr) 

224 ps.set("ints", intArr) 

225 ps.set("floats", floatArr) 

226 ps.set("strs", strArr) 

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

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

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

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

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

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

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

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

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

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

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

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

239 self.assertEqual(ps.valueCount(), 11) 

240 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

257 self.assertEqual(ps.valueCount(), 22) 

258 self.checkPickle(ps) 

259 

260 def testDateTimeToString(self): 

261 ps = dafBase.PropertySet() 

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

263 self.assertEqual(ps.toString(), 

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

265 self.checkPickle(ps) 

266 

267 def testGetScalarThrow(self): 

268 ps = dafBase.PropertySet() 

269 ps.setBool("bool", True) 

270 ps.setShort("short", 42) 

271 ps.setInt("int", 2008) 

272 with self.assertRaises(KeyError): 

273 ps["foo"] 

274 # This will not throw 

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

276 self.checkPickle(ps) 

277 

278 def testSubPS(self): 

279 ps = dafBase.PropertySet() 

280 ps1 = dafBase.PropertySet() 

281 ps1.set("a", 1) 

282 ps.setPropertySet("b", ps1) 

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

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

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

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

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

288 self.assertEqual(ps.valueCount(), 1) 

289 ps.set("c", ps1) 

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

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

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

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

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

295 self.assertEqual(ps.valueCount(), 2) 

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

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

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

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

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

301 self.assertEqual(ps.valueCount(), 2) 

302 self.checkPickle(ps) 

303 

304 def testCopy(self): 

305 dest = dafBase.PropertySet() 

306 source = dafBase.PropertySet() 

307 value1 = [1.5, 3.2] 

308 source.set("srcItem1", value1) 

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

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

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

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

313 self.assertEqual(source.valueCount(), 2) 

314 self.assertEqual(dest.valueCount(), 2) 

315 

316 # items are replaced, regardless of type 

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

318 value2 = [5, -4, 3] 

319 source.set("srcItem2", value2) 

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

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

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

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

324 self.assertEqual(source.valueCount(), 5) 

325 self.assertEqual(dest.valueCount(), 5) 

326 

327 # asScalar copies only the last value 

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

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

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

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

332 self.assertEqual(source.valueCount(), 5) 

333 self.assertEqual(dest.valueCount(), 6) 

334 

335 

336class FlatTestCase(unittest.TestCase): 

337 """A test case for flattened PropertySets. 

338 """ 

339 

340 def testConstruct(self): 

341 ps = dafBase.PropertySet(flat=True) 

342 self.assertIsNotNone(ps) 

343 

344 def testScalar(self): 

345 ps = dafBase.PropertySet(flat=True) 

346 ps.setBool("bool", True) 

347 ps.setShort("short", 42) 

348 ps.setInt("int", 2008) 

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

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

351 ps.setFloat("float", 3.14159) 

352 ps.setDouble("double", 2.718281828459045) 

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

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

355 ps.set("int2", 2009) 

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

357 ps.set("autobool", True) 

358 

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

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

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

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

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

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

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

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

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

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

369 dafBase.PropertySet.TYPE_LongLong) 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

392 

393 def testGetDefault(self): 

394 ps = dafBase.PropertySet(flat=True) 

395 ps.setInt("int", 42) 

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

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

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

399 

400 def testExists(self): 

401 ps = dafBase.PropertySet(flat=True) 

402 ps.setInt("int", 42) 

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

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

405 

406 def testGetVector(self): 

407 ps = dafBase.PropertySet(flat=True) 

408 v = [42, 2008, 1] 

409 ps.setInt("ints", v) 

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

411 w = ps.getArrayInt("ints") 

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

413 self.assertEqual(v, w) 

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

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

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

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

418 ps.setInt("int", 999) 

419 x = ps.get("int") 

420 self.assertEqual(x, 999) 

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

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

423 

424 def testGetVector2(self): 

425 ps = dafBase.PropertySet(flat=True) 

426 v = [42, 2008, 1] 

427 ps.setInt("ints", v) 

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

429 w = ps.getArrayInt("ints") 

430 self.assertEqual(w, v) 

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

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

433 

434 def testAddScalar(self): 

435 ps = dafBase.PropertySet(flat=True) 

436 v = [42, 2008, 1] 

437 ps.setInt("ints", v) 

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

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

440 ps.add("ints", 13) 

441 w = ps.getArrayInt("ints") 

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

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

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

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

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

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

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

449 

450 def testDateTimeToString(self): 

451 ps = dafBase.PropertySet(flat=True) 

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

453 self.assertEqual(ps.toString(), 

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

455 

456 def testGetScalarThrow(self): 

457 ps = dafBase.PropertySet(flat=True) 

458 ps.setBool("bool", True) 

459 ps.setShort("short", 42) 

460 ps.setInt("int", 2008) 

461 with self.assertRaises(KeyError): 

462 ps["foo"] 

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

464 

465 def testSubPS(self): 

466 ps = dafBase.PropertySet(flat=True) 

467 ps1 = dafBase.PropertySet() 

468 ps1.set("a", 1) 

469 ps1.add("a", 2) 

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

471 ps.setPropertySet("b", ps1) 

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

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

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

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

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

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

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

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

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

481 

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

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

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

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

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

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

488 

489 def testCombine(self): 

490 ps = dafBase.PropertySet() 

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

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

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

494 ps.set("int", 42) 

495 ps.set("double", 3.14) 

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

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

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

499 

500 psp = dafBase.PropertySet() 

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

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

503 psp.set("int", 2008) 

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

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

506 

507 ps.combine(psp) 

508 

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

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

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

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

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

514 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

529 

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

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

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

533 

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

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

536 v = ps.getArray("int") 

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

538 

539 def testUpdate(self): 

540 ps = dafBase.PropertySet() 

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

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

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

544 ps.set("int", 42) 

545 ps.set("double", 3.14) 

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

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

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

549 

550 psp = dafBase.PropertySet() 

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

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

553 psp.set("int", 2008) 

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

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

556 

557 ps.update(psp) 

558 

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

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

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

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

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

564 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

579 

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

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

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

583 

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

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

586 v = ps.getArray("int") 

587 self.assertEqual(v, [2008]) 

588 

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

590 ps.update(psd) 

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

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

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

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

595 

596 def testCombineThrow(self): 

597 ps = dafBase.PropertySet() 

598 ps.set("int", 42) 

599 

600 psp = dafBase.PropertySet() 

601 psp.set("int", 3.14159) 

602 

603 with self.assertRaises(TypeError): 

604 ps.combine(psp) 

605 

606 psd = {"bool": True} 

607 with self.assertRaises(TypeError): 

608 ps.combine(psd) 

609 

610 def testToDict(self): 

611 ps = dafBase.PropertySet() 

612 ps.setBool("bool", True) 

613 ps.setShort("short", 42) 

614 ps.setInt("int", 2008) 

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

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

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

618 

619 ps2 = dafBase.PropertySet() 

620 ps2.set("ps", ps) 

621 ps2.setFloat("float", 3.14159) 

622 ps2.setDouble("double", 2.718281828459045) 

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

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

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

626 ps2.set("undef", None) 

627 

628 d = ps2.toDict() 

629 self.assertIsInstance(d, dict) 

630 

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

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

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

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

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

636 

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

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

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

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

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

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

643 

644 # Check round tripping. 

645 from_dict = dafBase.PropertySet.from_mapping(d) 

646 

647 # The specialist type fields (float, short, uint64_t) will not 

648 # round trip properly and so use string equality and remove the 

649 # float field because the number of figures changes. 

650 # The float field won't round trip so has to be examined separately 

651 # because the type will have changed. 

652 self.assertAlmostEqual(from_dict["float"], ps2["float"]) 

653 del ps2["float"] 

654 del from_dict["float"] 

655 self.assertEqual(str(from_dict), str(ps2)) 

656 

657 # Test again, but relying on the toDict method of a PropertySet 

658 self.assertEqual(str(dafBase.PropertySet.from_mapping(ps2)), str(ps2)) 

659 

660 with self.assertRaises(ValueError): 

661 dafBase.PropertySet.from_mapping([]) 

662 

663 d2 = d["ps"] 

664 self.assertIsInstance(d2, dict) 

665 

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

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

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

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

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

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

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

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

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

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

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

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

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

679 

680 def testFromDataclass(self): 

681 """Test creation of PropertySet from a dataclass.""" 

682 

683 @dataclasses.dataclass 

684 class TestData: 

685 string: str 

686 number: int 

687 

688 t = TestData("test", 42) 

689 ps = dafBase.PropertySet.from_mapping(t) 

690 self.assertEqual(ps.toDict(), {"string": "test", "number": 42}) 

691 

692 def testAddVector(self): 

693 ps = dafBase.PropertySet() 

694 v = [42, 2008, 1] 

695 ps.set("ints", v) 

696 

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

698 ps.add("ints", vv) 

699 

700 w = ps.getArray("ints") 

701 self.assertEqual(w, v + vv) 

702 

703 def testArrayProperties(self): 

704 ps = dafBase.PropertySet() 

705 v = [42, 2008, 1] 

706 ps.set("ints", v) 

707 ps.set("int", 365) 

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

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

710 

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

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

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

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

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

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

717 self.assertEqual(ps.valueCount(), 6) 

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

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

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

721 

722 def testHierarchy(self): 

723 ps = dafBase.PropertySet() 

724 psp = dafBase.PropertySet() 

725 

726 psp.set("pre", 1) 

727 ps.set("ps1", psp) 

728 psp.set("post", 2) 

729 ps.set("int", 42) 

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

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

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

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

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

735 

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

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

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

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

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

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

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

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

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

745 

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

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

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

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

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

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

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

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

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

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

756 

757 psp1 = ps.getPropertySet("ps1") 

758 psp2 = ps.getPropertySet("ps2") 

759 psp3 = ps.getPropertySet("ps3") 

760 self.assertIsInstance(psp1, dafBase.PropertySet) 

761 self.assertIsInstance(psp2, dafBase.PropertySet) 

762 self.assertIsInstance(psp3, dafBase.PropertySet) 

763 self.assertEqual(psp1, psp) 

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

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

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

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

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

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

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

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

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

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

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

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

776 

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

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

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

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

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

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

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

784 # create it. 

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

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

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

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

789 

790# 

791 def testvariousThrows(self): 

792 ps = dafBase.PropertySet() 

793 ps.set("int", 42) 

794 with self.assertRaises(pexExcept.InvalidParameterError): 

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

796 with self.assertRaises(TypeError): 

797 ps.getDouble("int") 

798 with self.assertRaises(LookupError): 

799 ps.getDouble("double") 

800 with self.assertRaises(KeyError): 

801 ps.getArray("double") 

802 with self.assertRaises(LookupError): 

803 ps.typeOf("double") 

804 with self.assertRaises(TypeError): 

805 ps.add("int", 4.2) 

806 

807 v = [3.14159, 2.71828] 

808 with self.assertRaises(TypeError): 

809 ps.add("int", v) 

810 ps.remove("foo.bar") 

811 ps.remove("int.sub") 

812 

813 def testIntegerRanges(self): 

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

815 """ 

816 ps = dafBase.PropertySet() 

817 minI32 = -2**31 

818 maxI32 = 2**31 - 1 

819 minI64 = -2**63 

820 maxI64 = 2**63 - 1 

821 minU64 = 0 

822 maxU64 = 2**64 - 1 

823 # Out of range for the particular type 

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

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

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

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

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

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

830 # Out of all possible integer ranges 

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

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

833 

834 def testNames(self): 

835 ps = dafBase.PropertySet() 

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

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

838 ps.set("int", 42) 

839 ps.set("double", 3.14) 

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

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

842 

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

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

845 

846 v = set(ps.names()) 

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

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

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

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

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

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

853 

854 def testParamNames(self): 

855 ps = dafBase.PropertySet() 

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

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

858 ps.set("int", 42) 

859 ps.set("double", 3.14) 

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

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

862 

863 v = set(ps.paramNames()) 

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

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

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

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

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

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

870 

871 def testPropertySetNames(self): 

872 ps = dafBase.PropertySet() 

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

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

875 ps.set("int", 42) 

876 ps.set("double", 3.14) 

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

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

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

880 

881 v = set(ps.propertySetNames()) 

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

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

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

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

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

887 

888 def testGetAs(self): 

889 ps = dafBase.PropertySet() 

890 ps.set("bool", True) 

891 ps.setShort("short", 42) 

892 ps.set("int", 2008) 

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

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

895 f = 3.14159 

896 ps.setFloat("float", f) 

897 d = 2.718281828459045 

898 ps.setDouble("double", d) 

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

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

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

902 psp = dafBase.PropertySet() 

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

904 ps.set("top", psp) 

905 

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

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

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

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

910 with self.assertRaises(TypeError): 

911 ps.getAsInt("int64_t") 

912 with self.assertRaises(TypeError): 

913 ps.getAsInt("uint64_t") 

914 with self.assertRaises(TypeError): 

915 ps.getAsInt64("uint64_t") 

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

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

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

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

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

921 with self.assertRaises(TypeError): 

922 ps.getAsInt64("float") 

923 with self.assertRaises(TypeError): 

924 ps.getAsUInt64("float") 

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

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

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

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

929 float(0xfeeddeadbeef)) 

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

931 float(0xFFFFFFFFFFFFFFFF)) 

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

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

934 with self.assertRaises(TypeError): 

935 ps.getAsDouble("char*") 

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

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

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

939 with self.assertRaises(TypeError): 

940 ps.getAsString("int") 

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

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

943 with self.assertRaises(TypeError): 

944 ps.getAsPropertySetPtr("top.bottom") 

945 

946 def testRemove(self): 

947 ps = dafBase.PropertySet() 

948 ps.set("int", 42) 

949 ps.set("double", 3.14159) 

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

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

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

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

954 

955 ps.remove("int") 

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

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

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

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

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

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

962 

963 ps.remove("ps1.zero") 

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

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

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

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

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

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

970 

971 ps.remove("ps1") 

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

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

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

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

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

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

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

979 

980 ps.remove("double") 

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

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

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

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

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

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

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

988 

989 def testDeepCopy(self): 

990 ps = dafBase.PropertySet() 

991 ps.set("int", 42) 

992 psp = dafBase.PropertySet() 

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

994 ps.set("top", psp) 

995 

996 psp2 = ps.deepCopy() 

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

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

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

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

1001 # Make sure it was indeed a deep copy. 

1002 ps.set("int", 2008) 

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

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

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

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

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

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

1009 

1010 def testToString(self): 

1011 ps = dafBase.PropertySet() 

1012 ps.set("bool", True) 

1013 s = 42 

1014 ps.setShort("short", s) 

1015 ps.set("int", 2008) 

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

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

1018 f = 3.14159 

1019 ps.setFloat("float", f) 

1020 d = 2.718281828459045 

1021 ps.setDouble("double", d) 

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

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

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

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

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

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

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

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

1030 ps.add("v", 10) 

1031 ps.add("v", 9) 

1032 ps.add("v", 8) 

1033 

1034 self.assertEqual(ps.toString(), 

1035 "bool = 1\n" 

1036 "char* = \"foo\"\n" 

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

1038 "double = 2.7182818284590\n" 

1039 "float = 3.141590\n" 

1040 "int = 2008\n" 

1041 "int64_t = 280297596632815\n" 

1042 "ps1 = {\n" 

1043 "..post = 2\n" 

1044 "..pre = 1\n" 

1045 "}\n" 

1046 "ps2 = {\n" 

1047 "..minus = -10.240000000000\n" 

1048 "..plus = 10.240000000000\n" 

1049 "}\n" 

1050 "ps3 = {\n" 

1051 "..sub = {\n" 

1052 "....subsub = \"foo\"\n" 

1053 "..}\n" 

1054 "}\n" 

1055 "short = 42\n" 

1056 "string = \"bar\"\n" 

1057 "uint64_t = 18446744073709551615\n" 

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

1059 ) 

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

1061 "bool = 1\n" 

1062 "char* = \"foo\"\n" 

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

1064 "double = 2.7182818284590\n" 

1065 "float = 3.141590\n" 

1066 "int = 2008\n" 

1067 "int64_t = 280297596632815\n" 

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

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

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

1071 "short = 42\n" 

1072 "string = \"bar\"\n" 

1073 "uint64_t = 18446744073709551615\n" 

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

1075 ) 

1076 

1077 

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

1079 pass 

1080 

1081 

1082def setup_module(module): 

1083 lsst.utils.tests.init() 

1084 

1085 

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

1087 lsst.utils.tests.init() 

1088 unittest.main()