exercism · jmrunkle · Apr 23, 2020 · Apr 23, 2020 · Apr 23, 2020 · Apr 23, 2020
diff --git a/POLICIES.md b/POLICIES.md
@@ -17,7 +17,7 @@ Our policies are not set-in-stone. They represent directions chosen at a point i
 
 | Track Event | Policies to review |
 |:------------|:-----------------|
-| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test); [Add hint for the first exercises without starter implementation](#add-hint-for-the-first-exercises-without-starter-implementation); [Reference tutorial in the first exercises](#reference-tutorial-in-the-first-exercises); [Avoid returning null](#avoid-returning-null); [Use ExpectedException](#use-expectedexception); [Using other assertion libraries](#using-other-assertion-libraries)
+| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test); [Add hint for the first exercises without starter implementation](#add-hint-for-the-first-exercises-without-starter-implementation); [Reference tutorial in the first exercises](#reference-tutorial-in-the-first-exercises); [Avoid returning null](#avoid-returning-null); [Use assertThrows](#use-assertthrows); [Using other assertion libraries](#using-other-assertion-libraries)
 | Track rearranged | [Starter implementations](#starter-implementations); [Multiple file submissions](#multiple-file-submissions) |
 | New issue observed in track | [Good first issues](#good-first-issues) |
 | "Good first issue" issue completed | [Good first issues](#good-first-issues) |
@@ -149,14 +149,17 @@ References: [[1](https://github.com/exercism/java/issues/1389)]
 
 References: [[1](https://www.codebyamir.com/blog/stop-returning-null-in-java)]
 
-### Use ExpectedException
+### Use assertThrows
 
 > Some exercises expect exceptions to be thrown in the tests.
-> The exercises on this track are all using JUnit's [`ExpectedException`](http://junit.org/junit4/javadoc/4.12/org/junit/rules/ExpectedException.html) `@Rule` feature to support that instead of `@Test(expected = SomeException.class)`.
-> `ExpectedException` is more powerful than using the `@Test` annotation, since with `ExpectedException` you can also inspect the exception's error message and other properties.
-> To be consistent, please use `ExpectedException` whenever you expect an exception to be thrown.
-
-> See [the triangle tests](https://github.com/exercism/java/blob/master/exercises/triangle/src/test/java/TriangleTest.java) for an example of where `ExpectedException` is used.
+> The exercises on this track are all using [`org.junit.Assert.assertThrows`](https://junit.org/junit4/javadoc/latest/org/junit/Assert.html#assertThrows(java.lang.Class,%20org.junit.function.ThrowingRunnable)) instead of `@Test(expected = SomeException.class)`.
+> `assertThrows` is more powerful than using the `@Test` annotation.
+> With this method you can assert that a given function call (specified, for instance, as a lambda expression or method reference) results in a particular type of exception being thrown.
+> In addition it returns the exception that was thrown, so that further assertions can be made (e.g. to verify that the message and cause are correct).
+> Furthermore, you can make assertions on the state of a domain object after the exception has been thrown.
+> To be consistent, please use `assertThrows` whenever you expect an exception to be thrown.
+
+> See [the triangle tests](https://github.com/exercism/java/blob/master/exercises/triangle/src/test/java/TriangleTest.java) for an example of where `assertThrows` is used.
 
 References: [[1](https://github.com/junit-team/junit4/wiki/Exception-testing)]
 

diff --git a/_template/build.gradle b/_template/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/accumulate/build.gradle b/exercises/accumulate/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/acronym/build.gradle b/exercises/acronym/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/affine-cipher/build.gradle b/exercises/affine-cipher/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/affine-cipher/src/test/java/AffineCipherTest.java b/exercises/affine-cipher/src/test/java/AffineCipherTest.java
@@ -1,22 +1,13 @@
-import org.junit.Before;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
 import org.junit.Ignore;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
-
-import static org.junit.Assert.assertEquals;
 
 public class AffineCipherTest {
 
-    private AffineCipher affineCipher;
-
-    @Before
-    public void genAffineCipher() {
-        affineCipher = new AffineCipher();
-    }
-
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
+    private AffineCipher affineCipher = new AffineCipher();
 
     @Test
     public void testEncodeYes() {
@@ -71,11 +62,14 @@ public void testEncodeAllTheLetters() {
 
     @Ignore("Remove to run test")
     @Test
-    public void testEncodeThrowsMeaningfulException() throws IllegalArgumentException {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Error: keyA and alphabet size must be coprime.");
+    public void testEncodeThrowsMeaningfulException() {
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> affineCipher.encode("This is a test", 6, 17));
 
-        affineCipher.encode("This is a test", 6, 17);
+        assertThat(expected)
+            .hasMessage("Error: keyA and alphabet size must be coprime.");
     }
 
     @Ignore("Remove to run test")
@@ -120,10 +114,13 @@ public void testDecodeWithTooManySpaces() {
     @Ignore("Remove to run test")
     @Test
     public void testDecodeThrowsMeaningfulException() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Error: keyA and alphabet size must be coprime.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> affineCipher.decode("Test", 13, 5));
 
-        affineCipher.decode("Test", 13, 5);
+        assertThat(expected)
+            .hasMessage("Error: keyA and alphabet size must be coprime.");
     }
 
 }
diff --git a/exercises/all-your-base/build.gradle b/exercises/all-your-base/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/all-your-base/src/test/java/BaseConverterTest.java b/exercises/all-your-base/src/test/java/BaseConverterTest.java
@@ -1,17 +1,14 @@
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertThrows;
+
 import org.junit.Ignore;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 import java.util.Arrays;
 
-import static org.junit.Assert.assertArrayEquals;
-
 public class BaseConverterTest {
 
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
     @Test
     public void testSingleBitOneToDecimal() {
         BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
@@ -218,79 +215,97 @@ public void testLeadingZeros() {
     @Ignore("Remove to run test")
     @Test
     public void testFirstBaseIsOne() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new BaseConverter(1, new int[]{1}));
 
-        new BaseConverter(1, new int[]{1});
+        assertThat(expected).hasMessage("Bases must be at least 2.");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testFirstBaseIsZero() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new BaseConverter(0, new int[]{1}));
 
-        new BaseConverter(0, new int[]{});
+        assertThat(expected).hasMessage("Bases must be at least 2.");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testFirstBaseIsNegative() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new BaseConverter(-2, new int[]{1}));
 
-        new BaseConverter(-2, new int[]{});
+        assertThat(expected).hasMessage("Bases must be at least 2.");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testNegativeDigit() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Digits may not be negative.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new BaseConverter(2, new int[]{1, -1, 1, 0, 1, 0}));
 
-        new BaseConverter(2, new int[]{1, -1, 1, 0, 1, 0});
+        assertThat(expected).hasMessage("Digits may not be negative.");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testInvalidPositiveDigit() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("All digits must be strictly less than the base.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new BaseConverter(2, new int[]{1, 2, 1, 0, 1, 0}));
 
-        new BaseConverter(2, new int[]{1, 2, 1, 0, 1, 0});
+        assertThat(expected)
+            .hasMessage("All digits must be strictly less than the base.");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsOne() {
-        BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+        BaseConverter baseConverter =
+            new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
 
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> baseConverter.convertToBase(1));
 
-        baseConverter.convertToBase(1);
+        assertThat(expected).hasMessage("Bases must be at least 2.");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsZero() {
         BaseConverter baseConverter = new BaseConverter(10, new int[]{7});
 
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> baseConverter.convertToBase(0));
 
-        baseConverter.convertToBase(0);
+        assertThat(expected).hasMessage("Bases must be at least 2.");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsNegative() {
         BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
 
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Bases must be at least 2.");
+        IllegalArgumentException expected =
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> baseConverter.convertToBase(-7));
 
-        baseConverter.convertToBase(-7);
+        assertThat(expected).hasMessage("Bases must be at least 2.");
     }
 
 }
diff --git a/exercises/allergies/build.gradle b/exercises/allergies/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/alphametics/build.gradle b/exercises/alphametics/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/alphametics/src/test/java/AlphameticsTest.java b/exercises/alphametics/src/test/java/AlphameticsTest.java
@@ -1,16 +1,12 @@
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
 
 import org.junit.Ignore;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 import java.util.LinkedHashMap;
 
-
 public class AlphameticsTest {
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
 
     @Test
     public void testThreeLetters() throws UnsolvablePuzzleException {
@@ -24,16 +20,18 @@ public void testThreeLetters() throws UnsolvablePuzzleException {
 
     @Ignore("Remove to run test")
     @Test
-    public void testUniqueValue() throws UnsolvablePuzzleException {
-        expectedException.expect(UnsolvablePuzzleException.class);
-        new Alphametics("A == B").solve();
+    public void testUniqueValue() {
+        Alphametics alphametics = new Alphametics("A == B");
+
+        assertThrows(UnsolvablePuzzleException.class, alphametics::solve);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testLeadingZero() throws UnsolvablePuzzleException {
-        expectedException.expect(UnsolvablePuzzleException.class);
-        new Alphametics("ACA + DD == BD").solve();
+    public void testLeadingZero() {
+        Alphametics alphametics = new Alphametics("ACA + DD == BD");
+
+        assertThrows(UnsolvablePuzzleException.class, alphametics::solve);
     }
 
     @Ignore("Remove to run test")

diff --git a/exercises/anagram/build.gradle b/exercises/anagram/build.gradle
@@ -7,7 +7,7 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
   testImplementation "org.assertj:assertj-core:3.15.0"
 }
 

diff --git a/exercises/anagram/src/test/java/AnagramTest.java b/exercises/anagram/src/test/java/AnagramTest.java
@@ -5,7 +5,6 @@
 
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.List;
 
 public class AnagramTest {
 

diff --git a/exercises/armstrong-numbers/build.gradle b/exercises/armstrong-numbers/build.gradle
@@ -7,7 +7,8 @@ repositories {
 }
 
 dependencies {
-  testCompile "junit:junit:4.12"
+  testCompile "junit:junit:4.13"
+  testImplementation "org.assertj:assertj-core:3.15.0"
 }
 
 test {

diff --git a/exercises/armstrong-numbers/src/main/java/ArmstrongNumbers.java b/exercises/armstrong-numbers/src/main/java/ArmstrongNumbers.java
@@ -1,9 +1,9 @@
 class ArmstrongNumbers {
 
-	boolean isArmstrongNumber(int numberToCheck) {
+    boolean isArmstrongNumber(int numberToCheck) {
 
-		throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
-		
-	}
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+
+    }
 
 }