You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: yul.rs
    path of file: ./repos/solang/tests/polkadot_tests
    
    the code of the file until where you have to start completion: // SPDX-License-Identifier: Apache-2.0

use crate::build_solidity;
use parity_scale_codec::{Decode, Encode};
use primitive_types::U256;
use rand::{thread_rng, Rng};

#[derive(Debug, Encode, Decode)]
struct Val256(U256);

#[test]
fn assign_suffixes() {
    #[derive(Debug, Encode, Decode)]
    struct CallDataInput {
        pub input: U256,
        pub vec: Vec<u32>,
    }

    let mut runtime = build_solidity(
        r#"
contract testing  {
    struct stru_test {
        string a;
        uint b;
    }


    stru_test t_s_t;
    function test_local_vec(uint256 input) public pure returns (uint256 ret) {
        uint256[] vec;
        vec.push(uint256(4));
        assembly {
            vec := add(input, 7)
            input := 6
            ret := vec
        }
    }

    function test_struct(uint256 input) public pure retu
    
fn storage_slot_on_return_data() {
    let mut runtime = build_solidity(
        r#"
    library StorageSlot {
        struct AddressSlot {
            address value;
        }
    
        function getAddressSlot(
            bytes32 slot
        ) internal pure returns (AddressSlot storage r) {
            assembly {
                r.slot := slot
            }
        }
    }
    
    contract StorageKeys {
        function set(bytes32 key) public {
            StorageSlot.AddressSlot storage slot = StorageSlot.getAddressSlot(key);
            slot.value = msg.sender;
        }
    
        function get(bytes32 key) public returns (address a) {
            a = StorageSlot.getAddressSlot(key).value;
        }
    }"#,
    );

    let default_address = [0u8; 32];

    // Without setting any key, they all shuld be default
    let key = [0u8; 32];
    runtime.function("get", key.to_vec());
    assert_eq!(runtime.output(), default_address);

    let key = [0xffu8; 32];
    runtime.function("get", key.to_vec());
    assert_eq!(runtime.output(), default_address);

    let mut key = [0u8; 32];
    thread_rng().try_fill(&mut key).unwrap();
    runtime.function("get", key.to_vec());
    assert_eq!(runtime.output(), default_address);

    // Setting the key should write to the correct storage slot
    runtime.function("set", key.to_vec());
    runtime.function("get", key.to_vec());
    assert_eq!(runtime.output(), runtime.caller());

    let key = [0u8; 32];
    runtime.function("set", key.to_vec());
    runtime.function("get", key.to_vec());
    assert_eq!(runtime.output(), runtime.caller())
}