diff --git a/src/main/java/edu/hm/hafner/java2/assignment1/Assignment.java b/src/main/java/edu/hm/hafner/java2/assignment1/Assignment.java index ff0936e..88f4956 100644 --- a/src/main/java/edu/hm/hafner/java2/assignment1/Assignment.java +++ b/src/main/java/edu/hm/hafner/java2/assignment1/Assignment.java @@ -4,4 +4,85 @@ * Representation of an assignment. */ public class Assignment { + private final int number; + private final boolean[] testCases; + private final int tests; // redundant as implicitly given by array length + + public Assignment(final int number, final int tests) { + this.number = number; + this.testCases = new boolean[tests]; + this.tests = tests; + } + + public int getNumber() { + return number; + } + + public int getTests() { + return tests; + } + + /** + * Returns the number of green tests. + * + * @return the number of solved tests. + */ + public int getGreen() { + int solvedAmount = 0; + for (boolean isTestGreen : testCases) { + if (isTestGreen) { + solvedAmount++; + } + } + return solvedAmount; + } + + /** + * Get number of red tests. + * + * @return number of unsolved tests + */ + public int getRed() { + return tests - getGreen(); + } + + /** + * Get percentage of solved tests. + * + * @return percentage of solved tests + */ + public int getPercentage() { + int solvedAmount = getGreen(); + + return 100 * solvedAmount / getTests(); + } + + /** + * Solves a test with the given index. + * + * @param index + * index of test to solve + * @throws IndexOutOfBoundsException if the index is out of bounds + */ + public void solve(final int index) + throws IndexOutOfBoundsException { + if (index < 0 || index >= testCases.length) { + throw new IndexOutOfBoundsException(); + } + testCases[index] = true; + } + + /** + * Returns whether the percentage of solved tests is greater or equal than 50 percent. + * + * @return if achieved percentage is enough + */ + public boolean isSufficient() { + return getPercentage() >= 50; + } + + @Override + public String toString() { + return null; + } } diff --git a/src/main/java/edu/hm/hafner/java2/assignment1/Exam.java b/src/main/java/edu/hm/hafner/java2/assignment1/Exam.java index b769d40..5ac7291 100644 --- a/src/main/java/edu/hm/hafner/java2/assignment1/Exam.java +++ b/src/main/java/edu/hm/hafner/java2/assignment1/Exam.java @@ -1,7 +1,105 @@ package edu.hm.hafner.java2.assignment1; +import java.util.Arrays; + /** * An exam contains several assignments. */ public class Exam { + private static final int LIMIT_ONE = 95; + private static final int LIMIT_TWO = 80; + private static final int LIMIT_THREE = 65; + private static final int LIMIT_FOUR = 50; + private static final int LIMIT_FIVE = 0; + + private Assignment[] assignments = new Assignment[0]; + + /** + * Create a new {@link Exam}. + */ + public Exam() { + } + + /** + * Returns the number of assignments. + * + * @return the number of assignments + */ + public int getSize() { + return assignments.length; + } + + /** + * Adds an assignment to this exam. + * + * @param assignment + * the assignment to add + */ + public void addAssignment(final Assignment assignment) { + assignments = Arrays.copyOf(assignments, assignments.length + 1); + assignments[assignments.length - 1] = assignment; + } + + /** + * Returns the assignment at the given index. + * + * @param index + * index of the assignment + * + * @return assignment at the given index + */ + public Assignment getAssignment(final int index) { + return assignments[index]; + } + + /** + * Get total score of all assignments in the exam. + * + * @return score between 0 and 100 + */ + public int getScore() { + var size = getSize(); + if (size == 0) { + return 100; // Not specified: 0 or exception is possible as well + } + + int percentageSum = 0; + for (Assignment assignment : assignments) { + percentageSum += assignment.getPercentage(); + } + return percentageSum / size; + } + + /** + * Returns whether the score of this exam is greater or equal than 50 percent. + * + * @return if achieved score is enough + */ + public boolean isSufficient() { + return getScore() >= LIMIT_FOUR; + } + + /** + * Returns the grade for this exam between 1 and 6. + * + * @return grade for exam + */ + public int getGrade() { + if (getScore() >= LIMIT_ONE) { + return 1; + } + if (getScore() >= LIMIT_TWO) { + return 2; + } + if (getScore() >= LIMIT_THREE) { + return 3; + } + if (getScore() >= LIMIT_FOUR) { + return 4; + } + if (getScore() > LIMIT_FIVE) { + return 5; + } + return 6; + } } diff --git a/src/test/java/edu/hm/hafner/java2/assignment1/AssignmentTest.java b/src/test/java/edu/hm/hafner/java2/assignment1/AssignmentTest.java index 08536f5..551bee1 100644 --- a/src/test/java/edu/hm/hafner/java2/assignment1/AssignmentTest.java +++ b/src/test/java/edu/hm/hafner/java2/assignment1/AssignmentTest.java @@ -12,8 +12,62 @@ class AssignmentTest { @Test void shouldCreateEmptyAssignment() { - var assignment = new Assignment(); + var assignment = new Assignment(18, 5); - assertThat(assignment).isSameAs(assignment); // This is a fake test that needs to be replaced + assertThat(assignment.getNumber()).isEqualTo(18); + assertThat(assignment.getTests()).isEqualTo(5); + assertThat(assignment.getGreen()).isEqualTo(0); + assertThat(assignment.getRed()).isEqualTo(5); + assertThat(assignment.getPercentage()).isEqualTo(0); + assertThat(assignment.isSufficient()).isFalse(); + } + + @Test + public void shouldFixOneTest() { + var assignment = new Assignment(1, 10); + + assignment.solve(1); + + assertThat(assignment.getTests()).isEqualTo(10); + assertThat(assignment.getGreen()).isEqualTo(1); + assertThat(assignment.getRed()).isEqualTo(9); + assertThat(assignment.getPercentage()).isEqualTo(10); + assertThat(assignment.isSufficient()).isFalse(); + } + + @Test + void shouldFixAllTests() { + var assignment = new Assignment(1, 2); + + assignment.solve(0); + + assertThat(assignment.getGreen()).isEqualTo(1); + assertThat(assignment.getRed()).isEqualTo(1); + assertThat(assignment.getPercentage()).isEqualTo(50); + assertThat(assignment.isSufficient()).isTrue(); + + assignment.solve(1); + + assertThat(assignment.getGreen()).isEqualTo(2); + assertThat(assignment.getRed()).isEqualTo(0); + assertThat(assignment.getPercentage()).isEqualTo(100); + assertThat(assignment.isSufficient()).isTrue(); + } + + @Test + void shouldNotSolveSameTestTwice() { + var assignment = new Assignment(1, 3); + + assignment.solve(0); + + assertThat(assignment.getGreen()).isEqualTo(1); + assertThat(assignment.getRed()).isEqualTo(2); + assertThat(assignment.getPercentage()).isEqualTo(33); + + assignment.solve(0); + + assertThat(assignment.getGreen()).isEqualTo(1); + assertThat(assignment.getRed()).isEqualTo(2); + assertThat(assignment.getPercentage()).isEqualTo(33); } } diff --git a/src/test/java/edu/hm/hafner/java2/assignment1/ExamTest.java b/src/test/java/edu/hm/hafner/java2/assignment1/ExamTest.java index d61eb8c..e684336 100644 --- a/src/test/java/edu/hm/hafner/java2/assignment1/ExamTest.java +++ b/src/test/java/edu/hm/hafner/java2/assignment1/ExamTest.java @@ -1,5 +1,6 @@ package edu.hm.hafner.java2.assignment1; +import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import static org.assertj.core.api.Assertions.*; @@ -14,6 +15,136 @@ class ExamTest { void shouldCreateEmptyExam() { var exam = new Exam(); - assertThat(exam).isSameAs(exam); // This is a fake test that needs to be replaced + assertThat(exam.getSize()).isEqualTo(0); + assertThat(exam.getScore()).isEqualTo(100); + assertThat(exam.isSufficient()).isTrue(); + assertThat(exam.getGrade()).isEqualTo(1); + } + + @Test @DisplayName("Ein Examen mit genau einer Aufgabe sollte erstellt werden können.") + void shouldCreateExamWithOneAssignment() { + var exam = new Exam(); + + var assignment = new Assignment(1, 5); + exam.addAssignment(assignment); + + assertThat(exam.getSize()).isEqualTo(1); + assertThat(exam.getAssignment(0)).isSameAs(assignment); + + assertThat(exam.getScore()).isEqualTo(0); + assertThat(exam.isSufficient()).isFalse(); + assertThat(exam.getGrade()).isEqualTo(6); + } + + @Test + void shouldCreateExamWithTwoAssignments() { + var exam = new Exam(); + + var firstAssignment = new Assignment(1, 5); + exam.addAssignment(firstAssignment); + + var secondAssignment = new Assignment(2, 3); + exam.addAssignment(secondAssignment); + + assertThat(exam.getAssignment(0)) + .isSameAs(firstAssignment); + assertThat(exam.getAssignment(1)) + .isSameAs(secondAssignment); + + assertThat(exam.getSize()).isEqualTo(2); + assertThat(exam.getScore()).isEqualTo(0); + assertThat(exam.isSufficient()).isFalse(); + assertThat(exam.getGrade()).isEqualTo(6); + } + + @Test + void shouldCreateExamWithOneAssignmentAndSolveOneTest() { + var exam = new Exam(); + + var assignment = new Assignment(1, 5); + exam.addAssignment(assignment); + + assignment.solve(0); + + assertThat(exam.getSize()).isEqualTo(1); + assertThat(exam.getScore()).isEqualTo(20); + assertThat(exam.isSufficient()).isFalse(); + assertThat(exam.getGrade()).isEqualTo(5); + } + + @Test + void shouldSolveOneOfTwoAssignments() { + var exam = new Exam(); + + var assignment = new Assignment(1, 2); + + assignment.solve(0); + assignment.solve(1); + + var secondAssignment = new Assignment(2, 2); + + exam.addAssignment(assignment); + exam.addAssignment(secondAssignment); + + assertThat(exam.getSize()).isEqualTo(2); + assertThat(exam.getScore()).isEqualTo(50); + assertThat(exam.isSufficient()).isTrue(); + assertThat(exam.getGrade()).isEqualTo(4); + } + + @Test + void shouldCreateExamWithTwoAssignmentsAndSolveAllTests() { + var exam = new Exam(); + + var assignment = new Assignment(1, 2); + assignment.solve(0); + assignment.solve(1); + + var secondAssignment = new Assignment(2, 2); + secondAssignment.solve(0); + secondAssignment.solve(1); + + exam.addAssignment(assignment); + exam.addAssignment(secondAssignment); + + assertThat(exam.getSize()).isEqualTo(2); + assertThat(exam.getScore()).isEqualTo(100); + assertThat(exam.isSufficient()).isTrue(); + assertThat(exam.getGrade()).isEqualTo(1); + } + + @Test + void shouldCreateExamWithThreeAssignmentsAndSolveTwo() { + var exam = new Exam(); + + var assignment = new Assignment(1, 1); + assignment.solve(0); + + var secondAssignment = new Assignment(2, 1); + secondAssignment.solve(0); + + exam.addAssignment(assignment); + exam.addAssignment(secondAssignment); + exam.addAssignment(new Assignment(3, 9)); + + assertThat(exam.getSize()).isEqualTo(3); + assertThat(exam.getScore()).isEqualTo(66); + assertThat(exam.isSufficient()).isTrue(); + assertThat(exam.getGrade()).isEqualTo(3); + } + + @Test + void shouldTestGetAssignmentMethod() { + var exam = new Exam(); + exam.addAssignment(new Assignment(1, 10)); + + for (int i = 0; i < 8; i++) { + exam.getAssignment(0).solve(i); + } + + assertThat(exam.getSize()).isEqualTo(1); + assertThat(exam.getScore()).isEqualTo(80); + assertThat(exam.isSufficient()).isTrue(); + assertThat(exam.getGrade()).isEqualTo(2); } }