Coverage for /scratch/builds/bob/bob.med.tb/miniconda/conda-bld/bob.med.tb_1637571489937/_test_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeho/lib/python3.8/site-packages/bob/med/tb/test/test_mc_ch.py: 24%

1#!/usr/bin/env python 

2# coding=utf-8 

3 

4 

5"""Tests for the aggregated Montgomery-Shenzhen dataset""" 

6 

7import pytest 

8from ..configs.datasets.mc_ch import default as mc_ch 

9from ..configs.datasets.montgomery import default as mc 

10from ..configs.datasets.shenzhen import default as ch 

11from ..configs.datasets.mc_ch import fold_0 as mc_ch_f0 

12from ..configs.datasets.montgomery import fold_0 as mc_f0 

13from ..configs.datasets.shenzhen import fold_0 as ch_f0 

14from ..configs.datasets.mc_ch import fold_1 as mc_ch_f1 

15from ..configs.datasets.montgomery import fold_1 as mc_f1 

16from ..configs.datasets.shenzhen import fold_1 as ch_f1 

17from ..configs.datasets.mc_ch import fold_2 as mc_ch_f2 

18from ..configs.datasets.montgomery import fold_2 as mc_f2 

19from ..configs.datasets.shenzhen import fold_2 as ch_f2 

20from ..configs.datasets.mc_ch import fold_3 as mc_ch_f3 

21from ..configs.datasets.montgomery import fold_3 as mc_f3 

22from ..configs.datasets.shenzhen import fold_3 as ch_f3 

23from ..configs.datasets.mc_ch import fold_4 as mc_ch_f4 

24from ..configs.datasets.montgomery import fold_4 as mc_f4 

25from ..configs.datasets.shenzhen import fold_4 as ch_f4 

26from ..configs.datasets.mc_ch import fold_5 as mc_ch_f5 

27from ..configs.datasets.montgomery import fold_5 as mc_f5 

28from ..configs.datasets.shenzhen import fold_5 as ch_f5 

29from ..configs.datasets.mc_ch import fold_6 as mc_ch_f6 

30from ..configs.datasets.montgomery import fold_6 as mc_f6 

31from ..configs.datasets.shenzhen import fold_6 as ch_f6 

32from ..configs.datasets.mc_ch import fold_7 as mc_ch_f7 

33from ..configs.datasets.montgomery import fold_7 as mc_f7 

34from ..configs.datasets.shenzhen import fold_7 as ch_f7 

35from ..configs.datasets.mc_ch import fold_8 as mc_ch_f8 

36from ..configs.datasets.montgomery import fold_8 as mc_f8 

37from ..configs.datasets.shenzhen import fold_8 as ch_f8 

38from ..configs.datasets.mc_ch import fold_9 as mc_ch_f9 

39from ..configs.datasets.montgomery import fold_9 as mc_f9 

40from ..configs.datasets.shenzhen import fold_9 as ch_f9 

41from ..configs.datasets.mc_ch import fold_0_rgb as mc_ch_f0_rgb 

42from ..configs.datasets.montgomery import fold_0_rgb as mc_f0_rgb 

43from ..configs.datasets.shenzhen import fold_0_rgb as ch_f0_rgb 

44from ..configs.datasets.mc_ch import fold_1_rgb as mc_ch_f1_rgb 

45from ..configs.datasets.montgomery import fold_1_rgb as mc_f1_rgb 

46from ..configs.datasets.shenzhen import fold_1_rgb as ch_f1_rgb 

47from ..configs.datasets.mc_ch import fold_2_rgb as mc_ch_f2_rgb 

48from ..configs.datasets.montgomery import fold_2_rgb as mc_f2_rgb 

49from ..configs.datasets.shenzhen import fold_2_rgb as ch_f2_rgb 

50from ..configs.datasets.mc_ch import fold_3_rgb as mc_ch_f3_rgb 

51from ..configs.datasets.montgomery import fold_3_rgb as mc_f3_rgb 

52from ..configs.datasets.shenzhen import fold_3_rgb as ch_f3_rgb 

53from ..configs.datasets.mc_ch import fold_4_rgb as mc_ch_f4_rgb 

54from ..configs.datasets.montgomery import fold_4_rgb as mc_f4_rgb 

55from ..configs.datasets.shenzhen import fold_4_rgb as ch_f4_rgb 

