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# Developed for the LSST Data Management System. 

3# This product includes software developed by the LSST Project 

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

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

6# for details of code ownership. 

7# 

8# This program is free software: you can redistribute it and/or modify 

9# it under the terms of the GNU General Public License as published by 

10# the Free Software Foundation, either version 3 of the License, or 

11# (at your option) any later version. 

12# 

13# This program is distributed in the hope that it will be useful, 

14# but WITHOUT ANY WARRANTY; without even the implied warranty of 

15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

16# GNU General Public License for more details. 

17# 

18# You should have received a copy of the GNU General Public License 

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

20# 

21 

22import sys 

23import unittest 

24import numpy as np 

25 

26import lsst.utils.tests 

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

34 self.large = 100. 

35 self.epsilon = 1e-8 

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

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

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

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

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

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

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

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

44 self.ranges = np.arange(-12., 13.).reshape(5, 5) 

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

46 self.rangesEpsilon += np.linspace(-1E-4, 1E-4, 5) 

47 

48 def test_assertFloatsAlmostEqual(self): 

49 # zero scalar tests 

50 self.assertFloatsAlmostEqual(0.0, 0.0) 

51 self.assertFloatsAlmostEqual(0.0, 1E-8, atol=1E-7) 

52 self.assertFloatsAlmostEqual(0.0, 1E-8, atol=1E-7, rtol=None) 

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

54 

55 # zero array vs. scalar tests 

56 self.assertFloatsAlmostEqual(self.zeros, 0.) 

57 self.assertFloatsAlmostEqual(self.zeros, self.epsilon, atol=1E-7) 

58 self.assertFloatsAlmostEqual(self.zeros, self.epsilon, atol=1E-7, rtol=None) 

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

60 

61 # zero array vs. array tests 

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

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

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

65 self.assertFloatsAlmostEqual(self.zeros, self.epsilons, atol=1E-7) 

66 self.assertFloatsAlmostEqual(self.zeros, self.epsilons, atol=1E-7, rtol=None) 

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

68 

69 # invalid value tests 

70 with self.assertRaises(ValueError): 

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

72 

73 # non-zero scalar tests 

74 self.assertFloatsAlmostEqual(self.large, 100.) 

75 self.assertFloatsAlmostEqual(self.large, self.large + self.epsilon, rtol=1E-7) 

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

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

78 

79 # Non-zero array vs. scalar tests 

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

81 self.assertFloatsAlmostEqual(self.larges, self.large + self.epsilon, rtol=1E-7) 

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

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

84 

85 # Non-zero array vs. array tests 

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

87 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1E-7) 

88 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1E-7, atol=None) 

89 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1E-7, relTo=100.0) 

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

91 self.assertFloatsAlmostEqual(self.ranges, self.rangesEpsilon, rtol=1E-3, atol=1E-4) 

92 

93 # Test that it raises appropriately 

94 with self.assertRaises(AssertionError): 

95 self.assertFloatsAlmostEqual(self.large, 0.) 

96 with self.assertRaises(AssertionError): 

97 self.assertFloatsAlmostEqual(self.large, 0., rtol=1E-2) 

98 with self.assertRaises(AssertionError): 

99 self.assertFloatsAlmostEqual(self.large, 0., rtol=1E-2, atol=None) 

100 with self.assertRaises(AssertionError): 

101 self.assertFloatsAlmostEqual(self.large, 0., atol=1e-2) 

102 with self.assertRaises(AssertionError): 

103 self.assertFloatsAlmostEqual(self.large, 0., atol=1e-2, rtol=None) 

104 

105 with self.assertRaises(AssertionError): 

106 self.assertFloatsAlmostEqual(self.larges, 0.) 

107 with self.assertRaises(AssertionError): 

108 self.assertFloatsAlmostEqual(self.larges, 0., rtol=1E-2) 

109 with self.assertRaises(AssertionError): 

110 self.assertFloatsAlmostEqual(self.larges, 0., rtol=1E-2, atol=None) 

111 with self.assertRaises(AssertionError): 

112 self.assertFloatsAlmostEqual(self.larges, 0., atol=1e-2) 

113 with self.assertRaises(AssertionError): 

114 self.assertFloatsAlmostEqual(self.larges, 0., atol=1e-2, rtol=None) 

115 

116 with self.assertRaises(AssertionError): 

117 self.assertFloatsAlmostEqual(0., self.larges) 

118 with self.assertRaises(AssertionError): 

119 self.assertFloatsAlmostEqual(0., self.larges, rtol=1E-2) 

120 with self.assertRaises(AssertionError): 

121 self.assertFloatsAlmostEqual(0., self.larges, rtol=1E-2, atol=None) 

122 with self.assertRaises(AssertionError): 

123 self.assertFloatsAlmostEqual(0., self.larges, atol=1e-2) 

