Coverage for tests/test_coverage.py: 100.000%

1# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0

2# For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt

4"""Tests for coverage.py."""

6from __future__ import annotations 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

8import pytest 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

10import coverage 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

11from coverage import env 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

12from coverage.exceptions import NoDataError 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

14from tests.coveragetest import CoverageTest 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

17class TestCoverageTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

18 """Make sure our complex self.check_coverage method works."""

20 def test_successful_coverage(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

21 # The simplest run possible.

22 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

23 """\

24 a = 1

25 b = 2

26 """,

27 lines=[1, 2],

28 )

29 # You can specify missing lines.

30 self.check_coverage( 49 ctx1abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVW

31 """\

32 a = 1

33 if a == 2:

34 a = 3

35 """,

36 lines=[1, 2, 3],

37 missing="3",

38 )

40 def test_failed_coverage(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

41 # If the lines are wrong, the message shows right and wrong.

42 with pytest.raises(AssertionError, match=r"\[1, 2] != \[1]"): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

43 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

44 """\

45 a = 1

46 b = 2

47 """,

48 lines=[1],

49 )

50 # If the missing lines are wrong, the message shows right and wrong.

51 with pytest.raises(AssertionError, match=r"'3' != '37'"): 54 ctx1abcdefghijklmn2opqrs3tuvwxXyzABCYDEFGHIJKLMNOPQRSZTUVW

52 self.check_coverage( 54 ctx1abcdefghijklmn2opqrs3tuvwxXyzABCYDEFGHIJKLMNOPQRSZTUVW

53 """\

54 a = 1

55 if a == 2:

56 a = 3

57 """,

58 lines=[1, 2, 3],

59 missing="37",

60 )

62 def test_exceptions_really_fail(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

63 # An assert in the checked code will really raise up to us.

64 with pytest.raises(AssertionError, match="This is bad"): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

65 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

66 """\

67 a = 1

68 assert a == 99, "This is bad"

69 """,

70 )

71 # Other exceptions too.

72 with pytest.raises(ZeroDivisionError, match="division"): 55 ctx1abcd0efghi1jklmnopqrstuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

73 self.check_coverage( 55 ctx1abcd0efghi1jklmnopqrstuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

74 """\

75 a = 1

76 assert a == 1, "This is good"

77 a/0

78 """,

79 )

82class BasicCoverageTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

83 """The simplest tests, for quick smoke testing of fundamental changes."""

85 def test_simple(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

86 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

87 """\

88 a = 1

89 b = 2

91 c = 4

92 # Nothing here

93 d = 6

94 """,

95 lines=[1, 2, 4, 6],

96 report="4 0 0 0 100%",

97 )

99 def test_indentation_wackiness(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

100 # Partial final lines are OK.

101 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

102 """\

103 import sys

104 if not sys.path:

105 a = 1

106 """, # indented last line

107 lines=[1, 2, 3],

108 missing="3",

109 )

110

111 def test_multiline_initializer(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

112 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

113 """\

114 d = {

115 'foo': 1+2,

116 'bar': (lambda x: x+1)(1),

117 'baz': str(1),

118 }

119

120 e = { 'foo': 1, 'bar': 2 }

121 """,

122 lines=[1, 7],

123 missing="",

124 )

125

126 def test_list_comprehension(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

127 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

128 """\

129 l = [

130 2*i for i in range(10)

131 if i > 5

132 ]

133 assert l == [12, 14, 16, 18]

134 """,

135 lines=[1, 5],

136 missing="",

137 )

138

139

140class SimpleStatementTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

141 """Testing simple single-line statements."""

142

143 def test_expression(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

144 # Bare expressions as statements are tricky: some implementations

145 # optimize some of them away. All implementations seem to count

146 # the implicit return at the end as executable.

147 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

148 """\

149 12

150 23

151 """,

152 lines=[1, 2],

153 missing="",

154 )

155 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

156 """\

157 12

158 23

159 a = 3

160 """,

161 lines=[1, 2, 3],

162 missing="",

163 )

164 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

165 """\

166 1 + 2

167 1 + \\

168 2

169 """,

170 lines=[1, 2],

171 missing="",

172 )

173 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

174 """\

175 1 + 2

176 1 + \\

177 2

178 a = 4

179 """,

180 lines=[1, 2, 4],

181 missing="",

182 )

183

184 def test_assert(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

185 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

186 """\

187 assert (1 + 2)

188 assert (1 +

189 2)

190 assert (1 + 2), 'the universe is broken'

191 assert (1 +

192 2), \\

193 'something is amiss'

194 """,

195 lines=[1, 2, 4, 5],

196 missing="",

197 )

198

199 def test_assignment(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

200 # Simple variable assignment

201 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

202 """\

203 a = (1 + 2)

204 b = (1 +

205 2)

206 c = \\

207 1

208 """,

209 lines=[1, 2, 4],

210 missing="",

211 )

212

213 def test_assign_tuple(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

214 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

215 """\

216 a = 1

217 a,b,c = 7,8,9

218 assert a == 7 and b == 8 and c == 9

219 """,

220 lines=[1, 2, 3],

221 missing="",

222 )

223

224 def test_more_assignments(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

225 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

226 """\

227 x = []

228 d = {}

229 d[

230 4 + len(x)

231 + 5

232 ] = \\

233 d[

234 8 ** 2

235 ] = \\

236 9

237 """,

238 lines=[1, 2, 3],

239 missing="",

240 )

