Coverage for test_library_objects.py: 99%

318 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2024-02-27 14:21 +0000

1#----------------------------------------------------------------------------------- 

2# System tests to check the basic display and function of all library object permutations 

3#----------------------------------------------------------------------------------- 

4 

5from system_test_harness import * 

6from model_railway_signals.library import signals 

7from model_railway_signals.library import signals_common 

8import test_object_edit_windows 

9 

10def test_basic_point_operation(delay:float=0.0): 

11 # The sig file was saved with all points switched (and locked) 

12 print("Running basic point switching tests") 

13 assert_points_switched(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20) 

14 sleep(delay) 

15 set_fpls_off(5,6,7,8,13,15,16,19) 

16 sleep(delay) 

17 set_points_normal(1,2,3,4,5,6,7,8,13,14,15,16,17,18,19,20) 

18 sleep(delay) 

19 set_fpls_on(5,6,7,8,13,15,16,19) 

20 assert_points_normal(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20) 

21 sleep(delay) 

22 set_fpls_off(5,6,7,8,13,15,16,19) 

23 sleep(delay) 

24 set_points_switched(1,2,3,4,5,6,7,8,13,14,15,16,17,18,19,20) 

25 sleep(delay) 

26 set_fpls_on(5,6,7,8,13,15,16,19) 

27 assert_points_switched(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20) 

28 return() 

29 

30def test_basic_section_operation(delay:float=0.0): 

31 # The sig file was saved with all sections occupied 

32 print("Running basic section switching tests") 

33 assert_sections_occupied(1,2,3,4) 

34 assert_section_label(1,"ABC") 

35 assert_section_label(2,"DEF") 

36 assert_section_label(3,"ABC") 

37 assert_section_label(4,"DEF") 

38 sleep(delay) 

39 toggle_sections(1,2) 

40 assert_sections_clear(1,2,3,4) 

41 sleep(delay) 

42 toggle_sections(1,2) 

43 assert_sections_occupied(1,2,3,4) 

44 return() 

45 

46def test_basic_instrument_operation(delay:float=0.0): 

47 # The sig file was saved with instrument 1,3 OCCUPIED and 4 CLEAR 

48 # Instrument 1 is linked to 3 and Instrument 2 is linked to 4 

49 print("Running basic single line instrument switching tests") 

50 assert_block_section_ahead_not_clear(1,3) 

51 sleep(delay) 

52 set_instrument_clear(1) 

53 assert_block_section_ahead_clear(3) 

54 assert_block_section_ahead_not_clear(1) 

55 sleep(delay) 

56 set_instrument_blocked(1) 

57 assert_block_section_ahead_not_clear(1,3) 

58 sleep(delay) 

59 set_instrument_occupied(3) 

60 assert_block_section_ahead_not_clear(1,3) 

61 sleep(delay) 

62 set_instrument_clear(3) 

63 assert_block_section_ahead_clear(1) 

64 assert_block_section_ahead_not_clear(3) 

65 sleep(delay) 

66 set_instrument_blocked(3) 

67 assert_block_section_ahead_not_clear(1,3) 

68 sleep(delay) 

69 set_instrument_occupied(1) 

70 assert_block_section_ahead_not_clear(1,3) 

71 print("Running basic double line instrument switching tests") 

72 assert_block_section_ahead_clear(2) 

73 assert_block_section_ahead_not_clear(4) 

74 sleep(delay) 

75 set_instrument_clear(2) 

76 assert_block_section_ahead_clear(2,4) 

77 sleep(delay) 

78 set_instrument_blocked(2) 

79 assert_block_section_ahead_not_clear(4) 

80 assert_block_section_ahead_clear(2) 

81 sleep(delay) 

82 set_instrument_occupied(2) 

83 assert_block_section_ahead_not_clear(4) 

84 assert_block_section_ahead_clear(2) 

85 sleep(delay) 

86 set_instrument_blocked(4) 

