Merge branch 'dev'

11 months ago · 4c4002ad7f
3 changed files with 129 additions and 47 deletions
--- a/src/main/c/Jason/ASCII_art.c
+++ b/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(){
--- a/src/main/c/Jason/ASCII_art.h
+++ b/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);
--- a/src/test/c/Jason/test_ASCII_art.c
+++ b/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);
 }