124 with self.assertRaises(AssertionError): 

125 self.assertFloatsAlmostEqual(0., self.larges, atol=1e-2, rtol=None) 

126 

127 with self.assertRaises(AssertionError): 

128 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1E-16) 

129 with self.assertRaises(AssertionError): 

130 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1E-16, atol=None) 

131 with self.assertRaises(AssertionError): 

132 self.assertFloatsAlmostEqual(self.larges, self.largesEpsilon, rtol=1E-16, relTo=100.0) 

133 with self.assertRaises(AssertionError): 

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

135 with self.assertRaises(AssertionError): 

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

137 with self.assertRaises(AssertionError): 

138 self.assertFloatsAlmostEqual(self.ranges, self.rangesEpsilon, rtol=1E-15, atol=1E-4) 

139 

140 if display: 

141 # should see failures on the center row of the 5x5 image, but not the very center point 

142 nonzeroCenter = self.zeros.copy() 

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

144 with self.assertRaises(AssertionError): 

145 self.assertFloatsAlmostEqual(self.zeros, nonzeroCenter, rtol=1E-6, plotOnFailure=True) 

146 

147 with self.assertRaises(AssertionError) as cm: 

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

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

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

151 

152 def test_assertFloatsNotEqual(self): 

153 # zero scalar tests 

154 self.assertFloatsNotEqual(0.0, 1.0) 

155 self.assertFloatsNotEqual(0.0, 1E-8, atol=1E-9) 

156 self.assertFloatsNotEqual(0.0, 1E-8, atol=1E-9, rtol=None) 

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

158 

159 # zero array vs. scalar tests 

160 self.assertFloatsNotEqual(self.zeros, 1.) 

161 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=1E-9) 

162 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=1E-9, rtol=None) 

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

164 

165 # zero array vs. array tests 

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

167 self.assertFloatsNotEqual(self.zeros, self.epsilon, atol=1E-9, rtol=None) 

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

169 self.assertFloatsNotEqual(self.zeros, self.epsilons, atol=1E-9) 

170 self.assertFloatsNotEqual(self.zeros, self.epsilons, atol=1E-9, rtol=None) 

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

172 

173 # invalid value tests 

174 with self.assertRaises(ValueError): 

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

176 

177 # non-zero scalar tests 

178 self.assertFloatsNotEqual(self.large, 1.) 

179 self.assertFloatsNotEqual(self.large, self.large + self.epsilon, atol=1E-9) 

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

181 self.assertFloatsNotEqual(self.large, self.large + self.epsilon, rtol=1E-12, relTo=1.) 

182 

183 # Non-zero array vs. scalar tests 

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

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

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

187 self.assertFloatsNotEqual(self.larges, self.large + self.epsilon, rtol=1E-12, relTo=1.) 

188 

189 # Non-zero array vs. array tests 

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

191 self.assertFloatsNotEqual(self.larges, self.largesEpsilon, rtol=1E-12) 

192 self.assertFloatsNotEqual(self.larges, self.largesEpsilon, rtol=1E-12, atol=None) 

193 self.assertFloatsNotEqual(self.larges, self.largesEpsilon, rtol=1E-11, relTo=100.0) 

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

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

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

197 

198 with self.assertRaises(AssertionError) as cm: 

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

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

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

202 

203 def test_assertFloatsEqual(self): 

204 self.assertFloatsEqual(0, 0) 

205 self.assertFloatsEqual(0., 0.) 

206 self.assertFloatsEqual(1, 1) 

207 self.assertFloatsEqual(1., 1.) 

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

209 self.assertFloatsEqual(self.zeros, 0) 

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

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

212 with self.assertRaises(AssertionError): 

213 self.assertFloatsEqual(self.larges, 0.) 

214 with self.assertRaises(AssertionError): 

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

216 with self.assertRaises(AssertionError): 

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

218 with self.assertRaises(AssertionError): 

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

220 

221 def test_notfinite(self): 

222 with self.assertRaises(AssertionError): 

223 self.assertFloatsAlmostEqual(np.nan, 0.0) 

224 with self.assertRaises(AssertionError): 

225 self.assertFloatsAlmostEqual(0.0, np.inf) 

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

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

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

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

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

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

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

233 with self.assertRaises(AssertionError): 

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

235 with self.assertRaises(AssertionError): 

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

237 with self.assertRaises(AssertionError): 

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

239 with self.assertRaises(AssertionError): 

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

241 with self.assertRaises(AssertionError): 

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

243 with self.assertRaises(AssertionError): 

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

245 

246 

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

248 pass 

249 

250 

251def setup_module(module): 

252 lsst.utils.tests.init() 

253 

254 

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

256 setup_module(sys.modules[__name__]) 

257 unittest.main()