Clang-format tests/unit/s2n_s.*\.c and enforce in CI

.github/workflows/ci_clang_format_check.yml

@@ -20,7 +20,7 @@ jobs:
           - check: 'tests/testlib'
             exclude: ''
           - check: 'tests/unit'
-            exclude: "s2n_[^3a-cd-kt-z].*\\.c"
+            exclude: "s2n_[^3a-csd-kt-z].*\\.c"
           - check: 'tls'
             exclude: ''
           - check: 'tls/extensions'

tests/unit/s2n_safety_blinding_test.c

@@ -14,23 +14,22 @@
  */
 
 #include "s2n_test.h"
-
 #include "tls/s2n_connection.h"
 #include "utils/s2n_safety.h"
 
 #define TEST_ERRNO S2N_ERR_T_INTERNAL_END
 
-#define SETUP_TEST(conn) \
+#define SETUP_TEST(conn)                       \
     EXPECT_SUCCESS(s2n_connection_wipe(conn)); \
-    EXPECT_SUCCESS(s2n_connection_set_blinding(conn, S2N_SELF_SERVICE_BLINDING)); \
+    EXPECT_SUCCESS(s2n_connection_set_blinding(conn, S2N_SELF_SERVICE_BLINDING));
 
-#define EXPECT_BLINDING(conn) \
+#define EXPECT_BLINDING(conn)                            \
     EXPECT_NOT_EQUAL(s2n_connection_get_delay(conn), 0); \
-    EXPECT_TRUE(conn->closed); \
+    EXPECT_TRUE(conn->closed);
 
-#define EXPECT_NO_BLINDING(conn) \
+#define EXPECT_NO_BLINDING(conn)                     \
     EXPECT_EQUAL(s2n_connection_get_delay(conn), 0); \
-    EXPECT_FALSE(conn->closed); \
+    EXPECT_FALSE(conn->closed);
 
 S2N_RESULT s2n_result_func(bool success)
 {
@@ -45,7 +44,7 @@ int s2n_posix_func(bool success)
 }
 
 int ptr_value = 0;
-int* s2n_ptr_func(bool success)
+int *s2n_ptr_func(bool success)
 {
     PTR_ENSURE(success, TEST_ERRNO);
     return &ptr_value;
@@ -87,7 +86,7 @@ int s2n_posix_test(struct s2n_connection *conn)
     return S2N_SUCCESS;
 }
 
-int* s2n_ptr_test(struct s2n_connection *conn)
+int *s2n_ptr_test(struct s2n_connection *conn)
 {
     WITH_ERROR_BLINDING(conn, PTR_GUARD_RESULT(s2n_result_func(true)));
     EXPECT_NO_BLINDING(conn);
@@ -125,15 +124,15 @@ int main(int argc, char **argv)
             s2n_errno = S2N_ERR_OK;
             EXPECT_OK(s2n_connection_apply_error_blinding(&conn));
             EXPECT_NO_BLINDING(conn);
-        }
+        };
 
         /* No-op for retriable errors */
         {
             SETUP_TEST(conn);
             s2n_errno = S2N_ERR_IO_BLOCKED;
             EXPECT_OK(s2n_connection_apply_error_blinding(&conn));
             EXPECT_NO_BLINDING(conn);
-        }
+        };
 
         /* Closes connection but does not blind for non-blinding errors */
         {
@@ -142,18 +141,18 @@ int main(int argc, char **argv)
             EXPECT_OK(s2n_connection_apply_error_blinding(&conn));
             EXPECT_EQUAL(s2n_connection_get_delay(conn), 0);
             EXPECT_TRUE(conn->closed);
-        }
+        };
 
         /* Blinds for an average error */
         {
             SETUP_TEST(conn);
             s2n_errno = S2N_ERR_UNIMPLEMENTED;
             EXPECT_OK(s2n_connection_apply_error_blinding(&conn));
             EXPECT_BLINDING(conn);
-        }
+        };
 
         EXPECT_SUCCESS(s2n_connection_free(conn));
-    }
+    };
 
     /* Test: WITH_ERROR_BLINDING macro
      * The WITH_ERROR_BLINDING macro relies on the current method exiting early.
@@ -178,7 +177,7 @@ int main(int argc, char **argv)
         EXPECT_BLINDING(conn);
 
         EXPECT_SUCCESS(s2n_connection_free(conn));
-    }
+    };
 
     END_TEST();
 }

tests/unit/s2n_safety_macros_test.c

@@ -15,7 +15,6 @@
  */
 
 #include "s2n_test.h"