241

242 def test_attribute_assignment(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

243 # Attribute assignment

244 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

245 """\

246 class obj: pass

247 o = obj()

248 o.foo = (1 + 2)

249 o.foo = (1 +

250 2)

251 o.foo = \\

252 1

253 """,

254 lines=[1, 2, 3, 4, 6],

255 missing="",

256 )

257

258 def test_list_of_attribute_assignment(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

259 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

260 """\

261 class obj: pass

262 o = obj()

263 o.a, o.b = (1 + 2), 3

264 o.a, o.b = (1 +

265 2), (3 +

266 4)

267 o.a, o.b = \\

268 1, \\

269 2

270 """,

271 lines=[1, 2, 3, 4, 7],

272 missing="",

273 )

274

275 def test_augmented_assignment(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

276 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

277 """\

278 a = 1

279 a += 1

280 a += (1 +

281 2)

282 a += \\

283 1

284 """,

285 lines=[1, 2, 3, 5],

286 missing="",

287 )

288

289 def test_triple_string_stuff(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

290 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

291 """\

292 a = '''

293 a multiline

294 string.

295 '''

296 b = '''

297 long expression

298 ''' + '''

299 on many

300 lines.

301 '''

302 c = len('''

303 long expression

304 ''' +

305 '''

306 on many

307 lines.

308 ''')

309 """,

310 lines=[1, 5, 11],

311 missing="",

312 )

313

314 def test_pass(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

315 # pass is tricky: if it's the only statement in a block, then it is

316 # "executed". But if it is not the only statement, then it is not.

317 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

318 """\

319 if 1==1:

320 pass

321 """,

322 lines=[1, 2],

323 missing="",

324 )

325 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

326 """\

327 def foo():

328 pass

329 foo()

330 """,

331 lines=[1, 2, 3],

332 missing="",

333 )

334 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

335 """\

336 def foo():

337 "doc"

338 pass

339 foo()

340 """,

341 lines=[1, 3, 4],

342 missing="",

343 )

344 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

345 """\

346 class Foo:

347 def foo(self):

348 pass

349 Foo().foo()

350 """,

351 lines=[1, 2, 3, 4],

352 missing="",

353 )

354 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

355 """\

356 class Foo:

357 def foo(self):

358 "Huh?"

359 pass

360 Foo().foo()

361 """,

362 lines=[1, 2, 4, 5],

363 missing="",

364 )

365

366 def test_del(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

367 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

368 """\

369 d = { 'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1 }

370 del d['a']

371 del d[

372 'b'

373 ]

374 del d['c'], \\

375 d['d'], \\

376 d['e']

377 assert(len(d.keys()) == 0)

378 """,

379 lines=[1, 2, 3, 6, 9],

380 missing="",

381 )

382

383 def test_raise(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

384 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

385 """\

386 try:

387 raise Exception(

388 "hello %d" %

389 17)

390 except:

391 pass

392 """,

393 lines=[1, 2, 5, 6],

394 missing="",

395 )

396

397 def test_raise_followed_by_statement(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

398 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

399 """\

400 try:

401 raise Exception("hello")

402 a = 3

403 except:

404 pass

405 """,

406 lines=[1, 2, 4, 5],

407 missing="",

408 )

409

410 def test_return(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

411 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

412 """\

413 def fn():

414 a = 1

415 return a

416

417 x = fn()

418 assert(x == 1)

419 """,

420 lines=[1, 2, 3, 5, 6],

421 missing="",

422 )

423 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

424 """\

425 def fn():

426 a = 1

427 return (

428 a +

429 1)

430

431 x = fn()

432 assert(x == 2)

433 """,

434 lines=[1, 2, 3, 7, 8],

435 missing="",

436 )

437 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

438 """\

439 def fn():

440 a = 1

441 return (a,

442 a + 1,

443 a + 2)

444

445 x,y,z = fn()

446 assert x == 1 and y == 2 and z == 3

447 """,

448 lines=[1, 2, 3, 7, 8],

449 missing="",

450 )

451

452 def test_return_followed_by_statement(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

453 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

454 """\

455 def fn():

456 a = 2

457 return a

458 a = 4

459

460 x = fn()

461 assert(x == 2)

462 """,

463 lines=[1, 2, 3, 6, 7],

464 missing="",

465 )

466

467 def test_yield(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

468 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

469 """\

470 def gen():

471 yield 1

472 yield (2+

473 3+

474 4)

475 yield 1, \\

476 2

477 a,b,c = gen()

478 assert a == 1 and b == 9 and c == (1,2)

479 """,

480 lines=[1, 2, 3, 6, 8, 9],

481 missing="",

482 )

483

484 def test_break(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

485 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

486 """\

487 for x in range(10):

488 a = 2 + x

489 break

490 a = 4

491 assert a == 2

492 """,

493 lines=[1, 2, 3, 5],

494 missing="",

495 )

496

497 def test_continue(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

498 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

499 """\

500 for x in range(10):

501 a = 2 + x

502 continue

503 a = 4

504 assert a == 11

505 """,

506 lines=[1, 2, 3, 5],

507 missing="",

508 )

509

