Add issue templates (#13)

habedi · web-flow · commit 1d1b7ad970b4 · 2026-01-10T19:03:53.000+01:00
diff --git a/.editorconfig b/.editorconfig
@@ -1,4 +1,4 @@
-# EditorConfig is awesome: https://EditorConfig.org
+# https://EditorConfig.org
 
 root = true
 
@@ -15,7 +15,7 @@ max_line_length = 100
 
 [*.md]
 max_line_length = 130
-trim_trailing_whitespace = false # Don't remove trailing whitespace in Markdown files
+trim_trailing_whitespace = false
 
 [*.{yml,yaml}]
 indent_size = 2
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: [ habedi ]
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,25 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+1.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Logs**
+If applicable, add logs to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Discussions
+    url: https://github.com/habedi/bptree/discussions
+    about: Please ask and answer general questions here
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/.github/workflows/benches.yml b/.github/workflows/benches.yml
@@ -1,13 +1,16 @@
 name: Run Benchmarks
 
 on:
-  workflow_dispatch:  # Allow manual runs
+  workflow_dispatch:
   push:
     tags:
-      - 'v*'  # Trigger on version tags
+      - 'v*'
+
+permissions:
+  contents: read
 
 jobs:
-  lint:
+  benchmark:
     runs-on: ubuntu-latest
 
     steps:
diff --git a/.github/workflows/lints.yml b/.github/workflows/lints.yml
@@ -1,10 +1,18 @@
-name: Run Linters
+name: Run Linter Checks
 
 on:
-  workflow_dispatch:  # Allow manual runs
+  workflow_dispatch:
   push:
     tags:
-      - 'v*'  # Trigger on version tags
+      - 'v*'
+  pull_request:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+
+permissions:
+  contents: read
 
 jobs:
   lint:
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -1,13 +1,21 @@
 name: Run Test
 
 on:
-  workflow_dispatch:  # Allow manual runs
+  workflow_dispatch:
   push:
     tags:
-      - 'v*'  # Trigger on version tags
+      - 'v*'
+  pull_request:
+    branches:
+      - main
+    paths-ignore:
+      - '**.md'
+
+permissions:
+  contents: read
 
 jobs:
-  build:
+  test:
     runs-on: ubuntu-latest
 
     steps:
diff --git a/.gitignore b/.gitignore
@@ -145,3 +145,4 @@ perf.data
 *.old
 *.folded
 *.perf
+core.*
diff --git a/include/bptree.h b/include/bptree.h
@@ -43,7 +43,7 @@
  *   - This implementation is NOT thread-safe. Caller must provide external
  *     synchronization (e.g., mutexes) for concurrent access.
  *
- * @version 0.4.1-beta
+ * @version 0.4.3
  * @author
  *   "Hassan Abedi <hassan.abedi.t+bptree@gmail.com>"
  * @copyright MIT License
@@ -546,10 +546,18 @@ static bool bptree_check_invariants_node(bptree_node* node, const bptree* tree,
                 const bptree_key_t max_in_child0 =
                     bptree_find_largest_key(children[0], tree->max_keys);
                 if (tree->compare(&max_in_child0, &keys[0]) >= 0) {
+#ifdef BPTREE_KEY_TYPE_STRING
+                    bptree_debug_print(tree->enable_debug,
+                                       "Invariant Fail: max(child[0]) >= key[0] in node %p -- "
+                                       "MaxChild=%.*s Key=%.*s\n",
+                                       (void*)node, (int)BPTREE_KEY_SIZE, max_in_child0.data,
+                                       (int)BPTREE_KEY_SIZE, keys[0].data);
+#else
                     bptree_debug_print(tree->enable_debug,
                                        "Invariant Fail: max(child[0]) >= key[0] in node %p -- "
                                        "MaxChild=%lld Key=%lld\n",
                                        (void*)node, (long long)max_in_child0, (long long)keys[0]);
+#endif
                     return false;
                 }
             }
diff --git a/pyproject.toml b/pyproject.toml
@@ -11,11 +11,11 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=8.0.1",
-    "pytest-cov>=6.0.0",
-    "pytest-mock>=3.14.0",
+    "pytest (>=8.0.1,<9.0.0)",
+    "pytest-cov (>=6.0.0,<7.0.0)",
+    "pytest-mock (>=3.14.0,<4.0.0)",
     "pytest-asyncio (>=0.26.0,<0.27.0)",
-    "mypy>=1.11.1",
-    "ruff>=0.9.3",
+    "mypy (>=1.11.1,<2.0.0)",
+    "ruff (>=0.9.3,<1.0.0)",
     "icecream (>=2.1.4,<3.0.0)"
 ]
