Coverage for tests/test_utils.py: 5%

183 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2023-07-25 09:27 +0000

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 sys 

13import unittest 

14 

15import lsst.utils.tests 

16import numpy as np 

17 

18# set to True to test plotting and printing by-eye when tests fail 

19display = False 

20 

21 

22class UtilsTestCase(lsst.utils.tests.TestCase): 

23 """Test the utils test case.""" 

24 

25 def setUp(self): 

26 self.large = 100.0 

27 self.epsilon = 1e-8 

28 self.zeros = np.zeros((5, 5), dtype=float) 

29 self.zeros2 = np.zeros((5, 5), dtype=float) 

30 self.epsilons = np.zeros((5, 5), dtype=float) + self.epsilon 

31 self.larges = np.zeros((5, 5), dtype=float) + self.large 

32 self.larges2 = np.zeros((5, 5), dtype=float) + self.large 

33 self.largesOneOff = self.larges.copy() 

34 self.largesOneOff[0] += self.epsilon 

35 self.largesEpsilon = np.zeros((5, 5), dtype=float) + self.large + self.epsilon 

36 self.ranges = np.arange(-12.0, 13.0).reshape(5, 5) 

37 self.rangesEpsilon = self.ranges.copy() 

38 self.rangesEpsilon += np.linspace(-1e-4, 1e-4, 5) 

39 

40 def test_assertFloatsAlmostEqual(self): 

41 # zero scalar tests 

42 self.assertFloatsAlmostEqual(0.0, 0.0) 

43 self.assertFloatsAlmostEqual(0.0, 1e-8, atol=1e-7) 

44 self.assertFloatsAlmostEqual(0.0, 1e-8, atol=1e-7, rtol=None) 

45 self.assertFloatsAlmostEqual(0.0, 1e-8, atol=None, rtol=1e-5, relTo=1e-2) 

46 

47 # zero array vs. scalar tests 

48 self.assertFloatsAlmostEqual(self.zeros, 0.0) 

49 self.assertFloatsAlmostEqual(self.zeros, self.epsilon, atol=1e-7) 

50 self.assertFloatsAlmostEqual(self.zeros, self.epsilon, atol=1e-7, rtol=None) 

51 self.assertFloatsAlmostEqual(self.zeros, self.epsilon, atol=None, rtol=1e-5, relTo=1e-2) 

52 

53 # zero array vs. array tests 

54 self.assertFloatsAlmostEqual(self.zeros, self.zeros2) 

55 self.assertFloatsAlmostEqual(self.zeros, self.zeros2, rtol=None) 

56 self.assertFloatsAlmostEqual(self.zeros, self.zeros2, atol=None) 

57 self.assertFloatsAlmostEqual(self.zeros, self.epsilons, atol=1e-7) 

58 self.assertFloatsAlmostEqual(self.zeros, self.epsilons, atol=1e-7, rtol=None) 

59 self.assertFloatsAlmostEqual(self.zeros, self.epsilons, atol=None, rtol=1e-5, relTo=1e-2) 

60 

61 # invalid value tests 

62 with self.assertRaises(ValueError): 

63 self.assertFloatsAlmostEqual(self.zeros, self.zeros2, atol=None, rtol=None) 

64 

65 # non-zero scalar tests 

66 self.assertFloatsAlmostEqual(self.large, 100.0) 

67 self.assertFloatsAlmostEqual(self.large, self.large + self.epsilon, rtol=1e-7) 

68 self.assertFloatsAlmostEqual(self.large, self.large + self.epsilon, rtol=1e-7, atol=None) 

69 self.assertFloatsAlmostEqual(self.large, self.large + self.epsilon, rtol=1e-7, relTo=100.0) 

70 

71 # Non-zero array vs. scalar tests 

72 self.assertFloatsAlmostEqual(self.larges, self.large) 

73 self.assertFloatsAlmostEqual(self.larges, self.large + self.epsilon, rtol=1e-7) 

