Coverage for test_run_layout.py: 99%
1328 statements
« prev ^ index » next coverage.py v7.2.7, created at 2024-03-27 14:35 +0000
« prev ^ index » next coverage.py v7.2.7, created at 2024-03-27 14:35 +0000
1#-----------------------------------------------------------------------------------
2# System tests for the run layout functions
3# All tests are run with simulated user-generated signal passed events and simulated gpio events
4# - Track occupancy changes tests for signal types that aren't a distant or shunt-ahead
5# signal (we can test a single type to be representitive of all other types)
6# - sections ahead and behind of signal- testing all the possible routes.
7# - section ahead of signal, no section behind signal
8# - only section behind signal, no section ahead of signal
9# - Track occupancy changes tests for distant and shunt-ahead signals (in this case
10# we test all subtypes of these signals for completeness). Note we test for the cases
11# of signals not having a valid route configured as (which is a possible scenario for
12# distant signals which rely on the points ahead of the home signal to set the appropriate
13# route arms. In this case, the home signal could be locked at DANGER if the points are not
14# set/locked but the distant signal can still be legitimately passed at CAUTION (and move to
15# the track section ahead) as these signals can be passed even if the route is not set
16# - sections ahead and behind of signal
17# - section ahead of signal, no section behind signal
18# - only section behind signal, no section ahead of signal
19# - Interlock distant on home signal ahead tests - main route
20# - Interlock distant on home signal ahead tests - diverging route
21# - Override distant on home signal ahead tests - main route
22# - Override distant on home signal ahead tests - diverging route
23# - Override secondary distant on distant signal ahead tests
24#-----------------------------------------------------------------------------------
26from system_test_harness import *
27import test_object_edit_windows
29#-----------------------------------------------------------------------------------
30# This teats the basic interlocking of signals, points, sections and block instruments
31#-----------------------------------------------------------------------------------
33def run_interlocking_tests(delay:float, edit_mode:bool, automation_enabled:bool):
34 reset_layout()
35 sleep(delay)
37 print("Basic Interlocking and override on track occupancy - Main route")
38 # Test Interlocking of signal 1 with block instrument
39 # Signal Interlocking on block instruments should be active in all modes
40 assert_signals_route_MAIN(1)
41 assert_signals_unlocked(4)
42 assert_signals_locked(1,2,3,5,6)
43 assert_points_unlocked(1,2,3,4)
44 set_instrument_clear(2)
45 sleep(delay)
46 assert_signals_unlocked(1,4)
47 assert_signals_locked(2,3,5,6)
48 # Test Interlocking and override of signals with sections ahead
49 # Note that we can only do this in RUN mode (Sections don't 'exist' in EDIT mode)
50 # Signal overrides on section occupied should only be set when automation is enabled
51 # Signal Interlocking on section occupied should be active in all modes
52 if not edit_mode:
53 # Test Interlocking and override of signal 1 with sections ahead
54 set_sections_occupied(4)
55 sleep(delay)
56 assert_signals_unlocked(4)
57 assert_signals_locked(1,2,3,5,6)
58 if automation_enabled:
59 assert_signals_override_set(1)
60 assert_signals_override_clear(2,3,4,5,6)
61 else:
62 assert_signals_override_clear(1,2,3,4,5,6)
63 set_sections_clear(4)
64 sleep(delay)
65 assert_signals_unlocked(1,4)
66 assert_signals_locked(2,3,5,6)
67 assert_signals_override_clear(1,2,3,4,5,6)
68 set_sections_occupied(20)
69 sleep(delay)
70 assert_signals_unlocked(4)
71 assert_signals_locked(1,2,3,5,6)
72 if automation_enabled:
73 assert_signals_override_set(1)
74 assert_signals_override_clear(2,3,4,5,6)
75 else:
76 assert_signals_override_clear(1,2,3,4,5,6)
77 set_sections_clear(20)
78 sleep(delay)
79 assert_signals_unlocked(1,4)
80 assert_signals_locked(2,3,5,6)
81 assert_signals_override_clear(1,2,3,4,5,6)
82 set_sections_occupied(21)
83 sleep(delay)
84 assert_signals_unlocked(4)
85 assert_signals_locked(1,2,3,5,6)
86 if automation_enabled:
87 assert_signals_override_set(1)
88 assert_signals_override_clear(2,3,4,5,6)
89 else:
90 assert_signals_override_clear(1,2,3,4,5,6)
91 set_sections_clear(21)
92 sleep(delay)
93 assert_signals_unlocked(1,4)
94 assert_signals_locked(2,3,5,6)
95 assert_signals_override_clear(1,2,3,4,5,6)
96 # Test Interlocking of signal 4 with sections ahead
97 set_sections_occupied(1)
98 sleep(delay)
99 assert_signals_unlocked(1)
100 assert_signals_locked(2,3,4,5,6)
101 if automation_enabled:
102 assert_signals_override_set(4)
103 assert_signals_override_clear(1,2,3,5,6)
104 else:
105 assert_signals_override_clear(1,2,3,4,5,6)
106 set_sections_clear(1)
107 sleep(delay)
108 assert_signals_unlocked(1,4)
109 assert_signals_locked(2,3,5,6)
110 assert_signals_override_clear(1,2,3,4,5,6)
111 set_sections_occupied(26)
112 sleep(delay)
113 assert_signals_unlocked(1)
114 assert_signals_locked(2,3,4,5,6)
115 if automation_enabled:
116 assert_signals_override_set(4)
117 assert_signals_override_clear(1,2,3,5,6)
118 else:
119 assert_signals_override_clear(1,2,3,4,5,6)
120 set_sections_clear(26)
121 sleep(delay)
122 assert_signals_unlocked(1,4)
123 assert_signals_locked(2,3,5,6)
124 assert_signals_override_clear(1,2,3,4,5,6)
125 set_sections_occupied(27)
126 sleep(delay)
127 assert_signals_unlocked(1)
128 assert_signals_locked(2,3,4,5,6)
129 if automation_enabled:
130 assert_signals_override_set(4)
131 assert_signals_override_clear(1,2,3,5,6)
132 else:
133 assert_signals_override_clear(1,2,3,4,5,6)
134 set_sections_clear(27)
135 sleep(delay)
136 assert_signals_unlocked(1,4)
137 assert_signals_locked(2,3,5,6)
138 assert_signals_override_clear(1,2,3,4,5,6)
139 # Test Interlocking of signal 1 with signal 4 (and also point interlocking)
140 # Signal Interlocking on conflicting signals should be active in all modes
141 set_signals_off(4)
142 sleep(delay)
143 assert_signals_unlocked(4)
144 assert_signals_locked(1,2,3,5,6)
145 assert_points_locked(1,3)
146 assert_points_unlocked(2,4)
147 set_signals_on(4)
148 sleep(delay)
149 assert_signals_unlocked(1,4)
150 assert_signals_locked(2,3,5,6)
151 assert_points_unlocked(1,2,3,4)
152 # Test Interlocking of signal 4 with signal 1 (and also point interlocking)
153 # Signal Interlocking on conflicting signals should be active in all modes
154 set_signals_off(1)
155 sleep(delay)
156 assert_signals_unlocked(1)
157 assert_signals_locked(2,3,4,5,6)
158 assert_points_locked(1,3)
159 assert_points_unlocked(2,4)
160 set_signals_on(1)
161 sleep(delay)
162 assert_signals_unlocked(1,4)
163 assert_signals_locked(2,3,5,6)
164 assert_points_unlocked(1,2,3,4)
165 # Revert block instrument to line blocked to check signal is locked again
166 # Signal Interlocking on block instruments should be active in all modes
167 set_instrument_blocked(2)
168 sleep(delay)
169 assert_signals_unlocked(4)
170 assert_signals_locked(1,2,3,5,6)
172 print("Basic Interlocking and override on track occupancy - LH1 route")
173 set_fpls_off(1)
174 sleep(delay)
175 assert_signals_locked(1,2,3,4,5,6)
176 set_points_switched(1)
177 sleep(delay)
178 set_fpls_on(1)
179 sleep(delay)
180 assert_signals_unlocked(5)
181 assert_signals_locked(1,2,3,4,6)
182 assert_signals_route_LH1(1)
183 # Test Interlocking of signal 1 with block instrument
184 # Interlocking of block instruments should be active in all modes
185 set_instrument_clear(2)
186 sleep(delay)
187 assert_signals_unlocked(1,5)
188 assert_signals_locked(2,3,4,6)
189 # Test Interlocking and override of signals with sections ahead
190 # Note that we can only do this in RUN mode (Sections don't 'exist' in EDIT mode)
191 # Signal overrides on section occupied should only be set when automation is enabled
192 # Signal Interlocking on section occupied should be active in all modes
193 if not edit_mode:
194 # Test Interlocking of signal 1 with sections ahead
195 set_sections_occupied(5)
196 sleep(delay)
197 assert_signals_unlocked(5)
198 assert_signals_locked(1,2,3,4,6)
199 if automation_enabled:
200 assert_signals_override_set(1)
201 assert_signals_override_clear(2,3,4,5,6)
202 else:
203 assert_signals_override_clear(1,2,3,4,5,6)
204 set_sections_clear(5)
205 sleep(delay)
206 assert_signals_unlocked(1,5)
207 assert_signals_locked(2,3,4,6)
208 assert_signals_override_clear(1,2,3,4,5,6)
209 set_sections_occupied(18)
210 sleep(delay)
211 assert_signals_unlocked(5)
212 assert_signals_locked(1,2,3,4,6)
213 if automation_enabled:
214 assert_signals_override_set(1)
215 assert_signals_override_clear(2,3,4,5,6)
216 else:
217 assert_signals_override_clear(1,2,3,4,5,6)
218 set_sections_clear(18)
219 sleep(delay)
220 assert_signals_unlocked(1,5)
221 assert_signals_locked(2,3,4,6)
222 assert_signals_override_clear(1,2,3,4,5,6)
223 set_sections_occupied(19)
224 sleep(delay)
225 assert_signals_unlocked(5)
226 assert_signals_locked(1,2,3,4,6)
227 if automation_enabled:
228 assert_signals_override_set(1)
229 assert_signals_override_clear(2,3,4,5,6)
230 else:
231 assert_signals_override_clear(1,2,3,4,5,6)
232 set_sections_clear(19)
233 sleep(delay)
234 assert_signals_unlocked(1,5)
235 assert_signals_locked(2,3,4,6)
236 assert_signals_override_clear(1,2,3,4,5,6)
237 # Test Interlocking of signal 5 with sections ahead
238 set_sections_occupied(1)
239 sleep(delay)
240 assert_signals_unlocked(1)
241 assert_signals_locked(2,3,4,5,6)
242 if automation_enabled:
243 assert_signals_override_set(5)
244 assert_signals_override_clear(1,2,3,4,6)
245 else:
246 assert_signals_override_clear(1,2,3,4,5,6)
247 set_sections_clear(1)
248 sleep(delay)
249 assert_signals_unlocked(1,5)
250 assert_signals_locked(2,3,4,6)
251 set_sections_occupied(26)
252 sleep(delay)
253 assert_signals_unlocked(1)
254 assert_signals_locked(2,3,4,5,6)
255 if automation_enabled:
256 assert_signals_override_set(5)
257 assert_signals_override_clear(1,2,3,4,6)
258 else:
259 assert_signals_override_clear(1,2,3,4,5,6)
260 set_sections_clear(26)
261 sleep(delay)
262 assert_signals_unlocked(1,5)
263 assert_signals_locked(2,3,4,6)
264 set_sections_occupied(27)
265 sleep(delay)
266 assert_signals_unlocked(1)
267 assert_signals_locked(2,3,4,5,6)
268 if automation_enabled:
269 assert_signals_override_set(5)
270 assert_signals_override_clear(1,2,3,4,6)
271 else:
272 assert_signals_override_clear(1,2,3,4,5,6)
273 set_sections_clear(27)
274 sleep(delay)
275 assert_signals_unlocked(1,5)
276 assert_signals_locked(2,3,4,6)
277 assert_signals_override_clear(1,2,3,4,5,6)
278 # Test Interlocking of signal 1 with signal 5 (and also point interlocking)
279 # Signal Interlocking on conflicting signals should be active in all modes
280 set_signals_off(5)
281 sleep(delay)
282 assert_signals_unlocked(5)
283 assert_signals_locked(1,2,3,4,6)
284 assert_points_locked(1,2)
285 assert_points_unlocked(3,4)
286 set_signals_on(5)
287 sleep(delay)
288 assert_signals_unlocked(1,5)
289 assert_signals_locked(2,3,4,6)
290 assert_points_unlocked(1,2,3,4)
291 # Test Interlocking of signal 5 with signal 1 (and also point interlocking)
292 # Signal Interlocking on conflicting signals should be active in all modes
293 set_signals_off(1)
294 sleep(delay)
295 assert_signals_unlocked(1)
296 assert_signals_locked(2,3,4,5,6)
297 assert_points_locked(1,2)
298 assert_points_unlocked(3,4)
299 set_signals_on(1)
300 sleep(delay)
301 assert_signals_unlocked(1,5)
302 assert_signals_locked(2,3,4,6)
303 assert_points_unlocked(1,2,3,4)
304 # Revert block instrument to line blocked to check signal is locked again
305 # Interlocking of block instruments should be active in all modes
306 set_instrument_blocked(2)
307 sleep(delay)
308 assert_signals_unlocked(5)
309 assert_signals_locked(1,2,3,4,6)
311 print("Basic Interlocking and override on track occupancy - LH2 route")
312 set_fpls_off(2)
313 sleep(delay)
314 assert_signals_locked(1,2,3,4,5,6)
315 set_points_switched(2)
316 sleep(delay)
317 set_fpls_on(2)
318 sleep(delay)
319 assert_signals_unlocked(6)
320 assert_signals_locked(1,2,3,4,5)
321 # Test Interlocking of signal 1 with block instrument
322 # Signal Interlocking on block instruments should be active in all modes
323 assert_signals_route_LH2(1)
324 set_instrument_clear(2)
325 sleep(delay)
326 assert_signals_unlocked(1,6)
327 assert_signals_locked(2,3,4,5)
328 # Test Interlocking and override of signals with sections ahead
329 # Note that we can only do this in RUN mode (Sections don't 'exist' in EDIT mode)
330 # Signal overrides on section occupied should only be set when automation is enabled
331 # Signal Interlocking on section occupied should be active in all modes
332 if not edit_mode:
333 # Test Interlocking of signal 1 with sections ahead
334 set_sections_occupied(6)
335 sleep(delay)
336 assert_signals_unlocked(6)
337 assert_signals_locked(1,2,3,4,5)
338 if automation_enabled:
339 assert_signals_override_set(1)
340 assert_signals_override_clear(2,3,4,5,6)
341 else:
342 assert_signals_override_clear(1,2,3,4,5,6)
343 set_sections_clear(6)
344 sleep(delay)
345 assert_signals_unlocked(1,6)
346 assert_signals_locked(2,3,4,5)
347 assert_signals_override_clear(1,2,3,4,5,6)
348 set_sections_occupied(16)
349 sleep(delay)
350 assert_signals_unlocked(6)
351 assert_signals_locked(1,2,3,4,5)
352 if automation_enabled:
353 assert_signals_override_set(1)
354 assert_signals_override_clear(2,3,4,5,6)
355 else:
356 assert_signals_override_clear(1,2,3,4,5,6)
357 set_sections_clear(16)
358 sleep(delay)
359 assert_signals_unlocked(1,6)
360 assert_signals_locked(2,3,4,5)
361 assert_signals_override_clear(1,2,3,4,5,6)
362 set_sections_occupied(17)
363 sleep(delay)
364 assert_signals_unlocked(6)
365 assert_signals_locked(1,2,3,4,5)
366 if automation_enabled:
367 assert_signals_override_set(1)
368 assert_signals_override_clear(2,3,4,5,6)
369 else:
370 assert_signals_override_clear(1,2,3,4,5,6)
371 set_sections_clear(17)
372 sleep(delay)
373 assert_signals_unlocked(1,6)
374 assert_signals_locked(2,3,4,5)
375 assert_signals_override_clear(1,2,3,4,5,6)
376 # Test Interlocking of signal 6 with sections ahead
377 set_sections_occupied(1)
378 sleep(delay)
379 assert_signals_unlocked(1)
380 assert_signals_locked(2,3,4,5,6)
381 if automation_enabled:
382 assert_signals_override_set(6)
383 assert_signals_override_clear(1,2,3,4,5)
384 else:
385 assert_signals_override_clear(1,2,3,4,5,6)
386 set_sections_clear(1)
387 sleep(delay)
388 assert_signals_unlocked(1,6)
389 assert_signals_locked(2,3,4,5)
390 set_sections_occupied(26)
391 sleep(delay)
392 assert_signals_unlocked(1)
393 assert_signals_locked(2,3,4,5,6)
394 if automation_enabled:
395 assert_signals_override_set(6)
396 assert_signals_override_clear(1,2,3,4,5)
397 else:
398 assert_signals_override_clear(1,2,3,4,5,6)
399 set_sections_clear(26)
400 sleep(delay)
401 assert_signals_unlocked(1,6)
402 assert_signals_locked(2,3,4,5)
403 set_sections_occupied(27)
404 sleep(delay)
405 assert_signals_unlocked(1)
406 assert_signals_locked(2,3,4,5,6)
407 if automation_enabled:
408 assert_signals_override_set(6)
409 assert_signals_override_clear(1,2,3,4,5)
410 else:
411 assert_signals_override_clear(1,2,3,4,5,6)
412 set_sections_clear(27)
413 sleep(delay)
414 assert_signals_unlocked(1,6)
415 assert_signals_locked(2,3,4,5)
416 assert_signals_override_clear(1,2,3,4,5,6)
417 # Test Interlocking of signal 1 with signal 6 (and also point interlocking)
418 # Signal Interlocking on conflicting signals should be active in all modes
419 set_signals_off(6)
420 sleep(delay)
421 assert_signals_unlocked(6)
422 assert_signals_locked(1,2,3,4,5)
423 assert_points_locked(1,2)
424 assert_points_unlocked(3,4)
425 set_signals_on(6)
426 sleep(delay)
427 assert_signals_unlocked(1,6)
428 assert_signals_locked(2,3,4,5)
429 assert_points_unlocked(1,2,3,4)
430 # Test Interlocking of signal 6 with signal 1 (and also point interlocking)
431 # Signal Interlocking on conflicting signals should be active in all modes
432 set_signals_off(1)
433 sleep(delay)
434 assert_signals_unlocked(1)
435 assert_signals_locked(2,3,4,5,6)
436 assert_points_locked(1,2)
437 assert_points_unlocked(3,4)
438 set_signals_on(1)
439 sleep(delay)
440 assert_signals_unlocked(1,6)
441 assert_signals_locked(2,3,4,5)
442 assert_points_unlocked(1,2,3,4)
443 # Revert block instrument to line blocked to check signal is locked again
444 # Signal Interlocking on block instruments should be active in all modes
445 set_instrument_blocked(2)
446 sleep(delay)
447 assert_signals_unlocked(6)
448 assert_signals_locked(1,2,3,4,5)
450 print("Basic Interlocking and override on track occupancy - RH1 route")
451 set_fpls_off(1)
452 sleep(delay)
453 assert_signals_locked(1,2,3,4,5,6)
454 set_points_normal(1)
455 sleep(delay)
456 set_fpls_on(1)
457 sleep(delay)
458 assert_signals_unlocked(4)
459 assert_signals_locked(1,2,3,5,6)
460 set_fpls_off(3)
461 sleep(delay)
462 assert_signals_locked(1,2,3,4,5,6)
463 set_points_switched(3)
464 sleep(delay)
465 set_fpls_on(3)
466 sleep(delay)
467 assert_signals_unlocked(3)
468 assert_signals_locked(1,2,4,5,6)
469 # Test Interlocking of signal 1 with block instrument
470 # Signal Interlocking on block instruments should be active in all modes
471 assert_signals_route_RH1(1)
472 set_instrument_clear(2)
473 sleep(delay)
474 assert_signals_unlocked(1,3)
475 assert_signals_locked(2,6,4,5)
476 # Test Interlocking and override of signals with sections ahead
477 # Note that we can only do this in RUN mode (Sections don't 'exist' in EDIT mode)
478 # Signal overrides on section occupied should only be set when automation is enabled
479 # Signal Interlocking on section occupied should be active in all modes
480 if not edit_mode:
481 # Test Interlocking of signal 1 with sections ahead
482 set_sections_occupied(3)
483 sleep(delay)
484 assert_signals_unlocked(3)
485 assert_signals_locked(1,2,6,4,5)
486 if automation_enabled:
487 assert_signals_override_set(1)
488 assert_signals_override_clear(2,3,4,5,6)
489 else:
490 assert_signals_override_clear(1,2,3,4,5,6)
491 set_sections_clear(3)
492 sleep(delay)
493 assert_signals_unlocked(1,3)
494 assert_signals_locked(2,6,4,5)
495 assert_signals_override_clear(1,2,3,4,5,6)
496 set_sections_occupied(22)
497 sleep(delay)
498 assert_signals_unlocked(3)
499 assert_signals_locked(1,2,6,4,5)
500 if automation_enabled:
501 assert_signals_override_set(1)
502 assert_signals_override_clear(2,3,4,5,6)
503 else:
504 assert_signals_override_clear(1,2,3,4,5,6)
505 set_sections_clear(22)
506 sleep(delay)
507 assert_signals_unlocked(1,3)
508 assert_signals_locked(2,6,4,5)
509 assert_signals_override_clear(1,2,3,4,5,6)
510 set_sections_occupied(23)
511 sleep(delay)
512 assert_signals_unlocked(3)
513 assert_signals_locked(1,2,6,4,5)
514 if automation_enabled:
515 assert_signals_override_set(1)
516 assert_signals_override_clear(2,3,4,5,6)
517 else:
518 assert_signals_override_clear(1,2,3,4,5,6)
519 set_sections_clear(23)
520 sleep(delay)
521 assert_signals_unlocked(1,3)
522 assert_signals_locked(2,6,4,5)
523 assert_signals_override_clear(1,2,3,4,5,6)
524 # Test Interlocking of signal 3 with sections ahead
525 set_sections_occupied(1)
526 sleep(delay)
527 assert_signals_unlocked(1)
528 assert_signals_locked(2,3,4,5,6)
529 if automation_enabled:
530 assert_signals_override_set(3)
531 assert_signals_override_clear(1,2,4,5,6)
532 else:
533 assert_signals_override_clear(1,2,3,4,5,6)
534 set_sections_clear(1)
535 sleep(delay)
536 assert_signals_unlocked(1,3)
537 assert_signals_locked(2,6,4,5)
538 set_sections_occupied(26)
539 sleep(delay)
540 assert_signals_unlocked(1)
541 assert_signals_locked(2,3,4,5,6)
542 if automation_enabled:
543 assert_signals_override_set(3)
544 assert_signals_override_clear(1,2,4,5,6)
545 else:
546 assert_signals_override_clear(1,2,3,4,5,6)
547 set_sections_clear(26)
548 sleep(delay)
549 assert_signals_unlocked(1,3)
550 assert_signals_locked(2,6,4,5)
551 set_sections_occupied(27)
552 sleep(delay)
553 assert_signals_unlocked(1)
554 assert_signals_locked(2,3,4,5,6)
555 if automation_enabled:
556 assert_signals_override_set(3)
557 assert_signals_override_clear(1,2,4,5,6)
558 else:
559 assert_signals_override_clear(1,2,3,4,5,6)
560 set_sections_clear(27)
561 sleep(delay)
562 assert_signals_unlocked(1,3)
563 assert_signals_locked(2,6,4,5)
564 assert_signals_override_clear(1,2,3,4,5,6)
565 # Test Interlocking of signal 1 with signal 3 (and also point interlocking)
566 # Signal Interlocking on conflicting signals should be active in all modes
567 set_signals_off(3)
568 sleep(delay)
569 assert_signals_unlocked(3)
570 assert_signals_locked(1,2,6,4,5)
571 assert_points_locked(1,3,4)
572 assert_points_unlocked(2)
573 set_signals_on(3)
574 sleep(delay)
575 assert_signals_unlocked(1,3)
576 assert_signals_locked(2,6,4,5)
577 assert_points_unlocked(1,2,3,4)
578 # Test Interlocking of signal 3 with signal 1 (and also point interlocking)
579 # Signal Interlocking on conflicting signals should be active in all modes
580 set_signals_off(1)
581 sleep(delay)
582 assert_signals_unlocked(1)
583 assert_signals_locked(2,3,4,5,6)
584 assert_points_locked(1,3,4)
585 assert_points_unlocked(2)
586 set_signals_on(1)
587 sleep(delay)
588 assert_signals_unlocked(1,3)
589 assert_signals_locked(2,6,4,5)
590 assert_points_unlocked(1,2,3,4)
591 # Revert block instrument to line blocked to check signal is locked again
592 # Signal Interlocking on block instruments should be active in all modes
593 set_instrument_blocked(2)
594 sleep(delay)
595 assert_signals_unlocked(3)
596 assert_signals_locked(1,2,6,4,5)
598 print("Basic Interlocking and override on track occupancy - RH2 route")
599 set_fpls_off(4)
600 sleep(delay)
601 assert_signals_locked(1,2,3,4,5,6)
602 set_points_switched(4)
603 sleep(delay)
604 set_fpls_on(4)
605 sleep(delay)
606 assert_signals_unlocked(2)
607 assert_signals_locked(1,5,3,4,6)
608 # Test Interlocking of signal 1 with block instrument
609 # Signal Interlocking on block instruments should be active in all modes
610 assert_signals_route_RH2(1)
611 set_instrument_clear(2)
612 sleep(delay)
613 assert_signals_unlocked(1,2)
614 assert_signals_locked(3,6,4,5)
615 # Test Interlocking and override of signals with sections ahead
616 # Note that we can only do this in RUN mode (Sections don't 'exist' in EDIT mode)
617 # Signal overrides on section occupied should only be set when automation is enabled
618 # Signal Interlocking on section occupied should be active in all modes
619 if not edit_mode:
620 # Test Interlocking of signal 1 with sections ahead
621 set_sections_occupied(2)
622 sleep(delay)
623 assert_signals_unlocked(2)
624 assert_signals_locked(1,3,6,4,5)
625 if automation_enabled:
626 assert_signals_override_set(1)
627 assert_signals_override_clear(2,3,4,5,6)
628 else:
629 assert_signals_override_clear(1,2,3,4,5,6)
630 set_sections_clear(2)
631 sleep(delay)
632 assert_signals_unlocked(1,2)
633 assert_signals_locked(3,6,4,5)
634 assert_signals_override_clear(1,2,3,4,5,6)
635 set_sections_occupied(24)
636 sleep(delay)
637 assert_signals_unlocked(2)
638 assert_signals_locked(1,3,6,4,5)
639 if automation_enabled:
640 assert_signals_override_set(1)
641 assert_signals_override_clear(2,3,4,5,6)
642 else:
643 assert_signals_override_clear(1,2,3,4,5,6)
644 set_sections_clear(24)
645 sleep(delay)
646 assert_signals_unlocked(1,2)
647 assert_signals_locked(3,6,4,5)
648 assert_signals_override_clear(1,2,3,4,5,6)
649 set_sections_occupied(25)
650 sleep(delay)
651 assert_signals_unlocked(2)
652 assert_signals_locked(1,3,6,4,5)
653 if automation_enabled:
654 assert_signals_override_set(1)
655 assert_signals_override_clear(2,3,4,5,6)
656 else:
657 assert_signals_override_clear(1,2,3,4,5,6)
658 set_sections_clear(25)
659 sleep(delay)
660 assert_signals_unlocked(1,2)
661 assert_signals_locked(3,6,4,5)
662 assert_signals_override_clear(1,2,3,4,5,6)
663 # Test Interlocking of signal 3 with sections ahead
664 set_sections_occupied(1)
665 sleep(delay)
666 assert_signals_unlocked(1)
667 assert_signals_locked(2,3,4,5,6)
668 if automation_enabled:
669 assert_signals_override_set(2)
670 assert_signals_override_clear(1,3,4,5,6)
671 else:
672 assert_signals_override_clear(1,2,3,4,5,6)
673 set_sections_clear(1)
674 sleep(delay)
675 assert_signals_unlocked(1,2)
676 assert_signals_locked(3,6,4,5)
677 set_sections_occupied(26)
678 sleep(delay)
679 assert_signals_unlocked(1)
680 assert_signals_locked(2,3,4,5,6)
681 if automation_enabled:
682 assert_signals_override_set(2)
683 assert_signals_override_clear(1,3,4,5,6)
684 else:
685 assert_signals_override_clear(1,2,3,4,5,6)
686 set_sections_clear(26)
687 sleep(delay)
688 assert_signals_unlocked(1,2)
689 assert_signals_locked(3,6,4,5)
690 set_sections_occupied(27)
691 sleep(delay)
692 assert_signals_unlocked(1)
693 assert_signals_locked(2,3,4,5,6)
694 if automation_enabled:
695 assert_signals_override_set(2)
696 assert_signals_override_clear(1,3,4,5,6)
697 else:
698 assert_signals_override_clear(1,2,3,4,5,6)
699 set_sections_clear(27)
700 sleep(delay)
701 assert_signals_unlocked(1,2)
702 assert_signals_locked(3,6,4,5)
703 assert_signals_override_clear(1,2,3,4,5,6)
704 # Test Interlocking of signal 1 with signal 2 (and also point interlocking)
705 # Signal Interlocking on conflicting signals should be active in all modes
706 set_signals_off(2)
707 sleep(delay)
708 assert_signals_unlocked(2)
709 assert_signals_locked(1,3,6,4,5)
710 assert_points_locked(1,3,4)
711 assert_points_unlocked(2)
712 set_signals_on(2)
713 sleep(delay)
714 assert_signals_unlocked(1,2)
715 assert_signals_locked(3,6,4,5)
716 assert_points_unlocked(1,2,3,4)
717 # Test Interlocking of signal 2 with signal 1 (and also point interlocking)
718 # Signal Interlocking on conflicting signals should be active in all modes
719 set_signals_off(1)
720 sleep(delay)
721 assert_signals_unlocked(1)
722 assert_signals_locked(2,3,4,5,6)
723 assert_points_locked(1,3,4)
724 assert_points_unlocked(2)
725 set_signals_on(1)
726 sleep(delay)
727 assert_signals_unlocked(1,2)
728 assert_signals_locked(3,6,4,5)
729 assert_points_unlocked(1,2,3,4)
730 # Revert block instrument to line blocked to check signal is locked again
731 # Signal Interlocking on block instruments should be active in all modes
732 set_instrument_blocked(2)
733 sleep(delay)
734 assert_signals_unlocked(2)
735 assert_signals_locked(1,3,6,4,5)
736 return()
738#-----------------------------------------------------------------------------------
739# These test the changes to track occupancy on signal passed events for non-distant
740# and non-shunt-ahead signals - testing all the possible signal routes. This test
741# case has track sections both ahead of and behind the signal. Track occupancy
742# changes are operational only in RUN Mode (automation either on or off)
743#-----------------------------------------------------------------------------------
745def test_route(sig1, sig2, gpio1, gpio2, sec1, sec2, test_sensors, delay, edit_mode):
746 # We need to introduce a delay after triggering of the remote GPIO sensors
747 # as these are configured with a timeout period of 0.1 seconds (this means that
748 # any additional triggers received within the 0.1 seconds will be ignored
749 gpio_trigger_delay = 0.2
750 # Test the route forward
751 if not edit_mode:
752 assert_sections_occupied(sec1)
753 assert_sections_clear(sec2)
754 if test_sensors:
755 simulate_gpio_triggered(gpio1)
756 sleep(delay+gpio_trigger_delay)
757 simulate_gpio_triggered(gpio2)
758 sleep(delay+gpio_trigger_delay)
759 else:
760 trigger_signals_passed(sig1)
761 sleep(delay)
762 trigger_signals_passed(sig2)
763 sleep(delay)
764 if not edit_mode:
765 assert_sections_occupied(sec2)
766 assert_sections_clear(sec1)
767 return
769def run_signal_track_occupancy_tests(delay:float, edit_mode:bool, test_sensors:bool=False):
770 reset_layout()
771 sleep(delay)
772 if test_sensors: print("Signal Track occupancy changes - simulated GPIO events")
773 else: print("Signal Track occupancy changes - user-generated (button push) events")
774 # Set the block instrument to CLEAR (so it doesn't lock signal 1)
775 set_instrument_clear(2)
776 sleep(delay)
777 if not edit_mode: set_sections_occupied(1)
778 sleep(delay)
780 # Test MAIN route forward and back with signals at DANGER - train should still be passed but with warnings generated
781 if not edit_mode: print("Signal Track occupancy changes - Signals Passed at danger - 2 warnings should be generated:")
782 test_route(sig1=1, sig2=4, gpio1=4, gpio2=7, sec1=1, sec2=4, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
783 test_route(sig1=4, sig2=1, gpio1=7, gpio2=4, sec1=4, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
784 # Test MAIN route forward and back with signals CLEAR
785 set_signals_off(1)
786 sleep(delay)
787 test_route(sig1=1, sig2=4, gpio1=4, gpio2=7, sec1=1, sec2=4, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
788 set_signals_on(1)
789 sleep(delay)
790 set_signals_off(4)
791 sleep(delay)
792 test_route(sig1=4, sig2=1, gpio1=7, gpio2=4, sec1=4, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
793 set_signals_on(4)
794 sleep(delay)
796 # Test LH1 route forward and back with signals at DANGER - train should still be passed but with warnings generated
797 set_fpls_off(1)
798 sleep(delay)
799 set_points_switched(1)
800 sleep(delay)
801 set_fpls_on(1)
802 sleep(delay)
803 if not edit_mode: print("Signal Track occupancy changes - Signals Passed at danger - 2 warnings should be generated:")
804 test_route(sig1=1, sig2=5, gpio1=4, gpio2=8, sec1=1, sec2=5, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
805 test_route(sig1=5, sig2=1, gpio1=8, gpio2=4, sec1=5, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
806 # Test LH1 route forward and back with signals CLEAR
807 set_signals_off(1)
808 sleep(delay)
809 test_route(sig1=1, sig2=5, gpio1=4, gpio2=8, sec1=1, sec2=5, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
810 set_signals_on(1)
811 sleep(delay)
812 set_signals_off(5)
813 sleep(delay)
814 test_route(sig1=5, sig2=1, gpio1=8, gpio2=4, sec1=5, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
815 set_signals_on(5)
816 sleep(delay)
818 # Test LH2 route forward and back with signals at DANGER - train should still be passed but with warnings generated
819 set_fpls_off(2)
820 sleep(delay)
821 set_points_switched(2)
822 sleep(delay)
823 set_fpls_on(2)
824 sleep(delay)
825 if not edit_mode: print("Signal Track occupancy changes - Signals Passed at danger - 2 warnings should be generated:")
826 test_route(sig1=1, sig2=6, gpio1=4, gpio2=9, sec1=1, sec2=6, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
827 test_route(sig1=6, sig2=1, gpio1=9, gpio2=4, sec1=6, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
828 # Test LH2 route forward and back with signals CLEAR
829 set_signals_off(1)
830 sleep(delay)
831 test_route(sig1=1, sig2=6, gpio1=4, gpio2=9, sec1=1, sec2=6, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
832 set_signals_on(1)
833 sleep(delay)
834 set_signals_off(6)
835 sleep(delay)
836 test_route(sig1=6, sig2=1, gpio1=9, gpio2=4, sec1=6, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
837 set_signals_on(6)
838 sleep(delay)
840 # Test RH1 route forward and back with signals at DANGER - train should still be passed but with warnings generated
841 set_fpls_off(1,3)
842 sleep(delay)
843 set_points_switched(3)
844 set_points_normal(1)
845 sleep(delay)
846 set_fpls_on(1,3)
847 sleep(delay)
848 if not edit_mode: print("Signal Track occupancy changes - Signals Passed at danger - 2 warnings should be generated:")
849 test_route(sig1=1, sig2=3, gpio1=4, gpio2=6, sec1=1, sec2=3, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
850 test_route(sig1=3, sig2=1, gpio1=6, gpio2=4, sec1=3, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
851 # Test RH1 route forward and back with signals CLEAR
852 set_signals_off(1)
853 sleep(delay)
854 test_route(sig1=1, sig2=3, gpio1=4, gpio2=6, sec1=1, sec2=3, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
855 set_signals_on(1)
856 sleep(delay)
857 set_signals_off(3)
858 sleep(delay)
859 test_route(sig1=3, sig2=1, gpio1=6, gpio2=4, sec1=3, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
860 set_signals_on(3)
861 sleep(delay)
863 # Test RH2 route forward and back with signals at DANGER - train should still be passed but with warnings generated
864 set_fpls_off(4)
865 sleep(delay)
866 set_points_switched(4)
867 set_fpls_on(4)
868 sleep(delay)
869 if not edit_mode: print("Signal Track occupancy changes - Signals Passed at danger - 2 warnings should be generated:")
870 test_route(sig1=1, sig2=2, gpio1=4, gpio2=5, sec1=1, sec2=2, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
871 test_route(sig1=2, sig2=1, gpio1=5, gpio2=4, sec1=2, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
872 # Test RH2 route forward and back with signals CLEAR
873 set_signals_off(1)
874 sleep(delay)
875 test_route(sig1=1, sig2=2, gpio1=4, gpio2=5, sec1=1, sec2=2, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
876 set_signals_on(1)
877 sleep(delay)
878 set_signals_off(2)
879 sleep(delay)
880 test_route(sig1=2, sig2=1, gpio1=5, gpio2=4, sec1=2, sec2=1, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
881 set_signals_on(2)
882 sleep(delay)
884 if not edit_mode: print("Signal Track occupancy changes - Edge case tests - 3 warnings should be generated:")
885 # Test Both sections occupied - and signal is CLEAR - Valid Move - Train should be passed (without warnings)
886 set_subsidaries_off(1)
887 sleep(delay)
888 gpio_trigger_delay = 0.2
889 if not edit_mode:
890 set_sections_occupied(2)
891 sleep(delay)
892 assert_sections_occupied(1,2)
893 if test_sensors:
894 simulate_gpio_triggered(4)
895 sleep(delay+gpio_trigger_delay)
896 else:
897 trigger_signals_passed(1)
898 sleep(delay)
899 if not edit_mode:
900 assert_sections_occupied(2)
901 assert_sections_clear(1)
902 # Test Both sections occupied - and signal is at DANGER - Warning will be generated
903 set_subsidaries_on(1)
904 sleep(delay)
905 if not edit_mode:
906 set_sections_occupied(1)
907 sleep(delay)
908 assert_sections_occupied(1,2)
909 if test_sensors:
910 simulate_gpio_triggered(4)
911 sleep(delay+gpio_trigger_delay)
912 else:
913 trigger_signals_passed(1)
914 sleep(delay)
915 if not edit_mode:
916 assert_sections_occupied(1,2)
917 # Test Both sections clear - and signal is at DANGER - Warning will be generated
918 sleep(delay)
919 if not edit_mode:
920 set_sections_clear(1,2)
921 sleep(delay)
922 if test_sensors:
923 simulate_gpio_triggered(4)
924 sleep(delay+gpio_trigger_delay)
925 else:
926 trigger_signals_passed(1)
927 sleep(delay)
928 if not edit_mode:
929 assert_sections_clear(1,2)
930 # Test Both sections clear - and signal is Clear - Warning will be generated
931 set_subsidaries_off(1)
932 sleep(delay)
933 if test_sensors:
934 simulate_gpio_triggered(4)
935 sleep(delay+gpio_trigger_delay)
936 else:
937 trigger_signals_passed(1)
938 sleep(delay)
939 if not edit_mode:
940 assert_sections_clear(1,2)
941 set_subsidaries_on(1)
942 sleep(delay)
943 return()
945#-----------------------------------------------------------------------------------
946# These test the changes to track occupancy on Track Sensor passed events. This test
947# case has track sections both ahead of and behind the Track Section. Track occupancy
948# changes are operational only in RUN Mode (automation either on or off)
949#-----------------------------------------------------------------------------------
951def test_route_sensors(sen1, gpio1, sec1, sec2, test_sensors, delay, edit_mode):
952 # We need to introduce a delay after triggering of the remote GPIO sensors
953 # as these are configured with a timeout period of 0.1 seconds (this means that
954 # any additional triggers received within the 0.1 seconds will be ignored
955 gpio_trigger_delay = 0.2
956 # Test the route forward
957 if not edit_mode:
958 assert_sections_occupied(sec1)
959 assert_sections_clear(sec2)
960 if test_sensors:
961 simulate_gpio_triggered(gpio1)
962 sleep(delay+gpio_trigger_delay)
963 else:
964 trigger_sensors_passed(sen1)
965 sleep(delay)
966 if not edit_mode:
967 assert_sections_occupied(sec2)
968 assert_sections_clear(sec1)
969 return
971def run_track_sensor_occupancy_tests(delay:float, edit_mode:bool, test_sensors:bool=False):
972 reset_layout()
973 sleep(delay)
974 if test_sensors: print("Track Sensor occupancy changes - simulated GPIO events")
975 else: print("Track Sensoroccupancy changes - user-generated (button push) events")
976 if not edit_mode: set_sections_occupied(34)
977 sleep(delay)
979 # Test MAIN route forward and back
980 test_route_sensors(sen1=1, gpio1=22,sec1=34, sec2=29, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
981 test_route_sensors(sen1=1, gpio1=22,sec1=29, sec2=34, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
982 # Test Main => LH1
983 set_points_switched(10)
984 sleep(delay)
985 test_route_sensors(sen1=1, gpio1=22,sec1=34, sec2=30, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
986 # Test LH1 <= LH1
987 set_points_switched(15)
988 sleep(delay)
989 test_route_sensors(sen1=1, gpio1=22,sec1=30, sec2=37, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
990 # Test LH1 => LH2
991 set_points_switched(11)
992 sleep(delay)
993 test_route_sensors(sen1=1, gpio1=22,sec1=37, sec2=31, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
994 # Test LH2 <= LH2
995 set_points_switched(16)
996 sleep(delay)
997 test_route_sensors(sen1=1, gpio1=22,sec1=31, sec2=33, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
998 # Test LH2 => RH1
999 set_points_switched(12)
1000 set_points_normal(10)
1001 sleep(delay)
1002 test_route_sensors(sen1=1, gpio1=22,sec1=33, sec2=32, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
1003 # Test RH1 <= RH1
1004 set_points_switched(13)
1005 sleep(delay)
1006 test_route_sensors(sen1=1, gpio1=22,sec1=32, sec2=35, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
1007 # Test RH1 => RH2
1008 set_points_switched(9)
1009 sleep(delay)
1010 test_route_sensors(sen1=1, gpio1=22,sec1=35, sec2=28, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
1011 # Test RH2 <=RH2
1012 set_points_switched(14)
1013 sleep(delay)
1014 test_route_sensors(sen1=1, gpio1=22,sec1=28, sec2=36, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
1016 # Test the Track Sections both occupied (negative test coverage)
1017 gpio_trigger_delay = 0.2
1018 if not edit_mode:
1019 print("Track Sensor occupancy changes - negative tests - 4 warnings should be generated:")
1020 set_sections_occupied(28)
1021 assert_sections_occupied(28,36)
1022 if test_sensors:
1023 simulate_gpio_triggered(22)
1024 sleep(delay+gpio_trigger_delay)
1025 else:
1026 trigger_sensors_passed(1)
1027 sleep(delay)
1028 if not edit_mode: assert_sections_occupied(28,36)
1029 # Test the Track Sections both clear (negative test coverage)
1030 if not edit_mode:
1031 set_sections_clear(28,36)
1032 sleep(delay)
1033 if test_sensors:
1034 simulate_gpio_triggered(22)
1035 sleep(delay+gpio_trigger_delay)
1036 else:
1037 trigger_sensors_passed(1)
1038 sleep(delay)
1039 if not edit_mode: assert_sections_clear(28,36)
1040 # Test the case of route not locked - track occupancy will still change
1041 if not edit_mode: set_sections_occupied(28)
1042 set_fpls_off(17,18)
1043 sleep(delay)
1044 test_route_sensors(sen1=1, gpio1=22,sec1=28, sec2=36, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
1045 # Test the case of no route existing before the sensor (negative test coverage)
1046 set_points_switched(18)
1047 sleep(delay)
1048 if test_sensors:
1049 simulate_gpio_triggered(22)
1050 sleep(delay+gpio_trigger_delay)
1051 else:
1052 trigger_sensors_passed(1)
1053 sleep(delay)
1054 # Test the case of no route existing after the sensor (negative test coverage)
1055 set_points_normal(18)
1056 set_points_switched(17)
1057 sleep(delay)
1058 if test_sensors:
1059 simulate_gpio_triggered(22)
1060 sleep(delay+gpio_trigger_delay)
1061 else:
1062 trigger_sensors_passed(1)
1063 sleep(delay)
1064 set_points_normal(17)
1065 sleep(delay)
1066 test_route_sensors(sen1=1, gpio1=22,sec1=36, sec2=28, test_sensors=test_sensors, delay=delay, edit_mode=edit_mode)
1068 if not edit_mode: print("Track Sensor occupancy changes - Section Ahead or Section Behind Tests")
1069 # Section ahead of Track Sensor only - Section should change to OCCUPIED
1070 if test_sensors:
1071 simulate_gpio_triggered(23)
1072 sleep(delay+gpio_trigger_delay)
1073 else:
1074 trigger_sensors_passed(2)
1075 sleep(delay)
1076 if not edit_mode:
1077 assert_sections_occupied(38)
1078 # Section ahead of Track Sensor only - Section should change to CLEAR
1079 if test_sensors:
1080 simulate_gpio_triggered(23)
1081 sleep(delay+gpio_trigger_delay)
1082 else:
1083 trigger_sensors_passed(2)
1084 sleep(delay)
1085 if not edit_mode:
1086 assert_sections_clear(38)
1087 # Section behind of Track Sensor only - Section should change to OCCUPIED
1088 if test_sensors:
1089 simulate_gpio_triggered(24)
1090 sleep(delay+gpio_trigger_delay)
1091 else:
1092 trigger_sensors_passed(3)
1093 sleep(delay)
1094 if not edit_mode:
1095 assert_sections_occupied(39)
1096 # Section behind of Track Sensor only - Section should change to CLEAR
1097 if test_sensors:
1098 simulate_gpio_triggered(24)
1099 sleep(delay+gpio_trigger_delay)
1100 else:
1101 trigger_sensors_passed(3)
1102 sleep(delay)
1103 if not edit_mode:
1104 assert_sections_clear(39)
1105 return()
1107#-----------------------------------------------------------------------------------
1108# These test the changes to track occupancy on signal passed events for non-distant
1109# and non-shunt-ahead signals - where sections only exist one side of the signal
1110# Track occupancy changes work in RUN Mode (Automation enabled or disabled)
1111#-----------------------------------------------------------------------------------
1113def subtest_sections_ahead_behind_3(delay:float, edit_mode:bool, test_sensors:bool=False):
1114 # We need to introduce a delay after triggering of the remote GPIO sensors
1115 # as these are configured with a timeout period of 0.1 seconds (this means that
1116 # any additional triggers received within the 0.1 seconds will be ignored
1117 gpio_trigger_delay = 0.2
1118 if test_sensors:
1119 print("Section ahead/behind tests - Other signal types - simulated GPIO events")
1120 else:
1121 print("Section ahead/behind tests - Other signal types - user-generated events")
1122 # Track occupancy tests for non-distant signals - section ahead of signal only
1123 reset_layout()
1124 sleep(delay)
1125 # No Section behind signal, section ahead is CLEAR, signal is ON
1126 # Section ahead will be set to OCCUPIED (but with a SPAD warning)
1127 if not edit_mode:
1128 assert_sections_clear(7)
1129 print("signals passed at danger - a warning will be generated")
1130 if test_sensors:
1131 simulate_gpio_triggered(10)
1132 sleep(delay+gpio_trigger_delay)
1133 else:
1134 trigger_signals_passed(7)
1135 sleep(delay)
1136 if not edit_mode: assert_sections_occupied(7)
1137 # No Section behind signal, section ahead is now OCCUPIED, signal is ON
1138 # Section ahead will be set to CLEAR
1139 if test_sensors:
1140 simulate_gpio_triggered(10)
1141 sleep(delay+gpio_trigger_delay)
1142 else:
1143 trigger_signals_passed(7)
1144 sleep(delay)
1145 if not edit_mode: assert_sections_clear(7)
1146 # No Section behind signal, section ahead is now CLEAR, signal is OFF
1147 # Section ahead will be set to OCCUPIED (no SPAD warning this time)
1148 sleep(delay)
1149 set_signals_off(7)
1150 sleep(delay)
1151 if test_sensors:
1152 simulate_gpio_triggered(10)
1153 sleep(delay+gpio_trigger_delay)
1154 else:
1155 trigger_signals_passed(7)
1156 sleep(delay)
1157 if not edit_mode: assert_sections_occupied(7)
1158 # No Section behind signal, section ahead is now OCCUPIED, signal is ON
1159 # Section ahead will be set to CLEAR
1160 if test_sensors:
1161 simulate_gpio_triggered(10)
1162 sleep(delay+gpio_trigger_delay)
1163 else:
1164 trigger_signals_passed(7)
1165 sleep(delay)
1166 if not edit_mode: assert_sections_clear(7)
1167 set_signals_on(7)
1168 sleep(delay)
1170 # Track occupancy tests for non-distant signals - section behind signal only
1171 if not edit_mode: assert_sections_clear(8)
1172 # No Section ahead of signal, section behind is CLEAR, signal is ON
1173 # Section behind will be set to OCCUPIED
1174 if test_sensors:
1175 simulate_gpio_triggered(11)
1176 sleep(delay+gpio_trigger_delay)
1177 else:
1178 trigger_signals_passed(8)
1179 sleep(delay)
1180 if not edit_mode:
1181 assert_sections_occupied(8)
1182 print("signals passed at danger - a warning will be generated")
1183 # No Section ahead of signal, section behind is now OCCUPIED, signal is ON
1184 # Section behind will be set to CLEAR (but with a SPAD warning)
1185 if test_sensors:
1186 simulate_gpio_triggered(11)
1187 sleep(delay+gpio_trigger_delay)
1188 else:
1189 trigger_signals_passed(8)
1190 sleep(delay)
1191 if not edit_mode: assert_sections_clear(8)
1192 # No Section ahead of signal, section behind is CLEAR, signal is OFF
1193 # Section behind will be set to OCCUPIED
1194 set_signals_off(8)
1195 sleep(delay)
1196 if test_sensors:
1197 simulate_gpio_triggered(11)
1198 sleep(delay+gpio_trigger_delay)
1199 else:
1200 trigger_signals_passed(8)
1201 sleep(delay)
1202 if not edit_mode: assert_sections_occupied(8)
1203 # No Section ahead of signal, section behind is now OCCUPIED, signal isOFF
1204 # Section behind will be set to CLEAR (no SPAD warning this time)
1205 if test_sensors:
1206 simulate_gpio_triggered(11)
1207 sleep(delay+gpio_trigger_delay)
1208 else:
1209 trigger_signals_passed(8)
1210 sleep(delay)
1211 if not edit_mode: assert_sections_clear(8)
1212 set_signals_on(8)
1213 sleep(delay)
1214 return()
1216#-----------------------------------------------------------------------------------
1217# These test the changes to track occupancy on signal passed events for distant
1218# and shunt-ahead signals - all combinations of section ahead/behind
1219#-----------------------------------------------------------------------------------
1221def subtest_sections_ahead_behind_1(delay:float, edit_mode:bool, test_sensors:bool=False):
1222 # Track occupancy tests --- section ahead of signal only
1223 # Section will be set to occupied if signal is on
1224 sleep(delay)
1225 if test_sensors: simulate_gpio_triggered(12)
1226 else: trigger_signals_passed(9)
1227 if not edit_mode: assert_sections_occupied(9)
1228 sleep(delay)
1229 if not edit_mode: set_sections_clear(9)
1230 # Section will be set to occupied if signal is off
1231 sleep(delay)
1232 set_signals_off(9)
1233 sleep(delay)
1234 if test_sensors: simulate_gpio_triggered(12)
1235 else: trigger_signals_passed(9)
1236 if not edit_mode: assert_sections_occupied(9)
1237 # Check the train gets passed back the other way
1238 sleep(delay)
1239 if test_sensors: simulate_gpio_triggered(12)
1240 else: trigger_signals_passed(9)
1241 if not edit_mode: assert_sections_clear(9)
1242 sleep(delay)
1243 set_signals_on(9)
1244 sleep(delay)
1245 if not edit_mode: set_sections_occupied(9)
1246 if test_sensors: simulate_gpio_triggered(12)
1247 else: trigger_signals_passed(9)
1248 if not edit_mode: assert_sections_clear(9)
1249 # Track occupancy tests --- section behind signal only
1250 sleep(delay)
1251 # Test the normal condition (section behind occupied) - Section will be Cleared if signal is on
1252 sleep(delay)
1253 if not edit_mode: set_sections_occupied(10)
1254 # Section will be Cleared if signal is on
1255 sleep(delay)
1256 if test_sensors: simulate_gpio_triggered(13)
1257 else: trigger_signals_passed(10)
1258 if not edit_mode: assert_sections_clear(10)
1259 sleep(delay)
1260 if not edit_mode: set_sections_occupied(10)
1261 # Section will be Cleared if signal is on
1262 sleep(delay)
1263 set_signals_off(10)
1264 sleep(delay)
1265 if test_sensors: simulate_gpio_triggered(13)
1266 else: trigger_signals_passed(10)
1267 if not edit_mode: assert_sections_clear(10)
1268 # Check the train gets passed back the other way
1269 sleep(delay)
1270 if test_sensors: simulate_gpio_triggered(13)
1271 else: trigger_signals_passed(10)
1272 if not edit_mode: assert_sections_occupied(10)
1273 sleep(delay)
1274 set_signals_on(10)
1275 sleep(delay)
1276 if not edit_mode: set_sections_clear(10)
1277 if test_sensors: simulate_gpio_triggered(13)
1278 else: trigger_signals_passed(10)
1279 if not edit_mode: assert_sections_occupied(10)
1280 # Track occupancy tests --- sections ahead of and behind signal
1281 sleep(delay)
1282 if not edit_mode: set_sections_occupied(11)
1283 # Train will be passed forward if signal is on
1284 sleep(delay)
1285 if test_sensors: simulate_gpio_triggered(18)
1286 else: trigger_signals_passed(11)
1287 if not edit_mode:
1288 assert_sections_occupied(12)
1289 assert_sections_clear(11)
1290 # Check the train gets passed back the other way
1291 sleep(delay)
1292 if test_sensors: simulate_gpio_triggered(18)
1293 else: trigger_signals_passed(11)
1294 if not edit_mode:
1295 assert_sections_occupied(11)
1296 assert_sections_clear(12)
1297 # Train will be passed forward if signal is off
1298 sleep(delay)
1299 set_signals_off(11)
1300 sleep(delay)
1301 if test_sensors: simulate_gpio_triggered(18)
1302 else: trigger_signals_passed(11)
1303 if not edit_mode:
1304 assert_sections_occupied(12)
1305 assert_sections_clear(11)
1306 # Check the train gets passed back the other way
1307 sleep(delay)
1308 if test_sensors: simulate_gpio_triggered(18)
1309 else: trigger_signals_passed(11)
1310 if not edit_mode:
1311 assert_sections_occupied(11)
1312 assert_sections_clear(12)
1313 # Set everything back to normal
1314 set_signals_on(11)
1315 if not edit_mode: set_sections_clear(10,11)
1316 return()
1318#-----------------------------------------------------------------------------------
1319# This function runs the above two tests for all relevant signal types / subtypes
1320# That can be legitimately passed when either ON or OFF
1321# Sig Type: colour_light=1, ground_position=2, semaphore=3, ground_disc=4
1322# Sub type (colour light): distant=2
1323# Sub type (semaphore): distant=2
1324# Sub type (ground pos): shunt_ahead=2, early_shunt_ahead=4
1325# Sub type (ground disc): shunt_ahead=2
1326#-----------------------------------------------------------------------------------
1328def subtest_sections_ahead_behind_2(delay:float, edit_mode:bool, route_valid:bool, test_sensors:bool=False):
1329 if route_valid: text=" - Valid signal route"
1330 else: text=" - No route configured"
1331 s9 = get_object_id("signal",9)
1332 s10 = get_object_id("signal",10)
1333 s11 = get_object_id("signal",11)
1334 # Test with semaphore & Colour light distants - If the route is not valid the MAIN route will be assumed
1335 if test_sensors: print("Section ahead/behind tests - Colour Light Distant Signals - simulated GPIO events"+text)
1336 else: print("Section ahead/behind tests - Colour Light Distant Signals - user-generated events"+text)
1337 update_object_configuration(s9, {"itemtype":1, "itemsubtype":2} )
1338 update_object_configuration(s10, {"itemtype":1, "itemsubtype":2} )
1339 update_object_configuration(s11, {"itemtype":1, "itemsubtype":2} )
1340 subtest_sections_ahead_behind_1(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1341 if test_sensors: print("Section ahead/behind tests - Semaphore Distant Signals - simulated GPIO events"+text)
1342 else: print("Section ahead/behind tests - Semaphore Distant Signals - user-generated events"+text)
1343 update_object_configuration(s9, {"itemtype":3, "itemsubtype":2} )
1344 update_object_configuration(s10, {"itemtype":3, "itemsubtype":2} )
1345 update_object_configuration(s11, {"itemtype":3, "itemsubtype":2} )
1346 subtest_sections_ahead_behind_1(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1347 # Only run the tests for the other signal types if the route is valid
1348 if route_valid:
1349 if test_sensors: print("Section ahead/behind tests - Ground Disc Shunt Ahead Signals - simulated GPIO events"+text)
1350 else: print("Section ahead/behind tests - Ground Disc Shunt Ahead Signals - user-generated events"+text)
1351 update_object_configuration(s9, {"itemtype":4, "itemsubtype":2} )
1352 update_object_configuration(s10, {"itemtype":4, "itemsubtype":2} )
1353 update_object_configuration(s11, {"itemtype":4, "itemsubtype":2} )
1354 # Only run the tests if the route is valid
1355 subtest_sections_ahead_behind_1(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1356 if test_sensors: print("Section ahead/behind tests - Ground Position Shunt Ahead Signals - simulated GPIO events"+text)
1357 else: print("Section ahead/behind tests - Ground Position Shunt Ahead Signals - user-generated events"+text)
1358 update_object_configuration(s9, {"itemtype":2, "itemsubtype":2} )
1359 update_object_configuration(s10, {"itemtype":2, "itemsubtype":2} )
1360 update_object_configuration(s11, {"itemtype":2, "itemsubtype":2} )
1361 subtest_sections_ahead_behind_1(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1362 if test_sensors: print("Section ahead/behind tests - Ground Position Early Shunt Ahead Signals - simulated GPIO events"+text)
1363 else: print("Section ahead/behind tests - Ground Position Early Shunt Ahead Signals - user-generated events"+text)
1364 update_object_configuration(s9, {"itemtype":2, "itemsubtype":4} )
1365 update_object_configuration(s10, {"itemtype":2, "itemsubtype":4} )
1366 update_object_configuration(s11, {"itemtype":2, "itemsubtype":4} )
1367 subtest_sections_ahead_behind_1(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1368 return()
1370#-----------------------------------------------------------------------------------
1371# This function runs the above tests for the two cases of the signal having a valid
1372# route configured and the signal having no valid route configured (which is a possible
1373# scenario for splitting distant signals which rely on the points ahead of the home
1374# signal to set the appropriate route arms. In this case, the home signal could
1375# be locked at DANGER if the points are not set/locked but the distant signal can
1376# still be legitimately passed at CAUTION (and move to the track section ahead)
1377#-----------------------------------------------------------------------------------
1379def signals_sections_ahead_and_behind(delay:float, edit_mode:bool, test_sensors:bool=False):
1380 sleep(delay)
1381 reset_layout()
1382 # Signals 9,10,11 have a valid route
1383 subtest_sections_ahead_behind_2(delay, edit_mode=edit_mode, route_valid=False, test_sensors=test_sensors)
1384 # signals 9,10,11 have no valid route
1385 sleep(delay)
1386 set_points_switched(5)
1387 subtest_sections_ahead_behind_2(delay, edit_mode=edit_mode, route_valid=True, test_sensors=test_sensors)
1388 # Set everything back to its default state
1389 set_points_normal(5)
1390 subtest_sections_ahead_behind_3(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1391 # Set everything back to its default state
1392 return()
1394#-----------------------------------------------------------------------------------
1395# This function tests the correct behavior for shunt ahead signals (can be passed whilst ON)
1396# No Signal Passed at Danger warnings should be generated
1397#-----------------------------------------------------------------------------------
1399def subtest_shunt_ahead_signal_routes_1(delay:float, edit_mode:bool, test_sensors:bool=False):
1400 sleep(delay)
1401 if not edit_mode:
1402 set_sections_occupied(13)
1403 assert_sections_clear(14,15)
1404 sleep(delay)
1405 if test_sensors: simulate_gpio_triggered(19)
1406 else: trigger_signals_passed(12)
1407 if not edit_mode:
1408 assert_sections_occupied(14)
1409 assert_sections_clear(13,15)
1410 sleep(delay)
1411 if test_sensors: simulate_gpio_triggered(19)
1412 else: trigger_signals_passed(12)
1413 if not edit_mode:
1414 assert_sections_occupied(13)
1415 assert_sections_clear(14,15)
1416 sleep(delay)
1417 set_points_switched(6)
1418 sleep(delay)
1419 if test_sensors: simulate_gpio_triggered(19)
1420 else: trigger_signals_passed(12)
1421 if not edit_mode:
1422 assert_sections_occupied(15)
1423 assert_sections_clear(13,14)
1424 sleep(delay)
1425 if test_sensors: simulate_gpio_triggered(19)
1426 else: trigger_signals_passed(12)
1427 if not edit_mode:
1428 assert_sections_occupied(13)
1429 assert_sections_clear(14,15)
1430 # Clear everything down again
1431 if not edit_mode: set_sections_clear(13)
1432 set_points_normal(6)
1433 return()
1435def shunt_ahead_signal_route_tests(delay:float, edit_mode:bool, test_sensors:bool=False):
1436 sleep(delay)
1437 reset_layout()
1438 if test_sensors: print("Shunt Ahead signal route tests - Shunting signal ON - simulated GPIO events")
1439 else: print ("Shunt Ahead signal route tests - Shunting signal ON - simulated GPIO events")
1440 subtest_shunt_ahead_signal_routes_1(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1441 sleep(delay)
1442 set_signals_off(6)
1443 if test_sensors: print("Shunt Ahead signal route tests - Shunting signal OFF - simulated GPIO events")
1444 else: print ("Shunt Ahead signal route tests - Shunting signal OFF - simulated GPIO events")
1445 subtest_shunt_ahead_signal_routes_1(delay, edit_mode=edit_mode, test_sensors=test_sensors)
1446 # Clear everything down
1447 set_signals_on(6)
1448 return()
1450#-----------------------------------------------------------------------------------
1451# This function tests the interlocking and override of distant signals based on the
1452# state of home signals ahead (i.e. signal is only unlocked when ALL home signals
1453# ahead are showing CLEAR. Similarly, the signal is overridden to CAUTION if any
1454# home signals ahead are showing DANGER)
1455#-----------------------------------------------------------------------------------
1457def override_on_home_signal_ahead_tests(delay:float, edit_mode:bool, automation_enabled:bool):
1458 print("Interlock/Override distant on home signal ahead tests")
1459 reset_layout()
1460 sleep(delay)
1461 print("Interlock distant on home signal ahead tests - main route")
1462 # Test the interlocking on the main route
1463 # Interlocking unchanged whether edit or run mode / automation enabled/disabled
1464 assert_signals_locked(13,19,116)
1465 assert_signals_unlocked(14,15,16,17,18,20)
1466 set_signals_off(17)
1467 sleep(delay)
1468 assert_signals_locked(13,19)
1469 assert_signals_unlocked(14,15,16,17,18,20,116)
1470 set_signals_off(116)
1471 sleep(delay)
1472 assert_signals_locked(13,19)
1473 assert_signals_unlocked(14,15,16,17,18,20,116)
1474 set_signals_off(16)
1475 sleep(delay)
1476 assert_signals_locked(13,19)
1477 assert_signals_unlocked(14,15,16,17,18,20,116)
1478 set_signals_off(15)
1479 sleep(delay)
1480 assert_signals_locked(13,19)
1481 assert_signals_unlocked(14,15,16,17,18,20,116)
1482 set_signals_off(14)
1483 sleep(delay)
1484 assert_signals_locked(19)
1485 assert_signals_unlocked(13,14,15,16,17,18,20,116)
1486 set_signals_off(13)
1487 sleep(delay)
1488 # Test the override ahead for the main route
1489 # Override on home signals ahead only enabled in RUN mode with automation ON
1490 print("Override distant on home signal ahead tests - main route")
1491 assert_signals_PROCEED(13,14,15,16,17,116)
1492 set_signals_on(17)
1493 sleep(delay)
1494 assert_signals_DANGER(17)
1495 assert_signals_PROCEED(13,14,15)
1496 if not edit_mode and automation_enabled:
1497 assert_signals_CAUTION(16,116)
1498 else:
1499 assert_signals_PROCEED(16,116)
1500 set_signals_on(16)
1501 sleep(delay)
1502 assert_signals_DANGER(16,17)
1503 assert_signals_CAUTION(116)
1504 assert_signals_PROCEED(14,15)
1505 if not edit_mode and automation_enabled:
1506 assert_signals_CAUTION(13)
1507 else:
1508 assert_signals_PROCEED(13)
1509 set_signals_on(15)
1510 sleep(delay)
1511 assert_signals_DANGER(15,16,17)
1512 assert_signals_CAUTION(116)
1513 assert_signals_PROCEED(14)
1514 if not edit_mode and automation_enabled:
1515 assert_signals_CAUTION(13)
1516 else:
1517 assert_signals_PROCEED(13)
1518 set_signals_on(14)
1519 sleep(delay)
1520 assert_signals_DANGER(14,15,16,17)
1521 assert_signals_CAUTION(116)
1522 if not edit_mode and automation_enabled:
1523 assert_signals_CAUTION(13)
1524 else:
1525 assert_signals_PROCEED(13)
1526 # Clear down the overrides
1527 set_signals_off(14,15,16)
1528 sleep(delay)
1529 assert_signals_DANGER(17)
1530 assert_signals_PROCEED(13,14,15)
1531 if not edit_mode and automation_enabled:
1532 assert_signals_CAUTION(116,16)
1533 else:
1534 assert_signals_PROCEED(116,16)
1535 set_signals_off(17)
1536 sleep(delay)
1537 assert_signals_PROCEED(13,14,15,16,17,116)
1538 # reset everything back to default
1539 set_signals_on(13,14,15,16,17,116)
1540 sleep(delay)
1541 print("Interlock distant on home signal ahead tests - diverging route")
1542 # Test the diverging line
1543 set_points_switched(7)
1544 sleep(delay)
1545 # Test the interlocking on the diverging route
1546 # Interlocking unchanged whether edit or run mode / automation enabled/disabled
1547 assert_signals_locked(13,19,116)
1548 assert_signals_unlocked(14,15,16,17,18,20)
1549 set_signals_off(20)
1550 sleep(delay)
1551 assert_signals_locked(13,116)
1552 assert_signals_unlocked(14,15,16,17,18,19,20)
1553 set_signals_off(19)
1554 sleep(delay)
1555 assert_signals_locked(13,116)
1556 assert_signals_unlocked(14,15,16,17,18,19,20)
1557 set_signals_off(18)
1558 sleep(delay)
1559 assert_signals_locked(13,116)
1560 assert_signals_unlocked(14,15,16,17,18,19,20)
1561 set_signals_off(14)
1562 sleep(delay)
1563 assert_signals_locked(116)
1564 assert_signals_unlocked(13,14,15,16,17,18,19,20)
1565 set_signals_off(13)
1566 sleep(delay)
1567 # Test the override ahead for the diverging route
1568 # Override on home signals ahead only enabled in RUN mode with automation ON
1569 print("Override distant on home signal ahead tests - diverging route")
1570 assert_signals_PROCEED(13,14,18,19,20)
1571 set_signals_on(20)
1572 sleep(delay)
1573 assert_signals_DANGER(20)
1574 assert_signals_PROCEED(13,14,18)
1575 if not edit_mode and automation_enabled:
1576 assert_signals_CAUTION(19)
1577 else:
1578 assert_signals_PROCEED(19)
1579 set_signals_on(18)
1580 sleep(delay)
1581 assert_signals_DANGER(20,18)
1582 assert_signals_PROCEED(14)
1583 if not edit_mode and automation_enabled:
1584 assert_signals_CAUTION(13,19)
1585 else:
1586 assert_signals_PROCEED(13,19)
1587 set_signals_on(14)
1588 sleep(delay)
1589 assert_signals_DANGER(14,18,20)
1590 if not edit_mode and automation_enabled:
1591 assert_signals_CAUTION(13,19)
1592 else:
1593 assert_signals_PROCEED(13,19)
1594 # Clear down the overrides
1595 set_signals_off(14,18)
1596 sleep(delay)
1597 assert_signals_DANGER(20)
1598 assert_signals_PROCEED(13,14,18)
1599 if not edit_mode and automation_enabled:
1600 assert_signals_CAUTION(19)
1601 else:
1602 assert_signals_PROCEED(19)
1603 set_signals_off(20)
1604 sleep(delay)
1605 assert_signals_PROCEED(13,14,18,19,20)
1606 # reset everything back to default
1607 set_signals_on(13,14,18,19,20)
1608 sleep(delay)
1609 set_points_normal(7)
1610 sleep(delay)
1611 return()
1613#-----------------------------------------------------------------------------------
1614# This function tests the interlocking and override of distant signals based on the
1615# state of the distant signal ahead - use case is where the same distant signal
1616# controlled by one signal box can also appear on the signal box diagram of another
1617# signal box if it is co-located (and slotted) with a home signal controlled by that box
1618#-----------------------------------------------------------------------------------
1620def override_on_distant_signal_ahead_tests(delay:float, edit_mode:bool, automation_enabled:bool):
1621 print("Override automatic secondary distant on distant signal ahead tests")
1622 reset_layout()
1623 sleep(delay)
1624 # Main route
1625 assert_signals_DANGER(23)
1626 assert_signals_CAUTION(21)
1627 sleep(delay)
1628 set_signals_off(23)
1629 assert_signals_PROCEED(23)
1630 assert_signals_CAUTION(21)
1631 sleep(delay)
1632 set_signals_on(23)
1633 sleep(delay)
1634 assert_signals_DANGER(23)
1635 assert_signals_CAUTION(21)
1636 # diverting route - secondary distant overridden by distant ahead
1637 # Override on distant aheads only active in RUN mode with automation enabled
1638 set_points_switched(8)
1639 sleep(delay)
1640 set_signals_off(23)
1641 sleep(delay)
1642 if not edit_mode and automation_enabled:
1643 assert_signals_CAUTION(23)
1644 else:
1645 assert_signals_PROCEED(23)
1646 set_signals_off(21)
1647 sleep(delay)
1648 assert_signals_PROCEED(23)
1649 set_signals_on(21,23)
1650 sleep(delay)
1651 assert_signals_DANGER(23)
1652 return()
1654#-----------------------------------------------------------------------------------
1655# This function exercises all the run layout tests. it is called for each
1656# combination of modes (Edit/Run and Automation On/Off)
1657#-----------------------------------------------------------------------------------
1659def run_layout_tests(delay:float, edit_mode:bool, automation_enabled:bool):
1660 run_interlocking_tests(delay, edit_mode=edit_mode, automation_enabled=automation_enabled)
1661 run_signal_track_occupancy_tests(delay, edit_mode=edit_mode, test_sensors=False)
1662 run_signal_track_occupancy_tests(delay, edit_mode=edit_mode, test_sensors=True)
1663 run_track_sensor_occupancy_tests(delay, edit_mode=edit_mode, test_sensors=False)
1664 run_track_sensor_occupancy_tests(delay, edit_mode=edit_mode, test_sensors=True)
1665 signals_sections_ahead_and_behind(delay, edit_mode=edit_mode, test_sensors=False)
1666 signals_sections_ahead_and_behind(delay, edit_mode=edit_mode, test_sensors=True)
1667 shunt_ahead_signal_route_tests(delay, edit_mode=edit_mode, test_sensors=False)
1668 shunt_ahead_signal_route_tests(delay, edit_mode=edit_mode, test_sensors=True)
1669 override_on_home_signal_ahead_tests(delay, edit_mode=edit_mode, automation_enabled=automation_enabled)
1670 override_on_distant_signal_ahead_tests(delay, edit_mode=edit_mode, automation_enabled=automation_enabled)
1672######################################################################################################
1674def run_all_run_layout_tests(delay:float=0.0, shutdown:bool=False):
1675 initialise_test_harness(filename="./test_run_layout.sig")
1676 # IMPORTANT - Sig file must be saved in EDIT mode with Automation ON **************
1677 # Edit/save all schematic objects to give confidence that editing doesn't break the layout configuration
1678 set_edit_mode()
1679 test_object_edit_windows.test_all_object_edit_windows(delay)
1680 # Run the tests in all mode combinations. Note that we don't toggle Automation On/Off in Edit mode as
1681 # The 'A' keypress event is disabled and the menubar 'Automation Enable/Disable' selection is inhibited
1682 print("Run Layout Tests - EDIT Mode / Automation ON **************************************************")
1683 run_layout_tests(delay, edit_mode=True, automation_enabled=True)
1684 set_run_mode()
1685 print("Run Layout Tests - RUN Mode / Automation ON ***************************************************")
1686 run_layout_tests(delay, edit_mode=False, automation_enabled=True)
1687 toggle_automation()
1688 print("Run Layout Tests - RUN Mode / Automation OFF **************************************************")
1689 run_layout_tests(delay, edit_mode=False, automation_enabled=False)
1690 toggle_mode()
1691 print("Run Layout Tests - EDIT Mode / Automation OFF *************************************************")
1692 run_layout_tests(delay, edit_mode=True, automation_enabled=False)
1693 if shutdown: report_results()
1695if __name__ == "__main__": 1695 ↛ 1696line 1695 didn't jump to line 1696, because the condition on line 1695 was never true
1696 start_application(lambda:run_all_run_layout_tests(delay=0.0, shutdown=True))
1698###############################################################################################################################