56from ..configs.datasets.mc_ch import fold_5_rgb as mc_ch_f5_rgb 

57from ..configs.datasets.montgomery import fold_5_rgb as mc_f5_rgb 

58from ..configs.datasets.shenzhen import fold_5_rgb as ch_f5_rgb 

59from ..configs.datasets.mc_ch import fold_6_rgb as mc_ch_f6_rgb 

60from ..configs.datasets.montgomery import fold_6_rgb as mc_f6_rgb 

61from ..configs.datasets.shenzhen import fold_6_rgb as ch_f6_rgb 

62from ..configs.datasets.mc_ch import fold_7_rgb as mc_ch_f7_rgb 

63from ..configs.datasets.montgomery import fold_7_rgb as mc_f7_rgb 

64from ..configs.datasets.shenzhen import fold_7_rgb as ch_f7_rgb 

65from ..configs.datasets.mc_ch import fold_8_rgb as mc_ch_f8_rgb 

66from ..configs.datasets.montgomery import fold_8_rgb as mc_f8_rgb 

67from ..configs.datasets.shenzhen import fold_8_rgb as ch_f8_rgb 

68from ..configs.datasets.mc_ch import fold_9_rgb as mc_ch_f9_rgb 

69from ..configs.datasets.montgomery import fold_9_rgb as mc_f9_rgb 

70from ..configs.datasets.shenzhen import fold_9_rgb as ch_f9_rgb 

71 

72 

73@pytest.mark.skip_if_rc_var_not_set("bob.med.tb.montgomery.datadir") 

74@pytest.mark.skip_if_rc_var_not_set("bob.med.tb.shenzhen.datadir") 

75def test_dataset_consistency(): 

76 

77 # Default protocol 

78 mc_ch_dataset = mc_ch.dataset 

79 assert isinstance(mc_ch_dataset, dict) 

80 

81 mc_dataset = mc.dataset 

82 ch_dataset = ch.dataset 

83 

84 assert "train" in mc_ch_dataset 

85 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

86 ch_dataset["train"] 

87 ) 

88 

89 assert "validation" in mc_ch_dataset 

90 assert len(mc_ch_dataset["validation"]) == len( 

91 mc_dataset["validation"] 

92 ) + len(ch_dataset["validation"]) 

93 

94 assert "test" in mc_ch_dataset 

95 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

96 ch_dataset["test"] 

97 ) 

98 

99 # f0 protocol 

100 mc_ch_dataset = mc_ch_f0.dataset 

101 assert isinstance(mc_ch_dataset, dict) 

102 

103 mc_dataset = mc_f0.dataset 

104 ch_dataset = ch_f0.dataset 

105 

106 assert "train" in mc_ch_dataset 

107 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

108 ch_dataset["train"] 

109 ) 

110 

111 assert "validation" in mc_ch_dataset 

112 assert len(mc_ch_dataset["validation"]) == len( 

113 mc_dataset["validation"] 

114 ) + len(ch_dataset["validation"]) 

115 

116 assert "test" in mc_ch_dataset 

117 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

118 ch_dataset["test"] 

119 ) 

120 

121 # f1 protocol 

122 mc_ch_dataset = mc_ch_f1.dataset 

123 assert isinstance(mc_ch_dataset, dict) 

124 

125 mc_dataset = mc_f1.dataset 

126 ch_dataset = ch_f1.dataset 

127 

128 assert "train" in mc_ch_dataset 

129 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

130 ch_dataset["train"] 

131 ) 

132 

133 assert "validation" in mc_ch_dataset 

134 assert len(mc_ch_dataset["validation"]) == len( 

135 mc_dataset["validation"] 

136 ) + len(ch_dataset["validation"]) 

137 

138 assert "test" in mc_ch_dataset 

139 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

140 ch_dataset["test"] 

141 ) 

142 

143 # f2 protocol 

144 mc_ch_dataset = mc_ch_f2.dataset 

145 assert isinstance(mc_ch_dataset, dict) 

146 

147 mc_dataset = mc_f2.dataset 

148 ch_dataset = ch_f2.dataset 

149 

150 assert "train" in mc_ch_dataset 

151 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

152 ch_dataset["train"] 

153 ) 

154 

155 assert "validation" in mc_ch_dataset 

