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 lsst.utils.tests 

28import lsst.daf.base as dafBase 

29 

30 

31class FloatSubClass(float): 

32 """Intended to be something like numpy.float64, without introducing a 

33 dependency on numpy 

34 """ 

35 pass 

36 

37 

38class PropertyListTestCase(unittest.TestCase): 

39 """A test case for PropertyList. 

40 """ 

41 

42 def testConstruct(self): 

43 apl = dafBase.PropertyList() 

44 self.assertIsNotNone(apl) 

45 

46 def checkPickle(self, original): 

47 new = pickle.loads(pickle.dumps(original, 2)) 

48 self.assertEqual(new, original) 

49 return new 

50 

51 def testScalar(self): 

52 apl = dafBase.PropertyList() 

53 apl.setBool("bool", True) 

54 apl.setShort("short", 42) 

55 apl.setInt("int", 2008) 

56 apl.setLongLong("int64_t", 0xfeeddeadbeef) 

57 apl.setFloat("float", 3.14159) 

58 apl.setDouble("double", 2.718281828459045) 

59 apl.set("char*", "foo") 

60 apl.setString("string", "bar") 

61 apl.set("int2", 2009) 

62 apl.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC)) 

63 apl.set("subclass", FloatSubClass(1.23456789)) 

64 apl.set("undef", None) 

65 

66 self.assertTrue(apl.isUndefined("undef")) 

67 self.assertFalse(apl.isUndefined("string")) 

68 self.assertEqual(apl.typeOf("bool"), dafBase.PropertyList.TYPE_Bool) 

69 self.assertEqual(apl.getBool("bool"), True) 

70 self.assertEqual(apl.typeOf("short"), dafBase.PropertyList.TYPE_Short) 

71 self.assertEqual(apl.getShort("short"), 42) 

72 self.assertEqual(apl.typeOf("int"), dafBase.PropertyList.TYPE_Int) 

73 self.assertEqual(apl.getInt("int"), 2008) 

74 self.assertEqual(apl.typeOf("int64_t"), 

75 dafBase.PropertyList.TYPE_LongLong) 

76 self.assertEqual(apl.getLongLong("int64_t"), 0xfeeddeadbeef) 

77 self.assertEqual(apl.typeOf("float"), dafBase.PropertyList.TYPE_Float) 

78 self.assertAlmostEqual(apl.getFloat("float"), 3.14159, 6) 

79 self.assertEqual(apl.typeOf("double"), dafBase.PropertyList.TYPE_Double) 

80 self.assertEqual(apl.getDouble("double"), 2.718281828459045) 

81 self.assertEqual(apl.typeOf("char*"), dafBase.PropertyList.TYPE_String) 

82 self.assertEqual(apl.getString("char*"), "foo") 

83 self.assertEqual(apl.typeOf("string"), dafBase.PropertyList.TYPE_String) 

84 self.assertEqual(apl.getString("string"), "bar") 

85 self.assertEqual(apl.typeOf("int2"), dafBase.PropertyList.TYPE_Int) 

86 self.assertEqual(apl.getInt("int2"), 2009) 

87 self.assertEqual(apl.get("int2"), 2009) 

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

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

90 self.assertEqual(apl.typeOf("dt"), dafBase.PropertyList.TYPE_DateTime) 

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

92 self.assertEqual(apl.getDouble("subclass"), 1.23456789) 

93 self.assertEqual(apl["int2"], 2009) 

94 

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

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

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

98 self.assertIsNone(apl["undef"]) 

99 self.checkPickle(apl) 

100 

101 # Now replace the undef value with a defined value 

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

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

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

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

106 

107 def testGetDefault(self): 

108 apl = dafBase.PropertyList() 

109 apl.setInt("int", 42) 

110 self.assertEqual(apl.getInt("int"), 42) 

111 self.assertEqual(apl.getInt("int", 2008), 42) 

112 self.assertEqual(apl.getInt("foo", 2008), 2008) 

113 self.assertEqual(apl.get("int"), 42) 

114 self.assertEqual(apl.get("int", 2008), 42) 

115 self.assertEqual(apl.get("foo", 2008), 2008) 

116 self.assertEqual(apl.get("foo2", default="missing"), "missing") 

117 self.assertIsNone(apl.get("foo")) 

118 

119 def testExists(self): 

120 apl = dafBase.PropertyList() 

121 apl.setInt("int", 42) 

122 self.assertEqual(apl.exists("int"), True) 

123 self.assertEqual(apl.exists("foo"), False) 

124 