74 self.assertFloatsAlmostEqual(self.larges, self.large + self.epsilon, rtol=1e-7, atol=None) 

75 self.assertFloatsAlmostEqual(self.larges, self.large + self.epsilon, rtol=1e-7, relTo=100.0) 

76 

77 # Non-zero array vs. array tests 

78 self.assertFloatsAlmostEqual(self.larges, self.larges2) 

79 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1e-7) 

80 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1e-7, atol=None) 

81 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1e-7, relTo=100.0) 

82 self.assertFloatsAlmostEqual(self.larges, self.largesOneOff, atol=1e-7) 

83 self.assertFloatsAlmostEqual(self.ranges, self.rangesEpsilon, rtol=1e-3, atol=1e-4) 

84 

85 # Test that it raises appropriately 

86 with self.assertRaises(AssertionError): 

87 self.assertFloatsAlmostEqual(self.large, 0.0) 

88 with self.assertRaises(AssertionError): 

89 self.assertFloatsAlmostEqual(self.large, 0.0, rtol=1e-2) 

90 with self.assertRaises(AssertionError): 

91 self.assertFloatsAlmostEqual(self.large, 0.0, rtol=1e-2, atol=None) 

92 with self.assertRaises(AssertionError): 

93 self.assertFloatsAlmostEqual(self.large, 0.0, atol=1e-2) 

94 with self.assertRaises(AssertionError): 

95 self.assertFloatsAlmostEqual(self.large, 0.0, atol=1e-2, rtol=None) 

96 

97 with self.assertRaises(AssertionError): 

98 self.assertFloatsAlmostEqual(self.larges, 0.0) 

99 with self.assertRaises(AssertionError): 

100 self.assertFloatsAlmostEqual(self.larges, 0.0, rtol=1e-2) 

101 with self.assertRaises(AssertionError): 

102 self.assertFloatsAlmostEqual(self.larges, 0.0, rtol=1e-2, atol=None) 

103 with self.assertRaises(AssertionError): 

104 self.assertFloatsAlmostEqual(self.larges, 0.0, atol=1e-2) 

105 with self.assertRaises(AssertionError): 

106 self.assertFloatsAlmostEqual(self.larges, 0.0, atol=1e-2, rtol=None) 

107 

108 with self.assertRaises(AssertionError): 

109 self.assertFloatsAlmostEqual(0.0, self.larges) 

110 with self.assertRaises(AssertionError): 

111 self.assertFloatsAlmostEqual(0.0, self.larges, rtol=1e-2) 

112 with self.assertRaises(AssertionError): 

113 self.assertFloatsAlmostEqual(0.0, self.larges, rtol=1e-2, atol=None) 

114 with self.assertRaises(AssertionError): 

115 self.assertFloatsAlmostEqual(0.0, self.larges, atol=1e-2) 

116 with self.assertRaises(AssertionError): 

117 self.assertFloatsAlmostEqual(0.0, self.larges, atol=1e-2, rtol=None) 

118 

119 with self.assertRaises(AssertionError): 

120 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1e-16) 

121 with self.assertRaises(AssertionError): 

122 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1e-16, atol=None) 

123 with self.assertRaises(AssertionError): 

124 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1e-16, relTo=100.0) 

125 with self.assertRaises(AssertionError): 

126 self.assertFloatsAlmostEqual(self.larges, self.largesOneOff, atol=1e-16) 

127 with self.assertRaises(AssertionError): 

128 self.assertFloatsAlmostEqual(self.larges, self.largesOneOff, atol=1e-16, rtol=None) 

129 with self.assertRaises(AssertionError): 

130 self.assertFloatsAlmostEqual(self.ranges, self.rangesEpsilon, rtol=1e-15, atol=1e-4) 

131 

132 if display: 

133 # should see failures on the center row of the 5x5 image, but not 

134 # the very center point. 

135 nonzeroCenter = self.zeros.copy() 