156 assert len(mc_ch_dataset["validation"]) == len( 

157 mc_dataset["validation"] 

158 ) + len(ch_dataset["validation"]) 

159 

160 assert "test" in mc_ch_dataset 

161 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

162 ch_dataset["test"] 

163 ) 

164 

165 # f3 protocol 

166 mc_ch_dataset = mc_ch_f3.dataset 

167 assert isinstance(mc_ch_dataset, dict) 

168 

169 mc_dataset = mc_f3.dataset 

170 ch_dataset = ch_f3.dataset 

171 

172 assert "train" in mc_ch_dataset 

173 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

174 ch_dataset["train"] 

175 ) 

176 

177 assert "validation" in mc_ch_dataset 

178 assert len(mc_ch_dataset["validation"]) == len( 

179 mc_dataset["validation"] 

180 ) + len(ch_dataset["validation"]) 

181 

182 assert "test" in mc_ch_dataset 

183 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

184 ch_dataset["test"] 

185 ) 

186 

187 # f4 protocol 

188 mc_ch_dataset = mc_ch_f4.dataset 

189 assert isinstance(mc_ch_dataset, dict) 

190 

191 mc_dataset = mc_f4.dataset 

192 ch_dataset = ch_f4.dataset 

193 

194 assert "train" in mc_ch_dataset 

195 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

196 ch_dataset["train"] 

197 ) 

198 

199 assert "validation" in mc_ch_dataset 

200 assert len(mc_ch_dataset["validation"]) == len( 

201 mc_dataset["validation"] 

202 ) + len(ch_dataset["validation"]) 

203 

204 assert "test" in mc_ch_dataset 

205 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

206 ch_dataset["test"] 

207 ) 

208 

209 # f5 protocol 

210 mc_ch_dataset = mc_ch_f5.dataset 

211 assert isinstance(mc_ch_dataset, dict) 

212 

213 mc_dataset = mc_f5.dataset 

214 ch_dataset = ch_f5.dataset 

215 

216 assert "train" in mc_ch_dataset 

217 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

218 ch_dataset["train"] 

219 ) 

220 

221 assert "validation" in mc_ch_dataset 

222 assert len(mc_ch_dataset["validation"]) == len( 

223 mc_dataset["validation"] 

224 ) + len(ch_dataset["validation"]) 

225 

226 assert "test" in mc_ch_dataset 

227 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

228 ch_dataset["test"] 

229 ) 

230 

231 # f6 protocol 

232 mc_ch_dataset = mc_ch_f6.dataset 

233 assert isinstance(mc_ch_dataset, dict) 

234 

235 mc_dataset = mc_f6.dataset 

236 ch_dataset = ch_f6.dataset 

237 

238 assert "train" in mc_ch_dataset 

239 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

240 ch_dataset["train"] 

241 ) 

242 

243 assert "validation" in mc_ch_dataset 

244 assert len(mc_ch_dataset["validation"]) == len( 

245 mc_dataset["validation"] 

246 ) + len(ch_dataset["validation"]) 

247 

248 assert "test" in mc_ch_dataset 

249 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

250 ch_dataset["test"] 

251 ) 

252 

253 # f7 protocol 

254 mc_ch_dataset = mc_ch_f7.dataset 

255 assert isinstance(mc_ch_dataset, dict) 

256 

257 mc_dataset = mc_f7.dataset 

258 ch_dataset = ch_f7.dataset 

259 

260 assert "train" in mc_ch_dataset 

261 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

262 ch_dataset["train"] 

263 ) 

264 

265 assert "validation" in mc_ch_dataset 

266 assert len(mc_ch_dataset["validation"]) == len( 

267 mc_dataset["validation"] 

268 ) + len(ch_dataset["validation"]) 

269 

270 assert "test" in mc_ch_dataset 

271 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

272 ch_dataset["test"] 

273 ) 

274 

275 # f8 protocol 

276 mc_ch_dataset = mc_ch_f8.dataset 

277 assert isinstance(mc_ch_dataset, dict) 

278 

279 mc_dataset = mc_f8.dataset 

280 ch_dataset = ch_f8.dataset 

281 

282 assert "train" in mc_ch_dataset 

283 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

284 ch_dataset["train"] 

285 ) 

286 

287 assert "validation" in mc_ch_dataset 

