Moving Vector tests to vm2-collections-test contract so they will execute against a real execution engine

Author: zajko

executor/wasm/tests/collections.rs

@@ -86,3 +86,75 @@ fn should_run_test_suite() {
         assert!(res.host_error.is_none());
     }
 }
+
+#[test]
+fn inserting_into_non_existing_vec_index_fails() {
+    let chainspec_config = ChainspecConfig::from_chainspec_path(&*CHAINSPEC_SYMLINK)
+        .expect("must get chainspec config");
+    let storage_costs = chainspec_config.storage_costs;
+    let mint_costs = chainspec_config.system_costs_config.mint_costs().clone();
+    let auction_costs = chainspec_config.system_costs_config.auction_costs().clone();
+    let v1_config = EngineConfig::from(chainspec_config.clone());
+    let execution_engine_v1 = ExecutionEngineV1::new(v1_config);
+    let wasm_v2_config = *chainspec_config.wasm_config.v2();
+    let memory_limit = wasm_v2_config.max_memory();
+    let message_limits = chainspec_config.wasm_config.messages_limits();
+    let executor_config = ExecutorConfigBuilder::default()
+        .with_memory_limit(memory_limit)
+        .with_executor_kind(ExecutorKind::Compiled)
+        .with_wasm_config(wasm_v2_config)
+        .with_storage_costs(storage_costs)
+        .with_mint_costs(mint_costs)
+        .with_auction_costs(auction_costs)
+        .with_baseline_motes_amount(chainspec_config.core_config.baseline_motes_amount)
+        .with_message_limits(message_limits)
+        .build()
+        .expect("Should build");
+    let mut executor = ExecutorV2::new(executor_config, execution_engine_v1);
+
+    let (global_state, mut state_root_hash, _tempdir) = make_global_state_with_genesis();
+
+    let address_generator = make_address_generator();
+
+    let vm2_collections_test = read_wasm("vm2_collections_test.wasm");
+
+    let install_request = base_install_request_builder(&chainspec_config)
+        .with_wasm_bytes(vm2_collections_test.wasm)
+        .with_bundle_data(vm2_collections_test.meta.expect("should have bundle data"))
+        .with_shared_address_generator(Arc::clone(&address_generator))
+        .with_transferred_value(0)
+        .with_entry_point("new".to_string())
+        .build()
+        .expect("should build");
+
+    let create_result = run_create_contract(
+        &mut executor,
+        &global_state,
+        state_root_hash,
+        install_request,
+    );
+
+    let contract_address = *create_result.smart_contract_addr();
+    state_root_hash = global_state
+        .commit_effects(state_root_hash, create_result.effects().clone())
+        .expect("Should commit");
+
+    let run_method = base_execute_builder(&chainspec_config)
+        .with_shared_address_generator(Arc::clone(&address_generator))
+        .with_transferred_value(0)
+        .with_execution_kind(ExecutionKind::Stored {
+            address: contract_address,
+            entry_point: "test_remove_invalid_index_prepare".to_owned(),
+        })
+        .build()
+        .expect("should build");
+    let res = run_wasm_session(&mut executor, &global_state, state_root_hash, run_method);
+    assert!(res.is_ok());
+    if let Ok(res) = res {
+        let host_error = res.host_error;
+        assert!(host_error.is_some());
+        if let Some(err) = host_error {
+            println!("XXX {:?}", err);
+        }
+    }
+}

smart_contracts/contracts/vm2/vm2-collections-test/src/lib.rs

@@ -6,15 +6,17 @@ extern crate alloc;
 mod iterable_map;
 mod iterable_set;
 mod types;
-use casper_contract_sdk::prelude::*;
+mod vector;
+use casper_contract_sdk::{collections::Vector, prelude::*};
 use iterable_map::*;
 