87 assert_block_section_ahead_not_clear(2,4) 

88 sleep(delay) 

89 set_instrument_occupied(4) 

90 assert_block_section_ahead_not_clear(2,4) 

91 sleep(delay) 

92 set_instrument_clear(4) 

93 assert_block_section_ahead_not_clear(4) 

94 assert_block_section_ahead_clear(2) 

95 return() 

96 

97def test_basic_colour_light_operation(delay:float=0.0): 

98 # The sig file was saved with all colour light signals off 

99 print("Running basic colour light signal switching tests") 

100 assert_signals_PROCEED(1,2,4,5,6,7,8,10,11,12,14,15,16,17,33,18,20,21,22,23,24,34,26,27,29,30,31,32,33,34,67,69) 

101 assert_signals_CAUTION(3,9,13,19,25,28,68,70) 

102 sleep(delay) 

103 set_signals_on(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,67,68,69,70) 

104 assert_signals_DANGER(1,2,3,5,6,7,8,9,10,11,12,13,14,16,18,19,21,22,23,24,25,26,27,28,29,31,33,34,67,68,69,70) 

105 assert_signals_CAUTION(15,17,30,32,4,20) 

106 sleep(delay) 

107 set_signals_off(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,67,68,69,70) 

108 assert_signals_PROCEED(1,2,4,5,6,7,8,10,11,12,14,15,16,17,33,18,20,21,22,23,24,34,26,27,29,30,31,32,33,34,67,69) 

109 assert_signals_CAUTION(3,9,13,19,25,28,68,70) 

110 return() 

111 

112def test_basic_semaphore_operation(delay:float=0.0): 

113 # The sig file was saved with all Semaphore signals off (secondary distant arms are on) 

114 # MAIN route indications (We need to cheat to set the route) 

115 shunt_signals = (40,27) 

116 shunt_ahead_signals = (41,33) 

117 MAIN_dist_arms_only = (36,71,72,73,74,75,76,4,24,3,67,69,16,6) 

118 MAIN_home_arms_only = (35,45,65,52,64,60,66,70,10,68,18,9,11,21,42,17) 

119 MAIN_home_and_sub_arms = (37,50,51,53,54,55,56,20,15,29,13,31,5,8,77,78) 

120 MAIN_home_and_dist_arms = (39,59,61,58,62,57,63,1,2,32,7,25,12,19,79,80) 

121 MAIN_home_dist_and_sub_arms = (38,43,44,46,47,48,49,34,30,22,14,26,23,28,81,82) 

122 MAIN_all_signals = (MAIN_dist_arms_only + MAIN_home_arms_only + MAIN_home_and_sub_arms + 

123 MAIN_home_and_dist_arms + MAIN_home_dist_and_sub_arms + shunt_signals+shunt_ahead_signals) 

124 route = list(signals_common.route_type)[1] 

125 print("Running basic semaphore signal switching tests for route: "+str(route)) 

126 for sig_id in MAIN_all_signals: signals.set_route (sig_id, list(signals_common.route_type)[1],"M") 

127 # Tests start here 

128 assert_signals_PROCEED(*MAIN_dist_arms_only) 

129 assert_signals_PROCEED(*MAIN_home_arms_only) 

130 assert_signals_PROCEED(*MAIN_home_and_sub_arms) 

131 assert_signals_PROCEED(*shunt_signals) 

132 assert_signals_PROCEED(*shunt_ahead_signals) 

133 assert_signals_CAUTION(*MAIN_home_and_dist_arms) 

134 assert_signals_CAUTION(*MAIN_home_dist_and_sub_arms) 

135 sleep(delay) 

136 set_secondary_dists_off(*MAIN_home_and_dist_arms) 

137 set_secondary_dists_off(*MAIN_home_dist_and_sub_arms) 

138 assert_signals_PROCEED(*MAIN_home_and_dist_arms) 

139 assert_signals_PROCEED(*MAIN_home_dist_and_sub_arms) 

