Merge branch 'dev'

src/main/c/Jason/ASCII_art.c

@@ -5,13 +5,14 @@ int ASCII_Art(){
 
     int weitermachen = 0;
     do {
-        printWelcomeMessage();
+        Willkommensnachricht();
+
         int auswahl;
         scanf("%d", &auswahl);
         auswahlDerArt(auswahl);
 
 
-        printf("Vielen Dank, dass sie sich ASCII-Art angesehen haben\n"
+        printf("\nVielen Dank, dass sie sich ASCII-Art angesehen haben\n"
                "Wollen Sie weitere ASCII-Art sehen?\n"
                "(1) Ja\n"
                "(2) Nein\n"
@@ -25,39 +26,39 @@ int ASCII_Art(){
 void quadrat(){
 
     frageNachGroesse();
-    int groesse;
-    scanf("%d", &groesse);
-    int arraySize = berechnungDerLaengeDesQuadratArrays(groesse);
+    int LaengeDerZeilen;
+    scanf("%d", &LaengeDerZeilen);
+    int arraySize = berechnungDerLaengeDesQuadratArrays(LaengeDerZeilen);
     char Quadrat[arraySize];
     befuellenDesArraysMitX(Quadrat, arraySize);
-    befuelleArrayMitLeerzeichen(Quadrat, arraySize);
-    befuelleArrayMitZeilenumbruechen(Quadrat,groesse);
+    befuelleDasArrayMitLeerzeichen(Quadrat, arraySize);
+    befuelleDasArrayMitZeilenumbruechen(Quadrat,LaengeDerZeilen);
 
     printf("\n%s", Quadrat);
 
 }
 
-void weihnachtsbaum(){
+void Weihnachtsbaum(){
 
     abfrageDerHoehe();
-    int hoehe;
+    int hoeheVomBaumInklusiveStamm;
     do{
         // Diese Schleifen erfragen user input solange bis korrekte Werte eingegeben werden
 
-        scanf("%d", &hoehe);
-        if (hoehe < 3){
+        scanf("%d", &hoeheVomBaumInklusiveStamm);
+        if (hoeheVomBaumInklusiveStamm < 3){
             printf("\nDer Weihnachtsbaum muss mindestens 3 Zeilen groß sein!\n");
             printf("Bitte geben Sie erneut einen Wert ein der mindestens 3 lautet:");
         }
-    }while(hoehe < 3);
+    }while(hoeheVomBaumInklusiveStamm < 3);
 
-    int maxBreiteDesWeihnachtsbaums = max_breite(hoehe);
+    int maxBreiteDesWeihnachtsbaums = max_breiteDesBaums(hoeheVomBaumInklusiveStamm);
     int mitte_baum = mitteDesBaums(maxBreiteDesWeihnachtsbaums);
-    int groesseDesArrays = (hoehe -1) * maxBreiteDesWeihnachtsbaums;
+    int groesseDesArrays = (hoeheVomBaumInklusiveStamm -1) * maxBreiteDesWeihnachtsbaums;
     char weihnachtsbaum[groesseDesArrays];
     befuellenDesWeihnachtsbaumsMitLeerzeichen(weihnachtsbaum, groesseDesArrays);
-    befuellenDesWeihnachtsbaumsMitPlus(weihnachtsbaum, maxBreiteDesWeihnachtsbaums, (hoehe-1));
-    befuellenDesWeihnachtsbaumsMitZeilenumbruechen(weihnachtsbaum, hoehe, maxBreiteDesWeihnachtsbaums);
+    befuellenDesWeihnachtsbaumsMitPlus(weihnachtsbaum, maxBreiteDesWeihnachtsbaums, (hoeheVomBaumInklusiveStamm-1));
+    befuellenDesWeihnachtsbaumsMitZeilenumbruechen(weihnachtsbaum, hoeheVomBaumInklusiveStamm, maxBreiteDesWeihnachtsbaums);
     char stamm[maxBreiteDesWeihnachtsbaums];
     befuellenDesStammarraysMitLeerzeichen(stamm, maxBreiteDesWeihnachtsbaums);
     stammAnRichtigerStelleEinsetzen(stamm, maxBreiteDesWeihnachtsbaums);
@@ -70,37 +71,41 @@ void weihnachtsbaum(){
 
 void dreieck(){
     dreieckWillkommensnachricht();
-    int hoehe;
+    int hoeheDreieck;
+
+    // Eingabe Auf Definitions
     do{
-        scanf("%d", &hoehe);
-        if(hoehe < 2){
+        scanf("%d", &hoeheDreieck);
+        if(hoeheDreieck < 2){
             printf("Es wurde ein Wert eingegeben, der kleiner ist als 2. Bitte geben Sie erneut eine Zahl ein!\n"
                    "Eingbe:");
         }
-    } while(hoehe < 2);
+    } while(hoeheDreieck < 2);
 
-    int arraygroesse = berechnungDerDreieckArraygroesse(hoehe);
+    int arraygroesse = berechnungDerDreieckArraygroesse(hoeheDreieck);
     char dreieck[arraygroesse];
     befuellenDesDreiecksMitX(dreieck, arraygroesse);
-    befuellenDesDreiecksMitZeilenumbruechen(dreieck, hoehe, arraygroesse);
+    befuellenDesDreiecksMitZeilenumbruechen(dreieck, hoeheDreieck, arraygroesse);
     printf("%s", dreieck);
 
 }
 
 void rakete(){
     raketeBegruessung();
-    int hoehe;
+    int hoeheRakete;
     do{
-        scanf("%d", &hoehe);
-        if(hoehe < 3){
+        scanf("%d", &hoeheRakete);
+        if(hoeheRakete < 3){
             printf("Es wurde ein Wert eingegeben, der kleiner ist als 3. Bitte geben Sie erneut eine Zahl ein!\n"
                    "Eingbe:");
         }
-    } while(hoehe < 3);
+    } while(hoeheRakete < 3);
+
+    printf("\nComing soon ;)\n");
 }
 
 
-int printWelcomeMessage(){
+int Willkommensnachricht(){
     printf("Willkommen bei ASCII-Art!\n");
     printf("Wählen Sie aus welche ASCII-Art Sie sehen wollen!\n");
     printf("(1) Quadrat\n");
@@ -117,7 +122,7 @@ void auswahlDerArt(int pick){
             quadrat();
             break;
         case (2):
-            weihnachtsbaum();
+            Weihnachtsbaum();
             break;
 
         case (3):
@@ -156,7 +161,7 @@ void befuellenDesArraysMitX(char quadraT[], int laenge){
 
 }
 
-void befuelleArrayMitLeerzeichen(char quadraT[], int laenge){
+void befuelleDasArrayMitLeerzeichen(char quadraT[], int laenge){
 
 
     for (int i = 0; i < laenge; i++){
@@ -164,10 +169,12 @@ void befuelleArrayMitLeerzeichen(char quadraT[], int laenge){
             quadraT[i] = ' ';
         }
     }
+
+    // Das \0 muss Extra platziert werden um einen korrekten Ablauf sicherzustellen
     quadraT[laenge-1] = '\0';
 }
 
-void befuelleArrayMitZeilenumbruechen(char quadraT[], int laenge){
+void befuelleDasArrayMitZeilenumbruechen(char quadraT[], int laenge){
 
     int zeile = 2 * laenge;
     int laengeGesamt = zeile * laenge;
@@ -186,7 +193,7 @@ int abfrageDerHoehe(){
     return 0;
 }
 
-int max_breite(int zeilen){
+int max_breiteDesBaums(int zeilen){
 
     int maximaleBreiteEinerZeile;
     maximaleBreiteEinerZeile = zeilen + (zeilen - 2);
@@ -211,18 +218,18 @@ void befuellenDesWeihnachtsbaumsMitPlus(char arr[], int maxBreite, int zeilen){
 
     int arrayGroesse = maxBreite * zeilen;
     int mitteDesBaums = maxBreite / 2;
-    int mengeX = 1;
+    int mengeDerXInDerZeile = 1;
 
     for(int i = zeilen; i > 0; i--){
 
         int position = mitteDesBaums -1;
 
-         while(position < mitteDesBaums-1 + mengeX){
+         while(position < mitteDesBaums-1 + mengeDerXInDerZeile){
              arr[position++] = '+';
          }
 
         mitteDesBaums += (maxBreite -1);
-         mengeX += 2;
+         mengeDerXInDerZeile += 2;
     }
     arr[arrayGroesse] = '\0';
 }
@@ -305,7 +312,7 @@ void befuellenDesDreiecksMitZeilenumbruechen(char arr[], int gesamtzeilen, int a
         stelleFuerZeilenumbruch += (zeile+2);
 
     }
-    arr[arraygroesse] = '\0';
+    arr[arraygroesse -1] = '\0';
 }
 
 void raketeBegruessung(){

src/main/c/Jason/ASCII_art.h

@@ -2,17 +2,17 @@
 #define ASCII_ART_H
 
 int ASCII_Art();
-int printWelcomeMessage();
+int Willkommensnachricht();
 void auswahlDerArt(int);
 void quadrat();
 int frageNachGroesse();
 int berechnungDerLaengeDesQuadratArrays(int);
 void befuellenDesArraysMitX(char[], int);
-void befuelleArrayMitLeerzeichen(char[],int);
-void befuelleArrayMitZeilenumbruechen(char[],int);
-void weihnachtsbaum();
+void befuelleDasArrayMitLeerzeichen(char[],int);
+void befuelleDasArrayMitZeilenumbruechen(char[],int);
+void Weihnachtsbaum();
 int abfrageDerHoehe();
-int max_breite(int);
+int max_breiteDesBaums(int);
 int mitteDesBaums(int);
 void befuellenDesWeihnachtsbaumsMitLeerzeichen(char[],int);
 void befuellenDesWeihnachtsbaumsMitPlus(char[], int, int);

src/test/c/Jason/test_ASCII_art.c

@@ -9,12 +9,12 @@ void tearDown(void){
 
 }
 
-void test_doesWelcomeMessageWork() {
+void test_funktioniertDieWillkommensnachricht() {
     //arrange
     int expectedResult = 0;
 
     //act
-    int actualResult = printWelcomeMessage();
+    int actualResult = Willkommensnachricht();
     //assert
 
     TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
@@ -46,6 +46,8 @@ void test_stringAbgleich(void){
     // arrange
     char expectedMessage[] = "XXXXXXX";
 
+    // Dieser Test überprüft, ob das Feld für die Baumkrone korrekt mit X befüllt wird
+
     // act
     char message[9];
     befuellenDesArraysMitX(message, 8);
@@ -59,10 +61,12 @@ void test_stringAbgleichMitLeerzeichen(void){
     // arrange
     char expectedMessage[] = "X X X X X X X X X";
 
+    // Hier wird überprüft ob die Baumkrone wie erwartet mit X und Leerzeichen befüllt wird
+
     // act
     char message[19];
     befuellenDesArraysMitX(message, 18);
-    befuelleArrayMitLeerzeichen(message, 18);
+    befuelleDasArrayMitLeerzeichen(message, 18);
 
 
     // assert
@@ -76,8 +80,8 @@ void test_stringAbgleichMitLeerzeichenUndZeilenumbruch(void){
     // act
     char message[19];
     befuellenDesArraysMitX(message, 18);
-    befuelleArrayMitLeerzeichen(message, 18);
-    befuelleArrayMitZeilenumbruechen(message, 3);
+    befuelleDasArrayMitLeerzeichen(message, 18);
+    befuelleDasArrayMitZeilenumbruechen(message, 3);
 
 
     // assert
@@ -95,13 +99,84 @@ void test_erscheintDieAbfrageFuerWeihnachtsbaum() {
     TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
 }
 
-void test_korrekteBerechnungAufMaximaleBreiteWeihnachtsbaum() {
+void test_korrekteBerechnungAufMaximaleBreiteDesWeihnachtsbaums() {
     //arrange
     int expectedResult = 10;
 
     //act
-    int actualResult = max_breite(6);
+    int actualResult = max_breiteDesBaums(6);
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_korrekteBerechnungAufMaximaleGroesseDesDreiecks() {
+    //arrange
+    int expectedResult = 65;
+
+    //act
+    int actualResult = berechnungDerDreieckArraygroesse(10);
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_korrekteBerechnungAufMaximaleGroesseDesDreiecksBeiGrossenZahlen() {
+    //arrange
+    int expectedResult = 50015000;
+
+    // Hier sollte auf overflow überprüft werden bei großen Zahlen
+
+    //act
+    int actualResult = berechnungDerDreieckArraygroesse(10000);
     //assert
 
     TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_wirdKleinesDreieckKorrektBefuellt(void){
+    // arrange
+    char expectedMessage[] = "X\nXX";
+
+
+    // act
+    char message[6];
+
+    befuellenDesDreiecksMitX(message, 5);
+    befuellenDesDreiecksMitZeilenumbruechen(message, 2, 5);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}
+
+void test_wirdKleinesBaumkroneKorrektBefuelld(void){
+    // arrange
+    char expectedMessage[] = " + \n+++";
+
+    // act
+    char message[9];
+
+    befuellenDesWeihnachtsbaumsMitLeerzeichen(message, 8);
+    befuellenDesWeihnachtsbaumsMitPlus(message, 4, (3-1));
+    befuellenDesWeihnachtsbaumsMitZeilenumbruechen(message, 3, 4);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}
+
+void test_wirdBaumstammAnRichtigerStelleEingesetzt(void){
+    // arrange
+    char expectedMessage[] = "  +  ";
+
+    // act
+    char message[7];
+
+    befuellenDesStammarraysMitLeerzeichen(message, 6);
+    stammAnRichtigerStelleEinsetzen(message, 6);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
 }