test-job-type: modernize code a bit

1 files changed, 19 insertions, 22 deletions

diff --git a/src/test/test-job-type.c b/src/test/test-job-type.c
index 024d976a75..0a9b6dc249 100644
--- a/src/test/test-job-type.c
+++ b/src/test/test-job-type.c
@@ -6,27 +6,24 @@
 #include "unit.h"
 
 int main(int argc, char *argv[]) {
-        JobType a, b, c, ab, bc, ab_c, bc_a, a_bc;
         const ServiceState test_states[] = { SERVICE_DEAD, SERVICE_RUNNING };
-        unsigned i;
-        bool merged_ab;
-
-        /* fake a unit */
-        static Service s = {
-                .meta.load_state = UNIT_LOADED,
-                .type = SERVICE_SIMPLE,
-        };
-        Unit *u = UNIT(&s);
-
-        for (i = 0; i < ELEMENTSOF(test_states); i++) {
-                s.state = test_states[i];
+
+        for (size_t i = 0; i < ELEMENTSOF(test_states); i++) {
+                /* fake a unit */
+                Service s = {
+                        .meta.load_state = UNIT_LOADED,
+                        .type = SERVICE_SIMPLE,
+                        .state = test_states[i],
+                };
+                Unit *u = UNIT(&s);
+
                 printf("\nWith collapsing for service state %s\n"
                        "=========================================\n", service_state_to_string(s.state));
-                for (a = 0; a < _JOB_TYPE_MAX_MERGING; a++) {
-                        for (b = 0; b < _JOB_TYPE_MAX_MERGING; b++) {
+                for (JobType a = 0; a < _JOB_TYPE_MAX_MERGING; a++) {
+                        for (JobType b = 0; b < _JOB_TYPE_MAX_MERGING; b++) {
 
-                                ab = a;
-                                merged_ab = (job_type_merge_and_collapse(&ab, b, u) >= 0);
+                                JobType ab = a;
+                                bool merged_ab = job_type_merge_and_collapse(&ab, b, u) >= 0;
 
                                 if (!job_type_is_mergeable(a, b)) {
                                         assert_se(!merged_ab);
@@ -37,7 +34,7 @@ int main(int argc, char *argv[]) {
                                 assert_se(merged_ab);
                                 printf("%s + %s = %s\n", job_type_to_string(a), job_type_to_string(b), job_type_to_string(ab));
 
-                                for (c = 0; c < _JOB_TYPE_MAX_MERGING; c++) {
+                                for (JobType c = 0; c < _JOB_TYPE_MAX_MERGING; c++) {
 
                                         /* Verify transitivity of mergeability of job types */
                                         assert_se(!job_type_is_mergeable(a, b) ||
@@ -53,18 +50,18 @@ int main(int argc, char *argv[]) {
                                          * either a or b is not mergeable with c either. */
                                         assert_se(job_type_is_mergeable(ab, c) || !job_type_is_mergeable(a, c) || !job_type_is_mergeable(b, c));
 
-                                        bc = b;
+                                        JobType bc = b;
                                         if (job_type_merge_and_collapse(&bc, c, u) >= 0) {
 
                                                 /* Verify associativity */
 
-                                                ab_c = ab;
+                                                JobType ab_c = ab;
                                                 assert_se(job_type_merge_and_collapse(&ab_c, c, u) == 0);
 
-                                                bc_a = bc;
+                                                JobType bc_a = bc;
                                                 assert_se(job_type_merge_and_collapse(&bc_a, a, u) == 0);
 
-                                                a_bc = a;
+                                                JobType a_bc = a;
                                                 assert_se(job_type_merge_and_collapse(&a_bc, bc, u) == 0);
 
                                                 assert_se(ab_c == bc_a);