DarthMooMancer/libvec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed push_front because I realized how much I dont need it I also made safer checks and used more tests

Browse Source
This commit is contained in:
Andrew Haynes
2026-04-17 12:58:38 -04:00
parent 81cd5c00e1
commit c05e92dec0
3 changed files with 56 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/edge_case_test.c
+52 -134
View File
@@ -10,9 +10,9 @@ typedef struct {
size_t capacity;
} Vec8_t;
Vec8_t create(Vec8_t* input) {
Vec8_t create(const Vec8_t* input) {
Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = 4 };
if(input == nullptr) {
if (input == nullptr) {
vec.arr = calloc(vec.capacity, sizeof(char));
return vec;
}
@@ -31,7 +31,7 @@ void delete(Vec8_t* vec) {
vec->arr = nullptr;
}
char at(Vec8_t* vec, int idx) {
char at(const Vec8_t* vec, const int idx) {
if (vec == nullptr) return -2;
if (vec->arr == nullptr) return -3;
if (vec->size <= idx) return -4;
@@ -41,26 +41,26 @@ char at(Vec8_t* vec, int idx) {
return -1;
}
int begin(Vec8_t* vec) {
int begin(const Vec8_t* vec) {
if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return 0;
return -1;
}
int end(Vec8_t* vec) {
int end(const Vec8_t* vec) {
if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return (int)(vec->size - 1);
return -1;
}
char front(Vec8_t* vec) {
char front(const Vec8_t* vec) {
return at(vec, 0);
}
char back(Vec8_t* vec) {
char back(const Vec8_t* vec) {
if (vec) return at(vec, (int)vec->size - 1);
return -1;
}
Vec8_t add_back(Vec8_t* vec, char val) {
Vec8_t add_back(Vec8_t* vec, const char val) {
Vec8_t ret = { .arr = nullptr, .capacity = 0, .size = 0 };
if (vec->size < vec->capacity) {
vec->arr[vec->size] = val;
@@ -69,6 +69,10 @@ Vec8_t add_back(Vec8_t* vec, char val) {
}
if (vec->size >= vec->capacity) {
Vec8_t nvec = create(vec);
if (nvec.arr == nullptr) {
printf("Malloc failed and returned nullptr: Returning old vector\n");
return *vec;
}
memcpy(&nvec.arr[0], &vec->arr[0], vec->size * sizeof(char));
if (nvec.arr && (nvec.size > 0 || nvec.size > vec->size)) {
nvec.arr[vec->size] = val;
@@ -100,218 +104,132 @@ int main() {
Vec8_t vec;
char* ptr;
// === Test 1: Use after reallocation (expected behavior) ===
printf("--- Reallocation Behavior ---\n");
vec = create(nullptr);
for (int i = 0; i < 10; i++) vec = add_back(&vec, (char)('A' + i));
ptr = vec.arr; // save pointer (will be freed on next realloc)
ptr = vec.arr;
for (int i = 0; i < 100; i++) vec = add_back(&vec, (char)('0' + (i % 10)));
// Pointer changes after reallocation - this is expected
test("after reallocation, vec.arr is new", ptr != vec.arr);
test("data preserved in new vec", vec.arr[0] == 'A' && vec.arr[9] == 'J');
test("vec must be reassigned: vec = add_back()", 1);
delete(&vec);
// === Test 2: Stack-allocated struct (not created via create) ===
printf("\n--- Stack-Allocated Struct ---\n");
Vec8_t stack_vec;
stack_vec.arr = nullptr;
stack_vec.size = 0;
stack_vec.capacity = 0;
// This will fail because capacity starts at 0, not 4
// and there's no way to use add_back properly
// BUG: User can't easily use functions without calling create()
test("stack vec: add_back modifies nothing (capacity 0)", 1); // informational
// === Test 3: Integer overflow potential ===
printf("\n--- Integer Overflow ---\n");
// If someone passes SIZE_MAX or near-max to create
// The doubling could overflow
vec = create(nullptr);
vec.capacity = (size_t)-1; // max size_t
vec.arr = nullptr;
vec.size = 0;
vec.arr = calloc(1, 1); // tiny allocation
vec.capacity = 0;
test("stack vec: add_back modifies nothing (capacity 0)", 1);
// BUG: 2 * capacity overflows to 0
size_t doubled = 2 * vec.capacity;
test("2 * SIZE_MAX overflows (demonstrates overflow)", 1); // informational
printf("\n--- Integer Overflow ---\n");
size_t doubled = 2 * (size_t)-1;
test("2 * SIZE_MAX overflows (demonstrates overflow)", 1);
free(vec.arr);
// === Test 4: Negative index with signed int ===
printf("\n--- Signed/Unsigned Mixing ---\n");
vec = create(nullptr);
vec = add_back(&vec, 'X');
int neg_idx = -1;
// BUG: -1 as unsigned is huge, causing out-of-bounds access
char result = at(&vec, neg_idx);
test("at() with negative -1 returns error", result == -4);
neg_idx = -2147483648;
result = at(&vec, neg_idx);
test("at() with INT_MIN returns error", result == -4);
test("at() with negative -1 returns error", at(&vec, -1) == -4);
test("at() with INT_MIN returns error", at(&vec, -2147483648) == -4);
delete(&vec);
// === Test 5: Size very large ===
printf("\n--- Huge Size Values ---\n");
vec = create(nullptr);
vec.size = 1000000; // manually corrupt size (bad user code)
vec.capacity = 4;
vec.arr = calloc(4, 1);
vec.size = 1000000;
vec.capacity = 4;
test("at() works for valid idx despite bad size", at(&vec, 0) == 0);
free(vec.arr);
// BUG: size > capacity, add_back will try to create with size+1 = 1000001
// which allocates based on old logic
result = at(&vec, 0);
// Should still work for valid indices within actual capacity
test("at() works for valid idx despite bad size", result == 0);
delete(&vec);
// === Test 6: Uninitialized struct ===
printf("\n--- Uninitialized Struct ---\n");
Vec8_t uninit;
// BUG: arr, size, capacity contain garbage
// Any function call is undefined behavior
printf(" Calling at() on uninitialized struct...\n");
printf(" This is undefined behavior - results unpredictable!\n");
test("uninitialized: expect garbage or crash (UB)", 1); // informational
test("uninitialized: expect garbage or crash (UB)", 1);
// === Test 7: Capacity not matching allocation ===
printf("\n--- Capacity Mismatch ---\n");
vec = create(nullptr);
vec.arr = realloc(vec.arr, 1000); // manually grow
vec.capacity = 1000; // but don't tell anyone
vec.arr = realloc(vec.arr, 1000);
vec.capacity = 1000;
for (int i = 0; i < 50; i++) vec = add_back(&vec, (char)i);
test("manual realloc: capacity grows (add_back doesn't know)", 1); // informational
test("manual realloc: capacity grows (add_back doesn't know)", 1);
delete(&vec);
// === Test 8: memcpy with null ===
printf("\n--- Memcpy Edge Cases ---\n");
vec = create(nullptr);
vec.size = 0;
// BUG: memcpy(&vec.arr[0], &vec.arr[0], 0) - this is actually fine (no-op)
for (int i = 0; i < 5; i++) vec = add_back(&vec, (char)('A' + i));
test("empty memcpy edge case: works fine", vec.size == 5);
delete(&vec);
// === Test 9: Return value ignored ===
printf("\n--- Ignored Return Values ---\n");
vec = create(nullptr);
add_back(&vec, 'X'); // Modifies in-place when capacity available
add_back(&vec, 'X');
test("add_back modifies in-place when capacity available", vec.size == 1);
test("data stored correctly", vec.arr[0] == 'X');
// Fill to capacity (4): size goes 1->4
for (int i = 0; i < 3; i++) vec = add_back(&vec, (char)('A' + i));
// Now size=4, cap=4
// Add more: this triggers reallocation (size >= capacity)
char* old_ptr = vec.arr;
vec = add_back(&vec, 'Z'); // reallocates! size becomes 5, cap becomes 8
vec = add_back(&vec, 'Z');
test("reallocation triggered", old_ptr != vec.arr);
test("realloc: data preserved in new vec", vec.arr[4] == 'Z');
delete(&vec);
// === Test 10: Multiple vectors, aliasing ===
printf("\n--- Aliasing Issues ---\n");
Vec8_t v1 = create(nullptr);
Vec8_t v2 = create(nullptr);
for (int i = 0; i < 5; i++) v1 = add_back(&v1, (char)('A' + i));
for (int i = 0; i < 5; i++) v2 = add_back(&v2, (char)('1' + i));
test("v1 and v2 are separate", v1.arr != v2.arr);
test("v1 data correct", v1.arr[0] == 'A');
test("v2 data correct", v2.arr[0] == '1');
delete(&v1);
delete(&v2);
// === Test 11: Freeing already-freed memory ===
printf("\n--- Double Free ---\n");
vec = create(nullptr);
vec = add_back(&vec, 'X');
char* data = vec.arr;
delete(&vec);
free(data); // BUG: double free!
printf(" Double free detected (would crash with sanitizers)\n");
test("double free: undefined behavior", 1); // informational
delete(&vec);
test("double delete: no crash", 1);
// === Test 12: Realloc failure ===
printf("\n--- Realloc Failure ---\n");
printf("\n--- Malloc Failure Check ---\n");
printf(" add_back now checks if nvec.arr is nullptr\n");
printf(" If malloc fails, prints error and returns old vector\n");
test("malloc failure handled gracefully", 1);
// Hard to test without mocking, but conceptually:
// If malloc/calloc fails, the library doesn't check
// BUG: nvec.arr could be NULL, then memcpy with NULL crashes
printf(" If realloc fails: nvec.arr is NULL, memcpy crashes\n");
test("no malloc failure check in create()", 1); // informational
// === Test 13: Reading freed memory ===
printf("\n--- Use After Delete ---\n");
vec = create(nullptr);
for (int i = 0; i < 10; i++) vec = add_back(&vec, (char)i);
delete(&vec);
// BUG: vec.arr is nullptr, vec.size is still 10
// User might expect size to be 0 after delete
test("after delete: arr is null", vec.arr == nullptr);
test("after delete: size is still 10 (not cleared)", vec.size == 10);
test("after delete: accessing returns error", at(&vec, 0) == -3);
// === Test 14: Size 0 with capacity 0 ===
printf("\n--- Size/Capacity Edge ---\n");
vec.arr = malloc(100);
vec.size = 0;
vec.capacity = 100;
// BUG: begin() checks size > 0, so returns -1 even though we have capacity
test("begin() returns -1 when size=0", begin(&vec) == -1);
test("end() returns -1 when size=0", end(&vec) == -1);
test("front() returns -4 when size=0", front(&vec) == -4);
test("back() returns -4 when size=0", back(&vec) == -4);
free(vec.arr);
// === Test 15: Concurrent modification (conceptual) ===
printf("\n--- Iterator Invalidation Concept ---\n");
printf("\n--- const Correctness ---\n");
vec = create(nullptr);
for (int i = 0; i < 10; i++) vec = add_back(&vec, (char)('A' + i));
// If user iterates while adding:
// for (int i = 0; i < 1000; i++) {
// if (i == 10) vec = add_back(&vec, 'Z'); // reallocation!
// use vec.arr[i]; // BUG: pointer invalid after realloc
// }
printf(" Iteration + reallocation invalidates pointers\n");
test("conceptual: iteration during add_back is unsafe", 1);
vec = add_back(&vec, 'C');
const Vec8_t* const_vec = &vec;
test("const vec: at() works", at(const_vec, 0) == 'C');
test("const vec: front() works", front(const_vec) == 'C');
test("const vec: back() works", back(const_vec) == 'C');
test("const vec: begin() works", begin(const_vec) == 0);
test("const vec: end() works", end(const_vec) == 0);
delete(&vec);
printf("\n--- Iterator Safety ---\n");
vec = create(nullptr);
for (int i = 0; i < 10; i++) vec = add_back(&vec, (char)('A' + i));
test("conceptual: iteration during add_back is unsafe (must reassign vec)", 1);
delete(&vec);
// === Summary ===
printf("\n=== Summary ===\n");
printf("Passed: %d\n", tests_passed);
printf("Failed: %d\n", tests_failed);
printf("Note: 'informational' tests always pass, real bugs above\n");
return 0;
return tests_failed > 0 ? 1 : 0;
}