Issue #2971 display names

exercises/practice/dnd-character/src/test/java/DnDCharacterTest.java

@@ -1,4 +1,5 @@
 import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
@@ -10,150 +11,175 @@ public class DnDCharacterTest {
     private DnDCharacter dndCharacter = new DnDCharacter();
 
     @Test
+    @DisplayName("ability modifier for score 3 is -4")
     public void testAbilityModifierForScore3IsNegative4() {
         assertThat(dndCharacter.modifier(3)).isEqualTo(-4);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 4 is -3")
     public void testAbilityModifierForScore4IsNegative3() {
         assertThat(dndCharacter.modifier(4)).isEqualTo(-3);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 5 is -3")
     public void testAbilityModifierForScore5IsNegative3() {
         assertThat(dndCharacter.modifier(5)).isEqualTo(-3);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 6 is -2")
     public void testAbilityModifierForScore6IsNegative2() {
         assertThat(dndCharacter.modifier(6)).isEqualTo(-2);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 7 is -2")
     public void testAbilityModifierForScore7IsNegative2() {
         assertThat(dndCharacter.modifier(7)).isEqualTo(-2);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 8 is -1")
     public void testAbilityModifierForScore8IsNegative1() {
         assertThat(dndCharacter.modifier(8)).isEqualTo(-1);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 9 is -1")
     public void testAbilityModifierForScore9IsNegative1() {
         assertThat(dndCharacter.modifier(9)).isEqualTo(-1);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 10 is 0")
     public void testAbilityModifierForScore10Is0() {
         assertThat(dndCharacter.modifier(10)).isEqualTo(0);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 11 is 0")
     public void testAbilityModifierForScore11Is0() {
         assertThat(dndCharacter.modifier(11)).isEqualTo(0);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 12 is +1")
     public void testAbilityModifierForScore12Is1() {
         assertThat(dndCharacter.modifier(12)).isEqualTo(1);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 13 is +1")
     public void testAbilityModifierForScore13Is1() {
         assertThat(dndCharacter.modifier(13)).isEqualTo(1);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 14 is +2")
     public void testAbilityModifierForScore14Is2() {
         assertThat(dndCharacter.modifier(14)).isEqualTo(2);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 15 is +2")
     public void testAbilityModifierForScore15Is2() {
         assertThat(dndCharacter.modifier(15)).isEqualTo(2);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 16 is +3")
     public void testAbilityModifierForScore16Is3() {
         assertThat(dndCharacter.modifier(16)).isEqualTo(3);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 17 is +3")
     public void testAbilityModifierForScore17Is3() {
         assertThat(dndCharacter.modifier(17)).isEqualTo(3);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("ability modifier for score 18 is +4")
     public void testAbilityModifierForScore18Is4() {
         assertThat(dndCharacter.modifier(18)).isEqualTo(4);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Rolling uses 4 dice")
     public void test4DiceWereUsedForRollingScores() {
         assertThat(dndCharacter.rollDice().size()).isEqualTo(4);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Dice values are between 1 and 6 inclusive")
     public void testDiceValuesBetween1And6() {
         assertThat(dndCharacter.rollDice()).allMatch(d -> d >= 1 && d <= 6);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Ability uses 3 largest numbers from scores in descending order")
     public void testAbilityCalculationsUses3LargestNumbersFromScoresInDescendingOrder() {
         assertThat(dndCharacter.ability(List.of(4, 3, 2, 1))).isEqualTo(9);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Ability uses 3 largest numbers from scores in ascending order")
     public void testAbilityCalculationsUses3LargestNumbersFromFromScoresInAscendingOrder() {
         assertThat(dndCharacter.ability(List.of(1, 2, 3, 4))).isEqualTo(9);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Ability uses 3 largest numbers from scores in random order")
     public void testAbilityCalculationsUses3LargestNumbersFromScoresInRandomOrder() {
         assertThat(dndCharacter.ability(List.of(2, 4, 3, 1))).isEqualTo(9);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Ability with all lowest equal numbers yields 3")
     public void testAbilityCalculationsWithLowestEqualNumbers() {
         assertThat(dndCharacter.ability(List.of(1, 1, 1, 1))).isEqualTo(3);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Ability with all highest equal numbers yields 18")
     public void testAbilityCalculationsWithHighestEqualNumbers() {
         assertThat(dndCharacter.ability(List.of(6, 6, 6, 6))).isEqualTo(18);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Ability calculation with two lowest numbers")
     public void testAbilityCalculationsWithTwoLowestNumbers() {
         assertThat(dndCharacter.ability(List.of(3, 5, 3, 4))).isEqualTo(12);
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Ability calculation does not mutate input scores")
     public void testAbilityCalculationDoesNotChangeInputScores() {
         List<Integer> scores = List.of(1, 2, 3, 4);
         dndCharacter.ability(scores);
@@ -164,6 +190,7 @@ public void testAbilityCalculationDoesNotChangeInputScores() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("random character is valid")
     public void testRandomCharacterIsValid() {
         for (int i = 0; i < 1000; i++) {
             DnDCharacter character = new DnDCharacter();
@@ -179,6 +206,7 @@ public void testRandomCharacterIsValid() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("each ability is only calculated once")
     public void testEachAbilityIsOnlyCalculatedOnce() {
         assertThat(dndCharacter.getStrength()).isEqualTo(dndCharacter.getStrength());
         assertThat(dndCharacter.getDexterity()).isEqualTo(dndCharacter.getDexterity());
@@ -190,6 +218,7 @@ public void testEachAbilityIsOnlyCalculatedOnce() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Each randomly created character should be unique in attributes")
     public void testUniqueCharacterIsCreated() {
         DnDCharacter uniqueDnDCharacter = new DnDCharacter();
         for (int i = 0; i < 1000; i++) {

exercises/practice/error-handling/src/test/java/ErrorHandlingTest.java

@@ -1,23 +1,26 @@
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-
 import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 import java.util.Optional;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
 public class ErrorHandlingTest {
 
     private ErrorHandling errorHandling = new ErrorHandling();
 
     @Test
+    @DisplayName("Throws IllegalArgumentException")
     public void testThrowIllegalArgumentException() {
         assertThatExceptionOfType(Exception.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingIllegalArgumentException());
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws IllegalArgumentException with provided detail message")
     public void testThrowIllegalArgumentExceptionWithDetailMessage() {
         assertThatExceptionOfType(IllegalArgumentException.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage(
@@ -27,6 +30,7 @@ public void testThrowIllegalArgumentExceptionWithDetailMessage() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws any checked exception")
     public void testThrowAnyCheckedException() {
         assertThatExceptionOfType(Exception.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingAnyCheckedException())
@@ -35,6 +39,7 @@ public void testThrowAnyCheckedException() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws any checked exception with provided detail message")
     public void testThrowAnyCheckedExceptionWithDetailMessage() {
         assertThatExceptionOfType(Exception.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingAnyCheckedExceptionWithDetailMessage(
@@ -45,13 +50,15 @@ public void testThrowAnyCheckedExceptionWithDetailMessage() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws any unchecked exception")
     public void testThrowAnyUncheckedException() {
         assertThatExceptionOfType(RuntimeException.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingAnyUncheckedException());
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws any unchecked exception with provided detail message")
     public void testThrowAnyUncheckedExceptionWithDetailMessage() {
         assertThatExceptionOfType(RuntimeException.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage(
@@ -61,13 +68,15 @@ public void testThrowAnyUncheckedExceptionWithDetailMessage() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws custom checked exception")
     public void testThrowCustomCheckedException() {
         assertThatExceptionOfType(CustomCheckedException.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingCustomCheckedException());
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws custom checked exception with provided detail message")
     public void testThrowCustomCheckedExceptionWithDetailMessage() {
         assertThatExceptionOfType(CustomCheckedException.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingCustomCheckedExceptionWithDetailMessage(
@@ -77,13 +86,15 @@ public void testThrowCustomCheckedExceptionWithDetailMessage() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws custom unchecked exception")
     public void testThrowCustomUncheckedException() {
         assertThatExceptionOfType(CustomUncheckedException.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingCustomUncheckedException());
     }
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Throws custom unchecked exception with provided detail message")
     public void testThrowCustomUncheckedExceptionWithDetailMessage() {
         assertThatExceptionOfType(CustomUncheckedException.class)
                 .isThrownBy(() -> errorHandling.handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage(
@@ -93,6 +104,7 @@ public void testThrowCustomUncheckedExceptionWithDetailMessage() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Handles error by throwing Optional instance")
     public void testReturnOptionalInstance() {
         Optional<Integer> successfulResult = errorHandling.handleErrorByReturningOptionalInstance("1");
         assertThat(successfulResult).isPresent().hasValue(1);

exercises/practice/hangman/src/test/java/HangmanTest.java

@@ -1,8 +1,10 @@
 import io.reactivex.Observable;
 import io.reactivex.ObservableEmitter;
 import io.reactivex.disposables.Disposable;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
@@ -22,6 +24,7 @@ public void init() {
     }
 
     @Test
+    @DisplayName("Initial game state is set correctly")
     public void initialization() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),
@@ -39,6 +42,7 @@ public void initialization() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("First correct guess updates discovered and guess lists")
     public void firstGuess() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),
@@ -54,6 +58,7 @@ public void firstGuess() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("First incorrect guess registers a miss and adds a part")
     public void firstMiss() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),
@@ -69,6 +74,7 @@ public void firstMiss() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Game in progress accumulates guesses, misses and parts correctly")
     public void gameInProgress() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),
@@ -84,6 +90,7 @@ public void gameInProgress() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Winning the game results in WIN status")
     public void wonGame() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),
@@ -97,6 +104,7 @@ public void wonGame() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Losing the game results in LOSS status")
     public void lostGame() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),
@@ -118,6 +126,7 @@ public void lostGame() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Handles consecutive games correctly with ordered emissions")
     public void consecutiveGames() {
         // This test setup is more complex because we have to order the emission of values in the
         // different observers.
@@ -189,6 +198,7 @@ Observable createLetterObservable(ObservableEmitter[] emitters, Runnable emit) {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Cannot play the same guess twice")
     public void cannotPlayAGuessTwice() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),
@@ -201,6 +211,7 @@ public void cannotPlayAGuessTwice() {
 
     @Disabled("Remove to run test")
     @Test
+    @DisplayName("Cannot play the same miss twice")
     public void cannotPlayAMissTwice() {
         Observable<Output> result = hangman.play(
             Observable.fromArray("secret"),