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)