Update .clang-format and run it on filse

1 files changed, 26 insertions, 35 deletions

diff --git a/tests/test_memory.c b/tests/test_memory.c
index 6e523aa..0f4ccab 100644
--- a/tests/test_memory.c
+++ b/tests/test_memory.c
@@ -5,9 +5,9 @@
 #include <stdlib.h>
 
 #include "arch.h"
-#include "test_harness.c"
 #include "kern/common.h"
 #include "kern/mem.h"
+#include "test_harness.c"
 
 struct TEST_STRUCT {
   uint32_t array[3];
@@ -23,12 +23,12 @@ typedef struct KALLOC_NODE {
     uint32_t header;
     struct {
       /* Is this memory block currently in use (hasn't been kfree'd) */
-      bool     used:1;
+      bool used : 1;
       /* Number of words allocated. Does not include the header. */
-      uint16_t size:12;
+      uint16_t size : 12;
       /* The location of the previous block (in WORDS from offest) */
-      uint16_t prev:12;
-      uint8_t canary:7;
+      uint16_t prev : 12;
+      uint8_t canary : 7;
     } PACKED;
   };
 
@@ -43,11 +43,10 @@ static void wipeout_kalloc()
   kalloc_start = NULL;
 }
 
-
 static struct TEST_STRUCT* new_test_struct()
 {
   struct TEST_STRUCT* ret = kalloc(sizeof(struct TEST_STRUCT));
-  
+
   ret->array[0] = 1;
   ret->array[1] = 2;
   ret->array[2] = 3;
@@ -58,20 +57,18 @@ static struct TEST_STRUCT* new_test_struct()
 static struct TEST_STRUCT2* new_test_struct2()
 {
   struct TEST_STRUCT2* ret = kalloc(sizeof(struct TEST_STRUCT2));
-  
-  for (int i = 0; i < 10; ++ i) {
+
+  for (int i = 0; i < 10; ++i) {
     ret->array[i] = i;
   }
 
   return ret;
 }
 
-#define ASSERT_CHAIN(t1, t2) \
-  ASSERT_EQ(V(t1) + sizeof(*t1) + 4, V(t2))
+#define ASSERT_CHAIN(t1, t2) ASSERT_EQ(V(t1) + sizeof(*t1) + 4, V(t2))
 
 TEST(memory, kalloc)
 {
-
 #define V(x) ((void*)(x))
   struct TEST_STRUCT* test1 = new_test_struct();
   struct TEST_STRUCT2* test2 = new_test_struct2();
@@ -90,14 +87,9 @@ TEST(memory, kalloc)
   ASSERT_CHAIN(test3, test4);
   ASSERT_CHAIN(test4, test5);
 
-
   char buf[1024];
   if (debug_kalloc_assert_consistency(buf, 1024)) {
-    fprintf(
-        stderr,
-        "Consistency check failed. (%s:%d)\n",
-        __FILE__,
-        __LINE__);
+    fprintf(stderr, "Consistency check failed. (%s:%d)\n", __FILE__, __LINE__);
     fprintf(stderr, buf);
     ASSERT_TRUE(false);
   }
@@ -114,7 +106,7 @@ struct UNEVEN_STRUCT {
 struct UNEVEN_STRUCT* new_uneven_struct()
 {
   struct UNEVEN_STRUCT* ret = kalloc(sizeof(struct UNEVEN_STRUCT));
-  
+
   ret->arr[0] = 1;
   ret->arr[1] = 2;
   ret->arr[2] = 3;
@@ -124,8 +116,7 @@ struct UNEVEN_STRUCT* new_uneven_struct()
   return ret;
 }
 
-#define size_for(n) \
-  (((n) / 4) + ((n) % 4 != 0))
+#define size_for(n) (((n) / 4) + ((n) % 4 != 0))
 
 TEST(memory, uneven_kalloc)
 {
@@ -161,7 +152,7 @@ TEST(memory, kalloc_free)
   kfree(test1);
   kfree(test5);
 
-  ASSERT_EQ((int) kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
+  ASSERT_EQ((int)kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
 
   test1 = new_test_struct();
   test2 = new_test_struct2();
@@ -175,7 +166,7 @@ TEST(memory, kalloc_free)
   kfree(test4);
   kfree(test5);
 
-  ASSERT_EQ((int) kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
+  ASSERT_EQ((int)kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
 
   test1 = new_test_struct();
   test2 = new_test_struct2();
@@ -189,7 +180,7 @@ TEST(memory, kalloc_free)
   kfree(test2);
   kfree(test5);
 
-  ASSERT_EQ((int) kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
+  ASSERT_EQ((int)kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
 
   wipeout_kalloc();
 
@@ -262,10 +253,10 @@ TEST(memory, consistency_stress)
   }
 
   int i;
-  void* allocd[NRUNS] = { 0 };
+  void* allocd[NRUNS] = {0};
   char buf[1024];
 
-  for (i = 0; i < NRUNS; ++ i) {
+  for (i = 0; i < NRUNS; ++i) {
     size_t nalloc = rand() % 20;
     allocd[i] = kalloc(nalloc);
 
@@ -326,23 +317,23 @@ TEST(memory, consistency_stress)
     }
   }
 
-  for(i = 0; i < NRUNS; ++ i) {
+  for (i = 0; i < NRUNS; ++i) {
     if (allocd[i]) {
       kfree(allocd[i]);
     }
 
     if (debug_kalloc_assert_consistency(buf, 1024)) {
-        fprintf(
-            stderr,
-            "Consistency check failed. (At index=%d, %s:%d)\n",
-            i,
-            __FILE__,
-            __LINE__);
+      fprintf(
+          stderr,
+          "Consistency check failed. (At index=%d, %s:%d)\n",
+          i,
+          __FILE__,
+          __LINE__);
       fprintf(stderr, buf);
       ASSERT_TRUE(false);
     }
   }
-  ASSERT_EQ((int) kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
+  ASSERT_EQ((int)kalloc_start->size * 4, MAX_HEAP_SIZE - 4);
 
   return 0;
 }
@@ -364,7 +355,7 @@ TEST(memory, kalloc_free_alloc)
   struct TEST_STRUCT2* test6 = new_test_struct2();
 
   // test_6 should have been allocated in test_4's spot.
-  ASSERT_EQ(test6, test4); 
+  ASSERT_EQ(test6, test4);
 
   kfree(test2);
   struct TEST_STRUCT* test7 = new_test_struct();