Coverage for tests/test_tableAliases.py: 19%

101 statements  

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

1# This file is part of afw. 

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 

22""" 

23Tests for aliases in table.schema 

24 

25Run with: 

26 python test_tableAliases.py 

27or 

28 pytest test_tableAliases.py 

29""" 

30import unittest 

31 

32import numpy as np 

33 

34import lsst.utils.tests 

35import lsst.pex.exceptions 

36import lsst.afw.table 

37import lsst.afw.geom 

38 

39 

40class TableAliasTestCase(lsst.utils.tests.TestCase): 

41 

42 def setUp(self): 

43 self.schema = lsst.afw.table.Schema() 

44 self.a11 = self.schema.addField("a11", type=np.int32, doc="") 

45 self.a12 = self.schema.addField("a12", type=np.int32, doc="") 

46 self.ab11 = self.schema.addField("ab11", type=np.int32, doc="") 

47 self.ab12 = self.schema.addField("ab12", type=np.int32, doc="") 

48 self.dict = dict(q="a", r="a1", s="ab", t="ab11") 

49 for k, v in self.dict.items(): 

50 self.schema.getAliasMap().set(k, v) 

51 

52 def tearDown(self): 

53 del self.schema 

54 del self.a11 

55 del self.a12 

56 del self.ab11 

57 del self.ab12 

58 del self.dict 

59 

60 def testApply(self): 

61 self.assertEqual(self.schema.getAliasMap().apply("q11"), "a11") 

62 self.assertEqual(self.schema.getAliasMap().apply("q12"), "a12") 

63 self.assertEqual(self.schema.getAliasMap().apply("qb11"), "ab11") 

64 self.assertEqual(self.schema.getAliasMap().apply("qb12"), "ab12") 

65 self.assertEqual(self.schema.getAliasMap().apply("r1"), "a11") 

66 self.assertEqual(self.schema.getAliasMap().apply("r2"), "a12") 

67 self.assertEqual(self.schema.getAliasMap().apply("s11"), "ab11") 

68 self.assertEqual(self.schema.getAliasMap().apply("s12"), "ab12") 

69 self.assertEqual(self.schema.getAliasMap().apply("t"), "ab11") 

70 

71 def testAccessors(self): 

72 aliases = self.schema.getAliasMap() 

73 

74 # Check that iteration works 

75 self.assertEqual(dict(aliases), self.dict) 

76 for n, (k, v) in enumerate(aliases.items()): 

77 self.assertEqual(aliases.get(k), v) 

78 self.assertEqual(aliases[k], v) 

79 self.assertEqual(n + 1, len(aliases)) 

80 self.assertEqual(list(aliases.keys()), [k for k, v in aliases.items()]) 

81 self.assertEqual(list(aliases.values()), [ 

82 v for k, v in aliases.items()]) 

83 

84 # Try removing something using the C++-named methods 

85 self.assertTrue(aliases.erase("q")) 

86 del self.dict["q"] 

87 self.assertEqual(dict(aliases), self.dict) 

88 

89 # Try removing something using the Python operators 

90 del aliases["r"] 

91 del self.dict["r"] 

92 self.assertEqual(dict(aliases), self.dict) 

93 

94 # Try getting/setting something using the Python operators 

95 aliases["p"] = "ab12" 

96 self.assertEqual(aliases["p"], "ab12") 

97 

98 # Test empty and bool conversion 

99 self.assertFalse(aliases.empty()) 

100 self.assertTrue(aliases) 

101 aliases = lsst.afw.table.AliasMap() 

102 self.assertTrue(aliases.empty()) 

103 self.assertFalse(aliases) 

104 

105 def testFind(self): 

106 self.assertEqual(self.schema.find("q11").key, self.a11) 

107 self.assertEqual(self.schema.find("q12").key, self.a12) 

108 self.assertEqual(self.schema.find("qb11").key, self.ab11) 

109 self.assertEqual(self.schema.find("qb12").key, self.ab12) 

110 self.assertEqual(self.schema.find("r1").key, self.a11) 

111 self.assertEqual(self.schema.find("r2").key, self.a12) 

112 self.assertEqual(self.schema.find("s11").key, self.ab11) 

113 self.assertEqual(self.schema.find("s12").key, self.ab12) 

114 self.assertEqual(self.schema.find("t").key, self.ab11) 

115 

116 def testRecursiveAliases(self): 

117 """Test that multi-level alias replacement works. 

118 """ 

119 self.schema.setAliasMap(None) # remove all current aliases 

120 # applying the following aliases recursively should let us use 'u1' to 

121 # get to the 'a11' field 

122 self.schema.getAliasMap().set("t2", "a1") 

123 self.schema.getAliasMap().set("u", "t2") 

124 self.assertEqual(self.schema.find("u1").key, self.a11) 

125 

126 def testCycle(self): 

127 """Test that multi-level aliases that form a cycle produce an exception, not an infinite loop. 

128 """ 

129 self.schema.setAliasMap(None) # remove all current aliases 

130 self.schema.getAliasMap().set("t", "a") 

131 self.schema.getAliasMap().set("a", "t") 

132 with self.assertRaises(lsst.pex.exceptions.RuntimeError): 

133 self.schema.find("t") 

134 

135 def testReplace(self): 

136 aliases = self.schema.getAliasMap() 

137 self.assertEqual(aliases.get("q"), "a") 

138 aliases.set("q", "a1") 

139 self.assertEqual(aliases.get("q"), "a1") 

140 

141 def testSchemaComparison(self): 

142 self.assertEqual( 

143 self.schema.compare(self.schema, self.schema.EQUAL_ALIASES), 

144 self.schema.EQUAL_ALIASES) 

145 self.assertEqual( 

146 self.schema.compare(self.schema, self.schema.IDENTICAL), 

147 self.schema.IDENTICAL) 

148 copy = lsst.afw.table.Schema(self.schema) 

149 copy.disconnectAliases() 

150 self.assertEqual(self.schema.getAliasMap(), copy.getAliasMap()) 

151 copy.getAliasMap().erase("q") 

152 self.assertNotEqual(self.schema.getAliasMap(), copy.getAliasMap()) 

153 self.assertEqual( 

154 self.schema.compare(copy, self.schema.EQUAL_ALIASES), 

155 0) 

156 self.assertEqual( 

157 self.schema.compare(copy, self.schema.IDENTICAL), 

158 self.schema.EQUAL_FIELDS) 

159 self.assertEqual( 

160 self.schema.contains(copy, self.schema.EQUAL_ALIASES), 

161 self.schema.EQUAL_ALIASES) 

162 self.assertEqual( 

163 self.schema.contains(copy, self.schema.IDENTICAL), 

164 self.schema.IDENTICAL) 

165 

166 

167class MemoryTester(lsst.utils.tests.MemoryTestCase): 

168 pass 

169 

170 

171def setup_module(module): 

172 lsst.utils.tests.init() 

173 

174 

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

176 lsst.utils.tests.init() 

177 unittest.main()