1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#[cfg(test)]
mod parameter_tests {
    use crate::core::function::*;
    use crate::core::llvm_string::LLVMString;
    use crate::core::llvm_type::LLVMType;

    #[test]
    fn function_type_test() {
        let param_set = ParameterSet::new(vec![
            Parameter::new(LLVMString::from("foo"), None, LLVMType::new_int(32)),
            Parameter::new(LLVMString::from("bar"), None, LLVMType::new_int(64)),
        ]);
        let func_type = FunctionType::new(ReturnType::new(LLVMType::new_void(), None), param_set);

        assert_eq!("void (i32 foo, i64 bar)", format!("{}", func_type).as_str());
    }

    #[test]
    fn parameter_display_test() {
        // without parameter attributes
        let param = Parameter::new(LLVMString::from("foo"), None, LLVMType::new_int(32));
        assert_eq!("i32 foo", format!("{}", param).as_str());

        // with parameter attributes
        let mut param2_attrs: ParameterAttributes = Default::default();
        param2_attrs.add_attr(ParameterAttribute::ZEROEXT);
        let param2 = Parameter::new(
            LLVMString::from("bar"),
            Some(param2_attrs),
            LLVMType::new_void(),
        );
        assert_eq!("void zeroext bar", format!("{}", param2).as_str());

        // ParameterSet
        let param_set = ParameterSet::new(vec![param, param2]);
        assert_eq!("i32 foo, void zeroext bar", format!("{}", param_set));
    }

    #[test]
    fn param_attr_display_test() {
        // single attribute
        assert_eq!(
            "zeroext",
            format!("{}", ParameterAttribute::ZEROEXT).as_str()
        );
        assert_eq!(
            "signext",
            format!("{}", ParameterAttribute::SIGNEXT).as_str()
        );

        // attributes
        let mut param_attrs: ParameterAttributes = Default::default();
        param_attrs.add_attr(ParameterAttribute::ZEROEXT);
        param_attrs.add_attr(ParameterAttribute::SIGNEXT);

        let param_attrs_str = format!("{}", param_attrs);
        assert!(param_attrs_str.contains("zeroext"));
        assert!(param_attrs_str.contains("signext"));
    }
}