added missing testcases

2021-oop1/ku/exercise_fraction/README.md

@@ -2,17 +2,17 @@
 
 Ziel dieses Übungsbeispiels ist es, Operator-Overloading und Exception-Handling in einem kurzen Programm zu implementieren.
 
-### Aber um was geht es denn?
+### Aber worum geht es denn?
 
 Es soll eine Klasse `Fraction`, die einen Bruch - also eine rationale Zahl - darstellt, erstellt werden. Nach fertiger Implementierung soll mit dieser Klasse wie mit gewöhnlichen `int` oder `double` mit den Operatoren `+`, `*`, `==` ... gerechnet werden können.
 
-Beim Rechnen mit Brüchen ist außerdem zu beachten, dass der Nenner nie `0` werden darf. Insbesondere beim Erstellen eines neues Bruchs, aber auch beispielsweise beim Dividieren könnte es hier zu einem Problem kommen. Dafür soll eine eigene Exception `NullDivisionException` implementiert werden.
+Beim Rechnen mit Brüchen ist außerdem zu beachten, dass der Nenner nie `0` werden darf. Insbesondere beim Erstellen eines neuen Bruchs, aber auch beispielsweise beim Dividieren könnte es hier zu einem Problem kommen. Dafür soll eine eigene Exception `NullDivisionException` implementiert werden.
 
 ## Klasse Fraction
 
 Die Klasse `Fraction` soll genau einen Bruch darstellen. Dafür werden zwei Attribute benötigt, nämlich ein Zähler (`nominator_`) und ein Nenner (`denominator_`).
 
-Ein Bruch soll intern nach jeder Operation immer in gekürzter Form gespeichert sein und der Nenner soll immer positiv sein. Beispielsweise `5/-15` soll als `-1/3` gespeichert werden.
+Ein Bruch soll intern nach jeder Operation immer in gekürzter Form gespeichert sein und der Nenner soll immer positiv sein. Beispielsweise `5/-15` soll als `-1/3` gespeichert werden. Falls der Bruch den Wert `0` annimmt, soll der Nenner den Wert `1` besitzen.
 
 ### Konstruktoren
 
@@ -61,36 +61,34 @@ Folgende Operationen sollten auf jeden Fall implementiert werden, wobei der Copy
 
 - `b1 = b2 + b3`
   - `b2` und `b3` werden zusammenaddiert, ändern sich aber nicht
-
+- `b1 = b2 += b3`
+  - `b3` wird direkt auf `b2` addiert
+  - das Ergebnis kann an `b1` zugewiesen werden
 - `b1 = b2 + a`
   - `b2` und `a` werden zusammenaddiert, ändern sich aber nicht (`a` ist ein `int`!)
-
 - `b1 = a + b3`
   - `a` und `b3` werden zusammenaddiert, ändern sich aber nicht (`a` ist ein `int`!)
-
-- `b1 = b2 += b3`
-  - `b3` wird direkt auf `b2` addiert
-  - das Ergebnis kann an `b1` zugewiesen werden
-
 - `b1 = b2++`
   - post-increment
   - in `b1` wird der alte Wert von `b2` geschrieben
   - anschließend wird `b2` um den Wert `1` erhöht
-
 - `b1 = ++b2`
   - pre-increment
   - `b2` wird um den Wert `1` erhöht 
   - das Ergebnis wird in `b1` geschrieben
-
 - `b1 = -b2`
   - `b1` wird das Negative von `b2` zugewiesen
   - `b2` bleibt unverändert
-
 - `b1 = ~b2` (bitweiser Operator)
   - `b1` wird der Kehrwert von `b2` zugewiesen
     - der Nenner soll weiterhin positiv sein
     - `NullDivisionException` falls der Nenner `0` ist
   - `b2` bleibt unverändert
+- `b1 = b2 /= b3`
+  - `b2` wird durch `b3` durchdividiert
+  - `NullDivisionException` falls durch `0` dividiert wird
+    - in diesem Fall soll der `NullDivisionException` kein Parameter übergeben werden
+  - das Ergebnis kann an `b1` zugewiesen werden 
 
 Alle weiteren arithmetischen Operatoren, wie beispielsweise `-`, `-=`, `--`, `*`, `/`... können analog implementiert werden.
 
@@ -101,19 +99,14 @@ Folgende Operatoren sollten auf jeden Fall implementiert werden. `b1`, `b2` sind
 - `b1`
   - ist genau dann `false` sein, wenn der Bruch den Wert `0` besitzt
   - **Wichtig! `int a = b1;` darf nicht gültig sein bzw. kompilieren. Daher ist das Schlüsselwort `explicit` zu verwenden.**
