Coverage for tests/test_int.py: 100%

121 statements  

« prev     ^ index     » next       coverage.py v7.4.1, created at 2024-02-29 10:26 +0100

1""" 

2test for Int() 

3""" 

4import unittest 

5 

6from stricto import Int, Error 

7 

8 

9def pair_only(value, o): # pylint: disable=unused-argument 

10 """ 

11 return the value if par, or value +1  

12 """ 

13 return value + 1 if value % 2 else value 

14 

15 

16def check_pair(value, o): # pylint: disable=unused-argument 

17 """ 

18 return true if pair 

19 """ 

20 return not value % 2 

21 

22 

23class TestInt(unittest.TestCase): # pylint: disable=too-many-public-methods 

24 """ 

25 Test on Int 

26 """ 

27 def __init__(self, m): 

28 unittest.TestCase.__init__(self, m) 

29 self.on_change_bool = False 

30 

31 def test_error_type(self): 

32 """ 

33 Test error of type 

34 """ 

35 a = Int() 

36 with self.assertRaises(Error) as e: 

37 a.set(12.3) 

38 self.assertEqual(e.exception.message, "Must be a int") 

39 

40 def test_default(self): 

41 """ 

42 Test default value 

43 """ 

44 a = Int() 

45 self.assertEqual(a, None) 

46 a = Int(default=3) 

47 b = a + 2 

48 self.assertEqual(a, 3) 

49 self.assertEqual(b, 5) 

50 

51 def test_min(self): 

52 """ 

53 Test min 

54 """ 

55 a = Int(min=10) 

56 with self.assertRaises(Error) as e: 

57 a.set(9) 

58 self.assertEqual(e.exception.message, "Must be above Minimal") 

59 

60 def test_max(self): 

61 """ 

62 Test max 

63 """ 

64 a = Int(max=10) 

65 with self.assertRaises(Error) as e: 

66 a.set(11) 

67 self.assertEqual(e.exception.message, "Must be below Maximal") 

68 

69 def test_copy(self): 

70 """ 

71 Test ref and copy() 

72 """ 

73 a = Int(max=10) 

74 a.set(9) 

75 b = a.copy() 

76 self.assertEqual(b, 9) 

77 with self.assertRaises(Error) as e: 

78 b.set(a + 3) 

79 self.assertEqual(e.exception.message, "Must be below Maximal") 

80 

81 def test_comparison(self): 

82 """ 

83 test comparison operators 

84 """ 

85 a = Int(max=10) 

86 a.set(9) 

87 b = Int() 

88 b.set(9) 

89 self.assertEqual(b, a) 

90 b.set(11) 

91 self.assertNotEqual(b, a) 

92 self.assertGreater(b, a) 

93 self.assertLess(a, b) 

94 self.assertGreaterEqual(b, a) 

95 self.assertLessEqual(a, b) 

96 

97 def test_object_affectation(self): 

98 """ 

99 Test __add__ 

100 """ 

101 a = Int(max=10) 

102 a.set(9) 

103 b = Int() 

104 b.set(9) 

105 with self.assertRaises(Error) as e: 

106 c = a + b 

107 self.assertEqual(e.exception.message, "Must be below Maximal") 

108 c = b + a 

109 self.assertEqual(type(c), Int) 

110 self.assertEqual(c, 18) 

111 

112 def test_int_operator(self): 

113 """ 

114 Test __operators__ 

115 """ 

116 a = Int( default=5) 

117 for b in [ Int(default=2), 2 ]: 

118 self.assertEqual(a+b, 7) 

119 self.assertEqual(a-b, 3) 

120 self.assertEqual(a*b, 10) 

121 self.assertEqual(a**b, 25) 

122 self.assertEqual(a//b, 2) 

123 with self.assertRaises(Error) as e: 

124 self.assertEqual(a/b, 2) 

125 self.assertEqual(e.exception.message, "Must be a int") 

126 self.assertEqual(a%b, 1) 

127 self.assertEqual(a>>b, 1) 

128 self.assertEqual(a<<b, 20) 

129 self.assertEqual(a&b, 0) 

130 self.assertEqual(a|b, 7) 

131 self.assertEqual(a^b, 7) 

132 

133 def test_transform(self): 

134 """ 

135 Test transform= option 

136 """ 

137 a = Int(transform=pair_only) 

138 a.set(10) 

139 self.assertEqual(a, 10) 

140 a.set(9) 

141 self.assertEqual(a, 10) 

142 

143 def test_transform_lambda(self): 

144 """ 

145 Test transform with a lambda 

146 """ 

147 a = Int(transform=lambda value, o: value + 1 if value % 2 else value) 

148 a.set(10) 

149 self.assertEqual(a, 10) 

150 a.set(9) 

151 self.assertEqual(a, 10) 

152 

153 def test_constraint(self): 

154 """ 

155 Test constraints 

156 """ 

157 a = Int(constraint=check_pair) 

158 with self.assertRaises(Error) as e: 

159 a.set(11) 

160 self.assertEqual(e.exception.message, "constraint not validated") 

161 a = Int(constraint=[check_pair]) 

162 with self.assertRaises(Error) as e: 

163 a.set(11) 

164 self.assertEqual(e.exception.message, "constraint not validated") 

165 a.set(10) 

166 self.assertEqual(a, 10) 

167 

168 def test_constraint_error(self): 

169 """ 

170 Test constraint error 

171 """ 

172 a = Int(constraint="coucou") 

173 with self.assertRaises(Error) as e: 

174 a.set(11) 

175 self.assertEqual(e.exception.message, "constraint not callable") 

176 

177 def test_transform_on_change(self): 

178 """ 

179 Test onChange option 

180 """ 

181 self.on_change_bool = False 

182 

183 def change_test(old_value, value, o): # pylint: disable=unused-argument 

184 """ 

185 just a change option 

186 """ 

187 self.on_change_bool = True 

188 

189 a = Int(onChange=change_test) 

190 self.on_change_bool = False 

191 a.set(10) 

192 self.assertEqual(self.on_change_bool, True) 

193 self.on_change_bool = False 

194 a.set(10) 

195 self.assertEqual(self.on_change_bool, False) 

196 a.set(11) 

197 self.assertEqual(self.on_change_bool, True)