Update change calculator test to use assertj (exercism#2147) (exercism#2509)

pavanbaloju · web-flow · commit 633956bb96e5 · 2023-10-05T19:01:30.000+02:00
diff --git a/exercises/practice/change/src/test/java/ChangeCalculatorTest.java b/exercises/practice/change/src/test/java/ChangeCalculatorTest.java
@@ -1,31 +1,27 @@
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.junit.Assert.assertEquals;
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static java.util.Collections.singletonList;
-
 import org.junit.Ignore;
 import org.junit.Test;
 
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
 public class ChangeCalculatorTest {
 
     @Test
     public void testChangeThatCanBeGivenInASingleCoin() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 25, 100));
 
-        assertEquals(
-                singletonList(25),
-                changeCalculator.computeMostEfficientChange(25));
+        assertThat(changeCalculator.computeMostEfficientChange(25))
+            .containsExactly(25);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testChangeThatMustBeGivenInMultipleCoins() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 25, 100));
 
-        assertEquals(
-                asList(5, 10),
-                changeCalculator.computeMostEfficientChange(15));
+        assertThat(changeCalculator.computeMostEfficientChange(15))
+            .containsExactly(5, 10);
     }
 
     @Ignore("Remove to run test")
@@ -34,9 +30,8 @@ public void testChangeThatMustBeGivenInMultipleCoins() {
     public void testLilliputianCurrency() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 4, 15, 20, 50));
 
-        assertEquals(
-                asList(4, 4, 15),
-                changeCalculator.computeMostEfficientChange(23));
+        assertThat(changeCalculator.computeMostEfficientChange(23))
+            .containsExactly(4, 4, 15);
     }
 
     @Ignore("Remove to run test")
@@ -45,19 +40,17 @@ public void testLilliputianCurrency() {
     public void testLowerElbonianCurrency() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 21, 25));
 
-        assertEquals(
-                asList(21, 21, 21),
-                changeCalculator.computeMostEfficientChange(63));
+        assertThat(changeCalculator.computeMostEfficientChange(63))
+            .containsExactly(21, 21, 21);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testLargeAmountOfChange() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 2, 5, 10, 20, 50, 100));
 
-        assertEquals(
-                asList(2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100),
-                changeCalculator.computeMostEfficientChange(999));
+        assertThat(changeCalculator.computeMostEfficientChange(999))
+            .containsExactly(2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100);
     }
 
     @Ignore("Remove to run test")
@@ -66,9 +59,8 @@ public void testLargeAmountOfChange() {
     public void testPossibleChangeWithoutUnitCoinAvailable() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(2, 5, 10, 20, 50));
 
-        assertEquals(
-                asList(2, 2, 2, 5, 10),
-                changeCalculator.computeMostEfficientChange(21));
+        assertThat(changeCalculator.computeMostEfficientChange(21))
+            .containsExactly(2, 2, 2, 5, 10);
     }
 
     @Ignore("Remove to run test")
@@ -77,19 +69,17 @@ public void testPossibleChangeWithoutUnitCoinAvailable() {
     public void testAnotherPossibleChangeWithoutUnitCoinAvailable() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(4, 5));
 
-        assertEquals(
-                asList(4, 4, 4, 5, 5, 5),
-                changeCalculator.computeMostEfficientChange(27));
+        assertThat(changeCalculator.computeMostEfficientChange(27))
+            .containsExactly(4, 4, 4, 5, 5, 5);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testZeroChange() {
         ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 21, 25));
 
-        assertEquals(
-                emptyList(),
-                changeCalculator.computeMostEfficientChange(0));
+        assertThat(changeCalculator.computeMostEfficientChange(0))
+            .isEmpty();
     }
 
     @Ignore("Remove to run test")
