Coverage for /pythoncovmergedfiles/medio/medio/src/fuzz_structured.py: 10%

1###### Coverage stub 

2import atexit 

3import coverage 

4cov = coverage.coverage(data_file='.coverage', cover_pylib=True) 

5cov.start() 

6# Register an exist handler that will print coverage 

7def exit_handler(): 

8 cov.stop() 

9 cov.save() 

10atexit.register(exit_handler) 

11####### End of coverage stub 

12#!/usr/bin/python3 

13# Copyright 2025 Google LLC 

14# 

15# Licensed under the Apache License, Version 2.0 (the "License"); 

16# you may not use this file except in compliance with the License. 

17# You may obtain a copy of the License at 

18# 

19# http://www.apache.org/licenses/LICENSE-2.0 

20# 

21# Unless required by applicable law or agreed to in writing, software 

22# distributed under the License is distributed on an "AS IS" BASIS, 

23# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

24# See the License for the specific language governing permissions and 

25# limitations under the License. 

26import sys 

27import math 

28import atheris 

29import string 

30import ast, gast 

31 

32 

33def gen_identifier(fdp): 

34 return "".join( 

35 string.ascii_lowercase[ 

36 fdp.ConsumeIntInRange(0, len(string.ascii_lowercase) - 1) 

37 ] 

38 for i in range(fdp.ConsumeIntInRange(1, 8)) 

39 ) 

40 

41 

42def gen_mod(fdp): 

43 ops = [gen_Module] 

44 op_idx = fdp.ConsumeIntInRange(0, len(ops) - 1) 

45 return ops[op_idx](fdp) 

46 

47 

48def gen_Module(fdp): 

49 stmt_count = fdp.ConsumeIntInRange(1, 8) 

50 type_ignore_count = fdp.ConsumeIntInRange(0, 2) 

51 return ast.Module( 

52 [gen_stmt(fdp) for _ in range(stmt_count)], 

53 [gen_type_ignore(fdp) for _ in range(type_ignore_count)], 

54 ) 

55 

56 

57def gen_type_ignore(fdp): 

58 return ast.TypeIgnore(fdp.ConsumeIntInRange(0, 4), "") 

59 

60 

61# stmt 

62 

63 

64def gen_stmt(fdp): 

65 stmts = [ 

66 gen_Expr, 

67 gen_FunctionDef, 

68 gen_AsyncFunctionDef, 

69 gen_ClassDef, 

70 gen_Return, 

71 gen_Delete, 

72 gen_Assign, 

73 gen_AugAssign, 

74 gen_AnnAssign, 

75 gen_For, 

76 gen_AsyncFor, 

77 gen_While, 

78 gen_If, 

79 gen_With, 

80 gen_AsyncWith, 

81 gen_Match, 

82 gen_Raise, 

83 gen_Try, 

84 gen_Assert, 

85 gen_Import, 

86 gen_ImportFrom, 

87 gen_Global, 

88 gen_Nonlocal, 

89 gen_Expr, 

90 gen_Pass, 

91 gen_Break, 

92 gen_Continue, 

93 ] 

94 stmt_idx = fdp.ConsumeIntInRange(0, len(stmts) - 1) 

95 return stmts[stmt_idx](fdp) 

96 

97 

98def gen_FunctionDef(fdp): 

99 return ast.FunctionDef( 

100 gen_identifier(fdp), 

101 gen_arguments(fdp), 

102 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

103 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(0, 3))], 

104 gen_expr(fdp) if fdp.ConsumeBool() else None, 

105 fdp.ConsumeUnicode(4) if fdp.ConsumeBool() else None, 

106 ) 

107 

108 

109def gen_AsyncFunctionDef(fdp): 

110 return ast.AsyncFunctionDef( 

111 gen_identifier(fdp), 

112 gen_arguments(fdp), 

113 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

114 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(0, 3))], 

115 gen_expr(fdp) if fdp.ConsumeBool() else None, 

116 fdp.ConsumeUnicode(4) if fdp.ConsumeBool() else None, 

117 ) 

118 

119 

120def gen_keyword(fdp): 

121 return ast.keyword( 

122 gen_identifier(fdp) if fdp.ConsumeBool() else None, gen_expr(fdp) 

123 ) 

124 

125 

126def gen_ClassDef(fdp): 