140 sleep(delay) 

141 set_signals_on(*MAIN_all_signals) 

142 assert_signals_CAUTION(*MAIN_dist_arms_only) 

143 assert_signals_DANGER(*MAIN_home_arms_only) 

144 assert_signals_DANGER(*MAIN_home_and_sub_arms) 

145 assert_signals_DANGER(*shunt_signals) 

146 assert_signals_CAUTION(*shunt_ahead_signals) 

147 assert_signals_DANGER(*MAIN_home_and_dist_arms) 

148 assert_signals_DANGER(*MAIN_home_dist_and_sub_arms) 

149 sleep(delay) 

150 set_subsidaries_off(*MAIN_home_and_sub_arms) 

151 set_subsidaries_off(*MAIN_home_dist_and_sub_arms) 

152 sleep(delay) 

153 set_subsidaries_on(*MAIN_home_and_sub_arms) 

154 set_subsidaries_on(*MAIN_home_dist_and_sub_arms) 

155 # No asserts to make for the above but at least it exercises the code 

156 sleep(delay) 

157 set_secondary_dists_on(*MAIN_home_and_dist_arms) 

158 set_secondary_dists_on(*MAIN_home_dist_and_sub_arms) 

159 set_signals_off(*MAIN_all_signals) 

160 # LH1 route indications (We need to cheat to set the route) 

161 LH1_dist_arms_only = (71,72,75,76,24,3,16,6) 

162 LH1_home_arms_only = (45,65,60,66,10,68,11,21,17,42) 

163 LH1_home_and_sub_arms = (50,51,55,56,15,29,5,8,77,78) 

164 LH1_home_and_dist_arms = (59,61,57,63,2,32,12,19,79,80) 

165 LH1_home_dist_and_sub_arms = (43,44,48,49,30,22,23,28,81,82) 

166 LH1_all_signals = (LH1_dist_arms_only + LH1_home_arms_only + LH1_home_and_sub_arms + 

167 LH1_home_and_dist_arms + LH1_home_dist_and_sub_arms + shunt_signals + shunt_ahead_signals) 

168 route = list(signals_common.route_type)[2] 

169 print("Running basic semaphore signal switching tests for route: "+str(route)) 

170 for sig_id in LH1_all_signals: signals.set_route (sig_id, list(signals_common.route_type)[2],"1") 

171 # Tests start here 

172 assert_signals_PROCEED(*LH1_dist_arms_only) 

173 assert_signals_PROCEED(*LH1_home_arms_only) 

174 assert_signals_PROCEED(*LH1_home_and_sub_arms) 

175 assert_signals_PROCEED(*shunt_signals) 

176 assert_signals_PROCEED(*shunt_ahead_signals) 

177 assert_signals_CAUTION(*LH1_home_and_dist_arms) 

178 assert_signals_CAUTION(*LH1_home_dist_and_sub_arms) 

179 sleep(delay) 

180 set_secondary_dists_off(*LH1_home_and_dist_arms) 

181 set_secondary_dists_off(*LH1_home_dist_and_sub_arms) 

182 assert_signals_PROCEED(*LH1_home_and_dist_arms) 

183 assert_signals_PROCEED(*LH1_home_dist_and_sub_arms) 

184 sleep(delay) 

185 set_signals_on(*LH1_all_signals) 

186 assert_signals_CAUTION(*LH1_dist_arms_only) 

187 assert_signals_DANGER(*LH1_home_arms_only) 

188 assert_signals_DANGER(*LH1_home_and_sub_arms) 

189 assert_signals_DANGER(*shunt_signals) 

190 assert_signals_CAUTION(*shunt_ahead_signals) 

191 assert_signals_DANGER(*LH1_home_and_dist_arms) 

192 assert_signals_DANGER(*LH1_home_dist_and_sub_arms) 

193 sleep(delay) 

194 set_subsidaries_off(*LH1_home_and_sub_arms) 

