Coverage for test_automation_examples.py: 99%

701 statements  

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

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

2# System tests covering interlocking, automation and approach control functions 

3# 

4# When run as 'main' it uses the following example schematic files: 

5# "../configuration_examples/automation_colour_light_example.sig" 

6# "../configuration_examples/automation_semaphore_example.sig" 

7# 

8# Re-uses the interlocking and route setting system tests from test_interlocking_examples.py 

9#----------------------------------------------------------------------------------- 

10 

11from system_test_harness import * 

12import test_interlocking_examples 

13import test_object_edit_windows 

14 

15#----------------------------------------------------------------------------------- 

16 

17def run_initial_state_tests(semaphore=False): 

18 print("Initial state tests") 

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

20 assert_signals_route_LH1(2) 

21 assert_signals_DANGER(1,2,3,4,5,6,7,8,12,13,14,15) 

22 assert_signals_CAUTION(9,16) 

23 assert_signals_PROCEED(10,11,18,19) 

24 assert_points_unlocked(2,3,5) 

25 assert_signals_unlocked(1,3,4,5,6,7,8,12,13,15) 

26 assert_subsidaries_unlocked(1,2,3) 

27 assert_signals_locked(2,14) 

28 assert_sections_clear(1,2,3,4,5,6,7,8,9,10,11,12,13) 

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

30 assert_signals_app_cntl_clear(17,16,2,4,9,12,10,18,19,11) 

31 if semaphore: 

32 assert_signals_PROCEED(17) 

33 assert_signals_override_caution_set(9,116) 

34 assert_signals_app_cntl_set(1,3,8) 

35 else: 

36 assert_signals_PRELIM_CAUTION(17) 

37 assert_signals_app_cntl_clear(1) 

38 return() 

39 

40#----------------------------------------------------------------------------------- 

41 

42def run_colour_light_aspect_tests(): 

43 print("Colour Light Aspect tests") 

44 # Test the default state 

45 assert_signals_PROCEED(11,19,18,10) 

46 assert_signals_DANGER(8,1,2,3,4,12) 

47 assert_signals_CAUTION(16,9) 

48 assert_signals_PRELIM_CAUTION(17) 

49 # Main Route 1 

50 set_signals_off(8,1,3,4) 

51 assert_signals_PROCEED(17,16,8,1,3,4) 

52 set_signals_on(4) 

53 assert_signals_CAUTION(3) 

54 assert_signals_PRELIM_CAUTION(1) 

55 assert_signals_PROCEED(8,16,17) 

56 set_signals_on(3) 

57 assert_signals_CAUTION(1) 

58 assert_signals_PRELIM_CAUTION(8) 

59 assert_signals_PROCEED(16,17) 

60 set_signals_on(1) 

61 assert_signals_CAUTION(8) 

62 assert_signals_PRELIM_CAUTION(16) 

63 assert_signals_PROCEED(17) 

64 set_signals_on(8) 

65 assert_signals_CAUTION(16) 

66 assert_signals_PRELIM_CAUTION(17) 

67 # Main Route Loop 

68 set_fpls_off(2,3) 

69 set_points_switched(2,3) 

70 set_fpls_on(2,3) 

71 set_signals_off(8,1,2,4) 

72 assert_signals_PROCEED(2,4) 

73 assert_signals_CAUTION_APP_CNTL(1) 

74 assert_signals_FLASH_CAUTION(8) 

75 assert_signals_FLASH_PRELIM_CAUTION(16) 

76 assert_signals_PROCEED(17) 

77 set_signals_on(4) 

78 assert_signals_DANGER(4) 

79 assert_signals_CAUTION(2) 

80 assert_signals_CAUTION_APP_CNTL(1) 

81 assert_signals_FLASH_CAUTION(8) 

82 assert_signals_FLASH_PRELIM_CAUTION(16) 

83 assert_signals_PROCEED(17) 

84 set_signals_on(2) 

85 assert_signals_DANGER(2) 

86 assert_signals_CAUTION_APP_CNTL(1) 

87 assert_signals_FLASH_CAUTION(8) 

88 assert_signals_FLASH_PRELIM_CAUTION(16) 

89 assert_signals_PROCEED(17) 

