Remove LICENSE; Cleanup

6 files changed, 53 insertions, 72 deletions

diff --git a/source/kit/secure_random.c b/source/kit/secure_random.c
index 2f53866..2565f6f 100644
--- a/source/kit/secure_random.c
+++ b/source/kit/secure_random.c
@@ -1,7 +1,5 @@
 #include "secure_random.h"
 
-#include "status.h"
-
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
diff --git a/source/kit/secure_random.h b/source/kit/secure_random.h
index d09ea56..435fe88 100644
--- a/source/kit/secure_random.h
+++ b/source/kit/secure_random.h
@@ -2,6 +2,7 @@
 #define KIT_SECURE_RANDOM_H
 
 #include "types.h"
+#include "status.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/source/kit/test.h b/source/kit/test.h
index ca2b7c0..3563abc 100644
--- a/source/kit/test.h
+++ b/source/kit/test.h
@@ -42,32 +42,6 @@
 //    }
 //
 //  ================================================================
-//
-//  The MIT License
-//
-//  Copyright (c) 2022-2024 Mitya Selivanov
-//
-//  Permission is hereby granted, free of charge, to any person
-//  obtaining a copy of this software and associated documentation
-//  files (the "Software"), to deal in the Software without
-//  restriction, including without limitation the rights to use, copy,
-//  modify, merge, publish, distribute, sublicense, and/or sell copies
-//  of the Software, and to permit persons to whom the Software is
-//  furnished to do so, subject to the following conditions:
-//
-//  The above copyright notice and this permission notice shall be
-//  included in all copies or substantial portions of the Software.
-//
-//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-//  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-//  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-//  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-//  DEALINGS IN THE SOFTWARE.
-//
-//  ================================================================
 
 #ifndef KIT_TEST_H
 #define KIT_TEST_H
diff --git a/source/tests/_exe.c b/source/tests/_exe.c
index 1c59ba2..01add48 100644
--- a/source/tests/_exe.c
+++ b/source/tests/_exe.c
@@ -21,6 +21,7 @@
 #include "string_ref.test.c"
 #include "duration.test.c"
 #include "thread.test.c"
+#include "atomic.test.c"
 #include "xml.test.c"
 #include "http1.test.c"
 #include "bench.test.c"
