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
« 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#-----------------------------------------------------------------------------------
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
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()
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()
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()
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()
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()
338######################################################################################################
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()
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))
376###############################################################################################################################