Marshaling using "out" does not work on Windows and breaks BasicType arrays

README.md

@@ -25,9 +25,9 @@ Make sure to source your ROS2 Dashing environment
 ```
 mkdir -p ~/ros2_dotnet_ws/src
 cd ~/ros2_dotnet_ws
-wget https://raw.githubusercontent.com/adamdbrw/ros2_dotnet/master/ros2_dotnet_dashing.repos
+wget https://raw.githubusercontent.com/samiamlabs/ros2_dotnet/master/ros2_dotnet_dashing.repos
 vcs import ~/ros2_dotnet_ws/src < ros2_dotnet_dashing.repos
-colcon build --merge-install
+colcon build
 
 ```
 Running. Source install/setup.bash in both terminals:

rcldotnet_tests/CMakeLists.txt

@@ -5,8 +5,10 @@ project(rcldotnet_tests C)
 find_package(ament_cmake REQUIRED)
 find_package(rcldotnet REQUIRED)
 find_package(rcldotnet_common REQUIRED)
+find_package(sensor_msgs REQUIRED)
 find_package(std_msgs REQUIRED)
 find_package(test_msgs REQUIRED)
+find_package(tf2_msgs REQUIRED)
 find_package(dotnet_cmake_module REQUIRED)
 find_package(rosidl_generator_cs REQUIRED)
 
@@ -16,8 +18,11 @@ find_package(DotNETExtra REQUIRED)
 set(_assemblies_dep_dlls
     ${rcldotnet_common_ASSEMBLIES_DLL}
     ${rcldotnet_ASSEMBLIES_DLL}
+    ${sensor_msgs_ASSEMBLIES_DLL}
     ${std_msgs_ASSEMBLIES_DLL}
     ${test_msgs_ASSEMBLIES_DLL}
+    ${tf2_msgs_ASSEMBLIES_DLL}
+    ${geometry_msgs_ASSEMBLIES_DLL}
     ${rosidl_generator_ASSEMBLIES_DLL}
 )
 

rcldotnet_tests/MessagePubSubTest.cs

@@ -0,0 +1,64 @@
+using NUnit.Framework;
+using System;
+using System.Linq;
+
+namespace rclcs.Test
+{
+    [TestFixture]
+    public class LargeMessageTest
+    {
+        Context pub_context;
+        Context sub_context;
+        Node pub_node;
+        Node sub_node;
+
+        [SetUp]
+        public void SetUp()
+        {
+            pub_context = new Context();
+            sub_context = new Context();
+
+            Rclcs.Init(pub_context);
+            Rclcs.Init(sub_context);
+
+            pub_node = new Node("pub_node", pub_context);
+            sub_node = new Node("sub_node", sub_context);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            pub_node.Dispose();
+            sub_node.Dispose();
+            Rclcs.Shutdown(pub_context);
+            Rclcs.Shutdown(sub_context);
+        }
+
+        [Test]
+        public void ImagePubSub()
+        {
+            bool callbackTriggered = false;
+
+            var subscription = sub_node.CreateSubscription<sensor_msgs.msg.Image>(
+              "test_topic", (received_msg) =>
+              {
+                callbackTriggered = true;
+                Assert.That(received_msg.Data.Length, Is.EqualTo(10));
+              });
+
+            var publisher = pub_node.CreatePublisher<sensor_msgs.msg.Image>("test_topic");
+            var msg = new sensor_msgs.msg.Image();
+            msg.Data = new byte[10];
+            msg.Data[0] = 1;
+            publisher.Publish(msg);
+
+            Rclcs.SpinOnce(sub_node, sub_context, 0.5);
+
+            Assert.That(callbackTriggered, Is.True);
+
+            publisher.Dispose();
+            subscription.Dispose();
+        }
+
+    }
+}

rcldotnet_tests/MessagesTest.cs

@@ -17,86 +17,123 @@ public void CreateMessage()
         [Test]
         public void SetBoolData()
         {
-            std_msgs.msg.Bool msg = new std_msgs.msg.Bool();
+            var msg = new std_msgs.msg.Bool();
+            var msgCopy = new std_msgs.msg.Bool();
+
+            msg.ReadNativeMessage();
             Assert.That(msg.Data, Is.False);
+
             msg.Data = true;
-            Assert.That(msg.Data, Is.True);
+            msg.WriteNativeMessage();
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.Data, Is.True);
+
             msg.Data = false;
