From fefd7172a2ddff3356a6c37c1bb38b4ebc31374a Mon Sep 17 00:00:00 2001 From: Joao Esperancinha Date: Tue, 30 Jun 2020 15:52:17 +0200 Subject: [PATCH 1/4] [BAEL-4281] Examples of array comparisons --- java-collections/README.md | 8 +++ java-collections/pom.xml | 49 +++++++++++++++++++ .../com/baeldung/comparingarrays/Plane.java | 39 +++++++++++++++ .../src/main/resources/logback.xml | 13 +++++ .../baeldung/DeepEqualsCompareUnitTest.java | 34 +++++++++++++ .../com/baeldung/EqualsCompareUnitTest.java | 29 +++++++++++ .../com/baeldung/LengthsCompareUnitTest.java | 22 +++++++++ .../com/baeldung/OrderCompareUnitTest.java | 34 +++++++++++++ .../baeldung/ReferenceCompareUnitTest.java | 34 +++++++++++++ 9 files changed, 262 insertions(+) create mode 100644 java-collections/README.md create mode 100644 java-collections/pom.xml create mode 100644 java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java create mode 100644 java-collections/src/main/resources/logback.xml create mode 100644 java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java create mode 100644 java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java create mode 100644 java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java create mode 100644 java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java create mode 100644 java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java diff --git a/java-collections/README.md b/java-collections/README.md new file mode 100644 index 0000000000..480b7f257a --- /dev/null +++ b/java-collections/README.md @@ -0,0 +1,8 @@ +## Java Collections Examples + +This module support code for articles about handling java collections and arrays. + +### Relevant Articles: +- [Comparing two integer arrays in Java](https://stackoverflow.com/questions/14897366/comparing-two-integer-arrays-in-java) +- [Compare two arrays with not the same order](https://stackoverflow.com/questions/54711228/compare-two-arrays-with-not-the-same-order) +- More articles: [[next -->]](../java-collections-conversions-2) \ No newline at end of file diff --git a/java-collections/pom.xml b/java-collections/pom.xml new file mode 100644 index 0000000000..5e0ee42244 --- /dev/null +++ b/java-collections/pom.xml @@ -0,0 +1,49 @@ + + + 4.0.0 + java-collections + 0.1.0-SNAPSHOT + java-collections + jar + + + com.baeldung + parent-java + 0.0.1-SNAPSHOT + ../parent-java + + + + + org.apache.commons + commons-collections4 + ${commons-collections4.version} + + + org.apache.commons + commons-lang3 + ${commons-lang3.version} + + + org.hamcrest + hamcrest-all + ${hamcrest-all.version} + test + + + + + java-collections + + + src/main/resources + true + + + + + + 4.1 + + diff --git a/java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java b/java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java new file mode 100644 index 0000000000..db61807878 --- /dev/null +++ b/java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java @@ -0,0 +1,39 @@ +package com.baeldung.comparingarrays; + +import java.util.Objects; + +public class Plane { + + private final String name; + + private final String model; + + public Plane(String name, String model) { + + this.name = name; + this.model = model; + } + + public String getName() { + return name; + } + + public String getModel() { + return model; + } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + Plane plane = (Plane) o; + return Objects.equals(name, plane.name) && Objects.equals(model, plane.model); + } + + @Override + public int hashCode() { + return Objects.hash(name, model); + } +} diff --git a/java-collections/src/main/resources/logback.xml b/java-collections/src/main/resources/logback.xml new file mode 100644 index 0000000000..7d900d8ea8 --- /dev/null +++ b/java-collections/src/main/resources/logback.xml @@ -0,0 +1,13 @@ + + + + + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n + + + + + + + + \ No newline at end of file diff --git a/java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java new file mode 100644 index 0000000000..f311d0e5c9 --- /dev/null +++ b/java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java @@ -0,0 +1,34 @@ +package com.baeldung; + +import com.baeldung.comparingarrays.Plane; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class DeepEqualsCompareUnitTest { + + @Test + public void givenArray1andArray2_whenSameContent_thenDeepEquals() { + final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, + new Plane[] { new Plane("Plane 2", "B738") } }; + final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, + new Plane[] { new Plane("Plane 2", "B738") } }; + + boolean result = Arrays.deepEquals(planes1, planes2); + assertTrue("Result is not true", result); + } + + @Test + public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { + final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, + new Plane[] { new Plane("Plane 2", "B738") } }; + final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 2", "B738") }, + new Plane[] { new Plane("Plane 1", "A320") } }; + + boolean result = Arrays.deepEquals(planes1, planes2); + assertFalse("Result is true", result); + } +} diff --git a/java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java new file mode 100644 index 0000000000..b56395a848 --- /dev/null +++ b/java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java @@ -0,0 +1,29 @@ +package com.baeldung; + +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class EqualsCompareUnitTest { + + @Test + public void givenArray1andArray2_whenSameContent_thenEquals() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + + boolean result = Arrays.equals(planes1, planes2); + assertTrue("Result is not true", result); + } + + @Test + public void givenArray1andArray2_whenSameContentOtherSort_thenNotEquals() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = new String[] { "B738", "A320", "A321", "A319", "B77W", "B737", "A333", "A332" }; + + boolean result = Arrays.equals(planes1, planes2); + assertFalse("Result is true", result); + } +} diff --git a/java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java new file mode 100644 index 0000000000..8b3c90c427 --- /dev/null +++ b/java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java @@ -0,0 +1,22 @@ +package com.baeldung; + +import org.junit.jupiter.api.Test; + +import static org.hamcrest.Matchers.is; +import static org.hamcrest.collection.IsArrayWithSize.arrayWithSize; +import static org.junit.Assert.assertThat; + +public class LengthsCompareUnitTest { + + @Test + public void givenArray1andArray2_whenSameSizes_thenSizeEqualsOk() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final Integer[] quantities = new Integer[] { 10, 12, 34, 45, 12, 43, 5, 2 }; + + assertThat(planes1, arrayWithSize(8)); + assertThat(quantities, arrayWithSize(8)); + assertThat(planes1.length, is(8)); + assertThat(quantities.length, is(8)); + } +} + diff --git a/java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java new file mode 100644 index 0000000000..8be7251c05 --- /dev/null +++ b/java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java @@ -0,0 +1,34 @@ +package com.baeldung; + +import com.baeldung.comparingarrays.Plane; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.Comparator; + +import static org.junit.Assert.assertTrue; + +public class OrderCompareUnitTest { + @Test + public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { + final Plane[][] planes1 = new Plane[][] { + new Plane[] { new Plane("Plane 1", "A320"), new Plane("Plane 2", "B738") } }; + final Plane[][] planes2 = new Plane[][] { + new Plane[] { new Plane("Plane 2", "B738"), new Plane("Plane 1", "A320") } }; + + Comparator planeComparator = (o1, o2) -> { + if (o1.getName() + .equals(o2.getName())) { + return o2.getModel() + .compareTo(o1.getModel()); + } + return o2.getName() + .compareTo(o1.getName()); + }; + Arrays.sort(planes1[0], planeComparator); + Arrays.sort(planes2[0], planeComparator); + + boolean result = Arrays.deepEquals(planes1, planes2); + assertTrue("Result is false", result); + } +} diff --git a/java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java new file mode 100644 index 0000000000..9716a34607 --- /dev/null +++ b/java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java @@ -0,0 +1,34 @@ +package com.baeldung; + +import org.junit.jupiter.api.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertSame; + +public class ReferenceCompareUnitTest { + + @Test + public void givenArray1andArray2_whenEquals_thenEqual() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = planes1; + + assertSame("Objects are not equal!", planes1, planes2); + + planes2[0] = "747"; + + assertSame("Objects are not same!", planes1, planes2); + assertEquals("Objects are not equal!", "747", planes2[0]); + assertEquals("Objects are not equal!", "747", planes1[0]); + } + + @Test + public void givenArray1andArray2_whenDifferentValues_thenNotEqual() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + + assertNotSame("Objects are the same!", planes1, planes2); + assertNotEquals("Objects are equal!", planes1, planes2); + } +} From 1fc2f4358ebce4c791da63c0aca466733144c696 Mon Sep 17 00:00:00 2001 From: Joao Esperancinha Date: Tue, 21 Jul 2020 06:36:14 +0200 Subject: [PATCH 2/4] Revert "[BAEL-4281] Examples of array comparisons" This reverts commit fefd7172a2ddff3356a6c37c1bb38b4ebc31374a. --- java-collections/README.md | 8 --- java-collections/pom.xml | 49 ------------------- .../com/baeldung/comparingarrays/Plane.java | 39 --------------- .../src/main/resources/logback.xml | 13 ----- .../baeldung/DeepEqualsCompareUnitTest.java | 34 ------------- .../com/baeldung/EqualsCompareUnitTest.java | 29 ----------- .../com/baeldung/LengthsCompareUnitTest.java | 22 --------- .../com/baeldung/OrderCompareUnitTest.java | 34 ------------- .../baeldung/ReferenceCompareUnitTest.java | 34 ------------- 9 files changed, 262 deletions(-) delete mode 100644 java-collections/README.md delete mode 100644 java-collections/pom.xml delete mode 100644 java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java delete mode 100644 java-collections/src/main/resources/logback.xml delete mode 100644 java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java delete mode 100644 java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java delete mode 100644 java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java delete mode 100644 java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java delete mode 100644 java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java diff --git a/java-collections/README.md b/java-collections/README.md deleted file mode 100644 index 480b7f257a..0000000000 --- a/java-collections/README.md +++ /dev/null @@ -1,8 +0,0 @@ -## Java Collections Examples - -This module support code for articles about handling java collections and arrays. - -### Relevant Articles: -- [Comparing two integer arrays in Java](https://stackoverflow.com/questions/14897366/comparing-two-integer-arrays-in-java) -- [Compare two arrays with not the same order](https://stackoverflow.com/questions/54711228/compare-two-arrays-with-not-the-same-order) -- More articles: [[next -->]](../java-collections-conversions-2) \ No newline at end of file diff --git a/java-collections/pom.xml b/java-collections/pom.xml deleted file mode 100644 index 5e0ee42244..0000000000 --- a/java-collections/pom.xml +++ /dev/null @@ -1,49 +0,0 @@ - - - 4.0.0 - java-collections - 0.1.0-SNAPSHOT - java-collections - jar - - - com.baeldung - parent-java - 0.0.1-SNAPSHOT - ../parent-java - - - - - org.apache.commons - commons-collections4 - ${commons-collections4.version} - - - org.apache.commons - commons-lang3 - ${commons-lang3.version} - - - org.hamcrest - hamcrest-all - ${hamcrest-all.version} - test - - - - - java-collections - - - src/main/resources - true - - - - - - 4.1 - - diff --git a/java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java b/java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java deleted file mode 100644 index db61807878..0000000000 --- a/java-collections/src/main/java/com/baeldung/comparingarrays/Plane.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.baeldung.comparingarrays; - -import java.util.Objects; - -public class Plane { - - private final String name; - - private final String model; - - public Plane(String name, String model) { - - this.name = name; - this.model = model; - } - - public String getName() { - return name; - } - - public String getModel() { - return model; - } - - @Override - public boolean equals(Object o) { - if (this == o) - return true; - if (o == null || getClass() != o.getClass()) - return false; - Plane plane = (Plane) o; - return Objects.equals(name, plane.name) && Objects.equals(model, plane.model); - } - - @Override - public int hashCode() { - return Objects.hash(name, model); - } -} diff --git a/java-collections/src/main/resources/logback.xml b/java-collections/src/main/resources/logback.xml deleted file mode 100644 index 7d900d8ea8..0000000000 --- a/java-collections/src/main/resources/logback.xml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n - - - - - - - - \ No newline at end of file diff --git a/java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java deleted file mode 100644 index f311d0e5c9..0000000000 --- a/java-collections/src/test/java/com/baeldung/DeepEqualsCompareUnitTest.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.baeldung; - -import com.baeldung.comparingarrays.Plane; -import org.junit.jupiter.api.Test; - -import java.util.Arrays; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -public class DeepEqualsCompareUnitTest { - - @Test - public void givenArray1andArray2_whenSameContent_thenDeepEquals() { - final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, - new Plane[] { new Plane("Plane 2", "B738") } }; - final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, - new Plane[] { new Plane("Plane 2", "B738") } }; - - boolean result = Arrays.deepEquals(planes1, planes2); - assertTrue("Result is not true", result); - } - - @Test - public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { - final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, - new Plane[] { new Plane("Plane 2", "B738") } }; - final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 2", "B738") }, - new Plane[] { new Plane("Plane 1", "A320") } }; - - boolean result = Arrays.deepEquals(planes1, planes2); - assertFalse("Result is true", result); - } -} diff --git a/java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java deleted file mode 100644 index b56395a848..0000000000 --- a/java-collections/src/test/java/com/baeldung/EqualsCompareUnitTest.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.baeldung; - -import org.junit.jupiter.api.Test; - -import java.util.Arrays; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -public class EqualsCompareUnitTest { - - @Test - public void givenArray1andArray2_whenSameContent_thenEquals() { - final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - - boolean result = Arrays.equals(planes1, planes2); - assertTrue("Result is not true", result); - } - - @Test - public void givenArray1andArray2_whenSameContentOtherSort_thenNotEquals() { - final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - final String[] planes2 = new String[] { "B738", "A320", "A321", "A319", "B77W", "B737", "A333", "A332" }; - - boolean result = Arrays.equals(planes1, planes2); - assertFalse("Result is true", result); - } -} diff --git a/java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java deleted file mode 100644 index 8b3c90c427..0000000000 --- a/java-collections/src/test/java/com/baeldung/LengthsCompareUnitTest.java +++ /dev/null @@ -1,22 +0,0 @@ -package com.baeldung; - -import org.junit.jupiter.api.Test; - -import static org.hamcrest.Matchers.is; -import static org.hamcrest.collection.IsArrayWithSize.arrayWithSize; -import static org.junit.Assert.assertThat; - -public class LengthsCompareUnitTest { - - @Test - public void givenArray1andArray2_whenSameSizes_thenSizeEqualsOk() { - final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - final Integer[] quantities = new Integer[] { 10, 12, 34, 45, 12, 43, 5, 2 }; - - assertThat(planes1, arrayWithSize(8)); - assertThat(quantities, arrayWithSize(8)); - assertThat(planes1.length, is(8)); - assertThat(quantities.length, is(8)); - } -} - diff --git a/java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java deleted file mode 100644 index 8be7251c05..0000000000 --- a/java-collections/src/test/java/com/baeldung/OrderCompareUnitTest.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.baeldung; - -import com.baeldung.comparingarrays.Plane; -import org.junit.jupiter.api.Test; - -import java.util.Arrays; -import java.util.Comparator; - -import static org.junit.Assert.assertTrue; - -public class OrderCompareUnitTest { - @Test - public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { - final Plane[][] planes1 = new Plane[][] { - new Plane[] { new Plane("Plane 1", "A320"), new Plane("Plane 2", "B738") } }; - final Plane[][] planes2 = new Plane[][] { - new Plane[] { new Plane("Plane 2", "B738"), new Plane("Plane 1", "A320") } }; - - Comparator planeComparator = (o1, o2) -> { - if (o1.getName() - .equals(o2.getName())) { - return o2.getModel() - .compareTo(o1.getModel()); - } - return o2.getName() - .compareTo(o1.getName()); - }; - Arrays.sort(planes1[0], planeComparator); - Arrays.sort(planes2[0], planeComparator); - - boolean result = Arrays.deepEquals(planes1, planes2); - assertTrue("Result is false", result); - } -} diff --git a/java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java b/java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java deleted file mode 100644 index 9716a34607..0000000000 --- a/java-collections/src/test/java/com/baeldung/ReferenceCompareUnitTest.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.baeldung; - -import org.junit.jupiter.api.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertSame; - -public class ReferenceCompareUnitTest { - - @Test - public void givenArray1andArray2_whenEquals_thenEqual() { - final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - final String[] planes2 = planes1; - - assertSame("Objects are not equal!", planes1, planes2); - - planes2[0] = "747"; - - assertSame("Objects are not same!", planes1, planes2); - assertEquals("Objects are not equal!", "747", planes2[0]); - assertEquals("Objects are not equal!", "747", planes1[0]); - } - - @Test - public void givenArray1andArray2_whenDifferentValues_thenNotEqual() { - final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - - assertNotSame("Objects are the same!", planes1, planes2); - assertNotEquals("Objects are equal!", planes1, planes2); - } -} From 9787fc6f0f6f1bba64652770aedb66dbf0efd7b0 Mon Sep 17 00:00:00 2001 From: Joao Esperancinha Date: Tue, 21 Jul 2020 06:37:09 +0200 Subject: [PATCH 3/4] [BAEL-4281] moves example module --- .../java/com/baeldung/arraycompare/Plane.java | 39 +++++++++++++++++++ .../DeepEqualsCompareUnitTest.java | 33 ++++++++++++++++ .../arraycompare/EqualsCompareUnitTest.java | 29 ++++++++++++++ .../arraycompare/LengthsCompareUnitTest.java | 22 +++++++++++ .../arraycompare/OrderCompareUnitTest.java | 33 ++++++++++++++++ .../ReferenceCompareUnitTest.java | 34 ++++++++++++++++ 6 files changed, 190 insertions(+) create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arraycompare/Plane.java create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arraycompare/Plane.java b/core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arraycompare/Plane.java new file mode 100644 index 0000000000..1731578b76 --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arraycompare/Plane.java @@ -0,0 +1,39 @@ +package com.baeldung.arraycompare; + +import java.util.Objects; + +public class Plane { + + private final String name; + + private final String model; + + public Plane(String name, String model) { + + this.name = name; + this.model = model; + } + + public String getName() { + return name; + } + + public String getModel() { + return model; + } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + Plane plane = (Plane) o; + return Objects.equals(name, plane.name) && Objects.equals(model, plane.model); + } + + @Override + public int hashCode() { + return Objects.hash(name, model); + } +} diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java new file mode 100644 index 0000000000..ab7eaec127 --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java @@ -0,0 +1,33 @@ +package com.baeldung.arraycompare; + +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class DeepEqualsCompareUnitTest { + + @Test + public void givenArray1andArray2_whenSameContent_thenDeepEquals() { + final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, + new Plane[] { new Plane("Plane 2", "B738") } }; + final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, + new Plane[] { new Plane("Plane 2", "B738") } }; + + boolean result = Arrays.deepEquals(planes1, planes2); + assertTrue("Result is not true", result); + } + + @Test + public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { + final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, + new Plane[] { new Plane("Plane 2", "B738") } }; + final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 2", "B738") }, + new Plane[] { new Plane("Plane 1", "A320") } }; + + boolean result = Arrays.deepEquals(planes1, planes2); + assertFalse("Result is true", result); + } +} diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java new file mode 100644 index 0000000000..dd74eb8f0a --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java @@ -0,0 +1,29 @@ +package com.baeldung.arraycompare; + +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class EqualsCompareUnitTest { + + @Test + public void givenArray1andArray2_whenSameContent_thenEquals() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + + boolean result = Arrays.equals(planes1, planes2); + assertTrue("Result is not true", result); + } + + @Test + public void givenArray1andArray2_whenSameContentOtherSort_thenNotEquals() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = new String[] { "B738", "A320", "A321", "A319", "B77W", "B737", "A333", "A332" }; + + boolean result = Arrays.equals(planes1, planes2); + assertFalse("Result is true", result); + } +} diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java new file mode 100644 index 0000000000..ef22d69d90 --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java @@ -0,0 +1,22 @@ +package com.baeldung.arraycompare; + +import org.junit.jupiter.api.Test; + +import static org.hamcrest.Matchers.is; +import static org.hamcrest.collection.IsArrayWithSize.arrayWithSize; +import static org.junit.Assert.assertThat; + +public class LengthsCompareUnitTest { + + @Test + public void givenArray1andArray2_whenSameSizes_thenSizeEqualsOk() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final Integer[] quantities = new Integer[] { 10, 12, 34, 45, 12, 43, 5, 2 }; + + assertThat(planes1, arrayWithSize(8)); + assertThat(quantities, arrayWithSize(8)); + assertThat(planes1.length, is(8)); + assertThat(quantities.length, is(8)); + } +} + diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java new file mode 100644 index 0000000000..77cc91092a --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java @@ -0,0 +1,33 @@ +package com.baeldung.arraycompare; + +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.Comparator; + +import static org.junit.Assert.assertTrue; + +public class OrderCompareUnitTest { + @Test + public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { + final Plane[][] planes1 = new Plane[][] { + new Plane[] { new Plane("Plane 1", "A320"), new Plane("Plane 2", "B738") } }; + final Plane[][] planes2 = new Plane[][] { + new Plane[] { new Plane("Plane 2", "B738"), new Plane("Plane 1", "A320") } }; + + Comparator planeComparator = (o1, o2) -> { + if (o1.getName() + .equals(o2.getName())) { + return o2.getModel() + .compareTo(o1.getModel()); + } + return o2.getName() + .compareTo(o1.getName()); + }; + Arrays.sort(planes1[0], planeComparator); + Arrays.sort(planes2[0], planeComparator); + + boolean result = Arrays.deepEquals(planes1, planes2); + assertTrue("Result is false", result); + } +} diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java new file mode 100644 index 0000000000..8a26fc8e74 --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java @@ -0,0 +1,34 @@ +package com.baeldung.arraycompare; + +import org.junit.jupiter.api.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertSame; + +public class ReferenceCompareUnitTest { + + @Test + public void givenArray1andArray2_whenEquals_thenEqual() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = planes1; + + assertSame("Objects are not equal!", planes1, planes2); + + planes2[0] = "747"; + + assertSame("Objects are not same!", planes1, planes2); + assertEquals("Objects are not equal!", "747", planes2[0]); + assertEquals("Objects are not equal!", "747", planes1[0]); + } + + @Test + public void givenArray1andArray2_whenDifferentValues_thenNotEqual() { + final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; + + assertNotSame("Objects are the same!", planes1, planes2); + assertNotEquals("Objects are equal!", planes1, planes2); + } +} From c22df76e94140c718a86ed97d0884a96ffedb1f7 Mon Sep 17 00:00:00 2001 From: Joao Esperancinha Date: Tue, 21 Jul 2020 06:55:28 +0200 Subject: [PATCH 4/4] [BAEL-4281] Naming convention and conversion to assertJ --- .../DeepEqualsCompareUnitTest.java | 13 +++++------- .../arraycompare/EqualsCompareUnitTest.java | 13 +++++------- .../arraycompare/LengthsCompareUnitTest.java | 12 ++++------- .../arraycompare/OrderCompareUnitTest.java | 6 +++--- .../ReferenceCompareUnitTest.java | 20 ++++++++----------- 5 files changed, 25 insertions(+), 39 deletions(-) diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java index ab7eaec127..c8ebafb26b 100644 --- a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/DeepEqualsCompareUnitTest.java @@ -4,30 +4,27 @@ import org.junit.jupiter.api.Test; import java.util.Arrays; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; public class DeepEqualsCompareUnitTest { @Test - public void givenArray1andArray2_whenSameContent_thenDeepEquals() { + public void givenSameContents_whenDeepEquals_thenTrue() { final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, new Plane[] { new Plane("Plane 2", "B738") } }; final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, new Plane[] { new Plane("Plane 2", "B738") } }; - boolean result = Arrays.deepEquals(planes1, planes2); - assertTrue("Result is not true", result); + assertThat(Arrays.deepEquals(planes1, planes2)).isTrue(); } @Test - public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { + public void givenSameContentsWithDifferentOrder_whenDeepEquals_thenFalse() { final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320") }, new Plane[] { new Plane("Plane 2", "B738") } }; final Plane[][] planes2 = new Plane[][] { new Plane[] { new Plane("Plane 2", "B738") }, new Plane[] { new Plane("Plane 1", "A320") } }; - boolean result = Arrays.deepEquals(planes1, planes2); - assertFalse("Result is true", result); + assertThat(Arrays.deepEquals(planes1, planes2)).isFalse(); } } diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java index dd74eb8f0a..a022bf7082 100644 --- a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/EqualsCompareUnitTest.java @@ -4,26 +4,23 @@ import org.junit.jupiter.api.Test; import java.util.Arrays; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; public class EqualsCompareUnitTest { @Test - public void givenArray1andArray2_whenSameContent_thenEquals() { + public void givenSameContents_whenEquals_thenTrue() { final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - boolean result = Arrays.equals(planes1, planes2); - assertTrue("Result is not true", result); + assertThat(Arrays.equals(planes1, planes2)).isTrue(); } @Test - public void givenArray1andArray2_whenSameContentOtherSort_thenNotEquals() { + public void givenSameContentsDifferentOrder_whenEquals_thenFalse() { final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; final String[] planes2 = new String[] { "B738", "A320", "A321", "A319", "B77W", "B737", "A333", "A332" }; - boolean result = Arrays.equals(planes1, planes2); - assertFalse("Result is true", result); + assertThat(Arrays.equals(planes1, planes2)).isFalse(); } } diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java index ef22d69d90..23187b827c 100644 --- a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/LengthsCompareUnitTest.java @@ -2,21 +2,17 @@ package com.baeldung.arraycompare; import org.junit.jupiter.api.Test; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.collection.IsArrayWithSize.arrayWithSize; -import static org.junit.Assert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class LengthsCompareUnitTest { @Test - public void givenArray1andArray2_whenSameSizes_thenSizeEqualsOk() { + public void givenSameContent_whenSizeCompare_thenTrue() { final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; final Integer[] quantities = new Integer[] { 10, 12, 34, 45, 12, 43, 5, 2 }; - assertThat(planes1, arrayWithSize(8)); - assertThat(quantities, arrayWithSize(8)); - assertThat(planes1.length, is(8)); - assertThat(quantities.length, is(8)); + assertThat(planes1).hasSize(8); + assertThat(quantities).hasSize(8); } } diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java index 77cc91092a..4dd7964020 100644 --- a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/OrderCompareUnitTest.java @@ -5,11 +5,12 @@ import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.Comparator; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertTrue; public class OrderCompareUnitTest { @Test - public void givenArray1andArray2_whenNotSameContent_thenNotDeepEquals() { + public void givenSameContentDifferentOrder_whenSortedAndDeepEquals_thenTrue() { final Plane[][] planes1 = new Plane[][] { new Plane[] { new Plane("Plane 1", "A320"), new Plane("Plane 2", "B738") } }; final Plane[][] planes2 = new Plane[][] { @@ -27,7 +28,6 @@ public class OrderCompareUnitTest { Arrays.sort(planes1[0], planeComparator); Arrays.sort(planes2[0], planeComparator); - boolean result = Arrays.deepEquals(planes1, planes2); - assertTrue("Result is false", result); + assertThat(Arrays.deepEquals(planes1, planes2)).isTrue(); } } diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java index 8a26fc8e74..d8072a98e3 100644 --- a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ReferenceCompareUnitTest.java @@ -2,33 +2,29 @@ package com.baeldung.arraycompare; import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertSame; +import static org.assertj.core.api.Assertions.assertThat; public class ReferenceCompareUnitTest { @Test - public void givenArray1andArray2_whenEquals_thenEqual() { + public void givenSameReferences_whenSame_thenTrue() { final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; final String[] planes2 = planes1; - assertSame("Objects are not equal!", planes1, planes2); + assertThat(planes1).isSameAs(planes2); planes2[0] = "747"; - assertSame("Objects are not same!", planes1, planes2); - assertEquals("Objects are not equal!", "747", planes2[0]); - assertEquals("Objects are not equal!", "747", planes1[0]); + assertThat(planes1).isSameAs(planes2); + assertThat(planes2[0]).isEqualTo("747"); + assertThat(planes1[0]).isEqualTo("747"); } @Test - public void givenArray1andArray2_whenDifferentValues_thenNotEqual() { + public void givenSameContentDifferentReferences_whenSame_thenFalse() { final String[] planes1 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; final String[] planes2 = new String[] { "A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332" }; - assertNotSame("Objects are the same!", planes1, planes2); - assertNotEquals("Objects are equal!", planes1, planes2); + assertThat(planes1).isNotSameAs(planes2); } }