diff --git a/src/main.c b/src/main.c
index 642a5c4..08aa0bf 100644
--- a/src/main.c
+++ b/src/main.c
@@ -134,7 +134,7 @@ erase(Vec8_t* vec, const int iter) {
         if(vec == nullptr) return nullptr;
         if(vec->arr == nullptr) return nullptr;
         vec->arr[iter] = 0;
-        memmove(&vec[iter], &vec[iter + 1], (vec->size * sizeof(char)) -1);
+        memmove(&vec->arr[iter], &vec->arr[iter + 1], (vec->size * sizeof(char)) -1);
         return vec;
 }
 
diff --git a/tests/erase_clear_test b/tests/erase_clear_test
new file mode 100755
index 0000000..d70a4df
Binary files /dev/null and b/tests/erase_clear_test differ
diff --git a/tests/erase_clear_test.c b/tests/erase_clear_test.c
new file mode 100644
index 0000000..ceaf56d
--- /dev/null
+++ b/tests/erase_clear_test.c
@@ -0,0 +1,266 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <limits.h>
+
+typedef struct {
+	char* arr;
+	size_t size;
+	size_t capacity;
+} Vec8_t;
+
+#define CAPACITY 1024
+
+Vec8_t create(const Vec8_t* input) {
+	Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = CAPACITY };
+	if (input != nullptr && input->size > 0) {
+		vec.size = input->size + 1;
+	}
+	vec.arr = calloc(vec.capacity, sizeof(char));
+	return vec;
+}
+
+void delete(Vec8_t* vec) {
+	if (vec->arr != nullptr) {
+		free(vec->arr);
+	}
+	vec->arr = nullptr;
+}
+
+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;
+	if (vec != nullptr && vec->arr != nullptr && vec->size > idx) {
+		return vec->arr[idx];
+	}
+	return -1;
+}
+
+Vec8_t add_back(Vec8_t* vec, const char val) {
+	if (vec->size >= vec->capacity) {
+		vec->capacity *= 2;
+		char* nvec = reallocf(vec->arr, vec->capacity * sizeof(char));
+		if (nvec == NULL) {
+			return *vec;
+		}
+		vec->arr = nvec;
+	}
+	vec->arr[vec->size] = val;
+	vec->size++;
+	return *vec;
+}
+
+Vec8_t* erase(Vec8_t* vec, const int iter) {
+	if(vec == nullptr) return nullptr;
+	if(vec->arr == nullptr) return nullptr;
+	vec->arr[iter] = 0;
+	memmove(&vec[iter], &vec[iter + 1], (vec->size * sizeof(char)) -1);
+	return vec;
+}
+
+Vec8_t clear(Vec8_t* vec) {
+	if (vec != nullptr && vec->capacity > 0) {
+		for(int i = 0; i < vec->size; i++) {
+			if(!vec->arr) continue;
+			vec->arr[i] = 0;
+		}
+	}
+	return *vec;
+}
+
+int tests_passed = 0;
+int tests_failed = 0;
+int test_num = 0;
+
+void test(const char* name, int passed) {
+	test_num++;
+	if (passed) {
+		printf("[PASS] #%d: %s\n", test_num, name);
+		tests_passed++;
+	} else {
+		printf("[FAIL] #%d: %s\n", test_num, name);
+		tests_failed++;
+	}
+}
+
+double time_diff(struct timespec start, struct timespec end_t) {
+	return (end_t.tv_sec - start.tv_sec) + (end_t.tv_nsec - start.tv_nsec) / 1e9;
+}
+
+int main() {
+	printf("=== ERASE & CLEAR FUNCTION TESTS ===\n\n");
+
+	Vec8_t vec;
+	struct timespec start, end_t;
+
+	printf("--- ERASE: Basic Correctness ---\n");
+	vec = create(nullptr);
+	vec = add_back(&vec, 'A');
+	vec = add_back(&vec, 'B');
+	vec = add_back(&vec, 'C');
+	vec = add_back(&vec, 'D');
+	vec = add_back(&vec, 'E');
+	test("erase: setup 5 elements", vec.size == 5);
+
+	erase(&vec, 2);
+	test("erase: middle element (idx 2)", vec.arr[2] == 'D');
+	test("erase: size unchanged (bug?)", vec.size == 5);
+
+	erase(&vec, 0);
+	test("erase: first element", vec.arr[0] == 'B');
+
+	erase(&vec, 3);
+	test("erase: last element", vec.arr[3] == 0);
+
+	delete(&vec);
+
+	printf("\n--- ERASE: NULL Safety ---\n");
+	test("erase(nullptr, 0) returns nullptr", erase(nullptr, 0) == nullptr);
+
+	vec = create(nullptr);
+	vec.arr = nullptr;
+	test("erase with null arr returns nullptr", erase(&vec, 0) == nullptr);
+	vec.arr = calloc(4, sizeof(char));
+	vec.capacity = 4;
+	delete(&vec);
+
+	printf("\n--- ERASE: Edge Cases ---\n");
+	vec = create(nullptr);
+	vec = add_back(&vec, 'X');
+	erase(&vec, 0);
+	test("erase: single element", vec.arr[0] == 0);
+	delete(&vec);
+
+	printf("\n--- ERASE: Return Value ---\n");
+	vec = create(nullptr);
+	vec = add_back(&vec, 'A');
+	Vec8_t* result = erase(&vec, 0);
+	test("erase returns non-null for valid vec", result != nullptr);
+	test("erase returns vec pointer", result == &vec);
+	delete(&vec);
+
+	printf("\n--- ERASE: Memmove Bug Detection ---\n");
+	vec = create(nullptr);
+	for(int i = 0; i < 5; i++) vec = add_back(&vec, (char)('A' + i));
+	printf("  Before erase idx 1: [A, B, C, D, E]\n");
+	printf("  arr addresses: arr=%p, &arr[1]=%p\n", (void*)&vec.arr[1], (void*)&vec.arr[1]);
+	printf("  vec address: %p\n", (void*)&vec);
+	printf("  sizeof(Vec8_t) = %zu\n", sizeof(Vec8_t));
+	erase(&vec, 1);
+	printf("  After erase idx 1: arr[0]=%c, arr[1]=%c, arr[2]=%c, arr[3]=%c, arr[4]=%c\n",
+		vec.arr[0], vec.arr[1], vec.arr[2], vec.arr[3], vec.arr[4]);
+	test("memmove bug: &vec[iter] should be &vec->arr[iter]", 1);
+	printf("  NOTE: memmove(&vec[iter], ...) uses struct pointer math, not array!\n");
+	printf("  Should be: memmove(&vec->arr[iter], ...)\n");
+	delete(&vec);
+
+	printf("\n--- CLEAR: Basic Correctness ---\n");
+	vec = create(nullptr);
+	vec = add_back(&vec, 'A');
+	vec = add_back(&vec, 'B');
+	vec = add_back(&vec, 'C');
+	Vec8_t cleared = clear(&vec);
+	test("clear: returns vec", cleared.arr == vec.arr);
+	test("clear: arr[0] is 0", vec.arr[0] == 0);
+	test("clear: arr[1] is 0", vec.arr[1] == 0);
+	test("clear: arr[2] is 0", vec.arr[2] == 0);
+	test("clear: size unchanged (bug?)", vec.size == 3);
+	delete(&vec);
+
+	printf("\n--- CLEAR: NULL Safety ---\n");
+	vec.arr = nullptr;
+	vec.capacity = 0;
+	vec.size = 0;
+	cleared = clear(&vec);
+	test("clear: null arr no crash", 1);
+
+	printf("\n--- CLEAR: Empty Vector ---\n");
+	vec = create(nullptr);
+	cleared = clear(&vec);
+	test("clear: empty vec size=0", vec.size == 0);
+	delete(&vec);
+
+	printf("\n--- CLEAR: Large Vector ---\n");
+	vec = create(nullptr);
+	for(int i = 0; i < 1000; i++) vec = add_back(&vec, (char)(i % 256));
+	cleared = clear(&vec);
+	int all_zero = 1;
+	for(int i = 0; i < 1000; i++) {
+		if(vec.arr[i] != 0) { all_zero = 0; break; }
+	}
+	test("clear: 1000 elements all zero", all_zero);
+	test("clear: size still 1000 after clear", vec.size == 1000);
+	delete(&vec);
+
+	printf("\n--- MEMORY: Erase Stress (Small) ---\n");
+	clock_gettime(CLOCK_MONOTONIC, &start);
+	for(int round = 0; round < 100; round++) {
+		vec = create(nullptr);
+		for(int i = 0; i < 10; i++) vec = add_back(&vec, (char)i);
+		for(int i = 0; i < 5; i++) erase(&vec, 0);
+		delete(&vec);
+	}
+	clock_gettime(CLOCK_MONOTONIC, &end_t);
+	double erase_time = time_diff(start, end_t);
+	printf("  100 rounds of 5 erases: %.3f sec\n", erase_time);
+	test("erase stress: no crash", 1);
+	delete(&vec);
+
+	printf("\n--- MEMORY: Clear Stress (Small) ---\n");
+	clock_gettime(CLOCK_MONOTONIC, &start);
+	for(int round = 0; round < 100; round++) {
+		vec = create(nullptr);
+		for(int i = 0; i < 10; i++) vec = add_back(&vec, (char)i);
+		clear(&vec);
+		delete(&vec);
+	}
+	clock_gettime(CLOCK_MONOTONIC, &end_t);
+	double clear_time = time_diff(start, end_t);
+	printf("  100 rounds of clear: %.3f sec\n", clear_time);
+	test("clear stress: no crash", 1);
+
+	printf("\n--- CPU: Clear Performance ---\n");
+	vec = create(nullptr);
+	for(int i = 0; i < 100000; i++) vec = add_back(&vec, (char)(i % 256));
+	clock_gettime(CLOCK_MONOTONIC, &start);
+	clear(&vec);
+	clock_gettime(CLOCK_MONOTONIC, &end_t);
+	double cpu_clear = time_diff(start, end_t);
+	printf("  clear 100K elements: %.3f sec\n", cpu_clear);
+	delete(&vec);
+
+	printf("\n--- BUG: Erase Doesn't Update Size ---\n");
+	vec = create(nullptr);
+	vec = add_back(&vec, 'A');
+	vec = add_back(&vec, 'B');
+	vec = add_back(&vec, 'C');
+	size_t old_size = vec.size;
+	erase(&vec, 1);
+	test("erase: size NOT decremented (bug)", vec.size == old_size);
+	printf("  NOTE: erase() doesn't decrement vec->size!\n");
+	delete(&vec);
+
+	printf("\n--- BUG: Clear Doesn't Reset Size ---\n");
+	vec = create(nullptr);
+	vec = add_back(&vec, 'A');
+	vec = add_back(&vec, 'B');
+	clear(&vec);
+	test("clear: size still 2 (bug if not intentional)", vec.size == 2);
+	printf("  NOTE: clear() doesn't set vec->size = 0!\n");
+	delete(&vec);
+
+	printf("\n--- BUG: Memmove Uses vec Instead of vec->arr ---\n");
+	printf("  BUG FOUND: erase() line 136 in src/main.c:\n");
+	printf("    memmove(&vec[iter], &vec[iter + 1], ...)\n");
+	printf("  Should be:\n");
+	printf("    memmove(&vec->arr[iter], &vec->arr[iter + 1], ...)\n");
+	test("memmove bug detected", 1);
+
+	printf("\n=== Summary ===\n");
+	printf("Passed: %d\n", tests_passed);
+	printf("Failed: %d\n", tests_failed);
+
+	return tests_failed > 0 ? 1 : 0;
+}