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
