Coverage for tests/test_wrappers.py: 15%

Shortcuts 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

338 statements  

1# This file is part of utils. 

2# 

3# Developed for the LSST Data Management System. 

4# This product includes software developed by the LSST Project 

5# (https://www.lsst.org). 

6# See the COPYRIGHT file at the top-level directory of this distribution 

7# for details of code ownership. 

8# 

9# Use of this source code is governed by a 3-clause BSD-style 

10# license that can be found in the LICENSE file. 

11 

12import numpy as np 

13import unittest 

14import lsst.utils.tests 

15import lsst.utils 

16 

17 

18class MockClass: # continued class needs to be at module scope 

19 

20 def method1(self): 

21 return self 

22 

23 @classmethod 

24 def method2(cls): 

25 return cls 

26 

27 @staticmethod 

28 def method3(): 

29 return True 

30 

31 @property 

32 def property1(self): 

33 return False 

34 

35 

36class DecoratorsTestCase(lsst.utils.tests.TestCase): 

37 

38 def setUp(self): 

39 @lsst.utils.continueClass 

40 class MockClass: 

41 

42 def method1a(self): 

43 return self 

44 

45 @classmethod 

46 def method2a(cls): 

47 return cls 

48 

49 @staticmethod 

50 def method3a(): 

51 return True 

52 

53 @property 

54 def property1a(self): 

55 return False 

56 

57 @lsst.utils.inClass(MockClass) 

58 def method1b(self): 

59 return self 

60 

61 @lsst.utils.inClass(MockClass) 

62 @classmethod 

63 def method2b(cls): 

64 return cls 

65 

66 @lsst.utils.inClass(MockClass) 

67 @staticmethod 

68 def method3b(): 

69 return True 

70 

71 @lsst.utils.inClass(MockClass) 

72 @property 

73 def property1b(self): 

74 return False 

75 

76 def testAttributeCopying(self): 

77 x = MockClass() 

78 self.assertIs(x.method1(), x) 

79 self.assertIs(x.method1a(), x) 

80 self.assertIs(x.method1b(), x) 

81 self.assertIs(x.method2(), MockClass) 

82 self.assertIs(x.method2a(), MockClass) 

83 self.assertIs(x.method2b(), MockClass) 

84 self.assertIs(MockClass.method2(), MockClass) 

85 self.assertIs(MockClass.method2a(), MockClass) 

86 self.assertIs(MockClass.method2b(), MockClass) 

87 self.assertTrue(x.method3()) 

88 self.assertTrue(x.method3a()) 

89 self.assertTrue(x.method3b()) 

90 self.assertTrue(MockClass.method3()) 

91 self.assertTrue(MockClass.method3a()) 

92 self.assertTrue(MockClass.method3b()) 

93 self.assertFalse(x.property1) 

94 self.assertFalse(x.property1a) 

95 self.assertFalse(x.property1b) 

96 

97 

98class TemplateMetaSimpleTestCase(lsst.utils.tests.TestCase): 

99 """Test TemplateMeta on a mockup of a template with a single dtype 

100 template parameter. 

101 """ 

102 

103 def setUp(self): 

104 

105 class Example(metaclass=lsst.utils.TemplateMeta): 

106 

107 def method1(self): 

108 return self 

109 

110 @classmethod 

111 def method2(cls): 

112 return cls 

113 

114 @staticmethod 

115 def method3(): 

116 return True 

117 

118 @property 

119 def property1(self): 

120 return False 

121 

122 class ExampleF: 

123 pass 

124 

125 class ExampleD: 

126 pass 

127 

128 self.Example = Example 

129 self.ExampleF = ExampleF 

130 self.ExampleD = ExampleD 

131 

132 def register(self): 

133 self.Example.register(np.float32, self.ExampleF) 

134 self.Example.register(np.float64, self.ExampleD) 

135 

136 def alias(self): 

137 self.Example.alias("F", self.ExampleF) 

138 self.Example.alias("D", self.ExampleD) 

139 

140 def testCorrectRegistration(self): 

141 self.register() 

142 self.assertEqual(self.ExampleF.dtype, np.float32) 

143 self.assertEqual(self.ExampleD.dtype, np.float64) 

144 self.assertIn(np.float32, self.Example) 

145 self.assertIn(np.float64, self.Example) 

146 self.assertEqual(self.Example[np.float32], self.ExampleF) 

147 self.assertEqual(self.Example[np.float64], self.ExampleD) 

148 

149 def testAliases(self): 

150 self.register() 

