chore(actions): remove fuzz job

.gitea/workflows/build.yml

@@ -42,36 +42,3 @@ jobs:
 
       - name: Run unit tests
         run: ./demo/build/ikv_tests
-
-  linux-fuzz:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install build tools
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y build-essential coreutils
-
-      - name: Build fuzz target
-        run: |
-          mkdir -p demo/build
-          gcc -std=c11 -Wall -Wextra -pedantic \
-            -fsanitize=address,undefined \
-            -fno-omit-frame-pointer \
-            -Iinclude \
-            demo/fuzz.c \
-            src/ikv.c \
-            src/loaders/ikv1.c \
-            src/loaders/ikv2.c \
-            -o demo/build/ikv_fuzz
-
-      - name: Smoke check fuzz target
-        run: |
-          timeout 15s ./demo/build/ikv_fuzz
-
-      - name: Fuzz for 10 minutes
-        run: |
-          timeout 10m ./demo/build/ikv_fuzz

demo/fuzz.c

@@ -1,179 +0,0 @@
-#include "ikv.h"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-static uint32_t fuzz_rand_state = 0xC0FFEE42u;
-
-static uint32_t fuzz_rand_u32(void)
-{
-    fuzz_rand_state ^= fuzz_rand_state << 13;
-    fuzz_rand_state ^= fuzz_rand_state >> 17;
-    fuzz_rand_state ^= fuzz_rand_state << 5;
-    return fuzz_rand_state;
-}
-
-static size_t fuzz_rand_range(size_t limit)
-{
-    if (limit == 0u)
-        return 0u;
-    return (size_t)(fuzz_rand_u32() % (uint32_t)limit);
-}
-
-static void fuzz_mutate_bytes(uint8_t *buffer, size_t size, unsigned int mutations)
-{
-    for (unsigned int i = 0; i < mutations; ++i)
-    {
-        if (size == 0u)
-            return;
-
-        switch (fuzz_rand_u32() % 4u)
-        {
-        case 0:
-            buffer[fuzz_rand_range(size)] ^= (uint8_t)(1u << (fuzz_rand_u32() % 8u));
-            break;
-        case 1:
-            buffer[fuzz_rand_range(size)] = (uint8_t)fuzz_rand_u32();
-            break;
-        case 2:
-        {
-            size_t start = fuzz_rand_range(size);
-            size_t span = fuzz_rand_range(size - start);
-            memset(buffer + start, (int)(fuzz_rand_u32() & 0xFFu), span);
-        }
-        break;
-        default:
-            if (size > 1u)
-            {
-                size_t a = fuzz_rand_range(size);
-                size_t b = fuzz_rand_range(size);
-                uint8_t tmp = buffer[a];
-                buffer[a] = buffer[b];
-                buffer[b] = tmp;
-            }
-            break;
-        }
-    }
-}
-
-static void fuzz_text_input(const char *seed)
-{
-    size_t seed_len = strlen(seed);
-    size_t size = seed_len + 32u;
-    char *buffer = (char *)malloc(size + 1u);
-    if (!buffer)
-        return;
-
-    memcpy(buffer, seed, seed_len + 1u);
-    fuzz_mutate_bytes((uint8_t *)buffer, seed_len, 1u + (unsigned int)fuzz_rand_range(16u));
-    buffer[seed_len] = 0;
-
-    {
-        ikv_node_t *node = ikv_parse_string(buffer);
-        if (node)
-            ikv_free(node);
-    }
-
-    free(buffer);
-}
-
-static void fuzz_binary_input(const uint8_t *seed, size_t seed_size)
-{
-    uint8_t *buffer = (uint8_t *)malloc(seed_size ? seed_size : 1u);
-    if (!buffer)
-        return;
-
-    if (seed_size > 0u)
-        memcpy(buffer, seed, seed_size);
-    fuzz_mutate_bytes(buffer, seed_size, 1u + (unsigned int)fuzz_rand_range(24u));
-
-    {
-        ikv_node_t *node = ikvb_parse_memory(buffer, seed_size);
-        if (node)
-            ikv_free(node);
-    }
-
-    free(buffer);
-}
-
-static void fuzz_binary_truncations(const uint8_t *seed, size_t seed_size)
-{
-    for (size_t i = 0; i < seed_size; ++i)
-    {
-        ikv_node_t *node = ikvb_parse_memory(seed, i);
-        if (node)
-            ikv_free(node);
-    }
-}
-
-int main(void)
-{
-    static const char *text_seeds[] = {
-        "ikv1 \"root\" { \"a\" 1 }",
-        "ikv2 \"root\" { \"nested\" { \"flag\" true } }",
-        "{ \"plain\" \"text\" }",
-        "\"k\" \"v\", \"n\" 123",
-        "ikv2 \"root\" { \"arr\" [ 1 2 3 ] }",
-    };
-    ikv_node_t *root = ikv_create_object("root");
-    ikv_node_t *nested = NULL;
-    ikv_node_t *array = NULL;
-    uint8_t *good_v1 = NULL;
-    uint8_t *good_v2 = NULL;
-    uint32_t good_v1_size = 0u;
-    uint32_t good_v2_size = 0u;
-    unsigned long iterations = 0ul;
-    time_t end_time = time(NULL) + (10 * 60);
-
-    if (!root)
-        return 1;
-
-    ikv_object_set_string(root, "title", "fuzz");
-    ikv_object_set_int(root, "count", 42);
-    nested = ikv_object_add_object(root, "nested");
-    array = ikv_object_add_array(root, "items", IKV_STRING);
-    if (!nested || !array)
-    {
-        ikv_free(root);
-        return 1;
-    }
-
-    ikv_object_set_bool(nested, "flag", true);
-    ikv_object_set_float(nested, "value", 3.14159);
-    ikv_array_add_string(array, "a");
-    ikv_array_add_string(array, "b");
-    ikv_array_add_string(array, "c");
-
-    if (!ikvb_write_memory_version(root, &good_v1, &good_v1_size, IKV_VERSION_1) ||
-        !ikvb_write_memory_version(root, &good_v2, &good_v2_size, IKV_VERSION_2))
-    {
-        free(good_v1);
-        free(good_v2);
-        ikv_free(root);
-        return 1;
-    }
-
-    while (time(NULL) < end_time)
-    {
-        const char *text_seed = text_seeds[fuzz_rand_range(sizeof(text_seeds) / sizeof(text_seeds[0]))];
-
-        fuzz_text_input(text_seed);
-        fuzz_binary_input(good_v1, good_v1_size);
-        fuzz_binary_input(good_v2, good_v2_size);
-
-        if ((iterations % 128ul) == 0ul)
-            fuzz_binary_truncations(good_v2, good_v2_size);
-
-        ++iterations;
-    }
-
-    printf("fuzz iterations: %lu\n", iterations);
-
-    free(good_v1);
-    free(good_v2);
-    ikv_free(root);
-    return 0;
-}