interoptopus_backend_csharp 0.14.25

Generates C# bindings.
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

using System;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using My.Company;
using My.Company.Common;
using Xunit;
using Array = My.Company.Array;

namespace interop_test
{
    public class GeneralTests
    {

        [Fact]
        public void array_1()
        {
            var array = new Array {data0 = 5};
            Assert.Equal(5, Interop.array_1(array));
        }

        [Fact]
        public void pattern_ffi_slice_delegate()
        {
            Interop.pattern_ffi_slice_delegate(delegate (Sliceu8 x0)
            {
                Assert.Equal(x0.Count, 10);
                Assert.Equal(x0[0], 0);
                Assert.Equal(x0[5], 5);

                // Test IEnumerable using LINQ
                var arr = x0.ToArray();
                Assert.Equal(arr.Length, 10);
                Assert.Equal(arr[0], 0);
                Assert.Equal(arr[5], 5);

                return x0[0];
            });
        }

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

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

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


        [Fact]
        public void boolean_alignment()
        {
            const ulong BIT_PATTERN = 0x5555555555555555;

            for (var i = 0; i < 16; i++)
            {
                var x = new BooleanAlignment { is_valid = true, id = BIT_PATTERN, datum = BIT_PATTERN };

                x = Interop.boolean_alignment(x);
                Assert.Equal(x.is_valid, false);
                Assert.Equal(x.id, BIT_PATTERN);
                Assert.Equal(x.datum, BIT_PATTERN);

                x = Interop.boolean_alignment(x);
                Assert.Equal(x.is_valid, true);
                Assert.Equal(x.id, BIT_PATTERN);
                Assert.Equal(x.datum, BIT_PATTERN);

                x = Interop.boolean_alignment2(true);
                Assert.Equal(x.is_valid, true);

                x = Interop.boolean_alignment2(false);
                Assert.Equal(x.is_valid, false);
            }
        }



        [Fact]
        public void pattern_ffi_option_nullable()
        {
            var t = new Inner();
            OptionInner someOpt = OptionInner.FromNullable(t);
            Inner? nullableOpt = someOpt.ToNullable();
            Assert.True(nullableOpt.HasValue);

            OptionInner someOpt2 = OptionInner.FromNullable(null);
            Inner? nullableOpt2 = someOpt2.ToNullable();
            Assert.False(nullableOpt2.HasValue);
        }

        [Fact]
        public void pattern_service_generated()
        {
            var simpleService = SimpleService.NewWith(123);
            var b = new byte[] { 1, 2, 3 } ;

            simpleService.MethodMutSelfFfiError(b);
            var s1 = simpleService.ReturnString();
            var s2 = simpleService.ReturnString();

            var sliceMut = simpleService.ReturnSliceMut();
            sliceMut[0] = 44;

            var slice = simpleService.ReturnSlice();
            Assert.Equal(slice.Count, 123);
            Assert.Equal((int) slice[0], 44);
            Assert.Equal((int) slice[1], 123);

            uint value = 123;
            var lt = SimpleServiceLifetime.NewWith(ref value);
            var s3 = lt.ReturnStringAcceptSlice(System.Array.Empty<byte>());
            var s4 = lt.ReturnStringAcceptSlice(System.Array.Empty<byte>());
        }

    }
}