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: test_instruction_values.rs
    path of file: ./repos/inkwell/tests/all
    
    the code of the file until where you have to start completion: use inkwell::context::Context;
use inkwell::types::{AnyTypeEnum, AsTypeRef, BasicType};
use inkwell::values::{BasicValue, InstructionOpcode::*};
use inkwell::{AddressSpace, AtomicOrdering, AtomicRMWBinOp, FloatPredicate, IntPredicate};

#[test]
#[ignore]
fn test_operands() {
    let context = Context::create();
    let module = context.create_module("ivs");
    let builder = context.create_builder();
    let void_type = context.void_type();
    let f32_type = context.f32_type();
    let f32_ptr_type = f32_type.ptr_type(AddressSpace::default());
    let fn_type = void_type.fn_type(&[f32_ptr_type.into()]
    
fn test_instructions() {
    let context = Context::create();
    let module = context.create_module("testing");
    let builder = context.create_builder();

    let void_type = context.void_type();
    let i64_type = context.i64_type();
    let f32_type = context.f32_type();
    let f32_ptr_type = f32_type.ptr_type(AddressSpace::default());
    let fn_type = void_type.fn_type(&[f32_ptr_type.into(), f32_type.into()], false);

    let function = module.add_function("free_f32", fn_type, None);
    let basic_block = context.append_basic_block(function, "entry");

    builder.position_at_end(basic_block);

    let arg1 = function.get_first_param().unwrap().into_pointer_value();
    let arg2 = function.get_nth_param(1).unwrap().into_float_value();

    assert!(arg1.get_first_use().is_none());
    assert!(arg2.get_first_use().is_none());

    let f32_val = f32_type.const_float(::std::f64::consts::PI);

    let store_instruction = builder.build_store(arg1, f32_val).unwrap();
    let alloca_val = builder.build_alloca(i64_type, "alloca").unwrap();
    let ptr_val = builder.build_ptr_to_int(arg1, i64_type, "ptr_val").unwrap();
    let ptr = builder.build_int_to_ptr(ptr_val, f32_ptr_type, "ptr").unwrap();
    let icmp = builder.build_int_compare(IntPredicate::EQ, arg1, arg1, "icmp").unwrap();
    let f32_sum = builder.build_float_add(arg2, f32_val, "f32_sum").unwrap();
    let fcmp = builder
        .build_float_compare(FloatPredicate::OEQ, f32_sum, arg2, "fcmp")
        .unwrap();
    let free_instruction = builder.build_free(arg1).unwrap();
    let return_instruction = builder.build_return(None).unwrap();
    let cond_br_instruction = builder
        .build_conditional_branch(i64_type.const_zero(), basic_block, basic_block)
        .unwrap();

    assert_eq!(
        alloca_val.as_instruction().unwrap().get_allocated_type(),
        Ok(i64_type.as_basic_type_enum())
    );
    assert!(store_instruction.get_allocated_type().is_err());
    assert!(!store_instruction.is_terminator());
    assert!(return_instruction.is_terminator());
    assert!(!store_instruction.is_conditional());
    assert!(!return_instruction.is_conditional());
    assert!(cond_br_instruction.is_conditional());
    assert_eq!(store_instruction.get_opcode(), Store);
    assert_eq!(ptr_val.as_instruction().unwrap().get_opcode(), PtrToInt);
    assert_eq!(ptr.as_instruction().unwrap().get_opcode(), IntToPtr);
    assert_eq!(icmp.as_instruction().unwrap().get_opcode(), ICmp);
    assert_eq!(ptr.as_instruction().unwrap().get_icmp_predicate(), None);
    assert_eq!(
        icmp.as_instruction().unwrap().get_icmp_predicate().unwrap(),
        IntPredicate::EQ
    );
    assert_eq!(f32_sum.as_instruction().unwrap().get_opcode(), FAdd);
    assert_eq!(fcmp.as_instruction().unwrap().get_opcode(), FCmp);
    assert_eq!(f32_sum.as_instruction().unwrap().get_fcmp_predicate(), None);
    assert_eq!(icmp.as_instruction().unwrap().get_fcmp_predicate(), None);
    assert_eq!(
        fcmp.as_instruction().unwrap().get_fcmp_predicate().unwrap(),
        FloatPredicate::OEQ
    );
    assert_eq!(free_instruction.get_opcode(), Call);
    assert_eq!(return_instruction.get_opcode(), Return);

    // test instruction type
    assert_eq!(store_instruction.get_type(), AnyTypeEnum::from(void_type));
    assert_eq!(free_instruction.get_type(), AnyTypeEnum::from(void_type));
    assert_eq!(
        f32_sum.as_instruction().unwrap().get_type(),
        AnyTypeEnum::from(f32_type)
    );

    // test instruction cloning
    #[allow(clippy::redundant_clone)]
    let instruction_clone = return_instruction.clone();

    assert_eq!(instruction_clone.get_opcode(), return_instruction.get_opcode());
    assert_ne!(instruction_clone, return_instruction);

    // test copying
    let instruction_clone_copy = instruction_clone;

    assert_eq!(instruction_clone, instruction_clone_copy);
}