510 def test_strange_unexecuted_continue(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

511 # This used to be true, but no longer is:

512 # Peephole optimization of jumps to jumps can mean that some statements

513 # never hit the line tracer. The behavior is different in different

514 # versions of Python, so be careful when running this test.

515 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

516 """\

517 a = b = c = 0

518 for n in range(100):

519 if n % 2:

520 if n % 4:

521 a += 1

522 continue # <-- This line may not be hit.

523 else:

524 b += 1

525 c += 1

526 assert a == 50 and b == 50 and c == 50

527

528 a = b = c = 0

529 for n in range(100):

530 if n % 2:

531 if n % 3:

532 a += 1

533 continue # <-- This line is always hit.

534 else:

535 b += 1

536 c += 1

537 assert a == 33 and b == 50 and c == 50

538 """,

539 lines=[1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 13, 14, 15, 16, 17, 19, 20, 21],

540 missing="",

541 )

542

543 def test_import(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

544 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

545 """\

546 import string

547 from sys import path

548 a = 1

549 """,

550 lines=[1, 2, 3],

551 missing="",

552 )

553 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

554 """\

555 import string

556 if 1 == 2:

557 from sys import path

558 a = 1

559 """,

560 lines=[1, 2, 3, 4],

561 missing="3",

562 )

563 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

564 """\

565 import string, \\

566 os, \\

567 re

568 from sys import path, \\

569 stdout

570 a = 1

571 """,

572 lines=[1, 4, 6],

573 missing="",

574 )

575 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

576 """\

577 import sys, sys as s

578 assert s.path == sys.path

579 """,

580 lines=[1, 2],

581 missing="",

582 )

583 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

584 """\

585 import sys, \\

586 sys as s

587 assert s.path == sys.path

588 """,

589 lines=[1, 3],

590 missing="",

591 )

592 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

593 """\

594 from sys import path, \\

595 path as p

596 assert p == path

597 """,

598 lines=[1, 3],

599 missing="",

600 )

601 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

602 """\

603 from sys import \\

604 *

605 assert len(path) > 0

606 """,

607 lines=[1, 3],

608 missing="",

609 )

610

611 def test_global(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

612 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

613 """\

614 g = h = i = 1

615 def fn():

616 global g

617 global h, \\

618 i

619 g = h = i = 2

620 fn()

621 assert g == 2 and h == 2 and i == 2

622 """,

623 lines=[1, 2, 6, 7, 8],

624 missing="",

625 )

626 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

627 """\

628 g = h = i = 1

629 def fn():

630 global g; g = 2

631 fn()

632 assert g == 2 and h == 1 and i == 1

633 """,

634 lines=[1, 2, 3, 4, 5],

635 missing="",

636 )

637

638 def test_exec(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

639 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

640 """\

641 a = b = c = 1

642 exec("a = 2")

643 exec("b = " +

644 "c = " +

645 "2")

646 assert a == 2 and b == 2 and c == 2

647 """,

648 lines=[1, 2, 3, 6],

649 missing="",

650 )

651 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

652 """\

653 vars = {'a': 1, 'b': 1, 'c': 1}

654 exec("a = 2", vars)

655 exec("b = " +

656 "c = " +

657 "2", vars)

658 assert vars['a'] == 2 and vars['b'] == 2 and vars['c'] == 2

659 """,

660 lines=[1, 2, 3, 6],

661 missing="",

662 )

663 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

664 """\

665 globs = {}

666 locs = {'a': 1, 'b': 1, 'c': 1}

667 exec("a = 2", globs, locs)

668 exec("b = " +

669 "c = " +

670 "2", globs, locs)

671 assert locs['a'] == 2 and locs['b'] == 2 and locs['c'] == 2

672 """,

673 lines=[1, 2, 3, 4, 7],

674 missing="",

675 )

676

677 def test_extra_doc_string(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

678 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

679 """\

680 a = 1

681 "An extra docstring, should be a comment."

682 b = 3

683 assert (a,b) == (1,3)

684 """,

685 lines=[1, 2, 3, 4],

686 missing="",

687 )

688 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

689 """\

690 a = 1

691 "An extra docstring, should be a comment."

692 b = 3

693 123 # A number for some reason: ignored

694 1+1 # An expression: executed.

695 c = 6

696 assert (a,b,c) == (1,3,6)

697 """,

698 lines=[1, 2, 3, 4, 5, 6, 7],

699 missing="",

700 )

701

702 def test_nonascii(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

703 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

704 """\

705 # coding: utf-8

706 a = 2

707 b = 3

708 """,

709 lines=[2, 3],

710 )

711

712 def test_module_docstring(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

713 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

714 """\

715 '''I am a module docstring.'''

716 a = 2

717 b = 3

718 """,

719 lines=[2, 3],

720 )

721 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

722 """\

723 # Start with a comment, even though it doesn't change the behavior.

724 '''I am a module docstring.'''

725 a = 3

726 b = 4

727 """,

728 lines=[3, 4],

729 )

730

731

732class CompoundStatementTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

733 """Testing coverage of multi-line compound statements."""

734

735 def test_statement_list(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

736 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

737 """\

738 a = 1;

739 b = 2; c = 3

740 d = 4; e = 5;

741

742 assert (a,b,c,d,e) == (1,2,3,4,5)

743 """,

744 lines=[1, 2, 3, 5],

745 missing="",

746 )

747

