wrapped_mono 0.2.0

`wrapped_mono` is a safe, lightweight wrapper around the mono library. It allows embedding of the mono runtime inside a rust project. Inside this embedded runtime code written in languages supporting the .NET framework, such as C# and F#, can be run. This allows usage of libraries written in those languages, and using them as a scripting language. The mono runtime is used by many game engines, and this wrapper allows using it with projects written in Rust too.
Documentation 
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#![cfg(test)]
use rusty_fork::rusty_fork_test;
use crate as wrapped_mono;
rusty_fork_test!{
    #[test]
    fn test_interface_iteration(){
        use wrapped_mono::*;
        let domain = jit::init("main",None);
        let asm = domain.assembly_open("test/dlls/Test.dll").expect("Could not load assembly");
        let img = asm.get_image();
        let test_class = Class::from_name(&img,"","TestFunctions").expect("Could not find class");
        let ifaces = test_class.get_interfaces();
        println!("{}",&test_class.get_name());
        assert!(ifaces.len() > 0);
        assert!("IInterfaceOne" == &ifaces[0].get_name());
    }
    #[test]
    fn class_get_namespace(){
        use crate as wrapped_mono;
        use wrapped_mono::jit;
        use wrapped_mono::object::*;
        use wrapped_mono::class::Class;
        let _main = jit::init("main",None);
        let class = Class::get_int_64();
        assert!("System" == &class.get_namespace());
    }
    #[test]
    fn get_parrent(){
        use wrapped_mono::*;
        let domain = jit::init("main",None);
        let asm = domain.assembly_open("test/dlls/Test.dll").expect("Could not load assembly");
        let img = asm.get_image();
        let test_class = Class::from_name(&img,"","TestFunctions").expect("Could not find class");
        test_class.get_parent();
    }
    #[test]
    fn class_get_namespace_no_namespace(){
        use wrapped_mono::*;
        let domain = jit::init("main",None);
        let asm = domain.assembly_open("test/dlls/Test.dll").expect("Could not load assembly");
        let img = asm.get_image();
        let test_class = Class::from_name(&img,"","TestFunctions").expect("Could not find class");
        assert!("" == &test_class.get_namespace());
    }
    #[test]
    fn class_get_array_element_class(){
        use wrapped_mono::*;
        let domain = jit::init("main",None);
        let arr:Array<1,i64> = Array::new(&domain,&[32]);
        let arr_class = arr.get_class();
        assert!(Class::get_int_64() == arr_class.get_element_class());
    }
    #[test]
    fn class_get_rank(){
        use wrapped_mono::*;
        let domain = jit::init("main",None);
        let arr:Array<1,i64> = Array::new(&domain,&[32]);
        let arr_class = arr.get_class();
        let rank = arr_class.get_rank();
        assert!(rank == 1);
    }
    #[test]
    fn class_get_rank_not_array(){
        use wrapped_mono::*;
        let _domain = jit::init("main",None);
        let rank = Class::get_int_64().get_rank();
        assert!(rank == 0);
    }
    #[test]
    fn class_get_field(){
        use crate::binds::MonoObject;
        use wrapped_mono::{jit,class::Class,object::{Object,ObjectTrait}};
        let dom = jit::init("root",None);
        let asm = dom.assembly_open("test/dlls/Test.dll").unwrap();
        let img = asm.get_image();
        let class = Class::from_name(&img,"","TestFunctions").expect("Could not get class");
        let filed = Class::get_field_from_name(&class,"someField").expect("Could not get filed!");
    }
    // TODO:rethink removal of those functionalities, maybe re-add themin 0.3
    /*
    #[test]
    fn ctors_get(){
        use crate::binds::MonoObject;
        use wrapped_mono::{jit,class::Class,object::{Object,ObjectTrait}};
        let dom = jit::init("root",None);
        let asm = dom.assembly_open("test/dlls/Test.dll").unwrap();
        let img = asm.get_image();
        let class = Class::from_name(&img,"","TestFunctions").expect("Could not get class");
        unimplemented!("TODO:fix Class::get_ctors_recursive");
        //let ctors = class.get_ctros_recursive();
        //println!("{}",ctors.len());
        //assert!(ctors.len() == 2);//One of 'Object', one of 'TestFunctions'
    }
    #[test]
    fn ctors_recursive_get(){
        use crate::binds::MonoObject;
        use wrapped_mono::{jit,class::Class,object::{Object,ObjectTrait}};
        let dom = jit::init("root",None);
        let asm = dom.assembly_open("test/dlls/Test.dll").unwrap();
        let img = asm.get_image();
        let class = Class::from_name(&img,"","CtorTestClass").expect("Could not get class");
        unimplemented!("TODO:fix Class::get_ctors_recursive");
        /*
        let ctors = class.get_ctros_recursive();
        println!("Found {} constructors!",ctors.len());
        for ctor in &ctors{
            println!("{}",ctor);
        }
        assert!(ctors.len() == 5);
        */
        //panic!();
    }*/
    #[test]
    fn get_delegate(){
        use wrapped_mono::{jit,class::Class,object::{Object,ObjectTrait}};
        let dom = jit::init("root",None);
        let del = Class::get_delegate_class();
    }
    #[test]
    fn get_generic_class_string(){
        use crate::{Method,Class,MethodTrait};
        let dom = crate::jit::init("root",None);
        let asm = dom.assembly_open("test/dlls/Test.dll").unwrap();
        let img = asm.get_image();
        let class = Class::from_name(&img,"","TestFunctions").expect("Could not get class");
        let met:Method<()> = Method::get_from_name(&class,"CreateTypeString",0).unwrap();
        let res = met.invoke(None,()).expect("Got an exception").unwrap();
    }
         
}