-
 - `!b1`
   - ist genau dann `true` sein, wenn der Bruch den Wert `0` besitzt
-
 - `b1 == b2`
   - ist genau dann `true`, falls `b1` und `b2` denselben Wert besitzen
-
 - `b1 != b2`
   - ist genau dann `true`, falls `b1` und `b2` verschiedene Werte besitzen
-
 - `b1 < b2`
   - ist genau dann `true`, falls `b1` echt kleiner als `b2` ist
-
 - `b1 <= b2`
   - ist genau dann `true`, falls `b1 < b2` oder `b1 == b2`
 
@@ -125,7 +118,7 @@ Diese Klasse stellt eine Exception dar und soll eine Fehlermeldung repräsentier
 
 ### Konstruktor
 
-Weiters soll es genau einen Konstruktor geben, der als einzigen Parameter den Zähler des fehlerhaften Bruchs übergibt bekommt. Anschließend soll in `message_` die Fehlermeldung ```<nominator> / 0 - Dividing through 0 not valid!\n```, wobei `<nominator>` durch den übergebenen Parameter ersetzt werden soll. Der Copy-Konstruktor und der Copy-Assignment-Operator sollen gelöscht werden.
+Weiters soll es zwei Konstruktoren geben. Einen der als einzigen Parameter den Zähler des fehlerhaften Bruchs übergibt bekommt. Anschließend soll in `message_` die Fehlermeldung `<nominator> / 0 - Dividing through 0 not valid!\n` gespeichert werden, wobei `<nominator>` durch den übergebenen Parameter ersetzt werden soll. Dieser Konstruktor soll aufgerufen werden, wenn ein fehlerhafter Bruch erstellt wird, beispielsweise auch bei der Kehrwertbildung. Der zweite Konstruktor soll keinen Parameter bekommen und nur die Fehlermeldung `Dividing through 0 not valid!\n` in `message_` speichern. Dieser Konstruktor soll genau dann aufgerufen werden, wenn durch einen Bruch mit dem Wert `0` dividiert wird. Der Copy-Konstruktor und der Copy-Assignment-Operator sollen gelöscht werden.
 
 ### Methoden
 
@@ -133,4 +126,4 @@ Außerdem soll in der Klasse genau eine Methode implementiert werden, nämlich d
 
 ## Testprogramm
 
-Ein kurzes Testprogramm, dass die wesentlichen Funktionalitäten überprüft steht bereits zur Verfügung. Die noch offenen Testcases werden in Kürze noch folgen.
+Ein kurzes Testprogramm, das die wesentlichen Funktionalitäten überprüft, steht zur Verfügung.

2021-oop1/ku/exercise_fraction/test.cpp

 #include <iostream>
+#include <sstream>
 #include <cassert>
 #include "Fraction.hpp"
 #include "NullDivisionException.hpp"
@@ -12,13 +13,15 @@
 #define CONSTRUCTOR_NULL_DIVISION_EXCEPTION 1
 #define REDUCE_FRACTION 1
 #define COPY_ASSIGNMENT 1
-#define OUT_OPERATOR 0 // will follow soon
-#define PLUS_OPERATORS 0 // will follow soon
-#define PLUS_OPERATORS_WITH_INT 0 // will follow soon
-#define INCREMENT_OPERATORS 0 // will follow soon
-#define NEGATION_INVERSION 0 // will follow soon
-#define BOOL_OPERATOR 0 // will follow soon
-#define COMPARE_OPERATORS 0 // will follow soon
+#define OUT_OPERATOR 1
+#define PLUS_OPERATORS 1
+#define PLUS_OPERATORS_WITH_INT 1
+#define INCREMENT_OPERATORS 1
+#define NEGATION_INVERSION_DIVISION 1
+#define BOOL_OPERATOR 1
+#define BOOL_OPERATOR_COMPILATION_FAILER 0 // if this is set to 1, compilation
+  // has to fail, otherwise the bool-operator is not declared 'explicit'
+#define COMPARE_OPERATORS 1 // will follow soon
 
 void constructors();
 void constructorNullDivisionException();
@@ -28,7 +31,7 @@ void outOperator();
 void plusOperators();
 void plusOperatorsWithInt();
 void incrementOperators();
-void negationInversion();
+void negationInversionDivision();
 void boolOperators();
 void compareOperators();
 
@@ -46,7 +49,7 @@ int main(void)
   plusOperators();
   plusOperatorsWithInt();
   incrementOperators();
-  negationInversion();
+  negationInversionDivision();
   boolOperators();
   compareOperators();
 
@@ -65,6 +68,7 @@ void constructors()
   Fraction a;
   Fraction b(5);
   Fraction c(1, 10);