151 self.alias() 

152 self.assertEqual(self.ExampleF.dtype, np.float32) 

153 self.assertEqual(self.ExampleD.dtype, np.float64) 

154 self.assertIn("F", self.Example) 

155 self.assertIn("D", self.Example) 

156 self.assertEqual(self.Example["F"], self.ExampleF) 

157 self.assertEqual(self.Example["D"], self.ExampleD) 

158 self.assertEqual(self.Example["F"], self.Example[np.float32]) 

159 self.assertEqual(self.Example["D"], self.Example[np.float64]) 

160 

161 def testInheritanceHooks(self): 

162 self.register() 

163 self.assertTrue(issubclass(self.ExampleF, self.Example)) 

164 self.assertTrue(issubclass(self.ExampleD, self.Example)) 

165 f = self.ExampleF() 

166 d = self.ExampleD() 

167 self.assertIsInstance(f, self.Example) 

168 self.assertIsInstance(d, self.Example) 

169 self.assertEqual(set(self.Example.__subclasses__()), set([self.ExampleF, self.ExampleD])) 

170 

171 def testConstruction(self): 

172 self.register() 

173 f1 = self.Example(dtype=np.float32) 

174 # Test that numpy dtype objects resolve to their underlying type 

175 f2 = self.Example(dtype=np.dtype(np.float32)) 

176 for f in (f1, f2): 

177 self.assertIsInstance(f, self.Example) 

178 self.assertIsInstance(f, self.ExampleF) 

179 self.assertNotIsInstance(f, self.ExampleD) 

180 

181 with self.assertRaises(TypeError): 

182 self.Example() 

183 with self.assertRaises(TypeError): 

184 self.Example(dtype=np.int32) 

185 

186 def testAttributeCopying(self): 

187 self.register() 

188 f = self.ExampleF() 

189 d = self.ExampleD() 

190 self.assertIs(f.method1(), f) 

191 self.assertIs(d.method1(), d) 

192 self.assertIs(f.method2(), self.ExampleF) 

193 self.assertIs(d.method2(), self.ExampleD) 

194 self.assertIs(self.ExampleF.method2(), self.ExampleF) 

195 self.assertIs(self.ExampleD.method2(), self.ExampleD) 

196 self.assertTrue(f.method3()) 

197 self.assertTrue(d.method3()) 

198 self.assertTrue(self.ExampleF.method3()) 

199 self.assertTrue(self.ExampleD.method3()) 

200 self.assertFalse(f.property1) 

201 self.assertFalse(d.property1) 

202 

203 def testDictBehavior(self): 

204 self.register() 

205 self.assertIn(np.float32, self.Example) 

206 self.assertEqual(self.Example[np.float32], self.ExampleF) 

207 self.assertEqual(set(self.Example.keys()), 

208 set([np.float32, np.float64])) 

209 self.assertEqual(set(self.Example.values()), 

210 set([self.ExampleF, self.ExampleD])) 

211 self.assertEqual(set(self.Example.items()), 

212 set([(np.float32, self.ExampleF), 

213 (np.float64, self.ExampleD)])) 

214 self.assertEqual(len(self.Example), 2) 

215 self.assertEqual(set(iter(self.Example)), set([np.float32, np.float64])) 

216 self.assertEqual(self.Example.get(np.float64), self.ExampleD) 

217 self.assertEqual(self.Example.get(np.int32, False), False) 

218 

219 def testNoInheritedDictBehavior(self): 

220 self.register() 

221 f = self.ExampleF() 

222 with self.assertRaises(Exception): # Py2:AttributeError, Py3:TypeError 

223 len(f) 

224 with self.assertRaises(Exception): # Py2:AttributeError, Py3:TypeError 

225 f["F"] 

226 with self.assertRaises(TypeError): 

227 for x in f: 

228 pass 

229 with self.assertRaises(TypeError): 

230 len(self.ExampleF) 

231 with self.assertRaises(TypeError): 

232 self.ExampleF["F"] 

233 with self.assertRaises(TypeError): 

234 for x in self.ExampleF: 

235 pass 

236 

237 def testAliasUnregistered(self): 

238 with self.assertRaises(ValueError): 

239 self.Example.alias("F", self.ExampleF) 

240 self.assertEqual(len(self.Example), 0) 

241 self.assertEqual(len(self.Example), 0) 

242 

243 def testRegisterDTypeTwice(self): 

244 with self.assertRaises(KeyError): 

245 self.Example.register("F", self.ExampleF) 

246 self.Example.register("F", self.ExampleD) 

