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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

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

public class TestPatternVec
{
    [Fact]
    public void pattern_ffi_vec_1()
    {
        using var vec = Interop.pattern_vec_1();

        Assert.Equal(3, vec.Count);
        Assert.Equal(1, vec[0]);
        Assert.Equal(2, vec[1]);
        Assert.Equal(3, vec[2]);
    }

    [Fact]
    public void pattern_ffi_vec_2()
    {
        using var vec = Interop.pattern_vec_1();
        Interop.pattern_vec_2(vec);
    }

    [Fact]
    public void pattern_ffi_vec_2_no_reuse_after_move()
    {
        var vec = Interop.pattern_vec_1();
        Interop.pattern_vec_2(vec);

        // We must not be able to re-use the given vec
        Assert.Throws<NullReferenceException>(() => Interop.pattern_vec_2(vec));
    }

    [Fact]
    public void pattern_ffi_vec_2_no_reuse_after_dispose()
    {
        var vec = Interop.pattern_vec_1();
        vec.Dispose();
        Assert.Throws<NullReferenceException>(() => Interop.pattern_vec_2(vec));
    }

    [Fact]
    public void pattern_ffi_vec_2_dispose_dispose()
    {
        var vec = Interop.pattern_vec_1();
        vec.Dispose();
        vec.Dispose();
        vec.Dispose();
    }

    [Fact]
    public void pattern_ffi_vec_3()
    {
        var vec1 = Interop.pattern_vec_1();
        var vec2 = Interop.pattern_vec_3(vec1);

        Assert.Throws<NullReferenceException>(() => vec1[0]);

        Assert.Equal(3, vec2.Count);
        Assert.Equal(1, vec2[0]);
        Assert.Equal(2, vec2[1]);
        Assert.Equal(3, vec2[2]);

        vec2.Dispose();

        Assert.Throws<NullReferenceException>(() => vec2[0]);
    }

    [Fact]
    public void pattern_ffi_vec_4()
    {
        var vec1 = Interop.pattern_vec_1();
        using var vec2 = Interop.pattern_vec_4(ref vec1);

        Assert.Equal(3, vec1.Count);
        Assert.Equal(3, vec2.Count);
        Assert.Equal(vec1[0], vec2[0]);
        Assert.Equal(vec1[1], vec2[1]);
        Assert.Equal(vec1[2], vec2[2]);
        vec1.Dispose();
    }

    [Fact]
    public void pattern_ffi_vec_5()
    {
        var r = new[] { "1".Utf8(), "2".Utf8(), "3".Utf8() };
        var v = new[] { "1".Utf8(), "2".Utf8(), "3".Utf8() };
        var v1 = VecUtf8String.From(v);
        var v2 = Interop.pattern_vec_5(v1);

        Assert.Equal(r[0].String, v2[0].String);
        Assert.Equal(r[1].String, v2[1].String);
        Assert.Equal(r[2].String, v2[2].String);
    }


    [Fact]
    public void pattern_ffi_vec_6()
    {
        var v = new Vec3f32[]
        {
            new() { x = 1, y = 1, z = 1 },
            new() { x = 2, y = 2, z = 2 },
            new() { x = 3, y = 3, z = 3 }
        };

        var v1 = VecVec3f32.From(v);
        var v2 = Interop.pattern_vec_6(v1);

        Assert.Equal(v[0], v2[0]);
        Assert.Equal(v[1], v2[1]);
        Assert.Equal(v[2], v2[2]);
    }

    [Fact]
    public void pattern_ffi_vec_7()
    {
        var v = new[] { "1".Utf8(), "2".Utf8(), "3".Utf8() };
        var v1 = new UseSliceAndVec { s1 = SliceUtf8String.From(v), s2 = VecUtf8String.From(v) };
        Interop.pattern_vec_7(v1);

        // Assert.Equal(v[0], v2.s1[0]);
        // Assert.Equal(v[1], v2.s1[1]);
        // Assert.Equal(v[2], v2.s1[2]);
    }

    [Fact]
    public void pattern_ffi_vec_8()
    {
        var v = new[] { "1".Utf8(), "2".Utf8(), "3".Utf8() };
        var v1 = new UseSliceAndVec { s1 = SliceUtf8String.From(v), s2 = VecUtf8String.From(v) };

        // TODO: This rval deserialziation of slice inside composite has some issues
        var v2 = Interop.pattern_vec_8(v1);

         //Assert.Equal(v[0], v2.s1[0]);
         //Assert.Equal(v[1], v2.s1[1]);
         //Assert.Equal(v[2], v2.s1[2]);
    }

    [Fact]
    public void vec_empty()
    {
        using var empty = VecUtf8String.Empty();
        Assert.Equal(0, empty.Count);
    }
}