Added AlignAfterOpenBracket: AlwaysBreak and BinPackArguments: true to clang-format. Updated test/bacnet c/h files with updated format.

2024-04-24 09:38:12 -05:00
parent 1aaebe9414
commit 70c54817fd
120 changed files with 2182 additions and 1894 deletions
@@ -25,14 +25,18 @@ static BACNET_EVENT_NOTIFICATION_DATA data2;
 static void verifyBaseEventState(void)
 {
    zassert_equal(data.processIdentifier, data2.processIdentifier, NULL);
-    zassert_equal(data.initiatingObjectIdentifier.instance,
+    zassert_equal(
+        data.initiatingObjectIdentifier.instance,
        data2.initiatingObjectIdentifier.instance, NULL);
-    zassert_equal(data.initiatingObjectIdentifier.type,
+    zassert_equal(
+        data.initiatingObjectIdentifier.type,
        data2.initiatingObjectIdentifier.type, NULL);
-    zassert_equal(data.eventObjectIdentifier.instance,
+    zassert_equal(
+        data.eventObjectIdentifier.instance,
        data2.eventObjectIdentifier.instance, NULL);
-    zassert_equal(data.eventObjectIdentifier.type,
-        data2.eventObjectIdentifier.type, NULL);
+    zassert_equal(
+        data.eventObjectIdentifier.type, data2.eventObjectIdentifier.type,
+        NULL);
    zassert_equal(data.notificationClass, data2.notificationClass, NULL);
    zassert_equal(data.priority, data2.priority, NULL);
    zassert_equal(data.notifyType, data2.notifyType, NULL);
@@ -53,38 +57,51 @@ static void verifyBaseEventState(void)

    switch (data.timeStamp.tag) {
        case TIME_STAMP_SEQUENCE:
-            zassert_equal(data.timeStamp.value.sequenceNum,
+            zassert_equal(
+                data.timeStamp.value.sequenceNum,
                data2.timeStamp.value.sequenceNum, NULL);
            break;

        case TIME_STAMP_DATETIME:
-            zassert_equal(data.timeStamp.value.dateTime.time.hour,
+            zassert_equal(
+                data.timeStamp.value.dateTime.time.hour,
                data2.timeStamp.value.dateTime.time.hour, NULL);
-            zassert_equal(data.timeStamp.value.dateTime.time.min,
+            zassert_equal(
+                data.timeStamp.value.dateTime.time.min,
                data2.timeStamp.value.dateTime.time.min, NULL);
-            zassert_equal(data.timeStamp.value.dateTime.time.sec,
+            zassert_equal(
+                data.timeStamp.value.dateTime.time.sec,
                data2.timeStamp.value.dateTime.time.sec, NULL);
-            zassert_equal(data.timeStamp.value.dateTime.time.hundredths,
+            zassert_equal(
+                data.timeStamp.value.dateTime.time.hundredths,
                data2.timeStamp.value.dateTime.time.hundredths, NULL);

-            zassert_equal(data.timeStamp.value.dateTime.date.day,
+            zassert_equal(
+                data.timeStamp.value.dateTime.date.day,
                data2.timeStamp.value.dateTime.date.day, NULL);
-            zassert_equal(data.timeStamp.value.dateTime.date.month,
+            zassert_equal(
+                data.timeStamp.value.dateTime.date.month,
                data2.timeStamp.value.dateTime.date.month, NULL);
-            zassert_equal(data.timeStamp.value.dateTime.date.wday,
+            zassert_equal(
+                data.timeStamp.value.dateTime.date.wday,
                data2.timeStamp.value.dateTime.date.wday, NULL);
-            zassert_equal(data.timeStamp.value.dateTime.date.year,
+            zassert_equal(
+                data.timeStamp.value.dateTime.date.year,
                data2.timeStamp.value.dateTime.date.year, NULL);
            break;

        case TIME_STAMP_TIME:
-            zassert_equal(data.timeStamp.value.time.hour,
-                data2.timeStamp.value.time.hour, NULL);
-            zassert_equal(data.timeStamp.value.time.min,
-                data2.timeStamp.value.time.min, NULL);
-            zassert_equal(data.timeStamp.value.time.sec,
-                data2.timeStamp.value.time.sec, NULL);
-            zassert_equal(data.timeStamp.value.time.hundredths,
+            zassert_equal(
+                data.timeStamp.value.time.hour, data2.timeStamp.value.time.hour,
+                NULL);
+            zassert_equal(
+                data.timeStamp.value.time.min, data2.timeStamp.value.time.min,
+                NULL);
+            zassert_equal(
+                data.timeStamp.value.time.sec, data2.timeStamp.value.time.sec,
+                NULL);
+            zassert_equal(
+                data.timeStamp.value.time.hundredths,
                data2.timeStamp.value.time.hundredths, NULL);
            break;

@@ -132,13 +149,17 @@ static void testEventEventState(void)
        UNITS_SQUARE_METERS;

    bitstring_init(&data.notificationParams.changeOfState.statusFlags);
-    bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfState.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfState.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.changeOfState.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.changeOfState.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfState.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    null_len = event_notify_encode_service_request(NULL, &data);
@@ -151,13 +172,16 @@ static void testEventEventState(void)
        apdu_len, test_len, "apdu_len=%d test_len=%d", apdu_len, test_len);
    verifyBaseEventState();

-    zassert_equal(data.notificationParams.changeOfState.newState.tag,
+    zassert_equal(
+        data.notificationParams.changeOfState.newState.tag,
        data2.notificationParams.changeOfState.newState.tag, NULL);
-    zassert_equal(data.notificationParams.changeOfState.newState.state.units,
+    zassert_equal(
+        data.notificationParams.changeOfState.newState.state.units,
        data2.notificationParams.changeOfState.newState.state.units, NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.changeOfState.statusFlags,
+        bitstring_same(
+            &data.notificationParams.changeOfState.statusFlags,
            &data2.notificationParams.changeOfState.statusFlags),
        NULL);

@@ -188,9 +212,11 @@ static void testEventEventState(void)

    zassert_equal(apdu_len, test_len, NULL);
    verifyBaseEventState();
-    zassert_equal(data.notificationParams.changeOfState.newState.tag,
+    zassert_equal(
+        data.notificationParams.changeOfState.newState.tag,
        data2.notificationParams.changeOfState.newState.tag, NULL);
-    zassert_equal(data.notificationParams.changeOfState.newState.state.units,
+    zassert_equal(
+        data.notificationParams.changeOfState.newState.state.units,
        data2.notificationParams.changeOfState.newState.state.units, NULL);
    /*
     ** Event Type = EVENT_CHANGE_OF_BITSTRING
@@ -217,13 +243,17 @@ static void testEventEventState(void)

    bitstring_init(&data.notificationParams.changeOfBitstring.statusFlags);

-    bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfBitstring.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfBitstring.statusFlags,
        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfBitstring.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.changeOfBitstring.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfBitstring.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -247,7 +277,8 @@ static void testEventEventState(void)
        NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.changeOfBitstring.statusFlags,
+        bitstring_same(
+            &data.notificationParams.changeOfBitstring.statusFlags,
            &data2.notificationParams.changeOfBitstring.statusFlags),
        NULL);

@@ -260,13 +291,17 @@ static void testEventEventState(void)

    bitstring_init(&data.notificationParams.changeOfValue.statusFlags);

-    bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfValue.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfValue.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.changeOfValue.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.changeOfValue.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfValue.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -284,16 +319,20 @@ static void testEventEventState(void)
    verifyBaseEventState();

    zassert_true(
-        bitstring_same(&data.notificationParams.changeOfValue.statusFlags,
+        bitstring_same(
+            &data.notificationParams.changeOfValue.statusFlags,
            &data2.notificationParams.changeOfValue.statusFlags),
        NULL);

-    zassert_equal(data.notificationParams.changeOfValue.tag,
+    zassert_equal(
+        data.notificationParams.changeOfValue.tag,
        data2.notificationParams.changeOfValue.tag, NULL);

-    zassert_false(islessgreater(
-        data.notificationParams.changeOfValue.newValue.changeValue,
-        data2.notificationParams.changeOfValue.newValue.changeValue), NULL);
+    zassert_false(
+        islessgreater(
+            data.notificationParams.changeOfValue.newValue.changeValue,
+            data2.notificationParams.changeOfValue.newValue.changeValue),
+        NULL);

    /*
     ** Event Type = EVENT_CHANGE_OF_VALUE - bitstring value
@@ -322,10 +361,12 @@ static void testEventEventState(void)

    verifyBaseEventState();
    zassert_true(
-        bitstring_same(&data.notificationParams.changeOfValue.statusFlags,
+        bitstring_same(
+            &data.notificationParams.changeOfValue.statusFlags,
            &data2.notificationParams.changeOfValue.statusFlags),
        NULL);
-    zassert_equal(data.notificationParams.changeOfValue.tag,
+    zassert_equal(
+        data.notificationParams.changeOfValue.tag,
        data2.notificationParams.changeOfValue.tag, NULL);
    zassert_true(
        bitstring_same(
@@ -347,13 +388,17 @@ static void testEventEventState(void)
    data.notificationParams.commandFailure.feedbackValue.binaryValue =
        BINARY_ACTIVE;
    bitstring_init(&data.notificationParams.commandFailure.statusFlags);
-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);
    memset(buffer, 0, MAX_APDU);
    null_len = event_notify_encode_service_request(NULL, &data);
@@ -379,7 +424,8 @@ static void testEventEventState(void)
        NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.commandFailure.statusFlags,
+        bitstring_same(
+            &data.notificationParams.commandFailure.statusFlags,
            &data2.notificationParams.commandFailure.statusFlags),
        NULL);

@@ -393,13 +439,17 @@ static void testEventEventState(void)

    bitstring_init(&data.notificationParams.commandFailure.statusFlags);

-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.commandFailure.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.commandFailure.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -427,7 +477,8 @@ static void testEventEventState(void)
        NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.commandFailure.statusFlags,
+        bitstring_same(
+            &data.notificationParams.commandFailure.statusFlags,
            &data2.notificationParams.commandFailure.statusFlags),
        NULL);

@@ -441,13 +492,17 @@ static void testEventEventState(void)

    bitstring_init(&data.notificationParams.floatingLimit.statusFlags);

-    bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.floatingLimit.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.floatingLimit.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.floatingLimit.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.floatingLimit.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.floatingLimit.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -463,17 +518,24 @@ static void testEventEventState(void)
        apdu_len, test_len, "apdu_len=%d test_len=%d", apdu_len, test_len);
    verifyBaseEventState();

-    zassert_false(islessgreater(
-        data.notificationParams.floatingLimit.referenceValue,
-        data2.notificationParams.floatingLimit.referenceValue), NULL);
-    zassert_false(islessgreater(
-        data.notificationParams.floatingLimit.setPointValue,
-        data2.notificationParams.floatingLimit.setPointValue), NULL);
-    zassert_false(islessgreater(
-        data.notificationParams.floatingLimit.errorLimit,
-        data2.notificationParams.floatingLimit.errorLimit), NULL);
+    zassert_false(
+        islessgreater(
+            data.notificationParams.floatingLimit.referenceValue,
+            data2.notificationParams.floatingLimit.referenceValue),
+        NULL);
+    zassert_false(
+        islessgreater(
+            data.notificationParams.floatingLimit.setPointValue,
+            data2.notificationParams.floatingLimit.setPointValue),
+        NULL);
+    zassert_false(
+        islessgreater(
+            data.notificationParams.floatingLimit.errorLimit,
+            data2.notificationParams.floatingLimit.errorLimit),
+        NULL);
    zassert_true(
-        bitstring_same(&data.notificationParams.floatingLimit.statusFlags,
+        bitstring_same(
+            &data.notificationParams.floatingLimit.statusFlags,
            &data2.notificationParams.floatingLimit.statusFlags),
        NULL);

@@ -487,13 +549,17 @@ static void testEventEventState(void)

    bitstring_init(&data.notificationParams.outOfRange.statusFlags);

-    bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
-        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
-        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.outOfRange.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.outOfRange.statusFlags, STATUS_FLAG_IN_ALARM,
+        true);
+    bitstring_set_bit(
+        &data.notificationParams.outOfRange.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.outOfRange.statusFlags, STATUS_FLAG_OVERRIDDEN,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.outOfRange.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -510,18 +576,27 @@ static void testEventEventState(void)
    zassert_equal(apdu_len, test_len, NULL);
    verifyBaseEventState();

-    zassert_false(islessgreater(data.notificationParams.outOfRange.deadband,
-        data2.notificationParams.outOfRange.deadband), NULL);
+    zassert_false(
+        islessgreater(
+            data.notificationParams.outOfRange.deadband,
+            data2.notificationParams.outOfRange.deadband),
+        NULL);

-    zassert_false(islessgreater(
-        data.notificationParams.outOfRange.exceededLimit,
-        data2.notificationParams.outOfRange.exceededLimit), NULL);
+    zassert_false(
+        islessgreater(
+            data.notificationParams.outOfRange.exceededLimit,
+            data2.notificationParams.outOfRange.exceededLimit),
+        NULL);

-    zassert_false(islessgreater(
-        data.notificationParams.outOfRange.exceedingValue,
-        data2.notificationParams.outOfRange.exceedingValue), NULL);
-    zassert_true(bitstring_same(&data.notificationParams.outOfRange.statusFlags,
-                     &data2.notificationParams.outOfRange.statusFlags),
+    zassert_false(
+        islessgreater(
+            data.notificationParams.outOfRange.exceedingValue,
+            data2.notificationParams.outOfRange.exceedingValue),
+        NULL);
+    zassert_true(
+        bitstring_same(
+            &data.notificationParams.outOfRange.statusFlags,
+            &data2.notificationParams.outOfRange.statusFlags),
        NULL);

    /*
@@ -536,13 +611,17 @@ static void testEventEventState(void)

    bitstring_init(&data.notificationParams.changeOfLifeSafety.statusFlags);

-    bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfLifeSafety.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfLifeSafety.statusFlags,
        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfLifeSafety.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.changeOfLifeSafety.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.changeOfLifeSafety.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -559,17 +638,21 @@ static void testEventEventState(void)
    zassert_equal(apdu_len, test_len, NULL);
    verifyBaseEventState();

-    zassert_equal(data.notificationParams.changeOfLifeSafety.newMode,
+    zassert_equal(
+        data.notificationParams.changeOfLifeSafety.newMode,
        data2.notificationParams.changeOfLifeSafety.newMode, NULL);

-    zassert_equal(data.notificationParams.changeOfLifeSafety.newState,
+    zassert_equal(
+        data.notificationParams.changeOfLifeSafety.newState,
        data2.notificationParams.changeOfLifeSafety.newState, NULL);

-    zassert_equal(data.notificationParams.changeOfLifeSafety.operationExpected,
+    zassert_equal(
+        data.notificationParams.changeOfLifeSafety.operationExpected,
        data2.notificationParams.changeOfLifeSafety.operationExpected, NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.changeOfLifeSafety.statusFlags,
+        bitstring_same(
+            &data.notificationParams.changeOfLifeSafety.statusFlags,
            &data2.notificationParams.changeOfLifeSafety.statusFlags),
        NULL);

@@ -582,13 +665,17 @@ static void testEventEventState(void)

    bitstring_init(&data.notificationParams.unsignedRange.statusFlags);

-    bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.unsignedRange.statusFlags,
        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.unsignedRange.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.unsignedRange.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.unsignedRange.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.unsignedRange.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -605,14 +692,17 @@ static void testEventEventState(void)
    zassert_equal(apdu_len, test_len, NULL);
    verifyBaseEventState();

-    zassert_equal(data.notificationParams.unsignedRange.exceedingValue,
+    zassert_equal(
+        data.notificationParams.unsignedRange.exceedingValue,
        data2.notificationParams.unsignedRange.exceedingValue, NULL);

-    zassert_equal(data.notificationParams.unsignedRange.exceededLimit,
+    zassert_equal(
+        data.notificationParams.unsignedRange.exceededLimit,
        data2.notificationParams.unsignedRange.exceededLimit, NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.unsignedRange.statusFlags,
+        bitstring_same(
+            &data.notificationParams.unsignedRange.statusFlags,
            &data2.notificationParams.unsignedRange.statusFlags),
        NULL);

@@ -648,32 +738,38 @@ static void testEventEventState(void)
    zassert_equal(apdu_len, test_len, NULL);
    verifyBaseEventState();

-    zassert_equal(data.notificationParams.bufferReady.previousNotification,
+    zassert_equal(
+        data.notificationParams.bufferReady.previousNotification,
        data2.notificationParams.bufferReady.previousNotification, NULL);

-    zassert_equal(data.notificationParams.bufferReady.currentNotification,
+    zassert_equal(
+        data.notificationParams.bufferReady.currentNotification,
        data2.notificationParams.bufferReady.currentNotification, NULL);

-    zassert_equal(data.notificationParams.bufferReady.bufferProperty
-                      .deviceIdentifier.type,
+    zassert_equal(
+        data.notificationParams.bufferReady.bufferProperty.deviceIdentifier
+            .type,
        data2.notificationParams.bufferReady.bufferProperty.deviceIdentifier
            .type,
        NULL);

-    zassert_equal(data.notificationParams.bufferReady.bufferProperty
-                      .deviceIdentifier.instance,
+    zassert_equal(
+        data.notificationParams.bufferReady.bufferProperty.deviceIdentifier
+            .instance,
        data2.notificationParams.bufferReady.bufferProperty.deviceIdentifier
            .instance,
        NULL);

-    zassert_equal(data.notificationParams.bufferReady.bufferProperty
-                      .objectIdentifier.instance,
+    zassert_equal(
+        data.notificationParams.bufferReady.bufferProperty.objectIdentifier
+            .instance,
        data2.notificationParams.bufferReady.bufferProperty.objectIdentifier
            .instance,
        NULL);

-    zassert_equal(data.notificationParams.bufferReady.bufferProperty
-                      .objectIdentifier.type,
+    zassert_equal(
+        data.notificationParams.bufferReady.bufferProperty.objectIdentifier
+            .type,
        data2.notificationParams.bufferReady.bufferProperty.objectIdentifier
            .type,
        NULL);
@@ -683,7 +779,8 @@ static void testEventEventState(void)
        data2.notificationParams.bufferReady.bufferProperty.propertyIdentifier,
        NULL);

-    zassert_equal(data.notificationParams.bufferReady.bufferProperty.arrayIndex,
+    zassert_equal(
+        data.notificationParams.bufferReady.bufferProperty.arrayIndex,
        data2.notificationParams.bufferReady.bufferProperty.arrayIndex, NULL);

    /*
@@ -710,13 +807,17 @@ static void testEventEventState(void)
        AUTHENTICATION_FACTOR_MAX; // omit authenticationFactor

    bitstring_init(&data.notificationParams.accessEvent.statusFlags);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
-        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags, STATUS_FLAG_IN_ALARM,
+        true);
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -733,18 +834,22 @@ static void testEventEventState(void)
    zassert_equal(apdu_len, test_len, NULL);
    verifyBaseEventState();

-    zassert_equal(data.notificationParams.accessEvent.accessEvent,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessEvent,
        data2.notificationParams.accessEvent.accessEvent, NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.accessEvent.statusFlags,
+        bitstring_same(
+            &data.notificationParams.accessEvent.statusFlags,
            &data2.notificationParams.accessEvent.statusFlags),
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessEventTag,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessEventTag,
        data2.notificationParams.accessEvent.accessEventTag, NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessEventTime.tag,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessEventTime.tag,
        data2.notificationParams.accessEvent.accessEventTime.tag, NULL);

    zassert_equal(
@@ -752,26 +857,30 @@ static void testEventEventState(void)
        data2.notificationParams.accessEvent.accessEventTime.value.sequenceNum,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .deviceIdentifier.instance,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.deviceIdentifier
+            .instance,
        data2.notificationParams.accessEvent.accessCredential.deviceIdentifier
            .instance,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .deviceIdentifier.type,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.deviceIdentifier
+            .type,
        data2.notificationParams.accessEvent.accessCredential.deviceIdentifier
            .type,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .objectIdentifier.instance,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.objectIdentifier
+            .instance,
        data2.notificationParams.accessEvent.accessCredential.objectIdentifier
            .instance,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .objectIdentifier.type,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.objectIdentifier
+            .type,
        data2.notificationParams.accessEvent.accessCredential.objectIdentifier
            .type,
        NULL);
@@ -802,13 +911,17 @@ static void testEventEventState(void)
        octetstringValue, 2);

    bitstring_init(&data.notificationParams.accessEvent.statusFlags);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
-        STATUS_FLAG_IN_ALARM, true);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
-        STATUS_FLAG_FAULT, false);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags, STATUS_FLAG_IN_ALARM,
+        true);
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags, STATUS_FLAG_FAULT,
+        false);
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags,
        STATUS_FLAG_OVERRIDDEN, false);
-    bitstring_set_bit(&data.notificationParams.accessEvent.statusFlags,
+    bitstring_set_bit(
+        &data.notificationParams.accessEvent.statusFlags,
        STATUS_FLAG_OUT_OF_SERVICE, false);

    memset(buffer, 0, MAX_APDU);
@@ -825,18 +938,22 @@ static void testEventEventState(void)
    zassert_equal(apdu_len, test_len, NULL);
    verifyBaseEventState();

-    zassert_equal(data.notificationParams.accessEvent.accessEvent,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessEvent,
        data2.notificationParams.accessEvent.accessEvent, NULL);

    zassert_true(
-        bitstring_same(&data.notificationParams.accessEvent.statusFlags,
+        bitstring_same(
+            &data.notificationParams.accessEvent.statusFlags,
            &data2.notificationParams.accessEvent.statusFlags),
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessEventTag,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessEventTag,
        data2.notificationParams.accessEvent.accessEventTag, NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessEventTime.tag,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessEventTime.tag,
        data2.notificationParams.accessEvent.accessEventTime.tag, NULL);

    zassert_equal(
@@ -844,26 +961,30 @@ static void testEventEventState(void)
        data2.notificationParams.accessEvent.accessEventTime.value.sequenceNum,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .deviceIdentifier.instance,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.deviceIdentifier
+            .instance,
        data2.notificationParams.accessEvent.accessCredential.deviceIdentifier
            .instance,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .deviceIdentifier.type,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.deviceIdentifier
+            .type,
        data2.notificationParams.accessEvent.accessCredential.deviceIdentifier
            .type,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .objectIdentifier.instance,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.objectIdentifier
+            .instance,
        data2.notificationParams.accessEvent.accessCredential.objectIdentifier
            .instance,
        NULL);

-    zassert_equal(data.notificationParams.accessEvent.accessCredential
-                      .objectIdentifier.type,
+    zassert_equal(
+        data.notificationParams.accessEvent.accessCredential.objectIdentifier
+            .type,
        data2.notificationParams.accessEvent.accessCredential.objectIdentifier
            .type,
        NULL);