diff --git a/qemu/target/ppc/unicorn.c b/qemu/target/ppc/unicorn.c
index 8ce3e02b..b157ce5a 100644
--- a/qemu/target/ppc/unicorn.c
+++ b/qemu/target/ppc/unicorn.c
@@ -134,7 +134,7 @@ static void ppc_release(void *ctx)
     //    g_free(tcg_ctx->tb_ctx.tbs);
 
     if (env->nb_tlb != 0) {
-        switch(env->tlb_type) {
+        switch (env->tlb_type) {
         case TLB_6XX:
             g_free(env->tlb.tlb6);
             break;
diff --git a/samples/sample_ctl.c b/samples/sample_ctl.c
index f154f24e..0b1b5898 100644
--- a/samples/sample_ctl.c
+++ b/samples/sample_ctl.c
@@ -243,7 +243,8 @@ static void test_uc_ctl_tb_cache()
 
     // Now we request cache for all TBs.
     for (int i = 0; i < TB_COUNT; i++) {
-        err = uc_ctl_request_cache(uc, (uint64_t)(ADDRESS + i * TCG_MAX_INSNS), &tb);
+        err = uc_ctl_request_cache(uc, (uint64_t)(ADDRESS + i * TCG_MAX_INSNS),
+                                   &tb);
         printf(">>> TB is cached at 0x%" PRIx64 " which has %" PRIu16
                " instructions with %" PRIu16 " bytes.\n",
                tb.pc, tb.icount, tb.size);
diff --git a/tests/unit/test_arm64.c b/tests/unit/test_arm64.c
index bd64a4c9..0de80937 100644
--- a/tests/unit/test_arm64.c
+++ b/tests/unit/test_arm64.c
@@ -295,19 +295,20 @@ static void test_arm64_correct_address_in_long_jump_hook(void)
     OK(uc_close(uc));
 }
 
-static void test_arm64_block_sync_pc_cb(uc_engine* uc, uint64_t addr, uint32_t size, void* data)
+static void test_arm64_block_sync_pc_cb(uc_engine *uc, uint64_t addr,
+                                        uint32_t size, void *data)
 {
     uint64_t val = code_start;
-    bool first = *(bool*)data;
+    bool first = *(bool *)data;
     if (first) {
-        OK(uc_reg_write(uc, UC_ARM64_REG_PC, (void*)&val));
-        *(bool*)data = false;
+        OK(uc_reg_write(uc, UC_ARM64_REG_PC, (void *)&val));
+        *(bool *)data = false;
     }
 }
 
 static void test_arm64_block_sync_pc(void)
 {
-    uc_engine* uc;
+    uc_engine *uc;
     // add x0, x0, #1234;bl t;t:mov x1, #5678;
     const char code[] = "\x00\x48\x13\x91\x01\x00\x00\x94\xc1\xc5\x82\xd2";
     uc_hook hk;
@@ -316,13 +317,14 @@ static void test_arm64_block_sync_pc(void)
 
     uc_common_setup(&uc, UC_ARCH_ARM64, UC_MODE_ARM, code, sizeof(code) - 1,
                     UC_CPU_ARM64_A72);
-    OK(uc_hook_add(uc, &hk, UC_HOOK_BLOCK, test_arm64_block_sync_pc_cb, (void*)&data, code_start + 8, code_start + 12));    
-    
+    OK(uc_hook_add(uc, &hk, UC_HOOK_BLOCK, test_arm64_block_sync_pc_cb,
+                   (void *)&data, code_start + 8, code_start + 12));
+
     x0 = 0;
-    OK(uc_reg_write(uc, UC_ARM64_REG_X0, (void*)&x0));
+    OK(uc_reg_write(uc, UC_ARM64_REG_X0, (void *)&x0));
     OK(uc_emu_start(uc, code_start, code_start + sizeof(code) - 1, 0, 0));
 
-    OK(uc_reg_read(uc, UC_ARM64_REG_X0, (void*)&x0));
+    OK(uc_reg_read(uc, UC_ARM64_REG_X0, (void *)&x0));
 
     TEST_CHECK(x0 == (1234 * 2));
 
@@ -330,7 +332,6 @@ static void test_arm64_block_sync_pc(void)
     OK(uc_close(uc));
 }
 
-
 TEST_LIST = {{"test_arm64_until", test_arm64_until},
              {"test_arm64_code_patching", test_arm64_code_patching},
              {"test_arm64_code_patching_count", test_arm64_code_patching_count},
@@ -341,5 +342,5 @@ TEST_LIST = {{"test_arm64_until", test_arm64_until},
               test_arm64_correct_address_in_small_jump_hook},
              {"test_arm64_correct_address_in_long_jump_hook",
               test_arm64_correct_address_in_long_jump_hook},
-              {"test_arm64_block_sync_pc", test_arm64_block_sync_pc},
+             {"test_arm64_block_sync_pc", test_arm64_block_sync_pc},
              {NULL, NULL}};
diff --git a/tests/unit/test_x86.c b/tests/unit/test_x86.c
index ba37e638..a9291f92 100644
--- a/tests/unit/test_x86.c
+++ b/tests/unit/test_x86.c
@@ -1106,7 +1106,6 @@ static void test_x86_correct_address_in_long_jump_hook(void)
     OK(uc_close(uc));
 }
 
-
 static void test_x86_invalid_vex_l(void)
 {
     uc_engine *uc;
@@ -1132,15 +1131,16 @@ struct writelog_t {
 };
 
 static void test_x86_unaligned_access_callback(uc_engine *uc, uc_mem_type type,
-        uint64_t address, int size, int64_t value, void *user_data)
+                                               uint64_t address, int size,
+                                               int64_t value, void *user_data)
 {
     TEST_CHECK(size != 0);
     struct writelog_t *write_log = (struct writelog_t *)user_data;
 
     for (int i = 0; i < 10; i++) {
         if (write_log[i].size == 0) {
-            write_log[i].addr = (uint32_t) address;
-            write_log[i].size = (uint32_t) size;
+            write_log[i].addr = (uint32_t)address;
+            write_log[i].size = (uint32_t)size;
             return;
         }
     }
@@ -1161,10 +1161,10 @@ static void test_x86_unaligned_access(void)
 
     uc_common_setup(&uc, UC_ARCH_X86, UC_MODE_32, code, sizeof(code) - 1);
     OK(uc_mem_map(uc, 0x200000, 0x1000, UC_PROT_ALL));
-    OK(uc_hook_add(uc, &hook, UC_HOOK_MEM_WRITE, test_x86_unaligned_access_callback,
-                write_log, 1, 0));
-    OK(uc_hook_add(uc, &hook, UC_HOOK_MEM_READ, test_x86_unaligned_access_callback,
-                read_log, 1, 0));
+    OK(uc_hook_add(uc, &hook, UC_HOOK_MEM_WRITE,
+                   test_x86_unaligned_access_callback, write_log, 1, 0));
+    OK(uc_hook_add(uc, &hook, UC_HOOK_MEM_READ,
+                   test_x86_unaligned_access_callback, read_log, 1, 0));
 
     OK(uc_reg_write(uc, UC_X86_REG_EAX, &r_eax));
     OK(uc_emu_start(uc, code_start, code_start + sizeof(code) - 1, 0, 0));
@@ -1192,7 +1192,8 @@ static void test_x86_unaligned_access(void)
 #endif
 
 static bool test_x86_lazy_mapping_mem_callback(uc_engine *uc, uc_mem_type type,
-        uint64_t address, int size, int64_t value, void *user_data)
+                                               uint64_t address, int size,
+                                               int64_t value, void *user_data)
 {
     OK(uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL));
     OK(uc_mem_write(uc, 0x1000, "\x90\x90", 2)); // nop; nop
@@ -1202,9 +1203,10 @@ static bool test_x86_lazy_mapping_mem_callback(uc_engine *uc, uc_mem_type type,
 }
 
 static void test_x86_lazy_mapping_block_callback(uc_engine *uc,
-        uint64_t address, uint32_t size, void *user_data)
+                                                 uint64_t address,
+                                                 uint32_t size, void *user_data)
 {
-    int *block_count = (int*)user_data;
+    int *block_count = (int *)user_data;
     (*block_count)++;
 }
 
@@ -1215,8 +1217,10 @@ static void test_x86_lazy_mapping(void)
     int block_count = 0;
 
     OK(uc_open(UC_ARCH_X86, UC_MODE_32, &uc));
-    OK(uc_hook_add(uc, &mem_hook, UC_HOOK_MEM_FETCH_UNMAPPED, test_x86_lazy_mapping_mem_callback, NULL, 1, 0));
-    OK(uc_hook_add(uc, &block_hook, UC_HOOK_BLOCK, test_x86_lazy_mapping_block_callback, &block_count, 1, 0));
+    OK(uc_hook_add(uc, &mem_hook, UC_HOOK_MEM_FETCH_UNMAPPED,
+                   test_x86_lazy_mapping_mem_callback, NULL, 1, 0));
+    OK(uc_hook_add(uc, &block_hook, UC_HOOK_BLOCK,
+                   test_x86_lazy_mapping_block_callback, &block_count, 1, 0));
 
     OK(uc_emu_start(uc, 0x1000, 0x1002, 0, 0));
     TEST_CHECK(block_count == 1);