Coverage for tests/test_utils.py: 6%

186 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-02-04 02:34 -0800

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 def setUp(self): 

24 self.large = 100.0 

25 self.epsilon = 1e-8 

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

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

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

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

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

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

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

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

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

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

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

37 

38 def test_assertFloatsAlmostEqual(self): 

39 # zero scalar tests 

40 self.assertFloatsAlmostEqual(0.0, 0.0) 

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

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

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

44 

45 # zero array vs. scalar tests 

46 self.assertFloatsAlmostEqual(self.zeros, 0.0) 

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

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

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

50 

51 # zero array vs. array tests 

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

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

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

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

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

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

58 

59 # invalid value tests 

60 with self.assertRaises(ValueError): 

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

62 

63 # non-zero scalar tests 

64 self.assertFloatsAlmostEqual(self.large, 100.0) 

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

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

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

68 

69 # Non-zero array vs. scalar tests 

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

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

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

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

74 

75 # Non-zero array vs. array tests 

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

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

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

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

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

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

82 

83 # Test that it raises appropriately 

84 with self.assertRaises(AssertionError): 

85 self.assertFloatsAlmostEqual(self.large, 0.0) 

86 with self.assertRaises(AssertionError): 

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

88 with self.assertRaises(AssertionError): 

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

90 with self.assertRaises(AssertionError): 

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

92 with self.assertRaises(AssertionError): 

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

94 

95 with self.assertRaises(AssertionError): 

96 self.assertFloatsAlmostEqual(self.larges, 0.0) 

97 with self.assertRaises(AssertionError): 

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

99 with self.assertRaises(AssertionError): 

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

101 with self.assertRaises(AssertionError): 

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

103 with self.assertRaises(AssertionError): 

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

105 

106 with self.assertRaises(AssertionError): 

107 self.assertFloatsAlmostEqual(0.0, self.larges) 

108 with self.assertRaises(AssertionError): 

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

110 with self.assertRaises(AssertionError): 

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

112 with self.assertRaises(AssertionError): 

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

114 with self.assertRaises(AssertionError): 

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

116 

117 with self.assertRaises(AssertionError): 

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

119 with self.assertRaises(AssertionError): 

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

121 with self.assertRaises(AssertionError): 

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

123 with self.assertRaises(AssertionError): 

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

125 with self.assertRaises(AssertionError): 

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

127 with self.assertRaises(AssertionError): 

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

129 

130 if display: 

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

132 # the very center point. 

133 nonzeroCenter = self.zeros.copy() 

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

135 with self.assertRaises(AssertionError): 

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

137 

138 with self.assertRaises(AssertionError) as cm: 

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

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

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

142 

143 def test_assertFloatsNotEqual(self): 

144 # zero scalar tests 

145 self.assertFloatsNotEqual(0.0, 1.0) 

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

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

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

149 

150 # zero array vs. scalar tests 

151 self.assertFloatsNotEqual(self.zeros, 1.0) 

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

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

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

155 

156 # zero array vs. array tests 

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

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

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

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

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

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

163 

164 # invalid value tests 

165 with self.assertRaises(ValueError): 

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

167 

168 # non-zero scalar tests 

169 self.assertFloatsNotEqual(self.large, 1.0) 

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

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

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

173 

174 # Non-zero array vs. scalar tests 

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

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

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

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

179 

180 # Non-zero array vs. array tests 

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

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

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

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

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

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

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

188 

189 with self.assertRaises(AssertionError) as cm: 

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

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

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

193 

194 def test_assertFloatsEqual(self): 

195 self.assertFloatsEqual(0, 0) 

196 self.assertFloatsEqual(0.0, 0.0) 

197 self.assertFloatsEqual(1, 1) 

198 self.assertFloatsEqual(1.0, 1.0) 

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

200 self.assertFloatsEqual(self.zeros, 0) 

201 self.assertFloatsEqual(self.zeros, 0.0) 

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

203 with self.assertRaises(AssertionError): 

204 self.assertFloatsEqual(self.larges, 0.0) 

205 with self.assertRaises(AssertionError): 

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

207 with self.assertRaises(AssertionError): 

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

209 with self.assertRaises(AssertionError): 

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

211 

212 def test_notfinite(self): 

213 with self.assertRaises(AssertionError): 

214 self.assertFloatsAlmostEqual(np.nan, 0.0) 

215 with self.assertRaises(AssertionError): 

216 self.assertFloatsAlmostEqual(0.0, np.inf) 

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

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

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

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

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

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

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

224 with self.assertRaises(AssertionError): 

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

226 with self.assertRaises(AssertionError): 

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

228 with self.assertRaises(AssertionError): 

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

230 with self.assertRaises(AssertionError): 

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

232 with self.assertRaises(AssertionError): 

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

234 with self.assertRaises(AssertionError): 

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

236 

237 

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

239 pass 

240 

241 

242def setup_module(module): 

243 lsst.utils.tests.init() 

244 

245 

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

247 setup_module(sys.modules[__name__]) 

248 unittest.main()