Coverage for tests/test_list.py: 100%

204 statements  

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

1""" 

2test for List() 

3""" 

4import unittest 

5 

6from stricto import List, Int, String, Error 

7 

8 

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

10 """ 

11 Test on Lists 

12 """ 

13 

14 def test_error_type(self): 

15 """ 

16 Test error 

17 """ 

18 a = List(Int()) 

19 with self.assertRaises(Error) as e: 

20 a.set(12.3) 

21 self.assertEqual(e.exception.message, "Must be a list") 

22 with self.assertRaises(Error) as e: 

23 a.set(["toto"]) 

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

25 a.set([11]) 

26 self.assertEqual(a[0], 11) 

27 

28 def test_list_none(self): 

29 """ 

30 Test notnull value 

31 """ 

32 with self.assertRaises(Error) as e: 

33 a = List(Int(), notNone=True) 

34 self.assertEqual(e.exception.message, "Cannot be empty") 

35 a = List(Int(), notNone=True, default=[]) 

36 with self.assertRaises(Error) as e: 

37 a.set(None) 

38 self.assertEqual(e.exception.message, "Cannot be empty") 

39 a = List(Int()) 

40 a.set(None) 

41 self.assertEqual(a, None) 

42 

43 

44 def test_repr(self): 

45 """ 

46 Test repr() 

47 """ 

48 a = List(Int()) 

49 self.assertEqual(repr(a), 'None') 

50 a.set([1, 2, 3]) 

51 self.assertEqual(repr(a), '[1, 2, 3]') 

52 a = List(List(Int())) 

53 a.set([[1, 2, 3], [0, 4]]) 

54 self.assertEqual(repr(a), '[[1, 2, 3], [0, 4]]') 

55 

56 def test_default(self): 

57 """ 

58 Test default() 

59 """ 

60 a = List(Int(), default = [12]) 

61 self.assertEqual(len(a), 1) 

62 self.assertEqual(a[0], 12) 

63 

64 with self.assertRaises(Error) as e: 

65 a = List(Int(), default = 22) 

66 self.assertEqual(e.exception.message, "Must be a list") 

67 

68 def test_clear(self): 

69 """ 

70 Test clear() 

71 """ 

72 a = List(Int()) 

73 a.set([1, 2, 3]) 

74 a.clear() 

75 self.assertEqual(len(a), 0) 

76 a = List(Int(), default = [1]) 

77 a.set([1, 2, 3]) 

78 a.clear() 

79 self.assertEqual(len(a), 0) 

80 

81 def test_none_append(self): 

82 """ 

83 Test append on None list 

84 """ 

85 a = List(Int()) 

86 a.set(None) 

87 self.assertEqual(a, None) 

88 a.append(12) 

89 self.assertEqual(a[0], 12) 

90 

91 def test_none_extend(self): 

92 """ 

93 Test extend on None list 

94 """ 

95 a = List(Int()) 

96 a.set(None) 

97 self.assertEqual(a, None) 

98 a.extend([12, 32]) 

99 self.assertEqual(a[0], 12) 

100 

101 def test_pop(self): 

102 """ 

103 Test pop 

104 """ 

105 a = List(Int()) 

106 a.set([12, 32]) 

107 self.assertEqual(len(a), 2) 

108 b = a.pop() 

109 self.assertEqual(b, 32) 

110 self.assertEqual(len(a), 1) 

111 

112 def test_pop_index(self): 

113 """ 

114 Test pop with index 

115 """ 

116 a = List(Int()) 

117 a.set([12, 32]) 

118 self.assertEqual(len(a), 2) 

119 b = a.pop(0) 

120 self.assertEqual(b, 12) 

121 self.assertEqual(len(a), 1) 

122 

123 def test_del(self): 

124 """ 

125 Test del element 

126 """ 

127 a = List(Int()) 

128 a.set([12, 32]) 

129 self.assertEqual(len(a), 2) 

130 del a[0] 

131 self.assertEqual(a[0], 32) 

132 self.assertEqual(len(a), 1) 

133 

134 def test_remove(self): 

135 """ 

136 Test remove 

137 """ 

138 a = List(Int()) 

139 a.set([12, 32]) 

140 self.assertEqual(len(a), 2) 

141 with self.assertRaises(ValueError) as e: 

142 a.remove(44) 

143 self.assertEqual(e.exception.args[0], "list.remove(x): x not in list") 

144 a.remove(32) 

145 self.assertEqual(a[0], 12) 

146 self.assertEqual(len(a), 1) 

147 

148 def test_set_item(self): 

149 """ 

150 Test set a[index]=... 

151 """ 

152 a = List(Int()) 

153 a.set([12, 32]) 

154 self.assertEqual(len(a), 2) 

155 self.assertEqual(a[0], 12) 

156 a[0] = 22 

157 self.assertEqual(a[0], 22) 

158 

159 

160 def test_set_item_slice(self): 