247 self.assertEqual(len(self.Example), 1) 

248 

249 def testRegisterTemplateTwice(self): 

250 with self.assertRaises(ValueError): 

251 self.Example.register("F", self.ExampleF) 

252 self.Example.register("D", self.ExampleF) 

253 self.assertEqual(len(self.Example), 1) 

254 

255 

256class TemplateMetaHardTestCase(lsst.utils.tests.TestCase): 

257 """Test TemplateMeta with a mockup of a template with multiple 

258 template parameters. 

259 """ 

260 

261 def setUp(self): 

262 

263 class Example(metaclass=lsst.utils.TemplateMeta): 

264 

265 TEMPLATE_PARAMS = ("d", "u") 

266 TEMPLATE_DEFAULTS = (2, None) 

267 

268 class Example2F: 

269 pass 

270 

271 class Example2D: 

272 pass 

273 

274 class Example3F: 

275 pass 

276 

277 class Example3D: 

278 pass 

279 

280 self.Example = Example 

281 self.Example2F = Example2F 

282 self.Example2D = Example2D 

283 self.Example3F = Example3F 

284 self.Example3D = Example3D 

285 

286 def register(self): 

287 self.Example.register((2, np.float32), self.Example2F) 

288 self.Example.register((2, np.float64), self.Example2D) 

289 self.Example.register((3, np.float32), self.Example3F) 

290 self.Example.register((3, np.float64), self.Example3D) 

291 

292 def alias(self): 

293 self.Example.alias("2F", self.Example2F) 

294 self.Example.alias("2D", self.Example2D) 

295 self.Example.alias("3F", self.Example3F) 

296 self.Example.alias("3D", self.Example3D) 

297 

298 def testCorrectRegistration(self): 

299 self.register() 

300 self.assertEqual(self.Example2F.d, 2) 

301 self.assertEqual(self.Example2F.u, np.float32) 

302 self.assertEqual(self.Example2D.d, 2) 

303 self.assertEqual(self.Example2D.u, np.float64) 

304 self.assertEqual(self.Example3F.d, 3) 

305 self.assertEqual(self.Example3F.u, np.float32) 

306 self.assertEqual(self.Example3D.d, 3) 

307 self.assertEqual(self.Example3D.u, np.float64) 

308 self.assertIn((2, np.float32), self.Example) 

309 self.assertIn((2, np.float64), self.Example) 

310 self.assertIn((3, np.float32), self.Example) 

311 self.assertIn((3, np.float64), self.Example) 

312 self.assertEqual(self.Example[2, np.float32], self.Example2F) 

313 self.assertEqual(self.Example[2, np.float64], self.Example2D) 

314 self.assertEqual(self.Example[3, np.float32], self.Example3F) 

315 self.assertEqual(self.Example[3, np.float64], self.Example3D) 

316 

317 def testAliases(self): 

318 self.register() 

319 self.alias() 

320 self.assertEqual(self.Example2F.d, 2) 

321 self.assertEqual(self.Example2F.u, np.float32) 

322 self.assertEqual(self.Example2D.d, 2) 

323 self.assertEqual(self.Example2D.u, np.float64) 

324 self.assertEqual(self.Example3F.d, 3) 

325 self.assertEqual(self.Example3F.u, np.float32) 

326 self.assertEqual(self.Example3D.d, 3) 

327 self.assertEqual(self.Example3D.u, np.float64) 

328 self.assertIn("2F", self.Example) 

329 self.assertIn("2D", self.Example) 

330 self.assertIn("3F", self.Example) 

331 self.assertIn("3D", self.Example) 

332 self.assertEqual(self.Example["2F"], self.Example2F) 

333 self.assertEqual(self.Example["2D"], self.Example2D) 

334 self.assertEqual(self.Example["3F"], self.Example3F) 

335 self.assertEqual(self.Example["3D"], self.Example3D) 

336 

337 def testInheritanceHooks(self): 

338 self.register() 

339 self.assertTrue(issubclass(self.Example2F, self.Example)) 

340 self.assertTrue(issubclass(self.Example3D, self.Example)) 

341 f = self.Example2F() 

342 d = self.Example3D() 

343 self.assertIsInstance(f, self.Example) 

344 self.assertIsInstance(d, self.Example) 

345 self.assertEqual(set(self.Example.__subclasses__()), 

346 set([self.Example2F, self.Example2D, 

347 self.Example3F, self.Example3D])) 

348 

349 def testConstruction(self): 

350 self.register() 