748 def test_if(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

749 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

750 """\

751 a = 1

752 if a == 1:

753 x = 3

754 assert x == 3

755 if (a ==

756 1):

757 x = 7

758 assert x == 7

759 """,

760 lines=[1, 2, 3, 4, 5, 7, 8],

761 missing="",

762 )

763 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

764 """\

765 a = 1

766 if a == 1:

767 x = 3

768 else:

769 y = 5

770 assert x == 3

771 """,

772 lines=[1, 2, 3, 5, 6],

773 missing="5",

774 )

775 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

776 """\

777 a = 1

778 if a != 1:

779 x = 3

780 else:

781 y = 5

782 assert y == 5

783 """,

784 lines=[1, 2, 3, 5, 6],

785 missing="3",

786 )

787 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

788 """\

789 a = 1; b = 2

790 if a == 1:

791 if b == 2:

792 x = 4

793 else:

794 y = 6

795 else:

796 z = 8

797 assert x == 4

798 """,

799 lines=[1, 2, 3, 4, 6, 8, 9],

800 missing="6-8",

801 )

802

803 def test_elif(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

804 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

805 """\

806 a = 1; b = 2; c = 3;

807 if a == 1:

808 x = 3

809 elif b == 2:

810 y = 5

811 else:

812 z = 7

813 assert x == 3

814 """,

815 lines=[1, 2, 3, 4, 5, 7, 8],

816 missing="4-7",

817 report="7 3 4 1 45% 4-7",

818 )

819 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

820 """\

821 a = 1; b = 2; c = 3;

822 if a != 1:

823 x = 3

824 elif b == 2:

825 y = 5

826 else:

827 z = 7

828 assert y == 5

829 """,

830 lines=[1, 2, 3, 4, 5, 7, 8],

831 missing="3, 7",

832 report="7 2 4 2 64% 3, 7",

833 )

834 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

835 """\

836 a = 1; b = 2; c = 3;

837 if a != 1:

838 x = 3

839 elif b != 2:

840 y = 5

841 else:

842 z = 7

843 assert z == 7

844 """,

845 lines=[1, 2, 3, 4, 5, 7, 8],

846 missing="3, 5",

847 report="7 2 4 2 64% 3, 5",

848 )

849

850 def test_elif_no_else(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

851 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

852 """\

853 a = 1; b = 2; c = 3;

854 if a == 1:

855 x = 3

856 elif b == 2:

857 y = 5

858 assert x == 3

859 """,

860 lines=[1, 2, 3, 4, 5, 6],

861 missing="4-5",

862 report="6 2 4 1 50% 4-5",

863 )

864 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

865 """\

866 a = 1; b = 2; c = 3;

867 if a != 1:

868 x = 3

869 elif b == 2:

870 y = 5

871 assert y == 5

872 """,

873 lines=[1, 2, 3, 4, 5, 6],

874 missing="3",

875 report="6 1 4 2 70% 3, 4->6",

876 )

877

878 def test_elif_bizarre(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

879 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

880 """\

881 def f(self):

882 if self==1:

883 x = 3

884 elif self.m('fred'):

885 x = 5

886 elif (g==1) and (b==2):

887 x = 7

888 elif self.m('fred')==True:

889 x = 9

890 elif ((g==1) and (b==2))==True:

891 x = 11

892 else:

893 x = 13

894 """,

895 lines=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13],

896 missing="2-13",

897 )

898

899 def test_split_if(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

900 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

901 """\

902 a = 1; b = 2; c = 3;

903 if \\

904 a == 1:

905 x = 3

906 elif \\

907 b == 2:

908 y = 5

909 else:

910 z = 7

911 assert x == 3

912 """,

913 lines=[1, 2, 4, 5, 7, 9, 10],

914 missing="5-9",

915 )

916 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

917 """\

918 a = 1; b = 2; c = 3;

919 if \\

920 a != 1:

921 x = 3

922 elif \\

923 b == 2:

924 y = 5

925 else:

926 z = 7

927 assert y == 5

928 """,

929 lines=[1, 2, 4, 5, 7, 9, 10],

930 missing="4, 9",

931 )

932 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

933 """\

934 a = 1; b = 2; c = 3;

935 if \\

936 a != 1:

937 x = 3

938 elif \\

939 b != 2:

940 y = 5

941 else:

942 z = 7

943 assert z == 7

944 """,

945 lines=[1, 2, 4, 5, 7, 9, 10],

946 missing="4, 7",

947 )

948

949 def test_pathological_split_if(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

950 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

951 """\

952 a = 1; b = 2; c = 3;

953 if (

954 a == 1

955 ):

956 x = 3

957 elif (

958 b == 2

959 ):

960 y = 5

961 else:

962 z = 7

963 assert x == 3

964 """,

965 lines=[1, 2, 5, 6, 9, 11, 12],

966 missing="6-11",

967 )

968 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

969 """\

970 a = 1; b = 2; c = 3;

971 if (

972 a != 1

973 ):

974 x = 3

975 elif (

976 b == 2

977 ):

978 y = 5

979 else:

980 z = 7

981 assert y == 5

982 """,

983 lines=[1, 2, 5, 6, 9, 11, 12],

984 missing="5, 11",

985 )

986 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

987 """\

988 a = 1; b = 2; c = 3;

989 if (

990 a != 1

991 ):

992 x = 3

993 elif (

994 b != 2

995 ):

996 y = 5

997 else:

998 z = 7

999 assert z == 7

1000 """,

