def test_enum_without_tag(): parser = ParserWrapper("aml", "enum_type_name", AMLListener, useDatabase=False) DATA = """enum { "ADDRESS_GRANULARITY_BYTE" = 1, "ADDRESS_GRANULARITY_WORD" = 2, "ADDRESS_GRANULARITY_DWORD" = 4 };""" res = parser.parseFromString(DATA) enums = res.enum_types assert len(enums) == 1 enum = enums[0] assert enum.name is None assert len(enum.enumerators) == 3 en0 = enum.enumerators[0] en1 = enum.enumerators[1] en2 = enum.enumerators[2] assert en0.tag == "ADDRESS_GRANULARITY_BYTE" assert en0.constant == 1 assert en1.tag == "ADDRESS_GRANULARITY_WORD" assert en1.constant == 2 assert en2.tag == "ADDRESS_GRANULARITY_DWORD" assert en2.constant == 4
def test_type_definition(): parser = ParserWrapper("aml", "type_definition", AMLListener, useDatabase=False) DATA = """struct { char[101]; /* EVENT_CHANNEL_NAME */ char[9]; /* EVENT_CHANNEL_SHORT_NAME */ uint; /* EVENT_CHANNEL_NUMBER */ enum { "DAQ" = 1, "STIM" = 2, "DAQ_STIM" = 3 }; uchar; /* MAX_DAQ_LIST */ uchar; /* TIME_CYCLE */ uchar; /* TIME_UNIT */ uchar; /* PRIORITY */ };""" res = parser.parseFromString(DATA) type_definitions = res.type_definitions assert len(type_definitions) == 1 td = type_definitions[0] structs = [td.type_name.type_] struct(structs)
def test_enum_one_constant(): parser = ParserWrapper("aml", "enum_type_name", AMLListener, useDatabase=False) DATA = """enum { "NO_CHECKSUM" = 10, "CHECKSUM_BYTE", "CHECKSUM_WORD" };""" res = parser.parseFromString(DATA) enums = res.enum_types assert len(enums) == 1 enum = enums[0] assert enum.name is None assert len(enum.enumerators) == 3 en0 = enum.enumerators[0] en1 = enum.enumerators[1] en2 = enum.enumerators[2] assert en0.tag == "NO_CHECKSUM" assert en0.constant == 10 assert en1.tag == "CHECKSUM_BYTE" assert en1.constant == 11 assert en2.tag == "CHECKSUM_WORD" assert en2.constant == 12
def test_mod_common_f7ull_featured(): parser = ParserWrapper("a2l", "module", A2LListener, debug=False) DATA = """ /begin MODULE testModule "" /begin MOD_COMMON "Characteristic maps always deposited in same mode" S_REC_LAYOUT S_ABL DEPOSIT ABSOLUTE BYTE_ORDER MSB_LAST DATA_SIZE 16 ALIGNMENT_BYTE 1 ALIGNMENT_WORD 2 ALIGNMENT_LONG 4 ALIGNMENT_INT64 8 ALIGNMENT_FLOAT32_IEEE 4 ALIGNMENT_FLOAT64_IEEE 8 /end MOD_COMMON /end MODULE """ db = parser.parseFromString(DATA) mc = ModCommon(db.session, "testModule") assert mc.comment == "Characteristic maps always deposited in same mode" # assert mc.sRecLayout.name == "S_ABL" assert mc.sRecLayout == "S_ABL" assert mc.deposit == "ABSOLUTE" assert mc.byteOrder == "MSB_LAST" assert mc.dataSize == 16 assert mc.alignment == { "FLOAT64": 8, "DWORD": 4, "BYTE": 1, "WORD": 2, "QWORD": 8, "FLOAT32": 4, }
def import_a2l( self, file_name, debug=False, in_memory=False, remove_existing=False, encoding="latin-1", ): """Import `.a2l` file to `.a2ldb` database. Parameters ---------- file_name: str Name of the A2L to be imported. If you don't specify an extension ``.a2l`` is added. debug: bool Additional debugging output. in_memory: bool Create non-persistent in-memory database. remove_existing: bool ** DANGER ZONE **: Remove existing database. Returns ------- SQLAlchemy session object. Raises ------ OSError If database already exists. Note ---- ``AML`` and ``IF_DATA`` sections are currently not processed. """ from os import unlink from pya2l.a2l_listener import A2LListener, cut_a2ml from pya2l.parserlib import ParserWrapper self.in_memory = in_memory parser = ParserWrapper("a2l", "a2lFile", A2LListener, debug=debug) self._set_path_components(file_name) if not in_memory: if remove_existing: try: unlink(self._dbfn) except Exception: pass elif path.exists(self._dbfn): raise OSError("file '{}' already exists.".format(self._dbfn)) data = open(self._a2lfn, encoding=encoding).read() data, a2ml = cut_a2ml(data) self.db = parser.parseFromString(data, dbname=self._dbfn) self.session = self.db.session return self.session
def test_compu_method_tab_verb_no_default_value(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.TAB_VERB.DEFAULT_VALUE "Verbal conversion with default value" TAB_VERB "%12.0" "" COMPU_TAB_REF CM.TAB_VERB.DEFAULT_VALUE.REF /end COMPU_METHOD /begin COMPU_VTAB CM.TAB_VERB.DEFAULT_VALUE.REF "List of text strings and relation to impl value" TAB_VERB 3 1 "SawTooth" 2 "Square" 3 "Sinus" /end COMPU_VTAB /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() compu = functions.CompuMethod( db.session, inspect.CompuMethod(db.session, module.compu_method[0].name)) assert compu.int_to_physical(1) == "SawTooth" assert compu.physical_to_int("Sinus") == 3 assert compu.int_to_physical(10) is None
def test_enum_without_constants(): parser = ParserWrapper("aml", "enum_type_name", AMLListener, useDatabase=False) DATA = """enum { "PARITY_NONE", "PARITY_ODD", "PARITY_EVEN" };""" res = parser.parseFromString(DATA) enums = res.enum_types assert len(enums) == 1 enum = enums[0] assert enum.name is None assert len(enum.enumerators) == 3 en0 = enum.enumerators[0] en1 = enum.enumerators[1] en2 = enum.enumerators[2] assert en0.tag == "PARITY_NONE" assert en0.constant == 0 assert en1.tag == "PARITY_ODD" assert en1.constant == 1 assert en2.tag == "PARITY_EVEN" assert en2.constant == 2
def test_measurement_compu_method_identical(): parser = ParserWrapper("a2l", "module", A2LListener, debug=False) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.IDENTICAL "conversion that delivers always phys = int" IDENTICAL "%3.0" "hours" /end COMPU_METHOD /begin MEASUREMENT N /* name */ "Engine speed" /* long identifier */ UWORD /* datatype */ CM.IDENTICAL /* conversion */ 2 /* resolution */ 2.5 /* accuracy */ 120.0 /* lower limit */ 8400.0 /* upper limit */ /end MEASUREMENT /end MODULE """ db = parser.parseFromString(DATA) meas = Measurement(db.session, "N") assert meas.compuMethod.format == "%3.0" assert meas.compuMethod.conversionType == "IDENTICAL" assert meas.compuMethod.unit == "hours" assert ( meas.compuMethod.longIdentifier == "conversion that delivers always phys = int" )
def test_compu_method_tab_nointerp_both_defaults(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.TAB_NOINTP.DEFAULT_VALUE "" TAB_NOINTP "%8.4" "U/ min " COMPU_TAB_REF CM.TAB_NOINTP.DEFAULT_VALUE.REF /end COMPU_METHOD /begin COMPU_TAB CM.TAB_NOINTP.DEFAULT_VALUE.REF "" TAB_NOINTP 12 -3 98 -1 99 0 100 2 102 4 104 5 105 6 106 7 107 8 108 9 109 10 110 13 111 DEFAULT_VALUE "value out of range" DEFAULT_VALUE_NUMERIC 300.56 /* DEFAULT_VALUE_NUME RIC should be used here as the normal output is numeric */ /end COMPU_TAB /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() with pytest.raises(exceptions.StructuralError): compu = functions.CompuMethod(db.session, module.compu_method[0])
def test_measurement_compu_method_form(): parser = ParserWrapper("a2l", "module", A2LListener, debug=False) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.FORM.X_PLUS_4 "" FORM "%6.1" "rpm" /begin FORMULA "X1+4" FORMULA_INV "X1-4" /end FORMULA /end COMPU_METHOD /begin MEASUREMENT N /* name */ "Engine speed" /* long identifier */ UWORD /* datatype */ CM.FORM.X_PLUS_4 /* conversion */ 2 /* resolution */ 2.5 /* accuracy */ 120.0 /* lower limit */ 8400.0 /* upper limit */ /end MEASUREMENT /end MODULE """ db = parser.parseFromString(DATA) meas = Measurement(db.session, "N") assert meas.compuMethod.format == "%6.1" assert meas.compuMethod.conversionType == "FORM" assert meas.compuMethod.unit == "rpm" assert meas.compuMethod.longIdentifier == "" assert meas.compuMethod.formula["formula"] == "X1+4" assert meas.compuMethod.formula["formula_inv"] == "X1-4"
def test_measurement_compu_method_linear(): parser = ParserWrapper("a2l", "module", A2LListener, debug=False) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.LINEAR.MUL_2 "Linear function with parameter set for phys = f(int) = 2*int + 0" LINEAR "%3.1" "m/s" COEFFS_LINEAR 2 0 /end COMPU_METHOD /begin MEASUREMENT N /* name */ "Engine speed" /* long identifier */ UWORD /* datatype */ CM.LINEAR.MUL_2 /* conversion */ 2 /* resolution */ 2.5 /* accuracy */ 120.0 /* lower limit */ 8400.0 /* upper limit */ /end MEASUREMENT /end MODULE """ db = parser.parseFromString(DATA) meas = Measurement(db.session, "N") assert meas.compuMethod.format == "%3.1" assert meas.compuMethod.conversionType == "LINEAR" assert meas.compuMethod.unit == "m/s" assert ( meas.compuMethod.longIdentifier == "Linear function with parameter set for phys = f(int) = 2*int + 0" ) assert meas.compuMethod.coeffs_linear["a"] == 2.0 assert meas.compuMethod.coeffs_linear["b"] == 0.0
def test_mod_par_basic(): parser = ParserWrapper("a2l", "module", A2LListener, debug=False) DATA = """ /begin MODULE testModule "" /begin MOD_PAR "Note: Provisional release for test purposes only!" /end MOD_PAR /end MODULE """ db = parser.parseFromString(DATA) mp = ModPar(db.session, "testModule") assert mp.comment == "Note: Provisional release for test purposes only!" assert mp.version is None assert mp.addrEpk == [] assert mp.epk is None assert mp.supplier is None assert mp.customer is None assert mp.customerNo is None assert mp.user is None assert mp.phoneNo is None assert mp.ecu is None assert mp.cpu is None assert mp.noOfInterfaces is None assert mp.memorySegments == [] assert mp.memoryLayouts == [] assert mp.systemConstants == {}
def test_compu_method_formula_with_sysc(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin MOD_PAR "" SYSTEM_CONSTANT "System_Constant_1" "42" SYSTEM_CONSTANT "System_Constant_2" "Textual constant" /end MOD_PAR /begin COMPU_METHOD CM.FORM.X_PLUS_SYSC "" FORM "%6.1" "rpm" /begin FORMULA "X1 + sysc(System_Constant_1)" /end FORMULA /end COMPU_METHOD /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() compu = functions.CompuMethod( db.session, inspect.CompuMethod(db.session, module.compu_method[0].name)) assert compu.int_to_physical(23) == 65
def test_compu_method_tab_interp_default(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.TAB_INTP.DEFAULT_VALUE "" TAB_INTP "%8.4" "U/ min " COMPU_TAB_REF CM.TAB_INTP.DEFAULT_VALUE.REF /end COMPU_METHOD /begin COMPU_TAB CM.TAB_INTP.DEFAULT_VALUE.REF "" TAB_INTP 12 -3 98 -1 99 0 100 2 102 4 104 5 105 6 106 7 107 8 108 9 109 10 110 13 111 DEFAULT_VALUE_NUMERIC 300.56 /* DEFAULT_VALUE_NUME RIC should be used here as the normal output is numeric */ /end COMPU_TAB /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() compu = functions.CompuMethod( db.session, inspect.CompuMethod(db.session, module.compu_method[0].name)) xs = np.arange(-3, 14) ys = np.array([ 98.0, 98.5, 99.0, 100.0, 101.0, 102.0, 103.0, 104.0, 105.0, 106.0, 107.0, 108.0, 109.0, 110.0, 110.33333333333333, 110.66666666666667, 111.0, ]) assert np.array_equal(compu.int_to_physical(xs), ys) assert compu.int_to_physical(-3) == 98 assert compu.int_to_physical(8) == 108 assert compu.int_to_physical(14) == 300.56 assert compu.int_to_physical(-4) == 300.56
def test_enum_with_tag(): parser = ParserWrapper("aml", "enum_type_name", AMLListener, useDatabase=False) DATA = """enum checksum { "XCP_ADD_11" = 1, "XCP_ADD_12" = 2, "XCP_ADD_14" = 3, "XCP_ADD_22" = 4, "XCP_ADD_24" = 5, "XCP_ADD_44" = 6, "XCP_CRC_16" = 7, "XCP_CRC_16_CITT" = 8, "XCP_CRC_32" = 9, "XCP_USER_DEFINED" = 255 };""" res = parser.parseFromString(DATA) enums = res.enum_types assert len(enums) == 1 enum = enums[0] assert enum.name == "checksum" assert len(enum.enumerators) == 10 en0 = enum.enumerators[0] en1 = enum.enumerators[1] en2 = enum.enumerators[2] en3 = enum.enumerators[3] en4 = enum.enumerators[4] en5 = enum.enumerators[5] en6 = enum.enumerators[6] en7 = enum.enumerators[7] en8 = enum.enumerators[8] en9 = enum.enumerators[9] assert en0.tag == "XCP_ADD_11" assert en0.constant == 1 assert en1.tag == "XCP_ADD_12" assert en1.constant == 2 assert en2.tag == "XCP_ADD_14" assert en2.constant == 3 assert en3.tag == "XCP_ADD_22" assert en3.constant == 4 assert en4.tag == "XCP_ADD_24" assert en4.constant == 5 assert en5.tag == "XCP_ADD_44" assert en5.constant == 6 assert en6.tag == "XCP_CRC_16" assert en6.constant == 7 assert en7.tag == "XCP_CRC_16_CITT" assert en7.constant == 8 assert en8.tag == "XCP_CRC_32" assert en8.constant == 9 assert en9.tag == "XCP_USER_DEFINED" assert en9.constant == 255
def test_basic_tagged_struct(): parser = ParserWrapper("aml", "taggedstruct_type_name", AMLListener, useDatabase=False) DATA = """taggedstruct test { "SLAVE" ; "MASTER" struct { uchar; /* MAX_BS_PGM */ uchar; /* MIN_ST_PGM */ }; };""" res = parser.parseFromString(DATA) tagged_structs = res.tagged_struct_types assert len(tagged_structs) == 1 tagged_struct = tagged_structs[0] assert tagged_struct.name == "test" members = tagged_struct.members assert len(members) == 2 m0 = members[0] assert m0.block_definition is None assert m0.multiple is False tsd = m0.taggedstruct_definition assert tsd.tag == "SLAVE" assert tsd.multiple is False assert tsd.member is None m1 = members[1] assert m1.block_definition is None tsd = m1.taggedstruct_definition assert tsd.tag == "MASTER" assert tsd.multiple is False member = tsd.member tn = member.type_name assert tn.tag is None assert tn.name is None struct = tn.type_ assert struct.name is None members = struct.members assert len(members) == 2 m0 = members[0] assert m0.multiple is False tn = m0.value.type_name assert tn.tag is None assert tn.name is None assert tn.type_.type_ == AMLPredefinedTypes.PDT_UCHAR m1 = members[1] assert m1.multiple is False tn = m1.value.type_name assert tn.tag is None assert tn.name is None assert tn.type_.type_ == AMLPredefinedTypes.PDT_UCHAR
def test_compu_method_rat_func_no_coeffs(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.RAT_FUNC.DIV_81_9175 "rational function with parameter set for impl = f(phys) = phys * 81.9175" RAT_FUNC "%8.4" "grad C" /end COMPU_METHOD /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() with pytest.raises(exceptions.StructuralError): compu = functions.CompuMethod(db.session, module.compu_method[0])
def test_compu_method_invalid(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.TAB_VERB.DEFAULT_VALUE "Verbal conversion with default value" FOO_BAR "%12.0" "" /end COMPU_METHOD /end MODULE """ session = parser.parseFromString(DATA) module = session.query(model.Module).first() compu = functions.CompuMethod( session, inspect.CompuMethod(session, module.compu_method[0].name))
def test_compu_method_linear_no_coeffs(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.LINEAR.MUL_2 "Linear function with parameter set for phys = f(int) = 2*int + 0" LINEAR "%3.1" "m/s" /end COMPU_METHOD /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() with pytest.raises(exceptions.StructuralError): compu = functions.CompuMethod(db.session, None)
def test_measurement_compu_method_tab_verb(): parser = ParserWrapper("a2l", "module", A2LListener, debug=False) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.TAB_VERB.DEFAULT_VALUE "Verbal conversion with default value" TAB_VERB "%12.0" "" COMPU_TAB_REF CM.TAB_VERB.DEFAULT_VALUE.REF /end COMPU_METHOD /begin COMPU_VTAB CM.TAB_VERB.DEFAULT_VALUE.REF "List of text strings and relation to impl value" TAB_VERB 6 2 "red" 3 "orange" 4 "yellow" 5 "green" 6 "blue" 7 "violet" DEFAULT_VALUE "unknown signal type" /end COMPU_VTAB /begin MEASUREMENT N /* name */ "Engine speed" /* long identifier */ UWORD /* datatype */ CM.TAB_VERB.DEFAULT_VALUE /* conversion */ 2 /* resolution */ 2.5 /* accuracy */ 120.0 /* lower limit */ 8400.0 /* upper limit */ /end MEASUREMENT /end MODULE """ db = parser.parseFromString(DATA) meas = Measurement(db.session, "N") assert meas.compuMethod.format == "%12.0" assert meas.compuMethod.conversionType == "TAB_VERB" assert meas.compuMethod.unit == "" assert meas.compuMethod.longIdentifier == "Verbal conversion with default value" assert meas.compuMethod.tab_verb["default_value"] == "unknown signal type" assert meas.compuMethod.tab_verb["num_values"] == 6 assert meas.compuMethod.tab_verb["ranges"] is False assert meas.compuMethod.tab_verb["in_values"] == [2.0, 3.0, 4.0, 5.0, 6.0, 7.0] assert meas.compuMethod.tab_verb["text_values"] == [ "red", "orange", "yellow", "green", "blue", "violet", ]
def test_compu_method_tab_verb_no_vtab(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.TAB_VERB.DEFAULT_VALUE "Verbal conversion with default value" TAB_VERB "%12.0" "" COMPU_TAB_REF CM.TAB_VERB.DEFAULT_VALUE.REF /end COMPU_METHOD /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() with pytest.raises(exceptions.StructuralError): compu = functions.CompuMethod(db.session, module.compu_method[0])
def test_compu_method_identical(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.IDENTICAL "conversion that delivers always phys = int" IDENTICAL "%3.0" "hours" /end COMPU_METHOD /end MODULE """ session = parser.parseFromString(DATA) module = session.query(model.Module).first() compu = functions.CompuMethod( session, inspect.CompuMethod(session, module.compu_method[0].name)) xs = np.arange(-10, 11) assert np.array_equal(compu.int_to_physical(xs), xs) assert np.array_equal(compu.physical_to_int(xs), xs)
def test_compu_method_rat_func_identical(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.RAT_FUNC.IDENT "rational function with parameter set for int = f(phys) = phys" RAT_FUNC "%3.1" "m/s" COEFFS 0 1 0 0 0 1 /end COMPU_METHOD /end MODULE """ session = parser.parseFromString(DATA) module = session.query(model.Module).first() compu = functions.CompuMethod( session, inspect.CompuMethod(session, module.compu_method[0].name)) xs = np.arange(-10, 11) assert np.array_equal(compu.int_to_physical(xs), xs) assert np.array_equal(compu.physical_to_int(xs), xs)
def test_compu_method_linear(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.LINEAR.MUL_2 "Linear function with parameter set for phys = f(int) = 2*int + 0" LINEAR "%3.1" "m/s" COEFFS_LINEAR 2 0 /end COMPU_METHOD /end MODULE """ session = parser.parseFromString(DATA) module = session.query(model.Module).first() compu = functions.CompuMethod( session, inspect.CompuMethod(session, module.compu_method[0].name)) xs = np.arange(-10, 11) assert np.array_equal(compu.int_to_physical(xs), xs * 2.0) assert np.array_equal(compu.physical_to_int(xs * 2.0), xs)
def test_measurement_basic(): parser = ParserWrapper("a2l", "measurement", A2LListener, debug=False) DATA = """ /begin MEASUREMENT N /* name */ "Engine speed" /* long identifier */ UWORD /* datatype */ NO_COMPU_METHOD /* conversion */ 2 /* resolution */ 2.5 /* accuracy */ 120.0 /* lower limit */ 8400.0 /* upper limit */ /end MEASUREMENT """ db = parser.parseFromString(DATA) meas = Measurement(db.session, "N") assert meas.name == "N" assert meas.longIdentifier == "Engine speed" assert meas.datatype == "UWORD" assert meas.resolution == 2 assert meas.accuracy == 2.5 assert meas.lowerLimit == 120 assert meas.upperLimit == 8400.0 assert meas.annotations == [] assert meas.arraySize is None assert meas.bitMask is None assert meas.bitOperation is None assert meas.byteOrder is None assert meas.discrete is False assert meas.displayIdentifier is None assert meas.ecuAddress is None assert meas.ecuAddressExtension is None assert meas.errorMask is None assert meas.format is None assert meas.functionList == [] assert meas.layout is None assert meas.matrixDim is None assert meas.maxRefresh is None assert meas.physUnit is None assert meas.readWrite is False assert meas.refMemorySegment is None assert meas.symbolLink is None assert meas.virtual == [] assert meas.compuMethod == "NO_COMPU_METHOD"
def test_measurement_no_compu_method(): parser = ParserWrapper("a2l", "module", A2LListener, debug=False) DATA = """ /begin MODULE testModule "" /begin MEASUREMENT N /* name */ "Engine speed" /* long identifier */ UWORD /* datatype */ NO_COMPU_METHOD /* conversion */ 2 /* resolution */ 2.5 /* accuracy */ 120.0 /* lower limit */ 8400.0 /* upper limit */ /end MEASUREMENT /end MODULE """ db = parser.parseFromString(DATA) meas = Measurement(db.session, "N") assert meas.compuMethod == "NO_COMPU_METHOD"
def test_compu_method_rat_func_linear(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.RAT_FUNC.DIV_81_9175 "rational function with parameter set for impl = f(phys) = phys * 81.9175" RAT_FUNC "%8.4" "grad C" COEFFS 0 81.9175 0 0 0 1 /end COMPU_METHOD /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() compu = functions.CompuMethod( db.session, inspect.CompuMethod(db.session, module.compu_method[0].name)) xs = np.arange(-10, 11) ys = np.array([ -819.1750000000001, -737.2575, -655.34, -573.4225, -491.505, -409.58750000000003, -327.67, -245.7525, -163.835, -81.9175, 0.0, 81.9175, 163.835, 245.7525, 327.67, 409.58750000000003, 491.505, 573.4225, 655.34, 737.2575, 819.1750000000001, ]) assert np.array_equal(compu.int_to_physical(ys), xs) assert np.array_equal(compu.physical_to_int(xs), ys)
def test_compu_method_tab_verb_ranges(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.VTAB_RANGE.DEFAULT_VALUE "verbal range with default value" TAB_VERB "%4.2" "" COMPU_TAB_REF CM.VTAB_RANGE.DEFAULT_VALUE.REF /end COMPU_METHOD /begin COMPU_VTAB_RANGE CM.VTAB_RANGE.DEFAULT_VALUE.REF "" 11 0 1 "Zero_to_one" 2 3 "two_to_three" 4 7 "four_to_seven" 14 17 "fourteen_to_seventeen" 18 99 "eigteen_to_ninetynine" 100 100 "hundred" 101 101 "hundredone" 102 102 "hundredtwo" 103 103 "hundredthree" 104 104 "hundredfour" 105 105 "hundredfive" DEFAULT_VALUE "out of range value" /end COMPU_VTAB_RANGE /end MODULE """ db = parser.parseFromString(DATA) module = db.session.query(model.Module).first() compu = functions.CompuMethod( db.session, inspect.CompuMethod(db.session, module.compu_method[0].name)) assert compu.int_to_physical(0) == "Zero_to_one" assert compu.int_to_physical(6) == "four_to_seven" assert compu.int_to_physical(45) == "eigteen_to_ninetynine" assert compu.int_to_physical(100) == "hundred" assert compu.int_to_physical(105) == "hundredfive" assert compu.int_to_physical(-1) == "out of range value" assert compu.int_to_physical(106) == "out of range value" assert compu.int_to_physical(10) == "out of range value"
def test_basic_block_definition(): parser = ParserWrapper("aml", "block_definition", AMLListener, useDatabase=False) DATA = """ block "STIM" struct { enum { "GRANULARITY_ODT_ENTRY_SIZE_STIM_BYTE" = 1, "GRANULARITY_ODT_ENTRY_SIZE_STIM_WORD" = 2, "GRANULARITY_ODT_ENTRY_SIZE_STIM_DWORD" = 4, "GRANULARITY_ODT_ENTRY_SIZE_STIM_DLONG" = 8 }; uchar; /* MAX_ODT_ENTRY_SIZE_STIM */ taggedstruct { "BIT_STIM_SUPPORTED" ; }; };""" res = parser.parseFromString(DATA) block_def(res.block_definitions)
def test_compu_method_formula_without_inv(): parser = ParserWrapper("a2l", "module", A2LListener) DATA = """ /begin MODULE testModule "" /begin COMPU_METHOD CM.FORM.X_PLUS_4 "" FORM "%6.1" "rpm" /begin FORMULA "X1+4" /end FORMULA /end COMPU_METHOD /end MODULE """ session = parser.parseFromString(DATA) module = session.query(model.Module).first() compu = functions.CompuMethod( session, inspect.CompuMethod(session, module.compu_method[0].name)) assert compu.int_to_physical(6) == 10