351 f = self.Example(u=np.float32) 

352 self.assertIsInstance(f, self.Example) 

353 self.assertIsInstance(f, self.Example2F) 

354 with self.assertRaises(TypeError): 

355 self.Example() 

356 with self.assertRaises(TypeError): 

357 self.Example(u=np.int32, d=1) 

358 

359 def testDictBehavior(self): 

360 self.register() 

361 self.assertIn((2, np.float32), self.Example) 

362 self.assertEqual(self.Example[2, np.float32], self.Example2F) 

363 self.assertEqual(set(self.Example.keys()), 

364 set([(2, np.float32), (2, np.float64), 

365 (3, np.float32), (3, np.float64)])) 

366 self.assertEqual(set(self.Example.values()), 

367 set([self.Example2F, self.Example2D, 

368 self.Example3F, self.Example3D])) 

369 self.assertEqual(set(self.Example.items()), 

370 set([((2, np.float32), self.Example2F), 

371 ((2, np.float64), self.Example2D), 

372 ((3, np.float32), self.Example3F), 

373 ((3, np.float64), self.Example3D)])) 

374 self.assertEqual(len(self.Example), 4) 

375 self.assertEqual(set(iter(self.Example)), 

376 set([(2, np.float32), (2, np.float64), 

377 (3, np.float32), (3, np.float64)])) 

378 self.assertEqual(self.Example.get((3, np.float64)), self.Example3D) 

379 self.assertEqual(self.Example.get((2, np.int32), False), False) 

380 

381 def testRegisterBadKey(self): 

382 with self.assertRaises(ValueError): 

383 self.Example.register("F", self.Example2F) 

384 

385 def testRegisterDTypeTwice(self): 

386 with self.assertRaises(KeyError): 

387 self.Example.register((2, "F"), self.Example2F) 

388 self.Example.register((2, "F"), self.Example2D) 

389 self.assertEqual(len(self.Example), 1) 

390 

391 def testRegisterTemplateTwice(self): 

392 with self.assertRaises(ValueError): 

393 self.Example.register((2, "F"), self.Example2F) 

394 self.Example.register((2, "D"), self.Example2F) 

395 self.assertEqual(len(self.Example), 1) 

396 

397 

398class TestDefaultMethodCopying(lsst.utils.tests.TestCase): 

399 """ Test to determine if static and class methods from a class which is 

400 registered as a default type in a type ABC are properly copied. 

401 """ 

402 def setUp(self): 

403 class Example(metaclass=lsst.utils.TemplateMeta): 

404 

405 TEMPLATE_PARAMS = ("dtype",) 

406 TEMPLATE_DEFAULTS = (np.float32,) 

407 

408 class ExampleF: 

409 @staticmethod 

410 def staticCall(): 

411 return 6 

412 

413 @classmethod 

414 def classCall(cls): 

415 return cls 

416 

417 def regularCall(self): 

418 return self 

419 

420 class ExampleI: 

421 @staticmethod 

422 def notTransferedStaticCall(): 

423 return 8 

424 

425 @classmethod 

426 def notTransferedClassCall(cls): 

427 return cls 

428 

429 # Add in a built in function to ExampleF to mimic how pybind11 treats 

430 # static methods from c++ 

431 setattr(ExampleF, 'pow', pow) 

432 

433 Example.register(np.float32, ExampleF) 

434 Example.register(np.int32, ExampleI) 

435 self.Example = Example 

436 self.ExampleF = ExampleF 

437 self.ExampleI = ExampleI 

438 

439 def testMethodCopyForDefaultType(self): 

440 # Check that the methods for the default type were transfered and that 

441 # the regular method was not 

442 self.assertTrue(hasattr(self.Example, 'staticCall')) 

443 self.assertTrue(hasattr(self.Example, 'pow')) 

444 self.assertTrue(hasattr(self.Example, 'classCall')) 

445 self.assertFalse(hasattr(self.Example, 'regularCall')) 

446 

447 # Verify the default static and class method defaults return the 

448 # correct values 

449 self.assertEqual(self.Example.staticCall(), 6) 

450 self.assertEqual(self.Example.pow(2, 2), 4) 

451 self.assertIs(self.Example.classCall(), self.ExampleF) 

452 

453 # Verify static and class methods for non default keys are not 

454 # transfered 

455 self.assertFalse(hasattr(self.Example, "notTransferedStaticCall")) 

456 self.assertFalse(hasattr(self.Example, "notTransferedClassCall")) 

457 

458 

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

460 unittest.main()