1001 lines=[1, 2, 5, 6, 9, 11, 12],

1002 missing="5, 9",

1003 )

1004

1005 def test_absurd_split_if(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1006 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1007 """\

1008 a = 1; b = 2; c = 3;

1009 if a == 1 \\

1010 :

1011 x = 3

1012 elif b == 2 \\

1013 :

1014 y = 5

1015 else:

1016 z = 7

1017 assert x == 3

1018 """,

1019 lines=[1, 2, 4, 5, 7, 9, 10],

1020 missing="5-9",

1021 )

1022 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1023 """\

1024 a = 1; b = 2; c = 3;

1025 if a != 1 \\

1026 :

1027 x = 3

1028 elif b == 2 \\

1029 :

1030 y = 5

1031 else:

1032 z = 7

1033 assert y == 5

1034 """,

1035 lines=[1, 2, 4, 5, 7, 9, 10],

1036 missing="4, 9",

1037 )

1038 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1039 """\

1040 a = 1; b = 2; c = 3;

1041 if a != 1 \\

1042 :

1043 x = 3

1044 elif b != 2 \\

1045 :

1046 y = 5

1047 else:

1048 z = 7

1049 assert z == 7

1050 """,

1051 lines=[1, 2, 4, 5, 7, 9, 10],

1052 missing="4, 7",

1053 )

1054

1055 def test_constant_if(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1056 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1057 """\

1058 if 1:

1059 a = 2

1060 assert a == 2

1061 """,

1062 lines=[1, 2, 3],

1063 missing="",

1064 )

1065

1066 def test_while(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1067 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1068 """\

1069 a = 3; b = 0

1070 while a:

1071 b += 1

1072 a -= 1

1073 assert a == 0 and b == 3

1074 """,

1075 lines=[1, 2, 3, 4, 5],

1076 missing="",

1077 )

1078 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1079 """\

1080 a = 3; b = 0

1081 while a:

1082 b += 1

1083 break

1084 assert a == 3 and b == 1

1085 """,

1086 lines=[1, 2, 3, 4, 5],

1087 missing="",

1088 )

1089

1090 def test_while_else(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1091 # Take the else branch.

1092 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1093 """\

1094 a = 3; b = 0

1095 while a:

1096 b += 1

1097 a -= 1

1098 else:

1099 b = 99

1100 assert a == 0 and b == 99

1101 """,

1102 lines=[1, 2, 3, 4, 6, 7],

1103 missing="",

1104 )

1105 # Don't take the else branch.

1106 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1107 """\

1108 a = 3; b = 0

1109 while a:

1110 b += 1

1111 a -= 1

1112 break

1113 else:

1114 b = 99

1115 assert a == 2 and b == 1

1116 """,

1117 lines=[1, 2, 3, 4, 5, 7, 8],

1118 missing="7",

1119 )

1120

1121 def test_split_while(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1122 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1123 """\

1124 a = 3; b = 0

1125 while \\

1126 a:

1127 b += 1

1128 a -= 1

1129 assert a == 0 and b == 3

1130 """,

1131 lines=[1, 2, 4, 5, 6],

1132 missing="",

1133 )

1134 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1135 """\

1136 a = 3; b = 0

1137 while (

1138 a

1139 ):

1140 b += 1

1141 a -= 1

1142 assert a == 0 and b == 3

1143 """,

1144 lines=[1, 2, 5, 6, 7],

1145 missing="",

1146 )

1147

1148 def test_for(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1149 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1150 """\

1151 a = 0

1152 for i in [1,2,3,4,5]:

1153 a += i

1154 assert a == 15

1155 """,

1156 lines=[1, 2, 3, 4],

1157 missing="",

1158 )

1159 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1160 """\

1161 a = 0

1162 for i in [1,

1163 2,3,4,

1164 5]:

1165 a += i

1166 assert a == 15

1167 """,

1168 lines=[1, 2, 5, 6],

1169 missing="",

1170 )

1171 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1172 """\

1173 a = 0

1174 for i in [1,2,3,4,5]:

1175 a += i

1176 break

1177 assert a == 1

1178 """,

1179 lines=[1, 2, 3, 4, 5],

1180 missing="",

1181 )

1182

1183 def test_for_else(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1184 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1185 """\

1186 a = 0

1187 for i in range(5):

1188 a += i+1

1189 else:

1190 a = 99

1191 assert a == 99

1192 """,

1193 lines=[1, 2, 3, 5, 6],

1194 missing="",

1195 )

1196 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1197 """\

1198 a = 0

1199 for i in range(5):

1200 a += i+1

1201 break

1202 else:

1203 a = 123

1204 assert a == 1

1205 """,

1206 lines=[1, 2, 3, 4, 6, 7],

1207 missing="6",

1208 )

1209

1210 def test_split_for(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1211 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1212 """\

1213 a = 0

1214 for \\

1215 i in [1,2,3,4,5]:

1216 a += i

1217 assert a == 15

1218 """,

1219 lines=[1, 2, 4, 5],

1220 missing="",

1221 )

1222 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1223 """\

1224 a = 0

1225 for \\

1226 i in [1,

1227 2,3,4,

1228 5]:

1229 a += i

1230 assert a == 15

1231 """,