136 nonzeroCenter[2, :] = 1e-5 

137 with self.assertRaises(AssertionError): 

138 self.assertFloatsAlmostEqual(self.zeros, nonzeroCenter, rtol=1e-6, plotOnFailure=True) 

139 

140 with self.assertRaises(AssertionError) as cm: 

141 self.assertFloatsAlmostEqual(10, 0, msg="This is an error message.") 

142 self.assertIn("This is an error message.", str(cm.exception)) 

143 self.assertIn("10 != 0; diff=10/10=1.0 with rtol=", str(cm.exception)) 

144 

145 def test_assertFloatsNotEqual(self): 

146 # zero scalar tests 

147 self.assertFloatsNotEqual(0.0, 1.0) 

148 self.assertFloatsNotEqual(0.0, 1e-8, atol=1e-9) 

149 self.assertFloatsNotEqual(0.0, 1e-8, atol=1e-9, rtol=None) 

150 self.assertFloatsNotEqual(0.0, 1e-8, atol=None, rtol=1e-7, relTo=1e-2) 

151 

152 # zero array vs. scalar tests 

153 self.assertFloatsNotEqual(self.zeros, 1.0) 

154 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=1e-9) 

155 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=1e-9, rtol=None) 

156 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=None, rtol=1e-7, relTo=1e-2) 

157 

158 # zero array vs. array tests 

159 self.assertFloatsNotEqual(self.zeros, self.larges) 

160 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=1e-9, rtol=None) 

161 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=None, rtol=1e-5, relTo=1e-5) 

162 self.assertFloatsNotEqual(self.zeros, self.epsilons, atol=1e-9) 

163 self.assertFloatsNotEqual(self.zeros, self.epsilons, atol=1e-9, rtol=None) 

164 self.assertFloatsNotEqual(self.zeros, self.epsilons, atol=None, rtol=1e-7, relTo=1e-2) 

165 

166 # invalid value tests 

167 with self.assertRaises(ValueError): 

168 self.assertFloatsNotEqual(self.zeros, self.zeros2, atol=None, rtol=None) 

169 

170 # non-zero scalar tests 

171 self.assertFloatsNotEqual(self.large, 1.0) 

172 self.assertFloatsNotEqual(self.large, self.large + self.epsilon, atol=1e-9) 

173 self.assertFloatsNotEqual(self.large, self.large + self.epsilon, rtol=1e-11, atol=None) 

174 self.assertFloatsNotEqual(self.large, self.large + self.epsilon, rtol=1e-12, relTo=1.0) 

175 

176 # Non-zero array vs. scalar tests 

177 self.assertFloatsNotEqual(self.larges, self.large + self.epsilon, atol=1e-9) 

178 self.assertFloatsNotEqual(self.larges, self.large + self.epsilon, atol=1e-9, rtol=None) 

179 self.assertFloatsNotEqual(self.larges, self.large + self.epsilon, rtol=1e-11, atol=None) 

180 self.assertFloatsNotEqual(self.larges, self.large + self.epsilon, rtol=1e-12, relTo=1.0) 

181 

182 # Non-zero array vs. array tests 

183 self.assertFloatsNotEqual(self.larges, self.zeros) 

184 self.assertFloatsNotEqual(self.larges, self.largesEpsilon, rtol=1e-12) 

185 self.assertFloatsNotEqual(self.larges, self.largesEpsilon, rtol=1e-12, atol=None) 

186 self.assertFloatsNotEqual(self.larges, self.largesEpsilon, rtol=1e-11, relTo=100.0) 

187 self.assertFloatsNotEqual(self.larges, self.largesOneOff, atol=1e-9) 

188 self.assertFloatsNotEqual(self.larges, self.largesOneOff, atol=1e-9, rtol=None) 

189 self.assertFloatsNotEqual(self.ranges, self.rangesEpsilon) 

190 

191 with self.assertRaises(AssertionError) as cm: 