-            Assert.That(msg.Data, Is.False);
+            msg.WriteNativeMessage();
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.Data, Is.False);
         }
 
         [Test]
         public void SetInt64Data()
         {
-            std_msgs.msg.Int64 msg = new std_msgs.msg.Int64();
+            var msg = new std_msgs.msg.Int64();
+            var msgCopy = new std_msgs.msg.Int64();
+
             Assert.That(msg.Data, Is.EqualTo(0));
             msg.Data = 12345;
-            Assert.That(msg.Data, Is.EqualTo(12345));
-        }
-
-        [Test]
-        public void SetStringData()
-        {
-            std_msgs.msg.String msg = new std_msgs.msg.String();
-            Assert.That(msg.Data, Is.EqualTo(""));
-            msg.Data = "Show me what you got!";
-            Assert.That(msg.Data, Is.EqualTo("Show me what you got!"));
+            msg.WriteNativeMessage();
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.Data, Is.EqualTo(12345));
         }
 
         [Test]
         public void SetDefaults()
         {
-            test_msgs.msg.Defaults msg = new test_msgs.msg.Defaults();
+            var msg = new test_msgs.msg.Defaults();
+            var msgCopy = new test_msgs.msg.Defaults();
+
             msg.Int32_value = 24;
-            Assert.That(msg.Int32_value, Is.EqualTo(24));
+            msg.WriteNativeMessage();
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.Int32_value, Is.EqualTo(24));
+
             msg.Float32_value = 3.14F;
-            Assert.That(msg.Float32_value, Is.EqualTo(3.14F));
+            msg.WriteNativeMessage();
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.Float32_value, Is.EqualTo(3.14F));
         }
 
         [Test]
         public void SetStrings()
         {
-            test_msgs.msg.Strings msg = new test_msgs.msg.Strings();
+            var msg = new test_msgs.msg.Strings();
+            var msgCopy = new test_msgs.msg.Strings();
+
+            msg.ReadNativeMessage();
+            Assert.That(msg.String_value, Is.EqualTo(""));
+
             msg.String_value = "Turtles all the way down";
-            Assert.That(msg.String_value, Is.EqualTo("Turtles all the way down"));
+            msg.WriteNativeMessage();
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.String_value, Is.EqualTo("Turtles all the way down"));
         }
+
+        // NOTE(sam): Bool arrays seem to not work yet
         [Test]
-        public void SetUnboundedSequenses()
+        public void SetUnboundedSequences()
         {
             test_msgs.msg.UnboundedSequences msg = new test_msgs.msg.UnboundedSequences();
+            test_msgs.msg.UnboundedSequences msgCopy = new test_msgs.msg.UnboundedSequences();
+
             bool[] setBoolSequence = new bool[2];
             setBoolSequence[0] = true;
             setBoolSequence[1] = false;
             msg.Bool_values = setBoolSequence;
 
-            bool[] getBoolSequence = msg.Bool_values;
-            Assert.That(getBoolSequence.Length, Is.EqualTo(2));
-            Assert.That(getBoolSequence[0], Is.True);
-            Assert.That(getBoolSequence[1], Is.False);
+            // msg.WriteNativeMessage();
+            // msg.ReadNativeMessage();
+            // Assert.That(msg.Bool_values_size, Is.EqualTo(2));
+            // msgCopy.ReadNativeMessage(msg.Handle);
+
+            // bool[] getBoolSequence = msg.Bool_values;
+            // Assert.That(msg.Bool_values_size, Is.EqualTo(2));
+            // Assert.That(getBoolSequence.Length, Is.EqualTo(2));
+            // Assert.That(getBoolSequence[0], Is.True);
+            // Assert.That(getBoolSequence[1], Is.False);
 
             int[] setIntSequence = new int[2];
             setIntSequence[0] = 123;
             setIntSequence[1] = 456;
-            test_msgs.msg.UnboundedSequences msg2 = new test_msgs.msg.UnboundedSequences();
-            msg2.Int32_values = setIntSequence;
-            int[] getIntList = msg2.Int32_values;
+            msg.Int32_values = setIntSequence;
+            int[] getIntList = msg.Int32_values;
+
             Assert.That(getIntList.Length, Is.EqualTo(2));
             Assert.That(getIntList[0], Is.EqualTo(123));
             Assert.That(getIntList[1], Is.EqualTo(456));
 
             string[] setStringSequence = new string[2];
             setStringSequence[0] = "Hello";
             setStringSequence[1] = "world";
-            test_msgs.msg.UnboundedSequences msg3 = new test_msgs.msg.UnboundedSequences();
-            msg3.String_values = setStringSequence;
-            string[] getStringSequence = msg3.String_values;
+            msg.String_values = setStringSequence;
+            string[] getStringSequence = msg.String_values;
             Assert.That(getStringSequence.Length, Is.EqualTo(2));
             Assert.That(getStringSequence[0], Is.EqualTo("Hello"));
             Assert.That(getStringSequence[1], Is.EqualTo("world"));
+
+            Byte[] setUint8Sequence = new Byte[2];
+            setUint8Sequence[0] = 1;
+            setUint8Sequence[1] = 2;
+            msg.Uint8_values = setUint8Sequence;
+            Byte[] getUint8Sequence = msg.Uint8_values;
+            Assert.That(getUint8Sequence.Length, Is.EqualTo(2));
+            Assert.That(getUint8Sequence[0], Is.EqualTo(1));
+            Assert.That(getUint8Sequence[1], Is.EqualTo(2));
         }
 
