def test_odd_spaces(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
another_struct = my_module.struct_by_name('another_struct')
m = another_struct.member_by_name('another_struct_array1')
self.assertTrue(m.type.is_array)
self.assertEqual(m.type.inner_type.name, 'double')
self.assertEqual(m.type.size, 10)
m = another_struct.member_by_name('another_struct_array2')
self.assertEqual(m.type.inner_type.name, 'short')
self.assertTrue(m.type.is_array)
self.assertEqual(m.type.size, 11)
m = another_struct.member_by_name('another_struct_array3')
self.assertEqual(m.type.inner_type.name, 'short')
self.assertTrue(m.type.is_array)
self.assertEqual(m.type.size, 44)
m = another_struct.member_by_name('another_struct_array1')
m = another_struct.member_by_name('another_struct_seq1')
self.assertEqual(m.type.inner_type.name, 'my_byte')
m = another_struct.member_by_name('another_struct_seq2')
self.assertEqual(m.type.inner_type.name, 'long')
def test_module(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
moduleA = m.modules[0]
self.assertEqual(moduleA.name, 'moduleA')
structA = moduleA.struct_by_name('StructA')
self.assertEqual(structA.name, 'StructA')
double_member = structA.member_by_name('double_value')
self.assertEqual(double_member.name, 'double_value')
moduleB = m.modules[1]
self.assertEqual(moduleB.name, 'moduleB')
structB = moduleB.struct_by_name('StructB')
self.assertEqual(structB.name, 'StructB')
double_member = structB.member_by_name('double_valueA')
self.assertEqual(double_member.name, 'double_valueA')
moduleC = m.modules[2]
self.assertEqual(moduleC.name, 'moduleC')
structC = moduleC.struct_by_name('StructC')
self.assertEqual(structC.name, 'StructC')
structA_member = structC.member_by_name('structA_value')
self.assertEqual(structA_member.name, 'structA_value')
def test_union_types(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
my_union_1 = my_module.union_by_name('my_union1')
self.assertEqual(my_union_1.basename, 'my_union1')
self.assertTrue(my_union_1.is_union)
m = my_union_1.member_by_name('ull_value')
self.assertEqual(m.type.name, 'unsigned long long')
self.assertIn('descriminator_unknown',
m.descriminator_value_associations)
self.assertIn('descriminator_kind_count',
m.descriminator_value_associations)
self.assertIn('descriminator_ulonglong',
m.descriminator_value_associations)
m = my_union_1.member_by_name('ll_value')
self.assertEqual(m.type.name, 'long long')
self.assertIn('descriminator_longlong',
m.descriminator_value_associations)
m = my_union_1.member_by_name('d_value')
self.assertEqual(m.type.name, 'double')
self.assertIn('descriminator_double',
m.descriminator_value_associations)
m = my_union_1.member_by_name('str_value')
sequence_type = IDLType(m.type.name, m.parent)
self.assertTrue(sequence_type.is_sequence)
self.assertEqual(sequence_type.inner_type.name, 'char')
self.assertIn('descriminator_string',
m.descriminator_value_associations)
pass
def test_primitive_types(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
my_struct = my_module.struct_by_name('my_struct3')
self.assertEqual(my_struct.name, 'my_struct3')
typenames = {
'octet': 'octet_member',
'unsigned long': 'ulong_member',
'char': 'char_member',
'wchar': 'wchar_member',
'string': 'string_member',
'unsigned short': 'ushort_member',
'short': 'short_member',
'unsigned long': 'ulong_member',
'float': 'float_member',
'double': 'double_member'
}
for typename, valuename in typenames.items():
m = my_struct.member_by_name(valuename)
self.assertEqual(typename, m.type.name)
self.assertTrue(m.type.is_primitive)
self.assertFalse(m.type.is_struct)
self.assertFalse(m.type.is_typedef)
self.assertFalse(m.type.is_enum)
self.assertFalse(m.type.is_interface)
self.assertFalse(m.type.is_const)
def test_parser(self):
# find files
idl_files = glob.glob(IDL_DIR + "*.idl")
for idl_path in idl_files:
print("**** Attempt to parse: " + idl_path)
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
def test_module(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
my_struct = my_module.struct_by_name('my_struct1')
self.assertEqual(my_struct.name, 'my_struct1')
def test_invalid_message(self):
parser_ = parser.IDLParser()
try:
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read(), filepath=idl_path)
except IDLParserException as ex:
self.assertEqual(ex.line_number, 10)
except:
traceback.print_exc()
raise ex
def test_distinguish_same_struct_different_module(self):
parser_ = parser.IDLParser()
with open('idls/multi_module_test.idl', 'r') as idlf:
m = parser_.load(idlf.read(), include_dirs=['idls'])
self.assertEqual(m.name, '__global__')
moduleD = m.modules[3]
self.assertEqual(moduleD.name, 'moduleD')
structD = moduleD.struct_by_name('StructD')
self.assertEqual(structD.full_path, 'moduleD::StructD')
structA_member = structD.member_by_name('structA_value')
self.assertEqual(structA_member.type.full_path, 'moduleD::StructA')
def test_sequence_test(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
doubleSeq = my_module.find_types('DoubleSeq')[0]
self.assertEqual(doubleSeq.name, 'DoubleSeq')
seq_double = doubleSeq.type
self.assertTrue(seq_double.is_sequence)
self.assertEqual(seq_double.inner_type.name, 'double')
def test():
from idl_parser import parser
_parser = parser.IDLParser()
idl_str = '''
module my_module {
struct Time {
long sec;
long usec;
};
typedef sequence<double> DoubleSeq;
struct TimedDoubleSeq {
Time tm;
DoubleSeq data;
};
enum RETURN_VALUE {
RETURN_OK,
RETURN_FAILED,
};
interface DataGetter {
RETURN_VALUE getData(out TimedDoubleSeq data);
};
};
'''
global_module = _parser.load(idl_str)
my_module = global_module.module_by_name('my_module')
dataGetter = my_module.interface_by_name('DataGetter')
print 'DataGetter interface'
for m in dataGetter.methods:
print '- method:'
print ' name:', m.name
print ' returns:', m.returns.name
print ' arguments:'
for a in m.arguments:
print ' name:', a.name
print ' type:', a.type
print ' direction:', a.direction
doubleSeq = my_module.typedef_by_name('DoubleSeq')
print 'typedef %s %s' % (doubleSeq.type.name, doubleSeq.name)
timedDoubleSeq = my_module.struct_by_name('TimedDoubleSeq')
print 'TimedDoubleSeq'
for m in timedDoubleSeq.members:
print '- member:'
print ' name:', m.name
print ' type:', m.type.name
def test_enum_types(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
my_enum1 = my_module.enum_by_name('my_enum1')
self.assertEqual(my_enum1.name, 'my_enum1')
self.assertTrue(my_enum1.is_enum)
self.assertEqual(my_enum1.value_by_name('data1').value, 0)
self.assertEqual(my_enum1.value_by_name('data2').value, 1)
self.assertEqual(my_enum1.value_by_name('data3').value, 2)
pass
def test_struct_types(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
my_struct2 = my_module.struct_by_name('my_struct2')
self.assertEqual(my_struct2.basename, 'my_struct2')
self.assertTrue(my_struct2.is_struct)
m = my_struct2.member_by_name('my_struct_member')
self.assertEqual(m.type.basename, 'my_struct1')
my_struct = m.type
self.assertTrue(my_struct.is_struct)
def parse_for_interfaces(self, file_path: str):
file = Path(file_path)
file_path = str(file.absolute())
# fd = file descriptor
with open(file_path, 'r') as fd:
file_content = fd.read()
parser_obj = parser.IDLParser()
directories = []
directory = str(file.parent.absolute())
directories.append(directory)
idl_obj = parser_obj.load(file_content, directories)
modules = idl_obj.modules
for module in modules:
if_ = self._get_interfaces(module)
for if_idx in if_:
self.interfaces.append(if_idx)
def test_module(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
moduleA = m.modules[0]
self.assertEqual(moduleA.name, 'moduleA')
interfaceA = moduleA.interface_by_name('InterfaceA')
self.assertEqual(interfaceA.name, 'InterfaceA')
interfaceB = moduleA.interface_by_name('InterfaceB')
self.assertEqual(interfaceB.name, 'InterfaceB')
self.assertEqual(len(interfaceA.inheritances), 0)
self.assertEqual(len(interfaceB.inheritances), 1)
self.assertEqual(interfaceB.inheritances[0].full_path,
'moduleA::InterfaceA') # Must be fullpath
def test_const_types(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
value1 = my_module.const_by_name('value1')
self.assertTrue(value1.is_const)
self.assertEqual(value1.value_string, '-1')
self.assertEqual(value1.type.name, 'long')
value2 = my_module.const_by_name('value2')
self.assertTrue(value2.is_const)
self.assertEqual(value2.value_string, '4')
self.assertEqual(value2.type.name, 'unsigned long')
def test_typedef_types(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
my_byte = my_module.typedef_by_name('my_byte')
self.assertEqual(my_byte.name, 'my_byte')
self.assertEqual(my_byte.type.name, 'octet')
my_st = my_module.typedef_by_name('my_struct_typedef')
self.assertEqual(my_st.name, 'my_struct_typedef')
self.assertEqual(my_st.type.basename, 'my_struct1')
self.assertEqual(
my_st.type.member_by_name('long_member').type.name, 'long')
pass
def test_include(self):
parser_ = parser.IDLParser()
with open('idls/including_idl.idl', 'r') as idlf:
m = parser_.load(idlf.read(), include_dirs=['idls'])
self.assertEqual(m.name, '__global__')
moduleA = m.modules[0]
self.assertEqual(moduleA.name, 'moduleA')
structA = moduleA.struct_by_name('StructA')
self.assertEqual(structA.name, 'StructA')
double_member = structA.member_by_name('double_value')
self.assertEqual(double_member.name, 'double_value')
moduleB = m.modules[1]
self.assertEqual(moduleB.name, 'moduleB')
structB = moduleB.struct_by_name('StructB')
self.assertEqual(structB.name, 'StructB')
double_member = structB.member_by_name('structA_value')
self.assertEqual(double_member.name, 'structA_value')
def test_arraye_test(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
mat34 = my_module.find_types('Matrix34')[0]
self.assertEqual(mat34.name, 'Matrix34')
self.assertTrue(mat34.is_typedef)
arr_arr_double = mat34.type
self.assertTrue(arr_arr_double.is_array)
self.assertEqual(arr_arr_double.size, 3)
arr_double = arr_arr_double.inner_type
self.assertEqual(arr_double.name, 'double [4]')
self.assertTrue(arr_double.is_array)
self.assertEqual(arr_double.size, 4)
self.assertEqual(arr_double.inner_type.name, 'double')
mat3456 = my_module.find_types('Matrix3456')[0]
self.assertEqual(mat3456.name, 'Matrix3456')
self.assertTrue(mat3456.is_typedef)
arr_arr_arr_arr_ul = mat3456.type
self.assertTrue(arr_arr_arr_arr_ul.is_array)
self.assertEqual(arr_arr_arr_arr_ul.size, 3)
arr_arr_arr_ul = arr_arr_arr_arr_ul.inner_type
self.assertTrue(arr_arr_arr_ul.is_array)
self.assertEqual(arr_arr_arr_ul.size, 4)
arr_arr_ul = arr_arr_arr_ul.inner_type
self.assertTrue(arr_arr_ul.is_array)
self.assertEqual(arr_arr_ul.size, 5)
arr_ul = arr_arr_ul.inner_type
self.assertTrue(arr_ul.is_array)
self.assertEqual(arr_ul.size, 6)
self.assertTrue(arr_ul.inner_type.name, 'unsigned long')
def generate(self, argv):
""" Generate RTC skeleton code.
# Usage: mgr.py generate_rtc generate [RTC_NAME]
"""
self.parser.add_option('-f',
'--force',
help='Force option (default=False)',
default=False,
action='store_true',
dest='force_flag')
options, argv = self.parse_args(argv[:], self._print_alternatives)
verbose = options.verbose_flag # This is default option
force = options.force_flag
wasanbon.arg_check(argv, 4)
rtm_root_path = wasanbon.get_rtm_root()
default_idl_path = os.path.join(rtm_root_path, 'rtm')
except_files = [
'SDOPackage.idl', 'Manager.idl', 'OpenRTM.idl', 'RTC.idl'
]
idls, idl_dirs = self.search_idls(default_idl_path,
except_files=except_files)
idls = [
os.path.join(default_idl_path, 'idl', 'BasicDataType.idl'),
os.path.join(default_idl_path, 'idl', 'ExtendedDataTypes.idl'),
os.path.join(default_idl_path, 'idl', 'InterfaceDataTypes.idl')
]
self._parser = parser.IDLParser(verbose=verbose)
self._parser.parse(idls=idls,
idl_dirs=idl_dirs,
except_files=except_files)
pack = admin.package.get_package_from_path(os.getcwd())
rtc = admin.rtc.get_rtc_from_package(pack, argv[3], verbose=verbose)
self.generate_codes_from_profile(rtc)
def test_interface_types(self):
parser_ = parser.IDLParser()
with open(idl_path, 'r') as idlf:
m = parser_.load(idlf.read())
self.assertEqual(m.name, '__global__')
my_module = m.modules[1]
self.assertEqual(my_module.name, 'my_module')
my_int = my_module.interface_by_name('my_interface1')
self.assertEqual(my_int.basename, 'my_interface1')
method1 = my_int.method_by_name('method1')
self.assertEqual(method1.name, 'method1')
self.assertEqual(method1.returns.name, 'long')
la = method1.argument_by_name('long_arg')
self.assertEqual(la.name, 'long_arg')
self.assertEqual(la.type.name, 'long')
self.assertEqual(la.direction, 'in')
da = method1.argument_by_name('double_arg')
self.assertEqual(da.name, 'double_arg')
self.assertEqual(da.type.name, 'double')
self.assertEqual(da.direction, 'out')
sa = method1.argument_by_name('short_arg')
self.assertEqual(sa.name, 'short_arg')
self.assertEqual(sa.type.name, 'short')
self.assertEqual(sa.direction, 'inout')
method2 = my_int.method_by_name('method2')
self.assertEqual(method2.returns.basename, 'my_struct1')
self.assertEqual(
method2.argument_by_name('my_struct1_arg').type.basename,
'my_struct1')
self.assertEqual(
method2.argument_by_name('my_struct2_arg').type.basename,
'my_struct2')
def gen_module(idl_str):
idl_parser = parser.IDLParser()
return idl_parser.load(idl_str)