Coverage for tests/test_utils.py: 5%

183 statements  

« prev     ^ index     » next       coverage.py v7.4.3, created at 2024-03-01 11:57 +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# 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 GNU General Public License 

20# along with this program. If not, see <https://www.gnu.org/licenses/>. 

21 

22import sys 

23import unittest 

24 

25import lsst.utils.tests 

26import numpy as np 

27 

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

29display = False 

30 

31 

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

33 """Test the utils test case.""" 

34 

35 def setUp(self): 

36 self.large = 100.0 

37 self.epsilon = 1e-8 

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

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

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

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

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

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

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

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

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

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

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

49 

50 def test_assertFloatsAlmostEqual(self): 

51 # zero scalar tests 

52 self.assertFloatsAlmostEqual(0.0, 0.0) 

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

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

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

56 

57 # zero array vs. scalar tests 

58 self.assertFloatsAlmostEqual(self.zeros, 0.0) 

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

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

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

62 

63 # zero array vs. array tests 

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

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

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

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

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

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

70 

71 # invalid value tests 

72 with self.assertRaises(ValueError): 

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

74 

75 # non-zero scalar tests 

76 self.assertFloatsAlmostEqual(self.large, 100.0) 

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

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

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

80 

81 # Non-zero array vs. scalar tests 

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

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

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

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

86 

87 # Non-zero array vs. array tests 

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

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

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

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

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

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

94 

95 # Test that it raises appropriately 

96 with self.assertRaises(AssertionError): 

97 self.assertFloatsAlmostEqual(self.large, 0.0) 

98 with self.assertRaises(AssertionError): 

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

100 with self.assertRaises(AssertionError): 

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

102 with self.assertRaises(AssertionError): 

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

104 with self.assertRaises(AssertionError): 

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

106 

107 with self.assertRaises(AssertionError): 

108 self.assertFloatsAlmostEqual(self.larges, 0.0) 

109 with self.assertRaises(AssertionError): 

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

111 with self.assertRaises(AssertionError): 

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

113 with self.assertRaises(AssertionError): 

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

115 with self.assertRaises(AssertionError): 

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

117 

118 with self.assertRaises(AssertionError): 

119 self.assertFloatsAlmostEqual(0.0, self.larges) 

120 with self.assertRaises(AssertionError): 

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

122 with self.assertRaises(AssertionError): 

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

124 with self.assertRaises(AssertionError): 

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

126 with self.assertRaises(AssertionError): 

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

128 

129 with self.assertRaises(AssertionError): 

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

131 with self.assertRaises(AssertionError): 

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

133 with self.assertRaises(AssertionError): 

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

135 with self.assertRaises(AssertionError): 

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

137 with self.assertRaises(AssertionError): 

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

139 with self.assertRaises(AssertionError): 

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

141 

142 if display: 

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

144 # the very center point. 

145 nonzeroCenter = self.zeros.copy() 

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

147 with self.assertRaises(AssertionError): 

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

149 

150 with self.assertRaises(AssertionError) as cm: 

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

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

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

154 

155 def test_assertFloatsNotEqual(self): 

156 # zero scalar tests 

157 self.assertFloatsNotEqual(0.0, 1.0) 

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

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

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

161 

162 # zero array vs. scalar tests 

163 self.assertFloatsNotEqual(self.zeros, 1.0) 

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

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

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

167 

168 # zero array vs. array tests 

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

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

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

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

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

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

175 

176 # invalid value tests 

177 with self.assertRaises(ValueError): 

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

179 

180 # non-zero scalar tests 

181 self.assertFloatsNotEqual(self.large, 1.0) 

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

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

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

185 

186 # Non-zero array vs. scalar tests 

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

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

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

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

191 

192 # Non-zero array vs. array tests 

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

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

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

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

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

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

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

200 

201 with self.assertRaises(AssertionError) as cm: 

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

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

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

205 

206 def test_assertFloatsEqual(self): 

207 self.assertFloatsEqual(0, 0) 

208 self.assertFloatsEqual(0.0, 0.0) 

209 self.assertFloatsEqual(1, 1) 

210 self.assertFloatsEqual(1.0, 1.0) 

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

212 self.assertFloatsEqual(self.zeros, 0) 

213 self.assertFloatsEqual(self.zeros, 0.0) 

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

215 with self.assertRaises(AssertionError): 

216 self.assertFloatsEqual(self.larges, 0.0) 

217 with self.assertRaises(AssertionError): 

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

219 with self.assertRaises(AssertionError): 

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

221 with self.assertRaises(AssertionError): 

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

223 

224 def test_notfinite(self): 

225 with self.assertRaises(AssertionError): 

226 self.assertFloatsAlmostEqual(np.nan, 0.0) 

227 with self.assertRaises(AssertionError): 

228 self.assertFloatsAlmostEqual(0.0, np.inf) 

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

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

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

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

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

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

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

236 with self.assertRaises(AssertionError): 

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

238 with self.assertRaises(AssertionError): 

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

240 with self.assertRaises(AssertionError): 

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

242 with self.assertRaises(AssertionError): 

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

244 with self.assertRaises(AssertionError): 

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

246 with self.assertRaises(AssertionError): 

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

248 

249 

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

251 """Test for file descriptor leaks. 

252 

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

254 """ 

255 

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

257 

258 

259def setup_module(module): 

260 """Initialize the pytest environment.""" 

261 lsst.utils.tests.init() 

262 

263 

264if __name__ == "__main__": 

265 setup_module(sys.modules[__name__]) 

266 unittest.main()