1232 lines=[1, 2, 6, 7],

1233 missing="",

1234 )

1235

1236 def test_try_except(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1237 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1238 """\

1239 a = 0

1240 try:

1241 a = 1

1242 except:

1243 a = 99

1244 assert a == 1

1245 """,

1246 lines=[1, 2, 3, 4, 5, 6],

1247 missing="4-5",

1248 )

1249 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1250 """\

1251 a = 0

1252 try:

1253 a = 1

1254 raise Exception("foo")

1255 except:

1256 a = 99

1257 assert a == 99

1258 """,

1259 lines=[1, 2, 3, 4, 5, 6, 7],

1260 missing="",

1261 )

1262 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1263 """\

1264 a = 0

1265 try:

1266 a = 1

1267 raise Exception("foo")

1268 except ImportError:

1269 a = 99

1270 except:

1271 a = 123

1272 assert a == 123

1273 """,

1274 lines=[1, 2, 3, 4, 5, 6, 7, 8, 9],

1275 missing="6",

1276 )

1277 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1278 """\

1279 a = 0

1280 try:

1281 a = 1

1282 raise IOError("foo")

1283 except ImportError:

1284 a = 99

1285 except IOError:

1286 a = 17

1287 except:

1288 a = 123

1289 assert a == 17

1290 """,

1291 lines=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],

1292 missing="6, 9-10",

1293 )

1294 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1295 """\

1296 a = 0

1297 try:

1298 a = 1

1299 except:

1300 a = 99

1301 else:

1302 a = 123

1303 assert a == 123

1304 """,

1305 lines=[1, 2, 3, 4, 5, 7, 8],

1306 missing="4-5",

1307 branchz="",

1308 branchz_missing="",

1309 )

1310

1311 def test_try_except_stranded_else(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1312 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1313 """\

1314 a = 0

1315 try:

1316 a = 1

1317 raise Exception("foo")

1318 except:

1319 a = 99

1320 else:

1321 a = 123

1322 assert a == 99

1323 """,

1324 lines=[1, 2, 3, 4, 5, 6, 9],

1325 missing="",

1326 branchz="",

1327 branchz_missing="",

1328 )

1329

1330 def test_try_finally(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1331 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1332 """\

1333 a = 0

1334 try:

1335 a = 1

1336 finally:

1337 a = 99

1338 assert a == 99

1339 """,

1340 lines=[1, 2, 3, 5, 6],

1341 missing="",

1342 )

1343 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1344 """\

1345 a = 0; b = 0

1346 try:

1347 a = 1

1348 try:

1349 raise Exception("foo")

1350 finally:

1351 b = 123

1352 except:

1353 a = 99

1354 assert a == 99 and b == 123

1355 """,

1356 lines=[1, 2, 3, 4, 5, 7, 8, 9, 10],

1357 missing="",

1358 )

1359

1360 def test_function_def(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1361 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1362 """\

1363 a = 99

1364 def foo():

1365 ''' docstring

1366 '''

1367 return 1

1368

1369 a = foo()

1370 assert a == 1

1371 """,

1372 lines=[1, 2, 5, 7, 8],

1373 missing="",

1374 )

1375 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1376 """\

1377 def foo(

1378 a,

1379 b

1380 ):

1381 ''' docstring

1382 '''

1383 return a+b

1384

1385 x = foo(17, 23)

1386 assert x == 40

1387 """,

1388 lines=[1, 7, 9, 10],

1389 missing="",

1390 )

1391 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1392 """\

1393 def foo(

1394 a = (lambda x: x*2)(10),

1395 b = (

1396 lambda x:

1397 x+1

1398 )(1)

1399 ):

1400 ''' docstring

1401 '''

1402 return a+b

1403

1404 x = foo()

1405 assert x == 22

1406 """,

1407 lines=[1, 10, 12, 13],

1408 missing="",

1409 )

1410

1411 def test_class_def(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1412 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1413 """\

1414 # A comment.

1415 class theClass:

1416 ''' the docstring.

1417 Don't be fooled.

1418 '''

1419 def __init__(self):

1420 ''' Another docstring. '''

1421 self.a = 1

1422

1423 def foo(self):

1424 return self.a

1425

1426 x = theClass().foo()

1427 assert x == 1

1428 """,

1429 lines=[2, 6, 8, 10, 11, 13, 14],

1430 missing="",

1431 branchz="",

1432 branchz_missing="",

1433 )

1434

1435

1436class AnnotationTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1437 """Tests specific to annotations."""

1438

1439 def test_attribute_annotation(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1440 if env.PYBEHAVIOR.deferred_annotations: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1441 lines = [1, 3] 36 ctx1zA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)

1442 else:

1443 lines = [1, 2, 3] 33 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyUVW

1444 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1445 """\

1446 class X:

1447 x: int

1448 y = 1

1449 """,

1450 lines=lines,

1451 missing="",

1452 )

1453

1454 def test_attribute_annotation_from_future(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1455 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1456 """\

1457 from __future__ import annotations

1458 class X:

1459 x: int

1460 y = 1

1461 """,

1462 lines=[1, 2, 3, 4],

1463 missing="",

1464 )

1465

1466

1467class ExcludeTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1468 """Tests of the exclusion feature to mark lines as not covered."""

1469

