eclipse-aascw / aas-core-codegen / 41356886259

90%

push

github

Check safe integers and make JSON values public (#876)

We make the de/serialization of JSON-able values public in all SDKs so
that the aas-client3.2 implementations can use them, e.g.,
``json_value_from_jsonable`` in Python, ``JsonValueFromJsonable`` in Go,
``Deserialize.JsonValueFrom`` in C# and ``JsonValueFrom`` in C++.

A JSON number is read as a 64-bit float by the other SDKs, so we refuse
every integer outside the safe integer range [-2^53 + 1, 2^53 - 1]
consistently: for integer properties and in JSON-able values, in JSON
and XML de/serialization, in XML-RPC, in parsing with ``int`` and in
the verification. Once the verification passes, the serialization thus
works.

The bounds live in a single shared predicate per SDK, e.g., in Go:

    func IsSafeInteger(value int64) bool {
        return -9007199254740991 <= value && value <= 9007199254740991
    }

(``common.is_safe_integer`` in Python, ``common::IsSafeInteger`` in C++,
``Common.IsSafeInteger`` in C#, ``Verification.isSafeInteger`` in Java
and ``Number.isSafeInteger`` in TypeScript), generated if
``intermediate_uses.safe_integer_checks`` holds.

We accept a whole float such as ``5.0`` for an integer property.

The new live-test data and the generated unit tests cover the bounds in
all SDKs. The generated tests set an unsafe integer at every integer
property, and check that the verification and both serializations
refuse it. We hence made ``no_seven_from`` in ``int_length_interplay``
check ``start`` against the bounds before it indexes, as an invariant
would otherwise crash on ``count = -(2 ** 53)``.

The transpiled ``int(...)`` keeps checking the safe integer range, and
we document why: TypeScript represents the integers as ``number``, so
all SDKs check the same range to behave the same.

670 of 672 new or added lines in 49 files covered. (99.7%)

46996 of 52016 relevant lines covered (90.35%)

2.71 hits per line