+  Fraction d(0, 100);
 
   std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
   std::cout << b.getNominator() << " / " << b.getDenominator() << std::endl;
@@ -76,6 +80,8 @@ void constructors()
     "Constructor with one paramter not correct!\n");
   assert(c.getNominator() == 1 && c.getDenominator() == 10 &&
     "Constructor with two parameters not correct!\n");
+  assert(d.getNominator() == 0 && d.getDenominator() == 1 &&
+    "Constructor with two parameters when value 0 not correct!\n");
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;
@@ -185,12 +191,18 @@ void outOperator()
 
   std::cout << "Testcase: " << __func__ << std::endl << std::endl;
 
-  Fraction a(2, 6);
+  Fraction a(3, 4);
+  Fraction b(-222, 17);
+  Fraction c(-86, -56);
 
-  std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
+  std::stringstream ss;
+  ss << a << b << c;
 
-  assert(a.getNominator() == 1 && a.getDenominator() == 3 &&
-    "Reducing fraction not correct!\n");
+  std::string output = ss.str();
+  std::cout << output;
+
+  assert(output == "3 / 4\n-222 / 17\n43 / 28\n" &&
+    "Output operator wrong!\n");
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;
@@ -205,12 +217,31 @@ void plusOperators()
 
   std::cout << "Testcase: " << __func__ << std::endl << std::endl;
 
-  Fraction a(2, 6);
+  Fraction a(-99, 33); // -3
+  Fraction b(-68, -23);// 68 / 23
+  Fraction c(42, 19);  // 42 / 19
+  Fraction d;
+  Fraction e;
+  Fraction f(1, 4);
 
-  std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
+  d = a + b;
+  e = c += b;
+  f += f;
 
-  assert(a.getNominator() == 1 && a.getDenominator() == 3 &&
+  std::cout << a << b << c << d << e << f;
+
+  assert(a.getNominator() == -3 && a.getDenominator() == 1 &&
     "Reducing fraction not correct!\n");
+  assert(b.getNominator() == 68 && b.getDenominator() == 23 &&
+    "Making denominator positive not working!\n");
+  assert(c.getNominator() == 2258 && c.getDenominator() == 437 &&
+    "+= Operator not working!\n");
+  assert(d.getNominator() == -1 && d.getDenominator() == 23 &&
+    "+ Operator not working!\n");
+  assert(e.getNominator() == 2258 && e.getDenominator() == 437 &&
+    "+= Operator not working!\n");
+  assert(f.getNominator() == 1 && f.getDenominator() == 2 &&
+    "+= Operator does no reduce fraction!\n");
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;
@@ -225,12 +256,18 @@ void plusOperatorsWithInt()
 
   std::cout << "Testcase: " << __func__ << std::endl << std::endl;
 
-  Fraction a(2, 6);
+  Fraction a(20, 30);
+  Fraction b(-40, 50);
 
-  std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
+  a = a + 14;
+  b = -5 + b;
 
-  assert(a.getNominator() == 1 && a.getDenominator() == 3 &&
-    "Reducing fraction not correct!\n");
+  std::cout << a << b;
+
+  assert(a.getNominator() == 44 && a.getDenominator() == 3 &&
+    "+ Operator with leading fraction not working\n");
+  assert(b.getNominator() == -29 && b.getDenominator() == 5 &&
+    "+ Operator with leading int not working\n");
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;
@@ -245,12 +282,19 @@ void incrementOperators()
 
   std::cout << "Testcase: " << __func__ << std::endl << std::endl;
 
-  Fraction a(2, 6);
+  Fraction a(-11, 66);
 
-  std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
+  Fraction b = ++a;
+  Fraction c = a++;
 
-  assert(a.getNominator() == 1 && a.getDenominator() == 3 &&
-    "Reducing fraction not correct!\n");
+  std::cout << a << b << c;
+
+  assert(a.getNominator() == 11 && a.getDenominator() == 6 &&
+    "Increment operator(s) not working!\n");
+  assert(b.getNominator() == 5 && b.getDenominator() == 6 &&
+    "Increment operator(s) not working!\n");
+  assert(c.getNominator() == 5 && c.getDenominator() == 6 &&
+    "Increment operator(s) not working!\n");
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;
@@ -259,18 +303,61 @@ void incrementOperators()
 }
 
 //------------------------------------------------------------------------------