288 assert len(mc_ch_dataset["validation"]) == len( 

289 mc_dataset["validation"] 

290 ) + len(ch_dataset["validation"]) 

291 

292 assert "test" in mc_ch_dataset 

293 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

294 ch_dataset["test"] 

295 ) 

296 

297 # f9 protocol 

298 mc_ch_dataset = mc_ch_f9.dataset 

299 assert isinstance(mc_ch_dataset, dict) 

300 

301 mc_dataset = mc_f9.dataset 

302 ch_dataset = ch_f9.dataset 

303 

304 assert "train" in mc_ch_dataset 

305 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

306 ch_dataset["train"] 

307 ) 

308 

309 assert "validation" in mc_ch_dataset 

310 assert len(mc_ch_dataset["validation"]) == len( 

311 mc_dataset["validation"] 

312 ) + len(ch_dataset["validation"]) 

313 

314 assert "test" in mc_ch_dataset 

315 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

316 ch_dataset["test"] 

317 ) 

318 

319 # f0 protocol RGB 

320 mc_ch_dataset = mc_ch_f0_rgb.dataset 

321 assert isinstance(mc_ch_dataset, dict) 

322 

323 mc_dataset = mc_f0_rgb.dataset 

324 ch_dataset = ch_f0_rgb.dataset 

325 

326 assert "train" in mc_ch_dataset 

327 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

328 ch_dataset["train"] 

329 ) 

330 

331 assert "validation" in mc_ch_dataset 

332 assert len(mc_ch_dataset["validation"]) == len( 

333 mc_dataset["validation"] 

334 ) + len(ch_dataset["validation"]) 

335 

336 assert "test" in mc_ch_dataset 

337 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

338 ch_dataset["test"] 

339 ) 

340 

341 # f1 protocol RGB 

342 mc_ch_dataset = mc_ch_f1_rgb.dataset 

343 assert isinstance(mc_ch_dataset, dict) 

344 

345 mc_dataset = mc_f1_rgb.dataset 

346 ch_dataset = ch_f1_rgb.dataset 

347 

348 assert "train" in mc_ch_dataset 

349 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

350 ch_dataset["train"] 

351 ) 

352 

353 assert "validation" in mc_ch_dataset 

354 assert len(mc_ch_dataset["validation"]) == len( 

355 mc_dataset["validation"] 

356 ) + len(ch_dataset["validation"]) 

357 

358 assert "test" in mc_ch_dataset 

359 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

360 ch_dataset["test"] 

361 ) 

362 

363 # f2 protocol RGB 

364 mc_ch_dataset = mc_ch_f2_rgb.dataset 

365 assert isinstance(mc_ch_dataset, dict) 

366 

367 mc_dataset = mc_f2_rgb.dataset 

368 ch_dataset = ch_f2_rgb.dataset 

369 

370 assert "train" in mc_ch_dataset 

371 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

372 ch_dataset["train"] 

373 ) 

374 

375 assert "validation" in mc_ch_dataset 

376 assert len(mc_ch_dataset["validation"]) == len( 

377 mc_dataset["validation"] 

378 ) + len(ch_dataset["validation"]) 

379 

380 assert "test" in mc_ch_dataset 

381 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

382 ch_dataset["test"] 

383 ) 

384 

385 # f3 protocol RGB 

386 mc_ch_dataset = mc_ch_f3_rgb.dataset 

387 assert isinstance(mc_ch_dataset, dict) 

388 

389 mc_dataset = mc_f3_rgb.dataset 

390 ch_dataset = ch_f3_rgb.dataset 

391 

392 assert "train" in mc_ch_dataset 

393 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

394 ch_dataset["train"] 

395 ) 

396 

397 assert "validation" in mc_ch_dataset 

398 assert len(mc_ch_dataset["validation"]) == len( 

399 mc_dataset["validation"] 

400 ) + len(ch_dataset["validation"]) 

401 

402 assert "test" in mc_ch_dataset 

403 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

404 ch_dataset["test"] 

405 ) 

406 

407 # f4 protocol RGB 

408 mc_ch_dataset = mc_ch_f4_rgb.dataset 

409 assert isinstance(mc_ch_dataset, dict) 

410 

411 mc_dataset = mc_f4_rgb.dataset 

412 ch_dataset = ch_f4_rgb.dataset 

413 

414 assert "train" in mc_ch_dataset 

415 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