diff --git a/source/tests/atomic.test.c b/source/tests/atomic.test.c
index d5c172b..ca14959 100644
--- a/source/tests/atomic.test.c
+++ b/source/tests/atomic.test.c
@@ -5,13 +5,13 @@
 #include "../kit/test.h"
 
 TEST("atomic store and load") {
-  ATOMIC(int) value;
+  int _Atomic value;
   atomic_store_explicit(&value, 20, memory_order_relaxed);
   REQUIRE(atomic_load_explicit(&value, memory_order_relaxed) == 20);
 }
 
 TEST("atomic exchange") {
-  ATOMIC(int) value;
+  int _Atomic value;
   atomic_store_explicit(&value, 20, memory_order_relaxed);
   REQUIRE(atomic_exchange_explicit(&value, 42,
                                    memory_order_relaxed) == 20);
@@ -19,20 +19,23 @@ TEST("atomic exchange") {
 }
 
 TEST("atomic fetch add") {
-  ATOMIC(int) value;
+  int _Atomic value;
   atomic_store_explicit(&value, 20, memory_order_relaxed);
   REQUIRE(atomic_fetch_add_explicit(&value, 22,
                                     memory_order_relaxed) == 20);
   REQUIRE(atomic_load_explicit(&value, memory_order_relaxed) == 42);
 }
 
-enum { THREAD_COUNT = 20, TICK_COUNT = 10000 };
+enum {
+  TEST_ATOMIC_THREAD_COUNT = 20,
+  TEST_ATOMIC_TICK_COUNT   = 10000,
+};
 
 static int test_8_(void *p) {
   ptrdiff_t i;
-  ATOMIC(int8_t) *x = (ATOMIC(int8_t) *) p;
+  int8_t _Atomic *x = (int8_t _Atomic *) p;
 
-  for (i = 0; i < TICK_COUNT; i++) {
+  for (i = 0; i < TEST_ATOMIC_TICK_COUNT; i++) {
     atomic_fetch_add_explicit(x, 20, memory_order_relaxed);
     thrd_yield();
     atomic_fetch_add_explicit(x, 22, memory_order_relaxed);
@@ -45,11 +48,11 @@ static int test_8_(void *p) {
 }
 
 TEST("atomic types") {
-  ATOMIC(int8_t) b_1;
-  ATOMIC(int8_t) b_2;
-  ATOMIC(int16_t) i16;
-  ATOMIC(int32_t) i32;
-  ATOMIC(int64_t) i64;
+  int8_t _Atomic b_1;
+  int8_t _Atomic b_2;
+  int16_t _Atomic i16;
+  int32_t _Atomic i32;
+  int64_t _Atomic i64;
 
   atomic_store_explicit(&b_1, 42, memory_order_relaxed);
   atomic_store_explicit(&b_2, 43, memory_order_relaxed);
@@ -86,18 +89,18 @@ TEST("atomic types") {
 TEST("atomic byte concurrency") {
   ptrdiff_t i;
 
-  ATOMIC(int8_t) foo;
-  ATOMIC(int8_t) bar;
+  int8_t _Atomic foo;
+  int8_t _Atomic bar;
 
   atomic_store_explicit(&foo, 42, memory_order_relaxed);
   atomic_store_explicit(&bar, 43, memory_order_relaxed);
 
-  thrd_t threads[THREAD_COUNT];
-  for (i = 0; i < THREAD_COUNT; i++)
+  thrd_t threads[TEST_ATOMIC_THREAD_COUNT];
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++)
     REQUIRE_EQ(thrd_create(threads + i, test_8_,
                            (void *) ((i % 2) ? &foo : &bar)),
                thrd_success);
-  for (i = 0; i < THREAD_COUNT; i++) thrd_join(threads[i], NULL);
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++) thrd_join(threads[i], NULL);
 
   REQUIRE(atomic_load_explicit(&foo, memory_order_relaxed) == 42);
   REQUIRE(atomic_load_explicit(&bar, memory_order_relaxed) == 43);
@@ -106,9 +109,9 @@ TEST("atomic byte concurrency") {
 static int test_16_(void *p) {
   ptrdiff_t i;
 
-  ATOMIC(int16_t) *x = (ATOMIC(int16_t) *) p;
+  int16_t _Atomic *x = (int16_t _Atomic *) p;
 
-  for (i = 0; i < TICK_COUNT; i++) {
+  for (i = 0; i < TEST_ATOMIC_TICK_COUNT; i++) {
     atomic_fetch_add_explicit(x, 2020, memory_order_relaxed);
     thrd_yield();
     atomic_fetch_add_explicit(x, 2222, memory_order_relaxed);
@@ -123,18 +126,18 @@ static int test_16_(void *p) {
 TEST("atomic int16 concurrency") {
   ptrdiff_t i;
 
-  ATOMIC(int16_t) foo;
-  ATOMIC(int16_t) bar;
+  int16_t _Atomic foo;
+  int16_t _Atomic bar;
 
   atomic_store_explicit(&foo, 42, memory_order_relaxed);
   atomic_store_explicit(&bar, 43, memory_order_relaxed);
 
-  thrd_t threads[THREAD_COUNT];
-  for (i = 0; i < THREAD_COUNT; i++)
+  thrd_t threads[TEST_ATOMIC_THREAD_COUNT];
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++)
     REQUIRE_EQ(thrd_create(threads + i, test_16_,
                            (void *) ((i % 2) ? &foo : &bar)),
                thrd_success);
-  for (i = 0; i < THREAD_COUNT; i++) thrd_join(threads[i], NULL);
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++) thrd_join(threads[i], NULL);
 
   REQUIRE(atomic_load_explicit(&foo, memory_order_relaxed) == 42);
   REQUIRE(atomic_load_explicit(&bar, memory_order_relaxed) == 43);
@@ -143,9 +146,9 @@ TEST("atomic int16 concurrency") {
 static int test_32_(void *p) {
   ptrdiff_t i;
 
-  ATOMIC(int32_t) *x = (ATOMIC(int32_t) *) p;
+  int32_t _Atomic *x = (int32_t _Atomic *) p;
 
-  for (i = 0; i < TICK_COUNT; i++) {
+  for (i = 0; i < TEST_ATOMIC_TICK_COUNT; i++) {
     atomic_fetch_add_explicit(x, 202020, memory_order_relaxed);
     thrd_yield();
     atomic_fetch_add_explicit(x, 222222, memory_order_relaxed);
@@ -160,18 +163,18 @@ static int test_32_(void *p) {
 TEST("atomic int32 concurrency") {
   ptrdiff_t i;
 
-  ATOMIC(int32_t) foo;
-  ATOMIC(int32_t) bar;
+  int32_t _Atomic foo;
+  int32_t _Atomic bar;
 
   atomic_store_explicit(&foo, 42, memory_order_relaxed);
   atomic_store_explicit(&bar, 43, memory_order_relaxed);
 
-  thrd_t threads[THREAD_COUNT];
-  for (i = 0; i < THREAD_COUNT; i++)
+  thrd_t threads[TEST_ATOMIC_THREAD_COUNT];
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++)
     REQUIRE_EQ(thrd_create(threads + i, test_32_,
                            (void *) ((i % 2) ? &foo : &bar)),
                thrd_success);
-  for (i = 0; i < THREAD_COUNT; i++) thrd_join(threads[i], NULL);
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++) thrd_join(threads[i], NULL);
 
   REQUIRE(atomic_load_explicit(&foo, memory_order_relaxed) == 42);
   REQUIRE(atomic_load_explicit(&bar, memory_order_relaxed) == 43);
@@ -180,9 +183,9 @@ TEST("atomic int32 concurrency") {
 static int test_64_(void *p) {
   ptrdiff_t i;
 
-  ATOMIC(int64_t) *x = (ATOMIC(int64_t) *) p;
+  int64_t _Atomic *x = (int64_t _Atomic *) p;
 
-  for (i = 0; i < TICK_COUNT; i++) {
+  for (i = 0; i < TEST_ATOMIC_TICK_COUNT; i++) {
     atomic_fetch_add_explicit(x, 20202020202020ll,
                               memory_order_relaxed);
     thrd_yield();
@@ -200,18 +203,18 @@ static int test_64_(void *p) {
 TEST("atomic int64 concurrency") {
   ptrdiff_t i;
 
-  ATOMIC(int64_t) foo;
-  ATOMIC(int64_t) bar;
+  int64_t _Atomic foo;
+  int64_t _Atomic bar;
 
   atomic_store_explicit(&foo, 42, memory_order_relaxed);
   atomic_store_explicit(&bar, 43, memory_order_relaxed);
 
-  thrd_t threads[THREAD_COUNT];
-  for (i = 0; i < THREAD_COUNT; i++)
+  thrd_t threads[TEST_ATOMIC_THREAD_COUNT];
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++)
     REQUIRE_EQ(thrd_create(threads + i, test_64_,
                            (void *) ((i % 2) ? &foo : &bar)),
                thrd_success);
-  for (i = 0; i < THREAD_COUNT; i++) thrd_join(threads[i], NULL);
+  for (i = 0; i < TEST_ATOMIC_THREAD_COUNT; i++) thrd_join(threads[i], NULL);
 
   REQUIRE(atomic_load_explicit(&foo, memory_order_relaxed) == 42);
   REQUIRE(atomic_load_explicit(&bar, memory_order_relaxed) == 43);
diff --git a/source/tests/mutex.test.c b/source/tests/mutex.test.c
index 61c1caa..9261fb1 100644
--- a/source/tests/mutex.test.c
+++ b/source/tests/mutex.test.c
@@ -3,7 +3,11 @@
 #define KIT_TEST_FILE mutex
 #include "../kit/test.h"
 
-enum { SLEEP = 400000000, TICK_COUNT = 200, THREAD_COUNT = 100 };
+enum {
+  TEST_MUTEX_SLEEP        = 400000000,
+  TEST_MUTEX_TICK_COUNT   = 200,
+  TEST_MUTEX_THREAD_COUNT = 100,
+};
 
 typedef struct {
   mtx_t lock;
@@ -13,7 +17,7 @@ typedef struct {
 static int mtx_test_run(void *data) {
   int              i;
   mtx_test_data_t *x = (mtx_test_data_t *) data;
-  for (i = 0; i < TICK_COUNT; i++) {
+  for (i = 0; i < TEST_MUTEX_TICK_COUNT; i++) {
     mtx_lock(&x->lock);
 
     x->value += i;
@@ -33,13 +37,13 @@ TEST("mutex lock") {
   ptrdiff_t i;
 
   mtx_test_data_t data;
-  thrd_t          pool[THREAD_COUNT];
+  thrd_t          pool[TEST_MUTEX_THREAD_COUNT];
   data.value = 42;
   REQUIRE(mtx_init(&data.lock, mtx_plain) == thrd_success);
 
-  for (i = 0; i < THREAD_COUNT; i++)
+  for (i = 0; i < TEST_MUTEX_THREAD_COUNT; i++)
     thrd_create(pool + i, mtx_test_run, &data);
-  for (i = 0; i < THREAD_COUNT; i++) thrd_join(pool[i], NULL);
+  for (i = 0; i < TEST_MUTEX_THREAD_COUNT; i++) thrd_join(pool[i], NULL);
 
   mtx_destroy(&data.lock);
   REQUIRE(data.value == 42);
@@ -49,7 +53,7 @@ static int test_lock(void *data) {
   mtx_t *m = (mtx_t *) data;
   mtx_lock(m);
 
-  struct timespec sec = { .tv_sec = 0, .tv_nsec = SLEEP };
+  struct timespec sec = { .tv_sec = 0, .tv_nsec = TEST_MUTEX_SLEEP };
   thrd_sleep(&sec, NULL);
 
   mtx_unlock(m);
@@ -64,7 +68,7 @@ TEST("mutex try lock") {
   thrd_t t;
   REQUIRE(thrd_create(&t, test_lock, &m) == thrd_success);
 
-  struct timespec sec = { .tv_sec = 0, .tv_nsec = SLEEP / 2 };
+  struct timespec sec = { .tv_sec = 0, .tv_nsec = TEST_MUTEX_SLEEP / 2 };
   REQUIRE(thrd_sleep(&sec, NULL) == thrd_success);
 
   REQUIRE(mtx_trylock(&m) == thrd_busy);