-use crate::iterable_set::IterableSetTestData;
+use crate::{iterable_set::IterableSetTestData, vector::VectorTestData};
 
 #[casper(contract_state)]
 pub struct CollectionsTestContract {
     iterable_map_test_data: IterableMapTestData,
     iterable_set_test_data: IterableSetTestData,
+    vector_test_data: VectorTestData,
 }
 
 impl Default for CollectionsTestContract {
@@ -27,14 +29,24 @@ impl Default for CollectionsTestContract {
 impl CollectionsTestContract {
     #[casper(constructor)]
     pub fn new() -> Self {
+        let iterable_map_test_data = IterableMapTestData::new();
+        let iterable_set_test_data = IterableSetTestData::new();
+        let vector_test_data = VectorTestData::new();
         Self {
-            iterable_map_test_data: IterableMapTestData::new(),
-            iterable_set_test_data: IterableSetTestData::new(),
+            iterable_map_test_data,
+            iterable_set_test_data,
+            vector_test_data,
         }
     }
 
     pub(crate) fn assertions(&mut self) {
-        //self.iterable_map_test_data.do_assertions();
+        self.iterable_map_test_data.do_assertions();
         self.iterable_set_test_data.do_assertions();
+        self.vector_test_data.do_assertions();
+    }
+
+    pub(crate) fn vector_insert_out_of_bounds_panics(&mut self) {
+        let mut vec = Vector::<u64>::new("vector_insert_out_of_bounds");
+        vec.insert(1, 1);
     }
 }

smart_contracts/contracts/vm2/vm2-collections-test/src/types.rs

@@ -46,6 +46,35 @@ impl CasperABI for TestKey {
     }
 }
 
+#[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
+pub(crate) struct VectorTestStruct {
+    pub(crate) field: u64,
+}
+
+impl IterableMapHash for VectorTestStruct {}
+
+impl TypeUid for VectorTestStruct {
+    const UID: Uid = Uid::from_name("VectorTestStruct");
+}
+
+impl CLTyped for VectorTestStruct {
+    fn cl_type() -> CLType {
+        CLType::Any
+    }
+}
+
+#[cfg(all(not(target_arch = "wasm32")))]
+impl CasperABI for VectorTestStruct {
+    fn definition() -> casper_contract_sdk::abi::Definition {
+        Definition::Struct {
+            items: vec![StructField {
+                name: "field1".into(),
+                decl: casper_executor_wasm_common::type_uid::of::<u64>().into(),
+            }],
+        }
+    }
+}
+
 #[derive(BorshSerialize, BorshDeserialize, Clone, Debug, PartialEq)]
 pub(crate) struct TestStruct {
     pub(crate) field1: u64,

smart_contracts/contracts/vm2/vm2-collections-test/src/vector/assert.rs

@@ -0,0 +1,175 @@
+use core::{panic, ptr::NonNull};
+
+use alloc::{vec, vec::Vec};
+use casper_contract_sdk::{
+    casper,
+    collections::{compute_prefix_bytes_for_index, Vector},
+    types::HashAlgorithm,
+};
+use casper_executor_wasm_common::{
+    keyspace::{CollectionAddrInner, ContextAddr, Keyspace},
+    CollectionTypeTag,
+};
+use const_fnv1a_hash::fnv1a_hash_str_64;
+
+use crate::types::VectorTestStruct;
+
+fn get_vec_elements_from_storage(prefix: &str) -> Vec<u64> {
+    let mut values = Vec::new();
+    for idx in 0..64 {
+        let prefix_bytes = compute_prefix_bytes_for_index(prefix, idx);
+        let collection_prefix = fnv1a_hash_str_64(prefix).to_le_bytes();
+        let addr = CollectionAddrInner::new(
+            *casper::get_callee().address(),
+            CollectionTypeTag::Vector,
+            collection_prefix,
+            casper::generic_hash(&prefix_bytes, HashAlgorithm::Blake2b).unwrap(),
+        );
+
+        let mut value: [u8; 8] = [0; 8];
+        let result = casper::read(Keyspace::Context(ContextAddr::from(addr)), |size| {
+            assert_eq!(size, 8);
+            NonNull::new(value.as_mut_ptr())
+        })
+        .unwrap();
+
+        if result.is_some() {
+            values.push(u64::from_le_bytes(value));
+        }
+    }
+    values
+}
+
+pub(crate) fn should_not_panic_with_empty_assert(vec: &mut Vector<u64>) {
+    assert_eq!(vec.len(), 0);
+    assert_eq!(vec.remove(0), None);
+    vec.retain(|_| false);
+    let _ = vec.binary_search(&123);
+    let v: Vec<u64> = vec.iter().collect();
+    assert_eq!(v, Vec::<u64>::new())
+}
+
+pub(crate) fn should_retain_assert(vec: &mut Vector<u64>) {
+    let vec: Vec<_> = vec.iter().collect();
+    assert_eq!(vec, vec![2, 4]);
+}
+
+pub(crate) fn test_vec_assert(vec: &mut Vector<u64>) {
+    assert_eq!(vec.remove(5), Some(334));
+    assert_eq!(vec.remove(55), None);
+
+    let mut iter = vec.iter();
+    assert_eq!(iter.next(), Some(41));
+    assert_eq!(iter.next(), Some(43));
+    assert_eq!(iter.next(), Some(42));
+    assert_eq!(iter.next(), Some(111));
+    assert_eq!(iter.next(), Some(222));
+    assert_eq!(iter.next(), Some(333));
+    assert_eq!(iter.next(), None);
+
+    {
+        let ser = borsh::to_vec(vec).unwrap();
+        let deser: Vector<u64> = borsh::from_slice(&ser).unwrap();
+        let mut iter = deser.iter();
+        assert_eq!(iter.next(), Some(41));
+        assert_eq!(iter.next(), Some(43));
+        assert_eq!(iter.next(), Some(42));
+        assert_eq!(iter.next(), Some(111));
+        assert_eq!(iter.next(), Some(222));
+        assert_eq!(iter.next(), Some(333));
+        assert_eq!(iter.next(), None);
+    }
+
+    assert_eq!(
+        get_vec_elements_from_storage("test_vec"),
+        vec![41, 43, 42, 111, 222, 333]
+    );
+
+    let vec2 = Vector::<u64>::new("test1");
+    assert_eq!(vec2.get(0), None);
+
+    assert_eq!(get_vec_elements_from_storage("test1"), Vec::<u64>::new());
+}
+
+pub(crate) fn test_pop_assert(vec: &mut Vector<u64>) {
+    assert_eq!(vec.pop(), Some(2));
+    assert_eq!(vec.len(), 1);
+    assert_eq!(vec.pop(), Some(1));
+    assert!(vec.is_empty());
+
+    assert_eq!(get_vec_elements_from_storage("test_pop"), Vec::<u64>::new());
+}
+
+pub(crate) fn test_contains_assert(vec: &mut Vector<u64>) {
+    assert!(vec.contains(&1));
+    assert!(vec.contains(&2));
+    assert!(!vec.contains(&3));
+    vec.remove(0);
+    assert!(!vec.contains(&1));
+    assert_eq!(
+        get_vec_elements_from_storage("test_contains_prepare"),
+        vec![2]
+    );
+}
+
+pub(crate) fn test_clear_assert(vec: &mut Vector<u64>) {
+    vec.clear();
+    assert_eq!(vec.len(), 0);
+    assert!(vec.is_empty());
+    assert_eq!(vec.get(0), None);
+    vec.push(3);
+    assert_eq!(vec.get(0), Some(3));
+
+    assert_eq!(get_vec_elements_from_storage("test_clear"), vec![3]);
+}
+
+pub(crate) fn test_binary_search_assert(vec: &mut Vector<u64>) {
+    assert_eq!(vec.binary_search(&3), Ok(2));
+    assert_eq!(vec.binary_search(&0), Err(0));
+    assert_eq!(vec.binary_search(&6), Err(5));
+}
+
+pub(crate) fn test_swap_remove_assert(vec: &mut Vector<u64>) {
+    assert_eq!(vec.iter().collect::<Vec<_>>(), vec![1, 4]);
+    assert_eq!(
+        get_vec_elements_from_storage("test_swap_remove"),
+        vec![1, 4]
+    );
+}
+
+pub(crate) fn test_insert_at_len_assert(vec: &mut Vector<u64>) {
+    assert_eq!(vec.iter().collect::<Vec<_>>(), vec![1, 2]);
+    assert_eq!(
+        get_vec_elements_from_storage("test_insert_at_len"),
+        vec![1, 2]
+    );
+}
+
+pub(crate) fn test_struct_elements_assert(vec: &mut Vector<VectorTestStruct>) {
+    assert_eq!(vec.get(1), Some(VectorTestStruct { field: 2 }));
+    assert_eq!(vec.len(), 2);
+}
+
+pub(crate) fn test_multiple_operations_assert(vec: &mut Vector<u64>) {
+    vec.push(1);
+    vec.insert(0, 2);
+    vec.push(3);
+    assert_eq!(vec.iter().collect::<Vec<_>>(), vec![2, 1, 3]);
+    assert_eq!(vec.swap_remove(0), Some(2));
+    assert_eq!(vec.iter().collect::<Vec<_>>(), vec![3, 1]);
+    assert_eq!(vec.pop(), Some(1));
+    assert_eq!(vec.get(0), Some(3));
+    vec.clear();
+    assert!(vec.is_empty());
+
+    assert_eq!(
+        get_vec_elements_from_storage("test_multiple_operations"),
+        Vec::<u64>::new()
+    );
+}
+
+pub(crate) fn test_remove_invalid_index_assert(vec: &mut Vector<u64>) {
+    assert_eq!(vec.remove(1), None);
+    assert_eq!(vec.remove(0), Some(1));
+    assert_eq!(vec.remove(0), None);
+}