90 set_signals_on(1) 

91 assert_signals_DANGER(1) 

92 assert_signals_CAUTION(8) 

93 assert_signals_PRELIM_CAUTION(16) 

94 assert_signals_PROCEED(17) 

95 set_signals_on(8) 

96 assert_signals_DANGER(8) 

97 assert_signals_CAUTION(16) 

98 assert_signals_PRELIM_CAUTION(17) 

99 # Test 'signal released' aspects 

100 set_signals_off(8,1,2,4) 

101 assert_signals_PROCEED(2,4) 

102 assert_signals_CAUTION_APP_CNTL(1) 

103 assert_signals_FLASH_CAUTION(8) 

104 assert_signals_FLASH_PRELIM_CAUTION(16) 

105 assert_signals_PROCEED(17) 

106 trigger_signals_released(1) 

107 assert_signals_PROCEED(17,16,8,1) 

108 set_signals_on(8,1,2,4) 

109 # Switch points back to main line 

110 set_fpls_off(2,3) 

111 set_points_normal(2,3) 

112 set_fpls_on(2,3) 

113 # Main Route 2 

114 assert_signals_DANGER(12) 

115 assert_signals_CAUTION(9) 

116 assert_signals_PROCEED(11,19,18,10) 

117 set_signals_off(12) 

118 assert_signals_PROCEED(12,9) 

119 set_signals_on(12) 

120 # Test everything has been returned to the default state 

121 assert_signals_PROCEED(11,19,18,10) 

122 assert_signals_DANGER(8,1,2,3,4,12) 

123 assert_signals_CAUTION(16,9) 

124 assert_signals_PRELIM_CAUTION(17) 

125 return() 

126 

127#----------------------------------------------------------------------------------- 

128 

129def run_semaphore_aspect_tests(): 

130 print("Semaphore Aspect tests") 

131 # Test the default state 

132 assert_signals_PROCEED(17,10,18,19,11) 

133 assert_signals_DANGER(8,1,2,3,4,12) 

134 assert_signals_CAUTION(16,9) 

135 # Main Route 1 

136 set_signals_off(8,1,3,4) 

137 assert_signals_PROCEED(8,1,3,4,16,17) 

138 set_signals_on(4) 

139 assert_signals_DANGER(8,1,3,4) 

140 assert_signals_CAUTION(16) 

141 assert_signals_PROCEED(17) 

142 # test approach control aspects 

143 trigger_signals_released(3) 

144 assert_signals_PROCEED(3) 

145 # Set signal to on (set it back to DANGER) 

146 set_signals_on(3) 

147 assert_signals_DANGER(8,1,3) 

148 assert_signals_CAUTION(16) 

149 assert_signals_PROCEED(17) 

150 # test approach control aspects 

151 trigger_signals_released(1) 

152 assert_signals_PROCEED(1) 

153 # Set signal to on (set it back to DANGER) 

154 set_signals_on(1) 

155 assert_signals_DANGER(8,1) 

156 assert_signals_CAUTION(16) 

157 assert_signals_PROCEED(17) 

158 # test approach control aspects 

159 trigger_signals_released(8) 

160 assert_signals_PROCEED(8) 

161 # Set signal to on (set it back to DANGER) 

162 set_signals_on(8) 

163 assert_signals_DANGER(8) 

164 assert_signals_CAUTION(16) 

165 assert_signals_PROCEED(17) 

166 # Main Route Loop 

167 # Note signal 1 is subject to approach control for LH1 

168 set_fpls_off(2,3) 

169 set_points_switched(2,3) 

170 set_fpls_on(2,3) 

171 set_signals_off(8,1,2,4) 

172 assert_signals_PROCEED(2,4,17) 

173 assert_signals_CAUTION(16) 

174 assert_signals_DANGER(8,1) 

175 set_signals_on(4) 

176 assert_signals_DANGER(8,1,2,4) 

177 assert_signals_CAUTION(16) 

178 assert_signals_PROCEED(17) 

179 # test approach control aspects 

180 trigger_signals_released(2) 

181 assert_signals_PROCEED(2) 

182 # Set signal to on (set it back to DANGER) 

183 set_signals_on(2) 

