diff --git a/rosidl_generator_java/CMakeLists.txt b/rosidl_generator_java/CMakeLists.txt index 13b0c00d..4b1c2ea5 100644 --- a/rosidl_generator_java/CMakeLists.txt +++ b/rosidl_generator_java/CMakeLists.txt @@ -34,29 +34,6 @@ if(BUILD_TESTING) find_package(ament_lint_auto REQUIRED) ament_lint_auto_find_test_dependencies() - # TODO(jacobperron): Use test_interface_files instead and update tests - set(message_files - "msg/Bool.msg" - "msg/Byte.msg" - "msg/Char.msg" - "msg/Constants.msg" - "msg/Empty.msg" - "msg/Float32.msg" - "msg/Float64.msg" - "msg/Int16.msg" - "msg/Int32.msg" - "msg/Int64.msg" - "msg/Int8.msg" - "msg/Nested.msg" - "msg/Primitives.msg" - "msg/Strings.msg" - "msg/Uint16.msg" - "msg/Uint32.msg" - "msg/Uint64.msg" - "msg/Uint8.msg" - "msg/Various.msg" - ) - include(cmake/register_java.cmake) include(cmake/rosidl_generator_java_get_typesupports.cmake) @@ -70,6 +47,7 @@ if(BUILD_TESTING) rosidl_generate_interfaces(${PROJECT_NAME} ${message_files} + ${test_interface_files_MSG_FILES} ${test_interface_files_SRV_FILES} SKIP_INSTALL ) diff --git a/rosidl_generator_java/msg/Bool.msg b/rosidl_generator_java/msg/Bool.msg deleted file mode 100644 index b1578abb..00000000 --- a/rosidl_generator_java/msg/Bool.msg +++ /dev/null @@ -1 +0,0 @@ -bool empty_bool diff --git a/rosidl_generator_java/msg/Byte.msg b/rosidl_generator_java/msg/Byte.msg deleted file mode 100644 index 2e6fa040..00000000 --- a/rosidl_generator_java/msg/Byte.msg +++ /dev/null @@ -1 +0,0 @@ -byte empty_byte diff --git a/rosidl_generator_java/msg/Char.msg b/rosidl_generator_java/msg/Char.msg deleted file mode 100644 index 0f2e0c90..00000000 --- a/rosidl_generator_java/msg/Char.msg +++ /dev/null @@ -1 +0,0 @@ -char empty_char diff --git a/rosidl_generator_java/msg/Constants.msg b/rosidl_generator_java/msg/Constants.msg deleted file mode 100644 index d9e404e8..00000000 --- a/rosidl_generator_java/msg/Constants.msg +++ /dev/null @@ -1,5 +0,0 @@ -int32 X=123 -int32 Y=-123 -string FOO=foo -char TOTO=127 -byte TATA=48 diff --git a/rosidl_generator_java/msg/Empty.msg b/rosidl_generator_java/msg/Empty.msg deleted file mode 100644 index 8b137891..00000000 --- a/rosidl_generator_java/msg/Empty.msg +++ /dev/null @@ -1 +0,0 @@ - diff --git a/rosidl_generator_java/msg/Float32.msg b/rosidl_generator_java/msg/Float32.msg deleted file mode 100644 index a8bb0cb6..00000000 --- a/rosidl_generator_java/msg/Float32.msg +++ /dev/null @@ -1 +0,0 @@ -float32 empty_float32 diff --git a/rosidl_generator_java/msg/Float64.msg b/rosidl_generator_java/msg/Float64.msg deleted file mode 100644 index d6efd991..00000000 --- a/rosidl_generator_java/msg/Float64.msg +++ /dev/null @@ -1 +0,0 @@ -float64 empty_float64 diff --git a/rosidl_generator_java/msg/Int16.msg b/rosidl_generator_java/msg/Int16.msg deleted file mode 100644 index 14426ca1..00000000 --- a/rosidl_generator_java/msg/Int16.msg +++ /dev/null @@ -1 +0,0 @@ -int16 empty_int16 diff --git a/rosidl_generator_java/msg/Int32.msg b/rosidl_generator_java/msg/Int32.msg deleted file mode 100644 index 51c88f0e..00000000 --- a/rosidl_generator_java/msg/Int32.msg +++ /dev/null @@ -1 +0,0 @@ -int32 empty_int32 diff --git a/rosidl_generator_java/msg/Int64.msg b/rosidl_generator_java/msg/Int64.msg deleted file mode 100644 index 75a1c238..00000000 --- a/rosidl_generator_java/msg/Int64.msg +++ /dev/null @@ -1 +0,0 @@ -int64 empty_int64 diff --git a/rosidl_generator_java/msg/Int8.msg b/rosidl_generator_java/msg/Int8.msg deleted file mode 100644 index 76167eb9..00000000 --- a/rosidl_generator_java/msg/Int8.msg +++ /dev/null @@ -1 +0,0 @@ -int8 empty_int8 diff --git a/rosidl_generator_java/msg/Nested.msg b/rosidl_generator_java/msg/Nested.msg deleted file mode 100644 index a7386b58..00000000 --- a/rosidl_generator_java/msg/Nested.msg +++ /dev/null @@ -1,6 +0,0 @@ -uint8 ANSWER=42 - -Primitives primitives -Primitives[2] two_primitives -Primitives[<=3] up_to_three_primitives -Primitives[] unbounded_primitives diff --git a/rosidl_generator_java/msg/Primitives.msg b/rosidl_generator_java/msg/Primitives.msg deleted file mode 100644 index ec13f6ad..00000000 --- a/rosidl_generator_java/msg/Primitives.msg +++ /dev/null @@ -1,18 +0,0 @@ -bool bool_value true -byte byte_value -char char_value -float32 float32_value 1.125 -float64 float64_value -int8 int8_value -5 -uint8 uint8_value 23 -int16 int16_value -uint16 uint16_value -int32 int32_value -uint32 uint32_value -int64 int64_value -uint64 uint64_value -string string_value -string string_value_with_default 'default' -#string<=5[3] fixed_length_string_value -#string<=5[<=10] upper_bound_string_value -string unbound_string_value diff --git a/rosidl_generator_java/msg/Strings.msg b/rosidl_generator_java/msg/Strings.msg deleted file mode 100644 index f81e029b..00000000 --- a/rosidl_generator_java/msg/Strings.msg +++ /dev/null @@ -1,4 +0,0 @@ -string empty_string -string def_string "Hello world!" -string<=22 ub_string -string<=22 ub_def_string "Upper bounded string." diff --git a/rosidl_generator_java/msg/Uint16.msg b/rosidl_generator_java/msg/Uint16.msg deleted file mode 100644 index 9dd741c4..00000000 --- a/rosidl_generator_java/msg/Uint16.msg +++ /dev/null @@ -1 +0,0 @@ -uint16 empty_uint16 diff --git a/rosidl_generator_java/msg/Uint32.msg b/rosidl_generator_java/msg/Uint32.msg deleted file mode 100644 index cb65d083..00000000 --- a/rosidl_generator_java/msg/Uint32.msg +++ /dev/null @@ -1 +0,0 @@ -uint32 empty_uint32 diff --git a/rosidl_generator_java/msg/Uint64.msg b/rosidl_generator_java/msg/Uint64.msg deleted file mode 100644 index 9e7c0f80..00000000 --- a/rosidl_generator_java/msg/Uint64.msg +++ /dev/null @@ -1 +0,0 @@ -uint64 empty_uint64 diff --git a/rosidl_generator_java/msg/Uint8.msg b/rosidl_generator_java/msg/Uint8.msg deleted file mode 100644 index 6b0876e0..00000000 --- a/rosidl_generator_java/msg/Uint8.msg +++ /dev/null @@ -1 +0,0 @@ -uint8 empty_uint8 diff --git a/rosidl_generator_java/msg/Various.msg b/rosidl_generator_java/msg/Various.msg deleted file mode 100644 index efe284ae..00000000 --- a/rosidl_generator_java/msg/Various.msg +++ /dev/null @@ -1,23 +0,0 @@ -bool bool_value false -byte byte_value 1 -char char_value 1 -float32 float32_value 1.23 -float64 float64_value -int8 int8_value -5 -uint16[2] two_uint16_value [5, 23] -int32[<=3] up_to_three_int32_values -int32[<=3] up_to_three_int32_values_with_default_values [5, 23] -uint64[] unbounded_uint64_values - -#string[2] two_string_value ['foo', 'bar'] -string[<=3] up_to_three_string_values -string[] unbounded_string_values - -Empty empty -Empty[2] two_empty -Empty[] unbounded_empty - -Nested nested -Nested[2] two_nested -Nested[<=3] up_to_three_nested -Nested[] unbounded_nested diff --git a/rosidl_generator_java/src/test/java/org/ros2/generator/InterfacesTest.java b/rosidl_generator_java/src/test/java/org/ros2/generator/InterfacesTest.java index d1b0fada..dfea4a97 100644 --- a/rosidl_generator_java/src/test/java/org/ros2/generator/InterfacesTest.java +++ b/rosidl_generator_java/src/test/java/org/ros2/generator/InterfacesTest.java @@ -17,8 +17,9 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import java.util.concurrent.Callable; import java.util.Arrays; import java.util.List; import org.junit.BeforeClass; @@ -34,61 +35,18 @@ public static void setupOnce() { @Rule public ExpectedException thrown = ExpectedException.none(); - @Test - public final void testBool() { - boolean expected1 = false; - rosidl_generator_java.msg.Bool boolOne = new rosidl_generator_java.msg.Bool(); - boolOne.setEmptyBool(expected1); - assertEquals(expected1, boolOne.getEmptyBool()); - - boolean expected2 = true; - rosidl_generator_java.msg.Bool boolTwo = new rosidl_generator_java.msg.Bool(); - boolTwo.setEmptyBool(expected2); - assertEquals(expected2, boolTwo.getEmptyBool()); - - boolOne.setEmptyBool(expected2); - assertEquals(expected2, boolOne.getEmptyBool()); - } - - @Test - public final void testByte() { - byte expected1 = 123; - rosidl_generator_java.msg.Byte byteOne = new rosidl_generator_java.msg.Byte(); - byteOne.setEmptyByte(expected1); - assertEquals(expected1, byteOne.getEmptyByte()); - - byte expected2 = -42; - rosidl_generator_java.msg.Byte byteTwo = new rosidl_generator_java.msg.Byte(); - byteTwo.setEmptyByte(expected2); - assertEquals(expected2, byteTwo.getEmptyByte()); - - byteOne.setEmptyByte(expected2); - assertEquals(expected2, byteOne.getEmptyByte()); - } - - @Test - public final void testChar() { - byte expected1 = 'a'; - rosidl_generator_java.msg.Char charOne = new rosidl_generator_java.msg.Char(); - charOne.setEmptyChar(expected1); - assertEquals(expected1, charOne.getEmptyChar()); - - byte expected2 = 'b'; - rosidl_generator_java.msg.Char charTwo = new rosidl_generator_java.msg.Char(); - charTwo.setEmptyChar(expected2); - assertEquals(expected2, charTwo.getEmptyChar()); - - charOne.setEmptyChar(expected2); - assertEquals(expected2, charOne.getEmptyChar()); - } - - @Test - public final void testConstants() { - assertEquals(123, rosidl_generator_java.msg.Constants.X); - assertEquals(-123, rosidl_generator_java.msg.Constants.Y); - assertEquals("foo", rosidl_generator_java.msg.Constants.FOO); - assertEquals('\u007f', rosidl_generator_java.msg.Constants.TOTO); - assertEquals(48, rosidl_generator_java.msg.Constants.TATA); + // TODO(jacobperron): Replace with JUnit's assertThrows method when we switch to JUnit 5 + // See: https://junit.org/junit5/docs/5.0.1/api/org/junit/jupiter/api/Assertions.html + private static void assertThrows(Class expectedException, Callable func) { + try { + func.call(); + } + catch(Exception exception) { + if (expectedException.isInstance(exception)) { + return; + } + } + assertTrue("Callable did not throw the expected exception", false); } @Test @@ -98,232 +56,480 @@ public final void testEmpty() { } @Test - public final void testFloat32() { - float expected1 = 12.34f; - rosidl_generator_java.msg.Float32 float32One = new rosidl_generator_java.msg.Float32(); - float32One.setEmptyFloat32(expected1); - assertEquals(expected1, float32One.getEmptyFloat32(), 0.01); - - float expected2 = -43.21f; - rosidl_generator_java.msg.Float32 float32Two = new rosidl_generator_java.msg.Float32(); - float32Two.setEmptyFloat32(expected2); - assertEquals(expected2, float32Two.getEmptyFloat32(), 0.01); - - float32One.setEmptyFloat32(expected2); - assertEquals(expected2, float32One.getEmptyFloat32(), 0.01); - } - - @Test - public final void testFloat64() { - double expected1 = 12.34; - rosidl_generator_java.msg.Float64 float64One = new rosidl_generator_java.msg.Float64(); - float64One.setEmptyFloat64(expected1); - assertEquals(expected1, float64One.getEmptyFloat64(), 0.01); - - double expected2 = -43.21; - rosidl_generator_java.msg.Float64 float64Two = new rosidl_generator_java.msg.Float64(); - float64Two.setEmptyFloat64(expected2); - assertEquals(expected2, float64Two.getEmptyFloat64(), 0.01); - - float64One.setEmptyFloat64(expected2); - assertEquals(expected2, float64One.getEmptyFloat64(), 0.01); - } - - @Test - public final void testInt8() { - byte expected1 = 123; - rosidl_generator_java.msg.Int8 byteOne = new rosidl_generator_java.msg.Int8(); - byteOne.setEmptyInt8(expected1); - assertEquals(expected1, byteOne.getEmptyInt8()); - - byte expected2 = -42; - rosidl_generator_java.msg.Int8 byteTwo = new rosidl_generator_java.msg.Int8(); - byteTwo.setEmptyInt8(expected2); - assertEquals(expected2, byteTwo.getEmptyInt8()); - - byteOne.setEmptyInt8(expected2); - assertEquals(expected2, byteOne.getEmptyInt8()); - } - - @Test - public final void testInt16() { - short expected1 = 1230; - rosidl_generator_java.msg.Int16 shortOne = new rosidl_generator_java.msg.Int16(); - shortOne.setEmptyInt16(expected1); - assertEquals(expected1, shortOne.getEmptyInt16()); - - short expected2 = -420; - rosidl_generator_java.msg.Int16 shortTwo = new rosidl_generator_java.msg.Int16(); - shortTwo.setEmptyInt16(expected2); - assertEquals(expected2, shortTwo.getEmptyInt16()); - - shortOne.setEmptyInt16(expected2); - assertEquals(expected2, shortOne.getEmptyInt16()); + public final void testBasicTypes() { + // Test setting/getting positive values + rosidl_generator_java.msg.BasicTypes basicTypesOne = new rosidl_generator_java.msg.BasicTypes(); + boolean expectedBool1 = true; + basicTypesOne.setBoolValue(expectedBool1); + byte expectedByte1 = 123; + basicTypesOne.setByteValue(expectedByte1); + byte expectedChar1 = 'a'; + basicTypesOne.setCharValue(expectedChar1); + float expectedFloat1 = 12.34f; + basicTypesOne.setFloat32Value(expectedFloat1); + double expectedDouble1 = 12.34; + basicTypesOne.setFloat64Value(expectedDouble1); + byte expectedInt81 = 123; + basicTypesOne.setInt8Value(expectedInt81); + short expectedInt161 = 1230; + basicTypesOne.setInt16Value(expectedInt161); + int expectedInt321 = 123000; + basicTypesOne.setInt32Value(expectedInt321); + long expectedInt641 = 42949672960L; + basicTypesOne.setInt64Value(expectedInt641); + + assertEquals(expectedBool1, basicTypesOne.getBoolValue()); + assertEquals(expectedByte1, basicTypesOne.getByteValue()); + assertEquals(expectedChar1, basicTypesOne.getCharValue()); + assertEquals(expectedFloat1, basicTypesOne.getFloat32Value(), 0.01f); + assertEquals(expectedDouble1, basicTypesOne.getFloat64Value(), 0.01); + assertEquals(expectedInt81, basicTypesOne.getInt8Value()); + assertEquals(expectedInt161, basicTypesOne.getInt16Value()); + assertEquals(expectedInt321, basicTypesOne.getInt32Value()); + assertEquals(expectedInt641, basicTypesOne.getInt64Value()); + + // Test setting/getting negative values + rosidl_generator_java.msg.BasicTypes basicTypesTwo = new rosidl_generator_java.msg.BasicTypes(); + boolean expectedBool2 = false; + basicTypesTwo.setBoolValue(expectedBool2); + byte expectedByte2 = -42; + basicTypesTwo.setByteValue(expectedByte2); + byte expectedChar2 = ' '; + basicTypesTwo.setCharValue(expectedChar2); + float expectedFloat2 = -43.21f; + basicTypesTwo.setFloat32Value(expectedFloat2); + double expectedDouble2 = -43.21; + basicTypesTwo.setFloat64Value(expectedDouble2); + byte expectedInt82 = -42; + basicTypesTwo.setInt8Value(expectedInt82); + short expectedInt162 = -420; + basicTypesTwo.setInt16Value(expectedInt162); + int expectedInt322 = -42000; + basicTypesTwo.setInt32Value(expectedInt322); + long expectedInt642 = -4200000L; + basicTypesTwo.setInt64Value(expectedInt642); + + assertEquals(expectedBool2, basicTypesTwo.getBoolValue()); + assertEquals(expectedByte2, basicTypesTwo.getByteValue()); + assertEquals(expectedChar2, basicTypesTwo.getCharValue()); + assertEquals(expectedFloat2, basicTypesTwo.getFloat32Value(), 0.01f); + assertEquals(expectedDouble2, basicTypesTwo.getFloat64Value(), 0.01); + assertEquals(expectedInt82, basicTypesTwo.getInt8Value()); + assertEquals(expectedInt162, basicTypesTwo.getInt16Value()); + assertEquals(expectedInt322, basicTypesTwo.getInt32Value()); + assertEquals(expectedInt642, basicTypesTwo.getInt64Value()); } @Test - public final void testInt32() { - int expected1 = 123000; - rosidl_generator_java.msg.Int32 intOne = new rosidl_generator_java.msg.Int32(); - intOne.setEmptyInt32(expected1); - assertEquals(expected1, intOne.getEmptyInt32()); - - int expected2 = -42000; - rosidl_generator_java.msg.Int32 intTwo = new rosidl_generator_java.msg.Int32(); - intTwo.setEmptyInt32(expected2); - assertEquals(expected2, intTwo.getEmptyInt32()); - - intOne.setEmptyInt32(expected2); - assertEquals(expected2, intOne.getEmptyInt32()); - } - - @Test - public final void testInt64() { - long expected1 = 42949672960L; - rosidl_generator_java.msg.Int64 longOne = new rosidl_generator_java.msg.Int64(); - longOne.setEmptyInt64(expected1); - assertEquals(expected1, longOne.getEmptyInt64()); - - long expected2 = -4200000L; - rosidl_generator_java.msg.Int64 longTwo = new rosidl_generator_java.msg.Int64(); - longTwo.setEmptyInt64(expected2); - assertEquals(expected2, longTwo.getEmptyInt64()); - - longOne.setEmptyInt64(expected2); - assertEquals(expected2, longOne.getEmptyInt64()); + public final void testConstants() { + assertEquals(true, rosidl_generator_java.msg.Constants.BOOL_CONST); + assertEquals(50, rosidl_generator_java.msg.Constants.BYTE_CONST); + assertEquals(100, rosidl_generator_java.msg.Constants.CHAR_CONST); + assertEquals(1.125f, rosidl_generator_java.msg.Constants.FLOAT32_CONST, 0.01f); + assertEquals(1.125, rosidl_generator_java.msg.Constants.FLOAT64_CONST, 0.01); + assertEquals(-50, rosidl_generator_java.msg.Constants.INT8_CONST); + assertEquals((byte) 200, rosidl_generator_java.msg.Constants.UINT8_CONST); + assertEquals(-1000, rosidl_generator_java.msg.Constants.INT16_CONST); + assertEquals(2000, rosidl_generator_java.msg.Constants.UINT16_CONST); + assertEquals(-30000, rosidl_generator_java.msg.Constants.INT32_CONST); + assertEquals(60000, rosidl_generator_java.msg.Constants.UINT32_CONST); + assertEquals(-40000000, rosidl_generator_java.msg.Constants.INT64_CONST); + assertEquals(50000000, rosidl_generator_java.msg.Constants.UINT64_CONST); + + assertEquals("Hello world!", rosidl_generator_java.msg.Strings.STRING_CONST); } @Test public final void testDefaultValues() { - rosidl_generator_java.msg.Strings a = new rosidl_generator_java.msg.Strings(); - - assertEquals("", a.getEmptyString()); - assertEquals("Hello world!", a.getDefString()); - a.setDefString("Bye world"); - assertEquals("Bye world", a.getDefString()); - - rosidl_generator_java.msg.Various b = new rosidl_generator_java.msg.Various(); - assertEquals(Arrays.asList(new Short[] {5, 23}), b.getTwoUint16Value()); - assertEquals( - Arrays.asList(new Integer[] {5, 23}), b.getUpToThreeInt32ValuesWithDefaultValues()); - - assertEquals('\u0001', b.getCharValue()); - assertNotEquals('1', b.getCharValue()); - assertEquals((byte) '\u0001', b.getByteValue()); - assertNotEquals((byte) '1', b.getByteValue()); + rosidl_generator_java.msg.Defaults defaults = new rosidl_generator_java.msg.Defaults(); + assertEquals(true, defaults.getBoolValue()); + assertEquals(50, defaults.getByteValue()); + assertEquals(100, defaults.getCharValue()); + assertEquals(1.125f, defaults.getFloat32Value(), 0.01f); + assertEquals(1.125, defaults.getFloat64Value(), 0.01); + assertEquals(-50, defaults.getInt8Value()); + assertEquals((byte) 200, defaults.getUint8Value()); + assertEquals(-1000, defaults.getInt16Value()); + assertEquals(2000, defaults.getUint16Value()); + assertEquals(-30000, defaults.getInt32Value()); + assertEquals(60000, defaults.getUint32Value()); + assertEquals(-40000000, defaults.getInt64Value()); + assertEquals(50000000, defaults.getUint64Value()); + + rosidl_generator_java.msg.Strings strings = new rosidl_generator_java.msg.Strings(); + assertEquals("Hello world!", strings.getStringValueDefault1()); + assertEquals("Hello'world!", strings.getStringValueDefault2()); + assertEquals("Hello\"world!", strings.getStringValueDefault3()); + assertEquals("Hello'world!", strings.getStringValueDefault4()); + assertEquals("Hello\"world!", strings.getStringValueDefault5()); + assertEquals("Hello world!", strings.getBoundedStringValueDefault1()); + assertEquals("Hello'world!", strings.getBoundedStringValueDefault2()); + assertEquals("Hello\"world!", strings.getBoundedStringValueDefault3()); + assertEquals("Hello'world!", strings.getBoundedStringValueDefault4()); + assertEquals("Hello\"world!", strings.getBoundedStringValueDefault5()); } @Test public final void testCheckStringConstraints() { - rosidl_generator_java.msg.Strings a = new rosidl_generator_java.msg.Strings(); - a.setEmptyString("test"); - assertEquals("test", a.getEmptyString()); + rosidl_generator_java.msg.Strings strings = new rosidl_generator_java.msg.Strings(); + strings.setStringValue("test"); + assertEquals("test", strings.getStringValue()); char[] chars22 = new char[22]; Arrays.fill(chars22, 'a'); String chars22String = new String(chars22); - a.setUbString(chars22String); - assertEquals(chars22String, a.getUbString()); + strings.setBoundedStringValue(chars22String); + assertEquals(chars22String, strings.getBoundedStringValue()); char[] chars23 = new char[23]; Arrays.fill(chars23, 'a'); String chars23String = new String(chars23); thrown.expect(IllegalArgumentException.class); - a.setUbString(chars23String); + strings.setBoundedStringValue(chars23String); } @Test - public final void testCheckFixedArrayConstraints() { - rosidl_generator_java.msg.Nested b = new rosidl_generator_java.msg.Nested(); - rosidl_generator_java.msg.Primitives primitives = new rosidl_generator_java.msg.Primitives(); - b.setPrimitives(primitives); - assertEquals(primitives, b.getPrimitives()); - - List listOfPrimitives = - Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives, primitives}); - b.setTwoPrimitives(listOfPrimitives); - assertEquals(listOfPrimitives, b.getTwoPrimitives()); - - thrown.expect(IllegalArgumentException.class); - b.setTwoPrimitives(Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives})); + public final void testArrays() { + rosidl_generator_java.msg.Arrays arrays = new rosidl_generator_java.msg.Arrays(); + + // This value should not change and is asserted at end of test + arrays.setAlignmentCheck(42); + + // Test setting/getting fixed length arrays of primitive types + List boolList = Arrays.asList(true, false, true); + arrays.setBoolValues(boolList); + assertEquals(boolList, arrays.getBoolValues()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setBoolValues(Arrays.asList(true, false, true, false))); + List byteList = Arrays.asList((byte) 0, (byte) 1, (byte) 255); + arrays.setByteValues(byteList); + assertEquals(byteList, arrays.getByteValues()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setByteValues(Arrays.asList((byte) 1, (byte) 2))); + List charList = Arrays.asList(' ', 'a', 'Z'); + arrays.setCharValues(charList); + assertEquals(charList, arrays.getCharValues()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setCharValues(Arrays.asList((byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd'))); + List float32List = Arrays.asList(0.0f, -1.125f, 1.125f); + arrays.setFloat32Values(float32List); + assertEquals(float32List, arrays.getFloat32Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setFloat32Values(Arrays.asList(1.0f, 2.0f))); + List float64List = Arrays.asList(0.0f, -3.1415, 3.1415); + arrays.setFloat64Values(float64List); + assertEquals(float64List, arrays.getFloat64Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setFloat64Values(Arrays.asList(1.0, 2.0, 3.0, 4.0))); + List int8List = Arrays.asList(0, -128, 127); + arrays.setInt8Values(int8List); + assertEquals(int8List, arrays.getInt8Values()); + assertThrows(IllegalArgumentException.class, + () ->arrays.setInt8Values(Arrays.asList((byte) 1, (byte) 2))); + List uint8List = Arrays.asList(0, 1, 255); + arrays.setUint8Values(uint8List); + assertEquals(uint8List, arrays.getUint8Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setUint8Values(Arrays.asList((byte) 1, (byte) 2, (byte) 3, (byte) 4))); + List int16List = Arrays.asList(0, -32768, 32767); + arrays.setInt16Values(int16List); + assertEquals(int16List, arrays.getInt16Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setInt16Values(Arrays.asList((short) 1, (short) 2))); + List uint16List = Arrays.asList(0, 1, 65535); + arrays.setUint16Values(uint16List); + assertEquals(uint16List, arrays.getUint16Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setUint16Values(Arrays.asList((short) 1, (short) 2, (short) 3, (short) 4))); + List int32List = Arrays.asList(0, -2147483648, 2147483647); + arrays.setInt32Values(int32List); + assertEquals(int32List, arrays.getInt32Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setInt32Values(Arrays.asList(1, 2))); + List uint32List = Arrays.asList(0, 1, 4294967295L); + arrays.setUint32Values(uint32List); + assertEquals(uint32List, arrays.getUint32Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setUint32Values(Arrays.asList(1, 2, 3, 4))); + List int64List = Arrays.asList(0, -9223372036854775808L, 9223372036854775807L); + arrays.setInt64Values(int64List); + assertEquals(int64List, arrays.getInt64Values()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setInt64Values(Arrays.asList(1L, 2L))); + List uint64List = Arrays.asList(0, 1, -1); + arrays.setUint64Values(uint64List); + assertEquals(uint64List, arrays.getUint64Values()); + assertThrows(IllegalArgumentException.class, + () ->arrays.setUint64Values(Arrays.asList(1L, 2L, 3L, 4L))); + + // Test setting/getting fixed length arrays of strings + List stringList = Arrays.asList("", "min value", "max_value"); + arrays.setStringValues(stringList); + assertEquals(stringList, arrays.getStringValues()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setStringValues(Arrays.asList("too", "few"))); + + // Test setting/getting fixed length arrays of nested types + rosidl_generator_java.msg.BasicTypes basicTypes = new rosidl_generator_java.msg.BasicTypes(); + List basicTypesList = Arrays.asList( + new rosidl_generator_java.msg.BasicTypes[] {basicTypes, basicTypes, basicTypes}); + arrays.setBasicTypesValues(basicTypesList); + assertEquals(basicTypesList, arrays.getBasicTypesValues()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setBasicTypesValues(Arrays.asList(new rosidl_generator_java.msg.BasicTypes[] {basicTypes}))); + rosidl_generator_java.msg.Constants constants = new rosidl_generator_java.msg.Constants(); + List constantsList = Arrays.asList( + new rosidl_generator_java.msg.Constants[] {constants, constants, constants}); + arrays.setConstantsValues(constantsList); + assertEquals(constantsList, arrays.getConstantsValues()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setConstantsValues(Arrays.asList(new rosidl_generator_java.msg.Constants[] {constants}))); + rosidl_generator_java.msg.Defaults defaults = new rosidl_generator_java.msg.Defaults(); + List defaultsList = Arrays.asList( + new rosidl_generator_java.msg.Defaults[] {defaults, defaults, defaults}); + arrays.setDefaultsValues(defaultsList); + assertEquals(defaultsList, arrays.getDefaultsValues()); + assertThrows(IllegalArgumentException.class, + () -> arrays.setDefaultsValues(Arrays.asList(new rosidl_generator_java.msg.Defaults[] {defaults}))); + + assertEquals(42, arrays.getAlignmentCheck()); } @Test - public final void testCheckUpperboundArrayConstraints() { - rosidl_generator_java.msg.Nested b = new rosidl_generator_java.msg.Nested(); - rosidl_generator_java.msg.Primitives primitives = new rosidl_generator_java.msg.Primitives(); - b.setUpToThreePrimitives(Arrays.asList(new rosidl_generator_java.msg.Primitives[] {})); - assertEquals( - Arrays.asList(new rosidl_generator_java.msg.Primitives[] {}), b.getUpToThreePrimitives()); - b.setUpToThreePrimitives( - Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives})); - assertEquals(Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives}), - b.getUpToThreePrimitives()); - b.setUpToThreePrimitives( - Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives, primitives})); - assertEquals(Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives, primitives}), - b.getUpToThreePrimitives()); - b.setUpToThreePrimitives(Arrays.asList( - new rosidl_generator_java.msg.Primitives[] {primitives, primitives, primitives})); - assertEquals(Arrays.asList(new rosidl_generator_java.msg.Primitives[] { - primitives, primitives, primitives}), - b.getUpToThreePrimitives()); - - thrown.expect(IllegalArgumentException.class); - b.setUpToThreePrimitives(Arrays.asList(new rosidl_generator_java.msg.Primitives[] { - primitives, primitives, primitives, primitives})); + public final void testBoundedSequences() { + rosidl_generator_java.msg.BoundedSequences bounded_seq = new rosidl_generator_java.msg.BoundedSequences(); + + // This value should not change and is asserted at end of test + bounded_seq.setAlignmentCheck(42); + + // Test setting/getting fixed length bounded_seq of primitive types + List boolList = Arrays.asList(true, false, true); + bounded_seq.setBoolValues(boolList); + assertEquals(boolList, bounded_seq.getBoolValues()); + List boolListShort = Arrays.asList(false); + bounded_seq.setBoolValues(boolListShort); + assertEquals(boolListShort, bounded_seq.getBoolValues()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setBoolValues(Arrays.asList(true, false, true, false))); + List byteList = Arrays.asList((byte) 0, (byte) 1, (byte) 255); + bounded_seq.setByteValues(byteList); + assertEquals(byteList, bounded_seq.getByteValues()); + List byteListShort = Arrays.asList((byte) 1); + bounded_seq.setByteValues(byteListShort); + assertEquals(byteListShort, bounded_seq.getByteValues()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setByteValues(Arrays.asList((byte) 1, (byte) 2, (byte) 3, (byte) 4))); + List charList = Arrays.asList(' ', 'a', 'Z'); + bounded_seq.setCharValues(charList); + assertEquals(charList, bounded_seq.getCharValues()); + List charListShort = Arrays.asList('z', 'A'); + bounded_seq.setCharValues(charListShort); + assertEquals(charListShort, bounded_seq.getCharValues()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setCharValues(Arrays.asList((byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd'))); + List float32List = Arrays.asList(0.0f, -1.125f, 1.125f); + bounded_seq.setFloat32Values(float32List); + assertEquals(float32List, bounded_seq.getFloat32Values()); + List float32ListShort = Arrays.asList(1.125f, -1.125f); + bounded_seq.setFloat32Values(float32ListShort); + assertEquals(float32ListShort, bounded_seq.getFloat32Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setFloat32Values(Arrays.asList(1.0f, 2.0f, 3.0f, 4.0f))); + List float64List = Arrays.asList(0.0f, -3.1415, 3.1415); + bounded_seq.setFloat64Values(float64List); + assertEquals(float64List, bounded_seq.getFloat64Values()); + List float64ListShort = Arrays.asList(3.1415, -3.1415); + bounded_seq.setFloat64Values(float64ListShort); + assertEquals(float64ListShort, bounded_seq.getFloat64Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setFloat64Values(Arrays.asList(1.0, 2.0, 3.0, 4.0))); + List int8List = Arrays.asList(0, -128, 127); + bounded_seq.setInt8Values(int8List); + assertEquals(int8List, bounded_seq.getInt8Values()); + List int8ListShort = Arrays.asList(127, -128); + bounded_seq.setInt8Values(int8ListShort); + assertEquals(int8ListShort, bounded_seq.getInt8Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setInt8Values(Arrays.asList((byte) 1, (byte) 2, (byte) 3, (byte) 4))); + List uint8List = Arrays.asList(0, 1, 255); + bounded_seq.setUint8Values(uint8List); + assertEquals(uint8List, bounded_seq.getUint8Values()); + List uint8ListShort = Arrays.asList(255, 1); + bounded_seq.setUint8Values(uint8ListShort); + assertEquals(uint8ListShort, bounded_seq.getUint8Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setUint8Values(Arrays.asList((byte) 1, (byte) 2, (byte) 3, (byte) 4))); + List int16List = Arrays.asList(0, -32768, 32767); + bounded_seq.setInt16Values(int16List); + assertEquals(int16List, bounded_seq.getInt16Values()); + List int16ListShort = Arrays.asList(32767, -32768); + bounded_seq.setInt16Values(int16ListShort); + assertEquals(int16ListShort, bounded_seq.getInt16Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setInt16Values(Arrays.asList((short) 1, (short) 2, (short) 3, (short) 4))); + List uint16List = Arrays.asList(0, 1, 65535); + bounded_seq.setUint16Values(uint16List); + assertEquals(uint16List, bounded_seq.getUint16Values()); + List uint16ListShort = Arrays.asList(0, 1, 65535); + bounded_seq.setUint16Values(uint16ListShort); + assertEquals(uint16ListShort, bounded_seq.getUint16Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setUint16Values(Arrays.asList((short) 1, (short) 2, (short) 3, (short) 4))); + List int32List = Arrays.asList(0, -2147483648, 2147483647); + bounded_seq.setInt32Values(int32List); + assertEquals(int32List, bounded_seq.getInt32Values()); + List int32ListShort = Arrays.asList(2147483647, -2147483648); + bounded_seq.setInt32Values(int32ListShort); + assertEquals(int32ListShort, bounded_seq.getInt32Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setInt32Values(Arrays.asList(1, 2, 3, 4))); + List uint32List = Arrays.asList(0, 1, 4294967295L); + bounded_seq.setUint32Values(uint32List); + assertEquals(uint32List, bounded_seq.getUint32Values()); + List uint32ListShort = Arrays.asList(4294967295L, 1); + bounded_seq.setUint32Values(uint32ListShort); + assertEquals(uint32ListShort, bounded_seq.getUint32Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setUint32Values(Arrays.asList(1, 2, 3, 4))); + List int64List = Arrays.asList(0, -9223372036854775808L, 9223372036854775807L); + bounded_seq.setInt64Values(int64List); + assertEquals(int64List, bounded_seq.getInt64Values()); + List int64ListShort = Arrays.asList(0, -9223372036854775808L, 9223372036854775807L); + bounded_seq.setInt64Values(int64ListShort); + assertEquals(int64ListShort, bounded_seq.getInt64Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setInt64Values(Arrays.asList(1L, 2L, 3L, 4L))); + List uint64List = Arrays.asList(0, 1, -1); + bounded_seq.setUint64Values(uint64List); + assertEquals(uint64List, bounded_seq.getUint64Values()); + List uint64ListShort = Arrays.asList(0, 1, -1); + bounded_seq.setUint64Values(uint64ListShort); + assertEquals(uint64ListShort, bounded_seq.getUint64Values()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setUint64Values(Arrays.asList(1L, 2L, 3L, 4L))); + + // Test setting/getting fixed length bounded_seq of strings + List stringList = Arrays.asList("", "min value", "max_value"); + bounded_seq.setStringValues(stringList); + assertEquals(stringList, bounded_seq.getStringValues()); + List stringListShort = Arrays.asList("max_value", ""); + bounded_seq.setStringValues(stringListShort); + assertEquals(stringListShort, bounded_seq.getStringValues()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setStringValues(Arrays.asList("too", "many", "values", "!"))); + + // Test setting/getting fixed length bounded_seq of nested types + rosidl_generator_java.msg.BasicTypes basicTypes = new rosidl_generator_java.msg.BasicTypes(); + List basicTypesList = Arrays.asList( + new rosidl_generator_java.msg.BasicTypes[] {basicTypes, basicTypes, basicTypes}); + bounded_seq.setBasicTypesValues(basicTypesList); + assertEquals(basicTypesList, bounded_seq.getBasicTypesValues()); + List basicTypesListShort = Arrays.asList( + new rosidl_generator_java.msg.BasicTypes[] {basicTypes}); + bounded_seq.setBasicTypesValues(basicTypesListShort); + assertEquals(basicTypesListShort, bounded_seq.getBasicTypesValues()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setBasicTypesValues( + Arrays.asList(new rosidl_generator_java.msg.BasicTypes[] {basicTypes, basicTypes, basicTypes, basicTypes}))); + rosidl_generator_java.msg.Constants constants = new rosidl_generator_java.msg.Constants(); + List constantsList = Arrays.asList( + new rosidl_generator_java.msg.Constants[] {constants, constants, constants}); + bounded_seq.setConstantsValues(constantsList); + assertEquals(constantsList, bounded_seq.getConstantsValues()); + List constantsListShort = Arrays.asList( + new rosidl_generator_java.msg.Constants[] {constants}); + bounded_seq.setConstantsValues(constantsListShort); + assertEquals(constantsListShort, bounded_seq.getConstantsValues()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setConstantsValues( + Arrays.asList(new rosidl_generator_java.msg.Constants[] {constants, constants, constants, constants}))); + rosidl_generator_java.msg.Defaults defaults = new rosidl_generator_java.msg.Defaults(); + List defaultsList = Arrays.asList( + new rosidl_generator_java.msg.Defaults[] {defaults, defaults, defaults}); + bounded_seq.setDefaultsValues(defaultsList); + assertEquals(defaultsList, bounded_seq.getDefaultsValues()); + List defaultsListShort = Arrays.asList( + new rosidl_generator_java.msg.Defaults[] {defaults, defaults, defaults}); + bounded_seq.setDefaultsValues(defaultsListShort); + assertEquals(defaultsListShort, bounded_seq.getDefaultsValues()); + assertThrows(IllegalArgumentException.class, + () -> bounded_seq.setDefaultsValues( + Arrays.asList(new rosidl_generator_java.msg.Defaults[] {defaults, defaults, defaults, defaults}))); + + assertEquals(42, bounded_seq.getAlignmentCheck()); } @Test - public final void testCheckUnboundedArrays() { - rosidl_generator_java.msg.Nested b = new rosidl_generator_java.msg.Nested(); - rosidl_generator_java.msg.Primitives primitives = new rosidl_generator_java.msg.Primitives(); - b.setUnboundedPrimitives( - Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives, primitives})); - assertEquals(Arrays.asList(new rosidl_generator_java.msg.Primitives[] {primitives, primitives}), - b.getUnboundedPrimitives()); - } - - @Test - public final void testCheckIntArraysConstraints() { - rosidl_generator_java.msg.Various c = new rosidl_generator_java.msg.Various(); - c.setUpToThreeInt32Values(Arrays.asList(new Integer[] {})); - assertEquals(Arrays.asList(new Integer[] {}), c.getUpToThreeInt32Values()); - c.setUpToThreeInt32Values(Arrays.asList(new Integer[] {12345})); - assertEquals(Arrays.asList(new Integer[] {12345}), c.getUpToThreeInt32Values()); - c.setUpToThreeInt32Values(Arrays.asList(new Integer[] {12345, -12345})); - assertEquals(Arrays.asList(new Integer[] {12345, -12345}), c.getUpToThreeInt32Values()); - c.setUpToThreeInt32Values(Arrays.asList(new Integer[] {12345, -12345, 6789})); - assertEquals(Arrays.asList(new Integer[] {12345, -12345, 6789}), c.getUpToThreeInt32Values()); - - // Test that arrays of primitives are also accepted - c.setUpToThreeInt32Values(new int[] {}); - assertEquals(Arrays.asList(new Integer[] {}), c.getUpToThreeInt32Values()); - c.setUpToThreeInt32Values(new int[] {12345}); - assertEquals(Arrays.asList(new Integer[] {12345}), c.getUpToThreeInt32Values()); - c.setUpToThreeInt32Values(new int[] {12345, -12345}); - assertEquals(Arrays.asList(new Integer[] {12345, -12345}), c.getUpToThreeInt32Values()); - c.setUpToThreeInt32Values(new int[] {12345, -12345, 6789}); - assertEquals(Arrays.asList(new Integer[] {12345, -12345, 6789}), c.getUpToThreeInt32Values()); - - thrown.expect(IllegalArgumentException.class); - c.setUpToThreeInt32Values(Arrays.asList(new Integer[] {12345, -12345, 6789, -6789})); - } - - @Test - public final void testCheckUpperboundStringConstraints() { - rosidl_generator_java.msg.Various c = new rosidl_generator_java.msg.Various(); - c.setUpToThreeStringValues(Arrays.asList(new String[] {})); - assertEquals(Arrays.asList(new String[] {}), c.getUpToThreeStringValues()); - c.setUpToThreeStringValues(Arrays.asList(new String[] {"foo"})); - assertEquals(Arrays.asList(new String[] {"foo"}), c.getUpToThreeStringValues()); - c.setUpToThreeStringValues(Arrays.asList(new String[] {"foo", "bar"})); - assertEquals(Arrays.asList(new String[] {"foo", "bar"}), c.getUpToThreeStringValues()); - c.setUpToThreeStringValues(Arrays.asList(new String[] {"foo", "bar", "baz"})); - assertEquals(Arrays.asList(new String[] {"foo", "bar", "baz"}), c.getUpToThreeStringValues()); - - thrown.expect(IllegalArgumentException.class); - c.setUpToThreeStringValues(Arrays.asList(new String[] {"foo", "bar", "baz", "hello"})); + public final void testUnboundedSequences() { + rosidl_generator_java.msg.UnboundedSequences unbounded_seq = new rosidl_generator_java.msg.UnboundedSequences(); + + // This value should not change and is asserted at end of test + unbounded_seq.setAlignmentCheck(42); + + // Test setting/getting fixed length unbounded_seq of primitive types + List boolList = Arrays.asList(true, false, true); + unbounded_seq.setBoolValues(boolList); + assertEquals(boolList, unbounded_seq.getBoolValues()); + List byteList = Arrays.asList((byte) 0, (byte) 1, (byte) 255); + unbounded_seq.setByteValues(byteList); + assertEquals(byteList, unbounded_seq.getByteValues()); + List charList = Arrays.asList(' ', 'a', 'Z'); + unbounded_seq.setCharValues(charList); + assertEquals(charList, unbounded_seq.getCharValues()); + List float32List = Arrays.asList(0.0f, -1.125f, 1.125f); + unbounded_seq.setFloat32Values(float32List); + assertEquals(float32List, unbounded_seq.getFloat32Values()); + List float64List = Arrays.asList(0.0f, -3.1415, 3.1415); + unbounded_seq.setFloat64Values(float64List); + assertEquals(float64List, unbounded_seq.getFloat64Values()); + List int8List = Arrays.asList(0, -128, 127); + unbounded_seq.setInt8Values(int8List); + assertEquals(int8List, unbounded_seq.getInt8Values()); + List uint8List = Arrays.asList(0, 1, 255); + unbounded_seq.setUint8Values(uint8List); + assertEquals(uint8List, unbounded_seq.getUint8Values()); + List int16List = Arrays.asList(0, -32768, 32767); + unbounded_seq.setInt16Values(int16List); + assertEquals(int16List, unbounded_seq.getInt16Values()); + List uint16List = Arrays.asList(0, 1, 65535); + unbounded_seq.setUint16Values(uint16List); + assertEquals(uint16List, unbounded_seq.getUint16Values()); + List int32List = Arrays.asList(0, -2147483648, 2147483647); + unbounded_seq.setInt32Values(int32List); + assertEquals(int32List, unbounded_seq.getInt32Values()); + List uint32List = Arrays.asList(0, 1, 4294967295L); + unbounded_seq.setUint32Values(uint32List); + assertEquals(uint32List, unbounded_seq.getUint32Values()); + List int64List = Arrays.asList(0, -9223372036854775808L, 9223372036854775807L); + unbounded_seq.setInt64Values(int64List); + assertEquals(int64List, unbounded_seq.getInt64Values()); + List uint64List = Arrays.asList(0, 1, -1); + unbounded_seq.setUint64Values(uint64List); + assertEquals(uint64List, unbounded_seq.getUint64Values()); + + // Test setting/getting fixed length unbounded_seq of strings + List stringList = Arrays.asList("", "min value", "max_value"); + unbounded_seq.setStringValues(stringList); + assertEquals(stringList, unbounded_seq.getStringValues()); + + // Test setting/getting fixed length unbounded_seq of nested types + rosidl_generator_java.msg.BasicTypes basicTypes = new rosidl_generator_java.msg.BasicTypes(); + List basicTypesList = Arrays.asList( + new rosidl_generator_java.msg.BasicTypes[] {basicTypes, basicTypes, basicTypes}); + unbounded_seq.setBasicTypesValues(basicTypesList); + assertEquals(basicTypesList, unbounded_seq.getBasicTypesValues()); + rosidl_generator_java.msg.Constants constants = new rosidl_generator_java.msg.Constants(); + List constantsList = Arrays.asList( + new rosidl_generator_java.msg.Constants[] {constants, constants, constants}); + unbounded_seq.setConstantsValues(constantsList); + assertEquals(constantsList, unbounded_seq.getConstantsValues()); + rosidl_generator_java.msg.Defaults defaults = new rosidl_generator_java.msg.Defaults(); + List defaultsList = Arrays.asList( + new rosidl_generator_java.msg.Defaults[] {defaults, defaults, defaults}); + unbounded_seq.setDefaultsValues(defaultsList); + assertEquals(defaultsList, unbounded_seq.getDefaultsValues()); + + assertEquals(42, unbounded_seq.getAlignmentCheck()); } }