192 self.assertFloatsNotEqual(10, 10, msg="This is an error message.") 

193 self.assertIn("This is an error message.", str(cm.exception)) 

194 self.assertIn("10 == 10; diff=0/10=0.0 with rtol=", str(cm.exception)) 

195 

196 def test_assertFloatsEqual(self): 

197 self.assertFloatsEqual(0, 0) 

198 self.assertFloatsEqual(0.0, 0.0) 

199 self.assertFloatsEqual(1, 1) 

200 self.assertFloatsEqual(1.0, 1.0) 

201 self.assertFloatsEqual(self.zeros, self.zeros2) 

202 self.assertFloatsEqual(self.zeros, 0) 

203 self.assertFloatsEqual(self.zeros, 0.0) 

204 self.assertFloatsEqual(self.larges, self.large) 

205 with self.assertRaises(AssertionError): 

206 self.assertFloatsEqual(self.larges, 0.0) 

207 with self.assertRaises(AssertionError): 

208 self.assertFloatsEqual(self.larges, self.largesEpsilon) 

209 with self.assertRaises(AssertionError): 

210 self.assertFloatsEqual(self.larges, self.zeros) 

211 with self.assertRaises(AssertionError): 

212 self.assertFloatsEqual(self.larges, self.largesEpsilon) 

213 

214 def test_notfinite(self): 

215 with self.assertRaises(AssertionError): 

216 self.assertFloatsAlmostEqual(np.nan, 0.0) 

217 with self.assertRaises(AssertionError): 

218 self.assertFloatsAlmostEqual(0.0, np.inf) 

219 self.assertFloatsEqual(np.nan, np.nan, ignoreNaNs=True) 

220 self.assertFloatsEqual(np.nan, np.array([np.nan, np.nan]), ignoreNaNs=True) 

221 self.assertFloatsEqual(np.array([np.nan, np.nan]), np.nan, ignoreNaNs=True) 

222 self.assertFloatsEqual(np.array([np.nan, np.nan]), np.array([np.nan, np.nan]), ignoreNaNs=True) 

223 self.assertFloatsEqual(np.array([np.nan, 0.5]), np.array([np.nan, 0.5]), ignoreNaNs=True) 

224 self.assertFloatsEqual(0.5, np.array([0.5, 0.5]), ignoreNaNs=True) 

225 self.assertFloatsEqual(np.array([0.5, 0.5]), 0.5, ignoreNaNs=True) 

226 with self.assertRaises(AssertionError): 

227 self.assertFloatsEqual(np.array([np.nan, 0.5]), np.array([0.5, np.nan]), ignoreNaNs=True) 

228 with self.assertRaises(AssertionError): 

229 self.assertFloatsEqual(0.5, np.array([0.5, np.nan]), ignoreNaNs=True) 

230 with self.assertRaises(AssertionError): 

231 self.assertFloatsEqual(np.nan, np.array([0.5, np.nan]), ignoreNaNs=True) 

232 with self.assertRaises(AssertionError): 

233 self.assertFloatsEqual(np.array([0.5, np.nan]), 0.5, ignoreNaNs=True) 

234 with self.assertRaises(AssertionError): 

235 self.assertFloatsEqual(np.array([0.5, np.nan]), np.nan, ignoreNaNs=True) 

236 with self.assertRaises(AssertionError): 

237 self.assertFloatsEqual(np.array([np.nan, 1.0]), np.array([np.nan, 0.5]), ignoreNaNs=True) 

238 

239 

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

241 """Test for file descriptor leaks. 

242 

243 Verify that setting ignore_regexps doesn't cause anything to fail. 

244 """ 

245 

246 ignore_regexps = [r"\.extension$"] 

247 

248 

249def setup_module(module): 

250 """Initialize the pytest environment.""" 

251 lsst.utils.tests.init() 

252 

253 

254if __name__ == "__main__": 

255 setup_module(sys.modules[__name__]) 

256 unittest.main()