184 assert_signals_DANGER(8,1,2) 

185 assert_signals_CAUTION(16) 

186 assert_signals_PROCEED(17) 

187 # test approach control aspects 

188 trigger_signals_released(1) 

189 assert_signals_PROCEED(1) 

190 # Set signal to on (set it back to DANGER) 

191 set_signals_on(1) 

192 assert_signals_DANGER(8,1) 

193 assert_signals_CAUTION(16) 

194 assert_signals_PROCEED(17) 

195 # test approach control aspects 

196 trigger_signals_released(8) 

197 assert_signals_PROCEED(8) 

198 # Set signal to on (set it back to DANGER) 

199 set_signals_on(8) 

200 assert_signals_DANGER(8) 

201 assert_signals_CAUTION(16) 

202 assert_signals_PROCEED(17) 

203 # Switch points back to main line 

204 set_fpls_off(2,3) 

205 set_points_normal(2,3) 

206 set_fpls_on(2,3) 

207 # Main Route 2 

208 assert_signals_DANGER(12) 

209 assert_signals_CAUTION(9) 

210 assert_signals_PROCEED(11,19,18,10) 

211 set_signals_off(12) 

212 assert_signals_PROCEED(11,19,18,10,12,9) 

213 set_signals_on(12) 

214 # Test everything has been returned to the default state 

215 assert_signals_PROCEED(17,10,18,19,11) 

216 assert_signals_DANGER(8,1,2,3,4,12) 

217 assert_signals_CAUTION(16,9) 

218 return() 

219 

220#----------------------------------------------------------------------------------- 

221 

222def run_signal_override_tests(): 

223 print("Signal Override Tests") 

224 # test the default state 

225 assert_signals_override_clear(1,2,3,4,8,9,10,12,16,17,18,19) 

226 # Signal 17 

227 assert_signals_override_clear(17) 

228 set_sections_occupied(5) 

229 assert_signals_override_set(17) 

230 set_sections_clear(5) 

231 assert_signals_override_clear(17) 

232 # Signal 16 

233 assert_signals_override_clear(16) 

234 set_sections_occupied(1) 

235 assert_signals_override_set(16) 

236 set_sections_clear(1) 

237 assert_signals_override_clear(16) 

238 # Signal 8 

239 assert_signals_override_clear(8) 

240 set_sections_occupied(2) 

241 assert_signals_override_set(8) 

242 set_sections_clear(2) 

243 assert_signals_override_clear(8) 

244 # Signal 1 - main route 

245 assert_signals_override_clear(1) 

246 set_sections_occupied(3) 

247 assert_signals_override_set(1) 

248 set_sections_clear(3) 

249 assert_signals_override_clear(1) 

250 set_fpls_off(2) 

251 set_points_switched(2) 

252 set_fpls_on(2) 

253 assert_signals_override_clear(1) 

254 set_sections_occupied(12) 

255 assert_signals_override_set(1) 

256 set_sections_clear(12) 

257 assert_signals_override_clear(1) 

258 set_fpls_off(2) 

259 set_points_normal(2) 

260 set_fpls_on(2) 

261 # Signal 3 

262 assert_signals_override_clear(3) 

263 set_sections_occupied(4) 

264 assert_signals_override_set(3) 

265 set_sections_clear(4) 

266 assert_signals_override_clear(3) 

267 # Signal 2 

268 set_fpls_off(3) 

269 set_points_switched(3) 

270 set_fpls_on(3) 

271 assert_signals_override_clear(2) 

272 set_sections_occupied(4) 

273 assert_signals_override_set(2) 

274 set_sections_clear(4) 

275 assert_signals_override_clear(2) 

276 set_fpls_off(3) 

277 set_points_normal(3) 

278 set_fpls_on(3) 

279 # Signal 9 (Semaphore Signal 9 is overridden on home signals ahead) 

280 set_sections_occupied(7) 

281 assert_signals_override_set(9) 

282 set_sections_clear(7) 

283 # Signal 12 

284 assert_signals_override_clear(12) 

285 set_sections_occupied(8) 

286 assert_signals_override_set(12) 

287 set_sections_clear(8) 

288 assert_signals_override_clear(12) 