127 return ast.ClassDef( 

128 gen_identifier(fdp), 

129 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

130 [gen_keyword(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

131 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

132 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

133 ) 

134 

135 

136def gen_Return(fdp): 

137 return ast.Return(gen_expr(fdp) if fdp.ConsumeBool() else None) 

138 

139 

140def gen_Delete(fdp): 

141 return ast.Delete([gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))]) 

142 

143 

144def gen_Assign(fdp): 

145 return ast.Assign( 

146 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

147 gen_expr(fdp), 

148 fdp.ConsumeUnicode(4) if fdp.ConsumeBool() else None, 

149 ) 

150 

151 

152def gen_AugAssign(fdp): 

153 return ast.AugAssign( 

154 gen_expr(fdp), 

155 gen_operator(fdp), 

156 gen_expr(fdp), 

157 ) 

158 

159 

160def gen_AnnAssign(fdp): 

161 return ast.AnnAssign( 

162 gen_expr(fdp), 

163 gen_expr(fdp), 

164 gen_expr(fdp) if fdp.ConsumeBool() else None, 

165 fdp.ConsumeIntInRange(0, 4), 

166 ) 

167 

168 

169def gen_For(fdp): 

170 return ast.For( 

171 gen_expr(fdp), 

172 gen_expr(fdp), 

173 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

174 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(0, 4))], 

175 fdp.ConsumeUnicode(4) if fdp.ConsumeBool() else None, 

176 ) 

177 

178 

179def gen_AsyncFor(fdp): 

180 return ast.AsyncFor( 

181 gen_expr(fdp), 

182 gen_expr(fdp), 

183 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

184 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(0, 4))], 

185 fdp.ConsumeUnicode(4) if fdp.ConsumeBool() else None, 

186 ) 

187 

188 

189def gen_arguments(fdp): 

190 posonly_argcount = fdp.ConsumeIntInRange(0, 3) 

191 argcount = fdp.ConsumeIntInRange(0, 3) 

192 kwonlyargcount = fdp.ConsumeIntInRange(0, 3) 

193 return ast.arguments( 

194 [gen_arg(fdp) for _ in range(posonly_argcount)], 

195 [gen_arg(fdp) for _ in range(argcount)], 

196 gen_arg(fdp) if fdp.ConsumeBool() else None, 

197 [gen_arg(fdp) for _ in range(kwonlyargcount)], 

198 [ 

199 gen_expr(fdp) 

200 for _ in range(fdp.ConsumeIntInRange(0, posonly_argcount + argcount)) 

201 ], 

202 gen_arg(fdp) if fdp.ConsumeBool() else None, 

203 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(0, kwonlyargcount))], 

204 ) 

205 

206 

207def gen_While(fdp): 

208 return ast.While( 

209 gen_expr(fdp), 

210 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

211 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(0, 4))], 

212 ) 

213 

214 

215def gen_If(fdp): 

216 return ast.If( 

217 gen_expr(fdp), 

218 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

219 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(0, 4))], 

220 ) 

221 

222 

223def gen_With(fdp): 

