From 5e24c608c67c9df082826269ebfe67c156adce99 Mon Sep 17 00:00:00 2001 From: Tobias Busch Date: Tue, 2 Dec 2025 17:45:10 +0100 Subject: [PATCH] stackv2 --- makefile | 2 +- stack.c | 2 +- stack.o | Bin 0 -> 3216 bytes test_runner | Bin 0 -> 35128 bytes test_stack.c | 26 +++---- unittest.o | Bin 0 -> 7360 bytes unittest_stack.c | 197 +++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 212 insertions(+), 15 deletions(-) create mode 100644 stack.o create mode 100755 test_runner create mode 100644 unittest.o create mode 100644 unittest_stack.c diff --git a/makefile b/makefile index b792156..7bfefea 100644 --- a/makefile +++ b/makefile @@ -1,4 +1,4 @@ -```CC = gcc +CC = gcc FLAGS = -g -Wall -lm ifeq ($(OS),Windows_NT) diff --git a/stack.c b/stack.c index 4fabf41..d0105c7 100644 --- a/stack.c +++ b/stack.c @@ -10,7 +10,7 @@ // Pushes data as pointer onto the stack. StackNode *push(StackNode *stack, void *data) // es gibt bereits ein stack element, dieses wird übergeben + die daten, die in den stack müssen { - if(!stack || !data) + if(!data) return 0; StackNode *newNode = calloc(1, sizeof(StackNode)); //Speicher reserviert für data und prev, jeweils nur zeiger diff --git a/stack.o b/stack.o new file mode 100644 index 0000000000000000000000000000000000000000..07999dfb5582d8727e6110e35f0c69c8ec3baf59 GIT binary patch literal 3216 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 R_GR8leb4v$jL7X3{{c_u8|nZ6 literal 0 HcmV?d00001 diff --git a/test_stack.c b/test_stack.c index aaa0bd6..5ebf42f 100644 --- a/test_stack.c +++ b/test_stack.c @@ -9,9 +9,9 @@ void test_pushFailsOnNullPointer(StackNode *stack, void *data) { if (test != 0) { printf("Pass test_pushFailsOnNullPointerStack\n"); } else - printf("Did Not Pass test_pushFailsOnNullPointerStack EXPECTED Stac Node\n"); + printf("Did Not Pass test_pushFailsOnNullPointerStack EXPECTED StackNode\n"); - StackNode* test = push(stack, NULL); + test = push(stack, NULL); if (test == 0) { printf("Pass test_pushFailsOnNullPointerData\n"); return; @@ -24,35 +24,35 @@ void test_popFailsOnNullPointer() { StackNode* test = pop(NULL); if (test == 0) { - printf("Pass test_pushFailsOnNullPointerStack\n"); + printf("Pass test_popFailsOnNullPointerStack\n"); return; } - printf("Did Not Pass test_pushFailsOnNullPointerStack EXPECTED 0\n"); + printf("Did Not Pass test_popFailsOnNullPointerStack EXPECTED 0\n"); return; } void test_topFailsOnNullPointer() { - int* test = top(NULL); + int* test = (int*)top(NULL); if (test == 0) { - printf("Pass test_pushFailsOnNullPointerStack\n"); + printf("Pass test_topFailsOnNullPointerStack\n"); return; } - printf("Did Not Pass test_pushFailsOnNullPointerStack EXPECTED 0\n"); + printf("Did Not Pass test_topFailsOnNullPointerStack EXPECTED 0\n"); return; } int main() { - StackNode *stack0 = NULL; + int test0 = 3; int* dataTest0 = &test0; - stack0->data = dataTest0; + StackNode *stack0 = push(NULL, dataTest0); char test1[5] = "test\0"; - char* dataTest1 = &test1; + char* dataTest1 = test1; float test2 = 3.14; float* dataTest2 = &test2; @@ -72,7 +72,7 @@ int main() if(stack2->data == dataTest2) { printf("Pass test_pushFloat\n"); } else - printf("Fails test_pushFloat\n expected: %f\n was: %d\n", dataTest2, stack2->data); + printf("Fails test_pushFloat\n expected: %f\n was: %f\n", dataTest2, *(float*)(stack2->data)); int array[10] = {1,2,3,4,5,6,7,8,9,10}; @@ -80,8 +80,8 @@ int main() stack2 = push(stack2, &array[i]); } for(size_t i = 0; i<10; i++) { - int* data = top(stack2); - printf("%d\n", data); + int* data = (int*)top(stack2); + printf("%d\n", *data); stack2 = pop(stack2); } diff --git a/unittest.o b/unittest.o new file mode 100644 index 0000000000000000000000000000000000000000..5f18b3be5cd98e117a1b715a83586b26722cad69 GIT binary patch literal 7360 zcmcIpeQaCR6+iFU&v9(WcIviiNt?JVp=q_mNeDCr3`v`oe7J3tWNR2O*R`G2tG}=v zXrWTGrqe2|(1wqy8xo5Vf^;xIFt)O^qZ36!6O4lPfhHz3;tx_7urahXgRc9X_wKV} zH-+x&M#sN%&pqed^X}()FK_(g!++X{BtqdIBWOSWxIrk3L1wOBqMRz%8YYB}UN3=| z3BJ|h_h-U8Gok|U`v=wy4&>`PH)7B@_9uf)E+ksRA|s73=*903rZcHXe47vy`_uj0 z#!gV`%o^&yLabL2PcRWr=L0PE_l}~e)(MM!7A?MX)utPWd?ycLD3`@Sl0y(imJR`V#z=-;~$RS6^V!ZeqV+=zf#KUY-{JaywpG#Qvx-`d~@FzmPq(47Ta?$#m6ysGYjDup(G_UG!fxl*m zFtnntE5LwISc&Dmh{MfTi9HLSy!?7WT;>bn=Vslatq94NmkTe`o9FM5kDec;vGLLB zb5mBDnXj%%2(9Cp6+svy(KSB50}TJGzjST56F`%(D$|M+`ZMtl~Gn>>bbKV+8LW|$^0hA+Lm za+dQ z>gnYebC)z0Ird0jY3W4DEiJD)b2FWot|rV&e*DKrZxw#&L7opLmQ5|^`NP~*!cQf5 z#HGtl5?xa~7g$sC--iwB@-v(@a9lJ~rxfkR3}+#mfQ?jI`aSj85nE1Ip|NS$esbYL#RZ3uJ2W4A<-8Bo4(op!>mTFrB9B8I z$2TiB?yJB*`(gj^`vLqP#rmJU9(YW)H$y)h9ATjQxQ%dq;jdY)}#WyXWn3`^N$SD{XsVU~s1v@{DQAsZdzGA3H2dXp)}+Z+%Gnb6XKa0goHggI zZzlP5madhvrFrQ>lHX!i> zMT%LdLK836#7<3YrLSn>+Gg&(th^IOQp`pk?$#=gb-Jioux<0{YSywE#*Xb-KrQUZ zYB+eB7Sgrf*7#Scf>zzD@u!dyt>&1~LF;0=?s|=Fyn@Vdme}XFY63iNzZx}G4ZjUJLij0{>`tdsvX?6D8IC5B;gn}>A{Gn8Lq25Y1Bpa5?dk96NqaT~f}8pW8`7a2G>i3o zEsg#>nZ(uzJfwHvT=&ERk+?g(D<1UpXNE(O;h3i@83=j0nmxU#z>Z902PExRcODfOzMD8?qa4mZf6SNI;AAP(5g2P|1_$?0hLp28r8O@oVZD?H|Ofjn(HPFnkkS< z1$I${(viEv{tO;A6iDHX$}j4}@pNQcJREXI6L{Hw3M&UIlK2ed@`OO7Kx%P_cdJf; zae+?=d|jYbEY&`N+XWsL_@uzM1!~@j_(o&pG#m@MAKG2{$U9xO`j;#ZPu<~o;FHspPp*G>cj~97XLvjE*5fV6+vZ)=dE4<; z<*mtEl(#BxC*G30y}0nb%&*FLomJoEs(>}1l^}kAYe6@F)_^)eQjNi7#3d*NPRh->Q zsj0`*Z5maSNu{($DgRWlL2k*(Cl$pvsYuoyg^nu~mQNL@si5un>^94sZ6}mci(E5b zv5YD;J<4L}IMIXYxMDSX_bIl&q6cN!q_P4HO1G(}N2&5DSD~^PirtFC)PqpFm8IQ^ zxtqIIL+$8MHbJ-cicw%u@$Oft#vMq)|VIw+*v2tD#v5J3B&z&LXe~Vxh_GRpx<5%&O^nHZ}E{ zta8mf*@oHwU*8E0|H&og8BV7>k$5mV9142^sn~z*BfTr_@n?1=@indB0@W_k?WDCe zfYAZ}dy*6MqJ-_G{?fBIJCY;OzAcYUphRvcEdfUIWDW=5uT4@+E3b+t>49NEUQ3~%czGpS`?grxQ_U+Wr z%iqk{PbZMag-P5R$Jr*(EfAo}9}svelk{ z%W|Xs27HUh*~lN#=1#t~w&a{SyJ(y9100+tlH`XWPTWi?7z3(_JmOH#WPfn`4*w87 z+(8K*@QZ(+WrmP&&uZT`97u%_JBQh@T4!2yW|hudt25W=ObbObvE +#include +#include "stack.h" +#include "unity.h" + + +void test_createMatrixFailsOnZeroDimensions(void) +{ + Matrix matrixToTest1 = createMatrix(0, 1); + Matrix matrixToTest2 = createMatrix(1, 0); + TEST_ASSERT_NULL(matrixToTest1.buffer); + TEST_ASSERT_EQUAL_UINT32(0, matrixToTest1.rows); + TEST_ASSERT_EQUAL_UINT32(0, matrixToTest1.cols); + TEST_ASSERT_NULL(matrixToTest2.buffer); + TEST_ASSERT_EQUAL_UINT32(0, matrixToTest2.rows); + TEST_ASSERT_EQUAL_UINT32(0, matrixToTest2.cols); +} + +void test_createMatrixReturnsCorrectMatrixDimensions(void) +{ + const unsigned int expectedRows = 15; + const unsigned int expectedCols = 10; + + Matrix matrixToTest = createMatrix(expectedRows, expectedCols); + TEST_ASSERT_EQUAL_UINT32(expectedRows, matrixToTest.rows); + TEST_ASSERT_EQUAL_UINT32(expectedCols, matrixToTest.cols); + free(matrixToTest.buffer); +} + +void test_clearMatrixSetsMembersToNull(void) +{ + Matrix matrixToTest = createMatrix(10, 10); + clearMatrix(&matrixToTest); + TEST_ASSERT_NULL(matrixToTest.buffer); + TEST_ASSERT_EQUAL_UINT32(0, matrixToTest.rows); + TEST_ASSERT_EQUAL_UINT32(0, matrixToTest.cols); +} + +void test_addReturnsCorrectResult(void) +{ + MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; + MatrixType buffer2[] = {7, 8, 9, 10, 11, 12}; + Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1}; + Matrix matrix2 = {.rows=2, .cols=3, .buffer=buffer2}; + + Matrix result = add(matrix1, matrix2); + + float expectedResults[] = {8, 10, 12, 14, 16, 18}; + + TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result.rows); + TEST_ASSERT_EQUAL_UINT32(matrix2.rows, result.rows); + TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result.cols); + TEST_ASSERT_EQUAL_UINT32(matrix2.cols, result.cols); + TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result.rows * result.cols); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result.buffer, result.cols * result.rows); + free(result.buffer); +} + +void test_addFailsOnDifferentInputDimensions(void) +{ + MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; + MatrixType buffer2[] = {7, 8, 9, 10, 11, 12}; + Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1}; + Matrix matrix2 = {.rows=3, .cols=2, .buffer=buffer2}; + + Matrix result = add(matrix1, matrix2); + + TEST_ASSERT_NULL(result.buffer); + TEST_ASSERT_EQUAL_UINT32(0, result.rows); + TEST_ASSERT_EQUAL_UINT32(0, result.cols); +} + +void test_addSupportsBroadcasting(void) +{ + MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; + MatrixType buffer2[] = {7, 8}; + Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1}; + Matrix matrix2 = {.rows=2, .cols=1, .buffer=buffer2}; + + Matrix result1 = add(matrix1, matrix2); + Matrix result2 = add(matrix2, matrix1); + + float expectedResults[] = {8, 9, 10, 12, 13, 14}; + + TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result1.rows); + TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result1.cols); + TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result2.rows); + TEST_ASSERT_EQUAL_UINT32(matrix1.cols, result2.cols); + + TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result1.rows * result1.cols); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result1.buffer, result1.cols * result1.rows); + TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result2.rows * result2.cols); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result2.buffer, result2.cols * result2.rows); + + free(result1.buffer); + free(result2.buffer); +} + +void test_multiplyReturnsCorrectResults(void) +{ + MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; + MatrixType buffer2[] = {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}; + Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1}; + Matrix matrix2 = {.rows=3, .cols=4, .buffer=buffer2}; + + Matrix result = multiply(matrix1, matrix2); + + float expectedResults[] = {74, 80, 86, 92, 173, 188, 203, 218}; + + TEST_ASSERT_EQUAL_UINT32(matrix1.rows, result.rows); + TEST_ASSERT_EQUAL_UINT32(matrix2.cols, result.cols); + TEST_ASSERT_EQUAL_INT(sizeof(expectedResults)/sizeof(expectedResults[0]), result.rows * result.cols); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, result.buffer, result.cols * result.rows); + + free(result.buffer); +} + +void test_multiplyFailsOnWrongInputDimensions(void) +{ + MatrixType buffer1[] = {1, 2, 3, 4, 5, 6}; + MatrixType buffer2[] = {7, 8, 9, 10, 11, 12}; + Matrix matrix1 = {.rows=2, .cols=3, .buffer=buffer1}; + Matrix matrix2 = {.rows=2, .cols=3, .buffer=buffer2}; + + Matrix result = multiply(matrix1, matrix2); + + TEST_ASSERT_NULL(result.buffer); + TEST_ASSERT_EQUAL_UINT32(0, result.rows); + TEST_ASSERT_EQUAL_UINT32(0, result.cols); +} + +void test_getMatrixAtReturnsCorrectResult(void) +{ + MatrixType buffer[] = {1, 2, 3, 4, 5, 6}; + Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer}; + int expectedResult = buffer[4]; + + TEST_ASSERT_EQUAL_INT(expectedResult, getMatrixAt(matrixToTest, 1, 1)); +} + +void test_getMatrixAtFailsOnIndicesOutOfRange(void) +{ + MatrixType buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer}; + + TEST_ASSERT_EQUAL_INT(UNDEFINED_MATRIX_VALUE, getMatrixAt(matrixToTest, 2, 3)); +} + +void test_setMatrixAtSetsCorrectValue(void) +{ + const int expectedResult = -1; + MatrixType buffer[] = {1, 2, 3, 4, 5, 6}; + Matrix matrixUnderTest = {.rows=2, .cols=3, .buffer=buffer}; + + setMatrixAt(expectedResult, matrixUnderTest, 1, 2); + TEST_ASSERT_EQUAL_INT(expectedResult, buffer[5]); +} + +void test_setMatrixAtFailsOnIndicesOutOfRange(void) +{ + const float expectedResults[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + MatrixType buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + Matrix matrixToTest = {.rows=2, .cols=3, .buffer=buffer}; + + setMatrixAt(-1, matrixToTest, 2, 3); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(expectedResults, matrixToTest.buffer, sizeof(buffer)/sizeof(MatrixType)); +} + +void setUp(void) { + // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden +} + +void tearDown(void) { + // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden +} + +int main() +{ + UNITY_BEGIN(); + + printf("============================\nMatrix tests\n============================\n"); + RUN_TEST(test_createMatrixReturnsCorrectMatrixDimensions); + RUN_TEST(test_createMatrixFailsOnZeroDimensions); + RUN_TEST(test_clearMatrixSetsMembersToNull); + RUN_TEST(test_addReturnsCorrectResult); + RUN_TEST(test_addFailsOnDifferentInputDimensions); + RUN_TEST(test_addSupportsBroadcasting); + RUN_TEST(test_multiplyReturnsCorrectResults); + RUN_TEST(test_multiplyFailsOnWrongInputDimensions); + RUN_TEST(test_getMatrixAtReturnsCorrectResult); + RUN_TEST(test_getMatrixAtFailsOnIndicesOutOfRange); + RUN_TEST(test_setMatrixAtSetsCorrectValue); + RUN_TEST(test_setMatrixAtFailsOnIndicesOutOfRange); + + return UNITY_END(); +} \ No newline at end of file