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

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#----------------------------------------------------------------------------------- 

25 

26from system_test_harness import * 

27import test_object_edit_windows 

28 

29#----------------------------------------------------------------------------------- 

30# This teats the basic interlocking of signals, points, sections and block instruments 

31#----------------------------------------------------------------------------------- 

32 

33def run_interlocking_tests(delay:float, edit_mode:bool, automation_enabled:bool): 

34 reset_layout() 

35 sleep(delay) 

36 

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) 

171 

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) 

310 

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) 

449 

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) 

597 

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() 

737 

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#----------------------------------------------------------------------------------- 

744 

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 

768 

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) 

779 

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) 

795 

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) 

817 

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) 

839 

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) 

862 

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) 

883 

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() 

944 

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#----------------------------------------------------------------------------------- 

950 

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 

970 

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) 

978 

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) 

1015 

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) 

1067 

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() 

1106 

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#----------------------------------------------------------------------------------- 

1112 

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) 

1169 

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() 

1215 

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#----------------------------------------------------------------------------------- 

1220 

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() 

1317 

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#----------------------------------------------------------------------------------- 

1327 

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() 

1369 

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#----------------------------------------------------------------------------------- 

1378 

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() 

1393 

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#----------------------------------------------------------------------------------- 

1398 

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() 

1434 

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() 

1449 

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#----------------------------------------------------------------------------------- 

1456 

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() 

1612 

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#----------------------------------------------------------------------------------- 

1619 

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() 

1653 

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#----------------------------------------------------------------------------------- 

1658 

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) 

1671 

1672###################################################################################################### 

1673 

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() 

1694 

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)) 

1697 

1698############################################################################################################################### 

1699