195 set_subsidaries_off(*LH1_home_dist_and_sub_arms) 

196 sleep(delay) 

197 set_subsidaries_on(*LH1_home_and_sub_arms) 

198 set_subsidaries_on(*LH1_home_dist_and_sub_arms) 

199 # No asserts to make for the above but at least it exercises the code 

200 sleep(delay) 

201 set_secondary_dists_on(*LH1_home_and_dist_arms) 

202 set_secondary_dists_on(*LH1_home_dist_and_sub_arms) 

203 set_signals_off(*LH1_all_signals) 

204 # LH2 route indications (We need to cheat to set the route) 

205 LH2_dist_arms_only = (72,76,3,6) 

206 LH2_home_arms_only = (65,66,68,21,17,42) 

207 LH2_home_and_sub_arms = (51,56,29,8,77,78) 

208 LH2_home_and_dist_arms = (61,63,32,19,79,80) 

209 LH2_home_dist_and_sub_arms = (44,49,22,28,81,82) 

210 LH2_all_signals = (LH2_dist_arms_only + LH2_home_arms_only + LH2_home_and_sub_arms + 

211 LH2_home_and_dist_arms + LH2_home_dist_and_sub_arms + shunt_signals+shunt_ahead_signals) 

212 route = list(signals_common.route_type)[3] 

213 print("Running basic semaphore signal switching tests for route: "+str(route)) 

214 for sig_id in LH2_all_signals: signals.set_route (sig_id, list(signals_common.route_type)[3],"2") 

215 # Tests start here 

216 assert_signals_PROCEED(*LH2_dist_arms_only) 

217 assert_signals_PROCEED(*LH2_home_arms_only) 

218 assert_signals_PROCEED(*LH2_home_and_sub_arms) 

219 assert_signals_PROCEED(*shunt_signals) 

220 assert_signals_PROCEED(*shunt_ahead_signals) 

221 assert_signals_CAUTION(*LH2_home_and_dist_arms) 

222 assert_signals_CAUTION(*LH2_home_dist_and_sub_arms) 

223 sleep(delay) 

224 set_secondary_dists_off(*LH2_home_and_dist_arms) 

225 set_secondary_dists_off(*LH2_home_dist_and_sub_arms) 

226 assert_signals_PROCEED(*LH2_home_and_dist_arms) 

227 assert_signals_PROCEED(*LH2_home_dist_and_sub_arms) 

228 sleep(delay) 

229 set_signals_on(*LH2_all_signals) 

230 assert_signals_CAUTION(*LH2_dist_arms_only) 

231 assert_signals_DANGER(*LH2_home_arms_only) 

232 assert_signals_DANGER(*LH2_home_and_sub_arms) 

233 assert_signals_DANGER(*shunt_signals) 

234 assert_signals_CAUTION(*shunt_ahead_signals) 

235 assert_signals_DANGER(*LH2_home_and_dist_arms) 

236 assert_signals_DANGER(*LH2_home_dist_and_sub_arms) 

237 sleep(delay) 

238 set_subsidaries_off(*LH2_home_and_sub_arms) 

239 set_subsidaries_off(*LH2_home_dist_and_sub_arms) 

240 sleep(delay) 

241 set_subsidaries_on(*LH2_home_and_sub_arms) 

242 set_subsidaries_on(*LH2_home_dist_and_sub_arms) 

243 # No asserts to make for the above but at least it exercises the code 

244 sleep(delay) 

245 set_secondary_dists_on(*LH2_home_and_dist_arms) 

246 set_secondary_dists_on(*LH2_home_dist_and_sub_arms) 

247 set_signals_off(*LH2_all_signals) 

248 # RH1 route indications (We need to cheat to set the route) 

249 RH1_dist_arms_only = (73,74,75,76,67,69,16,6) 

250 RH1_home_arms_only = (52,64,60,66,18,9,11,21,17,42) 

251 RH1_home_and_sub_arms = (53,54,55,56,13,31,5,8,77,78) 

