diff --git a/message_generation/build.gradle b/message_generation/build.gradle
index 1de91f4f26dcf945a83a1a386f036fbf312475bf..9958016b58d58a1581dccfa22720d309e024f048 100644
--- a/message_generation/build.gradle
+++ b/message_generation/build.gradle
@@ -15,13 +15,14 @@
*/
dependencies {
- compile "com.google.guava:guava:12.0"
- compile "commons-pool:commons-pool:1.6"
- compile "io.netty:netty:3.5.2.Final"
- compile "org.apache.commons:com.springsource.org.apache.commons.codec:1.3.0"
- compile "org.apache.commons:com.springsource.org.apache.commons.io:1.4.0"
- compile "org.apache.commons:com.springsource.org.apache.commons.lang:2.4.0"
- testCompile "junit:junit:4.8.2"
+ compile 'io.netty:netty:3.5.2.Final'
+ compile 'com.google.guava:guava:12.0'
+ compile 'org.apache.commons:com.springsource.org.apache.commons.codec:1.3.0'
+ compile 'org.apache.commons:com.springsource.org.apache.commons.io:1.4.0'
+ compile 'commons-pool:commons-pool:1.6'
+ compile 'org.apache.commons:com.springsource.org.apache.commons.lang:2.4.0'
+ compile project(':gradle_plugins')
+ testCompile 'junit:junit:4.8.2'
}
apply plugin: "application"
diff --git a/message_generation/src/test/java/org/ros/internal/message/Md5GeneratorTest.java b/message_generation/src/test/java/org/ros/internal/message/Md5GeneratorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ff244a66ee97b7cd953490494cbf5bf6cd7474d
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/internal/message/Md5GeneratorTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.internal.message;
+
+import static org.junit.Assert.assertEquals;
+
+import org.ros.internal.message.definition.MessageDefinitionProviderChain;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.ros.internal.message.service.ServiceDefinitionResourceProvider;
+import org.ros.internal.message.service.ServiceDescription;
+import org.ros.internal.message.service.ServiceDescriptionFactory;
+import org.ros.internal.message.topic.TopicDefinitionResourceProvider;
+import org.ros.internal.message.topic.TopicDescription;
+import org.ros.internal.message.topic.TopicDescriptionFactory;
+
+/**
+ * @author damonkohler@google.com (Damon Kohler)
+ */
+public class Md5GeneratorTest {
+
+ private TopicDescriptionFactory topicDescriptionFactory;
+ private ServiceDescriptionFactory serviceDescriptionFactory;
+
+ @Before
+ public void setUp() {
+ MessageDefinitionProviderChain messageDefinitionProviderChain =
+ new MessageDefinitionProviderChain();
+ messageDefinitionProviderChain
+ .addMessageDefinitionProvider(new TopicDefinitionResourceProvider());
+ messageDefinitionProviderChain
+ .addMessageDefinitionProvider(new ServiceDefinitionResourceProvider());
+ topicDescriptionFactory = new TopicDescriptionFactory(messageDefinitionProviderChain);
+ serviceDescriptionFactory = new ServiceDescriptionFactory(messageDefinitionProviderChain);
+ }
+
+ @Test
+ public void testPrimitives() {
+ TopicDescription topicDescription =
+ topicDescriptionFactory.newFromType("test_msgs/TestPrimitives");
+ assertEquals("3e70f428a22c0d26ca67f87802c8e00f", topicDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testString() {
+ TopicDescription topicDescription = topicDescriptionFactory.newFromType("test_msgs/TestString");
+ assertEquals("334ff4377be93faa44ebc66d23d40fd3", topicDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testHeader() {
+ TopicDescription topicDescription = topicDescriptionFactory.newFromType("test_msgs/TestHeader");
+ assertEquals("4b5a00f536da2f756ba6aebcf795a967", topicDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testArrays() {
+ TopicDescription topicDescription = topicDescriptionFactory.newFromType("test_msgs/TestArrays");
+ assertEquals("4cc9b5e2cebe791aa3e994f5bc159eb6", topicDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testComposite() {
+ TopicDescription topicDescription = topicDescriptionFactory.newFromType("test_msgs/Composite");
+ assertEquals("d8fb6eb869ad3956b50e8737d96dc9fa", topicDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testOdometry() {
+ TopicDescription topicDescription = topicDescriptionFactory.newFromType("nav_msgs/Odometry");
+ assertEquals("cd5e73d190d741a2f92e81eda573aca7", topicDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testEmpty() {
+ ServiceDescription serviceDescription = serviceDescriptionFactory.newFromType("std_srvs/Empty");
+ assertEquals("d41d8cd98f00b204e9800998ecf8427e", serviceDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testAddTwoInts() {
+ ServiceDescription serviceDescription =
+ serviceDescriptionFactory.newFromType("test_msgs/AddTwoInts");
+ assertEquals("6a2e34150c00229791cc89ff309fff21", serviceDescription.getMd5Checksum());
+ }
+
+ @Test
+ public void testTransitiveSrv() {
+ ServiceDescription serviceDescription =
+ serviceDescriptionFactory.newFromType("test_msgs/TransitiveSrv");
+ assertEquals("8b7918ee2b81eaf825f4c70de011f6fa", serviceDescription.getMd5Checksum());
+ }
+}
diff --git a/message_generation/src/test/java/org/ros/internal/message/MessageInterfaceBuilderTest.java b/message_generation/src/test/java/org/ros/internal/message/MessageInterfaceBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..38e5316113765c178b347e9eaf82872e4e7a489b
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/internal/message/MessageInterfaceBuilderTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.internal.message;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.ros.internal.message.topic.TopicDefinitionResourceProvider;
+import org.ros.message.MessageDeclaration;
+import org.ros.message.MessageFactory;
+
+/**
+ * @author damonkohler@google.com (Damon Kohler)
+ */
+public class MessageInterfaceBuilderTest {
+
+ private TopicDefinitionResourceProvider topicDefinitionResourceProvider;
+ private MessageFactory messageFactory;
+
+ @Before
+ public void before() {
+ topicDefinitionResourceProvider = new TopicDefinitionResourceProvider();
+ messageFactory = new DefaultMessageFactory(topicDefinitionResourceProvider);
+ }
+
+ @Test
+ public void testDuplicateFieldNames() {
+ MessageInterfaceBuilder builder = new MessageInterfaceBuilder();
+ builder.setPackageName("foo");
+ builder.setInterfaceName("bar");
+ builder.setMessageDeclaration(MessageDeclaration.of("foo/bar", "int32 foo\nint32 Foo"));
+ builder.setAddConstantsAndMethods(true);
+ String result = builder.build(messageFactory);
+ assertEquals("package foo;\n\n"
+ + "public interface bar extends org.ros.internal.message.Message {\n"
+ + " static final java.lang.String _TYPE = \"foo/bar\";\n"
+ + " static final java.lang.String _DEFINITION = \"int32 foo\\nint32 Foo\";\n"
+ + " int getFoo();\n" + " void setFoo(int value);\n" + "}\n", result);
+ }
+}
diff --git a/message_generation/src/test/java/org/ros/internal/message/MessageTest.java b/message_generation/src/test/java/org/ros/internal/message/MessageTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe80bb483e139b811229ddf2453e02abcc866e22
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/internal/message/MessageTest.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.internal.message;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.collect.Lists;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.ros.internal.message.topic.TopicDefinitionResourceProvider;
+import org.ros.message.MessageFactory;
+
+/**
+ * @author damonkohler@google.com (Damon Kohler)
+ */
+public class MessageTest {
+
+ private TopicDefinitionResourceProvider topicDefinitionResourceProvider;
+ private MessageFactory messageFactory;
+
+ @Before
+ public void before() {
+ topicDefinitionResourceProvider = new TopicDefinitionResourceProvider();
+ messageFactory = new DefaultMessageFactory(topicDefinitionResourceProvider);
+ }
+
+ @Test
+ public void testCreateEmptyMessage() {
+ topicDefinitionResourceProvider.add("foo/foo", "");
+ messageFactory.newFromType("foo/foo");
+ }
+
+ @Test
+ public void testCreateEmptyMessageWithBlankLines() {
+ topicDefinitionResourceProvider.add("foo/foo", "\n\n\n\n\n");
+ messageFactory.newFromType("foo/foo");
+ }
+
+ @Test
+ public void testString() {
+ String data = "Hello, ROS!";
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/String");
+ rawMessage.setString("data", data);
+ assertEquals(data, rawMessage.getString("data"));
+ }
+
+ @Test
+ public void testStringWithComments() {
+ topicDefinitionResourceProvider.add("foo/foo", "# foo\nstring data\n # string other data");
+ String data = "Hello, ROS!";
+ RawMessage rawMessage = messageFactory.newFromType("foo/foo");
+ rawMessage.setString("data", data);
+ assertEquals(data, rawMessage.getString("data"));
+ }
+
+ @Test
+ public void testInt8() {
+ byte data = 42;
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Int8");
+ rawMessage.setInt8("data", data);
+ assertEquals(data, rawMessage.getInt8("data"));
+ }
+
+ @Test
+ public void testNestedMessage() {
+ topicDefinitionResourceProvider.add("foo/foo", "bar data");
+ topicDefinitionResourceProvider.add("foo/bar", "int8 data");
+ RawMessage fooMessage = messageFactory.newFromType("foo/foo");
+ RawMessage barMessage = messageFactory.newFromType("foo/bar");
+ fooMessage.setMessage("data", barMessage);
+ byte data = 42;
+ barMessage.setInt8("data", data);
+ assertEquals(data, fooMessage.getMessage("data").toRawMessage().getInt8("data"));
+ }
+
+ @Test
+ public void testNestedMessageList() {
+ topicDefinitionResourceProvider.add("foo/foo", "bar[] data");
+ topicDefinitionResourceProvider.add("foo/bar", "int8 data");
+ RawMessage fooMessage = messageFactory.newFromType("foo/foo");
+ RawMessage barMessage = messageFactory.newFromType("foo/bar");
+ fooMessage.setMessageList("data", Lists.<Message>newArrayList(barMessage));
+ byte data = 42;
+ barMessage.toRawMessage().setInt8("data", data);
+ assertEquals(data, fooMessage.getMessageList("data").get(0).toRawMessage().getInt8("data"));
+ }
+
+ @Test
+ public void testConstantInt8() {
+ topicDefinitionResourceProvider.add("foo/foo", "int8 data=42");
+ RawMessage rawMessage = messageFactory.newFromType("foo/foo");
+ assertEquals(42, rawMessage.getInt8("data"));
+ }
+
+ @Test
+ public void testConstantString() {
+ topicDefinitionResourceProvider.add("foo/foo", "string data=Hello, ROS! # comment ");
+ RawMessage rawMessage = messageFactory.newFromType("foo/foo");
+ assertEquals("Hello, ROS! # comment", rawMessage.getString("data"));
+ }
+
+ public void testInt8List() {
+ topicDefinitionResourceProvider.add("foo/foo", "int8[] data");
+ RawMessage rawMessage = messageFactory.newFromType("foo/foo");
+ byte[] data = new byte[] { (byte) 1, (byte) 2, (byte) 3 };
+ rawMessage.setInt8Array("data", data);
+ assertEquals(data, rawMessage.getInt8Array("data"));
+ }
+}
\ No newline at end of file
diff --git a/message_generation/src/test/java/org/ros/internal/message/RawMessageSerializationTest.java b/message_generation/src/test/java/org/ros/internal/message/RawMessageSerializationTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5bf1bbce7e81cec0c1aca33b8bab7331d3eee6b
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/internal/message/RawMessageSerializationTest.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.internal.message;
+
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.Lists;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.junit.Before;
+import org.junit.Test;
+import org.ros.internal.message.topic.TopicDefinitionResourceProvider;
+import org.ros.message.Duration;
+import org.ros.message.MessageFactory;
+import org.ros.message.Time;
+
+/**
+ * @author damonkohler@google.com (Damon Kohler)
+ */
+public class RawMessageSerializationTest {
+
+ private TopicDefinitionResourceProvider topicDefinitionResourceProvider;
+ private MessageFactory messageFactory;
+
+ @Before
+ public void before() {
+ topicDefinitionResourceProvider = new TopicDefinitionResourceProvider();
+ messageFactory = new DefaultMessageFactory(topicDefinitionResourceProvider);
+ }
+
+ private void checkSerializeAndDeserialize(Message message) {
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ DefaultMessageSerializer serializer = new DefaultMessageSerializer();
+ serializer.serialize(message, buffer);
+ DefaultMessageDeserializer<RawMessage> deserializer =
+ new DefaultMessageDeserializer<RawMessage>(message.toRawMessage().getIdentifier(),
+ messageFactory);
+ RawMessage deserializedMessage = deserializer.deserialize(buffer);
+ assertTrue(message.equals(deserializedMessage));
+ }
+
+ @Test
+ public void testBool() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Bool");
+ rawMessage.setBool("data", true);
+ checkSerializeAndDeserialize(rawMessage);
+ rawMessage.setBool("data", false);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testInt8() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Int8");
+ rawMessage.setInt8("data", (byte) 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testUint8() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/UInt8");
+ rawMessage.setUInt8("data", (byte) 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testInt16() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Int16");
+ rawMessage.setInt16("data", (short) 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testUInt16() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/UInt16");
+ rawMessage.setUInt16("data", (short) 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testInt32() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Int32");
+ rawMessage.setInt32("data", 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testUInt32() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/UInt32");
+ rawMessage.setUInt32("data", 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testInt64() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Int64");
+ rawMessage.setInt64("data", 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testUInt64() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/UInt64");
+ rawMessage.setUInt64("data", 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testFloat32() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Float32");
+ rawMessage.setFloat32("data", 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testFloat64() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Float64");
+ rawMessage.setFloat64("data", 42);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testString() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/String");
+ rawMessage.setString("data", "Hello, ROS!");
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testTime() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Time");
+ rawMessage.setTime("data", new Time());
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testDuration() {
+ RawMessage rawMessage = messageFactory.newFromType("std_msgs/Duration");
+ rawMessage.setDuration("data", new Duration());
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testNestedMessage() {
+ topicDefinitionResourceProvider.add("foo/foo", "std_msgs/String data");
+ RawMessage fooMessage = messageFactory.newFromType("foo/foo");
+ RawMessage stringMessage = messageFactory.newFromType("std_msgs/String");
+ stringMessage.setString("data", "Hello, ROS!");
+ fooMessage.setMessage("data", stringMessage);
+ checkSerializeAndDeserialize(fooMessage);
+ }
+
+ @Test
+ public void testNestedMessageArray() {
+ topicDefinitionResourceProvider.add("foo/foo", "std_msgs/String[] data");
+ RawMessage fooMessage = messageFactory.newFromType("foo/foo");
+ RawMessage stringMessageA = messageFactory.newFromType("std_msgs/String");
+ stringMessageA.setString("data", "Hello, ROS!");
+ RawMessage stringMessageB = messageFactory.newFromType("std_msgs/String");
+ stringMessageB.setString("data", "Goodbye, ROS!");
+ fooMessage.setMessageList("data", Lists.<Message>newArrayList(stringMessageA, stringMessageB));
+ checkSerializeAndDeserialize(fooMessage);
+ }
+
+ @Test
+ public void testChannelBuffer() {
+ topicDefinitionResourceProvider.add("foo/foo", "uint8[] data");
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ buffer.writeBytes(new byte[] { 1, 2, 3, 4, 5 });
+ RawMessage rawMessage = messageFactory.newFromType("foo/foo");
+ rawMessage.setChannelBuffer("data", buffer);
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testInt32Array() {
+ topicDefinitionResourceProvider.add("foo/foo", "int32[] data");
+ RawMessage rawMessage = messageFactory.newFromType("foo/foo");
+ rawMessage.setInt32Array("data", new int[] { 1, 2, 3, 4, 5 });
+ checkSerializeAndDeserialize(rawMessage);
+ }
+
+ @Test
+ public void testFloat64Array() {
+ topicDefinitionResourceProvider.add("foo/foo", "float64[] data");
+ RawMessage rawMessage = messageFactory.newFromType("foo/foo");
+ rawMessage.setFloat64Array("data", new double[] { 1, 2, 3, 4, 5 });
+ checkSerializeAndDeserialize(rawMessage);
+ }
+}
diff --git a/message_generation/src/test/java/org/ros/internal/message/ServiceTest.java b/message_generation/src/test/java/org/ros/internal/message/ServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..decb7c333b0353dedd3c8f61a74ec3dec95acaca
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/internal/message/ServiceTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.internal.message;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.ros.internal.message.service.ServiceDefinitionResourceProvider;
+import org.ros.internal.message.service.ServiceRequestMessageFactory;
+import org.ros.internal.message.service.ServiceResponseMessageFactory;
+
+/**
+ * @author damonkohler@google.com (Damon Kohler)
+ */
+public class ServiceTest {
+
+ private ServiceDefinitionResourceProvider serviceDefinitionResourceProvider;
+ private ServiceRequestMessageFactory serviceRequestMessageFactory;
+ private ServiceResponseMessageFactory serviceResponseMessageFactory;
+
+ @Before
+ public void setUp() {
+ serviceDefinitionResourceProvider = new ServiceDefinitionResourceProvider();
+ serviceDefinitionResourceProvider.add("foo/Echo", "string data\n---\nstring data");
+ serviceRequestMessageFactory =
+ new ServiceRequestMessageFactory(serviceDefinitionResourceProvider);
+ serviceResponseMessageFactory =
+ new ServiceResponseMessageFactory(serviceDefinitionResourceProvider);
+ }
+
+ @Test
+ public void testCreateEchoService() {
+ RawMessage request = serviceRequestMessageFactory.newFromType("foo/Echo");
+ RawMessage response = serviceResponseMessageFactory.newFromType("foo/Echo");
+ request.setString("data", "Hello, ROS!");
+ response.setString("data", "Hello, ROS!");
+ }
+}
diff --git a/message_generation/src/test/java/org/ros/internal/message/field/ArrayFieldTest.java b/message_generation/src/test/java/org/ros/internal/message/field/ArrayFieldTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ebb26489cd77a1c252685904b056e97e742b6b9
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/internal/message/field/ArrayFieldTest.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.internal.message.field;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import org.ros.internal.message.MessageBuffers;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.junit.Test;
+
+/**
+ * The following unit tests were created by inspecting the serialization of
+ * array fields using the ROS Python client library.
+ *
+ * @author damonkohler@google.com (Damon Kohler)
+ */
+public class ArrayFieldTest {
+
+ @Test
+ public void testBooleanArrayFieldVariableSize() {
+ BooleanArrayField field = BooleanArrayField.newVariable("foo", -1);
+ boolean[] value = new boolean[] { true, false, true, false };
+ field.setValue(value);
+ assertEquals(PrimitiveFieldType.BOOL, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 4, 0, 0, 0, 1, 0, 1, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testBooleanArrayFieldFixedSize() {
+ BooleanArrayField field = BooleanArrayField.newVariable("foo", 4);
+ field.setValue(new boolean[] { true, false, true, false });
+ assertEquals(PrimitiveFieldType.BOOL, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 1, 0, 1, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @SuppressWarnings("deprecation")
+ @Test
+ public void testByteArrayFieldVariableSize() {
+ testByteArrayFieldVariableSize(PrimitiveFieldType.INT8);
+ testByteArrayFieldVariableSize(PrimitiveFieldType.BYTE);
+ testByteArrayFieldVariableSize(PrimitiveFieldType.UINT8);
+ testByteArrayFieldVariableSize(PrimitiveFieldType.CHAR);
+ }
+
+ private void testByteArrayFieldVariableSize(FieldType type) {
+ ByteArrayField field = ByteArrayField.newVariable(type, "foo", -1);
+ field.setValue(new byte[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 4, 0, 0, 0, 1, 2, 3, 4 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @SuppressWarnings("deprecation")
+ @Test
+ public void testByteArrayFieldFixedSize() {
+ testByteArrayFieldFixedSize(PrimitiveFieldType.INT8);
+ testByteArrayFieldFixedSize(PrimitiveFieldType.BYTE);
+ testByteArrayFieldFixedSize(PrimitiveFieldType.UINT8);
+ testByteArrayFieldFixedSize(PrimitiveFieldType.CHAR);
+ }
+
+ private void testByteArrayFieldFixedSize(FieldType type) {
+ ByteArrayField field = ByteArrayField.newVariable(type, "foo", 4);
+ field.setValue(new byte[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 1, 2, 3, 4 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testDoubleArrayFieldVariableSize() {
+ DoubleArrayField field = DoubleArrayField.newVariable("foo", -1);
+ field.setValue(new double[] { 1, 2, 3, 4 });
+ assertEquals(PrimitiveFieldType.FLOAT64, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected =
+ new byte[] { 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, -16, 63, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0,
+ 0, 8, 64, 0, 0, 0, 0, 0, 0, 16, 64 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testDoubleArrayFieldFixedSize() {
+ DoubleArrayField field = DoubleArrayField.newVariable("foo", 4);
+ field.setValue(new double[] { 1, 2, 3, 4 });
+ assertEquals(PrimitiveFieldType.FLOAT64, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected =
+ new byte[] { 0, 0, 0, 0, 0, 0, -16, 63, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 8, 64,
+ 0, 0, 0, 0, 0, 0, 16, 64 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testFloatArrayFieldVariableSize() {
+ FloatArrayField field = FloatArrayField.newVariable("foo", -1);
+ field.setValue(new float[] { 1, 2, 3, 4 });
+ assertEquals(PrimitiveFieldType.FLOAT32, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected =
+ new byte[] { 4, 0, 0, 0, 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, -128, 64 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testFloatArrayFieldFixedSize() {
+ FloatArrayField field = FloatArrayField.newVariable("foo", 4);
+ field.setValue(new float[] { 1, 2, 3, 4 });
+ assertEquals(PrimitiveFieldType.FLOAT32, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 0, 0, -128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, -128, 64 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testIntegerArrayFieldVariableSize() {
+ testIntegerArrayFieldVariableSize(PrimitiveFieldType.INT32);
+ testIntegerArrayFieldVariableSize(PrimitiveFieldType.UINT32);
+ }
+
+ private void testIntegerArrayFieldVariableSize(FieldType type) {
+ IntegerArrayField field = IntegerArrayField.newVariable(type, "foo", -1);
+ field.setValue(new int[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 4, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testIntegerArrayFieldFixedSize() {
+ testIntegerArrayFieldFixedSize(PrimitiveFieldType.INT32);
+ testIntegerArrayFieldFixedSize(PrimitiveFieldType.UINT32);
+ }
+
+ private void testIntegerArrayFieldFixedSize(FieldType type) {
+ IntegerArrayField field = IntegerArrayField.newVariable(type, "foo", 4);
+ field.setValue(new int[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testLongArrayFieldVariableSize() {
+ testLongArrayFieldVariableSize(PrimitiveFieldType.INT64);
+ testLongArrayFieldVariableSize(PrimitiveFieldType.UINT64);
+ }
+
+ private void testLongArrayFieldVariableSize(FieldType type) {
+ LongArrayField field = LongArrayField.newVariable(type, "foo", -1);
+ field.setValue(new long[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected =
+ new byte[] { 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
+ 0, 0, 4, 0, 0, 0, 0, 0, 0, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testLongArrayFieldFixedSize() {
+ testLongArrayFieldFixedSize(PrimitiveFieldType.INT64);
+ testLongArrayFieldFixedSize(PrimitiveFieldType.UINT64);
+ }
+
+ private void testLongArrayFieldFixedSize(FieldType type) {
+ LongArrayField field = LongArrayField.newVariable(type, "foo", 4);
+ field.setValue(new long[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected =
+ new byte[] { 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0,
+ 0, 0, 0, 0, 0, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testShortArrayFieldVariableSize() {
+ testShortArrayFieldVariableSize(PrimitiveFieldType.INT16);
+ testShortArrayFieldVariableSize(PrimitiveFieldType.UINT16);
+ }
+
+ private void testShortArrayFieldVariableSize(FieldType type) {
+ ShortArrayField field = ShortArrayField.newVariable(type, "foo", -1);
+ field.setValue(new short[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 4, 0, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void testShortArrayFieldFixedSize() {
+ testShortArrayFieldFixedSize(PrimitiveFieldType.INT16);
+ testShortArrayFieldFixedSize(PrimitiveFieldType.UINT16);
+ }
+
+ private void testShortArrayFieldFixedSize(FieldType type) {
+ ShortArrayField field = ShortArrayField.newVariable(type, "foo", 4);
+ field.setValue(new short[] { 1, 2, 3, 4 });
+ assertEquals(type, field.getType());
+ ChannelBuffer buffer = MessageBuffers.dynamicBuffer();
+ field.serialize(buffer);
+ byte[] expected = new byte[] { 1, 0, 2, 0, 3, 0, 4, 0 };
+ byte[] actual = new byte[buffer.readableBytes()];
+ buffer.readBytes(actual);
+ assertArrayEquals(expected, actual);
+ }
+}
diff --git a/message_generation/src/test/java/org/ros/message/DurationTest.java b/message_generation/src/test/java/org/ros/message/DurationTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb337eb43c7dc0998f3d830eadc28314e6c85440
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/message/DurationTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.message;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author kwc@willowgarage.com (Ken Conley)
+ */
+public class DurationTest {
+
+ @Before
+ public void setUp() {
+ }
+
+ @Test
+ public void testConstructor() {
+ // Test no args constructor.
+ Duration t = new Duration();
+ assertEquals(0, t.nsecs);
+ assertEquals(0, t.secs);
+
+ // Test secs/nsecs constructor with no normalization.
+ t = new Duration(1, 2);
+ assertEquals(1, t.secs);
+ assertEquals(2, t.nsecs);
+
+ // Test secs/nsecs constructor with normalization.
+ t = new Duration(2, -1);
+ assertEquals(1, t.secs);
+ assertEquals(1000000000 - 1, t.nsecs);
+
+ t = new Duration(2, 1000000000 + 2);
+ assertEquals(3, t.secs);
+ assertEquals(2, t.nsecs);
+ }
+
+ @Test
+ public void testNormalize() {
+ Duration d = new Duration(0, 0);
+ d.secs = 1;
+ d.nsecs = 1000000000;
+ d.normalize();
+ assertEquals(2, d.secs);
+ assertEquals(0, d.nsecs);
+
+ d.secs = 1;
+ d.nsecs = -1;
+ d.normalize();
+ assertEquals(0, d.secs);
+ assertEquals(1000000000-1, d.nsecs);
+ }
+
+ @Test
+ public void testIsZero() {
+ assertTrue(new Duration(0, 0).isZero());
+ assertFalse(new Duration(1, 0).isZero());
+ assertFalse(new Duration(0, 1).isZero());
+ }
+
+ @Test
+ public void testComparable() {
+ assertEquals(0, new Duration(0, 0).compareTo(new Duration(0, 0)));
+ assertEquals(0, new Duration(1, 0).compareTo(new Duration(1, 0)));
+
+ assertTrue(new Duration(0, 0).compareTo(new Duration(0, -1)) > 0);
+ assertTrue(new Duration(0, -1).compareTo(new Duration(0, 0)) < 0);
+
+ assertTrue(new Duration(0, 0).compareTo(new Duration(-1, 0)) > 0);
+ assertTrue(new Duration(-1, 0).compareTo(new Duration(0, 0)) < 0);
+
+ assertTrue(new Duration(1, 0).compareTo(new Duration(0, 0)) > 0);
+ assertTrue(new Duration(0, 0).compareTo(new Duration(1, 0)) < 0);
+
+ assertTrue(new Duration(0, 1).compareTo(new Duration(0, 0)) > 0);
+ assertTrue(new Duration(0, 0).compareTo(new Duration(0, 1)) < 0);
+ }
+}
\ No newline at end of file
diff --git a/message_generation/src/test/java/org/ros/message/TimeTest.java b/message_generation/src/test/java/org/ros/message/TimeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5ef0c4d5c631a23571a2b9261866e1f7d46bc6e3
--- /dev/null
+++ b/message_generation/src/test/java/org/ros/message/TimeTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.message;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author kwc@willowgarage.com (Ken Conley)
+ */
+public class TimeTest {
+
+ @Before
+ public void setUp() {
+ }
+
+ @Test
+ public void testConstructor() {
+ // Test no args constructor.
+ Time t = new Time();
+ assertEquals(0, t.nsecs);
+ assertEquals(0, t.secs);
+
+ // Test secs/nsecs constructor with no normalization.
+ t = new Time(1, 2);
+ assertEquals(1, t.secs);
+ assertEquals(2, t.nsecs);
+
+ // Test secs/nsecs constructor with normalization.
+ t = new Time(2, -1);
+ assertEquals(1, t.secs);
+ assertEquals(1000000000 - 1, t.nsecs);
+
+ t = new Time(2, 1000000000 + 2);
+ assertEquals(3, t.secs);
+ assertEquals(2, t.nsecs);
+ }
+
+ @Test
+ public void testFromMillis() {
+ assertEquals(new Time(0, 0), Time.fromMillis(0));
+ assertEquals(new Time(0, 1000000), Time.fromMillis(1));
+ assertEquals(new Time(1, 0), Time.fromMillis(1000));
+ assertEquals(new Time(10, 0), Time.fromMillis(10000));
+ assertEquals(new Time(1, 1000000), Time.fromMillis(1001));
+ assertEquals(new Time(1, 11000000), Time.fromMillis(1011));
+ }
+
+ @Test
+ public void testNormalize() {
+ Time t = new Time(0, 0);
+ t.secs = 1;
+ t.nsecs = 1000000000;
+ t.normalize();
+ assertEquals(2, t.secs);
+ assertEquals(0, t.nsecs);
+
+ t.secs = 1;
+ t.nsecs = -1;
+ t.normalize();
+ assertEquals(0, t.secs);
+ assertEquals(1000000000 - 1, t.nsecs);
+ }
+
+ @Test
+ public void testIsZero() {
+ assertTrue(new Time(0, 0).isZero());
+ assertFalse(new Time(1, 0).isZero());
+ assertFalse(new Time(0, 1).isZero());
+ }
+
+ @Test
+ public void testComparable() {
+ assertEquals(0, new Time(0, 0).compareTo(new Time(0, 0)));
+ assertEquals(0, new Time(1, 1).compareTo(new Time(1, 1)));
+ assertTrue(new Time(0, 1).compareTo(new Time(0, 0)) > 0);
+
+ assertEquals(-1, new Time(0, 0).compareTo(new Time(0, 1)));
+ assertTrue(new Time(0, 0).compareTo(new Time(0, 1)) < 0);
+ assertTrue(new Time(1, 0).compareTo(new Time(0, 0)) > 0);
+ assertTrue(new Time(0, 0).compareTo(new Time(1, 0)) < 0);
+
+ }
+}
\ No newline at end of file
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Point.msg b/message_generation/src/test/resources/geometry_msgs/msg/Point.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f1d3a71a853c668f066de795ba5e0f4458f3f1c0
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Point.msg
@@ -0,0 +1,4 @@
+# This contains the position of a point in free space
+float64 x
+float64 y
+float64 z
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Point32.msg b/message_generation/src/test/resources/geometry_msgs/msg/Point32.msg
new file mode 100644
index 0000000000000000000000000000000000000000..52af0a29a13b606b40945c2fd96a6473d0b2067e
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Point32.msg
@@ -0,0 +1,11 @@
+# This contains the position of a point in free space(with 32 bits of precision).
+# It is recommeded to use Point wherever possible instead of Point32.
+#
+# This recommendation is to promote interoperability.
+#
+# This message is designed to take up less space when sending
+# lots of points at once, as in the case of a PointCloud.
+
+float32 x
+float32 y
+float32 z
\ No newline at end of file
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/PointStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/PointStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..82c3437946ccaf5c65817a0485cde96992b622dc
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/PointStamped.msg
@@ -0,0 +1,3 @@
+# This represents a Point with reference coordinate frame and timestamp
+Header header
+Point point
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Polygon.msg b/message_generation/src/test/resources/geometry_msgs/msg/Polygon.msg
new file mode 100644
index 0000000000000000000000000000000000000000..c081fc4374ef1f3b560b441da7451829a98f5f76
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Polygon.msg
@@ -0,0 +1,2 @@
+#A specification of a polygon where the first and last points are assumed to be connected
+Point32[] points
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/PolygonStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/PolygonStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..c9ee413840b3c8bd47d9c41b13a6d68176b29f56
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/PolygonStamped.msg
@@ -0,0 +1,3 @@
+# This represents a Polygon with reference coordinate frame and timestamp
+Header header
+Polygon polygon
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Pose.msg b/message_generation/src/test/resources/geometry_msgs/msg/Pose.msg
new file mode 100644
index 0000000000000000000000000000000000000000..b81919c7b256667be00908b866f8bf63404256c6
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Pose.msg
@@ -0,0 +1,3 @@
+# A representation of pose in free space, composed of postion and orientation.
+Point position
+Quaternion orientation
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Pose2D.msg b/message_generation/src/test/resources/geometry_msgs/msg/Pose2D.msg
new file mode 100644
index 0000000000000000000000000000000000000000..e9555b466ac37570adcb69619fa3b3b78a9e602e
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Pose2D.msg
@@ -0,0 +1,5 @@
+# This expresses a position and orientation on a 2D manifold.
+
+float64 x
+float64 y
+float64 theta
\ No newline at end of file
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/PoseArray.msg b/message_generation/src/test/resources/geometry_msgs/msg/PoseArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..4fe0cec7c78baf2a9ee60cb751d7f7d617a8fe3a
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/PoseArray.msg
@@ -0,0 +1,5 @@
+# An array of poses with a header for global reference.
+
+Header header
+
+Pose[] poses
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/PoseStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/PoseStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..7e3cdc57b7ba5856bce0cb954d20b7a74354bdc2
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/PoseStamped.msg
@@ -0,0 +1,3 @@
+# A Pose with reference coordinate frame and timestamp
+Header header
+Pose pose
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/PoseWithCovariance.msg b/message_generation/src/test/resources/geometry_msgs/msg/PoseWithCovariance.msg
new file mode 100644
index 0000000000000000000000000000000000000000..86bc45adbb5d7d64e90556ac1f24ca8f725313cd
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/PoseWithCovariance.msg
@@ -0,0 +1,9 @@
+# This represents a pose in free space with uncertainty.
+
+Pose pose
+
+# Row-major representation of the 6x6 covariance matrix
+# The orientation parameters use a fixed-axis representation.
+# In order, the parameters are:
+# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
+float64[36] covariance
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/PoseWithCovarianceStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/PoseWithCovarianceStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..cdc306b906075b54479aa7a6a0db66f7edbc2f45
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/PoseWithCovarianceStamped.msg
@@ -0,0 +1,4 @@
+# This expresses an estimated pose with a reference coordinate frame and timestamp
+
+Header header
+PoseWithCovariance pose
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Quaternion.msg b/message_generation/src/test/resources/geometry_msgs/msg/Quaternion.msg
new file mode 100644
index 0000000000000000000000000000000000000000..9f4fde2bf4c13dc86a95688e4b5254aaec186e2a
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Quaternion.msg
@@ -0,0 +1,6 @@
+# This represents an orientation in free space in quaternion form.
+
+float64 x
+float64 y
+float64 z
+float64 w
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/QuaternionStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/QuaternionStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..62c2fdfe992c1a5eef9bf2c3a07aae7f7ad30b8a
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/QuaternionStamped.msg
@@ -0,0 +1,4 @@
+# This represents an orientation with reference coordinate frame and timestamp.
+
+Header header
+Quaternion quaternion
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Transform.msg b/message_generation/src/test/resources/geometry_msgs/msg/Transform.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f605c85ea8ec4c4871bdb7d77db6e7011c63e86d
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Transform.msg
@@ -0,0 +1,4 @@
+# This represents the transform between two coordinate frames in free space.
+
+Vector3 translation
+Quaternion rotation
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/TransformStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/TransformStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..c28ae8af1e841f2f7ef05f83bf570a13b891cb72
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/TransformStamped.msg
@@ -0,0 +1,10 @@
+# This expresses a transform from coordinate frame header.frame_id
+# to the coordinate frame child_frame_id
+#
+# This message is mostly used by the
+# <a href="http://www.ros.org/wiki/tf">tf</a> package.
+# See its documentation for more information.
+
+Header header
+string child_frame_id # the frame id of the child frame
+Transform transform
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Twist.msg b/message_generation/src/test/resources/geometry_msgs/msg/Twist.msg
new file mode 100644
index 0000000000000000000000000000000000000000..7012c2dd87ea6702f8e37a9cfbb7aab10caa8f7d
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Twist.msg
@@ -0,0 +1,3 @@
+# This expresses velocity in free space broken into its linear and angular parts.
+Vector3 linear
+Vector3 angular
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/TwistStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/TwistStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..53b8253b4251a4c6637ddd85d9937d796558949c
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/TwistStamped.msg
@@ -0,0 +1,3 @@
+# A twist with reference coordinate frame and timestamp
+Header header
+Twist twist
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/TwistWithCovariance.msg b/message_generation/src/test/resources/geometry_msgs/msg/TwistWithCovariance.msg
new file mode 100644
index 0000000000000000000000000000000000000000..111a19c5f7da42f846ed9eaff26ffc6a515c9e5f
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/TwistWithCovariance.msg
@@ -0,0 +1,9 @@
+# This expresses velocity in free space with uncertainty.
+
+Twist twist
+
+# Row-major representation of the 6x6 covariance matrix
+# The orientation parameters use a fixed-axis representation.
+# In order, the parameters are:
+# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
+float64[36] covariance
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/TwistWithCovarianceStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/TwistWithCovarianceStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..aba6ebe735871ba35218fcebe021fbef6e11d5d9
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/TwistWithCovarianceStamped.msg
@@ -0,0 +1,3 @@
+# This represents an estimated twist with reference coordinate frame and timestamp.
+Header header
+TwistWithCovariance twist
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Vector3.msg b/message_generation/src/test/resources/geometry_msgs/msg/Vector3.msg
new file mode 100644
index 0000000000000000000000000000000000000000..00dd4cbac99e2729865cd00faff2ac482c0794cd
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Vector3.msg
@@ -0,0 +1,5 @@
+# This represents a vector in free space.
+
+float64 x
+float64 y
+float64 z
\ No newline at end of file
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Vector3Stamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/Vector3Stamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..e68eb062bebd5bba3cbaf9f33beae5a207f72a51
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Vector3Stamped.msg
@@ -0,0 +1,3 @@
+# This represents a Vector3 with reference coordinate frame and timestamp
+Header header
+Vector3 vector
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/Wrench.msg b/message_generation/src/test/resources/geometry_msgs/msg/Wrench.msg
new file mode 100644
index 0000000000000000000000000000000000000000..41201d4b844607ee2d3751f3f474774a2ae1e387
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/Wrench.msg
@@ -0,0 +1,4 @@
+# This represents force in free space, separated into
+# its linear and angular parts.
+Vector3 force
+Vector3 torque
diff --git a/message_generation/src/test/resources/geometry_msgs/msg/WrenchStamped.msg b/message_generation/src/test/resources/geometry_msgs/msg/WrenchStamped.msg
new file mode 100644
index 0000000000000000000000000000000000000000..dad910ed724de005e89e3422ef1ca7cec401e9e4
--- /dev/null
+++ b/message_generation/src/test/resources/geometry_msgs/msg/WrenchStamped.msg
@@ -0,0 +1,3 @@
+# A wrench with reference coordinate frame and timestamp
+Header header
+Wrench wrench
diff --git a/message_generation/src/test/resources/nav_msgs/action/GetMap.action b/message_generation/src/test/resources/nav_msgs/action/GetMap.action
new file mode 100644
index 0000000000000000000000000000000000000000..080e54fe195b4dd96a8c5ba0e08e824aa94c0416
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/action/GetMap.action
@@ -0,0 +1,5 @@
+# Get the map as a nav_msgs/OccupancyGrid
+---
+nav_msgs/OccupancyGrid map
+---
+# no feedback
\ No newline at end of file
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GetMapAction.msg b/message_generation/src/test/resources/nav_msgs/msg/GetMapAction.msg
new file mode 100644
index 0000000000000000000000000000000000000000..1cbd69ca56edab0cb1590f60636bdc664eee96c9
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GetMapAction.msg
@@ -0,0 +1,5 @@
+# ====== DO NOT MODIFY! AUTOGENERATED FROM AN ACTION DEFINITION ======
+
+GetMapActionGoal action_goal
+GetMapActionResult action_result
+GetMapActionFeedback action_feedback
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GetMapActionFeedback.msg b/message_generation/src/test/resources/nav_msgs/msg/GetMapActionFeedback.msg
new file mode 100644
index 0000000000000000000000000000000000000000..485360150b18d2411696610d80cb7758bef9cfbd
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GetMapActionFeedback.msg
@@ -0,0 +1,5 @@
+# ====== DO NOT MODIFY! AUTOGENERATED FROM AN ACTION DEFINITION ======
+
+Header header
+actionlib_msgs/GoalStatus status
+GetMapFeedback feedback
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GetMapActionGoal.msg b/message_generation/src/test/resources/nav_msgs/msg/GetMapActionGoal.msg
new file mode 100644
index 0000000000000000000000000000000000000000..8782a1e363336ed8220ce9a33547dbd46fd9268c
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GetMapActionGoal.msg
@@ -0,0 +1,5 @@
+# ====== DO NOT MODIFY! AUTOGENERATED FROM AN ACTION DEFINITION ======
+
+Header header
+actionlib_msgs/GoalID goal_id
+GetMapGoal goal
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GetMapActionResult.msg b/message_generation/src/test/resources/nav_msgs/msg/GetMapActionResult.msg
new file mode 100644
index 0000000000000000000000000000000000000000..707d61d63c5d986a1bb3e1b87c8f21e71dedf351
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GetMapActionResult.msg
@@ -0,0 +1,5 @@
+# ====== DO NOT MODIFY! AUTOGENERATED FROM AN ACTION DEFINITION ======
+
+Header header
+actionlib_msgs/GoalStatus status
+GetMapResult result
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GetMapFeedback.msg b/message_generation/src/test/resources/nav_msgs/msg/GetMapFeedback.msg
new file mode 100644
index 0000000000000000000000000000000000000000..8eb4d4840eb0d27a33a08d42bfec821e08a2906e
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GetMapFeedback.msg
@@ -0,0 +1,2 @@
+# ====== DO NOT MODIFY! AUTOGENERATED FROM AN ACTION DEFINITION ======
+# no feedback
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GetMapGoal.msg b/message_generation/src/test/resources/nav_msgs/msg/GetMapGoal.msg
new file mode 100644
index 0000000000000000000000000000000000000000..6354ac1172379e5191897cc96c52cb3f2e753de8
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GetMapGoal.msg
@@ -0,0 +1,2 @@
+# ====== DO NOT MODIFY! AUTOGENERATED FROM AN ACTION DEFINITION ======
+# Get the map as a nav_msgs/OccupancyGrid
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GetMapResult.msg b/message_generation/src/test/resources/nav_msgs/msg/GetMapResult.msg
new file mode 100644
index 0000000000000000000000000000000000000000..b8c9dcd5a819bd847ff29b4b8d6e1bbaa64f4d7b
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GetMapResult.msg
@@ -0,0 +1,2 @@
+# ====== DO NOT MODIFY! AUTOGENERATED FROM AN ACTION DEFINITION ======
+nav_msgs/OccupancyGrid map
diff --git a/message_generation/src/test/resources/nav_msgs/msg/GridCells.msg b/message_generation/src/test/resources/nav_msgs/msg/GridCells.msg
new file mode 100644
index 0000000000000000000000000000000000000000..2c92894115110f24c745e06d9aeab55d0f3abb1d
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/GridCells.msg
@@ -0,0 +1,5 @@
+#an array of cells in a 2D grid
+Header header
+float32 cell_width
+float32 cell_height
+geometry_msgs/Point[] cells
diff --git a/message_generation/src/test/resources/nav_msgs/msg/MapMetaData.msg b/message_generation/src/test/resources/nav_msgs/msg/MapMetaData.msg
new file mode 100644
index 0000000000000000000000000000000000000000..398fbdd016f91045fd14ec727a65b6d1cf55dc0a
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/MapMetaData.msg
@@ -0,0 +1,13 @@
+# This hold basic information about the characterists of the OccupancyGrid
+
+# The time at which the map was loaded
+time map_load_time
+# The map resolution [m/cell]
+float32 resolution
+# Map width [cells]
+uint32 width
+# Map height [cells]
+uint32 height
+# The origin of the map [m, m, rad]. This is the real-world pose of the
+# cell (0,0) in the map.
+geometry_msgs/Pose origin
\ No newline at end of file
diff --git a/message_generation/src/test/resources/nav_msgs/msg/OccupancyGrid.msg b/message_generation/src/test/resources/nav_msgs/msg/OccupancyGrid.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f2e79bdad33b17af3236514343abe486e779522a
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/OccupancyGrid.msg
@@ -0,0 +1,11 @@
+# This represents a 2-D grid map, in which each cell represents the probability of
+# occupancy.
+
+Header header
+
+#MetaData for the map
+MapMetaData info
+
+# The map data, in row-major order, starting with (0,0). Occupancy
+# probabilities are in the range [0,100]. Unknown is -1.
+int8[] data
diff --git a/message_generation/src/test/resources/nav_msgs/msg/Odometry.msg b/message_generation/src/test/resources/nav_msgs/msg/Odometry.msg
new file mode 100644
index 0000000000000000000000000000000000000000..73578ed85765ca14b040dc888d9cb148530a95d3
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/Odometry.msg
@@ -0,0 +1,7 @@
+# This represents an estimate of a position and velocity in free space.
+# The pose in this message should be specified in the coordinate frame given by header.frame_id.
+# The twist in this message should be specified in the coordinate frame given by the child_frame_id
+Header header
+string child_frame_id
+geometry_msgs/PoseWithCovariance pose
+geometry_msgs/TwistWithCovariance twist
diff --git a/message_generation/src/test/resources/nav_msgs/msg/Path.msg b/message_generation/src/test/resources/nav_msgs/msg/Path.msg
new file mode 100644
index 0000000000000000000000000000000000000000..979cb7d368d4246445d43e62df9d9aa20939fbe1
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/msg/Path.msg
@@ -0,0 +1,3 @@
+#An array of poses that represents a Path for a robot to follow
+Header header
+geometry_msgs/PoseStamped[] poses
diff --git a/message_generation/src/test/resources/nav_msgs/srv/GetMap.srv b/message_generation/src/test/resources/nav_msgs/srv/GetMap.srv
new file mode 100644
index 0000000000000000000000000000000000000000..6bd8e4a60a0f746dd500dbd550559f4735749208
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/srv/GetMap.srv
@@ -0,0 +1,3 @@
+# Get the map as a nav_msgs/OccupancyGrid
+---
+nav_msgs/OccupancyGrid map
diff --git a/message_generation/src/test/resources/nav_msgs/srv/GetPlan.srv b/message_generation/src/test/resources/nav_msgs/srv/GetPlan.srv
new file mode 100644
index 0000000000000000000000000000000000000000..f5c23edb78558e6fef8cda881c45c2bf3e94486a
--- /dev/null
+++ b/message_generation/src/test/resources/nav_msgs/srv/GetPlan.srv
@@ -0,0 +1,13 @@
+# Get a plan from the current position to the goal Pose
+
+# The start pose for the plan
+geometry_msgs/PoseStamped start
+
+# The final pose of the goal position
+geometry_msgs/PoseStamped goal
+
+# If the goal is obstructed, how many meters the planner can
+# relax the constraint in x and y before failing.
+float32 tolerance
+---
+nav_msgs/Path plan
diff --git a/message_generation/src/test/resources/std_msgs/msg/Bool.msg b/message_generation/src/test/resources/std_msgs/msg/Bool.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f7cabb94fc04ac5f83ca8f219357b439f29d002f
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Bool.msg
@@ -0,0 +1 @@
+bool data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/Byte.msg b/message_generation/src/test/resources/std_msgs/msg/Byte.msg
new file mode 100644
index 0000000000000000000000000000000000000000..d993b3455539598fdc5db3365a4534ed9f125b5d
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Byte.msg
@@ -0,0 +1 @@
+byte data
diff --git a/message_generation/src/test/resources/std_msgs/msg/ByteMultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/ByteMultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..bb00bd348bc726b4bf52ae12c1fe740855447b95
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/ByteMultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+byte[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/Char.msg b/message_generation/src/test/resources/std_msgs/msg/Char.msg
new file mode 100644
index 0000000000000000000000000000000000000000..39a1d46a97c419a2b8ab45b30c68758ed03b905b
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Char.msg
@@ -0,0 +1 @@
+char data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/ColorRGBA.msg b/message_generation/src/test/resources/std_msgs/msg/ColorRGBA.msg
new file mode 100644
index 0000000000000000000000000000000000000000..182dbc8349abec122d95436cb840906503f569f2
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/ColorRGBA.msg
@@ -0,0 +1,4 @@
+float32 r
+float32 g
+float32 b
+float32 a
diff --git a/message_generation/src/test/resources/std_msgs/msg/Duration.msg b/message_generation/src/test/resources/std_msgs/msg/Duration.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f13931ec8a7937ca624ff91af7f861559b5fc3fe
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Duration.msg
@@ -0,0 +1 @@
+duration data
diff --git a/message_generation/src/test/resources/std_msgs/msg/Empty.msg b/message_generation/src/test/resources/std_msgs/msg/Empty.msg
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/message_generation/src/test/resources/std_msgs/msg/Float32.msg b/message_generation/src/test/resources/std_msgs/msg/Float32.msg
new file mode 100644
index 0000000000000000000000000000000000000000..e89740534bd9c0344c18709de0c29667620295bd
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Float32.msg
@@ -0,0 +1 @@
+float32 data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/Float32MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/Float32MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..915830846dd023a111abd8ad2831d982b9c85a82
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Float32MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+float32[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/Float64.msg b/message_generation/src/test/resources/std_msgs/msg/Float64.msg
new file mode 100644
index 0000000000000000000000000000000000000000..cd09d39b8caedf067b9548d62ecab3c73b6ecace
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Float64.msg
@@ -0,0 +1 @@
+float64 data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/Float64MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/Float64MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..0a13b928fd70d116defc17ec0acc09a6296b57ff
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Float64MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+float64[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/Header.msg b/message_generation/src/test/resources/std_msgs/msg/Header.msg
new file mode 100644
index 0000000000000000000000000000000000000000..b2f34f6f1d15f22149dae16e5e6bbf190a89a0d8
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Header.msg
@@ -0,0 +1,15 @@
+# Standard metadata for higher-level stamped data types.
+# This is generally used to communicate timestamped data
+# in a particular coordinate frame.
+#
+# sequence ID: consecutively increasing ID
+uint32 seq
+#Two-integer timestamp that is expressed as:
+# * stamp.secs: seconds (stamp_secs) since epoch
+# * stamp.nsecs: nanoseconds since stamp_secs
+# time-handling sugar is provided by the client library
+time stamp
+#Frame this data is associated with
+# 0: no frame
+# 1: global frame
+string frame_id
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int16.msg b/message_generation/src/test/resources/std_msgs/msg/Int16.msg
new file mode 100644
index 0000000000000000000000000000000000000000..c4389faf706f189e64bc576af0f7788f06d16c86
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int16.msg
@@ -0,0 +1 @@
+int16 data
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int16MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/Int16MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..d2ddea1d1d6a69a15cb17e434900a1afbadaac89
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int16MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+int16[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int32.msg b/message_generation/src/test/resources/std_msgs/msg/Int32.msg
new file mode 100644
index 0000000000000000000000000000000000000000..0ecfe35f5f480f463e0b26e696c4f0e858aba06c
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int32.msg
@@ -0,0 +1 @@
+int32 data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int32MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/Int32MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..af60abda3a697bac5e596b23b04038414258188a
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int32MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+int32[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int64.msg b/message_generation/src/test/resources/std_msgs/msg/Int64.msg
new file mode 100644
index 0000000000000000000000000000000000000000..6961e00f52989d8e03f54e0a0e0333ae470e6508
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int64.msg
@@ -0,0 +1 @@
+int64 data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int64MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/Int64MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f4f35e171b316dacbb0eb3a80e20885977171ebd
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int64MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+int64[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int8.msg b/message_generation/src/test/resources/std_msgs/msg/Int8.msg
new file mode 100644
index 0000000000000000000000000000000000000000..1e42e554feea25175f15af74433d802e86ed0180
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int8.msg
@@ -0,0 +1 @@
+int8 data
diff --git a/message_generation/src/test/resources/std_msgs/msg/Int8MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/Int8MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..a59a37259e5e97c8dbee0072f4e6c282d7fc8fd3
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Int8MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+int8[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/MultiArrayDimension.msg b/message_generation/src/test/resources/std_msgs/msg/MultiArrayDimension.msg
new file mode 100644
index 0000000000000000000000000000000000000000..08240462c4315969a5a8cde9292683c51865a5d3
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/MultiArrayDimension.msg
@@ -0,0 +1,3 @@
+string label # label of given dimension
+uint32 size # size of given dimension (in type units)
+uint32 stride # stride of given dimension
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/MultiArrayLayout.msg b/message_generation/src/test/resources/std_msgs/msg/MultiArrayLayout.msg
new file mode 100644
index 0000000000000000000000000000000000000000..5437f8542af613c0058e380c27ab59cb5ebb7df0
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/MultiArrayLayout.msg
@@ -0,0 +1,26 @@
+# The multiarray declares a generic multi-dimensional array of a
+# particular data type. Dimensions are ordered from outer most
+# to inner most.
+
+MultiArrayDimension[] dim # Array of dimension properties
+uint32 data_offset # padding bytes at front of data
+
+# Accessors should ALWAYS be written in terms of dimension stride
+# and specified outer-most dimension first.
+#
+# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]
+#
+# A standard, 3-channel 640x480 image with interleaved color channels
+# would be specified as:
+#
+# dim[0].label = "height"
+# dim[0].size = 480
+# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)
+# dim[1].label = "width"
+# dim[1].size = 640
+# dim[1].stride = 3*640 = 1920
+# dim[2].label = "channel"
+# dim[2].size = 3
+# dim[2].stride = 3
+#
+# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/String.msg b/message_generation/src/test/resources/std_msgs/msg/String.msg
new file mode 100644
index 0000000000000000000000000000000000000000..ae721739e8fa7035347d3fed3cca1b137e670c97
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/String.msg
@@ -0,0 +1 @@
+string data
diff --git a/message_generation/src/test/resources/std_msgs/msg/Time.msg b/message_generation/src/test/resources/std_msgs/msg/Time.msg
new file mode 100644
index 0000000000000000000000000000000000000000..7f8f721711fbbc620fa7f6b58a9f89d5667281be
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/Time.msg
@@ -0,0 +1 @@
+time data
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt16.msg b/message_generation/src/test/resources/std_msgs/msg/UInt16.msg
new file mode 100644
index 0000000000000000000000000000000000000000..87d0c44eb59dca29f419aaa77801b4fbc278f9f6
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt16.msg
@@ -0,0 +1 @@
+uint16 data
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt16MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/UInt16MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f38970b656cf1160e292f9effc8f5d8c3281a12b
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt16MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+uint16[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt32.msg b/message_generation/src/test/resources/std_msgs/msg/UInt32.msg
new file mode 100644
index 0000000000000000000000000000000000000000..b6c696b421e4a4c89c7f1420fbaa15af83913093
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt32.msg
@@ -0,0 +1 @@
+uint32 data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt32MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/UInt32MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..b2bb0771f0208bc3c45210a918d689d5a24b53a7
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt32MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+uint32[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt64.msg b/message_generation/src/test/resources/std_msgs/msg/UInt64.msg
new file mode 100644
index 0000000000000000000000000000000000000000..2eb1afad37e320a366f7b0296fb207569a30db47
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt64.msg
@@ -0,0 +1 @@
+uint64 data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt64MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/UInt64MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..30d0cd92854159d4cc3fa5e996763cc08e9dcdf9
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt64MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+uint64[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt8.msg b/message_generation/src/test/resources/std_msgs/msg/UInt8.msg
new file mode 100644
index 0000000000000000000000000000000000000000..5eefd870db82c99cf7d62e7ccff1824c114bd462
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt8.msg
@@ -0,0 +1 @@
+uint8 data
diff --git a/message_generation/src/test/resources/std_msgs/msg/UInt8MultiArray.msg b/message_generation/src/test/resources/std_msgs/msg/UInt8MultiArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..31f7d6a213995f216f4d124f1d6402852d1572b2
--- /dev/null
+++ b/message_generation/src/test/resources/std_msgs/msg/UInt8MultiArray.msg
@@ -0,0 +1,6 @@
+# Please look at the MultiArrayLayout message definition for
+# documentation on all multiarrays.
+
+MultiArrayLayout layout # specification of data layout
+uint8[] data # array of data
+
diff --git a/message_generation/src/test/resources/std_srvs/srv/Empty.srv b/message_generation/src/test/resources/std_srvs/srv/Empty.srv
new file mode 100644
index 0000000000000000000000000000000000000000..73b314ff7c704c18889cf90fdc024716c634adb6
--- /dev/null
+++ b/message_generation/src/test/resources/std_srvs/srv/Empty.srv
@@ -0,0 +1 @@
+---
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/msg/ArrayVal.msg b/message_generation/src/test/resources/test_msgs/msg/ArrayVal.msg
new file mode 100644
index 0000000000000000000000000000000000000000..4a34dd1bb8c84ef12a33f1782a27acaaa8dc8812
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/ArrayVal.msg
@@ -0,0 +1,2 @@
+Val[] vals
+#Val[10] vals_fixed
diff --git a/message_generation/src/test/resources/test_msgs/msg/Composite.msg b/message_generation/src/test/resources/test_msgs/msg/Composite.msg
new file mode 100644
index 0000000000000000000000000000000000000000..4629d3e56c7c03e55052196f34f3a5976024f524
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/Composite.msg
@@ -0,0 +1,3 @@
+# composite message. required for testing import calculation in generators
+CompositeA a
+CompositeB b
diff --git a/message_generation/src/test/resources/test_msgs/msg/CompositeA.msg b/message_generation/src/test/resources/test_msgs/msg/CompositeA.msg
new file mode 100644
index 0000000000000000000000000000000000000000..9f4fde2bf4c13dc86a95688e4b5254aaec186e2a
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/CompositeA.msg
@@ -0,0 +1,6 @@
+# This represents an orientation in free space in quaternion form.
+
+float64 x
+float64 y
+float64 z
+float64 w
diff --git a/message_generation/src/test/resources/test_msgs/msg/CompositeB.msg b/message_generation/src/test/resources/test_msgs/msg/CompositeB.msg
new file mode 100644
index 0000000000000000000000000000000000000000..fb689bc8225e2c6f60b45c852c7f19da3dcd00cb
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/CompositeB.msg
@@ -0,0 +1,4 @@
+# copy of geometry_msgs/Point for testing
+float64 x
+float64 y
+float64 z
diff --git a/message_generation/src/test/resources/test_msgs/msg/EmbedTest.msg b/message_generation/src/test/resources/test_msgs/msg/EmbedTest.msg
new file mode 100644
index 0000000000000000000000000000000000000000..e1962cd4e10b88807c085907284686a85e1b9026
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/EmbedTest.msg
@@ -0,0 +1,6 @@
+std_msgs/String str1
+std_msgs/Int32 int1
+std_msgs/Int32[] ints
+Val val
+Val[] vals
+ArrayVal[] arrayval
diff --git a/message_generation/src/test/resources/test_msgs/msg/Floats.msg b/message_generation/src/test/resources/test_msgs/msg/Floats.msg
new file mode 100644
index 0000000000000000000000000000000000000000..6bd8052d3121617bd05bb32247181ab8819791a1
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/Floats.msg
@@ -0,0 +1,2 @@
+# exact copy of rospy_tutorials/Floats, used for testing
+float32[] data
diff --git a/message_generation/src/test/resources/test_msgs/msg/HeaderHeaderVal.msg b/message_generation/src/test/resources/test_msgs/msg/HeaderHeaderVal.msg
new file mode 100644
index 0000000000000000000000000000000000000000..6882d7ac4ae5e42bab89bdb212d21aba8dedf918
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/HeaderHeaderVal.msg
@@ -0,0 +1,2 @@
+Header header
+HeaderVal val
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/msg/HeaderVal.msg b/message_generation/src/test/resources/test_msgs/msg/HeaderVal.msg
new file mode 100644
index 0000000000000000000000000000000000000000..91f99b2545dbf8b10e20be09e7cbbd0478531d12
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/HeaderVal.msg
@@ -0,0 +1,2 @@
+Header header
+string val
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/msg/PythonKeyword.msg b/message_generation/src/test/resources/test_msgs/msg/PythonKeyword.msg
new file mode 100644
index 0000000000000000000000000000000000000000..0949ea888777ebf179376c7c044c8886c9eac1bd
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/PythonKeyword.msg
@@ -0,0 +1 @@
+int32 yield
diff --git a/message_generation/src/test/resources/test_msgs/msg/TestArrays.msg b/message_generation/src/test/resources/test_msgs/msg/TestArrays.msg
new file mode 100644
index 0000000000000000000000000000000000000000..2d7493fe41614d7fed5ba02067c030377780d85d
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TestArrays.msg
@@ -0,0 +1,10 @@
+# caller_id of most recent node to send this message
+string caller_id
+# caller_id of the original node to send this message
+string orig_caller_id
+
+int32[] int32_array
+float32[] float32_array
+time[] time_array
+TestString[] test_string_array
+# TODO: array of arrays
diff --git a/message_generation/src/test/resources/test_msgs/msg/TestConstants.msg b/message_generation/src/test/resources/test_msgs/msg/TestConstants.msg
new file mode 100644
index 0000000000000000000000000000000000000000..344afc3840a05ca3247d780a54893fe263e73939
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TestConstants.msg
@@ -0,0 +1,15 @@
+float32 A=-123.0
+float32 B=124.0
+float64 C=125.0
+int32 X=123
+int32 Y=-123
+uint32 Z=124
+string FOO=foo
+string SINGLEQUOTE='hi
+string DOUBLEQUOTE="hello" there
+string MULTIQUOTE="hello" 'goodbye'
+string EXAMPLE="#comments" are ignored, and leading and trailing whitespace removed
+string WHITESPACE= strip
+string EMPTY=
+bool TRUE=1
+bool FALSE=0
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/msg/TestFixedArray.msg b/message_generation/src/test/resources/test_msgs/msg/TestFixedArray.msg
new file mode 100644
index 0000000000000000000000000000000000000000..005aa94af24fd1e3cfac5215cf76a6a6b9523999
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TestFixedArray.msg
@@ -0,0 +1,16 @@
+float32[1] f32_1
+float32[3] f32_3
+float64[1] f64_1
+float64[3] f64_3
+int8[1] i8_1
+int8[3] i8_3
+uint8[1] u8_1
+uint8[3] u8_3
+int32[1] i32_1
+int32[3] i32_3
+uint32[1] u32_1
+uint32[3] u32_3
+string[1] s_1
+string[3] s_3
+bool[1] b_1
+bool[3] b_3
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/msg/TestHeader.msg b/message_generation/src/test/resources/test_msgs/msg/TestHeader.msg
new file mode 100644
index 0000000000000000000000000000000000000000..22897c3b85330325819e6e8fee8ab8198ba6fe00
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TestHeader.msg
@@ -0,0 +1,8 @@
+Header header
+
+# caller_id of most recent node to send this message
+string caller_id
+# caller_id of the original node to send this message
+string orig_caller_id
+
+byte auto_header # autoset header on response
diff --git a/message_generation/src/test/resources/test_msgs/msg/TestPrimitives.msg b/message_generation/src/test/resources/test_msgs/msg/TestPrimitives.msg
new file mode 100644
index 0000000000000000000000000000000000000000..815dd5b0d18f9b94da8c8952c36cb0738d5d6438
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TestPrimitives.msg
@@ -0,0 +1,21 @@
+# Integration test message of all primitive types
+
+# caller_id of most recent node to send this message
+string caller_id
+# caller_id of the original node to send this message
+string orig_caller_id
+
+string str
+byte b
+int16 int16
+int32 int32
+int64 int64
+char c
+uint16 uint16
+uint32 uint32
+uint64 uint64
+float32 float32
+float64 float64
+time t
+duration d
+
diff --git a/message_generation/src/test/resources/test_msgs/msg/TestString.msg b/message_generation/src/test/resources/test_msgs/msg/TestString.msg
new file mode 100644
index 0000000000000000000000000000000000000000..4ab04385050da20743d887191f80a17361d0f4c3
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TestString.msg
@@ -0,0 +1,6 @@
+# Integration test message
+# caller_id of most recent node to send this message
+string caller_id
+# caller_id of the original node to send this message
+string orig_caller_id
+string data
diff --git a/message_generation/src/test/resources/test_msgs/msg/TransitiveImport.msg b/message_generation/src/test/resources/test_msgs/msg/TransitiveImport.msg
new file mode 100644
index 0000000000000000000000000000000000000000..bf33d172859640df342b6ea66d89d5cfed850537
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TransitiveImport.msg
@@ -0,0 +1,2 @@
+# Bug #2133/2139: EmbedTest uses std_msgs, so TransitiveImport needs it as well
+EmbedTest data
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/msg/TransitiveMsg1.msg b/message_generation/src/test/resources/test_msgs/msg/TransitiveMsg1.msg
new file mode 100644
index 0000000000000000000000000000000000000000..f41ed0cf3ce5662220a8a4ce94d31e9edb521320
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TransitiveMsg1.msg
@@ -0,0 +1,2 @@
+TransitiveMsg2 msg2
+
diff --git a/message_generation/src/test/resources/test_msgs/msg/TransitiveMsg2.msg b/message_generation/src/test/resources/test_msgs/msg/TransitiveMsg2.msg
new file mode 100644
index 0000000000000000000000000000000000000000..0084c088e0f5036d60aedb2f93ccebcc78dd22a5
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/TransitiveMsg2.msg
@@ -0,0 +1 @@
+test_msgs/Composite data
diff --git a/message_generation/src/test/resources/test_msgs/msg/Val.msg b/message_generation/src/test/resources/test_msgs/msg/Val.msg
new file mode 100644
index 0000000000000000000000000000000000000000..c11841ad234e1b31fc7dde9c26a5249b7181c02a
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/msg/Val.msg
@@ -0,0 +1 @@
+string val
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/srv/AddTwoInts.srv b/message_generation/src/test/resources/test_msgs/srv/AddTwoInts.srv
new file mode 100644
index 0000000000000000000000000000000000000000..3a68808ee591a3623cbf5e553eed28bac5233be8
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/AddTwoInts.srv
@@ -0,0 +1,4 @@
+int64 a
+int64 b
+---
+int64 sum
diff --git a/message_generation/src/test/resources/test_msgs/srv/ConstantsMultiplex.srv b/message_generation/src/test/resources/test_msgs/srv/ConstantsMultiplex.srv
new file mode 100644
index 0000000000000000000000000000000000000000..b955445414b95f3c56ac4e676e2d20e350b6acb4
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/ConstantsMultiplex.srv
@@ -0,0 +1,26 @@
+byte BYTE_X=0
+byte BYTE_Y=15
+byte BYTE_Z=5
+int32 INT32_X=0
+int32 INT32_Y=-12345678
+int32 INT32_Z=12345678
+uint32 UINT32_X=0
+uint32 UINT32_Y=12345678
+uint32 UINT32_Z=1
+float32 FLOAT32_X=0.0
+float32 FLOAT32_Y=-3.14159
+float32 FLOAT32_Z=12345.78
+byte SELECT_X=1
+byte SELECT_Y=2
+byte SELECT_Z=3
+byte selection
+---
+# test response constants as well
+byte CONFIRM_X=1
+byte CONFIRM_Y=2
+byte CONFIRM_Z=3
+byte select_confirm
+byte ret_byte
+int32 ret_int32
+uint32 ret_uint32
+float32 ret_float32
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/srv/EmptyReqSrv.srv b/message_generation/src/test/resources/test_msgs/srv/EmptyReqSrv.srv
new file mode 100644
index 0000000000000000000000000000000000000000..1f2c1eb6ac0db364f9ad16172625c6002c52d06e
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/EmptyReqSrv.srv
@@ -0,0 +1,2 @@
+---
+int32 fake_secret
diff --git a/message_generation/src/test/resources/test_msgs/srv/EmptyRespSrv.srv b/message_generation/src/test/resources/test_msgs/srv/EmptyRespSrv.srv
new file mode 100644
index 0000000000000000000000000000000000000000..6ef29bc8d831056d98c78522e1393160490ff326
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/EmptyRespSrv.srv
@@ -0,0 +1,2 @@
+int32 fake_secret
+---
diff --git a/message_generation/src/test/resources/test_msgs/srv/EmptySrv.srv b/message_generation/src/test/resources/test_msgs/srv/EmptySrv.srv
new file mode 100644
index 0000000000000000000000000000000000000000..ed97d539c095cf1413af30cc23dea272095b97dd
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/EmptySrv.srv
@@ -0,0 +1 @@
+---
diff --git a/message_generation/src/test/resources/test_msgs/srv/ListReturn.srv b/message_generation/src/test/resources/test_msgs/srv/ListReturn.srv
new file mode 100644
index 0000000000000000000000000000000000000000..311e806433675ad02b272023067b9e9444dc7349
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/ListReturn.srv
@@ -0,0 +1,7 @@
+# test case for having single list return value
+int32 a
+int32 b
+int32 c
+int32 d
+---
+int32[] abcd
diff --git a/message_generation/src/test/resources/test_msgs/srv/MultipleAddTwoInts.srv b/message_generation/src/test/resources/test_msgs/srv/MultipleAddTwoInts.srv
new file mode 100644
index 0000000000000000000000000000000000000000..522a482621cf430cf3ed8318667ab6896ffee9ef
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/MultipleAddTwoInts.srv
@@ -0,0 +1,8 @@
+# test case for having multiple return values
+int32 a
+int32 b
+int32 c
+int32 d
+---
+int32 ab
+int32 cd
\ No newline at end of file
diff --git a/message_generation/src/test/resources/test_msgs/srv/StringString.srv b/message_generation/src/test/resources/test_msgs/srv/StringString.srv
new file mode 100644
index 0000000000000000000000000000000000000000..a9242d416e849ba58184d8f030fef12fd5cc7a0b
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/StringString.srv
@@ -0,0 +1,4 @@
+std_msgs/String str
+Val str2
+---
+std_msgs/String str
diff --git a/message_generation/src/test/resources/test_msgs/srv/TransitiveSrv.srv b/message_generation/src/test/resources/test_msgs/srv/TransitiveSrv.srv
new file mode 100644
index 0000000000000000000000000000000000000000..09a03750a8042d51ac320d4ef6619e96a91db1b5
--- /dev/null
+++ b/message_generation/src/test/resources/test_msgs/srv/TransitiveSrv.srv
@@ -0,0 +1,4 @@
+test_msgs/TransitiveMsg1 msg
+---
+int32 a
+