289 # Signal 10 

290 set_sections_occupied(9) 

291 assert_signals_override_set(10) 

292 set_sections_clear(9) 

293 assert_signals_override_clear(10) 

294 # Signal 18 (Semaphore Signal 18 is overridden on home signals ahead) 

295 # But signals 11 and 19 are automatic so Signal 18 override will be clear) 

296 set_sections_occupied(14) 

297 assert_signals_override_set(18) 

298 set_sections_clear(14) 

299 assert_signals_override_clear(18) 

300 # Signal 19 

301 assert_signals_override_clear(19) 

302 set_sections_occupied(15) 

303 assert_signals_override_set(19) 

304 set_sections_clear(15) 

305 assert_signals_override_clear(19) 

306 # test everything has been set back to the default state 

307 assert_signals_override_clear(1,2,3,4,8,9,10,12,16,17,18,19) 

308 return() 

309 

310#----------------------------------------------------------------------------------- 

311 

312def run_semaphore_override_ahead_tests(): 

313 print("Semaphore override ahead Tests") 

314 # test the default state 

315 assert_signals_override_caution_set(9,116) 

316 # bottom main line 

317 set_signals_off(12) 

318 assert_signals_override_caution_clear(9) 

319 set_signals_on(12) 

320 # top main line - route 1 

321 set_signals_off(8) 

322 assert_signals_override_caution_set(116) 

323 set_signals_off(1) 

324 assert_signals_override_caution_set(116) 

325 set_signals_off(3) 

326 assert_signals_override_caution_set(116) 

327 set_signals_off(4) 

328 assert_signals_override_caution_clear(116) 

329 set_signals_on(8) 

330 assert_signals_override_caution_set(116) 

331 set_signals_on(1) 

332 assert_signals_override_caution_set(116) 

333 set_signals_on(3) 

334 assert_signals_override_caution_set(116) 

335 set_signals_on(4) 

336 assert_signals_override_caution_set(116) 

337 # top main line - loop 

338 set_fpls_off(2,3) 

339 set_points_switched(2,3) 

340 set_fpls_on(2,3) 

341 set_signals_off(8) 

342 assert_signals_override_caution_set(116) 

343 set_signals_off(1) 

344 assert_signals_override_caution_set(116) 

345 set_signals_off(2) 

346 assert_signals_override_caution_set(116) 

347 set_signals_off(4) 

348 assert_signals_override_caution_set(116) 

349 # Now release signal 1 approach control 

350 trigger_signals_released(1) 

351 assert_signals_override_caution_clear(116) 

352 set_signals_on(8) 

353 assert_signals_override_caution_set(116) 

354 set_signals_on(1) 

355 assert_signals_override_caution_set(116) 

356 set_signals_on(2) 

357 assert_signals_override_caution_set(116) 

358 set_signals_on(4) 

359 assert_signals_override_caution_set(116) 

360 set_fpls_off(2,3) 

361 set_points_normal(2,3) 

362 set_fpls_on(2,3) 

363 # test everything has returned to the default state 

364 assert_signals_override_caution_set(9,116) 

365 return() 

366 

367#----------------------------------------------------------------------------------- 

368 

369def run_main_line_tests_1(delay=0): 

370 print("Main line tests 1") 

371 # This clears all the signals and sends a train from Left to right along the main line 

372 sleep(delay) 

373 set_signals_off(8,1,3,4) 

374 set_sections_occupied(10) 

375 sleep(delay) 

376 trigger_signals_passed(17) 

377 assert_sections_occupied(5) 

378 assert_sections_clear(10) 

379 sleep(delay) 

380 trigger_signals_passed(16) 

381 assert_sections_occupied(1) 

382 assert_sections_clear(5) 

383 sleep(delay) 

384 trigger_signals_passed(8) 

385 assert_sections_occupied(2) 

386 assert_sections_clear(1) 

387 sleep(delay/2) 

388 trigger_signals_released(1) 

389 sleep(delay/2) 

390 trigger_signals_passed(1) 

391 assert_sections_occupied(3) 

392 assert_sections_clear(2) 

393 sleep(delay/2) 

394 trigger_signals_passed(15) 

395 sleep(delay/2) 