252 RH1_home_and_dist_arms = (58,62,57,63,7,25,12,19,79,80) 

253 RH1_home_dist_and_sub_arms = (46,47,48,49,14,26,23,28,81,82) 

254 RH1_all_signals = (RH1_dist_arms_only + RH1_home_arms_only + RH1_home_and_sub_arms + 

255 RH1_home_and_dist_arms + RH1_home_dist_and_sub_arms + shunt_signals + shunt_ahead_signals) 

256 route = list(signals_common.route_type)[4] 

257 print("Running basic semaphore signal switching tests for route: "+str(route)) 

258 for sig_id in RH1_all_signals: signals.set_route (sig_id, list(signals_common.route_type)[4],"3") 

259 # Tests start here 

260 assert_signals_PROCEED(*RH1_dist_arms_only) 

261 assert_signals_PROCEED(*RH1_home_arms_only) 

262 assert_signals_PROCEED(*RH1_home_and_sub_arms) 

263 assert_signals_PROCEED(*shunt_signals) 

264 assert_signals_PROCEED(*shunt_ahead_signals) 

265 assert_signals_CAUTION(*RH1_home_and_dist_arms) 

266 assert_signals_CAUTION(*RH1_home_dist_and_sub_arms) 

267 sleep(delay) 

268 set_secondary_dists_off(*RH1_home_and_dist_arms) 

269 set_secondary_dists_off(*RH1_home_dist_and_sub_arms) 

270 assert_signals_PROCEED(*RH1_home_and_dist_arms) 

271 assert_signals_PROCEED(*RH1_home_dist_and_sub_arms) 

272 sleep(delay) 

273 set_signals_on(*RH1_all_signals) 

274 assert_signals_CAUTION(*RH1_dist_arms_only) 

275 assert_signals_DANGER(*RH1_home_arms_only) 

276 assert_signals_DANGER(*RH1_home_and_sub_arms) 

277 assert_signals_DANGER(*shunt_signals) 

278 assert_signals_CAUTION(*shunt_ahead_signals) 

279 assert_signals_DANGER(*RH1_home_and_dist_arms) 

280 assert_signals_DANGER(*RH1_home_dist_and_sub_arms) 

281 sleep(delay) 

282 set_subsidaries_off(*RH1_home_and_sub_arms) 

283 set_subsidaries_off(*RH1_home_dist_and_sub_arms) 

284 sleep(delay) 

285 set_subsidaries_on(*RH1_home_and_sub_arms) 

286 set_subsidaries_on(*RH1_home_dist_and_sub_arms) 

287 # No asserts to make for the above but at least it exercises the code 

288 sleep(delay) 

289 set_secondary_dists_on(*RH1_home_and_dist_arms) 

290 set_secondary_dists_on(*RH1_home_dist_and_sub_arms) 

291 set_signals_off(*RH1_all_signals) 

292 # RH2 route indications (We need to cheat to set the route) 

293 RH2_dist_arms_only = (74,76,69,6) 

294 RH2_home_arms_only = (64,66,9,21,17,42) 

295 RH2_home_and_sub_arms = (54,56,31,8,77,78) 

296 RH2_home_and_dist_arms = (62,63,25,19,79,80) 

297 RH2_home_dist_and_sub_arms = (47,49,26,28,81,82) 

298 RH2_all_signals = (RH2_dist_arms_only + RH2_home_arms_only + RH2_home_and_sub_arms + 

299 RH2_home_and_dist_arms + RH2_home_dist_and_sub_arms + shunt_signals + shunt_ahead_signals) 

300 route = list(signals_common.route_type)[5] 

301 print("Running basic semaphore signal switching tests for route: "+str(route)) 

302 for sig_id in RH2_all_signals: signals.set_route (sig_id, list(signals_common.route_type)[5],"4") 

303 # Tests start here 

304 assert_signals_PROCEED(*RH2_dist_arms_only) 

