Wrap long lines to fit within 80 columns across the codebase

Pure whitespace/line-break reformatting (braces, newlines, and line
continuations matching this codebase's existing wrap conventions) - no
logic, string content, or identifiers changed anywhere. Confirmed via
diff against the pre-change tree and by rebuilding + re-running the
affected test suites, which produce identical pass/fail results.

Co-Authored-By: Claude Sonnet 5 <[email protected]>

test/animation/test_animation.c

@@ -84,7 +84,9 @@ static void test_animationInitMultiLayerDurationIsMax(void **state) {
 }
 
 static void test_animationInitNullAsserts(void **state) {
-  keyframe_t keyframes[1] = { { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR } };
+  keyframe_t keyframes[1] = {
+    { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
+  };
   uint16_t keyframeCounts[1] = { 1 };
   animation_t anim;
 
@@ -94,7 +96,9 @@ static void test_animationInitNullAsserts(void **state) {
 }
 
 static void test_animationInitZeroLayerCountAsserts(void **state) {
-  keyframe_t keyframes[1] = { { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR } };
+  keyframe_t keyframes[1] = {
+    { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
+  };
   uint16_t keyframeCounts[1] = { 1 };
   animation_t anim;
 
@@ -112,7 +116,9 @@ static void test_animationInitUnsortedKeyframesAsserts(void **state) {
   expect_assert_failure(animationInit(&anim, keyframes, keyframeCounts, 1));
 }
 
-static void test_animationGetLayerValueSamplesEachLayerIndependently(void **state) {
+static void test_animationGetLayerValueSamplesEachLayerIndependently(
+  void **state
+) {
   keyframe_t keyframes[4] = {
     { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
     { .time = 2.0f, .value = 20.0f, .easing = EASING_LINEAR },
@@ -159,7 +165,9 @@ static void test_animationUpdateAdvancesTimeAndCallsOnUpdate(void **state) {
   assert_int_equal(cb.completeCount, 0);
 }
 
-static void test_animationUpdatePlainPlayStopsAtEndAndFiresOnceOnly(void **state) {
+static void test_animationUpdatePlainPlayStopsAtEndAndFiresOnceOnly(
+  void **state
+) {
   keyframe_t keyframes[2] = {
     { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
     { .time = 2.0f, .value = 20.0f, .easing = EASING_LINEAR },
@@ -219,7 +227,9 @@ static void test_animationUpdateLoopWrapsAndFiresOnLoop(void **state) {
   assert_int_equal(cb.completeCount, 0);
 }
 
-static void test_animationUpdateLoopStopEndCompletesInsteadOfWrapping(void **state) {
+static void test_animationUpdateLoopStopEndCompletesInsteadOfWrapping(
+  void **state
+) {
   keyframe_t keyframes[2] = {
     { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
     { .time = 2.0f, .value = 20.0f, .easing = EASING_LINEAR },
@@ -277,7 +287,9 @@ static void test_animationUpdateReverseStopsAtBeginning(void **state) {
   assert_int_equal(cb.completeCount, 1);
 }
 
-static void test_animationUpdatePingpongBouncesForeverWithoutStopFlags(void **state) {
+static void test_animationUpdatePingpongBouncesForeverWithoutStopFlags(
+  void **state
+) {
   keyframe_t keyframes[2] = {
     { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
     { .time = 2.0f, .value = 20.0f, .easing = EASING_LINEAR },
@@ -320,7 +332,9 @@ static void test_animationUpdatePingpongStopEndCompletesAtEnd(void **state) {
   assert_int_equal(cb.completeCount, 1);
 }
 
-static void test_animationUpdatePingpongStopBeginningCompletesAtStart(void **state) {
+static void test_animationUpdatePingpongStopBeginningCompletesAtStart(
+  void **state
+) {
   keyframe_t keyframes[2] = {
     { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
     { .time = 2.0f, .value = 20.0f, .easing = EASING_LINEAR },
@@ -376,7 +390,9 @@ static void test_animationUpdateNegativeDeltaTimeAsserts(void **state) {
 }
 
 static void test_animationInitZeroDurationAsserts(void **state) {
-  keyframe_t keyframes[1] = { { .time = 0.0f, .value = 5.0f, .easing = EASING_LINEAR } };
+  keyframe_t keyframes[1] = {
+    { .time = 0.0f, .value = 5.0f, .easing = EASING_LINEAR },
+  };
   uint16_t keyframeCounts[1] = { 1 };
   animation_t anim;
 
@@ -412,7 +428,9 @@ int main(int argc, char **argv) {
     cmocka_unit_test(test_animationUpdateLoopStopEndCompletesInsteadOfWrapping),
     cmocka_unit_test(test_animationUpdateReversePlaysBackward),
     cmocka_unit_test(test_animationUpdateReverseStopsAtBeginning),
-    cmocka_unit_test(test_animationUpdatePingpongBouncesForeverWithoutStopFlags),
+    cmocka_unit_test(
+      test_animationUpdatePingpongBouncesForeverWithoutStopFlags
+    ),
     cmocka_unit_test(test_animationUpdatePingpongStopEndCompletesAtEnd),
     cmocka_unit_test(test_animationUpdatePingpongStopBeginningCompletesAtStart),
     cmocka_unit_test(test_animationUpdateMultiLayerCallsOnUpdatePerLayer),

test/animation/test_easing.c

@@ -141,22 +141,61 @@ static void test_easingInOutBack(void **state) {
 }
 
 static void test_easingApplyDispatchesToEachType(void **state) {
-  assert_float_equal(easingApply(EASING_LINEAR, 0.5f), easingLinear(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_SINE, 0.5f), easingInSine(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_OUT_SINE, 0.5f), easingOutSine(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_OUT_SINE, 0.5f), easingInOutSine(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_QUAD, 0.5f), easingInQuad(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_OUT_QUAD, 0.5f), easingOutQuad(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_OUT_QUAD, 0.5f), easingInOutQuad(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_CUBIC, 0.5f), easingInCubic(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_OUT_CUBIC, 0.5f), easingOutCubic(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_OUT_CUBIC, 0.5f), easingInOutCubic(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_QUART, 0.5f), easingInQuart(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_OUT_QUART, 0.5f), easingOutQuart(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_OUT_QUART, 0.5f), easingInOutQuart(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_BACK, 0.5f), easingInBack(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_OUT_BACK, 0.5f), easingOutBack(0.5f), EASING_TOLERANCE);
-  assert_float_equal(easingApply(EASING_IN_OUT_BACK, 0.5f), easingInOutBack(0.5f), EASING_TOLERANCE);
+  assert_float_equal(
+    easingApply(EASING_LINEAR, 0.5f), easingLinear(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_SINE, 0.5f), easingInSine(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_OUT_SINE, 0.5f), easingOutSine(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_OUT_SINE, 0.5f), easingInOutSine(0.5f),
+    EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_QUAD, 0.5f), easingInQuad(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_OUT_QUAD, 0.5f), easingOutQuad(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_OUT_QUAD, 0.5f), easingInOutQuad(0.5f),
+    EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_CUBIC, 0.5f), easingInCubic(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_OUT_CUBIC, 0.5f), easingOutCubic(0.5f),
+    EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_OUT_CUBIC, 0.5f), easingInOutCubic(0.5f),
+    EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_QUART, 0.5f), easingInQuart(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_OUT_QUART, 0.5f), easingOutQuart(0.5f),
+    EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_OUT_QUART, 0.5f), easingInOutQuart(0.5f),
+    EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_BACK, 0.5f), easingInBack(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_OUT_BACK, 0.5f), easingOutBack(0.5f), EASING_TOLERANCE
+  );
+  assert_float_equal(
+    easingApply(EASING_IN_OUT_BACK, 0.5f), easingInOutBack(0.5f),
+    EASING_TOLERANCE
+  );
 }
 
 static void test_easingApplyInvalidTypeAsserts(void **state) {

test/animation/test_keyframe.c

@@ -83,7 +83,9 @@ static void test_keyframeGetValueBeforeFirstKeyframeIsNaN(void **state) {
   assert_true(isnan(keyframeGetValue(keyframes, 2, 0.0f)));
 }
 
-static void test_keyframeGetValueAtOrAfterLastKeyframeClampsToLastValue(void **state) {
+static void test_keyframeGetValueAtOrAfterLastKeyframeClampsToLastValue(
+  void **state
+) {
   keyframe_t keyframes[2] = {
     { .time = 0.0f, .value = 0.0f, .easing = EASING_LINEAR },
     { .time = 1.0f, .value = 10.0f, .easing = EASING_LINEAR },
@@ -93,7 +95,9 @@ static void test_keyframeGetValueAtOrAfterLastKeyframeClampsToLastValue(void **s
   assert_float_equal(keyframeGetValue(keyframes, 2, 2.0f), 10.0f, 0.0001f);
 }
 
-static void test_keyframeGetValueSingleKeyframeAtOrAfterClampsToValue(void **state) {
+static void test_keyframeGetValueSingleKeyframeAtOrAfterClampsToValue(
+  void **state
+) {
   keyframe_t keyframes[1] = {
     { .time = 5.0f, .value = 42.0f, .easing = EASING_LINEAR },
   };
@@ -147,7 +151,9 @@ static void test_keyframeGetValueLaterKeyframeOutOfOrderAsserts(void **state) {
   expect_assert_failure(keyframeGetValue(keyframes, 3, 0.0f));
 }
 
-static void test_keyframeGetValueEqualConsecutiveTimesDoesNotAssert(void **state) {
+static void test_keyframeGetValueEqualConsecutiveTimesDoesNotAssert(
+  void **state
+) {
   // Equal (non-decreasing) times are allowed - only strictly decreasing
   // times should trigger the sorted check.
   keyframe_t keyframes[3] = {
@@ -167,7 +173,9 @@ int main(int argc, char **argv) {
     cmocka_unit_test(test_keyframeGetValueAppliesEasing),
     cmocka_unit_test(test_keyframeGetValueNonZeroStartTime),
     cmocka_unit_test(test_keyframeGetValueBeforeFirstKeyframeIsNaN),
-    cmocka_unit_test(test_keyframeGetValueAtOrAfterLastKeyframeClampsToLastValue),
+    cmocka_unit_test(
+      test_keyframeGetValueAtOrAfterLastKeyframeClampsToLastValue
+    ),
     cmocka_unit_test(test_keyframeGetValueSingleKeyframeAtOrAfterClampsToValue),
     cmocka_unit_test(test_keyframeGetValueNullKeyframesAsserts),
     cmocka_unit_test(test_keyframeGetValueZeroCountAsserts),

test/assert/test_assert.c

@@ -108,7 +108,8 @@ static void test_assertStrLenMin(void **state) {
 }
 
 static void test_assertIsMainThread(void **state) {
-  // The group setup recorded this thread as main  -  assertIsMainThread must pass.
+  // The group setup recorded this thread as main  -  assertIsMainThread
+  // must pass.
   assertIsMainThread("test thread is main, should not assert");
 
   // assertNotMainThread must fail when called from the main thread.

test/asset/test_asset.c

@@ -90,7 +90,8 @@ static bool_t loading_slot_has_entry(const assetentry_t *entry) {
 // ============================================================
 
 static void test_getEntry_creates_new(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assert_non_null(entry);
   assert_int_equal(entry->state, ASSET_ENTRY_STATE_NOT_STARTED);
@@ -101,8 +102,10 @@ static void test_getEntry_creates_new(void **state) {
 }
 
 static void test_getEntry_dedup(void **state) {
-  assetentry_t *a = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
-  assetentry_t *b = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *a =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *b =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assert_ptr_equal(a, b);
   assert_int_equal(memoryGetAllocatedCount(), 0);
@@ -121,7 +124,8 @@ static void test_getEntry_distinct_names(void **state) {
 // ============================================================
 
 static void test_update_entry_reaches_loaded(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
   assert_int_equal(entry->state, ASSET_ENTRY_STATE_NOT_STARTED);
 
   assetEntryLock(entry);
@@ -134,7 +138,8 @@ static void test_update_entry_reaches_loaded(void **state) {
 }
 
 static void test_update_slot_cleared_after_first_update(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -149,7 +154,8 @@ static void test_update_slot_cleared_after_first_update(void **state) {
 }
 
 static void test_update_slot_stays_cleared_on_further_updates(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -186,10 +192,12 @@ static void test_update_four_slots_fill_independently(void **state) {
 static void test_update_error_state(void **state) {
   ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_LOCALE].loadSync = stub_load_fail;
 
-  assetentry_t *entry = assetGetEntry("fail.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("fail.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   // First update: dispatches and calls the failing stub.
-  // assetUpdate itself returns OK here; the error from loadSync is caught internally.
+  // assetUpdate itself returns OK here; the error from loadSync is
+  // caught internally.
   errorret_t ret = assetUpdate();
   assert_true(errorIsOk(ret));
   assert_int_equal(entry->state, ASSET_ENTRY_STATE_ERROR);
@@ -209,7 +217,8 @@ static void test_update_noop_on_empty_table(void **state) {
 }
 
 static void test_update_loaded_entry_not_redispatched(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -255,13 +264,17 @@ static void test_update_overflow_queues_entries(void **state) {
   for(int i = 0; i < ASSET_LOADING_COUNT_MAX; i++) {
     assert_int_equal(entries[i]->state, ASSET_ENTRY_STATE_LOADED);
   }
-  assert_int_equal(entries[ASSET_LOADING_COUNT_MAX]->state, ASSET_ENTRY_STATE_NOT_STARTED);
+  assert_int_equal(
+    entries[ASSET_LOADING_COUNT_MAX]->state, ASSET_ENTRY_STATE_NOT_STARTED
+  );
 
   // Update 2: the slots freed during update 1 are now available, so the
   // overflow entry is dispatched and loaded in this pass.
   ret = assetUpdate();
   assert_true(errorIsOk(ret));
-  assert_int_equal(entries[ASSET_LOADING_COUNT_MAX]->state, ASSET_ENTRY_STATE_LOADED);
+  assert_int_equal(
+    entries[ASSET_LOADING_COUNT_MAX]->state, ASSET_ENTRY_STATE_LOADED
+  );
 
   for(int i = 0; i < TOTAL; i++) {
     assetEntryUnlock(entries[i]);
@@ -273,12 +286,14 @@ static void test_update_overflow_queues_entries(void **state) {
 static void test_update_error_slot_stays_occupied(void **state) {
   ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_LOCALE].loadSync = stub_load_fail;
 
-  assetentry_t *entry = assetGetEntry("fail.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("fail.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetUpdate();
   assert_int_equal(entry->state, ASSET_ENTRY_STATE_ERROR);
 
-  // Unlike LOADED, the ERROR case does NOT clear the slot  -  it throws instead.
+  // Unlike LOADED, the ERROR case does NOT clear the slot  -  it throws
+  // instead.
   assert_true(loading_slot_has_entry(entry));
 
   errorret_t ret = assetUpdate();
@@ -293,7 +308,8 @@ static void test_update_error_slot_stays_occupied(void **state) {
 // ============================================================
 
 static void test_getEntry_null_input_stays_null(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assert_null(entry->input);
   assert_int_equal(memoryGetAllocatedCount(), 0);
@@ -304,7 +320,8 @@ static void test_getEntry_input_copied_into_entry(void **state) {
   memoryZero(&input, sizeof(input));
   input.texture = (textureformat_t)42;
 
-  assetentry_t *entry = assetGetEntry("test.texture", ASSET_LOADER_TYPE_TEXTURE, &input);
+  assetentry_t *entry =
+    assetGetEntry("test.texture", ASSET_LOADER_TYPE_TEXTURE, &input);
 
   // input must have been copied  -  entry->input must point inside the entry.
   assert_non_null(entry->input);
@@ -338,10 +355,13 @@ static errorret_t reentrant_stub_load(assetloading_t *loading) {
 static void test_update_reentrant_sync_loader(void **state) {
   reentrant_inner_entry = NULL;
   reentrant_inner_loaded = false;
-  // LOCALE uses the re-entrant loader; JSON keeps the default stub_load_success.
-  ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_LOCALE].loadSync = reentrant_stub_load;
+  // LOCALE uses the re-entrant loader; JSON keeps the default
+  // stub_load_success.
+  ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_LOCALE].loadSync =
+    reentrant_stub_load;
 
-  assetentry_t *outer = assetGetEntry("outer.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *outer =
+    assetGetEntry("outer.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   errorret_t ret = assetRequireLoaded(outer);
   assert_true(errorIsOk(ret));
@@ -360,7 +380,8 @@ static void test_update_reentrant_sync_loader(void **state) {
 // ============================================================
 
 static void test_getEntry_returns_loaded_entry(void **state) {
-  assetentry_t *a = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *a =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(a);
   assetUpdate();
@@ -368,7 +389,8 @@ static void test_getEntry_returns_loaded_entry(void **state) {
 
   // A second request for the same name must return the same entry even though
   // it is already LOADED rather than NOT_STARTED.
-  assetentry_t *b = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *b =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
   assert_ptr_equal(a, b);
   assert_int_equal(b->state, ASSET_ENTRY_STATE_LOADED);
   assetEntryUnlock(a);
@@ -381,7 +403,8 @@ static void test_getEntry_returns_loaded_entry(void **state) {
 // ============================================================
 
 static void test_entry_dispose_clears_entry(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -427,7 +450,8 @@ static void test_entry_dispose_slot_reusable(void **state) {
 // ============================================================
 
 static void test_requireLoaded_already_loaded(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -442,7 +466,8 @@ static void test_requireLoaded_already_loaded(void **state) {
 }
 
 static void test_requireLoaded_spins_to_loaded(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
   assert_int_equal(entry->state, ASSET_ENTRY_STATE_NOT_STARTED);
 
   // requireLoaded calls assetUpdate internally until LOADED.
@@ -456,10 +481,12 @@ static void test_requireLoaded_spins_to_loaded(void **state) {
 static void test_requireLoaded_propagates_error(void **state) {
   ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_LOCALE].loadSync = stub_load_fail;
 
-  assetentry_t *entry = assetGetEntry("fail.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("fail.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
-  // requireLoaded spins assetUpdate until LOADED  -  but the loader always fails,
-  // so the second assetUpdate sees ERROR and throws, which errorChain propagates.
+  // requireLoaded spins assetUpdate until LOADED  -  but the loader
+  // always fails, so the second assetUpdate sees ERROR and throws, which
+  // errorChain propagates.
   errorret_t ret = assetRequireLoaded(entry);
   assert_true(errorIsNotOk(ret));
   errorCatch(ret);
@@ -473,7 +500,8 @@ static void test_requireLoaded_propagates_error(void **state) {
 // ============================================================
 
 static void test_update_does_not_reap_automatically(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -497,7 +525,8 @@ static void test_update_does_not_reap_automatically(void **state) {
 }
 
 static void test_reapUnused_disposes_zero_ref_loaded(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -513,7 +542,8 @@ static void test_reapUnused_disposes_zero_ref_loaded(void **state) {
 }
 
 static void test_reapUnused_ignores_referenced_entries(void **state) {
-  assetentry_t *entry = assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *entry =
+    assetGetEntry("test.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
 
   assetEntryLock(entry);
   assetUpdate();
@@ -548,7 +578,8 @@ static void test_getEntry_reaps_when_pool_full(void **state) {
   // The pool is now completely full of zero-ref LOADED entries with no
   // ASSET_LOADER_TYPE_NULL slots left. Requesting one more must trigger an
   // implicit reap instead of asserting.
-  assetentry_t *fresh = assetGetEntry("fresh.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
+  assetentry_t *fresh =
+    assetGetEntry("fresh.locale", ASSET_LOADER_TYPE_LOCALE, NULL);
   assert_non_null(fresh);
   assert_int_equal(fresh->state, ASSET_ENTRY_STATE_NOT_STARTED);
 
@@ -572,39 +603,90 @@ int main(void) {
   assertInit();
   const struct CMUnitTest tests[] = {
     // getEntry
-    cmocka_unit_test_setup_teardown(test_getEntry_creates_new, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_getEntry_dedup, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_getEntry_distinct_names, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_getEntry_returns_loaded_entry, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_getEntry_null_input_stays_null, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_getEntry_input_copied_into_entry, asset_setup, asset_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_getEntry_creates_new, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getEntry_dedup, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getEntry_distinct_names, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getEntry_returns_loaded_entry, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getEntry_null_input_stays_null, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getEntry_input_copied_into_entry, asset_setup, asset_teardown
+    ),
 
     // assetUpdate  -  state machine
-    cmocka_unit_test_setup_teardown(test_update_noop_on_empty_table, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_entry_reaches_loaded, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_slot_cleared_after_first_update, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_slot_stays_cleared_on_further_updates, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_four_slots_fill_independently, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_loaded_entry_not_redispatched, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_overflow_queues_entries, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_error_state, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_error_slot_stays_occupied, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_update_reentrant_sync_loader, asset_setup, asset_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_update_noop_on_empty_table, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_entry_reaches_loaded, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_slot_cleared_after_first_update, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_slot_stays_cleared_on_further_updates,
+      asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_four_slots_fill_independently, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_loaded_entry_not_redispatched, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_overflow_queues_entries, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_error_state, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_error_slot_stays_occupied, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_update_reentrant_sync_loader, asset_setup, asset_teardown
+    ),
 
     // assetEntryDispose
-    cmocka_unit_test_setup_teardown(test_entry_dispose_clears_entry, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_entry_dispose_slot_reusable, asset_setup, asset_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_entry_dispose_clears_entry, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_entry_dispose_slot_reusable, asset_setup, asset_teardown
+    ),
 
     // assetRequireLoaded
-    cmocka_unit_test_setup_teardown(test_requireLoaded_already_loaded, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_requireLoaded_spins_to_loaded, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_requireLoaded_propagates_error, asset_setup, asset_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_requireLoaded_already_loaded, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_requireLoaded_spins_to_loaded, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_requireLoaded_propagates_error, asset_setup, asset_teardown
+    ),
 
     // assetReapUnused
-    cmocka_unit_test_setup_teardown(test_update_does_not_reap_automatically, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_reapUnused_disposes_zero_ref_loaded, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_reapUnused_ignores_referenced_entries, asset_setup, asset_teardown),
-    cmocka_unit_test_setup_teardown(test_getEntry_reaps_when_pool_full, asset_setup, asset_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_update_does_not_reap_automatically, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_reapUnused_disposes_zero_ref_loaded, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_reapUnused_ignores_referenced_entries, asset_setup, asset_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getEntry_reaps_when_pool_full, asset_setup, asset_teardown
+    ),
   };
   return cmocka_run_group_tests(tests, NULL, NULL);
 }

test/asset/test_assetjsonloader.c

@@ -240,10 +240,18 @@ static void test_json_buffer_cleared_after_load(void **state) {
 int main(void) {
   assertInit();
   const struct CMUnitTest tests[] = {
-    cmocka_unit_test_setup_teardown(test_json_valid_loads, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_json_parse_error, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_json_missing_file, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_json_buffer_cleared_after_load, zip_setup, zip_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_json_valid_loads, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_json_parse_error, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_json_missing_file, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_json_buffer_cleared_after_load, zip_setup, zip_teardown
+    ),
   };
   return cmocka_run_group_tests(tests, NULL, NULL);
 }

test/asset/test_assetlocale.c

@@ -104,10 +104,14 @@ static int locale_setup(void **state) {
 
   char_t header[512];
   ret = assetLocaleGetString(&g_locale, "", 0, header, sizeof(header));
-  if(errorIsNotOk(ret)) { errorCatch(ret); assetFileClose(&g_locale.file); goto fail; }
+  if(errorIsNotOk(ret)) {
+    errorCatch(ret); assetFileClose(&g_locale.file); goto fail;
+  }
 
   ret = assetLocaleParseHeader(&g_locale, header, sizeof(header));
-  if(errorIsNotOk(ret)) { errorCatch(ret); assetFileClose(&g_locale.file); goto fail; }
+  if(errorIsNotOk(ret)) {
+    errorCatch(ret); assetFileClose(&g_locale.file); goto fail;
+  }
 
   return 0;
 
@@ -309,7 +313,8 @@ static void test_evaluatePlural_less_than_boundary(void **state) {
 
 static void test_getString_simple(void **state) {
   char_t result[256];
-  errorret_t ret = assetLocaleGetString(&g_locale, "greeting", 0, result, sizeof(result));
+  errorret_t ret =
+    assetLocaleGetString(&g_locale, "greeting", 0, result, sizeof(result));
 
   assert_true(errorIsOk(ret));
   assert_string_equal(result, "Hello, World!");
@@ -321,7 +326,8 @@ static void test_getString_simple(void **state) {
 
 static void test_getString_plural_singular(void **state) {
   char_t result[256];
-  errorret_t ret = assetLocaleGetString(&g_locale, "item", 1, result, sizeof(result));
+  errorret_t ret =
+    assetLocaleGetString(&g_locale, "item", 1, result, sizeof(result));
 
   assert_true(errorIsOk(ret));
   assert_string_equal(result, "one item");
@@ -330,7 +336,8 @@ static void test_getString_plural_singular(void **state) {
 
 static void test_getString_plural_many(void **state) {
   char_t result[256];
-  errorret_t ret = assetLocaleGetString(&g_locale, "item", 5, result, sizeof(result));
+  errorret_t ret =
+    assetLocaleGetString(&g_locale, "item", 5, result, sizeof(result));
 
   assert_true(errorIsOk(ret));
   assert_string_equal(result, "many items");
@@ -353,7 +360,8 @@ static void test_getString_multiple_calls(void **state) {
 
 static void test_getString_missing_id(void **state) {
   char_t result[256];
-  errorret_t ret = assetLocaleGetString(&g_locale, "nonexistent", 0, result, sizeof(result));
+  errorret_t ret =
+    assetLocaleGetString(&g_locale, "nonexistent", 0, result, sizeof(result));
 
   assert_true(errorIsNotOk(ret));
   errorCatch(ret);
@@ -372,7 +380,8 @@ static void test_cache_findMiss_onEmptyCache(void **state) {
 
   char_t result[64];
   bool_t hit = true;
-  errorret_t ret = assetLocaleCacheFind(&locale, "greeting", 0, result, sizeof(result), &hit);
+  errorret_t ret =
+    assetLocaleCacheFind(&locale, "greeting", 0, result, sizeof(result), &hit);
 
   assert_true(errorIsOk(ret));
   assert_false(hit);
@@ -389,7 +398,8 @@ static void test_cache_insertThenFind_hits(void **state) {
 
   char_t result[64];
   bool_t hit = false;
-  errorret_t ret = assetLocaleCacheFind(&locale, "greeting", 0, result, sizeof(result), &hit);
+  errorret_t ret =
+    assetLocaleCacheFind(&locale, "greeting", 0, result, sizeof(result), &hit);
 
   assert_true(errorIsOk(ret));
   assert_true(hit);
@@ -409,7 +419,8 @@ static void test_cache_distinguishesByPluralCount(void **state) {
   char_t result[64];
   bool_t hit = false;
 
-  errorret_t ret = assetLocaleCacheFind(&locale, "item", 1, result, sizeof(result), &hit);
+  errorret_t ret =
+    assetLocaleCacheFind(&locale, "item", 1, result, sizeof(result), &hit);
   assert_true(errorIsOk(ret));
   assert_true(hit);
   assert_string_equal(result, "one item");
@@ -430,7 +441,8 @@ static void test_cache_find_missOnDifferentMessageId(void **state) {
 
   char_t result[64];
   bool_t hit = true;
-  errorret_t ret = assetLocaleCacheFind(&locale, "farewell", 0, result, sizeof(result), &hit);
+  errorret_t ret =
+    assetLocaleCacheFind(&locale, "farewell", 0, result, sizeof(result), &hit);
 
   assert_true(errorIsOk(ret));
   assert_false(hit);
@@ -446,7 +458,8 @@ static void test_cache_find_bufferTooSmall_errors(void **state) {
 
   char_t result[4];// too small for "Hello, World!"
   bool_t hit = false;
-  errorret_t ret = assetLocaleCacheFind(&locale, "greeting", 0, result, sizeof(result), &hit);
+  errorret_t ret =
+    assetLocaleCacheFind(&locale, "greeting", 0, result, sizeof(result), &hit);
 
   assert_true(errorIsNotOk(ret));
   errorCatch(ret);
@@ -502,7 +515,8 @@ static void test_cache_insert_evictsLeastRecentlyUsed(void **state) {
 
   char_t result[32];
   bool_t hit = true;
-  errorret_t ret = assetLocaleCacheFind(&locale, "id0", 0, result, sizeof(result), &hit);
+  errorret_t ret =
+    assetLocaleCacheFind(&locale, "id0", 0, result, sizeof(result), &hit);
   assert_true(errorIsOk(ret));
   assert_false(hit);
 
@@ -530,7 +544,8 @@ static void test_cache_find_movesHitToFront(void **state) {
 
   char_t result[32];
   bool_t hit = false;
-  errorret_t ret = assetLocaleCacheFind(&locale, "id0", 0, result, sizeof(result), &hit);
+  errorret_t ret =
+    assetLocaleCacheFind(&locale, "id0", 0, result, sizeof(result), &hit);
   assert_true(errorIsOk(ret));
   assert_true(hit);
 
@@ -594,7 +609,8 @@ static void test_localeDispose_freesCache(void **state) {
   zip_source_free(write_src);
 
   zip_error_init(&err);
-  zip_source_t *read_src = zip_source_buffer_create(zipbuf, (zip_uint64_t)zs.size, 1, &err);
+  zip_source_t *read_src =
+    zip_source_buffer_create(zipbuf, (zip_uint64_t)zs.size, 1, &err);
   assert_non_null(read_src);
   zip_t *zip = zip_open_from_source(read_src, 0, &err);
   assert_non_null(zip);
@@ -604,7 +620,8 @@ static void test_localeDispose_freesCache(void **state) {
   memoryZero(&entry, sizeof(entry));
   entry.type = ASSET_LOADER_TYPE_LOCALE;
 
-  errorret_t ret = assetFileInit(&entry.data.locale.file, "en.locale", NULL, NULL);
+  errorret_t ret =
+    assetFileInit(&entry.data.locale.file, "en.locale", NULL, NULL);
   assert_true(errorIsOk(ret));
   ret = assetFileOpen(&entry.data.locale.file);
   assert_true(errorIsOk(ret));
@@ -679,15 +696,29 @@ int main(void) {
     cmocka_unit_test(test_evaluatePlural_less_than_boundary),
 
     // getString  -  in-memory ZIP
-    cmocka_unit_test_setup_teardown(test_getString_simple, locale_setup, locale_teardown),
-    cmocka_unit_test_setup_teardown(test_getString_plural_singular, locale_setup, locale_teardown),
-    cmocka_unit_test_setup_teardown(test_getString_plural_many, locale_setup, locale_teardown),
-    cmocka_unit_test_setup_teardown(test_getString_multiple_calls, locale_setup, locale_teardown),
-    cmocka_unit_test_setup_teardown(test_getString_missing_id, locale_setup, locale_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_getString_simple, locale_setup, locale_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getString_plural_singular, locale_setup, locale_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getString_plural_many, locale_setup, locale_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getString_multiple_calls, locale_setup, locale_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getString_missing_id, locale_setup, locale_teardown
+    ),
 
     // getStringWithArgs  -  in-memory ZIP
-    cmocka_unit_test_setup_teardown(test_getStringWithArgs_int, locale_setup, locale_teardown),
-    cmocka_unit_test_setup_teardown(test_getStringWithArgs_string, locale_setup, locale_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_getStringWithArgs_int, locale_setup, locale_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_getStringWithArgs_string, locale_setup, locale_teardown
+    ),
 
     // assetLocaleCacheFind / assetLocaleCacheInsert  -  pure
     cmocka_unit_test(test_cache_findMiss_onEmptyCache),

test/asset/test_assettilesetloader.c

@@ -124,7 +124,9 @@ static bool_t run_tileset_async(assetloading_t *loading) {
 
 static zip_t *g_zip = NULL;
 
-static int tileset_zip_add(zip_t *za, const char_t *name, const void *data, size_t len) {
+static int tileset_zip_add(
+  zip_t *za, const char_t *name, const void *data, size_t len
+) {
   zip_source_t *s = zip_source_buffer(za, data, len, 0);
   return (int)zip_file_add(za, name, s, ZIP_FL_OVERWRITE);
 }
@@ -139,14 +141,30 @@ static int zip_setup(void **state) {
   zip_t *za = zip_open_from_source(write_src, ZIP_TRUNCATE, &err);
   if(!za) { zip_source_free(write_src); return -1; }
 
-  if(tileset_zip_add(za, "valid.tileset",       DTF_VALID,        sizeof(DTF_VALID))        < 0 ||
-     tileset_zip_add(za, "badmagic.tileset",    DTF_BAD_MAGIC,    sizeof(DTF_BAD_MAGIC))    < 0 ||
-     tileset_zip_add(za, "badversion.tileset",  DTF_BAD_VERSION,  sizeof(DTF_BAD_VERSION))  < 0 ||
-     tileset_zip_add(za, "zerowidth.tileset",   DTF_ZERO_WIDTH,   sizeof(DTF_ZERO_WIDTH))   < 0 ||
-     tileset_zip_add(za, "zeroheight.tileset",  DTF_ZERO_HEIGHT,  sizeof(DTF_ZERO_HEIGHT))  < 0 ||
-     tileset_zip_add(za, "zerocolumns.tileset", DTF_ZERO_COLUMNS, sizeof(DTF_ZERO_COLUMNS)) < 0 ||
-     tileset_zip_add(za, "zerorows.tileset",    DTF_ZERO_ROWS,    sizeof(DTF_ZERO_ROWS))    < 0 ||
-     tileset_zip_add(za, "invaliduv.tileset",   DTF_INVALID_UV,   sizeof(DTF_INVALID_UV))   < 0) {
+  if(
+    tileset_zip_add(za, "valid.tileset", DTF_VALID, sizeof(DTF_VALID)) < 0 ||
+    tileset_zip_add(
+      za, "badmagic.tileset", DTF_BAD_MAGIC, sizeof(DTF_BAD_MAGIC)
+    ) < 0 ||
+    tileset_zip_add(
+      za, "badversion.tileset", DTF_BAD_VERSION, sizeof(DTF_BAD_VERSION)
+    ) < 0 ||
+    tileset_zip_add(
+      za, "zerowidth.tileset", DTF_ZERO_WIDTH, sizeof(DTF_ZERO_WIDTH)
+    ) < 0 ||
+    tileset_zip_add(
+      za, "zeroheight.tileset", DTF_ZERO_HEIGHT, sizeof(DTF_ZERO_HEIGHT)
+    ) < 0 ||
+    tileset_zip_add(
+      za, "zerocolumns.tileset", DTF_ZERO_COLUMNS, sizeof(DTF_ZERO_COLUMNS)
+    ) < 0 ||
+    tileset_zip_add(
+      za, "zerorows.tileset", DTF_ZERO_ROWS, sizeof(DTF_ZERO_ROWS)
+    ) < 0 ||
+    tileset_zip_add(
+      za, "invaliduv.tileset", DTF_INVALID_UV, sizeof(DTF_INVALID_UV)
+    ) < 0
+  ) {
     zip_close(za); return -1;
   }
 
@@ -369,16 +387,36 @@ static void test_tileset_missing_file(void **state) {
 int main(void) {
   assertInit();
   const struct CMUnitTest tests[] = {
-    cmocka_unit_test_setup_teardown(test_tileset_valid_loads, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_data_cleared_after_load, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_bad_magic, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_bad_version, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_zero_tile_width, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_zero_tile_height, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_zero_columns, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_zero_rows, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_invalid_uv, zip_setup, zip_teardown),
-    cmocka_unit_test_setup_teardown(test_tileset_missing_file, zip_setup, zip_teardown),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_valid_loads, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_data_cleared_after_load, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_bad_magic, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_bad_version, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_zero_tile_width, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_zero_tile_height, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_zero_columns, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_zero_rows, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_invalid_uv, zip_setup, zip_teardown
+    ),
+    cmocka_unit_test_setup_teardown(
+      test_tileset_missing_file, zip_setup, zip_teardown
+    ),
   };
   return cmocka_run_group_tests(tests, NULL, NULL);
 }

test/rpg/battle/test_battle.c

@@ -17,7 +17,8 @@ static const cutsceneitem_t CUTSCENE_TEST_SCRATCH_ITEMS[] = {
   // reach PRE_ROUND on its own to satisfy the wait.
   CUTSCENE_BATTLE_WAIT_STATE(BATTLE_STATE_PRE_ROUND),
   CUTSCENE_SET_PAUSE(CUTSCENE_PAUSE_BATTLE),
-  CUTSCENE_BATTLE_FORCE_ACTION(2, 0),// enemy (slot 2) forced onto allyA (slot 0)
+  // enemy (slot 2) forced onto allyA (slot 0)
+  CUTSCENE_BATTLE_FORCE_ACTION(2, 0),
   CUTSCENE_SET_PAUSE(CUTSCENE_PAUSE_NONE)
 };
 static const cutscene_t CUTSCENE_TEST_SCRATCH = {
@@ -45,8 +46,12 @@ static void test_battleStartEntersOpeningThenPreRound(void **state) {
 
 
   battleInit();
-  addFighter(BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 10, 0, 10, 20);
-  addFighter(BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI, 10, 0, 5, 20);
+  addFighter(
+    BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 10, 0, 10, 20
+  );
+  addFighter(
+    BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI, 10, 0, 5, 20
+  );
 
   battleStart(BATTLE_ENCOUNTER_REGULAR, true);
   assert_int_equal(BATTLE.state, BATTLE_STATE_OPENING);
@@ -231,8 +236,12 @@ static void test_battleFleeEndsInStateEndedImmediately(void **state) {
 
 
   battleInit();
-  addFighter(BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 5, 0, 10, 20);
-  addFighter(BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI, 5, 0, 5, 20);
+  addFighter(
+    BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 5, 0, 10, 20
+  );
+  addFighter(
+    BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI, 5, 0, 5, 20
+  );
 
   battleStart(BATTLE_ENCOUNTER_REGULAR, true);
   battleUpdate();// OPENING -> PRE_ROUND
@@ -247,8 +256,12 @@ static void test_battleFleeUnavailableIsIgnored(void **state) {
 
 
   battleInit();
-  addFighter(BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 5, 0, 10, 20);
-  addFighter(BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI, 5, 0, 5, 20);
+  addFighter(
+    BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 5, 0, 10, 20
+  );
+  addFighter(
+    BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI, 5, 0, 5, 20
+  );
 
   battleStart(BATTLE_ENCOUNTER_REGULAR, false);
   battleUpdate();// OPENING -> PRE_ROUND
@@ -279,7 +292,9 @@ static void test_battleOnStateChangedFiresAcrossFullRound(void **state) {
   stateChangedCount = 0;
   BATTLE.onStateChanged = recordStateChanged;
 
-  addFighter(BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 1, 0, 10, 100);
+  addFighter(
+    BATTLE_FIGHTER_TEAM_ALLY, BATTLE_FIGHTER_CONTROLLER_PLAYER, 1, 0, 10, 100
+  );
   battlefighter_t *enemy = addFighter(
     BATTLE_FIGHTER_TEAM_ENEMY, BATTLE_FIGHTER_CONTROLLER_AI, 1, 0, 5, 100
   );
@@ -410,10 +425,13 @@ static void test_battleCutsceneForceActionOverridesTarget(void **state) {
   battlePlayerAttack(enemy->id);// allyA -> AI_SELECTION would be next...
   assert_ptr_equal(battleGetCurrentFighter(), allyB);
   battlePlayerAttack(enemy->id);// ...but AI_SELECTION must skip the enemy,
-  assert_int_equal(BATTLE.state, BATTLE_STATE_AI_SELECTION);// since it's decided
+  // since it's decided
+  assert_int_equal(BATTLE.state, BATTLE_STATE_AI_SELECTION);
 
-  battleUpdate();// AI_SELECTION: enemy already decided, skipped -> MOVES_EXECUTING
-  assert_int_equal(BATTLE.actions[enemy->id].targetIndex, allyA->id);// untouched
+  // AI_SELECTION: enemy already decided, skipped -> MOVES_EXECUTING
+  battleUpdate();
+  // untouched
+  assert_int_equal(BATTLE.actions[enemy->id].targetIndex, allyA->id);
 
   battleUpdate();// allyA attacks enemy
   battleUpdate();// allyB attacks enemy
@@ -435,7 +453,9 @@ int main(int argc, char** argv) {
     cmocka_unit_test(test_battleFleeEndsInStateEndedImmediately),
     cmocka_unit_test(test_battleFleeUnavailableIsIgnored),
     cmocka_unit_test(test_battleOnStateChangedFiresAcrossFullRound),
-    cmocka_unit_test(test_battleOnActionDecidedFiresPerFighterRegardlessOfSource),
+    cmocka_unit_test(
+      test_battleOnActionDecidedFiresPerFighterRegardlessOfSource
+    ),
     cmocka_unit_test(test_battleCutsceneForceActionOverridesTarget),
   };
 

test/rpg/cutscene/test_cutscenecontrol.c

@@ -54,7 +54,8 @@ static void test_cutsceneCallbackFiresOnStartWithUserData(void **state) {
 static void test_cutsceneCallbackNullIsNoop(void **state) {
 
   callbackCallCount = 0;
-  cutsceneitem_t item = { .type = CUTSCENE_ITEM_TYPE_CALLBACK, .callback = NULL };
+  cutsceneitem_t item =
+    { .type = CUTSCENE_ITEM_TYPE_CALLBACK, .callback = NULL };
   cutsceneitemdata_t data;
 
   cutsceneCallbackStart(&item, &data);// should not crash

test/rpg/cutscene/test_cutscenemaparea.c

@@ -60,7 +60,8 @@ static void test_cutsceneMapAreaRemoveResolvesLastCreatedSentinel(
   cutsceneMapAreaAddStart(&addItem, &data);
   uint8_t id = CUTSCENE_SYSTEM.areaLastCreated;
 
-  cutsceneitem_t removeItem = CUTSCENE_MAP_AREA_REMOVE(CUTSCENE_AREA_LAST_CREATED);
+  cutsceneitem_t removeItem =
+    CUTSCENE_MAP_AREA_REMOVE(CUTSCENE_AREA_LAST_CREATED);
   cutsceneMapAreaRemoveStart(&removeItem, &data);
   assert_null(MAP_AREAS[id].callback);
 }
@@ -135,7 +136,9 @@ int main(int argc, char** argv) {
     cmocka_unit_test(test_cutsceneMapAreaRemoveClearsSlot),
     cmocka_unit_test(test_cutsceneMapAreaRemoveResolvesLastCreatedSentinel),
     cmocka_unit_test(test_cutsceneMapAreaWaitCompletesWhenTriggerCountChanges),
-    cmocka_unit_test(test_cutsceneMapAreaWaitCompletesWhenAnyWatchedAreaChanges),
+    cmocka_unit_test(
+      test_cutsceneMapAreaWaitCompletesWhenAnyWatchedAreaChanges
+    ),
     cmocka_unit_test(test_cutsceneMapAreaWaitResolvesLastCreatedSentinel),
   };
 

test/rpg/cutscene/test_cutscenesystem.c

@@ -126,7 +126,9 @@ static void test_cutsceneSystemGetEntityDirectIndexUpdatesLastRef(
   entity_t *resolved = cutsceneSystemGetEntity(2);
   assert_ptr_equal(resolved, &ENTITIES[2]);
   // Resolving by direct index also updates LAST_REF.
-  assert_ptr_equal(cutsceneSystemGetEntity(CUTSCENE_ENTITY_LAST_REF), &ENTITIES[2]);
+  assert_ptr_equal(
+    cutsceneSystemGetEntity(CUTSCENE_ENTITY_LAST_REF), &ENTITIES[2]
+  );
 }
 
 static void test_cutsceneSystemGetAreaId(void **state) {

test/rpg/entity/test_entity.c

@@ -10,7 +10,9 @@
 #include "rpg/overworld/map.h"
 #include "rpg/overworld/worldpos.h"
 
-static void setTile(const worldpos_t pos, const tileshape_t shape, const uint8_t z) {
+static void setTile(
+  const worldpos_t pos, const tileshape_t shape, const uint8_t z
+) {
   chunktileindex_t index = worldPosToChunkTileIndex(&pos);
   MAP.chunks[0].tiles[index] = (tile_t){ .shape = shape, .z = z };
 }

test/rpg/entity/test_entityinteract.c

@@ -57,7 +57,9 @@ static void test_entityInteractWithPrintTurnsNpcToFacePlayer(void **state) {
   entityInteractWith(player, target);
 
   assert_true(uiTextboxMainIsActive());
-  assert_int_equal(target->data.npc.interactState, NPC_INTERACT_STATE_CONVERSING);
+  assert_int_equal(
+    target->data.npc.interactState, NPC_INTERACT_STATE_CONVERSING
+  );
   // NPC turns to face the opposite of the player's facing direction.
   assert_int_equal(target->direction, entityDirGetOpposite(player->direction));
 }

test/rpg/overworld/test_maparea.c

@@ -33,7 +33,9 @@ static void test_mapAreaInit(void **state) {
   const worldpos_t max = { 0, 0, 0 };
 
   // min/max should be normalized regardless of argument order.
-  mapAreaInit(&area, min, max, recordCallback, MAP_AREA_NOTIFY_ALL, MAP_TRIGGER_ALL);
+  mapAreaInit(
+    &area, min, max, recordCallback, MAP_AREA_NOTIFY_ALL, MAP_TRIGGER_ALL
+  );
   assert_int_equal(area.min.x, 0);
   assert_int_equal(area.min.y, 0);
   assert_int_equal(area.max.x, 5);
@@ -56,7 +58,9 @@ static void test_mapAreaIsInside(void **state) {
 
   assert_true(mapAreaIsInside(&area, (worldpos_t){ 5, 5, 0 }));
   assert_true(mapAreaIsInside(&area, (worldpos_t){ 0, 0, 0 }));// inclusive min
-  assert_true(mapAreaIsInside(&area, (worldpos_t){ 10, 10, 0 }));// inclusive max
+  assert_true(
+    mapAreaIsInside(&area, (worldpos_t){ 10, 10, 0 })
+  );// inclusive max
   assert_false(mapAreaIsInside(&area, (worldpos_t){ 11, 5, 0 }));
   assert_false(mapAreaIsInside(&area, (worldpos_t){ 5, 5, 1 }));
 }

test/save/savetestfixture.c

@@ -36,7 +36,8 @@ int saveTestFixtureSetup(void **state) {
   SAVE_TEST_FIXTURE_HAD_REAL_HOME = realHome != NULL;
   if(realHome != NULL) {
     stringCopy(
-      SAVE_TEST_FIXTURE_REAL_HOME, realHome, sizeof(SAVE_TEST_FIXTURE_REAL_HOME) - 1
+      SAVE_TEST_FIXTURE_REAL_HOME, realHome,
+      sizeof(SAVE_TEST_FIXTURE_REAL_HOME) - 1
     );
   }
 
@@ -55,7 +56,10 @@ int saveTestFixtureSetup(void **state) {
 }
 
 int saveTestFixtureTeardown(void **state) {
-  nftw(SAVE_TEST_FIXTURE_HOME, saveTestFixtureRemoveEntry, 16, FTW_DEPTH | FTW_PHYS);
+  nftw(
+    SAVE_TEST_FIXTURE_HOME, saveTestFixtureRemoveEntry, 16,
+    FTW_DEPTH | FTW_PHYS
+  );
 
   if(SAVE_TEST_FIXTURE_HAD_REAL_HOME) {
     setenv("HOME", SAVE_TEST_FIXTURE_REAL_HOME, 1);

test/save/test_save.c

@@ -299,7 +299,9 @@ static void test_saveSaveSlot_success(void **state) {
   makeDeviceAvailable();
   SAVE.slotCurrent = 1;
   saveSlotInit(&SAVE.slot);
-  stringCopy(SAVE.slot.cachedData.name, "Hero", sizeof(SAVE.slot.cachedData.name));
+  stringCopy(
+    SAVE.slot.cachedData.name, "Hero", sizeof(SAVE.slot.cachedData.name)
+  );
   SAVE.slot.cachedData.playerLevel = 12;
   SAVE.slotDirty = true;
 
@@ -353,7 +355,9 @@ static void test_saveLoadSlot_deviceReadFails_cacheStaysStale(void **state) {
   makeDeviceAvailable();
 
   char_t slotPath[512];
-  errorret_t pathRet = saveDeviceLinuxGetSlotPath(slotPath, sizeof(slotPath), 0);
+  errorret_t pathRet = saveDeviceLinuxGetSlotPath(
+    slotPath, sizeof(slotPath), 0
+  );
   assert_true(errorIsOk(pathRet));
   FILE *file = fopen(slotPath, "w");
   assert_non_null(file);
@@ -428,7 +432,9 @@ static void test_saveLoadAllSlots_middleSlotCorrupt_stopsAtFailingIndex(
   assert_true(errorIsOk(saveRet));
 
   char_t slotPath[512];
-  errorret_t pathRet = saveDeviceLinuxGetSlotPath(slotPath, sizeof(slotPath), 1);
+  errorret_t pathRet = saveDeviceLinuxGetSlotPath(
+    slotPath, sizeof(slotPath), 1
+  );
   assert_true(errorIsOk(pathRet));
   FILE *file = fopen(slotPath, "w");
   assert_non_null(file);
@@ -487,7 +493,8 @@ int main(void) {
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_saveUpdate_noopWhenNotFinding, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveUpdate_noopWhenNotFinding,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
 
     cmocka_unit_test_setup_teardown(
@@ -537,7 +544,8 @@ int main(void) {
       saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveSaveSettings_notDirty_isNoop, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveSaveSettings_notDirty_isNoop,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
       test_saveSaveSettings_dirtyForced_writesAndClearsFlag,
@@ -553,19 +561,23 @@ int main(void) {
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_saveSaveSlot_noCurrentDeviceAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveSaveSlot_noCurrentDeviceAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveSaveSlot_invalidSlotIndexAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveSaveSlot_invalidSlotIndexAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
       test_saveSaveSlot_success, saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveLoadSlot_noCurrentDeviceAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveLoadSlot_noCurrentDeviceAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveLoadSlot_invalidSlotIndexAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveLoadSlot_invalidSlotIndexAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
       test_saveLoadSlot_success, saveTestFixtureSetup, saveTestFixtureTeardown

test/save/test_savedevice.c

@@ -258,30 +258,38 @@ int main(void) {
   assertInit();
   const struct CMUnitTest tests[] = {
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceInit_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceInit_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceInit_setsUnknownState, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceInit_setsUnknownState,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceUpdate_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceUpdate_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceUpdate_firesQueuedCallbackOnce, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceUpdate_firesQueuedCallbackOnce,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceFireCallback_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceFireCallback_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceFireCallback_setsFlag, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceFireCallback_setsFlag,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceFireCallback_assertsIfAlreadyQueued, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceFireCallback_assertsIfAlreadyQueued,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceCheckAvailability_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceCheckAvailability_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
       test_saveDeviceCheckAvailability_assertsWhileAlreadyChecking,
@@ -293,29 +301,37 @@ int main(void) {
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceSlotWrite_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceSlotWrite_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceSlotRead_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceSlotRead_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceSettingsWrite_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceSettingsWrite_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceSettingsRead_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceSettingsRead_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceSlot_dispatchesToPlatform, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceSlot_dispatchesToPlatform,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceSettings_dispatchesToPlatform, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceSettings_dispatchesToPlatform,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceDispose_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceDispose_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_saveDeviceDispose_succeeds, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_saveDeviceDispose_succeeds,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
   };
 

test/save/test_savedevicelinux.c

@@ -250,7 +250,8 @@ static void test_slotRead_corruptFile_errors(void **state) {
   assert_int_equal(tmpDevice.state, SAVE_DEVICE_STATE_AVAILABLE);
 
   char_t slotPath[512];
-  errorret_t pathRet = saveDeviceLinuxGetSlotPath(slotPath, sizeof(slotPath), 0);
+  errorret_t pathRet =
+    saveDeviceLinuxGetSlotPath(slotPath, sizeof(slotPath), 0);
   assert_true(errorIsOk(pathRet));
 
   FILE *file = fopen(slotPath, "w");
@@ -334,7 +335,8 @@ static void test_settingsRead_corruptFile_errors(void **state) {
   assert_int_equal(tmpDevice.state, SAVE_DEVICE_STATE_AVAILABLE);
 
   char_t settingsPath[512];
-  errorret_t pathRet = saveDeviceLinuxGetSettingsPath(settingsPath, sizeof(settingsPath));
+  errorret_t pathRet =
+    saveDeviceLinuxGetSettingsPath(settingsPath, sizeof(settingsPath));
   assert_true(errorIsOk(pathRet));
 
   FILE *file = fopen(settingsPath, "w");
@@ -357,38 +359,48 @@ int main(void) {
       test_getDirectory_success, saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_getDirectory_homeUnset_errors, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_getDirectory_homeUnset_errors,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_getDirectory_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_getDirectory_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_getSettingsPath_success, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_getSettingsPath_success,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_getSettingsPath_homeUnset_errors, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_getSettingsPath_homeUnset_errors,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
       test_getSlotPath_success, saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_getSlotPath_homeUnset_errors, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_getSlotPath_homeUnset_errors,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_checkAvailability_wrongStateAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_checkAvailability_wrongStateAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_checkAvailability_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_checkAvailability_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_checkAvailability_success, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_checkAvailability_success,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_checkAvailability_homeUnset, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_checkAvailability_homeUnset,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_checkAvailability_mkdirpFails, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_checkAvailability_mkdirpFails,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
 
     cmocka_unit_test_setup_teardown(
@@ -398,29 +410,37 @@ int main(void) {
       test_slotRead_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_slotWriteRead_roundTrip, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_slotWriteRead_roundTrip,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_slotRead_noFileYet_leavesSlotUntouched, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_slotRead_noFileYet_leavesSlotUntouched,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_slotRead_corruptFile_errors, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_slotRead_corruptFile_errors,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
 
     cmocka_unit_test_setup_teardown(
-      test_settingsWrite_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_settingsWrite_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_settingsRead_nullAsserts, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_settingsRead_nullAsserts,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_settingsWriteRead_roundTrip, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_settingsWriteRead_roundTrip,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_settingsRead_noFileYet_leavesUntouched, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_settingsRead_noFileYet_leavesUntouched,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
     cmocka_unit_test_setup_teardown(
-      test_settingsRead_corruptFile_errors, saveTestFixtureSetup, saveTestFixtureTeardown
+      test_settingsRead_corruptFile_errors,
+      saveTestFixtureSetup, saveTestFixtureTeardown
     ),
   };
 

test/save/test_savesettings.c

@@ -37,7 +37,9 @@ static errorret_t settingsToJSON(
   errorOk();
 }
 
-static errorret_t settingsFromJSON(savesettings_t *settings, const char_t *json) {
+static errorret_t settingsFromJSON(
+  savesettings_t *settings, const char_t *json
+) {
   readInit(json, strlen(json));
   errorret_t readResult = saveSettingsReadJSON(settings, object);
   yyjson_doc_free(jsonDoc);

test/save/test_saveslot.c

@@ -18,7 +18,9 @@
 // inside a function returning errorret_t) so tests can call them plainly.
 // ============================================================
 
-static errorret_t slotToJSON(saveslot_t *slot, char_t **outJson, size_t *outLen) {
+static errorret_t slotToJSON(
+  saveslot_t *slot, char_t **outJson, size_t *outLen
+) {
   writeInit();
 
   errorret_t writeResult = saveSlotWriteJSON(slot, doc, object);

test/util/test_memory.c

@@ -100,8 +100,12 @@ static void test_memoryCopy(void **state) {
 
   // Overlapping regions (should assert)
   void *overlap = memoryAllocate(size * 2);
-  expect_assert_failure(memoryCopy((uint8_t*)overlap, (uint8_t*)overlap + 8, size));
-  expect_assert_failure(memoryCopy((uint8_t*)overlap + 8, (uint8_t*)overlap, size));
+  expect_assert_failure(
+    memoryCopy((uint8_t*)overlap, (uint8_t*)overlap + 8, size)
+  );
+  expect_assert_failure(
+    memoryCopy((uint8_t*)overlap + 8, (uint8_t*)overlap, size)
+  );
   memoryFree(overlap);
 
   memoryFree(src);
@@ -198,22 +202,32 @@ static void test_memoryCopyRangeSafe(void **state) {
   assert_memory_equal(dest, src, size);
 
   // Cannot copy to NULL destination
-  expect_assert_failure(memoryCopyRangeSafe(NULL, src, (uint8_t*)src + 5, size));
-  
+  expect_assert_failure(
+    memoryCopyRangeSafe(NULL, src, (uint8_t*)src + 5, size)
+  );
+
   // Cannot copy from NULL start
-  expect_assert_failure(memoryCopyRangeSafe(dest, NULL, (uint8_t*)src + 5, size));
-  
+  expect_assert_failure(
+    memoryCopyRangeSafe(dest, NULL, (uint8_t*)src + 5, size)
+  );
+
   // Cannot copy from NULL end
   expect_assert_failure(memoryCopyRangeSafe(dest, (uint8_t*)src, NULL, size));
-  
+
   // Start and end are the same
-  expect_assert_failure(memoryCopyRangeSafe(dest, (uint8_t*)src, (uint8_t*)src, size));
-  
+  expect_assert_failure(
+    memoryCopyRangeSafe(dest, (uint8_t*)src, (uint8_t*)src, size)
+  );
+
   // End is before start
-  expect_assert_failure(memoryCopyRangeSafe(dest, (uint8_t*)src + 5, (uint8_t*)src + 2, size));
-  
+  expect_assert_failure(
+    memoryCopyRangeSafe(dest, (uint8_t*)src + 5, (uint8_t*)src + 2, size)
+  );
+
   // Size to copy exceeds maximum
-  expect_assert_failure(memoryCopyRangeSafe(dest, (uint8_t*)src, (uint8_t*)src + 10, 5));
+  expect_assert_failure(
+    memoryCopyRangeSafe(dest, (uint8_t*)src, (uint8_t*)src + 10, 5)
+  );
 
   memoryFree(src);
   memoryFree(dest);

test/util/test_sort.c

@@ -77,7 +77,8 @@ void testSortMethod(
   int_t compareStructsValues(const void *a, const void *b) {
     const teststruct_t *structA = (const teststruct_t*)a;
     const teststruct_t *structB = (const teststruct_t*)b;
-    return (structA->value > structB->value) - (structA->value < structB->value);
+    return
+      (structA->value > structB->value) - (structA->value < structB->value);
   }
   sortMethod(structArray, 4, sizeof(teststruct_t), compareStructsValues);
   char expectedValues[4] = {'a', 'b', 'c', 'd'};

test/util/test_string.c

@@ -207,7 +207,11 @@ static void test_stringFormat(void **state) {
 
   // Test buffer too small
   expect_assert_failure(stringFormat(buffer, 5, "This is too long"));
-  expect_assert_failure(stringFormat(buffer, sizeof(buffer), "Hello %s", "This string is way too long to fit within the buffer that we have allocated"));
+  expect_assert_failure(stringFormat(
+    buffer, sizeof(buffer), "Hello %s",
+    "This string is way too long to fit within the buffer that we have "
+    "allocated"
+  ));
 
   // Test NULL destination, simply returns required length
   len = stringFormat(NULL, 0, "Hello %s!", "World");