Support quickcheck based property testing

core/Cargo.toml

@@ -48,6 +48,8 @@ scale-info = { version = "0.2", default-features = false, features = ["derive"],
 criterion = { version = "0.3", optional = true }
 
 [dev-dependencies]
+quickcheck = "0.9"
+quickcheck_macros = "0.8"
 itertools = "0.9"
 
 [features]
@@ -70,6 +72,7 @@ std = [
     "sha3",
     "blake2",
 ]
+ink-fuzz-tests = ["std"]
 
 [[bench]]
 name = "bench"

core/src/lib.rs

@@ -48,6 +48,10 @@
 #[cfg(not(feature = "std"))]
 extern crate ink_alloc;
 
+#[cfg(all(test, feature = "std", feature = "ink-fuzz-tests"))]
+#[macro_use(quickcheck)]
+extern crate quickcheck_macros;
+
 pub mod env;
 pub mod hash;
 pub mod storage2;

core/src/storage2/collections/hashmap/fuzz_tests.rs

@@ -0,0 +1,121 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::HashMap as StorageHashMap;
+use crate::env;
+
+use itertools::Itertools;
+
+/// Conducts repeated insert and remove operations into the map by iterating
+/// over `xs`. For each odd `x` in `xs` a defined number of insert operations
+/// (`inserts_each`) is executed. For each even `x` it's asserted that the
+/// previously inserted elements are in the map and they are removed subsequently.
+///
+/// The reasoning behind this even/odd sequence is to introduce some
+/// randomness into when elements are inserted/removed.
+///
+/// `inserts_each` was chosen as `u8` to keep the number of inserts per `x` in
+/// a reasonable range.
+fn insert_and_remove(xs: Vec<i32>, inserts_each: u8) {
+    let mut map = <StorageHashMap<i32, i32>>::new();
+    let mut cnt_inserts = 0;
+    let mut previous_even_x = None;
+    let inserts_each = inserts_each as i32;
+
+    xs.into_iter().for_each(|x| {
+        if x % 2 == 0 {
+            // On even numbers we insert
+            for key in x..x + inserts_each {
+                let val = key * 10;
+                if let None = map.insert(key, val) {
+                    assert_eq!(map.get(&key), Some(&val));
+                    cnt_inserts += 1;
+                }
+                assert_eq!(map.len(), cnt_inserts);
+            }
+            if let None = previous_even_x {
+                previous_even_x = Some(x);
+            }
+        } else if x % 2 == 1 && previous_even_x.is_some() {
+            // If it's an odd number and we inserted in a previous run we assert
+            // that the last insert worked correctly and remove the elements again.
+            //
+            // It can happen that after one insert run there are many more
+            // insert runs (i.e. even `x` in `xs`) before we remove the numbers
+            // of the last run again. This is intentional, as to include testing
+            // if subsequent insert operations have an effect on already inserted
+            // items.
+            let x = previous_even_x.unwrap();
+            for key in x..x + inserts_each {
+                let val = key * 10;
+                assert_eq!(map.get(&key), Some(&val));
+                assert_eq!(map.take(&key), Some(val));
+                assert_eq!(map.get(&key), None);
+                cnt_inserts -= 1;
+                assert_eq!(map.len(), cnt_inserts);
+            }
+            previous_even_x = None;
+        }
+    });
+}
+
+#[quickcheck]
+fn inserts_and_removes(xs: Vec<i32>, inserts_each: u8) {
+    env::test::run_test::<env::DefaultEnvTypes, _>(|_| {
+        insert_and_remove(xs, inserts_each);
+        Ok(())
+    })
+    .unwrap()
+}
+
+/// Inserts all elements from `xs`. Then removes each `xth` element from the map
+/// and asserts that all non-`xth` elements are still in the map.
+#[quickcheck]
+fn removes(xs: Vec<i32>, xth: usize) {
+    env::test::run_test::<env::DefaultEnvTypes, _>(|_| {
+        // given
+        let xs: Vec<i32> = xs.into_iter().unique().collect();
+        let xth = xth.max(1);
+        let mut map = <StorageHashMap<i32, i32>>::new();
+        let mut len = map.len();
+
+        // when
+        // 1) insert all
+        xs.iter().for_each(|i| {
+            assert_eq!(map.insert(*i, i * 10), None);
+            len += 1;
+            assert_eq!(map.len(), len);
+        });
+
+        // 2) remove every `xth` element of `xs` from the map
+        xs.iter().enumerate().for_each(|(x, i)| {
+            if x % xth == 0 {
+                assert_eq!(map.take(&i), Some(i * 10));
+                len -= 1;
+            }
+            assert_eq!(map.len(), len);
+        });
+
+        // then
+        // everything else must still be get-able
+        xs.iter().enumerate().for_each(|(x, i)| {
+            if x % xth != 0 {
+                assert_eq!(map.get(&i), Some(&(i * 10)));
+            }
+        });
+
+        Ok(())
+    })
+    .unwrap()
+}

core/src/storage2/collections/hashmap/mod.rs

@@ -21,6 +21,9 @@ mod storage;
 #[cfg(test)]
 mod tests;
 
+#[cfg(all(test, feature = "ink-fuzz-tests"))]
+mod fuzz_tests;
+
 pub use self::iter::{
     Iter,
     IterMut,