224 return ast.With( 

225 [gen_withitem(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

226 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

227 gen_identifier(fdp), 

228 ) 

229 

230 

231def gen_AsyncWith(fdp): 

232 return ast.AsyncWith( 

233 [gen_withitem(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

234 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

235 gen_identifier(fdp), 

236 ) 

237 

238 

239def gen_withitem(fdp): 

240 return ast.withitem(gen_expr(fdp), gen_expr(fdp) if fdp.ConsumeBool() else None) 

241 

242 

243def gen_Match(fdp): 

244 return ast.Match( 

245 gen_expr(fdp), 

246 [gen_match_case(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

247 ) 

248 

249 

250def gen_match_case(fdp): 

251 return ast.match_case( 

252 gen_pattern(fdp), 

253 gen_expr(fdp) if fdp.ConsumeBool() else None, 

254 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

255 ) 

256 

257 

258def gen_constant(fdp): 

259 return fdp.ConsumeIntInRange(1, 4) 

260 

261 

262def gen_pattern(fdp): 

263 case = fdp.ConsumeIntInRange(1, 8) 

264 if case == 1: 

265 return ast.MatchValue(gen_expr(fdp)) 

266 elif case == 2: 

267 return ast.MatchSingleton(gen_constant(fdp)) 

268 elif case == 3: 

269 return ast.MatchSequence( 

270 [gen_pattern(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))] 

271 ) 

272 elif case == 4: 

273 nelts = fdp.ConsumeIntInRange(1, 4) 

274 return ast.MatchMapping( 

275 [gen_expr(fdp) for _ in range(nelts)], 

276 [gen_pattern(fdp) for _ in range(nelts)], 

277 gen_identifier(fdp) if fdp.ConsumeBool() else None, 

278 ) 

279 elif case == 5: 

280 nkwd = fdp.ConsumeIntInRange(0, 2) 

281 return ast.MatchClass( 

282 gen_expr(fdp), 

283 [gen_pattern(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

284 [gen_identifier(fdp) for _ in range(nkwd)], 

285 [gen_pattern(fdp) for _ in range(nkwd)], 

286 ) 

287 elif case == 6: 

288 return ast.MatchStar(gen_identifier(fdp) if fdp.ConsumeBool() else None) 

289 elif case == 7: 

290 return ast.MatchAs( 

291 gen_pattern(fdp) if fdp.ConsumeBool() else None, 

292 gen_identifier(fdp) if fdp.ConsumeBool() else None, 

293 ) 

294 elif case == 8: 

295 return ast.MatchOr( 

296 [gen_pattern(fdp) for _ in range(fdp.ConsumeIntInRange(2, 3))] 

297 ) 

298 

299 

300def gen_Raise(fdp): 

301 return ast.Raise( 

302 gen_expr(fdp) if fdp.ConsumeBool() else None, 

303 gen_expr(fdp) if fdp.ConsumeBool() else None, 

304 ) 

305 

306 

307def gen_Try(fdp): 

308 return ast.Try( 

309 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

310 [gen_excepthandler(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

311 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

312 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

313 ) 

314 

315 

316def gen_excepthandler(fdp): 

317 return ast.ExceptHandler( 

318 gen_expr(fdp) if fdp.ConsumeBool() else None, 

319 gen_identifier(fdp) if fdp.ConsumeBool() else None, 

320 [gen_stmt(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

321 ) 

322 

323 

324def gen_Assert(fdp): 

325 return ast.Assert(gen_expr(fdp), gen_expr(fdp) if fdp.ConsumeBool() else None) 

326 

327 

328def gen_Import(fdp): 

329 return ast.Import([gen_alias(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))]) 

330 

331 

332def gen_alias(fdp): 

333 return ast.alias( 

334 gen_identifier(fdp), gen_identifier(fdp) if fdp.ConsumeBool() else None 

335 ) 

336 

337 

338def gen_ImportFrom(fdp): 

339 return ast.ImportFrom( 

340 gen_identifier(fdp) if fdp.ConsumeBool() else None, 

341 [gen_alias(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

342 fdp.ConsumeIntInRange(0, 3) if fdp.ConsumeBool() else None, 

343 ) 

344 

345 

346def gen_Global(fdp): 

347 return ast.Global([gen_identifier(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))]) 

348 

349 

350def gen_Nonlocal(fdp): 

351 return ast.Nonlocal( 

352 [gen_identifier(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))] 

353 ) 

354 

355 

356def gen_Expr(fdp): 

357 return ast.Expr(gen_expr(fdp)) 

358 

359 

360def gen_Pass(fdp): 

361 return ast.Pass() 

362 

363 

364def gen_Break(fdp): 

365 return ast.Break() 

366 

367 

368def gen_Continue(fdp): 

369 return ast.Continue() 

370 

371 

372## expr 

373 

374 

375def gen_operator(fdp): 

376 ops = [ 

377 ast.Add, 

378 ast.Sub, 

379 ast.Mult, 

380 ast.MatMult, 

381 ast.Div, 

382 ast.Mod, 

383 ast.Pow, 

384 ast.LShift, 

385 ast.RShift, 

386 ast.BitOr, 

387 ast.BitXor, 

388 ast.BitAnd, 

389 ast.FloorDiv, 

390 ] 

391 ops_idx = fdp.ConsumeIntInRange(0, len(ops) - 1) 

392 return ops[ops_idx]() 

393 

394 

395def gen_arg(fdp): 

396 return ast.arg( 

397 gen_identifier(fdp), 

398 gen_expr(fdp) if fdp.ConsumeBool() else None, 

399 fdp.ConsumeUnicode(4) if fdp.ConsumeBool() else None, 

400 ) 

401 

402 

403def gen_BoolOp(fdp): 

404 values_len = fdp.ConsumeIntInRange(2, 3) 

405 return ast.BoolOp(gen_boolop(fdp), [gen_expr(fdp) for _ in range(values_len)]) 

406 

407 

408def gen_NamedExpr(fdp): 

409 return ast.NamedExpr(gen_expr(fdp), gen_expr(fdp)) 

410 

411 

412def gen_BinOp(fdp): 

413 return ast.BinOp(gen_expr(fdp), gen_operator(fdp), gen_expr(fdp)) 

414 

415 

416def gen_UnaryOp(fdp): 

417 return ast.UnaryOp(gen_unaryop(fdp), gen_expr(fdp)) 

418 

419 

420def gen_unaryop(fdp): 

421 ops = [ast.Invert, ast.Not, ast.UAdd, ast.USub] 

422 ops_idx = fdp.ConsumeIntInRange(0, len(ops) - 1) 

423 return ops[ops_idx]() 

424 

425 

426def gen_Lambda(fdp): 

427 return ast.Lambda(gen_arguments(fdp), gen_expr(fdp)) 

428 

429 

430def gen_IfExp(fdp): 

431 return ast.IfExp(gen_expr(fdp), gen_expr(fdp), gen_expr(fdp)) 

432 

433 

434def gen_Dict(fdp): 

435 nelts = fdp.ConsumeIntInRange(0, 4) 

436 return ast.Dict( 

437 [gen_expr(fdp) for _ in range(nelts)], [gen_expr(fdp) for _ in range(nelts)] 

438 ) 

439 

440 

441def gen_Set(fdp): 

442 return ast.Set([gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))]) 

443 

444 

445def gen_boolop(fdp): 

446 op_len = fdp.ConsumeIntInRange(0, 1) 

447 return [ast.And(), ast.Or()][op_len] 

448 

449 

450def gen_comprehension(fdp): 

451 return ast.comprehension( 

452 gen_expr(fdp), 

453 gen_expr(fdp), 

454 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

455 fdp.ConsumeIntInRange(0, 4), 

456 ) 

457 

458 

459def gen_ListComp(fdp): 

460 return ast.ListComp( 

461 gen_expr(fdp), 

462 [gen_comprehension(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

463 ) 

464 

465 

466def gen_SetComp(fdp): 

467 return ast.SetComp( 

468 gen_expr(fdp), 

469 [gen_comprehension(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

470 ) 

471 

472 

473def gen_DictComp(fdp): 

474 return ast.DictComp( 

475 gen_expr(fdp), 

476 gen_expr(fdp), 

477 [gen_comprehension(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

478 ) 

479 

480 

481def gen_GeneratorExp(fdp): 

482 return ast.GeneratorExp( 

483 gen_expr(fdp), 

484 [gen_comprehension(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))], 

485 ) 

486 

487 

488def gen_Await(fdp): 

489 return ast.Await(gen_expr(fdp)) 

490 

491 

492def gen_Yield(fdp): 

493 return ast.Yield(gen_expr(fdp) if fdp.ConsumeBool() else None) 

494 

495 

496def gen_YieldFrom(fdp): 

497 return ast.YieldFrom(gen_expr(fdp)) 

498 

499 

500def gen_Compare(fdp): 

501 nops = fdp.ConsumeIntInRange(0, 1) 

502 return ast.Compare( 

503 gen_expr(fdp), 

504 [gen_cmpop(fdp) for _ in range(nops)], 

505 [gen_expr(fdp) for _ in range(nops)], 

506 ) 

507 

508 

509def gen_cmpop(fdp): 

510 ops = [ 

511 ast.Eq, 

512 ast.NotEq, 

513 ast.Lt, 

514 ast.LtE, 

515 ast.Gt, 

516 ast.GtE, 

517 ast.Is, 

518 ast.IsNot, 

519 ast.In, 

520 ast.NotIn, 

521 ] 

522 ops_idx = fdp.ConsumeIntInRange(0, len(ops) - 1) 

523 return ops[ops_idx]() 

524 

525 

526def gen_Call(fdp): 

527 return ast.Call( 

528 gen_expr_context(fdp), 

529 [gen_expr(fdp) for _ in range(fdp.ConsumeIntInRange(0, 4))], 

530 [gen_keyword(fdp) for _ in range(fdp.ConsumeIntInRange(0, 2))], 

531 ) 

532 

533 

534def gen_FormattedValue(fdp): 

535 return ast.FormattedValue( 

536 gen_expr(fdp), 

537 fdp.ConsumeIntInRange(0, 4), 

538 gen_expr(fdp) if fdp.ConsumeBool() else None, 

539 ) 

540 

541 

542def gen_JoinedStr(fdp): 

543 return ast.JoinedStr([gen_fstring(fdp) for _ in range(fdp.ConsumeIntInRange(1, 4))]) 

544 

545 

546def gen_fstring(fdp): 

547 ops = [gen_JoinedStr, gen_StrConstant, gen_FormattedValue] 

548 op_len = fdp.ConsumeIntInRange(0, len(ops) - 1) 

549 return ops[op_len](fdp) 

550 

551 

552def gen_StrConstant(fdp): 

553 return ast.Constant(fdp.ConsumeUnicode(4), None) 

554 

555 

556def gen_IntConstant(fdp): 

557 return ast.Constant(fdp.ConsumeInt(4), None) 

558 

559 

560def gen_Constant(fdp): 

561 ops = [gen_StrConstant, gen_IntConstant] 

562 op_len = fdp.ConsumeIntInRange(0, len(ops) - 1) 

563 return ops[op_len](fdp) 

564 

565 

566def gen_Attribute(fdp): 

567 return ast.Attribute(gen_expr(fdp), gen_identifier(fdp), gen_expr_context(fdp)) 

568 

569 

570def gen_Subscript(fdp): 

571 return ast.Subscript(gen_expr(fdp), gen_expr(fdp), gen_expr_context(fdp)) 

572 

573 

574def gen_Starred(fdp): 

575 return ast.Starred(gen_expr(fdp), gen_expr_context(fdp)) 

576 

577 

578def gen_Name(fdp): 

579 return ast.Name(gen_identifier(fdp), gen_expr_context(fdp)) 

580 

581 

582def gen_List(fdp): 

583 return ast.List([], gen_expr_context(fdp)) 

584 

585 

586def gen_Tuple(fdp): 

587 return ast.Tuple([], gen_expr_context(fdp)) 

588 

589 

590def gen_Slice(fdp): 

591 return ast.Slice( 

592 gen_expr(fdp) if fdp.ConsumeBool() else None, 

593 gen_expr(fdp) if fdp.ConsumeBool() else None, 

594 gen_expr(fdp) if fdp.ConsumeBool() else None, 

595 ) 

596 

597 

598def gen_expr(fdp): 

599 ops = [ 

600 gen_BoolOp, 

601 gen_NamedExpr, 

602 gen_BinOp, 

603 gen_UnaryOp, 

604 gen_Lambda, 

605 gen_IfExp, 

606 gen_Dict, 

607 gen_Set, 

608 gen_ListComp, 

609 gen_SetComp, 

610 gen_DictComp, 

611 gen_GeneratorExp, 

612 gen_Await, 

613 gen_Yield, 

614 gen_YieldFrom, 

615 gen_Compare, 

616 gen_Call, 

617 gen_FormattedValue, 

618 gen_JoinedStr, 

619 gen_Constant, 

620 gen_Attribute, 

621 gen_Subscript, 

622 gen_Starred, 

623 gen_Name, 

624 gen_List, 

625 gen_Tuple, 

626 gen_Slice, 

627 ] 

628 op_len = fdp.ConsumeIntInRange(0, len(ops) - 1) 

629 return ops[op_len](fdp) 

630 

631 

632def gen_expr_context(fdp): 

633 expr_contexts = [ast.Load, ast.Store, ast.Del, ast.AugLoad, ast.AugStore, ast.Param] 

634 expr_context_idx = fdp.ConsumeIntInRange(0, len(expr_contexts) - 1) 

635 return expr_contexts[expr_context_idx]() 

636 

637 

638# expr 

639 

640 

641def TestOneInput(data): 

642 fdp = atheris.FuzzedDataProvider(data) 

643 try: 

644 tree = ast.fix_missing_locations(gen_mod(fdp)) 

645 except RecursionError: 

646 return 

647 

648 try: 

649 code = ast.unparse(tree) 

650 tree = ast.parse(code) 

651 except (SyntaxError, ValueError, RecursionError) as e: 

652 return 

653 

654 # Any valid tree should be processable 

655 try: 

656 gtree = gast.ast_to_gast(tree) 

657 gast.dump(gtree) 

658 converted_ast = gast.gast_to_ast(gtree) 

659 code = gast.unparse(gtree) 

660 except RecursionError: 

661 return 

662 

663 

664def main(): 

665 atheris.instrument_all() 

666 atheris.Setup(sys.argv, TestOneInput, enable_python_coverage=True) 

667 atheris.Fuzz() 

668 

669 

670if __name__ == "__main__": 

671 main()