-
 #include "utils/s2n_safety.h"
 
 /**
@@ -627,7 +626,7 @@ static const char* PTR_GUARD_OSSL_harness(int result, int error)
     return "ok";
 }
 
-int main(int argc, char **argv)
+int main(int argc, char** argv)
 {
     BEGIN_TEST();
 
@@ -640,11 +639,11 @@ int main(int argc, char **argv)
 
     /* RESULT_DEBUG_ENSURE(condition, error) */
     EXPECT_OK(RESULT_DEBUG_ENSURE_harness(true));
-    #ifdef NDEBUG
+#ifdef NDEBUG
     EXPECT_OK(RESULT_DEBUG_ENSURE_harness(false));
-    #else
+#else
     EXPECT_ERROR_WITH_ERRNO(RESULT_DEBUG_ENSURE_harness(false), S2N_ERR_SAFETY);
-    #endif
+#endif
 
     /* RESULT_ENSURE_OK(result, error) */
     EXPECT_OK(RESULT_ENSURE_OK_harness(true));
@@ -734,11 +733,11 @@ int main(int argc, char **argv)
 
     /* RESULT_POSTCONDITION(result) */
     EXPECT_OK(RESULT_POSTCONDITION_harness(RESULT_POSTCONDITION_harness_check(true)));
-    #ifdef NDEBUG
+#ifdef NDEBUG
     EXPECT_OK(RESULT_POSTCONDITION_harness(RESULT_POSTCONDITION_harness_check(false)));
-    #else
+#else
     EXPECT_ERROR_WITH_ERRNO(RESULT_POSTCONDITION_harness(RESULT_POSTCONDITION_harness_check(false)), S2N_ERR_SAFETY);
-    #endif
+#endif
 
     /* RESULT_CHECKED_MEMCPY(destination, source, len) */
     uint32_t RESULT__checked_memcpy_dest = 1;
@@ -775,11 +774,11 @@ int main(int argc, char **argv)
 
     /* POSIX_DEBUG_ENSURE(condition, error) */
     EXPECT_SUCCESS(POSIX_DEBUG_ENSURE_harness(true));
-    #ifdef NDEBUG
+#ifdef NDEBUG
     EXPECT_SUCCESS(POSIX_DEBUG_ENSURE_harness(false));
-    #else
+#else
     EXPECT_FAILURE_WITH_ERRNO(POSIX_DEBUG_ENSURE_harness(false), S2N_ERR_SAFETY);
-    #endif
+#endif
 
     /* POSIX_ENSURE_OK(result, error) */
     EXPECT_SUCCESS(POSIX_ENSURE_OK_harness(true));
@@ -869,11 +868,11 @@ int main(int argc, char **argv)
 
     /* POSIX_POSTCONDITION(result) */
     EXPECT_SUCCESS(POSIX_POSTCONDITION_harness(POSIX_POSTCONDITION_harness_check(true)));
-    #ifdef NDEBUG
+#ifdef NDEBUG
     EXPECT_SUCCESS(POSIX_POSTCONDITION_harness(POSIX_POSTCONDITION_harness_check(false)));
-    #else
+#else
     EXPECT_FAILURE_WITH_ERRNO(POSIX_POSTCONDITION_harness(POSIX_POSTCONDITION_harness_check(false)), S2N_ERR_SAFETY);
-    #endif
+#endif
 
     /* POSIX_CHECKED_MEMCPY(destination, source, len) */
     uint32_t POSIX__checked_memcpy_dest = 1;
@@ -910,11 +909,11 @@ int main(int argc, char **argv)
 
     /* PTR_DEBUG_ENSURE(condition, error) */
     EXPECT_NOT_NULL(PTR_DEBUG_ENSURE_harness(true));
-    #ifdef NDEBUG
+#ifdef NDEBUG
     EXPECT_NOT_NULL(PTR_DEBUG_ENSURE_harness(false));
-    #else
+#else
     EXPECT_NULL_WITH_ERRNO(PTR_DEBUG_ENSURE_harness(false), S2N_ERR_SAFETY);
-    #endif
+#endif
 
     /* PTR_ENSURE_OK(result, error) */
     EXPECT_NOT_NULL(PTR_ENSURE_OK_harness(true));
@@ -1004,11 +1003,11 @@ int main(int argc, char **argv)
 
     /* PTR_POSTCONDITION(result) */
     EXPECT_NOT_NULL(PTR_POSTCONDITION_harness(PTR_POSTCONDITION_harness_check(true)));