125 def testGetVector(self): 

126 apl = dafBase.PropertyList() 

127 v = [42, 2008, 1] 

128 apl.setInt("ints", v) 

129 apl.setInt("ints2", [10, 9, 8]) 

130 w = apl.getArrayInt("ints") 

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

132 self.assertEqual(v, w) 

133 self.assertEqual(apl.getInt("ints2"), 8) 

134 self.assertEqual(apl.getArrayInt("ints2"), [10, 9, 8]) 

135 w = apl.get("ints") 

136 self.assertIsInstance(w, int) 

137 self.assertEqual(v[-1], w) 

138 self.assertEqual(apl["ints"], v[-1]) 

139 self.assertEqual(apl.getArray("ints"), v) 

140 self.assertEqual(apl.getScalar("ints"), v[-1]) 

141 apl.setInt("int", 999) 

142 x = apl.get("int") 

143 self.assertEqual(x, 999) 

144 self.assertEqual(apl.getArray("int"), [999]) 

145 self.assertEqual(apl.getScalar("int"), 999) 

146 self.assertEqual(apl["int"], 999) 

147 

148 self.checkPickle(apl) 

149 

150 def testGetVector2(self): 

151 apl = dafBase.PropertyList() 

152 v = [42, 2008, 1] 

153 apl.setInt("ints", v) 

154 apl.setInt("ints2", [10, 9, 8]) 

155 w = apl.getArrayInt("ints") 

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

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

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

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

160 self.assertEqual(apl.getInt("ints2"), 8) 

161 self.assertEqual(apl.getArrayInt("ints2"), [10, 9, 8]) 

162 

163 self.checkPickle(apl) 

164 

165 def testAddScalar(self): 

166 apl = dafBase.PropertyList() 

167 v = [42, 2008, 1] 

168 apl.setInt("ints", v) 

169 apl.addInt("ints", -999) 

170 apl.add("other", "foo") 

171 apl.add("ints", 13) 

172 apl.add("subclass", FloatSubClass(1.23456789)) 

173 w = apl.getArrayInt("ints") 

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

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

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

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

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

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

180 self.assertEqual(apl.getString("other"), "foo") 

181 self.assertEqual(apl.get("subclass"), 1.23456789) 

182 self.assertEqual(apl.getArray("subclass"), [1.23456789]) 

183 self.assertEqual(apl.getScalar("subclass"), 1.23456789) 

184 

185 def testDateTimeToString(self): 

186 apl = dafBase.PropertyList() 

187 apl.set("dt", dafBase.DateTime("20090402T072639.314159265Z", dafBase.DateTime.UTC)) 

