Commit 07b83ec

mo khan <mo.khan@gmail.com>
2020-07-12 21:59:14
Run code formatter
master
1 parent f69c64a
Changed files (2)
src
02
01
binary_tree.c
binary_tree_test.c
src/02/01/binary_tree.c
@@ -14,31 +14,27 @@ void traverse(Node *node, Visitor visitor, enum Traversal traversal) {
     return;
 
   switch (traversal) {
-    case PREORDER:
-      visitor(node);
-      traverse(node->left, visitor, traversal);
-      traverse(node->right, visitor, traversal);
-      break;
-    case INORDER:
-      traverse(node->left, visitor, traversal);
-      visitor(node);
-      traverse(node->right, visitor, traversal);
-      break;
-    case POSTORDER:
-      traverse(node->left, visitor, traversal);
-      traverse(node->right, visitor, traversal);
-      visitor(node);
-      break;
-    default:
-      visitor(node);
-      break;
+  case PREORDER:
+    visitor(node);
+    traverse(node->left, visitor, traversal);
+    traverse(node->right, visitor, traversal);
+    break;
+  case INORDER:
+    traverse(node->left, visitor, traversal);
+    visitor(node);
+    traverse(node->right, visitor, traversal);
+    break;
+  case POSTORDER:
+    traverse(node->left, visitor, traversal);
+    traverse(node->right, visitor, traversal);
+    visitor(node);
+    break;
+  default:
+    visitor(node);
+    break;
   }
 }
 
-static void destructor(Node *node) {
-  free(node);
-}
+static void destructor(Node *node) { free(node); }
 
-void destroy(Node *head) {
-  traverse(head, destructor, POSTORDER);
-}
+void destroy(Node *head) { traverse(head, destructor, POSTORDER); }
src/02/01/binary_tree_test.c
@@ -23,7 +23,8 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_is_empty) {
   assert_that(visited_count, is_equal_to(0));
 }
 
-Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_single_node) {
+Ensure(BinaryTree,
+       when_traversing_in_preorder_when_the_tree_has_a_single_node) {
   Node *node = initialize(100);
 
   traverse(node, visitor, PREORDER);
@@ -57,7 +58,8 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_right_node) {
   destroy(node);
 }
 
-Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_and_right_node) {
+Ensure(BinaryTree,
+       when_traversing_in_preorder_when_the_tree_has_a_left_and_right_node) {
   Node *node = initialize(100);
   node->left = initialize(200);
   node->right = initialize(300);
@@ -71,7 +73,8 @@ Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_and_righ
   destroy(node);
 }
 
-Ensure(BinaryTree, when_traversing_in_preorder_when_the_tree_has_multiple_levels) {
+Ensure(BinaryTree,
+       when_traversing_in_preorder_when_the_tree_has_multiple_levels) {
   Node *node = initialize(100);
   node->left = initialize(200);
   node->right = initialize(300);
@@ -96,7 +99,8 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_is_empty) {
   assert_that(visited_count, is_equal_to(0));
 }
 
-Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_single_node) {
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_a_single_node) {
   Node *node = initialize(100);
 
   traverse(node, visitor, POSTORDER);
@@ -118,7 +122,8 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_node) {
   destroy(node);
 }
 
-Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_right_node) {
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_a_right_node) {
   Node *node = initialize(100);
   node->right = initialize(300);
 
@@ -130,7 +135,8 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_right_node)
   destroy(node);
 }
 
-Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node) {
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node) {
   Node *node = initialize(100);
   node->left = initialize(200);
   node->right = initialize(300);
@@ -144,7 +150,8 @@ Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_and_rig
   destroy(node);
 }
 
-Ensure(BinaryTree, when_traversing_in_postorder_when_the_tree_has_multiple_levels) {
+Ensure(BinaryTree,
+       when_traversing_in_postorder_when_the_tree_has_multiple_levels) {
   Node *node = initialize(100);
   node->left = initialize(200);
   node->right = initialize(300);
@@ -203,7 +210,8 @@ Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_right_node) {
   destroy(node);
 }
 
-Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_a_left_and_right_node) {
+Ensure(BinaryTree,
+       when_traversing_inorder_when_the_tree_has_a_left_and_right_node) {
   Node *node = initialize(100);
   node->left = initialize(200);
   node->right = initialize(300);
@@ -239,26 +247,57 @@ Ensure(BinaryTree, when_traversing_inorder_when_the_tree_has_multiple_levels) {
 TestSuite *binary_tree_tests() {
   TestSuite *suite = create_test_suite();
 
-  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_is_empty);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_single_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_right_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_a_left_and_right_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_preorder_when_the_tree_has_multiple_levels);
-
-  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_is_empty);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_single_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_right_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_in_postorder_when_the_tree_has_multiple_levels);
-
-  add_test_with_context(suite, BinaryTree, when_traversing_inorder_when_the_tree_is_empty);
-  add_test_with_context(suite, BinaryTree, when_traversing_inorder_when_the_tree_has_a_single_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_inorder_when_the_tree_has_a_left_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_inorder_when_the_tree_has_a_right_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_inorder_when_the_tree_has_a_left_and_right_node);
-  add_test_with_context(suite, BinaryTree, when_traversing_inorder_when_the_tree_has_multiple_levels);
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_in_preorder_when_the_tree_is_empty);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_single_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_left_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_preorder_when_the_tree_has_multiple_levels);
+
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_in_postorder_when_the_tree_is_empty);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_single_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_left_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_in_postorder_when_the_tree_has_multiple_levels);
+
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_inorder_when_the_tree_is_empty);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_inorder_when_the_tree_has_a_single_node);
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_inorder_when_the_tree_has_a_left_node);
+  add_test_with_context(suite, BinaryTree,
+                        when_traversing_inorder_when_the_tree_has_a_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_inorder_when_the_tree_has_a_left_and_right_node);
+  add_test_with_context(
+      suite, BinaryTree,
+      when_traversing_inorder_when_the_tree_has_multiple_levels);
 
   return suite;
 }