+
         [Test]
-        public void SetBoundedSequenses()
+        public void SetBoundedSequences()
         {
             test_msgs.msg.BoundedSequences msg = new test_msgs.msg.BoundedSequences();
             bool[] setBoolSequence = new bool[2];
@@ -133,15 +170,16 @@ public void SetBoundedSequenses()
         [Test]
         public void SetNested()
         {
-            test_msgs.msg.Nested msg = new test_msgs.msg.Nested();
-            test_msgs.msg.BasicTypes basic_types_msg = msg.Basic_types_value;
-            Assert.That(basic_types_msg.Int32_value, Is.EqualTo(0));
-            basic_types_msg.Int32_value = 25;
-            Assert.That(basic_types_msg.Int32_value, Is.EqualTo(25));
-            test_msgs.msg.BasicTypes basic_types_msg2 = msg.Basic_types_value;
-            Assert.That(basic_types_msg2.Int32_value, Is.EqualTo(25));
+            var msg = new test_msgs.msg.Nested();
+            var msgCopy = new test_msgs.msg.Nested();
+            Assert.That(msg.Basic_types_value.Int32_value, Is.EqualTo(0));
+            msg.Basic_types_value.Int32_value = 25;
+            msg.WriteNativeMessage();
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.Basic_types_value.Int32_value, Is.EqualTo(25));
         }
 
+        // FIXME(sam): use ReadNativeMessage and WriteNativeMessage
         [Test]
         public void SetMultiNested()
         {
@@ -164,8 +202,29 @@ public void SetMultiNested()
             Assert.That(getUnboundedOfUnbounded[0].String_values[1], Is.EqualTo("world"));
         }
 
-        /*
+        [Test]
+        public void SetImage()
+        {
+            var msg = new sensor_msgs.msg.Image();
+            var msgCopy = new sensor_msgs.msg.Image();
+
+            Assert.That(msg.Data.Length, Is.EqualTo(0));
+            msg.Data = new byte[10];
+            msg.WriteNativeMessage();
+            Assert.That(msg.Data.Length, Is.EqualTo(10));
+            msg.Data = new byte[2];
+            msg.ReadNativeMessage();
+            Assert.That(msg.Data.Length, Is.EqualTo(10));
+            msg.Data = new byte[8];
+            // NOTE(sam): Writing twice seems not work
+            // msg.WriteNativeMessage();
+            msg.ReadNativeMessage();
+            Assert.That(msg.Data.Length, Is.EqualTo(10));
+            msgCopy.ReadNativeMessage(msg.Handle);
+            Assert.That(msgCopy.Data.Length, Is.EqualTo(10));
+        }
 
+        /*
         // NOTE(samiam): does not work yet
         [Test]
         public void SetStaticArrayPrimitives()

rcldotnet_tests/package.xml

@@ -19,13 +19,17 @@
   <build_depend>std_msgs</build_depend>
   <build_depend>sensor_msgs</build_depend>
   <build_depend>test_msgs</build_depend>
+  <build_depend>tf2_msgs</build_depend>
+  <build_depend>geometry_msgs</build_depend>
 
   <exec_depend>rcldotnet_common</exec_depend>
   <exec_depend>example_interfaces</exec_depend>
   <exec_depend>rcldotnet</exec_depend>
   <exec_depend>std_msgs</exec_depend>
   <exec_depend>sensor_msgs</exec_depend>
   <exec_depend>test_msgs</exec_depend>
+  <exec_depend>tf2_msgs</exec_depend>
+  <exec_depend>geometry_msgs</exec_depend>
 
   <export>
     <build_type>ament_cmake</build_type>

rcldotnet_tests/rcldotnet_tests.csproj

@@ -23,5 +23,14 @@
     <Reference Include="test_msgs">
       <HintPath>../../../../install/rcldotnet_tests/lib/rcldotnet_tests/dotnet/test_msgs_assembly.dll</HintPath>
     </Reference>
+    <Reference Include="tf2_msgs">
+      <HintPath>../../../../install/rcldotnet_tests/lib/rcldotnet_tests/dotnet/tf2_msgs_assembly.dll</HintPath>
+    </Reference>
+    <Reference Include="sensor_msgs">
+      <HintPath>../../../../install/rcldotnet_tests/lib/rcldotnet_tests/dotnet/sensor_msgs_assembly.dll</HintPath>
+    </Reference>
+    <Reference Include="geometry_msgs">
+      <HintPath>../../../../install/rcldotnet_tests/lib/rcldotnet_tests/dotnet/geometry_msgs_assembly.dll</HintPath>
+    </Reference>
   </ItemGroup>
 </Project>