188 self.assertEqual(apl.toString(), 

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

190 

191 def testGetScalarThrow(self): 

192 apl = dafBase.PropertyList() 

193 apl.setBool("bool", True) 

194 apl.setShort("short", 42) 

195 apl.setInt("int", 2008) 

196 apl.setLongLong("int64_t", 0xfeeddeadbeef) 

197 apl.setFloat("float", 3.14159) 

198 apl.setDouble("double", 2.718281828459045) 

199 apl.setString("string", "bar") 

200 

201 with self.assertRaises(KeyError): 

202 apl["foo"] 

203 with self.assertRaises(TypeError): 

204 apl.getBool("short") 

205 with self.assertRaises(TypeError): 

206 apl.getBool("int") 

207 with self.assertRaises(TypeError): 

208 apl.getShort("int") 

209 with self.assertRaises(TypeError): 

210 apl.getInt("short") 

211 with self.assertRaises(TypeError): 

212 apl.getInt("bool") 

213 with self.assertRaises(TypeError): 

214 apl.getDouble("float") 

215 with self.assertRaises(TypeError): 

216 apl.getFloat("double") 

217 with self.assertRaises(TypeError): 

218 apl.getString("int") 

219 

220 def testAddVector(self): 

221 apl = dafBase.PropertyList() 

222 v = [42, 2008, 1] 

223 apl.set("ints", v) 

224 apl.add("ints", [-42, -2008, -1]) 

225 subclass = [FloatSubClass(1.23), FloatSubClass(4.56), FloatSubClass(7.89)] 

226 apl.add("subclass", subclass) 

227 self.assertEqual(apl.getArrayInt("ints"), 

228 [42, 2008, 1, -42, -2008, -1]) 

229 self.assertEqual(apl.get("subclass"), subclass[-1]) 

230 self.assertEqual(apl.getArray("subclass"), subclass) 

231 self.assertEqual(apl.getScalar("subclass"), subclass[-1]) 

232 

233 def testComment(self): 

234 apl = dafBase.PropertyList() 

235 apl.set("NAXIS", 2, "two-dimensional") 

236 self.assertEqual(apl.get("NAXIS"), 2) 

237 self.assertEqual(apl.getArray("NAXIS"), [2]) 

238 self.assertEqual(apl.getScalar("NAXIS"), 2) 

239 self.assertEqual(apl.getComment("NAXIS"), "two-dimensional") 

240 apl.set("NAXIS", 3, "three-dimensional") 

241 self.assertEqual(apl.get("NAXIS"), 3) 

242 self.assertEqual(apl.getArray("NAXIS"), [3]) 

243 self.assertEqual(apl.getScalar("NAXIS"), 3) 

244 self.assertEqual(apl.getComment("NAXIS"), "three-dimensional") 

245 

246 def testOrder(self): 

247 apl = dafBase.PropertyList() 

248 apl.set("SIMPLE", True) 

249 apl.set("BITPIX", -32) 

250 apl.set("NAXIS", 2) 

251 apl.set("COMMENT", "This is a test") 

252 apl.add("COMMENT", "This is a test line 2") 

253 apl.set("RA", 3.14159, "decimal degrees") 

254 apl.set("DEC", 2.71828, "decimal radians") 

255 correct = [ 

256 ("SIMPLE", True, ""), 

257 ("BITPIX", -32, ""), 

258 ("NAXIS", 2, ""), 

259 ("COMMENT", "This is a test", ""), 

260 ("COMMENT", "This is a test line 2", ""), 

261 ("RA", 3.14159, "decimal degrees"), 

262 ("DEC", 2.71828, "decimal radians"), 

263 ] 

264 self.assertEqual(apl.toList(), correct) 

265 apl.set("NAXIS1", 513, "length of data axis 1") 

266 correct.append(("NAXIS1", 513, "length of data axis 1")) 

267 self.assertEqual(apl.toList(), correct) 

268 apl.set("RA", 1.414) 

269 correct[5] = ("RA", 1.414, "decimal degrees") 

270 self.assertEqual(apl.toList(), correct) 

271 apl.set("DEC", 1.732) 

272 correct[6] = ("DEC", 1.732, "decimal radians") 

273 self.assertEqual(apl.toList(), correct) 

274 apl.set("DEC", -6.28, "") 

275 correct[6] = ("DEC", -6.28, "") 

276 self.assertEqual(apl.toList(), correct) 

277 apl.add("COMMENT", "This is a test line 3", "") 

278 correct.insert(5, ("COMMENT", "This is a test line 3", "")) 

279 self.assertEqual(apl.toList(), correct) 

280 

281 self.checkPickle(apl) 

282 

283 def testToOrderedDict(self): 

284 from collections import OrderedDict 

285 

286 apl = dafBase.PropertyList() 

287 apl.set("SIMPLE", True) 

288 apl.set("BITPIX", -32) 

289 apl.set("NAXIS", 2) 

290 apl.set("RA", 3.14159) 

291 apl.set("DEC", 2.71828) 

292 apl.set("FILTER", None) 

293 apl.set("COMMENT", "This is a test") 

294 apl.add("COMMENT", "This is a test line 2") 

295 correct = OrderedDict([ 

296 ("SIMPLE", True), 

297 ("BITPIX", -32), 

298 ("NAXIS", 2), 

299 ("RA", 3.14159), 

300 ("DEC", 2.71828), 

301 ("FILTER", None), 

302 ("COMMENT", ["This is a test", "This is a test line 2"]) 

303 ]) 

304 self.assertEqual(apl.toOrderedDict(), correct) 

305 

306 apl.set("NAXIS1", 513) 

307 correct["NAXIS1"] = 513 

308 self.assertEqual(apl.toOrderedDict(), correct) 

309 apl.set("RA", 1.414) 

310 correct["RA"] = 1.414 

311 self.assertEqual(apl.toOrderedDict(), correct) 

312 apl.set("DEC", 1.732) 

313 correct["DEC"] = 1.732 

314 self.assertEqual(apl.toOrderedDict(), correct) 

315 apl.set("DEC", -6.28) 

316 correct["DEC"] = -6.28 

317 self.assertEqual(apl.toOrderedDict(), correct) 

318 apl.add("COMMENT", "This is a test line 3") 

319 correct["COMMENT"] = correct["COMMENT"] + ["This is a test line 3", ] 

320 self.assertEqual(apl.toOrderedDict(), correct) 

321 

322 def testHierarchy(self): 

323 apl = dafBase.PropertyList() 

324 apl.set("CURRENT", 49.5) 

325 apl.set("CURRENT.foo", -32) 

326 apl.set("CURRENT.bar", 2) 

327 self.assertEqual(apl.get("CURRENT"), 49.5) 

328 self.assertEqual(apl.getArray("CURRENT"), [49.5]) 

329 self.assertEqual(apl.getScalar("CURRENT"), 49.5) 

330 self.assertEqual(apl.get("CURRENT.foo"), -32) 

331 self.assertEqual(apl.getArray("CURRENT.foo"), [-32]) 

332 self.assertEqual(apl.getScalar("CURRENT.foo"), -32) 

333 self.assertEqual(apl.get("CURRENT.bar"), 2) 

334 self.assertEqual(apl.getArray("CURRENT.bar"), [2]) 

335 self.assertEqual(apl.getScalar("CURRENT.bar"), 2) 

336 

337 aps = dafBase.PropertySet() 

338 aps.set("bottom", "x") 

339 aps.set("sibling", 42) 

340 apl.set("top", aps) 

341 self.assertEqual(apl.get("top.bottom"), "x") 

342 self.assertEqual(apl.getArray("top.bottom"), ["x"]) 

343 self.assertEqual(apl.getScalar("top.bottom"), "x") 

344 self.assertEqual(apl.get("top.sibling"), 42) 

345 self.assertEqual(apl.getArray("top.sibling"), [42]) 

346 self.assertEqual(apl.getScalar("top.sibling"), 42) 

347 with self.assertRaises(KeyError): 

348 apl["top"] 

349 self.assertEqual(apl.toString(), 

350 'CURRENT = 49.500000000000\nCURRENT.foo = -32\nCURRENT.bar = 2\n' 

351 'top.sibling = 42\ntop.bottom = "x"\n') 

352 

353 self.checkPickle(apl) 

354 

355 # Check that a PropertyList (with comment) can go in a PropertySet 

356 apl.set("INT", 45, "an integer") 

357 aps = dafBase.PropertySet() 

358 aps.set("bottom", "x") 

359 aps.set("apl", apl) 

360 new = self.checkPickle(aps) 

361 self.assertIsInstance(new, dafBase.PropertySet) 

362 self.assertIsInstance(new.getScalar("apl"), dafBase.PropertyList) 

363 self.assertEqual(new.getScalar("apl").getComment("INT"), "an integer") 

364 

365 def testCombineHierarchical(self): 

366 # Test that we can perform a deep copy of a PropertyList containing a 

367 # hierarchical (contains a '.') key. 

368 # This was a segfault prior to addressing DM-882. 

369 pl1 = dafBase.PropertyList() 

370 pl1.set("a.b", 1) 

371 pl2 = pl1.deepCopy() # should not segfault 

372 self.assertEqual(pl1.get("a.b"), pl2.get("a.b")) 

373 self.assertEqual(pl1.getArray("a.b"), pl2.getArray("a.b")) 

374 self.assertEqual(pl1.getScalar("a.b"), pl2.getScalar("a.b")) 

375 self.checkPickle(pl1) 

376 

377 def testCopy(self): 

378 dest = dafBase.PropertyList() 

379 source = dafBase.PropertyList() 

380 value1 = [1.5, 3.2] 

381 source.set("srcItem1", value1) 

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

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

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

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

386 

387 # items are replaced, regardless of type 

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

389 value2 = [5, -4, 3] 

390 source.set("srcItem2", value2) 

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

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

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

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

395 

396 # asScalar copies only the last value 

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

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

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

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

401 

402 def testArrayProperties(self): 

403 apl = dafBase.PropertyList() 

404 v = [42, 2008, 1] 

405 apl.set("ints", v) 

406 apl.set("int", 365) 

407 apl.set("ints2", -42) 

408 apl.add("ints2", -2008) 

409 

410 self.assertTrue(apl.isArray("ints")) 

411 self.assertFalse(apl.isArray("int")) 

412 self.assertTrue(apl.isArray("ints2")) 

413 self.assertEqual(apl.valueCount("ints"), 3) 

414 self.assertEqual(apl.valueCount("int"), 1) 

415 self.assertEqual(apl.valueCount("ints2"), 2) 

416 self.assertEqual(apl.typeOf("ints"), dafBase.PropertyList.TYPE_Int) 

417 self.assertEqual(apl.typeOf("int"), dafBase.PropertyList.TYPE_Int) 

418 self.assertEqual(apl.typeOf("ints2"), dafBase.PropertyList.TYPE_Int) 

419 

420 def testHierarchy2(self): 

421 apl = dafBase.PropertyList() 

422 aplp = dafBase.PropertyList() 

423 

424 aplp.set("pre", 1) 

425 apl.set("apl1", aplp) 

426 

427 # Python will not see this, aplp is disconnected 

428 aplp.set("post", 2) 

429 self.assertFalse(apl.exists("apl1.post")) 

430 

431 apl.set("int", 42) 

432 

433 # Setting an empty PropertyList has no effect 

434 apl.set("apl2", dafBase.PropertyList()) 

435 self.assertFalse(apl.exists("apl2")) 

436 

437 apl.set("apl2.plus", 10.24) 

438 apl.set("apl2.minus", -10.24) 

439 apl.set("apl3.sub1", "foo") 

440 apl.set("apl3.sub2", "bar") 

441 

442 self.assertTrue(apl.exists("apl1.pre")) 

443 self.assertTrue(apl.exists("apl2.plus")) 

444 self.assertTrue(apl.exists("apl2.minus")) 

445 self.assertTrue(apl.exists("apl3.sub1")) 

446 self.assertTrue(apl.exists("apl3.sub2")) 

447 

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

449 self.assertFalse(apl.exists("apl2.pre")) 

450 self.assertFalse(apl.exists("apl2.pre")) 

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

452 self.assertFalse(apl.exists("apl4")) 

453 self.assertFalse(apl.exists("apl4")) 

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

455 # create it. 

456 self.assertFalse(apl.exists("apl4.sub")) 

457 self.assertFalse(apl.exists("apl4.sub")) 

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

459 self.assertFalse(apl.exists("apl4")) 

460 

461 def testvariousThrows(self): 

462 apl = dafBase.PropertyList() 

463 apl.set("int", 42) 

464 

465 # This raises an exception in C++ test but works in Python 

466 apl.set("int.sub", "foo") 

467 

468 with self.assertRaises(TypeError): 

469 apl.getDouble("int") 

470 with self.assertRaises(LookupError): 

471 apl.getDouble("double"), 

472 with self.assertRaises(LookupError): 

473 apl.getArrayDouble("double") 

474 with self.assertRaises(LookupError): 

475 apl.typeOf("double") 

476 with self.assertRaises(TypeError): 

477 apl.add("int", 4.2), 

478 

479 v = [3.14159, 2.71828] 

480 with self.assertRaises(TypeError): 

481 apl.add("int", v) 

482 apl.remove("foo.bar") 

483 apl.remove("int.sub") 

484 

485 def testNames(self): 

486 apl = dafBase.PropertyList() 

487 apl.set("apl1.pre", 1) 

488 apl.set("apl1.post", 2) 

489 apl.set("int", 42) 

490 apl.set("double", 3.14) 

491 apl.set("apl2.plus", 10.24) 

492 apl.set("apl2.minus", -10.24) 

493 

494 # Hierarchy is always flat 

495 self.assertEqual(apl.nameCount(), 6) 

496 self.assertEqual(apl.nameCount(False), 6) 

497 

498 v = set(apl.names()) 

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

500 self.assertEqual(v, {"double", "int", "apl1.post", 

501 "apl1.pre", "apl2.minus", "apl2.plus"}) 

502 

503 def testParamNames(self): 

504 apl = dafBase.PropertyList() 

505 apl.set("apl1.pre", 1) 

506 apl.set("apl1.post", 2) 

507 apl.set("int", 42) 

508 apl.set("double", 3.14) 

509 apl.set("apl2.plus", 10.24) 

510 apl.set("apl2.minus", -10.24) 

511 

512 v = set(apl.paramNames()) 

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

514 self.assertEqual(v, {"double", "int", "apl1.post", "apl1.pre", 

515 "apl2.minus", "apl2.plus"}) 

516 

517 def testPropertySetNames(self): 

518 apl = dafBase.PropertyList() 

519 apl.set("apl1.pre", 1) 

520 apl.set("apl1.post", 2) 

521 apl.set("int", 42) 

522 apl.set("double", 3.14) 

523 apl.set("apl2.plus", 10.24) 

524 apl.set("apl2.minus", -10.24) 

525 apl.set("apl3.sub.subsub", "foo") 

526 

527 # There are no PropertySets inside flattened PropertyList 

528 v = set(apl.propertySetNames()) 

529 self.assertEqual(len(v), 0) 

530 

531 def testGetAs(self): 

532 apl = dafBase.PropertyList() 

533 apl.set("bool", True) 

534 s = 42 

535 apl.setShort("short", s) 

536 apl.set("int", 2008) 

537 apl.set("int64_t", 0xfeeddeadbeef) 

538 f = 3.14159 

539 apl.setFloat("float", f) 

540 d = 2.718281828459045 

541 apl.setDouble("double", d) 

542 apl.setString("char*", "foo") 

543 apl.set("char*2", "foo2") 

544 apl.set("string", "bar") 

545 aplp = dafBase.PropertyList() 

546 aplp.set("bottom", "x") 

547 apl.set("top", aplp) 

548 

549 self.assertEqual(apl.getAsBool("bool"), True) 

550 self.assertEqual(apl.getAsInt("bool"), 1) 

551 self.assertEqual(apl.getAsInt("short"), 42) 

552 self.assertEqual(apl.getAsInt("int"), 2008) 

553 with self.assertRaises(TypeError): 

554 apl.getAsInt("int64_t") 

555 self.assertEqual(apl.getAsInt64("bool"), 1) 

556 self.assertEqual(apl.getAsInt64("short"), 42) 

557 self.assertEqual(apl.getAsInt64("int"), 2008) 

558 self.assertEqual(apl.getAsInt64("int64_t"), 0xfeeddeadbeef) 

559 with self.assertRaises(TypeError): 

560 apl.getAsInt64("float") 

561 self.assertEqual(apl.getAsDouble("bool"), 1.0) 

562 self.assertEqual(apl.getAsDouble("short"), 42.0) 

563 self.assertEqual(apl.getAsDouble("int"), 2008.0) 

564 self.assertEqual(apl.getAsDouble("int64_t"), float(0xfeeddeadbeef)) 

565 self.assertAlmostEqual(apl.getAsDouble("float"), 3.14159, places=5) 

566 self.assertEqual(apl.getAsDouble("double"), 2.718281828459045) 

567 with self.assertRaises(TypeError): 

568 apl.getAsDouble("char*") 

569 self.assertEqual(apl.getAsString("char*"), "foo") 

570 self.assertEqual(apl.getAsString("char*2"), "foo2") 

571 self.assertEqual(apl.getAsString("string"), "bar") 

572 with self.assertRaises(TypeError): 

573 apl.getAsString("int") 

574 self.assertEqual(apl.getAsString("top.bottom"), "x") 

575 

576 def testCombine(self): 

577 apl = dafBase.PropertyList() 

578 apl.set("apl1.pre", 1) 

579 apl.set("apl1.post", 2) 

580 apl.set("int", 42) 

581 apl.set("double", 3.14) 

582 apl.set("apl2.plus", 10.24) 

583 apl.set("apl2.minus", -10.24) 

584 apl.set("apl3.sub.subsub", "foo") 

585 

586 aplp = dafBase.PropertyList() 

587 aplp.set("apl1.pre", 3) 

588 aplp.add("apl1.pre", 4) 

589 aplp.set("int", 2008) 

590 aplp.set("apl2.foo", "bar") 

591 aplp.set("apl4.top", "bottom") 

592 

593 apl.combine(aplp) 

594 

595 self.assertFalse(apl.isArray("apl1")) 

596 self.assertTrue(apl.isArray("apl1.pre")) 

597 self.assertFalse(apl.isArray("apl1.post")) 

598 self.assertFalse(apl.isArray("apl2")) 

599 self.assertFalse(apl.isArray("apl2.plus")) 

600 self.assertFalse(apl.isArray("apl2.minus")) 

601 self.assertFalse(apl.isArray("apl2.foo")) 

602 self.assertFalse(apl.isArray("apl3")) 

603 self.assertFalse(apl.isArray("apl3.sub")) 

604 self.assertFalse(apl.isArray("apl3.subsub")) 

605 self.assertFalse(apl.isArray("apl4")) 

606 self.assertFalse(apl.isArray("apl4.top")) 

607 self.assertTrue(apl.isArray("int")) 

608 self.assertFalse(apl.isArray("double")) 

609 self.assertEqual(apl.valueCount("apl1.pre"), 3) 

610 self.assertEqual(apl.valueCount("int"), 2) 

611 v = apl.getArray("apl1.pre") 

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

613 v = apl.getArray("int") 

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

615 

616 def testUpdate(self): 

617 apl = dafBase.PropertyList() 

618 apl.set("apl1.pre", 1) 

619 apl.set("apl1.post", 2) 

620 apl.set("int", 42) 

621 apl.set("double", 3.14) 

622 apl.set("apl2.plus", 10.24) 

623 apl.set("apl2.minus", -10.24) 

624 apl.set("apl3.sub.subsub", "foo") 

625 

626 aplp = dafBase.PropertyList() 

627 aplp.set("apl1.pre", 3) 

628 aplp.add("apl1.pre", 4) 

629 aplp.set("int", 2008) 

630 aplp.set("apl2.foo", "bar") 

631 aplp.set("apl4.top", "bottom") 

632 

633 apl.update(aplp) 

634 

635 self.assertFalse(apl.isArray("apl1")) 

636 self.assertTrue(apl.isArray("apl1.pre")) 

637 self.assertFalse(apl.isArray("apl1.post")) 

638 self.assertFalse(apl.isArray("apl2")) 

639 self.assertFalse(apl.isArray("apl2.plus")) 

640 self.assertFalse(apl.isArray("apl2.minus")) 

641 self.assertFalse(apl.isArray("apl2.foo")) 

642 self.assertFalse(apl.isArray("apl3")) 

643 self.assertFalse(apl.isArray("apl3.sub")) 

644 self.assertFalse(apl.isArray("apl3.subsub")) 

645 self.assertFalse(apl.isArray("apl4")) 

646 self.assertFalse(apl.isArray("apl4.top")) 

647 self.assertFalse(apl.isArray("int")) 

648 self.assertFalse(apl.isArray("double")) 

649 self.assertEqual(apl.valueCount("apl1.pre"), 2) 

650 self.assertEqual(apl.valueCount("int"), 1) 

651 v = apl.getArray("apl1.pre") 

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

653 v = apl.getArray("int") 

654 self.assertEqual(v, [2008]) 

655 

656 apld = {"int": 100, "str": "String", "apl1.foo": 10.5} 

657 apl.update(apld) 

658 self.assertEqual(apl["int"], apld["int"]) 

659 self.assertEqual(apl["str"], apld["str"]) 

660 self.assertEqual(apl["apl1.foo"], apld["apl1.foo"]) 

661 self.assertEqual(apl["double"], 3.14) 

662 

663 def testCombineThrow(self): 

664 apl = dafBase.PropertyList() 

665 apl.set("int", 42) 

666 

667 aplp = dafBase.PropertyList() 

668 aplp.set("int", 3.14159) 

669 

670 with self.assertRaises(TypeError): 

671 apl.combine(aplp) 

672 

673 psd = {"bool": True} 

674 with self.assertRaises(TypeError): 

675 apl.combine(psd) 

676 

677 def testremove(self): 

678 apl = dafBase.PropertyList() 

679 apl.set("int", 42) 

680 apl.set("double", 3.14159) 

681 apl.set("apl1.plus", 1) 

682 apl.set("apl1.minus", -1) 

683 apl.set("apl1.zero", 0) 

684 self.assertEqual(apl.nameCount(False), 5) 

685 

686 apl.remove("int") 

687 self.assertFalse(apl.exists("int")) 

688 self.assertEqual(apl.getAsDouble("double"), 3.14159) 

689 self.assertEqual(apl.getAsInt("apl1.plus"), 1) 

690 self.assertEqual(apl.getAsInt("apl1.minus"), -1) 

691 self.assertEqual(apl.getAsInt("apl1.zero"), 0) 

692 self.assertEqual(apl.nameCount(False), 4) 

693 

694 apl.remove("apl1.zero") 

695 self.assertFalse(apl.exists("int")) 

696 self.assertEqual(apl.getAsDouble("double"), 3.14159) 

697 self.assertFalse(apl.exists("apl1.zero")) 

698 self.assertEqual(apl.getAsInt("apl1.plus"), 1) 

699 self.assertEqual(apl.getAsInt("apl1.minus"), -1) 

700 self.assertEqual(apl.nameCount(False), 3) 

701 

702 # Removing a non-existent key (flattened) has no effect 

703 self.assertFalse(apl.exists("apl1")) 

704 apl.remove("apl1") 

705 self.assertFalse(apl.exists("int")) 

706 self.assertEqual(apl.getAsDouble("double"), 3.14159) 

707 self.assertFalse(apl.exists("apl1")) 

708 self.assertTrue(apl.exists("apl1.plus")) 

709 self.assertTrue(apl.exists("apl1.minus")) 

710 self.assertFalse(apl.exists("apl1.zero")) 

711 self.assertEqual(apl.nameCount(False), 3) 

712 

713 apl.remove("double") 

714 self.assertFalse(apl.exists("int")) 

715 self.assertFalse(apl.exists("double")) 

716 self.assertFalse(apl.exists("apl1")) 

717 self.assertTrue(apl.exists("apl1.plus")) 

718 self.assertTrue(apl.exists("apl1.minus")) 

719 self.assertFalse(apl.exists("apl1.zero")) 

720 self.assertEqual(apl.nameCount(False), 2) 

721 

722 apl.remove("apl1.plus") 

723 apl.remove("apl1.minus") 

724 self.assertEqual(apl.nameCount(False), 0) 

725 

726 def testdeepCopy(self): 

727 apl = dafBase.PropertyList() 

728 apl.set("int", 42) 

729 aplp = dafBase.PropertyList() 

730 aplp.set("bottom", "x") 

731 apl.set("top", aplp) 

732 

733 aplp2 = apl.deepCopy() 

734 self.assertTrue(aplp2.exists("int")) 

735 self.assertTrue(aplp2.exists("top.bottom")) 

736 self.assertEqual(aplp2.getAsInt("int"), 42) 

737 self.assertEqual(aplp2.getAsString("top.bottom"), "x") 

738 # Make sure it was indeed a deep copy. 

739 apl.set("int", 2008) 

740 apl.set("top.bottom", "z") 

741 self.assertEqual(apl.getAsInt("int"), 2008) 

742 self.assertEqual(apl.getAsString("top.bottom"), "z") 

743 self.assertEqual(aplp2.getAsInt("int"), 42) 

744 self.assertEqual(aplp2.getAsString("top.bottom"), "x") 

745 

746 def testToString(self): 

747 apl = dafBase.PropertyList() 

748 apl.set("bool", True) 

749 s = 42 

750 apl.setShort("short", s) 

751 apl.set("int", 2008) 

752 apl.set("int64_t", 0xfeeddeadbeef) 

753 f = 3.14159 

754 apl.setFloat("float", f) 

755 d = 2.718281828459045 

756 apl.setDouble("double", d) 

757 apl.setString("char*", "foo") 

758 apl.set("char*2", "foo2") 

759 apl.set("string", "bar") 

760 apl.set("apl1.pre", 1) 

761 apl.set("apl1.post", 2) 

762 apl.set("apl2.plus", 10.24) 

763 apl.set("apl2.minus", -10.24) 

764 apl.set("apl3.sub.subsub", "foo") 

765 apl.add("v", 10) 

766 apl.add("v", 9) 

767 apl.add("v", 8) 

768 

769 # Check that the keys returned for this PropertyList match 

770 # the order they were set 

771 order = ['bool', 'short', 'int', 'int64_t', 'float', 'double', 'char*', 'char*2', 

772 'string', 'apl1.pre', 'apl1.post', 'apl2.plus', 'apl2.minus', 'apl3.sub.subsub', 'v'] 

773 self.assertEqual(apl.getOrderedNames(), order) 

774 

775 # Argument to toString has no effect for flattened hierarchy 

776 self.assertEqual(apl.toString(), 

777 "bool = 1\n" 

778 "short = 42\n" 

779 "int = 2008\n" 

780 "int64_t = 280297596632815\n" 

781 "float = 3.141590\n" 

782 "double = 2.7182818284590\n" 

783 "char* = \"foo\"\n" 

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

785 "string = \"bar\"\n" 

786 "apl1.pre = 1\n" 

787 "apl1.post = 2\n" 

788 "apl2.plus = 10.240000000000\n" 

789 "apl2.minus = -10.240000000000\n" 

790 "apl3.sub.subsub = \"foo\"\n" 

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

792 ) 

793 self.assertEqual(apl.toString(True), 

794 "bool = 1\n" 

795 "short = 42\n" 

796 "int = 2008\n" 

797 "int64_t = 280297596632815\n" 

798 "float = 3.141590\n" 

799 "double = 2.7182818284590\n" 

800 "char* = \"foo\"\n" 

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

802 "string = \"bar\"\n" 

803 "apl1.pre = 1\n" 

804 "apl1.post = 2\n" 

805 "apl2.plus = 10.240000000000\n" 

806 "apl2.minus = -10.240000000000\n" 

807 "apl3.sub.subsub = \"foo\"\n" 

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

809 ) 

810 

811 

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

813 pass 

814 

815 

816def setup_module(module): 

817 lsst.utils.tests.init() 

818 

819 

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

821 lsst.utils.tests.init() 

822 unittest.main()