From b87efd23985d7cdf4ebdb773507230e7652a30d0 Mon Sep 17 00:00:00 2001 From: Andrew Haynes Date: Tue, 5 May 2026 13:23:19 -0400 Subject: [PATCH] removing AI and am going to start learning how to write my own unit tests --- AGENTS.md | 12 - main_test | Bin 34152 -> 0 bytes src/main.c | 69 ++- stress_erase_test | Bin 34144 -> 0 bytes tests/cpu_stress | Bin 34072 -> 0 bytes tests/cpu_stress.c | 187 -------- tests/crash_9b_test | Bin 33888 -> 0 bytes tests/crash_9b_test.c | 107 ----- tests/crash_memory_test | Bin 33888 -> 0 bytes tests/crash_memory_test.c | 198 --------- tests/edge_case_test | Bin 34112 -> 0 bytes tests/edge_case_test.c | 235 ---------- tests/erase_clear_test | Bin 35792 -> 0 bytes tests/erase_clear_test.c | 705 ----------------------------- tests/erase_stress_test | Bin 35072 -> 0 bytes tests/erase_stress_test.c | 418 ----------------- tests/full_test | Bin 52440 -> 0 bytes tests/full_test.c | 912 -------------------------------------- tests/leak_check | Bin 33880 -> 0 bytes tests/leak_check.c | 108 ----- tests/memory_stress | Bin 33824 -> 0 bytes tests/memory_stress.c | 95 ---- tests/quick_test | Bin 33736 -> 0 bytes tests/quick_test.c | 69 --- tests/reliability_test | Bin 34064 -> 0 bytes tests/reliability_test.c | 264 ----------- tests/stress_erase_test.c | 156 ------- tests/stress_full_test | Bin 33936 -> 0 bytes tests/stress_full_test.c | 181 -------- tests/stress_test | Bin 34168 -> 0 bytes tests/stress_test.c | 191 -------- 31 files changed, 27 insertions(+), 3880 deletions(-) delete mode 100644 AGENTS.md delete mode 100755 main_test delete mode 100755 stress_erase_test delete mode 100755 tests/cpu_stress delete mode 100644 tests/cpu_stress.c delete mode 100755 tests/crash_9b_test delete mode 100644 tests/crash_9b_test.c delete mode 100755 tests/crash_memory_test delete mode 100644 tests/crash_memory_test.c delete mode 100755 tests/edge_case_test delete mode 100644 tests/edge_case_test.c delete mode 100755 tests/erase_clear_test delete mode 100644 tests/erase_clear_test.c delete mode 100755 tests/erase_stress_test delete mode 100644 tests/erase_stress_test.c delete mode 100755 tests/full_test delete mode 100644 tests/full_test.c delete mode 100755 tests/leak_check delete mode 100644 tests/leak_check.c delete mode 100755 tests/memory_stress delete mode 100644 tests/memory_stress.c delete mode 100755 tests/quick_test delete mode 100644 tests/quick_test.c delete mode 100755 tests/reliability_test delete mode 100644 tests/reliability_test.c delete mode 100644 tests/stress_erase_test.c delete mode 100755 tests/stress_full_test delete mode 100644 tests/stress_full_test.c delete mode 100755 tests/stress_test delete mode 100644 tests/stress_test.c diff --git a/AGENTS.md b/AGENTS.md deleted file mode 100644 index da65e01..0000000 --- a/AGENTS.md +++ /dev/null @@ -1,12 +0,0 @@ -# AI Agent Rules - -## AI Usage Policy (from src/main.c:46-55) -- Absolutely no AI is permitted when writing source code. -- AI is allowed to generate tests for code; however, test results and the AI cannot give code as to how to fix the source aside from pseudo code that has no clear relation to the source aside from a recreation of the problem in a different way entirely. -- Source code comments are for the author's short-term memory and do not affect AI behavior. - -## Project Code Conventions -- **Formatting**: Follow `.clang-format` (Google-based style, tabs (width 8), Allman braces, short functions/if/loops can be single-line) -- **Linting**: Follow `.clang-tidy` (bugprone, concurrency, misc, modernize, performance, readability, portability checks; `lower_case` naming for variables and functions) -- **Build**: C23 standard, CMake 3.16+ -- **Naming**: Variables and functions use `lower_case` (enforced by clang-tidy) diff --git a/main_test b/main_test deleted file mode 100755 index b2fb5836f0551e1bb70f1289cc41f329fb06493a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 34152 zcmeI5Yiv}<701urwehY^v7saoXle)2VpkC+1sX$*x?pHbKwuoJqKGoF*Vov=4{9%j zm&AfWf{?bjSPf09)-)+y8(LWjRqP~{joel!suWD3ko38vv|2+Vk>*3~v}XH1bLZOE z5BiGQPiLgropWa9%$eUgckcCv^?mKb_ij%mvIxb8IvsUq3ei!@L5t`f)M8YnN>)C+ zX3Lt=jjSD8^yIOs2@>0R3j>uZTeG=rY`2~t8ml8Cr$X&k9-&mk-V@=LQ^wotgzs#x zGwAfQ%=;QCDHI)PqoGt&WLHJgh-$pO$EG><3e5W0i%f)b@r^YInAmi?O~pH3yaREPq#1V}5N-MSkVp z+Dgb==AyD6C3{={`uL_VeCOp?pLzSi{M}nW3tbMXv!^*kDRXpN=Um_~DW5@~-XFfX zfNzxT$KY+HsQAcPzL1>3wGS6j%YZ-7G2o}6cp42M|4#-EEpH*KcSVjBT@eU| zhH`^6lt>E=#Voo2(=)jpNJX{i{h&oGg$u(Dtp+5aK_w9zkA%`R@AJlh{aLZafq7GvRZJnTxjT>v6y1 zYjPHKYdf=|-2>>)(|ZZtoab};d42%vRTKS`$EER}jcx#Q0#@(@)?en>2z3WiX?g-S z-%TcG@wjZW_W^KXc|1$+zT+7*bS;y*6B*!Z*1MD)ElnJxWx2dA^z4h<7c+hLxqa|` zAXEEv6JvBNj+rsY6FtA$XIL0p2{(=`d*S@j%e8BY?`|;|L+u(~>z#lgjNMpShp7%-5Jl7}Y@AZ=qlTkU; zorjoM7xNsQXOD>0`@Z4O>wb!U^PEMkyk;)PANpLxjcvrRChxDUSq%>FU)7%MGkH46 z9^c7uV&~n@Dv!TjJ??#+N64SShji{_+7Q>WpT6UHYxe5yEe@aDHLXQ&5b`yji(z4l{h^WNG%_(Q=M zo8J8yHtl8)x$uE~$GvhUbDF@WZ}jXy9EUhJ&NO8g==j5y&JEl{I0wTfH&~a;x}k%w z=LQMatQzEdgq{Pvg=@TrsMWonV1N27=lhg1cI^EP38C+6+OFl?yY$#5RnP(3kHGdh zeD8oik60NeigEt1zL@ul`&}{4j>+uuUdQBDpC9MsG@O(EmY%-st{7sLz&!wu3s>fX zb)3(iKT?1BlxXQo$ZeL}ntxl^=Ko${tobX0F@N@8tjOv=g#PEa5 z4Ej6V{^qyM{4Kga(QLI`ME|vH>ONz}#OL;|;58DT$NE?!G2d#j(xRo`HvQMKL*4P_ zpKCjbd@}~;Vhi_Ynz{2GeXM!gAnu1l$pz-TT7Yw6mJ`2`YumqVZ~*#1%|O8=qNU79 zUz3B&TQ(qWEXT~4bc}JX@$?SFapd}5ZN?=Qn6nM*{mFA}|3;S zc>f06d;IztX%Wt}EFYdFeA#d6_7qP$-P4}tY0q%llRgCEg68t6a1Nf67wKo&PeAse z-p?H<{LL~-3LY+f{5N1R1g?+qgER`ay@j8Lr&1c8e-S~H%P>&_BePSiyk?!`>D|chw z1-!@HS6Qhl%ELQoWrV)yr}K9~f9d1Uv+m3G_L_Ryh7~fP?hHa*YnM0DPPh}XX&3CI z^ZIP84X^t2)$NSzrLSA{m2}GT(-Afnn~jg>W)KAx%_*mK6%-EBzDm2+hK1vnjW?TD zH8#{o=&V&&j@8atde3UN9i~o)c4zP@YxM=|SJri_*Y}*YxiYt`@LhEAjx%`(UgphT zcNzJ*k@K{ig-@q{g_em5@dA1t|FDslAXF@`GxB-7WS-?sM!tlNv%J~JQT=vzgwDwP z4o&XgZsbDK-(X}i>+Lpjj!krL(K)` zn=j}1@cPq#s{|Q27oE#0VmC#oDDS(!c=qM=p5zPRtyN#Uwc??jyVHX|>^^Yv8_PG` zII?unj}M-IesjYw2da8guJ-ru@NL|jnmlmfz`mou{@ID*;}87kqxQd7{r95BTR(RD zZ?jsDuRVItlLap>?7evQt#^J>c=qCz^0h}ls{Ma8zpCb?z86Y1b-uRv=!=Wb #include #include @@ -68,6 +54,26 @@ create(const Vec8_t* input) return vec; } +Vec8_t* +shrink_to_fit(const Vec8_t* ptr) { + /* Create a new empty heap + * copy current ptr values + * realloc heap to current size + * + * */ +} + +char* +data(const Vec8_t* ptr) { + if(ptr == nullptr || ptr->arr == nullptr) return nullptr; + return &ptr->arr[0]; +} + +size_t +max_size(const Vec8_t* ptr) { + return ptr->capacity; +} + void delete(Vec8_t* vec) { @@ -114,17 +120,6 @@ at(const Vec8_t* vec, const int idx) return -1; } -// 1. Single erase (line 117-126): -// - size-- before memmove → wrong copy size -// - arr[iter] = 0 after memmove → zeros shifted element -// - Result: a b \0 e f g h i j (after erasing index 2 from a b c d e f g h i j) -// 2. Range erase (line 128-140): -// - Bounds check uses && (should be ||) -// - diff = iter_end - iter_start (off-by-one for inclusive range) -// - memmove uses iter_end not iter_end+1 -// - Zeroing loop zeros wrong positions -// - Result: a b \0 \0 g h i j (size=8, should be 7) - __attribute__((overloadable)) Vec8_t* erase(Vec8_t* vec, const size_t iter) { if(vec == nullptr) return nullptr; @@ -140,7 +135,7 @@ __attribute__((overloadable)) Vec8_t* erase(Vec8_t* vec, const size_t iter_start, const size_t iter_end) { if(vec == nullptr) return nullptr; if(vec->arr == nullptr) return nullptr; - if(iter_start < 0 || iter_end >= vec->size) return nullptr; + if(iter_start < 0 || iter_end > vec->size) return nullptr; if(iter_start >= iter_end) return nullptr; size_t diff = iter_end - iter_start; memmove(&vec->arr[iter_start], &vec->arr[iter_end], (vec->size - iter_end) * sizeof(char)); @@ -239,21 +234,11 @@ main() vec = add_back(&vec, '6'); size_t size = vec.size; - for (int i = 0; i < size; i++) { - if(vec.arr[i] == 0) printf("0"); - printf("%c ", vec.arr[i]); - } - printf("\n"); - // print_vec(&vec); - vec = *erase(&vec, begin(&vec) + 2); - // vec = *erase(&vec, begin(&vec) + 2, begin(&vec) + 4); - for (int i = 0; i < size; i++) { - if(vec.arr[i] == 0) printf("0"); - printf("%c ", vec.arr[i]); - } - printf("\n"); - // print_vec(&vec); - // printf("%c", at(nullptr, 0)); + print_vec(&vec); + // vec = *erase(&vec, begin(&vec) + 2); + vec = *erase(&vec, begin(&vec) + 2, begin(&vec) + 4); + print_vec(&vec); + printf("%p", data(&vec)); delete(&vec); return 0; diff --git a/stress_erase_test b/stress_erase_test deleted file mode 100755 index 1d8ba49cca5b26c8d4934e508324f654c315a1fe..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 34144 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 SbMDa-&os0h8+jcEmi`x32?n+R diff --git a/tests/cpu_stress b/tests/cpu_stress deleted file mode 100755 index 06a92d72da80746c255225f560275da7822ea5cc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 34072 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 -#include -#include -#include -#include - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -Vec8_t create(Vec8_t* input) { - Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = 4 }; - if(input == nullptr) { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (input->size > 0) { - vec.size = input->size + 1; - } - if (input->capacity >= vec.capacity) { - vec.capacity = 2 * input->capacity; - } - 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(Vec8_t* vec, 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; -} - -int begin(Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return 0; - return -1; -} - -int end(Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return (int)(vec->size - 1); - return -1; -} - -char front(Vec8_t* vec) { - return at(vec, 0); -} - -char back(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 ret = { .arr = nullptr, .capacity = 0, .size = 0 }; - if (vec->size < vec->capacity) { - vec->arr[vec->size] = val; - vec->size++; - return *vec; - } - if (vec->size >= vec->capacity) { - Vec8_t nvec = create(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; - } - free(vec->arr); - return nvec; - } - return ret; -} - -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() { - struct timespec start, end_t; - Vec8_t vec; - - printf("=== CPU Stress Tests ===\n\n"); - - // Test 1: Rapid fire inserts (tight loop) - printf("--- Test 1: Rapid Fire (100M tight loop) ---\n"); - vec = create(nullptr); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 100000000; i++) { - vec = add_back(&vec, (char)i); - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t1 = time_diff(start, end_t); - printf(" Time: %.3f sec\n", t1); - printf(" Rate: %.0f/sec\n", 100000000.0 / t1); - delete(&vec); - - // Test 2: Read-heavy (iteration + at()) - printf("\n--- Test 2: Read Every Element (100M at() calls) ---\n"); - vec = create(nullptr); - for (int i = 0; i < 100000000; i++) vec = add_back(&vec, (char)i); - long sum = 0; - clock_gettime(CLOCK_MONOTONIC, &start); - for (size_t i = 0; i < vec.size; i++) { - sum += at(&vec, (int)i); - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t2 = time_diff(start, end_t); - printf(" Time: %.3f sec\n", t2); - printf(" Sum: %ld\n", sum); - printf(" Rate: %.0f reads/sec\n", 100000000.0 / t2); - delete(&vec); - - // Test 3: Mixed operations - printf("\n--- Test 3: Mixed Operations (50M each) ---\n"); - vec = create(nullptr); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 50000000; i++) { - vec = add_back(&vec, (char)i); - char f = front(&vec); - char b = back(&vec); - at(&vec, i / 2); - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t3 = time_diff(start, end_t); - printf(" Time: %.3f sec\n", t3); - printf(" Rate: %.0f ops/sec\n", 50000000.0 * 3 / t3); - delete(&vec); - - // Test 4: Cache thrashing (random access) - printf("\n--- Test 4: Random Access (100M random at() calls) ---\n"); - vec = create(nullptr); - for (int i = 0; i < 100000000; i++) vec = add_back(&vec, (char)i); - srand(12345); - clock_gettime(CLOCK_MONOTONIC, &start); - sum = 0; - for (int i = 0; i < 100000000; i++) { - int idx = rand() % (int)vec.size; - sum += at(&vec, idx); - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t4 = time_diff(start, end_t); - printf(" Time: %.3f sec\n", t4); - printf(" Sum: %ld\n", sum); - printf(" Rate: %.0f random reads/sec\n", 100000000.0 / t4); - delete(&vec); - - // Test 5: Sequential scan (raw pointer access) - printf("\n--- Test 5: Sequential Scan (raw pointer, 500M bytes) ---\n"); - vec = create(nullptr); - for (int i = 0; i < 500000000; i++) vec = add_back(&vec, (char)(i % 256)); - sum = 0; - clock_gettime(CLOCK_MONOTONIC, &start); - char* ptr = vec.arr; - for (size_t i = 0; i < vec.size; i++) { - sum += ptr[i]; - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t5 = time_diff(start, end_t); - printf(" Time: %.3f sec\n", t5); - printf(" Throughput: %.1f GB/sec\n", (vec.size / 1e9) / t5); - printf(" Sum: %ld\n", sum); - delete(&vec); - - // Test 6: Create/delete cycles (memory allocation stress) - printf("\n--- Test 6: Create/Delete Cycles (1M vectors) ---\n"); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 1000000; i++) { - vec = create(nullptr); - for (int j = 0; j < 100; j++) vec = add_back(&vec, (char)j); - delete(&vec); - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t6 = time_diff(start, end_t); - printf(" Time: %.3f sec\n", t6); - printf(" Rate: %.0f create/delete cycles/sec\n", 1000000.0 / t6); - - printf("\n=== CPU Stress Complete ===\n"); - return 0; -} diff --git a/tests/crash_9b_test b/tests/crash_9b_test deleted file mode 100755 index fe8ae2a029820c6b3a5b28aa016c3b78e2ad25d7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33888 zcmeI5e{56N701uBo!}TKE(Ah>kr!H4+A&Bw{-9m6*>O^WN=RgTCF{^`9LGsq@@uiP z5zHDFR+M$xl&3{gg{l@!RX0ajl}<$)LR8t1rfr=x(N45lr7o<~){OR#Zj>fbjQ2h7 zy%5`!_K)_zog**fv{~?tp*pRt%`M3Dv=y)OI&X%jyJK)ipLCC*v^mVw&Q`JDN05AdJ{_t7RQ^l z<2Bpw_U}1JNit!a6NXF zS@HVqAZ!=Mu)EBH*Yzo=Qg!~YUj>@>hpg50S#b!ZDMcmEnU&Yd3stJKZ;9H?g)DeSrM;(!G43y(u#e;!hL4HX%X$h2+ohkO``acZBN2x zM$BeCblc-ZD^XS-BN|1y9NG-cm&F{hZ?gt}9tFqOF)!YlciA@cV)-1D z`=`L|l$9hm-&C$Ny`0IWv`jWY#($meal{;TU#c`no2qGbq-)$|zPT0lM5gD((`wK`}noAPI_H2wDHQ%-fUFfNS~`Q}Ze(iDO^fY2kBW4=$MoN8i zYrD4X=92RpL4Ik6HHQ(8HHU1f7WeRHt{ymV=9qJ87qTg5CVQTY1}z|GQ@Xd4rSo! zFaUj&9=P4Wdtq!nrC-Hv8GR(68*5M|wp1A#SEYk%Q9u3676bdO{E8yX6Jy+4423af zP8CHtMUhj;%87lZ1GNkEM&vQ~zyI~Brgc6;?#O1=X(wf;oomM%*~htVya8opCB5HT zLg53c!?Wv`kui(=O*_|&*P(B5Ex(NVRdC;ge9NJ^QhI;x#Iq+Wu-16a%DL~&M|bTW zD<$J;#Q3Un(`Da$F8r*c;&LFD3x7C2{2JfylCxqQ&-z&UTJH2k=z`Yn0&)p_-GdG!re9kFi|m(}!+`C`B`d8cKcI$=GOzS>o0 zL;5FASsj-?u-*`VJc%VB^3>GS=;8WMSl`-yzrOXzpdRav^~8FU2^~Ei3IzS3hWa`^ zk}T+~@=)k&fk1sIR5)n69*y)zqVePqyL+fH*3&mI1fL!EcIb_@9(pj|8|l`2ikmr$ z=3vvFAR_L4xZcd@e*K<@^e=uzzo*(R?6T2nw2Nx1thLfLr{mwZ&kPXKoBg2>l1Fr& zD-*%`nUY`fdy#){_)xO)Zv_^gd0o0N;uYjV3=8@QLN4I7`hZ4G#CD;dJ6zaD_Npw6 zm6{L`0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf5D)@FKnMr{As_^VfDjM@LO=)z0U;m+ zgn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf5D)@FKnVOl5%8w1ul&6DG?m4hwmt*& zrmYXqylLxWKX2Op#yV}f$wdeV0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf z5D)@FKnMr{As_^VfDjM@LO=)z0U;m+gn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf z5D)@FKnMr{As_^VfDri12vh!94btkdLr>&s=|4`Wi8c7pLM%c znwRfv@>z#+6+rDaPeCWrZJW>kWqvp_+U&>K-lkn`+Y`23YukLzI{V|iYc9EJ3a}N} z4;R^;MK;dtF7O{LvWJUo{vQWkYn(4l9w?tz&u6?Zw!2X;?n4vlq&@;kzG03co&`^2NuI&?vxJnw?J7itz%QV!lZE@ax}G+PvJ~r{U zmER7}?;L&6)A%EG>zl8{Q!DN~{hLo4|C7eoE&qn&Pv^e--iI$9TY0wZ_g!bo|MJ#P TN1K0qaev1*&whP$)`IpwD}e;& diff --git a/tests/crash_9b_test.c b/tests/crash_9b_test.c deleted file mode 100644 index 943eab4..0000000 --- a/tests/crash_9b_test.c +++ /dev/null @@ -1,107 +0,0 @@ -#include -#include -#include -#include - -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 = NULL, .size = 0, .capacity = CAPACITY }; - if (input == NULL) - { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (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 != NULL) - { - free(vec->arr); - vec->arr = NULL; - } - vec->size = 0; - vec->capacity = 0; -} - -Vec8_t -add_back(Vec8_t* vec, const char val) -{ - if (vec->size >= vec->capacity) - { - vec->capacity = 2 * vec->capacity; - char* new_arr = - reallocf(vec->arr, vec->capacity * sizeof(char)); - if (new_arr == NULL) - { - return *vec; - } - vec->arr = new_arr; - } - vec->arr[vec->size] = val; - vec->size++; - return *vec; -} - -vm_size_t -get_physical_mem() -{ - struct task_basic_info info; - mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT; - task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, - &count); - return info.resident_size; -} - -int -main() -{ - printf("=== PROGRESSIVE TEST: 1K -> 10K -> 100K -> 1M -> 10M -> 100M -> 1B ===\n\n"); - - size_t targets[] = {1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000}; - int num_tests = 7; - - for (int t = 0; t < num_tests; t++) { - size_t target = targets[t]; - printf("\n=== TEST %d: %zu elements ===\n", t+1, target); - - Vec8_t vec = create(NULL); - size_t start_cap = vec.capacity; - - for (size_t i = 0; i < target; i++) { - vec = add_back(&vec, 'x'); - - if (vec.arr == NULL) { - printf("CRASHED at %zu elements!\n", i); - return 1; - } - } - - printf("SUCCESS: %zu elements, capacity %zu\n", vec.size, vec.capacity); - printf("Memory: %.2f MB\n", get_physical_mem() / 1024.0 / 1024.0); - - delete(&vec); - } - - printf("\n=== ALL TESTS PASSED ===\n"); - printf("Final memory: %.2f MB\n", get_physical_mem() / 1024.0 / 1024.0); - - return 0; -} \ No newline at end of file diff --git a/tests/crash_memory_test b/tests/crash_memory_test deleted file mode 100755 index 63332b9a9c44a1fc1e64a70496c0c7aecf74a4ec..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33888 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 diff --git a/tests/crash_memory_test.c b/tests/crash_memory_test.c deleted file mode 100644 index 9718b06..0000000 --- a/tests/crash_memory_test.c +++ /dev/null @@ -1,198 +0,0 @@ -#include -#include -#include -#include -#include - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -Vec8_t create(const Vec8_t* input) { - Vec8_t vec = { .arr = NULL, .size = 0, .capacity = 4 }; - if (input == NULL) { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (input->size > 0) { - vec.size = input->size + 1; - } - if (input->capacity >= vec.capacity) { - vec.capacity = 2 * input->capacity; - } - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; -} - -void delete(Vec8_t* vec) { - if (vec->arr != NULL) { - free(vec->arr); - } - vec->arr = NULL; -} - -Vec8_t add_back(Vec8_t* vec, const char val) { - if (vec->size < vec->capacity) { - vec->arr[vec->size] = val; - vec->size++; - return *vec; - } - if (vec->size >= vec->capacity) { - Vec8_t nvec = create(vec); - if (nvec.arr == NULL) { - 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; - } - free(vec->arr); - return nvec; - } - Vec8_t ret = { .arr = NULL, .capacity = 0, .size = 0 }; - return ret; -} - -void print_rusage(const char* label) { - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - printf("%s: %.2f MB maxRSS\n", label, ru.ru_maxrss / 1024.0); -} - -void force_rusage_reset() { - struct rusage start; - getrusage(RUSAGE_SELF, &start); -} - -int main() { - printf("=== MEMORY CRASH + LEAK TEST ===\n\n"); - - printf("Initial memory:\n"); - print_rusage("before"); - - printf("\n=== TEST 1: PUSH UNTIL CRASH ===\n\n"); - - Vec8_t vec = create(NULL); - size_t crashed_at = 0; - - for (size_t i = 0; ; i++) { - vec = add_back(&vec, (char)(i % 256)); - - if (vec.arr == NULL) { - crashed_at = i; - break; - } - - if (i % 50000000 == 0 && i > 0) { - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - printf(" %zu elements: %.2f MB used\n", i, ru.ru_maxrss / 1024.0); - } - - if (i >= 4000000000UL) { - crashed_at = i; - printf(" STOPPED at 4 billion\n"); - break; - } - } - - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - - if (crashed_at > 0) { - printf("\nCRASHED at %zu elements\n", crashed_at); - } else { - printf("\nStopped at %zu elements\n", vec.size); - printf("capacity: %zu\n", vec.capacity); - } - - printf("memory used: %.2f MB\n", ru.ru_maxrss / 1024.0); - - delete(&vec); - - printf("\nAfter delete:\n"); - print_rusage("after delete"); - - printf("\n=== TEST 2: MULTIPLE VECTORS (LEAK CHECK) ===\n\n"); - - size_t num_vectors = 10000; - Vec8_t* vectors = calloc(num_vectors, sizeof(Vec8_t)); - - printf("Creating %zu vectors...\n", num_vectors); - print_rusage("before vectors"); - - for (size_t i = 0; i < num_vectors; i++) { - vectors[i] = create(NULL); - for (size_t j = 0; j < 10000; j++) { - vectors[i] = add_back(&vectors[i], (char)(j % 256)); - } - } - - print_rusage("with vectors"); - printf("Each vector has %zu elements\n", vectors[0].size); - - printf("\nFreeing vectors...\n"); - for (size_t i = 0; i < num_vectors; i++) { - delete(&vectors[i]); - } - free(vectors); - - print_rusage("after free"); - - printf("\n=== TEST 3: CREATE/DELETE CYCLES ===\n\n"); - - size_t cycles = 100000; - printf("Running %zu create/delete cycles...\n", cycles); - print_rusage("before cycles"); - - for (size_t c = 0; c < cycles; c++) { - Vec8_t v = create(NULL); - for (size_t i = 0; i < 1000; i++) { - v = add_back(&v, 'x'); - } - delete(&v); - - if (c % 10000 == 0) { - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - printf(" cycle %zu: %.2f MB\n", c, ru.ru_maxrss / 1024.0); - } - } - - print_rusage("after cycles"); - - printf("\n=== TEST 4: REALLOC STRESS ===\n\n"); - - Vec8_t big = create(NULL); - printf("Single vec realloc stress...\n"); - - size_t prev_cap = 0; - for (size_t i = 0; i < 100000000; i++) { - big = add_back(&big, 'x'); - - if (big.capacity != prev_cap) { - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - printf(" cap %zu -> %.2f MB\n", big.capacity, ru.ru_maxrss / 1024.0); - prev_cap = big.capacity; - } - } - - print_rusage("final big vec"); - printf("size: %zu, capacity: %zu\n", big.size, big.capacity); - - delete(&big); - - printf("\nAfter cleanup:\n"); - print_rusage("cleanup done"); - - printf("\n=== RESULT ===\n"); - - struct rusage final; - getrusage(RUSAGE_SELF, &final); - printf("Peak memory: %.2f MB\n", final.ru_maxrss / 1024.0); - - return 0; -} \ No newline at end of file diff --git a/tests/edge_case_test b/tests/edge_case_test deleted file mode 100755 index 90f5b08254b0f7935692824eb27163f8a3a0131b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 34112 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 FzX9y* -#include -#include -#include -#include - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -Vec8_t create(const Vec8_t* input) { - Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = 4 }; - if (input == nullptr) { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (input->size > 0) { - vec.size = input->size + 1; - } - if (input->capacity >= vec.capacity) { - vec.capacity = 2 * input->capacity; - } - 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; -} - -int begin(const Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return 0; - return -1; -} - -int end(const Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return (int)(vec->size - 1); - return -1; -} - -char front(const Vec8_t* vec) { - return at(vec, 0); -} - -char back(const Vec8_t* vec) { - if (vec) return at(vec, (int)vec->size - 1); - return -1; -} - -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; - vec->size++; - return *vec; - } - 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; - } - free(vec->arr); - return nvec; - } - return ret; -} - -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++; - } -} - -int main() { - printf("=== EDGE CASE BRUTAL TESTS ===\n\n"); - - Vec8_t vec; - char* ptr; - - printf("--- Reallocation Behavior ---\n"); - vec = create(nullptr); - for (int i = 0; i < 10; i++) vec = add_back(&vec, (char)('A' + i)); - ptr = vec.arr; - for (int i = 0; i < 100; i++) vec = add_back(&vec, (char)('0' + (i % 10))); - 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); - - printf("\n--- Stack-Allocated Struct ---\n"); - vec.arr = nullptr; - vec.size = 0; - vec.capacity = 0; - test("stack vec: add_back modifies nothing (capacity 0)", 1); - - printf("\n--- Integer Overflow ---\n"); - size_t doubled = 2 * (size_t)-1; - test("2 * SIZE_MAX overflows (demonstrates overflow)", 1); - - printf("\n--- Signed/Unsigned Mixing ---\n"); - vec = create(nullptr); - vec = add_back(&vec, 'X'); - test("at() with negative -1 returns error", at(&vec, -1) == -4); - test("at() with INT_MIN returns error", at(&vec, -2147483648) == -4); - delete(&vec); - - printf("\n--- Huge Size Values ---\n"); - 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); - - printf("\n--- Uninitialized Struct ---\n"); - Vec8_t uninit; - printf(" Calling at() on uninitialized struct...\n"); - printf(" This is undefined behavior - results unpredictable!\n"); - test("uninitialized: expect garbage or crash (UB)", 1); - - printf("\n--- Capacity Mismatch ---\n"); - vec = create(nullptr); - 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); - delete(&vec); - - printf("\n--- Memcpy Edge Cases ---\n"); - vec = create(nullptr); - 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); - - printf("\n--- Ignored Return Values ---\n"); - vec = create(nullptr); - add_back(&vec, 'X'); - test("add_back modifies in-place when capacity available", vec.size == 1); - test("data stored correctly", vec.arr[0] == 'X'); - for (int i = 0; i < 3; i++) vec = add_back(&vec, (char)('A' + i)); - char* old_ptr = vec.arr; - vec = add_back(&vec, 'Z'); - test("reallocation triggered", old_ptr != vec.arr); - test("realloc: data preserved in new vec", vec.arr[4] == 'Z'); - - 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); - - printf("\n--- Double Free ---\n"); - vec = create(nullptr); - vec = add_back(&vec, 'X'); - delete(&vec); - delete(&vec); - test("double delete: no crash", 1); - - 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); - - printf("\n--- Use After Delete ---\n"); - vec = create(nullptr); - for (int i = 0; i < 10; i++) vec = add_back(&vec, (char)i); - delete(&vec); - 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); - - printf("\n--- Size/Capacity Edge ---\n"); - vec.arr = malloc(100); - vec.size = 0; - vec.capacity = 100; - 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); - - printf("\n--- const Correctness ---\n"); - vec = create(nullptr); - 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); - - printf("\n=== Summary ===\n"); - printf("Passed: %d\n", tests_passed); - printf("Failed: %d\n", tests_failed); - - return tests_failed > 0 ? 1 : 0; -} diff --git a/tests/erase_clear_test b/tests/erase_clear_test deleted file mode 100755 index d267cfdd34b1aeec6a1d1c0fb4657c61eebffee7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 35792 zcmeHQdwf*Yoj-SGB9j0mybL0ci-4KPBSA$WCNd#JLBpdVwiK|J$;>2-Br{}1ZYYQ6MMQgW!)^~RkAKQuO`dC{Nmze$j&N+8-XOdXm z?PveG!{^T2bAIRi&hPjAz0OU-ncsi-)<+W==eyJUm~2B7W?VEv)1v-8QMwbaOnz%H znD}j*Bk0s7y;3g+i>K~!qiK<7tTvMB%H;RJJi*Tpnc8N4PRS1#@|UK0L&3v+v)ar ztw`{T(_p-)oykK`#5>vb5H3wyU0zeJRcu(lNkHWmd>B6YE8~-Nri*Nqi%Zk$L&K#D_5^I9P4<7TyZh}l(Z}HG4r~du{hyI-rR|g%VfI~?OZ59GLVls z_cOK#pX}?56{DZnZKSs8wE*{Ynej7``R&QCG4`3vPPC~{#YOrT#UkONhCpqRZ*PMS zZF*gZi{v=d+GCsjvlX`<`nm1#g0_`8m!eO_C3Kp}m}4ftC;XZ7J;x>Z;QCP;FBkM9 zK6@_W&D0yMyBrtM1nyNl1EgeuJe&4LqW;DutCm2nK&_a1F+Pa@$ri@k_$-ud!i!$B zaS^@v4#wKdz!Pzl*H8;PJ=mW2cuGfF%)+Ixce52%Lw$XAHy^|MvzYG6Vgr0E`Wbl4W$`m#8pm3b z)K=KQU~_ppWYCY>wP($;kPMu^;vP83hSy_gM=;-5KYtV+NzCn;g!z*ovqR3sJ?TKQ z-fkDN4&|{f&L=P4)dzYZ*CqSxMK(dF`A)32gR!5{IQZE#qpuHhoJ#hcSbv4!;qG!~ zvB^pBd~;|hkH+Oo-TQzOwKK6a>)kV+4fIZ8UCHslSFU$5KVF@@jjeFey67ia3|d0c z<{C7}-ZzQMbQWW{Ee^;r@G(ArhfQK3c_j@yQrk4YP}#rbr9K=uZCf$2( zJH8^NOE>wGt$h$SHS2Uh>U69nzaMd((#PBn-v++01>`Yo0XOHm&^(mJ)I38b!rv?> zgH49p?yf@EM0u=G^qF*ot=_c_x}UbQ_}$N*$69Gk7ug^EF4&EDB(Nsw*Vdx-4>qrA zAL^EVYSJ-jX9H~*cYh>*c>?1I$98-ca$n0n>y^GneJ<)7xb10IHUn?1pM06mLB9f7 zegioSzjrCZ=O~`U*z`EeBP`%ooG)U4R%&t z)Ym}A(fAUdG+is$=^p5qgdC)s6YtrG~AwPYUou2EAS8o{-ZIZ36 z<>k^g`}a!|EjPmNVCxFybUDU+);z}kk{Dy(#>XVRitfRfHKs8=Ex+btl2^+7Z&&m$ zW6VnPn5oChXszTzIpzq{@5h)cFoyD8Ps`(+M_)d4hAiBVrn7f@^A4kc!md@5^_b*W z4vgN0UOdl|zfCrcJ33k4iE#=07yGl7<13sPTbQNnO3q_lkI9_PX<3q%Eoi+mpK)5Y zq)iqy#YA&X1Z_I{As6u^pG?k!uPAIvvVe8<7Pz~(yy_HvEy+RlfqxKRC-DW(lujq7 z=x)*pzH%M(8EmdE|G-rJM3%HIe2#28lWdEaOTNluM7_BHy6J0P)fd$ z`jvxz#GsF&p9l2s8T1VO$e*@?ma>t;hHcb3U4PD?k?!!Nl>OeHuAee!q&s{mMcZ+{ z{)AlbY3PxrJK}7x*@5_#wte}0eI0ZsJ5jA5+a57=hi&HO#H$-5uO7(WGd^BMzMs61 za(cXa5onYvoFt!F_HB83LeBdsmti&hOOg91k|7H@N6K&_PhVu<4}T>YzCtp;a5XUmm1+?U+Zkemj@bgkv}1cpmmL9LElJaHjqu z=JL3gwk*aR9;ZhHjsvo7@)|d6; zN!d2n4lcW0;j%w2={=@=&*{*eV(^~~y3F@x-DiT9$}z)!+`&%H(*I)6D9+5ZX|wgW z4I1TFGj029Jqa55WIN?w)MDv-z-6}H3mWi-8xxS{wX9w$_t@{ZV@+XPQKVuG$ z4cP2W+#^SKu%rQ%vLakjB$< z4(7iL-o4{^P3&OFe0@LUA=&QY7?^x9J>EOmc2#!*gEnAJ{!VdA`}+j&Fk*#xaNM6! zIqr?%&0`pGM=|`ST|7hb7>1pV7(Rwr3i9<$HmIOja3Uwu9t^gunoGI3_3yd7`TfVR zFXgylFPgpUE7kC&olj>m){bNYo{Fpt}1R_EKmZm3Awpa_^g!FF9IZ9se|2R;lw9CM-*<{1BH z%p>|TNu&KU=LsE7f#xHhKwhMpLC*#h7kzTSZthDWpVM<3_E2Z&p09&gqWz}Kjk-&r zS^>OXo~z$Wcq3;z3*q+#JpXsFdoR+*VZFiTHK;wZ_P1o@osIMKZ({D%AA|KBj&!VF z`tQGjHS&>x^?igj&qu&|;n-Lwj|lrv9s2lRAe^oHn z7{mP)bKVD!V|*<(@CNo2hHsgk>pIwki**O|evj2g%Ngz~cqo7-tzKH{ZC;7Y!=9qYFk`l9xauCGf! z37JJ~xwyU*&*YOUxxVIjqUXVh*vr{P?z+5C@50=hFrJ>N&AH22p1&(6J3W@191m08 znrk=Jmu(~J3q2V12Uc5SvIX%b|U!D-J{*t^; z9#Qm}xF4#QK2(oVDmccedV)XMTY;@EYvGa{(CRvHtz?r=eJh(eUjKV`R``J;1l@oal~vdFq?(- zhw`Ou@)6&re3BXCHWN{ zL2DN4b>L62+XU>=YEdTEFE7^NbE!O9{x`sS5IjB&){kNRv9P|$sQ=J~_WDW|+jSKD zGx2`Ug!jXQO9tK>#=^UGiT)tQe-gagh%e!N(3g(4t4Pn0cu&j3yPJGF2hU4#pVe8U z-vvHK-Fkf>!?#U-_HlJ9VMk5^CRDfX$C_<+`LiwijmSx(*Ddl##Ccb5g`)c)1F!$! zL3!!}$kBsm#$LqCjie{`4ZX-Uub>XTTHqcS;x>i9PR;Pw)y4W28jpS@H<*sg$zuHk z%|q_{SMVQfz7Ee~a!-_ri+icQ#)Qk^Ok6%;%`)S%^?!lOoD5ukV!|bF6kNK-!sWzL z9S;WrmxK8Er#U{|m+H4lTn>!D#c}#vXma~t^Az}uL#Nu4L_OuXq2p40h{1Qd#h#~U z9virUuO<1sUW_sM$w5}LOn)Ep&|c!BeyoeS zaSoq@&DHJaLZ3w}Irz`E2AhxJISw@hzbjzRFVk-ZKYstr6*~SJLfjv{Qg1Tuo0jX1 z#(m8S{U+nyQKHuy_m7n5KI1-qmF_X_eWiSFCgS(1}wGMp&Y ztBtwQG97<%BIH?gwO)n$Y~cB2T%EZ7g6n+b(K1|Azglsl| z_AE(z&V%x~?jY;GTF39)T9bHYq4B0Y%|SMQrJheT_>U9w(`Yp-b^K0||IQ4*r|BgA zh4|SF`@`Xx=HI2@_cEt)ZSDbP%YT;NpJ%$yG2MU0bU(#(f4=E{rnrZ$=`U>3=(TlY z`KC=bs`D23O4J3B9JckE^0if_cFy9(i`B~N@=cW`>MBnp;8iO^;jrHu4f-Py6~r9o z4|^hhHR6xPno87Vs=vYC=nqCCqQ69q1ort=pWhqi-F}}M4XKwKL}RcT*%7FVg6I|8 z8}_Q@>MC`$TA49Y^+eTxZ;yJZ8Vv1LcZ3>z5j7MJ)CYo|22Qw4brq~GC}d{A*9Lw5 zJ!-M)`g|xHiK-Qlx6mv*F)S`oJ>l@y;u|^Rf-e+Ey-c*FlD4HFjeC^`JS&CPX08qB z7fdg`Q4K`YV##s1AB)9;-W{G`z27&2h}DLPW^Fd%uY(%=qpcX>l$0WTP4moZ*eD!S zKj&$P`OT7sd4B|&2Nwrp4GmHjqdVeh^s7ywKrreLr)j?ahN>!clc&xf-D_g!A{I^2 z@FKOiP&IhSKFN7^Ai6`PF2a1o7_-Q$La`uB{JB7=!4nOHf~IxUP%OGQRJXX64=EYJ zM)+mMAnuJBxK>nEmRFDI-rfekC!CI{sS8%(Fq^szYs)SJft&qa0iIm0vat!UeGZ`% z3Jb0H1l3RdC9s9+MPThi%}i$BGK9-mGCVF`f)8RGgB($Wwr#78ITjocMP3r%=OYMEMpT`24? z6Id(~V98bvYv6|Fv&XW5kU#+8TDorJ`hoZ#l{;9_Zv?0stbSnNV(sH{V@1cOJr$)9U?pM zcb7X!d^o1G$bu!8)uFU`bC{}Dd!l|6$tA^g(s)Ijz)hj<=9R?@o0g!4H8wT)qfok3 zy{wp~%kUbOa1})c)gjeI<-jn}SW@yas6@29A&^+NmKcp(76FpJtTZ_(CQDVyBqoxP z6KI_)q~fq10*ah8U9+X5udr?`{=pTiLZMKTnh~8Ps!3~AE`{Vy7T=@R!A!_mQB-SGnkGM-!6*D6 zN2chpM+oz;y5U;2e0_P<7dEZkRHBw6$8HS!Zw`cF5$twW!(Y6_a#gH8qOQl@=9<7B zG-dXz2nC~_KoA1(ER3q@*=v;KMR2%SFp5MG#Qw?CNe_fPMSVzNa_mb;2#^6{UFK4X+ZPbjg-{af67|{w@p}XAYmC#D6 zoK>c}#Eix2T6M9yv{1do7^qS0qOlbut>9mqzB3eM0dj?I_B3#T(#Ikh`ymuB9#pkR zc5^A?Q^aPEix2i-6!39ddFr7p1q)wZzMLiAhXI~E6=!r!9v}wov zHJ(6&agRMco`2aaTsBIE08{-%KjXS-lZGPeJ)9`n`*{oR3 zJO$Pp!9;a1+crEu#305^Dv|MxHMaaMWi#qZrX4Zxl1 z;`0<7AfTwYigB&SwFOrbt~jGFPuFmCFP%ZDd3Wq&niq#PhP?R1`%bOiAB_eY{YGNr|9`8;zG0LXc z*`W#OKbeDmI<=H70EeibU1Dd?j0Yh(1#gEYfl6mAvkE#@l&!I|#B}ucuci@8@z!<` z-deB1+tD(NEiT^4LX9kHXPxuWmso(eLko#oz}R`UbSOH$G(L4GI=ji+6w{Wnz5F0& z4M*(afM?dC@Pm7e<^e^VX{?D8hS@h2It^Qk@Uyhp-HM$(PcprxV*L>dyshxlk~N$i zDh|bF?_f{LpE_PwuS>bV}7>ZF3v7b&A#0ZixgqCmls1Beq^f_3~Ay>?Dy>a@Y~^z z59|(h0B2cXP6cdYIzm_zBLxF-oG|l?7WkNL1#$miE^ zFsNo649b4saIpPY$id=xXSO>)=)WA~u-{4@-MEm(UN zoL$3tpLOgPSu{N7m9ukFCWs{Sy`_OLuJD-s8+va9`U9b$qaNNcQRTj>Z< zwmr%ocilI?N-^Ik8@F}{Uh1##5Xrn`w7{8bb@I2$o9R+X+)WnTn9PJFOg<38Sello(6(v|?pul~J|?NnkE?P8BUPNiJs8 zGeM%#Bksm5Kb#!VWYv)^S$Z_uOo{sPH{5r9_-_-ABU0}}SQ)WB4Sf{Nw=jb=CAyE)eoK82Z7#; zH|M?m;XBh~v;NTf$D_V~iQRt9mT1Y`D}LA4y6c-ix_j5cqOX<(&(wT(UBNxJrGL2E zxBvct`}M=V3DZ9t`Hx*wpV-?s|BhSS_FIqs`^1}TJ}f%;lbm&TX_H_2ZJ>EV!OtFh z__m`z-5mN&U)^!XbEi-5v~Ad&HFV1(x9t1si@&^c&FzbR_Z`}5!WartvU*jK}A-2VWX)7!)V diff --git a/tests/erase_clear_test.c b/tests/erase_clear_test.c deleted file mode 100644 index ce2b5e8..0000000 --- a/tests/erase_clear_test.c +++ /dev/null @@ -1,705 +0,0 @@ -#include -#include -#include -#include -#include - -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; -} - -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; - } - vec->size = 0; - } - return *vec; -} - -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* -erase(Vec8_t* vec, const int iter) -{ - if (vec == nullptr) - return nullptr; - if (vec->arr == nullptr) - return nullptr; - if (iter >= vec->size) - return nullptr; - vec->arr[iter] = 0; - memmove(&vec->arr[iter], &vec->arr[iter + 1], (vec->size - iter - 1) * sizeof(char)); - vec->size--; - return vec; -} - -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; -} - -int -empty(const Vec8_t* vec) -{ - if (vec->size > 0) - { - return 1; - } - return 0; -} - -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; -} - -size_t -get_mem_mb(void) -{ - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - return (size_t)(ru.ru_maxrss / 1024); -} - -void -test_erase_basic_correctness(void) -{ - printf("\n--- ERASE: Basic Correctness ---\n"); - - Vec8_t 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: size decremented to 4", vec.size == 4); - - int elements_intact = (vec.arr[0] == 'A') && (vec.arr[1] == 'B') - && (vec.arr[2] == 'D') && (vec.arr[3] == 'E'); - test("erase: elements shifted correctly A B D E", elements_intact); - - test("erase: element at idx 2 now holds original idx 3 ('D')", vec.arr[2] == 'D'); - - delete(&vec); -} - -void -test_erase_index_zero(void) -{ - printf("\n--- ERASE: Index 0 (Worst Case) ---\n"); - - Vec8_t vec = create(nullptr); - vec = add_back(&vec, 'X'); - vec = add_back(&vec, 'Y'); - vec = add_back(&vec, 'Z'); - - erase(&vec, 0); - - test("erase idx 0: arr[0] now 'Y'", vec.arr[0] == 'Y'); - test("erase idx 0: arr[1] now 'Z'", vec.arr[1] == 'Z'); - - delete(&vec); -} - -void -test_erase_last_element(void) -{ - printf("\n--- ERASE: Last Element ---\n"); - - Vec8_t vec = create(nullptr); - vec = add_back(&vec, 'A'); - vec = add_back(&vec, 'B'); - vec = add_back(&vec, 'C'); - - erase(&vec, 2); - - test("erase last: arr[2] is 0", vec.arr[2] == 0); - test("erase last: arr[0] unchanged", vec.arr[0] == 'A'); - test("erase last: arr[1] unchanged", vec.arr[1] == 'B'); - - delete(&vec); -} - -void -test_erase_single_element(void) -{ - printf("\n--- ERASE: Single Element ---\n"); - - Vec8_t vec = create(nullptr); - vec = add_back(&vec, 'Q'); - - erase(&vec, 0); - - test("erase single: arr[0] is 0", vec.arr[0] == 0); - - delete(&vec); -} - -void -test_erase_return_value(void) -{ - printf("\n--- ERASE: Return Value ---\n"); - - Vec8_t vec = create(nullptr); - vec = add_back(&vec, 'A'); - - Vec8_t* result = erase(&vec, 0); - test("erase returns non-null", result != nullptr); - test("erase returns same pointer", result == &vec); - - delete(&vec); -} - -void -test_erase_null_safety(void) -{ - printf("\n--- ERASE: NULL Safety ---\n"); - - test("erase(nullptr, 0) returns nullptr", erase(nullptr, 0) == nullptr); - - Vec8_t 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); -} - -void -test_erase_bounds_violation(void) -{ - printf("\n--- ERASE: Bounds Violation ---\n"); - - Vec8_t vec = create(nullptr); - vec = add_back(&vec, 'A'); - vec = add_back(&vec, 'B'); - - Vec8_t* result = erase(&vec, 10); - - test("erase out-of-bounds: returns nullptr", result == nullptr); - test("erase out-of-bounds: size unchanged", vec.size == 2); - - delete(&vec); -} - -void -test_clear_basic_correctness(void) -{ - printf("\n--- CLEAR: Basic Correctness ---\n"); - - Vec8_t 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: 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: returns vec", cleared.arr == vec.arr); - - delete(&vec); -} - -void -test_clear_empty_vector(void) -{ - printf("\n--- CLEAR: Empty Vector ---\n"); - - Vec8_t vec = create(nullptr); - - clear(&vec); - - test("clear empty: no crash", 1); - test("clear empty: size still 0", vec.size == 0); - - delete(&vec); -} - -void -test_clear_large_vector(void) -{ - printf("\n--- CLEAR: Large Vector (1000 elements) ---\n"); - - Vec8_t vec = create(nullptr); - for (int i = 0; i < 1000; i++) - { - vec = add_back(&vec, (char)(i % 256)); - } - - 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: all elements zero", all_zero); - - delete(&vec); -} - -void -test_clear_null_safety(void) -{ - printf("\n--- CLEAR: Null Safety ---\n"); - - Vec8_t vec; - vec.arr = nullptr; - vec.capacity = 0; - vec.size = 5; - - clear(&vec); - - test("clear with null arr: no crash", 1); - - vec.arr = calloc(4, sizeof(char)); - vec.capacity = 4; - vec.size = 0; - delete(&vec); -} - -void -test_erase_memory_stress(void) -{ - printf("\n--- MEMORY: Erase Stress Test ---\n"); - - size_t mem_before = get_mem_mb(); - - for (int round = 0; round < 5000; round++) - { - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100; i++) - vec = add_back(&vec, (char)i); - - for (int i = 0; i < 50; i++) - erase(&vec, 0); - - delete(&vec); - } - - size_t mem_after = get_mem_mb(); - size_t mem_delta = mem_after > mem_before ? mem_after - mem_before : 0; - - printf(" Memory delta after 5000 erase rounds: %zu MB\n", mem_delta); - test("erase stress: memory stable (< 10 MB growth)", mem_delta < 10); -} - -void -test_clear_memory_stress(void) -{ - printf("\n--- MEMORY: Clear Stress Test ---\n"); - - size_t mem_before = get_mem_mb(); - - for (int round = 0; round < 5000; round++) - { - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100; i++) - vec = add_back(&vec, (char)i); - - clear(&vec); - delete(&vec); - } - - size_t mem_after = get_mem_mb(); - size_t mem_delta = mem_after > mem_before ? mem_after - mem_before : 0; - - printf(" Memory delta after 5000 clear rounds: %zu MB\n", mem_delta); - test("clear stress: memory stable (< 10 MB growth)", mem_delta < 10); -} - -void -test_large_erase_no_crash(void) -{ - printf("\n--- MEMORY: Large Erase (100K elements) ---\n"); - - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100000; i++) - { - vec = add_back(&vec, (char)(i % 256)); - } - - size_t mem_before = get_mem_mb(); - - for (int i = 0; i < 10000; i++) - { - erase(&vec, 0); - } - - size_t mem_after = get_mem_mb(); - - printf(" 10K erases on 100K vec: memory before=%zu MB, after=%zu MB\n", - mem_before, mem_after); - - test("large erase: no crash", 1); - - delete(&vec); -} - -void -test_large_clear_no_crash(void) -{ - printf("\n--- MEMORY: Large Clear (1M elements) ---\n"); - - Vec8_t vec = create(nullptr); - for (int i = 0; i < 1000000; i++) - { - vec = add_back(&vec, (char)(i % 256)); - } - - size_t mem_before = get_mem_mb(); - - clear(&vec); - - size_t mem_after = get_mem_mb(); - - printf(" Clear 1M vec: memory before=%zu MB, after=%zu MB\n", mem_before, - mem_after); - - test("large clear: no crash", 1); - - delete(&vec); -} - -void -test_alternating_erase_clear_cycles(void) -{ - printf("\n--- MEMORY: Alternating Erase/Clear Cycles ---\n"); - - size_t mem_before = get_mem_mb(); - - for (int cycle = 0; cycle < 2000; cycle++) - { - Vec8_t vec = create(nullptr); - for (int i = 0; i < 200; i++) - vec = add_back(&vec, (char)(i % 256)); - - erase(&vec, 50); - erase(&vec, 100); - clear(&vec); - - for (int i = 0; i < 100; i++) - vec = add_back(&vec, 'X'); - - erase(&vec, 0); - clear(&vec); - - delete(&vec); - } - - size_t mem_after = get_mem_mb(); - size_t mem_delta = mem_after > mem_before ? mem_after - mem_before : 0; - - printf(" 2000 cycles: memory delta=%zu MB\n", mem_delta); - test("alternating cycles: memory stable (< 10 MB growth)", - mem_delta < 10); -} - -void -test_erase_cpu_worst_case(void) -{ - printf("\n--- CPU: Erase Worst Case (index 0) ---\n"); - - Vec8_t vec = create(nullptr); - for (int i = 0; i < 500000; i++) - { - vec = add_back(&vec, (char)(i % 256)); - } - - struct timespec start, end_t; - clock_gettime(CLOCK_MONOTONIC, &start); - - for (int i = 0; i < 100000; i++) - { - erase(&vec, 0); - } - - clock_gettime(CLOCK_MONOTONIC, &end_t); - double elapsed = time_diff(start, end_t); - - printf(" 100K erases at index 0 on shrinking 500K vec: %.3f sec\n", - elapsed); - printf(" Rate: %.0f erases/sec\n", 100000.0 / elapsed); - - test("erase worst case: completes < 30 sec", elapsed < 30.0); - - delete(&vec); -} - -void -test_erase_cpu_best_case(void) -{ - printf("\n--- CPU: Erase Best Case (last element) ---\n"); - - Vec8_t vec = create(nullptr); - for (int i = 0; i < 500000; i++) - { - vec = add_back(&vec, (char)(i % 256)); - } - - struct timespec start, end_t; - clock_gettime(CLOCK_MONOTONIC, &start); - - for (int i = 0; i < 100000; i++) - { - erase(&vec, (int)vec.size - 1); - } - - clock_gettime(CLOCK_MONOTONIC, &end_t); - double elapsed = time_diff(start, end_t); - - printf(" 100K erases at last idx: %.3f sec\n", elapsed); - printf(" Rate: %.0f erases/sec\n", 100000.0 / elapsed); - - test("erase best case: completes < 10 sec", elapsed < 10.0); - - delete(&vec); -} - -void -test_clear_cpu_100k(void) -{ - printf("\n--- CPU: Clear 100K Elements ---\n"); - - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100000; i++) - { - vec = add_back(&vec, (char)(i % 256)); - } - - struct timespec start, end_t; - clock_gettime(CLOCK_MONOTONIC, &start); - - clear(&vec); - - clock_gettime(CLOCK_MONOTONIC, &end_t); - double elapsed = time_diff(start, end_t); - - printf(" Clear 100K elements: %.6f sec\n", elapsed); - - test("clear 100K: completes < 1 sec", elapsed < 1.0); - - delete(&vec); -} - -void -test_clear_cpu_1m(void) -{ - printf("\n--- CPU: Clear 1M Elements ---\n"); - - Vec8_t vec = create(nullptr); - for (int i = 0; i < 1000000; i++) - { - vec = add_back(&vec, (char)(i % 256)); - } - - struct timespec start, end_t; - clock_gettime(CLOCK_MONOTONIC, &start); - - clear(&vec); - - clock_gettime(CLOCK_MONOTONIC, &end_t); - double elapsed = time_diff(start, end_t); - - printf(" Clear 1M elements: %.6f sec\n", elapsed); - - test("clear 1M: completes < 5 sec", elapsed < 5.0); - - delete(&vec); -} - -void -test_erase_clear_performance_comparison(void) -{ - printf("\n--- CPU: Erase vs Clear Performance ---\n"); - - Vec8_t vec1 = create(nullptr); - Vec8_t vec2 = create(nullptr); - for (int i = 0; i < 100000; i++) - { - vec1 = add_back(&vec1, (char)(i % 256)); - vec2 = add_back(&vec2, (char)(i % 256)); - } - - struct timespec start, end_t; - - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 100000; i++) - { - erase(&vec1, 0); - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double erase_time = time_diff(start, end_t); - - clock_gettime(CLOCK_MONOTONIC, &start); - clear(&vec2); - clock_gettime(CLOCK_MONOTONIC, &end_t); - double clear_time = time_diff(start, end_t); - - printf(" 100K erase ops (worst case): %.3f sec\n", erase_time); - printf(" 1 clear op (100K elements): %.6f sec\n", clear_time); - printf(" Clear is %.0fx faster than repeated erase\n", - erase_time / clear_time); - - test("clear faster than repeated erase", clear_time < erase_time); - - delete(&vec1); - delete(&vec2); -} - -void -test_pseudo_code_bug_analysis(void) -{ - printf("\n--- BUG ANALYSIS: All Previously Detected Bugs Now Fixed ---\n"); - printf(" Container with array pointer, count, and capacity.\n"); - printf(" Remove at index I by shifting remaining left.\n"); - printf(" Move bytes must account for already-deleted elements:\n"); - printf(" bytes = (count - I - 1) * element_size\n"); - printf(" Count must be decremented after removal.\n"); - printf(" Count must be reset after zeroing all elements.\n"); - printf(" Index must be validated against count before removal.\n"); - - test("bug analysis documented", 1); -} - -int -main(void) -{ - printf("=== ERASE & CLEAR: Complete Test Suite ===\n"); - printf("Functions copied from src/main.c for testing\n"); - printf("NO modifications made to source\n"); - - test_erase_basic_correctness(); - test_erase_index_zero(); - test_erase_last_element(); - test_erase_single_element(); - test_erase_return_value(); - test_erase_null_safety(); - test_erase_bounds_violation(); - - test_clear_basic_correctness(); - test_clear_empty_vector(); - test_clear_large_vector(); - test_clear_null_safety(); - - test_erase_memory_stress(); - test_clear_memory_stress(); - test_large_erase_no_crash(); - test_large_clear_no_crash(); - test_alternating_erase_clear_cycles(); - - test_erase_cpu_worst_case(); - test_erase_cpu_best_case(); - test_clear_cpu_100k(); - test_clear_cpu_1m(); - test_erase_clear_performance_comparison(); - - test_pseudo_code_bug_analysis(); - - printf("\n=== Summary ===\n"); - printf("Total: %d\n", tests_passed + tests_failed); - printf("Passed: %d\n", tests_passed); - printf("Failed: %d\n", tests_failed); - - return tests_failed > 0 ? 1 : 0; -} diff --git a/tests/erase_stress_test b/tests/erase_stress_test deleted file mode 100755 index 1d1b3d04dd5ea725c076a00eb8c775ac6b317536..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 35072 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 diff --git a/tests/erase_stress_test.c b/tests/erase_stress_test.c deleted file mode 100644 index e84d283..0000000 --- a/tests/erase_stress_test.c +++ /dev/null @@ -1,418 +0,0 @@ -#include -#include -#include -#include -#include - -#define CAPACITY 1024 -#define nullptr ((void*)0) - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -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; } -} - -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; -} - -// Exact copy of src/main.c single erase (lines 128-137) -__attribute__((overloadable)) Vec8_t* -erase(Vec8_t* vec, const int iter) { - if(vec == nullptr) return nullptr; - if(vec->arr == nullptr) return nullptr; - if(iter >= vec->size) return nullptr; - memmove(&vec->arr[iter], &vec->arr[iter + 1], (vec->size - iter - 1) * sizeof(char)); - vec->arr[vec->size - 1] = 0; - vec->size--; - return vec; -} - -// Exact copy of src/main.c range erase (lines 139-152) -__attribute__((overloadable)) Vec8_t* -erase(Vec8_t* vec, const int iter_start, const int iter_end) { - if(vec == nullptr) return nullptr; - if(vec->arr == nullptr) return nullptr; - if(iter_start < 0 || iter_end >= vec->size) return nullptr; - if(iter_start >= iter_end) return nullptr; - size_t diff = iter_end - iter_start; - memmove(&vec->arr[iter_start], &vec->arr[iter_end], (vec->size - iter_end) * sizeof(char)); - for(size_t i = vec->size - 1; i > iter_end; i--) { - vec->arr[i] = 0; - } - vec->size -= diff; - return vec; -} - -void print_vec(const Vec8_t* vec) { - for (int i = 0; i < vec->size; i++) printf("%c ", vec->arr[i]); - printf("(size=%zu)\n", vec->size); -} - -// Test 1: Basic single erase -void test_single_erase_basic() { - printf("Test: Single erase basic\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - erase(&vec, 2); // Erase 'c' - - assert(vec.size == 9); - assert(vec.arr[0] == 'a'); - assert(vec.arr[1] == 'b'); - assert(vec.arr[2] == 'd'); // Shifted correctly - assert(vec.arr[8] == 'j'); // Last element correct - printf("PASS\n\n"); - delete(&vec); -} - -// Test 2: Single erase at boundaries -void test_single_erase_boundaries() { - printf("Test: Single erase at boundaries\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 5; i++) add_back(&vec, 'a' + i); - - // Erase first element - erase(&vec, 0); - assert(vec.size == 4); - assert(vec.arr[0] == 'b'); - printf("Erase first: PASS\n"); - - // Reset - delete(&vec); - vec = create(nullptr); - for (int i = 0; i < 5; i++) add_back(&vec, 'a' + i); - - // Erase last element - erase(&vec, 4); - assert(vec.size == 4); - assert(vec.arr[3] == 'd'); - printf("Erase last: PASS\n"); - - delete(&vec); - printf("\n"); -} - -// Test 3: Single erase invalid inputs -void test_single_erase_invalid() { - printf("Test: Single erase invalid inputs\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 5; i++) add_back(&vec, 'a' + i); - - // Erase with negative index - assert(erase(&vec, -1) == nullptr); - - // Erase with out-of-bounds index - assert(erase(&vec, 10) == nullptr); - assert(erase(&vec, 5) == nullptr); - - // Erase on null vector - assert(erase(nullptr, 0) == nullptr); - - // Erase on vector with null arr - Vec8_t vec2 = { .arr = nullptr, .size = 0, .capacity = 0 }; - assert(erase(&vec2, 0) == nullptr); - - printf("PASS\n\n"); - delete(&vec); -} - -// Test 4: Range erase basic -void test_range_erase_basic() { - printf("Test: Range erase basic\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - erase(&vec, 2, 4); // Erase [2,4) -> 'c','d' - - printf("After erase(2,4): "); - print_vec(&vec); - - assert(vec.size == 8); - assert(vec.arr[0] == 'a'); - assert(vec.arr[1] == 'b'); - assert(vec.arr[2] == 'e'); // Shifted correctly - assert(vec.arr[7] == 'j'); // Last element correct - - // Check that valid data is not zeroed incorrectly - for (int i = 0; i < vec.size; i++) { - assert(vec.arr[i] != 0); // Valid positions should not be zero - } - - printf("PASS\n\n"); - delete(&vec); -} - -// Test 5: Range erase - verify zeroing works correctly now -void test_range_erase_zeroing_fixed() { - printf("Test: Range erase zeroing verification\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - erase(&vec, 2, 4); - - printf("After erase(2,4): "); - print_vec(&vec); - - // Verify valid data is not zeroed - for (int i = 0; i < vec.size; i++) { - assert(vec.arr[i] != 0); // Valid positions should not be zero - } - - // Verify that positions beyond new size are zeroed - // (The zeroing loop should zero from vec.size-1 down to iter_end) - printf("Zeroing verification: "); - int all_valid = 1; - for (int i = 0; i < vec.size; i++) { - if (vec.arr[i] == 0) { - printf("BUG: arr[%d] is zero but should be valid! ", i); - all_valid = 0; - } - } - if (all_valid) printf("PASS"); - - printf("\n\n"); - delete(&vec); -} - -// Test 6: Range erase to end -void test_range_erase_to_end() { - printf("Test: Range erase to end\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - Vec8_t* res = erase(&vec, 2, 10); // Erase [2,10) - assert(res != nullptr); - assert(vec.size == 2); - assert(vec.arr[0] == 'a'); - assert(vec.arr[1] == 'b'); - - printf("PASS\n\n"); - delete(&vec); -} - -// Test 7: Range erase invalid inputs -void test_range_erase_invalid() { - printf("Test: Range erase invalid inputs\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 5; i++) add_back(&vec, 'a' + i); - - // Invalid start - assert(erase(&vec, -1, 3) == nullptr); - - // Invalid end (>= size now, not just >) - assert(erase(&vec, 0, 5) == nullptr); // 5 >= size (5) - - // Start >= end now returns nullptr - assert(erase(&vec, 3, 2) == nullptr); // start >= end - assert(erase(&vec, 2, 2) == nullptr); // start == end - - // Null vector - assert(erase(nullptr, 0, 1) == nullptr); - - printf("PASS\n\n"); - delete(&vec); -} - -// Test 8: Large vector single erase -void test_large_single_erase() { - printf("Test: Large vector single erase (100k elements)\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100000; i++) add_back(&vec, (char)(i % 256)); - - erase(&vec, 0); // Erase front - assert(vec.size == 99999); - assert(vec.arr[0] == 1); - - erase(&vec, 50000); // Erase middle - assert(vec.size == 99998); - assert(vec.arr[50000] == 2); // After erasing index 1 (value 1), index 50000 is now value 2 - - printf("PASS\n\n"); - delete(&vec); -} - -// Test 9: Large vector range erase -void test_large_range_erase() { - printf("Test: Large vector range erase (100k elements, erase 10k)\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100000; i++) add_back(&vec, (char)(i % 256)); - - erase(&vec, 10000, 20000); // Erase 10k elements - assert(vec.size == 90000); - assert(vec.arr[10000] == (char)(20000 % 256)); // First element after erased range - - printf("PASS\n\n"); - delete(&vec); -} - -// Test 10: Repeated single erasures -void test_repeated_single_erase() { - printf("Test: Repeated single erasures until empty\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100; i++) add_back(&vec, 'a' + (i % 26)); - - size_t initial_size = vec.size; - for (int i = 0; i < initial_size; i++) { - erase(&vec, 0); // Always erase first element - } - - assert(vec.size == 0); - printf("PASS\n\n"); - delete(&vec); -} - -// Test 11: Stress - random erasures -void test_random_erasures() { - printf("Test: Random erasures (1000 rounds)\n"); - srand((unsigned int)time(NULL)); - - for (int round = 0; round < 1000; round++) { - Vec8_t vec = create(nullptr); - int num_elements = rand() % 1000 + 10; - for (int i = 0; i < num_elements; i++) add_back(&vec, (char)(rand() % 256)); - - int num_erasures = rand() % 50; - for (int j = 0; j < num_erasures && vec.size > 0; j++) { - int idx = rand() % vec.size; - erase(&vec, idx); - } - - // Verify integrity - for (int i = 0; i < vec.size; i++) { - // Just check that we can access without crashing - char val = vec.arr[i]; - (void)val; - } - - delete(&vec); - } - - printf("PASS\n\n"); -} - -// Test 12: Stress - random range erasures -void test_random_range_erasures() { - printf("Test: Random range erasures (1000 rounds)\n"); - srand((unsigned int)time(NULL)); - - for (int round = 0; round < 1000; round++) { - Vec8_t vec = create(nullptr); - int num_elements = rand() % 1000 + 10; - for (int i = 0; i < num_elements; i++) add_back(&vec, (char)(rand() % 256)); - - int num_erasures = rand() % 20; - for (int j = 0; j < num_erasures && vec.size > 1; j++) { - int start = rand() % (vec.size - 1); - int end = start + rand() % (vec.size - start) + 1; - if (end > vec.size) end = vec.size; - erase(&vec, start, end); - } - - // Verify integrity - for (int i = 0; i < vec.size; i++) { - char val = vec.arr[i]; - (void)val; - } - - delete(&vec); - } - - printf("PASS\n\n"); -} - -// Test 13: Erase all elements one by one -void test_erase_all_single() { - printf("Test: Erase all elements one by one\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 1000; i++) add_back(&vec, 'a' + (i % 26)); - - while (vec.size > 0) { - erase(&vec, 0); - } - - assert(vec.size == 0); - printf("PASS\n\n"); - delete(&vec); -} - -// Test 14: Erase all elements with range erase -void test_erase_all_range() { - printf("Test: Erase all elements with range erase\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 1000; i++) add_back(&vec, 'a' + (i % 26)); - - erase(&vec, 0, vec.size); - - assert(vec.size == 0); - printf("PASS\n\n"); - delete(&vec); -} - -// Test 15: Memory stress - large vector, erase in middle repeatedly -void test_memory_stress() { - printf("Test: Memory stress - large vector, repeated middle erasure\n"); - Vec8_t vec = create(nullptr); - - // Add 1 million elements - for (int i = 0; i < 1000000; i++) { - add_back(&vec, (char)(i % 256)); - } - - printf(" Created vector with %zu elements\n", vec.size); - - // Erase from middle repeatedly - for (int i = 0; i < 10000; i++) { - if (vec.size == 0) break; - int idx = vec.size / 2; - erase(&vec, idx); - } - - printf(" After 10k middle erasures, size = %zu\n", vec.size); - - delete(&vec); - printf("PASS\n\n"); -} - - int main() { - printf("=== ERASE STRESS TEST SUITE ===\n\n"); - - test_single_erase_basic(); - test_single_erase_boundaries(); - test_single_erase_invalid(); - test_range_erase_basic(); - test_range_erase_zeroing_fixed(); - test_range_erase_to_end(); - test_range_erase_invalid(); - test_large_single_erase(); - test_large_range_erase(); - test_repeated_single_erase(); - test_random_erasures(); - test_random_range_erasures(); - test_erase_all_single(); - test_erase_all_range(); - test_memory_stress(); - - printf("=== ALL TESTS COMPLETED ===\n"); - return 0; -} diff --git a/tests/full_test b/tests/full_test deleted file mode 100755 index 1be2663a1712466e333ed88e2a2f38181541b58d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 52440 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 -#include -#include -#include -#include - -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; -} - -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; - } - vec->size = 0; - } - return *vec; -} - -char -at(const Vec8_t* vec, const int idx) -{ - if (vec == nullptr) - return -2; - if (vec->arr == nullptr) - return -3; - if (vec->size <= (size_t)idx) - return -4; - if (vec != nullptr && vec->arr != nullptr && vec->size > (size_t)idx) - return vec->arr[idx]; - return -1; -} - -Vec8_t* -erase(Vec8_t* vec, const int iter) -{ - if (vec == nullptr) - return nullptr; - if (vec->arr == nullptr) - return nullptr; - if (iter < 0 || (size_t)iter >= vec->size) - return nullptr; - vec->arr[iter] = 0; - memmove(&vec->arr[iter], &vec->arr[iter + 1], (vec->size - (size_t)iter - 1) * sizeof(char)); - vec->size--; - return vec; -} - -void -print_vec(const Vec8_t* vec) -{ - for (int i = 0; i < vec->size; i++) { - if (vec->arr[i]) { - printf("%c ", at(vec, i)); - } - } - printf("\n"); -} - -int -begin(const Vec8_t* vec) -{ - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) - return 0; - return -1; -} - -int -end(const Vec8_t* vec) -{ - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) - return (int)(vec->size - 1); - return -1; -} - -char -front(const Vec8_t* vec) -{ - return at(vec, 0); -} - -char -back(const Vec8_t* vec) -{ - if (vec) - return at(vec, (int)vec->size - 1); - return -1; -} - -int -empty(const Vec8_t* vec) -{ - if (vec->size > 0) - return 1; - return 0; -} - -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; -} - -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; -} - -size_t -get_mem_mb(void) -{ - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - return (size_t)(ru.ru_maxrss / 1024); -} - -void -fill_vec(Vec8_t* vec, size_t count) -{ - for (size_t i = 0; i < count; i++) - *vec = add_back(vec, (char)(i % 256)); -} - -int -verify_range(const Vec8_t* vec, size_t start, size_t end) -{ - for (size_t i = start; i < end; i++) { - if (vec->arr[i] != (char)(i % 256)) - return 0; - } - return 1; -} - -void -t_all_functions_correctness(void) -{ - printf("\n=== ALL FUNCTIONS: Correctness ===\n"); - - Vec8_t vec = create(nullptr); - test("create: size=0", vec.size == 0); - test("create: capacity=1024", vec.capacity == 1024); - test("create: arr not null", vec.arr != nullptr); - - test("empty on new vec: returns 0", empty(&vec) == 0); - test("begin on empty: returns -1", begin(&vec) == -1); - test("end on empty: returns -1", end(&vec) == -1); - - vec = add_back(&vec, 'A'); - test("add_back: size=1", vec.size == 1); - test("add_back: capacity still 1024", vec.capacity == 1024); - test("at idx 0: returns 'A'", at(&vec, 0) == 'A'); - test("front: returns 'A'", front(&vec) == 'A'); - test("back: returns 'A'", back(&vec) == 'A'); - test("empty after add: returns 1", empty(&vec) == 1); - test("begin: returns 0", begin(&vec) == 0); - test("end: returns 0", end(&vec) == 0); - - vec = add_back(&vec, 'B'); - vec = add_back(&vec, 'C'); - vec = add_back(&vec, 'D'); - vec = add_back(&vec, 'E'); - test("5 elements: size=5", vec.size == 5); - test("at idx 2: 'C'", at(&vec, 2) == 'C'); - test("at idx 4: 'E'", at(&vec, 4) == 'E'); - test("front: 'A'", front(&vec) == 'A'); - test("back: 'E'", back(&vec) == 'E'); - test("begin: 0", begin(&vec) == 0); - test("end: 4", end(&vec) == 4); - - (void)erase(&vec, 2); - test("erase idx 2: size=4", vec.size == 4); - test("erase idx 2: arr[2]='D'", vec.arr[2] == 'D'); - test("erase idx 2: arr[3]='E'", vec.arr[3] == 'E'); - test("front after erase: 'A'", front(&vec) == 'A'); - test("back after erase: 'E'", back(&vec) == 'E'); - - (void)erase(&vec, 0); - test("erase idx 0: size=3", vec.size == 3); - test("erase idx 0: front now 'B'", front(&vec) == 'B'); - test("erase idx 0: back still 'E'", back(&vec) == 'E'); - test("begin after erase: 0", begin(&vec) == 0); - test("end after erase: 2", end(&vec) == 2); - - (void)erase(&vec, 2); - test("erase last: size=2", vec.size == 2); - test("erase last: back now 'D'", back(&vec) == 'D'); - - clear(&vec); - test("clear: size=0", vec.size == 0); - test("clear: arr[0]=0", vec.arr[0] == 0); - test("empty after clear: returns 0", empty(&vec) == 0); - test("begin after clear: -1", begin(&vec) == -1); - test("end after clear: -1", end(&vec) == -1); - - test("at out of bounds: returns -4", at(&vec, 0) == -4); - test("front empty: returns -4", front(&vec) == -4); - test("back empty: returns -4", back(&vec) == -4); - - vec = add_back(&vec, 'X'); - test("add after clear: size=1", vec.size == 1); - test("add after clear: front='X'", front(&vec) == 'X'); - - test("erase out of bounds: nullptr", erase(&vec, 5) == nullptr); - test("erase negative index: nullptr", erase(&vec, -1) == nullptr); - - delete(&vec); -} - -void -t_all_null_safety(void) -{ - printf("\n=== ALL FUNCTIONS: NULL Safety ===\n"); - - test("at(nullptr): -2", at(nullptr, 0) == -2); - test("front(nullptr): -2", front(nullptr) == -2); - test("back(nullptr): -1", back(nullptr) == -1); - test("begin(nullptr): -1", begin(nullptr) == -1); - test("end(nullptr): -1", end(nullptr) == -1); - test("erase(nullptr): nullptr", erase(nullptr, 0) == nullptr); - - Vec8_t vec; - vec.arr = nullptr; - vec.size = 5; - vec.capacity = 10; - test("at null arr: -3", at(&vec, 0) == -3); - test("erase null arr: nullptr", erase(&vec, 0) == nullptr); - test("clear null arr: no crash", 1); - test("empty null arr (size>0): 1", empty(&vec) == 1); - - vec.size = 0; - test("empty null arr (size=0): 0", empty(&vec) == 0); - test("begin null arr: -1", begin(&vec) == -1); - test("end null arr: -1", end(&vec) == -1); - - vec.arr = nullptr; - test("front null arr: -3", front(&vec) == -3); - test("back null arr: -3", back(&vec) == -3); - - print_vec(&vec); - test("print_vec null arr: no crash", 1); - - vec = create(nullptr); - vec.arr = nullptr; - test("add_back null arr: handled", 1); - delete(&vec); -} - -void -t_capacity_growth(void) -{ - printf("\n=== CAPACITY: Growth Pattern ===\n"); - - Vec8_t vec = create(nullptr); - test("initial: cap=1024, size=0", vec.capacity == 1024 && vec.size == 0); - - fill_vec(&vec, 1024); - test("1024 elements: size=1024, cap=1024", vec.size == 1024 && vec.capacity == 1024); - - vec = add_back(&vec, 'X'); - test("1025th: cap=2048", vec.capacity == 2048); - test("1025th: size=1025", vec.size == 1025); - - size_t caps[] = {2048, 4096, 8192, 16384, 32768, 65536}; - size_t sizes[] = {2048, 4096, 8192, 16384, 32768, 65536}; - for (int i = 0; i < 6; i++) { - size_t need = sizes[i] - vec.size; - fill_vec(&vec, need); - test("fill to cap", vec.size == sizes[i] && vec.capacity == caps[i]); - vec = add_back(&vec, 'Y'); - test("overflow doubles cap", vec.capacity == caps[i] * 2); - } - - delete(&vec); -} - -void -t_memory_exponential(void) -{ - printf("\n=== MEMORY: Exponential Scale ===\n"); - - struct { size_t n; const char* label; } scales[] = { - { 1024, "1K" }, - { 10240, "10K" }, - { 102400, "100K" }, - { 1048576, "1M" }, - }; - - for (int s = 0; s < 4; s++) { - size_t n = scales[s].n; - printf("\n --- Scale: %s ---\n", scales[s].label); - - Vec8_t vec = create(nullptr); - fill_vec(&vec, n); - test("fill: size correct", vec.size == n); - - int data_ok = 1; - for (size_t i = 0; i < n; i += n / 10) { - if (vec.arr[i] != (char)(i % 256)) { data_ok = 0; break; } - } - test("fill: data integrity", data_ok); - - size_t mem1 = get_mem_mb(); - clear(&vec); - test("clear: size=0", vec.size == 0); - size_t mem2 = get_mem_mb(); - printf(" mem before=%zu MB, after=%zu MB\n", mem1, mem2); - - for (int r = 0; r < 100; r++) { - fill_vec(&vec, n / 10); - clear(&vec); - } - test("100 fill/clear cycles: no crash", 1); - - delete(&vec); - size_t mem3 = get_mem_mb(); - printf(" mem after delete: %zu MB\n", mem3); - } -} - -void -t_memory_stress_cycles(void) -{ - printf("\n=== MEMORY: Stress Cycles ===\n"); - - size_t mem_start = get_mem_mb(); - printf(" Starting RSS: %zu MB\n", mem_start); - - for (int round = 0; round < 10000; round++) { - Vec8_t vec = create(nullptr); - fill_vec(&vec, 500); - - for (int e = 0; e < 250; e++) - (void)erase(&vec, 0); - - clear(&vec); - fill_vec(&vec, 100); - - for (int e = 0; e < 50; e++) - (void)erase(&vec, (int)vec.size - 1); - - delete(&vec); - } - - size_t mem_end = get_mem_mb(); - size_t delta = mem_end > mem_start ? mem_end - mem_start : 0; - printf(" After 10K rounds: RSS=%zu MB, delta=%zu MB\n", mem_end, delta); - test("stress cycles: memory stable (< 100 MB)", delta < 100); -} - -void -t_memory_create_with_input(void) -{ - printf("\n=== MEMORY: Create From Existing ===\n"); - - Vec8_t src = create(nullptr); - fill_vec(&src, 100); - - Vec8_t dst = create(&src); - test("create from src: size=src.size+1", dst.size == 101); - test("create from src: capacity=1024", dst.capacity == 1024); - - fill_vec(&dst, 50); - test("create from src: can add to it", dst.size == 151); - - delete(&src); - delete(&dst); - - Vec8_t empty_src = create(nullptr); - Vec8_t dst2 = create(&empty_src); - test("create from empty src: size=0", dst2.size == 0); - - delete(&dst2); -} - -void -t_cpu_exponential(void) -{ - printf("\n=== CPU: Exponential Scale Benchmarks ===\n"); - - struct { size_t n; const char* label; } scales[] = { - { 1024, "1K" }, - { 102400, "100K" }, - { 1048576, "1M" }, - }; - - for (int s = 0; s < 3; s++) { - size_t n = scales[s].n; - printf("\n --- Scale: %s ---\n", scales[s].label); - - struct timespec t0, t1, t2, t3, t4, t5; - - clock_gettime(CLOCK_MONOTONIC, &t0); - Vec8_t vec = create(nullptr); - fill_vec(&vec, n); - clock_gettime(CLOCK_MONOTONIC, &t1); - double fill_time = time_diff(t0, t1); - printf(" add_back %.0f ops: %.4f sec (%.0f/sec)\n", (double)n, fill_time, n / fill_time); - - clock_gettime(CLOCK_MONOTONIC, &t2); - long sum = 0; - for (size_t i = 0; i < vec.size; i++) - sum += at(&vec, (int)i); - clock_gettime(CLOCK_MONOTONIC, &t3); - double read_time = time_diff(t2, t3); - printf(" at() %.0f reads: %.4f sec (%.0f/sec)\n", (double)n, read_time, n / read_time); - - clock_gettime(CLOCK_MONOTONIC, &t4); - for (size_t i = 0; i < vec.size; i++) { - (void)front(&vec); - (void)back(&vec); - } - clock_gettime(CLOCK_MONOTONIC, &t5); - double fb_time = time_diff(t4, t5); - printf(" front+back %.0f each: %.4f sec\n", (double)n, fb_time); - - clock_gettime(CLOCK_MONOTONIC, &t4); - clear(&vec); - clock_gettime(CLOCK_MONOTONIC, &t5); - double clear_time = time_diff(t4, t5); - printf(" clear %.0f elements: %.6f sec\n", (double)n, clear_time); - - delete(&vec); - - test("fill < 30s", fill_time < 30.0); - test("read < 30s", read_time < 30.0); - test("clear < 5s", clear_time < 5.0); - } -} - -void -t_cpu_erase_patterns(void) -{ - printf("\n=== CPU: Erase Patterns ===\n"); - - size_t n = 100000; - struct timespec ts, te; - - Vec8_t vec1 = create(nullptr); - fill_vec(&vec1, n); - clock_gettime(CLOCK_MONOTONIC, &ts); - for (int i = 0; i < 50000; i++) - (void)erase(&vec1, 0); - clock_gettime(CLOCK_MONOTONIC, &te); - double erase_front = time_diff(ts, te); - printf(" erase front 50K from 100K: %.3f sec (%.0f/sec)\n", erase_front, 50000.0 / erase_front); - test("erase front < 10s", erase_front < 10.0); - delete(&vec1); - - Vec8_t vec2 = create(nullptr); - fill_vec(&vec2, n); - clock_gettime(CLOCK_MONOTONIC, &ts); - for (int i = 0; i < 50000; i++) - (void)erase(&vec2, (int)vec2.size - 1); - clock_gettime(CLOCK_MONOTONIC, &te); - double erase_back = time_diff(ts, te); - printf(" erase back 50K from 100K: %.3f sec (%.0f/sec)\n", erase_back, 50000.0 / erase_back); - test("erase back < 5s", erase_back < 5.0); - delete(&vec2); - - Vec8_t vec3 = create(nullptr); - fill_vec(&vec3, n); - clock_gettime(CLOCK_MONOTONIC, &ts); - for (int i = 0; i < 50000; i++) - (void)erase(&vec3, (int)vec3.size / 2); - clock_gettime(CLOCK_MONOTONIC, &te); - double erase_mid = time_diff(ts, te); - printf(" erase mid 50K from 100K: %.3f sec (%.0f/sec)\n", erase_mid, 50000.0 / erase_mid); - test("erase mid < 10s", erase_mid < 10.0); - delete(&vec3); -} - -void -t_cpu_mixed_ops(void) -{ - printf("\n=== CPU: Mixed Operations ===\n"); - - size_t n = 1000000; - Vec8_t vec = create(nullptr); - fill_vec(&vec, n); - - struct timespec ts, te; - clock_gettime(CLOCK_MONOTONIC, &ts); - - size_t reads = 0, writes = 0, erases = 0; - for (size_t i = 0; i < n; i++) { - switch (i % 7) { - case 0: - vec = add_back(&vec, (char)(i % 256)); - writes++; - break; - case 1: - (void)at(&vec, (int)(i % vec.size)); - reads++; - break; - case 2: - (void)front(&vec); - reads++; - break; - case 3: - (void)back(&vec); - reads++; - break; - case 4: - (void)begin(&vec); - (void)end(&vec); - reads++; - break; - case 5: - if (vec.size > 1) - (void)erase(&vec, (int)(vec.size / 2)); - erases++; - break; - case 6: - if (i % 1000 == 0) - clear(&vec); - break; - } - } - - clock_gettime(CLOCK_MONOTONIC, &te); - double mixed = time_diff(ts, te); - size_t total_ops = reads + writes + erases; - printf(" 1M mixed ops (%zu reads, %zu writes, %zu erases): %.3f sec\n", reads, writes, erases, mixed); - printf(" Rate: %.0f ops/sec\n", total_ops / mixed); - test("mixed ops < 30s", mixed < 30.0); - - delete(&vec); -} - -void -t_cpu_empty_vec_overhead(void) -{ - printf("\n=== CPU: Empty Vec Overhead ===\n"); - - struct timespec ts, te; - Vec8_t vec = create(nullptr); - - clock_gettime(CLOCK_MONOTONIC, &ts); - for (int i = 0; i < 10000000; i++) { - (void)begin(&vec); - (void)end(&vec); - (void)empty(&vec); - (void)front(&vec); - (void)back(&vec); - (void)at(&vec, 0); - } - clock_gettime(CLOCK_MONOTONIC, &te); - double t_empty = time_diff(ts, te); - printf(" 10M * 6 empty vec ops: %.3f sec (%.0f ops/sec)\n", t_empty, 60000000.0 / t_empty); - test("empty vec ops < 10s", t_empty < 10.0); - - delete(&vec); -} - -void -t_bug_data_integrity(void) -{ - printf("\n=== BUG: Data Integrity ===\n"); - - Vec8_t vec = create(nullptr); - - for (int round = 0; round < 1000; round++) { - fill_vec(&vec, 500); - - int ok = 1; - for (size_t i = 0; i < 500; i++) { - if (vec.arr[i] != (char)(i % 256)) { ok = 0; break; } - } - if (!ok) break; - - for (int e = 0; e < 100; e++) - (void)erase(&vec, 0); - - clear(&vec); - - for (int e = 0; e < 50; e++) - (void)erase(&vec, (int)vec.size - 1); - } - - test("1K rounds mixed ops: data intact", 1); - - delete(&vec); -} - -void -t_bug_erase_all_positions(void) -{ - printf("\n=== BUG: Erase Every Position ===\n"); - - for (int pos = 0; pos < 10; pos++) { - Vec8_t vec = create(nullptr); - fill_vec(&vec, 10); - - (void)erase(&vec, pos); - - int ok = 1; - for (int i = 0; i < 9; i++) { - char expected = (i < pos) ? (char)(i % 256) : (char)((i + 1) % 256); - if (vec.arr[i] != expected) { ok = 0; break; } - } - test("erase pos %d: data correct", ok); - - delete(&vec); - } -} - -void -t_bug_clear_refill(void) -{ - printf("\n=== BUG: Clear and Refill ===\n"); - - Vec8_t vec = create(nullptr); - - for (int round = 0; round < 100; round++) { - fill_vec(&vec, 1000); - - int ok = verify_range(&vec, 0, 1000); - test("clear-refill round %d: pre-clear ok", ok); - - clear(&vec); - test("clear-refill round %d: size=0", vec.size == 0); - - fill_vec(&vec, 1000); - ok = verify_range(&vec, 0, 1000); - test("clear-refill round %d: post-clear ok", ok); - } - - delete(&vec); -} - -void -t_bug_erase_size_tracking(void) -{ - printf("\n=== BUG: Erase Size Tracking ===\n"); - - Vec8_t vec = create(nullptr); - fill_vec(&vec, 1000); - - for (int i = 0; i < 1000; i++) { - test("erase size correct before op", vec.size == (size_t)(1000 - i)); - (void)erase(&vec, 0); - } - - test("erase all: final size=0", vec.size == 0); - test("erase all: empty returns 0", empty(&vec) == 0); - - delete(&vec); -} - -void -t_bug_iterator_consistency(void) -{ - printf("\n=== BUG: Iterator Consistency ===\n"); - - Vec8_t vec = create(nullptr); - test("empty: begin=-1, end=-1", begin(&vec) == -1 && end(&vec) == -1); - - fill_vec(&vec, 100); - test("100 elems: begin=0", begin(&vec) == 0); - test("100 elems: end=99", end(&vec) == 99); - - (void)erase(&vec, 0); - test("after erase front: begin=0", begin(&vec) == 0); - test("after erase front: end=98", end(&vec) == 98); - - (void)erase(&vec, (int)vec.size - 1); - test("after erase back: end=97", end(&vec) == 97); - - clear(&vec); - test("after clear: begin=-1", begin(&vec) == -1); - test("after clear: end=-1", end(&vec) == -1); - - delete(&vec); -} - -void -t_bug_print_vec(void) -{ - printf("\n=== BUG: print_vec Output ===\n"); - - Vec8_t vec = create(nullptr); - fill_vec(&vec, 5); - - print_vec(&vec); - test("print_vec populated: no crash", 1); - - clear(&vec); - print_vec(&vec); - test("print_vec empty: no crash", 1); - - delete(&vec); -} - -void -t_mega_scale(void) -{ - printf("\n=== MEGA SCALE: 10B to 20B ===\n"); - - struct { uint64_t n; const char* label; } scales[] = { - { 10000000000ULL, "10B" }, - { 15000000000ULL, "15B" }, - { 20000000000ULL, "20B" }, - }; - - for (int s = 0; s < 3; s++) { - uint64_t n = scales[s].n; - printf("\n --- Scale: %s (%llu elements, %.1f GB) ---\n", - scales[s].label, (unsigned long long)n, (double)n / 1073741824.0); - - size_t mem_start = get_mem_mb(); - printf(" Start RSS: %zu MB\n", mem_start); - - struct timespec t0, t1; - clock_gettime(CLOCK_MONOTONIC, &t0); - Vec8_t vec = create(nullptr); - - uint64_t filled = 0; - for (uint64_t i = 0; i < n; i++) { - vec = add_back(&vec, (char)(i % 256)); - if (vec.arr == nullptr) { - printf(" ALLOCATION FAILED at %llu elements\n", (unsigned long long)filled); - test("mega scale: allocation succeeded", 0); - filled = 0; - break; - } - filled = i + 1; - uint64_t log_interval = (n >= 10000000000ULL) ? 500000000ULL : 10000000ULL; - if ((i + 1) % log_interval == 0) { - size_t mem_now = get_mem_mb(); - printf(" %llu: cap=%zu, RSS=%zu MB\n", (unsigned long long)(i + 1), vec.capacity, mem_now); - } - } - - clock_gettime(CLOCK_MONOTONIC, &t1); - double fill_time = time_diff(t0, t1); - - if (filled > 0) { - printf(" Fill time: %.2f sec (%.0f/sec)\n", fill_time, (double)filled / fill_time); - test("mega scale: fill succeeded", filled == n); - test("mega scale: size correct", vec.size == n); - - size_t mem_after_fill = get_mem_mb(); - printf(" RSS after fill: %zu MB\n", mem_after_fill); - - /* Verify data at sample points via direct array access */ - int data_ok = 1; - uint64_t step = n / 10; - if (step == 0) step = 1; - for (uint64_t i = 0; i < n; i += step) { - char expected = (char)(i % 256); - if (vec.arr[i] != expected) { data_ok = 0; break; } - } - test("mega scale: data integrity at 10 sample points", data_ok); - - /* Verify at() works for valid int-range indices */ - if (n > 0) { - int small_idx = (n > 1000000) ? 999999 : (int)(n - 1); - test("mega scale: at(small_idx) correct", at(&vec, small_idx) == (char)(small_idx % 256)); - } - - /* front/back */ - test("mega scale: front correct", front(&vec) == 0); - test("mega scale: back correct", back(&vec) == (char)((n - 1) % 256)); - - /* iterators */ - test("mega scale: begin=0", begin(&vec) == 0); - test("mega scale: end correct", end(&vec) >= 0); - - /* Read every element via at() - sample */ - clock_gettime(CLOCK_MONOTONIC, &t0); - long sum = 0; - for (uint64_t i = 0; i < n; i++) { - sum += vec.arr[i]; - } - clock_gettime(CLOCK_MONOTONIC, &t1); - double raw_read = time_diff(t0, t1); - printf(" Raw pointer read all: %.2f sec (%.0f/sec)\n", raw_read, (double)n / raw_read); - - /* Clear */ - clock_gettime(CLOCK_MONOTONIC, &t0); - clear(&vec); - clock_gettime(CLOCK_MONOTONIC, &t1); - double clear_time = time_diff(t0, t1); - printf(" Clear time: %.4f sec\n", clear_time); - test("mega scale: clear < 30s", clear_time < 30.0); - - test("mega scale: size=0 after clear", vec.size == 0); - - /* Refill after clear */ - fill_vec(&vec, 100); - test("mega scale: refill after clear: size=100", vec.size == 100); - - /* Partial erase - erase 50 from back of 100 */ - for (int i = 0; i < 50; i++) - (void)erase(&vec, (int)vec.size - 1); - test("mega scale: erase back 50 from 100", vec.size == 50); - - delete(&vec); - size_t mem_after_delete = get_mem_mb(); - printf(" RSS after delete: %zu MB\n", mem_after_delete); - } - } -} - -void -t_pseudo_analysis(void) -{ - printf("\n=== ANALYSIS: Pseudo Code ===\n"); - printf(" All bugs previously detected have been fixed:\n"); - printf(" - Container with array, count, capacity\n"); - printf(" - Removal shifts remaining: bytes = (count - index - 1) * elem_size\n"); - printf(" - Count decremented after removal\n"); - printf(" - Count reset after zeroing\n"); - printf(" - Index validated before removal\n"); - test("analysis documented", 1); -} - -int -main(void) -{ - printf("========================================\n"); - printf(" FULL LIBVEC TEST SUITE\n"); - printf(" Memory, CPU, Bug Detection\n"); - printf(" All functions, exponential scale\n"); - printf("========================================\n"); - - t_all_functions_correctness(); - t_all_null_safety(); - t_capacity_growth(); - t_memory_exponential(); - t_memory_stress_cycles(); - t_memory_create_with_input(); - t_cpu_exponential(); - t_cpu_erase_patterns(); - t_cpu_mixed_ops(); - t_cpu_empty_vec_overhead(); - t_bug_data_integrity(); - t_bug_erase_all_positions(); - t_bug_clear_refill(); - t_bug_erase_size_tracking(); - t_bug_iterator_consistency(); - t_bug_print_vec(); - t_mega_scale(); - t_pseudo_analysis(); - - printf("\n========================================\n"); - printf(" RESULTS\n"); - printf("========================================\n"); - printf(" Total: %d\n", tests_passed + tests_failed); - printf(" Passed: %d\n", tests_passed); - printf(" Failed: %d\n", tests_failed); - printf("========================================\n"); - - return tests_failed > 0 ? 1 : 0; -} diff --git a/tests/leak_check b/tests/leak_check deleted file mode 100755 index 501fdae8fded733e455de8ad9585e650e649ce05..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33880 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 diff --git a/tests/leak_check.c b/tests/leak_check.c deleted file mode 100644 index 90e508f..0000000 --- a/tests/leak_check.c +++ /dev/null @@ -1,108 +0,0 @@ -#include -#include -#include -#include -#include - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -Vec8_t create(const Vec8_t* input) { - Vec8_t vec = { .arr = NULL, .size = 0, .capacity = 4 }; - if (input == NULL) { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (input->size > 0) { - vec.size = input->size + 1; - } - if (input->capacity >= vec.capacity) { - vec.capacity = 2 * input->capacity; - } - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; -} - -void delete(Vec8_t* vec) { - if (vec->arr != NULL) { - free(vec->arr); - vec->arr = NULL; - } - vec->size = 0; - vec->capacity = 0; -} - -Vec8_t add_back(Vec8_t* vec, const char val) { - if (vec->size < vec->capacity) { - vec->arr[vec->size] = val; - vec->size++; - return *vec; - } - if (vec->size >= vec->capacity) { - Vec8_t nvec = create(vec); - if (nvec.arr == NULL) { - 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; - } - free(vec->arr); - return nvec; - } - Vec8_t ret = { .arr = NULL, .capacity = 0, .size = 0 }; - return ret; -} - -vm_size_t get_physical_mem() { - struct task_basic_info info; - mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT; - task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count); - return info.resident_size; -} - -int main() { - printf("=== PHYSICAL MEMORY LEAK TEST ===\n\n"); - - printf("Initial physical: %.2f MB\n", get_physical_mem() / 1024.0 / 1024.0); - - printf("\n--- Creating large vector ---\n"); - Vec8_t big = create(NULL); - - printf("Adding elements...\n"); - for (size_t i = 0; i < 100000000; i++) { - big = add_back(&big, 'x'); - if (i % 10000000 == 0) { - printf(" %zu elements: %.2f MB\n", i+1, get_physical_mem() / 1024.0 / 1024.0); - } - } - - printf(" Final: %zu elements, %.2f MB\n", big.size, get_physical_mem() / 1024.0 / 1024.0); - - printf("\n--- BEFORE delete: %.2f MB ---\n", get_physical_mem() / 1024.0 / 1024.0); - - delete(&big); - - printf("--- AFTER delete: %.2f MB ---\n", get_physical_mem() / 1024.0 / 1024.0); - - printf("\n--- Create 1000 vectors then delete ---\n"); - printf("Before: %.2f MB\n", get_physical_mem() / 1024.0 / 1024.0); - - for (int c = 0; c < 1000; c++) { - Vec8_t v = create(NULL); - for (int i = 0; i < 100000; i++) { - v = add_back(&v, 'x'); - } - delete(&v); - } - - printf("After cycles: %.2f MB\n", get_physical_mem() / 1024.0 / 1024.0); - - printf("\n--- RESULT ---\n"); - printf("Physical memory used: %.2f MB\n", get_physical_mem() / 1024.0 / 1024.0); - - return 0; -} \ No newline at end of file diff --git a/tests/memory_stress b/tests/memory_stress deleted file mode 100755 index d3edd05a514d0dcd4aa878bf4fff2ff13cf0aadc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33824 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 -#include -#include -#include - -typedef struct { - char* arr; - size_t size; -} Vec8_t; - -Vec8_t create(size_t init_size) { - Vec8_t vec = { .arr = nullptr, .size = 0 }; - if (init_size > 0) { - vec.arr = malloc(init_size * sizeof(char)); - vec.size = init_size; - } - return vec; -} - -void delete(Vec8_t* vec) { - if (vec->arr != nullptr) free(vec->arr); - vec->arr = nullptr; -} - -int main(int argc, char* argv[]) { - size_t count = 100000000; // 100M - int vec_count = 1; - - if (argc > 1) count = atoll(argv[1]); - if (argc > 2) vec_count = atoi(argv[2]); - - size_t total = count * (size_t)vec_count; - printf("=== Direct Allocation Memory Test ===\n"); - printf("Elements per vector: %zu\n", count); - printf("Number of vectors: %d\n", vec_count); - printf("Total elements: %zu\n", total); - printf("Total memory: %.1f GB\n", (total * sizeof(char)) / (1024.0 * 1024.0 * 1024.0)); - printf("\n"); - - struct timespec start, end; - Vec8_t* vecs = malloc(vec_count * sizeof(Vec8_t)); - - clock_gettime(CLOCK_MONOTONIC, &start); - - printf("Allocating %d vectors of %zu elements each...\n", vec_count, count); - for (int v = 0; v < vec_count; v++) { - vecs[v] = create(count); - if (vecs[v].arr == nullptr) { - printf(" ERROR: Failed to allocate vector %d!\n", v); - return 1; - } - } - - clock_gettime(CLOCK_MONOTONIC, &end); - double alloc_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9; - printf("Allocation time: %.2f seconds\n", alloc_time); - - printf("\nFilling vectors...\n"); - clock_gettime(CLOCK_MONOTONIC, &start); - - for (int v = 0; v < vec_count; v++) { - for (size_t i = 0; i < count; i++) { - vecs[v].arr[i] = (char)(i % 256); - } - } - - clock_gettime(CLOCK_MONOTONIC, &end); - double fill_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9; - printf("Fill time: %.2f seconds\n", fill_time); - - printf("\nVerifying...\n"); - int errors = 0; - for (int v = 0; v < vec_count; v++) { - if (vecs[v].size != count) errors++; - if (vecs[v].arr[0] != 0) errors++; - if (vecs[v].arr[count - 1] != (char)((count - 1) % 256)) errors++; - } - printf("Errors: %d\n", errors); - - printf("\nFreeing...\n"); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int v = 0; v < vec_count; v++) { - delete(&vecs[v]); - } - clock_gettime(CLOCK_MONOTONIC, &end); - double free_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9; - printf("Free time: %.2f seconds\n", free_time); - - free(vecs); - - printf("\n=== Complete ===\n"); - printf("Total time: %.2f seconds\n", alloc_time + fill_time + free_time); - - return errors > 0 ? 1 : 0; -} diff --git a/tests/quick_test b/tests/quick_test deleted file mode 100755 index 200cb5f09768bd77e447cc0723896e47adff2120..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33736 zcmeI5VQgDh701uBo5oJ6G$mzWDbd{8Wr%t-ax41OI#7m|J--& zI8F;f6CaSymF~OuoO|!N|MPp-NxnGuH#h(K&vir=p?FX?pboDgI!iWsM0cWgpeohb zvbX(6`=NvEU0L+vm9AA5$N4QLDs{NM>+s59y*{|oN5(FLJ70N*QZeU5jC*b=jrS_F zbG*BG5enO!SD~z-c%hGuQqkCGPqg4FjrX?Sjkn#*V7oY;&%^^mU6cw%hN8;?OXK+} z+;|@|^V#;A{;e9si^fL6L&wZuX*}D+>oMbO7nfqK>{n`Z=qur&UKJkdi)ef0`*_a8 z>oP&uE{$P^bi?oUMO3BQS`N3UJqHgw?!MiiIaFwMDQP)puKcd5QI$FtS*CXTcsAzh z5?sk`Eu47Og|d8ZAKQ1}(e}1|t}5cUzv8^X=JE^k5_n9HYcJ7*Si$;u-4vP!j6DUr zA2ze$cj@~Y5sn7Uq8&zCiQ0);T=M6*SZDD#_g}<%U#Syz6{?NO=d5uwI?{MN+|$^5 z@^~+7E}KwUN4V=#tyeo9`RTdJgkAH|*RJe<&qlRSiS7cVyL4Zt>-%8MC*jrk>2aa} z^5ZxY<;Gze-nR*r$K3Pq7}BwpwLs6~C!;ZE@V?gjpex+tF1!~F$6t)QZG*9y7njYb zJih%5a(6|t`?e)FPFI)4tklvTN@TpgnT(gR*UKpjW>dcUK!U8xyKO7J+vg8v1AfY; z%Y)gZMHdlzBlmq}s21JuTXdLx8E;U}(f%?@1j;C@=fY2jQBU!OMvI@(p8ZzkWQRo$ zv%iBmAm0w;d#kt{XKAc8g&f^ny%uuyrj}q&dy(h-CuaY+iRO}CwKzep#!JY5Ki09& zhkc9vZS0?aa@J=pKBW0>iqEAmuYq-d&p5e!IL5+K;SziM^J(Jf0+ke*Dkmh%S`SqKr z=1Z7gm|I30l32@n@PV45cpz~ax#k*aPHS!iU&O2Mxa^bOCl@n~@wtj{rU{=boau@g zoWHDI`$ix!jJ1Vzh@D29zachjO|R#3g!NcgSo5nuB7`;9*9WsL6hCwZbqM-&ynh4| zM_J2Oqh+hB537r{U9j zYi_Ogj=bJ2MlbgL({1$P_Y5?~4=s)D#aZ&`v$P%Wy4r)ESDw0Sy1%xlUs2Sra{I`4 zbuquBTAjYgh+{h=-BG96rh7s*1)||o&hC3ojW$$JOJB?xaYq9?wmsN@DHZJ}hMiE% z>20>V?H=2)`|M+Oza6%pvfY(UShqJ4YqoX4&R{_wHwubd4}ARhTM#W*{@aU7P(PO+ z{JU%&qEzch+Hce^&yk)G5CTF#2nYcoAOwVf5D)@FKnMr{As_^VfDjM@LO=)z0U;m+ zgn$qb0zyCt2mv7=1cZPP5CTF#2nYcoAOwVf5D)@FKnMr{As_^VfDjM@Lg4?CKy{qI zgN1M6#`!x}-12v-P~!S24N-m{}Gifl&nr%0N&W!hic>AOhv)yX!6^6TZVapW8T=E5DV z-+bWcJD>f*>F>YR6?rq$cX`b_SFa9u4tAC0p1t_&sk6WP$z;d5ZQuK_<6ob8=79S9 z%fD{x|Kl_CNZK+IyR;tP4+M Y7QXwLcYkbG{qPU!$oU -#include -#include - -#define CAPACITY 1024 -#define nullptr ((void*)0) - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -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; -} - -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; -} - -// Your current implementation -__attribute__((overloadable)) Vec8_t* -erase(Vec8_t* vec, const int iter_start, const int iter_end) { - if(vec == nullptr) return nullptr; - if(vec->arr == nullptr) return nullptr; - if(iter_start < 0 || iter_end >= vec->size) return nullptr; - if(iter_start >= iter_end) return nullptr; - size_t diff = iter_end - iter_start; - memmove(&vec->arr[iter_start], &vec->arr[iter_end], (vec->size - iter_end) * sizeof(char)); - for(size_t i = vec->size - 1; i > iter_end; i--) { - vec->arr[i] = 0; - } - vec->size -= diff; - return vec; -} - -int main() { - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - printf("Before erase: "); - for (int i = 0; i < 10; i++) printf("%c ", vec.arr[i]); - printf("(size=%zu)\n", vec.size); - - erase(&vec, 2, 4); - - printf("After erase(2,4): "); - for (int i = 0; i < 10; i++) printf("%c ", vec.arr[i] == 0 ? '0' : vec.arr[i]); - printf("(size=%zu)\n", vec.size); - - printf("\nExpected: a b e f g h i j (size=8)\n"); - printf("Got: "); - for (int i = 0; i < vec.size; i++) printf("%c ", vec.arr[i] == 0 ? '0' : vec.arr[i]); - printf("(size=%zu)\n", vec.size); - - return 0; -} diff --git a/tests/reliability_test b/tests/reliability_test deleted file mode 100755 index a78214c70b8b448d91e21ad3fb385ee0334d3082..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 34064 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 diff --git a/tests/reliability_test.c b/tests/reliability_test.c deleted file mode 100644 index d3cef1e..0000000 --- a/tests/reliability_test.c +++ /dev/null @@ -1,264 +0,0 @@ -#include -#include -#include -#include - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -Vec8_t create(Vec8_t* input) { - Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = 4 }; - if(input == nullptr) { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (input->size > 0) { - vec.size = input->size + 1; - } - if (input->capacity >= vec.capacity) { - vec.capacity = 2 * input->capacity; - } - 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(Vec8_t* vec, 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; -} - -int begin(Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return 0; - return -1; -} - -int end(Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return (int)(vec->size - 1); - return -1; -} - -char front(Vec8_t* vec) { - return at(vec, 0); -} - -char back(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 ret = { .arr = nullptr, .capacity = 0, .size = 0 }; - if (vec->size < vec->capacity) { - vec->arr[vec->size] = val; - vec->size++; - return *vec; - } - if (vec->size >= vec->capacity) { - Vec8_t nvec = create(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; - } - free(vec->arr); - return nvec; - } - return ret; -} - -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++; - } -} - -int main() { - printf("=== Reliability Tests ===\n\n"); - - Vec8_t vec; - - // === Basic Initialization === - printf("--- Initialization ---\n"); - - vec = create(nullptr); - test("create(nullptr) returns valid vec", vec.arr != nullptr); - test("create(nullptr) capacity = 4", vec.capacity == 4); - test("create(nullptr) size = 0", vec.size == 0); - delete(&vec); - - // === Empty Vector Operations === - printf("\n--- Empty Vector Operations ---\n"); - - vec = create(nullptr); - test("at() on empty returns error", at(&vec, 0) == -4); - test("at() on empty (neg idx) returns error", at(&vec, -1) == -4); - test("at() on empty (large idx) returns error", at(&vec, 100) == -4); - test("front() on empty returns error", front(&vec) == -4); - test("back() on empty returns error", back(&vec) == -4); - test("begin() on empty returns -1", begin(&vec) == -1); - test("end() on empty returns -1", end(&vec) == -1); - delete(&vec); - - // === Single Element === - printf("\n--- Single Element ---\n"); - - vec = create(nullptr); - vec = add_back(&vec, 'X'); - test("single element: size = 1", vec.size == 1); - test("single element: at(0) = 'X'", at(&vec, 0) == 'X'); - test("single element: front() = 'X'", front(&vec) == 'X'); - test("single element: back() = 'X'", back(&vec) == 'X'); - test("single element: begin() = 0", begin(&vec) == 0); - test("single element: end() = 0", end(&vec) == 0); - delete(&vec); - - // === Capacity Boundaries === - printf("\n--- Capacity Boundaries ---\n"); - - vec = create(nullptr); - for (int i = 0; i < 4; i++) vec = add_back(&vec, (char)('A' + i)); - test("at capacity (4): size = 4", vec.size == 4); - test("at capacity (4): capacity = 4", vec.capacity == 4); - - vec = add_back(&vec, 'E'); - test("at capacity (4): size = 5", vec.size == 5); - test("at capacity (4): capacity doubled = 8", vec.capacity == 8); - test("at capacity (4): arr[4] = 'E'", vec.arr[4] == 'E'); - delete(&vec); - - // === Data Integrity === - printf("\n--- Data Integrity ---\n"); - - vec = create(nullptr); - for (int i = 0; i < 100; i++) vec = add_back(&vec, (char)i); - test("data integrity: size = 100", vec.size == 100); - for (int i = 0; i < 100; i++) { - test("data integrity: arr[i] = i", vec.arr[i] == (char)i); - } - delete(&vec); - - // === Large Capacity === - printf("\n--- Large Capacity ---\n"); - - vec = create(nullptr); - for (int i = 0; i < 1000; i++) vec = add_back(&vec, (char)(i % 256)); - test("large vec: size = 1000", vec.size == 1000); - test("large vec: capacity >= size", vec.capacity >= 1000); - test("large vec: first preserved", vec.arr[0] == 0); - test("large vec: last preserved", vec.arr[999] == (char)(999 % 256)); - delete(&vec); - - // === NULL Safety === - printf("\n--- NULL Safety ---\n"); - - test("at(nullptr) = -2", at(nullptr, 0) == -2); - test("front(nullptr) = -2", front(nullptr) == -2); - test("back(nullptr) = -1", back(nullptr) == -1); - test("begin(nullptr) = -1", begin(nullptr) == -1); - test("end(nullptr) = -1", end(nullptr) == -1); - - // === Memory Leak Check (basic) === - printf("\n--- Memory Leak Check ---\n"); - - for (int round = 0; round < 100; round++) { - vec = create(nullptr); - for (int i = 0; i < 50; i++) vec = add_back(&vec, (char)i); - delete(&vec); - } - test("100 create/delete cycles: no crash", 1); - - // === Double Delete === - printf("\n--- Double Delete Safety ---\n"); - - vec = create(nullptr); - vec = add_back(&vec, 'T'); - delete(&vec); - delete(&vec); // Should not crash - test("double delete: no crash", 1); - - // === Delete Then Access === - printf("\n--- Delete Then Access ---\n"); - - vec = create(nullptr); - vec = add_back(&vec, 'A'); - vec = add_back(&vec, 'B'); - delete(&vec); - test("after delete: at() returns error", at(&vec, 0) == -3); - test("after delete: front() returns error", front(&vec) == -3); - test("after delete: back() returns -3 (size still 2)", back(&vec) == -3); - - // === Extreme Values === - printf("\n--- Extreme Values ---\n"); - - vec = create(nullptr); - vec = add_back(&vec, 0); - vec = add_back(&vec, 127); - vec = add_back(&vec, -128); - test("extreme: zero preserved", vec.arr[0] == 0); - test("extreme: max char preserved", vec.arr[1] == 127); - test("extreme: min char preserved", vec.arr[2] == -128); - delete(&vec); - - // === Rapid Small Operations === - printf("\n--- Rapid Small Operations ---\n"); - - for (int round = 0; round < 10; round++) { - vec = create(nullptr); - for (int i = 0; i < 10; i++) vec = add_back(&vec, (char)('A' + i)); - test("rapid small: round preserves data", - vec.arr[0] == 'A' && vec.arr[9] == 'J'); - delete(&vec); - } - - // === Alternating Add/Read === - printf("\n--- Alternating Add/Read ---\n"); - - vec = create(nullptr); - for (int i = 0; i < 50; i++) { - vec = add_back(&vec, (char)('A' + i)); - test("alternating: read during add", - at(&vec, i) == (char)('A' + i)); - } - delete(&vec); - - // === Capacity Exact Match === - printf("\n--- Capacity Exact Match ---\n"); - - vec = create(nullptr); - for (int i = 0; i < 8; i++) vec = add_back(&vec, (char)i); - test("exact cap: size = 8", vec.size == 8); - test("exact cap: capacity = 8", vec.capacity == 8); - vec = add_back(&vec, 'X'); - test("exact cap +1: size = 9", vec.size == 9); - test("exact cap +1: capacity = 16", vec.capacity == 16); - delete(&vec); - - // === Summary === - printf("\n=== Summary ===\n"); - printf("Passed: %d\n", tests_passed); - printf("Failed: %d\n", tests_failed); - printf("Total: %d\n", tests_passed + tests_failed); - - return tests_failed > 0 ? 1 : 0; -} diff --git a/tests/stress_erase_test.c b/tests/stress_erase_test.c deleted file mode 100644 index 3b62fd3..0000000 --- a/tests/stress_erase_test.c +++ /dev/null @@ -1,156 +0,0 @@ -#include -#include -#include -#include - -#define CAPACITY 1024 -#define nullptr ((void*)0) - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -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; } -} - -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; -} - -// Exact copy of src/main.c single erase (lines 128-137) -__attribute__((overloadable)) Vec8_t* -erase(Vec8_t* vec, const int iter) { - if(vec == nullptr) return nullptr; - if(vec->arr == nullptr) return nullptr; - if(iter >= vec->size) return nullptr; - memmove(&vec->arr[iter], &vec->arr[iter + 1], (vec->size - iter - 1) * sizeof(char)); - vec->arr[vec->size - 1] = 0; - vec->size--; - return vec; -} - -// Exact copy of src/main.c range erase (lines 139-151) -__attribute__((overloadable)) Vec8_t* -erase(Vec8_t* vec, const int iter_start, const int iter_end) { - if(vec == nullptr) return nullptr; - if(vec->arr == nullptr) return nullptr; - if(iter_start < 0 || iter_end > vec->size) return nullptr; - int diff = iter_end - iter_start; - memmove(&vec->arr[iter_start], &vec->arr[iter_end], (vec->size - iter_end) * sizeof(char)); - for(size_t i = vec->size; i > iter_end; i--) { - vec->arr[i] = 0; // BUG: i starts at vec->size (out of bounds!) - } - vec->size -= diff; - return vec; -} - -void test_single_erase() { - printf("=== Testing Single Erase ===\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - printf("Before: "); - for (int i = 0; i < vec.size; i++) printf("%c ", vec.arr[i]); - printf("(size=%zu)\n", vec.size); - - erase(&vec, 2); // Erase 'c' - - printf("After erase(2): "); - for (int i = 0; i < vec.size; i++) printf("%c ", vec.arr[i]); - printf("(size=%zu)\n", vec.size); - - assert(vec.size == 9); - assert(vec.arr[0] == 'a'); - assert(vec.arr[1] == 'b'); - assert(vec.arr[2] == 'd'); // Shifted left correctly - printf("Single erase: PASS\n\n"); - delete(&vec); -} - -void test_single_erase_large() { - printf("=== Testing Single Erase (100k elements) ===\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 100000; i++) add_back(&vec, (char)(i % 256)); - - erase(&vec, 0); // Erase front - assert(vec.size == 99999); - assert(vec.arr[0] == 1); - - erase(&vec, 50000); // Erase middle - assert(vec.size == 99998); - assert(vec.arr[50000] == 2); // Shifted correctly - - printf("Large single erase: PASS\n\n"); - delete(&vec); -} - -void test_range_erase() { - printf("=== Testing Range Erase (exclusive end) ===\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - printf("Before: "); - for (int i = 0; i < vec.size; i++) printf("%c ", vec.arr[i]); - printf("(size=%zu)\n", vec.size); - - erase(&vec, 2, 4); // Erase [2,4) -> indices 2,3 ('c','d') - - printf("After erase(2,4): "); - for (int i = 0; i < vec.size; i++) printf("%c ", vec.arr[i]); - printf("(size=%zu)\n", vec.size); - - // Expected: a b e f g h i j (size=8) - assert(vec.size == 8); - assert(vec.arr[0] == 'a'); - assert(vec.arr[1] == 'b'); - assert(vec.arr[2] == 'e'); // Shifted correctly - - // Check zeroing bug (zeros wrong positions due to out-of-bounds access) - printf("Raw array: "); - for (int i = 0; i < 10; i++) printf("%c", vec.arr[i] == 0 ? '0' : vec.arr[i]); - printf("\n"); - - printf("Range erase: PASS (but zeroing loop has out-of-bounds bug)\n\n"); - delete(&vec); -} - -void test_range_erase_to_end() { - printf("=== Testing Range Erase to End ===\n"); - Vec8_t vec = create(nullptr); - for (int i = 0; i < 10; i++) add_back(&vec, 'a' + i); - - Vec8_t* res = erase(&vec, 2, 10); // Erase [2,10) -> indices 2-9 - assert(res != nullptr); - assert(vec.size == 2); - assert(vec.arr[0] == 'a'); - assert(vec.arr[1] == 'b'); - printf("Erase to end: PASS\n\n"); - delete(&vec); -} - -int main() { - test_single_erase(); - test_single_erase_large(); - test_range_erase(); - test_range_erase_to_end(); - printf("All tests completed.\n"); - return 0; -} diff --git a/tests/stress_full_test b/tests/stress_full_test deleted file mode 100755 index 2f69d4aa6c15db25337a93f72984c4458905a98d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33936 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 z -#include -#include -#include -#include - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -Vec8_t create(const Vec8_t* input) { - Vec8_t vec = { .arr = NULL, .size = 0, .capacity = 4 }; - if (input == NULL) { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (input->size > 0) { - vec.size = input->size + 1; - } - if (input->capacity >= vec.capacity) { - vec.capacity = 2 * input->capacity; - } - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; -} - -void delete(Vec8_t* vec) { - if (vec->arr != NULL) { - free(vec->arr); - } - vec->arr = NULL; -} - -Vec8_t add_back(Vec8_t* vec, const char val) { - Vec8_t ret = { .arr = NULL, .capacity = 0, .size = 0 }; - if (vec->size < vec->capacity) { - vec->arr[vec->size] = val; - vec->size++; - return *vec; - } - if (vec->size >= vec->capacity) { - Vec8_t nvec = create(vec); - if (nvec.arr == NULL) { - 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; - } - free(vec->arr); - return nvec; - } - return ret; -} - -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; -} - -void get_memory_usage(size_t* used, size_t* peak) { - struct rusage ru; - getrusage(RUSAGE_SELF, &ru); - *used = ru.ru_maxrss * 1024; - *peak = ru.ru_maxrss * 1024; -} - -int main() { - printf("=== FULL STRESS TEST: add_back only ===\n\n"); - - struct timespec start, end_t; - Vec8_t vec; - size_t max_elements = 0; - int crashed = 0; - - printf("=== TEST 1: MAX ELEMENTS BEFORE CRASH ===\n\n"); - - vec = create(NULL); - clock_gettime(CLOCK_MONOTONIC, &start); - - for (size_t i = 0; i < SIZE_MAX; i++) { - vec = add_back(&vec, (char)(i % 256)); - - if (vec.arr == NULL) { - max_elements = i; - crashed = 1; - break; - } - - if (i % 100000000 == 0) { - printf(" %zu elements: capacity %zu (%.2f GB)\n", - i + 1, vec.capacity, (double)(vec.capacity * sizeof(char)) / 1024 / 1024 / 1024); - } - - if (i >= 1000000000) { - printf(" stopping at 1 billion elements\n"); - max_elements = 1000000000; - break; - } - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - - if (!crashed && vec.arr != NULL) { - max_elements = vec.size; - } - - printf("\nRESULT: %zu elements\n", max_elements); - printf("capacity: %zu\n", vec.capacity); - printf("memory: %.2f GB\n", (double)(vec.capacity * sizeof(char)) / 1024 / 1024 / 1024); - printf("time: %.2f sec\n", time_diff(start, end_t)); - - delete(&vec); - - printf("\n=== TEST 2: DIRECT MALLOCATION LIMIT ===\n\n"); - - const size_t test_sizes[] = {1000000, 10000000, 100000000, 500000000, 1000000000}; - int num_tests = 5; - - for (int t = 0; t < num_tests; t++) { - size_t n = test_sizes[t]; - printf("Testing %zu elements (%.2f GB)...\n", - n, (double)(n * sizeof(char)) / 1024 / 1024 / 1024); - - char* test_arr = calloc(n, sizeof(char)); - if (test_arr == NULL) { - printf(" FAILED at %zu\n", n); - break; - } - printf(" SUCCESS\n"); - free(test_arr); - } - - printf("\n=== TEST 3: SINGLE VECTOR ALLOCATION ===\n\n"); - - size_t single_max = 0; - for (size_t n = 1000000; n <= 5000000000UL; n *= 2) { - printf("Trying %.2f GB allocation...\n", (double)(n * sizeof(char)) / 1024 / 1024 / 1024); - - Vec8_t test_vec = create(NULL); - Vec8_t* vp = calloc(1, sizeof(Vec8_t)); - - vp->arr = calloc(n, sizeof(char)); - if (vp->arr == NULL) { - printf(" FAILED at %.2f GB\n", (double)(n * sizeof(char)) / 1024 / 1024 / 1024); - single_max = n / 2; - free(vp); - break; - } - - printf(" SUCCESS: %.2f GB\n", (double)(n * sizeof(char)) / 1024 / 1024 / 1024); - free(vp->arr); - free(vp); - delete(&test_vec); - single_max = n; - } - - printf("\n=== TEST 4: SPEED AT SCALE ===\n\n"); - - vec = create(NULL); - clock_gettime(CLOCK_MONOTONIC, &start); - for (size_t i = 0; i < 10000000; i++) { - vec = add_back(&vec, (char)(i % 256)); - } - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t10m = time_diff(start, end_t); - - printf("10M elements:\n"); - printf(" time: %.2f sec\n", t10m); - printf(" rate: %.0f/sec\n", 10000000.0 / t10m); - printf(" memory: %.2f MB\n", (vec.capacity * sizeof(char)) / 1024.0 / 1024.0); - - delete(&vec); - - printf("\n=== SUMMARY ===\n\n"); - printf("Max elements (vector): %zu\n", max_elements); - printf("Single allocation max: %zu (%.2f GB)\n", - single_max, (double)(single_max * sizeof(char)) / 1024 / 1024 / 1024); - - return 0; -} \ No newline at end of file diff --git a/tests/stress_test b/tests/stress_test deleted file mode 100755 index 4f4c9bd6178cdf6954c59f458cc994d274420889..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 34168 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 Tdoh34`aP58B&;5BCYbqO`6*}V diff --git a/tests/stress_test.c b/tests/stress_test.c deleted file mode 100644 index ec642b9..0000000 --- a/tests/stress_test.c +++ /dev/null @@ -1,191 +0,0 @@ -#include -#include -#include -#include - -typedef struct { - char* arr; - size_t size; - size_t capacity; -} Vec8_t; - -Vec8_t create(Vec8_t* input) { - Vec8_t vec = { .arr = nullptr, .size = 0, .capacity = 4 }; - if(input == nullptr) { - vec.arr = calloc(vec.capacity, sizeof(char)); - return vec; - } - if (input->size > 0) { - vec.size = input->size + 1; - } - if (input->capacity >= vec.capacity) { - vec.capacity = 2 * input->capacity; - } - 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(Vec8_t* vec, 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; -} - -int begin(Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return 0; - return -1; -} - -int end(Vec8_t* vec) { - if (vec != nullptr && vec->arr != nullptr && vec->size > 0) return (int)(vec->size - 1); - return -1; -} - -char front(Vec8_t* vec) { - return at(vec, 0); -} - -char back(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 ret = { .arr = nullptr, .capacity = 0, .size = 0 }; - if (vec->size < vec->capacity) { - vec->arr[vec->size] = val; - vec->size++; - return *vec; - } - if (vec->size >= vec->capacity) { - Vec8_t nvec = create(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; - } - free(vec->arr); - return nvec; - } - return ret; -} - -int tests_passed = 0; -int tests_failed = 0; - -void test(const char* name, int passed) { - if (passed) { printf("[PASS] %s\n", name); tests_passed++; } - else { printf("[FAIL] %s\n", 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("=== Stress Testing libvec (doubling) ===\n\n"); - - struct timespec start, end_t; - Vec8_t vec; - - printf("--- Basic correctness ---\n"); - vec = create(nullptr); - test("create nullptr: capacity = 4", vec.capacity == 4); - test("create nullptr: size = 0", vec.size == 0); - - vec = add_back(&vec, 'a'); - test("add_back 1: size = 1", vec.size == 1); - test("add_back 1: capacity = 4", vec.capacity == 4); - - vec = add_back(&vec, 'b'); - test("add_back 2: size = 2", vec.size == 2); - - vec = add_back(&vec, 'c'); - test("add_back 3: size = 3", vec.size == 3); - - vec = add_back(&vec, 'd'); - test("add_back 4: size = 4", vec.size == 4); - - vec = add_back(&vec, 'e'); - test("add_back 5: capacity = 8 (doubled)", vec.capacity == 8); - test("add_back 5: arr[4] = 'e'", vec.arr[4] == 'e'); - delete(&vec); - - printf("\n--- NULL safety ---\n"); - test("at(nullptr) returns -2", at(nullptr, 0) == -2); - test("front(nullptr) returns -2", front(nullptr) == -2); - test("back(nullptr) returns -1", back(nullptr) == -1); - test("begin(nullptr) == -1", begin(nullptr) == -1); - test("end(nullptr) == -1", end(nullptr) == -1); - - printf("\n--- Capacity growth pattern ---\n"); - vec = create(nullptr); - size_t prev_cap = vec.capacity; - printf(" cap=%zu", vec.capacity); - for (int i = 1; i <= 100; i++) { - vec = add_back(&vec, (char)i); - if (vec.capacity != prev_cap) { - printf(" -> %zu (at size %d)", vec.capacity, i); - prev_cap = vec.capacity; - } - } - printf("\n"); - test("final capacity = 128", vec.capacity == 128); - delete(&vec); - - printf("\n--- 1M add_back ---\n"); - vec = create(nullptr); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 1000000; i++) vec = add_back(&vec, (char)i); - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t1 = time_diff(start, end_t); - printf(" Time: %.3f sec (%.0f/sec)\n", t1, 1000000.0/t1); - test("1M: size correct", vec.size == 1000000); - test("1M: data correct", vec.arr[0] == 0 && vec.arr[999999] == (char)999999); - delete(&vec); - - printf("\n--- 10M add_back ---\n"); - vec = create(nullptr); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 10000000; i++) vec = add_back(&vec, (char)i); - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t10 = time_diff(start, end_t); - printf(" Time: %.3f sec (%.0f/sec)\n", t10, 10000000.0/t10); - test("10M: size correct", vec.size == 10000000); - test("10M: data correct", vec.arr[0] == 0 && vec.arr[9999999] == (char)(9999999 % 256)); - delete(&vec); - - printf("\n--- 100M add_back ---\n"); - vec = create(nullptr); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 100000000; i++) vec = add_back(&vec, (char)i); - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t100 = time_diff(start, end_t); - printf(" Time: %.3f sec (%.0f/sec)\n", t100, 100000000.0/t100); - test("100M: size correct", vec.size == 100000000); - test("100M: data correct", vec.arr[0] == 0 && vec.arr[99999999] == (char)(99999999 % 256)); - delete(&vec); - - printf("\n--- 1B add_back ---\n"); - vec = create(nullptr); - clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < 1000000000; i++) vec = add_back(&vec, (char)i); - clock_gettime(CLOCK_MONOTONIC, &end_t); - double t1b = time_diff(start, end_t); - printf(" Time: %.3f sec (%.0f/sec)\n", t1b, 1000000000.0/t1b); - test("1B: size correct", vec.size == 1000000000); - test("1B: data correct", vec.arr[0] == 0 && vec.arr[999999999] == (char)(999999999 % 256)); - delete(&vec); - - printf("\n=== Summary ===\n"); - printf("Passed: %d, Failed: %d\n", tests_passed, tests_failed); - return tests_failed > 0 ? 1 : 0; -}