396 trigger_signals_passed(3) 

397 assert_sections_occupied(4) 

398 assert_sections_clear(3) 

399 sleep(delay/2) 

400 trigger_signals_passed(13) 

401 sleep(delay/2) 

402 trigger_signals_passed(4) 

403 assert_sections_clear(4) 

404 # Wait for the timed signal sequences to finish 

405 sleep(5.0) 

406 # Revert the signals to danger 

407 set_signals_on(8,1,3,4) 

408 return() 

409 

410#----------------------------------------------------------------------------------- 

411 

412def run_main_line_tests_2(delay=0): 

413 print("Main line tests 2") 

414 # This clears all the signals and sends a train from right to left along the main line 

415 sleep(delay) 

416 set_signals_off(12) 

417 set_sections_occupied(6) 

418 sleep(delay) 

419 trigger_signals_passed(9) 

420 assert_sections_occupied(7) 

421 assert_sections_clear(6) 

422 sleep(delay) 

423 trigger_signals_passed(12) 

424 assert_sections_occupied(8) 

425 assert_sections_clear(7) 

426 sleep(delay/2) 

427 trigger_signals_passed(14) 

428 sleep(delay/2) 

429 trigger_signals_passed(10) 

430 assert_sections_occupied(9) 

431 assert_sections_clear(8) 

432 sleep(delay) 

433 trigger_signals_passed(18) 

434 assert_sections_occupied(14) 

435 assert_sections_clear(15) 

436 sleep(delay) 

437 trigger_signals_passed(19) 

438 assert_sections_occupied(15) 

439 assert_sections_clear(14) 

440 sleep(delay) 

441 trigger_signals_passed(11) 

442 assert_sections_clear(15) 

443 # Wait for the timed signal sequences to finish 

444 sleep(5.0) 

445 # revert the signal to danger 

446 set_signals_on(12) 

447 return() 

448 

449#----------------------------------------------------------------------------------- 

450 

451def run_loop_line_tests(delay=0): 

452 print("Loop line tests") 

453 # This clears all the signals and sends a train from right to left via the loop line 

454 # Note the loop line is subject to approach control (controlled via signal 1) 

455 sleep(delay) 

456 # Change point 1 3 for the new route 

457 set_fpls_off(2,3) 

458 set_points_switched(2,3) 

459 set_fpls_on(2,3) 

460 # Clear the signals for the loop line 

461 sleep(delay) 

462 set_signals_off(8,1,2,4) 

463 # Now feed in the first train 

464 sleep(delay) 

465 set_sections_occupied(10) 

466 sleep(delay) 

467 trigger_signals_passed(17) 

468 assert_sections_occupied(5) 

469 assert_sections_clear(10) 

470 sleep(delay) 

471 trigger_signals_passed(16) 

472 assert_sections_occupied(1) 

473 assert_sections_clear(5) 

474 sleep(delay) 

475 trigger_signals_released(8) 

476 sleep(delay) 

477 trigger_signals_passed(8) 

478 assert_sections_occupied(2) 

479 assert_sections_clear(1) 

480 sleep(delay/2) 

481 assert_signals_app_cntl_set(1) 

482 trigger_signals_released(1) 

483 assert_signals_app_cntl_clear(1) 

484 sleep(delay/2) 

485 trigger_signals_passed(1) 

486 assert_signals_app_cntl_set(1) 

487 assert_sections_occupied(12) 

488 assert_sections_clear(2) 

489 sleep(delay/2) 

490 trigger_signals_passed(6) 

491 sleep(delay/2) 

492 trigger_signals_passed(2) 

493 assert_sections_occupied(4) 

494 assert_sections_clear(12) 

495 sleep(delay/2) 

496 trigger_signals_passed(13) 

497 sleep(delay/2) 

498 trigger_signals_passed(4) 

499 assert_sections_clear(4) 

500 # Wait for the timed signal sequences to finish 

501 sleep(5.0) 

502 # Revert the signals to danger 

503 set_signals_on(8,1,2,4) 

504 # Revert the points 

505 sleep(delay) 

506 set_fpls_off(2,3) 

507 set_points_normal(2,3) 

508 set_fpls_on(2,3) 

