Skip to content

Commit 2e05913

Browse files
ejalaa12ejalaa12
authored
Fix issues when using parameters of type array (#855)
* add unit test for all conversions * handle PARAMETER_STRING_ARRAY that was not handled everywhere * fixed TypedArray issue * PARAMETER_BYTE is not defined, interpret BYTE_ARRAY as integers * fixed typo in param type
1 parent 688979b commit 2e05913

2 files changed

Lines changed: 184 additions & 7 deletions

File tree

‎lib/parameter.js‎

Lines changed: 12 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,7 @@ class Parameter {
7171
/**
7272
* Create a Parameter instance from an rlc_interfaces/msg/Parameter message.
7373
* @constructs
74-
* @param {rlc_interfaces/msg/Parameter} parameterMsg - The message to convert to a parameter.
74+
* @param {rcl_interfaces/msg/Parameter} parameterMsg - The message to convert to a parameter.
7575
* @return {Parameter} - The new instance.
7676
*/
7777
static fromParameterMessage(parameterMsg) {
@@ -89,25 +89,25 @@ class Parameter {
8989
value = parameterMsg.value.bool_array_value;
9090
break;
9191
case ParameterType.PARAMETER_BYTE_ARRAY:
92-
value = parameterMsg.value.byte_array_value;
92+
value = Array.from(parameterMsg.value.byte_array_value);
9393
break;
9494
case ParameterType.PARAMETER_DOUBLE:
9595
value = parameterMsg.value.double_value;
9696
break;
9797
case ParameterType.PARAMETER_DOUBLE_ARRAY:
98-
value = parameterMsg.value.double_array_value;
98+
value = Array.from(parameterMsg.value.double_array_value);
9999
break;
100100
case ParameterType.PARAMETER_INTEGER:
101101
value = parameterMsg.value.integer_value;
102102
break;
103103
case ParameterType.PARAMETER_INTEGER_ARRAY:
104-
value = parameterMsg.value.integer_array_value;
104+
value = Array.from(parameterMsg.value.integer_array_value);
105105
break;
106106
case ParameterType.PARAMETER_STRING:
107107
value = parameterMsg.value.string_value;
108108
break;
109109
case ParameterType.PARAMETER_STRING_ARRAY:
110-
value = parameterMsg.value.string_array_value;
110+
value = Array.from(parameterMsg.value.string_array_value);
111111
break;
112112
}
113113

@@ -771,6 +771,7 @@ function validValue(value, type) {
771771
case ParameterType.PARAMETER_BYTE_ARRAY:
772772
case ParameterType.PARAMETER_INTEGER_ARRAY:
773773
case ParameterType.PARAMETER_DOUBLE_ARRAY:
774+
case ParameterType.PARAMETER_STRING_ARRAY:
774775
const values = value;
775776
result = _validArray(values, type);
776777
break;
@@ -788,14 +789,17 @@ function _validArray(values, type) {
788789
if (type === ParameterType.PARAMETER_BOOL_ARRAY) {
789790
arrayElementType = ParameterType.PARAMETER_BOOL;
790791
} else if (type === ParameterType.PARAMETER_BYTE_ARRAY) {
791-
arrayElementType = ParameterType.PARAMETER_BYTE;
792+
arrayElementType = ParameterType.PARAMETER_INTEGER;
792793
}
793794
if (type === ParameterType.PARAMETER_INTEGER_ARRAY) {
794795
arrayElementType = ParameterType.PARAMETER_INTEGER;
795796
}
796797
if (type === ParameterType.PARAMETER_DOUBLE_ARRAY) {
797798
arrayElementType = ParameterType.PARAMETER_DOUBLE;
798799
}
800+
if (type === ParameterType.PARAMETER_STRING_ARRAY) {
801+
arrayElementType = ParameterType.PARAMETER_STRING;
802+
}
799803

800804
return values.reduce(
801805
(compatible, val) =>
@@ -811,7 +815,8 @@ function _isArrayParameterType(type) {
811815
type === ParameterType.PARAMETER_BOOL_ARRAY ||
812816
type === ParameterType.PARAMETER_BYTE_ARRAY ||
813817
type === ParameterType.PARAMETER_INTEGER_ARRAY ||
814-
type === ParameterType.PARAMETER_DOUBLE_ARRAY
818+
type === ParameterType.PARAMETER_DOUBLE_ARRAY ||
819+
type === ParameterType.PARAMETER_STRING_ARRAY
815820
);
816821
}
817822

‎test/test-parameters.js‎

Lines changed: 172 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@ const assertUtils = require('./utils.js');
1919
const assertThrowsError = assertUtils.assertThrowsError;
2020
const IsClose = require('is-close');
2121
const rclnodejs = require('../index.js');
22+
const loader = require('../lib/interface_loader.js');
2223

2324
const ParameterType = rclnodejs.ParameterType;
2425
const Parameter = rclnodejs.Parameter;
@@ -102,6 +103,177 @@ describe('rclnodejs parameters test suite', function () {
102103
});
103104
});
104105

106+
describe('convert fromParameterMessage test suite', function () {
107+
it('should convert PARAMETER_NOT_SET type', function () {
108+
let param_msg = new (loader.loadInterface(
109+
'rcl_interfaces/msg/Parameter'
110+
))();
111+
param_msg.name = 'not_set_param';
112+
param_msg.value.type = ParameterType.PARAMETER_NOT_SET;
113+
114+
let param;
115+
assert.doesNotThrow(() => {
116+
param = Parameter.fromParameterMessage(param_msg);
117+
});
118+
assert.strictEqual(param.name, 'not_set_param');
119+
assert.strictEqual(param.type, ParameterType.PARAMETER_NOT_SET);
120+
assert.strictEqual(param.value, undefined);
121+
});
122+
123+
it('should convert PARAMETER_BOOL type', function () {
124+
let param_msg = new (loader.loadInterface(
125+
'rcl_interfaces/msg/Parameter'
126+
))();
127+
param_msg.name = 'bool_param';
128+
param_msg.value.type = ParameterType.PARAMETER_BOOL;
129+
param_msg.value.bool_value = false;
130+
131+
let param;
132+
assert.doesNotThrow(() => {
133+
param = Parameter.fromParameterMessage(param_msg);
134+
});
135+
assert.strictEqual(param.name, 'bool_param');
136+
assert.strictEqual(param.type, ParameterType.PARAMETER_BOOL);
137+
assert.strictEqual(param.value, false);
138+
});
139+
140+
it('should convert PARAMETER_BOOL_ARRAY type', function () {
141+
let param_msg = new (loader.loadInterface(
142+
'rcl_interfaces/msg/Parameter'
143+
))();
144+
param_msg.name = 'bool_array_param';
145+
param_msg.value.type = ParameterType.PARAMETER_BOOL_ARRAY;
146+
param_msg.value.bool_array_value = [true, false, true];
147+
148+
let param;
149+
assert.doesNotThrow(() => {
150+
param = Parameter.fromParameterMessage(param_msg);
151+
});
152+
assert.strictEqual(param.name, 'bool_array_param');
153+
assert.strictEqual(param.type, ParameterType.PARAMETER_BOOL_ARRAY);
154+
assert.deepStrictEqual(param.value, [true, false, true]);
155+
});
156+
157+
it('should convert PARAMETER_BYTE_ARRAY type', function () {
158+
let param_msg = new (loader.loadInterface(
159+
'rcl_interfaces/msg/Parameter'
160+
))();
161+
param_msg.name = 'byte_array_param';
162+
param_msg.value.type = ParameterType.PARAMETER_BYTE_ARRAY;
163+
param_msg.value.byte_array_value = [1, 2, 3];
164+
165+
let param;
166+
assert.doesNotThrow(() => {
167+
param = Parameter.fromParameterMessage(param_msg);
168+
});
169+
assert.strictEqual(param.name, 'byte_array_param');
170+
assert.strictEqual(param.type, ParameterType.PARAMETER_BYTE_ARRAY);
171+
assert.deepStrictEqual(param.value, [1, 2, 3]);
172+
});
173+
174+
it('should convert PARAMETER_DOUBLE type', function () {
175+
let param_msg = new (loader.loadInterface(
176+
'rcl_interfaces/msg/Parameter'
177+
))();
178+
param_msg.name = 'double_param';
179+
param_msg.value.type = ParameterType.PARAMETER_DOUBLE;
180+
param_msg.value.double_value = 1.23;
181+
182+
let param;
183+
assert.doesNotThrow(() => {
184+
param = Parameter.fromParameterMessage(param_msg);
185+
});
186+
assert.strictEqual(param.name, 'double_param');
187+
assert.strictEqual(param.type, ParameterType.PARAMETER_DOUBLE);
188+
assert.strictEqual(param.value, 1.23);
189+
});
190+
191+
it('should convert PARAMETER_DOUBLE_ARRAY type', function () {
192+
let param_msg = new (loader.loadInterface(
193+
'rcl_interfaces/msg/Parameter'
194+
))();
195+
param_msg.name = 'double_array_param';
196+
param_msg.value.type = ParameterType.PARAMETER_DOUBLE_ARRAY;
197+
param_msg.value.double_array_value = [1.1, 2.2, 3.3, 4.4, 5.5];
198+
199+
let param;
200+
assert.doesNotThrow(() => {
201+
param = Parameter.fromParameterMessage(param_msg);
202+
});
203+
assert.strictEqual(param.name, 'double_array_param');
204+
assert.strictEqual(param.type, ParameterType.PARAMETER_DOUBLE_ARRAY);
205+
assert.deepStrictEqual(param.value, [1.1, 2.2, 3.3, 4.4, 5.5]);
206+
});
207+
208+
it('should convert PARAMETER_INTEGER type', function () {
209+
let param_msg = new (loader.loadInterface(
210+
'rcl_interfaces/msg/Parameter'
211+
))();
212+
param_msg.name = 'integer_param';
213+
param_msg.value.type = ParameterType.PARAMETER_INTEGER;
214+
param_msg.value.integer_value = 123;
215+
216+
let param;
217+
assert.doesNotThrow(() => {
218+
param = Parameter.fromParameterMessage(param_msg);
219+
});
220+
assert.strictEqual(param.name, 'integer_param');
221+
assert.strictEqual(param.type, ParameterType.PARAMETER_INTEGER);
222+
assert.strictEqual(param.value, 123);
223+
});
224+
225+
it('should convert PARAMETER_INTEGER_ARRAY type', function () {
226+
let param_msg = new (loader.loadInterface(
227+
'rcl_interfaces/msg/Parameter'
228+
))();
229+
param_msg.name = 'integer_array_param';
230+
param_msg.value.type = ParameterType.PARAMETER_INTEGER_ARRAY;
231+
param_msg.value.integer_array_value = [1, 2, 3, 4, 5];
232+
233+
let param;
234+
assert.doesNotThrow(() => {
235+
param = Parameter.fromParameterMessage(param_msg);
236+
});
237+
assert.strictEqual(param.name, 'integer_array_param');
238+
assert.strictEqual(param.type, ParameterType.PARAMETER_INTEGER_ARRAY);
239+
assert.deepStrictEqual(param.value, [1, 2, 3, 4, 5]);
240+
});
241+
242+
it('should convert PARAMETER_STRING type', function () {
243+
let param_msg = new (loader.loadInterface(
244+
'rcl_interfaces/msg/Parameter'
245+
))();
246+
param_msg.name = 'string_param';
247+
param_msg.value.type = ParameterType.PARAMETER_STRING;
248+
param_msg.value.string_value = 'hello world';
249+
250+
let param;
251+
assert.doesNotThrow(() => {
252+
param = Parameter.fromParameterMessage(param_msg);
253+
});
254+
assert.strictEqual(param.name, 'string_param');
255+
assert.strictEqual(param.type, ParameterType.PARAMETER_STRING);
256+
assert.strictEqual(param.value, 'hello world');
257+
});
258+
259+
it('should convert PARAMETER_STRING_ARRAY type', function () {
260+
let param_msg = new (loader.loadInterface(
261+
'rcl_interfaces/msg/Parameter'
262+
))();
263+
param_msg.name = 'string_array_param';
264+
param_msg.value.type = ParameterType.PARAMETER_STRING_ARRAY;
265+
param_msg.value.string_array_value = ['hello', 'world'];
266+
267+
let param;
268+
assert.doesNotThrow(() => {
269+
param = Parameter.fromParameterMessage(param_msg);
270+
});
271+
assert.strictEqual(param.name, 'string_array_param');
272+
assert.strictEqual(param.type, ParameterType.PARAMETER_STRING_ARRAY);
273+
assert.deepStrictEqual(param.value, ['hello', 'world']);
274+
});
275+
});
276+
105277
describe('range tests', function () {
106278
it('Math IsClose test', function () {
107279
assert.ok(IsClose.isClose(1.0, 1.0, DEFAULT_NUMERIC_RANGE_TOLERANCE));

0 commit comments

Comments
 (0)