Add return error code instead of throwing exceptions code smell

Author: JavierCane

examples/java/java-student_grades-01_base_example/src/main/java/tv/codely/student_grades/Pair.java

@@ -0,0 +1,19 @@
+package tv.codely.student_grades;
+
+public final class Pair<FirstType, SecondType> {
+    final private FirstType first;
+    final private SecondType second;
+
+    public Pair(FirstType first, SecondType second) {
+        this.first  = first;
+        this.second = second;
+    }
+
+    public FirstType first() {
+        return first;
+    }
+
+    public SecondType second() {
+        return second;
+    }
+}

examples/java/java-student_grades-01_base_example/src/main/java/tv/codely/student_grades/StudentGradeCalculator.java

@@ -1,25 +1,32 @@
 package tv.codely.student_grades;
 
 import java.util.List;
+import java.util.Map;
 
 public class StudentGradeCalculator {
-    public Float calculateGrades(final List<Float> examsGrades, final Boolean hasReachedMinimumClasses) {
+    public Float calculateGrades(final List<Pair<Integer, Float>> examsGrades, final boolean hasReachedMinimumClasses) {
         if (!examsGrades.isEmpty()) {
-            Float gradesSum = 0.f;
-            Integer gradesCounter = 0;
+            Float gradesSum = 0f;
+            Integer gradesWeightSum = 0;
 
-            for (Float examGrade : examsGrades) {
-                gradesSum += examGrade;
-                gradesCounter++;
+            for (Pair<Integer, Float> examGrade : examsGrades) {
+                gradesSum += (examGrade.first() * examGrade.second() / 100);
+                gradesWeightSum += examGrade.first();
             }
 
-            if (hasReachedMinimumClasses) {
-                return gradesSum / gradesCounter;
+            if (gradesWeightSum == 100) {
+                if (hasReachedMinimumClasses) {
+                    return gradesSum;
+                } else {
+                    return 0f;
+                }
+            } else if (gradesWeightSum > 100) {
+                return -1f;
             } else {
-                return 0.f;
+                return -2f;
             }
         } else {
-            return 0.f;
+            return 0f;
         }
     }
 }

examples/java/java-student_grades-01_base_example/src/test/java/tv/codely/student_grades/StudentGradeCalculatorShould.java

@@ -1,20 +1,19 @@
 package tv.codely.student_grades;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
 import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 import java.util.List;
 
-public class StudentGradeCalculatorShould {
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
+public class StudentGradeCalculatorShould {
     @Test
     void fail_given_there_are_no_exams() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = Collections.emptyList();
-        final Boolean     hasReachedMinimumClasses = true;
+        final List<Pair<Integer, Float>> examsGrades              = Collections.emptyList();
+        final boolean                    hasReachedMinimumClasses = true;
 
         assertEquals(0, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -23,8 +22,8 @@ void fail_given_there_are_no_exams() {
     void calculate_same_grade_given_one_single_exam_and_attending_the_minimum_classes() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = List.of(5.f);
-        final Boolean     hasReachedMinimumClasses = true;
+        final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 5f));
+        final boolean                    hasReachedMinimumClasses = true;
 
         assertEquals(5, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -33,8 +32,19 @@ void calculate_same_grade_given_one_single_exam_and_attending_the_minimum_classe
     void calculate_average_grade_given_different_exam_grades_and_attending_the_minimum_classes() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = List.of(5.f, 4.f, 6.f, 2.f, 8.f, 0.f, 10.f);
-        final Boolean     hasReachedMinimumClasses = true;
+        final List<Pair<Integer, Float>> examsGrades = List.of(
+            new Pair<>(10, 4f),
+            new Pair<>(10, 6f),
+            new Pair<>(10, 2f),
+            new Pair<>(10, 8f),
+            new Pair<>(10, 0f),
+            new Pair<>(10, 10f),
+            new Pair<>(10, 0f),
+            new Pair<>(10, 10f),
+            new Pair<>(10, 0f),
+            new Pair<>(10, 10f)
+        );
+        final boolean hasReachedMinimumClasses = true;
 
         assertEquals(5, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -43,8 +53,11 @@ void calculate_average_grade_given_different_exam_grades_and_attending_the_minim
     void round_up_to_2_decimals_given_odd_exam_grades_and_attending_the_minimum_classes() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = List.of(5.f, 4.f);
-        final Boolean     hasReachedMinimumClasses = true;
+        final List<Pair<Integer, Float>> examsGrades = List.of(
+            new Pair<>(50, 4f),
+            new Pair<>(50, 5f)
+        );
+        final boolean hasReachedMinimumClasses = true;
 
         assertEquals(4.5f, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -55,8 +68,8 @@ void round_up_to_2_decimals_given_odd_exam_grades_and_attending_the_minimum_clas
     void fail_when_there_are_no_exams_and_has_not_attended_the_minimum_classes() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = Collections.emptyList();
-        final Boolean     hasReachedMinimumClasses = false;
+        final List<Pair<Integer, Float>> examsGrades              = Collections.emptyList();
+        final boolean                    hasReachedMinimumClasses = false;
 
         assertEquals(0, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -65,8 +78,8 @@ void fail_when_there_are_no_exams_and_has_not_attended_the_minimum_classes() {
     void fail_given_one_single_exam_but_not_attending_the_minimum_classes() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = List.of(5.f);
-        final Boolean     hasReachedMinimumClasses = false;
+        final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 5f));
+        final boolean                    hasReachedMinimumClasses = false;
 
         assertEquals(0, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -75,8 +88,19 @@ void fail_given_one_single_exam_but_not_attending_the_minimum_classes() {
     void fail_given_different_exam_grades_but_not_attending_the_minimum_classes() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = List.of(5.f, 4.f, 6.f, 2.f, 8.f, 0.f, 10.f);
-        final Boolean     hasReachedMinimumClasses = false;
+        final List<Pair<Integer, Float>> examsGrades = List.of(
+            new Pair<>(10, 4f),
+            new Pair<>(10, 6f),
+            new Pair<>(10, 2f),
+            new Pair<>(10, 8f),
+            new Pair<>(10, 0f),
+            new Pair<>(10, 10f),
+            new Pair<>(10, 0f),
+            new Pair<>(10, 10f),
+            new Pair<>(10, 0f),
+            new Pair<>(10, 10f)
+        );
+        final boolean hasReachedMinimumClasses = false;
 
         assertEquals(0, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -85,9 +109,40 @@ void fail_given_different_exam_grades_but_not_attending_the_minimum_classes() {
     void fail_given_odd_exam_grades_but_not_attending_the_minimum_classes() {
         StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
 
-        final List<Float> examsGrades              = List.of(5.f, 4.f);
-        final Boolean     hasReachedMinimumClasses = false;
+        final List<Pair<Integer, Float>> examsGrades = List.of(
+            new Pair<>(50, 5f),
+            new Pair<>(50, 4f)
+        );
+        final boolean hasReachedMinimumClasses = false;
 
         assertEquals(0, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
+
+    // Weight
+
+    @Test
+    void validate_all_exam_grades_weight_below_100() {
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+
+        final List<Pair<Integer, Float>> examsGrades = List.of(
+            new Pair<>(10, 4f),
+            new Pair<>(10, 6f)
+        );
+        final boolean hasReachedMinimumClasses = true;
+
+        assertEquals(-2, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
+    }
+
+    @Test
+    void validate_all_exam_grades_weight_over_100() {
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+
+        final List<Pair<Integer, Float>> examsGrades = List.of(
+            new Pair<>(90, 4f),
+            new Pair<>(20, 6f)
+        );
+        final boolean hasReachedMinimumClasses = true;
+
+        assertEquals(-1, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
+    }
 }