509 return() 

510 

511#----------------------------------------------------------------------------------- 

512 

513def run_main_line_approach_control_tests(delay=0): 

514 print("Main line approach control tests") 

515 # This clears all the signals apart from the last Home signal and sends a train from 

516 # Left to right along the main line, using approach control to clear each signal 

517 sleep(delay) 

518 set_signals_off(8,1,3) 

519 assert_signals_app_cntl_set(8,1,3) 

520 assert_signals_DANGER(8,1,3,4) 

521 assert_signals_CAUTION(16) 

522 assert_signals_PROCEED(17) 

523 set_sections_occupied(10) 

524 sleep(delay) 

525 trigger_signals_passed(17) 

526 sleep(delay) 

527 trigger_signals_passed(16) 

528 sleep(delay/2) 

529 trigger_signals_released(8) 

530 assert_signals_app_cntl_clear(8) 

531 assert_signals_PROCEED(8) 

532 sleep(delay/2) 

533 trigger_signals_passed(8) 

534 assert_signals_app_cntl_set(8) 

535 assert_signals_DANGER(8) 

536 sleep(delay/2) 

537 trigger_signals_released(1) 

538 assert_signals_app_cntl_clear(1) 

539 assert_signals_PROCEED(1) 

540 sleep(delay/2) 

541 trigger_signals_passed(1) 

542 assert_signals_app_cntl_set(1) 

543 assert_signals_DANGER(1) 

544 sleep(delay/2) 

545 trigger_signals_released(3) 

546 assert_signals_app_cntl_clear(3) 

547 assert_signals_PROCEED(3) 

548 sleep(delay/2) 

549 trigger_signals_passed(3) 

550 assert_signals_app_cntl_set(3) 

551 assert_signals_DANGER(3) 

552 sleep(delay/2) 

553 set_signals_off(4) 

554 trigger_signals_passed(4) 

555 # Wait for the timed signal sequences to finish 

556 sleep(5.0) 

557 # Revert the signals to danger 

558 set_signals_on(8,1,3,4) 

559 return() 

560 

561#----------------------------------------------------------------------------------- 

562 

563def run_loop_line_approach_control_tests(delay=0): 

564 print("Loop line approach control tests") 

565 # This clears all the signals apart from the last Home signal and sends a train from 

566 # Left to right along the loop line, using approach control to clear each signal 

567 sleep(delay) 

568 # Change points 2 3 for the new route 

569 set_fpls_off(2,3) 

570 set_points_switched(2,3) 

571 set_fpls_on(2,3) 

572 sleep(delay) 

573 set_signals_off(8,1,2) 

574 assert_signals_app_cntl_set(8,1,2) 

575 assert_signals_DANGER(8,1,2,4) 

576 assert_signals_CAUTION(16) 

577 assert_signals_PROCEED(17) 

578 set_sections_occupied(10) 

579 sleep(delay) 

580 trigger_signals_passed(17) 

581 sleep(delay) 

582 trigger_signals_passed(16) 

583 sleep(delay/2) 

584 trigger_signals_released(8) 

585 assert_signals_app_cntl_clear(8) 

586 assert_signals_PROCEED(8) 

587 sleep(delay/2) 

588 trigger_signals_passed(8) 

589 assert_signals_app_cntl_set(8) 

590 assert_signals_DANGER(8) 

591 sleep(delay/2) 

592 trigger_signals_released(1) 

593 assert_signals_app_cntl_clear(1) 

594 assert_signals_PROCEED(1) 

595 sleep(delay/2) 

596 trigger_signals_passed(1) 

597 assert_signals_app_cntl_set(1) 

598 assert_signals_DANGER(1) 

599 sleep(delay/2) 

600 trigger_signals_released(2) 

601 assert_signals_app_cntl_clear(2) 

602 assert_signals_PROCEED(2) 

603 sleep(delay/2) 

604 trigger_signals_passed(2) 

605 assert_signals_app_cntl_set(2) 

606 assert_signals_DANGER(2) 

607 sleep(delay/2) 

608 set_signals_off(4) 

609 trigger_signals_passed(4) 

610 # Wait for the timed signal sequences to finish 

611 sleep(5.0) 

