interoptopus_csharp 0.16.0-alpha.18

The C# backend for Interoptopus.
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

using My.Company;
using My.Company.Common;
using Xunit;
using Interop = My.Company.Interop;

public class TestPatternSlices
{
    [Fact]
    public void pattern_ffi_slice_1()
    {
        using var data = new uint[100_000].Slice();
        var result = Interop.pattern_ffi_slice_1(data);
        Assert.Equal(100_000u, result);
    }


    [Fact]
    public void pattern_ffi_slice_2()
    {
        using var data = new Vec3f32[]
        {
            new() { x = 1.0f, y = 2.0f, z = 3.0f },
            new() { x = 4.0f, y = 5.0f, z = 6.0f },
            new() { x = 7.0f, y = 8.0f, z = 9.0f }
        }.Slice();

        var result = Interop.pattern_ffi_slice_2(data, 1);

        Assert.Equal(4.0f, result.x);
        Assert.Equal(5.0f, result.y);
        Assert.Equal(6.0f, result.z);
    }

    [Fact]
    public void pattern_ffi_slice_3()
    {
        using var data = new byte[100_000].SliceMut();

        Interop.pattern_ffi_slice_3(data, slice =>
        {
            slice[0] = 1;
            slice[1] = 100;
        });

        Assert.Equal(data[0], 1);
        Assert.Equal(data[1], 100);
    }

    [Fact]
    public void pattern_ffi_slice_5()
    {
        var data1 = new byte[100_000].Slice();
        var data2 = new byte[100_000].SliceMut();

        Interop.pattern_ffi_slice_5(ref data1, ref data2);
        data1.Dispose();
        data2.Dispose();
    }

    [Fact]
    public void pattern_ffi_slice_6()
    {
        var data = new byte[] { 1, 2, 3 }.SliceMut();

        using var callback = new CallbackU8(x =>
        {
            Assert.Equal(1, x);
            return 0;
        });
        Interop.pattern_ffi_slice_6(ref data, callback);
        data.Dispose();
    }

    // [Fact]
    // public void pattern_ffi_slice7()
    // {
    //     var data = new CharArray { str = "test", str_2 = "test2" };
    //     var slice = new SliceMut<CharArray>([data]);
    //     Interop.pattern_ffi_slice_8(ref slice, (ca) => {
    //         Assert.Equal("test", ca.str);
    //         Assert.Equal("test2", ca.str_2);
    //     });
    // }

    [Fact]
    public void pattern_ffi_slice_delegate_huge()
    {
        var result = Interop.pattern_ffi_slice_delegate_huge(x => x[0]);
        Assert.Equal(0, result.x);
    }

    [Fact]
    public void pattern_ffi_slice_9()
    {
        using var use_string = new UseString
        {
            s1 = "hello".Utf8(),
            s2 = "world".Utf8()
        };

        using var slice = new[]
        {
            use_string,
            use_string,
            use_string
        }.Slice();

        var rval = Interop.pattern_ffi_slice_9(slice).IntoString();

        Assert.Equal("hello", rval);
    }

    [Fact]
    public void pattern_ffi_slice_1b()
    {
        using var data = new uint[500].SliceMut();
        var result = Interop.pattern_ffi_slice_1b(data);
        Assert.Equal(500u, result);
    }

    [Fact]
    public void pattern_ffi_slice_4()
    {
        using var slice = new byte[] { 1, 2, 3 }.Slice();
        using var sliceMut = new byte[] { 4, 5, 6 }.SliceMut();
        Interop.pattern_ffi_slice_4(slice, sliceMut);
    }
}