├── .cargo └── config.toml ├── .clang-format ├── .dockerignore ├── .editorconfig ├── .gitattributes ├── .github ├── CODEOWNERS ├── ISSUE_TEMPLATE │ ├── bug_report.md │ ├── dev-improvement.md │ └── feature_request.md ├── PULL_REQUEST_TEMPLATE.md ├── SECURITY.md ├── actions │ ├── build-bundle │ │ └── action.yml │ └── setup │ │ └── action.yml ├── dependabot.yml ├── labeler.yml └── workflows │ ├── bench.yml │ ├── cargo-update.yml │ ├── cbmc-latest.yml │ ├── cbmc-update.yml │ ├── deny.yml │ ├── extra_jobs.yml │ ├── format-check.yml │ ├── kani.yml │ ├── release.yml │ ├── slow-tests.yml │ ├── toolchain-upgrade.yml │ └── verify-std-check.yml ├── .gitignore ├── .gitmodules ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── Cargo.lock ├── Cargo.toml ├── LICENSE-APACHE ├── LICENSE-MIT ├── README.md ├── build.rs ├── cprover_bindings ├── Cargo.toml └── src │ ├── cbmc_string.rs │ ├── env.rs │ ├── goto_program │ ├── builtin.rs │ ├── expr.rs │ ├── location.rs │ ├── mod.rs │ ├── stmt.rs │ ├── symbol.rs │ ├── symbol_table.rs │ └── typ.rs │ ├── irep │ ├── goto_binary_serde.rs │ ├── irep.rs │ ├── irep_id.rs │ ├── mod.rs │ ├── serialize.rs │ ├── symbol.rs │ ├── symbol_table.rs │ └── to_irep.rs │ ├── lib.rs │ ├── machine_model.rs │ └── utils.rs ├── deny.toml ├── docs ├── README.md ├── book.toml └── src │ ├── SUMMARY.md │ ├── application.md │ ├── benchcomp-cli.md │ ├── benchcomp-conf.md │ ├── benchcomp-parse.md │ ├── build-from-source.md │ ├── cargo-kani.md │ ├── cbmc-hacks.md │ ├── cheat-sheets.md │ ├── conventions.md │ ├── crates │ └── index.md │ ├── dev-assess.md │ ├── dev-documentation.md │ ├── faq.md │ ├── getting-started.md │ ├── getting-started │ └── verification-results │ │ ├── Cargo.toml │ │ ├── failure_example.expected │ │ ├── src │ │ └── main.rs │ │ ├── success_example.expected │ │ ├── undetermined_example.expected │ │ └── unreachable_example.expected │ ├── install-github-ci.md │ ├── install-guide.md │ ├── kani-single-file.md │ ├── kani-tutorial.md │ ├── limitations.md │ ├── overrides.md │ ├── performance-comparisons.md │ ├── reference.md │ ├── reference │ ├── attributes.md │ ├── bounded_arbitrary.md │ └── experimental │ │ ├── autoharness.md │ │ ├── concrete-playback.md │ │ ├── contracts.md │ │ ├── coverage.md │ │ ├── experimental-features.md │ │ ├── loop-contracts.md │ │ ├── quantifiers.md │ │ └── stubbing.md │ ├── regression-testing.md │ ├── repo-crawl.md │ ├── rust-feature-support.md │ ├── rust-feature-support │ ├── intrinsics.md │ └── unstable.md │ ├── rustc-hacks.md │ ├── stable-mir.md │ ├── testing.md │ ├── tool-comparison.md │ ├── tutorial-first-steps.md │ ├── tutorial-kinds-of-failure.md │ ├── tutorial-loop-unwinding.md │ ├── tutorial-nondeterministic-variables.md │ ├── tutorial-real-code.md │ ├── tutorial │ ├── arbitrary-variables │ │ ├── Cargo.toml │ │ ├── check_rating.expected │ │ ├── safe_update.expected │ │ └── src │ │ │ ├── exercise_solution.rs │ │ │ ├── inventory.rs │ │ │ ├── lib.rs │ │ │ └── rating.rs │ ├── first-steps-v1 │ │ ├── Cargo.toml │ │ ├── check_estimate_size.expected │ │ └── src │ │ │ └── lib.rs │ ├── first-steps-v2 │ │ ├── Cargo.toml │ │ ├── src │ │ │ └── lib.rs │ │ ├── verify_success.expected │ │ └── will_fail.expected │ ├── kinds-of-failure │ │ ├── Cargo.toml │ │ ├── add_overflow.expected │ │ ├── bound_check.expected │ │ ├── midpoint_overflow.expected │ │ └── src │ │ │ ├── bounds_check.rs │ │ │ ├── lib.rs │ │ │ ├── overflow.rs │ │ │ └── overflow_quicksort.rs │ └── loops-unwinding │ │ ├── Cargo.toml │ │ ├── check_initialize_prefix.expected │ │ └── src │ │ └── lib.rs │ ├── undefined-behaviour.md │ ├── usage.md │ └── verification-results.md ├── favicon.ico ├── kani-compiler ├── Cargo.lock ├── Cargo.toml ├── README.md ├── build.rs └── src │ ├── args.rs │ ├── codegen_aeneas_llbc │ ├── compiler_interface.rs │ ├── mir_to_ullbc │ │ └── mod.rs │ └── mod.rs │ ├── codegen_cprover_gotoc │ ├── codegen │ │ ├── assert.rs │ │ ├── block.rs │ │ ├── contract.rs │ │ ├── foreign_function.rs │ │ ├── function.rs │ │ ├── intrinsic.rs │ │ ├── mod.rs │ │ ├── operand.rs │ │ ├── place.rs │ │ ├── rvalue.rs │ │ ├── source_region.rs │ │ ├── span.rs │ │ ├── statement.rs │ │ ├── static_var.rs │ │ ├── ty_stable.rs │ │ └── typ.rs │ ├── compiler_interface.rs │ ├── context │ │ ├── current_fn.rs │ │ ├── goto_ctx.rs │ │ ├── mod.rs │ │ └── vtable_ctx.rs │ ├── mod.rs │ ├── overrides │ │ ├── hooks.rs │ │ └── mod.rs │ └── utils │ │ ├── debug.rs │ │ ├── float_utils.rs │ │ ├── mod.rs │ │ ├── names.rs │ │ └── utils.rs │ ├── intrinsics.rs │ ├── kani_compiler.rs │ ├── kani_middle │ ├── abi.rs │ ├── analysis.rs │ ├── attributes.rs │ ├── codegen_units.rs │ ├── coercion.rs │ ├── intrinsics.rs │ ├── kani_functions.rs │ ├── metadata.rs │ ├── mod.rs │ ├── points_to │ │ ├── mod.rs │ │ ├── points_to_analysis.rs │ │ └── points_to_graph.rs │ ├── provide.rs │ ├── reachability.rs │ ├── resolve.rs │ ├── resolve │ │ └── type_resolution.rs │ ├── stubbing │ │ ├── annotations.rs │ │ └── mod.rs │ └── transform │ │ ├── automatic.rs │ │ ├── body.rs │ │ ├── check_uninit │ │ ├── delayed_ub │ │ │ ├── initial_target_visitor.rs │ │ │ ├── instrumentation_visitor.rs │ │ │ └── mod.rs │ │ ├── mod.rs │ │ ├── ptr_uninit │ │ │ ├── mod.rs │ │ │ └── uninit_visitor.rs │ │ ├── relevant_instruction.rs │ │ └── ty_layout.rs │ │ ├── check_values.rs │ │ ├── contracts.rs │ │ ├── dump_mir_pass.rs │ │ ├── internal_mir.rs │ │ ├── kani_intrinsics.rs │ │ ├── loop_contracts.rs │ │ ├── mod.rs │ │ ├── rustc_intrinsics.rs │ │ └── stubs.rs │ ├── kani_queries │ └── mod.rs │ ├── main.rs │ └── session.rs ├── kani-dependencies ├── kani-driver ├── Cargo.toml ├── build.rs └── src │ ├── args │ ├── assess_args.rs │ ├── autoharness_args.rs │ ├── cargo.rs │ ├── common.rs │ ├── list_args.rs │ ├── mod.rs │ ├── playback_args.rs │ └── std_args.rs │ ├── args_toml.rs │ ├── assess │ ├── metadata.rs │ ├── mod.rs │ ├── scan.rs │ ├── table_builder.rs │ ├── table_failure_reasons.rs │ ├── table_promising_tests.rs │ └── table_unsupported_features.rs │ ├── autoharness │ └── mod.rs │ ├── call_cargo.rs │ ├── call_cbmc.rs │ ├── call_goto_cc.rs │ ├── call_goto_instrument.rs │ ├── call_goto_synthesizer.rs │ ├── call_single_file.rs │ ├── cbmc_output_parser.rs │ ├── cbmc_property_renderer.rs │ ├── concrete_playback │ ├── mod.rs │ ├── playback.rs │ └── test_generator.rs │ ├── coverage │ ├── cov_results.rs │ ├── cov_session.rs │ └── mod.rs │ ├── harness_runner.rs │ ├── list │ ├── collect_metadata.rs │ ├── mod.rs │ └── output.rs │ ├── main.rs │ ├── metadata.rs │ ├── project.rs │ ├── session.rs │ ├── util.rs │ └── version.rs ├── kani-logo.png ├── kani-verifier-security.public.key ├── kani_metadata ├── Cargo.toml └── src │ ├── artifact.rs │ ├── cbmc_solver.rs │ ├── harness.rs │ ├── lib.rs │ ├── unstable.rs │ └── vtable.rs ├── library ├── kani │ ├── Cargo.toml │ ├── build.rs │ ├── kani_lib.c │ └── src │ │ ├── arbitrary.rs │ │ ├── bounded_arbitrary.rs │ │ ├── concrete_playback.rs │ │ ├── contracts.rs │ │ ├── futures.rs │ │ ├── invariant.rs │ │ ├── lib.rs │ │ ├── models │ │ └── mod.rs │ │ ├── shadow.rs │ │ ├── tuple.rs │ │ └── vec.rs ├── kani_core │ ├── Cargo.toml │ └── src │ │ ├── arbitrary.rs │ │ ├── arbitrary │ │ ├── pointer.rs │ │ └── slice.rs │ │ ├── bounded_arbitrary.rs │ │ ├── float.rs │ │ ├── lib.rs │ │ ├── mem.rs │ │ ├── mem_init.rs │ │ └── models.rs ├── kani_macros │ ├── Cargo.toml │ ├── build.rs │ └── src │ │ ├── derive.rs │ │ ├── derive_bounded.rs │ │ ├── lib.rs │ │ └── sysroot │ │ ├── contracts │ │ ├── assert.rs │ │ ├── bootstrap.rs │ │ ├── check.rs │ │ ├── helpers.rs │ │ ├── initialize.rs │ │ ├── mod.rs │ │ ├── replace.rs │ │ └── shared.rs │ │ └── loop_contracts │ │ └── mod.rs └── std │ ├── Cargo.toml │ └── src │ ├── lib.rs │ └── process.rs ├── papers └── vstte2024 │ ├── README.md │ ├── paper.bib │ └── paper.tex ├── rfc ├── book.toml └── src │ ├── SUMMARY.md │ ├── intro.md │ ├── rfcs │ ├── 0001-mir-linker.md │ ├── 0002-function-stubbing.md │ ├── 0003-cover-statement.md │ ├── 0004-loop-contract-synthesis.md │ ├── 0005-should-panic-attr.md │ ├── 0006-unstable-api.md │ ├── 0007-global-conditions.md │ ├── 0008-line-coverage.md │ ├── 0009-function-contracts.md │ ├── 0010-quantifiers.md │ ├── 0011-source-coverage.md │ ├── 0012-loop-contracts.md │ └── 0013-list.md │ └── template.md ├── rust-toolchain.toml ├── rustfmt.toml ├── scripts ├── assess-scan-regression.sh ├── build-docs.sh ├── cargo-kani ├── check-cbmc-version.py ├── check_kissat_version.sh ├── ci │ ├── Dockerfile.bundle-release-24-04 │ ├── Dockerfile.bundle-test-al2 │ ├── Dockerfile.bundle-test-nixos │ ├── Dockerfile.bundle-test-ubuntu-20-04 │ ├── Dockerfile.bundle-test-ubuntu-20-04-alt │ ├── Dockerfile.bundle-test-ubuntu-22-04 │ ├── Dockerfile.bundle-test-ubuntu-24-04 │ ├── copyright-exclude │ ├── copyright_check.py │ └── run-copyright-check.sh ├── codegen-firecracker.sh ├── exps │ └── assess-scan-on-repos.sh ├── gen_benchcomp_schemas.py ├── kani ├── kani-fmt.sh ├── kani-llbc-regression.sh ├── kani-perf.sh ├── kani-regression.sh ├── kani-slow-tests.sh ├── pyproject.toml ├── run-autopep8.sh ├── run-clang-format.sh ├── setup │ ├── al2 │ │ ├── install_cbmc.sh │ │ └── install_deps.sh │ ├── install_kissat.sh │ ├── install_rustup.sh │ ├── macos-10.15 │ ├── macos-11 │ ├── macos-12 │ ├── macos-13 │ ├── macos-14 │ ├── macos │ │ ├── install_cbmc.sh │ │ └── install_deps.sh │ ├── ubuntu-20.04 │ │ ├── install_cbmc.sh │ │ ├── install_deps.sh │ │ └── install_doc_deps.sh │ ├── ubuntu-22.04 │ ├── ubuntu-24.04 │ └── ubuntu │ │ ├── install_cbmc.sh │ │ ├── install_deps.sh │ │ └── install_doc_deps.sh └── toolchain_update.sh ├── src ├── bin │ ├── cargo_kani.rs │ └── kani.rs ├── cmd.rs ├── lib.rs ├── os_hacks.rs └── setup.rs ├── tests ├── .gitignore ├── README.md ├── assess-scan-test-scaffold │ ├── README.md │ ├── bar │ │ ├── Cargo.toml │ │ └── src │ │ │ └── lib.rs │ ├── compile_error │ │ ├── Cargo.toml │ │ └── src │ │ │ └── lib.rs │ ├── foo │ │ ├── Cargo.toml │ │ └── src │ │ │ └── lib.rs │ └── manifest_error │ │ ├── Cargo.toml │ │ └── src │ │ └── lib.rs ├── cargo-coverage │ └── simple-lib │ │ ├── Cargo.toml │ │ ├── src │ │ ├── lib.rs │ │ └── pair.rs │ │ ├── test_one_plus_two.expected │ │ └── test_sum.expected ├── cargo-kani │ ├── .gitignore │ ├── asm │ │ ├── global │ │ │ ├── Cargo.toml │ │ │ ├── calls_crate_with_global_asm.expected │ │ │ ├── crate_with_global_asm │ │ │ │ ├── Cargo.toml │ │ │ │ └── src │ │ │ │ │ └── lib.rs │ │ │ ├── reads_static_var_in_crate_with_global_asm.expected │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── global_error │ │ │ ├── Cargo.toml │ │ │ ├── crate_with_global_asm │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ │ ├── doesnt_call_crate_with_global_asm.expected │ │ │ └── src │ │ │ └── lib.rs │ ├── assert-reach │ │ ├── Cargo.toml │ │ ├── foo │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── src │ │ │ └── lib.rs │ │ └── test.expected │ ├── assess-artifacts │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── src │ │ │ └── lib.rs │ │ └── tests │ │ │ └── integ.rs │ ├── assess-workspace-artifacts │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── src │ │ │ └── lib.rs │ │ ├── subpackage │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── tests │ │ │ └── integ.rs │ ├── build-rs-plus-host-with-kani-proofs │ │ ├── README.md │ │ ├── binary │ │ │ ├── Cargo.toml │ │ │ ├── build.rs │ │ │ └── src │ │ │ │ └── main.rs │ │ └── constants │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── build-rs-works │ │ ├── Cargo.toml │ │ ├── build.rs │ │ └── src │ │ │ └── lib.rs │ ├── cargo-features-flag │ │ ├── Cargo.toml │ │ ├── src │ │ │ └── lib.rs │ │ └── trivial_success.expected │ ├── cargo-tests-dir │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── src │ │ │ └── lib.rs │ │ └── tests │ │ │ └── integ.rs │ ├── cbmc-unknown-lang-mode │ │ ├── Cargo.toml │ │ ├── src │ │ │ └── lib.rs │ │ └── test.expected │ ├── chrono_dep │ │ ├── Cargo.toml │ │ ├── main.expected │ │ └── src │ │ │ └── main.rs │ ├── codegen-scalar-with-phantom │ │ ├── Cargo.toml │ │ ├── check_phantom_data.expected │ │ └── src │ │ │ └── lib.rs │ ├── codegen-scalar-with-zsts │ │ ├── Cargo.toml │ │ ├── check_zst.expected │ │ └── src │ │ │ └── lib.rs │ ├── concrete-playback-in-verification-mode │ │ ├── Cargo.toml │ │ └── src │ │ │ └── main.rs │ ├── config │ │ ├── Cargo.toml │ │ └── src │ │ │ └── lib.rs │ ├── demos │ │ └── non-empty-range │ │ │ ├── Cargo.toml │ │ │ ├── check_range.expected │ │ │ └── src │ │ │ └── lib.rs │ ├── dependencies │ │ ├── Cargo.toml │ │ ├── check_dummy.expected │ │ └── src │ │ │ └── lib.rs │ ├── dependency-test │ │ ├── dependency3 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── diamond-dependency │ │ │ ├── Cargo.toml │ │ │ ├── dependency1 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ │ ├── dependency2 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ │ ├── dependency3 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ │ ├── harness.expected │ │ │ └── main │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── dev-depends │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── feature-flag │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── firecracker-block-example │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── requirement_2642.expected │ │ └── src │ │ │ ├── descriptor_permission_checker.rs │ │ │ ├── main.rs │ │ │ └── virtio_defs.rs │ ├── iss2857 │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── main.rs │ ├── issue-3817 │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── itoa_dep │ │ ├── Cargo.toml │ │ ├── check_unsigned.expected │ │ └── src │ │ │ └── main.rs │ ├── libc │ │ ├── Cargo.toml │ │ ├── check_create.expected │ │ └── src │ │ │ ├── lib.rs │ │ │ └── pthread_key_create.rs │ ├── mir-linker │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── nested-dirs │ │ ├── Cargo.toml │ │ ├── crate1 │ │ │ ├── Cargo.toml │ │ │ ├── a_check.expected │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── crate2 │ │ │ ├── Cargo.toml │ │ │ ├── another_check.expected │ │ │ ├── nested_crate │ │ │ ├── Cargo.toml │ │ │ ├── src │ │ │ │ └── lib.rs │ │ │ └── yet_another_check.expected │ │ │ └── src │ │ │ └── lib.rs │ ├── no-std │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── output-format │ │ ├── Cargo.toml │ │ ├── main.expected │ │ └── src │ │ │ └── main.rs │ ├── percent-encoding │ │ ├── Cargo.toml │ │ └── src │ │ │ └── lib.rs │ ├── rectangle-example │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── src │ │ │ ├── lib.rs │ │ │ └── rectangle.rs │ │ ├── stretched_rectangle_can_hold_original.expected │ │ └── stretched_rectangle_can_hold_original_fixed.expected │ ├── simple-config-toml │ │ ├── Cargo.toml │ │ ├── src │ │ │ ├── lib.rs │ │ │ └── pair.rs │ │ ├── test_one_plus_two.expected │ │ └── test_sum.expected │ ├── simple-extern │ │ ├── Cargo.toml │ │ ├── src │ │ │ ├── externs.rs │ │ │ ├── helper.c │ │ │ └── lib.rs │ │ └── test_sum.expected │ ├── simple-kissat │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── main.rs │ ├── simple-lib │ │ ├── Cargo.toml │ │ ├── src │ │ │ ├── lib.rs │ │ │ └── pair.rs │ │ ├── test_one_plus_two.expected │ │ └── test_sum.expected │ ├── simple-main │ │ ├── Cargo.toml │ │ ├── main.expected │ │ └── src │ │ │ └── main.rs │ ├── simple-proof-annotation │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── main.expected │ │ └── src │ │ │ └── main.rs │ ├── simple-unwind-annotation │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── harness_1.expected │ │ └── src │ │ │ └── lib.rs │ ├── small-vec │ │ ├── Cargo.toml │ │ ├── check_vec.expected │ │ └── src │ │ │ └── lib.rs │ ├── storage-markers │ │ ├── Cargo.toml │ │ ├── crate-with-bug │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── crate-with-harness │ │ │ ├── Cargo.toml │ │ │ ├── call_fn_with_bug.expected │ │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-do-not-resolve │ │ ├── Cargo.toml │ │ ├── harness.expected │ │ ├── other_crate1 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── other_crate2 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-double-extern-path │ │ ├── crate_a │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── crate_b │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── harness │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-extern-path │ │ ├── Cargo.toml │ │ ├── harness.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-foreign-method │ │ ├── Cargo.toml │ │ ├── main.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── main.rs │ ├── stubbing-private-foreign-function │ │ ├── Cargo.toml │ │ ├── main.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── main.rs │ ├── stubbing-public-foreign-function │ │ ├── Cargo.toml │ │ ├── main.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── main.rs │ ├── stubbing-resolve-extern-crate-as │ │ ├── Cargo.toml │ │ ├── harness.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-use-as-foreign │ │ ├── Cargo.toml │ │ ├── harness.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-use-foreign │ │ ├── Cargo.toml │ │ ├── harness.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-use-glob-foreign │ │ ├── Cargo.toml │ │ ├── harness.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-use-in-foreign │ │ ├── Cargo.toml │ │ ├── harness.expected │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-validate-random │ │ ├── Cargo.toml │ │ ├── main.expected │ │ └── src │ │ │ └── main.rs │ ├── stubbing-ws-packages │ │ ├── Cargo.toml │ │ ├── dependency │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── expected │ │ └── top │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── symlink │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── src │ │ │ └── main.rs │ │ └── target │ ├── type-mismatch │ │ ├── Cargo.toml │ │ ├── src │ │ │ └── lib.rs │ │ ├── uses_core │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── uses_std │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── unexpected_cfgs │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── main.rs │ ├── vecdeque-cve │ │ ├── Cargo.toml │ │ ├── README.md │ │ ├── abstract_remove_maintains_invariant.expected │ │ ├── abstract_reserve_maintains_invariant_with_cve.expected │ │ ├── abstract_reserve_maintains_invariant_with_cve_fixed.expected │ │ ├── issue44800.rs │ │ ├── minimal_example_with_cve_fixed.expected │ │ ├── minimal_example_with_cve_should_fail.expected │ │ ├── reserve_available_capacity_is_no_op.expected │ │ ├── reserve_available_capacity_should_fail.expected │ │ ├── reserve_more_capacity_still_works.expected │ │ ├── reserve_more_capacity_works.expected │ │ └── src │ │ │ ├── abstract_vecdeque.rs │ │ │ ├── cve.rs │ │ │ ├── fixed.rs │ │ │ ├── harness.rs │ │ │ └── raw_vec.rs │ ├── ws-crate-type-bin │ │ ├── Cargo.toml │ │ ├── bincrate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── expected │ │ └── libcrate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── ws-flag │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── libcrate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── ws-name-conflict │ │ ├── Cargo.toml │ │ ├── expected │ │ ├── lib1 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── lib2 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── ws-specified │ │ ├── Cargo.toml │ │ ├── bincrate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── expected │ │ ├── libcrate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── src │ │ │ └── lib.rs │ │ └── subcrate3 │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ └── zero-harnesses-is-success │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ └── lib.rs ├── cargo-ui │ ├── assess-error │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── debug │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── function-stubbing-trait-mismatch │ │ ├── Cargo.toml │ │ ├── main.expected │ │ └── src │ │ │ └── main.rs │ ├── multiple-harnesses │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── stubbing-flag │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── main.rs │ ├── supported-lib-types │ │ ├── cdylib-rlib │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── cdylib │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── dylib │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── lib-rlib │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── lib │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── rlib │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── src │ │ │ └── lib.rs │ │ └── staticlib │ │ │ ├── Cargo.toml │ │ │ └── expected │ ├── target-selection │ │ ├── all-targets │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── bin-target │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── bins-target │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── lib-target │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── non-test-targets │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── src │ │ │ ├── bin │ │ │ │ ├── bar.rs │ │ │ │ └── foo.rs │ │ │ └── lib.rs │ │ └── tests │ │ │ └── integ.rs │ ├── unstable-attr │ │ ├── defs │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── enabled │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── invalid │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── unstable_reachable │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ └── lib.rs │ ├── unsupported-lib-types │ │ ├── proc-macro │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ ├── rlib-pmacro │ │ │ ├── Cargo.toml │ │ │ └── expected │ │ └── src │ │ │ └── lib.rs │ ├── verbose-cmds │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── verbose │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── ws-integ-tests │ │ ├── Cargo.toml │ │ ├── all_harness │ │ │ ├── Cargo.toml │ │ │ ├── src │ │ │ │ └── lib.rs │ │ │ └── tests │ │ │ │ └── check_result.rs │ │ ├── expected │ │ ├── in_src_harness │ │ │ ├── Cargo.toml │ │ │ ├── src │ │ │ │ └── lib.rs │ │ │ └── tests │ │ │ │ └── check_result.rs │ │ └── integ_harness │ │ │ ├── Cargo.toml │ │ │ ├── src │ │ │ └── lib.rs │ │ │ └── tests │ │ │ └── check_result.rs │ ├── ws-package-exclude-unknown │ │ ├── Cargo.toml │ │ ├── bin_package │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── expected │ │ ├── lib_package │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── main.rs │ ├── ws-package-exclude │ │ ├── Cargo.toml │ │ ├── bin_package │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── expected │ │ ├── lib_package │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── main.rs │ ├── ws-package-select-unknown │ │ ├── Cargo.toml │ │ ├── bin_package │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── expected │ │ ├── lib_package │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── main.rs │ └── ws-package-select │ │ ├── Cargo.toml │ │ ├── bin_package │ │ ├── Cargo.toml │ │ └── src │ │ │ └── main.rs │ │ ├── expected │ │ ├── lib_package │ │ ├── Cargo.toml │ │ └── src │ │ │ └── lib.rs │ │ └── src │ │ └── main.rs ├── coverage │ ├── abort │ │ ├── expected │ │ └── main.rs │ ├── assert │ │ ├── expected │ │ └── test.rs │ ├── assert_eq │ │ ├── expected │ │ └── test.rs │ ├── assert_ne │ │ ├── expected │ │ └── test.rs │ ├── break │ │ ├── expected │ │ └── main.rs │ ├── compare │ │ ├── expected │ │ └── main.rs │ ├── contradiction │ │ ├── expected │ │ └── main.rs │ ├── debug-assert │ │ ├── expected │ │ └── main.rs │ ├── div-zero │ │ ├── expected │ │ └── test.rs │ ├── early-return │ │ ├── expected │ │ └── main.rs │ ├── if-statement-multi │ │ ├── expected │ │ └── test.rs │ ├── if-statement │ │ ├── expected │ │ └── main.rs │ ├── known_issues │ │ ├── assert_uncovered_end │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── assume_assert │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── out-of-bounds │ │ │ ├── expected │ │ │ └── test.rs │ │ └── variant │ │ │ ├── expected │ │ │ └── main.rs │ ├── multiple-harnesses │ │ ├── expected │ │ └── main.rs │ ├── overflow-failure │ │ ├── expected │ │ └── test.rs │ ├── overflow-full-coverage │ │ ├── expected │ │ └── test.rs │ └── while-loop-break │ │ ├── expected │ │ └── main.rs ├── expected │ ├── MemPredicates │ │ ├── adt_with_metadata.expected │ │ ├── adt_with_metadata.rs │ │ ├── fat_ptr_validity.expected │ │ ├── fat_ptr_validity.rs │ │ ├── ptr_size_validity.expected │ │ ├── ptr_size_validity.rs │ │ ├── thin_ptr_validity.expected │ │ └── thin_ptr_validity.rs │ ├── abort │ │ ├── expected │ │ └── main.rs │ ├── allocation │ │ ├── expected │ │ └── main.rs │ ├── any_vec │ │ ├── exact_length.expected │ │ ├── exact_length.rs │ │ ├── out_bounds.expected │ │ └── out_bounds.rs │ ├── arbitrary │ │ ├── duration.expected │ │ ├── duration.rs │ │ ├── enums │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── floats │ │ │ ├── non_standard_floats │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ └── standard_floats │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ ├── integers │ │ │ ├── expected │ │ │ └── main.rs │ │ └── ptrs │ │ │ ├── pointer_generator.expected │ │ │ ├── pointer_generator.rs │ │ │ ├── pointer_generator_error.expected │ │ │ ├── pointer_generator_error.rs │ │ │ ├── pointer_inbounds.expected │ │ │ └── pointer_inbounds.rs │ ├── arith-offset-i32-fail │ │ ├── expected │ │ └── main.rs │ ├── arith-offset-overflow │ │ ├── expected │ │ └── main.rs │ ├── arith-offset-u8-fail │ │ ├── expected │ │ └── main.rs │ ├── arith_checks │ │ ├── check_arith_failures.rs │ │ └── expected │ ├── array │ │ ├── expected │ │ └── main.rs │ ├── assert-arg-error │ │ ├── expected │ │ └── test.rs │ ├── assert-eq-chained │ │ ├── expected │ │ └── main.rs │ ├── assert-eq │ │ ├── expected │ │ └── main.rs │ ├── assert-location │ │ ├── assert-false │ │ │ ├── expected │ │ │ └── main.rs │ │ └── debug-assert │ │ │ ├── expected │ │ │ └── main.rs │ ├── associated-fn │ │ ├── associated_fn.rs │ │ └── expected │ ├── async_proof │ │ ├── expected │ │ └── main.rs │ ├── binop │ │ ├── expected │ │ └── main.rs │ ├── bounded-arbitrary │ │ ├── hash │ │ │ ├── hash.expected │ │ │ └── hash.rs │ │ ├── option │ │ │ ├── option.expected │ │ │ └── option.rs │ │ ├── result │ │ │ ├── result.expected │ │ │ └── result.rs │ │ ├── reverse_vec │ │ │ ├── vec.expected │ │ │ └── vec.rs │ │ └── string │ │ │ ├── string.expected │ │ │ └── string.rs │ ├── closure │ │ ├── expected │ │ └── main.rs │ ├── closure2 │ │ ├── expected │ │ └── main.rs │ ├── closure3 │ │ ├── expected │ │ └── main.rs │ ├── comp │ │ ├── expected │ │ └── main.rs │ ├── coroutines │ │ ├── as_parameter │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── expected │ │ ├── main.rs │ │ └── pin │ │ │ ├── expected │ │ │ └── main.rs │ ├── cover │ │ ├── cover-fail │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── cover-message │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── cover-pass │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── cover-undetermined │ │ │ ├── expected │ │ │ └── main.rs │ │ └── cover-unreachable │ │ │ ├── expected │ │ │ └── main.rs │ ├── dangling-ptr-println │ │ ├── main.expected │ │ └── main.rs │ ├── dead-invalid-access-via-raw │ │ ├── main.expected │ │ ├── main.rs │ │ ├── value.expected │ │ └── value.rs │ ├── dealloc │ │ └── stack │ │ │ ├── expected │ │ │ └── test.rs │ ├── derive-arbitrary │ │ ├── box │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── phantom_data │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── phantom_pinned │ │ │ ├── expected │ │ │ └── test.rs │ │ └── safety_constraint_helper │ │ │ ├── expected │ │ │ └── safety_constraint_helper.rs │ ├── derive-bounded-arbitrary │ │ ├── enum.expected │ │ ├── enum.rs │ │ ├── generic_default.expected │ │ ├── generic_default.rs │ │ ├── struct.expected │ │ └── struct.rs │ ├── derive-invariant │ │ ├── attrs_cfg_guard │ │ │ ├── attrs_cfg_guard.rs │ │ │ └── expected │ │ ├── attrs_mixed │ │ │ ├── attrs_mixed.rs │ │ │ └── expected │ │ ├── empty_struct │ │ │ ├── empty_struct.rs │ │ │ └── expected │ │ ├── generic_struct │ │ │ ├── expected │ │ │ └── generic_struct.rs │ │ ├── named_struct │ │ │ ├── expected │ │ │ └── named_struct.rs │ │ ├── safety_constraint_helper │ │ │ ├── expected │ │ │ └── safety_constraint_helper.rs │ │ ├── safety_constraint_helper_funs │ │ │ ├── expected │ │ │ └── safety_constraint_helper_funs.rs │ │ ├── safety_invariant_fail │ │ │ ├── expected │ │ │ └── safety_invariant_fail.rs │ │ ├── safety_invariant_fail_mut │ │ │ ├── expected │ │ │ └── safety_invariant_fail_mut.rs │ │ └── unnamed_struct │ │ │ ├── expected │ │ │ └── unnamed_struct.rs │ ├── dynamic-error-trait │ │ ├── expected │ │ └── main.rs │ ├── dynamic-trait-static-dispatch │ │ ├── expected │ │ └── main.rs │ ├── dynamic-trait │ │ ├── expected │ │ └── main.rs │ ├── empty │ │ ├── expected │ │ └── main.rs │ ├── enum │ │ ├── expected │ │ └── main.rs │ ├── float-nan │ │ ├── expected │ │ └── main.rs │ ├── float-to-int-in-range │ │ ├── invalid_float.expected │ │ ├── invalid_float.rs │ │ ├── invalid_int.expected │ │ └── invalid_int.rs │ ├── foreign-function │ │ ├── expected │ │ └── ffi_ptr.rs │ ├── function-contract │ │ ├── arbitrary_ensures_fail.expected │ │ ├── arbitrary_ensures_fail.rs │ │ ├── arbitrary_ensures_pass.expected │ │ ├── arbitrary_ensures_pass.rs │ │ ├── arbitrary_requires_fail.expected │ │ ├── arbitrary_requires_fail.rs │ │ ├── arbitrary_requires_pass.expected │ │ ├── arbitrary_requires_pass.rs │ │ ├── as-assertions │ │ │ ├── assert-postconditions.expected │ │ │ ├── assert-postconditions.rs │ │ │ ├── assert-preconditions.expected │ │ │ ├── assert-preconditions.rs │ │ │ ├── loops.expected │ │ │ ├── loops.rs │ │ │ ├── precedence.expected │ │ │ └── precedence.rs │ │ ├── attribute_complain.expected │ │ ├── attribute_complain.rs │ │ ├── attribute_no_complain.expected │ │ ├── attribute_no_complain.rs │ │ ├── checking_from_external_mod.expected │ │ ├── checking_from_external_mod.rs │ │ ├── checking_in_impl.expected │ │ ├── checking_in_impl.rs │ │ ├── const_fn.expected │ │ ├── const_fn.rs │ │ ├── const_fn_with_effect.expected │ │ ├── const_fn_with_effect.rs │ │ ├── const_generic_function.expected │ │ ├── const_generic_function.rs │ │ ├── diverging_loop.expected │ │ ├── diverging_loop.rs │ │ ├── fail_on_two.expected │ │ ├── fail_on_two.rs │ │ ├── gcd_failure_code.expected │ │ ├── gcd_failure_code.rs │ │ ├── gcd_failure_contract.expected │ │ ├── gcd_failure_contract.rs │ │ ├── gcd_rec_code_fail.expected │ │ ├── gcd_rec_code_fail.rs │ │ ├── gcd_rec_comparison_pass.expected │ │ ├── gcd_rec_comparison_pass.rs │ │ ├── gcd_rec_contract_fail.expected │ │ ├── gcd_rec_contract_fail.rs │ │ ├── gcd_rec_replacement_pass.expected │ │ ├── gcd_rec_replacement_pass.rs │ │ ├── gcd_rec_simple_pass.expected │ │ ├── gcd_rec_simple_pass.rs │ │ ├── gcd_replacement_fail.expected │ │ ├── gcd_replacement_fail.rs │ │ ├── gcd_replacement_pass.expected │ │ ├── gcd_replacement_pass.rs │ │ ├── gcd_success.expected │ │ ├── gcd_success.rs │ │ ├── generic_infinity_recursion.expected │ │ ├── generic_infinity_recursion.rs │ │ ├── history │ │ │ ├── block.expected │ │ │ ├── block.rs │ │ │ ├── clone_pass.expected │ │ │ ├── clone_pass.rs │ │ │ ├── copy_pass.expected │ │ │ ├── copy_pass.rs │ │ │ ├── function_call.expected │ │ │ ├── function_call.rs │ │ │ ├── no_modifies.expected │ │ │ ├── no_modifies.rs │ │ │ ├── old_old.expected │ │ │ ├── old_old.rs │ │ │ ├── respects-preconditions │ │ │ │ ├── ensures_before_requires.expected │ │ │ │ ├── ensures_before_requires.rs │ │ │ │ ├── modifies.expected │ │ │ │ ├── modifies.rs │ │ │ │ ├── requires_before_ensures.expected │ │ │ │ └── requires_before_ensures.rs │ │ │ ├── side_effect.expected │ │ │ ├── side_effect.rs │ │ │ ├── simple_fail.expected │ │ │ ├── simple_fail.rs │ │ │ ├── simple_pass.expected │ │ │ ├── simple_pass.rs │ │ │ ├── simple_pass_twice.expected │ │ │ ├── simple_pass_twice.rs │ │ │ ├── stub.expected │ │ │ ├── stub.rs │ │ │ └── ui │ │ │ │ ├── no_args.expected │ │ │ │ ├── no_args.rs │ │ │ │ ├── noncopy_ignore.expected │ │ │ │ ├── noncopy_ignore.rs │ │ │ │ ├── old_result.expected │ │ │ │ ├── old_result.rs │ │ │ │ ├── statement.expected │ │ │ │ └── statement.rs │ │ ├── interior-mutability │ │ │ ├── api │ │ │ │ ├── cell.expected │ │ │ │ ├── cell.rs │ │ │ │ ├── cell_stub.expected │ │ │ │ ├── cell_stub.rs │ │ │ │ ├── unsafecell.expected │ │ │ │ └── unsafecell.rs │ │ │ └── whole-struct │ │ │ │ ├── cell.expected │ │ │ │ ├── cell.rs │ │ │ │ ├── oncecell.expected │ │ │ │ ├── oncecell.rs │ │ │ │ ├── refcell.expected │ │ │ │ ├── refcell.rs │ │ │ │ ├── unsafecell.expected │ │ │ │ └── unsafecell.rs │ │ ├── missing_contract_for_check.expected │ │ ├── missing_contract_for_check.rs │ │ ├── missing_contract_for_replace.expected │ │ ├── missing_contract_for_replace.rs │ │ ├── modifies │ │ │ ├── check_invalid_modifies.expected │ │ │ ├── check_invalid_modifies.rs │ │ │ ├── check_only_verification.expected │ │ │ ├── check_only_verification.rs │ │ │ ├── expr_pass.expected │ │ │ ├── expr_pass.rs │ │ │ ├── expr_replace_fail.expected │ │ │ ├── expr_replace_fail.rs │ │ │ ├── expr_replace_pass.expected │ │ │ ├── expr_replace_pass.rs │ │ │ ├── fail_missing_recursion_attr.expected │ │ │ ├── fail_missing_recursion_attr.rs │ │ │ ├── field_pass.expected │ │ │ ├── field_pass.rs │ │ │ ├── field_replace_fail.expected │ │ │ ├── field_replace_fail.rs │ │ │ ├── field_replace_pass.expected │ │ │ ├── field_replace_pass.rs │ │ │ ├── global_fail.expected │ │ │ ├── global_fail.rs │ │ │ ├── global_pass.expected │ │ │ ├── global_pass.rs │ │ │ ├── global_replace_fail.expected │ │ │ ├── global_replace_fail.rs │ │ │ ├── global_replace_pass.expected │ │ │ ├── global_replace_pass.rs │ │ │ ├── havoc_pass.expected │ │ │ ├── havoc_pass.rs │ │ │ ├── havoc_pass_reordered.expected │ │ │ ├── havoc_pass_reordered.rs │ │ │ ├── mistake_condition_return.expected │ │ │ ├── mistake_condition_return.rs │ │ │ ├── refcell_fixme.rs │ │ │ ├── simple_fail.expected │ │ │ ├── simple_fail.rs │ │ │ ├── simple_only_verification.expected │ │ │ ├── simple_only_verification.rs │ │ │ ├── simple_only_verification_modifies.expected │ │ │ ├── simple_only_verification_modifies.rs │ │ │ ├── simple_pass.expected │ │ │ ├── simple_pass.rs │ │ │ ├── stmt_expr.expected │ │ │ ├── stmt_expr.rs │ │ │ ├── unique_arguments.expected │ │ │ ├── unique_arguments.rs │ │ │ ├── unsafe_rc_fixme.rs │ │ │ ├── vec_pass.expected │ │ │ ├── vec_pass.rs │ │ │ ├── zst_pass.expected │ │ │ └── zst_pass.rs │ │ ├── modifies_fat_pointer │ │ │ ├── nondeterministic_size.expected │ │ │ ├── nondeterministic_size.rs │ │ │ ├── slice_of_array.expected │ │ │ ├── slice_of_array.rs │ │ │ ├── string_rewrite_ignore.rs │ │ │ ├── u32slice.expected │ │ │ ├── u32slice.rs │ │ │ ├── u8slice.expected │ │ │ └── u8slice.rs │ │ ├── multiple_replace_fail.expected │ │ ├── multiple_replace_fail.rs │ │ ├── multiple_replace_pass.expected │ │ ├── multiple_replace_pass.rs │ │ ├── pattern_use.expected │ │ ├── pattern_use.rs │ │ ├── prohibit-pointers │ │ │ ├── allowed_const_ptr.expected │ │ │ ├── allowed_const_ptr.rs │ │ │ ├── allowed_mut_ref.expected │ │ │ ├── allowed_mut_ref.rs │ │ │ ├── allowed_mut_return_ref.expected │ │ │ ├── allowed_mut_return_ref.rs │ │ │ ├── allowed_ref.expected │ │ │ ├── allowed_ref.rs │ │ │ ├── hidden.expected │ │ │ ├── hidden.rs │ │ │ ├── plain_pointer.expected │ │ │ ├── plain_pointer.rs │ │ │ ├── return_pointer.expected │ │ │ └── return_pointer.rs │ │ ├── simple_ensures_fail.expected │ │ ├── simple_ensures_fail.rs │ │ ├── simple_ensures_pass.expected │ │ ├── simple_ensures_pass.rs │ │ ├── simple_ensures_pass_no_annotation.expected │ │ ├── simple_ensures_pass_no_annotation.rs │ │ ├── simple_replace_fail.expected │ │ ├── simple_replace_fail.rs │ │ ├── simple_replace_pass.expected │ │ ├── simple_replace_pass.rs │ │ ├── trait_impls │ │ │ ├── associated_fn.expected │ │ │ ├── associated_fn.rs │ │ │ ├── methods.expected │ │ │ └── methods.rs │ │ ├── type_annotation_needed.expected │ │ ├── type_annotation_needed.rs │ │ ├── valid_ptr.expected │ │ └── valid_ptr.rs │ ├── function-stubbing-error │ │ ├── expected │ │ └── main.rs │ ├── function-stubbing-no-harness │ │ ├── expected │ │ └── main.rs │ ├── generics │ │ ├── expected │ │ └── main.rs │ ├── intrinsics │ │ ├── align_of_dst.expected │ │ ├── align_of_dst.rs │ │ ├── breakpoint │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── copy-nonoverlapping │ │ │ ├── copy-overflow │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ ├── copy-overlapping │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ ├── copy-unaligned-dst │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ ├── copy-unaligned-src │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ ├── copy-unreadable-src │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ └── copy-unwritable-dst │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ ├── copy │ │ │ ├── copy-overflow │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ ├── copy-unaligned-dst │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ ├── copy-unaligned-src │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ ├── copy-unreadable-src │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ │ └── copy-unwritable-dst │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ ├── float-to-int │ │ │ ├── non_finite.expected │ │ │ ├── non_finite.rs │ │ │ ├── oob.expected │ │ │ ├── oob.rs │ │ │ ├── oob_f128.expected │ │ │ └── oob_f128.rs │ │ ├── offset-same-object │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── ptr_offset_from_unsigned │ │ │ ├── check_invariant_violation.rs │ │ │ └── expected │ │ ├── simd-arith-overflows │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-cmp-result-type-is-diff-size │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-div-div-zero │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-div-rem-overflow │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-extract-wrong-type │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-insert-wrong-type │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-rem-div-zero │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-result-type-is-float │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-shl-shift-negative │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-shl-shift-too-large │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-shr-shift-negative │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-shr-shift-too-large │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-shuffle-indexes-out │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-shuffle-result-type-is-diff-size │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── simd-shuffle-result-type-is-diff-type │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── size_of_dst.expected │ │ ├── size_of_dst.rs │ │ ├── sub_with_overflow_ice_fixme │ │ │ ├── arithmetic_zst_fixme.rs │ │ │ └── expected │ │ ├── transmute_diff_size.expected │ │ ├── transmute_diff_size.rs │ │ ├── transmute_unchecked_size.expected │ │ ├── transmute_unchecked_size.rs │ │ ├── unreachable │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── volatile_load │ │ │ └── unaligned │ │ │ │ ├── expected │ │ │ │ └── main.rs │ │ └── write_bytes │ │ │ ├── out-of-bounds │ │ │ ├── expected │ │ │ └── main.rs │ │ │ ├── overflow │ │ │ ├── expected │ │ │ └── main.rs │ │ │ └── unaligned │ │ │ ├── expected │ │ │ └── main.rs │ ├── issue-2239 │ │ ├── issue_2239.expected │ │ └── issue_2239.rs │ ├── issue-2589 │ │ ├── issue_2589.expected │ │ └── issue_2589.rs │ ├── issue-3022 │ │ ├── issue_3022.expected │ │ └── issue_3022.rs │ ├── issue-3571 │ │ ├── issue_3571.expected │ │ └── issue_3571.rs │ ├── iterator │ │ ├── expected │ │ └── main.rs │ ├── loop-backedge │ │ ├── expected │ │ └── test.rs │ ├── loop-contract │ │ ├── contract_proof_function_with_loop.expected │ │ ├── contract_proof_function_with_loop.rs │ │ ├── count_zero.expected │ │ ├── count_zero.rs │ │ ├── count_zero_loop_contracts_disable.expected │ │ ├── count_zero_loop_contracts_disable.rs │ │ ├── fixme_box.expected │ │ ├── fixme_box.rs │ │ ├── function_call_with_loop.expected │ │ ├── function_call_with_loop.rs │ │ ├── function_with_loop_no_assertion.expected │ │ ├── function_with_loop_no_assertion.rs │ │ ├── loop_with_old.expected │ │ ├── loop_with_old.rs │ │ ├── loop_with_old_and_prev.expected │ │ ├── loop_with_old_and_prev.rs │ │ ├── loop_with_prev.expected │ │ ├── loop_with_prev.rs │ │ ├── loop_with_prev_break_first_iter.expected │ │ ├── loop_with_prev_break_first_iter.rs │ │ ├── loop_with_true_invariant.expected │ │ ├── loop_with_true_invariant.rs │ │ ├── memchar_naive.expected │ │ ├── memchar_naive.rs │ │ ├── multiple_loops.expected │ │ ├── multiple_loops.rs │ │ ├── simple_loop_loop.expected │ │ ├── simple_loop_loop.rs │ │ ├── simple_while_loop.expected │ │ ├── simple_while_loop.rs │ │ ├── simple_while_loop_not_enabled.expected │ │ ├── simple_while_loop_not_enabled.rs │ │ ├── small_slice_eq.expected │ │ ├── small_slice_eq.rs │ │ ├── struct_projection.expected │ │ └── struct_projection.rs │ ├── never-return │ │ ├── check_never.rs │ │ └── expected │ ├── niche │ │ ├── expected │ │ └── main.rs │ ├── niche2 │ │ ├── expected │ │ └── main.rs │ ├── nondet-slice-i32-oob │ │ ├── expected │ │ └── main.rs │ ├── nondet-slice-len │ │ ├── expected │ │ └── main.rs │ ├── nondet-slice-u8-oob │ │ ├── expected │ │ └── main.rs │ ├── nondet │ │ ├── expected │ │ └── main.rs │ ├── object-bits │ │ └── insufficient │ │ │ ├── expected │ │ │ └── main.rs │ ├── offset-bounds-check │ │ ├── fixme_offset_usize.expected │ │ ├── fixme_offset_usize.rs │ │ ├── offset_from.expected │ │ ├── offset_from.rs │ │ ├── offset_from_unsigned.expected │ │ ├── offset_from_unsigned.rs │ │ ├── out_of_bounds_ub_check.expected │ │ ├── out_of_bounds_ub_check.rs │ │ ├── start_from_oob.expected │ │ └── start_from_oob.rs │ ├── offset-bytes-overflow │ │ ├── expected │ │ └── main.rs │ ├── offset-from-bytes-overflow │ │ ├── expected │ │ └── main.rs │ ├── offset-from-distance-check │ │ ├── expected │ │ └── main.rs │ ├── offset-i32-fail │ │ ├── expected │ │ └── main.rs │ ├── offset-invalid-args │ │ ├── invalid_offset_ty.expected │ │ ├── invalid_offset_ty.rs │ │ ├── non_ptr_arg.expected │ │ └── non_ptr_arg.rs │ ├── offset-overflows-isize │ │ ├── expected │ │ └── main.rs │ ├── offset-u8-fail │ │ ├── expected │ │ └── main.rs │ ├── offset-wraps-around │ │ ├── expected │ │ └── main.rs │ ├── one-assert │ │ ├── expected │ │ └── test.rs │ ├── panic │ │ ├── arg-error │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── expected │ │ ├── panic-2018 │ │ │ ├── expected │ │ │ └── messages.rs │ │ ├── panic-2021 │ │ │ ├── expected │ │ │ └── messages.rs │ │ └── test.rs │ ├── per-harness │ │ ├── drop.rs │ │ └── expected │ ├── pointer-overflow │ │ ├── expected │ │ └── main.rs │ ├── ptr-offset-overflow-bytes │ │ ├── expected │ │ └── main.rs │ ├── ptr_to_ref_cast │ │ ├── alignment │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── expected │ │ ├── invalid │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── ptr_to_ref_cast.rs │ │ ├── slice │ │ │ ├── expected │ │ │ └── test.rs │ │ └── str │ │ │ ├── expected │ │ │ └── test.rs │ ├── quantifiers │ │ ├── assert_with_exists_fail.expected │ │ ├── assert_with_exists_fail.rs │ │ ├── assert_with_exists_pass.expected │ │ ├── assert_with_exists_pass.rs │ │ ├── assert_with_forall_fail.expected │ │ ├── assert_with_forall_fail.rs │ │ ├── assert_with_forall_pass.expected │ │ ├── assert_with_forall_pass.rs │ │ ├── assume_with_exists_fail.expected │ │ ├── assume_with_exists_fail.rs │ │ ├── contracts_fail.expected │ │ ├── contracts_fail.rs │ │ ├── quantifier_with_no_external_variable.expected │ │ └── quantifier_with_no_external_variable.rs │ ├── raw_slice │ │ ├── expected │ │ └── slice.rs │ ├── raw_slice_c_repr │ │ ├── expected │ │ └── slice.rs │ ├── raw_slice_packed │ │ ├── expected │ │ └── slice.rs │ ├── reach │ │ ├── assert │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── assert_eq │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── assert_ne │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── bounds │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── check_id │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── debug-assert-eq │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── debug-assert-ne │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── debug-assert │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── div-zero │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── overflow-neg │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── overflow │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── rem-zero │ │ │ ├── reachable_fail │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable_pass │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ └── turned-off │ │ │ ├── expected │ │ │ └── test.rs │ ├── realloc │ │ ├── null │ │ │ ├── expected │ │ │ └── main.rs │ │ ├── shrink │ │ │ ├── expected │ │ │ └── main.rs │ │ └── zero_size │ │ │ ├── expected │ │ │ └── main.rs │ ├── references │ │ ├── expected │ │ └── main.rs │ ├── report │ │ ├── insufficient_unwind │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── uncolor │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── unsupported │ │ │ ├── failure │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── reachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── unreachable │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ └── verification-time │ │ │ ├── expected │ │ │ └── main.rs │ ├── safety-constraint-attribute │ │ ├── abstract-value │ │ │ ├── abstract-value.rs │ │ │ └── expected │ │ ├── check-arbitrary │ │ │ ├── check-arbitrary.rs │ │ │ └── expected │ │ ├── check-invariant │ │ │ ├── check-invariant.rs │ │ │ └── expected │ │ └── grade-example │ │ │ ├── expected │ │ │ └── grade-example.rs │ ├── shadow │ │ ├── slices │ │ │ ├── slice_of_array │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ ├── slice_reverse │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ │ └── slice_split │ │ │ │ ├── expected │ │ │ │ └── test.rs │ │ ├── uninit_array │ │ │ ├── expected │ │ │ └── test.rs │ │ ├── unsupported_num_objects │ │ │ ├── expected │ │ │ └── test.rs │ │ └── unsupported_object_size │ │ │ ├── expected │ │ │ └── test.rs │ ├── slice-pattern-array │ │ ├── expected │ │ └── main.rs │ ├── slice │ │ ├── expected │ │ └── main.rs │ ├── slice_c_str │ │ ├── c_str_fixme.rs │ │ └── expected │ ├── static-mutable-struct │ │ ├── expected │ │ └── main.rs │ ├── static-mutable │ │ ├── expected │ │ └── main.rs │ ├── static │ │ ├── expected │ │ └── main.rs │ ├── stubbing-ambiguous-path │ │ ├── expected │ │ └── main.rs │ ├── stubbing-different-sets │ │ ├── stubbing.expected │ │ └── stubbing.rs │ ├── test1 │ │ ├── expected │ │ └── main.rs │ ├── test2 │ │ ├── expected │ │ └── main.rs │ ├── test3 │ │ ├── expected │ │ └── main.rs │ ├── test4 │ │ ├── expected │ │ └── main.rs │ ├── test5 │ │ ├── expected │ │ └── main.rs │ ├── test6 │ │ ├── expected │ │ └── main.rs │ ├── trait-receiver │ │ ├── expected │ │ └── receiver_types.rs │ ├── transmute │ │ ├── expected │ │ └── main.rs │ ├── uninit │ │ ├── access-padding-uninit │ │ │ ├── access-padding-enum-diverging-variants.expected │ │ │ ├── access-padding-enum-diverging-variants.rs │ │ │ ├── access-padding-enum-multiple-variants.expected │ │ │ ├── access-padding-enum-multiple-variants.rs │ │ │ ├── access-padding-enum-single-field.expected │ │ │ ├── access-padding-enum-single-field.rs │ │ │ ├── access-padding-enum-single-variant.expected │ │ │ ├── access-padding-enum-single-variant.rs │ │ │ ├── access-padding-uninit.expected │ │ │ └── access-padding-uninit.rs │ │ ├── access-padding-via-cast │ │ │ ├── access-padding-via-cast.rs │ │ │ └── expected │ │ ├── access-static-padding.expected │ │ ├── access-static-padding.rs │ │ ├── alloc-to-slice │ │ │ ├── alloc-to-slice.rs │ │ │ └── expected │ │ ├── atomic │ │ │ ├── atomic.rs │ │ │ └── expected │ │ ├── copy │ │ │ ├── copy_without_padding.expected │ │ │ ├── copy_without_padding.rs │ │ │ ├── expose_padding_via_copy.expected │ │ │ ├── expose_padding_via_copy.rs │ │ │ ├── expose_padding_via_copy_convoluted.expected │ │ │ ├── expose_padding_via_copy_convoluted.rs │ │ │ ├── expose_padding_via_non_byte_copy.expected │ │ │ ├── expose_padding_via_non_byte_copy.rs │ │ │ ├── non_byte_copy_without_padding.expected │ │ │ ├── non_byte_copy_without_padding.rs │ │ │ ├── read_after_copy.expected │ │ │ └── read_after_copy.rs │ │ ├── delayed-ub-overapprox.expected │ │ ├── delayed-ub-overapprox.rs │ │ ├── delayed-ub │ │ │ ├── delayed-ub.expected │ │ │ ├── delayed-ub.rs │ │ │ ├── slices_fixme.expected │ │ │ └── slices_fixme.rs │ │ ├── fixme_unions.rs │ │ ├── intrinsics │ │ │ ├── expected │ │ │ └── intrinsics.rs │ │ ├── multiple-instrumentations.expected │ │ ├── multiple-instrumentations.rs │ │ ├── transmute-padding │ │ │ ├── expected │ │ │ └── transmute_padding.rs │ │ ├── unions.expected │ │ ├── unions.rs │ │ ├── vec-read-bad-len │ │ │ ├── expected │ │ │ └── vec-read-bad-len.rs │ │ ├── vec-read-semi-init │ │ │ ├── expected │ │ │ └── vec-read-semi-init.rs │ │ └── vec-read-uninit │ │ │ ├── expected │ │ │ └── vec-read-uninit.rs │ ├── unreachable │ │ ├── expected │ │ └── unreach_msg.rs │ ├── unsupported-fatptr-comparison │ │ ├── expected │ │ └── vtable_comparison.rs │ ├── unwind-flags-conflict │ │ ├── expected │ │ └── main.rs │ ├── unwind-recursion-fail │ │ ├── expected │ │ └── main.rs │ ├── unwind_tip │ │ ├── expected │ │ └── main.rs │ ├── valid-value-checks │ │ ├── can_dereference.expected │ │ ├── can_dereference.rs │ │ ├── char_validity.expected │ │ ├── char_validity.rs │ │ ├── constants.expected │ │ ├── constants.rs │ │ ├── custom_niche.expected │ │ ├── custom_niche.rs │ │ ├── maybe_uninit.expected │ │ ├── maybe_uninit.rs │ │ ├── non_null.expected │ │ ├── non_null.rs │ │ ├── write_bytes.expected │ │ ├── write_bytes.rs │ │ ├── write_invalid.expected │ │ └── write_invalid.rs │ ├── vec │ │ ├── expected │ │ └── main.rs │ ├── vecdq │ │ ├── expected │ │ └── main.rs │ ├── verbose-cmds │ │ ├── expected │ │ └── main.rs │ ├── wrapping-offset-bytes-overflow │ │ ├── expected │ │ └── main.rs │ └── zst │ │ ├── expected │ │ └── main.rs ├── firecracker │ ├── micro-http-parsed-request │ │ └── ignore-main.rs │ └── virtio-balloon-compact │ │ └── ignore-main.rs ├── kani-docs ├── kani-fixme ├── kani │ ├── AggregateRvalue │ │ ├── dyn_ptr.rs │ │ └── slice_ptr.rs │ ├── Arbitrary │ │ ├── arbitrary_impls.rs │ │ ├── arbitrary_structs.rs │ │ ├── nonzero.rs │ │ ├── ops.rs │ │ ├── option.rs │ │ ├── result.rs │ │ └── vector_wrapper.rs │ ├── ArithEqualOperators │ │ └── main.rs │ ├── ArithOperators │ │ ├── div_fail.rs │ │ ├── div_zero_fail.rs │ │ ├── main.rs │ │ ├── rem_fail.rs │ │ ├── rem_float_fixme.rs │ │ ├── rem_zero_fail.rs │ │ ├── unchecked.rs │ │ ├── unchecked_add_fail.rs │ │ ├── unchecked_mul_fail.rs │ │ ├── unchecked_sub_fail.rs │ │ ├── unsafe.rs │ │ ├── unsafe_add_fail.rs │ │ ├── unsafe_mul_fail.rs │ │ ├── unsafe_sub_fail.rs │ │ └── wrapping.rs │ ├── Array │ │ ├── array-zst.rs │ │ ├── array_init.rs │ │ └── repeat_const_generic.rs │ ├── Asm │ │ └── main_fixme.rs │ ├── Assert │ │ ├── assert2018.rs │ │ ├── bool_ref.rs │ │ ├── in_const_fn.rs │ │ ├── in_const_fn_args.rs │ │ ├── in_match.rs │ │ ├── multiple_asserts.rs │ │ └── var_in_arg.rs │ ├── AssociatedTypes │ │ ├── associated_types.rs │ │ ├── into_iter.rs │ │ └── type_of.rs │ ├── Assume │ │ └── main.rs │ ├── AsyncAwait │ │ ├── main.rs │ │ └── spawn.rs │ ├── BinOp_Offset │ │ ├── main.rs │ │ └── main_fail.rs │ ├── BitwiseArithOperators │ │ ├── bool.rs │ │ └── main.rs │ ├── BitwiseEqualOperators │ │ └── main.rs │ ├── BitwiseShiftOperators │ │ ├── Usize │ │ │ └── main.rs │ │ ├── main.rs │ │ └── shift_neg_vals.rs │ ├── Bool-BoolOperators │ │ └── main.rs │ ├── Cast │ │ ├── cast_abstract_args_to_concrete.rs │ │ ├── from_be_bytes.rs │ │ ├── main.rs │ │ └── path.rs │ ├── Cleanup │ │ ├── assert.rs │ │ └── unwind_fixme.rs │ ├── Closure │ │ ├── boxed_closure.rs │ │ ├── closure_ptr.rs │ │ ├── fn_mut_closure.rs │ │ ├── main.rs │ │ ├── tupled_closure.rs │ │ ├── zst_param.rs │ │ └── zst_unwrap.rs │ ├── CodegenConstValue │ │ ├── bigints.rs │ │ ├── main.rs │ │ └── u128.rs │ ├── CodegenMisc │ │ ├── main.rs │ │ └── missing_mut_fn.rs │ ├── CodegenStatic │ │ ├── main.rs │ │ └── struct.rs │ ├── ConstEval │ │ ├── limit.rs │ │ └── slices.rs │ ├── CopyNonOverlapping │ │ └── copy.rs │ ├── Coroutines │ │ ├── issue-1593.rs │ │ ├── issue-2434.rs │ │ ├── main.rs │ │ └── rustc-coroutine-tests │ │ │ ├── conditional-drop.rs │ │ │ ├── control-flow.rs │ │ │ ├── env-drop.rs │ │ │ ├── iterator-count.rs │ │ │ ├── live-upvar-across-yield.rs │ │ │ ├── moved-locals-size.rs │ │ │ ├── moved-locals.rs │ │ │ ├── nested-generators.rs │ │ │ ├── niche-in-generator-size.rs │ │ │ ├── niche-in-generator.rs │ │ │ ├── overlap-locals-size.rs │ │ │ ├── overlap-locals.rs │ │ │ ├── resume-arg-size.rs │ │ │ ├── resume-arg.rs │ │ │ ├── resume-live-across-yield.rs │ │ │ ├── smoke-resume-args.rs │ │ │ ├── smoke.rs │ │ │ ├── static-generator.rs │ │ │ └── yield-in-box.rs │ ├── Count │ │ └── Unstable │ │ │ ├── Ctlz │ │ │ ├── bounds.rs │ │ │ └── main.rs │ │ │ └── Cttz │ │ │ ├── bounds.rs │ │ │ └── main.rs │ ├── Cover │ │ ├── simp_satisfied.rs │ │ └── simp_unsatisfiable.rs │ ├── DerefCopy │ │ └── check_deref_copy.rs │ ├── Drop │ │ ├── drop_after_move_closure_call.rs │ │ ├── drop_after_moving_across_channel.rs │ │ ├── drop_after_mutating_refcell.rs │ │ ├── drop_boxed_dyn.rs │ │ ├── drop_concrete.rs │ │ ├── drop_dyn_pointer.rs │ │ ├── drop_enum_only_one_called.rs │ │ ├── drop_nested_boxed_dyn.rs │ │ ├── drop_slice.rs │ │ ├── dyn_struct_member.rs │ │ ├── forget_no_drop.rs │ │ └── rc_dyn.rs │ ├── DynTrait │ │ ├── any_cast_int.rs │ │ ├── boxed_closure.rs │ │ ├── boxed_debug_cast.rs │ │ ├── boxed_trait.rs │ │ ├── boxed_trait_fail.rs │ │ ├── different_crates.rs │ │ ├── different_crates_fail.rs │ │ ├── dyn_fn_mut.rs │ │ ├── dyn_fn_once.rs │ │ ├── dyn_fn_param.rs │ │ ├── dyn_fn_param_closure.rs │ │ ├── dyn_fn_param_closure_capture.rs │ │ ├── encode_utf8.rs │ │ ├── generic_duplicate_names.rs │ │ ├── generic_duplicate_names_impl.rs │ │ ├── main.rs │ │ ├── nested_boxes.rs │ │ ├── nested_boxes_fail.rs │ │ ├── nested_closures.rs │ │ ├── object_safe_generics.rs │ │ ├── object_safe_trait.rs │ │ ├── std_lib_add_duplicate.rs │ │ ├── unsized_cast.rs │ │ ├── unsized_rc_cast.rs │ │ ├── upcast.rs │ │ ├── vtable_duplicate_field_override.rs │ │ ├── vtable_duplicate_fields.rs │ │ ├── vtable_restrictions.rs │ │ ├── vtable_restrictions_fail_fixme.rs │ │ └── vtable_size_align_drop.rs │ ├── EQ-NE │ │ └── main.rs │ ├── Enum │ │ ├── discriminant.rs │ │ ├── discriminant_128bits.rs │ │ ├── main.rs │ │ ├── min_offset.rs │ │ ├── multiple_never.rs │ │ ├── neg_discriminant.rs │ │ ├── niche.rs │ │ ├── niche_many_variants.rs │ │ ├── niche_variants_with_data.rs │ │ ├── one_two.rs │ │ ├── result1.rs │ │ ├── result2.rs │ │ ├── result3.rs │ │ ├── variants_multiple_len_2.rs │ │ ├── variants_single_len_1_fields_arbitrary_0.rs │ │ ├── variants_single_len_1_fields_arbitrary_1.rs │ │ ├── variants_single_len_1_fields_arbitrary_2.rs │ │ └── variants_single_len_2_fields_arbitrary_1.rs │ ├── FatPointers │ │ ├── boxmuttrait.rs │ │ ├── boxmuttrait_fail.rs │ │ ├── boxslice1.rs │ │ ├── boxslice2.rs │ │ ├── boxtrait.rs │ │ ├── boxtrait_fail.rs │ │ ├── metadata.rs │ │ ├── slice1.rs │ │ ├── slice2.rs │ │ ├── slice3.rs │ │ ├── structslice.rs │ │ ├── trait1.rs │ │ ├── trait1_fail.rs │ │ ├── trait2.rs │ │ ├── trait2_fail.rs │ │ ├── trait3.rs │ │ └── trait3_fail.rs │ ├── FileNameWithSpace │ │ └── my src │ │ │ └── hi.rs │ ├── FloatToIntInRange │ │ └── test.rs │ ├── FloatingPoint │ │ └── main.rs │ ├── ForeignItems │ │ ├── extern_fn_ptr.rs │ │ ├── fixme_option_ref.rs │ │ ├── fixme_varadic.rs │ │ ├── lib.c │ │ ├── main.rs │ │ └── missing_fn_fail.rs │ ├── FunctionAbstractions │ │ ├── mem_replace.rs │ │ ├── mem_swap.rs │ │ ├── ptr_read.rs │ │ └── ptr_write.rs │ ├── FunctionCall │ │ ├── FnPtr │ │ │ └── main.rs │ │ ├── Variadic │ │ │ ├── fixme_main.rs │ │ │ └── main.rs │ │ ├── marker_tuple.rs │ │ └── type_check.rs │ ├── FunctionCall_ImplicitReturn │ │ └── main.rs │ ├── FunctionCall_MultiModuleSameHarnessName │ │ └── main.rs │ ├── FunctionCall_NoRet-NoParam │ │ └── main.rs │ ├── FunctionCall_NoRet-Param │ │ └── main.rs │ ├── FunctionCall_Ret-NoParam │ │ └── main.rs │ ├── FunctionCall_Ret-Param │ │ └── main.rs │ ├── FunctionContracts │ │ ├── fixme_receiver_contracts.rs │ │ ├── fixme_static_interior_mut.rs │ │ ├── fixme_static_mut.rs │ │ ├── fn_params.rs │ │ ├── modify_slice_elem_fixme.rs │ │ ├── multiple_inherent_impls.rs │ │ ├── no-assert.rs │ │ ├── promoted_constants.rs │ │ ├── promoted_constants_enum.rs │ │ ├── receiver_contracts.rs │ │ └── static_interior_mut.rs │ ├── FunctionSymbols │ │ ├── builtin_name.rs │ │ ├── fixme_main.rs │ │ ├── issue1243.rs │ │ └── main.rs │ ├── Helpers │ │ └── vtable_utils_ignore.rs │ ├── IfElseifElse_NonReturning │ │ └── main.rs │ ├── IfElseifElse_Returning │ │ └── main.rs │ ├── Intrinsics │ │ ├── AlignOfVal │ │ │ ├── align_of_basic.rs │ │ │ └── align_of_fat_ptr.rs │ │ ├── ArithOffset │ │ │ ├── offset_i32_ok.rs │ │ │ └── offset_u8_ok.rs │ │ ├── Assert │ │ │ ├── inhabited_panic.rs │ │ │ ├── uninit_valid_panic.rs │ │ │ ├── zero_valid.rs │ │ │ └── zero_valid_panic.rs │ │ ├── Assume │ │ │ ├── assume_fail.rs │ │ │ └── assume_ok.rs │ │ ├── Atomic │ │ │ ├── Stable │ │ │ │ ├── AtomicPtr │ │ │ │ │ └── main.rs │ │ │ │ ├── CompareExchange │ │ │ │ │ └── main.rs │ │ │ │ ├── Exchange │ │ │ │ │ └── main.rs │ │ │ │ ├── Fence │ │ │ │ │ └── main.rs │ │ │ │ ├── FetchAdd │ │ │ │ │ └── main.rs │ │ │ │ ├── FetchAnd │ │ │ │ │ └── main.rs │ │ │ │ ├── FetchOr │ │ │ │ │ └── main.rs │ │ │ │ ├── FetchSub │ │ │ │ │ └── main.rs │ │ │ │ ├── FetchXor │ │ │ │ │ └── main.rs │ │ │ │ ├── Load │ │ │ │ │ └── main.rs │ │ │ │ └── Store │ │ │ │ │ └── main.rs │ │ │ └── Unstable │ │ │ │ ├── AtomicAdd │ │ │ │ └── main.rs │ │ │ │ ├── AtomicAnd │ │ │ │ └── main.rs │ │ │ │ ├── AtomicCxchg │ │ │ │ └── main.rs │ │ │ │ ├── AtomicCxchgWeak │ │ │ │ └── main.rs │ │ │ │ ├── AtomicFence │ │ │ │ └── main.rs │ │ │ │ ├── AtomicLoad │ │ │ │ └── main.rs │ │ │ │ ├── AtomicMax │ │ │ │ └── main.rs │ │ │ │ ├── AtomicMin │ │ │ │ └── main.rs │ │ │ │ ├── AtomicNand │ │ │ │ └── main.rs │ │ │ │ ├── AtomicOr │ │ │ │ └── main.rs │ │ │ │ ├── AtomicSingleThreadFence │ │ │ │ └── main.rs │ │ │ │ ├── AtomicStore │ │ │ │ └── main.rs │ │ │ │ ├── AtomicSub │ │ │ │ └── main.rs │ │ │ │ ├── AtomicUmax │ │ │ │ └── main.rs │ │ │ │ ├── AtomicUmin │ │ │ │ └── main.rs │ │ │ │ ├── AtomicXchg │ │ │ │ └── main.rs │ │ │ │ └── AtomicXor │ │ │ │ └── main.rs │ │ ├── Compiler │ │ │ ├── variant_count.rs │ │ │ └── variant_count_fixme.rs │ │ ├── ConstEval │ │ │ ├── min_align_of.rs │ │ │ ├── needs_drop.rs │ │ │ ├── pref_align_of.rs │ │ │ ├── size_of.rs │ │ │ ├── type_id.rs │ │ │ └── type_name.rs │ │ ├── Copy │ │ │ ├── copy.rs │ │ │ ├── copy_nonoverlapping.rs │ │ │ ├── copy_nonoverlapping_append.rs │ │ │ └── copy_nonoverlapping_swap.rs │ │ ├── CopySign │ │ │ ├── copysignf32.rs │ │ │ └── copysignf64.rs │ │ ├── Count │ │ │ ├── ctlz.rs │ │ │ ├── ctlz_nonzero_panic.rs │ │ │ ├── ctpop.rs │ │ │ ├── cttz.rs │ │ │ └── cttz_nonzero_panic.rs │ │ ├── ExactDiv │ │ │ ├── divisor_is_zero.rs │ │ │ ├── main.rs │ │ │ ├── not_exact_division.rs │ │ │ └── overflow_division.rs │ │ ├── FastMath │ │ │ ├── add_f32.rs │ │ │ ├── add_f64.rs │ │ │ ├── add_overflow_f32.rs │ │ │ ├── add_overflow_f64.rs │ │ │ ├── div_f32.rs │ │ │ ├── div_f64.rs │ │ │ ├── div_overflow_f32.rs │ │ │ ├── div_overflow_f64.rs │ │ │ ├── mul_f32.rs │ │ │ ├── mul_f64.rs │ │ │ ├── mul_overflow_f32.rs │ │ │ ├── mul_overflow_f64.rs │ │ │ ├── sub_f32.rs │ │ │ ├── sub_f64.rs │ │ │ ├── sub_overflow_f32.rs │ │ │ └── sub_overflow_f64.rs │ │ ├── FloatToInt │ │ │ └── float_to_int.rs │ │ ├── Forget │ │ │ ├── forget_fail.rs │ │ │ └── forget_ok.rs │ │ ├── Likely │ │ │ └── main.rs │ │ ├── Math │ │ │ ├── Arith │ │ │ │ ├── Unchecked │ │ │ │ │ ├── add_fail.rs │ │ │ │ │ ├── div_fail.rs │ │ │ │ │ ├── div_zero_fail.rs │ │ │ │ │ ├── mul_fail.rs │ │ │ │ │ ├── no_overflows.rs │ │ │ │ │ ├── rem_fail.rs │ │ │ │ │ ├── rem_zero_fail.rs │ │ │ │ │ ├── shl_fail.rs │ │ │ │ │ ├── shr_fail.rs │ │ │ │ │ └── sub_fail.rs │ │ │ │ ├── exp.rs │ │ │ │ ├── exp2.rs │ │ │ │ ├── fma.rs │ │ │ │ ├── log.rs │ │ │ │ ├── log10.rs │ │ │ │ ├── log2.rs │ │ │ │ ├── ops_with_overflow.rs │ │ │ │ ├── powf32.rs │ │ │ │ ├── powf64.rs │ │ │ │ ├── powi.rs │ │ │ │ ├── sqrt.rs │ │ │ │ └── wrapping_ops.rs │ │ │ ├── Rounding │ │ │ │ ├── Ceil │ │ │ │ │ ├── ceilf32.rs │ │ │ │ │ └── ceilf64.rs │ │ │ │ ├── Floor │ │ │ │ │ ├── floorf32.rs │ │ │ │ │ └── floorf64.rs │ │ │ │ ├── Round │ │ │ │ │ ├── roundf32.rs │ │ │ │ │ └── roundf64.rs │ │ │ │ ├── RoundTiesEven │ │ │ │ │ ├── round_ties_even_f32.rs │ │ │ │ │ └── round_ties_even_f64.rs │ │ │ │ └── Trunc │ │ │ │ │ ├── truncf32.rs │ │ │ │ │ └── truncf64.rs │ │ │ ├── Trigonometry │ │ │ │ ├── cosf32.rs │ │ │ │ ├── cosf64.rs │ │ │ │ ├── sinf32.rs │ │ │ │ └── sinf64.rs │ │ │ ├── fabsf32.rs │ │ │ └── fabsf64.rs │ │ ├── MaxNum │ │ │ ├── maxnumf32.rs │ │ │ └── maxnumf64.rs │ │ ├── MinNum │ │ │ ├── minnumf32.rs │ │ │ └── minnumf64.rs │ │ ├── NonRet │ │ │ ├── abort.rs │ │ │ └── transmute_zst.rs │ │ ├── Offset │ │ │ ├── offset_i32_ok.rs │ │ │ └── offset_u8_ok.rs │ │ ├── PtrGuaranteedCmp │ │ │ └── cmp.rs │ │ ├── PtrOffsetFrom │ │ │ └── main.rs │ │ ├── PtrOffsetFromUnsigned │ │ │ └── check_unsigned_ptr_offset_from.rs │ │ ├── RawEq │ │ │ ├── main.rs │ │ │ ├── uninit_eq.rs │ │ │ └── uninit_ne.rs │ │ ├── Rotate │ │ │ ├── rotate_left.rs │ │ │ └── rotate_right.rs │ │ ├── SIMD │ │ │ ├── Compare │ │ │ │ ├── float.rs │ │ │ │ ├── result_type_is_same_size.rs │ │ │ │ ├── signed.rs │ │ │ │ └── unsigned.rs │ │ │ ├── Construction │ │ │ │ └── main.rs │ │ │ ├── Operators │ │ │ │ ├── arith.rs │ │ │ │ ├── bitmask.rs │ │ │ │ ├── bitshift.rs │ │ │ │ ├── bitwise.rs │ │ │ │ ├── division.rs │ │ │ │ ├── division_float.rs │ │ │ │ └── remainder_float_fixme.rs │ │ │ └── Shuffle │ │ │ │ └── main.rs │ │ ├── Saturating │ │ │ └── main.rs │ │ ├── SizeOfVal │ │ │ ├── size_of_basic.rs │ │ │ └── size_of_fat_ptr.rs │ │ ├── Transmute │ │ │ ├── arr_to_struct.rs │ │ │ ├── bytes_to_u32.rs │ │ │ ├── ptr_to_fn_ptr.rs │ │ │ └── str_to_slice.rs │ │ ├── Volatile │ │ │ ├── load.rs │ │ │ ├── store.rs │ │ │ └── store_fail.rs │ │ ├── WriteBytes │ │ │ └── main.rs │ │ ├── bitreverse.rs │ │ ├── black_box.rs │ │ ├── bswap.rs │ │ ├── discriminant_value.rs │ │ ├── exact_div.rs │ │ ├── fixme_catch_unwind.rs │ │ ├── fixme_try.rs │ │ └── typed_swap_nonoverlapping.rs │ ├── Invariant │ │ ├── invariant_impls.rs │ │ └── percentage.rs │ ├── Invariants │ │ └── niche_opt.rs │ ├── Iterator │ │ ├── flat_map.rs │ │ ├── into_iter.rs │ │ └── try_fold.rs │ ├── LT-GT-LE-GE │ │ └── main.rs │ ├── LayoutRandomization │ │ ├── should_fail.rs │ │ └── should_succeed.rs │ ├── LexicographicCmp │ │ └── main.rs │ ├── LibC │ │ ├── posix_memalign.rs │ │ └── sysconf.rs │ ├── LongNames │ │ └── test.rs │ ├── LoopLoop_NonReturning │ │ ├── main.rs │ │ └── main_no_unwind_asserts.rs │ ├── LoopWhile_NonReturning │ │ ├── main.rs │ │ └── main_no_unwind_asserts.rs │ ├── Loops │ │ ├── loop_free.rs │ │ └── loop_with_drop.rs │ ├── Match │ │ ├── match_bool.rs │ │ └── match_pattern.rs │ ├── MemCmpCpyZero │ │ └── issue1489.rs │ ├── MemPredicates │ │ ├── foreign_type.rs │ │ └── same_allocation.rs │ ├── MemReplace │ │ └── main.rs │ ├── NameMangling │ │ └── issue1438.rs │ ├── Never │ │ ├── main.rs │ │ └── never_return.rs │ ├── NondetSlices │ │ ├── test1.rs │ │ ├── test2.rs │ │ └── test3.rs │ ├── NondetVectors │ │ ├── bytes.rs │ │ └── fixme_main.rs │ ├── Options │ │ └── check_tests.rs │ ├── Overflow │ │ └── pointer_overflow_fail.rs │ ├── Panic │ │ ├── compile_panic.rs │ │ ├── const.rs │ │ ├── const_args.rs │ │ ├── core_mod.rs │ │ └── extern_core.rs │ ├── Parenths │ │ └── main.rs │ ├── PhantomData │ │ └── phantom_data.rs │ ├── PointerComparison │ │ └── ptr_comparison.rs │ ├── PointerOffset │ │ ├── fixme_wrap_nonzero_offset.rs │ │ ├── offset_from.rs │ │ ├── offset_from_vec.rs │ │ └── offset_sub.rs │ ├── Pointers_Basic │ │ ├── fixme_from_raw.rs │ │ └── main.rs │ ├── Pointers_Functions │ │ └── main.rs │ ├── Pointers_InAssert │ │ └── main.rs │ ├── Pointers_OtherTypes │ │ └── main.rs │ ├── Print │ │ ├── arg_not_moved.rs │ │ ├── main.rs │ │ ├── no_semicolon.rs │ │ └── side_effects.rs │ ├── Projection │ │ ├── dyn_dyn_projection.rs │ │ ├── dyn_slice_projection.rs │ │ ├── slice_dyn_projection.rs │ │ └── slice_slice_projection.rs │ ├── ProjectionElem │ │ ├── ConstantIndex │ │ │ └── main.rs │ │ └── OpaqueCast │ │ │ └── check_opaque_cast.rs │ ├── Quantifiers │ │ ├── array.rs │ │ ├── contracts.rs │ │ ├── even.rs │ │ ├── from_raw_part_fixme.rs │ │ └── no_array.rs │ ├── Realloc │ │ └── two_reallocs.rs │ ├── Refs │ │ └── main.rs │ ├── Repr │ │ ├── check_repr.rs │ │ ├── issue_837.rs │ │ └── main.rs │ ├── SIMD │ │ ├── array_simd_repr.rs │ │ ├── generic_access.rs │ │ ├── multi_field_simd.rs │ │ ├── portable_simd.rs │ │ ├── simd_bitmask_equiv.rs │ │ ├── simd_float_ops.rs │ │ └── swizzle.rs │ ├── Scopes_NonReturning │ │ └── main.rs │ ├── Scopes_Returning │ │ └── main.rs │ ├── Serde │ │ └── main.rs │ ├── SizeAndAlignOfDst │ │ ├── main.rs │ │ ├── main_assert.rs │ │ ├── main_assert_fixme.rs │ │ ├── unsized_foreign.rs │ │ └── unsized_tail.rs │ ├── Slice │ │ ├── codegen.rs │ │ ├── const_bytes.rs │ │ ├── drop_in_place.rs │ │ ├── empty_slice.rs │ │ ├── empty_slice_fail.rs │ │ ├── extra_checks_fail.rs │ │ ├── fixme_issue_707.rs │ │ ├── main.rs │ │ ├── pathbuf.rs │ │ ├── size_of.rs │ │ ├── slice.rs │ │ └── slice_from_raw.rs │ ├── Static │ │ ├── anon_static.rs │ │ ├── main.rs │ │ ├── method_static_var.rs │ │ ├── pointer_to_const_alloc.rs │ │ ├── pub_static.rs │ │ ├── static_value.rs │ │ ├── table_of_pairs.rs │ │ ├── table_of_pairs2.rs │ │ └── unsafe_extern_static_uninitialized.rs │ ├── StdLink │ │ └── overlapping_traits.rs │ ├── StdOverrides │ │ └── arg.rs │ ├── StorageMarkers │ │ └── main.rs │ ├── Str │ │ ├── raw_ptr.rs │ │ └── utf8.rs │ ├── Strings │ │ ├── boxed_str.rs │ │ ├── copy_empty_string_by_ref.rs │ │ ├── main.rs │ │ ├── os_str.rs │ │ ├── os_str_reduced.rs │ │ └── parse.rs │ ├── Stubbing │ │ ├── StubPrimitives │ │ │ ├── fixme_stub_lowered_methods.rs │ │ │ ├── stub_bool_methods.rs │ │ │ ├── stub_char_methods.rs │ │ │ ├── stub_float_methods.rs │ │ │ ├── stub_int_methods.rs │ │ │ ├── stub_ptr_methods.rs │ │ │ └── stub_slice_methods.rs │ │ ├── enum_method.rs │ │ ├── fixme_issue_1953.rs │ │ ├── foreign_functions.rs │ │ ├── glob_cycle.rs │ │ ├── glob_path.rs │ │ ├── method_generic_type.rs │ │ ├── multiple_harnesses.rs │ │ ├── partial_harness_name.rs │ │ ├── private_function.rs │ │ ├── public_function.rs │ │ ├── qualifiers.rs │ │ ├── resolve_superseded_glob_use.rs │ │ ├── resolve_use.rs │ │ ├── resolve_use_as.rs │ │ ├── resolve_use_glob.rs │ │ ├── std_fs_read.rs │ │ ├── struct_method.rs │ │ ├── stub_harnesses.rs │ │ ├── use_std_fs_read.rs │ │ └── validate_mismatched_traits.rs │ ├── SubSlice │ │ ├── subslice1.rs │ │ ├── subslice2.rs │ │ └── subslice3.rs │ ├── SwitchInt │ │ └── main.rs │ ├── TargetFeatures │ │ └── target_features.rs │ ├── ThreadLocalRef │ │ └── main.rs │ ├── Transparent │ │ ├── transparent1.rs │ │ ├── transparent2.rs │ │ ├── transparent3.rs │ │ └── transparent4.rs │ ├── Tuple │ │ ├── main.rs │ │ └── tuple_trait.rs │ ├── Uninit │ │ ├── access-padding-init.rs │ │ ├── alloc-to-slice.rs │ │ ├── alloc-zeroed-to-slice.rs │ │ ├── atomic.rs │ │ ├── struct-padding-and-arr-init.rs │ │ └── vec-read-init.rs │ ├── Unit │ │ └── main.rs │ ├── UnsafeBlocks_Useless │ │ └── main.rs │ ├── UnsizedCoercion │ │ ├── basic_coercion.rs │ │ ├── basic_inner_coercion.rs │ │ ├── basic_outer_coercion.rs │ │ ├── box_coercion.rs │ │ ├── box_inner_coercion.rs │ │ ├── box_outer_coercion.rs │ │ ├── custom_outer_coercion.rs │ │ ├── defs.rs │ │ ├── double_coercion.rs │ │ ├── rc_outer_coercion.rs │ │ └── trait_to_trait_coercion.rs │ ├── Unwind-Attribute │ │ └── fixme_lib.rs │ ├── ValidValues │ │ └── unaligned.rs │ ├── Vectors │ │ ├── any │ │ │ ├── fixme_append.rs │ │ │ ├── resize.rs │ │ │ └── sorting.rs │ │ ├── issue-763.rs │ │ ├── push.rs │ │ ├── push_u8.rs │ │ ├── sort_by_key.rs │ │ ├── vector_extend.rs │ │ ├── vector_extend_bytes.rs │ │ ├── vector_extend_fail.rs │ │ ├── vector_extend_in_new.rs │ │ └── vector_extend_loop.rs │ ├── VolatileIntrinsics │ │ ├── core_intrinsics.rs │ │ └── main_fixme.rs │ ├── Whitespace │ │ └── main.rs │ └── i32-Unary- │ │ └── main.rs ├── llbc │ ├── basic0 │ │ ├── expected │ │ └── test.rs │ ├── basic1 │ │ ├── expected │ │ └── test.rs │ ├── enum │ │ ├── expected │ │ └── test.rs │ ├── generic │ │ ├── expected │ │ └── test.rs │ ├── option │ │ ├── expected │ │ └── test.rs │ ├── projection │ │ ├── expected │ │ └── test.rs │ ├── struct │ │ ├── expected │ │ └── test.rs │ ├── traitimpl │ │ ├── expected │ │ └── test.rs │ └── tuple │ │ ├── expected │ │ └── test.rs ├── perf │ ├── btreeset │ │ ├── insert_any │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── insert_multi │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ │ └── main.rs │ │ └── insert_same │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ └── main.rs │ ├── format │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── hashset │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── kani-lib │ │ └── arbitrary │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── check_arbitrary.rs │ ├── misc │ │ ├── array_fold │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── display_trait │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ │ └── main.rs │ │ └── struct_defs │ │ │ ├── Cargo.toml │ │ │ ├── expected │ │ │ └── src │ │ │ └── main.rs │ ├── overlays │ │ ├── README.md │ │ └── s2n-quic │ │ │ ├── common │ │ │ └── s2n-codec │ │ │ │ └── expected │ │ │ └── quic │ │ │ ├── s2n-quic-core │ │ │ └── expected │ │ │ └── s2n-quic-platform │ │ │ └── expected │ ├── smol_str │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── string │ │ ├── expected │ │ └── src │ │ │ └── any_str.rs │ └── vec │ │ ├── box_dyn │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── main.rs │ │ ├── string │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ │ └── main.rs │ │ └── vec │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ └── main.rs ├── prusti │ ├── 100_doors.rs │ ├── Ackermann_function.rs │ ├── Binary_search.rs │ ├── Fibonacci_sequence.rs │ ├── Heapsort.rs │ ├── Selection_sort.rs │ ├── Tower_of_Hanoi.rs │ └── borrow_first.rs ├── remote-target-lists │ ├── top-100-crate-names-2022-12-26.txt │ ├── top-100-crates-2022-12-26.txt │ └── top-100-crates-2022-6-27.txt ├── script-based-pre │ ├── ambiguous_crate │ │ ├── Cargo.toml │ │ ├── ambiguous.sh │ │ ├── config.yml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── build-cache-bin │ │ ├── bin │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── cache_works.expected │ │ ├── cache_works.sh │ │ └── config.yml │ ├── build-cache-dirty │ │ ├── config.yml │ │ ├── rebuild.expected │ │ ├── rebuild.sh │ │ └── target_lib │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── build-cache-fresh │ │ ├── cache_works.expected │ │ ├── cache_works.sh │ │ ├── config.yml │ │ └── lib │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── build-rs-conditional │ │ ├── Cargo.toml │ │ ├── build.rs │ │ ├── build_rs.sh │ │ ├── config.yml │ │ ├── expected │ │ └── src │ │ │ └── lib.rs │ ├── cargo-kani-version-flag-version │ │ ├── cargo-kani-version-flag-version.expected │ │ ├── cargo-kani-version-flag-version.sh │ │ ├── config.yml │ │ └── dummy-project │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── main.rs │ ├── cargo_autoharness_contracts │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── contracts.expected │ │ ├── contracts.sh │ │ └── src │ │ │ └── lib.rs │ ├── cargo_autoharness_dependencies │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── dependencies.expected │ │ ├── dependencies.sh │ │ ├── other_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── lib.rs │ │ └── src │ │ │ └── lib.rs │ ├── cargo_autoharness_exclude │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── exclude.expected │ │ ├── exclude.sh │ │ └── src │ │ │ └── lib.rs │ ├── cargo_autoharness_filter │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── filter.expected │ │ ├── filter.sh │ │ └── src │ │ │ └── lib.rs │ ├── cargo_autoharness_harnesses_fail │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── harnesses_fail.expected │ │ ├── harnesses_fail.sh │ │ └── src │ │ │ └── lib.rs │ ├── cargo_autoharness_include │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── include.expected │ │ ├── include.sh │ │ └── src │ │ │ └── lib.rs │ ├── cargo_autoharness_list │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── list.expected │ │ ├── list.sh │ │ └── src │ │ │ └── lib.rs │ ├── cargo_autoharness_termination_timeout │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── src │ │ │ └── lib.rs │ │ ├── termination_timeout.expected │ │ └── termination_timeout.sh │ ├── cargo_autoharness_termination_unwind │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── src │ │ │ └── lib.rs │ │ ├── termination_unwind.expected │ │ └── termination_unwind.sh │ ├── cargo_autoharness_type_invariant │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── src │ │ │ └── lib.rs │ │ ├── type-invariant.expected │ │ └── type-invariant.sh │ ├── cargo_list_json │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── list.expected │ │ ├── list.sh │ │ └── src │ │ │ ├── lib.rs │ │ │ └── standard_harnesses.rs │ ├── cargo_list_md │ │ ├── .gitignore │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── list.expected │ │ ├── list.sh │ │ └── src │ │ │ ├── lib.rs │ │ │ └── standard_harnesses.rs │ ├── cargo_manifest_test │ │ ├── add │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── main.rs │ │ ├── config.yml │ │ ├── manifest_test.expected │ │ └── manifest_test.sh │ ├── cargo_playback_build │ │ ├── config.yml │ │ ├── playback_with_build.expected │ │ ├── playback_with_build.sh │ │ └── sample_crate │ │ │ ├── Cargo.toml │ │ │ ├── build.rs │ │ │ └── src │ │ │ └── lib.rs │ ├── cargo_playback_opts │ │ ├── config.yml │ │ ├── playback_opts.expected │ │ ├── playback_opts.sh │ │ └── sample_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── cargo_playback_target │ │ ├── config.yml │ │ ├── playback_target.expected │ │ ├── playback_target.sh │ │ └── sample_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ ├── bin │ │ │ ├── bar.rs │ │ │ └── foo.rs │ │ │ └── lib.rs │ ├── check-output │ │ ├── .gitignore │ │ ├── check-output.sh │ │ ├── config.yml │ │ ├── multifile │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ │ └── main.rs │ │ └── singlefile.rs │ ├── check-quiet │ │ ├── assume.rs │ │ ├── check-quiet.expected │ │ ├── check-quiet.sh │ │ └── config.yml │ ├── concrete_playback_e2e │ │ ├── config.yml │ │ ├── playback_e2e.expected │ │ ├── playback_e2e.sh │ │ └── sample_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── crate-name │ │ ├── a │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── b │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── c │ │ │ └── src │ │ │ │ └── lib.rs │ │ ├── config.yml │ │ ├── crate-name.expected │ │ ├── crate-name.sh │ │ └── my-code.rs │ ├── error-code │ │ ├── config.yml │ │ ├── exit-one.expected │ │ └── exit-one.sh │ ├── individual_file_output │ │ ├── config.yml │ │ ├── individual_file_output.sh │ │ └── sample_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── kani-version-flag-version │ │ ├── config.yml │ │ ├── dummy-file.rs │ │ ├── kani-version-flag-version.expected │ │ └── kani-version-flag-version.sh │ ├── kani_autoharness_exclude_precedence │ │ ├── config.yml │ │ ├── precedence.sh │ │ └── src │ │ │ └── lib.rs │ ├── kani_lib_dep │ │ ├── Cargo.toml │ │ ├── build.sh │ │ ├── config.yml │ │ ├── expected │ │ └── src │ │ │ └── main.rs │ ├── kani_list_json │ │ ├── config.yml │ │ ├── list.expected │ │ ├── list.sh │ │ └── src │ │ │ └── lib.rs │ ├── kani_list_md │ │ ├── .gitignore │ │ ├── config.yml │ │ ├── list.expected │ │ ├── list.sh │ │ └── src │ │ │ └── lib.rs │ ├── mem-init-reinstrumentation │ │ ├── alloc-zeroed.rs │ │ ├── config.yml │ │ ├── mem-init-reinstrumentation.expected │ │ └── mem-init-reinstrumentation.sh │ ├── no_codegen │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── expected │ │ ├── run.sh │ │ └── src │ │ │ └── main.rs │ ├── no_codegen_error │ │ ├── Cargo.toml │ │ ├── config.yml │ │ ├── expected │ │ ├── run.sh │ │ └── src │ │ │ └── main.rs │ ├── playback_already_existing │ │ ├── config.yml │ │ ├── original.rs │ │ ├── playback_opts.expected │ │ └── playback_opts.sh │ ├── playback_array │ │ ├── array.rs │ │ ├── config.yml │ │ ├── playback_array.expected │ │ └── playback_array.sh │ ├── playback_expected │ │ ├── config.yml │ │ ├── expected │ │ ├── playback.sh │ │ └── src │ │ │ ├── playback_contract.rs │ │ │ └── playback_stubs.rs │ ├── playback_multi_harness_multi_inject │ │ ├── config.yml │ │ ├── original.rs │ │ ├── playback_opts.expected │ │ └── playback_opts.sh │ ├── playback_no_rustfmt │ │ ├── bin │ │ │ └── rustfmt │ │ ├── config.yml │ │ ├── original.rs │ │ ├── playback_no_rustfmt.expected │ │ └── playback_no_rustfmt.sh │ ├── playback_opts │ │ ├── config.yml │ │ ├── original.rs │ │ ├── playback_opts.expected │ │ └── playback_opts.sh │ ├── playback_print │ │ ├── config.yml │ │ ├── expected │ │ ├── playback_print.sh │ │ └── print_vars.rs │ ├── playback_with_cfg_kani │ │ ├── config.yml │ │ ├── playback_with_cfg_kani.expected │ │ ├── playback_with_cfg_kani.sh │ │ └── sample_crate │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── main.rs │ ├── playback_zero_size │ │ ├── config.yml │ │ ├── original.rs │ │ ├── playback_zst.expected │ │ └── playback_zst.sh │ ├── std_codegen │ │ ├── codegen_std.expected │ │ ├── codegen_std.sh │ │ ├── config.yml │ │ └── dummy │ │ │ ├── Cargo.toml │ │ │ └── src │ │ │ └── lib.rs │ ├── tool-scanner │ │ ├── config.yml │ │ ├── scanner-test.expected │ │ ├── scanner-test.sh │ │ └── test.rs │ └── verify_std_cmd │ │ ├── config.yml │ │ ├── verify_core.rs │ │ ├── verify_std.expected │ │ └── verify_std.sh ├── slow │ ├── kani │ │ ├── Strings │ │ │ └── copy_empty_string_by_intrinsic.rs │ │ └── Vectors │ │ │ └── any │ │ │ └── push_slow.rs │ └── tokio-proofs │ │ ├── Cargo.toml │ │ ├── expected │ │ └── src │ │ ├── lib.rs │ │ ├── tokio │ │ ├── io_chain.rs │ │ ├── io_copy.rs │ │ ├── io_lines.rs │ │ ├── io_mem_stream.rs │ │ ├── io_read.rs │ │ ├── io_read_buf.rs │ │ ├── io_read_exact.rs │ │ ├── io_read_line.rs │ │ ├── io_read_to_end.rs │ │ ├── io_read_to_string.rs │ │ ├── io_read_until.rs │ │ ├── io_take.rs │ │ ├── io_util_empty.rs │ │ ├── io_write.rs │ │ ├── io_write_all.rs │ │ ├── io_write_all_buf.rs │ │ ├── io_write_buf.rs │ │ ├── io_write_int.rs │ │ ├── mod.rs │ │ ├── support │ │ │ ├── io_vec.rs │ │ │ ├── leaked_buffers.rs │ │ │ ├── mod.rs │ │ │ ├── mpsc_stream.rs │ │ │ ├── panic.rs │ │ │ └── signal.rs │ │ └── sync_mpsc.rs │ │ ├── tokio_stream │ │ ├── mod.rs │ │ ├── stream_chain.rs │ │ ├── stream_collect.rs │ │ ├── stream_empty.rs │ │ ├── stream_fuse.rs │ │ ├── stream_merge.rs │ │ ├── stream_once.rs │ │ ├── stream_stream_map.rs │ │ └── support │ │ │ ├── mod.rs │ │ │ └── mpsc.rs │ │ ├── tokio_test │ │ ├── block_on.rs │ │ ├── io.rs │ │ └── mod.rs │ │ └── tokio_util │ │ ├── io_reader_stream.rs │ │ ├── io_stream_reader.rs │ │ └── mod.rs ├── smack │ ├── basic │ │ ├── add.rs │ │ ├── arith.rs │ │ ├── arith_assume.rs │ │ ├── arith_assume2.rs │ │ ├── arith_assume3.rs │ │ ├── div.rs │ │ ├── mod.rs │ │ ├── mul.rs │ │ └── sub.rs │ ├── functions │ │ ├── closure.rs │ │ ├── closure_fail.rs │ │ ├── double.rs │ │ └── double_fail.rs │ ├── generics │ │ ├── generic_function.rs │ │ ├── generic_function1.rs │ │ ├── generic_function2.rs │ │ ├── generic_function3.rs │ │ ├── generic_function4.rs │ │ └── generic_function5.rs │ ├── loops │ │ ├── gauss_sum_nondet.rs │ │ ├── gauss_sum_nondet_fail.rs │ │ ├── iterator.rs │ │ └── iterator_fail.rs │ ├── overflow │ │ ├── add_overflow.rs │ │ ├── mul_overflow.rs │ │ └── sub_overflow.rs │ ├── recursion │ │ ├── fac.rs │ │ ├── fac_fail.rs │ │ ├── fib.rs │ │ └── fib_fail.rs │ ├── structures │ │ ├── option.rs │ │ ├── option_fail.rs │ │ ├── point.rs │ │ └── point_fail.rs │ └── vector │ │ ├── vec1.rs │ │ ├── vec11.rs │ │ ├── vec12.rs │ │ ├── vec13.rs │ │ ├── vec_resize.rs │ │ └── vec_resize_fail.rs ├── std-checks │ ├── core │ │ ├── Cargo.toml │ │ ├── mem.expected │ │ ├── ptr.expected │ │ ├── slice.expected │ │ └── src │ │ │ ├── lib.rs │ │ │ ├── mem.rs │ │ │ ├── ptr.rs │ │ │ └── slice.rs │ └── std │ │ ├── Cargo.toml │ │ ├── atomic.expected │ │ ├── boxed.expected │ │ └── src │ │ ├── boxed.rs │ │ ├── lib.rs │ │ └── sync │ │ ├── atomic.rs │ │ └── mod.rs └── ui │ ├── Property-Class-UI │ ├── arithmetic_overflow │ │ ├── expected │ │ └── main.rs │ ├── cover │ │ ├── expected │ │ └── main.rs │ └── exact_div │ │ ├── expected │ │ └── main.rs │ ├── arbitrary-ptr-doc │ ├── doc_examples.expected │ └── doc_examples.rs │ ├── arguments-proof │ ├── expected │ ├── main.rs │ └── missing-unstable-flag │ │ ├── expected │ │ └── main.rs │ ├── cbmc_checks │ ├── float-overflow │ │ ├── check_message.expected │ │ ├── check_message.rs │ │ ├── check_message_overflow.expected │ │ └── check_message_overflow.rs │ ├── pointer │ │ ├── check_message.rs │ │ └── expected │ ├── signed-overflow │ │ ├── check_message.rs │ │ └── expected │ └── unsigned-overflow │ │ ├── check_message.rs │ │ └── expected │ ├── check_operations │ ├── expected │ └── operations.rs │ ├── check_summary_for_single_harness │ ├── expected │ └── single_harness.rs │ ├── code-location │ ├── expected │ ├── main.rs │ └── module │ │ ├── expected │ │ └── mod.rs │ ├── compiler-stats │ ├── expected │ └── stats.rs │ ├── concrete-playback │ ├── README.md │ ├── array │ │ ├── expected │ │ └── main.rs │ ├── bool │ │ ├── expected │ │ └── main.rs │ ├── cover │ │ ├── expected │ │ └── main.rs │ ├── custom │ │ ├── expected │ │ └── main.rs │ ├── f32 │ │ ├── expected │ │ └── main.rs │ ├── f64 │ │ ├── expected │ │ └── main.rs │ ├── i128 │ │ ├── expected │ │ └── main.rs │ ├── i16 │ │ ├── expected │ │ └── main.rs │ ├── i32 │ │ ├── expected │ │ └── main.rs │ ├── i64 │ │ ├── expected │ │ └── main.rs │ ├── i8 │ │ ├── expected │ │ └── main.rs │ ├── isize │ │ ├── expected │ │ └── main.rs │ ├── message-order │ │ ├── expected │ │ └── main.rs │ ├── mult-harnesses │ │ ├── expected │ │ └── main.rs │ ├── non_zero │ │ ├── expected │ │ └── main.rs │ ├── option │ │ ├── expected │ │ └── main.rs │ ├── result │ │ ├── expected │ │ └── main.rs │ ├── slice-formula │ │ ├── expected │ │ └── main.rs │ ├── u128 │ │ ├── expected │ │ └── main.rs │ ├── u16 │ │ ├── expected │ │ └── main.rs │ ├── u32 │ │ ├── expected │ │ └── main.rs │ ├── u64 │ │ ├── expected │ │ └── main.rs │ ├── u8 │ │ ├── expected │ │ └── main.rs │ ├── ub │ │ ├── null_ptr │ │ │ ├── expected │ │ │ └── test.rs │ │ └── oob_ptr │ │ │ ├── expected │ │ │ └── test.rs │ ├── unsupported │ │ ├── expected │ │ └── loop.rs │ └── usize │ │ ├── expected │ │ └── main.rs │ ├── cover-property-class │ ├── expected │ └── main.rs │ ├── derive-arbitrary │ ├── empty_enum │ │ ├── empty_enum.rs │ │ └── expected │ ├── empty_struct │ │ ├── empty_struct.rs │ │ └── expected │ ├── enum │ │ ├── enum.rs │ │ └── expected │ ├── generic_struct │ │ ├── expected │ │ └── generic_struct.rs │ ├── named_struct │ │ ├── expected │ │ └── named_struct.rs │ ├── non_arbitrary_field │ │ ├── expected │ │ └── non_arbitrary_field.rs │ ├── non_arbitrary_param │ │ ├── expected │ │ └── non_arbitrary_param.rs │ ├── single_variant_enum │ │ ├── expected │ │ └── single_variant_enum.rs │ ├── union │ │ ├── expected │ │ └── union.rs │ └── unnamed_struct │ │ ├── expected │ │ └── unnamed_struct.rs │ ├── derive-invariant │ ├── helper-empty │ │ ├── expected │ │ └── helper-empty.rs │ ├── helper-no-expr │ │ ├── expected │ │ └── helper-no-expr.rs │ ├── helper-side-effect │ │ ├── expected │ │ └── helper-side-effect.rs │ └── helper-wrong-expr │ │ ├── expected │ │ └── helper-wrong-expr.rs │ ├── duplicates │ ├── dup_checks.rs │ └── expected │ ├── entry-fn │ ├── main │ │ ├── expected │ │ └── function.rs │ └── non-main │ │ ├── expected │ │ └── function.rs │ ├── exact-harness │ ├── check-qualified-name │ │ ├── expected │ │ └── select_harness_with_module.rs │ ├── check_some │ │ ├── expected │ │ └── select_harnesses.rs │ ├── check_substring_not_matching │ │ ├── expected │ │ └── select_harness_with_module.rs │ ├── fail_on_missing │ │ ├── expected │ │ └── subset.rs │ ├── incomplete-harness-name │ │ ├── expected │ │ └── incomplete_harness.rs │ └── multiple_matches │ │ ├── expected │ │ └── select_multiple_harnesses.rs │ ├── extern_std │ ├── macro_override.expected │ └── macro_override.rs │ ├── function-contracts │ ├── invalid_target_path.expected │ ├── invalid_target_path.rs │ ├── mutating_ensures_error.expected │ ├── mutating_ensures_error.rs │ ├── non_bool_contracts.expected │ └── non_bool_contracts.rs │ ├── function-stubbing-error │ ├── invalid_stub_args.expected │ ├── invalid_stub_args.rs │ ├── resolution_errors.expected │ ├── resolution_errors.rs │ ├── unsupported_resolutions.expected │ └── unsupported_resolutions.rs │ ├── harness-timeout │ ├── hours.expected │ ├── hours.rs │ ├── invalid.expected │ ├── invalid.rs │ ├── minutes.expected │ ├── minutes.rs │ ├── no_timeout.expected │ ├── no_timeout.rs │ ├── timeout.expected │ └── timeout.rs │ ├── invalid-attribute │ ├── attrs.rs │ └── expected │ ├── invalid-cbmc-function-arg │ ├── expected │ └── main.rs │ ├── invalid-contract-harness │ ├── expected │ └── invalid.rs │ ├── invalid-harnesses │ ├── expected │ └── invalid.rs │ ├── logging │ ├── debug │ │ ├── expected │ │ └── trivial.rs │ └── warning │ │ ├── expected │ │ └── trivial.rs │ ├── loop-contracts-synthesis │ ├── main_signed │ │ ├── expected │ │ └── main_signed.rs │ └── main_unsigned │ │ ├── expected │ │ └── main_unsigned.rs │ ├── mir-linker │ └── generic-harness │ │ ├── expected │ │ └── incorrect.rs │ ├── missing-function │ └── extern_c │ │ ├── expected │ │ └── extern_c.rs │ ├── multiple-harnesses │ ├── check_all │ │ ├── expected │ │ └── test.rs │ ├── check_some │ │ ├── expected │ │ └── select_harnesses.rs │ ├── multiple_matches │ │ ├── expected │ │ └── select_harnesses.rs │ ├── no_matching_harness │ │ ├── expected │ │ └── non_matching.rs │ ├── some_matching_harnesses │ │ ├── expected │ │ └── subset.rs │ └── stop_at_single_fail │ │ ├── fail_fast_test.expected │ │ ├── fail_fast_test.rs │ │ ├── fail_fast_test_parallel.expected │ │ └── fail_fast_test_parallel.rs │ ├── multiple-proof-attributes │ ├── expected │ └── main.rs │ ├── regular-output-format-fail │ ├── expected │ └── fail.rs │ ├── regular-output-format-pass │ ├── expected │ └── main.rs │ ├── safety-constraint-attribute │ ├── double-attribute │ │ ├── double-attribute.rs │ │ └── expected │ ├── invalid-pred-error │ │ ├── expected │ │ └── invalid-pred-error.rs │ ├── mixed-attributes │ │ ├── expected │ │ └── mixed-attributes.rs │ └── no-struct-error │ │ ├── expected │ │ └── no-struct-error.rs │ ├── save-coverage-results │ ├── expected │ └── test.rs │ ├── should-panic-attribute │ ├── expected-panics │ │ ├── expected │ │ └── test.rs │ ├── multiple-attrs │ │ ├── expected │ │ └── test.rs │ ├── multiple-harnesses-panic │ │ ├── expected │ │ └── test.rs │ ├── no-panics │ │ ├── expected │ │ └── test.rs │ ├── unexpected-failures │ │ ├── expected │ │ └── test.rs │ └── with-args │ │ ├── expected │ │ └── test.rs │ ├── solver-attribute │ ├── cadical │ │ ├── expected │ │ └── test.rs │ ├── invalid │ │ ├── expected │ │ └── test.rs │ ├── multiple-args │ │ ├── expected │ │ └── test.rs │ ├── multiple-attrs │ │ ├── expected │ │ └── test.rs │ ├── no-arg │ │ ├── expected │ │ └── test.rs │ ├── not-found │ │ ├── expected │ │ └── test.rs │ └── unknown │ │ ├── expected │ │ └── test.rs │ ├── solver-option │ ├── bin │ │ ├── expected │ │ └── test.rs │ ├── cadical │ │ ├── expected │ │ └── test.rs │ ├── invalid │ │ ├── expected │ │ └── test.rs │ ├── kissat │ │ ├── expected │ │ └── test.rs │ └── minisat │ │ ├── expected │ │ └── test.rs │ ├── std-override │ ├── format_panic.expected │ └── format_panic.rs │ ├── stub-attribute │ ├── attribute.rs │ └── expected │ ├── stubbing │ ├── invalid-path │ │ ├── invalid_inherent_impls.expected │ │ ├── invalid_inherent_impls.rs │ │ ├── invalid_mod.expected │ │ └── invalid_mod.rs │ ├── stubbing-flag │ │ ├── expected │ │ └── main.rs │ ├── stubbing-trait-validation │ │ ├── expected │ │ └── trait_mismatch.rs │ └── stubbing-type-validation │ │ ├── expected │ │ └── type_mismatch.rs │ ├── terse-output-format-fail │ ├── expected │ └── fail.rs │ ├── terse-output-format-pass │ ├── expected │ └── main.rs │ ├── unknown-contract-harness │ ├── expected │ └── test.rs │ ├── unsupported-annotation │ ├── expected │ └── main.rs │ ├── unwind-multiple-arguments │ ├── expected │ └── main.rs │ └── unwind-without-proof │ ├── expected │ └── main.rs └── tools ├── benchcomp ├── .gitignore ├── README.md ├── benchcomp │ ├── __init__.py │ ├── cmd_args.py │ ├── entry │ │ ├── README.md │ │ ├── __init__.py │ │ ├── benchcomp.py │ │ ├── collate.py │ │ ├── filter.py │ │ ├── run.py │ │ └── visualize.py │ ├── parsers │ │ ├── README.md │ │ ├── __init__.py │ │ ├── kani_perf.py │ │ ├── test.py │ │ └── test_file_to_metric.py │ └── visualizers │ │ ├── __init__.py │ │ └── utils.py ├── bin │ └── benchcomp ├── configs │ ├── README.md │ └── perf-regression.yaml ├── requirements.txt └── test │ ├── README.md │ ├── __init__.py │ ├── run │ ├── test_regression.py │ ├── test_unit.py │ └── unit │ ├── __init__.py │ └── test_utils.py ├── build-kani ├── Cargo.toml ├── build.rs ├── license-notes.txt └── src │ ├── main.rs │ ├── parser.rs │ └── sysroot.rs ├── compiletest ├── Cargo.toml └── src │ ├── common.rs │ ├── header.rs │ ├── json.rs │ ├── main.rs │ ├── raise_fd_limit.rs │ ├── read2.rs │ ├── runtest.rs │ └── util.rs ├── kani-cov ├── Cargo.toml └── src │ ├── args.rs │ ├── coverage.rs │ ├── main.rs │ ├── merge.rs │ ├── report.rs │ └── summary.rs ├── scanner ├── Cargo.toml ├── build.rs └── src │ ├── analysis.rs │ ├── bin │ └── scan.rs │ ├── call_graph.rs │ └── lib.rs └── sizeofs └── main.cpp /.dockerignore: -------------------------------------------------------------------------------- 1 | .git 2 | firecracker 3 | target/debug 4 | target/release 5 | build 6 | -------------------------------------------------------------------------------- /.github/CODEOWNERS: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | * @model-checking/kani-devs 5 | -------------------------------------------------------------------------------- /docs/src/cargo-kani.md: -------------------------------------------------------------------------------- 1 | # Usage on a package 2 | 3 | [See here](./usage.md#usage-on-a-package) 4 | -------------------------------------------------------------------------------- /docs/src/getting-started/verification-results/failure_example.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "assertion failed: arr.len() != 3" 3 | -------------------------------------------------------------------------------- /docs/src/getting-started/verification-results/success_example.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "assertion failed: sum == 6" 3 | -------------------------------------------------------------------------------- /docs/src/getting-started/verification-results/undetermined_example.expected: -------------------------------------------------------------------------------- 1 | UNDETERMINED\ 2 | Description: "assertion failed: x == 0" 3 | -------------------------------------------------------------------------------- /docs/src/getting-started/verification-results/unreachable_example.expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: x < 8" 3 | -------------------------------------------------------------------------------- /docs/src/kani-single-file.md: -------------------------------------------------------------------------------- 1 | # Usage on a single file 2 | 3 | [See here](./usage.md#usage-on-a-single-crate) 4 | -------------------------------------------------------------------------------- /docs/src/reference.md: -------------------------------------------------------------------------------- 1 | # Reference 2 | 3 | This section is the main reference for Kani. 4 | It contains sections that informally describe its main features. 5 | -------------------------------------------------------------------------------- /docs/src/tutorial/arbitrary-variables/check_rating.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /docs/src/tutorial/arbitrary-variables/safe_update.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | "NonZeroU32 is internally a u32 but it should never be 0." 3 | SUCCESS\ 4 | assertion failed: inventory.get(&id).unwrap() == quantity 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /docs/src/tutorial/arbitrary-variables/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | mod exercise_solution; 5 | pub mod inventory; 6 | pub mod rating; 7 | -------------------------------------------------------------------------------- /docs/src/tutorial/first-steps-v1/check_estimate_size.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Oh no, a failing corner case! 3 | -------------------------------------------------------------------------------- /docs/src/tutorial/first-steps-v2/verify_success.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: x < 4096 3 | SUCCESS\ 4 | assertion failed: y < 10 5 | -------------------------------------------------------------------------------- /docs/src/tutorial/first-steps-v2/will_fail.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | assertion failed: x < 4096 3 | -------------------------------------------------------------------------------- /docs/src/tutorial/kinds-of-failure/add_overflow.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | attempt to add with overflow 3 | -------------------------------------------------------------------------------- /docs/src/tutorial/kinds-of-failure/bound_check.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | index out of bounds: the length is less than or equal to the given index 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /docs/src/tutorial/kinds-of-failure/midpoint_overflow.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | attempt to add with overflow 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /docs/src/tutorial/kinds-of-failure/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | pub mod bounds_check; 4 | pub mod overflow; 5 | pub mod overflow_quicksort; 6 | -------------------------------------------------------------------------------- /docs/src/tutorial/loops-unwinding/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "loops-unwinding" 5 | version = "0.1.0" 6 | edition = "2018" 7 | 8 | [workspace] -------------------------------------------------------------------------------- /docs/src/tutorial/loops-unwinding/check_initialize_prefix.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | unwinding assertion loop 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/favicon.ico -------------------------------------------------------------------------------- /kani-compiler/Cargo.lock: -------------------------------------------------------------------------------- 1 | # This file is automatically @generated by Cargo. 2 | # It is not intended for manual editing. 3 | version = 3 4 | 5 | [[package]] 6 | name = "kani-compiler" 7 | version = "0.1.0" 8 | -------------------------------------------------------------------------------- /kani-dependencies: -------------------------------------------------------------------------------- 1 | CBMC_MAJOR="6" 2 | CBMC_MINOR="6" 3 | CBMC_VERSION="6.6.0" 4 | 5 | KISSAT_VERSION="4.0.1" 6 | -------------------------------------------------------------------------------- /kani-driver/src/concrete_playback/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | //! Implements the logic related to concrete playback 4 | 5 | pub mod playback; 6 | pub mod test_generator; 7 | -------------------------------------------------------------------------------- /kani-driver/src/coverage/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub mod cov_results; 5 | pub mod cov_session; 6 | -------------------------------------------------------------------------------- /kani-logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/kani-logo.png -------------------------------------------------------------------------------- /library/kani/build.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() { 5 | // Make sure `kani_sysroot` is a recognized config 6 | println!("cargo::rustc-check-cfg=cfg(kani_sysroot)"); 7 | } 8 | -------------------------------------------------------------------------------- /library/kani_macros/build.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() { 5 | // Make sure `kani_sysroot` is a recognized config 6 | println!("cargo::rustc-check-cfg=cfg(kani_sysroot)"); 7 | } 8 | -------------------------------------------------------------------------------- /rust-toolchain.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [toolchain] 5 | channel = "nightly-2025-06-03" 6 | components = ["llvm-tools", "rustc-dev", "rust-src", "rustfmt"] 7 | -------------------------------------------------------------------------------- /rustfmt.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | # Run rustfmt with this config (it should be picked up automatically). 5 | edition = "2021" 6 | style_edition = "2024" 7 | use_small_heuristics = "Max" 8 | merge_derives = false 9 | -------------------------------------------------------------------------------- /scripts/pyproject.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [tool.autopep8] 5 | max_line_length = 120 6 | recursive = true 7 | aggressive = 3 8 | ignore = "E302" # Ignore 2 spaces before functions until we fix fn docstrings 9 | -------------------------------------------------------------------------------- /scripts/setup/macos-10.15: -------------------------------------------------------------------------------- 1 | macos -------------------------------------------------------------------------------- /scripts/setup/macos-11: -------------------------------------------------------------------------------- 1 | macos -------------------------------------------------------------------------------- /scripts/setup/macos-12: -------------------------------------------------------------------------------- 1 | macos -------------------------------------------------------------------------------- /scripts/setup/macos-13: -------------------------------------------------------------------------------- 1 | macos -------------------------------------------------------------------------------- /scripts/setup/macos-14: -------------------------------------------------------------------------------- 1 | macos -------------------------------------------------------------------------------- /scripts/setup/ubuntu-22.04: -------------------------------------------------------------------------------- 1 | ubuntu -------------------------------------------------------------------------------- /scripts/setup/ubuntu-24.04: -------------------------------------------------------------------------------- 1 | ubuntu -------------------------------------------------------------------------------- /src/bin/cargo_kani.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | use anyhow::Result; 5 | 6 | fn main() -> Result<()> { 7 | kani_verifier::proxy("cargo-kani") 8 | } 9 | -------------------------------------------------------------------------------- /src/bin/kani.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | use anyhow::Result; 5 | 6 | fn main() -> Result<()> { 7 | kani_verifier::proxy("kani") 8 | } 9 | -------------------------------------------------------------------------------- /tests/.gitignore: -------------------------------------------------------------------------------- 1 | # Temporary files and folders 2 | *.json 3 | kani_concrete_playback 4 | rmet*/ 5 | target/ 6 | 7 | # Binary artifacts 8 | *.goto 9 | *.out 10 | smoke 11 | check_tests 12 | function 13 | -------------------------------------------------------------------------------- /tests/README.md: -------------------------------------------------------------------------------- 1 | # Kani Test Suites 2 | 3 | You can see more details about each test suite in this folder in the 4 | [Kani testing suites](https://model-checking.github.io/kani/regression-testing.html#kani-testing-suites). 5 | 6 | -------------------------------------------------------------------------------- /tests/assess-scan-test-scaffold/bar/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "bar" 6 | version = "0.1.0" 7 | edition = "2021" 8 | -------------------------------------------------------------------------------- /tests/assess-scan-test-scaffold/compile_error/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | /// Function with a compilation error 5 | pub fn with_error(left: usize, right: u32) -> usize { 6 | left + right 7 | } 8 | -------------------------------------------------------------------------------- /tests/assess-scan-test-scaffold/foo/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "foo" 6 | version = "0.1.0" 7 | edition = "2021" 8 | -------------------------------------------------------------------------------- /tests/assess-scan-test-scaffold/manifest_error/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | /// Nothing here 5 | pub fn void() {} 6 | -------------------------------------------------------------------------------- /tests/cargo-coverage/simple-lib/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "simple-lib" 5 | version = "0.1.0" 6 | edition = "2018" 7 | 8 | [dependencies] 9 | 10 | [workspace] 11 | -------------------------------------------------------------------------------- /tests/cargo-kani/.gitignore: -------------------------------------------------------------------------------- 1 | target/ 2 | Cargo.lock 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/asm/global/calls_crate_with_global_asm.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: x * y == 33" 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/asm/global/reads_static_var_in_crate_with_global_asm.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: x == 98" 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/asm/global_error/doesnt_call_crate_with_global_asm.expected: -------------------------------------------------------------------------------- 1 | error: Crate crate_with_global_asm contains global ASM, which is not supported by Kani. Rerun with `-Z unstable-options --ignore-global-asm` to suppress this error (**Verification results may be impacted**). 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/assert-reach/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn test() { 6 | let x = 4; 7 | let y = foo::foo(x); 8 | assert!(y == x); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/assert-reach/test.expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: z == x - 1" 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/assess-workspace-artifacts/subpackage/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "subpackage" 6 | version = "0.1.0" 7 | edition = "2021" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/build-rs-plus-host-with-kani-proofs/README.md: -------------------------------------------------------------------------------- 1 | This repo contains contains a minimal example that used to break compilation 2 | when using Kani. See https://github.com/model-checking/kani/issues/3101. 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/build-rs-plus-host-with-kani-proofs/constants/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "constants" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/build-rs-works/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "build-rs-works" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/build-rs-works/build.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() { 5 | println!("cargo:rustc-env=SET_IN_BUILD_RS=Y"); 6 | } 7 | -------------------------------------------------------------------------------- /tests/cargo-kani/build-rs-works/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn check() { 6 | assert!(env!("SET_IN_BUILD_RS") == "Y"); 7 | } 8 | -------------------------------------------------------------------------------- /tests/cargo-kani/cargo-features-flag/trivial_success.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/cargo-tests-dir/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/cargo-tests-dir/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub const ONE: u32 = 1; 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/cbmc-unknown-lang-mode/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn test() { 6 | assert!(1 + 1 == 2); 7 | } 8 | -------------------------------------------------------------------------------- /tests/cargo-kani/cbmc-unknown-lang-mode/test.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/chrono_dep/main.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/codegen-scalar-with-phantom/check_phantom_data.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: C.x == 0" 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/codegen-scalar-with-zsts/check_zst.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: C.x == 0" 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/demos/non-empty-range/check_range.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: range.is_none() || !range.as_ref().unwrap().is_empty()" 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/dependencies/check_dummy.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: x > 2 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/dependencies/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | pub fn check_dummy() { 6 | let x = kani::any::(); 7 | kani::assume(x > 10); 8 | assert!(x > 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/dependency-test/diamond-dependency/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [workspace] 5 | members = ["main", "dependency1", "dependency2", "dependency3"] 6 | -------------------------------------------------------------------------------- /tests/cargo-kani/dependency-test/diamond-dependency/harness.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/dev-depends/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/feature-flag/expected: -------------------------------------------------------------------------------- 1 | 3 successfully verified harnesses 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/firecracker-block-example/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "firecracker-block-example" 6 | version = "0.1.0" 7 | edition = "2018" 8 | -------------------------------------------------------------------------------- /tests/cargo-kani/firecracker-block-example/requirement_2642.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/firecracker-block-example/src/virtio_defs.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub const VIRTQ_DESC_F_NEXT: u16 = 0x1; 5 | pub const VIRTQ_DESC_F_WRITE: u16 = 0x2; 6 | -------------------------------------------------------------------------------- /tests/cargo-kani/iss2857/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "iss2857" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | sec1 = "0.7.3" 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/iss2857/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/itoa_dep/check_unsigned.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: result == &output" 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/libc/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub mod pthread_key_create; 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/mir-linker/expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Next is greater\ 3 | in function check_version 4 | -------------------------------------------------------------------------------- /tests/cargo-kani/nested-dirs/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [workspace] 4 | 5 | members = [ 6 | "crate1", 7 | "crate2", 8 | "crate2/nested_crate", 9 | ] 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/nested-dirs/crate1/a_check.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: v.len() == 3" 3 | VERIFICATION:- SUCCESSFUL 4 | -------------------------------------------------------------------------------- /tests/cargo-kani/nested-dirs/crate1/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn a_check() { 6 | let v = vec![1, 2, 3]; 7 | assert_eq!(v.len(), 3); 8 | } 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/nested-dirs/crate2/another_check.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: result == 4" 3 | VERIFICATION:- SUCCESSFUL 4 | -------------------------------------------------------------------------------- /tests/cargo-kani/nested-dirs/crate2/nested_crate/yet_another_check.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: y - x == 0" 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/nested-dirs/crate2/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn another_check() { 6 | let result = 2 + 2; 7 | assert_eq!(result, 4); 8 | } 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/no-std/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "no-std" 6 | version = "0.1.0" 7 | edition = "2024" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/no-std/expected: -------------------------------------------------------------------------------- 1 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. -------------------------------------------------------------------------------- /tests/cargo-kani/output-format/main.expected: -------------------------------------------------------------------------------- 1 | Description: "assertion failed: 1 + 1 == 2" 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/output-format/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | assert!(1 + 1 == 2); 7 | } 8 | -------------------------------------------------------------------------------- /tests/cargo-kani/rectangle-example/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub mod rectangle; 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/rectangle-example/stretched_rectangle_can_hold_original.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- FAILED 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/rectangle-example/stretched_rectangle_can_hold_original_fixed.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-config-toml/test_one_plus_two.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: p.sum() == 3 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-config-toml/test_sum.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: p.sum() == a.wrapping_add(b) 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-extern/test_sum.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion rust_add1(x) == x + 1 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-kissat/expected: -------------------------------------------------------------------------------- 1 | Solving with External SAT solver 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-lib/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "simple-lib" 5 | version = "0.1.0" 6 | edition = "2018" 7 | 8 | [dependencies] 9 | 10 | [workspace] 11 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-lib/test_one_plus_two.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: p.sum() == 3 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-lib/test_sum.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: p.sum() == a.wrapping_add(b) 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-main/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "empty-main" 5 | version = "0.1.0" 6 | edition = "2018" 7 | 8 | [dependencies] 9 | 10 | [workspace] 11 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-main/main.expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | assertion failed: 1 == 2 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-main/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | #[kani::proof] 4 | fn main() { 5 | assert!(1 == 2); 6 | } 7 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-proof-annotation/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "simple-proof-annotation" 6 | version = "0.1.0" 7 | edition = "2021" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-proof-annotation/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | assertion failed: 3 == 4 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-proof-annotation/main.expected: -------------------------------------------------------------------------------- 1 | error: no harnesses matched the harness filter: `main` 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-proof-annotation/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() { 5 | assert!(1 == 2); 6 | } 7 | 8 | #[kani::proof] 9 | fn harness() { 10 | assert!(3 == 4); 11 | } 12 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-unwind-annotation/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "simple-unwind-annotation" 6 | version = "0.1.0" 7 | edition = "2021" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-unwind-annotation/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | assertion failed: counter < 10 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/simple-unwind-annotation/harness_1.expected: -------------------------------------------------------------------------------- 1 | UNDETERMINED\ 2 | assertion failed: counter < 10 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/small-vec/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "check_stack_vec" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | 9 | [dependencies] 10 | smallvec = "1.8.0" 11 | -------------------------------------------------------------------------------- /tests/cargo-kani/small-vec/check_vec.expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: c < char::MAX"\ 3 | in function check_vec 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/cargo-kani/storage-markers/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [workspace] 4 | members = ["crate-with-bug", "crate-with-harness"] 5 | resolver = "2" 6 | -------------------------------------------------------------------------------- /tests/cargo-kani/storage-markers/crate-with-bug/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "crate-with-bug" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/storage-markers/crate-with-harness/call_fn_with_bug.expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | Description: "dereference failure: dead object"\ 3 | in function crate_with_bug::fn_with_bug 4 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-do-not-resolve/other_crate1/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn mock() {} 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-do-not-resolve/other_crate2/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn mock() {} 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-double-extern-path/crate_a/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | //! Define `assert_true` function. 4 | 5 | pub fn assert_true(b: bool) { 6 | assert!(b); 7 | } 8 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-double-extern-path/harness/expected: -------------------------------------------------------------------------------- 1 | error: Cannot stub `crate_b::assert_false`. Stub configuration for harness `check_inverted` has a cycle 2 | error: Cannot stub `crate_b::assert_true`. Stub configuration for harness `check_inverted` has a cycle 3 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-extern-path/harness.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-extern-path/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-extern-path/other_crate/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn magic_number() -> u32 { 5 | 42 6 | } 7 | 8 | pub fn twelve() -> u32 { 9 | 12 10 | } 11 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-foreign-method/main.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-foreign-method/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-private-foreign-function/main.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-private-foreign-function/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-public-foreign-function/main.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-public-foreign-function/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-resolve-extern-crate-as/harness.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-as-foreign/harness.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-as-foreign/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-foreign/harness.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-foreign/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-glob-foreign/harness.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-glob-foreign/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-in-foreign/harness.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-use-in-foreign/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/stubbing-validate-random/main.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/symlink/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/symlink/target: -------------------------------------------------------------------------------- 1 | foo -------------------------------------------------------------------------------- /tests/cargo-kani/type-mismatch/uses_std/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | pub fn bar(r: std::ops::Range) -> std::ops::Range { 4 | std::ops::Range { start: r.start + 5, end: r.end + 5 } 5 | } 6 | -------------------------------------------------------------------------------- /tests/cargo-kani/unexpected_cfgs/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "unexpected_cfgs" 6 | version = "0.1.0" 7 | edition = "2021" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/unexpected_cfgs/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/vecdeque-cve/abstract_remove_maintains_invariant.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/vecdeque-cve/abstract_reserve_maintains_invariant_with_cve.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- FAILED 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/vecdeque-cve/abstract_reserve_maintains_invariant_with_cve_fixed.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/vecdeque-cve/minimal_example_with_cve_fixed.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/vecdeque-cve/minimal_example_with_cve_should_fail.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- FAILED 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/ws-crate-type-bin/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [workspace] 5 | members = [ 6 | "libcrate", 7 | "bincrate", 8 | ] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/ws-crate-type-bin/expected: -------------------------------------------------------------------------------- 1 | 2 successfully verified harnesses 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/ws-flag/expected: -------------------------------------------------------------------------------- 1 | 2 successfully verified harnesses 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/ws-flag/libcrate/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | //! test in sub-crate. 5 | 6 | #[kani::proof] 7 | fn check_libcrate_proof() { 8 | assert!(1 == 1); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/ws-flag/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | //! test in top crate. 5 | 6 | #[kani::proof] 7 | fn check_toplevel_proof() { 8 | assert!(1 == 1); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-kani/ws-specified/expected: -------------------------------------------------------------------------------- 1 | Complete - 1 successfully verified harnesses, 1 failures, 2 total. 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/ws-specified/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | //! empty lib for toplevel directory 5 | -------------------------------------------------------------------------------- /tests/cargo-kani/zero-harnesses-is-success/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "zero-harnesses-is-success" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/cargo-kani/zero-harnesses-is-success/expected: -------------------------------------------------------------------------------- 1 | No proof harnesses (functions with #[kani::proof]) were found to verify. 2 | -------------------------------------------------------------------------------- /tests/cargo-kani/zero-harnesses-is-success/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | pub fn nop() {} 4 | -------------------------------------------------------------------------------- /tests/cargo-ui/assess-error/expected: -------------------------------------------------------------------------------- 1 | error: Failed to compile lib `compilation_error` 2 | error: Failed to assess project: Failed to build all targets 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/debug/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "debug" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | 10 | [package.metadata.kani.flags] 11 | debug=true 12 | -------------------------------------------------------------------------------- /tests/cargo-ui/debug/expected: -------------------------------------------------------------------------------- 1 | DEBUG kani_compiler 2 | goto-cc 3 | cbmc 4 | -------------------------------------------------------------------------------- /tests/cargo-ui/multiple-harnesses/expected: -------------------------------------------------------------------------------- 1 | Checking harness bar... 2 | Checking harness foo... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/cargo-ui/stubbing-flag/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/cargo-ui/supported-lib-types/cdylib-rlib/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_ok... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/supported-lib-types/cdylib/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_ok... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/supported-lib-types/dylib/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_ok... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/supported-lib-types/lib-rlib/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_ok... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/supported-lib-types/lib/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_ok... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/supported-lib-types/rlib/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_ok... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/supported-lib-types/staticlib/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_ok... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/target-selection/bin-target/expected: -------------------------------------------------------------------------------- 1 | Checking harness verify::foo_harness... 2 | 3 | Status: SATISFIED\ 4 | Description: "Cover `foo`" 5 | 6 | ** 1 of 1 cover properties satisfied 7 | 8 | -------------------------------------------------------------------------------- /tests/cargo-ui/target-selection/lib-target/expected: -------------------------------------------------------------------------------- 1 | Checking harness verify::lib_harness... 2 | Status: SATISFIED\ 3 | Description: "Cover lib" 4 | 5 | -------------------------------------------------------------------------------- /tests/cargo-ui/target-selection/non-test-targets/expected: -------------------------------------------------------------------------------- 1 | Checking harness verify::bar_harness... 2 | Checking harness verify::foo_harness... 3 | Checking harness verify::lib_harness... 4 | 5 | Complete - 3 successfully verified harnesses, 0 failures, 3 total. 6 | -------------------------------------------------------------------------------- /tests/cargo-ui/unstable-attr/enabled/expected: -------------------------------------------------------------------------------- 1 | Checking harness harness... 2 | defs::no_op.cover\ 3 | Status: SATISFIED 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/cargo-ui/unsupported-lib-types/proc-macro/expected: -------------------------------------------------------------------------------- 1 | Skipped verification of the following unsupported targets: 'lib'. 2 | error: No supported targets were found. 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/unsupported-lib-types/rlib-pmacro/expected: -------------------------------------------------------------------------------- 1 | error: could not compile `unsupported-lib` 2 | -------------------------------------------------------------------------------- /tests/cargo-ui/verbose-cmds/expected: -------------------------------------------------------------------------------- 1 | CARGO_ENCODED_RUSTFLAGS= 2 | cargo + 3 | Running: `goto-cc 4 | Running: `goto-instrument 5 | Checking harness dummy_harness... 6 | Running: `cbmc 7 | -------------------------------------------------------------------------------- /tests/cargo-ui/verbose/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "verbose" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | 10 | [package.metadata.kani.flags] 11 | verbose=true 12 | -------------------------------------------------------------------------------- /tests/cargo-ui/verbose/expected: -------------------------------------------------------------------------------- 1 | goto-cc 2 | cbmc 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude-unknown/bin_package/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_bin_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude-unknown/expected: -------------------------------------------------------------------------------- 1 | error: package ID specification `unknown_package` did not match any packages 2 | error: Failed to retrieve information for `unknown_package` 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude-unknown/lib_package/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn api() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_lib_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude-unknown/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_ws_package() { 8 | assert!(1 + 1 == 3); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude/bin_package/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_bin_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude/expected: -------------------------------------------------------------------------------- 1 | Checking harness harness_in_bin_package... 2 | Checking harness harness_in_lib_package... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude/lib_package/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn api() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_lib_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-exclude/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_ws_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select-unknown/bin_package/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_bin_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select-unknown/expected: -------------------------------------------------------------------------------- 1 | error: package ID specification `unknown_package` did not match any packages 2 | error: Failed to retrieve information for `unknown_package` 3 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select-unknown/lib_package/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn api() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_lib_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select-unknown/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_ws_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select/bin_package/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_bin_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select/expected: -------------------------------------------------------------------------------- 1 | Checking harness harness_in_bin_package... 2 | Checking harness harness_in_lib_package... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select/lib_package/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn api() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_lib_package() { 8 | assert!(1 + 1 == 2); 9 | } 10 | -------------------------------------------------------------------------------- /tests/cargo-ui/ws-package-select/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn main() {} 5 | 6 | #[kani::proof] 7 | fn harness_in_ws_package() { 8 | assert!(1 + 1 == 3); 9 | } 10 | -------------------------------------------------------------------------------- /tests/coverage/div-zero/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn div(x: u16, y: u16) -> u16 { 5 | if y != 0 { x / y } else { 0 } 6 | } 7 | 8 | #[kani::proof] 9 | fn main() { 10 | div(11, 3); 11 | } 12 | -------------------------------------------------------------------------------- /tests/expected/MemPredicates/adt_with_metadata.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Kani does not support reasoning about pointer to unallocated memory 2 | 3 | Verification failed for - invalid_access::check_invalid_dyn_ptr 4 | Complete - 3 successfully verified harnesses, 1 failures, 4 total. 5 | -------------------------------------------------------------------------------- /tests/expected/MemPredicates/ptr_size_validity.expected: -------------------------------------------------------------------------------- 1 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. -------------------------------------------------------------------------------- /tests/expected/allocation/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: foo() == None 3 | SUCCESS\ 4 | assertion failed: foo() == y 5 | -------------------------------------------------------------------------------- /tests/expected/any_vec/out_bounds.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_always_out_bounds... 2 | 3 | Failed Checks: Rust intrinsic assumption failed 4 | in >::get_unchecked 5 | 6 | Verification failed for - check_always_out_bounds 7 | -------------------------------------------------------------------------------- /tests/expected/arith-offset-i32-fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | dereference failure: pointer outside object bounds -------------------------------------------------------------------------------- /tests/expected/arith-offset-overflow/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/arith-offset-u8-fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | dereference failure: pointer outside object bounds -------------------------------------------------------------------------------- /tests/expected/arith_checks/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: attempt to subtract with overflow 2 | -------------------------------------------------------------------------------- /tests/expected/array/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: y[0] == 1 3 | SUCCESS\ 4 | assertion failed: y[1] == 2 5 | FAILURE\ 6 | index out of bounds: the length is less than or equal to the given index 7 | -------------------------------------------------------------------------------- /tests/expected/assert-arg-error/expected: -------------------------------------------------------------------------------- 1 | cannot find value `foo` in this scope 2 | -------------------------------------------------------------------------------- /tests/expected/assert-eq/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: x + 1 == y 3 | FAILURE\ 4 | assertion failed: x == y 5 | UNREACHABLE\ 6 | assertion failed: x != y 7 | -------------------------------------------------------------------------------- /tests/expected/assert-location/assert-false/expected: -------------------------------------------------------------------------------- 1 | line 18 assertion failed: false: FAILURE 2 | line 23 "{}", s: FAILURE 3 | line 27 "Fail with custom static message": FAILURE 4 | -------------------------------------------------------------------------------- /tests/expected/assert-location/debug-assert/expected: -------------------------------------------------------------------------------- 1 | line 13 "This should fail and stop the execution": FAILURE 2 | line 14 "This should be unreachable": SUCCESS 3 | -------------------------------------------------------------------------------- /tests/expected/associated-fn/expected: -------------------------------------------------------------------------------- 1 | Checking harness Dummy::new... 2 | VERIFICATION:- SUCCESSFUL 3 | 4 | -------------------------------------------------------------------------------- /tests/expected/async_proof/expected: -------------------------------------------------------------------------------- 1 | `foo` is not a valid option for `#[kani::proof]`. 2 | 3 | `#[kani::proof]` cannot be applied to async functions that take arguments for now 4 | -------------------------------------------------------------------------------- /tests/expected/bounded-arbitrary/option/option.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_option... 2 | 3 | ** 6 of 6 cover properties satisfied 4 | 5 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/bounded-arbitrary/result/result.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_result... 2 | 3 | ** 10 of 10 cover properties satisfied 4 | 5 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/bounded-arbitrary/string/string.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_string... 2 | 3 | ** 6 of 6 cover properties satisfied 4 | 5 | Manual Harness Summary: 6 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/closure/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | attempt to add with overflow 3 | SUCCESS\ 4 | attempt to add with overflow 5 | SUCCESS\ 6 | attempt to add with overflow 7 | SUCCESS\ 8 | attempt to add with overflow 9 | SUCCESS\ 10 | assertion failed: original_num + 12 == num 11 | -------------------------------------------------------------------------------- /tests/expected/closure2/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | attempt to add with overflow 3 | SUCCESS\ 4 | attempt to add with overflow 5 | SUCCESS\ 6 | assertion failed: z == 102 7 | SUCCESS\ 8 | assertion failed: g(z) == 206 9 | -------------------------------------------------------------------------------- /tests/expected/closure3/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | attempt to add with overflow 3 | SUCCESS\ 4 | attempt to add with overflow 5 | SUCCESS\ 6 | assertion failed: num + 10 == y 7 | -------------------------------------------------------------------------------- /tests/expected/coroutines/as_parameter/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/cover/cover-fail/expected: -------------------------------------------------------------------------------- 1 | Status: UNSATISFIABLE\ 2 | Description: "cover condition: x != 0"\ 3 | in function cover_overconstrained 4 | 5 | ** 0 of 1 cover properties satisfied 6 | 7 | VERIFICATION:- SUCCESSFUL 8 | -------------------------------------------------------------------------------- /tests/expected/dead-invalid-access-via-raw/main.expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | address must be a multiple of its type's alignment 3 | SUCCESS\ 4 | pointer NULL 5 | SUCCESS\ 6 | pointer invalid 7 | SUCCESS\ 8 | deallocated dynamic object 9 | FAILURE\ 10 | dead object 11 | -------------------------------------------------------------------------------- /tests/expected/dead-invalid-access-via-raw/value.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: dereference failure: dead object 2 | -------------------------------------------------------------------------------- /tests/expected/dealloc/stack/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | Description: "free argument must be dynamic object" 3 | 4 | VERIFICATION:- FAILED 5 | -------------------------------------------------------------------------------- /tests/expected/derive-arbitrary/phantom_data/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/derive-arbitrary/phantom_pinned/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/derive-bounded-arbitrary/enum.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_enum... 2 | 3 | ** 15 of 15 cover properties satisfied 4 | 5 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/derive-bounded-arbitrary/generic_default.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_my_vec... 2 | 3 | ** 2 of 2 cover properties satisfied 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/derive-bounded-arbitrary/struct.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_my_vec... 2 | 3 | ** 5 of 5 cover properties satisfied 4 | 5 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/derive-invariant/generic_struct/expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "assertion failed: point.is_safe()" 3 | -------------------------------------------------------------------------------- /tests/expected/derive-invariant/named_struct/expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "assertion failed: point.is_safe()" 3 | -------------------------------------------------------------------------------- /tests/expected/derive-invariant/safety_invariant_fail/expected: -------------------------------------------------------------------------------- 1 | - Status: FAILURE\ 2 | - Description: "assertion failed: wrapper.is_safe()" 3 | 4 | Verification failed for - check_invariant_fail 5 | -------------------------------------------------------------------------------- /tests/expected/derive-invariant/unnamed_struct/expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "assertion failed: point.is_safe()" 3 | -------------------------------------------------------------------------------- /tests/expected/dynamic-error-trait/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: mm.size == 2 3 | FAILURE\ 4 | assertion failed: mm.size == 3 5 | -------------------------------------------------------------------------------- /tests/expected/dynamic-trait-static-dispatch/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: bar.a() == 3 3 | SUCCESS\ 4 | assertion failed: bar.b() == 5 5 | -------------------------------------------------------------------------------- /tests/expected/empty/expected: -------------------------------------------------------------------------------- 1 | 0 of 0 failed 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/expected/empty/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | /// This test checks that zero checks are reported for an empty test 5 | 6 | #[kani::proof] 7 | fn check_nothing() {} 8 | -------------------------------------------------------------------------------- /tests/expected/enum/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: x == 10 3 | UNREACHABLE\ 4 | assertion failed: false 5 | UNREACHABLE\ 6 | assertion failed: false 7 | SUCCESS\ 8 | assertion failed: x == 30 && y == 60.0 9 | FAILURE\ 10 | assertion failed: x == 31 11 | -------------------------------------------------------------------------------- /tests/expected/function-contract/arbitrary_ensures_fail.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: FAILURE\ 3 | - Description: "|result : &u32| *result == x"\ 4 | in function max 5 | 6 | VERIFICATION:- FAILED 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/arbitrary_ensures_pass.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result : &u32| *result == x || *result == y"\ 4 | in function max 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/arbitrary_requires_fail.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: FAILURE\ 3 | - Description: "attempt to divide by zero"\ 4 | arbitrary_requires_fail.rs:7:5 5 | -------------------------------------------------------------------------------- /tests/expected/function-contract/arbitrary_requires_pass.expected: -------------------------------------------------------------------------------- 1 | arithmetic_overflow\ 2 | - Status: SUCCESS\ 3 | - Description: "attempt to divide by zero"\ 4 | in function div 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/attribute_complain.expected: -------------------------------------------------------------------------------- 1 | error: Using the proof_for_contract attribute requires activating the unstable `function-contracts` feature 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/attribute_no_complain.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/attribute_no_complain.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::ensures(|result| true)] 5 | fn always() {} 6 | 7 | #[kani::proof] 8 | fn random_harness() {} 9 | -------------------------------------------------------------------------------- /tests/expected/function-contract/checking_from_external_mod.expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "|result : &u32| (*result == x) | (*result == y)"\ 3 | in function max 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/checking_in_impl.expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "|result : &WrappedInt| (*result == self) | (*result == y)"\ 3 | in function WrappedInt::max 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/const_fn.expected: -------------------------------------------------------------------------------- 1 | Checking harness check... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/expected/function-contract/const_fn_with_effect.expected: -------------------------------------------------------------------------------- 1 | Checking harness check... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/expected/function-contract/const_generic_function.expected: -------------------------------------------------------------------------------- 1 | ** 1 of 2 | Failed Checks: Check that *dst is assignable 3 | -------------------------------------------------------------------------------- /tests/expected/function-contract/diverging_loop.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: unwinding assertion loop 0 2 | 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /tests/expected/function-contract/gcd_rec_code_fail.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: |result : &T| *result != 0 && x % *result == 0 && y % *result == 0 2 | 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /tests/expected/function-contract/gcd_rec_contract_fail.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: |result : &T| *result != 0 && x % *result == 1 && y % *result == 0 2 | 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /tests/expected/function-contract/gcd_success.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result : &T| *result != 0 && x % *result == 0 && y % *result == 0"\ 4 | in function gcd 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/generic_infinity_recursion.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/block.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result| old({let x = &ptr; let y = **x; y + 1}) == *ptr"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/clone_pass.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result| old(ptr.clone()).0 + 1 == ptr.0"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/copy_pass.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result| old(ptr.0) + 1 == ptr.0"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/function_call.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result| old(add1(dereference(ptr))) == *ptr"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/no_modifies.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result : &u32| old(val) == val && old(val.wrapping_add(1)) == *result"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/old_old.expected: -------------------------------------------------------------------------------- 1 | error: Nested calls to `old` are prohibited 2 | #[kani::ensures(|result| old(*ptr + old(1)) == *ptr)] 3 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/respects-preconditions/ensures_before_requires.expected: -------------------------------------------------------------------------------- 1 | next\ 2 | - Status: SUCCESS\ 3 | - Description: "attempt to add with overflow" 4 | 5 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/expected/function-contract/history/respects-preconditions/modifies.expected: -------------------------------------------------------------------------------- 1 | modify\ 2 | - Status: SUCCESS\ 3 | - Description: "attempt to add with overflow" 4 | 5 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/expected/function-contract/history/respects-preconditions/requires_before_ensures.expected: -------------------------------------------------------------------------------- 1 | next\ 2 | - Status: SUCCESS\ 3 | - Description: "attempt to add with overflow" 4 | 5 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/expected/function-contract/history/side_effect.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: |result| old({*ptr+=1; *ptr}) == _val 2 | VERIFICATION:- FAILED 3 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/simple_fail.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: FAILURE\ 3 | - Description: "|_| old(*ptr) == *ptr" 4 | 5 | Failed Checks: |_| old(*ptr) == *ptr 6 | 7 | VERIFICATION:- FAILED 8 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/simple_pass.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result| old(*ptr + 1) == *ptr"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/ui/no_args.expected: -------------------------------------------------------------------------------- 1 | Failed assertion args.len() == 1 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/ui/noncopy_ignore.expected: -------------------------------------------------------------------------------- 1 | use of moved value: `ptr` 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/ui/old_result.expected: -------------------------------------------------------------------------------- 1 | cannot find value `result` in this scope 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/history/ui/statement.expected: -------------------------------------------------------------------------------- 1 | error 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/interior-mutability/api/cell.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| im.x.get() < 101"\ 4 | in function modify 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/interior-mutability/api/unsafecell.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| unsafe{*im.x.get()} < 101"\ 4 | in function modify 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/interior-mutability/whole-struct/cell.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| im.x.get() < 101"\ 4 | in function modify 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/interior-mutability/whole-struct/oncecell.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| im.x.get().is_some()"\ 4 | in function modify 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/interior-mutability/whole-struct/refcell.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| unsafe{*im.x.as_ptr()} < 101"\ 4 | in function modify 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/interior-mutability/whole-struct/unsafecell.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| unsafe{*im.x.get()} < 101"\ 4 | in function modify 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/check_only_verification.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/expr_pass.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/expr_replace_fail.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: FAILURE\ 3 | - Description: ""Increment"" 4 | 5 | Failed Checks: "Increment" 6 | 7 | VERIFICATION:- FAILED 8 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/expr_replace_pass.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "Increment"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/fail_missing_recursion_attr.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- FAILED 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/field_pass.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/field_replace_fail.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: FAILURE\ 3 | - Description: "Increment havocked" 4 | 5 | Failed Checks: Increment havocked 6 | 7 | VERIFICATION:- FAILED 8 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/field_replace_pass.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "Increment"\ 4 | 5 | main.assertion\ 6 | - Status: SUCCESS\ 7 | - Description: "Unchanged" 8 | 9 | VERIFICATION:- SUCCESSFUL 10 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/global_fail.expected: -------------------------------------------------------------------------------- 1 | assigns\ 2 | - Status: FAILURE\ 3 | - Description: "Check that *var_3 is assignable"\ 4 | in function modify 5 | 6 | Failed Checks: Check that *var_3 is assignable\ 7 | in modify 8 | 9 | VERIFICATION:- FAILED 10 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/global_pass.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/global_replace_fail.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: FAILURE\ 3 | - Description: "not havocked"\ 4 | in function main 5 | 6 | Failed Checks: not havocked 7 | 8 | VERIFICATION:- FAILED 9 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/global_replace_pass.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "replaced"\ 4 | in function main 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/mistake_condition_return.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: assertion failed: res == 100 2 | 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/simple_fail.expected: -------------------------------------------------------------------------------- 1 | assigns\ 2 | - Status: FAILURE\ 3 | - Description: "Check that *var_6 is assignable" 4 | 5 | Failed Checks: Check that *var_6 is assignable 6 | 7 | VERIFICATION:- FAILED 8 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/simple_only_verification.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/simple_only_verification_modifies.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/simple_pass.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/stmt_expr.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/unique_arguments.expected: -------------------------------------------------------------------------------- 1 | test_stubbing.assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "a is 1" 4 | 5 | test_stubbing.assertion\ 6 | - Status: SUCCESS\ 7 | - Description: "b is 2" 8 | 9 | VERIFICATION:- SUCCESSFUL 10 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies/zst_pass.expected: -------------------------------------------------------------------------------- 1 | .assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "ptr NULL or writable up to size"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies_fat_pointer/nondeterministic_size.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| x.iter().map(|v| *v == 0).fold(true,|a,b|a&b)"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies_fat_pointer/slice_of_array.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| x[0..3].iter().map(|v| *v == 0).fold(true,|a,b|a&b)"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies_fat_pointer/u32slice.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| x.iter().map(|v| *v == 0).fold(true,|a,b|a&b)"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/modifies_fat_pointer/u8slice.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|_| x.iter().map(|v| *v == 0).fold(true,|a,b|a&b)"\ 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/function-contract/multiple_replace_fail.expected: -------------------------------------------------------------------------------- 1 | warning: Multiple occurrences of `stub_verified(one)`. 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/multiple_replace_pass.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/pattern_use.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: FAILURE\ 3 | - Description: "attempt to divide by zero"\ 4 | -------------------------------------------------------------------------------- /tests/expected/function-contract/prohibit-pointers/allowed_const_ptr.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/prohibit-pointers/allowed_mut_ref.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/prohibit-pointers/allowed_mut_return_ref.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/prohibit-pointers/allowed_ref.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/prohibit-pointers/hidden.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/prohibit-pointers/plain_pointer.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/prohibit-pointers/return_pointer.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-contract/simple_ensures_fail.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: FAILURE\ 3 | - Description: "|result : &u32| *result == x"\ 4 | in function max 5 | 6 | Failed Checks: |result : &u32| *result == x 7 | 8 | VERIFICATION:- FAILED 9 | -------------------------------------------------------------------------------- /tests/expected/function-contract/simple_ensures_pass.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result : &u32| (*result == x) | (*result == y)"\ 4 | in function max 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/simple_ensures_pass_no_annotation.expected: -------------------------------------------------------------------------------- 1 | assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "|result| (*result == x) | (*result == y)"\ 4 | in function max 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/function-contract/simple_replace_fail.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: FAILURE\ 3 | - Description: ""contract doesn't guarantee equality"" 4 | -------------------------------------------------------------------------------- /tests/expected/function-contract/simple_replace_pass.expected: -------------------------------------------------------------------------------- 1 | .assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "divisor != 0" 4 | 5 | main.assertion\ 6 | - Status: SUCCESS\ 7 | - Description: ""contract guarantees smallness"" 8 | 9 | VERIFICATION:- SUCCESSFUL 10 | -------------------------------------------------------------------------------- /tests/expected/function-contract/trait_impls/associated_fn.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_foo_b... 2 | VERIFICATION:- SUCCESSFUL 3 | 4 | Checking harness check_foo_a... 5 | VERIFICATION:- SUCCESSFUL 6 | 7 | Complete - 2 successfully verified harnesses, 0 failures, 2 total 8 | -------------------------------------------------------------------------------- /tests/expected/function-contract/type_annotation_needed.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/function-stubbing-error/expected: -------------------------------------------------------------------------------- 1 | error: Use of unstable feature 'stubbing' in harness `main`. 2 | To enable stubbing, pass option `-Z stubbing` 3 | -------------------------------------------------------------------------------- /tests/expected/function-stubbing-no-harness/expected: -------------------------------------------------------------------------------- 1 | error: no harnesses matched the harness filter: `foo` 2 | -------------------------------------------------------------------------------- /tests/expected/generics/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: x == y.data 3 | SUCCESS\ 4 | assertion failed: z == w.data 5 | -------------------------------------------------------------------------------- /tests/expected/intrinsics/align_of_dst.expected: -------------------------------------------------------------------------------- 1 | Checking harness check_zst1024... 2 | Checking harness check_large... 3 | Checking harness check_1char_tup... 4 | Checking harness check_1zst_usize... 5 | 6 | Complete - 4 successfully verified harnesses, 0 failures, 4 total -------------------------------------------------------------------------------- /tests/expected/intrinsics/breakpoint/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: true -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy-nonoverlapping/copy-overflow/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | copy_nonoverlapping: attempt to compute number in bytes which would overflow -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy-nonoverlapping/copy-overlapping/expected: -------------------------------------------------------------------------------- 1 | memcpy src/dst overlap -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy-nonoverlapping/copy-unaligned-dst/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | `dst` must be properly aligned -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy-nonoverlapping/copy-unaligned-src/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | `src` must be properly aligned -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy-nonoverlapping/copy-unreadable-src/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | memcpy source region readable -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy-nonoverlapping/copy-unwritable-dst/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | memcpy destination region writeable -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy/copy-overflow/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | copy: attempt to compute number in bytes which would overflow -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy/copy-unaligned-dst/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | `dst` must be properly aligned -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy/copy-unaligned-src/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | `src` must be properly aligned -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy/copy-unreadable-src/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | memmove source region readable -------------------------------------------------------------------------------- /tests/expected/intrinsics/copy/copy-unwritable-dst/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | memmove destination region writeable -------------------------------------------------------------------------------- /tests/expected/intrinsics/offset-same-object/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Offset result and original pointer should point to the same allocation 2 | -------------------------------------------------------------------------------- /tests/expected/intrinsics/ptr_offset_from_unsigned/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Expected non-negative distance between pointers 2 | -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-arith-overflows/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | attempt to compute simd_add which would overflow 3 | FAILURE\ 4 | attempt to compute simd_sub which would overflow 5 | FAILURE\ 6 | attempt to compute simd_mul which would overflow -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-cmp-result-type-is-diff-size/expected: -------------------------------------------------------------------------------- 1 | expected return type with length 2 (same as input type `u64x2`), found `u32x4` with length 4 2 | error: aborting due to 1 previous error -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-div-div-zero/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | division by zero -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-extract-wrong-type/expected: -------------------------------------------------------------------------------- 1 | expected return type `i64` (element of input `i64x2`), found `i32` 2 | error: aborting due to 1 previous error -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-insert-wrong-type/expected: -------------------------------------------------------------------------------- 1 | expected inserted type `i64` (element of input `i64x2`), found `i32` 2 | error: aborting due to 1 previous error -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-rem-div-zero/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | division by zero -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-result-type-is-float/expected: -------------------------------------------------------------------------------- 1 | expected return type with integer elements, found `f32x2` with non-integer `f32` 2 | error: aborting due to 1 previous error -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-shl-shift-negative/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | attempt simd_shl with negative shift distance -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-shl-shift-too-large/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | attempt simd_shl with excessive shift distance -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-shr-shift-negative/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | attempt simd_shr with negative shift distance -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-shr-shift-too-large/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | attempt simd_shr with excessive shift distance -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-shuffle-indexes-out/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | index out of bounds: the length is less than or equal to the given index -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-shuffle-result-type-is-diff-size/expected: -------------------------------------------------------------------------------- 1 | expected return type of length 4, found `i64x2` with length 2 2 | error: aborting due to 1 previous error -------------------------------------------------------------------------------- /tests/expected/intrinsics/simd-shuffle-result-type-is-diff-type/expected: -------------------------------------------------------------------------------- 1 | expected return element type `i64` (element of input `i64x2`), found `f64x2` with element type `f64` 2 | error: aborting due to 1 previous error -------------------------------------------------------------------------------- /tests/expected/intrinsics/sub_with_overflow_ice_fixme/expected: -------------------------------------------------------------------------------- 1 | Kani unexpectedly panicked during compilation. 2 | -------------------------------------------------------------------------------- /tests/expected/intrinsics/transmute_diff_size.expected: -------------------------------------------------------------------------------- 1 | error[E0512]: cannot transmute between types of different sizes, or dependently-sized types 2 | error: aborting due to 3 previous errors 3 | -------------------------------------------------------------------------------- /tests/expected/intrinsics/unreachable/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | "unreachable code" -------------------------------------------------------------------------------- /tests/expected/intrinsics/volatile_load/unaligned/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | `src` must be properly aligned -------------------------------------------------------------------------------- /tests/expected/intrinsics/write_bytes/out-of-bounds/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | memset destination region writeable -------------------------------------------------------------------------------- /tests/expected/intrinsics/write_bytes/overflow/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | write_bytes: attempt to compute number in bytes which would overflow -------------------------------------------------------------------------------- /tests/expected/intrinsics/write_bytes/unaligned/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | `dst` must be properly aligned -------------------------------------------------------------------------------- /tests/expected/issue-2239/issue_2239.expected: -------------------------------------------------------------------------------- 1 | test_trivial_bounds.unreachable.1\ 2 | - Status: FAILURE\ 3 | - Description: "unreachable code" 4 | 5 | VERIFICATION:- FAILED -------------------------------------------------------------------------------- /tests/expected/issue-2589/issue_2589.expected: -------------------------------------------------------------------------------- 1 | error: Type `std::string::String` does not implement trait `Dummy`. This is likely because `stub` is used as a stub but its generic bounds are not being met. 2 | -------------------------------------------------------------------------------- /tests/expected/issue-3022/issue_3022.expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | - Status: SUCCESS\ 3 | - Description: "assertion failed: inner == func2.inner" 4 | 5 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/expected/iterator/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | unreachable code 3 | SUCCESS\ 4 | attempt to multiply with overflow 5 | SUCCESS\ 6 | assertion failed: z == 6 7 | -------------------------------------------------------------------------------- /tests/expected/iterator/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | let mut z = 1; 7 | for i in 1..4 { 8 | z *= i; 9 | } 10 | assert!(z == 6); 11 | } 12 | -------------------------------------------------------------------------------- /tests/expected/loop-backedge/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/count_zero.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/count_zero_loop_contracts_disable.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/fixme_box.expected: -------------------------------------------------------------------------------- 1 | internal error: entered unreachable code: The loop invariant support only reference of user variables. The provided invariants contain unsupported dereference.\ -------------------------------------------------------------------------------- /tests/expected/loop-contract/function_with_loop_no_assertion.expected: -------------------------------------------------------------------------------- 1 | has_loop.loop_invariant_base.1\ 2 | - Status: SUCCESS\ 3 | - Description: "Check invariant before entry for loop has_loop.0"\ 4 | in function has_loop 5 | 6 | 7 | 8 | VERIFICATION:- SUCCESSFUL 9 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/loop_with_old.expected: -------------------------------------------------------------------------------- 1 | loop_with_old.loop_invariant_base.1\ 2 | - Status: SUCCESS\ 3 | - Description: "Check invariant before entry for loop loop_with_old.0" 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/loop_with_old_and_prev.expected: -------------------------------------------------------------------------------- 1 | loop_with_old_and_prev.loop_invariant_base.1\ 2 | - Status: SUCCESS\ 3 | - Description: "Check invariant before entry for loop loop_with_old_and_prev.0"\ 4 | 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/loop_with_prev.expected: -------------------------------------------------------------------------------- 1 | loop_with_prev.loop_invariant_step.1\ 2 | - Status: SUCCESS\ 3 | - Description: "Check invariant after step for loop loop_with_prev.0" 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/loop_with_prev_break_first_iter.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: assertion failed: (i >= 2) && (i <= 100) && (__kani_prev_var_ 2 | 3 | VERIFICATION:- FAILED 4 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/loop_with_true_invariant.expected: -------------------------------------------------------------------------------- 1 | main.loop_invariant_base.1\ 2 | - Status: SUCCESS\ 3 | - Description: "Check invariant before entry for loop main.0" 4 | 5 | VERIFICATION:- SUCCESSFUL 6 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/memchar_naive.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/multiple_loops.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 3 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/simple_loop_loop.expected: -------------------------------------------------------------------------------- 1 | main.loop_invariant_base.1\ 2 | - Status: SUCCESS\ 3 | - Description: "Check invariant before entry for loop main.0"\ 4 | in function main 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/simple_while_loop.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/simple_while_loop_not_enabled.expected: -------------------------------------------------------------------------------- 1 | Unwinding loop 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/expected/loop-contract/small_slice_eq.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/niche/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | assertion failed: false 3 | UNREACHABLE\ 4 | assertion failed: false 5 | SUCCESS\ 6 | assertion failed: a == *b 7 | -------------------------------------------------------------------------------- /tests/expected/niche2/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | assertion failed: false 3 | SUCCESS\ 4 | assertion failed: x == 10 5 | UNREACHABLE\ 6 | assertion failed: false 7 | UNREACHABLE\ 8 | assertion failed: false 9 | -------------------------------------------------------------------------------- /tests/expected/nondet-slice-i32-oob/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | dereference failure: pointer outside object bounds\ 3 | in function check_out_of_bounds 4 | -------------------------------------------------------------------------------- /tests/expected/nondet-slice-u8-oob/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | dereference failure: pointer outside object bounds\ 3 | in function check_out_of_bounds 4 | -------------------------------------------------------------------------------- /tests/expected/object-bits/insufficient/expected: -------------------------------------------------------------------------------- 1 | too many addressed objects: maximum number of objects is set to 2^n=32 (with n=5); use the `-Z unstable-options --cbmc-args --object-bits n` option to increase the maximum number 2 | -------------------------------------------------------------------------------- /tests/expected/offset-bounds-check/start_from_oob.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Offset result and original pointer must point to the same allocation 2 | Verification failed for - check_add_to_oob 3 | 4 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. 5 | -------------------------------------------------------------------------------- /tests/expected/offset-bytes-overflow/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Offset in bytes overflows isize 2 | Verification failed for - check_wrap_offset 3 | 4 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. 5 | -------------------------------------------------------------------------------- /tests/expected/offset-from-bytes-overflow/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Offset in bytes overflows isize 2 | Verification failed for - main 3 | 4 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. 5 | -------------------------------------------------------------------------------- /tests/expected/offset-from-distance-check/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Expected the distance between the pointers, in bytes, to be a 2 | multiple of the size of `T` 3 | VERIFICATION:- FAILED -------------------------------------------------------------------------------- /tests/expected/offset-i32-fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | dereference failure: pointer outside object bounds -------------------------------------------------------------------------------- /tests/expected/offset-invalid-args/invalid_offset_ty.expected: -------------------------------------------------------------------------------- 1 | Cannot offset by non-isize type u32 2 | -------------------------------------------------------------------------------- /tests/expected/offset-invalid-args/non_ptr_arg.expected: -------------------------------------------------------------------------------- 1 | Cannot offset non-pointer type 2 | -------------------------------------------------------------------------------- /tests/expected/offset-u8-fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | dereference failure: pointer outside object bounds -------------------------------------------------------------------------------- /tests/expected/one-assert/expected: -------------------------------------------------------------------------------- 1 | ** 0 of 1 failed 2 | -------------------------------------------------------------------------------- /tests/expected/one-assert/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | pub fn check_assert() { 6 | let x: u8 = kani::any(); 7 | let y = x; 8 | assert!(x == y); 9 | } 10 | -------------------------------------------------------------------------------- /tests/expected/panic/arg-error/expected: -------------------------------------------------------------------------------- 1 | error: 1 positional argument in format string, but no arguments were given 2 | error: aborting due to 1 previous error 3 | -------------------------------------------------------------------------------- /tests/expected/panic/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/expected/panic/expected -------------------------------------------------------------------------------- /tests/expected/per-harness/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_drop_foo... 2 | 3 | Status: SATISFIED\ 4 | Description: "DropFoo" 5 | 6 | 1 of 1 cover properties satisfied 7 | -------------------------------------------------------------------------------- /tests/expected/pointer-overflow/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Offset in bytes overflows isize 2 | -------------------------------------------------------------------------------- /tests/expected/ptr-offset-overflow-bytes/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Offset in bytes overflows isize 2 | Verification failed for - main 3 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. 4 | -------------------------------------------------------------------------------- /tests/expected/ptr_to_ref_cast/alignment/expected: -------------------------------------------------------------------------------- 1 | check_misaligned_ptr_cast_fail.safety_check\ 2 | Status: FAILURE\ 3 | Description: "misaligned pointer dereference: address must be a multiple of its type's alignment"\ 4 | in function check_misaligned_ptr_cast_fail 5 | -------------------------------------------------------------------------------- /tests/expected/ptr_to_ref_cast/str/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | Description: "dereference failure: pointer invalid"\ 3 | 4 | VERIFICATION:- FAILED 5 | Verification failed for - check_with_metadata_fail 6 | -------------------------------------------------------------------------------- /tests/expected/quantifiers/assert_with_exists_fail.expected: -------------------------------------------------------------------------------- 1 | - Status: FAILURE\ 2 | - Description: "assertion with exists"\ 3 | 4 | VERIFICATION:- FAILED 5 | -------------------------------------------------------------------------------- /tests/expected/quantifiers/assert_with_exists_pass.expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "assertion with exists"\ 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/expected/quantifiers/assert_with_forall_fail.expected: -------------------------------------------------------------------------------- 1 | - Status: FAILURE\ 2 | - Description: "assertion with forall"\ 3 | 4 | VERIFICATION:- FAILED 5 | 6 | -------------------------------------------------------------------------------- /tests/expected/quantifiers/assert_with_forall_pass.expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "assertion with forall"\ 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/expected/quantifiers/assume_with_exists_fail.expected: -------------------------------------------------------------------------------- 1 | - Status: FAILURE\ 2 | - Description: "assume with exists"\ 3 | 4 | VERIFICATION:- FAILED 5 | -------------------------------------------------------------------------------- /tests/expected/quantifiers/quantifier_with_no_external_variable.expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | - Description: "assertion failed: quan" 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | 6 | -------------------------------------------------------------------------------- /tests/expected/reach/assert/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "assertion failed: x != 5" 3 | Failed Checks: assertion failed: x != 5 4 | -------------------------------------------------------------------------------- /tests/expected/reach/assert/reachable_fail/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | let x = 5; 7 | if kani::any() { 8 | assert!(x != 5); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /tests/expected/reach/assert/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "assertion failed: x > 4" 3 | VERIFICATION:- SUCCESSFUL 4 | -------------------------------------------------------------------------------- /tests/expected/reach/assert/reachable_pass/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | let x = 5; 7 | if x > 3 { 8 | assert!(x > 4); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /tests/expected/reach/assert/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: x == 2" 3 | ** 1 of 3 failed (1 unreachable) 4 | -------------------------------------------------------------------------------- /tests/expected/reach/assert_eq/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: y == 55" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/assert_ne/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: y != 1" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/bounds/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "index out of bounds: the length is less than or equal to the given index" 3 | Failed Checks: index out of bounds: the length is less than or equal to the given index 4 | -------------------------------------------------------------------------------- /tests/expected/reach/bounds/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "index out of bounds: the length is less than or equal to the given index" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/bounds/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "index out of bounds: the length is less than or equal to the given index" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert-eq/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "assertion failed: x == 10" 3 | Failed Checks: assertion failed: x == 10 4 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert-eq/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "assertion failed: x == 10" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert-eq/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: x == 10" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert-ne/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "assertion failed: x != 17" 3 | Failed Checks: assertion failed: x != 17 4 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert-ne/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "assertion failed: x != 17" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert-ne/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: x != 17" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "assertion failed: x != -10" 3 | Failed Checks: assertion failed: x != -10 4 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "assertion failed: x != -10" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/debug-assert/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "assertion failed: x != -10" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/div-zero/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "attempt to divide by zero" 3 | Failed Checks: attempt to divide by zero 4 | -------------------------------------------------------------------------------- /tests/expected/reach/div-zero/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "attempt to divide by zero" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/div-zero/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "attempt to divide by zero" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/overflow-neg/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "attempt to negate with overflow" 3 | Failed Checks: attempt to negate with overflow 4 | -------------------------------------------------------------------------------- /tests/expected/reach/overflow-neg/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "attempt to negate with overflow" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/overflow-neg/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "attempt to negate with overflow" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/overflow/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "attempt to subtract with overflow" 3 | Failed Checks: attempt to subtract with overflow 4 | -------------------------------------------------------------------------------- /tests/expected/reach/overflow/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "attempt to subtract with overflow" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/overflow/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "attempt to subtract with overflow" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/rem-zero/reachable_fail/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | Description: "attempt to calculate the remainder with a divisor of zero" 3 | Failed Checks: attempt to calculate the remainder with a divisor of zero 4 | -------------------------------------------------------------------------------- /tests/expected/reach/rem-zero/reachable_pass/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "attempt to calculate the remainder with a divisor of zero" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/rem-zero/unreachable/expected: -------------------------------------------------------------------------------- 1 | UNREACHABLE\ 2 | Description: "attempt to calculate the remainder with a divisor of zero" 3 | -------------------------------------------------------------------------------- /tests/expected/reach/turned-off/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: x != 11 3 | -------------------------------------------------------------------------------- /tests/expected/realloc/null/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | Description: "rust_realloc must be called with a non-null pointer" 3 | 4 | VERIFICATION:- FAILED 5 | -------------------------------------------------------------------------------- /tests/expected/realloc/shrink/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | Description: "dereference failure: pointer outside object bounds" 3 | 4 | VERIFICATION:- FAILED 5 | -------------------------------------------------------------------------------- /tests/expected/realloc/zero_size/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | Description: "rust_realloc must be called with a size greater than 0" 3 | 4 | VERIFICATION:- FAILED 5 | -------------------------------------------------------------------------------- /tests/expected/references/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: z == 2 3 | -------------------------------------------------------------------------------- /tests/expected/report/insufficient_unwind/expected: -------------------------------------------------------------------------------- 1 | UNDETERMINED\ 2 | Description: "assertion failed: sum == 6" 3 | [Kani] info: Verification output shows one or more unwinding failures. 4 | [Kani] tip: Consider increasing the unwinding value or disabling `--unwinding-assertions`. 5 | -------------------------------------------------------------------------------- /tests/expected/report/uncolor/expected: -------------------------------------------------------------------------------- 1 | - Status: SUCCESS\ 2 | Description: "assertion failed: 1 + 1 == 2" 3 | - Status: FAILURE\ 4 | - Description: "assertion failed: 2 + 2 == 3" 5 | VERIFICATION:- FAILED 6 | -------------------------------------------------------------------------------- /tests/expected/report/unsupported/unreachable/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | Description: "assertion failed: x == 0" 3 | VERIFICATION:- SUCCESSFUL 4 | -------------------------------------------------------------------------------- /tests/expected/report/verification-time/expected: -------------------------------------------------------------------------------- 1 | Verification Time: 2 | -------------------------------------------------------------------------------- /tests/expected/shadow/slices/slice_of_array/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/shadow/slices/slice_reverse/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/shadow/slices/slice_split/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/shadow/uninit_array/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: assertion failed: SM.get(p) 2 | Verification failed for - check_init_any 3 | Complete - 1 successfully verified harnesses, 1 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/expected/shadow/unsupported_object_size/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: The object size exceeds the maximum size supported by Kani's shadow memory model (64) 2 | Verification failed for - check_max_object_size_fail 3 | Complete - 1 successfully verified harnesses, 1 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/expected/slice-pattern-array/expected: -------------------------------------------------------------------------------- 1 | Status: FAILURE\ 2 | Description: "Sub-array binding is not currently supported by Kani. Please post your example at https://github.com/model-checking/kani/issues/707" 3 | -------------------------------------------------------------------------------- /tests/expected/slice/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: y.len() == 5 3 | SUCCESS\ 4 | index out of bounds: the length is less than or equal to the given index 5 | SUCCESS\ 6 | assertion failed: y[1] == 2 7 | SUCCESS\ 8 | assertion failed: z.len() == 3 9 | -------------------------------------------------------------------------------- /tests/expected/slice_c_str/expected: -------------------------------------------------------------------------------- 1 | warning: Found the following unsupported constructs: 2 | - C string literal 3 | 4 | Checking harness check_c_str... 5 | Failed Checks: C string literal is not currently supported by Kani. 6 | 7 | VERIFICATION:- FAILED 8 | -------------------------------------------------------------------------------- /tests/expected/static-mutable/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | assertion failed: 10 == foo() 3 | SUCCESS\ 4 | assertion failed: 12 == foo() 5 | SUCCESS\ 6 | assertion failed: 10 == foo() 7 | FAILURE\ 8 | assertion failed: 12 == foo() 9 | -------------------------------------------------------------------------------- /tests/expected/static/expected: -------------------------------------------------------------------------------- 1 | FAILURE\ 2 | assertion failed: 10 == foo() 3 | UNREACHABLE\ 4 | assertion failed: 12 == foo() 5 | -------------------------------------------------------------------------------- /tests/expected/stubbing-ambiguous-path/expected: -------------------------------------------------------------------------------- 1 | error: failed to resolve `foo`: `foo` is ambiguous because of multiple glob imports in module `main`. Found:\ 2 | mod2::foo\ 3 | mod1::foo\ 4 | -------------------------------------------------------------------------------- /tests/expected/test1/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | attempt to add with overflow 3 | SUCCESS\ 4 | attempt to subtract with overflow 5 | FAILURE\ 6 | assertion failed: a == 54 7 | UNREACHABLE\ 8 | assertion failed: a == 55 9 | UNREACHABLE\ 10 | assertion failed: a >= 55 11 | -------------------------------------------------------------------------------- /tests/expected/test5/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: div(4, 2) == 2 3 | FAILURE\ 4 | assertion failed: div(6, 2) == 2 5 | SUCCESS\ 6 | attempt to divide by zero 7 | SUCCESS\ 8 | attempt to divide with overflow 9 | -------------------------------------------------------------------------------- /tests/expected/test6/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: add2(1, 1) == 2.0 3 | FAILURE\ 4 | assertion failed: add2(2, 1) == 2.0 5 | -------------------------------------------------------------------------------- /tests/expected/transmute/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: bitpattern == 0x3F800000 3 | SUCCESS\ 4 | assertion failed: f == 1.0 5 | -------------------------------------------------------------------------------- /tests/expected/uninit/access-padding-uninit/access-padding-uninit.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Reading from an uninitialized pointer of type `*const u8` 2 | 3 | VERIFICATION:- FAILED 4 | 5 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/uninit/access-padding-via-cast/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Reading from an uninitialized pointer of type `*mut [u8; 4]` 2 | 3 | VERIFICATION:- FAILED 4 | 5 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/uninit/alloc-to-slice/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Reading from an uninitialized pointer of type `*const [u8]` 2 | 3 | VERIFICATION:- FAILED 4 | 5 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/uninit/copy/copy_without_padding.expected: -------------------------------------------------------------------------------- 1 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 2 | -------------------------------------------------------------------------------- /tests/expected/uninit/copy/non_byte_copy_without_padding.expected: -------------------------------------------------------------------------------- 1 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 2 | -------------------------------------------------------------------------------- /tests/expected/uninit/delayed-ub-overapprox.expected: -------------------------------------------------------------------------------- 1 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 2 | -------------------------------------------------------------------------------- /tests/expected/uninit/delayed-ub/slices_fixme.expected: -------------------------------------------------------------------------------- 1 | delayed_ub_slices.assertion.\ 2 | - Status: FAILURE\ 3 | - Description: "Undefined Behavior: Reading from an uninitialized pointer of type `[u128; 4]`" 4 | 5 | Verification failed for - delayed_ub_slices 6 | -------------------------------------------------------------------------------- /tests/expected/uninit/transmute-padding/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Transmuting between types of incompatible layouts. 2 | 3 | VERIFICATION:- FAILED 4 | 5 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/uninit/vec-read-bad-len/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Reading from an uninitialized pointer of type `*const [u8]` 2 | 3 | VERIFICATION:- FAILED 4 | 5 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/uninit/vec-read-semi-init/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Reading from an uninitialized pointer of type `*const u8` 2 | 3 | VERIFICATION:- FAILED 4 | 5 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/uninit/vec-read-uninit/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Reading from an uninitialized pointer of type `*const u8` 2 | 3 | VERIFICATION:- FAILED 4 | 5 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/expected/unwind-flags-conflict/expected: -------------------------------------------------------------------------------- 1 | error: Conflicting flags: unwind flags provided to kani and in --cbmc-args. 2 | -------------------------------------------------------------------------------- /tests/expected/unwind-flags-conflict/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | // kani-flags: --default-unwind 2 -Z unstable-options --cbmc-args --unwindset 2 5 | 6 | #[kani::proof] 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /tests/expected/unwind_tip/expected: -------------------------------------------------------------------------------- 1 | UNDETERMINED 2 | [Kani] info: Verification output shows one or more unwinding failures. 3 | [Kani] tip: Consider increasing the unwinding value or disabling `--unwinding-assertions`. 4 | -------------------------------------------------------------------------------- /tests/expected/valid-value-checks/can_dereference.expected: -------------------------------------------------------------------------------- 1 | 2 of 2 cover properties satisfied 2 | 3 | Complete - 3 successfully verified harnesses, 0 failures, 3 total. 4 | -------------------------------------------------------------------------------- /tests/expected/valid-value-checks/maybe_uninit.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Invalid value of type `std::num::NonZero` 2 | 3 | Verification failed for - check_invalid_zeroed 4 | Complete - 1 successfully verified harnesses, 1 failures, 2 total. 5 | -------------------------------------------------------------------------------- /tests/expected/valid-value-checks/write_bytes.expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Undefined Behavior: Invalid value of type `char` 2 | 3 | Verification failed for - check_invalid_write 4 | Complete - 1 successfully verified harnesses, 1 failures, 2 total. 5 | -------------------------------------------------------------------------------- /tests/expected/verbose-cmds/expected: -------------------------------------------------------------------------------- 1 | Running: `goto-cc 2 | Running: `goto-instrument 3 | Running: `cbmc 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/expected/wrapping-offset-bytes-overflow/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/expected/zst/expected: -------------------------------------------------------------------------------- 1 | - Status: FAILURE\ 2 | - Description: "null pointer dereference occurred" 3 | 4 | VERIFICATION:- FAILED 5 | -------------------------------------------------------------------------------- /tests/kani-docs: -------------------------------------------------------------------------------- 1 | ../docs/ -------------------------------------------------------------------------------- /tests/kani-fixme: -------------------------------------------------------------------------------- 1 | kani -------------------------------------------------------------------------------- /tests/kani/Asm/main_fixme.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | #![feature(asm)] 4 | 5 | #[kani::proof] 6 | fn main() { 7 | unsafe { 8 | asm!("nop"); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /tests/kani/Cast/path.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | use std::path::Path; 4 | 5 | #[kani::proof] 6 | fn main() { 7 | let path = Path::new("./foo/bar.txt"); 8 | } 9 | -------------------------------------------------------------------------------- /tests/kani/FileNameWithSpace/my src/hi.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | let cond: bool = kani::any(); 7 | kani::assume(cond); 8 | assert!(cond); 9 | } 10 | -------------------------------------------------------------------------------- /tests/kani/FunctionSymbols/fixme_main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | // size_of is not supported yet: 5 | #[kani::proof] 6 | fn assert_fndef_zst() { 7 | assert_eq!(std::mem::size_of_val(&h), 0); 8 | } 9 | -------------------------------------------------------------------------------- /tests/kani/Pointers_Basic/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | #[kani::proof] 4 | fn main() { 5 | let x = 3; 6 | let y = &x; 7 | let mut z = *y; 8 | 9 | assert!(z == 3); 10 | } 11 | -------------------------------------------------------------------------------- /tests/kani/Slice/codegen.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | #[kani::proof] 4 | fn main() { 5 | let name = String::from("Mark"); 6 | let name_str = name.as_str(); 7 | assert!(name_str.len() > 0); 8 | } 9 | -------------------------------------------------------------------------------- /tests/kani/Slice/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | #[kani::unwind(6)] 6 | fn main() { 7 | let name: &str = "hello"; 8 | assert!(name == "hello"); 9 | } 10 | -------------------------------------------------------------------------------- /tests/kani/Slice/slice.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | #[kani::proof] 4 | fn main() { 5 | let list = [1, 2, 3]; 6 | let slice = &list[1..2]; 7 | assert!(slice.len() > 0); 8 | } 9 | -------------------------------------------------------------------------------- /tests/kani/Strings/boxed_str.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | let s = String::from("hello"); 7 | let _b = s.into_boxed_str(); 8 | } 9 | -------------------------------------------------------------------------------- /tests/llbc/basic0/expected: -------------------------------------------------------------------------------- 1 | fn test::is_zero(@1: i32) -> bool\ 2 | {\ 3 | let @0: bool; // return\ 4 | let i@1: i32; // arg #1\ 5 | 6 | @0 := copy (i@1) == const (0 : i32)\ 7 | return\ 8 | } 9 | -------------------------------------------------------------------------------- /tests/llbc/enum/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/llbc/enum/expected -------------------------------------------------------------------------------- /tests/llbc/generic/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/llbc/generic/expected -------------------------------------------------------------------------------- /tests/llbc/option/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/llbc/option/expected -------------------------------------------------------------------------------- /tests/llbc/projection/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/llbc/projection/expected -------------------------------------------------------------------------------- /tests/llbc/struct/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/llbc/struct/expected -------------------------------------------------------------------------------- /tests/llbc/traitimpl/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/llbc/traitimpl/expected -------------------------------------------------------------------------------- /tests/llbc/tuple/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/llbc/tuple/expected -------------------------------------------------------------------------------- /tests/perf/btreeset/insert_any/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/perf/btreeset/insert_multi/expected: -------------------------------------------------------------------------------- 1 | ** 2 of 2 cover properties satisfied 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/perf/btreeset/insert_same/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/perf/format/expected: -------------------------------------------------------------------------------- 1 | Complete - 2 successfully verified harnesses, 0 failures, 2 total 2 | -------------------------------------------------------------------------------- /tests/perf/hashset/expected: -------------------------------------------------------------------------------- 1 | 3 successfully verified harnesses, 0 failures, 3 total 2 | -------------------------------------------------------------------------------- /tests/perf/misc/array_fold/expected: -------------------------------------------------------------------------------- 1 | Complete - 0 successfully verified harnesses, 2 failures, 2 total. 2 | -------------------------------------------------------------------------------- /tests/perf/misc/display_trait/expected: -------------------------------------------------------------------------------- 1 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 2 | -------------------------------------------------------------------------------- /tests/perf/misc/struct_defs/expected: -------------------------------------------------------------------------------- 1 | Complete - 3 successfully verified harnesses, 0 failures, 3 total. 2 | -------------------------------------------------------------------------------- /tests/perf/overlays/s2n-quic/common/s2n-codec/expected: -------------------------------------------------------------------------------- 1 | successfully verified harnesses, 0 failures 2 | -------------------------------------------------------------------------------- /tests/perf/overlays/s2n-quic/quic/s2n-quic-core/expected: -------------------------------------------------------------------------------- 1 | successfully verified harnesses, 0 failures 2 | -------------------------------------------------------------------------------- /tests/perf/overlays/s2n-quic/quic/s2n-quic-platform/expected: -------------------------------------------------------------------------------- 1 | successfully verified harnesses, 0 failures 2 | -------------------------------------------------------------------------------- /tests/perf/smol_str/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_new... 2 | VERIFICATION:- SUCCESSFUL 3 | 4 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 5 | -------------------------------------------------------------------------------- /tests/perf/string/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: Function `alloc::string::String::from_utf8_lossy` with missing definition is unreachable 2 | 3 | -------------------------------------------------------------------------------- /tests/perf/vec/box_dyn/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/perf/vec/string/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/perf/vec/vec/expected: -------------------------------------------------------------------------------- 1 | Status: SUCCESS\ 2 | Description: "assertion failed: v2 == vec![1]" 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/ambiguous_crate/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: ambiguous.sh 4 | expected: expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/build-cache-bin/bin/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "bin" 5 | version = "0.1.0" 6 | edition = "2021" 7 | -------------------------------------------------------------------------------- /tests/script-based-pre/build-cache-bin/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: cache_works.sh 4 | expected: cache_works.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/build-cache-dirty/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: rebuild.sh 4 | expected: rebuild.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/build-cache-fresh/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: cache_works.sh 4 | expected: cache_works.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/build-rs-conditional/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: build_rs.sh 4 | expected: expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo-kani-version-flag-version/cargo-kani-version-flag-version.expected: -------------------------------------------------------------------------------- 1 | success: version printed agrees 2 | success: `(cargo plugin)` appears in version line -------------------------------------------------------------------------------- /tests/script-based-pre/cargo-kani-version-flag-version/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: cargo-kani-version-flag-version.sh 4 | expected: cargo-kani-version-flag-version.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_contracts/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: contracts.sh 4 | expected: contracts.expected 5 | exit_code: 1 -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_contracts/contracts.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_dependencies/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: dependencies.sh 4 | expected: dependencies.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_dependencies/dependencies.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_dependencies/other_crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | [package] 4 | name = "other_crate" 5 | version = "0.1.0" 6 | edition = "2021" 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_dependencies/other_crate/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | fn no_harness(x: u8) -> u8 { 5 | x + 1 6 | } 7 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_exclude/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: exclude.sh 4 | expected: exclude.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_exclude/exclude.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness --exclude-pattern exclude 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_filter/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: filter.sh 4 | expected: filter.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_filter/filter.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_harnesses_fail/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: harnesses_fail.sh 4 | expected: harnesses_fail.expected 5 | exit_code: 1 -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_harnesses_fail/harnesses_fail.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_include/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: include.sh 4 | expected: include.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_include/include.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness --include-pattern cargo_autoharness_include::include 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_list/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: list.sh 4 | expected: list.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_list/list.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness --list 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_termination_timeout/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: termination_timeout.sh 4 | expected: termination_timeout.expected 5 | exit_code: 1 -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_termination_timeout/termination_timeout.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_termination_unwind/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: termination_unwind.sh 4 | expected: termination_unwind.expected 5 | exit_code: 1 -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_type_invariant/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: type-invariant.sh 4 | expected: type-invariant.expected 5 | exit_code: 1 -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_autoharness_type_invariant/type-invariant.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | cargo kani autoharness -Z autoharness 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_list_json/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: list.sh 4 | expected: list.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_list_md/.gitignore: -------------------------------------------------------------------------------- 1 | kani-list.md 2 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_list_md/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: list.sh 4 | expected: list.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_manifest_test/add/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "add" 6 | version = "0.1.0" 7 | edition = "2021" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_manifest_test/add/src/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | 1 + 1; 7 | } 8 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_manifest_test/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: manifest_test.sh 4 | expected: manifest_test.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_manifest_test/manifest_test.expected: -------------------------------------------------------------------------------- 1 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 2 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_playback_build/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_with_build.sh 4 | expected: playback_with_build.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_playback_opts/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_opts.sh 4 | expected: playback_opts.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_playback_opts/playback_opts.expected: -------------------------------------------------------------------------------- 1 | [TEST] Only codegen test... 2 | Executable unittests src/lib.rs 3 | [TEST] Only codegen test... 4 | Finished `test` 5 | [TEST] Executable 6 | debug/deps/sample_crate- 7 | -------------------------------------------------------------------------------- /tests/script-based-pre/cargo_playback_target/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_target.sh 4 | expected: playback_target.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/check-output/.gitignore: -------------------------------------------------------------------------------- 1 | target/ 2 | Cargo.lock 3 | *.c 4 | build/ 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/check-output/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: check-output.sh 4 | -------------------------------------------------------------------------------- /tests/script-based-pre/check-output/multifile/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "multifile" 6 | version = "0.1.0" 7 | edition = "2021" 8 | 9 | [workspace] 10 | 11 | [dependencies] 12 | -------------------------------------------------------------------------------- /tests/script-based-pre/check-quiet/check-quiet.expected: -------------------------------------------------------------------------------- 1 | success: `--quiet` produced NO output -------------------------------------------------------------------------------- /tests/script-based-pre/check-quiet/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: check-quiet.sh 4 | expected: check-quiet.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/concrete_playback_e2e/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_e2e.sh 4 | expected: playback_e2e.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/crate-name/a/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn add_a(left: usize, right: usize) -> usize { 5 | left + right 6 | } 7 | -------------------------------------------------------------------------------- /tests/script-based-pre/crate-name/b/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | extern crate a; 4 | 5 | pub fn add_b(left: usize, right: usize) -> usize { 6 | a::add_a(left, right) 7 | } 8 | -------------------------------------------------------------------------------- /tests/script-based-pre/crate-name/c/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | extern crate a; 4 | extern crate b; 5 | 6 | pub fn add_c(left: usize, right: usize) -> usize { 7 | b::add_b(left, right) 8 | } 9 | -------------------------------------------------------------------------------- /tests/script-based-pre/crate-name/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: crate-name.sh 4 | expected: crate-name.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/crate-name/crate-name.expected: -------------------------------------------------------------------------------- 1 | No proof harnesses (functions with #[kani::proof]) were found to verify. 2 | -------------------------------------------------------------------------------- /tests/script-based-pre/crate-name/my-code.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub fn add_a(left: usize, right: usize) -> usize { 5 | left + right 6 | } 7 | -------------------------------------------------------------------------------- /tests/script-based-pre/error-code/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: exit-one.sh 4 | expected: exit-one.expected 5 | exit_code: 1 -------------------------------------------------------------------------------- /tests/script-based-pre/error-code/exit-one.expected: -------------------------------------------------------------------------------- 1 | Exiting with code 1! -------------------------------------------------------------------------------- /tests/script-based-pre/error-code/exit-one.sh: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | echo "Exiting with code 1!" 5 | exit 1 -------------------------------------------------------------------------------- /tests/script-based-pre/individual_file_output/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: individual_file_output.sh 4 | -------------------------------------------------------------------------------- /tests/script-based-pre/kani-version-flag-version/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: kani-version-flag-version.sh 4 | expected: kani-version-flag-version.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/kani-version-flag-version/kani-version-flag-version.expected: -------------------------------------------------------------------------------- 1 | success: version printed agrees 2 | success: `(standalone)` appears in version line -------------------------------------------------------------------------------- /tests/script-based-pre/kani_autoharness_exclude_precedence/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: precedence.sh 4 | -------------------------------------------------------------------------------- /tests/script-based-pre/kani_lib_dep/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: build.sh 4 | expected: expected 5 | exit_code: 0 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/kani_lib_dep/expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/model-checking/kani/931661b0cdbf9354eba3902608efadad00b1cbb3/tests/script-based-pre/kani_lib_dep/expected -------------------------------------------------------------------------------- /tests/script-based-pre/kani_list_json/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: list.sh 4 | expected: list.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/kani_list_md/.gitignore: -------------------------------------------------------------------------------- 1 | kani-list.md 2 | -------------------------------------------------------------------------------- /tests/script-based-pre/kani_list_md/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: list.sh 4 | expected: list.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/mem-init-reinstrumentation/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: mem-init-reinstrumentation.sh 4 | expected: mem-init-reinstrumentation.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/mem-init-reinstrumentation/mem-init-reinstrumentation.expected: -------------------------------------------------------------------------------- 1 | success: no pointer checks are detected in initialized memory instrumentaiton 2 | -------------------------------------------------------------------------------- /tests/script-based-pre/no_codegen/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "no_codegen" 6 | version = "0.1.0" 7 | edition = "2024" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/script-based-pre/no_codegen/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: run.sh 4 | expected: expected 5 | exit_code: 0 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/no_codegen/expected: -------------------------------------------------------------------------------- 1 | info: Compilation succeeded up until codegen. Skipping codegen because of `--no-codegen` option. Rerun without `--no-codegen` to perform codegen. 2 | -------------------------------------------------------------------------------- /tests/script-based-pre/no_codegen_error/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "no_codegen_error" 6 | version = "0.1.0" 7 | edition = "2024" 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /tests/script-based-pre/no_codegen_error/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: run.sh 4 | expected: expected 5 | exit_code: 1 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/no_codegen_error/expected: -------------------------------------------------------------------------------- 1 | could not compile `no_codegen_error` 2 | -------------------------------------------------------------------------------- /tests/script-based-pre/no_codegen_error/run.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Copyright Kani Contributors 3 | # SPDX-License-Identifier: Apache-2.0 OR MIT 4 | 5 | rm -rf target 6 | 7 | # Test the behavior of the `--no-codegen` option 8 | cargo kani --no-codegen -Zunstable-options 9 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_already_existing/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_opts.sh 4 | expected: playback_opts.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_array/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_array.sh 4 | expected: playback_array.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_expected/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback.sh 4 | expected: expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_multi_harness_multi_inject/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_opts.sh 4 | expected: playback_opts.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_no_rustfmt/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_no_rustfmt.sh 4 | expected: playback_no_rustfmt.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_no_rustfmt/playback_no_rustfmt.expected: -------------------------------------------------------------------------------- 1 | [TEST] Generate test... 2 | Checking harness verify::try_nz_u8 3 | 4 | WARNING: Failed to rustfmt modified source code 5 | 6 | [TEST] Run test... 7 | test result: ok. 2 passed; 0 failed; 8 | 9 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_opts/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_opts.sh 4 | expected: playback_opts.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_print/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_print.sh 4 | expected: expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_with_cfg_kani/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_with_cfg_kani.sh 4 | expected: playback_with_cfg_kani.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_with_cfg_kani/playback_with_cfg_kani.expected: -------------------------------------------------------------------------------- 1 | failures: 2 | harnesses::kani_concrete_playback_harness_15598097466099501582 3 | 4 | test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_zero_size/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: playback_zst.sh 4 | expected: playback_zst.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/playback_zero_size/playback_zst.expected: -------------------------------------------------------------------------------- 1 | [TEST] Generate test... 2 | Checking harness any_is_ok 3 | 4 | [TEST] Run test... 5 | test result: ok. 1 passed; 0 failed; 6 | -------------------------------------------------------------------------------- /tests/script-based-pre/std_codegen/codegen_std.expected: -------------------------------------------------------------------------------- 1 | [TEST] Copy standard library from the current toolchain 2 | [TEST] Modify library 3 | ------ Build succeeded ------- 4 | -------------------------------------------------------------------------------- /tests/script-based-pre/std_codegen/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: codegen_std.sh 4 | expected: codegen_std.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/std_codegen/dummy/Cargo.toml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | [package] 5 | name = "dummy" 6 | version = "0.1.0" 7 | edition = "2021" 8 | 9 | [workspace] 10 | -------------------------------------------------------------------------------- /tests/script-based-pre/std_codegen/dummy/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | //! Just a dummy file. We are interested in the standard library only 4 | 5 | pub fn void() { 6 | todo!() 7 | } 8 | -------------------------------------------------------------------------------- /tests/script-based-pre/tool-scanner/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: scanner-test.sh 4 | expected: scanner-test.expected 5 | -------------------------------------------------------------------------------- /tests/script-based-pre/verify_std_cmd/config.yml: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | script: verify_std.sh 4 | expected: verify_std.expected 5 | -------------------------------------------------------------------------------- /tests/slow/tokio-proofs/expected: -------------------------------------------------------------------------------- 1 | Complete - 13 successfully verified harnesses, 0 failures, 13 total. 2 | -------------------------------------------------------------------------------- /tests/slow/tokio-proofs/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | mod tokio; 5 | mod tokio_stream; 6 | mod tokio_test; 7 | mod tokio_util; 8 | -------------------------------------------------------------------------------- /tests/slow/tokio-proofs/src/tokio/support/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub mod leaked_buffers; 5 | -------------------------------------------------------------------------------- /tests/slow/tokio-proofs/src/tokio_stream/support/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | pub mod mpsc; 5 | -------------------------------------------------------------------------------- /tests/slow/tokio-proofs/src/tokio_test/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | mod block_on; 5 | mod io; 6 | -------------------------------------------------------------------------------- /tests/slow/tokio-proofs/src/tokio_util/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | mod io_reader_stream; 5 | mod io_stream_reader; 6 | -------------------------------------------------------------------------------- /tests/smack/basic/add.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | // @expect error 4 | // kani-verify-fail 5 | 6 | #[kani::proof] 7 | pub fn main() { 8 | let a = 2; 9 | let b = 3; 10 | assert!(a + b == 6); 11 | } 12 | -------------------------------------------------------------------------------- /tests/smack/basic/div.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | // @expect error 4 | // kani-verify-fail 5 | 6 | #[kani::proof] 7 | pub fn main() { 8 | let a = 2; 9 | let b = 3; 10 | assert!(b / a != 1); 11 | } 12 | -------------------------------------------------------------------------------- /tests/smack/basic/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | // @expect error 4 | // kani-verify-fail 5 | 6 | #[kani::proof] 7 | pub fn main() { 8 | let a = 2; 9 | let b = 3; 10 | assert!(b % a != 1); 11 | } 12 | -------------------------------------------------------------------------------- /tests/smack/basic/mul.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | // @expect error 4 | // kani-verify-fail 5 | 6 | #[kani::proof] 7 | pub fn main() { 8 | let a = 2; 9 | let b = 3; 10 | assert!(b * a != 6); 11 | } 12 | -------------------------------------------------------------------------------- /tests/smack/basic/sub.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | // @expect error 4 | // kani-verify-fail 5 | 6 | #[kani::proof] 7 | pub fn main() { 8 | let a = 2; 9 | let b = 3; 10 | assert!(b - a != 1); 11 | } 12 | -------------------------------------------------------------------------------- /tests/std-checks/core/mem.expected: -------------------------------------------------------------------------------- 1 | Checking harness mem::verify::check_swap_unit... 2 | 3 | Complete - 7 successfully verified harnesses, 0 failures, 7 total. 4 | -------------------------------------------------------------------------------- /tests/std-checks/core/ptr.expected: -------------------------------------------------------------------------------- 1 | Summary: 2 | Verification failed for - ptr::verify::check_as_ref_dangling 3 | Complete - 5 successfully verified harnesses, 1 failures, 6 total. 4 | -------------------------------------------------------------------------------- /tests/std-checks/core/slice.expected: -------------------------------------------------------------------------------- 1 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 2 | -------------------------------------------------------------------------------- /tests/std-checks/std/atomic.expected: -------------------------------------------------------------------------------- 1 | Complete - 5 successfully verified harnesses, 0 failures, 5 total. 2 | -------------------------------------------------------------------------------- /tests/std-checks/std/boxed.expected: -------------------------------------------------------------------------------- 1 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 2 | -------------------------------------------------------------------------------- /tests/std-checks/std/src/lib.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | //! Top file that includes all sub-modules mimicking std structure. 5 | 6 | extern crate kani; 7 | 8 | mod boxed; 9 | mod sync; 10 | -------------------------------------------------------------------------------- /tests/std-checks/std/src/sync/mod.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | mod atomic; 5 | -------------------------------------------------------------------------------- /tests/ui/Property-Class-UI/cover/expected: -------------------------------------------------------------------------------- 1 | main.cover.\ 2 | Status: SATISFIED\ 3 | Description: "i may be negative"\ 4 | main.rs:7:5 in function main 5 | 6 | ** 1 of 1 cover properties satisfied 7 | 8 | VERIFICATION:- SUCCESSFUL 9 | -------------------------------------------------------------------------------- /tests/ui/Property-Class-UI/cover/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | fn main() { 6 | let i: i32 = kani::any(); 7 | kani::cover!(i < 0, "i may be negative"); 8 | } 9 | -------------------------------------------------------------------------------- /tests/ui/arguments-proof/expected: -------------------------------------------------------------------------------- 1 | `some` is not a valid option for `#[kani::proof]`. 2 | 3 | the trait bound `NotASchedule: kani::futures::SchedulingStrategy` is not satisfied 4 | -------------------------------------------------------------------------------- /tests/ui/arguments-proof/missing-unstable-flag/expected: -------------------------------------------------------------------------------- 1 | error: Use of unstable feature `async-lib`: experimental async support 2 | -------------------------------------------------------------------------------- /tests/ui/cbmc_checks/float-overflow/check_message_overflow.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/ui/cbmc_checks/pointer/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: misaligned pointer dereference: address must be a multiple of its type's alignment 2 | Failed Checks: assertion failed: unsafe { *p1 != 0 } 3 | -------------------------------------------------------------------------------- /tests/ui/check_summary_for_single_harness/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_foo... 2 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 3 | -------------------------------------------------------------------------------- /tests/ui/code-location/expected: -------------------------------------------------------------------------------- 1 | module/mod.rs:10:5 in function module::not_empty 2 | main.rs:13:5 in function same_file 3 | /toolchains/ 4 | alloc/src/vec/mod.rs: 5 | in function as std::ops::Drop>::drop 6 | 7 | VERIFICATION:- SUCCESSFUL 8 | -------------------------------------------------------------------------------- /tests/ui/code-location/module/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | 3 | -------------------------------------------------------------------------------- /tests/ui/compiler-stats/expected: -------------------------------------------------------------------------------- 1 | Reachability Analysis Result 2 | Total # items: 3 | Total # statements: 4 | Total # expressions: 5 | 6 | Reachable Items: 7 | - function: 8 | Statements: 9 | - Call: 10 | Expressions: 11 | -------------------------------------------------------------------------------- /tests/ui/concrete-playback/README.md: -------------------------------------------------------------------------------- 1 | These tests check that the correct concrete values are read and formatted into a concrete playback unit test case. 2 | -------------------------------------------------------------------------------- /tests/ui/concrete-playback/unsupported/expected: -------------------------------------------------------------------------------- 1 | Failed Checks: unwinding assertion loop 0 2 | WARNING: Kani could not produce a concrete playback for `check_unwind_fail` because there were no failing panic checks or satisfiable cover statements. 3 | -------------------------------------------------------------------------------- /tests/ui/cover-property-class/expected: -------------------------------------------------------------------------------- 1 | Check 1: main.cover.\ 2 | Status: SATISFIED\ 3 | Description: "i may be greater than 20"\ 4 | main.rs:9:5 in function main 5 | -------------------------------------------------------------------------------- /tests/ui/derive-arbitrary/empty_enum/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_no_variants... 2 | Failed Checks: Cannot create symbolic enum `Empty`. Enums with zero-variants cannot be instantiated 3 | -------------------------------------------------------------------------------- /tests/ui/derive-arbitrary/empty_struct/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_arbitrary_point... 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/ui/derive-arbitrary/generic_struct/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_arbitrary_point... 2 | 6 of 6 cover properties satisfied 3 | -------------------------------------------------------------------------------- /tests/ui/derive-arbitrary/named_struct/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_arbitrary_point... 2 | 4 of 4 cover properties satisfied 3 | -------------------------------------------------------------------------------- /tests/ui/derive-arbitrary/unnamed_struct/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_arbitrary_point... 2 | 6 of 6 cover properties satisfied 3 | -------------------------------------------------------------------------------- /tests/ui/entry-fn/main/expected: -------------------------------------------------------------------------------- 1 | main.assertion\ 2 | SUCCESS\ 3 | Some(10).and_then(|v| Some(v * 2)) == Some(20)\ 4 | in function main 5 | 6 | VERIFICATION:- SUCCESSFUL 7 | -------------------------------------------------------------------------------- /tests/ui/entry-fn/non-main/expected: -------------------------------------------------------------------------------- 1 | SUCCESS\ 2 | assertion failed: pos != 0 3 | 4 | VERIFICATION:- SUCCESSFUL 5 | -------------------------------------------------------------------------------- /tests/ui/exact-harness/check-qualified-name/expected: -------------------------------------------------------------------------------- 1 | Checking harness first::check_foo... 2 | VERIFICATION:- SUCCESSFUL 3 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 4 | -------------------------------------------------------------------------------- /tests/ui/exact-harness/check_some/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_second_harness... 2 | Checking harness check_first_harness... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/ui/exact-harness/check_substring_not_matching/expected: -------------------------------------------------------------------------------- 1 | Checking harness first::harness... 2 | VERIFICATION:- SUCCESSFUL 3 | Complete - 1 successfully verified harnesses, 0 failures, 1 total. 4 | 5 | -------------------------------------------------------------------------------- /tests/ui/exact-harness/fail_on_missing/expected: -------------------------------------------------------------------------------- 1 | error: Failed to match the following harness(es): 2 | check_blah`, `check_foo 3 | Please specify the fully-qualified name of a harness. 4 | -------------------------------------------------------------------------------- /tests/ui/exact-harness/incomplete-harness-name/expected: -------------------------------------------------------------------------------- 1 | error: Failed to match the following harness(es): 2 | ignore_third_harness 3 | Please specify the fully-qualified name of a harness. 4 | -------------------------------------------------------------------------------- /tests/ui/exact-harness/multiple_matches/expected: -------------------------------------------------------------------------------- 1 | Checking harness second::verify_foo... 2 | Checking harness first::check_blah... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/ui/function-contracts/mutating_ensures_error.expected: -------------------------------------------------------------------------------- 1 | cannot assign to `*_x`, as `Fn` closures cannot mutate their captured variables 2 | -------------------------------------------------------------------------------- /tests/ui/function-stubbing-error/unsupported_resolutions.expected: -------------------------------------------------------------------------------- 1 | error: Kani currently does not support stubbing trait implementations. 2 | error: failed to resolve `::bar`: unable to find `bar` inside trait `Foo` 3 | 4 | error: aborting due to 4 previous errors 5 | -------------------------------------------------------------------------------- /tests/ui/harness-timeout/hours.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/ui/harness-timeout/invalid.expected: -------------------------------------------------------------------------------- 1 | error: invalid value '5k' for '--harness-timeout ': Invalid time unit. Use 's' for seconds, 'm' for minutes, or 'h' for hours 2 | -------------------------------------------------------------------------------- /tests/ui/harness-timeout/minutes.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/ui/harness-timeout/no_timeout.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/ui/harness-timeout/timeout.expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- FAILED 2 | CBMC timed out. You may want to rerun your proof with a larger timeout or use stubbing to reduce the size of the code the verifier reasons about. 3 | 4 | Verification failed for - check_harness_timeout 5 | -------------------------------------------------------------------------------- /tests/ui/invalid-cbmc-function-arg/expected: -------------------------------------------------------------------------------- 1 | error: Invalid flag: --function is not supported in Kani. 2 | -------------------------------------------------------------------------------- /tests/ui/logging/debug/expected: -------------------------------------------------------------------------------- 1 | DEBUG 2 | -------------------------------------------------------------------------------- /tests/ui/logging/warning/expected: -------------------------------------------------------------------------------- 1 | warning: Found the following unsupported constructs: 2 | - TerminatorKind::InlineAsm (1) 3 | Verification will fail if one or more of these constructs is reachable. 4 | 5 | -------------------------------------------------------------------------------- /tests/ui/loop-contracts-synthesis/main_signed/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/ui/loop-contracts-synthesis/main_unsigned/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/ui/mir-linker/generic-harness/expected: -------------------------------------------------------------------------------- 1 | error: the '#[kani::proof]' attribute cannot be applied to generic functions 2 | -------------------------------------------------------------------------------- /tests/ui/missing-function/extern_c/expected: -------------------------------------------------------------------------------- 1 | Status: UNDETERMINED\ 2 | Description: "assertion failed: x == 5" 3 | Status: FAILURE\ 4 | Description: "Function `missing_function` with missing definition is unreachable" 5 | VERIFICATION:- FAILED 6 | -------------------------------------------------------------------------------- /tests/ui/multiple-harnesses/check_all/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_first_harness... 2 | Checking harness check_second_harness... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/ui/multiple-harnesses/check_some/expected: -------------------------------------------------------------------------------- 1 | Checking harness check_first_harness... 2 | Checking harness check_second_harness... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/ui/multiple-harnesses/no_matching_harness/expected: -------------------------------------------------------------------------------- 1 | error: no harnesses matched the harness filters: `non_existing`, `invalid` 2 | -------------------------------------------------------------------------------- /tests/ui/multiple-harnesses/some_matching_harnesses/expected: -------------------------------------------------------------------------------- 1 | Checking harness existing_harness... 2 | Checking harness existing... 3 | Complete - 2 successfully verified harnesses, 0 failures, 2 total. 4 | -------------------------------------------------------------------------------- /tests/ui/multiple-harnesses/stop_at_single_fail/fail_fast_test.expected: -------------------------------------------------------------------------------- 1 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/ui/multiple-harnesses/stop_at_single_fail/fail_fast_test_parallel.expected: -------------------------------------------------------------------------------- 1 | Complete - 0 successfully verified harnesses, 1 failures, 1 total. -------------------------------------------------------------------------------- /tests/ui/multiple-proof-attributes/expected: -------------------------------------------------------------------------------- 1 | error: only one '#[kani::proof]' attribute is allowed per harness\ 2 | main.rs\ 3 | |\ 4 | | #[kani::proof]\ 5 | | ^^^^^^^^^^^^^^\ 6 | |\ 7 | -------------------------------------------------------------------------------- /tests/ui/regular-output-format-fail/expected: -------------------------------------------------------------------------------- 1 | Description: "assertion failed: 1 + 1 == 3" 2 | Failed Checks: assertion failed: 1 + 1 == 3 3 | -------------------------------------------------------------------------------- /tests/ui/regular-output-format-fail/fail.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | // kani-flags: --output-format regular 5 | 6 | #[kani::proof] 7 | fn main() { 8 | assert!(1 + 1 == 3); 9 | } 10 | -------------------------------------------------------------------------------- /tests/ui/regular-output-format-pass/expected: -------------------------------------------------------------------------------- 1 | Description: "assertion failed: 1 + 1 == 2"\ 2 | Location: 3 | tests/ui/regular-output-format-pass/main.rs:7:5 in function main 4 | -------------------------------------------------------------------------------- /tests/ui/regular-output-format-pass/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | // kani-flags: --output-format regular 5 | #[kani::proof] 6 | fn main() { 7 | assert!(1 + 1 == 2); 8 | } 9 | -------------------------------------------------------------------------------- /tests/ui/safety-constraint-attribute/double-attribute/expected: -------------------------------------------------------------------------------- 1 | error: Cannot derive `Invariant` for `Point` 2 | | 3 | | #[derive(Invariant)] 4 | | ^^^^^^^^^ 5 | | 6 | note: `#[safety_constraint(...)]` cannot be used more than once. 7 | -------------------------------------------------------------------------------- /tests/ui/safety-constraint-attribute/mixed-attributes/expected: -------------------------------------------------------------------------------- 1 | error: Cannot derive `Invariant` for `Point` 2 | | 3 | | #[derive(Invariant)] 4 | | ^^^^^^^^^ 5 | | 6 | note: `#[safety_constraint(...)]` cannot be used in struct and its fields simultaneously 7 | -------------------------------------------------------------------------------- /tests/ui/safety-constraint-attribute/no-struct-error/expected: -------------------------------------------------------------------------------- 1 | error: Cannot derive `Invariant` for `MyEnum` 2 | | 3 | | #[derive(kani::Invariant)] 4 | | ^^^^^^^^^^^^^^^ 5 | | 6 | note: `#[safety_constraint(...)]` can only be used in structs 7 | -------------------------------------------------------------------------------- /tests/ui/save-coverage-results/expected: -------------------------------------------------------------------------------- 1 | Source-based code coverage results: 2 | 3 | [info] Coverage results saved to 4 | -------------------------------------------------------------------------------- /tests/ui/should-panic-attribute/expected-panics/expected: -------------------------------------------------------------------------------- 1 | ** 2 of 2 failed 2 | Failed Checks: panicked on the `if` branch! 3 | Failed Checks: panicked on the `else` branch! 4 | VERIFICATION:- SUCCESSFUL (encountered one or more panics as expected) 5 | -------------------------------------------------------------------------------- /tests/ui/should-panic-attribute/multiple-attrs/expected: -------------------------------------------------------------------------------- 1 | error: only one '#[kani::should_panic]' attribute is allowed per harness 2 | error: aborting due to 1 previous error 3 | -------------------------------------------------------------------------------- /tests/ui/should-panic-attribute/multiple-harnesses-panic/expected: -------------------------------------------------------------------------------- 1 | Complete - 3 successfully verified harnesses, 0 failures, 3 total. 2 | -------------------------------------------------------------------------------- /tests/ui/should-panic-attribute/no-panics/expected: -------------------------------------------------------------------------------- 1 | check.assertion\ 2 | SUCCESS\ 3 | assertion failed: 1 + 1 == 2 4 | 5 | VERIFICATION:- FAILED (encountered no panics, but at least one was expected) 6 | -------------------------------------------------------------------------------- /tests/ui/should-panic-attribute/with-args/expected: -------------------------------------------------------------------------------- 1 | error: custom attribute panicked 2 | help: message: `#[kani::should_panic]` does not take any arguments currently 3 | error: aborting due to 1 previous error 4 | -------------------------------------------------------------------------------- /tests/ui/should-panic-attribute/with-args/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | //! Checks that `#[kani::should_panic]` doesn't accept arguments. 5 | 6 | #[kani::proof] 7 | #[kani::should_panic(arg)] 8 | fn check() {} 9 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/cadical/expected: -------------------------------------------------------------------------------- 1 | Solving with CaDiCaL 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/invalid/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | #[kani::solver(123)] 6 | fn check() {} 7 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/multiple-args/expected: -------------------------------------------------------------------------------- 1 | error: the `#[kani::solver]` attribute expects a single argument. Got 2 arguments.\ 2 | test.rs:\ 3 | |\ 4 | | #[kani::solver(kissat, minisat)]\ 5 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 | error: aborting due to 1 previous error 7 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/multiple-args/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | #[kani::solver(kissat, minisat)] 6 | fn check() {} 7 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/multiple-attrs/expected: -------------------------------------------------------------------------------- 1 | error: only one '#[kani::solver]' attribute is allowed per harness\ 2 | test.rs:\ 3 | |\ 4 | | #[kani::solver(kissat)]\ 5 | | ^^^^^^^^^^^^^^^^^^^^^^^ 6 | error: aborting due to 1 previous error 7 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/multiple-attrs/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | #[kani::solver(kissat)] 6 | #[kani::solver(kissat)] 7 | fn check() {} 8 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/no-arg/expected: -------------------------------------------------------------------------------- 1 | error: the `#[kani::solver]` attribute expects a single argument. Got 0 arguments.\ 2 | test.rs:\ 3 | |\ 4 | | #[kani::solver]\ 5 | | ^^^^^^^^^^^^^^^ 6 | error: aborting due to 1 previous error 7 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/no-arg/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | #[kani::solver] 6 | fn check() {} 7 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/not-found/expected: -------------------------------------------------------------------------------- 1 | error: the specified solver "non_existing_solver" was not found in path 2 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/unknown/expected: -------------------------------------------------------------------------------- 1 | error: unknown solver `foo`\ 2 | test.rs:\ 3 | |\ 4 | | #[kani::solver(foo)]\ 5 | | ^^^^^^^^^^^^^^^^^^^^ 6 | error: aborting due to 1 previous error 7 | -------------------------------------------------------------------------------- /tests/ui/solver-attribute/unknown/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | #[kani::proof] 5 | #[kani::solver(foo)] 6 | fn check() {} 7 | -------------------------------------------------------------------------------- /tests/ui/solver-option/bin/expected: -------------------------------------------------------------------------------- 1 | Solving with External SAT solver 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/ui/solver-option/cadical/expected: -------------------------------------------------------------------------------- 1 | Solving with CaDiCaL 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/ui/solver-option/invalid/expected: -------------------------------------------------------------------------------- 1 | error: invalid value 'foo=bar' for '--solver ' 2 | -------------------------------------------------------------------------------- /tests/ui/solver-option/invalid/test.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | // kani-flags: --solver foo=bar 4 | 5 | //! Checks that `--solver` rejects an invalid argument 6 | 7 | #[kani::proof] 8 | fn check_solver_option() {} 9 | -------------------------------------------------------------------------------- /tests/ui/solver-option/kissat/expected: -------------------------------------------------------------------------------- 1 | Solving with External SAT solver 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/ui/solver-option/minisat/expected: -------------------------------------------------------------------------------- 1 | Solving with MiniSAT 2 | VERIFICATION:- SUCCESSFUL 3 | -------------------------------------------------------------------------------- /tests/ui/std-override/format_panic.expected: -------------------------------------------------------------------------------- 1 | Complete - 0 successfully verified harnesses, 2 failures, 2 total. 2 | -------------------------------------------------------------------------------- /tests/ui/stub-attribute/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL -------------------------------------------------------------------------------- /tests/ui/stubbing/invalid-path/invalid_mod.expected: -------------------------------------------------------------------------------- 1 | error: failed to resolve `crate::mod_a::method_a::invalid`: expected module, found function `mod_a::method_a`\ 2 | invalid_mod.rs:\ 3 | |\ 4 | | #[cfg_attr(kani, kani::stub(crate::mod_a::method_a::invalid, noop))]\ 5 | -------------------------------------------------------------------------------- /tests/ui/stubbing/stubbing-flag/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION:- SUCCESSFUL 2 | -------------------------------------------------------------------------------- /tests/ui/terse-output-format-fail/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION RESULT: 2 | Failed Checks: assertion failed: 1 + 1 == 3 3 | -------------------------------------------------------------------------------- /tests/ui/terse-output-format-fail/fail.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | // kani-flags: --output-format terse 5 | #[kani::proof] 6 | fn main() { 7 | assert!(1 + 1 == 3); 8 | } 9 | -------------------------------------------------------------------------------- /tests/ui/terse-output-format-pass/expected: -------------------------------------------------------------------------------- 1 | VERIFICATION RESULT: 2 | -------------------------------------------------------------------------------- /tests/ui/terse-output-format-pass/main.rs: -------------------------------------------------------------------------------- 1 | // Copyright Kani Contributors 2 | // SPDX-License-Identifier: Apache-2.0 OR MIT 3 | 4 | // kani-flags: --output-format terse 5 | #[kani::proof] 6 | fn main() { 7 | assert!(1 + 1 == 2); 8 | } 9 | -------------------------------------------------------------------------------- /tests/ui/unknown-contract-harness/expected: -------------------------------------------------------------------------------- 1 | error: The function specified in the `proof_for_contract` attribute, `foo`, was not found.\ 2 | Make sure the function is reachable from the harness. 3 | test.rs:\ 4 | |\ 5 | | #[kani::proof_for_contract(foo)]\ 6 | | ^^^^^^^^^^^^^^ 7 | -------------------------------------------------------------------------------- /tests/ui/unsupported-annotation/expected: -------------------------------------------------------------------------------- 1 | error[E0433]: failed to resolve: could not find `test_annotation` in `kani` 2 | -------------------------------------------------------------------------------- /tests/ui/unwind-multiple-arguments/expected: -------------------------------------------------------------------------------- 1 | error: invalid argument for `unwind` attribute, expected an integer 2 | -------------------------------------------------------------------------------- /tests/ui/unwind-without-proof/expected: -------------------------------------------------------------------------------- 1 | error: the `unwind` attribute also requires the `#[kani::proof]` attribute 2 | -------------------------------------------------------------------------------- /tools/benchcomp/.gitignore: -------------------------------------------------------------------------------- 1 | # the regression tests write result.yaml files into their directories 2 | result.yaml 3 | -------------------------------------------------------------------------------- /tools/benchcomp/benchcomp/entry/README.md: -------------------------------------------------------------------------------- 1 | Each file X.py in this directory contains a `main` method, which 2 | bin/benchcomp will call when you run `benchcomp X`. Running `benchcomp` 3 | with no arguments will invoke the `main` method in `benchcomp.py`. 4 | -------------------------------------------------------------------------------- /tools/benchcomp/benchcomp/entry/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | -------------------------------------------------------------------------------- /tools/benchcomp/configs/README.md: -------------------------------------------------------------------------------- 1 | Example Benchcomp Configurations 2 | ================================ 3 | 4 | The files in this directory can be passed to benchcomp's -c/--config flag. 5 | -------------------------------------------------------------------------------- /tools/benchcomp/requirements.txt: -------------------------------------------------------------------------------- 1 | cerberus 2 | pyyaml 3 | -------------------------------------------------------------------------------- /tools/benchcomp/test/README.md: -------------------------------------------------------------------------------- 1 | # Benchcomp unit & regression tests 2 | 3 | To run, invoke `./test/run` from the tools/benchcomp directory. 4 | -------------------------------------------------------------------------------- /tools/benchcomp/test/unit/__init__.py: -------------------------------------------------------------------------------- 1 | # Copyright Kani Contributors 2 | # SPDX-License-Identifier: Apache-2.0 OR MIT 3 | --------------------------------------------------------------------------------