[third_party][rust] Upgrade proptest to 0.9.3
Change-Id: Idfbf7567469d25c057076c9853ee23b63a3de8e7
diff --git a/garnet/lib/rust/fidl_fuchsia_amber_ext/src/types.rs b/garnet/lib/rust/fidl_fuchsia_amber_ext/src/types.rs
index a076d89..6b7cac3 100644
--- a/garnet/lib/rust/fidl_fuchsia_amber_ext/src/types.rs
+++ b/garnet/lib/rust/fidl_fuchsia_amber_ext/src/types.rs
@@ -304,10 +304,7 @@
#[cfg(test)]
mod tests {
- use {
- super::*,
- proptest::{prelude::*, prop_compose, proptest, proptest_helper},
- };
+ use {super::*, proptest::prelude::*};
prop_compose! {
fn arb_url()(
diff --git a/garnet/lib/rust/fidl_fuchsia_pkg_ext/src/lib.rs b/garnet/lib/rust/fidl_fuchsia_pkg_ext/src/lib.rs
index c5ef14f..9b9a72f 100644
--- a/garnet/lib/rust/fidl_fuchsia_pkg_ext/src/lib.rs
+++ b/garnet/lib/rust/fidl_fuchsia_pkg_ext/src/lib.rs
@@ -5,10 +5,6 @@
//! `fidl_fuchsia_pkg_ext` contains wrapper types around the auto-generated `fidl_fuchsia_pkg`
//! bindings.
-#[cfg(test)]
-#[macro_use]
-extern crate proptest;
-
mod types;
pub use crate::types::{BlobId, BlobInfo};
diff --git a/garnet/lib/rust/fuchsia_pkg/src/build.rs b/garnet/lib/rust/fuchsia_pkg/src/build.rs
index 528408e..a198c93 100644
--- a/garnet/lib/rust/fuchsia_pkg/src/build.rs
+++ b/garnet/lib/rust/fuchsia_pkg/src/build.rs
@@ -125,7 +125,6 @@
use crate::test::*;
use maplit::{btreemap, hashmap};
use proptest::prelude::*;
- use proptest::{prop_assert, prop_assert_eq, proptest, proptest_helper};
use rand::SeedableRng;
use std::collections::{HashMap, HashSet};
use std::io;
@@ -366,7 +365,6 @@
use super::*;
use crate::test::*;
use proptest::prelude::*;
- use proptest::{prop_assert, prop_assert_eq, proptest, proptest_helper};
use rand::SeedableRng;
use std::fs;
use std::io::{self, Write};
diff --git a/garnet/lib/rust/fuchsia_pkg/src/creation_manifest.rs b/garnet/lib/rust/fuchsia_pkg/src/creation_manifest.rs
index 063da976..0e04713 100644
--- a/garnet/lib/rust/fuchsia_pkg/src/creation_manifest.rs
+++ b/garnet/lib/rust/fuchsia_pkg/src/creation_manifest.rs
@@ -140,7 +140,7 @@
use crate::errors::ResourcePathError::PathStartsWithSlash;
use crate::test::*;
use maplit::btreemap;
- use proptest::{prop_assert, prop_assert_eq, prop_assume, proptest, proptest_helper};
+ use proptest::prelude::*;
use serde_json::json;
fn from_json_value(
diff --git a/garnet/lib/rust/fuchsia_pkg/src/meta_contents.rs b/garnet/lib/rust/fuchsia_pkg/src/meta_contents.rs
index 911553d..49a1c1a 100644
--- a/garnet/lib/rust/fuchsia_pkg/src/meta_contents.rs
+++ b/garnet/lib/rust/fuchsia_pkg/src/meta_contents.rs
@@ -145,9 +145,6 @@
use crate::test::*;
use maplit::btreemap;
use proptest::prelude::*;
- use proptest::{
- prop_assert, prop_assert_eq, prop_assume, prop_compose, proptest, proptest_helper,
- };
use std::str::FromStr;
#[test]
diff --git a/garnet/lib/rust/fuchsia_pkg/src/meta_package.rs b/garnet/lib/rust/fuchsia_pkg/src/meta_package.rs
index 25664e4..65a5f4e 100644
--- a/garnet/lib/rust/fuchsia_pkg/src/meta_package.rs
+++ b/garnet/lib/rust/fuchsia_pkg/src/meta_package.rs
@@ -93,7 +93,7 @@
use crate::errors::{PackageNameError, PackageVariantError};
use crate::test::{random_meta_package, random_package_name, random_package_variant};
use lazy_static::lazy_static;
- use proptest::{proptest, proptest_helper};
+ use proptest::prelude::*;
use regex::Regex;
#[test]
diff --git a/garnet/lib/rust/fuchsia_pkg/src/path.rs b/garnet/lib/rust/fuchsia_pkg/src/path.rs
index ca11a18..108ce3a 100644
--- a/garnet/lib/rust/fuchsia_pkg/src/path.rs
+++ b/garnet/lib/rust/fuchsia_pkg/src/path.rs
@@ -93,7 +93,6 @@
use super::*;
use crate::test::*;
use proptest::prelude::*;
- use proptest::{prop_assert, prop_assert_eq, prop_assume, proptest, proptest_helper};
// Tests for invalid paths
#[test]
@@ -211,7 +210,7 @@
mod check_package_name_tests {
use super::*;
use crate::test::random_package_name;
- use proptest::{prop_assert, prop_assert_eq, proptest, proptest_helper};
+ use proptest::prelude::*;
#[test]
fn test_reject_empty_name() {
@@ -250,7 +249,7 @@
mod check_package_variant_tests {
use super::*;
use crate::test::random_package_variant;
- use proptest::{prop_assert, prop_assert_eq, proptest, proptest_helper};
+ use proptest::prelude::*;
#[test]
fn test_reject_empty_variant() {
diff --git a/garnet/lib/rust/fuchsia_pkg/src/test.rs b/garnet/lib/rust/fuchsia_pkg/src/test.rs
index 518c1d2..67c0b08 100644
--- a/garnet/lib/rust/fuchsia_pkg/src/test.rs
+++ b/garnet/lib/rust/fuchsia_pkg/src/test.rs
@@ -5,7 +5,6 @@
use crate::CreationManifest;
use crate::MetaPackage;
use proptest::prelude::*;
-use proptest::{prop_compose, proptest_helper};
/// Helper to assist asserting a single match branch.
///
@@ -26,13 +25,13 @@
pub const ANY_UNICODE_EXCEPT_SLASH_NULL_DOT_OR_NEWLINE: &str = "[^/\0\\.\n]";
prop_compose! {
- [pub] fn always_valid_resource_path_char()(c in ANY_UNICODE_EXCEPT_SLASH_NULL_DOT_OR_NEWLINE) -> String {
+ pub fn always_valid_resource_path_char()(c in ANY_UNICODE_EXCEPT_SLASH_NULL_DOT_OR_NEWLINE) -> String {
c
}
}
prop_compose! {
- [pub] fn always_valid_resource_path_chars
+ pub fn always_valid_resource_path_chars
(min: usize, max: usize)
(s in prop::collection::vec(always_valid_resource_path_char(), min..max)) -> String {
s.join("")
@@ -40,7 +39,7 @@
}
prop_compose! {
- [pub] fn random_resource_path
+ pub fn random_resource_path
(min: usize, max: usize)
(s in prop::collection::vec(always_valid_resource_path_chars(1, 4), min..max))
-> String
@@ -50,7 +49,7 @@
}
prop_compose! {
- [pub] fn random_resource_path_with_regex_segment_string
+ pub fn random_resource_path_with_regex_segment_string
(max_segments: usize, inner: String)
(vec in prop::collection::vec(
always_valid_resource_path_chars(1, 3), 3..max_segments),
@@ -66,7 +65,7 @@
}
prop_compose! {
- [pub] fn random_resource_path_with_regex_segment_str
+ pub fn random_resource_path_with_regex_segment_str
(max_segments: usize, inner: &'static str)
(s in random_resource_path_with_regex_segment_string(
max_segments, inner.to_string())) -> String
@@ -76,7 +75,7 @@
}
prop_compose! {
- [pub] fn random_external_resource_path()
+ pub fn random_external_resource_path()
(s in random_resource_path(1, 4)
.prop_filter(
"External package contents cannot be in the 'meta/' directory",
@@ -88,7 +87,7 @@
}
prop_compose! {
- [pub] fn random_far_resource_path()
+ pub fn random_far_resource_path()
(s in random_resource_path(1, 4)) -> String
{
format!("meta/{}", s)
@@ -96,25 +95,25 @@
}
prop_compose! {
- [pub] fn random_merkle_hex()(s in "[[:xdigit:]]{64}") -> String {
+ pub fn random_merkle_hex()(s in "[[:xdigit:]]{64}") -> String {
s
}
}
prop_compose! {
- [pub] fn random_package_name()(s in r"[-0-9a-z\.]{1, 100}") -> String {
+ pub fn random_package_name()(s in r"[-0-9a-z\.]{1, 100}") -> String {
s
}
}
prop_compose! {
- [pub] fn random_package_variant()(s in r"[-0-9a-z\.]{1, 100}") -> String {
+ pub fn random_package_variant()(s in r"[-0-9a-z\.]{1, 100}") -> String {
s
}
}
prop_compose! {
- [pub] fn random_meta_package()
+ pub fn random_meta_package()
(name in random_package_name(),
variant in random_package_variant()
) -> MetaPackage
@@ -124,7 +123,7 @@
}
prop_compose! {
- [pub] fn random_creation_manifest()
+ pub fn random_creation_manifest()
(external_content in prop::collection::btree_map(
random_external_resource_path(), random_resource_path(1, 2), 1..4),
far_content in prop::collection::btree_map(
diff --git a/garnet/public/rust/fuchsia-merkle/src/hash.rs b/garnet/public/rust/fuchsia-merkle/src/hash.rs
index ee11c2e..388a2d0 100644
--- a/garnet/public/rust/fuchsia-merkle/src/hash.rs
+++ b/garnet/public/rust/fuchsia-merkle/src/hash.rs
@@ -69,7 +69,7 @@
#[cfg(test)]
mod tests {
use super::*;
- use proptest::{prop_assert, prop_assert_eq, prop_assume, proptest, proptest_helper};
+ use proptest::prelude::*;
use std::str::FromStr;
proptest! {
diff --git a/src/sys/lib/fuchsia_url_rewrite/src/rule.rs b/src/sys/lib/fuchsia_url_rewrite/src/rule.rs
index 7707a5d..ba641f8 100644
--- a/src/sys/lib/fuchsia_url_rewrite/src/rule.rs
+++ b/src/sys/lib/fuchsia_url_rewrite/src/rule.rs
@@ -346,7 +346,7 @@
mod rule_tests {
use super::*;
use fuchsia_inspect::assert_inspect_tree;
- use proptest::{prop_compose, proptest, proptest_helper};
+ use proptest::prelude::*;
macro_rules! test_new_error {
(
diff --git a/third_party/rust_crates/Cargo.lock b/third_party/rust_crates/Cargo.lock
index aa0e373..219fe73 100644
--- a/third_party/rust_crates/Cargo.lock
+++ b/third_party/rust_crates/Cargo.lock
@@ -680,7 +680,7 @@
"proc-macro-hack 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro-nested 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)",
- "proptest 0.8.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proptest 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)",
"proptest-derive 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"quote 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1512,7 +1512,7 @@
[[package]]
name = "proptest"
-version = "0.8.7"
+version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"bit-set 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1521,7 +1521,9 @@
"lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
"quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
"regex-syntax 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"rusty-fork 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"tempfile 3.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2740,7 +2742,7 @@
"checksum proc-macro-hack 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)" = "0c1dd4172a1e1f96f709341418f49b11ea6c2d95d53dca08c0f74cbd332d9cf3"
"checksum proc-macro-nested 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e9968e025d6368d1273a93bc23051e30dbf5482475e716d7385d8ec8fbd5b5b6"
"checksum proc-macro2 0.4.27 (registry+https://github.com/rust-lang/crates.io-index)" = "4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"
-"checksum proptest 0.8.7 (registry+https://github.com/rust-lang/crates.io-index)" = "926d0604475349f463fe44130aae73f2294b5309ab2ca0310b998bd334ef191f"
+"checksum proptest 0.9.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2afed8cbdc8a64b58a5c021757a782351ec1afee85be374872721c84d5da5d80"
"checksum proptest-derive 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "08b264c54525e760fc1d39c5b2bfc96923b922a752893053b4adaafe33fa9346"
"checksum publicsuffix 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5afecba86dcf1e4fd610246f89899d1924fe12e1e89f555eb7c7f710f3c5ad1d"
"checksum pulse 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "655612b6c8d96a8a02f331fe296cb4f925b68e87c1d195544675abca2d9b9af0"
diff --git a/third_party/rust_crates/Cargo.toml b/third_party/rust_crates/Cargo.toml
index d113b04..17be81e 100644
--- a/third_party/rust_crates/Cargo.toml
+++ b/third_party/rust_crates/Cargo.toml
@@ -79,7 +79,7 @@
paste = "0.1"
pin-utils = "=0.1.0-alpha.4"
proc-macro-nested = "0.1.2"
-proptest = "0.8.7"
+proptest = "0.9.3"
proptest-derive = "0.1.1"
rand = "0.6"
rand_core = "0.4.0"
diff --git a/third_party/rust_crates/vendor/proptest/.cargo-checksum.json b/third_party/rust_crates/vendor/proptest/.cargo-checksum.json
index 8bfc9b2..bb07421 100644
--- a/third_party/rust_crates/vendor/proptest/.cargo-checksum.json
+++ b/third_party/rust_crates/vendor/proptest/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"CHANGELOG.md":"35956f8af45795520d010de08c0d4dc05d1162576e388235736d7935414d05ae","Cargo.toml":"3d6bb4df2cc8dac6a7d7b4e4a56d074aec63bad09af5bf09791eb2ecd7f24295","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"d8e0806926ce9f0a5030c382ecc0ffdf6de6fbea5c69a458435fd443fa7a5b92","README.md":"561ced318b4c093e408c9d6bbf65054cb19bbf1a49600695fa0ff7b7e21d1c55","appveyor.yml":"185b511ee8ad637b5c8065b037b51ab95b90ba178f0087df54331c8544e62c4b","examples/config-defaults.rs":"7a03d9c3da74f90dc35c86afe247ea2dded6ad08eef25a89fb3b56373e0a51cd","examples/dateparser_v1.rs":"6e5d9c5293e79d55ddf548b3bdcfb1ca5784961184a94feb8a880d37bb3a45be","examples/dateparser_v2.rs":"7dad9ad236972d24f7a427ef6292099b887cbb4fa56d91be9e0aadbaed54aad5","examples/fib.rs":"7bae84454ac8ab4039e6a0751885a7e8f89cf0af283af5a773714bfb5f1ed7a9","examples/tutorial-simplify-play.rs":"04a7f4c71e3ac58b8eeff47bbcd107fcd40a51d9f66ab30d184c7b62c642de24","examples/tutorial-strategy-play.rs":"3a9a84bed3cf05ac0efd8df88ed800620b14375cf3e7eb105b2ac55ea8f63bf6","gen-readme.sh":"4ef7d963d0227177972208c4bae6e3ceba9063f1e2452a81de4496abf64bf0ac","proptest-regressions/arbitrary/_std/env.txt":"3450a5867e58f6a6c4e5d50e4dce30283e2bf6d5389f48bfa1d535f1269c6516","readme-antelogue.md":"0fa5ca9a6265e5857411475caf4fddbf85d32bd7c35902dc9b51b2b7b96901af","readme-prologue.md":"e0493c5068cd1768d933fe483225dfbbea854483953a90daa20e4b4c6c816b4d","src/arbitrary/_alloc/alloc.rs":"bdbd7ea9b3f8b76856d885d50add44d28aea38d80ea29d46a4fd33d1f758a0cb","src/arbitrary/_alloc/borrow.rs":"245e78c4352ec602e65002211374633f586000b11353a6b5bd7062caa9530c82","src/arbitrary/_alloc/boxed.rs":"544fbdeeaa19de2be70dd09e0447bd73665b888d4603260c06dceae6b623e7c1","src/arbitrary/_alloc/char.rs":"353290bd9b41ba7afc1da731f3e52cd58cff39decac7f95bc416f0e966e0766b","src/arbitrary/_alloc/collections.rs":"33da2fc69efdf1b367f3b7bdfd5b41a5d029ed41f2456ad621d1a582d565e76d","src/arbitrary/_alloc/hash.rs":"ef2313f21211662aafbd70a8531c3a0d11b32176faa19f2e740086fc7d7a0bbf","src/arbitrary/_alloc/mod.rs":"b49db65bd88506b2b35cbed65c3da3d15c140214342d7d2bef6c180a22e503d4","src/arbitrary/_alloc/ops.rs":"55d26ddf4884dc5b0d44a580ada478ac83fc0764ece5b6ca612299a65fe09c20","src/arbitrary/_alloc/rc.rs":"2f284d9e3f36f317e817e73d07710d27bd954accf98d318a0652a00f250ff7c7","src/arbitrary/_alloc/str.rs":"185408d70335e566bbd841ba570567bdbd5e792533b0ca013c4f14294cc91588","src/arbitrary/_alloc/sync.rs":"78e98f883aea98815ee9554f7699a9656c7473225d0d69f419b9e3a642afa0a7","src/arbitrary/_core/ascii.rs":"91ef86c7159d06afce42d648165697dfd623cb820a7c8cb2c90a02a86bf9f4c8","src/arbitrary/_core/cell.rs":"c96b6c350601a1f5b4aeca938bb17c054b838676e6ece13d98b5a9e21e3b5ff4","src/arbitrary/_core/cmp.rs":"51c48567ed574530029a676c73c7d19d414d05fa4c07bcd56a13edaac38add77","src/arbitrary/_core/convert.rs":"830e889cf24e64d68d81706e45a33aef93450ee8430062817e1d288eb2e8b318","src/arbitrary/_core/fmt.rs":"e09f679e873b25f1d42e05daa189c802b48d639d83635c79d380a481afde27ce","src/arbitrary/_core/iter.rs":"d5fea7648696d05a875ca8fa5574d34233041365cf7c04e3512df9bd6e3e3594","src/arbitrary/_core/marker.rs":"ba1368ff79549a84293b61652af0bd531941f5eacc9845b753edf221585b4430","src/arbitrary/_core/mem.rs":"b2e84114f821c23bdba6dd7e4596769ab3027dc8ee3dc900bf324c26b7de23fa","src/arbitrary/_core/mod.rs":"b30ebd2a2e0606fb6aac4ad63eb8068fc189b576283bbd63299b9f5d21d32846","src/arbitrary/_core/num.rs":"6b758ad6a40deebd4cc08a73066e3bfe6d95ff8f30b362346f65f33e233e9ad4","src/arbitrary/_core/option.rs":"8f9d661cff088e21b5df10bf8ff4510e8fb5f2f26ce554f0705fea9f1313a6c6","src/arbitrary/_core/result.rs":"4b6f4e47e3f64a56f80ab1fa20939a8abbf81e49bbfe4ee9830d68886ac2a192","src/arbitrary/_std/env.rs":"8fe031f2ebca12598498d197f0b866a5647ff22bd67660dbd4a25c26361cbcfb","src/arbitrary/_std/ffi.rs":"f27382d2885d9ceacd09e4b3bb5a1f6666175481407c91d65d16b453990d6511","src/arbitrary/_std/fs.rs":"50c1fd9099413d6d9e086a1fde54c350dc0c224cec8ae46230cf3483b9079e3e","src/arbitrary/_std/io.rs":"6d42653a4e795444772b939c0000761f9d93b080ad36836e0425cf2fd156bc69","src/arbitrary/_std/mod.rs":"73845b1e2e31d6fe820143d427f48d9955f67f28ecd5344d9ca0c74928f6ddb7","src/arbitrary/_std/net.rs":"5c698d56dc93dc29bbaf27899b653b59c4c690a2bb071bdadf282dca65feca0c","src/arbitrary/_std/panic.rs":"20380439a655610d5f5011cc6c16c7e7acfbb7d314a219746fd174f46ea1320f","src/arbitrary/_std/path.rs":"af8fd327ff6bc73686a7bf796694294c418607141dea991c063c4422da4ccbc2","src/arbitrary/_std/string.rs":"5a28437d96bf9847c34c30a7358e7c5411e1f955c3229f1342452ec1f71e966f","src/arbitrary/_std/sync.rs":"92ffc951db7ea9f7065ba4bab346741fb89fc605ce98e69ca8302abda3a160eb","src/arbitrary/_std/thread.rs":"66232e2d6f961215278dda034dd137937176dba70c99c3956b530521330507c6","src/arbitrary/_std/time.rs":"403179306829a4ba493a41cc820623549cdbe5f379846c0d4d03dd7d4fda47e9","src/arbitrary/arrays.rs":"e697df01435068aeba2c134271ac264c88d43c41f4d1f11a4f8f658e3517606d","src/arbitrary/functor.rs":"620ec439ba3c4dc7182f5ebd47700db6f8eb1d7e1b31fad3af3bb852247dd1a3","src/arbitrary/macros.rs":"a3fe075811c1e711cb8ffef0557604f70df5e0a75d4110ed2f8516c4e324a24b","src/arbitrary/mod.rs":"dc801344578cc0d30250eceb49f9634e601b4835f4e3e607ae58bf298cb5bc2b","src/arbitrary/primitives.rs":"08bff49d255e68236bc6bb6aae068f59ee571cc529cd426efd0fd31d7fcb62e6","src/arbitrary/sample.rs":"8711068bf47b2cf6a19194e091b06446512220475dfef13d95849473b0f9f566","src/arbitrary/traits.rs":"09e5c5e0b1cf2bd391c6922a51e436f39fc1c9a510070927fa85ee793cf24ba6","src/arbitrary/tuples.rs":"bbc8626b2ed4a71e5f7530e5671af6ae2570c1bb9ca80aca804b946f3d4ee7ba","src/array.rs":"e76c0564abf95ccf212de15aed266ed4655f67f4a019c3673b884f682668ace1","src/bits.rs":"2c279f83b8672b873ee17357b3412c96a483b641f919916df8c5709225013747","src/bool.rs":"ed1e8111889e166c75abba3eb814811d2f6431141d7aa20ff2287a53f1b3f9e0","src/char.rs":"c0d990f14158cb2ab1111a584dee0370ff8d73f823eebd7f410d9c7ecd33c1e1","src/collection.rs":"4eb6689f8b636f1bb6444f8f140dab434bb8c030b5f3c3e8fd2f3b22f929c587","src/file-preamble":"a4a75492b40e467fa8d1bcf050e685ea4de56c3a76095d756488c554d76a4986","src/lib.rs":"301b843ca4f0bf3695220aac6f9b2d35060db1186c934202e51b5d7df5a74d20","src/macros.rs":"39c880602d8c0450bdaf77356a1f614f5ec3e521206659781135b1956fb599a0","src/num.rs":"d1d49a40640ac39c5b8ee142c8a4d7e3310d0529d139b28cd6643656892d2bff","src/option.rs":"74f1f8f89f3ffc17818e31d283ba576a40ec1af4fe12a001d4f1e459b2ff98f9","src/prelude.rs":"194182b27df3050b2bbc63939277f2f98d4cd42cb34b0c78b5aeb192a34f4c02","src/product_frunk.rs":"212d5b2468672cb98c3f9024d2d6403177ee16a70cb1e35e2f4bdd79cb7c7edc","src/product_tuple.rs":"aaa0a8d3b0c4ca2294846b4098908df720b2dcf536582599404c03aec530f629","src/regex-contrib/README.md":"add72e2a9a34d4e67d647613970cbf5affc1d987ebe90858a487f3ee6e4032ce","src/regex-contrib/crates_regex.rs":"7812e91c25a2aad48ba024bcbeb8b922ffc1cfa3113a33615885d72d8a2cae64","src/result.rs":"ee06e0e97fdf0b8ec59fa9af588a6ff68b80b0e7493623e26988f36a64964597","src/sample.rs":"96465ef733ebb8bc58cb739a6997b56bcdc9466850ea23a13cc407c7c1057025","src/std_facade.rs":"4dcf19c2bad475ca7ed55d6ef008c331eb9bdf14ff3d342f275f5b16224558b7","src/strategy/filter.rs":"14057ffb8680800f47ba85cb86ace4642e21c2ba8e7dbba8a0e2e6e029deeb59","src/strategy/filter_map.rs":"47ea8e6828616f45ebce9baf3180ac1135d7f5ae5bc9b8c8c076ae66976a438f","src/strategy/flatten.rs":"ba48c1ff5657ba3c74b951f0fe356f15e50aee52fd3ffa861cfa0e7dbf073d29","src/strategy/fuse.rs":"e30615bd5f0cf24d92fd6a8ba22869f41dc7ef88a52e56eeef9a69ba6a479e56","src/strategy/just.rs":"c14a5bc2fcbcc6e8345b302a046e0f98c65b5c04171d9b75daf2fc5868f9ac16","src/strategy/map.rs":"605ab1ae03319d0c74e7b840472a7a5697c3fb4a30d7bb678a80a9fc3b594baf","src/strategy/mod.rs":"984c3a38909e5c82130addafa048904e463a44ed5ab825a6439b039e8bdad123","src/strategy/recursive.rs":"76d13f6fbdd07bad5e20d9baa84140f36d599cf213bb618c5a8182a8232907f0","src/strategy/shuffle.rs":"0d8f03cd44282d149f22b3137f133a8b4d9693b8bc1a83c83e085257df4270ae","src/strategy/statics.rs":"75fc9c16d31261439425164eb75c256c5e345e8191a27f54785dc5855c09cbff","src/strategy/traits.rs":"9bea30fd0e41f2b61fa91b70c2e62e91b5bf63b3f8e4d8606d12fded9862b18c","src/strategy/unions.rs":"b72dded23434d9e228396b8da518cfe01fc903cf7dd5e82b2b793e3087b9ba96","src/string.rs":"c807e27ce3d39475dc75b8808d4c5288fbadce06d3f5198e03a2f6d0360586c3","src/sugar.rs":"ada3fd1eee0b3bca4da6a4a6a1e3c04c0c7cfcf5d621c89712b1da1b36740048","src/test_runner/config.rs":"330a9bce9f5d87a8fc819916a1a58f1f9b68721038dcbdeac0772f06d586fbdd","src/test_runner/errors.rs":"3d855228a1f3b73888d685a037f7b98aaf09b17c69f9f4d86e8eeccb7a6f11ab","src/test_runner/failure_persistence/file.rs":"4458ce6cbf7e84eab0aa0c8642e0be41e9faf8dc70c47008c34a818318022c1b","src/test_runner/failure_persistence/map.rs":"a6afe71eb6110d2a50ac7c45ea8459c7453e335ccf0e2be9206efd228a094d2a","src/test_runner/failure_persistence/mod.rs":"7d0655c5faa2a7f66715afd24c1e6cd3fdea5b6fca10d05f32b7d5fee4f16190","src/test_runner/failure_persistence/noop.rs":"82297ffec5b82797a6846892f4c1b05b46e32c341752fe5471b63477007bb0fb","src/test_runner/mod.rs":"c5f165426bd81fd3a934369430e07d18003b89e9dda24624f8456ce430696e89","src/test_runner/reason.rs":"06a1a52f23d1a7e65fbf35a212188f67bb6a0f6786dfcdd5c79c95272373e87a","src/test_runner/replay.rs":"06357299b3ce214bf48be6ea4c0ca138a0a8bd6db5c6107a11076e7cdeac9872","src/test_runner/result_cache.rs":"4010d878658eb005deddd23334e5d5b34c2844d0d9774036ddc7ca95102ead69","src/test_runner/rng.rs":"3da6ef6cfc91f484e2cae60463f3b2013db50c24f3aef34b592ea4867ff15ed5","src/test_runner/runner.rs":"5262e8d028b16d2c84d8878011776e7a77174eca34f73f64a82989382794f95a","src/tuple.rs":"11405b3ee4bb6e564640ef6411786dfdbb36e5abd984b58e076123c655bda9c0","test-persistence-location/README.md":"83c3b124b9203f711b8a7ecfb126db96d66bbe73831288c9ee1fb030acfe44a9","test-persistence-location/run-tests.bat":"ba04781900565fd1cec389dd0f9a1c67dd2d0e23b06e63de2b53365e3985c78f","test-persistence-location/run-tests.sh":"03f05cf0409baabf39b0aca33d659e6385306eaccf036fe47e0155a97dd64afb"},"package":"926d0604475349f463fe44130aae73f2294b5309ab2ca0310b998bd334ef191f"}
\ No newline at end of file
+{"files":{"CHANGELOG.md":"f3e527c5e97f3a765b52bb53f058532f680a0bd79e776ef459b38c88d21b4de1","Cargo.toml":"f277e9d1dcbaec9f96568a712571bf1991bdc0bed5c1c2714d29e126c50b1ae2","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"d8e0806926ce9f0a5030c382ecc0ffdf6de6fbea5c69a458435fd443fa7a5b92","README.md":"b3f0d59d2ad665814da50fe487d79bd7cf744e8cd6b249486da09767323a3c5f","examples/config-defaults.rs":"312ee1c5f98ee858d0401a092e0a87b4c3231095f87a5dd4e6ba3288600ef596","examples/dateparser_v1.rs":"5f91b684ce2d46d865f1f1c0e642efb351e4469067104213871d0fcb1b5a369a","examples/dateparser_v2.rs":"d91d93a7ae5fd7e18c535847bcb3e783f1bc461e9797c8f0b21bc0cec5dd812c","examples/fib.rs":"4740e33bbfb420648a6e49468c178083a7f4c04c8c7512653fed3fff3332edb0","examples/tutorial-simplify-play.rs":"2d048a86334589389b26416fc27f6154b20e182e3766125ffabaeb491dd9295f","examples/tutorial-strategy-play.rs":"3242ba366e52e6d8c66155c9545af3b8863589979fbc6623dd97f532c8fb5285","proptest-regressions/arbitrary/_std/env.txt":"3450a5867e58f6a6c4e5d50e4dce30283e2bf6d5389f48bfa1d535f1269c6516","proptest-regressions/test_runner/rng.txt":"978d8519044a3c6056fa3c99edfd1ff9dee184ff1e74a2592830d54be3f22e81","src/arbitrary/_alloc/alloc.rs":"12942e50c77634b53f5efeb27e24d75fabd77048575fd5d7edf991d96ec8d980","src/arbitrary/_alloc/borrow.rs":"957814eb8c8ff5a7faae922063a8488fe448a3a7d02a273a15df107599f271bf","src/arbitrary/_alloc/boxed.rs":"54b0279c9e5acbff5b4a47f96d75ecf39b5209153b5b07f28437e8a2175a8ad9","src/arbitrary/_alloc/char.rs":"3046abfd531dffb46dc51ab2e9a424f588eefcb512d5c73a6e8b78915aa7c9c3","src/arbitrary/_alloc/collections.rs":"2784124e214edafff38fa125c4211e84908a858e2d1d014c9e2c0573a95bf3e9","src/arbitrary/_alloc/hash.rs":"d53aa7d615421b6989147a5dc74342f95baab4d065be9f41037621c893b68575","src/arbitrary/_alloc/mod.rs":"b49db65bd88506b2b35cbed65c3da3d15c140214342d7d2bef6c180a22e503d4","src/arbitrary/_alloc/ops.rs":"621bbaf95e8cb0995cd86602cb890cb2287434064e828211ba2feb161579d4a5","src/arbitrary/_alloc/rc.rs":"a83680953b444454655cf15f3078838c4c1af4376f9b8482f3bb0e0c01825d92","src/arbitrary/_alloc/str.rs":"0702f576b52b79b7414ae955d607efc033bcc3ddec57aac87b1edce7db37af18","src/arbitrary/_alloc/sync.rs":"9b1b4c791118a4dda40fe815f431695c3d685f14599baa51d0b65d1ccbab8d24","src/arbitrary/_core/ascii.rs":"f205048847c9f1cb6811561a097c4a25a0e5f711a6a4a551da7c2f2cb043d99a","src/arbitrary/_core/cell.rs":"c96b6c350601a1f5b4aeca938bb17c054b838676e6ece13d98b5a9e21e3b5ff4","src/arbitrary/_core/cmp.rs":"783ca9c9b3ba7bec14e505fcfa00838d591c72fc368afa5d48fa760f28f22e0a","src/arbitrary/_core/convert.rs":"830e889cf24e64d68d81706e45a33aef93450ee8430062817e1d288eb2e8b318","src/arbitrary/_core/fmt.rs":"e09f679e873b25f1d42e05daa189c802b48d639d83635c79d380a481afde27ce","src/arbitrary/_core/iter.rs":"dd8d12a93dd5ef0dc2a6c3c5ce8cf61f33e84f1ebc561579f8ac9f5729c24723","src/arbitrary/_core/marker.rs":"ba1368ff79549a84293b61652af0bd531941f5eacc9845b753edf221585b4430","src/arbitrary/_core/mem.rs":"3d7229c4d958a9a7a98a25e1eaec66e9241cb0bd38cbf362ec02cb417381dad0","src/arbitrary/_core/mod.rs":"b30ebd2a2e0606fb6aac4ad63eb8068fc189b576283bbd63299b9f5d21d32846","src/arbitrary/_core/num.rs":"f18835d55c4066ecf8a87567217d95f66a21f780de55dc02ab73e0158a345174","src/arbitrary/_core/option.rs":"065ed70c706474e8a5ff825b73ef856e12e64d4cde42a0e8001fd7f3f5fb5b54","src/arbitrary/_core/result.rs":"592dc209cfa0beab04394682718923da9f8a77575de1ea48518125d09352568e","src/arbitrary/_std/env.rs":"2f190609dd29212f89e2c69e2b4cda1bd47326ae9318bbfddd1093f85ae3ab9f","src/arbitrary/_std/ffi.rs":"e655491b3333fa50e288ebe96e3be83ad6fb5c595e9517f38ed1a2b7294762b9","src/arbitrary/_std/fs.rs":"dcecd2f7d4661513fa08da60f6c2e2f374410acc8292b3b11967a12a6a93f2ea","src/arbitrary/_std/io.rs":"1759939b9abf8c3e4458a113083c848e950b884f46c9c0c682c584750c1f1d5d","src/arbitrary/_std/mod.rs":"73845b1e2e31d6fe820143d427f48d9955f67f28ecd5344d9ca0c74928f6ddb7","src/arbitrary/_std/net.rs":"06d12b4f9172bd42628b36696789e5369b34084ffbe9fb7ca73b30a9697d230c","src/arbitrary/_std/panic.rs":"20380439a655610d5f5011cc6c16c7e7acfbb7d314a219746fd174f46ea1320f","src/arbitrary/_std/path.rs":"af8fd327ff6bc73686a7bf796694294c418607141dea991c063c4422da4ccbc2","src/arbitrary/_std/string.rs":"1cf6ec348ca61fba28d1b9da53370ebc9e2affe8353bd72796ac41be9f1fffbc","src/arbitrary/_std/sync.rs":"f614c528541350c86e1f555c6e811670dbfa7ec0ef9588bed0ceda89b1891092","src/arbitrary/_std/thread.rs":"42c87b24cecdb12befdc0ab26937a01893a68bdb1066aba304f124edb5bbe901","src/arbitrary/_std/time.rs":"63812a1133f138fd0749507f785f477120cafbd1b71714db418f966ab47563cf","src/arbitrary/arrays.rs":"ed29c09ddb1bc49e85f5afa9c7be6d1be83c751fe953ef45cf9d4e35b8c5807f","src/arbitrary/functor.rs":"2613612ded1494351cc9fcb1362470be662ae46c9afa0578a2daf031cb30f0ff","src/arbitrary/macros.rs":"a3fe075811c1e711cb8ffef0557604f70df5e0a75d4110ed2f8516c4e324a24b","src/arbitrary/mod.rs":"6768489e0530db92557f674102d37c1909ee4f658e4dcd2d3b4b4eaf629b58d0","src/arbitrary/primitives.rs":"11733326f88e08f559350306a22b731e1ef411430fd34e430b3d9c5999065754","src/arbitrary/sample.rs":"79fafd09814cd3f1ebcbd73f7f5a976f5a80af89f5a076e58b7565038e7a2293","src/arbitrary/traits.rs":"bf3ce2f950ebbf359b592c5e39f8fbca2302cb2f45b93b185ccc1d81308a7d5b","src/arbitrary/tuples.rs":"ae04d5c912edb0ce7c387eed72eb57785435c1063721e45e0e65f60cf03a7f13","src/array.rs":"790c5f178334fe6d57774f3664ad95761b288ba9ee9c17965cc5814772563bdb","src/bits.rs":"4f03e8910a40aa0b55fbbf8c6715d03abf0db2fcc4fec78ce6d63d49dc42d732","src/bool.rs":"5e5cb12798541043a42b48f1e6b958087483b9bbb5515851daaaf9de7433e936","src/char.rs":"257b8c9585e9debdf72ca350c4c7d9150550a18f9cc2a9e9c5435b64e6cd6f8a","src/collection.rs":"c82ae8dc1c1ce6ce05fef92006e88d9eb82be5a9f972234a44a5e98f466a3e64","src/file-preamble":"a4a75492b40e467fa8d1bcf050e685ea4de56c3a76095d756488c554d76a4986","src/lib.rs":"21a1bcd20c4e36ad394875ff70f6c151248fa692a447acf86b0b9ecacfde150b","src/macros.rs":"a16360937ee7c9ddf7f7cfc34bea3da69155a2fb217a9743a4a3e123104154cd","src/num.rs":"568156cd7b63bcc15141b150631ca02557927e5221dd4afc937a6edc60e3911f","src/option.rs":"e2a55cc32e59fdbedbcfa1e04d3a1cb9e44fe294f01039acc0b15fbf564caea7","src/prelude.rs":"cb2eec1f9b0e61e28a077067639538d6a8c19f945f5b919cbb204dae872bc86b","src/product_frunk.rs":"212d5b2468672cb98c3f9024d2d6403177ee16a70cb1e35e2f4bdd79cb7c7edc","src/product_tuple.rs":"aaa0a8d3b0c4ca2294846b4098908df720b2dcf536582599404c03aec530f629","src/regex-contrib/README.md":"add72e2a9a34d4e67d647613970cbf5affc1d987ebe90858a487f3ee6e4032ce","src/regex-contrib/crates_regex.rs":"7812e91c25a2aad48ba024bcbeb8b922ffc1cfa3113a33615885d72d8a2cae64","src/result.rs":"940bc7d204e6f4b1d171a4559b39da3c10b3b14af7080527b5c4c319897363f3","src/sample.rs":"cbb02d9cbb787ab1cd8bbf9bff8f0f18c30a8e880916409a6ed291ce489cb446","src/std_facade.rs":"4dcf19c2bad475ca7ed55d6ef008c331eb9bdf14ff3d342f275f5b16224558b7","src/strategy/filter.rs":"fac9b991add45493277a7f0a28a38387ee484da9b503a278a0309efc2eba1967","src/strategy/filter_map.rs":"122658d948d9ae525b7f2b5b55c101c8e9e9bdb6cf4445ece7b7b764b6978ebf","src/strategy/flatten.rs":"74cab4b3c7b21754ff508f300b29f05ef762d1f77524d9c05afd472991cb65f4","src/strategy/fuse.rs":"25b847ea51eeed536977d08c4a086348b71d61806926c08e5e15e0b82a912f3e","src/strategy/just.rs":"4713d290fa3d89e832132e200942b952f945c6ec8254a00ed1f1d6561fb59998","src/strategy/map.rs":"05107da9b2e58f1750af4a65a20b32e028ee7610b5265e03cb9c2de90901c394","src/strategy/mod.rs":"984c3a38909e5c82130addafa048904e463a44ed5ab825a6439b039e8bdad123","src/strategy/recursive.rs":"8efcbd303f3ec8a4a5c95921608e6dff31cc4d3c4a53abdcf638ecb20f4e379b","src/strategy/shuffle.rs":"81ff00bbfabdcd536d98b9bada2787e048b1fbe1c4a32e2cb813e12570463774","src/strategy/statics.rs":"e563abaf6ccde3d89404866df9836508b07133e842bc69e8017de2657e27b02d","src/strategy/traits.rs":"5b99571fb62104041e3f7e9343a802d1738f9f07e55ca2eea43833551caf1f70","src/strategy/unions.rs":"8aaa2c36c49b2347d5787ccb8e9f3ba6eb84c6d19ab6fc16db7f66b3a2008434","src/string.rs":"dae23140bc0fbd98a39450d5ef2bd98972125c11272717f5f677f7408ff4abd5","src/sugar.rs":"eded86f0a28a07a341b66e9bca47630fb16dc663a1780c106fd9447edebefdd7","src/test_runner/config.rs":"f305f8f948dc3168ec7ec9d3e0a33c8c30d945b1c11f166ced97d0e013bbab9d","src/test_runner/errors.rs":"b0562fa535e36ed1db8b266ec83ba0466e63d2c08f4e4ad7613dbd48ab513e87","src/test_runner/failure_persistence/file.rs":"56a73b29397821b68ea213d500dd2b7787b95f7c0777d39e66ad9cf5c5d43fec","src/test_runner/failure_persistence/map.rs":"aee5dd40ffcb8aab87e55981021b9fa3d60b9c21f815473736e16bcf274d11f8","src/test_runner/failure_persistence/mod.rs":"e45d8d0ffb451b42e8f0c67ea42193acb356f4973129f3240b1b892329eeae2a","src/test_runner/failure_persistence/noop.rs":"374b8c6fdcc6f0b55dcda8996ea1beed174acea8dbbcb0fe285fd5be5ca447bb","src/test_runner/mod.rs":"c5f165426bd81fd3a934369430e07d18003b89e9dda24624f8456ce430696e89","src/test_runner/reason.rs":"0e7c765d64561267b3e704880223903d37e59003ca0c275acb56ce90afb7108e","src/test_runner/replay.rs":"e590cc7978a51cf1c0a6e527b7c471e93a2a521820e62c55764d68e55c3f4615","src/test_runner/result_cache.rs":"2e1f70886cdcc19da5471aa83541c56060b3465e504c62b04bb9fa1a37248373","src/test_runner/rng.rs":"1b9723456ee49fe796f3e0a76b0ac5d0c369e8cadad9e2e2200c2468c3b469f9","src/test_runner/runner.rs":"70d1e4f9ca79f924f06354150309a1ad7bcd8aab05256c8a8090da809e758635","src/tuple.rs":"9ebe2cd7190ff48ec348720476280ef828e0516edb0bdbbd59ec16d7d5ed9a9d","test-persistence-location/README.md":"83c3b124b9203f711b8a7ecfb126db96d66bbe73831288c9ee1fb030acfe44a9","test-persistence-location/run-tests.bat":"ba04781900565fd1cec389dd0f9a1c67dd2d0e23b06e63de2b53365e3985c78f","test-persistence-location/run-tests.sh":"03f05cf0409baabf39b0aca33d659e6385306eaccf036fe47e0155a97dd64afb"},"package":"2afed8cbdc8a64b58a5c021757a782351ec1afee85be374872721c84d5da5d80"}
\ No newline at end of file
diff --git a/third_party/rust_crates/vendor/proptest/CHANGELOG.md b/third_party/rust_crates/vendor/proptest/CHANGELOG.md
index 9cb0858..edff88e 100644
--- a/third_party/rust_crates/vendor/proptest/CHANGELOG.md
+++ b/third_party/rust_crates/vendor/proptest/CHANGELOG.md
@@ -1,3 +1,132 @@
+## 0.9.3
+
+This is a minor release to correct some packaging errors. The licence files are
+now included in the files published to crates.io, and some unneeded files are
+now excluded.
+
+## 0.9.2
+
+### New Additions
+
+- Closures generated by `prop_compose!` are now `move`. This is not expected to
+ cause any breakage since there is no way to successfully use a borrowing
+ closure with that macro.
+
+- There is now **highly experimental** support for building on Web Assembly.
+ Refer to [the Proptest
+ book](https://altsysrq.github.io/proptest-book/proptest/wasm.html) for build
+ instructions.
+
+### Other Notes
+
+- Using proptest with the default `std` feature enabled, the `spin` crate is no
+ longer brought in as a dependency.
+
+- Using proptest with the `std` feature disabled, neither `spin` nor
+ `lazy_static` are brought in as dependencies.
+
+## 0.9.1
+
+### New RNG Algorithm
+
+Starting in this version, the default RNG algorithm has been changed from
+XorShift to ChaCha since it produces higher-quality randomness. This may make
+test case generation a bit slower but it avoids certain pathological cases that
+the old generator had.
+
+The old algorithm is still supported, and is used automatically when reading
+old failure persistence files.
+
+Note that this change also affects the internal representation of RNG seeds,
+which affects the `FailurePersistence` trait which previously only supported
+the seed representation for XorShift. This release maintains source
+compatibility with 0.9.0 by providing defaults for the new methods which
+delegate (when possible) to the old ones, but be aware that custom failure
+persistence implementations using the old API will not function when using an
+RNG other than XorShift.
+
+To keep using the old algorithm, you can set the environment variable
+`PROPTEST_RNG_ALGORITHM` to `xs` or set `Config.rng_algorithm` to
+`RngAlgorithm::XorShift` in code.
+
+Besides ChaCha, this version also adds a `PassThrough` RNG "algorithm" which
+makes it possible to use an external source of entropy with Proptest.
+
+### New Additions
+
+- `TestRng` instances can be created with the `from_seed` function.
+
+- `TestRunner` instances can be created with user-provided `TestRng`s.
+
+- `TestRunner` now has a `deterministic()` constructor which uses the same RNG
+ every time, to facilitate doing statistical tests on strategy outputs.
+
+- There is now a work-around for a [compiler
+ bug](https://github.com/rust-lang/rust/issues/52478) which prevents building
+ with `-C link-dead-code`. Please see this issue for details:
+ https://github.com/AltSysrq/proptest/issues/124
+
+### Deprecations
+
+- The `load_persisted_failures` and `save_persisted_failure` methods on the
+ `FailurePersistence` trait have been deprecated and will be removed in
+ 0.10.0.
+
+## 0.9.0
+
+### Breaking Changes
+
+- The minimum Rust version has been increased to 1.32.0.
+
+- The version of the `rand` crate has been increased to 0.6.
+
+- The `ValueFor` type alias (deprecated in 0.8.0) has been removed. Replace
+ `ValueFor<S>` with `S::Value` or `<S as Strategy>::Value` as necessary.
+
+- `From<SizeRange>` implementations converting a `SizeRange` back to various
+ std types have been removed since they were of limited utility and had
+ unclear or incorrect conversion properties.
+
+- Many optional elements (such as trailing commas or function visibility
+ modifiers) in certain macros could be specified more than once. The macros
+ now accept at most one occurrence.
+
+- Visibility modifiers inside `prop_compose` must no longer be enclosed in
+ brackets. Unless other modifiers (e.g., `unsafe`) are also in use, simply
+ removing the brackets is sufficient.
+
+### New Additions
+
+- Rust 2018 style macro imports are now supported.
+
+- In a Rust 2018 crate, all the macros can be brought into scope with
+ `import proptest::prelude::*;`.
+
+- The proptest macros now accept trailing commas in more locations.
+
+- Visibility modifiers can now be passed to `prop_compose!` without enclosing
+ them in brackets. Unfortunately, the old way could not continue to be
+ supported due to the way the `vis` macro matcher works.
+
+### Nightly-only breakage
+
+- The `nightly` feature, which was formerly required for using proptest with
+ `#[no_std]`, has been removed. References to the feature can simply be
+ deleted.
+
+- When using the `unstable` feature and setting `default-features = false`, the
+ `AtomicI64` and `AtomicU64` types are not supported unless the `atomic64bit`
+ feature is enabled. This supports `no_std` usage on platforms which do not
+ support atomic 64-bit operations.
+
+### Other Notes
+
+- Generated strings are now much more likely to contain right-to-left override
+ characters.
+
+- Most of the crate-level documentation has been relocated to the [Proptest
+ Book](https://altsysrq.github.io/proptest-book/proptest/index.html).
+
## 0.8.7
### New Additions
diff --git a/third_party/rust_crates/vendor/proptest/Cargo.toml b/third_party/rust_crates/vendor/proptest/Cargo.toml
index 809e6a0..f044a6b 100644
--- a/third_party/rust_crates/vendor/proptest/Cargo.toml
+++ b/third_party/rust_crates/vendor/proptest/Cargo.toml
@@ -3,7 +3,7 @@
# When uploading crates to the registry Cargo will automatically
# "normalize" Cargo.toml files for maximal compatibility
# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
+# to registry (e.g., crates.io) dependencies
#
# If you believe there's an error in this file please file an
# issue against the rust-lang/cargo repository. If you're
@@ -11,11 +11,14 @@
# will likely look very different (and much more reasonable)
[package]
+edition = "2018"
name = "proptest"
-version = "0.8.7"
+version = "0.9.3"
authors = ["Jason Lingle"]
+exclude = ["/gen-*.sh", "/readme-*.md"]
description = "Hypothesis-like property-based testing and shrinking.\n"
-documentation = "https://altsysrq.github.io/rustdoc/proptest/0.8.7/proptest/"
+homepage = "https://altsysrq.github.io/proptest-book/proptest/index.html"
+documentation = "https://altsysrq.github.io/rustdoc/proptest/0.9.3/proptest/"
readme = "README.md"
keywords = ["property", "testing", "quickcheck", "fuzz", "hypothesis"]
categories = ["development-tools::testing"]
@@ -33,8 +36,8 @@
default-features = false
[dependencies.lazy_static]
-version = "1.0.0"
-default-features = false
+version = "1.2"
+optional = true
[dependencies.num-traits]
version = "0.2.2"
@@ -45,10 +48,16 @@
optional = true
[dependencies.rand]
-version = "0.5.0"
+version = "0.6"
features = ["alloc", "i128_support"]
default-features = false
+[dependencies.rand_chacha]
+version = "0.1"
+
+[dependencies.rand_xorshift]
+version = "0.1"
+
[dependencies.regex-syntax]
version = "0.6.0"
optional = true
@@ -66,12 +75,14 @@
[features]
alloc = []
-default = ["std", "fork", "timeout", "bit-set"]
+atomic64bit = []
+break-dead-code = []
+default = ["std", "fork", "timeout", "bit-set", "break-dead-code"]
+default-code-coverage = ["std", "fork", "timeout", "bit-set"]
fork = ["std", "rusty-fork", "tempfile"]
-nightly = ["lazy_static/spin_no_std"]
-std = ["rand/std", "byteorder/std", "quick-error", "regex-syntax", "num-traits/std"]
+std = ["rand/std", "byteorder/std", "lazy_static", "quick-error", "regex-syntax", "num-traits/std"]
timeout = ["fork", "rusty-fork/timeout"]
-unstable = ["rand/i128_support"]
+unstable = []
[badges.appveyor]
branch = "master"
repository = "AltSysrq/proptest"
diff --git a/third_party/rust_crates/vendor/proptest/README.md b/third_party/rust_crates/vendor/proptest/README.md
index 53de6c6..3a66208bb 100644
--- a/third_party/rust_crates/vendor/proptest/README.md
+++ b/third_party/rust_crates/vendor/proptest/README.md
@@ -4,6 +4,8 @@
[](https://ci.appveyor.com/project/AltSysrq/proptest/branch/master)
[](https://crates.io/crates/proptest)
+## Introduction
+
Proptest is a property testing framework (i.e., the QuickCheck family)
inspired by the [Hypothesis](http://hypothesis.works/) framework for
Python. It allows to test that certain properties of your code hold for
@@ -12,12 +14,7 @@
and shrinking is defined on a per-value basis instead of per-type, which
makes it more flexible and simplifies composition.
-If you have dependencies which provide QuickCheck `Arbitrary`
-implementations, see also the related
-[`proptest-quickcheck-interop`](https://crates.io/crates/proptest-quickcheck-interop)
-crates which enables reusing those implementations with proptest.
-
-## Status of this crate
+### Status of this crate
The majority of the functionality offered by proptest is in active use and
is known to work well.
@@ -29,7 +26,7 @@
See the [changelog](https://github.com/AltSysrq/proptest/blob/master/CHANGELOG.md)
for a full list of substantial historical changes, breaking and otherwise.
-## Introduction
+### What is property testing?
_Property testing_ is a system of testing code by checking that certain
properties of its output or behaviour are fulfilled for all inputs. These
@@ -41,14 +38,13 @@
known edge cases, simple inputs, and inputs that were known in the past to
reveal bugs, whereas property tests will search for more complicated inputs
that cause problems.
-
## Getting Started
Let's say we want to make a function that parses dates of the form
`YYYY-MM-DD`. We're not going to worry about _validating_ the date, any
triple of integers is fine. So let's bang something out real quick.
-```rust
+```rust,no_run
fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
if 10 != s.len() { return None; }
if "-" != &s[4..5] || "-" != &s[7..8] { return None; }
@@ -66,7 +62,7 @@
It compiles, that means it works, right? Maybe not, let's add some tests.
-```rust
+```rust,ignore
#[test]
fn test_parse_date() {
assert_eq!(None, parse_date("2017-06-1"));
@@ -85,13 +81,7 @@
```toml
[dev-dependencies]
-proptest = "0.8.7"
-```
-
-and at the top of `main.rs` or `lib.rs`:
-
-```rust
-#[macro_use] extern crate proptest;
+proptest = "0.9.3"
```
Now we can add some property tests to our date parser. But how do we test
@@ -101,11 +91,14 @@
simpler property to test: _The function should not crash._ Let's start
there.
-```rust
+```rust,ignore
+// Bring the macros and other important things into scope.
+use proptest::prelude::*;
+
proptest! {
#[test]
fn doesnt_crash(s in "\\PC*") {
- parse_date(s);
+ parse_date(&s);
}
}
```
@@ -140,7 +133,7 @@
test since it has exposed a bug not similar to what we've tested in the
past.
-```rust
+```rust,ignore
#[test]
fn test_unicode_gibberish() {
assert_eq!(None, parse_date("aAௗ0㌀0"));
@@ -154,7 +147,7 @@
In the interest of making the code changes as small as possible, we'll just
check that the string is ASCII and reject anything that isn't.
-```rust
+```rust,no_run
fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
if 10 != s.len() { return None; }
@@ -180,13 +173,13 @@
Another property we want from our code is that it parses every valid date.
We can add another test to the `proptest!` section:
-```rust
+```rust,ignore
proptest! {
// snip...
#[test]
fn parses_all_valid_dates(s in "[0-9]{4}-[0-9]{2}-[0-9]{2}") {
- parse_date(s).unwrap();
+ parse_date(&s).unwrap();
}
}
```
@@ -204,7 +197,7 @@
reimplementing the date parser in the test! Instead, we start from the
expected output, generate the string, and check that it gets parsed back.
-```rust
+```rust,ignore
proptest! {
// snip...
@@ -240,7 +233,7 @@
proptest did to arrive at this value. At the start of our test function,
insert
-```rust
+```rust,ignore
println!("y = {}, m = {}, d = {}", y, m, d);
```
@@ -292,10 +285,10 @@
$ git add proptest-regressions
```
-```rust
+```rust,ignore
#[test]
fn test_october_first() {
- assert_eq!(Some(0, 10, 1), parse_date("0000-10-01"));
+ assert_eq!(Some((0, 10, 1)), parse_date("0000-10-01"));
}
```
@@ -307,7 +300,7 @@
hold for `9`. In this case, that "special something" is being two digits
wide. In our code:
-```rust
+```rust,ignore
let month = &s[6..7];
```
@@ -318,10 +311,6 @@
configuration for things like the number of test cases to generate. See its
[documentation](https://altsysrq.github.io/rustdoc/proptest/latest/proptest/macro.proptest.html)
for more details.
-
-There is a more in-depth tutorial
-[in the crate documentation](https://altsysrq.github.io/rustdoc/proptest/latest/proptest/#in-depth-tutorial).
-
## Differences between QuickCheck and Proptest
QuickCheck and Proptest are similar in many ways: both generate random
@@ -332,28 +321,28 @@
based on type alone, whereas Proptest uses explicit `Strategy` objects. The
QuickCheck approach has a lot of disadvantages in comparison:
-- QuickCheck can only define one generator and shrinker per type. If you
-need a custom generation strategy, you need to wrap it in a newtype and
-implement traits on that by hand. In Proptest, you can define arbitrarily
-many different strategies for the same type, and there are plenty built-in.
+- QuickCheck can only define one generator and shrinker per type. If you need a
+ custom generation strategy, you need to wrap it in a newtype and implement
+ traits on that by hand. In Proptest, you can define arbitrarily many
+ different strategies for the same type, and there are plenty built-in.
-- For the same reason, QuickCheck has a single "size" configuration that
-tries to define the range of values generated. If you need an integer
-between 0 and 100 and another between 0 and 1000, you probably need to do
-another newtype. In Proptest, you can directly just express that you want a
-`0..100` integer and a `0..1000` integer.
+- For the same reason, QuickCheck has a single "size" configuration that tries
+ to define the range of values generated. If you need an integer between 0 and
+ 100 and another between 0 and 1000, you probably need to do another newtype.
+ In Proptest, you can directly just express that you want a `0..100` integer
+ and a `0..1000` integer.
- Types in QuickCheck are not easily composable. Defining `Arbitrary` and
-`Shrink` for a new struct which is simply produced by the composition of
-its fields requires implementing both by hand, including a bidirectional
-mapping between the struct and a tuple of its fields. In Proptest, you can
-make a tuple of the desired components and then `prop_map` it into the
-desired form. Shrinking happens automatically in terms of the input types.
+ `Shrink` for a new struct which is simply produced by the composition of its
+ fields requires implementing both by hand, including a bidirectional mapping
+ between the struct and a tuple of its fields. In Proptest, you can make a
+ tuple of the desired components and then `prop_map` it into the desired form.
+ Shrinking happens automatically in terms of the input types.
-- Because constraints on values cannot be expressed in QuickCheck,
-generation and shrinking may lead to a lot of input rejections. Strategies
-in Proptest are aware of simple constraints and do not generate or shrink
-to values that violate them.
+- Because constraints on values cannot be expressed in QuickCheck, generation
+ and shrinking may lead to a lot of input rejections. Strategies in Proptest
+ are aware of simple constraints and do not generate or shrink to values that
+ violate them.
The author of Hypothesis also has an [article on this
topic](http://hypothesis.works/articles/integrated-shrinking/).
@@ -362,11 +351,10 @@
Proptest does differently:
- Generating complex values in Proptest can be up to an order of magnitude
-slower than in QuickCheck. This is because QuickCheck performs stateless
-shrinking based on the output value, whereas Proptest must hold on to all
-the intermediate states and relationships in order for its richer shrinking
-model to work.
-
+ slower than in QuickCheck. This is because QuickCheck performs stateless
+ shrinking based on the output value, whereas Proptest must hold on to all the
+ intermediate states and relationships in order for its richer shrinking model
+ to work.
## Limitations of Property Testing
Given infinite time, property testing will eventually explore the whole
@@ -376,7 +364,6 @@
large space. For example, the following test will virtually always pass:
```rust
-#[macro_use] extern crate proptest;
use proptest::prelude::*;
proptest! {
@@ -397,122 +384,6 @@
great to fuzz a C parser, but is highly unlikely to produce anything that
makes it to a code generator.
-## Failure Persistence
-
-By default, when Proptest finds a failing test case, it _persists_ that
-failing case in a file named after the source containing the failing test,
-but in a separate directory tree rooted at `proptest-regressions`† . Later
-runs of tests will replay those test cases before generating novel cases.
-This ensures that the test will not fail on one run and then spuriously
-pass on the next, and also exposes similar tests to the same
-known-problematic input.
-
-(† If you do not have an obvious source directory, you may instead find
-files next to the source files, with a different extension.)
-
-It is recommended to check these files in to your source control so that
-other test runners (e.g., collaborators or a CI system) also replay these
-cases.
-
-Note that, by default, all tests in the same crate will share that one
-persistence file. If you have a very large number of tests, it may be
-desirable to separate them into smaller groups so the number of extra test
-cases that get run is reduced. This can be done by adjusting the
-`failure_persistence` flag on `Config`.
-
-There are two ways this persistence could theoretically be done.
-
-The immediately obvious option is to persist a representation of the value
-itself, for example by using Serde. While this has some advantages,
-particularly being resistant to changes like tweaking the input strategy,
-it also has a lot of problems. Most importantly, there is no way to
-determine whether any given value is actually within the domain of the
-strategy that produces it. Thus, some (likely extremely fragile) mechanism
-to ensure that the strategy that produced the value exactly matches the one
-in use in a test case would be required.
-
-The other option is to store the _seed_ that was used to produce the
-failing test case. This approach requires no support from the strategy or
-the produced value. If the strategy in use differs from the one used to
-produce failing case that was persisted, the seed may or may not produce
-the problematic value, but nonetheless produces a valid value. Due to these
-advantages, this is the approach Proptest uses.
-
-## Forking and Timeouts
-
-By default, proptest tests are run in-process and are allowed to run for
-however long it takes them. This is resource-efficient and produces the
-nicest test output, and for many use cases is sufficient. However, problems
-like overflowing the stack, aborting the process, or getting stuck in an
-infinite will simply break the entire test process and prevent proptest
-from determining a minimal reproducible case.
-
-As of version 0.7.1, proptest has optional "fork" and "timeout" features
-(both enabled by default), which make it possible to run your test cases in
-a subprocess and limit how long they may run. This is generally slower,
-may make using a debugger more difficult, and makes test output harder to
-interpret, but allows proptest to find and minimise test cases for these
-situations as well.
-
-To enable these features, simply set the `fork` and/or `timeout` fields on
-the `Config`. (Setting `timeout` implies `fork`.)
-
-Here is a simple example of using both features:
-
-```rust
-#[macro_use] extern crate proptest;
-use proptest::prelude::*;
-
-// The worst possible way to calculate Fibonacci numbers
-fn fib(n: u64) -> u64 {
- if n <= 1 {
- n
- } else {
- fib(n - 1) + fib(n - 2)
- }
-}
-
-proptest! {
- #![proptest_config(ProptestConfig {
- // Setting both fork and timeout is redundant since timeout implies
- // fork, but both are shown for clarity.
- fork: true,
- timeout: 1000,
- .. ProptestConfig::default()
- })]
-
- #[test]
- fn test_fib(n: u64) {
- // For large n, this will variously run for an extremely long time,
- // overflow the stack, or panic due to integer overflow.
- assert!(fib(n) >= n);
- }
-}
-```
-
-The exact value of the test failure depends heavily on the performance of
-the host system, the rust version, and compiler flags, but on the system
-where it was originally tested, it found that the maximum value that
-`fib()` could handle was 39, despite having dozens of processes dump core
-due to stack overflow or time out along the way.
-
-If you just want to run tests in subprocesses or with a timeout every now
-and then, you can do that by setting the `PROPTEST_FORK` or
-`PROPTEST_TIMEOUT` environment variables to alter the default
-configuration. For example, on Unix,
-
-```sh
-# Run all the proptest tests in subprocesses with no timeout.
-# Individual tests can still opt out by setting `fork: false` in their
-# own configuration.
-PROPTEST_FORK=true cargo test
-# Run all the proptest tests in subprocesses with a 1 second timeout.
-# Tests can still opt out or use a different timeout by setting `timeout: 0`
-# or another timeout in their own configuration.
-PROPTEST_TIMEOUT=1000 cargo test
-```
-
-
# Acknowledgements
This crate wouldn't have come into existence had it not been for the [Rust port
diff --git a/third_party/rust_crates/vendor/proptest/appveyor.yml b/third_party/rust_crates/vendor/proptest/appveyor.yml
deleted file mode 100644
index ee3b6d6..0000000
--- a/third_party/rust_crates/vendor/proptest/appveyor.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-environment:
- matrix:
- - TARGET: nightly-x86_64-pc-windows-msvc
- - TARGET: nightly-i686-pc-windows-msvc
- - TARGET: nightly-x86_64-pc-windows-gnu
- - TARGET: nightly-i686-pc-windows-gnu
- - TARGET: 1.27.0-x86_64-pc-windows-gnu
-install:
- - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-${env:TARGET}.exe" -FileName "rust-install.exe"
- - ps: .\rust-install.exe /VERYSILENT /NORESTART /DIR="C:\rust" | Out-Null
- - ps: $env:PATH="$env:PATH;C:\rust\bin"
- - rustc -vV
- - cargo -vV
-build_script:
- - cargo build
-test_script:
- - cargo test
- - cd test-persistence-location & run-tests.bat
diff --git a/third_party/rust_crates/vendor/proptest/examples/config-defaults.rs b/third_party/rust_crates/vendor/proptest/examples/config-defaults.rs
index d7552ac..8c9817a 100644
--- a/third_party/rust_crates/vendor/proptest/examples/config-defaults.rs
+++ b/third_party/rust_crates/vendor/proptest/examples/config-defaults.rs
@@ -7,8 +7,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-extern crate proptest;
-
use proptest::test_runner::Config;
fn main() {
diff --git a/third_party/rust_crates/vendor/proptest/examples/dateparser_v1.rs b/third_party/rust_crates/vendor/proptest/examples/dateparser_v1.rs
index baf54a3..9b9c78c 100644
--- a/third_party/rust_crates/vendor/proptest/examples/dateparser_v1.rs
+++ b/third_party/rust_crates/vendor/proptest/examples/dateparser_v1.rs
@@ -7,8 +7,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#[macro_use]
-extern crate proptest;
+use proptest::prelude::*;
fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
if 10 != s.len() {
@@ -33,8 +32,8 @@
// NB We omit #[test] on these functions so that main() can call them.
proptest! {
- fn doesnt_crash(ref s in "\\PC*") {
- parse_date(s);
+ fn doesnt_crash(s in "\\PC*") {
+ parse_date(&s);
}
}
diff --git a/third_party/rust_crates/vendor/proptest/examples/dateparser_v2.rs b/third_party/rust_crates/vendor/proptest/examples/dateparser_v2.rs
index 50c820b..45ec4e8 100644
--- a/third_party/rust_crates/vendor/proptest/examples/dateparser_v2.rs
+++ b/third_party/rust_crates/vendor/proptest/examples/dateparser_v2.rs
@@ -7,8 +7,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#[macro_use]
-extern crate proptest;
+use proptest::prelude::*;
fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
if 10 != s.len() {
@@ -38,12 +37,12 @@
// NB We omit #[test] on these functions so that main() can call them.
proptest! {
- fn doesnt_crash(ref s in "\\PC*") {
- parse_date(s);
+ fn doesnt_crash(s in "\\PC*") {
+ parse_date(&s);
}
- fn parses_all_valid_dates(ref s in "[0-9]{4}-[0-9]{2}-[0-9]{2}") {
- parse_date(s).unwrap();
+ fn parses_all_valid_dates(s in "[0-9]{4}-[0-9]{2}-[0-9]{2}") {
+ parse_date(&s).unwrap();
}
fn parses_date_back_to_original(y in 0u32..10_000,
diff --git a/third_party/rust_crates/vendor/proptest/examples/fib.rs b/third_party/rust_crates/vendor/proptest/examples/fib.rs
index 0e8a466..f2d4408 100644
--- a/third_party/rust_crates/vendor/proptest/examples/fib.rs
+++ b/third_party/rust_crates/vendor/proptest/examples/fib.rs
@@ -7,8 +7,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#[macro_use] extern crate proptest;
-
// This #[cfg] is only here so that CI can test building proptest with the
// timeout feature disabled. You do not need it in your code.
#[cfg(feature = "timeout")]
diff --git a/third_party/rust_crates/vendor/proptest/examples/tutorial-simplify-play.rs b/third_party/rust_crates/vendor/proptest/examples/tutorial-simplify-play.rs
index 8d1284f..fed4c1d 100644
--- a/third_party/rust_crates/vendor/proptest/examples/tutorial-simplify-play.rs
+++ b/third_party/rust_crates/vendor/proptest/examples/tutorial-simplify-play.rs
@@ -12,8 +12,6 @@
// This is *not* how proptest is normally used; it is simply used to play
// around with value generation.
-extern crate proptest;
-
use proptest::strategy::{Strategy, ValueTree};
use proptest::test_runner::TestRunner;
diff --git a/third_party/rust_crates/vendor/proptest/examples/tutorial-strategy-play.rs b/third_party/rust_crates/vendor/proptest/examples/tutorial-strategy-play.rs
index 22b4e2c..52b2930 100644
--- a/third_party/rust_crates/vendor/proptest/examples/tutorial-strategy-play.rs
+++ b/third_party/rust_crates/vendor/proptest/examples/tutorial-strategy-play.rs
@@ -12,8 +12,6 @@
// This is *not* how proptest is normally used; it is simply used to play
// around with value generation.
-extern crate proptest;
-
use proptest::strategy::{Strategy, ValueTree};
use proptest::test_runner::TestRunner;
diff --git a/third_party/rust_crates/vendor/proptest/gen-readme.sh b/third_party/rust_crates/vendor/proptest/gen-readme.sh
deleted file mode 100755
index 054ed37d..0000000
--- a/third_party/rust_crates/vendor/proptest/gen-readme.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#! /bin/sh
-
-# Generate `README.md` from the crate documentation, plus some extra stuff.
-
-cat readme-prologue.md >README.md
-<src/lib.rs grep -E '^//!' | grep -v NOREADME | \
- sed -E 's:^//! ?::g;/```rust/s/,.*//;/ENDREADME/,$d;s/&H2/##/g;s/&NL//g' >>README.md
-cat readme-antelogue.md >>README.md
diff --git a/third_party/rust_crates/vendor/proptest/proptest-regressions/test_runner/rng.txt b/third_party/rust_crates/vendor/proptest/proptest-regressions/test_runner/rng.txt
new file mode 100644
index 0000000..939267e
--- /dev/null
+++ b/third_party/rust_crates/vendor/proptest/proptest-regressions/test_runner/rng.txt
@@ -0,0 +1,8 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc c07e85d05e65b51ff76176b8f3fb2ef318b8590d6e39cc1013d36c32a8f4589c # shrinks to seed = PassThrough(None, [4, 236, 242, 152, 113, 207, 60, 224, 102, 251, 83, 252, 39, 193, 248, 85, 34, 142, 244, 163, 10, 16, 16, 192, 82, 17, 210, 144, 251, 173, 175, 190, 94, 56, 129, 205, 214, 88, 168, 187, 100, 86, 98, 190, 160, 60, 58, 9, 194, 66, 118, 50, 208, 64, 157, 161, 246, 106, 14, 132, 132, 230, 125, 27, 216, 105, 121, 193, 171, 131, 10, 150, 189, 175, 177, 32, 34, 49, 77, 66, 36, 161, 178, 39, 171, 250, 156, 163, 160, 99, 200, 159, 134, 242, 43, 88, 68, 4, 156, 123, 104, 6, 74, 167, 60, 215, 9, 203, 60, 6, 45, 186, 252, 196, 64, 61, 135, 132, 144, 191, 162, 134, 157, 159, 78, 218, 161, 28, 100, 69, 23, 82, 115, 252, 183, 2, 217, 137, 145, 224, 73, 161, 28, 230, 88, 226, 209, 34, 86, 183, 152, 36, 233, 174, 24, 169, 151, 14, 106, 246, 27, 10, 200, 151, 179, 142, 37, 239, 75, 159, 167, 78, 110, 14, 241, 163, 48, 79, 194, 33, 166, 173, 46, 22, 251, 62, 115, 194, 146, 154, 35, 59, 20, 242, 161, 101, 33, 216, 83, 55, 52, 209, 249, 51, 24, 187, 58, 154, 166, 152, 1, 55, 149, 11, 158, 239, 3, 198, 142, 105, 139, 247, 245, 37, 193, 163, 180, 254, 64, 133, 177, 110, 26, 173, 72, 237, 19, 223, 69, 120, 8, 55, 85, 216, 84, 21, 197, 30, 109, 126, 144, 76, 215, 98, 204, 33, 84, 103, 33, 7, 172, 179, 119, 247, 197, 153, 191, 136, 245, 249, 27, 184, 29, 189, 60, 28, 77, 193, 144, 10, 71, 18, 68, 130, 218, 29, 188, 4, 233, 16, 143, 215, 52, 56, 71, 70, 146, 2, 130, 119, 179, 150, 79, 109, 139, 138, 3, 57, 109, 144, 160, 179, 117, 208, 53, 241, 226, 52, 141, 116, 6, 47, 248, 76, 10, 209, 255, 205, 145, 127, 215, 201, 43, 28, 51, 166, 177, 193, 232, 6, 241, 205, 53, 104, 133, 202, 1, 203, 146, 151, 154, 168, 248, 63, 139, 186, 211, 142, 206, 122, 222, 63, 134, 227, 12, 84, 197, 45, 41, 155, 211, 165, 118, 10, 255, 117, 238, 57, 133, 157, 121, 240, 67, 255, 103, 116, 94, 28, 4, 224, 24, 120, 161, 59, 83, 103, 182, 227, 176, 89, 194, 131, 22, 251, 59, 131, 117, 243, 123, 141, 3, 181, 191, 214, 31, 41, 227, 27, 169, 168, 132, 207, 167, 169, 1, 201, 191, 186, 249, 16, 32, 237, 199, 122, 153, 151, 1, 254, 69, 169, 137, 244, 84, 214, 31, 217, 26, 20, 197, 15, 179, 74, 149, 219, 45, 145, 245, 239, 215, 172, 249, 144, 79, 76, 10, 27, 21, 168, 160, 248, 178, 22, 251, 204, 12, 18, 197, 226, 11, 26, 2, 128, 86, 85, 92, 164, 59, 253, 75, 84, 122, 229, 45, 130, 39, 162, 35, 84, 126, 250, 164, 21, 55, 73, 149, 82, 83, 26, 81, 147, 231, 19, 244, 159, 23, 51, 215, 81, 93, 171, 27, 246, 234, 230, 107, 47, 47, 201, 23, 161, 194, 213, 146, 164, 91, 174, 151, 148, 113, 147, 148, 206, 224, 17, 167, 139, 70, 240, 60, 37, 102, 17, 176, 60, 213, 42, 22, 123, 50, 44, 87, 244, 193, 141, 53, 212, 228, 239, 212, 55, 146, 192, 157, 250, 248, 46, 73, 98, 173, 145, 249, 51, 10, 154, 154, 179, 95, 140, 184, 96, 162, 96, 35, 147, 243, 187, 255, 5, 191, 185, 182, 216, 69, 24, 45, 45, 160, 232, 83, 180, 185, 103, 10, 140, 86, 206, 104, 99, 70, 200, 201, 13, 235, 54, 136, 23, 142, 220, 16, 231, 158, 243, 54, 167, 45, 125, 51, 116, 210, 246, 216, 89, 30, 218, 108, 214, 29, 85, 95, 0, 226, 11, 90, 196, 186, 48, 188, 9, 8, 212, 213, 35, 231, 182, 78, 105, 239, 231, 22, 191, 166, 210, 227, 134, 79, 144, 17, 154, 60, 179, 135, 211, 104, 109, 75, 213, 109, 182, 55, 82, 172, 20, 249, 73, 0, 169, 162, 37, 1, 92, 25, 141, 25, 140, 118, 77, 221, 54, 7, 224, 224, 115, 107, 41, 20, 37, 35, 102, 243, 206, 200, 98, 176, 118, 140, 23, 159, 127, 90, 82, 174, 21, 34, 72, 25, 236, 241, 68, 65, 116, 41, 67, 153, 211, 73, 120, 113, 189, 125, 158, 72, 201, 200, 201, 207, 253, 75, 246, 120, 146, 187, 9, 24, 164, 57, 160, 127, 178, 147, 239, 155, 188, 160, 179, 191, 241, 245, 31, 245, 57, 18, 64, 246, 44, 150, 32, 99, 79, 124, 188, 147, 122, 104, 30, 71, 4, 232, 91, 224, 94, 230, 207, 165, 227, 85, 166, 82, 25, 149, 95, 168, 100, 58, 104, 173, 157, 245, 254, 33, 187, 7, 174, 61, 216, 80, 64, 119, 245, 123, 231, 208, 248, 184, 224, 196, 3, 18, 37, 101, 88, 224, 209, 42, 122, 55, 251, 240, 253, 210, 191, 243, 109, 151, 228, 109, 79, 66, 182, 48, 169, 163, 109, 206, 52, 90, 137, 254, 111, 225, 58, 141, 118, 247, 50, 141, 98, 87, 123, 213, 242, 23, 177, 128, 100, 144, 167, 156, 96, 59, 0, 0, 241, 53, 94, 45, 2, 252, 145, 17, 35, 16, 10, 146, 94, 180, 207, 67, 23, 213, 31, 121, 169, 196, 16, 211, 189, 153, 199, 47, 150, 109, 17, 55, 228, 237, 117, 59, 153, 175, 130, 73, 241, 85, 41, 165, 225, 83, 223, 69, 213, 183, 118, 41, 239, 172, 31, 169, 222, 211, 181, 87, 183, 34, 34, 171, 97, 115, 180, 177, 249, 126, 56, 213, 205, 241, 250, 136, 43, 84, 211, 214, 33, 185, 5, 177, 30, 152, 135, 35, 232, 194, 34, 252, 93, 192, 233, 181, 42, 239, 113, 58, 67, 132, 197, 160, 179, 202, 51, 146, 240, 194, 201, 34, 174, 251, 155, 59, 219, 89, 74, 3, 164, 175, 88, 40, 191, 11, 149, 16, 35, 16, 147, 53, 127, 5, 158, 248, 45, 24, 127, 235, 73, 29, 244, 65, 131, 217, 157, 88, 115, 152, 217, 58, 209, 135, 36, 203, 20, 211, 123, 156, 114, 110, 71, 0, 38, 123, 34, 179, 135, 6, 50, 44, 165, 162, 209, 77, 10, 32, 75, 185, 134, 220, 195, 164, 212, 70, 209, 241, 188, 67, 168, 245, 198, 243, 79, 3, 246, 218, 43, 35, 249, 217, 181, 128, 165, 86, 101, 82, 241, 230, 250, 246, 170, 76, 245, 126, 91, 116, 92, 240, 42, 40, 42, 190, 71, 158, 155, 199, 209, 223, 138, 195, 87, 175, 145, 78, 83, 160, 206, 165, 188, 64, 22, 86, 219, 50, 230, 180, 132, 233, 111, 251, 101, 141, 228, 218, 101, 72, 187, 172, 59, 126, 115, 175, 239, 135, 188, 137, 8, 152, 199, 23, 125, 164, 0, 24, 252, 158, 102, 229, 9, 207, 37, 235, 167, 122, 48, 175, 153, 98, 235, 26, 96, 66, 217, 180, 136, 30, 78, 138, 47, 13, 5, 12, 82, 151, 224, 20, 106, 57, 104, 243, 175, 37, 231, 111, 74, 51, 176, 236, 236, 128, 12, 134, 196, 18, 9, 79, 2, 146, 235, 238, 72, 165, 164, 201, 190, 212, 53, 240, 131, 39, 178, 229, 59, 10, 171, 229, 245, 222, 197, 237, 233, 132, 161, 116, 39, 193, 207, 222, 211, 209, 232, 46, 202, 55, 196, 7, 202, 67, 105, 211, 84, 138, 118, 145, 194, 132, 107, 217, 116, 136, 147, 190, 39, 243, 81, 104, 162, 78, 123, 174, 73, 181, 220, 166, 40, 133, 189, 64, 202, 129, 83, 251, 4, 13, 122, 250, 172, 152, 175, 13, 214, 253, 175, 36, 160, 171, 239, 58, 38, 66, 216, 250, 227, 0, 159, 45, 72, 82, 204, 30, 4, 18, 76, 253, 11, 170, 26, 56, 212, 101, 84, 127, 179, 197, 170, 217, 14, 63, 0, 162, 223, 215, 171, 159, 30, 82, 221, 24, 43, 60, 204, 50, 52, 1, 187, 65, 83, 206, 122, 104, 44, 126, 224, 42, 192, 211, 48, 205, 112, 70, 181, 131, 41, 76, 2, 8, 213, 127, 48, 63, 115, 243, 125, 118, 83, 97, 167, 25, 253, 61, 233, 0, 219, 244, 231, 154, 69, 135, 161, 132, 138, 2, 62, 49, 3, 162, 123, 26, 179, 222, 247, 48, 44, 196, 183, 114, 74, 159, 224, 133, 140, 86, 111, 156, 39, 225, 40, 24, 16, 215, 143, 102, 131, 59, 5, 49, 185, 202, 157, 103, 90, 49, 72, 42, 251, 183, 162, 140, 15, 40, 213, 169, 230, 236, 19, 41, 229, 79, 163, 91, 196, 176, 130, 53, 197, 182, 133, 161, 231, 57, 23, 138, 163, 46, 85, 177, 86, 45, 40, 29, 89, 72, 241, 151, 28, 109, 117, 18, 178, 52, 237, 200, 152, 255, 85, 223, 150, 167, 1, 253, 62, 153, 146, 104, 48, 45, 131, 89, 239, 204, 89, 152, 91, 32, 26, 174, 97, 82, 88, 113, 8, 208, 8, 124, 120, 236, 0, 72, 43, 252, 125, 227, 232, 13, 17, 208, 82, 242, 223, 161, 63, 33, 49, 20, 105, 38, 210, 31, 170, 37, 185, 142, 233, 23, 213, 118, 161, 128, 60, 182, 91, 247, 234, 251, 90, 58, 72, 103, 19, 158, 194, 108, 146, 225, 243, 107, 190, 19, 93, 62, 144, 128, 226, 26, 49, 4, 175, 142, 131, 212, 182, 71, 120, 160, 178, 30, 115, 190, 0, 30, 21, 165, 118, 180, 236, 11, 68, 243, 92, 38, 218, 96, 180, 41, 27, 160, 237, 101, 181, 127, 127, 144, 209, 133, 179, 121, 85, 229, 171, 19, 176, 227, 85, 131, 179, 102, 78, 203, 168, 126, 189, 217, 188, 133, 81, 195, 177, 248, 232, 201, 206, 32, 68, 4, 139, 136, 92, 29, 44, 235, 134, 246, 94, 97, 140, 245, 59, 45, 198, 41, 181, 255, 124, 254, 57, 210, 198, 166, 141, 119, 85, 114, 246, 182, 69, 44, 209, 237, 255, 8, 49, 91, 60, 24, 195, 237, 102, 178, 154, 60, 4, 11, 35, 125, 38, 243, 168, 226, 231, 113, 173, 148, 212, 124, 162, 167, 213, 168, 22, 141, 124, 72, 5, 195, 160, 249, 3, 156, 239, 104, 10, 248, 52, 118, 3, 73, 165, 160, 35, 141, 67, 31, 185, 178, 212, 94, 1, 210, 62, 77, 102, 36, 8, 106, 39, 228, 132, 208, 187, 68, 62, 209, 116, 103, 83, 71, 160, 218, 189, 117, 222, 207, 95, 130, 174, 143, 188, 102, 199, 210, 134, 192, 138, 160, 46, 116, 55, 220, 109, 36, 9, 156, 148, 226, 72, 113, 16, 173, 156, 176, 209, 29, 185, 234, 59, 50, 248, 250, 88, 197, 23, 193, 218, 119, 113, 50, 165, 190, 123, 177, 41, 92, 53, 28, 147, 170, 12, 4, 93, 85, 119, 255, 17, 59, 90, 153, 68, 25, 152, 6, 52, 165, 175, 189, 100, 56, 73, 146, 50, 203, 206, 174, 209, 104, 156, 214, 126, 224, 4, 191, 147, 182, 52, 1, 189, 105, 250, 19, 43, 7, 154, 186, 70, 114, 115, 225, 250, 171, 157, 61, 166, 59, 183, 89, 147, 6, 166, 91, 127, 182, 243, 0, 95, 156, 187, 48, 157, 188, 211, 169, 85, 253, 60, 158, 9, 95, 245, 173, 20, 35, 11, 13, 49, 0, 8, 30, 234, 175, 89, 183, 153, 186, 171, 200, 107, 237, 14, 128, 142, 223, 69, 36, 237, 161, 60, 159, 7, 5, 221, 13, 232, 155, 78, 146, 213, 223, 14, 232, 253, 65, 210, 23, 26, 230, 123, 163, 228, 54, 222, 198, 191, 13, 10, 68, 12, 222, 17, 81, 202, 106, 62, 82, 98, 180, 118, 37, 61, 240, 214, 185, 142, 220, 132, 75, 187, 32, 36, 244, 121, 161, 180, 231, 216, 254, 120, 83, 212, 255, 88, 224, 63, 103, 77, 117, 144, 20, 46, 120, 115, 140, 147, 78, 228, 62, 222, 238, 172, 107, 18, 73, 3, 118, 251, 127, 246, 10, 88, 91, 63, 246, 43, 17, 144, 238, 67, 102, 120, 173, 89, 94, 209, 15, 201, 70, 185])
+cc ea20181bc161c5c2b5a2a9f4a684a8afc64b7c4e78242355f117f4bd2d387a3f # shrinks to seed = PassThrough(None, [])
diff --git a/third_party/rust_crates/vendor/proptest/readme-antelogue.md b/third_party/rust_crates/vendor/proptest/readme-antelogue.md
deleted file mode 100644
index 774dff1..0000000
--- a/third_party/rust_crates/vendor/proptest/readme-antelogue.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-# Acknowledgements
-
-This crate wouldn't have come into existence had it not been for the [Rust port
-of QuickCheck](https://github.com/burntsushi/quickcheck) and the
-[`regex_generate`](https://github.com/CryptArchy/regex_generate) crate which
-gave wonderful examples of what is possible.
-
-## Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
diff --git a/third_party/rust_crates/vendor/proptest/readme-prologue.md b/third_party/rust_crates/vendor/proptest/readme-prologue.md
deleted file mode 100644
index 39aa17f..0000000
--- a/third_party/rust_crates/vendor/proptest/readme-prologue.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# Proptest
-
-[](https://travis-ci.org/AltSysrq/proptest)
-[](https://ci.appveyor.com/project/AltSysrq/proptest/branch/master)
-[](https://crates.io/crates/proptest)
-
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/alloc.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/alloc.rs
index bb4adc2..74b5b99 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/alloc.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/alloc.rs
@@ -13,19 +13,19 @@
use core::ops::Range;
use core::usize;
-multiplex_alloc!(alloc::alloc, ::std::alloc);
+multiplex_alloc!(::alloc::alloc, ::std::alloc);
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
-arbitrary!(alloc::CannotReallocInPlace; alloc::CannotReallocInPlace);
-arbitrary!(alloc::Global; alloc::Global);
+arbitrary!(self::alloc::CannotReallocInPlace; self::alloc::CannotReallocInPlace);
+arbitrary!(self::alloc::Global; self::alloc::Global);
// Not Debug.
//lazy_just!(System, || System);
-arbitrary!(alloc::Layout, SFnPtrMap<(Range<u8>, StrategyFor<usize>), Self>;
+arbitrary!(self::alloc::Layout, SFnPtrMap<(Range<u8>, StrategyFor<usize>), Self>;
// 1. align must be a power of two and <= (1 << 31):
// 2. "when rounded up to the nearest multiple of align, must not overflow".
static_map((0u8..32u8, any::<usize>()), |(align_power, size)| {
@@ -33,11 +33,11 @@
let max_size = 0usize.wrapping_sub(align);
// Not quite a uniform distribution due to clamping,
// but probably good enough
- alloc::Layout::from_size_align(cmp::min(max_size, size), align).unwrap()
+ self::alloc::Layout::from_size_align(cmp::min(max_size, size), align).unwrap()
})
);
-arbitrary!(alloc::AllocErr, Just<Self>; Just(alloc::AllocErr));
+arbitrary!(self::alloc::AllocErr, Just<Self>; Just(self::alloc::AllocErr));
/* 2018-07-28 CollectionAllocErr is not currently available outside of using
* the `alloc` crate, which would require a different nightly feature. For now,
* disable.
@@ -48,9 +48,11 @@
#[cfg(test)]
mod test {
+ multiplex_alloc!(::alloc::alloc, ::std::alloc);
+
no_panic_test!(
- layout => alloc::Layout,
- alloc_err => alloc::AllocErr
+ layout => self::alloc::Layout,
+ alloc_err => self::alloc::AllocErr
//collection_alloc_err => alloc::collections::CollectionAllocErr
);
}
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/borrow.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/borrow.rs
index 8c1c363..347ab51 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/borrow.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/borrow.rs
@@ -10,11 +10,11 @@
//! Arbitrary implementations for std::borrow.
use core::borrow::Borrow;
-use std_facade::{ToOwned, Cow};
-use std_facade::fmt;
+use crate::std_facade::{ToOwned, Cow};
+use crate::std_facade::fmt;
-use strategy::statics::static_map;
-use arbitrary::{any_with, SMapped, Arbitrary};
+use crate::strategy::statics::static_map;
+use crate::arbitrary::{any_with, SMapped, Arbitrary};
arbitrary!(
[A: Arbitrary + Borrow<B>, B: ToOwned<Owned = A> + fmt::Debug]
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/boxed.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/boxed.rs
index 01463d8..2223625 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/boxed.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/boxed.rs
@@ -9,7 +9,7 @@
//! Arbitrary implementations for `std::boxed`.
-use std_facade::Box;
+use crate::std_facade::Box;
wrap_from!(Box);
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/char.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/char.rs
index 6cda3b6..4bf6315 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/char.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/char.rs
@@ -12,9 +12,9 @@
use core::char::*;
use core::iter::once;
use core::ops::Range;
-use std_facade::Vec;
+use crate::std_facade::Vec;
-use collection::vec;
+use crate::collection::vec;
multiplex_alloc! {
core::char::DecodeUtf16, std::char::DecodeUtf16,
@@ -24,9 +24,9 @@
const VEC_MAX: usize = ::core::u16::MAX as usize;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
macro_rules! impl_wrap_char {
($type: ty, $mapper: expr) => {
@@ -43,6 +43,7 @@
#[cfg(feature = "unstable")]
impl_wrap_char!(ToUppercase, char::to_uppercase);
+#[cfg(feature = "break-dead-code")]
arbitrary!(DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter>,
SMapped<Vec<u16>, Self>;
static_map(vec(any::<u16>(), ..VEC_MAX), decode_utf16)
@@ -71,10 +72,14 @@
escape_default => EscapeDefault,
escape_unicode => EscapeUnicode,
parse_char_error => ParseCharError,
- decode_utf16 => DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter>,
decode_utf16_error => DecodeUtf16Error
);
+ #[cfg(feature = "break-dead-code")]
+ no_panic_test!(
+ decode_utf16 => DecodeUtf16<<Vec<u16> as IntoIterator>::IntoIter>
+ );
+
#[cfg(feature = "unstable")]
no_panic_test!(
to_lowercase => ToLowercase,
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/collections.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/collections.rs
index 904fd02..1f755d1 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/collections.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/collections.rs
@@ -17,18 +17,18 @@
use core::ops::{RangeInclusive, Bound};
use core::hash::Hash;
-use std_facade::{
+use crate::std_facade::{
fmt, Box, Rc, Arc, Vec, vec, BTreeMap, BTreeSet, btree_map, btree_set,
BinaryHeap, binary_heap, VecDeque, vec_deque, LinkedList, linked_list,
};
#[cfg(feature = "std")]
-use std_facade::{hash_map, HashMap, hash_set, HashSet};
+use crate::std_facade::{hash_map, HashMap, hash_set, HashSet};
-use strategy::*;
-use strategy::statics::static_map;
-use collection::*;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::collection::*;
+use crate::arbitrary::*;
//==============================================================================
// Macros:
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/hash.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/hash.rs
index 0f2aadf..da8ffe2 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/hash.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/hash.rs
@@ -11,7 +11,7 @@
use core::hash::{BuildHasherDefault, Hasher};
#[cfg(feature = "std")]
-use std_facade::hash_map::{DefaultHasher, RandomState};
+use crate::std_facade::hash_map::{DefaultHasher, RandomState};
// NOTE: don't impl for std::hash::SipHasher.. since deprecated!
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/ops.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/ops.rs
index 0caffd8..02ac929 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/ops.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/ops.rs
@@ -10,11 +10,11 @@
//! Arbitrary implementations for `std::ops`.
use core::ops::*;
-use std_facade::Arc;
+use crate::std_facade::Arc;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
arbitrary!(RangeFull; ..);
wrap_ctor!(RangeFrom, |a| a..);
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/rc.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/rc.rs
index 506f55f..1ddb6aa 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/rc.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/rc.rs
@@ -9,7 +9,7 @@
//! Arbitrary implementations for `std::rc`.
-use std_facade::Rc;
+use crate::std_facade::Rc;
// Weak would always give None on upgrade since there's no owned Rc.
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/str.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/str.rs
index 7a22efe..85271e5 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/str.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/str.rs
@@ -11,11 +11,11 @@
use core::iter::repeat;
use core::str::{ParseBoolError, Utf8Error, from_utf8};
-use std_facade::Vec;
+use crate::std_facade::Vec;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
arbitrary!(ParseBoolError; "".parse::<bool>().unwrap_err());
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/sync.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/sync.rs
index 2c47995..eed4ee3 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/sync.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_alloc/sync.rs
@@ -10,11 +10,11 @@
//! Arbitrary implementations for `std::sync`.
use core::sync::atomic::*;
-use std_facade::Arc;
+use crate::std_facade::Arc;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
wrap_from!(Arc);
@@ -30,8 +30,11 @@
atomic!(AtomicBool, bool; AtomicIsize, isize; AtomicUsize, usize);
#[cfg(feature = "unstable")]
-atomic!(AtomicI8, i8; AtomicI16, i16; AtomicI32, i32; AtomicI64, i64;
- AtomicU8, u8; AtomicU16, u16; AtomicU32, u32; AtomicU64, u64);
+atomic!(AtomicI8, i8; AtomicI16, i16; AtomicI32, i32;
+ AtomicU8, u8; AtomicU16, u16; AtomicU32, u32);
+
+#[cfg(all(feature = "unstable", feature = "atomic64bit"))]
+atomic!(AtomicI64, i64; AtomicU64, u64);
arbitrary!(Ordering,
TupleUnion<(W<Just<Self>>, W<Just<Self>>, W<Just<Self>>,
@@ -60,10 +63,14 @@
atomic_i8 => AtomicI8,
atomic_i16 => AtomicI16,
atomic_i32 => AtomicI32,
- atomic_i64 => AtomicI64,
atomic_u8 => AtomicU8,
atomic_u16 => AtomicU16,
- atomic_u32 => AtomicU32,
+ atomic_u32 => AtomicU32
+ );
+
+ #[cfg(all(feature = "unstable", feature = "atomic64bit"))]
+ no_panic_test!(
+ atomic_i64 => AtomicI64,
atomic_u64 => AtomicU64
);
}
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/ascii.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/ascii.rs
index 8176841..f5239fbe 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/ascii.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/ascii.rs
@@ -11,8 +11,8 @@
use core::ascii::{EscapeDefault, escape_default};
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
arbitrary!(EscapeDefault, SMapped<u8, Self>;
static_map(any::<u8>(), escape_default));
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/cmp.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/cmp.rs
index 7db338b..4d7c03e 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/cmp.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/cmp.rs
@@ -11,7 +11,7 @@
use core::cmp::{Reverse, Ordering};
-use strategy::{Just, TupleUnion, W};
+use crate::strategy::{Just, TupleUnion, W};
wrap_ctor!(Reverse, Reverse);
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/iter.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/iter.rs
index bbb980d..37ce988 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/iter.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/iter.rs
@@ -13,9 +13,9 @@
use core::iter::*;
use core::iter::Fuse;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
// TODO: Filter, FilterMap, FlatMap, Map, Inspect, Scan, SkipWhile
// Might be possible with CoArbitrary
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/mem.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/mem.rs
index adafc7b..624ee3e 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/mem.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/mem.rs
@@ -11,8 +11,8 @@
use core::mem::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
arbitrary!([A: Arbitrary] Discriminant<A>,
SMapped<A, Self>, A::Parameters;
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/num.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/num.rs
index 53a6e4f..e5065f7 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/num.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/num.rs
@@ -11,7 +11,7 @@
use core::num::*;
-use strategy::*;
+use crate::strategy::*;
arbitrary!(ParseFloatError; "".parse::<f32>().unwrap_err());
arbitrary!(ParseIntError; "".parse::<u32>().unwrap_err());
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/option.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/option.rs
index 63ccc3e..82b65f2 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/option.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/option.rs
@@ -11,12 +11,12 @@
use core::option as opt;
use core::ops::RangeInclusive;
-use std_facade::string;
+use crate::std_facade::string;
-use option::{weighted, OptionStrategy, Probability};
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::option::{weighted, OptionStrategy, Probability};
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
arbitrary!(Probability, MapInto<RangeInclusive<f64>, Self>;
(0.0..=1.0).prop_map_into()
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/result.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/result.rs
index aa9be84..66c8be5 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/result.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_core/result.rs
@@ -11,12 +11,12 @@
use core::fmt;
use core::result::IntoIter;
-use std_facade::string;
+use crate::std_facade::string;
-use strategy::*;
-use strategy::statics::static_map;
-use result::*;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::result::*;
+use crate::arbitrary::*;
// These are Result with uninhabited type in some variant:
arbitrary!([A: Arbitrary] Result<A, string::ParseError>,
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/env.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/env.rs
index 24b8686..f164b0b 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/env.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/env.rs
@@ -13,9 +13,9 @@
use std::iter::once;
use std::ffi::OsString;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
// FIXME: SplitPaths when lifetimes in strategies are possible.
@@ -68,45 +68,50 @@
buf[p] = (buf[p] & !force_bits_mask) | force_bits_value;
}
-/// Generates the set of `WTF-16 \ UTF-16` and makes
-/// an `OsString` that is not a valid String from it.
-#[cfg(target_os = "windows")]
-fn osstring_invalid_string() -> impl Strategy<Value = OsString> {
- use std::os::windows::ffi::OsStringExt;
- let size = 1..::std::u16::MAX as usize;
- let vec_gen = ::collection::vec(..::std::u16::MAX, size.clone());
- (size, vec_gen).prop_map(|(p, mut sbuf)| {
- // Not quite a uniform distribution due to clamping,
- // but probably good enough
- let p = ::std::cmp::min(p, sbuf.len() - 1);
- make_utf16_invalid(&mut sbuf, p);
- OsString::from_wide(sbuf.as_slice()).into_string().unwrap_err()
- })
-}
+#[cfg(not(target_arch = "wasm32"))]
+mod var_error {
+ use super::*;
-#[cfg(not(target_os = "windows"))]
-fn osstring_invalid_string() -> impl Strategy<Value = OsString> {
- use std::os::unix::ffi::OsStringExt;
- use arbitrary::_std::string::not_utf8_bytes;
- static_map(not_utf8_bytes(true), OsString::from_vec)
-}
+ /// Generates the set of `WTF-16 \ UTF-16` and makes
+ /// an `OsString` that is not a valid String from it.
+ #[cfg(target_os = "windows")]
+ fn osstring_invalid_string() -> impl Strategy<Value = OsString> {
+ use std::os::windows::ffi::OsStringExt;
+ let size = 1..::std::u16::MAX as usize;
+ let vec_gen = crate::collection::vec(..::std::u16::MAX, size.clone());
+ (size, vec_gen).prop_map(|(p, mut sbuf)| {
+ // Not quite a uniform distribution due to clamping,
+ // but probably good enough
+ let p = ::std::cmp::min(p, sbuf.len() - 1);
+ make_utf16_invalid(&mut sbuf, p);
+ OsString::from_wide(sbuf.as_slice()).into_string().unwrap_err()
+ })
+ }
-arbitrary!(VarError,
- TupleUnion<(
- W<Just<Self>>,
- W<SFnPtrMap<BoxedStrategy<OsString>, Self>>
- )>;
- prop_oneof![
- Just(VarError::NotPresent),
- static_map(osstring_invalid_string().boxed(), VarError::NotUnicode)
- ]
-);
+ #[cfg(not(target_os = "windows"))]
+ fn osstring_invalid_string() -> impl Strategy<Value = OsString> {
+ use std::os::unix::ffi::OsStringExt;
+ use crate::arbitrary::_std::string::not_utf8_bytes;
+ static_map(not_utf8_bytes(true), OsString::from_vec)
+ }
+
+ arbitrary!(VarError,
+ TupleUnion<(
+ W<Just<Self>>,
+ W<SFnPtrMap<BoxedStrategy<OsString>, Self>>
+ )>;
+ prop_oneof![
+ Just(VarError::NotPresent),
+ static_map(osstring_invalid_string().boxed(), VarError::NotUnicode)
+ ]
+ );
+}
#[cfg(test)]
mod test {
use super::*;
- use num;
- use test_runner::Config;
+ use crate::num;
+ use crate::test_runner::Config;
no_panic_test!(
args => Args,
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/ffi.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/ffi.rs
index 6db4d9c..f2156c3 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/ffi.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/ffi.rs
@@ -11,12 +11,12 @@
use std::ffi::*;
use std::ops::RangeInclusive;
-use std_facade::{Box, Vec, String};
+use crate::std_facade::{Box, Vec, String};
-use strategy::*;
-use strategy::statics::static_map;
-use collection::*;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::collection::*;
+use crate::arbitrary::*;
use super::string::not_utf8_bytes;
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/fs.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/fs.rs
index 642fdf2..d0f2bdc 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/fs.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/fs.rs
@@ -11,8 +11,8 @@
use std::fs::{DirBuilder};
-use strategy::statics::static_map;
-use arbitrary::{any, SMapped};
+use crate::strategy::statics::static_map;
+use crate::arbitrary::{any, SMapped};
// TODO: other parts (figure out workable semantics).
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/io.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/io.rs
index b9e54763..68a4df2 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/io.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/io.rs
@@ -12,12 +12,12 @@
use std::io::*;
use std::io::ErrorKind::*;
#[cfg(test)]
-use std_facade::Vec;
-use std_facade::String;
+use crate::std_facade::Vec;
+use crate::std_facade::String;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
// TODO: IntoInnerError
// Consider: std::io::Initializer
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/net.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/net.rs
index 7cfa4db..21059b8 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/net.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/net.rs
@@ -11,9 +11,9 @@
use std::net::*;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
// TODO: Can we design a workable semantic for PBT wrt. actual networking
// connections?
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/string.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/string.rs
index 4feacbd..3cf082a 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/string.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/string.rs
@@ -13,18 +13,18 @@
use std::slice;
use std::rc::Rc;
use std::sync::Arc;
-use std_facade::{Box, Vec, String};
+use crate::std_facade::{Box, Vec, String};
multiplex_alloc! {
alloc::string::FromUtf8Error, ::std::string::FromUtf8Error,
alloc::string::FromUtf16Error, ::std::string::FromUtf16Error
}
-use strategy::*;
-use strategy::statics::static_map;
-use collection;
-use arbitrary::*;
-use string::StringParam;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::collection;
+use crate::arbitrary::*;
+use crate::string::StringParam;
impl Arbitrary for String {
type Parameters = StringParam;
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/sync.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/sync.rs
index 52b5fbe..928a4f37 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/sync.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/sync.rs
@@ -15,9 +15,9 @@
use std::thread;
use std::time::Duration;
-use strategy::*;
-use strategy::statics::static_map;
-use arbitrary::*;
+use crate::strategy::*;
+use crate::strategy::statics::static_map;
+use crate::arbitrary::*;
// OnceState can not escape Once::call_once_force.
// PoisonError depends implicitly on the lifetime on MutexGuard, etc.
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/thread.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/thread.rs
index 635b318..3ff8b51 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/thread.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/thread.rs
@@ -10,11 +10,11 @@
//! Arbitrary implementations for `std::thread`.
use std::thread::*;
-use std_facade::String;
+use crate::std_facade::String;
-use strategy::statics::static_map;
-use option::prob;
-use arbitrary::*;
+use crate::strategy::statics::static_map;
+use crate::option::prob;
+use crate::arbitrary::*;
arbitrary!(Builder, SMapped<(Option<usize>, Option<String>), Self>; {
let prob = prob(0.7);
@@ -38,7 +38,7 @@
args => {
let prob = prob(0.1);
let args2 = product_pack![
- args,
+ args,
product_pack![prob, default()],
default()
];
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/time.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/time.rs
index e423808..43ffeb9 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/time.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/_std/time.rs
@@ -12,9 +12,9 @@
use std::time::*;
use core::ops::Range;
-use strategy::statics::{self, static_map};
-use arbitrary::*;
-use num;
+use crate::strategy::statics::{self, static_map};
+use crate::arbitrary::*;
+use crate::num;
arbitrary!(Duration, SMapped<(u64, u32), Self>;
static_map(any::<(u64, u32)>(), |(a, b)| Duration::new(a, b))
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/arrays.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/arrays.rs
index 40026d2..23b200d 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/arrays.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/arrays.rs
@@ -9,8 +9,8 @@
//! Arbitrary implementations for arrays.
-use arbitrary::{Arbitrary, any_with};
-use array::UniformArrayStrategy;
+use crate::arbitrary::{Arbitrary, any_with};
+use crate::array::UniformArrayStrategy;
macro_rules! array {
($($n: expr),*) => { $(
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/functor.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/functor.rs
index 5dcedf3..8349028 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/functor.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/functor.rs
@@ -24,9 +24,9 @@
//! For these reasons, the traits here are deliberatly
//! not exported in a convenient way.
-use std_facade::fmt;
+use crate::std_facade::fmt;
-use strategy::{Strategy, BoxedStrategy};
+use crate::strategy::{Strategy, BoxedStrategy};
/// `ArbitraryF1` lets you lift a [`Strategy`] to unary
/// type constructors such as `Box`, `Vec`, and `Option`.
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/mod.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/mod.rs
index 0f875a8..49b371c 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/mod.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/mod.rs
@@ -7,13 +7,15 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! Defines the [`Arbitrary`] trait and related free functions
-//! and type aliases. See the trait for more information.
+//! Defines the `Arbitrary` trait and related free functions
+//! and type aliases.
+//!
+//! See the [`Arbitrary`] trait for more information.
//!
//! [`Arbitrary`]: trait.Arbitrary.html
-use strategy::{Map, Strategy};
-use strategy::statics;
+use crate::strategy::{Map, Strategy};
+use crate::strategy::statics;
//==============================================================================
// Trait and impls
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/primitives.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/primitives.rs
index 619c883..acf33ed 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/primitives.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/primitives.rs
@@ -9,17 +9,23 @@
//! Arbitrary implementations for primitive types.
-use bool;
-use char;
-use num::{isize, usize, f32, f64, i16, i32, i64, i8, u16, u32, u64, u8,
- u128, i128};
+use crate::bool;
+use crate::char;
+use crate::num::{
+ isize, usize, f32, f64, i16, i32, i64, i8, u16, u32, u64, u8
+};
+#[cfg(not(target_arch = "wasm32"))]
+use crate::num::{i128, u128};
arbitrary!(
bool,
- i8, i16, i32, i64, i128, isize,
- u8, u16, u32, u64, u128, usize
+ i8, i16, i32, i64, isize,
+ u8, u16, u32, u64, usize
);
+#[cfg(not(target_arch = "wasm32"))]
+arbitrary!(i128, u128);
+
// Note that for floating point types we limit the space since a lot of code
// isn't prepared for (and is not intended to be) things like NaN and infinity.
arbitrary!(f32, f32::Any; {
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/sample.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/sample.rs
index 94f8796..ee0965f 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/sample.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/sample.rs
@@ -7,8 +7,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use sample::{Index, IndexStrategy, Selector, SelectorStrategy};
-use arbitrary::Arbitrary;
+use crate::sample::{Index, IndexStrategy, Selector, SelectorStrategy};
+use crate::arbitrary::Arbitrary;
impl Arbitrary for Index {
type Parameters = ();
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/traits.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/traits.rs
index 3ac7e14..83f0214 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/traits.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/traits.rs
@@ -9,7 +9,7 @@
use core::fmt;
-use strategy::Strategy;
+use crate::strategy::Strategy;
//==============================================================================
// Arbitrary trait
@@ -137,8 +137,7 @@
/// The function can be used as:
///
/// ```rust
-/// #[macro_use] extern crate proptest;
-/// use proptest::prelude::any;
+/// use proptest::prelude::*;
///
/// proptest! {
/// fn reverse_reverse_is_identity(ref vec in any::<Vec<u32>>()) {
@@ -179,8 +178,7 @@
/// The function can be used as:
///
/// ```rust
-/// #[macro_use] extern crate proptest;
-/// use proptest::prelude::any_with;
+/// use proptest::prelude::*;
/// use proptest::collection::size_range;
///
/// proptest! {
diff --git a/third_party/rust_crates/vendor/proptest/src/arbitrary/tuples.rs b/third_party/rust_crates/vendor/proptest/src/arbitrary/tuples.rs
index 3eb4317..6c18daf 100644
--- a/third_party/rust_crates/vendor/proptest/src/arbitrary/tuples.rs
+++ b/third_party/rust_crates/vendor/proptest/src/arbitrary/tuples.rs
@@ -9,7 +9,7 @@
//! Arbitrary implementations for tuples.
-use arbitrary::{Arbitrary, any_with};
+use crate::arbitrary::{Arbitrary, any_with};
macro_rules! impl_tuple {
($($typ: ident),*) => {
diff --git a/third_party/rust_crates/vendor/proptest/src/array.rs b/third_party/rust_crates/vendor/proptest/src/array.rs
index 09ea709..9d45de1 100644
--- a/third_party/rust_crates/vendor/proptest/src/array.rs
+++ b/third_party/rust_crates/vendor/proptest/src/array.rs
@@ -20,8 +20,8 @@
use core::marker::PhantomData;
-use strategy::*;
-use test_runner::*;
+use crate::strategy::*;
+use crate::test_runner::*;
/// A `Strategy` which generates fixed-size arrays containing values drawn from
/// an inner strategy.
@@ -36,7 +36,6 @@
/// ## Example
///
/// ```
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// proptest! {
@@ -257,7 +256,7 @@
}
let input = [0..32, 0..32];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let mut cases_tested = 0;
for _ in 0..256 {
diff --git a/third_party/rust_crates/vendor/proptest/src/bits.rs b/third_party/rust_crates/vendor/proptest/src/bits.rs
index 5d85c24..35108ab 100644
--- a/third_party/rust_crates/vendor/proptest/src/bits.rs
+++ b/third_party/rust_crates/vendor/proptest/src/bits.rs
@@ -18,16 +18,16 @@
use core::marker::PhantomData;
use core::mem;
-use std_facade::{fmt, Vec};
+use crate::std_facade::{fmt, Vec};
#[cfg(feature = "bit-set")]
use bit_set::BitSet;
-use rand::{self, Rng};
+use rand::{self, Rng, seq::IteratorRandom};
-use collection::SizeRange;
-use num::sample_uniform_incl;
-use strategy::*;
-use test_runner::*;
+use crate::collection::SizeRange;
+use crate::num::sample_uniform_incl;
+use crate::strategy::*;
+use crate::test_runner::*;
/// Trait for types which can be handled with `BitSetStrategy`.
#[cfg_attr(feature="cargo-clippy", allow(len_without_is_empty))]
@@ -263,10 +263,11 @@
let mut bits = T::new_bitset(self.bits.end_excl());
let count = sample_uniform_incl(
runner, self.size.start(), self.size.end_incl());
- for bit in
- rand::seq::sample_iter(runner.rng(), self.bits.iter(), count)
- .expect("not enough bits to sample")
- {
+ if bits.len() < count {
+ panic!("not enough bits to sample");
+ }
+
+ for bit in self.bits.iter().choose_multiple(runner.rng(), count) {
bits.set(bit);
}
@@ -517,7 +518,7 @@
fn generates_values_in_mask() {
let mut accum = 0;
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = u32::masked(0xdeadbeef);
for _ in 0..1024 {
accum |= input.new_tree(&mut runner).unwrap().current();
@@ -536,7 +537,7 @@
mask.insert(0);
mask.insert(2);
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = bitset::masked(mask);
for _ in 0..32 {
let v = input.new_tree(&mut runner).unwrap().current();
@@ -555,7 +556,7 @@
let mask = vec![true, false, true, false];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = bool_vec::masked(mask);
for _ in 0..32 {
let v = input.new_tree(&mut runner).unwrap().current();
@@ -608,7 +609,7 @@
let mut seen_counts = [0; 32];
let mut seen_bits = [0; 32];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..2048 {
let value = input.new_tree(&mut runner).unwrap().current();
let count = value.count_ones() as usize;
diff --git a/third_party/rust_crates/vendor/proptest/src/bool.rs b/third_party/rust_crates/vendor/proptest/src/bool.rs
index bb8dab2..449287b 100644
--- a/third_party/rust_crates/vendor/proptest/src/bool.rs
+++ b/third_party/rust_crates/vendor/proptest/src/bool.rs
@@ -9,8 +9,8 @@
//! Strategies for generating `bool` values.
-use strategy::*;
-use test_runner::*;
+use crate::strategy::*;
+use crate::test_runner::*;
use rand::Rng;
diff --git a/third_party/rust_crates/vendor/proptest/src/char.rs b/third_party/rust_crates/vendor/proptest/src/char.rs
index 3b9ea87..1e037f5 100644
--- a/third_party/rust_crates/vendor/proptest/src/char.rs
+++ b/third_party/rust_crates/vendor/proptest/src/char.rs
@@ -18,13 +18,13 @@
//! inclusive ranges.
use core::ops::RangeInclusive;
-use std_facade::Cow;
+use crate::std_facade::Cow;
use rand::Rng;
-use num;
-use strategy::*;
-use test_runner::*;
+use crate::num;
+use crate::strategy::*;
+use crate::test_runner::*;
/// An inclusive char range from fst to snd.
type CharRange = RangeInclusive<char>;
@@ -47,8 +47,10 @@
'¥',
// No non-Unicode encoding has both ¥ and Ѩ
'Ѩ',
- // More Unicode edge-cases: BOM, replacement character, and non-BMP
- '\u{FEFF}', '\u{FFFD}', '🕴',
+ // In UTF-8, Ⱥ increases in length from 2 to 3 bytes when lowercased
+ 'Ⱥ',
+ // More Unicode edge-cases: BOM, replacement character, RTL override, and non-BMP
+ '\u{FEFF}', '\u{FFFD}', '\u{202E}', '🕴',
];
/// A default sequence of ranges used preferentially when generating random
@@ -296,45 +298,42 @@
use std::vec::Vec;
use super::*;
- use collection;
+ use crate::collection;
- #[test]
- fn stays_in_range() {
- let meta_input = collection::vec(
+ proptest! {
+ #[test]
+ fn stays_in_range(input_ranges in collection::vec(
(0..::std::char::MAX as u32,
0..::std::char::MAX as u32),
- 1..5);
- TestRunner::default().run(
- &meta_input, |input_ranges| {
- let input = ranges(Cow::Owned(input_ranges.iter().map(
- |&(lo, hi)| ::std::char::from_u32(lo).and_then(
- |lo| ::std::char::from_u32(hi).map(
- |hi| min(lo, hi) ..= max(lo, hi)))
- .ok_or_else(|| TestCaseError::reject("non-char")))
- .collect::<Result<Vec<CharRange>,_>>()?));
+ 1..5))
+ {
+ let input = ranges(Cow::Owned(input_ranges.iter().map(
+ |&(lo, hi)| ::std::char::from_u32(lo).and_then(
+ |lo| ::std::char::from_u32(hi).map(
+ |hi| min(lo, hi) ..= max(lo, hi)))
+ .ok_or_else(|| TestCaseError::reject("non-char")))
+ .collect::<Result<Vec<CharRange>,_>>()?));
- let mut runner = TestRunner::default();
- for _ in 0..256 {
- let mut value = input.new_tree(&mut runner).unwrap();
- loop {
- let ch = value.current() as u32;
- assert!(input_ranges.iter().any(
- |&(lo, hi)| ch >= min(lo, hi) &&
- ch <= max(lo, hi)));
+ let mut runner = TestRunner::default();
+ for _ in 0..256 {
+ let mut value = input.new_tree(&mut runner).unwrap();
+ loop {
+ let ch = value.current() as u32;
+ assert!(input_ranges.iter().any(
+ |&(lo, hi)| ch >= min(lo, hi) &&
+ ch <= max(lo, hi)));
- if !value.simplify() { break; }
- }
+ if !value.simplify() { break; }
}
-
- Ok(())
- }).unwrap()
+ }
+ }
}
#[test]
fn applies_desired_bias() {
let mut men_in_business_suits_levitating = 0;
let mut ascii_printable = 0;
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..1024 {
let ch = any().new_tree(&mut runner).unwrap().current();
@@ -352,7 +351,7 @@
#[test]
fn doesnt_shrink_to_ascii_control() {
let mut accepted = 0;
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..256 {
let mut value = any().new_tree(&mut runner).unwrap();
diff --git a/third_party/rust_crates/vendor/proptest/src/collection.rs b/third_party/rust_crates/vendor/proptest/src/collection.rs
index 56cb6bc..e29b938 100644
--- a/third_party/rust_crates/vendor/proptest/src/collection.rs
+++ b/third_party/rust_crates/vendor/proptest/src/collection.rs
@@ -14,16 +14,16 @@
use core::ops::{Add, Range, RangeTo, RangeInclusive, RangeToInclusive};
use core::usize;
-use std_facade::{fmt, Vec, VecDeque, BinaryHeap, BTreeMap, BTreeSet, LinkedList};
+use crate::std_facade::{fmt, Vec, VecDeque, BinaryHeap, BTreeMap, BTreeSet, LinkedList};
#[cfg(feature = "std")]
-use std_facade::{HashMap, HashSet};
+use crate::std_facade::{HashMap, HashSet};
-use bits::{BitSetLike, VarBitSet};
-use num::sample_uniform_incl;
-use strategy::*;
-use tuple::TupleValueTree;
-use test_runner::*;
+use crate::bits::{BitSetLike, VarBitSet};
+use crate::num::sample_uniform_incl;
+use crate::strategy::*;
+use crate::tuple::TupleValueTree;
+use crate::test_runner::*;
//==============================================================================
// SizeRange
@@ -143,17 +143,6 @@
fn from(high: RangeToInclusive<usize>) -> Self { size_range(0..=high.end) }
}
-impl From<SizeRange> for Range<usize> {
- fn from(sr: SizeRange) -> Self {
- sr.start()..sr.end_excl()
- }
-}
-
-/// Given a size range `[low, high]`, then a range `low..=high` is returned.
-impl From<SizeRange> for RangeInclusive<usize> {
- fn from(sr: SizeRange) -> Self { sr.start()..=sr.end_incl() }
-}
-
#[cfg(feature = "frunk")]
impl Generic for SizeRange {
type Repr = RangeInclusive<usize>;
@@ -635,15 +624,15 @@
mod test {
use super::*;
- use bits;
+ use crate::bits;
#[test]
fn test_vec() {
let input = vec(1usize..20usize, 5..20);
let mut num_successes = 0;
+ let mut runner = TestRunner::deterministic();
for _ in 0..256 {
- let mut runner = TestRunner::default();
let case = input.new_tree(&mut runner).unwrap();
let start = case.current();
// Has correct length
@@ -708,7 +697,7 @@
fn test_map() {
// Only 8 possible keys
let input = hash_map("[ab]{3}", "a", 2..3);
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..256 {
let v = input.new_tree(&mut runner).unwrap().current();
@@ -721,7 +710,7 @@
fn test_set() {
// Only 8 possible values
let input = hash_set("[ab]{3}", 2..3);
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..256 {
let v = input.new_tree(&mut runner).unwrap().current();
diff --git a/third_party/rust_crates/vendor/proptest/src/lib.rs b/third_party/rust_crates/vendor/proptest/src/lib.rs
index fb6638c..9b9a4a1 100644
--- a/third_party/rust_crates/vendor/proptest/src/lib.rs
+++ b/third_party/rust_crates/vendor/proptest/src/lib.rs
@@ -7,1643 +7,12 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! Proptest is a property testing framework (i.e., the QuickCheck family)
-//! inspired by the [Hypothesis](http://hypothesis.works/) framework for
-//! Python. It allows to test that certain properties of your code hold for
-//! arbitrary inputs, and if a failure is found, automatically finds the
-//! minimal test case to reproduce the problem. Unlike QuickCheck, generation
-//! and shrinking is defined on a per-value basis instead of per-type, which
-//! makes it more flexible and simplifies composition.
+//! # Proptest Reference Documentation
//!
-//! If you have dependencies which provide QuickCheck `Arbitrary`
-//! implementations, see also the related
-//! [`proptest-quickcheck-interop`](https://crates.io/crates/proptest-quickcheck-interop)
-//! crates which enables reusing those implementations with proptest.
+//! This is the reference documentation for the proptest API.
//!
-//! <!-- NOREADME
-//! NOREADME The funky ampersand stuff here is necessary since pulldown doesn't
-//! NOREADME allow HTML comments to span paragraphs. gen-readme.sh turns
-//! NOREADME these into the appropriate markup.
-//! &H2 Status of this crate
-//! &NL
-//! The majority of the functionality offered by proptest is in active use and
-//! is known to work well.
-//! &NL
-//! The API is unlikely to see drastic breaking changes, but there may still be
-//! minor breaking changes here and there, particularly when "impl Trait"
-//! becomes stable and after the upcoming redesign of the `rand` crate.
-//! &NL
-//! See the [changelog](https://github.com/AltSysrq/proptest/blob/master/CHANGELOG.md)
-//! for a full list of substantial historical changes, breaking and otherwise.
-//! NOREADME -->
-//!
-//! ## Introduction
-//!
-//! _Property testing_ is a system of testing code by checking that certain
-//! properties of its output or behaviour are fulfilled for all inputs. These
-//! inputs are generated automatically, and, critically, when a failing input
-//! is found, the input is automatically reduced to a _minimal_ test case.
-//!
-//! Property testing is best used to compliment traditional unit testing (i.e.,
-//! using specific inputs chosen by hand). Traditional tests can test specific
-//! known edge cases, simple inputs, and inputs that were known in the past to
-//! reveal bugs, whereas property tests will search for more complicated inputs
-//! that cause problems.
-//!
-//! ## Getting Started
-//!
-//! Let's say we want to make a function that parses dates of the form
-//! `YYYY-MM-DD`. We're not going to worry about _validating_ the date, any
-//! triple of integers is fine. So let's bang something out real quick.
-//!
-//! ```rust,no_run
-//! fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
-//! if 10 != s.len() { return None; }
-//! if "-" != &s[4..5] || "-" != &s[7..8] { return None; }
-//!
-//! let year = &s[0..4];
-//! let month = &s[6..7];
-//! let day = &s[8..10];
-//!
-//! year.parse::<u32>().ok().and_then(
-//! |y| month.parse::<u32>().ok().and_then(
-//! |m| day.parse::<u32>().ok().map(
-//! |d| (y, m, d))))
-//! }
-//! ```
-//!
-//! It compiles, that means it works, right? Maybe not, let's add some tests.
-//!
-//! ```rust,ignore
-//! #[test]
-//! fn test_parse_date() {
-//! assert_eq!(None, parse_date("2017-06-1"));
-//! assert_eq!(None, parse_date("2017-06-170"));
-//! assert_eq!(None, parse_date("2017006-17"));
-//! assert_eq!(None, parse_date("2017-06017"));
-//! assert_eq!(Some((2017, 06, 17)), parse_date("2017-06-17"));
-//! }
-//! ```
-//!
-//! Tests pass, deploy to production! But now your application starts crashing,
-//! and people are upset that you moved Christmas to February. Maybe we need to
-//! be a bit more thorough.
-//!
-//! In `Cargo.toml`, add
-//!
-//! ```toml
-//! [dev-dependencies]
-//! proptest = "0.8.7"
-//! ```
-//!
-//! and at the top of `main.rs` or `lib.rs`:
-//!
-//! ```rust,ignore
-//! #[macro_use] extern crate proptest;
-//! ```
-//!
-//! Now we can add some property tests to our date parser. But how do we test
-//! the date parser for arbitrary inputs, without making another date parser in
-//! the test to validate it? We won't need to as long as we choose our inputs
-//! and properties correctly. But before correctness, there's actually an even
-//! simpler property to test: _The function should not crash._ Let's start
-//! there.
-//!
-//! ```rust,ignore
-//! proptest! {
-//! #[test]
-//! fn doesnt_crash(s in "\\PC*") {
-//! parse_date(s);
-//! }
-//! }
-//! ```
-//!
-//! What this does is take a literally random `&String` (ignore `\\PC*` for the
-//! moment, we'll get back to that — if you've already figured it out, contain
-//! your excitement for a bit) and give it to `parse_date()` and then throw the
-//! output away.
-//!
-//! When we run this, we get a bunch of scary-looking output, eventually ending
-//! with
-//!
-//! ```text
-//! thread 'main' panicked at 'Test failed: byte index 4 is not a char boundary; it is inside 'ௗ' (bytes 2..5) of `aAௗ0㌀0`; minimal failing input: s = "aAௗ0㌀0"
-//! successes: 102
-//! local rejects: 0
-//! global rejects: 0
-//! '
-//! ```
-//!
-//! If we look at the top directory after the test fails, we'll see a new
-//! `proptest-regressions` directory, which contains some files corresponding
-//! to source files containing failing test cases. These are [_failure
-//! persistence_](#failure-persistence) files. The first thing we should do is
-//! add these to source control.
-//!
-//! ```text
-//! $ git add proptest-regressions
-//! ```
-//!
-//! The next thing we should do is copy the failing case to a traditional unit
-//! test since it has exposed a bug not similar to what we've tested in the
-//! past.
-//!
-//! ```rust,ignore
-//! #[test]
-//! fn test_unicode_gibberish() {
-//! assert_eq!(None, parse_date("aAௗ0㌀0"));
-//! }
-//! ```
-//!
-//! Now, let's see what happened... we forgot about UTF-8! You can't just
-//! blindly slice strings since you could split a character, in this case that
-//! Tamil diacritic placed atop other characters in the string.
-//!
-//! In the interest of making the code changes as small as possible, we'll just
-//! check that the string is ASCII and reject anything that isn't.
-//!
-//! ```rust,no_run
-//! # use std::ascii::AsciiExt; //NOREADME
-//! # // NOREADME
-//! fn parse_date(s: &str) -> Option<(u32, u32, u32)> {
-//! if 10 != s.len() { return None; }
-//!
-//! // NEW: Ignore non-ASCII strings so we don't need to deal with Unicode.
-//! if !s.is_ascii() { return None; }
-//!
-//! if "-" != &s[4..5] || "-" != &s[7..8] { return None; }
-//!
-//! let year = &s[0..4];
-//! let month = &s[6..7];
-//! let day = &s[8..10];
-//!
-//! year.parse::<u32>().ok().and_then(
-//! |y| month.parse::<u32>().ok().and_then(
-//! |m| day.parse::<u32>().ok().map(
-//! |d| (y, m, d))))
-//! }
-//! ```
-//!
-//! The tests pass now! But we know there are still more problems, so let's
-//! test more properties.
-//!
-//! Another property we want from our code is that it parses every valid date.
-//! We can add another test to the `proptest!` section:
-//!
-//! ```rust,ignore
-//! proptest! {
-//! // snip...
-//!
-//! #[test]
-//! fn parses_all_valid_dates(s in "[0-9]{4}-[0-9]{2}-[0-9]{2}") {
-//! parse_date(s).unwrap();
-//! }
-//! }
-//! ```
-//!
-//! The thing to the right-hand side of `in` is actually a *regular
-//! expression*, and `s` is chosen from strings which match it. So in our
-//! previous test, `"\\PC*"` was generating arbitrary strings composed of
-//! arbitrary non-control characters. Now, we generate things in the YYYY-MM-DD
-//! format.
-//!
-//! The new test passes, so let's move on to something else.
-//!
-//! The final property we want to check is that the dates are actually parsed
-//! _correctly_. Now, we can't do this by generating strings — we'd end up just
-//! reimplementing the date parser in the test! Instead, we start from the
-//! expected output, generate the string, and check that it gets parsed back.
-//!
-//! ```rust,ignore
-//! proptest! {
-//! // snip...
-//!
-//! #[test]
-//! fn parses_date_back_to_original(y in 0u32..10000,
-//! m in 1u32..13, d in 1u32..32) {
-//! let (y2, m2, d2) = parse_date(
-//! &format!("{:04}-{:02}-{:02}", y, m, d)).unwrap();
-//! // prop_assert_eq! is basically the same as assert_eq!, but doesn't
-//! // cause a bunch of panic messages to be printed on intermediate
-//! // test failures. Which one to use is largely a matter of taste.
-//! prop_assert_eq!((y, m, d), (y2, m2, d2));
-//! }
-//! }
-//! ```
-//!
-//! Here, we see that besides regexes, we can use any expression which is a
-//! `proptest::strategy::Strategy`, in this case, integer ranges.
-//!
-//! The test fails when we run it. Though there's not much output this time.
-//!
-//! ```text
-//! thread 'main' panicked at 'Test failed: assertion failed: `(left == right)` (left: `(0, 10, 1)`, right: `(0, 0, 1)`) at examples/dateparser_v2.rs:46; minimal failing input: y = 0, m = 10, d = 1
-//! successes: 2
-//! local rejects: 0
-//! global rejects: 0
-//! ', examples/dateparser_v2.rs:33
-//! note: Run with `RUST_BACKTRACE=1` for a backtrace.
-//! ```
-//!
-//! The failing input is `(y, m, d) = (0, 10, 1)`, which is a rather specific
-//! output. Before thinking about why this breaks the code, let's look at what
-//! proptest did to arrive at this value. At the start of our test function,
-//! insert
-//!
-//! ```rust,ignore
-//! println!("y = {}, m = {}, d = {}", y, m, d);
-//! ```
-//!
-//! Running the test again, we get something like this:
-//!
-//! ```text
-//! y = 2497, m = 8, d = 27
-//! y = 9641, m = 8, d = 18
-//! y = 7360, m = 12, d = 20
-//! y = 3680, m = 12, d = 20
-//! y = 1840, m = 12, d = 20
-//! y = 920, m = 12, d = 20
-//! y = 460, m = 12, d = 20
-//! y = 230, m = 12, d = 20
-//! y = 115, m = 12, d = 20
-//! y = 57, m = 12, d = 20
-//! y = 28, m = 12, d = 20
-//! y = 14, m = 12, d = 20
-//! y = 7, m = 12, d = 20
-//! y = 3, m = 12, d = 20
-//! y = 1, m = 12, d = 20
-//! y = 0, m = 12, d = 20
-//! y = 0, m = 6, d = 20
-//! y = 0, m = 9, d = 20
-//! y = 0, m = 11, d = 20
-//! y = 0, m = 10, d = 20
-//! y = 0, m = 10, d = 10
-//! y = 0, m = 10, d = 5
-//! y = 0, m = 10, d = 3
-//! y = 0, m = 10, d = 2
-//! y = 0, m = 10, d = 1
-//! ```
-//!
-//! The test failure message said there were two successful cases; we see these
-//! at the very top, `2497-08-27` and `9641-08-18`. The next case,
-//! `7360-12-20`, failed. There's nothing immediately obviously special about
-//! this date. Fortunately, proptest reduced it to a much simpler case. First,
-//! it rapidly reduced the `y` input to `0` at the beginning, and similarly
-//! reduced the `d` input to the minimum allowable value of `1` at the end.
-//! Between those two, though, we see something different: it tried to shrink
-//! `12` to `6`, but then ended up raising it back up to `10`. This is because
-//! the `0000-06-20` and `0000-09-20` test cases _passed_.
-//!
-//! In the end, we get the date `0000-10-01`, which apparently gets parsed as
-//! `0000-00-01`. Again, this failing case was added to the failure persistence
-//! file, and we should add this as its own unit test:
-//!
-//! ```text
-//! $ git add proptest-regressions
-//! ```
-//!
-//! ```rust,ignore
-//! #[test]
-//! fn test_october_first() {
-//! assert_eq!(Some(0, 10, 1), parse_date("0000-10-01"));
-//! }
-//! ```
-//!
-//! Now to figure out what's broken in the code. Even without the intermediate
-//! input, we can say with reasonable confidence that the year and day parts
-//! don't come into the picture since both were reduced to the minimum
-//! allowable input. The month input was _not_, but was reduced to `10`. This
-//! means we can infer that there's something special about `10` that doesn't
-//! hold for `9`. In this case, that "special something" is being two digits
-//! wide. In our code:
-//!
-//! ```rust,ignore
-//! let month = &s[6..7];
-//! ```
-//!
-//! We were off by one, and need to use the range `5..7`. After fixing this,
-//! the test passes.
-//!
-//! The `proptest!` macro has some additional syntax, including for setting
-//! configuration for things like the number of test cases to generate. See its
-//! [documentation](macro.proptest.html) <!-- NOREADME
-//! [documentation](https://altsysrq.github.io/rustdoc/proptest/latest/proptest/macro.proptest.html)
-//! NOREADME -->
-//! for more details.
-//!
-//! There is a more in-depth tutorial
-//! [further down](#in-depth-tutorial). <!-- NOREADME
-//! [in the crate documentation](https://altsysrq.github.io/rustdoc/proptest/latest/proptest/#in-depth-tutorial).
-//! NOREADME -->
-//!
-//! ## Differences between QuickCheck and Proptest
-//!
-//! QuickCheck and Proptest are similar in many ways: both generate random
-//! inputs for a function to check certain properties, and automatically shrink
-//! inputs to minimal failing cases.
-//!
-//! The one big difference is that QuickCheck generates and shrinks values
-//! based on type alone, whereas Proptest uses explicit `Strategy` objects. The
-//! QuickCheck approach has a lot of disadvantages in comparison:
-//!
-//! - QuickCheck can only define one generator and shrinker per type. If you
-//! need a custom generation strategy, you need to wrap it in a newtype and
-//! implement traits on that by hand. In Proptest, you can define arbitrarily
-//! many different strategies for the same type, and there are plenty built-in.
-//!
-//! - For the same reason, QuickCheck has a single "size" configuration that
-//! tries to define the range of values generated. If you need an integer
-//! between 0 and 100 and another between 0 and 1000, you probably need to do
-//! another newtype. In Proptest, you can directly just express that you want a
-//! `0..100` integer and a `0..1000` integer.
-//!
-//! - Types in QuickCheck are not easily composable. Defining `Arbitrary` and
-//! `Shrink` for a new struct which is simply produced by the composition of
-//! its fields requires implementing both by hand, including a bidirectional
-//! mapping between the struct and a tuple of its fields. In Proptest, you can
-//! make a tuple of the desired components and then `prop_map` it into the
-//! desired form. Shrinking happens automatically in terms of the input types.
-//!
-//! - Because constraints on values cannot be expressed in QuickCheck,
-//! generation and shrinking may lead to a lot of input rejections. Strategies
-//! in Proptest are aware of simple constraints and do not generate or shrink
-//! to values that violate them.
-//!
-//! The author of Hypothesis also has an [article on this
-//! topic](http://hypothesis.works/articles/integrated-shrinking/).
-//!
-//! Of course, there's also some relative downsides that fall out of what
-//! Proptest does differently:
-//!
-//! - Generating complex values in Proptest can be up to an order of magnitude
-//! slower than in QuickCheck. This is because QuickCheck performs stateless
-//! shrinking based on the output value, whereas Proptest must hold on to all
-//! the intermediate states and relationships in order for its richer shrinking
-//! model to work.
-//!
-//! ## Limitations of Property Testing
-//!
-//! Given infinite time, property testing will eventually explore the whole
-//! input space to a test. However, time is not infinite, so only a randomly
-//! sampled portion of the input space can be explored. This means that
-//! property testing is extremely unlikely to find single-value edge cases in a
-//! large space. For example, the following test will virtually always pass:
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! proptest! {
-//! # /* NOREADME
-//! #[test]
-//! # NOREADME */
-//! fn i64_abs_is_never_negative(a: i64) {
-//! // This actually fails if a == i64::MIN, but randomly picking one
-//! // specific value out of 2⁶⁴ is overwhelmingly unlikely.
-//! assert!(a.abs() >= 0);
-//! }
-//! }
-//! # // NOREADME
-//! # fn main() { i64_abs_is_never_negative(); } // NOREADME
-//! ```
-//!
-//! Because of this, traditional unit testing with intelligently selected cases
-//! is still necessary for many kinds of problems.
-//!
-//! Similarly, in some cases it can be hard or impossible to define a strategy
-//! which actually produces useful inputs. A strategy of `.{1,4096}` may be
-//! great to fuzz a C parser, but is highly unlikely to produce anything that
-//! makes it to a code generator.
-//!
-//! ## Failure Persistence
-//!
-//! By default, when Proptest finds a failing test case, it _persists_ that
-//! failing case in a file named after the source containing the failing test,
-//! but in a separate directory tree rooted at `proptest-regressions`† . Later
-//! runs of tests will replay those test cases before generating novel cases.
-//! This ensures that the test will not fail on one run and then spuriously
-//! pass on the next, and also exposes similar tests to the same
-//! known-problematic input.
-//!
-//! († If you do not have an obvious source directory, you may instead find
-//! files next to the source files, with a different extension.)
-//!
-//! It is recommended to check these files in to your source control so that
-//! other test runners (e.g., collaborators or a CI system) also replay these
-//! cases.
-//!
-//! Note that, by default, all tests in the same crate will share that one
-//! persistence file. If you have a very large number of tests, it may be
-//! desirable to separate them into smaller groups so the number of extra test
-//! cases that get run is reduced. This can be done by adjusting the
-//! `failure_persistence` flag on `Config`.
-//!
-//! There are two ways this persistence could theoretically be done.
-//!
-//! The immediately obvious option is to persist a representation of the value
-//! itself, for example by using Serde. While this has some advantages,
-//! particularly being resistant to changes like tweaking the input strategy,
-//! it also has a lot of problems. Most importantly, there is no way to
-//! determine whether any given value is actually within the domain of the
-//! strategy that produces it. Thus, some (likely extremely fragile) mechanism
-//! to ensure that the strategy that produced the value exactly matches the one
-//! in use in a test case would be required.
-//!
-//! The other option is to store the _seed_ that was used to produce the
-//! failing test case. This approach requires no support from the strategy or
-//! the produced value. If the strategy in use differs from the one used to
-//! produce failing case that was persisted, the seed may or may not produce
-//! the problematic value, but nonetheless produces a valid value. Due to these
-//! advantages, this is the approach Proptest uses.
-//!
-//! ## Forking and Timeouts
-//!
-//! By default, proptest tests are run in-process and are allowed to run for
-//! however long it takes them. This is resource-efficient and produces the
-//! nicest test output, and for many use cases is sufficient. However, problems
-//! like overflowing the stack, aborting the process, or getting stuck in an
-//! infinite will simply break the entire test process and prevent proptest
-//! from determining a minimal reproducible case.
-//!
-//! As of version 0.7.1, proptest has optional "fork" and "timeout" features
-//! (both enabled by default), which make it possible to run your test cases in
-//! a subprocess and limit how long they may run. This is generally slower,
-//! may make using a debugger more difficult, and makes test output harder to
-//! interpret, but allows proptest to find and minimise test cases for these
-//! situations as well.
-//!
-//! To enable these features, simply set the `fork` and/or `timeout` fields on
-//! the `Config`. (Setting `timeout` implies `fork`.)
-//!
-//! Here is a simple example of using both features:
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! // The worst possible way to calculate Fibonacci numbers
-//! fn fib(n: u64) -> u64 {
-//! if n <= 1 {
-//! n
-//! } else {
-//! fib(n - 1) + fib(n - 2)
-//! }
-//! }
-//!
-//! proptest! {
-//! #![proptest_config(ProptestConfig {
-//! // Setting both fork and timeout is redundant since timeout implies
-//! // fork, but both are shown for clarity.
-//! fork: true,
-//! timeout: 1000,
-//! .. ProptestConfig::default()
-//! })]
-//!
-//! # /* NOREADME
-//! #[test]
-//! # NOREADME */
-//! fn test_fib(n: u64) {
-//! // For large n, this will variously run for an extremely long time,
-//! // overflow the stack, or panic due to integer overflow.
-//! assert!(fib(n) >= n);
-//! }
-//! }
-//! # //NOREADME
-//! # fn main() { } //NOREADME
-//! ```
-//!
-//! The exact value of the test failure depends heavily on the performance of
-//! the host system, the rust version, and compiler flags, but on the system
-//! where it was originally tested, it found that the maximum value that
-//! `fib()` could handle was 39, despite having dozens of processes dump core
-//! due to stack overflow or time out along the way.
-//!
-//! If you just want to run tests in subprocesses or with a timeout every now
-//! and then, you can do that by setting the `PROPTEST_FORK` or
-//! `PROPTEST_TIMEOUT` environment variables to alter the default
-//! configuration. For example, on Unix,
-//!
-//! ```sh
-//! # Run all the proptest tests in subprocesses with no timeout.
-//! # Individual tests can still opt out by setting `fork: false` in their
-//! # own configuration.
-//! PROPTEST_FORK=true cargo test
-//! # Run all the proptest tests in subprocesses with a 1 second timeout.
-//! # Tests can still opt out or use a different timeout by setting `timeout: 0`
-//! # or another timeout in their own configuration.
-//! PROPTEST_TIMEOUT=1000 cargo test
-//! ```
-//!
-//! <!-- ENDREADME -->
-//!
-//! ## In-Depth Tutorial
-//!
-//! This tutorial will introduce proptest from the bottom up, starting from the
-//! basic building blocks, in the hopes of making the model as a whole clear.
-//! In particular, we'll start off without using the macros so that the macros
-//! can later be understood in terms of what they expand into rather than
-//! magic. But as a result, the first part is _not_ representative of how
-//! proptest is normally used. If bottom-up isn't your style, you may wish to
-//! skim the first few sections.
-//!
-//! Also note that the examples here focus on the usage of proptest itself, and
-//! as such generally have trivial test bodies. In real code, you would
-//! obviously have assertions and so forth in the test bodies.
-//!
-//! ### Strategy Basics
-//!
-//! The [_Strategy_](strategy/trait.Strategy.html) is the most fundamental
-//! concept in proptest. A strategy defines two things:
-//!
-//! - How to generate random values of a particular type from a random number
-//! generator.
-//!
-//! - How to "shrink" such values into "simpler" forms.
-//!
-//! Proptest ships with a substantial library of strategies. Some of these are
-//! defined in terms of built-in types; for example, `0..100i32` is a strategy
-//! to generate `i32`s between 0, inclusive, and 100, exclusive. As we've
-//! already seen, strings are themselves strategies for generating strings
-//! which match the former as a regular expression.
-//!
-//! Generating a value is a two-step process. First, a `TestRunner` is passed
-//! to the `new_tree()` method of the `Strategy`; this returns a `ValueTree`,
-//! which we'll look at in more detail momentarily. Calling the `current()`
-//! method on the `ValueTree` produces the actual value. Knowing that, we can
-//! put the pieces together and generate values. The below is the
-//! `tutoral-strategy-play.rs` example:
-//!
-//! ```rust
-//! extern crate proptest;
-//!
-//! use proptest::test_runner::TestRunner;
-//! use proptest::strategy::{Strategy, ValueTree};
-//!
-//! fn main() {
-//! let mut runner = TestRunner::default();
-//! let int_val = (0..100i32).new_tree(&mut runner).unwrap();
-//! let str_val = "[a-z]{1,4}\\p{Cyrillic}{1,4}\\p{Greek}{1,4}"
-//! .new_tree(&mut runner).unwrap();
-//! println!("int_val = {}, str_val = {}",
-//! int_val.current(), str_val.current());
-//! }
-//! ```
-//!
-//! If you run this a few times, you'll get output similar to the following:
-//!
-//! ```text
-//! $ target/debug/examples/tutorial-strategy-play
-//! int_val = 99, str_val = vѨͿἕΌ
-//! $ target/debug/examples/tutorial-strategy-play
-//! int_val = 25, str_val = cwᵸійΉ
-//! $ target/debug/examples/tutorial-strategy-play
-//! int_val = 5, str_val = oegiᴫᵸӈᵸὛΉ
-//! ```
-//!
-//! This knowledge is sufficient to build an extremely primitive fuzzing test.
-//!
-//! ```rust,no_run
-//! extern crate proptest;
-//!
-//! use proptest::test_runner::TestRunner;
-//! use proptest::strategy::{Strategy, ValueTree};
-//!
-//! fn some_function(v: i32) {
-//! // Do a bunch of stuff, but crash if v > 500
-//! assert!(v <= 500);
-//! }
-//!
-//! # /*
-//! #[test]
-//! # */
-//! fn some_function_doesnt_crash() {
-//! let mut runner = TestRunner::default();
-//! for _ in 0..256 {
-//! let val = (0..10000i32).new_tree(&mut runner).unwrap();
-//! some_function(val.current());
-//! }
-//! }
-//! # fn main() { }
-//! ```
-//!
-//! This _works_, but when the test fails, we don't get much context, and even
-//! if we recover the input, we see some arbitrary-looking value like 1771
-//! rather than the boundary condition of 501. For a function taking just an
-//! integer, this is probably still good enough, but as inputs get more
-//! complex, interpreting completely random values becomes increasingly
-//! difficult.
-//!
-//! ### Shrinking Basics
-//!
-//! Finding the "simplest" input that causes a test failure is referred to as
-//! _shrinking_. This is where the intermediate `ValueTree` type comes in.
-//! Besides `current()`, it provides two methods — `simplify()` and
-//! `complicate()` — which together allow binary searching over the input
-//! space. The `tutorial-simplify-play.rs` example shows how repeated calls to
-//! `simplify()` produce incrementally "simpler" outputs, both in terms of size
-//! and in characters used.
-//!
-//! ```rust
-//! extern crate proptest;
-//!
-//! use proptest::test_runner::TestRunner;
-//! use proptest::strategy::{Strategy, ValueTree};
-//!
-//! fn main() {
-//! let mut runner = TestRunner::default();
-//! let mut str_val = "[a-z]{1,4}\\p{Cyrillic}{1,4}\\p{Greek}{1,4}"
-//! .new_tree(&mut runner).unwrap();
-//! println!("str_val = {}", str_val.current());
-//! while str_val.simplify() {
-//! println!(" = {}", str_val.current());
-//! }
-//! }
-//! ```
-//!
-//! A couple runs:
-//!
-//! ```text
-//! $ target/debug/examples/tutorial-simplify-play
-//! str_val = vy꙲ꙈᴫѱΆῨῨ
-//! = y꙲ꙈᴫѱΆῨῨ
-//! = y꙲ꙈᴫѱΆῨῨ
-//! = m꙲ꙈᴫѱΆῨῨ
-//! = g꙲ꙈᴫѱΆῨῨ
-//! = d꙲ꙈᴫѱΆῨῨ
-//! = b꙲ꙈᴫѱΆῨῨ
-//! = a꙲ꙈᴫѱΆῨῨ
-//! = aꙈᴫѱΆῨῨ
-//! = aᴫѱΆῨῨ
-//! = aѱΆῨῨ
-//! = aѱΆῨῨ
-//! = aѱΆῨῨ
-//! = aиΆῨῨ
-//! = aМΆῨῨ
-//! = aЎΆῨῨ
-//! = aЇΆῨῨ
-//! = aЃΆῨῨ
-//! = aЁΆῨῨ
-//! = aЀΆῨῨ
-//! = aЀῨῨ
-//! = aЀῨ
-//! = aЀῨ
-//! = aЀῢ
-//! = aЀ῟
-//! = aЀ῞
-//! = aЀ῝
-//! $ target/debug/examples/tutorial-simplify-play
-//! str_val = dyiꙭᾪῇΊ
-//! = yiꙭᾪῇΊ
-//! = iꙭᾪῇΊ
-//! = iꙭᾪῇΊ
-//! = iꙭᾪῇΊ
-//! = eꙭᾪῇΊ
-//! = cꙭᾪῇΊ
-//! = bꙭᾪῇΊ
-//! = aꙭᾪῇΊ
-//! = aꙖᾪῇΊ
-//! = aꙋᾪῇΊ
-//! = aꙅᾪῇΊ
-//! = aꙂᾪῇΊ
-//! = aꙁᾪῇΊ
-//! = aꙀᾪῇΊ
-//! = aꙀῇΊ
-//! = aꙀΊ
-//! = aꙀΊ
-//! = aꙀΊ
-//! = aꙀΉ
-//! = aꙀΈ
-//! ```
-//!
-//! Note that shrinking never shrinks a value to something outside the range
-//! the strategy describes. Notice the strings in the above example still match
-//! the regular expression even in the end. An integer drawn from
-//! `100..1000i32` will shrink towards zero, but will stop at 100 since that is
-//! the minimum value.
-//!
-//! `simplify()` and `complicate()` can be used to adapt our primitive fuzz
-//! test to actually find the boundary condition.
-//!
-//! ```rust
-//! extern crate proptest;
-//!
-//! use proptest::test_runner::TestRunner;
-//! use proptest::strategy::{Strategy, ValueTree};
-//!
-//! fn some_function(v: i32) -> bool {
-//! // Do a bunch of stuff, but crash if v > 500
-//! // assert!(v <= 500);
-//! // But return a boolean instead of panicking for simplicity
-//! v <= 500
-//! }
-//!
-//! // We know the function is broken, so use a purpose-built main function to
-//! // find the breaking point.
-//! fn main() {
-//! let mut runner = TestRunner::default();
-//! for _ in 0..256 {
-//! let mut val = (0..10000i32).new_tree(&mut runner).unwrap();
-//! if some_function(val.current()) {
-//! // Test case passed
-//! continue;
-//! }
-//!
-//! // We found our failing test case, simplify it as much as possible.
-//! loop {
-//! if !some_function(val.current()) {
-//! // Still failing, find a simpler case
-//! if !val.simplify() {
-//! // No more simplification possible; we're done
-//! break;
-//! }
-//! } else {
-//! // Passed this input, back up a bit
-//! if !val.complicate() {
-//! break;
-//! }
-//! }
-//! }
-//!
-//! println!("The minimal failing case is {}", val.current());
-//! assert_eq!(501, val.current());
-//! return;
-//! }
-//! panic!("Didn't find a failing test case");
-//! }
-//! ```
-//!
-//! This code reliably finds the boundary of the failure, 501.
-//!
-//! ### Using the Test Runner
-//!
-//! The above is quite a bit of code though, and it can't handle things like
-//! panics. Fortunately, proptest's
-//! [`TestRunner`](test_runner/struct.TestRunner.html) provides this
-//! functionality for us. The method we're interested in is `run`. We simply
-//! give it the strategy and a function to test inputs and it takes care of the
-//! rest.
-//!
-//! ```rust
-//! extern crate proptest;
-//!
-//! use proptest::test_runner::{Config, FileFailurePersistence,
-//! TestError, TestRunner};
-//!
-//! fn some_function(v: i32) {
-//! // Do a bunch of stuff, but crash if v > 500.
-//! // We return to normal `assert!` here since `TestRunner` catches
-//! // panics.
-//! assert!(v <= 500);
-//! }
-//!
-//! // We know the function is broken, so use a purpose-built main function to
-//! // find the breaking point.
-//! fn main() {
-//! let mut runner = TestRunner::new(Config {
-//! // Turn failure persistence off for demonstration
-//! failure_persistence: Some(Box::new(FileFailurePersistence::Off)),
-//! .. Config::default()
-//! });
-//! let result = runner.run(&(0..10000i32), |v| {
-//! some_function(v);
-//! Ok(())
-//! });
-//! match result {
-//! Err(TestError::Fail(_, value)) => {
-//! println!("Found minimal failing case: {}", value);
-//! assert_eq!(501, value);
-//! },
-//! result => panic!("Unexpected result: {:?}", result),
-//! }
-//! }
-//! ```
-//!
-//! That's a lot better! Still a bit boilerplatey; the `proptest!` macro will
-//! help with that, but it does some other stuff we haven't covered yet, so for
-//! the moment we'll keep using `TestRunner` directly.
-//!
-//! ### Compound Strategies
-//!
-//! Testing functions that take single arguments of primitive types is nice and
-//! all, but is kind of underwhelming. Back when we were writing the whole
-//! stack by hand, extending the technique to, say, _two_ integers was clear,
-//! if verbose. But `TestRunner` only takes a single `Strategy`; how can we
-//! test a function that needs inputs from more than one?
-//!
-//! ```rust,ignore
-//! use proptest::test_runner::TestRunner;
-//!
-//! fn add(a: i32, b: i32) -> i32 {
-//! a + b
-//! }
-//!
-//! # /*
-//! #[test]
-//! # */
-//! fn test_add() {
-//! let mut runner = TestRunner::default();
-//! runner.run(/* uhhm... */).unwrap();
-//! }
-//! #
-//! # fn main() { test_add(); }
-//! ```
-//!
-//! The key is that strategies are _composable_. The simplest form of
-//! composition is "compound strategies", where we take multiple strategies and
-//! combine their values into one value that holds each input separately. There
-//! are several of these. The simplest is a tuple; a tuple of strategies is
-//! itself a strategy for tuples of the values those strategies produce. For
-//! example, `(0..100i32,100..1000i32)` is a strategy for pairs of integers
-//! where the first value is between 0 and 100 and the second is between 100
-//! and 1000.
-//!
-//! So for our two-argument function, our strategy is simply a tuple of ranges.
-//!
-//! ```rust
-//! use proptest::test_runner::TestRunner;
-//!
-//! fn add(a: i32, b: i32) -> i32 {
-//! a + b
-//! }
-//!
-//! # /*
-//! #[test]
-//! # */
-//! fn test_add() {
-//! let mut runner = TestRunner::default();
-//! // Combine our two inputs into a strategy for one tuple. Our test
-//! // function then destructures the generated tuples back into separate
-//! // `a` and `b` variables to be passed in to `add()`.
-//! runner.run(&(0..1000i32, 0..1000i32), |(a, b)| {
-//! let sum = add(a, b);
-//! assert!(sum >= a);
-//! assert!(sum >= b);
-//! Ok(())
-//! }).unwrap();
-//! }
-//! #
-//! # fn main() { test_add(); }
-//! ```
-//!
-//! Other compound strategies include fixed-sizes arrays of strategies and
-//! `Vec`s of strategies (which produce arrays or `Vec`s of values parallel to
-//! the strategy collection), as well as the various strategies provided in the
-//! [collection](collection/index.html) module.
-//!
-//! ### Syntax Sugar: `proptest!`
-//!
-//! Now that we know about compound strategies, we can understand how the
-//! [`proptest!`](macro.proptest.html) macro works. Our example from the prior
-//! section can be rewritten using that macro like so:
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//!
-//! fn add(a: i32, b: i32) -> i32 {
-//! a + b
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_add(a in 0..1000i32, b in 0..1000i32) {
-//! let sum = add(a, b);
-//! assert!(sum >= a);
-//! assert!(sum >= b);
-//! }
-//! }
-//! #
-//! # fn main() { test_add(); }
-//! ```
-//!
-//! Conceptually, the desugaring process is fairly simple. At the start of the
-//! test function, a new `TestRunner` is constructed. The input strategies
-//! (after the `in` keyword) are grouped into a tuple. That tuple is passed in
-//! to the `TestRunner` as the input strategy. The test body has `Ok(())` added
-//! to the end, then is put into a lambda that destructures the generated input
-//! tuple back into the named parameters and then runs the body. The end result
-//! is extremely similar to what we wrote by hand in the prior section.
-//!
-//! `proptest!` actually does a few other things in order to make failure
-//! output easier to read and to overcome the 10-tuple limit.
-//!
-//! ### Transforming Strategies
-//!
-//! Suppose you have a function that takes a string which needs to be the
-//! `Display` format of an arbitrary `u32`. A first attempt to providing this
-//! argument might be to use a regular expression, like so:
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//!
-//! fn do_stuff(v: String) {
-//! let i: u32 = v.parse().unwrap();
-//! let s = i.to_string();
-//! assert_eq!(s, v);
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_do_stuff(v in "[1-9][0-9]{0,8}") {
-//! do_stuff(v);
-//! }
-//! }
-//! # fn main() { test_do_stuff(); }
-//! ```
-//!
-//! This kind of works, but it has problems. For one, it does not explore the
-//! whole `u32` space. It is possible to write a regular expression that does,
-//! but such an expression is rather long, and also results in a pretty odd
-//! distribution of values. The input also doesn't shrink correctly, since
-//! proptest tries to shrink it in terms of a string rather than an integer.
-//!
-//! What you really want to do is generate a `u32` and then pass in its string
-//! representation. One way to do this is to just take `u32` as an input to the
-//! test and then transform it to a string within the test code. This approach
-//! works fine, but isn't reusable or composable. Ideally, we could get a
-//! _strategy_ that does this.
-//!
-//! The thing we're looking for is the first strategy _combinator_, `prop_map`.
-//! We need to ensure `Strategy` is in scope to use it.
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! // Grab `Strategy` and a shorter namespace prefix
-//! use proptest::prelude::*;
-//!
-//! fn do_stuff(v: String) {
-//! let i: u32 = v.parse().unwrap();
-//! let s = i.to_string();
-//! assert_eq!(s, v);
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_do_stuff(v in any::<u32>().prop_map(|v| v.to_string())) {
-//! do_stuff(v);
-//! }
-//! }
-//! # fn main() { test_do_stuff(); }
-//! ```
-//!
-//! Calling `prop_map` on a `Strategy` creates a new strategy which transforms
-//! every generated value using the provided function. Proptest retains the
-//! relationship between the original `Strategy` and the transformed one; as a
-//! result, shrinking occurs in terms of `u32`, even though we're generating a
-//! `String`.
-//!
-//! `prop_map` is also the principal way to define strategies for new types,
-//! since most types are simply composed of other, simpler values.
-//!
-//! Let's update our code so it takes a more interesting structure.
-//!
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! #[derive(Clone, Debug)]
-//! struct Order {
-//! id: String,
-//! // Some other fields, though the test doesn't do anything with them
-//! item: String,
-//! quantity: u32,
-//! }
-//!
-//! fn do_stuff(order: Order) {
-//! let i: u32 = order.id.parse().unwrap();
-//! let s = i.to_string();
-//! assert_eq!(s, order.id);
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_do_stuff(
-//! order in
-//! (any::<u32>().prop_map(|v| v.to_string()),
-//! "[a-z]*", 1..1000u32).prop_map(
-//! |(id, item, quantity)| Order { id, item, quantity })
-//! ) {
-//! do_stuff(order);
-//! }
-//! }
-//! # fn main() { test_do_stuff(); }
-//! ```
-//!
-//! Notice how we were able to take the output from `prop_map` and put it in a
-//! tuple, then call `prop_map` on _that_ tuple to produce yet another value.
-//!
-//! But that's quite a mouthful in the argument list. Fortunately, strategies
-//! are normal values, so we can extract it to a function.
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! // snip
-//! #
-//! # #[derive(Clone, Debug)]
-//! # struct Order {
-//! # id: String,
-//! # // Some other fields, though the test doesn't do anything with them
-//! # item: String,
-//! # quantity: u32,
-//! # }
-//! #
-//! # fn do_stuff(order: Order) {
-//! # let i: u32 = order.id.parse().unwrap();
-//! # let s = i.to_string();
-//! # assert_eq!(s, order.id);
-//! # }
-//!
-//! fn arb_order(max_quantity: u32) -> BoxedStrategy<Order> {
-//! (any::<u32>().prop_map(|v| v.to_string()),
-//! "[a-z]*", 1..max_quantity)
-//! .prop_map(|(id, item, quantity)| Order { id, item, quantity })
-//! .boxed()
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_do_stuff(order in arb_order(1000)) {
-//! do_stuff(order);
-//! }
-//! }
-//! # fn main() { test_do_stuff(); }
-//! ```
-//!
-//! We `boxed()` the strategy in the function since otherwise the type would
-//! not be nameable, and even if it were, it would be very hard to read or
-//! write. Boxing a `Strategy` turns both it and its `ValueTree`s into trait
-//! objects, which both makes the types simpler and can be used to mix
-//! heterogeneous `Strategy` types as long as they produce the same value
-//! types.
-//!
-//! The `arb_order()` function is also _parameterised_, which is another
-//! advantage of extracting strategies to separate functions. In this case, if
-//! we have a test that needs an `Order` with no more than a dozen items, we
-//! can simply call `arb_order(12)` rather than needing to write out a whole
-//! new strategy.
-//!
-//! We can also use `-> impl Strategy<Value = Order>` instead to avoid the
-//! overhead as in the following example. You should use `-> impl Strategy<..>`
-//! unless you need the dynamic dispatch.
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! // snip
-//! #
-//! # #[derive(Clone, Debug)]
-//! # struct Order {
-//! # id: String,
-//! # // Some other fields, though the test doesn't do anything with them
-//! # item: String,
-//! # quantity: u32,
-//! # }
-//! #
-//!
-//! # fn do_stuff(order: Order) {
-//! # let i: u32 = order.id.parse().unwrap();
-//! # let s = i.to_string();
-//! # assert_eq!(s, order.id);
-//! # }
-//!
-//! fn arb_order(max_quantity: u32) -> impl Strategy<Value = Order> {
-//! (any::<u32>().prop_map(|v| v.to_string()),
-//! "[a-z]*", 1..max_quantity)
-//! .prop_map(|(id, item, quantity)| Order { id, item, quantity })
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_do_stuff(order in arb_order(1000)) {
-//! do_stuff(order);
-//! }
-//! }
-//!
-//! # fn main() { test_do_stuff(); }
-//! ```
-//!
-//! ### Syntax Sugar: `prop_compose!`
-//!
-//! Defining strategy-returning functions like this is extremely useful, but
-//! the code above is a bit verbose, as well as hard to read for similar
-//! reasons to writing test functions by hand.
-//!
-//! To simplify this task, proptest includes the
-//! [`prop_compose!`](macro.prop_compose.html) macro. Before going into
-//! details, here's our code from above rewritten to use it.
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! // snip
-//! #
-//! # #[derive(Clone, Debug)]
-//! # struct Order {
-//! # id: String,
-//! # // Some other fields, though the test doesn't do anything with them
-//! # item: String,
-//! # quantity: u32,
-//! # }
-//! #
-//! # fn do_stuff(order: Order) {
-//! # let i: u32 = order.id.parse().unwrap();
-//! # let s = i.to_string();
-//! # assert_eq!(s, order.id);
-//! # }
-//!
-//! prop_compose! {
-//! fn arb_order_id()(id in any::<u32>()) -> String {
-//! id.to_string()
-//! }
-//! }
-//! prop_compose! {
-//! fn arb_order(max_quantity: u32)
-//! (id in arb_order_id(), item in "[a-z]*",
-//! quantity in 1..max_quantity)
-//! -> Order {
-//! Order { id, item, quantity }
-//! }
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_do_stuff(order in arb_order(1000)) {
-//! do_stuff(order);
-//! }
-//! }
-//! # fn main() { test_do_stuff(); }
-//! ```
-//!
-//! We had to extract `arb_order_id()` out into its own function, but otherwise
-//! this desugars to almost exactly what we wrote in the previous section. The
-//! generated function takes the first parameter list as arguments. These
-//! arguments are used to select the strategies in the second argument list.
-//! Values are then drawn from those strategies and transformed by the function
-//! body. The actual function has a return type of `impl Strategy<Value = T>`
-//! where `T` is the declared return type.
-//!
-//! ### Generating Enums
-//!
-//! The syntax sugar for defining strategies for `enum`s is currently somewhat
-//! limited. Creating such strategies with `prop_compose!` is possible but
-//! generally is not very readable, so in most cases defining the function by
-//! hand is preferable.
-//!
-//! The core building block is the [`prop_oneof!`](macro.prop_oneof.html)
-//! macro, in which you list one case for each case in your `enum`. For `enum`s
-//! which have no data, the strategy for each case is
-//! `Just(YourEnum::TheCase)`. Enum cases with data generally require putting
-//! the data in a tuple and then using `prop_map` to map it into the enum case.
-//!
-//! Here is a simple example:
-//!
-//! ```rust,no_run
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! #[derive(Debug, Clone)]
-//! enum MyEnum {
-//! SimpleCase,
-//! CaseWithSingleDatum(u32),
-//! CaseWithMultipleData(u32, String),
-//! }
-//!
-//! fn my_enum_strategy() -> impl Strategy<Value = MyEnum> {
-//! prop_oneof![
-//! // For cases without data, `Just` is all you need
-//! Just(MyEnum::SimpleCase),
-//!
-//! // For cases with data, write a strategy for the interior data, then
-//! // map into the actual enum case.
-//! any::<u32>().prop_map(MyEnum::CaseWithSingleDatum),
-//!
-//! (any::<u32>(), ".*").prop_map(
-//! |(a, b)| MyEnum::CaseWithMultipleData(a, b)),
-//! ]
-//! }
-//! #
-//! # fn main() { }
-//! ```
-//!
-//! In general, it is best to list the enum cases in order from "simplest" to
-//! "most complex", since shrinking will shrink down toward items earlier in
-//! the list.
-//!
-//! For particularly complex enum cases, it can be helpful to extract the
-//! strategy for that case to a separate strategy. Here,
-//! [`prop_compose!`](macro.prop_compose.html) can be of use.
-//!
-//! ```rust,no_run
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! #[derive(Debug, Clone)]
-//! enum MyComplexEnum {
-//! SimpleCase,
-//! AnotherSimpleCase,
-//! ComplexCase {
-//! product_code: String,
-//! id: u64,
-//! chapter: String,
-//! },
-//! }
-//!
-//! prop_compose! {
-//! fn my_complex_enum_complex_case()(
-//! product_code in "[0-9A-Z]{10,20}",
-//! id in 1u64..10000u64,
-//! chapter in "X{0,2}(V?I{1,3}|IV|IX)",
-//! ) -> MyComplexEnum {
-//! MyComplexEnum::ComplexCase { product_code, id, chapter }
-//! }
-//! }
-//!
-//! fn my_enum_strategy() -> BoxedStrategy<MyComplexEnum> {
-//! prop_oneof![
-//! Just(MyComplexEnum::SimpleCase),
-//! Just(MyComplexEnum::AnotherSimpleCase),
-//! my_complex_enum_complex_case(),
-//! ].boxed()
-//! }
-//! #
-//! # fn main() { }
-//! ```
-//!
-//! ### Filtering
-//!
-//! Sometimes, you have a case where your input values have some sort of
-//! "irregular" constraint on them. For example, an integer needing to be even,
-//! or two values needing to be non-equal.
-//!
-//! In general, the ideal solution is to find a way to take a seed value and
-//! then use `prop_map` to transform it into the desired, irregular domain. For
-//! example, to generate even integers, use something like
-//!
-//! ```rust,no_run
-//! # #[macro_use] extern crate proptest;
-//! prop_compose! {
-//! // Generate arbitrary integers up to half the maximum desired value,
-//! // then multiply them by 2, thus producing only even integers in the
-//! // desired range.
-//! fn even_integer(max: i32)(base in 0..max/2) -> i32 { base * 2 }
-//! }
-//! # fn main() { }
-//! ```
-//!
-//! For the cases where this is not viable, it is possible to filter
-//! strategies. Proptest actually divides filters into two categories:
-//!
-//! - "Local" filters apply to a single strategy. If a value is rejected,
-//! a new value is drawn from that strategy only.
-//!
-//! - "Global" filters apply to the whole test case. If the test case is
-//! rejected, the whole thing is regenerated.
-//!
-//! The distinction is somewhat arbitrary, since something like a "global
-//! filter" could be created by just putting a "local filter" around the whole
-//! input strategy. In practise, the distinction is as to what code performs
-//! the rejection.
-//!
-//! A local filter is created with the `prop_filter` combinator. Besides a
-//! function indicating whether to accept the value, it also takes a value of
-//! type `&'static str`, `String`, .., which it uses to record where/why the
-//! rejection happened.
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn some_test(
-//! v in (0..1000u32)
-//! .prop_filter("Values must not divisible by 7 xor 11",
-//! |v| !((0 == v % 7) ^ (0 == v % 11)))
-//! ) {
-//! assert_eq!(0 == v % 7, 0 == v % 11);
-//! }
-//! }
-//! # fn main() { some_test(); }
-//! ```
-//!
-//! Global filtering results when a test itself returns
-//! `Err(TestCaseError::Reject)`. The [`prop_assume!`](macro.prop_assume.html)
-//! macro provides an easy way to do this.
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//!
-//! fn frob(a: i32, b: i32) -> (i32, i32) {
-//! let d = (a - b).abs();
-//! (a / d, b / d)
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_frob(a in -1000..1000, b in -1000..1000) {
-//! // Input illegal if a==b.
-//! // Equivalent to
-//! // if (a == b) { return Err(TestCaseError::Reject(...)); }
-//! prop_assume!(a != b);
-//!
-//! let (a2, b2) = frob(a, b);
-//! assert!(a2.abs() <= a.abs());
-//! assert!(b2.abs() <= b.abs());
-//! }
-//! }
-//! # fn main() { test_frob(); }
-//! ```
-//!
-//! While useful, filtering has a lot of disadvantages:
-//!
-//! - Since it is simply rejection sampling, it will slow down generation of
-//! test cases since values need to be generated additional times to satisfy
-//! the filter. In the case where a filter always returns false, a test could
-//! theoretically never generate a result.
-//!
-//! - Proptest tracks how many local and global rejections have happened, and
-//! aborts if they exceed a certain number. This prevents a test taking an
-//! extremely long time due to rejections, but means not all filters are viable
-//! in the default configuration. The limits for local and global rejections
-//! are different; by default, proptest allows a large number of local
-//! rejections but a fairly small number of global rejections, on the premise
-//! that the former are cheap but potentially common (having been built into
-//! the strategy) but the latter are expensive but rare (being an edge case in
-//! the particular test).
-//!
-//! - Shrinking and filtering do not play well together. When shrinking, if a
-//! value winds up being rejected, there is no pass/fail information to
-//! continue shrinking properly. Instead, proptest treats such a rejection the
-//! same way it handles a shrink that results in a passing test: by backing
-//! away from simplification with a call to `complicate()`. Thus encountering a
-//! filter rejection during shrinking prevents shrinking from continuing to any
-//! simpler values, even if there are some that would be accepted by the
-//! filter.
-//!
-//! ### Generating Recursive Data
-//! [generating-recursive-data]: #generating-recursive-data
-//!
-//! Randomly generating recursive data structures is trickier than it sounds.
-//! For example, the below is a naïve attempt at generating a JSON AST by using
-//! recursion. This also uses the [`prop_oneof!`](macro.prop_oneof.html), which
-//! we haven't seen yet but should be self-explanatory.
-//!
-//! ```rust,no_run
-//! #[macro_use] extern crate proptest;
-//!
-//! use std::collections::HashMap;
-//! use proptest::prelude::*;
-//!
-//! #[derive(Clone, Debug)]
-//! enum Json {
-//! Null,
-//! Bool(bool),
-//! Number(f64),
-//! String(String),
-//! Array(Vec<Json>),
-//! Map(HashMap<String, Json>),
-//! }
-//!
-//! fn arb_json() -> impl Strategy<Value = Json> {
-//! prop_oneof![
-//! Just(Json::Null),
-//! any::<bool>().prop_map(Json::Bool),
-//! any::<f64>().prop_map(Json::Number),
-//! ".*".prop_map(Json::String),
-//! prop::collection::vec(arb_json(), 0..10).prop_map(Json::Array),
-//! prop::collection::hash_map(
-//! ".*", arb_json(), 0..10).prop_map(Json::Map),
-//! ]
-//! }
-//! # fn main() { }
-//! ```
-//!
-//! Upon closer consideration, this obviously can't work because `arb_json()`
-//! recurses unconditionally.
-//!
-//! A more sophisticated attempt is to define one strategy for each level of
-//! nesting up to some maximum. This doesn't overflow the stack, but as defined
-//! here, even four levels of nesting will produce trees with _thousands_ of
-//! nodes; by eight levels, we get to tens of _millions_.
-//!
-//! Proptest provides a more reliable solution in the form of the
-//! `prop_recursive` combinator. To use this, we create a strategy for the
-//! non-recursive case, then give the combinator that strategy, some size
-//! parameters, and a function to transform a nested strategy into a recursive
-//! strategy.
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//!
-//! use std::collections::HashMap;
-//! use proptest::prelude::*;
-//!
-//! #[derive(Clone, Debug)]
-//! enum Json {
-//! Null,
-//! Bool(bool),
-//! Number(f64),
-//! String(String),
-//! Array(Vec<Json>),
-//! Map(HashMap<String, Json>),
-//! }
-//!
-//! fn arb_json() -> impl Strategy<Value = Json> {
-//! let leaf = prop_oneof![
-//! Just(Json::Null),
-//! any::<bool>().prop_map(Json::Bool),
-//! any::<f64>().prop_map(Json::Number),
-//! ".*".prop_map(Json::String),
-//! ];
-//! leaf.prop_recursive(
-//! 8, // 8 levels deep
-//! 256, // Shoot for maximum size of 256 nodes
-//! 10, // We put up to 10 items per collection
-//! |inner| prop_oneof![
-//! // Take the inner strategy and make the two recursive cases.
-//! prop::collection::vec(inner.clone(), 0..10)
-//! .prop_map(Json::Array),
-//! prop::collection::hash_map(".*", inner, 0..10)
-//! .prop_map(Json::Map),
-//! ])
-//! }
-//! # fn main() { }
-//! ```
-//!
-//! ### Higher-Order Strategies
-//!
-//! A _higher-order strategy_ is a strategy which is generated by another
-//! strategy. That sounds kind of scary, so let's consider an example first.
-//!
-//! Say you have a function you want to test that takes a slice and an index
-//! into that slice. If we use a fixed size for the slice, it's easy, but maybe
-//! we need to test with different slice sizes. We could try something with a
-//! filter:
-//!
-//! ```rust,ignore
-//! fn some_function(stuff: &[String], index: usize) { /* do stuff */ }
-//!
-//! proptest! {
-//! #[test]
-//! fn test_some_function(
-//! stuff in prop::collection::vec(".*", 1..100),
-//! index in 0..100usize
-//! ) {
-//! prop_assume!(index < stuff.len());
-//! some_function(stuff, index);
-//! }
-//! }
-//! ```
-//!
-//! This doesn't work very well. First off, you get a lot of global rejections
-//! since `index` will be outside of `stuff` 50% of the time. But secondly, it
-//! will be rare to actually get a small `stuff` vector, since it would have to
-//! randomly choose a small `index` at the same time.
-//!
-//! The solution is the `prop_flat_map` combinator. This is sort of like
-//! `prop_map`, except that the transform returns a _strategy_ instead of a
-//! value. This is more easily understood by implementing our example:
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::prelude::*;
-//!
-//! fn some_function(stuff: Vec<String>, index: usize) {
-//! let _ = &stuff[index];
-//! // Do stuff
-//! }
-//!
-//! fn vec_and_index() -> impl Strategy<Value = (Vec<String>, usize)> {
-//! prop::collection::vec(".*", 1..100)
-//! .prop_flat_map(|vec| {
-//! let len = vec.len();
-//! (Just(vec), 0..len)
-//! })
-//! }
-//!
-//! proptest! {
-//! # /*
-//! #[test]
-//! # */
-//! fn test_some_function((vec, index) in vec_and_index()) {
-//! some_function(vec, index);
-//! }
-//! }
-//! # fn main() { test_some_function(); }
-//! ```
-//!
-//! In `vec_and_index()`, we make a strategy to produce an arbitrary vector.
-//! But then we derive a new strategy based on _values_ produced by the first
-//! one. The new strategy produces the generated vector unchanged, but also
-//! adds a valid index into that vector, which we can do by picking the
-//! strategy for that index based on the size of the vector.
-//!
-//! Even though the new strategy specifies the singleton `Just(vec)` strategy
-//! for the vector, proptest still understands the connection to the original
-//! strategy and will shrink `vec` as well. All the while, `index` continues to
-//! be a valid index into `vec`.
-//!
-//! `prop_compose!` actually allows making second-order strategies like this by
-//! simply providing three argument lists instead of two. The below desugars to
-//! something much like what we wrote by hand above, except that the index and
-//! vector's positions are internally reversed due to borrowing limitations.
-//!
-//! ```rust,no_run
-//! # #[macro_use] extern crate proptest;
-//! # use proptest::prelude::*;
-//! prop_compose! {
-//! fn vec_and_index()(vec in prop::collection::vec(".*", 1..100))
-//! (index in 0..vec.len(), vec in Just(vec))
-//! -> (Vec<String>, usize) {
-//! (vec, index)
-//! }
-//! }
-//! # fn main() { }
-//! ```
-//!
-//! ### Defining a canonical `Strategy` for a type
-//!
-//! We previously used the function `any` as in `any::<u32>()` to generate a
-//! strategy for all `u32`s. This function works with the trait `Arbitrary`,
-//! which QuickCheck users may be familiar with. In proptest, this trait
-//! is already implemented for most owned types in the standard library,
-//! but you can of course implement it for your own types.
-//!
-//! In some cases, where it makes sense to define a canonical strategy, such
-//! as in the [JSON AST example][generating-recursive-data], it is a good
-//! idea to implement `Arbitrary`.
-//!
-//! Stay tuned for more information about this. Soon you will be able to
-//! derive `Arbitrary` for a lot of cases.
-//!
-//! ### Configuring the number of tests cases requried
-//!
-//! The default number of successful test cases that must execute for a test
-//! as a whole to pass is currently 256. If you are not satisfied with this
-//! and want to run more or fewer, there are a few ways to do this.
-//!
-//! The first way is to set the environment-variable `PROPTEST_CASES` to a
-//! value that can be successfully parsed as a `u32`. The value you set to this
-//! variable is now the new default.
-//!
-//! Another way is to use `#![proptest_config(expr)]` inside `proptest!` where
-//! `expr : Config`. To only change the number of test cases, you can simply
-//! write:
-//!
-//! ```rust
-//! #[macro_use] extern crate proptest;
-//! use proptest::test_runner::Config;
-//!
-//! fn add(a: i32, b: i32) -> i32 { a + b }
-//!
-//! proptest! {
-//! // The next line modifies the number of tests.
-//! #![proptest_config(Config::with_cases(1000))]
-//! # /*
-//! #[test]
-//! # */
-//! fn test_add(a in 0..1000i32, b in 0..1000i32) {
-//! let sum = add(a, b);
-//! assert!(sum >= a);
-//! assert!(sum >= b);
-//! }
-//! }
-//! #
-//! # fn main() { test_add(); }
-//! ```
-//!
-//! Through the same `proptest_config` mechanism you may fine-tune your
-//! configuration through the `Config` type. See its documentation for more
-//! information.
-//!
-//! ### Conclusion
-//!
-//! That's it for the tutorial, at least for now. There are more details for
-//! the features discussed above on their individual documentation pages, and
-//! you can find out about all the strategies provided out-of-the-box by
-//! perusing the module tree below.
+//! For documentation on how to get started with proptest and general usage
+//! advice, please refer to the [Proptest Book](https://altsysrq.github.io/proptest-book/intro.html).
#![deny(missing_docs, bare_trait_objects)]
#![no_std]
@@ -1656,8 +25,6 @@
allocator_api,
try_trait,
generator_trait,
- try_from,
- integer_atomics,
never_type,
try_reserve
))]
@@ -1670,9 +37,6 @@
core_intrinsics
))]
-// FIXME: remove this after refactoring!
-#![allow(renamed_and_removed_lints)]
-
#[macro_use]
mod std_facade;
@@ -1684,11 +48,6 @@
#[macro_use]
extern crate alloc;
-//#[cfg(all(feature = "alloc", not(feature = "std")))]
-//extern crate hashmap_core;
-
-extern crate byteorder;
-
#[cfg(feature = "frunk")]
#[macro_use]
extern crate frunk_core;
@@ -1705,30 +64,20 @@
extern crate bitflags;
#[cfg(feature = "bit-set")]
extern crate bit_set;
+
+#[cfg(feature = "std")]
#[macro_use]
extern crate lazy_static;
-extern crate num_traits;
-
// Only required for the string module.
#[cfg(feature = "std")]
#[macro_use]
extern crate quick_error;
-// Only required for the string module.
-#[cfg(feature = "std")]
-extern crate regex_syntax;
-extern crate rand;
#[cfg(feature = "fork")]
#[macro_use]
extern crate rusty_fork;
-#[cfg(feature = "fork")]
-extern crate tempfile;
-
-#[cfg(test)]
-extern crate regex;
-
#[macro_use]
mod macros;
diff --git a/third_party/rust_crates/vendor/proptest/src/macros.rs b/third_party/rust_crates/vendor/proptest/src/macros.rs
index 62d4b3d..7d96217 100644
--- a/third_party/rust_crates/vendor/proptest/src/macros.rs
+++ b/third_party/rust_crates/vendor/proptest/src/macros.rs
@@ -19,7 +19,7 @@
#[derive(Clone, Copy, Debug)]
$($vis)* struct $name;
$(#[$allmeta])*
- impl $($gen)* ::strategy::statics::MapFn<$input> for $name {
+ impl $($gen)* $crate::strategy::statics::MapFn<$input> for $name {
type Output = $output;
fn apply(&self, $parm: $input) -> $output {
$($body)*
diff --git a/third_party/rust_crates/vendor/proptest/src/num.rs b/third_party/rust_crates/vendor/proptest/src/num.rs
index 8caa436..62832bb 100644
--- a/third_party/rust_crates/vendor/proptest/src/num.rs
+++ b/third_party/rust_crates/vendor/proptest/src/num.rs
@@ -15,7 +15,7 @@
use rand::distributions::{Distribution, Standard};
use rand::distributions::uniform::{Uniform, SampleUniform};
use core::ops::Range;
-use test_runner::TestRunner;
+use crate::test_runner::TestRunner;
pub(crate) fn sample_uniform<X : SampleUniform>
(run: &mut TestRunner, range: Range<X>) -> X {
@@ -123,8 +123,8 @@
pub mod $typ {
use rand::Rng;
- use strategy::*;
- use test_runner::TestRunner;
+ use crate::strategy::*;
+ use crate::test_runner::TestRunner;
int_any!($typ);
@@ -225,8 +225,8 @@
pub mod $typ {
use rand::Rng;
- use strategy::*;
- use test_runner::TestRunner;
+ use crate::strategy::*;
+ use crate::test_runner::TestRunner;
int_any!($typ);
@@ -307,12 +307,14 @@
signed_integer_bin_search!(i16);
signed_integer_bin_search!(i32);
signed_integer_bin_search!(i64);
+#[cfg(not(target_arch = "wasm32"))]
signed_integer_bin_search!(i128);
signed_integer_bin_search!(isize);
unsigned_integer_bin_search!(u8);
unsigned_integer_bin_search!(u16);
unsigned_integer_bin_search!(u32);
unsigned_integer_bin_search!(u64);
+#[cfg(not(target_arch = "wasm32"))]
unsigned_integer_bin_search!(u128);
unsigned_integer_bin_search!(usize);
@@ -642,8 +644,8 @@
use rand::Rng;
- use strategy::*;
- use test_runner::TestRunner;
+ use crate::strategy::*;
+ use crate::test_runner::TestRunner;
use super::{FloatTypes, FloatLayout};
float_any!($typ);
@@ -816,14 +818,14 @@
#[cfg(test)]
mod test {
- use strategy::*;
- use test_runner::*;
+ use crate::strategy::*;
+ use crate::test_runner::*;
use super::*;
#[test]
fn u8_inclusive_end_included() {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let mut ok = 0;
for _ in 0..20 {
let tree = (0..=1).new_tree(&mut runner).unwrap();
@@ -840,7 +842,7 @@
#[test]
fn u8_inclusive_to_end_included() {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let mut ok = 0;
for _ in 0..20 {
let tree = (..=1u8).new_tree(&mut runner).unwrap();
@@ -988,7 +990,7 @@
macro_rules! contract_sanity {
($t:tt) => {
mod $t {
- use strategy::check_strategy_sanity;
+ use crate::strategy::check_strategy_sanity;
const FOURTY_TWO: $t = 42 as $t;
const FIFTY_SIX: $t = 56 as $t;
@@ -1150,7 +1152,7 @@
let mut seen_infinite = 0;
let mut seen_quiet_nan = 0;
let mut seen_signaling_nan = 0;
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
// Check whether this version of Rust honours the NaN payload in
// from_bits
@@ -1274,18 +1276,18 @@
}
proptest! {
- #![proptest_config(::test_runner::Config::with_cases(1024))]
+ #![proptest_config(crate::test_runner::Config::with_cases(1024))]
#[test]
fn f32_any_generates_desired_values(
- strategy in ::bits::u32::ANY.prop_map(f32::Any::from_bits)
+ strategy in crate::bits::u32::ANY.prop_map(f32::Any::from_bits)
) {
float_generation_test_body!(strategy, f32);
}
#[test]
fn f32_any_sanity(
- strategy in ::bits::u32::ANY.prop_map(f32::Any::from_bits)
+ strategy in crate::bits::u32::ANY.prop_map(f32::Any::from_bits)
) {
check_strategy_sanity(strategy, Some(CheckStrategySanityOptions {
strict_complicate_after_simplify: false,
@@ -1295,14 +1297,14 @@
#[test]
fn f64_any_generates_desired_values(
- strategy in ::bits::u32::ANY.prop_map(f64::Any::from_bits)
+ strategy in crate::bits::u32::ANY.prop_map(f64::Any::from_bits)
) {
float_generation_test_body!(strategy, f64);
}
#[test]
fn f64_any_sanity(
- strategy in ::bits::u32::ANY.prop_map(f64::Any::from_bits)
+ strategy in crate::bits::u32::ANY.prop_map(f64::Any::from_bits)
) {
check_strategy_sanity(strategy, Some(CheckStrategySanityOptions {
strict_complicate_after_simplify: false,
diff --git a/third_party/rust_crates/vendor/proptest/src/option.rs b/third_party/rust_crates/vendor/proptest/src/option.rs
index 78f1be6..a253c77 100644
--- a/third_party/rust_crates/vendor/proptest/src/option.rs
+++ b/third_party/rust_crates/vendor/proptest/src/option.rs
@@ -14,8 +14,8 @@
use core::fmt;
use core::marker::PhantomData;
-use strategy::*;
-use test_runner::*;
+use crate::strategy::*;
+use crate::test_runner::*;
//==============================================================================
// Probability
@@ -202,7 +202,7 @@
use super::*;
fn count_some_of_1000(s: OptionStrategy<Just<i32>>) -> u32 {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let mut count = 0;
for _ in 0..1000 {
count += s.new_tree(&mut runner).unwrap()
diff --git a/third_party/rust_crates/vendor/proptest/src/prelude.rs b/third_party/rust_crates/vendor/proptest/src/prelude.rs
index 7f3d9a2..3265297 100644
--- a/third_party/rust_crates/vendor/proptest/src/prelude.rs
+++ b/third_party/rust_crates/vendor/proptest/src/prelude.rs
@@ -1,5 +1,5 @@
//-
-// Copyright 2017, 2018 The proptest developers
+// Copyright 2017, 2018, 2019 The proptest developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
@@ -20,10 +20,19 @@
//! `rand` crate directly will not provide insulation from the upcoming
//! revision to the `rand` crate.
-pub use strategy::{BoxedStrategy, Just, SBoxedStrategy, Strategy};
-pub use arbitrary::{Arbitrary, any, any_with};
-pub use test_runner::Config as ProptestConfig;
-pub use test_runner::TestCaseError;
+pub use crate::strategy::{BoxedStrategy, Just, SBoxedStrategy, Strategy};
+pub use crate::arbitrary::{Arbitrary, any, any_with};
+pub use crate::test_runner::Config as ProptestConfig;
+pub use crate::test_runner::TestCaseError;
+pub use crate::{
+ proptest,
+ prop_assert,
+ prop_assert_eq,
+ prop_assert_ne,
+ prop_assume,
+ prop_oneof,
+ prop_compose,
+};
pub use rand::{RngCore, Rng};
@@ -31,19 +40,19 @@
/// allows simply writing, for example, `prop::num::i32::ANY` rather than
/// `proptest::num::i32::ANY` plus a separate `use proptest;`.
pub mod prop {
- pub use test_runner;
- pub use strategy;
- pub use arbitrary;
- pub use bool;
- pub use num;
- pub use bits;
- pub use tuple;
- pub use array;
- pub use collection;
- pub use char;
+ pub use crate::test_runner;
+ pub use crate::strategy;
+ pub use crate::arbitrary;
+ pub use crate::bool;
+ pub use crate::num;
+ pub use crate::bits;
+ pub use crate::tuple;
+ pub use crate::array;
+ pub use crate::collection;
+ pub use crate::char;
#[cfg(feature = "std")]
- pub use string;
- pub use option;
- pub use result;
- pub use sample;
+ pub use crate::string;
+ pub use crate::option;
+ pub use crate::result;
+ pub use crate::sample;
}
diff --git a/third_party/rust_crates/vendor/proptest/src/result.rs b/third_party/rust_crates/vendor/proptest/src/result.rs
index 769bfa2..e063061 100644
--- a/third_party/rust_crates/vendor/proptest/src/result.rs
+++ b/third_party/rust_crates/vendor/proptest/src/result.rs
@@ -31,11 +31,11 @@
use core::fmt;
use core::marker::PhantomData;
-use strategy::*;
-use test_runner::*;
+use crate::strategy::*;
+use crate::test_runner::*;
// Re-export the type for easier usage.
-pub use option::{prob, Probability};
+pub use crate::option::{prob, Probability};
struct WrapOk<T, E>(PhantomData<T>, PhantomData<E>);
impl<T, E> Clone for WrapOk<T, E> {
@@ -186,7 +186,7 @@
use super::*;
fn count_ok_of_1000(s: impl Strategy<Value = Result<(), ()>>) -> u32 {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let mut count = 0;
for _ in 0..1000 {
count += s.new_tree(&mut runner).unwrap()
diff --git a/third_party/rust_crates/vendor/proptest/src/sample.rs b/third_party/rust_crates/vendor/proptest/src/sample.rs
index 78f424c..65b46943 100644
--- a/third_party/rust_crates/vendor/proptest/src/sample.rs
+++ b/third_party/rust_crates/vendor/proptest/src/sample.rs
@@ -17,17 +17,17 @@
use core::mem;
use core::ops::Range;
use core::u64;
-use std_facade::{Cow, Vec, Arc};
+use crate::std_facade::{Cow, Vec, Arc};
use rand::Rng;
-use bits::{self, BitSetValueTree, SampledBitSetStrategy, VarBitSet};
-use num;
-use strategy::*;
-use test_runner::*;
+use crate::bits::{self, BitSetValueTree, SampledBitSetStrategy, VarBitSet};
+use crate::num;
+use crate::strategy::*;
+use crate::test_runner::*;
/// Re-exported to make usage more ergonomic.
-pub use collection::{SizeRange, size_range};
+pub use crate::collection::{SizeRange, size_range};
/// Sample subsequences whose size are within `size` from the given collection
/// `values`.
@@ -187,7 +187,6 @@
/// call to `prop_flat_map()`.
///
/// ```
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// proptest! {
@@ -290,7 +289,6 @@
/// Generate a non-indexable collection and a value to pick out of it.
///
/// ```
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// proptest! {
@@ -413,10 +411,10 @@
#[cfg(test)]
mod test {
- use std_facade::BTreeSet;
+ use crate::std_facade::BTreeSet;
use super::*;
- use arbitrary::any;
+ use crate::arbitrary::any;
#[test]
fn sample_slice() {
@@ -424,7 +422,7 @@
let mut size_counts = [0; 8];
let mut value_counts = [0; 8];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = subsequence(VALUES, 3..7);
for _ in 0..2048 {
@@ -462,7 +460,7 @@
// Just test that the types work out
let values = vec![0, 1, 2, 3, 4];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = subsequence(values, 1..3);
let _ = input.new_tree(&mut runner).unwrap().current();
@@ -473,7 +471,7 @@
let values = vec![0, 1, 2, 3, 4, 5, 6, 7];
let mut counts = [0; 8];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = select(values);
for _ in 0..1024 {
@@ -498,7 +496,7 @@
#[test]
fn subseq_empty_vec_works() {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = subsequence(Vec::<()>::new(), 0..1);
assert_eq!(Vec::<()>::new(), input.new_tree(&mut runner).unwrap().current());
}
@@ -506,14 +504,14 @@
#[test]
fn subseq_full_vec_works() {
let v = vec![1u32, 2u32, 3u32];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = subsequence(v.clone(), 3);
assert_eq!(v, input.new_tree(&mut runner).unwrap().current());
}
#[test]
fn index_works() {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = any::<Index>();
let col = vec!["foo", "bar", "baz"];
let mut seen = BTreeSet::new();
@@ -532,7 +530,7 @@
#[test]
fn selector_works() {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let input = any::<Selector>();
let col: BTreeSet<&str> = vec!["foo", "bar", "baz"].into_iter().collect();
let mut seen = BTreeSet::new();
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/filter.rs b/third_party/rust_crates/vendor/proptest/src/strategy/filter.rs
index c6b2809..5dbc62f 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/filter.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/filter.rs
@@ -7,10 +7,10 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::{fmt, Arc};
+use crate::std_facade::{fmt, Arc};
-use strategy::traits::*;
-use test_runner::*;
+use crate::strategy::traits::*;
+use crate::test_runner::*;
/// `Strategy` and `ValueTree` filter adaptor.
///
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/filter_map.rs b/third_party/rust_crates/vendor/proptest/src/strategy/filter_map.rs
index 2bd7fe5..3f3fa88 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/filter_map.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/filter_map.rs
@@ -7,10 +7,10 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::{fmt, Arc, Cell};
+use crate::std_facade::{fmt, Arc, Cell};
-use strategy::traits::*;
-use test_runner::*;
+use crate::strategy::traits::*;
+use crate::test_runner::*;
/// `Strategy` and `ValueTree` filter_map adaptor.
///
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/flatten.rs b/third_party/rust_crates/vendor/proptest/src/strategy/flatten.rs
index 8be7804..2b0f860 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/flatten.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/flatten.rs
@@ -8,11 +8,11 @@
// except according to those terms.
use core::mem;
-use std_facade::{fmt, Arc};
+use crate::std_facade::{fmt, Arc};
-use strategy::fuse::Fuse;
-use strategy::traits::*;
-use test_runner::*;
+use crate::strategy::fuse::Fuse;
+use crate::strategy::traits::*;
+use crate::test_runner::*;
/// Adaptor that flattens a `Strategy` which produces other `Strategy`s into a
/// `Strategy` that picks one of those strategies and then picks values from
@@ -224,7 +224,7 @@
impl<S : Strategy, R : Strategy,
F : Fn(S::Value) -> R>
Strategy for IndFlattenMap<S, F> {
- type Tree = ::tuple::TupleValueTree<(S::Tree, R::Tree)>;
+ type Tree = crate::tuple::TupleValueTree<(S::Tree, R::Tree)>;
type Value = (S::Value, R::Value);
fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
@@ -232,13 +232,13 @@
let right_source = (self.fun)(left.current());
let right = right_source.new_tree(runner)?;
- Ok(::tuple::TupleValueTree::new((left, right)))
+ Ok(crate::tuple::TupleValueTree::new((left, right)))
}
}
#[cfg(test)]
mod test {
- use strategy::just::Just;
+ use crate::strategy::just::Just;
use super::*;
#[test]
@@ -250,8 +250,8 @@
|a| (Just(a), (a-5..a+5)));
let mut failures = 0;
+ let mut runner = TestRunner::deterministic();
for _ in 0..1000 {
- let mut runner = TestRunner::default();
let case = input.new_tree(&mut runner).unwrap();
let result = runner.run_one(case, |(a, b)| {
if a <= 10000 || b <= a {
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/fuse.rs b/third_party/rust_crates/vendor/proptest/src/strategy/fuse.rs
index 5ecb353..2a6a8c6 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/fuse.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/fuse.rs
@@ -7,8 +7,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use strategy::*;
-use test_runner::*;
+use crate::strategy::*;
+use crate::test_runner::*;
/// Adaptor for `Strategy` and `ValueTree` which guards `simplify()` and
/// `complicate()` to avoid contract violations.
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/just.rs b/third_party/rust_crates/vendor/proptest/src/strategy/just.rs
index d769349..d813cbb 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/just.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/just.rs
@@ -7,10 +7,10 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::fmt;
+use crate::std_facade::fmt;
-use strategy::{Strategy, ValueTree, NewTree};
-use test_runner::TestRunner;
+use crate::strategy::{Strategy, ValueTree, NewTree};
+use crate::test_runner::TestRunner;
macro_rules! noshrink {
() => {
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/map.rs b/third_party/rust_crates/vendor/proptest/src/strategy/map.rs
index 1210602..3703dc3 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/map.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/map.rs
@@ -9,10 +9,10 @@
use core::fmt;
use core::marker::PhantomData;
-use std_facade::Arc;
+use crate::std_facade::Arc;
-use strategy::traits::*;
-use test_runner::*;
+use crate::strategy::traits::*;
+use crate::test_runner::*;
//==============================================================================
// Map
@@ -243,7 +243,7 @@
use rand::RngCore;
- use strategy::just::Just;
+ use crate::strategy::just::Just;
use super::*;
#[test]
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/recursive.rs b/third_party/rust_crates/vendor/proptest/src/strategy/recursive.rs
index bd9b459..262dd9b 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/recursive.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/recursive.rs
@@ -7,11 +7,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::{fmt, Arc, Box, Vec};
+use crate::std_facade::{fmt, Arc, Box, Vec};
-use strategy::traits::*;
-use strategy::unions::float_to_weight;
-use test_runner::*;
+use crate::strategy::traits::*;
+use crate::strategy::unions::float_to_weight;
+use crate::test_runner::*;
/// Return type from `Strategy::prop_recursive()`.
#[must_use = "strategies do nothing unless used"]
@@ -134,7 +134,7 @@
mod test {
use std::cmp::max;
- use strategy::just::Just;
+ use crate::strategy::just::Just;
use super::*;
#[derive(Clone, Debug, PartialEq)]
@@ -168,9 +168,9 @@
let mut max_count = 0;
let strat = Just(Tree::Leaf).prop_recursive(4, 64, 16,
- |element| ::collection::vec(element, 8..16).prop_map(Tree::Branch));
+ |element| crate::collection::vec(element, 8..16).prop_map(Tree::Branch));
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..65536 {
let tree = strat.new_tree(&mut runner).unwrap().current();
let (depth, count) = tree.stats();
@@ -187,9 +187,9 @@
#[test]
fn simplifies_to_non_recursive() {
let strat = Just(Tree::Leaf).prop_recursive(4, 64, 16,
- |element| ::collection::vec(element, 8..16).prop_map(Tree::Branch));
+ |element| crate::collection::vec(element, 8..16).prop_map(Tree::Branch));
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..256 {
let mut value = strat.new_tree(&mut runner).unwrap();
while value.simplify() { }
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/shuffle.rs b/third_party/rust_crates/vendor/proptest/src/strategy/shuffle.rs
index ed1c8bf..640c3ef 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/shuffle.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/shuffle.rs
@@ -7,13 +7,13 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::{Cell, VecDeque, Vec};
+use crate::std_facade::{Cell, VecDeque, Vec};
use rand::Rng;
-use num;
-use strategy::traits::*;
-use test_runner::*;
+use crate::num;
+use crate::strategy::traits::*;
+use crate::test_runner::*;
/// `Strategy` shuffle adaptor.
///
@@ -204,8 +204,8 @@
use std::collections::HashSet;
use std::i32;
- use collection;
- use strategy::just::Just;
+ use crate::collection;
+ use crate::strategy::just::Just;
use super::*;
static VALUES: &'static [i32] = &[
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/statics.rs b/third_party/rust_crates/vendor/proptest/src/strategy/statics.rs
index e4a90de..81ac09f 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/statics.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/statics.rs
@@ -24,10 +24,10 @@
//! **This module is subject to removal at some point after the language
//! features linked above become stable.**
-use std_facade::fmt;
+use crate::std_facade::fmt;
-use strategy::traits::*;
-use test_runner::*;
+use crate::strategy::traits::*;
+use crate::test_runner::*;
//==============================================================================
// Filter
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/traits.rs b/third_party/rust_crates/vendor/proptest/src/strategy/traits.rs
index fd1c362..915eed6 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/traits.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/traits.rs
@@ -8,10 +8,10 @@
// except according to those terms.
use core::cmp;
-use std_facade::{fmt, Box, Rc, Arc};
+use crate::std_facade::{fmt, Box, Rc, Arc};
-use strategy::*;
-use test_runner::*;
+use crate::strategy::*;
+use crate::test_runner::*;
//==============================================================================
// Traits
@@ -28,15 +28,12 @@
/// [`Err`]: https://doc.rust-lang.org/nightly/std/result/enum.Result.html#variant.Err
pub type NewTree<S> = Result<<S as Strategy>::Tree, Reason>;
-/// The value that functions under test use for a particular `Strategy`.
-#[deprecated(since = "0.8.0", note="please use `S::Value` instead")]
-pub type ValueFor<S> = <<S as Strategy>::Tree as ValueTree>::Value;
-
/// A strategy for producing arbitrary values of a given type.
///
/// `fmt::Debug` is a hard requirement for all strategies currently due to
/// `prop_flat_map()`. This constraint will be removed when specialisation
/// becomes stable.
+#[must_use = "strategies do nothing unless used"]
pub trait Strategy : fmt::Debug {
/// The value tree generated by this `Strategy`.
type Tree : ValueTree<Value = Self::Value>;
@@ -68,6 +65,12 @@
/// There is no need (or possibility, for that matter) to define how the
/// output is to be shrunken. Shrinking continues to take place in terms of
/// the source value.
+ ///
+ /// `fun` should be a deterministic function. That is, for a given input
+ /// value, it should produce an equivalent output value on every call.
+ /// Proptest assumes that it can call the function as many times as needed
+ /// to generate as many identical values as needed. For this reason, `F` is
+ /// `Fn` rather than `FnMut`.
fn prop_map<O : fmt::Debug,
F : Fn (Self::Value) -> O>
(self, fun: F) -> Map<Self, F>
@@ -107,7 +110,6 @@
/// ## Example
///
/// ```
- /// #[macro_use] extern crate proptest;
/// // The prelude also gets us the `Rng` trait.
/// use proptest::prelude::*;
///
@@ -161,8 +163,6 @@
/// without using filtering:
///
/// ```
- /// #[macro_use] extern crate proptest;
- ///
/// use proptest::prelude::*;
///
/// proptest! {
@@ -366,7 +366,6 @@
/// # #![allow(unused_variables)]
/// use std::collections::HashMap;
///
- /// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// /// Define our own JSON AST type
@@ -428,7 +427,6 @@
/// ## Example
///
/// ```
- /// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// static VALUES: &'static [u32] = &[0, 1, 2, 3, 4];
diff --git a/third_party/rust_crates/vendor/proptest/src/strategy/unions.rs b/third_party/rust_crates/vendor/proptest/src/strategy/unions.rs
index 40aa266..6573333 100644
--- a/third_party/rust_crates/vendor/proptest/src/strategy/unions.rs
+++ b/third_party/rust_crates/vendor/proptest/src/strategy/unions.rs
@@ -9,14 +9,14 @@
use core::cmp::{max, min};
use core::u32;
-use std_facade::Vec;
+use crate::std_facade::Vec;
#[cfg(not(feature="std"))]
use num_traits::float::FloatCore;
-use num::sample_uniform;
-use strategy::traits::*;
-use test_runner::*;
+use crate::num::sample_uniform;
+use crate::strategy::traits::*;
+use crate::test_runner::*;
/// A **relative** `weight` of a particular `Strategy` corresponding to `T`
/// coupled with `T` itself. The weight is currently given in `u32`.
@@ -335,7 +335,7 @@
#[cfg(test)]
mod test {
- use strategy::just::Just;
+ use crate::strategy::just::Just;
use super::*;
// FIXME(2018-06-01): figure out a way to run this test on no_std.
@@ -353,8 +353,8 @@
let mut passed = 0;
let mut converged_low = 0;
let mut converged_high = 0;
+ let mut runner = TestRunner::deterministic();
for _ in 0..256 {
- let mut runner = TestRunner::default();
let case = input.new_tree(&mut runner).unwrap();
let result = runner.run_one(case, |v| {
prop_assert!(v < 15);
@@ -386,7 +386,7 @@
]);
let mut counts = [0, 0, 0];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..65536 {
counts[input.new_tree(&mut runner).unwrap().current()] += 1;
}
@@ -421,8 +421,8 @@
let mut passed = 0;
let mut converged_low = 0;
let mut converged_high = 0;
+ let mut runner = TestRunner::deterministic();
for _ in 0..256 {
- let mut runner = TestRunner::default();
let case = input.new_tree(&mut runner).unwrap();
let result = runner.run_one(case, |v| {
prop_assert!(v < 15);
@@ -454,7 +454,7 @@
));
let mut counts = [0, 0, 0];
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..65536 {
counts[input.new_tree(&mut runner).unwrap().current()] += 1;
}
@@ -468,7 +468,7 @@
#[test]
fn test_tuple_union_all_sizes() {
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
let r = 1i32..10;
macro_rules! test {
diff --git a/third_party/rust_crates/vendor/proptest/src/string.rs b/third_party/rust_crates/vendor/proptest/src/string.rs
index 4fa75d8..7681f00 100644
--- a/third_party/rust_crates/vendor/proptest/src/string.rs
+++ b/third_party/rust_crates/vendor/proptest/src/string.rs
@@ -14,7 +14,7 @@
use core::fmt;
use core::ops::RangeInclusive;
use core::u32;
-use std_facade::{Cow, Box, String, Vec, ToOwned};
+use crate::std_facade::{Cow, Box, String, Vec, ToOwned};
use regex_syntax::{Parser, Error as ParseError};
use regex_syntax::hir::{
@@ -22,11 +22,11 @@
RepetitionKind::{self, *}, RepetitionRange::*
};
-use bool;
-use char;
-use collection::{vec, size_range, SizeRange};
-use strategy::*;
-use test_runner::*;
+use crate::bool;
+use crate::char;
+use crate::collection::{vec, size_range, SizeRange};
+use crate::strategy::*;
+use crate::test_runner::*;
/// Wraps the regex that forms the `Strategy` for `String` so that a sensible
/// `Default` can be given. The default is a string of non-control characters.
@@ -100,6 +100,37 @@
type ParseResult<T> = Result<RegexGeneratorStrategy<T>, Error>;
+#[doc(hidden)]
+/// A type which knows how to produce a `Strategy` from a regular expression
+/// generating the type.
+///
+/// This trait exists for the benefit of `#[proptest(regex = "...")]`.
+/// It is semver extempt, so use at your own risk.
+/// If you found a use for the trait beyond `Vec<u8>` and `String`,
+/// please file an issue at https://github.com/AltSysrq/proptest.
+pub trait StrategyFromRegex: Sized + fmt::Debug {
+ type Strategy: Strategy<Value = Self>;
+
+ /// Produce a strategy for `Self` from the `regex`.
+ fn from_regex(regex: &str) -> Self::Strategy;
+}
+
+impl StrategyFromRegex for String {
+ type Strategy = RegexGeneratorStrategy<Self>;
+
+ fn from_regex(regex: &str) -> Self::Strategy {
+ string_regex(regex).unwrap()
+ }
+}
+
+impl StrategyFromRegex for Vec<u8> {
+ type Strategy = RegexGeneratorStrategy<Self>;
+
+ fn from_regex(regex: &str) -> Self::Strategy {
+ bytes_regex(regex).unwrap()
+ }
+}
+
/// Creates a strategy which generates strings matching the given regular
/// expression.
///
@@ -307,7 +338,7 @@
let mut generated = HashSet::new();
let strategy = string_regex(pattern).unwrap();
- let mut runner = TestRunner::default();
+ let mut runner = TestRunner::deterministic();
for _ in 0..iterations {
let mut value = strategy.new_tree(&mut runner).unwrap();
diff --git a/third_party/rust_crates/vendor/proptest/src/sugar.rs b/third_party/rust_crates/vendor/proptest/src/sugar.rs
index 3ddb06a3..0d71f2f 100644
--- a/third_party/rust_crates/vendor/proptest/src/sugar.rs
+++ b/third_party/rust_crates/vendor/proptest/src/sugar.rs
@@ -1,5 +1,5 @@
//-
-// Copyright 2017 Jason Lingle
+// Copyright 2017, 2019 The proptest developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
@@ -7,7 +7,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::fmt;
+use crate::std_facade::fmt;
/// Easily define `proptest` tests.
///
@@ -23,7 +23,7 @@
/// ### Example
///
/// ```
-/// #[macro_use] extern crate proptest;
+/// use proptest::prelude::*;
///
/// proptest! {
/// # /*
@@ -48,7 +48,7 @@
/// You can also use the normal argument syntax `pattern: type` as in:
///
/// ```rust
-/// #[macro_use] extern crate proptest;
+/// use proptest::prelude::*;
///
/// proptest! {
/// # /*
@@ -79,7 +79,6 @@
/// evaluates to a `proptest::test_runner::Config` (or a reference to one).
///
/// ```
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// proptest! {
@@ -111,7 +110,6 @@
/// ### Example
///
/// ```
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// #[derive(Debug)]
@@ -154,7 +152,7 @@
(#![proptest_config($config:expr)]
$(
$(#[$meta:meta])*
- fn $test_name:ident($($parm:pat in $strategy:expr),+) $body:block
+ fn $test_name:ident($($parm:pat in $strategy:expr),+ $(,)?) $body:block
)*) => {
$(
$(#[$meta])*
@@ -162,7 +160,7 @@
let mut config = $config.clone();
config.test_name = Some(
concat!(module_path!(), "::", stringify!($test_name)));
- proptest_helper!(@_BODY config ($($parm in $strategy),+) [] $body);
+ $crate::proptest_helper!(@_BODY config ($($parm in $strategy),+) [] $body);
}
)*
};
@@ -177,15 +175,15 @@
let mut config = $config.clone();
config.test_name = Some(
concat!(module_path!(), "::", stringify!($test_name)));
- proptest_helper!(@_BODY2 config ($($arg)+) [] $body);
+ $crate::proptest_helper!(@_BODY2 config ($($arg)+) [] $body);
}
)*
};
($(
$(#[$meta:meta])*
- fn $test_name:ident($($parm:pat in $strategy:expr),+) $body:block
- )*) => { proptest! {
+ fn $test_name:ident($($parm:pat in $strategy:expr),+ $(,)?) $body:block
+ )*) => { $crate::proptest! {
#![proptest_config($crate::test_runner::Config::default())]
$($(#[$meta])*
fn $test_name($($parm in $strategy),+) $body)*
@@ -194,58 +192,58 @@
($(
$(#[$meta:meta])*
fn $test_name:ident($($arg:tt)+) $body:block
- )*) => { proptest! {
+ )*) => { $crate::proptest! {
#![proptest_config($crate::test_runner::Config::default())]
$($(#[$meta])*
fn $test_name($($arg)+) $body)*
} };
- (|($($parm:pat in $strategy:expr),+)| $body:expr) => {
- proptest!(
+ (|($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => {
+ $crate::proptest!(
$crate::test_runner::Config::default(),
|($($parm in $strategy),+)| $body)
};
- (move |($($parm:pat in $strategy:expr),+)| $body:expr) => {
- proptest!(
+ (move |($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => {
+ $crate::proptest!(
$crate::test_runner::Config::default(),
move |($($parm in $strategy),+)| $body)
};
(|($($arg:tt)+)| $body:expr) => {
- proptest!(
+ $crate::proptest!(
$crate::test_runner::Config::default(),
|($($arg)+)| $body)
};
(move |($($arg:tt)+)| $body:expr) => {
- proptest!(
+ $crate::proptest!(
$crate::test_runner::Config::default(),
move |($($arg)+)| $body)
};
- ($config:expr, |($($parm:pat in $strategy:expr),+)| $body:expr) => { {
+ ($config:expr, |($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => { {
let mut config = $config.__sugar_to_owned();
$crate::sugar::force_no_fork(&mut config);
- proptest_helper!(@_BODY config ($($parm in $strategy),+) [] $body)
+ $crate::proptest_helper!(@_BODY config ($($parm in $strategy),+) [] $body)
} };
- ($config:expr, move |($($parm:pat in $strategy:expr),+)| $body:expr) => { {
+ ($config:expr, move |($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => { {
let mut config = $config.__sugar_to_owned();
$crate::sugar::force_no_fork(&mut config);
- proptest_helper!(@_BODY config ($($parm in $strategy),+) [move] $body)
+ $crate::proptest_helper!(@_BODY config ($($parm in $strategy),+) [move] $body)
} };
($config:expr, |($($arg:tt)+)| $body:expr) => { {
let mut config = $config.__sugar_to_owned();
$crate::sugar::force_no_fork(&mut config);
- proptest_helper!(@_BODY2 config ($($arg)+) [] $body);
+ $crate::proptest_helper!(@_BODY2 config ($($arg)+) [] $body);
} };
($config:expr, move |($($arg:tt)+)| $body:expr) => { {
let mut config = $config.__sugar_to_owned();
$crate::sugar::force_no_fork(&mut config);
- proptest_helper!(@_BODY2 config ($($arg)+) [move] $body);
+ $crate::proptest_helper!(@_BODY2 config ($($arg)+) [move] $body);
} };
}
@@ -262,10 +260,10 @@
#[macro_export]
macro_rules! prop_assume {
($expr:expr) => {
- prop_assume!($expr, "{}", stringify!($expr))
+ $crate::prop_assume!($expr, "{}", stringify!($expr))
};
- ($expr:expr, $fmt:tt $(, $fmt_arg:expr),*) => {
+ ($expr:expr, $fmt:tt $(, $fmt_arg:expr),* $(,)?) => {
if !$expr {
return ::std::result::Result::Err(
$crate::test_runner::TestCaseError::reject(
@@ -298,7 +296,6 @@
/// ## Example
///
/// ```rust,no_run
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// #[derive(Clone, Copy, Debug)]
@@ -328,23 +325,23 @@
/// ```
#[macro_export]
macro_rules! prop_oneof {
- ($($item:expr),+ $(,)*) => {
- prop_oneof![
+ ($($item:expr),+ $(,)?) => {
+ $crate::prop_oneof![
$(1 => $item),*
]
};
- ($_weight0:expr => $item0:expr $(,)*) => { $item0 };
+ ($_weight0:expr => $item0:expr $(,)?) => { $item0 };
($weight0:expr => $item0:expr,
- $weight1:expr => $item1:expr $(,)*) => {
+ $weight1:expr => $item1:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1)))
};
($weight0:expr => $item0:expr,
$weight1:expr => $item1:expr,
- $weight2:expr => $item2:expr $(,)*) => {
+ $weight2:expr => $item2:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2)))
@@ -353,7 +350,7 @@
($weight0:expr => $item0:expr,
$weight1:expr => $item1:expr,
$weight2:expr => $item2:expr,
- $weight3:expr => $item3:expr $(,)*) => {
+ $weight3:expr => $item3:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2), ($weight3, $item3)))
@@ -363,7 +360,7 @@
$weight1:expr => $item1:expr,
$weight2:expr => $item2:expr,
$weight3:expr => $item3:expr,
- $weight4:expr => $item4:expr $(,)*) => {
+ $weight4:expr => $item4:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2), ($weight3, $item3),
@@ -375,7 +372,7 @@
$weight2:expr => $item2:expr,
$weight3:expr => $item3:expr,
$weight4:expr => $item4:expr,
- $weight5:expr => $item5:expr $(,)*) => {
+ $weight5:expr => $item5:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2), ($weight3, $item3),
@@ -388,7 +385,7 @@
$weight3:expr => $item3:expr,
$weight4:expr => $item4:expr,
$weight5:expr => $item5:expr,
- $weight6:expr => $item6:expr $(,)*) => {
+ $weight6:expr => $item6:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2), ($weight3, $item3),
@@ -403,7 +400,7 @@
$weight4:expr => $item4:expr,
$weight5:expr => $item5:expr,
$weight6:expr => $item6:expr,
- $weight7:expr => $item7:expr $(,)*) => {
+ $weight7:expr => $item7:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2), ($weight3, $item3),
@@ -419,7 +416,7 @@
$weight5:expr => $item5:expr,
$weight6:expr => $item6:expr,
$weight7:expr => $item7:expr,
- $weight8:expr => $item8:expr $(,)*) => {
+ $weight8:expr => $item8:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2), ($weight3, $item3),
@@ -437,7 +434,7 @@
$weight6:expr => $item6:expr,
$weight7:expr => $item7:expr,
$weight8:expr => $item8:expr,
- $weight9:expr => $item9:expr $(,)*) => {
+ $weight9:expr => $item9:expr $(,)?) => {
$crate::strategy::TupleUnion::new(
(($weight0, $item0), ($weight1, $item1),
($weight2, $item2), ($weight3, $item3),
@@ -446,7 +443,7 @@
($weight8, $item8), ($weight9, $item9)))
};
- ($($weight:expr => $item:expr),+ $(,)*) => {
+ ($($weight:expr => $item:expr),+ $(,)?) => {
$crate::strategy::Union::new_weighted(vec![
$(($weight, $crate::strategy::Strategy::boxed($item))),*
])
@@ -466,7 +463,7 @@
///
/// ```rust,no_run
/// # #![allow(dead_code)]
-/// #[macro_use] extern crate proptest;
+/// use proptest::prelude::*;
///
/// #[derive(Clone, Debug)]
/// struct MyStruct {
@@ -490,8 +487,8 @@
///
/// ```rust,no_run
/// # #![allow(dead_code)]
-/// # #[macro_use] extern crate proptest;
-///
+/// # use proptest::prelude::*;
+/// #
/// # #[derive(Clone, Debug)]
/// # struct MyStruct {
/// # integer: u32,
@@ -515,7 +512,7 @@
///
/// ```rust,no_run
/// # #![allow(dead_code)]
-/// #[macro_use] extern crate proptest;
+/// use proptest::prelude::*;
///
/// prop_compose! {
/// fn nearby_numbers()(centre in -1000..1000)
@@ -535,7 +532,6 @@
///
/// ```rust,no_run
/// # #![allow(dead_code)]
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// prop_compose! {
@@ -554,16 +550,15 @@
/// The second form is sugar around making a strategy tuple, calling
/// `prop_flat_map()`, then `prop_map()`.
///
-/// To give the function a visibility or unsafe modifier, put it in brackets
-/// before the `fn` token.
+/// To give the function any modifier which isn't a visibility modifier, put it
+/// in brackets before the `fn` token but after any visibility modifier.
///
/// ```rust,no_run
/// # #![allow(dead_code)]
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// prop_compose! {
-/// [pub(crate) unsafe] fn pointer()(v in prop::num::usize::ANY)
+/// pub(crate) [unsafe] fn pointer()(v in prop::num::usize::ANY)
/// -> *const () {
/// v as *const ()
/// }
@@ -586,72 +581,80 @@
#[macro_export]
macro_rules! prop_compose {
($(#[$meta:meta])*
- $([$($vis:tt)*])* fn $name:ident $params:tt
- ($($var:pat in $strategy:expr),+ $(,)*)
+ $vis:vis
+ $([$($modi:tt)*])? fn $name:ident $params:tt
+ ($($var:pat in $strategy:expr),+ $(,)?)
-> $return_type:ty $body:block) =>
{
#[must_use = "strategies do nothing unless used"]
$(#[$meta])*
- $($($vis)*)* fn $name $params
+ $vis
+ $($($modi)*)? fn $name $params
-> impl $crate::strategy::Strategy<Value = $return_type> {
- let strat = proptest_helper!(@_WRAP ($($strategy)*));
+ let strat = $crate::proptest_helper!(@_WRAP ($($strategy)*));
$crate::strategy::Strategy::prop_map(strat,
- |proptest_helper!(@_WRAPPAT ($($var),*))| $body)
+ move |$crate::proptest_helper!(@_WRAPPAT ($($var),*))| $body)
}
};
($(#[$meta:meta])*
- $([$($vis:tt)*])* fn $name:ident $params:tt
- ($($var:pat in $strategy:expr),+ $(,)*)
- ($($var2:pat in $strategy2:expr),+ $(,)*)
+ $vis:vis
+ $([$($modi:tt)*])? fn $name:ident $params:tt
+ ($($var:pat in $strategy:expr),+ $(,)?)
+ ($($var2:pat in $strategy2:expr),+ $(,)?)
-> $return_type:ty $body:block) =>
{
#[must_use = "strategies do nothing unless used"]
$(#[$meta])*
- $($($vis)*)* fn $name $params
+ $vis
+ $($($modi)*)? fn $name $params
-> impl $crate::strategy::Strategy<Value = $return_type> {
- let strat = proptest_helper!(@_WRAP ($($strategy)*));
+ let strat = $crate::proptest_helper!(@_WRAP ($($strategy)*));
let strat = $crate::strategy::Strategy::prop_flat_map(
strat,
- |proptest_helper!(@_WRAPPAT ($($var),*))|
- proptest_helper!(@_WRAP ($($strategy2)*)));
+ move |$crate::proptest_helper!(@_WRAPPAT ($($var),*))|
+ $crate::proptest_helper!(@_WRAP ($($strategy2)*)));
$crate::strategy::Strategy::prop_map(strat,
- |proptest_helper!(@_WRAPPAT ($($var2),*))| $body)
+ move |$crate::proptest_helper!(@_WRAPPAT ($($var2),*))| $body)
}
};
($(#[$meta:meta])*
- $([$($vis:tt)*])* fn $name:ident $params:tt
+ $vis:vis
+ $([$($modi:tt)*])? fn $name:ident $params:tt
($($arg:tt)+)
-> $return_type:ty $body:block) =>
{
#[must_use = "strategies do nothing unless used"]
$(#[$meta])*
- $($($vis)*)* fn $name $params
+ $vis
+ $($($modi)*)? fn $name $params
-> impl $crate::strategy::Strategy<Value = $return_type> {
- let strat = proptest_helper!(@_EXT _STRAT ($($arg)+));
+ let strat = $crate::proptest_helper!(@_EXT _STRAT ($($arg)+));
$crate::strategy::Strategy::prop_map(strat,
- |proptest_helper!(@_EXT _PAT ($($arg)+))| $body)
+ move |$crate::proptest_helper!(@_EXT _PAT ($($arg)+))| $body)
}
};
($(#[$meta:meta])*
- $([$($vis:tt)*])* fn $name:ident $params:tt
- ($($arg:tt)+ $(,)*)
- ($($arg2:tt)+ $(,)*)
+ $vis:vis
+ $([$($modi:tt)*])? fn $name:ident $params:tt
+ ($($arg:tt)+ $(,)?)
+ ($($arg2:tt)+ $(,)?)
-> $return_type:ty $body:block) =>
{
#[must_use = "strategies do nothing unless used"]
$(#[$meta])*
- $($($vis)*)* fn $name $params
+ $vis
+ $($($modi)*)? fn $name $params
-> impl $crate::strategy::Strategy<Value = $return_type> {
- let strat = proptest_helper!(@_WRAP ($($strategy)*));
+ let strat = $crate::proptest_helper!(@_WRAP ($($strategy)*));
let strat = $crate::strategy::Strategy::prop_flat_map(
strat,
- |proptest_helper!(@_EXT _PAT ($($arg)+))|
- proptest_helper!(@_EXT _STRAT ($($arg2)*)));
+ move |$crate::proptest_helper!(@_EXT _PAT ($($arg)+))|
+ $crate::proptest_helper!(@_EXT _STRAT ($($arg2)*)));
$crate::strategy::Strategy::prop_map(strat,
- |proptest_helper!(@_EXT _PAT ($($arg2)*))| $body)
+ move |$crate::proptest_helper!(@_EXT _PAT ($($arg2)*))| $body)
}
};
}
@@ -672,7 +675,6 @@
/// ## Example
///
/// ```
-/// #[macro_use] extern crate proptest;
/// use proptest::prelude::*;
///
/// proptest! {
@@ -703,7 +705,7 @@
#[macro_export]
macro_rules! prop_assert {
($cond:expr) => {
- prop_assert!($cond, concat!("assertion failed: ", stringify!($cond)))
+ $crate::prop_assert!($cond, concat!("assertion failed: ", stringify!($cond)))
};
($cond:expr, $($fmt:tt)*) => {
@@ -724,7 +726,7 @@
/// ## Example
///
/// ```
-/// #[macro_use] extern crate proptest;
+/// use proptest::prelude::*;
///
/// proptest! {
/// # /*
@@ -748,18 +750,20 @@
($left:expr, $right:expr) => {{
let left = $left;
let right = $right;
- prop_assert!(left == right, "assertion failed: `(left == right)` \
- (left: `{:?}`, right: `{:?}`)",
- left, right);
+ $crate::prop_assert!(
+ left == right,
+ "assertion failed: `(left == right)` (left: `{:?}`, right: `{:?}`)",
+ left, right);
}};
($left:expr, $right:expr, $fmt:tt $($args:tt)*) => {{
let left = $left;
let right = $right;
- prop_assert!(left == right, concat!(
- "assertion failed: `(left == right)` \
- (left: `{:?}`, right: `{:?}`): ", $fmt),
- left, right $($args)*);
+ $crate::prop_assert!(
+ left == right,
+ concat!(
+ "assertion failed: `(left == right)` (left: `{:?}`, right: `{:?}`): ", $fmt),
+ left, right $($args)*);
}};
}
@@ -792,7 +796,7 @@
($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8, $a9)
};
(@_WRAP ($a:tt $($rest:tt)*)) => {
- ($a, proptest_helper!(@_WRAP ($($rest)*)))
+ ($a, $crate::proptest_helper!(@_WRAP ($($rest)*)))
};
(@_WRAPPAT ($item:pat)) => { $item };
(@_WRAPPAT ($a0:pat, $a1:pat)) => { ($a0, $a1) };
@@ -823,7 +827,7 @@
($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8, $a9)
};
(@_WRAPPAT ($a:pat, $($rest:pat),*)) => {
- ($a, proptest_helper!(@_WRAPPAT ($($rest),*)))
+ ($a, $crate::proptest_helper!(@_WRAPPAT ($($rest),*)))
};
(@_WRAPSTR ($item:pat)) => { stringify!($item) };
(@_WRAPSTR ($a0:pat, $a1:pat)) => { (stringify!($a0), stringify!($a1)) };
@@ -864,19 +868,19 @@
stringify!($a8), stringify!($a9))
};
(@_WRAPSTR ($a:pat, $($rest:pat),*)) => {
- (stringify!($a), proptest_helper!(@_WRAPSTR ($($rest),*)))
+ (stringify!($a), $crate::proptest_helper!(@_WRAPSTR ($($rest),*)))
};
// build a property testing block that when executed, executes the full property test.
(@_BODY $config:ident ($($parm:pat in $strategy:expr),+) [$($mod:tt)*] $body:expr) => {{
$config.source_file = Some(file!());
let mut runner = $crate::test_runner::TestRunner::new($config);
- let names = proptest_helper!(@_WRAPSTR ($($parm),*));
+ let names = $crate::proptest_helper!(@_WRAPSTR ($($parm),*));
match runner.run(
&$crate::strategy::Strategy::prop_map(
- proptest_helper!(@_WRAP ($($strategy)*)),
+ $crate::proptest_helper!(@_WRAP ($($strategy)*)),
|values| $crate::sugar::NamedArguments(names, values)),
$($mod)* |$crate::sugar::NamedArguments(
- _, proptest_helper!(@_WRAPPAT ($($parm),*)))|
+ _, $crate::proptest_helper!(@_WRAPPAT ($($parm),*)))|
{
$body;
Ok(())
@@ -890,13 +894,13 @@
(@_BODY2 $config:ident ($($arg:tt)+) [$($mod:tt)*] $body:expr) => {{
$config.source_file = Some(file!());
let mut runner = $crate::test_runner::TestRunner::new($config);
- let names = proptest_helper!(@_EXT _STR ($($arg)*));
+ let names = $crate::proptest_helper!(@_EXT _STR ($($arg)*));
match runner.run(
&$crate::strategy::Strategy::prop_map(
- proptest_helper!(@_EXT _STRAT ($($arg)*)),
+ $crate::proptest_helper!(@_EXT _STRAT ($($arg)*)),
|values| $crate::sugar::NamedArguments(names, values)),
$($mod)* |$crate::sugar::NamedArguments(
- _, proptest_helper!(@_EXT _PAT ($($arg)*)))|
+ _, $crate::proptest_helper!(@_EXT _PAT ($($arg)*)))|
{
$body;
Ok(())
@@ -921,56 +925,56 @@
// We have to do this because `:` can't FOLLOW(pat).
// Note that this is not the full `pat` grammar...
// See https://docs.rs/syn/0.14.2/syn/enum.Pat.html for that.
- (@_EXT $cmd:ident ($p:pat in $s:expr $(,)*)) => {
- proptest_helper!(@$cmd in [$s] [$p])
+ (@_EXT $cmd:ident ($p:pat in $s:expr $(,)?)) => {
+ $crate::proptest_helper!(@$cmd in [$s] [$p])
};
- (@_EXT $cmd:ident (($p:pat) : $s:ty $(,)*)) => {
+ (@_EXT $cmd:ident (($p:pat) : $s:ty $(,)?)) => {
// Users can wrap in parens as a last resort.
- proptest_helper!(@$cmd [$s] [$p])
+ $crate::proptest_helper!(@$cmd [$s] [$p])
};
- (@_EXT $cmd:ident (_ : $s:ty $(,)*)) => {
- proptest_helper!(@$cmd [$s] [_])
+ (@_EXT $cmd:ident (_ : $s:ty $(,)?)) => {
+ $crate::proptest_helper!(@$cmd [$s] [_])
};
- (@_EXT $cmd:ident (ref mut $p:ident : $s:ty $(,)*)) => {
- proptest_helper!(@$cmd [$s] [ref mut $p])
+ (@_EXT $cmd:ident (ref mut $p:ident : $s:ty $(,)?)) => {
+ $crate::proptest_helper!(@$cmd [$s] [ref mut $p])
};
- (@_EXT $cmd:ident (ref $p:ident : $s:ty $(,)*)) => {
- proptest_helper!(@$cmd [$s] [ref $p])
+ (@_EXT $cmd:ident (ref $p:ident : $s:ty $(,)?)) => {
+ $crate::proptest_helper!(@$cmd [$s] [ref $p])
};
- (@_EXT $cmd:ident (mut $p:ident : $s:ty $(,)*)) => {
- proptest_helper!(@$cmd [$s] [mut $p])
+ (@_EXT $cmd:ident (mut $p:ident : $s:ty $(,)?)) => {
+ $crate::proptest_helper!(@$cmd [$s] [mut $p])
};
- (@_EXT $cmd:ident ($p:ident : $s:ty $(,)*)) => {
- proptest_helper!(@$cmd [$s] [$p])
+ (@_EXT $cmd:ident ($p:ident : $s:ty $(,)?)) => {
+ $crate::proptest_helper!(@$cmd [$s] [$p])
};
- (@_EXT $cmd:ident ([$($p:tt)*] : $s:ty $(,)*)) => {
- proptest_helper!(@$cmd [$s] [[$($p)*]])
+ (@_EXT $cmd:ident ([$($p:tt)*] : $s:ty $(,)?)) => {
+ $crate::proptest_helper!(@$cmd [$s] [[$($p)*]])
};
// Rewrite, Inductive case:
(@_EXT $cmd:ident ($p:pat in $s:expr, $($r:tt)*)) => {
- (proptest_helper!(@$cmd in [$s] [$p]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd in [$s] [$p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
(@_EXT $cmd:ident (($p:pat) : $s:ty, $($r:tt)*)) => {
- (proptest_helper!(@$cmd [$s] [$p]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd [$s] [$p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
(@_EXT $cmd:ident (_ : $s:ty, $($r:tt)*)) => {
- (proptest_helper!(@$cmd [$s] [_]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd [$s] [_]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
(@_EXT $cmd:ident (ref mut $p:ident : $s:ty, $($r:tt)*)) => {
- (proptest_helper!(@$cmd [$s] [ref mut $p]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd [$s] [ref mut $p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
(@_EXT $cmd:ident (ref $p:ident : $s:ty, $($r:tt)*)) => {
- (proptest_helper!(@$cmd [$s] [ref $p]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd [$s] [ref $p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
(@_EXT $cmd:ident (mut $p:ident : $s:ty, $($r:tt)*)) => {
- (proptest_helper!(@$cmd [$s] [mut $p]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd [$s] [mut $p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
(@_EXT $cmd:ident ($p:ident : $s:ty, $($r:tt)*)) => {
- (proptest_helper!(@$cmd [$s] [$p]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd [$s] [$p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
(@_EXT $cmd:ident ([$($p:tt)*] : $s:ty, $($r:tt)*)) => {
- (proptest_helper!(@$cmd [$s] [[$($p)*]]), proptest_helper!(@_EXT $cmd ($($r)*)))
+ ($crate::proptest_helper!(@$cmd [$s] [[$($p)*]]), $crate::proptest_helper!(@_EXT $cmd ($($r)*)))
};
}
@@ -1053,7 +1057,7 @@
/// ## Example
///
/// ```
-/// #[macro_use] extern crate proptest;
+/// use proptest::prelude::*;
///
/// proptest! {
/// # /*
@@ -1091,7 +1095,7 @@
#[cfg(feature = "std")]
#[doc(hidden)]
-pub fn force_no_fork(config: &mut ::test_runner::Config) {
+pub fn force_no_fork(config: &mut crate::test_runner::Config) {
if config.fork() {
eprintln!("proptest: Forking/timeout not supported in closure-style \
invocations; ignoring");
@@ -1107,11 +1111,11 @@
}
#[cfg(not(feature = "std"))]
-pub fn force_no_fork(_: &mut ::test_runner::Config) { }
+pub fn force_no_fork(_: &mut crate::test_runner::Config) { }
#[cfg(test)]
mod test {
- use ::strategy::Just;
+ use crate::strategy::Just;
prop_compose! {
/// These are docs!
@@ -1125,13 +1129,36 @@
prop_compose! {
/// These are docs!
#[allow(dead_code)]
- [pub] fn two_ints_pub(relative: i32)(a in 0..relative, b in relative..)
- -> (i32, i32) {
+ pub fn two_ints_pub(relative: i32)(a in 0..relative, b in relative..)
+ -> (i32, i32) {
(a, b)
}
}
prop_compose! {
+ /// These are docs!
+ #[allow(dead_code)]
+ pub [extern "C"] fn two_ints_pub_with_attrs
+ (relative: i32)(a in 0..relative, b in relative..)
+ -> (i32, i32)
+ {
+ (a, b)
+ }
+ }
+
+ prop_compose! {
+ // The only modifier we can usefully put here is "unsafe", but we want
+ // to keep this crate unsafe-free, even nominally. "const" may
+ // eventually work, but is not allowed right now since the generated
+ // code contains local variables. `extern "C"` is accepted, even though
+ // the result is useless since the return type isn't C-compatible.
+ #[allow(dead_code)]
+ [extern "C"] fn with_modifier(relative: i32)(a in 0..relative) -> i32 {
+ a
+ }
+ }
+
+ prop_compose! {
#[allow(dead_code)]
fn a_less_than_b()(b in 0..1000)(a in 0..b, b in Just(b))
-> (i32, i32) {
@@ -1147,9 +1174,28 @@
}
}
+ prop_compose! {
+ #[allow(dead_code)]
+ fn single_closure_is_move(base: u64)(off in 0..10u64) -> u64 {
+ base + off
+ }
+ }
+
+ prop_compose! {
+ #[allow(dead_code)]
+ fn double_closure_is_move
+ (base: u64)
+ (off1 in 0..10u64)
+ (off2 in off1..off1+10)
+ -> u64
+ {
+ base + off2
+ }
+ }
+
#[allow(unused_variables)]
mod test_arg_counts {
- use strategy::Just;
+ use crate::strategy::Just;
proptest! {
#[test]
@@ -1223,12 +1269,12 @@
#[test]
fn oneof_all_counts() {
- use ::strategy::{Strategy, TupleUnion, Union, Just as J};
+ use crate::strategy::{Strategy, TupleUnion, Union, Just as J};
fn expect_count(n: usize, s: impl Strategy<Value = i32>) {
use std::collections::HashSet;
- use strategy::*;
- use test_runner::*;
+ use crate::strategy::*;
+ use crate::test_runner::*;
let mut runner = TestRunner::default();
let mut seen = HashSet::new();
@@ -1334,9 +1380,9 @@
#[cfg(all(test, feature = "timeout"))]
mod test_timeout {
proptest! {
- #![proptest_config(::test_runner::Config {
+ #![proptest_config(crate::test_runner::Config {
fork: true,
- .. ::test_runner::Config::default()
+ .. crate::test_runner::Config::default()
})]
// Ensure that the macro sets the test name properly. If it doesn't,
@@ -1348,12 +1394,13 @@
#[cfg(test)]
mod another_test {
- use sugar;
+ use crate::sugar;
// Ensure that we can access the `[pub]` composed function above.
#[allow(dead_code)]
fn can_access_pub_compose() {
let _ = sugar::test::two_ints_pub(42);
+ let _ = sugar::test::two_ints_pub_with_attrs(42);
}
}
@@ -1363,14 +1410,14 @@
proptest! {
#[test]
fn accept_ref_arg(ref s in "[0-9]") {
- use std_facade::String;
+ use crate::std_facade::String;
fn assert_string(_s: &String) {}
assert_string(s);
}
#[test]
fn accept_move_arg(s in "[0-9]") {
- use std_facade::String;
+ use crate::std_facade::String;
fn assert_string(_s: String) {}
assert_string(s);
}
@@ -1407,6 +1454,15 @@
println!("{}", y);
assert!(x != y);
});
+
+ proptest!(|(y: i32,)| {
+ assert!(x != y);
+ });
+
+ proptest!(|(y in 0..100,)| {
+ println!("{}", y);
+ assert!(x != y);
+ });
}
#[test]
@@ -1438,17 +1494,25 @@
#[test]
fn accepts_unblocked_syntax() {
proptest!(|(x in 0u32..10, y in 10u32..20)| assert!(x < y));
+ proptest!(|(x in 0u32..10, y in 10u32..20,)| assert!(x < y));
}
#[test]
fn accepts_custom_config() {
- let conf = ::test_runner::Config::default();
+ let conf = crate::test_runner::Config::default();
proptest!(conf, |(x in 0u32..10, y in 10u32..20)| assert!(x < y));
proptest!(&conf, |(x in 0u32..10, y in 10u32..20)| assert!(x < y));
proptest!(conf, move |(x in 0u32..10, y in 10u32..20)| assert!(x < y));
proptest!(conf, |(_x: u32, _y: u32)| { });
proptest!(conf, move |(_x: u32, _y: u32)| { });
+
+ // Same as above, but with extra trailing comma
+ proptest!(conf, |(x in 0u32..10, y in 10u32..20,)| assert!(x < y));
+ proptest!(&conf, |(x in 0u32..10, y in 10u32..20,)| assert!(x < y));
+ proptest!(conf, move |(x in 0u32..10, y in 10u32..20,)| assert!(x < y));
+ proptest!(conf, |(_x: u32, _y: u32,)| { });
+ proptest!(conf, move |(_x: u32, _y: u32,)| { });
}
}
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/config.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/config.rs
index 4361274..1f1c3fb 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/config.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/config.rs
@@ -7,7 +7,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::Box;
+use crate::std_facade::Box;
use core::u32;
#[cfg(feature = "std")]
@@ -19,10 +19,11 @@
#[cfg(feature = "std")]
use std::str::FromStr;
-use test_runner::FailurePersistence;
+use crate::test_runner::FailurePersistence;
#[cfg(feature = "std")]
-use test_runner::FileFailurePersistence;
-use test_runner::result_cache::{noop_result_cache, ResultCache};
+use crate::test_runner::FileFailurePersistence;
+use crate::test_runner::rng::RngAlgorithm;
+use crate::test_runner::result_cache::{noop_result_cache, ResultCache};
#[cfg(feature = "std")]
const CASES: &str = "PROPTEST_CASES";
@@ -42,6 +43,7 @@
const TIMEOUT: &str = "PROPTEST_TIMEOUT";
#[cfg(feature = "std")]
const VERBOSE: &str = "PROPTEST_VERBOSE";
+const RNG_ALGORITHM: &str = "PROPTEST_RNG_ALGORITHM";
#[cfg(feature = "std")]
fn contextualize_config(mut result: Config) -> Config {
@@ -88,6 +90,8 @@
&value, &mut result.max_shrink_iters, "u32", MAX_SHRINK_ITERS),
VERBOSE => parse_or_warn(
&value, &mut result.verbose, "u32", VERBOSE),
+ RNG_ALGORITHM => parse_or_warn(
+ &value, &mut result.rng_algorithm, "RngAlgorithm", RNG_ALGORITHM),
_ => if var.starts_with("PROPTEST_") {
eprintln!("proptest: Ignoring unknown env-var {}.", var);
@@ -101,32 +105,36 @@
#[cfg(not(feature = "std"))]
fn contextualize_config(result: Config) -> Config { result }
-/// The default config, computed by combining environment variables and
-/// defaults.
+fn default_default_config() -> Config {
+ Config {
+ cases: 256,
+ max_local_rejects: 65_536,
+ max_global_rejects: 1024,
+ max_flat_map_regens: 1_000_000,
+ failure_persistence: None,
+ source_file: None,
+ test_name: None,
+ #[cfg(feature = "fork")]
+ fork: false,
+ #[cfg(feature = "timeout")]
+ timeout: 0,
+ #[cfg(feature = "std")]
+ max_shrink_time: 0,
+ max_shrink_iters: u32::MAX,
+ result_cache: noop_result_cache,
+ #[cfg(feature = "std")]
+ verbose: 0,
+ rng_algorithm: RngAlgorithm::default(),
+ _non_exhaustive: (),
+ }
+}
+
+// The default config, computed by combining environment variables and
+// defaults.
+#[cfg(feature = "std")]
lazy_static! {
static ref DEFAULT_CONFIG: Config = {
- let result = Config {
- cases: 256,
- max_local_rejects: 65_536,
- max_global_rejects: 1024,
- max_flat_map_regens: 1_000_000,
- failure_persistence: None,
- source_file: None,
- test_name: None,
- #[cfg(feature = "fork")]
- fork: false,
- #[cfg(feature = "timeout")]
- timeout: 0,
- #[cfg(feature = "std")]
- max_shrink_time: 0,
- max_shrink_iters: u32::MAX,
- result_cache: noop_result_cache,
- #[cfg(feature = "std")]
- verbose: 0,
- _non_exhaustive: (),
- };
-
- contextualize_config(result)
+ contextualize_config(default_default_config())
};
}
@@ -290,6 +298,15 @@
#[cfg(feature = "std")]
pub verbose: u32,
+ /// The RNG algorithm to use when not using a user-provided RNG.
+ ///
+ /// The default is `RngAlgorithm::default()`, which can be overridden by
+ /// setting the `PROPTEST_RNG_ALGORITHM` environment variable to one of the following:
+ ///
+ /// - `xs` — `RngAlgorithm::XorShift`
+ /// - `cc` — `RngAlgorithm::ChaCha`
+ pub rng_algorithm: RngAlgorithm,
+
// Needs to be public so FRU syntax can be used.
#[doc(hidden)]
pub _non_exhaustive: (),
@@ -400,8 +417,16 @@
}
}
+#[cfg(feature = "std")]
impl Default for Config {
fn default() -> Self {
DEFAULT_CONFIG.clone()
}
}
+
+#[cfg(not(feature = "std"))]
+impl Default for Config {
+ fn default() -> Self {
+ default_default_config()
+ }
+}
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/errors.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/errors.rs
index 72975d4..320cf87 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/errors.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/errors.rs
@@ -7,12 +7,12 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::fmt;
+use crate::std_facade::fmt;
#[cfg(feature = "std")]
use std::string::ToString;
-use test_runner::Reason;
+use crate::test_runner::Reason;
/// Errors which can be returned from test cases to indicate non-successful
/// completion.
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/file.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/file.rs
index 9a30142..647f478 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/file.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/file.rs
@@ -1,5 +1,5 @@
//-
-// Copyright 2017, 2018 The proptest developers
+// Copyright 2017, 2018, 2019 The proptest developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
@@ -9,7 +9,6 @@
use core::any::Any;
use core::fmt::Debug;
-use core::num::ParseIntError;
use std::borrow::{Cow, ToOwned};
use std::boxed::Box;
use std::env;
@@ -20,7 +19,7 @@
use std::vec::Vec;
use std::string::{String, ToString};
-use test_runner::{Seed, failure_persistence::FailurePersistence};
+use crate::test_runner::failure_persistence::{PersistedSeed, FailurePersistence};
use self::FileFailurePersistence::*;
/// Describes how failing test cases are persisted.
@@ -81,15 +80,15 @@
}
impl FailurePersistence for FileFailurePersistence {
- fn load_persisted_failures(&self, source_file: Option<&'static str>)
- -> Vec<Seed> {
+ fn load_persisted_failures2(&self, source_file: Option<&'static str>)
+ -> Vec<PersistedSeed> {
let p = self.resolve(
source_file.and_then(|s| absolutize_source_file(Path::new(s)))
.as_ref()
.map(|cow| &**cow));
let path: Option<&PathBuf> = p.as_ref();
- let result: io::Result<Vec<Seed>> = path.map_or_else(
+ let result: io::Result<Vec<PersistedSeed>> = path.map_or_else(
|| Ok(vec![]),
|path| {
// .ok() instead of .unwrap() so we don't propagate panics here
@@ -117,10 +116,10 @@
})
}
- fn save_persisted_failure(
+ fn save_persisted_failure2(
&mut self,
source_file: Option<&'static str>,
- seed: Seed,
+ seed: PersistedSeed,
shrunken_value: &dyn Debug,
) {
let path = self.resolve(source_file.map(Path::new));
@@ -135,7 +134,7 @@
.expect("proptest: couldn't write header.");
}
- write_seed_line(&mut to_write, seed, shrunken_value)
+ write_seed_line(&mut to_write, &seed, shrunken_value)
.expect("proptest: couldn't write seed line.");
if let Err(e) = write_seed_data_to_file(&path, &to_write) {
@@ -148,7 +147,7 @@
{}",
path.display(),
if is_new { " (You may need to create it.)" } else { "" },
- format_basic_seed_line(seed));
+ seed);
}
}
}
@@ -235,81 +234,34 @@
}
fn parse_seed_line(mut line: String, path: &Path, lineno: usize)
- -> Option<Seed> {
+ -> Option<PersistedSeed> {
// Remove anything after and including '#':
if let Some(comment_start) = line.find('#') {
line.truncate(comment_start);
}
if line.len() > 0 {
- // Split by whitespace and ignore empty lines:
- let parts = line.trim().split(char::is_whitespace).collect::<Vec<_>>();
- let len = parts.len();
- // "xs" stands for "XorShift".
- if parts[0] == "xs" && len == 5 {
- // Parse using the chosen one:
- if let Ok(seed) = parse_seed_old(&parts[1..]) {
- return Some(seed);
- } else {
- eprintln!("proptest: {}:{}: unparsable line, ignoring",
- path.display(), lineno + 1);
- }
- } else {
- eprintln!("proptest: {}:{}: unknown case type `{}` \
- (corrupt file or newer proptest version?)",
- &path.display(), lineno + 1, parts[0]);
+ let ret = line.parse::<PersistedSeed>().ok();
+ if !ret.is_some() {
+ eprintln!("proptest: {}:{}: unparsable line, ignoring",
+ path.display(), lineno + 1);
}
+ return ret;
}
None
}
-fn parse_seed_old(parts: &[&str]) -> Result<Seed, ParseIntError> {
- let mut ret = [0u32; 4];
- for (src, dst) in parts.iter().zip(ret.iter_mut()) {
- *dst = src.parse()?;
- }
-
- Ok(convert_to_new_format(ret))
-}
-
-fn convert_to_new_format(old_format: [u32; 4]) -> Seed {
- use byteorder::{ByteOrder, LittleEndian};
- let mut new_format = [0; 16];
- // rand uses little endian for this conversion on all platforms
- LittleEndian::write_u32_into(&old_format[..], &mut new_format);
- new_format
-}
-
-fn convert_from_new_format(new_format: Seed) -> [u32; 4] {
- use byteorder::{ByteOrder, LittleEndian};
- let mut old_format = [0; 4];
- LittleEndian::read_u32_into(&new_format[..], &mut old_format);
- old_format
-}
-
-fn format_basic_seed_line(seed: Seed) -> String {
- // Write line start:
- let mut buf = "xs ".to_owned();
-
- // Write out each part of seed:
- for &s in &convert_from_new_format(seed) {
- buf.push_str(&s.to_string());
- buf.push(' ');
- }
-
- buf
-}
-
-fn write_seed_line(buf: &mut Vec<u8>, seed: Seed, shrunken_value: &dyn Debug)
+fn write_seed_line(buf: &mut Vec<u8>, seed: &PersistedSeed,
+ shrunken_value: &dyn Debug)
-> io::Result<()>
{
// Write the seed itself
- write!(buf, "{}", format_basic_seed_line(seed));
+ write!(buf, "{}", seed.to_string())?;
// Write out comment:
let debug_start = buf.len();
- write!(buf, "# shrinks to {:?}", shrunken_value)?;
+ write!(buf, " # shrinks to {:?}", shrunken_value)?;
// Ensure there are no newlines in the debug output
for byte in &mut buf[debug_start..] {
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/map.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/map.rs
index 3410c97..57d99eb 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/map.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/map.rs
@@ -8,10 +8,10 @@
// except according to those terms.
use core::any::Any;
-use std_facade::{fmt, Box, Vec, BTreeMap, BTreeSet};
+use crate::std_facade::{fmt, Box, Vec, BTreeMap, BTreeSet};
-use test_runner::failure_persistence::FailurePersistence;
-use test_runner::Seed;
+use crate::test_runner::failure_persistence::FailurePersistence;
+use crate::test_runner::failure_persistence::PersistedSeed;
/// Failure persistence option that loads and saves seeds in memory
/// on the heap. This may be useful when accumulating test failures
@@ -20,22 +20,22 @@
#[derive(Clone, Debug, Default, PartialEq)]
pub struct MapFailurePersistence {
/// Backing map, keyed by source_file.
- pub map: BTreeMap<&'static str, BTreeSet<Seed>>
+ pub map: BTreeMap<&'static str, BTreeSet<PersistedSeed>>
}
impl FailurePersistence for MapFailurePersistence {
- fn load_persisted_failures(&self, source_file: Option<&'static str>)
- -> Vec<Seed> {
+ fn load_persisted_failures2(&self, source_file: Option<&'static str>)
+ -> Vec<PersistedSeed> {
source_file
.and_then(|source| self.map.get(source))
.map(|seeds| seeds.iter().cloned().collect::<Vec<_>>())
.unwrap_or_default()
}
- fn save_persisted_failure(
+ fn save_persisted_failure2(
&mut self,
source_file: Option<&'static str>,
- seed: Seed,
+ seed: PersistedSeed,
_shrunken_value: &dyn fmt::Debug,
) {
let s = match source_file {
@@ -60,32 +60,32 @@
#[cfg(test)]
mod tests {
use super::*;
- use test_runner::failure_persistence::tests::*;
+ use crate::test_runner::failure_persistence::tests::*;
#[test]
fn initial_map_is_empty() {
assert!(MapFailurePersistence::default()
- .load_persisted_failures(HI_PATH).is_empty())
+ .load_persisted_failures2(HI_PATH).is_empty())
}
#[test]
fn seeds_recoverable() {
let mut p = MapFailurePersistence::default();
- p.save_persisted_failure(HI_PATH, INC_SEED, &"");
- let restored = p.load_persisted_failures(HI_PATH);
+ p.save_persisted_failure2(HI_PATH, INC_SEED, &"");
+ let restored = p.load_persisted_failures2(HI_PATH);
assert_eq!(1, restored.len());
assert_eq!(INC_SEED, *restored.first().unwrap());
- assert!(p.load_persisted_failures(None).is_empty());
- assert!(p.load_persisted_failures(UNREL_PATH).is_empty());
+ assert!(p.load_persisted_failures2(None).is_empty());
+ assert!(p.load_persisted_failures2(UNREL_PATH).is_empty());
}
#[test]
fn seeds_deduplicated() {
let mut p = MapFailurePersistence::default();
- p.save_persisted_failure(HI_PATH, INC_SEED, &"");
- p.save_persisted_failure(HI_PATH, INC_SEED, &"");
- let restored = p.load_persisted_failures(HI_PATH);
+ p.save_persisted_failure2(HI_PATH, INC_SEED, &"");
+ p.save_persisted_failure2(HI_PATH, INC_SEED, &"");
+ let restored = p.load_persisted_failures2(HI_PATH);
assert_eq!(1, restored.len());
}
}
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/mod.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/mod.rs
index 7a39dfe..be848d1 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/mod.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/mod.rs
@@ -1,5 +1,5 @@
//-
-// Copyright 2017, 2018 The proptest developers
+// Copyright 2017, 2018, 2019 The proptest developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
@@ -8,7 +8,10 @@
// except according to those terms.
use core::any::Any;
-use std_facade::{fmt, Box, Vec};
+use core::fmt::Display;
+use core::result::Result;
+use core::str::FromStr;
+use crate::std_facade::{fmt, Box, Vec};
#[cfg(feature = "std")]
mod file;
@@ -20,23 +23,95 @@
pub use self::map::*;
pub use self::noop::*;
-use test_runner::Seed;
+use crate::test_runner::Seed;
+
+/// Opaque struct representing a seed which can be persisted.
+///
+/// The `Display` and `FromStr` implementations go to and from the format
+/// Proptest uses for its persistence file.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct PersistedSeed(pub(crate) Seed);
+
+impl Display for PersistedSeed {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.0.to_persistence())
+ }
+}
+
+impl FromStr for PersistedSeed {
+ type Err = ();
+
+ fn from_str(s: &str) -> Result<Self, ()> {
+ Seed::from_persistence(s).map(PersistedSeed).ok_or(())
+ }
+}
/// Provides external persistence for historical test failures by storing seeds.
+///
+/// **Note**: Implementing `load_persisted_failures` and
+/// `save_persisted_failures` is **deprecated** and these methods will be
+/// removed in proptest 0.10.0. Instead, implement `load_persisted_failures2`
+/// and `save_persisted_failures2`.
pub trait FailurePersistence: Send + Sync + fmt::Debug {
/// Supply seeds associated with the given `source_file` that may be used
/// by a `TestRunner`'s random number generator in order to consistently
/// recreate a previously-failing `Strategy`-provided value.
+ ///
+ /// The default implementation is **for backwards compatibility**. It
+ /// delegates to `load_persisted_failures` and converts the results into
+ /// XorShift seeds.
+ #[allow(deprecated)]
+ fn load_persisted_failures2(&self, source_file: Option<&'static str>)
+ -> Vec<PersistedSeed> {
+ self.load_persisted_failures(source_file)
+ .into_iter()
+ .map(|seed| PersistedSeed(Seed::XorShift(seed)))
+ .collect()
+ }
+
+ /// Use `load_persisted_failures2` instead.
+ ///
+ /// This function inadvertently exposes the implementation of seeds prior
+ /// to Proptest 0.9.1 and only works with XorShift seeds.
+ #[deprecated]
+ #[allow(unused_variables)]
fn load_persisted_failures(&self, source_file: Option<&'static str>)
- -> Vec<Seed>;
+ -> Vec<[u8; 16]> {
+ panic!("load_persisted_failures2 not implemented");
+ }
/// Store a new failure-generating seed associated with the given `source_file`.
+ ///
+ /// The default implementation is **for backwards compatibility**. It
+ /// delegates to `save_persisted_failure` if `seed` is a XorShift seed.
+ #[allow(deprecated)]
+ fn save_persisted_failure2(
+ &mut self,
+ source_file: Option<&'static str>,
+ seed: PersistedSeed,
+ shrunken_value: &dyn fmt::Debug)
+ {
+ match seed.0 {
+ Seed::XorShift(seed) => self.save_persisted_failure(
+ source_file, seed, shrunken_value),
+ _ => (),
+ }
+ }
+
+ /// Use `save_persisted_failures2` instead.
+ ///
+ /// This function inadvertently exposes the implementation of seeds prior
+ /// to Proptest 0.9.1 and only works with XorShift seeds.
+ #[deprecated]
+ #[allow(unused_variables)]
fn save_persisted_failure(
&mut self,
source_file: Option<&'static str>,
- seed: Seed,
- shrunken_value: &dyn fmt::Debug,
- );
+ seed: [u8;16],
+ shrunken_value: &dyn fmt::Debug)
+ {
+ panic!("save_persisted_failure2 not implemented");
+ }
/// Delegate method for producing a trait object usable with `Clone`
fn box_clone(&self) -> Box<dyn FailurePersistence>;
@@ -63,8 +138,13 @@
#[cfg(test)]
mod tests {
- pub const INC_SEED: [u8; 16] =
- [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+ use super::PersistedSeed;
+ use crate::test_runner::rng::Seed;
+
+ pub const INC_SEED: PersistedSeed =
+ PersistedSeed(
+ Seed::XorShift(
+ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]));
pub const HI_PATH: Option<&str> = Some("hi");
pub const UNREL_PATH: Option<&str> = Some("unrelated");
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/noop.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/noop.rs
index 3819c1e..3168252 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/noop.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/failure_persistence/noop.rs
@@ -8,23 +8,22 @@
// except according to those terms.
use core::any::Any;
-use std_facade::{fmt, Box, Vec};
+use crate::std_facade::{fmt, Box, Vec};
-use test_runner::failure_persistence::FailurePersistence;
-use test_runner::Seed;
+use crate::test_runner::failure_persistence::{FailurePersistence, PersistedSeed};
/// Failure persistence option that loads and saves nothing at all.
#[derive(Debug, Default, PartialEq)]
struct NoopFailurePersistence;
impl FailurePersistence for NoopFailurePersistence {
- fn load_persisted_failures(&self, _source_file: Option<&'static str>) -> Vec<Seed> {
+ fn load_persisted_failures2(&self, _source_file: Option<&'static str>) -> Vec<PersistedSeed> {
Vec::new()
}
- fn save_persisted_failure(&mut self,
+ fn save_persisted_failure2(&mut self,
_source_file: Option<&'static str>,
- _seed: Seed,
+ _seed: PersistedSeed,
_shrunken_value: &dyn fmt::Debug,
) {
}
@@ -43,22 +42,22 @@
#[cfg(test)]
mod tests {
use super::*;
- use test_runner::failure_persistence::tests::*;
+ use crate::test_runner::failure_persistence::tests::*;
#[test]
fn default_load_is_empty() {
assert!(NoopFailurePersistence::default()
- .load_persisted_failures(None).is_empty());
+ .load_persisted_failures2(None).is_empty());
assert!(NoopFailurePersistence::default()
- .load_persisted_failures(HI_PATH).is_empty());
+ .load_persisted_failures2(HI_PATH).is_empty());
}
#[test]
fn seeds_not_recoverable() {
let mut p = NoopFailurePersistence::default();
- p.save_persisted_failure(HI_PATH, INC_SEED, &"");
- assert!(p.load_persisted_failures(HI_PATH).is_empty());
- assert!(p.load_persisted_failures(None).is_empty());
- assert!(p.load_persisted_failures(UNREL_PATH).is_empty());
+ p.save_persisted_failure2(HI_PATH, INC_SEED, &"");
+ assert!(p.load_persisted_failures2(HI_PATH).is_empty());
+ assert!(p.load_persisted_failures2(None).is_empty());
+ assert!(p.load_persisted_failures2(UNREL_PATH).is_empty());
}
}
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/reason.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/reason.rs
index 09395b6..b7c2476 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/reason.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/reason.rs
@@ -7,7 +7,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::{fmt, Cow, String, Box};
+use crate::std_facade::{fmt, Cow, String, Box};
/// The reason for why something, such as a generated value, was rejected.
///
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/replay.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/replay.rs
index 4dc8a3f..9215425 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/replay.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/replay.rs
@@ -15,7 +15,7 @@
use std::string::String;
use std::vec::Vec;
-use test_runner::{TestCaseError, TestCaseResult, Seed};
+use crate::test_runner::{TestCaseError, TestCaseResult, Seed};
const SENTINEL: &'static str = "proptest-forkfile";
@@ -40,12 +40,12 @@
/// to the file without having to worry about the possibility of appends being
/// non-atomic.
#[derive(Clone, Debug)]
-pub struct Replay {
+pub(crate) struct Replay {
/// The seed of the RNG used to start running the test cases.
- pub seed: Seed,
+ pub(crate) seed: Seed,
/// A log of whether certain test cases passed or failed. The runner will
/// assume the same results occur without actually running the test cases.
- pub steps: Vec<TestCaseResult>,
+ pub(crate) steps: Vec<TestCaseResult>,
}
impl Replay {
@@ -60,7 +60,7 @@
/// Result of loading a replay file.
#[derive(Clone, Debug)]
-pub enum ReplayFileStatus {
+pub(crate) enum ReplayFileStatus {
/// The file is valid and represents a currently-in-progress test.
InProgress(Replay),
/// The file is valid, but indicates that all testing has completed.
@@ -70,7 +70,7 @@
}
/// Open the file in the usual read+append+create mode.
-pub fn open_file(path: impl AsRef<Path>) -> io::Result<fs::File> {
+pub(crate) fn open_file(path: impl AsRef<Path>) -> io::Result<fs::File> {
fs::OpenOptions::new()
.read(true)
.append(true)
@@ -88,18 +88,18 @@
}
/// Append the given step to the given output.
-pub fn append(mut file: impl Write, step: &TestCaseResult)
+pub(crate) fn append(mut file: impl Write, step: &TestCaseResult)
-> io::Result<()> {
write!(file, "{}", step_to_char(step))
}
/// Append a no-op step to the given output.
-pub fn ping(mut file: impl Write) -> io::Result<()> {
+pub(crate) fn ping(mut file: impl Write) -> io::Result<()> {
write!(file, " ")
}
/// Append a termination mark to the given output.
-pub fn terminate(mut file: impl Write) -> io::Result<()> {
+pub(crate) fn terminate(mut file: impl Write) -> io::Result<()> {
write!(file, ".")
}
@@ -107,10 +107,7 @@
/// Write the full state of this `Replay` to the given output.
pub fn init_file(&self, mut file: impl Write) -> io::Result<()> {
writeln!(file, "{}", SENTINEL)?;
-
- for word in &self.seed {
- writeln!(file, "{}", word)?;
- }
+ writeln!(file, "{}", self.seed.to_persistence())?;
let mut step_data = Vec::<u8>::new();
for step in &self.steps {
@@ -154,16 +151,12 @@
return Ok(ReplayFileStatus::Corrupt);
}
- let mut seed: Seed = [0; 16];
- for word in &mut seed {
- line.clear();
- reader.read_line(&mut line)?;
-
- match line.trim().parse::<u8>() {
- Ok(w) => *word = w,
- Err(_) => return Ok(ReplayFileStatus::Corrupt),
- }
- }
+ line.clear();
+ reader.read_line(&mut line)?;
+ let seed = match Seed::from_persistence(&line) {
+ Some(seed) => seed,
+ None => return Ok(ReplayFileStatus::Corrupt),
+ };
line.clear();
reader.read_line(&mut line)?;
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/result_cache.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/result_cache.rs
index 0f1c337..4b657dc 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/result_cache.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/result_cache.rs
@@ -7,11 +7,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std_facade::Box;
-use std_facade::fmt;
+use crate::std_facade::Box;
+use crate::std_facade::fmt;
#[cfg(feature = "std")] use std::collections::HashMap;
-use test_runner::errors::TestCaseResult;
+use crate::test_runner::errors::TestCaseResult;
/// A key used for the result cache.
///
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/rng.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/rng.rs
index 1be53d7..3fccdd8 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/rng.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/rng.rs
@@ -1,5 +1,5 @@
//-
-// Copyright 2017, 2018 The proptest developers
+// Copyright 2017, 2018, 2019 The proptest developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
@@ -7,81 +7,514 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rand::{Error, RngCore, Rng, SeedableRng};
-use rand::prng::XorShiftRng;
+use core::{u8, fmt, str};
+use core::result::Result;
+use crate::std_facade::{Arc, String, Vec, ToOwned};
-/// Proptest's random number generator.
+use byteorder::{ByteOrder, LittleEndian};
+use rand::{self, RngCore, Rng, SeedableRng};
+use rand_xorshift::XorShiftRng;
+use rand_chacha::ChaChaRng;
+
+/// Identifies a particular RNG algorithm supported by proptest.
///
-/// Currently, this is just a wrapper around `XorShiftRng`.
-#[derive(Clone, Debug)]
-pub struct TestRng { rng: XorShiftRng }
+/// Proptest supports dynamic configuration of algorithms to allow it to
+/// continue operating with persisted regression files and to allow the
+/// configuration to be expressed in the `Config` struct.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RngAlgorithm {
+ /// The [XorShift](https://rust-random.github.io/rand/rand_xorshift/struct.XorShiftRng.html)
+ /// algorithm. This was the default up through and including Proptest 0.9.0.
+ ///
+ /// It is faster than ChaCha but produces lower quality randomness and has
+ /// some pathological cases where it may fail to produce outputs that are
+ /// random even to casual observation.
+ ///
+ /// The seed must be exactly 16 bytes.
+ XorShift,
+ /// The [ChaCha](https://rust-random.github.io/rand/rand_chacha/struct.ChaChaRng.html)
+ /// algorithm. This became the default with Proptest 0.9.1.
+ ///
+ /// The seed must be exactly 32 bytes.
+ ChaCha,
+ /// This is not an actual RNG algorithm, but instead returns data directly
+ /// from its "seed".
+ ///
+ /// This is useful when Proptest is being driven from some other entropy
+ /// source, such as a fuzzer.
+ ///
+ /// It is the user's responsibility to ensure that the seed is "big
+ /// enough". Proptest makes no guarantees about how much data is consumed
+ /// from the seed for any particular strategy. If the seed is exhausted,
+ /// the RNG panics.
+ ///
+ /// Note that in cases where a new RNG is to be derived from an existing
+ /// one, *the data is split evenly between them*, regardless of how much
+ /// entropy is actually needed. This means that combinators like
+ /// `prop_perturb` and `prop_flat_map` can require extremely large inputs.
+ PassThrough,
+ #[allow(missing_docs)] #[doc(hidden)] _NonExhaustive,
+}
-impl RngCore for TestRng {
- fn next_u32(&mut self) -> u32 { self.rng.next_u32() }
- fn next_u64(&mut self) -> u64 { self.rng.next_u64() }
- fn fill_bytes(&mut self, dest: &mut [u8]) { self.rng.fill_bytes(dest) }
- fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
- self.rng.try_fill_bytes(dest)
+impl Default for RngAlgorithm {
+ fn default() -> Self {
+ RngAlgorithm::ChaCha
}
}
-pub(crate) type Seed = [u8; 16];
+impl RngAlgorithm {
+ pub(crate) fn persistence_key(self) -> &'static str {
+ match self {
+ RngAlgorithm::XorShift => "xs",
+ RngAlgorithm::ChaCha => "cc",
+ RngAlgorithm::PassThrough => "pt",
+ RngAlgorithm::_NonExhaustive => unreachable!(),
+ }
+ }
+
+ pub(crate) fn from_persistence_key(k: &str) -> Option<Self> {
+ match k {
+ "xs" => Some(RngAlgorithm::XorShift),
+ "cc" => Some(RngAlgorithm::ChaCha),
+ "pt" => Some(RngAlgorithm::PassThrough),
+ _ => None,
+ }
+ }
+}
+
+// These two are only used for parsing the environment variable
+// PROPTEST_RNG_ALGORITHM.
+impl str::FromStr for RngAlgorithm {
+ type Err = ();
+ fn from_str(s: &str) -> Result<Self, ()> {
+ RngAlgorithm::from_persistence_key(s).ok_or(())
+ }
+}
+impl fmt::Display for RngAlgorithm {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.persistence_key())
+ }
+}
+
+/// Proptest's random number generator.
+#[derive(Clone, Debug)]
+pub struct TestRng { rng: TestRngImpl }
+
+#[derive(Clone, Debug)]
+enum TestRngImpl {
+ XorShift(XorShiftRng),
+ ChaCha(ChaChaRng),
+ PassThrough { off: usize, end: usize, data: Arc<[u8]> },
+}
+
+impl RngCore for TestRng {
+ fn next_u32(&mut self) -> u32 {
+ match &mut self.rng {
+ &mut TestRngImpl::XorShift(ref mut rng) =>
+ rng.next_u32(),
+
+ &mut TestRngImpl::ChaCha(ref mut rng) =>
+ rng.next_u32(),
+
+ &mut TestRngImpl::PassThrough { .. } => {
+ let mut buf = [0; 4];
+ self.fill_bytes(&mut buf[..]);
+ LittleEndian::read_u32(&buf[..])
+ },
+ }
+ }
+
+ fn next_u64(&mut self) -> u64 {
+ match &mut self.rng {
+ &mut TestRngImpl::XorShift(ref mut rng) =>
+ rng.next_u64(),
+
+ &mut TestRngImpl::ChaCha(ref mut rng) =>
+ rng.next_u64(),
+
+ &mut TestRngImpl::PassThrough { .. } => {
+ let mut buf = [0; 8];
+ self.fill_bytes(&mut buf[..]);
+ LittleEndian::read_u64(&buf[..])
+ },
+ }
+ }
+
+ fn fill_bytes(&mut self, dest: &mut [u8]) {
+ match &mut self.rng {
+ &mut TestRngImpl::XorShift(ref mut rng) =>
+ rng.fill_bytes(dest),
+
+ &mut TestRngImpl::ChaCha(ref mut rng) =>
+ rng.fill_bytes(dest),
+
+ &mut TestRngImpl::PassThrough { ref mut off, end, ref data } => {
+ assert!(*off + dest.len() <= end, "out of PassThrough data");
+ dest.copy_from_slice(&data[*off..*off + dest.len()]);
+ *off += dest.len();
+ },
+ }
+ }
+
+ fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+ match self.rng {
+ TestRngImpl::XorShift(ref mut rng) =>
+ rng.try_fill_bytes(dest),
+
+ TestRngImpl::ChaCha(ref mut rng) =>
+ rng.try_fill_bytes(dest),
+
+ TestRngImpl::PassThrough { ref mut off, end, ref data } => {
+ if *off + dest.len() > end {
+ return Err(rand::Error::new(
+ rand::ErrorKind::Unavailable,
+ "out of PassThrough data"));
+ }
+
+ dest.copy_from_slice(&data[*off..*off + dest.len()]);
+ *off += dest.len();
+ Ok(())
+ },
+ }
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) enum Seed {
+ XorShift([u8; 16]),
+ ChaCha([u8; 32]),
+ PassThrough(Option<(usize, usize)>, Arc<[u8]>),
+}
+
+impl Seed {
+ pub(crate) fn from_bytes(algorithm: RngAlgorithm, seed: &[u8]) -> Self {
+ match algorithm {
+ RngAlgorithm::XorShift => {
+ assert_eq!(16, seed.len(), "XorShift requires a 16-byte seed");
+ let mut buf = [0; 16];
+ buf.copy_from_slice(seed);
+ Seed::XorShift(buf)
+ },
+
+ RngAlgorithm::ChaCha => {
+ assert_eq!(32, seed.len(), "ChaCha requires a 32-byte seed");
+ let mut buf = [0; 32];
+ buf.copy_from_slice(seed);
+ Seed::ChaCha(buf)
+ },
+
+ RngAlgorithm::PassThrough =>
+ Seed::PassThrough(None, seed.into()),
+
+ RngAlgorithm::_NonExhaustive => unreachable!(),
+ }
+ }
+
+ pub(crate) fn from_persistence(string: &str) -> Option<Seed> {
+ fn from_base16(dst: &mut [u8], src: &str) -> Option<()> {
+ if dst.len() * 2 != src.len() {
+ return None;
+ }
+
+ for (dst_byte, src_pair) in dst.into_iter().zip(src.as_bytes().chunks(2)) {
+ *dst_byte = u8::from_str_radix(str::from_utf8(src_pair).ok()?, 16).ok()?;
+ }
+
+ Some(())
+ }
+
+ let parts = string.trim().split(char::is_whitespace).collect::<Vec<_>>();
+ RngAlgorithm::from_persistence_key(&parts[0]).and_then(|alg| match alg {
+ RngAlgorithm::XorShift => {
+ if 5 != parts.len() {
+ return None;
+ }
+
+ let mut dwords = [0u32; 4];
+ for (dword, part) in (&mut dwords[..]).into_iter().zip(&parts[1..]) {
+ *dword = part.parse().ok()?;
+ }
+
+ let mut seed = [0u8; 16];
+ LittleEndian::write_u32_into(&dwords[..], &mut seed[..]);
+ Some(Seed::XorShift(seed))
+ },
+
+ RngAlgorithm::ChaCha => {
+ if 2 != parts.len() {
+ return None;
+ }
+
+ let mut seed = [0u8; 32];
+ from_base16(&mut seed, &parts[1])?;
+ Some(Seed::ChaCha(seed))
+ },
+
+ RngAlgorithm::PassThrough => {
+ if 1 == parts.len() {
+ return Some(Seed::PassThrough(None, vec![].into()));
+ }
+
+ if 2 != parts.len() {
+ return None;
+ }
+
+ let mut seed = vec![0u8; parts[1].len() / 2];
+ from_base16(&mut seed, &parts[1])?;
+ Some(Seed::PassThrough(None, seed.into()))
+ },
+
+ RngAlgorithm::_NonExhaustive => unreachable!(),
+ })
+ }
+
+ pub(crate) fn to_persistence(&self) -> String {
+ fn to_base16(dst: &mut String, src: &[u8]) {
+ for byte in src {
+ dst.push_str(&format!("{:02x}", byte));
+ }
+ }
+
+ match *self {
+ Seed::XorShift(ref seed) => {
+ let mut dwords = [0u32; 4];
+ LittleEndian::read_u32_into(seed, &mut dwords[..]);
+ format!("{} {} {} {} {}",
+ RngAlgorithm::XorShift.persistence_key(),
+ dwords[0], dwords[1], dwords[2], dwords[3])
+ },
+
+ Seed::ChaCha(ref seed) => {
+ let mut string =
+ RngAlgorithm::ChaCha.persistence_key().to_owned();
+ string.push(' ');
+ to_base16(&mut string, seed);
+ string
+ },
+
+ Seed::PassThrough(bounds, ref data) => {
+ let data = bounds
+ .map_or(&data[..], |(start, end)| &data[start..end]);
+ let mut string =
+ RngAlgorithm::PassThrough.persistence_key().to_owned();
+ string.push(' ');
+ to_base16(&mut string, data);
+ string
+ },
+ }
+ }
+}
impl TestRng {
+ /// Create a new RNG with the given algorithm and seed.
+ ///
+ /// Any RNG created with the same algorithm-seed pair will produce the same
+ /// sequence of values on all systems and all supporting versions of
+ /// proptest.
+ ///
+ /// ## Panics
+ ///
+ /// Panics if `seed` is not an appropriate length for `algorithm`.
+ pub fn from_seed(algorithm: RngAlgorithm, seed: &[u8]) -> Self {
+ TestRng::from_seed_internal(Seed::from_bytes(algorithm, seed))
+ }
+
/// Construct a default TestRng from entropy.
- pub(crate) fn default_rng() -> Self {
+ pub(crate) fn default_rng(algorithm: RngAlgorithm) -> Self {
#[cfg(feature = "std")]
{
use rand::FromEntropy;
- Self { rng: XorShiftRng::from_entropy() }
+ Self { rng: match algorithm {
+ RngAlgorithm::XorShift =>
+ TestRngImpl::XorShift(XorShiftRng::from_entropy()),
+ RngAlgorithm::ChaCha =>
+ TestRngImpl::ChaCha(ChaChaRng::from_entropy()),
+ RngAlgorithm::PassThrough =>
+ panic!("cannot create default instance of PassThrough"),
+ RngAlgorithm::_NonExhaustive => unreachable!(),
+ } }
}
#[cfg(not(feature = "std"))]
- Self::from_seed([
- 0x19, 0x3a, 0x67, 0x54, // x
- 0x69, 0xd4, 0xa7, 0xa8, // y
- 0x05, 0x0e, 0x83, 0x97, // z
- 0xbb, 0xa7, 0x3b, 0x11, // w
- ])
+ Self::deterministic_rng(algorithm)
+ }
+
+ /// Returns a `TestRng` with a particular hard-coded seed.
+ ///
+ /// The seed value will always be the same for a particular version of
+ /// Proptest and algorithm, but may change across releases.
+ ///
+ /// This is useful for testing things like strategy implementations without
+ /// risking getting "unlucky" RNGs which deviate from average behaviour
+ /// enough to cause spurious failures. For example, a strategy for `bool`
+ /// which is supposed to produce `true` 50% of the time might have a test
+ /// which checks that the distribution is "close enough" to 50%. If every
+ /// test run starts with a different RNG, occasionally there will be
+ /// spurious test failures when the RNG happens to produce a very skewed
+ /// distribution. Using this or `TestRunner::deterministic()` avoids such
+ /// issues.
+ pub fn deterministic_rng(algorithm: RngAlgorithm) -> Self {
+ Self::from_seed_internal(match algorithm {
+ RngAlgorithm::XorShift => Seed::XorShift([
+ 0xf4, 0x16, 0x16, 0x48, 0xc3, 0xac, 0x77, 0xac,
+ 0x72, 0x20, 0x0b, 0xea, 0x99, 0x67, 0x2d, 0x6d,
+ ]),
+ RngAlgorithm::ChaCha => Seed::ChaCha([
+ 0xf4, 0x16, 0x16, 0x48, 0xc3, 0xac, 0x77, 0xac,
+ 0x72, 0x20, 0x0b, 0xea, 0x99, 0x67, 0x2d, 0x6d,
+ 0xca, 0x9f, 0x76, 0xaf, 0x1b, 0x09, 0x73, 0xa0,
+ 0x59, 0x22, 0x6d, 0xc5, 0x46, 0x39, 0x1c, 0x4a,
+ ]),
+ RngAlgorithm::PassThrough =>
+ panic!("deterministic RNG not available for PassThrough"),
+ RngAlgorithm::_NonExhaustive => unreachable!(),
+ })
}
/// Construct a TestRng by the perturbed randomized seed
/// from an existing TestRng.
pub(crate) fn gen_rng(&mut self) -> Self {
- Self::from_seed(self.new_rng_seed())
+ Self::from_seed_internal(self.new_rng_seed())
}
/// Overwrite the given TestRng with the provided seed.
pub(crate) fn set_seed(&mut self, seed: Seed) {
- *self = Self::from_seed(seed);
+ *self = Self::from_seed_internal(seed);
}
/// Generate a new randomized seed, set it to this TestRng,
/// and return the seed.
pub(crate) fn gen_get_seed(&mut self) -> Seed {
let seed = self.new_rng_seed();
- self.set_seed(seed);
+ self.set_seed(seed.clone());
seed
}
/// Randomize a perturbed randomized seed from the given TestRng.
pub(crate) fn new_rng_seed(&mut self) -> Seed {
- let mut seed = self.rng.gen::<Seed>();
-
- // Directly using XorShiftRng::from_seed() at this point would result
- // in self.rng and the returned value being exactly the same. Perturb
- // the seed with some arbitrary values to prevent this.
- for word in seed.chunks_mut(4) {
- word[3] ^= 0xde;
- word[2] ^= 0xad;
- word[1] ^= 0xbe;
- word[0] ^= 0xef;
- }
+ match self.rng {
+ TestRngImpl::XorShift(ref mut rng) => {
+ let mut seed = rng.gen::<[u8;16]>();
- seed
+ // Directly using XorShiftRng::from_seed() at this point would
+ // result in rng and the returned value being exactly the same.
+ // Perturb the seed with some arbitrary values to prevent this.
+ for word in seed.chunks_mut(4) {
+ word[3] ^= 0xde;
+ word[2] ^= 0xad;
+ word[1] ^= 0xbe;
+ word[0] ^= 0xef;
+ }
+
+ Seed::XorShift(seed)
+ },
+
+ TestRngImpl::ChaCha(ref mut rng) =>
+ Seed::ChaCha(rng.gen()),
+
+ TestRngImpl::PassThrough { ref mut off, ref mut end, ref data } => {
+ let len = *end - *off;
+ let child_start = *off + len / 2;
+ let child_end = *off + len;
+ *end = child_start;
+ Seed::PassThrough(Some((child_start, child_end)), Arc::clone(data))
+ },
+ }
}
/// Construct a TestRng from a given seed.
- fn from_seed(seed: Seed) -> Self {
- Self { rng: XorShiftRng::from_seed(seed) }
+ fn from_seed_internal(seed: Seed) -> Self {
+ Self { rng: match seed {
+ Seed::XorShift(seed) =>
+ TestRngImpl::XorShift(XorShiftRng::from_seed(seed)),
+
+ Seed::ChaCha(seed) =>
+ TestRngImpl::ChaCha(ChaChaRng::from_seed(seed)),
+
+ Seed::PassThrough(bounds, data) => {
+ let (start, end) = bounds.unwrap_or((0, data.len()));
+ TestRngImpl::PassThrough { off: start, end, data }
+ }
+ } }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use crate::std_facade::Vec;
+
+ use rand::{Rng, RngCore};
+
+ use super::{RngAlgorithm, Seed, TestRng};
+ use crate::arbitrary::any;
+ use crate::strategy::*;
+
+ proptest! {
+ #[test]
+ fn gen_parse_seeds(
+ seed in prop_oneof![
+ any::<[u8;16]>().prop_map(Seed::XorShift),
+ any::<[u8;32]>().prop_map(Seed::ChaCha),
+ any::<Vec<u8>>().prop_map(|data| Seed::PassThrough(None, data.into())),
+ ])
+ {
+ assert_eq!(seed, Seed::from_persistence(&seed.to_persistence()).unwrap());
+ }
+
+ #[test]
+ fn rngs_dont_clone_self_on_genrng(
+ seed in prop_oneof![
+ any::<[u8;16]>().prop_map(Seed::XorShift),
+ any::<[u8;32]>().prop_map(Seed::ChaCha),
+ Just(()).prop_perturb(|_, mut rng| {
+ let mut buf = vec![0u8; 2048];
+ rng.fill_bytes(&mut buf);
+ Seed::PassThrough(None, buf.into())
+ }),
+ ])
+ {
+ type Value = [u8;32];
+ let orig = TestRng::from_seed_internal(seed);
+
+ {
+ let mut rng1 = orig.clone();
+ let mut rng2 = rng1.gen_rng();
+ assert_ne!(rng1.gen::<Value>(), rng2.gen::<Value>());
+ }
+
+ {
+ let mut rng1 = orig.clone();
+ let mut rng2 = rng1.gen_rng();
+ let mut rng3 = rng1.gen_rng();
+ let mut rng4 = rng2.gen_rng();
+ let a = rng1.gen::<Value>();
+ let b = rng2.gen::<Value>();
+ let c = rng3.gen::<Value>();
+ let d = rng4.gen::<Value>();
+ assert_ne!(a, b);
+ assert_ne!(a, c);
+ assert_ne!(a, d);
+ assert_ne!(b, c);
+ assert_ne!(b, d);
+ assert_ne!(c, d);
+ }
+ }
+ }
+
+ #[test]
+ fn passthrough_rng_behaves_properly() {
+ let mut rng = TestRng::from_seed(
+ RngAlgorithm::PassThrough,
+ &[0xDE, 0xC0, 0x12, 0x34,
+ 0x56, 0x78, 0xFE, 0xCA, 0xEF, 0xBE, 0xAD, 0xDE,
+ 0x01, 0x02, 0x03]);
+
+ assert_eq!(0x3412C0DE, rng.next_u32());
+ assert_eq!(0xDEADBEEFCAFE7856, rng.next_u64());
+
+ let mut buf = [0u8; 4];
+ assert!(rng.try_fill_bytes(&mut buf[0..4]).is_err());
+ rng.fill_bytes(&mut buf[0..2]);
+ rng.fill_bytes(&mut buf[2..3]);
+ assert_eq!([1, 2, 3, 0], buf);
}
}
diff --git a/third_party/rust_crates/vendor/proptest/src/test_runner/runner.rs b/third_party/rust_crates/vendor/proptest/src/test_runner/runner.rs
index e83ef63..b045b39 100644
--- a/third_party/rust_crates/vendor/proptest/src/test_runner/runner.rs
+++ b/third_party/rust_crates/vendor/proptest/src/test_runner/runner.rs
@@ -1,5 +1,5 @@
//-
-// Copyright 2017, 2018 The proptest developers
+// Copyright 2017, 2018, 2019 The proptest developers
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
@@ -12,7 +12,7 @@
use std::panic::{self, AssertUnwindSafe};
use core::sync::atomic::AtomicUsize;
use core::sync::atomic::Ordering::SeqCst;
-use std_facade::{Box, Arc, Vec, BTreeMap, String};
+use crate::std_facade::{Box, Arc, Vec, BTreeMap, String};
#[cfg(feature = "fork")]
use std::fs;
@@ -25,14 +25,15 @@
#[cfg(feature = "fork")]
use tempfile;
-use test_runner::{TestRng, Seed};
-use test_runner::errors::*;
-use test_runner::config::*;
-use test_runner::reason::*;
-use test_runner::result_cache::*;
+use crate::test_runner::rng::TestRng;
+use crate::test_runner::errors::*;
+use crate::test_runner::config::*;
+use crate::test_runner::reason::*;
+use crate::test_runner::result_cache::*;
+use crate::test_runner::failure_persistence::PersistedSeed;
#[cfg(feature = "fork")]
-use test_runner::replay;
-use strategy::*;
+use crate::test_runner::replay;
+use crate::strategy::*;
#[cfg(feature = "fork")]
const ENV_FORK_FILE: &'static str = "_PROPTEST_FORKFILE";
@@ -266,13 +267,48 @@
impl TestRunner {
/// Create a fresh `TestRunner` with the given configuration.
+ ///
+ /// The runner will use an RNG with a generated seed and the default
+ /// algorithm.
+ ///
+ /// In `no_std` environments, every `TestRunner` will use the same
+ /// hard-coded seed. This seed is not contractually guaranteed and may be
+ /// changed between releases without notice.
pub fn new(config: Config) -> Self {
+ let algorithm = config.rng_algorithm;
+ TestRunner::new_with_rng(config, TestRng::default_rng(algorithm))
+ }
+
+ /// Create a fresh `TestRunner` with the standard deterministic RNG.
+ ///
+ /// This is sugar for the following:
+ ///
+ /// ```rust
+ /// # use proptest::test_runner::*;
+ /// let config = Config::default();
+ /// let algorithm = config.rng_algorithm;
+ /// TestRunner::new_with_rng(
+ /// config,
+ /// TestRng::deterministic_rng(algorithm));
+ /// ```
+ ///
+ /// Refer to `TestRng::deterministic_rng()` for more information on the
+ /// properties of the RNG used here.
+ pub fn deterministic() -> Self {
+ let config = Config::default();
+ let algorithm = config.rng_algorithm;
+ TestRunner::new_with_rng(
+ config, TestRng::deterministic_rng(algorithm))
+ }
+
+ /// Create a fresh `TestRunner` with the given configuration and RNG.
+ pub fn new_with_rng(config: Config, rng: TestRng) -> Self {
TestRunner {
config: config,
successes: 0,
local_rejects: 0,
global_rejects: 0,
- rng: TestRng::default_rng(),
+ rng: rng,
flat_map_regens: Arc::new(AtomicUsize::new(0)),
local_reject_detail: BTreeMap::new(),
global_reject_detail: BTreeMap::new(),
@@ -472,15 +508,15 @@
{
let old_rng = self.rng.clone();
- let persisted_failure_seeds: Vec<Seed> =
+ let persisted_failure_seeds: Vec<PersistedSeed> =
self.config.failure_persistence
.as_ref()
- .map(|f| f.load_persisted_failures(self.config.source_file))
+ .map(|f| f.load_persisted_failures2(self.config.source_file))
.unwrap_or_default();
let mut result_cache = self.new_cache();
- for persisted_seed in persisted_failure_seeds {
+ for PersistedSeed(persisted_seed) in persisted_failure_seeds {
self.rng.set_seed(persisted_seed);
self.gen_and_run_case(strategy, &test, &mut replay,
&mut *result_cache, &mut fork_output)?;
@@ -501,8 +537,8 @@
// process. The parent relies on it remaining consistent
// and will take care of updating it itself.
if !fork_output.is_in_fork() {
- failure_persistence.save_persisted_failure(
- *source_file, seed, value);
+ failure_persistence.save_persisted_failure2(
+ *source_file, PersistedSeed(seed), value);
}
}
}
@@ -715,7 +751,7 @@
#[cfg(feature = "fork")]
fn init_replay(rng: &mut TestRng) -> (Vec<TestCaseResult>, ForkOutput) {
- use test_runner::replay::{open_file, Replay, ReplayFileStatus::*};
+ use crate::test_runner::replay::{open_file, Replay, ReplayFileStatus::*};
if let Some(path) = env::var_os(ENV_FORK_FILE) {
let mut file = open_file(&path).expect("Failed to open replay file");
@@ -814,8 +850,8 @@
use std::fs;
use super::*;
- use test_runner::FileFailurePersistence;
- use strategy::Strategy;
+ use crate::test_runner::FileFailurePersistence;
+ use crate::strategy::Strategy;
#[test]
fn gives_up_after_too_many_rejections() {
@@ -941,8 +977,8 @@
fn new_rng_makes_separate_rng() {
use rand::Rng;
let mut runner = TestRunner::default();
- let from_1 = runner.new_rng().gen::<Seed>();
- let from_2 = runner.rng().gen::<Seed>();
+ let from_1 = runner.new_rng().gen::<[u8;16]>();
+ let from_2 = runner.rng().gen::<[u8;16]>();
assert_ne!(from_1, from_2);
}
@@ -1092,7 +1128,7 @@
for _ in 0..256 {
let mut runner = TestRunner::new(Config {
failure_persistence: None,
- result_cache: ::test_runner::result_cache::basic_result_cache,
+ result_cache: crate::test_runner::result_cache::basic_result_cache,
.. Config::default()
});
let pass = Rc::new(Cell::new(true));
@@ -1181,7 +1217,7 @@
fn test_shrink_bail(config: Config) {
let mut runner = TestRunner::new(config);
- let result = runner.run(&::num::u64::ANY, |v| {
+ let result = runner.run(&crate::num::u64::ANY, |v| {
thread::sleep(Duration::from_millis(250));
prop_assert!(v <= u32::MAX as u64);
Ok(())
diff --git a/third_party/rust_crates/vendor/proptest/src/tuple.rs b/third_party/rust_crates/vendor/proptest/src/tuple.rs
index a050663..d03efeb 100644
--- a/third_party/rust_crates/vendor/proptest/src/tuple.rs
+++ b/third_party/rust_crates/vendor/proptest/src/tuple.rs
@@ -12,8 +12,8 @@
//! There is no explicit "tuple strategy"; simply make a tuple containing the
//! strategy and that tuple is itself a strategy.
-use strategy::*;
-use test_runner::*;
+use crate::strategy::*;
+use crate::test_runner::*;
/// Common `ValueTree` implementation for all tuple strategies.
#[derive(Clone, Copy, Debug)]
@@ -102,7 +102,7 @@
#[cfg(test)]
mod test {
- use strategy::*;
+ use crate::strategy::*;
use super::*;