1470 def test_default(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1471 # A number of forms of pragma comment are accepted.

1472 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1473 """\

1474 a = 1

1475 b = 2 # pragma: no cover

1476 c = 3

1477 d = 4 #pragma NOCOVER

1478 e = 5

1479 f = 6#\tpragma:\tno cover

1480 g = 7

1481 ...

1482 i = 9

1483 ... # we don't care about this line

1484 k = 11

1485 def foo12(): ... # do nothing

1486 async def bar13(): ...

1487 def method14(self) ->None: ...

1488 def method15( # 15

1489 self,

1490 some_arg: str = "Hello",

1491 ): ...

1492 def method19(self): return a[1,...]

1493 def method20(

1494 self,

1495 some_args,

1496 ) -> int: ...

1497 x = 24

1498 def method25(

1499 self,

1500 ): return a[1,...]

1501 def f28(): print("(well): ... #2 false positive!")

1502 """,

1503 lines=[1, 3, 5, 7, 9, 11, 19, 24, 25],

1504 )

1505

1506 def test_two_excludes(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1507 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1508 """\

1509 a = 1; b = 2

1510

1511 if a == 99:

1512 a = 4 # -cc

1513 b = 5

1514 c = 6 # -xx

1515 assert a == 1 and b == 2

1516 """,

1517 lines=[1, 3, 5, 7],

1518 missing="5",

1519 excludes=["-cc", "-xx"],

1520 )

1521

1522 def test_excluding_elif_suites(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1523 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1524 """\

1525 a = 1; b = 2

1526

1527 if 1==1:

1528 a = 4

1529 b = 5

1530 c = 6

1531 elif 1==0: #pragma: NO COVER

1532 a = 8

1533 b = 9

1534 else:

1535 a = 11

1536 b = 12

1537 assert a == 4 and b == 5 and c == 6

1538 """,

1539 lines=[1, 3, 4, 5, 6, 11, 12, 13],

1540 missing="11-12",

1541 excludes=["#pragma: NO COVER"],

1542 )

1543

1544 def test_excluding_try_except(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1545 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1546 """\

1547 a = 0

1548 try:

1549 a = 1

1550 except: #pragma: NO COVER

1551 a = 99

1552 else:

1553 a = 123

1554 assert a == 123

1555 """,

1556 lines=[1, 2, 3, 7, 8],

1557 missing="",

1558 excludes=["#pragma: NO COVER"],

1559 branchz="",

1560 branchz_missing="",

1561 )

1562

1563 def test_excluding_try_except_stranded_else(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1564 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1565 """\

1566 a = 0

1567 try:

1568 a = 1

1569 raise Exception("foo")

1570 except:

1571 a = 99

1572 else: #pragma: NO COVER

1573 x = 2

1574 assert a == 99

1575 """,

1576 lines=[1, 2, 3, 4, 5, 6, 9],

1577 missing="",

1578 excludes=["#pragma: NO COVER"],

1579 branchz="",

1580 branchz_missing="",

1581 )

1582

1583 def test_excluded_comprehension_branches(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1584 # https://github.com/coveragepy/coveragepy/issues/1271

1585 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1586 """\

1587 x, y = [0], [1]

1588 if x == [2]:

1589 raise NotImplementedError # NOCOVPLZ

1590 if all(_ == __ for _, __ in zip(x, y)):

1591 raise NotImplementedError # NOCOVPLZ

1592 """,

1593 lines=[1, 2, 4],

1594 missing="",

1595 excludes=["# NOCOVPLZ"],

1596 branchz="23 24 45 4.",

1597 branchz_missing="",

1598 )

1599

1600