612 # Revert the signals to danger 

613 set_signals_on(8,1,2,4) 

614 # Revert the points 

615 sleep(delay) 

616 set_fpls_off(2,3) 

617 set_points_normal(2,3) 

618 set_fpls_on(2,3) 

619 return() 

620 

621#----------------------------------------------------------------------------------- 

622 

623def run_shunting_tests(delay=0): 

624 print("Shunting tests") 

625 set_sections_occupied(4) 

626 sleep(delay) 

627 # Test the crossover first 

628 set_points_switched(5) 

629 sleep(delay) 

630 set_signals_off(13) 

631 sleep(delay) 

632 trigger_signals_passed(13) 

633 assert_sections_occupied(8) 

634 assert_sections_clear(4) 

635 sleep(delay/2) 

636 trigger_signals_passed(14) 

637 sleep(delay) 

638 # Now go back the other way 

639 set_signals_on(13) 

640 set_signals_off(14) 

641 sleep(delay) 

642 trigger_signals_passed(14) 

643 assert_sections_occupied(4) 

644 assert_sections_clear(8) 

645 sleep(delay/2) 

646 trigger_signals_passed(13) 

647 sleep(delay/2) 

648 set_signals_on(14) 

649 # Revert the points 

650 set_points_normal(5) 

651 sleep(delay) 

652 # Now reverse down the main line 

653 set_signals_off(13,15) 

654 sleep(delay) 

655 trigger_signals_passed(13) 

656 assert_sections_occupied(3) 

657 assert_sections_clear(4) 

658 sleep(delay/2) 

659 trigger_signals_passed(3) 

660 sleep(delay/2) 

661 trigger_signals_passed(15) 

662 assert_sections_occupied(2) 

663 assert_sections_clear(3) 

664 sleep(delay/2) 

665 trigger_signals_passed(1) 

666 sleep(delay) 

667 set_signals_on(13,15) 

668 # Move into the loop RH siding 

669 sleep(delay) 

670 set_fpls_off(2) 

671 set_points_switched(2) 

672 set_fpls_on(2) 

673 sleep(delay) 

674 set_subsidaries_off(1,2) 

675 sleep(delay) 

676 trigger_signals_passed(1) 

677 assert_sections_occupied(12) 

678 assert_sections_clear(2) 

679 sleep(delay/2) 

680 trigger_signals_passed(6) 

681 sleep(delay/2) 

682 trigger_signals_passed(2) 

683 assert_sections_occupied(13) 

684 assert_sections_clear(12) 

685 sleep(delay/2) 

686 trigger_signals_passed(7) 

687 sleep(delay) 

688 set_subsidaries_on(1,2) 

689 sleep(delay) 

690 # Set the route for the LH siding 

691 set_fpls_off(2) 

692 set_points_normal(2) 

693 set_fpls_on(2) 

694 sleep(delay) 

695 set_signals_off(7,6) 

696 sleep(delay) 

697 trigger_signals_passed(7) 

698 assert_sections_occupied(12) 

699 assert_sections_clear(13) 

700 sleep(delay/2) 

701 trigger_signals_passed(2) 

702 sleep(delay/2) 

703 trigger_signals_passed(6) 

704 assert_sections_occupied(11) 

705 assert_sections_clear(12) 

706 sleep(delay/2) 

707 trigger_signals_passed(5) 

708 sleep(delay) 

709 set_signals_on(7,6) 

710 # Now move out of the siding back onto the loop 

711 sleep(delay) 

712 set_signals_off(5) 

713 sleep(delay) 

714 trigger_signals_passed(5) 

715 assert_sections_occupied(12) 

716 assert_sections_clear(11) 

717 sleep(delay/2) 

718 trigger_signals_passed(6) 

719 sleep(delay) 

720 set_signals_on(5) 

721 sleep(delay) 

722 # Reverse back onto the main line 

723 set_fpls_off(2) 

724 set_points_switched(2) 

725 set_fpls_on(2) 

726 sleep(delay) 

727 set_signals_off(6) 

728 sleep(delay) 

729 trigger_signals_passed(6) 

730 assert_sections_occupied(2) 

731 assert_sections_clear(12) 