-void negationInversion()
+void negationInversionDivision()
 {
-#if NEGATION_INVERSION == 1
+#if NEGATION_INVERSION_DIVISION == 1
 
   std::cout << "Testcase: " << __func__ << std::endl << std::endl;
 
-  Fraction a(2, 6);
+  Fraction a(17, 19);
+  Fraction b(18, 20);
 
-  std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
+  Fraction c = -a;
+  Fraction d = ~b;
+  Fraction e;
 
-  assert(a.getNominator() == 1 && a.getDenominator() == 3 &&
+  std::cout << a << b << c << d;
+
+  assert(a.getNominator() == 17 && a.getDenominator() == 19 &&
+    "Reducing fraction not correct!\n");
+  assert(b.getNominator() == 9 && b.getDenominator() == 10 &&
     "Reducing fraction not correct!\n");
+  assert(c.getNominator() == -17 && c.getDenominator() == 19 &&
+    "Reducing fraction not correct!\n");
+  assert(d.getNominator() == 10 && d.getDenominator() == 9 &&
+    "Reducing fraction not correct!\n");
+  assert(e.getNominator() == 0 && e.getDenominator() == 1 &&
+    "Reducing fraction not correct!\n");
+
+  try
+  {
+    e = ~Fraction(0);
+    assert(false && "No NullDivisionException thrown!\n");
+  }
+  catch (NullDivisionException& ex)
+  {
+    std::cout << "Error: " << ex.what();
+
+    assert(std::string(ex.what()) == "1 / 0 - Dividing through 0 not valid!\n"
+      && "NullDivisionException not correct!\n");
+  }
+
+  try
+  {
+    b /= b;
+    assert(b.getNominator() == 1 && b.getDenominator() == 1
+      && "Division not deliviering right result!\n");
+
+    c = a /= e;
+    assert(false && "No NullDivisionException thrown!\n");
+  }
+  catch (NullDivisionException& ex)
+  {
+    std::cout << "Error: " << ex.what();
+
+    assert(std::string(ex.what()) == "Dividing through 0 not valid!\n"
+      && "NullDivisionException not correct!\n");
+  }
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;
@@ -285,12 +372,23 @@ void boolOperators()
 
   std::cout << "Testcase: " << __func__ << std::endl << std::endl;
 
-  Fraction a(2, 6);
+  Fraction a;
+  Fraction b(2);
 
-  std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
+  std::cout << a << b;
 
-  assert(a.getNominator() == 1 && a.getDenominator() == 3 &&
-    "Reducing fraction not correct!\n");
+  if (a)
+  {
+    assert(false && "Fraction with value 0 should not be true!\n");
+  }
+  if (!b)
+  {
+    assert(false && "!Fraction with value inequal to zero should be true!\n");
+  }
+
+  #if BOOL_OPERATOR_COMPILATION_FAILER == 1
+  int c = a;
+  #endif
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;
@@ -305,12 +403,36 @@ void compareOperators()
 
   std::cout << "Testcase: " << __func__ << std::endl << std::endl;
 
-  Fraction a(2, 6);
-
-  std::cout << a.getNominator() << " / " << a.getDenominator() << std::endl;
-
-  assert(a.getNominator() == 1 && a.getDenominator() == 3 &&
-    "Reducing fraction not correct!\n");
+  Fraction a(5769, 243);
+  Fraction b(1283, 54); // b > a
+  Fraction c(6410, 270); // a == c
+  Fraction d(-641, 27);
+
+  std::cout << a << b << c << d;
+
+  if (a == b || a == d || b == a || b == c || b == d || c == b || c == d || 
+      d == a || d == b || d == c)
+    assert(false && "Inequival fractions are assumed as equal in ==!\n");
+  if (!(a == a && a == c && b == b && c == a && c == c && d == d))
+    assert(false && "Equal fractions are assumed as inequival in ==!\n");
+
+  if (!(a != b && a != d && b != a && b != c && b != d && c != b && c != d &&
+      d != a && d != b && d != c))
+    assert(false && "Inequival fractions are assumed as equal in !=!\n");
+  if (a != a || a != c || b != b || c != a || c != c || d != d)
+    assert(false && "Equal fractions are assumed as inequival in !=!\n");
+
+  if (!(a < b && c < b && d < a && d < b && d < c))
+    assert(false && "<-operator not working correctly!\n");
+  if (a < a || a < c || a < d || b < a || b < b || b < c || b < d || c < a || 
+      c < c || c < d || d < d)
+    assert(false && "<-operator not working correctly!\n");
+
+  if (!(a <= a && a <= b && a <= c && b <= b && c <= a && c <= b && c <= c && d <= a && 
+      d <= b && d <= c && d <= d))
+    assert(false && "<=-operator not working correctly!\n");
+  if (a <= d || b <= a || b <= c || b <= d || c <= d)
+    assert(false && "<=-operator not working correctly!\n"); 
 
   std::cout << "\nAll good!\n\n";
   std::cout << "-----------------------------------------------\n" << std::endl;