-    #ifdef NDEBUG
+#ifdef NDEBUG
     EXPECT_NOT_NULL(PTR_POSTCONDITION_harness(PTR_POSTCONDITION_harness_check(false)));
-    #else
+#else
     EXPECT_NULL_WITH_ERRNO(PTR_POSTCONDITION_harness(PTR_POSTCONDITION_harness_check(false)), S2N_ERR_SAFETY);
-    #endif
+#endif
 
     /* PTR_CHECKED_MEMCPY(destination, source, len) */
     uint32_t PTR__checked_memcpy_dest = 1;
@@ -1036,7 +1035,6 @@ int main(int argc, char **argv)
     EXPECT_NOT_NULL(PTR_GUARD_OSSL_harness(1, S2N_ERR_SAFETY));
     EXPECT_NULL_WITH_ERRNO(PTR_GUARD_OSSL_harness(0, S2N_ERR_SAFETY), S2N_ERR_SAFETY);
 
-
     END_TEST();
     return S2N_SUCCESS;
 }

tests/unit/s2n_safety_test.c

@@ -13,36 +13,34 @@
  * permissions and limitations under the License.
  */
 
-#include "s2n_test.h"
-
 #include "utils/s2n_safety.h"
 
-#define CHECK_OVF_0(fn, type, a, b)             \
-  do {                                          \
-    type result_val;                            \
-    EXPECT_FAILURE(fn((a), (b), &result_val));  \
-  } while (0)
-
-
-#define CHECK_OVF(fn, type, a, b)               \
-  do {                                          \
-    CHECK_OVF_0(fn, type, a, b);                \
-    CHECK_OVF_0(fn, type, b, a);                \
-  } while (0)
-
-#define CHECK_NO_OVF_0(fn, type, a, b, r)       \
-  do {                                          \
-    type result_val;                            \
-    EXPECT_SUCCESS(fn((a), (b), &result_val));  \
-    EXPECT_EQUAL(result_val,(r));               \
-  } while (0)
-
-#define CHECK_NO_OVF(fn, type, a, b, r)         \
-  do {                                          \
-    CHECK_NO_OVF_0(fn, type, a, b, r);          \
-    CHECK_NO_OVF_0(fn, type, b, a, r);          \
-  } while (0)
+#include "s2n_test.h"
 
+#define CHECK_OVF_0(fn, type, a, b)                \
+    do {                                           \
+        type result_val;                           \
+        EXPECT_FAILURE(fn((a), (b), &result_val)); \
+    } while (0)
+
+#define CHECK_OVF(fn, type, a, b)    \
+    do {                             \
+        CHECK_OVF_0(fn, type, a, b); \
+        CHECK_OVF_0(fn, type, b, a); \
+    } while (0)
+
+#define CHECK_NO_OVF_0(fn, type, a, b, r)          \
+    do {                                           \
+        type result_val;                           \
+        EXPECT_SUCCESS(fn((a), (b), &result_val)); \
+        EXPECT_EQUAL(result_val, (r));             \
+    } while (0)
+
+#define CHECK_NO_OVF(fn, type, a, b, r)    \
+    do {                                   \
+        CHECK_NO_OVF_0(fn, type, a, b, r); \
+        CHECK_NO_OVF_0(fn, type, b, a, r); \
+    } while (0)
 
 static int failure_gte()
 {
@@ -121,7 +119,7 @@ static int failure_notnull()
 static int success_memcpy()
 {
     char dst[1024];
-    char src[1024] = {0};
+    char src[1024] = { 0 };
 
     POSIX_CHECKED_MEMCPY(dst, src, 1024);
 
@@ -252,7 +250,6 @@ static int success_ct_pkcs1_negative()
     return 0;
 }
 
-
 int main(int argc, char **argv)
 {
     BEGIN_TEST();
@@ -314,16 +311,16 @@ int main(int argc, char **argv)
 
     for (int i = 0; i < 256; i++) {
         for (int j = 0; j < 256; j++) {
-           x[0] = i;
-           y[0] = j;
+            x[0] = i;
+            y[0] = j;
 
-           int expected = 0;
+            int expected = 0;
 
-           if (i == j) {
+            if (i == j) {
                 expected = 1;
-           }
+            }
 
-           EXPECT_EQUAL(s2n_constant_time_equals(x, y, sizeof(x)), expected);
+            EXPECT_EQUAL(s2n_constant_time_equals(x, y, sizeof(x)), expected);
         }
     }