161 """ 

162 Test set a[i:j]=[...] 

163 """ 

164 a = List(Int()) 

165 a.set([12, 32]) 

166 self.assertEqual(len(a), 2) 

167 self.assertEqual(a[0], 12) 

168 a[0:1] = [22, 44] 

169 self.assertEqual(a[0], 22) 

170 self.assertEqual(a[1], 44) 

171 a[0:3] = [22, 44, 66, 88] 

172 self.assertEqual(len(a), 4) 

173 self.assertEqual(a[0], 22) 

174 self.assertEqual(a[3], 88) 

175 

176 def test_insert(self): 

177 """ 

178 Test insert 

179 """ 

180 a = List(Int()) 

181 a.set([12, 32]) 

182 self.assertEqual(len(a), 2) 

183 self.assertEqual(a[0], 12) 

184 a.insert(0, 23) 

185 self.assertEqual(len(a), 3) 

186 self.assertEqual(a[0], 23) 

187 self.assertEqual(a[1], 12) 

188 self.assertEqual(a[2], 32) 

189 

190 def test_insert_none(self): 

191 """ 

192 Test insert into a none list 

193 """ 

194 a = List(Int()) 

195 a.insert(0, 23) 

196 self.assertEqual(len(a), 1) 

197 self.assertEqual(a[0], 23) 

198 

199 a = List(Int()) 

200 a.insert(10, 23) 

201 self.assertEqual(len(a), 1) 

202 self.assertEqual(a[0], 23) 

203 

204 a.set(None) 

205 a.insert(10, 23) 

206 self.assertEqual(len(a), 1) 

207 self.assertEqual(a[0], 23) 

208 

209 def test_sort(self): 

210 """ 

211 Test sort 

212 """ 

213 a = List(String()) 

214 a.set(["Ford", "BMW", "Volvo"]) 

215 a.sort() 

216 self.assertEqual(a[0], "BMW") 

217 self.assertEqual(a[2], "Volvo") 

218 a.sort(reverse=True) 

219 self.assertEqual(a[0], "Volvo") 

220 self.assertEqual(a[2], "BMW") 

221 a.set(None) 

222 a.sort() 

223 

224 def test_set_as_list(self): 

225 """ 

226 Test set as a list 

227 """ 

228 a = List(String()) 

229 a.set(["Ford", "BMW", "Volvo"]) 

230 b = List(String()) 

231 b.check(a) 

232 b.set(a) 

233 

234 def test_add(self): 

235 """ 

236 Test __add__ 

237 """ 

238 a = List(String()) 

239 a.set(["Ford", "BMW", "Volvo"]) 

240 b = a + ["Renault"] 

241 self.assertEqual(len(b), 4) 

242 self.assertEqual(type(b), List) 

243 

244 def test_ref(self): 

245 """ 

246 Test ref on list 

247 """ 

248 a = List(String()) 

249 a.set(["Ford", "BMW", "Volvo"]) 

250 b = a 

251 b[1] = "Renault" 

252 self.assertEqual(a[1], "Renault") 

253 self.assertEqual(b[1], "Renault") 

254 

255 def test_copy(self): 

256 """ 

257 Test copy() 

258 """ 

259 a = List(String()) 

260 a.set(["Ford", "BMW", "Volvo"]) 

261 b = a.copy() 

262 b[1] = "Renault" 

263 self.assertEqual(a[1], "BMW") 

264 self.assertEqual(b[1], "Renault") 

265 

266 def test_uniq(self): 

267 """ 

268 Test uniq() 

269 """ 

270 a = List(String(), uniq=True) 

271 a.set(["Ford", "BMW", "Volvo"]) 

272 with self.assertRaises(Error) as e: 

273 a[1]="Ford" 

274 self.assertEqual(e.exception.message, "duplicate value in list") 

275 with self.assertRaises(Error) as e: 

276 a=a+["BMW", "yolo"] 

277 self.assertEqual(e.exception.message, "duplicate value in list") 

278 

279 def test_min_max(self): 

280 """ 

281 Test min and max() 

282 """ 

283 with self.assertRaises(Error) as e: 

284 a = List(String(), min=2, default=["zaza"]) 

285 print(a) 

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

287 

288 a = List(String(), min=2, default=[ "a", "b" ] ) 

289 with self.assertRaises(Error) as e: 

290 a.set(["Ford"]) 

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

292 a.set(["Ford", "BMW"]) 

293 with self.assertRaises(Error) as e: 

294 a.pop() 

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

296 with self.assertRaises(Error) as e: 

297 a.clear() 

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

299 self.assertEqual(a[1], "BMW") 

300 

301 a = List(String(), max=2 ) 

302 with self.assertRaises(Error) as e: 

303 a.set(["Ford", "BMW", "Volvo"]) 

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

305 a.set(["Ford", "BMW"]) 

306 with self.assertRaises(Error) as e: 

307 a.append("yolo") 

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