interoptopus_csharp 0.16.0-alpha.8

The C# backend for Interoptopus.
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
131
132
133
134
135
136
137
138
139
140
141

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

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


    [Fact]
    public void pattern_ffi_slice_2()
    {
        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);

        data.Dispose();

        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()
    {
        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);
        data.Dispose();
    }

    [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();

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

        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()
    {

        var use_string = new UseString()
        {
            s1 = "hello".Utf8(),
            s2 = "world".Utf8()
        };

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

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

        Assert.Equal("hello", rval);

        slice.Dispose();
        use_string.Dispose();
    }

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

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