netcorehost 0.13.1

A Rust library for hosting the .NET Core runtime.
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

#![cfg(feature = "netcore3_0")]

use netcorehost::{hostfxr::GetManagedFunctionError, nethost, pdcstr};
use rusty_fork::rusty_fork_test;

#[path = "common.rs"]
mod common;

rusty_fork_test! {
    #[test]
    fn get_function_pointer() {
        common::setup();

        let hostfxr = nethost::load_hostfxr().unwrap();

        let context = hostfxr
            .initialize_for_runtime_config(common::test_runtime_config_path())
            .unwrap();
        let fn_loader = context
            .get_delegate_loader_for_assembly(common::test_dll_path())
            .unwrap();

        let invalid_method_name = fn_loader.get_function_with_default_signature(
            pdcstr!("Test.Program, Test"),
            pdcstr!("SomeMethodThatDoesNotExist"),
        );
        assert!(invalid_method_name.is_err());
        assert_eq!(
            unsafe { invalid_method_name.unwrap_err_unchecked() },
            GetManagedFunctionError::MissingMethod
        );

        let invalid_method_signature = fn_loader
            .get_function_with_default_signature(pdcstr!("Test.Program, Test"), pdcstr!("Main"));
        assert!(invalid_method_signature.is_err());
        assert_eq!(
            unsafe { invalid_method_signature.unwrap_err_unchecked() },
            GetManagedFunctionError::MissingMethod
        );

        let invalid_type_name = fn_loader.get_function_with_default_signature(
            pdcstr!("Test.SomeTypeThatDoesNotExist, Test"),
            pdcstr!("Hello"),
        );
        assert!(invalid_type_name.is_err());
        assert_eq!(
            unsafe { invalid_type_name.unwrap_err_unchecked() },
            GetManagedFunctionError::TypeNotFound
        );

        let invalid_namespace_name = fn_loader.get_function_with_default_signature(
            pdcstr!("SomeNamespaceThatDoesNotExist.Program, Test"),
            pdcstr!("Hello"),
        );
        assert!(invalid_namespace_name.is_err());
        assert_eq!(
            unsafe { invalid_namespace_name.unwrap_err_unchecked() },
            GetManagedFunctionError::TypeNotFound
        );

        let invalid_assembly_name = fn_loader.get_function_with_default_signature(
            pdcstr!("Test.Program, SomeAssemblyThatDoesNotExist"),
            pdcstr!("Hello"),
        );
        assert!(invalid_assembly_name.is_err());
        assert_eq!(
            unsafe { invalid_assembly_name.unwrap_err_unchecked() },
            GetManagedFunctionError::AssemblyNotFound
        );

        let method_not_marked = fn_loader.get_function_with_unmanaged_callers_only::<fn()>(
            pdcstr!("Test.Program, Test"),
            pdcstr!("Hello"),
        );
        assert!(method_not_marked.is_err());
        assert_eq!(
            unsafe { method_not_marked.unwrap_err_unchecked() },
            GetManagedFunctionError::MethodNotUnmanagedCallersOnly
        );

        let invalid_delegate_type_name = fn_loader.get_function::<fn()>(
            pdcstr!("Test.Program, Test"),
            pdcstr!("Hello"),
            pdcstr!("Test.Program+SomeDelegateThatDoesNotExist, Test"),
        );
        assert!(invalid_delegate_type_name.is_err());
        assert_eq!(
            unsafe { invalid_delegate_type_name.unwrap_err_unchecked() },
            GetManagedFunctionError::TypeNotFound
        );

        unsafe { context.close() }.unwrap();
    }

    #[test]
    fn get_delegate_loader_for_assembly() {
        common::setup();

        let hostfxr = nethost::load_hostfxr().unwrap();

        let context = hostfxr
            .initialize_for_runtime_config(common::test_runtime_config_path())
            .unwrap();

        let fn_loader = context
            .get_delegate_loader_for_assembly(pdcstr!("tests/errors.rs"))
            .unwrap();
        let invalid_assembly_path = fn_loader
            .get_function_with_default_signature(pdcstr!("Test.Program, Test"), pdcstr!("Hello"));
        assert!(invalid_assembly_path.is_err());
        assert_eq!(
            unsafe { invalid_assembly_path.unwrap_err_unchecked() },
            GetManagedFunctionError::AssemblyNotFound
        );

        let fn_loader = context
            .get_delegate_loader_for_assembly(pdcstr!("PathThatDoesNotExist.dll"))
            .unwrap();
        let non_existant_assembly_path = fn_loader
            .get_function_with_default_signature(pdcstr!("Test.Program, Test"), pdcstr!("Hello"));
        assert!(non_existant_assembly_path.is_err());
        assert_eq!(
            unsafe { non_existant_assembly_path.unwrap_err_unchecked() },
            GetManagedFunctionError::AssemblyNotFound
        );

        unsafe { context.close() }.unwrap();
    }
}