305 assert_signals_PROCEED(*RH2_home_arms_only) 

306 assert_signals_PROCEED(*RH2_home_and_sub_arms) 

307 assert_signals_PROCEED(*shunt_signals) 

308 assert_signals_PROCEED(*shunt_ahead_signals) 

309 assert_signals_CAUTION(*RH2_home_and_dist_arms) 

310 assert_signals_CAUTION(*RH2_home_dist_and_sub_arms) 

311 sleep(delay) 

312 set_secondary_dists_off(*RH2_home_and_dist_arms) 

313 set_secondary_dists_off(*RH2_home_dist_and_sub_arms) 

314 assert_signals_PROCEED(*RH2_home_and_dist_arms) 

315 assert_signals_PROCEED(*RH2_home_dist_and_sub_arms) 

316 sleep(delay) 

317 set_signals_on(*RH2_all_signals) 

318 assert_signals_CAUTION(*RH2_dist_arms_only) 

319 assert_signals_DANGER(*RH2_home_arms_only) 

320 assert_signals_DANGER(*RH2_home_and_sub_arms) 

321 assert_signals_DANGER(*shunt_signals) 

322 assert_signals_CAUTION(*shunt_ahead_signals) 

323 assert_signals_DANGER(*RH2_home_and_dist_arms) 

324 assert_signals_DANGER(*RH2_home_dist_and_sub_arms) 

325 sleep(delay) 

326 set_subsidaries_off(*RH2_home_and_sub_arms) 

327 set_subsidaries_off(*RH2_home_dist_and_sub_arms) 

328 sleep(delay) 

329 set_subsidaries_on(*RH2_home_and_sub_arms) 

330 set_subsidaries_on(*RH2_home_dist_and_sub_arms) 

331 # No asserts to make for the above but at least it exercises the code 

332 sleep(delay) 

333 set_secondary_dists_on(*RH2_home_and_dist_arms) 

334 set_secondary_dists_on(*RH2_home_dist_and_sub_arms) 

335 set_signals_off(*RH2_all_signals) 

336 return() 

337 

338###################################################################################################### 

339 

340def run_all_basic_library_tests(delay:float=0.0, shutdown:bool=False): 

341 initialise_test_harness(filename="./test_library_objects1.sig") 

342 # basic_library_tests1.sig was saved in edit mode 

343 set_run_mode() 

344 test_basic_point_operation(delay) 

345 test_basic_section_operation(delay) 

346 test_basic_instrument_operation(delay) 

347 test_basic_colour_light_operation(delay) 

348 ### TO DO - colour light route indications 

349 ### TO DO - colour light subsidaries 

350 ### TO DO - colour light timed sequences 

351 ### TO DO - colour light override to DANGER 

352 ### TO DO - colour light override to CAUTION 

353 ### TO DO - colour light release on yellow 

354 ### TO DO - colour light release on red 

355 set_edit_mode() 

356 test_object_edit_windows.test_all_object_edit_windows(delay) 

357 initialise_test_harness(filename="./test_library_objects2.sig") 

358 # basic_library_tests1.sig was saved in edit mode 

359 set_run_mode() 

360 test_basic_semaphore_operation(delay) 

361 ### TO DO - home signals with just subsidary arms 

362 ### TO DO - Load with some subsidaries clear (with different routes set) 

363 ### TO DO - Load with some signals clear (with different routes set) 

364 ### TO DO - semaphore timed sequences 

365 ### TO DO - semaphore override to DANGER 

366 ### TO DO - semaphore override to CAUTION 

367 ### TO DO - semaphore update distant on home signal ahead 

368 ### TO DO - semaphore release on red 

369 set_edit_mode() 

370 test_object_edit_windows.test_all_object_edit_windows(delay) 

371 if shutdown: report_results() 

372 

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

374 start_application(lambda:run_all_basic_library_tests(delay=0.0, shutdown=True)) 

375 

376############################################################################################################################### 

377