1601class Py24Test(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1602 """Tests of new syntax in Python 2.4."""

1603

1604 def test_function_decorators(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1605 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1606 """\

1607 def require_int(func):

1608 def wrapper(arg):

1609 assert isinstance(arg, int)

1610 return func(arg)

1611

1612 return wrapper

1613

1614 @require_int

1615 def p1(arg):

1616 return arg*2

1617

1618 assert p1(10) == 20

1619 """,

1620 lines=[1, 2, 3, 4, 6, 8, 9, 10, 12],

1621 missing="",

1622 )

1623

1624 def test_function_decorators_with_args(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1625 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1626 """\

1627 def boost_by(extra):

1628 def decorator(func):

1629 def wrapper(arg):

1630 return extra*func(arg)

1631 return wrapper

1632 return decorator

1633

1634 @boost_by(10)

1635 def boosted(arg):

1636 return arg*2

1637

1638 assert boosted(10) == 200

1639 """,

1640 lines=[1, 2, 3, 4, 5, 6, 8, 9, 10, 12],

1641 missing="",

1642 )

1643

1644 def test_double_function_decorators(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1645 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1646 """\

1647 def require_int(func):

1648 def wrapper(arg):

1649 assert isinstance(arg, int)

1650 return func(arg)

1651 return wrapper

1652

1653 def boost_by(extra):

1654 def decorator(func):

1655 def wrapper(arg):

1656 return extra*func(arg)

1657 return wrapper

1658 return decorator

1659

1660 @require_int

1661 @boost_by(10)

1662 def boosted1(arg):

1663 return arg*2

1664

1665 assert boosted1(10) == 200

1666

1667 @boost_by(10)

1668 @require_int

1669 def boosted2(arg):

1670 return arg*2

1671

1672 assert boosted2(10) == 200

1673 """,

1674 lines=[1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 19, 21, 22, 23, 24, 26],

1675 missing="",

1676 )

1677

1678

1679class Py25Test(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1680 """Tests of new syntax in Python 2.5."""

1681

1682 def test_with_statement(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1683 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1684 """\

1685 class Managed:

1686 def __enter__(self):

1687 desc = "enter"

1688

1689 def __exit__(self, type, value, tb):

1690 desc = "exit"

1691

1692 m = Managed()

1693 with m:

1694 desc = "block1a"

1695 desc = "block1b"

1696

1697 try:

1698 with m:

1699 desc = "block2"

1700 raise Exception("Boo!")

1701 except:

1702 desc = "caught"

1703 """,

1704 lines=[1, 2, 3, 5, 6, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18],

1705 missing="",

1706 )

1707

1708 def test_try_except_finally(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1709 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1710 """\

1711 a = 0; b = 0

1712 try:

1713 a = 1

1714 except:

1715 a = 99

1716 finally:

1717 b = 2

1718 assert a == 1 and b == 2

1719 """,

1720 lines=[1, 2, 3, 4, 5, 7, 8],

1721 missing="4-5",

1722 branchz="",

1723 branchz_missing="",

1724 )

1725 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1726 """\

1727 a = 0; b = 0

1728 try:

1729 a = 1

1730 raise Exception("foo")

1731 except:

1732 a = 99

1733 finally:

1734 b = 2

1735 assert a == 99 and b == 2

1736 """,

1737 lines=[1, 2, 3, 4, 5, 6, 8, 9],

1738 missing="",

1739 branchz="",

1740 branchz_missing="",

1741 )

1742 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1743 """\

1744 a = 0; b = 0

1745 try:

1746 a = 1

1747 raise Exception("foo")

1748 except ImportError:

1749 a = 99

1750 except:

1751 a = 123

1752 finally:

1753 b = 2

1754 assert a == 123 and b == 2

1755 """,

1756 lines=[1, 2, 3, 4, 5, 6, 7, 8, 10, 11],

1757 missing="6",

1758 branchz="",

1759 branchz_missing="",

1760 )

1761 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1762 """\

1763 a = 0; b = 0

1764 try:

1765 a = 1

1766 raise IOError("foo")

1767 except ImportError:

1768 a = 99

1769 except IOError:

1770 a = 17

1771 except:

1772 a = 123

1773 finally:

1774 b = 2

1775 assert a == 17 and b == 2

1776 """,

1777 lines=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13],

1778 missing="6, 9-10",

1779 branchz="",

1780 branchz_missing="",

1781 )

1782 self.check_coverage( 57 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzABCYDEFGH4IJKLMNOPQRSZTUVW

1783 """\

1784 a = 0; b = 0

1785 try:

1786 a = 1

1787 except:

1788 a = 99

1789 else:

1790 a = 123

1791 finally:

1792 b = 2

1793 assert a == 123 and b == 2

1794 """,

1795 lines=[1, 2, 3, 4, 5, 7, 9, 10],

1796 missing="4-5",

1797 branchz="",

1798 branchz_missing="",

1799 )

1800

1801 def test_try_except_finally_stranded_else(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1802 self.check_coverage( 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1803 """\

1804 a = 0; b = 0

1805 try:

1806 a = 1

1807 raise Exception("foo")

1808 except:

1809 a = 99

1810 else:

1811 a = 123

1812 finally:

1813 b = 2

1814 assert a == 99 and b == 2

1815 """,

1816 # The else can't be reached because the try ends with a raise.

1817 lines=[1, 2, 3, 4, 5, 6, 10, 11],

1818 missing="",

1819 branchz="",

1820 branchz_missing="",

1821 )

1822

1823

1824class ModuleTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1825 """Tests for the module-level behavior of the `coverage` module."""

1826

1827 run_in_temp_dir = False 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1828

1829 def test_not_singleton(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1830 # You *can* create another coverage object.

1831 coverage.Coverage() 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1832 coverage.Coverage() 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1833

1834 def test_old_name_and_new_name(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1835 assert coverage.coverage is coverage.Coverage 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1836

1837

1838class ReportingTest(CoverageTest): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1839 """Tests of some reporting behavior."""

1840

1841 def test_no_data_to_report_on_annotate(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1842 # Reporting with no data produces a nice message and no output

1843 # directory.

1844 with pytest.raises(NoDataError, match="No data to report."): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1845 self.command_line("annotate -d ann") 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1846 self.assert_doesnt_exist("ann") 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1847

1848 def test_no_data_to_report_on_html(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1849 # Reporting with no data produces a nice message and no output

1850 # directory.

1851 with pytest.raises(NoDataError, match="No data to report."): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1852 self.command_line("html -d htmlcov") 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1853 self.assert_doesnt_exist("htmlcov") 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1854

1855 def test_no_data_to_report_on_xml(self) -> None: 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1856 # Reporting with no data produces a nice message.

1857 with pytest.raises(NoDataError, match="No data to report."): 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1858 self.command_line("xml") 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

1859 self.assert_doesnt_exist("coverage.xml") 69 ctx1abcd0efghi1jklmn2opqrs3tuvwxXyzA5BC6YD7EF8GH94I!JK#LM$NO%PQ'RS(ZT)UVW

Coverage for tests / test_coverage.py: 100.000%

226 statements