From efdb3f65b3b98538daac7413171108759ceab231 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Mon, 23 Oct 2023 19:15:17 +0000 Subject: [PATCH 01/11] return first non null and non empty optional unit tests --- .../ReturnFirstNonEmptyOptionalUnitTest.java | 37 ++++++ ...eturnFirstNonNullLazyEvaluateUnitTest.java | 69 +++++++++++ .../ReturnFirstNonNullUnitTest.java | 108 ++++++++++++++++++ 3 files changed, 214 insertions(+) create mode 100644 core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java create mode 100644 core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java create mode 100644 core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java diff --git a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java new file mode 100644 index 0000000000..439cae6235 --- /dev/null +++ b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java @@ -0,0 +1,37 @@ +package returnfirstnonempty; + +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class ReturnFirstNonEmptyOptionalUnitTest { + + private List> optionals; + + @Before + public void init() { + optionals = Arrays.asList( + Optional.empty(), + Optional.of(new Object()), + Optional.empty() + ); + } + + @Test + public void givenListOfOptionals_thenReturnFirstNonEmpty() { + Object object = optionals + .stream() + .filter(Optional::isPresent) + .map(Optional::get) + .findFirst(); + + assertTrue(object != null); + assertEquals(optionals.get(1), object); + } +} \ No newline at end of file diff --git a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java new file mode 100644 index 0000000000..ae8ca09ea1 --- /dev/null +++ b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java @@ -0,0 +1,69 @@ +package returnfirstnonull; + +import java.util.Objects; +import java.util.Optional; +import java.util.function.Supplier; +import java.util.stream.Stream; + +import org.apache.commons.lang3.ObjectUtils; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class ReturnFirstNonNullLazyEvaluateUnitTest { + + private static Object METHOD_B_OBJECT = new Object(); + + private Object methodA() { return null; } + + private Object methodB() { return METHOD_B_OBJECT; } + + private Object methodC() { return null; } + + @Test + public void givenChainOfMethods_thenLazilyEvaluateMethodsUntilFirstNonNull() { + Object object = methodA(); + if(object == null) + object = methodB(); + + if(object == null) + object = methodC(); + + assertTrue(object != null); + assertEquals(METHOD_B_OBJECT, object); + } + + @Test + public void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() { + Optional object = Stream + .>of( + this::methodA, + this::methodB, + this::methodC) + .map(Supplier::get) + .filter(Objects::nonNull) + .findFirst(); + + assertTrue(object.isPresent()); + assertEquals(METHOD_B_OBJECT, object.get()); + } + + @Test + public void givenTwoObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + Object object1 = methodA(); + Object object = ObjectUtils.getIfNull(object1, this::methodB); + + assertTrue(object != null); + assertEquals(METHOD_B_OBJECT, object); + } + + @Test + public void givenChainOfMethods_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + Object object = ObjectUtils.getFirstNonNull(this::methodA, this::methodB, this::methodC); + + assertTrue(object != null); + assertEquals(METHOD_B_OBJECT, object); + } +} \ No newline at end of file diff --git a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java new file mode 100644 index 0000000000..ddf3a131da --- /dev/null +++ b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java @@ -0,0 +1,108 @@ +package returnfirstnonull; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.Optional; + +import org.apache.commons.lang3.ObjectUtils; + +import org.junit.Before; +import org.junit.Test; + +import com.google.common.base.MoreObjects; +import com.google.common.base.Predicates; +import com.google.common.collect.Iterables; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +public class ReturnFirstNonNullUnitTest { + + private List objects; + + @Before + public void init() { + objects = Arrays.asList( + null, + new Object(), + new Object() + ); + } + + @Test + public void givenListOfObjects_whenIteratingWithForLoop_thenReturnFirstNonNull() { + Object object = null; + for(int i = 0; i < objects.size(); i++) { + if(objects.get(i) != null) { + object = objects.get(i); + break; + } + } + + assertTrue(object != null); + assertEquals(objects.get(1), object); + } + + @Test + public void givenListOfObjects_whenIteratingWithEnhancedForLoop_thenReturnFirstNonNull() { + Object object = null; + for(Object o: objects) { + if(o != null) { + object = o; + break; + } + } + + assertTrue(object != null); + assertEquals(objects.get(1), object); + } + + @Test + public void givenListOfObjects_whenFilterIsLambdaNullCheck_thenReturnFirstNonNull() { + Optional object = objects + .stream() + .filter(o -> o != null) + .findFirst(); + + assertTrue(object.isPresent()); + assertEquals(objects.get(1), object.get()); + } + + @Test + public void givenListOfObjects_whenFilterIsMethodRefNullCheck_thenReturnFirstNonNull() { + Optional object = objects + .stream() + .filter(Objects::nonNull) + .findFirst(); + + assertTrue(object.isPresent()); + assertEquals(objects.get(1), object.get()); + } + + @Test + public void givenListOfObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + Object object = ObjectUtils.firstNonNull(objects.toArray()); + + assertTrue(object != null); + assertEquals(objects.get(1), object); + } + + @Test + public void givenTwoObjects_whenUsingGoogleGuava_thenReturnFirstNonNull() { + Object object1 = null; + Object object2 = new Object(); + Object object = MoreObjects.firstNonNull(object1, object2); + + assertTrue(object != null); + assertEquals(object2, object); + } + + @Test + public void givenListOfObjects_whenUsingGoogleGuava_thenReturnFirstNonNull() { + Object object = Iterables.find(objects, Predicates.notNull()); + + assertTrue(object != null); + assertEquals(objects.get(1), object); + } +} \ No newline at end of file From 9d66171dd55ebbab41c74962f3a2dfad95edbe66 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Tue, 31 Oct 2023 20:19:54 +0000 Subject: [PATCH 02/11] change unit test name for apache commons unit test given one object and alt method --- .../ReturnFirstNonNullLazyEvaluateUnitTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java index ae8ca09ea1..4064ec612c 100644 --- a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java +++ b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java @@ -51,8 +51,8 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { } @Test - public void givenTwoObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { - Object object1 = methodA(); + public void givenNullableObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + Object object1 = null; Object object = ObjectUtils.getIfNull(object1, this::methodB); assertTrue(object != null); From a33bdf8a0309c30597d8e1ba7c7bc4672085d341 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sun, 5 Nov 2023 11:37:03 +0000 Subject: [PATCH 03/11] Use String over Object for unit tests --- .../ReturnFirstNonEmptyOptionalUnitTest.java | 30 +++++ ...eturnFirstNonNullLazyEvaluateUnitTest.java | 79 +++++++++++++ .../ReturnFirstNonNullUnitTest.java | 79 +++++++++++++ .../ReturnFirstNonEmptyOptionalUnitTest.java | 37 ------ ...eturnFirstNonNullLazyEvaluateUnitTest.java | 69 ----------- .../ReturnFirstNonNullUnitTest.java | 108 ------------------ 6 files changed, 188 insertions(+), 214 deletions(-) create mode 100644 core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java create mode 100644 core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java create mode 100644 core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java delete mode 100644 core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java delete mode 100644 core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java delete mode 100644 core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java new file mode 100644 index 0000000000..d855959f51 --- /dev/null +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java @@ -0,0 +1,30 @@ +package com.baeldung.returnfirstnonempty; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class ReturnFirstNonEmptyOptionalUnitTest { + + private List> optionals; + + @BeforeEach + public void init() { + optionals = Arrays.asList(Optional. empty(), Optional.of("first non null"), Optional.of("second non null")); + } + + @Test + public void givenListOfOptionals_thenReturnFirstNonEmpty() { + Optional object = optionals.stream() + .filter(Optional::isPresent) + .map(Optional::get) + .findFirst(); + + assertThat(object).contains("first non null"); + } +} \ No newline at end of file diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java new file mode 100644 index 0000000000..f6bf6adbdc --- /dev/null +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java @@ -0,0 +1,79 @@ +package com.baeldung.returnfirstnonnull; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import java.util.Objects; +import java.util.Optional; +import java.util.function.Supplier; +import java.util.stream.Stream; + +import org.apache.commons.lang3.ObjectUtils; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.mockito.Spy; + +public class ReturnFirstNonNullLazyEvaluateUnitTest { + + @Spy + private final LazyEvaluate spy = Mockito.spy(new LazyEvaluate()); + + @Test + public void givenChainOfMethods_thenLazilyEvaluateMethodsUntilFirstNonNull() { + String object = spy.methodA(); + if (object == null) { + object = spy.methodB(); + } + + if (object == null) { + object = spy.methodC(); + } + + assertEquals("first non null", object); + verify(spy, times(1)).methodA(); + verify(spy, times(1)).methodB(); + verify(spy, times(0)).methodC(); + } + + @Test + public void givenChainOfMethods_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + String object = ObjectUtils.getFirstNonNull(spy::methodA, spy::methodB, spy::methodC); + + assertEquals("first non null", object); + verify(spy, times(1)).methodA(); + verify(spy, times(1)).methodB(); + verify(spy, times(0)).methodC(); + } + + @Test + public void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() { + Optional object = Stream.> of(spy::methodA, spy::methodB, spy::methodC) + .map(Supplier::get) + .filter(Objects::nonNull) + .findFirst(); + + assertThat(object).contains("first non null"); + verify(spy, times(1)).methodA(); + verify(spy, times(1)).methodB(); + verify(spy, times(0)).methodC(); + } + + @Test + public void givenNonNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + String nonNullObject = spy.methodB(); + String object = ObjectUtils.getIfNull(nonNullObject, spy::methodC); + + assertEquals("first non null", object); + verify(spy, times(0)).methodC(); + } + + @Test + public void givenNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + String nullObject = null; + String object = ObjectUtils.getIfNull(nullObject, spy::methodB); + + assertEquals("first non null", object); + } +} \ No newline at end of file diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java new file mode 100644 index 0000000000..19b25d3265 --- /dev/null +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java @@ -0,0 +1,79 @@ +package com.baeldung.returnfirstnonnull; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.Optional; + +import org.apache.commons.lang3.ObjectUtils; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import com.google.common.base.MoreObjects; +import com.google.common.base.Predicates; +import com.google.common.collect.Iterables; + +public class ReturnFirstNonNullUnitTest { + + private List objects; + + @BeforeEach + public void init() { + objects = Arrays.asList(null, "first non null", "second nun null"); + } + + @Test + public void givenListOfObjects_whenFilterIsLambdaNullCheck_thenReturnFirstNonNull() { + Optional object = objects.stream() + .filter(o -> o != null) + .findFirst(); + + assertThat(object).contains("first non null"); + } + + @Test + public void givenListOfObjects_whenFilterIsMethodRefNullCheck_thenReturnFirstNonNull() { + Optional object = objects.stream() + .filter(Objects::nonNull) + .findFirst(); + + assertThat(object).contains("first non null"); + } + + @Test + public void givenListOfObjects_whenIteratingWithForLoop_thenReturnFirstNonNull() { + String object = null; + for (int i = 0; i < objects.size(); i++) { + if (objects.get(i) != null) { + object = objects.get(i); + break; + } + } + + assertEquals("first non null", object); + } + + @Test + public void givenListOfObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + String object = ObjectUtils.firstNonNull(objects.toArray(new String[0])); + + assertEquals("first non null", object); + } + + @Test + public void givenListOfObjects_whenUsingGoogleGuavaIterables_thenReturnFirstNonNull() { + String object = Iterables.find(objects, Predicates.notNull()); + + assertEquals("first non null", object); + } + + @Test + public void givenTwoObjects_whenUsingGoogleGuavaMoreObjects_thenReturnFirstNonNull() { + String object = MoreObjects.firstNonNull(null, "first non null"); + + assertEquals("first non null", object); + } +} \ No newline at end of file diff --git a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java deleted file mode 100644 index 439cae6235..0000000000 --- a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java +++ /dev/null @@ -1,37 +0,0 @@ -package returnfirstnonempty; - -import java.util.Arrays; -import java.util.List; -import java.util.Optional; - -import org.junit.Before; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -public class ReturnFirstNonEmptyOptionalUnitTest { - - private List> optionals; - - @Before - public void init() { - optionals = Arrays.asList( - Optional.empty(), - Optional.of(new Object()), - Optional.empty() - ); - } - - @Test - public void givenListOfOptionals_thenReturnFirstNonEmpty() { - Object object = optionals - .stream() - .filter(Optional::isPresent) - .map(Optional::get) - .findFirst(); - - assertTrue(object != null); - assertEquals(optionals.get(1), object); - } -} \ No newline at end of file diff --git a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java deleted file mode 100644 index 4064ec612c..0000000000 --- a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java +++ /dev/null @@ -1,69 +0,0 @@ -package returnfirstnonull; - -import java.util.Objects; -import java.util.Optional; -import java.util.function.Supplier; -import java.util.stream.Stream; - -import org.apache.commons.lang3.ObjectUtils; - -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -public class ReturnFirstNonNullLazyEvaluateUnitTest { - - private static Object METHOD_B_OBJECT = new Object(); - - private Object methodA() { return null; } - - private Object methodB() { return METHOD_B_OBJECT; } - - private Object methodC() { return null; } - - @Test - public void givenChainOfMethods_thenLazilyEvaluateMethodsUntilFirstNonNull() { - Object object = methodA(); - if(object == null) - object = methodB(); - - if(object == null) - object = methodC(); - - assertTrue(object != null); - assertEquals(METHOD_B_OBJECT, object); - } - - @Test - public void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() { - Optional object = Stream - .>of( - this::methodA, - this::methodB, - this::methodC) - .map(Supplier::get) - .filter(Objects::nonNull) - .findFirst(); - - assertTrue(object.isPresent()); - assertEquals(METHOD_B_OBJECT, object.get()); - } - - @Test - public void givenNullableObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { - Object object1 = null; - Object object = ObjectUtils.getIfNull(object1, this::methodB); - - assertTrue(object != null); - assertEquals(METHOD_B_OBJECT, object); - } - - @Test - public void givenChainOfMethods_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { - Object object = ObjectUtils.getFirstNonNull(this::methodA, this::methodB, this::methodC); - - assertTrue(object != null); - assertEquals(METHOD_B_OBJECT, object); - } -} \ No newline at end of file diff --git a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java deleted file mode 100644 index ddf3a131da..0000000000 --- a/core-java-modules/core-java-lang-oop-patterns/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java +++ /dev/null @@ -1,108 +0,0 @@ -package returnfirstnonull; - -import java.util.Arrays; -import java.util.List; -import java.util.Objects; -import java.util.Optional; - -import org.apache.commons.lang3.ObjectUtils; - -import org.junit.Before; -import org.junit.Test; - -import com.google.common.base.MoreObjects; -import com.google.common.base.Predicates; -import com.google.common.collect.Iterables; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; - -public class ReturnFirstNonNullUnitTest { - - private List objects; - - @Before - public void init() { - objects = Arrays.asList( - null, - new Object(), - new Object() - ); - } - - @Test - public void givenListOfObjects_whenIteratingWithForLoop_thenReturnFirstNonNull() { - Object object = null; - for(int i = 0; i < objects.size(); i++) { - if(objects.get(i) != null) { - object = objects.get(i); - break; - } - } - - assertTrue(object != null); - assertEquals(objects.get(1), object); - } - - @Test - public void givenListOfObjects_whenIteratingWithEnhancedForLoop_thenReturnFirstNonNull() { - Object object = null; - for(Object o: objects) { - if(o != null) { - object = o; - break; - } - } - - assertTrue(object != null); - assertEquals(objects.get(1), object); - } - - @Test - public void givenListOfObjects_whenFilterIsLambdaNullCheck_thenReturnFirstNonNull() { - Optional object = objects - .stream() - .filter(o -> o != null) - .findFirst(); - - assertTrue(object.isPresent()); - assertEquals(objects.get(1), object.get()); - } - - @Test - public void givenListOfObjects_whenFilterIsMethodRefNullCheck_thenReturnFirstNonNull() { - Optional object = objects - .stream() - .filter(Objects::nonNull) - .findFirst(); - - assertTrue(object.isPresent()); - assertEquals(objects.get(1), object.get()); - } - - @Test - public void givenListOfObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { - Object object = ObjectUtils.firstNonNull(objects.toArray()); - - assertTrue(object != null); - assertEquals(objects.get(1), object); - } - - @Test - public void givenTwoObjects_whenUsingGoogleGuava_thenReturnFirstNonNull() { - Object object1 = null; - Object object2 = new Object(); - Object object = MoreObjects.firstNonNull(object1, object2); - - assertTrue(object != null); - assertEquals(object2, object); - } - - @Test - public void givenListOfObjects_whenUsingGoogleGuava_thenReturnFirstNonNull() { - Object object = Iterables.find(objects, Predicates.notNull()); - - assertTrue(object != null); - assertEquals(objects.get(1), object); - } -} \ No newline at end of file From 88a92d399cb7d48c687f735d607c10d1af4dc070 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sun, 5 Nov 2023 11:43:32 +0000 Subject: [PATCH 04/11] Add LazyEvaluate class --- .../returnfirstnonnull/LazyEvaluate.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 core-java-modules/core-java-lang-6/src/main/java/com/baeldung/returnfirstnonnull/LazyEvaluate.java diff --git a/core-java-modules/core-java-lang-6/src/main/java/com/baeldung/returnfirstnonnull/LazyEvaluate.java b/core-java-modules/core-java-lang-6/src/main/java/com/baeldung/returnfirstnonnull/LazyEvaluate.java new file mode 100644 index 0000000000..faa6cce465 --- /dev/null +++ b/core-java-modules/core-java-lang-6/src/main/java/com/baeldung/returnfirstnonnull/LazyEvaluate.java @@ -0,0 +1,16 @@ +package com.baeldung.returnfirstnonnull; + +class LazyEvaluate { + + String methodA() { + return null; + } + + String methodB() { + return "first non null"; + } + + String methodC() { + return "second non null"; + } +} \ No newline at end of file From 8f01f4545564109b63595f2f3aaa490d6f70e4b5 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sun, 5 Nov 2023 12:06:33 +0000 Subject: [PATCH 05/11] Modify givenTwoObjects_whenUsingGoogleGuavaMoreObjects_thenReturnFirstNonNull() unit test to have two extra local variables for readability --- .../returnfirstnonnull/ReturnFirstNonNullUnitTest.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java index 19b25d3265..f99a8cb419 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java @@ -72,7 +72,9 @@ public class ReturnFirstNonNullUnitTest { @Test public void givenTwoObjects_whenUsingGoogleGuavaMoreObjects_thenReturnFirstNonNull() { - String object = MoreObjects.firstNonNull(null, "first non null"); + String nullObject = null; + String nonNullObject = "first non null"; + String object = MoreObjects.firstNonNull(nullObject, nonNullObject); assertEquals("first non null", object); } From a8e298e3898c9d298bff410aca0903898307aab7 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sun, 5 Nov 2023 20:11:49 +0000 Subject: [PATCH 06/11] Modify Optional value to be more descriptive --- .../ReturnFirstNonEmptyOptionalUnitTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java index d855959f51..c432af6591 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java @@ -15,7 +15,7 @@ public class ReturnFirstNonEmptyOptionalUnitTest { @BeforeEach public void init() { - optionals = Arrays.asList(Optional. empty(), Optional.of("first non null"), Optional.of("second non null")); + optionals = Arrays.asList(Optional. empty(), Optional.of("first non empty"), Optional.of("second non empty")); } @Test @@ -25,6 +25,6 @@ public class ReturnFirstNonEmptyOptionalUnitTest { .map(Optional::get) .findFirst(); - assertThat(object).contains("first non null"); + assertThat(object).contains("first non empty"); } } \ No newline at end of file From 392928ccfaac9eb3f0521b2c914b9b2f1905e053 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Mon, 6 Nov 2023 20:59:54 +0000 Subject: [PATCH 07/11] Remove unnecessary spy annotation and make unit tests package private --- .../ReturnFirstNonEmptyOptionalUnitTest.java | 2 +- .../ReturnFirstNonNullLazyEvaluateUnitTest.java | 12 +++++------- .../ReturnFirstNonNullUnitTest.java | 12 ++++++------ 3 files changed, 12 insertions(+), 14 deletions(-) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java index c432af6591..4686692215 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java @@ -19,7 +19,7 @@ public class ReturnFirstNonEmptyOptionalUnitTest { } @Test - public void givenListOfOptionals_thenReturnFirstNonEmpty() { + void givenListOfOptionals_thenReturnFirstNonEmpty() { Optional object = optionals.stream() .filter(Optional::isPresent) .map(Optional::get) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java index f6bf6adbdc..649e5f4299 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java @@ -13,15 +13,13 @@ import java.util.stream.Stream; import org.apache.commons.lang3.ObjectUtils; import org.junit.jupiter.api.Test; import org.mockito.Mockito; -import org.mockito.Spy; public class ReturnFirstNonNullLazyEvaluateUnitTest { - @Spy private final LazyEvaluate spy = Mockito.spy(new LazyEvaluate()); @Test - public void givenChainOfMethods_thenLazilyEvaluateMethodsUntilFirstNonNull() { + void givenChainOfMethods_thenLazilyEvaluateMethodsUntilFirstNonNull() { String object = spy.methodA(); if (object == null) { object = spy.methodB(); @@ -38,7 +36,7 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { } @Test - public void givenChainOfMethods_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + void givenChainOfMethods_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { String object = ObjectUtils.getFirstNonNull(spy::methodA, spy::methodB, spy::methodC); assertEquals("first non null", object); @@ -48,7 +46,7 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { } @Test - public void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() { + void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() { Optional object = Stream.> of(spy::methodA, spy::methodB, spy::methodC) .map(Supplier::get) .filter(Objects::nonNull) @@ -61,7 +59,7 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { } @Test - public void givenNonNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + void givenNonNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { String nonNullObject = spy.methodB(); String object = ObjectUtils.getIfNull(nonNullObject, spy::methodC); @@ -70,7 +68,7 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { } @Test - public void givenNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + void givenNullObjectAndFallbackMethod_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { String nullObject = null; String object = ObjectUtils.getIfNull(nullObject, spy::methodB); diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java index f99a8cb419..aae775997d 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java @@ -26,7 +26,7 @@ public class ReturnFirstNonNullUnitTest { } @Test - public void givenListOfObjects_whenFilterIsLambdaNullCheck_thenReturnFirstNonNull() { + void givenListOfObjects_whenFilterIsLambdaNullCheck_thenReturnFirstNonNull() { Optional object = objects.stream() .filter(o -> o != null) .findFirst(); @@ -35,7 +35,7 @@ public class ReturnFirstNonNullUnitTest { } @Test - public void givenListOfObjects_whenFilterIsMethodRefNullCheck_thenReturnFirstNonNull() { + void givenListOfObjects_whenFilterIsMethodRefNullCheck_thenReturnFirstNonNull() { Optional object = objects.stream() .filter(Objects::nonNull) .findFirst(); @@ -44,7 +44,7 @@ public class ReturnFirstNonNullUnitTest { } @Test - public void givenListOfObjects_whenIteratingWithForLoop_thenReturnFirstNonNull() { + void givenListOfObjects_whenIteratingWithForLoop_thenReturnFirstNonNull() { String object = null; for (int i = 0; i < objects.size(); i++) { if (objects.get(i) != null) { @@ -57,21 +57,21 @@ public class ReturnFirstNonNullUnitTest { } @Test - public void givenListOfObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { + void givenListOfObjects_whenUsingApacheCommonsLang3_thenReturnFirstNonNull() { String object = ObjectUtils.firstNonNull(objects.toArray(new String[0])); assertEquals("first non null", object); } @Test - public void givenListOfObjects_whenUsingGoogleGuavaIterables_thenReturnFirstNonNull() { + void givenListOfObjects_whenUsingGoogleGuavaIterables_thenReturnFirstNonNull() { String object = Iterables.find(objects, Predicates.notNull()); assertEquals("first non null", object); } @Test - public void givenTwoObjects_whenUsingGoogleGuavaMoreObjects_thenReturnFirstNonNull() { + void givenTwoObjects_whenUsingGoogleGuavaMoreObjects_thenReturnFirstNonNull() { String nullObject = null; String nonNullObject = "first non null"; String object = MoreObjects.firstNonNull(nullObject, nonNullObject); From c03477e2bd52385683bbb4d93ee1af3b731d4e02 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sat, 11 Nov 2023 19:14:58 +0000 Subject: [PATCH 08/11] rename returning first non empty optional test method --- .../ReturnFirstNonEmptyOptionalUnitTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java index 4686692215..f2ea8f74e3 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java @@ -19,7 +19,7 @@ public class ReturnFirstNonEmptyOptionalUnitTest { } @Test - void givenListOfOptionals_thenReturnFirstNonEmpty() { + void givenListOfOptionals_whenStreaming_thenReturnFirstNonEmpty() { Optional object = optionals.stream() .filter(Optional::isPresent) .map(Optional::get) From 2581618debfd1519af6dd37160d0d0942fcff927 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sat, 11 Nov 2023 19:17:28 +0000 Subject: [PATCH 09/11] indent fluent apis 2 spaces --- .../ReturnFirstNonEmptyOptionalUnitTest.java | 6 +++--- .../ReturnFirstNonNullLazyEvaluateUnitTest.java | 6 +++--- .../returnfirstnonnull/ReturnFirstNonNullUnitTest.java | 8 ++++---- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java index f2ea8f74e3..b05e0e2d34 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java @@ -21,9 +21,9 @@ public class ReturnFirstNonEmptyOptionalUnitTest { @Test void givenListOfOptionals_whenStreaming_thenReturnFirstNonEmpty() { Optional object = optionals.stream() - .filter(Optional::isPresent) - .map(Optional::get) - .findFirst(); + .filter(Optional::isPresent) + .map(Optional::get) + .findFirst(); assertThat(object).contains("first non empty"); } diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java index 649e5f4299..fff348052a 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java @@ -48,9 +48,9 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { @Test void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() { Optional object = Stream.> of(spy::methodA, spy::methodB, spy::methodC) - .map(Supplier::get) - .filter(Objects::nonNull) - .findFirst(); + .map(Supplier::get) + .filter(Objects::nonNull) + .findFirst(); assertThat(object).contains("first non null"); verify(spy, times(1)).methodA(); diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java index aae775997d..e7bb4d399f 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java @@ -28,8 +28,8 @@ public class ReturnFirstNonNullUnitTest { @Test void givenListOfObjects_whenFilterIsLambdaNullCheck_thenReturnFirstNonNull() { Optional object = objects.stream() - .filter(o -> o != null) - .findFirst(); + .filter(o -> o != null) + .findFirst(); assertThat(object).contains("first non null"); } @@ -37,8 +37,8 @@ public class ReturnFirstNonNullUnitTest { @Test void givenListOfObjects_whenFilterIsMethodRefNullCheck_thenReturnFirstNonNull() { Optional object = objects.stream() - .filter(Objects::nonNull) - .findFirst(); + .filter(Objects::nonNull) + .findFirst(); assertThat(object).contains("first non null"); } From b31e6984ad8800bb9590b4ab06d2fd0857988d3c Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sat, 11 Nov 2023 19:22:20 +0000 Subject: [PATCH 10/11] rename test methods --- .../ReturnFirstNonNullLazyEvaluateUnitTest.java | 2 +- .../returnfirstnonnull/ReturnFirstNonNullUnitTest.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java index fff348052a..56c846eb0e 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java @@ -19,7 +19,7 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { private final LazyEvaluate spy = Mockito.spy(new LazyEvaluate()); @Test - void givenChainOfMethods_thenLazilyEvaluateMethodsUntilFirstNonNull() { + void givenChainOfMethods_whenUsingIfStatements_thenLazilyEvaluateMethodsUntilFirstNonNull() { String object = spy.methodA(); if (object == null) { object = spy.methodB(); diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java index e7bb4d399f..32c95f0e84 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java @@ -26,7 +26,7 @@ public class ReturnFirstNonNullUnitTest { } @Test - void givenListOfObjects_whenFilterIsLambdaNullCheck_thenReturnFirstNonNull() { + void givenListOfObjects_whenFilterIsLambdaNullCheckInStream_thenReturnFirstNonNull() { Optional object = objects.stream() .filter(o -> o != null) .findFirst(); @@ -35,7 +35,7 @@ public class ReturnFirstNonNullUnitTest { } @Test - void givenListOfObjects_whenFilterIsMethodRefNullCheck_thenReturnFirstNonNull() { + void givenListOfObjects_whenFilterIsMethodRefNullCheckInStream_thenReturnFirstNonNull() { Optional object = objects.stream() .filter(Objects::nonNull) .findFirst(); From 1c10f4f35b1e42572c34ae5e48ac354535cb7cc9 Mon Sep 17 00:00:00 2001 From: danielmcnally285 <144589379+danielmcnally285@users.noreply.github.com> Date: Sat, 18 Nov 2023 20:25:43 +0000 Subject: [PATCH 11/11] change 2 spaces for fluent apis to 4 --- .../ReturnFirstNonEmptyOptionalUnitTest.java | 6 +++--- .../ReturnFirstNonNullLazyEvaluateUnitTest.java | 6 +++--- .../returnfirstnonnull/ReturnFirstNonNullUnitTest.java | 8 ++++---- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java index b05e0e2d34..f2ea8f74e3 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonempty/ReturnFirstNonEmptyOptionalUnitTest.java @@ -21,9 +21,9 @@ public class ReturnFirstNonEmptyOptionalUnitTest { @Test void givenListOfOptionals_whenStreaming_thenReturnFirstNonEmpty() { Optional object = optionals.stream() - .filter(Optional::isPresent) - .map(Optional::get) - .findFirst(); + .filter(Optional::isPresent) + .map(Optional::get) + .findFirst(); assertThat(object).contains("first non empty"); } diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java index 56c846eb0e..af88545170 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullLazyEvaluateUnitTest.java @@ -48,9 +48,9 @@ public class ReturnFirstNonNullLazyEvaluateUnitTest { @Test void givenChainOfMethods_whenUsingSupplierInterface_thenLazilyEvaluateMethodsUntilFirstNonNull() { Optional object = Stream.> of(spy::methodA, spy::methodB, spy::methodC) - .map(Supplier::get) - .filter(Objects::nonNull) - .findFirst(); + .map(Supplier::get) + .filter(Objects::nonNull) + .findFirst(); assertThat(object).contains("first non null"); verify(spy, times(1)).methodA(); diff --git a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java index 32c95f0e84..124de5843c 100644 --- a/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java +++ b/core-java-modules/core-java-lang-6/src/test/java/com/baeldung/returnfirstnonnull/ReturnFirstNonNullUnitTest.java @@ -28,8 +28,8 @@ public class ReturnFirstNonNullUnitTest { @Test void givenListOfObjects_whenFilterIsLambdaNullCheckInStream_thenReturnFirstNonNull() { Optional object = objects.stream() - .filter(o -> o != null) - .findFirst(); + .filter(o -> o != null) + .findFirst(); assertThat(object).contains("first non null"); } @@ -37,8 +37,8 @@ public class ReturnFirstNonNullUnitTest { @Test void givenListOfObjects_whenFilterIsMethodRefNullCheckInStream_thenReturnFirstNonNull() { Optional object = objects.stream() - .filter(Objects::nonNull) - .findFirst(); + .filter(Objects::nonNull) + .findFirst(); assertThat(object).contains("first non null"); }