732 sleep(delay/2) 

733 trigger_signals_passed(1) 

734 sleep(delay) 

735 set_signals_on(6) 

736 sleep(delay) 

737 set_fpls_off(2) 

738 set_points_normal(2) 

739 set_fpls_on(2) 

740 sleep(delay) 

741 # Now go forwards on the main line 

742 set_subsidaries_off(1,3) 

743 sleep(delay) 

744 trigger_signals_passed(1) 

745 assert_sections_occupied(3) 

746 assert_sections_clear(2) 

747 sleep(delay/2) 

748 trigger_signals_passed(15) 

749 sleep(delay/2) 

750 trigger_signals_passed(3) 

751 assert_sections_occupied(4) 

752 assert_sections_clear(3) 

753 sleep(delay/2) 

754 trigger_signals_passed(13) 

755 sleep(delay) 

756 set_subsidaries_on(1,3) 

757 sleep(delay) 

758 # Reverse back into the loop 

759 set_fpls_off(3) 

760 set_points_switched(3) 

761 set_fpls_on(3) 

762 sleep(delay) 

763 set_signals_off(13) 

764 sleep(delay) 

765 trigger_signals_passed(13) 

766 assert_sections_occupied(12) 

767 assert_sections_clear(4) 

768 sleep(delay/2) 

769 trigger_signals_passed(2) 

770 sleep(delay) 

771 set_signals_on(13) 

772 sleep(delay) 

773 set_subsidaries_off(2) 

774 sleep(delay) 

775 trigger_signals_passed(2) 

776 assert_sections_occupied(4) 

777 assert_sections_clear(12) 

778 sleep(delay/2) 

779 trigger_signals_passed(13) 

780 sleep(delay) 

781 set_subsidaries_on(2) 

782 sleep(delay) 

783 # Revert the points to normal 

784 set_fpls_off(3) 

785 set_points_normal(3) 

786 set_fpls_on(3) 

787 sleep(delay) 

788 # Finally clear the track occupancy 

789 set_sections_clear(4) 

790 return() 

791 

792#----------------------------------------------------------------------------------- 

793 

794def run_all_automation_example_tests(delay:float=0.0, shutdown:bool=False): 

795 initialise_test_harness(filename="../configuration_examples/automation_colour_light_example.sig") 

796 # Edit/save all schematic objects to give confidence that editing doesn't break the layout configuration 

797 set_edit_mode() 

798 test_object_edit_windows.test_all_object_edit_windows(delay) 

799 set_run_mode() 

800 reset_layout() 

801 run_initial_state_tests() 

802 run_colour_light_aspect_tests() 

803 test_interlocking_examples.run_signal_route_tests() 

804 test_interlocking_examples.run_point_interlocking_tests() 

805 test_interlocking_examples.run_signal_interlocking_tests() 

806 run_signal_override_tests() 

807 run_main_line_tests_1(delay) 

808 run_main_line_tests_2(delay) 

809 run_loop_line_tests(delay) 

810 run_shunting_tests(delay) 

811 initialise_test_harness(filename="../configuration_examples/automation_semaphore_example.sig") 

812 # Edit/save all schematic objects to give confidence that editing doesn't break the layout configuration 

813 set_edit_mode() 

814 test_object_edit_windows.test_all_object_edit_windows(delay) 

815 set_run_mode() 

816 reset_layout() 

817 run_initial_state_tests(semaphore=True) 

818 run_semaphore_aspect_tests() 

819 test_interlocking_examples.run_signal_route_tests() 

820 test_interlocking_examples.run_point_interlocking_tests() 

821 test_interlocking_examples.run_signal_interlocking_tests() 

822 run_signal_override_tests() 

823 run_semaphore_override_ahead_tests() 

824 run_main_line_tests_1(delay) 

825 run_main_line_tests_2(delay) 

826 run_loop_line_tests(delay) 

827 run_shunting_tests(delay) 

828 run_main_line_approach_control_tests(delay) 

829 run_loop_line_approach_control_tests(delay) 

830 if shutdown: report_results() 

831 

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

833 start_application(lambda:run_all_automation_example_tests(delay=0.0, shutdown=True)) 

834 

835###################################################################################################### 

836