diff --git a/test/bench_bptree.c b/test/bench_bptree.c
@@ -12,7 +12,7 @@
  * Benchmark parameters (number of items `N`, tree order `MAX_ITEMS`, random seed `SEED`)
  * can be configured via environment variables.
  *
- * @version 0.4.1-beta
+ * @version 0.4.3
  */
 
 #define BPTREE_IMPLEMENTATION  // Include the bptree implementation
diff --git a/test/example.c b/test/example.c
@@ -7,7 +7,7 @@
  * removing records, and updating records using the bptree library.
  * It uses numeric keys and stores pointers to a custom `record_t` struct as values.
  *
- * @version 0.4.1-beta
+ * @version 0.4.3
  */
 
 #define BPTREE_IMPLEMENTATION             // Include implementation of B+ tree
diff --git a/test/extras/repro_bugs.c b/test/extras/repro_bugs.c
@@ -0,0 +1,167 @@
+#define BPTREE_IMPLEMENTATION
+#include "bptree.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <assert.h>
+#include <string.h>
+
+#define MAX_ITEMS 2000
+#define OPERATIONS 10000
+
+// Simple numeric key comparison
+int compare_ints(const bptree_key_t* a, const bptree_key_t* b) {
+    return (*a < *b) ? -1 : ((*a > *b) ? 1 : 0);
+}
+
+void print_tree_structure(bptree_node* node, int depth, int max_keys) {
+    if (!node) return;
+    for (int i = 0; i < depth; i++) printf("  ");
+    printf("%s [", node->is_leaf ? "LEAF" : "INTERNAL");
+    bptree_key_t* keys = (bptree_key_t*)node->data;
+    for (int i = 0; i < node->num_keys; i++) {
+        printf(" %lld", (long long)keys[i]);
+    }
+    printf(" ]\n");
+    
+    if (!node->is_leaf) {
+        size_t offset = (size_t)(max_keys + 1) * sizeof(bptree_key_t);
+        size_t req_align = (sizeof(bptree_value_t) > sizeof(bptree_node*) ? sizeof(bptree_value_t) : sizeof(bptree_node*));
+        size_t pad = (req_align - (offset % req_align)) % req_align;
+        bptree_node** children = (bptree_node**)(node->data + offset + pad);
+        
+        for (int i = 0; i <= node->num_keys; i++) {
+            print_tree_structure(children[i], depth + 1, max_keys);
+        }
+    }
+}
+
+int main(int argc, char** argv) {
+    int seed = time(NULL);
+    int max_keys = 3;
+    int operations = 10000;
+
+    if (argc > 1) seed = atoi(argv[1]);
+    if (argc > 2) max_keys = atoi(argv[2]);
+    if (argc > 3) operations = atoi(argv[3]);
+
+    printf("Seed: %d, Max Keys: %d, Operations: %d\n", seed, max_keys, operations);
+    srand(seed);
+
+    bptree* tree = bptree_create(max_keys, compare_ints, false);
+    
+    // Keep track of what we think is in the tree
+    bool in_tree[MAX_ITEMS] = {0};
+    int count = 0;
+
+    for (int i = 0; i < operations; i++) {
+        int op = rand() % 10;
+        int key_val = rand() % MAX_ITEMS;
+        bptree_key_t key = (bptree_key_t)key_val;
+        bptree_value_t val = (bptree_value_t)(intptr_t)key_val;
+
+        if (op < 3) { // 30% Insert
+            if (!in_tree[key_val]) {
+                // printf("Op %d: Insert %d\n", i, key_val);
+                bptree_status status = bptree_put(tree, &key, val);
+                if (status != BPTREE_OK) {
+                    printf("Insert failed for key %d with status %d\n", key_val, status);
+                    exit(1);
+                }
+                in_tree[key_val] = true;
+                count++;
+            }
+        } else if (op < 6) { // 30% Delete
+            if (in_tree[key_val]) {
+                // printf("Op %d: Remove %d\n", i, key_val);
+                bptree_status status = bptree_remove(tree, &key);
+                if (status != BPTREE_OK) {
+                    printf("Remove failed for key %d with status %d\n", key_val, status);
+                    // print_tree_structure(tree->root, 0, tree->max_keys);
+                    exit(1);
+                }
+                in_tree[key_val] = false;
+                count--;
+            }
+        } else if (op < 8) { // 20% Get
+            if (in_tree[key_val]) {
+                bptree_value_t val;
+                bptree_status status = bptree_get(tree, &key, &val);
+                if (status != BPTREE_OK) {
+                    printf("Get failed for key %d with status %d\n", key_val, status);
+                    exit(1);
+                }
+                if ((intptr_t)val != key_val) {
+                    printf("Get returned wrong value for key %d: %ld\n", key_val, (intptr_t)val);
+                    exit(1);
+                }
+            } else {
+                bptree_value_t val;
+                bptree_status status = bptree_get(tree, &key, &val);
+                if (status == BPTREE_OK) {
+                    printf("Get found deleted/missing key %d!\n", key_val);
+                    exit(1);
+                }
+            }
+        } else { // 20% Range Query
+            int start_val = rand() % MAX_ITEMS;
+            int end_val = start_val + rand() % 100;
+            if (end_val >= MAX_ITEMS) end_val = MAX_ITEMS - 1;
+            
+            bptree_key_t start_key = (bptree_key_t)start_val;
+            bptree_key_t end_key = (bptree_key_t)end_val;
+            
+            bptree_value_t* results = NULL;
+            int n_results = 0;
+            bptree_status status = bptree_get_range(tree, &start_key, &end_key, &results, &n_results);
+            if (status != BPTREE_OK) {
+                printf("Range query failed for [%d, %d] with status %d\n", start_val, end_val, status);
+                exit(1);
+            }
+            
+            int expected_count = 0;
+            for (int k = start_val; k <= end_val; k++) {
+                if (in_tree[k]) expected_count++;
+            }
+            
+            if (n_results != expected_count) {
+                printf("Range query count mismatch for [%d, %d]. Got %d, Expected %d\n", start_val, end_val, n_results, expected_count);
+                exit(1);
+            }
+            
+            // Verify results are sorted
+            for (int k = 0; k < n_results - 1; k++) {
+                if ((intptr_t)results[k] >= (intptr_t)results[k+1]) {
+                    printf("Range query results not sorted!\n");
+                    exit(1);
+                }
+            }
+            
+            // Verify values match keys (since value == key in this test)
+            for (int k = 0; k < n_results; k++) {
+                 int val = (int)(intptr_t)results[k];
+                 if (val < start_val || val > end_val || !in_tree[val]) {
+                     printf("Range query returned invalid value: %d\n", val);
+                     exit(1);
+                 }
+            }
+
+            free(results);
+        }
+        if (!bptree_check_invariants(tree)) {
+            printf("Invariant check failed after operation %d (Key: %d, Op: %s)\n", 
+                   i, key_val, (op < 6) ? "Insert" : "Remove");
+            // print_tree_structure(tree->root, 0, tree->max_keys);
+            exit(1);
+        }
+        
+        if (tree->count != count) {
+             printf("Count mismatch! Tree: %d, Expected: %d\n", tree->count, count);
+             exit(1);
+        }
+    }
+
+    printf("Completed %d operations successfully. Final count: %d, Height: %d\n", operations, tree->count, tree->height);
+    bptree_free(tree);
+    return 0;
+}
diff --git a/test/extras/repro_string.c b/test/extras/repro_string.c
diff --git a/test/extras/test_merge.c b/test/extras/test_merge.c
diff --git a/test/test_bptree.c b/test/test_bptree.c

-Original file line number
+Diff line change
 *.old
 *.folded
 *.perf
 +core.*