416 ch_dataset["train"] 

417 ) 

418 

419 assert "validation" in mc_ch_dataset 

420 assert len(mc_ch_dataset["validation"]) == len( 

421 mc_dataset["validation"] 

422 ) + len(ch_dataset["validation"]) 

423 

424 assert "test" in mc_ch_dataset 

425 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

426 ch_dataset["test"] 

427 ) 

428 

429 # f5 protocol RGB 

430 mc_ch_dataset = mc_ch_f5_rgb.dataset 

431 assert isinstance(mc_ch_dataset, dict) 

432 

433 mc_dataset = mc_f5_rgb.dataset 

434 ch_dataset = ch_f5_rgb.dataset 

435 

436 assert "train" in mc_ch_dataset 

437 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

438 ch_dataset["train"] 

439 ) 

440 

441 assert "validation" in mc_ch_dataset 

442 assert len(mc_ch_dataset["validation"]) == len( 

443 mc_dataset["validation"] 

444 ) + len(ch_dataset["validation"]) 

445 

446 assert "test" in mc_ch_dataset 

447 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

448 ch_dataset["test"] 

449 ) 

450 

451 # f6 protocol RGB 

452 mc_ch_dataset = mc_ch_f6_rgb.dataset 

453 assert isinstance(mc_ch_dataset, dict) 

454 

455 mc_dataset = mc_f6_rgb.dataset 

456 ch_dataset = ch_f6_rgb.dataset 

457 

458 assert "train" in mc_ch_dataset 

459 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

460 ch_dataset["train"] 

461 ) 

462 

463 assert "validation" in mc_ch_dataset 

464 assert len(mc_ch_dataset["validation"]) == len( 

465 mc_dataset["validation"] 

466 ) + len(ch_dataset["validation"]) 

467 

468 assert "test" in mc_ch_dataset 

469 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

470 ch_dataset["test"] 

471 ) 

472 

473 # f7 protocol RGB 

474 mc_ch_dataset = mc_ch_f7_rgb.dataset 

475 assert isinstance(mc_ch_dataset, dict) 

476 

477 mc_dataset = mc_f7_rgb.dataset 

478 ch_dataset = ch_f7_rgb.dataset 

479 

480 assert "train" in mc_ch_dataset 

481 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

482 ch_dataset["train"] 

483 ) 

484 

485 assert "validation" in mc_ch_dataset 

486 assert len(mc_ch_dataset["validation"]) == len( 

487 mc_dataset["validation"] 

488 ) + len(ch_dataset["validation"]) 

489 

490 assert "test" in mc_ch_dataset 

491 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

492 ch_dataset["test"] 

493 ) 

494 

495 # f8 protocol RGB 

496 mc_ch_dataset = mc_ch_f8_rgb.dataset 

497 assert isinstance(mc_ch_dataset, dict) 

498 

499 mc_dataset = mc_f8_rgb.dataset 

500 ch_dataset = ch_f8_rgb.dataset 

501 

502 assert "train" in mc_ch_dataset 

503 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

504 ch_dataset["train"] 

505 ) 

506 

507 assert "validation" in mc_ch_dataset 

508 assert len(mc_ch_dataset["validation"]) == len( 

509 mc_dataset["validation"] 

510 ) + len(ch_dataset["validation"]) 

511 

512 assert "test" in mc_ch_dataset 

513 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

514 ch_dataset["test"] 

515 ) 

516 

517 # f9 protocol RGB 

518 mc_ch_dataset = mc_ch_f9_rgb.dataset 

519 assert isinstance(mc_ch_dataset, dict) 

520 

521 mc_dataset = mc_f9_rgb.dataset 

522 ch_dataset = ch_f9_rgb.dataset 

523 

524 assert "train" in mc_ch_dataset 

525 assert len(mc_ch_dataset["train"]) == len(mc_dataset["train"]) + len( 

526 ch_dataset["train"] 

527 ) 

528 

529 assert "validation" in mc_ch_dataset 

530 assert len(mc_ch_dataset["validation"]) == len( 

531 mc_dataset["validation"] 

532 ) + len(ch_dataset["validation"]) 

533 

534 assert "test" in mc_ch_dataset 

535 assert len(mc_ch_dataset["test"]) == len(mc_dataset["test"]) + len( 

536 ch_dataset["test"] 

537 )