From 7135047ba1ee35b1cec031a7e653fd68426a0806 Mon Sep 17 00:00:00 2001 From: maenolis Date: Wed, 15 Nov 2023 08:33:33 +0200 Subject: [PATCH 1/4] Initial commit for lazy lambda article --- core-java-modules/core-java-21/pom.xml | 13 +++++++-- .../baeldung/lazylambda/LambdaSupplier.java | 16 ++++++++++ .../lazylambda/LazyLambdaSupplier.java | 22 ++++++++++++++ .../LazyLambdaThreadSafeSupplier.java | 29 +++++++++++++++++++ .../lazylambda/LambdaSupplierUnitTest.java | 24 +++++++++++++++ .../LazyLambdaSupplierUnitTest.java | 23 +++++++++++++++ .../LazyLambdaThreadSafeSupplierUnitTest.java | 23 +++++++++++++++ 7 files changed, 147 insertions(+), 3 deletions(-) create mode 100644 core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java create mode 100644 core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java create mode 100644 core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java create mode 100644 core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java create mode 100644 core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java create mode 100644 core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java diff --git a/core-java-modules/core-java-21/pom.xml b/core-java-modules/core-java-21/pom.xml index bfe1cd2c78..98e73c89c0 100644 --- a/core-java-modules/core-java-21/pom.xml +++ b/core-java-modules/core-java-21/pom.xml @@ -22,9 +22,7 @@ 21 false - - --enable-preview - + --enable-preview @@ -38,6 +36,15 @@ + + + org.mockito + mockito-core + 5.7.0 + test + + + 21 21 diff --git a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java b/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java new file mode 100644 index 0000000000..a9c4c78edd --- /dev/null +++ b/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java @@ -0,0 +1,16 @@ +package com.baeldung.lazylambda; + +import java.util.function.Supplier; + +public class LambdaSupplier { + + private final Supplier expensiveData; + + public LambdaSupplier(Supplier expensiveData) { + this.expensiveData = expensiveData; + } + + public T getData() { + return expensiveData.get(); + } +} diff --git a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java b/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java new file mode 100644 index 0000000000..484fadbe90 --- /dev/null +++ b/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java @@ -0,0 +1,22 @@ +package com.baeldung.lazylambda; + +import java.util.function.Supplier; + +public class LazyLambdaSupplier { + + private final Supplier expensiveData; + + private T data; + + public LazyLambdaSupplier(Supplier expensiveData) { + this.expensiveData = expensiveData; + } + + public T getData() { + if (data != null) { + return data; + } + return data = expensiveData.get(); + } + +} diff --git a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java b/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java new file mode 100644 index 0000000000..27180ced7d --- /dev/null +++ b/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java @@ -0,0 +1,29 @@ +package com.baeldung.lazylambda; + +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Supplier; + +public class LazyLambdaThreadSafeSupplier { + + private final Supplier expensiveData; + + private final AtomicReference data; + + public LazyLambdaThreadSafeSupplier(Supplier expensiveData) { + this.expensiveData = expensiveData; + data = new AtomicReference<>(); + } + + public T getData() { + if (data.get() == null) { + synchronized (data) { + if (data.get() == null) { + data.set(expensiveData.get()); + } + } + } + + return data.get(); + } + +} diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java new file mode 100644 index 0000000000..b2d8b91043 --- /dev/null +++ b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java @@ -0,0 +1,24 @@ +package com.baeldung.lazylambda; + +import java.util.function.Supplier; + +import org.junit.Test; +import org.mockito.Mockito; + +public class LambdaSupplierUnitTest { + + @Test + public void whenCalledMultipleTimes_thenShouldBeCalledMultipleTimes() { + @SuppressWarnings("unchecked") + Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()).thenReturn("expensive call"); + LambdaSupplier testee = new LambdaSupplier<>(mockedExpensiveFunction); + Mockito.verify(mockedExpensiveFunction, Mockito.never()).get(); + testee.getData(); + testee.getData(); + testee.getData(); + testee.getData(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(4)).get(); + } + +} diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java new file mode 100644 index 0000000000..37464afe2e --- /dev/null +++ b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java @@ -0,0 +1,23 @@ +package com.baeldung.lazylambda; + +import java.util.function.Supplier; + +import org.junit.Test; +import org.mockito.Mockito; + +public class LazyLambdaSupplierUnitTest { + + @Test + public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { + @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()).thenReturn("expensive call"); + LazyLambdaSupplier testee = new LazyLambdaSupplier<>(mockedExpensiveFunction); + Mockito.verify(mockedExpensiveFunction, Mockito.never()).get(); + testee.getData(); + testee.getData(); + testee.getData(); + testee.getData(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(1)).get(); + } + +} diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java new file mode 100644 index 0000000000..a67600c974 --- /dev/null +++ b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java @@ -0,0 +1,23 @@ +package com.baeldung.lazylambda; + +import java.util.function.Supplier; + +import org.junit.Test; +import org.mockito.Mockito; + +public class LazyLambdaThreadSafeSupplierUnitTest { + + @Test + public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { + @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()).thenReturn("expensive call"); + LazyLambdaThreadSafeSupplier testee = new LazyLambdaThreadSafeSupplier<>(mockedExpensiveFunction); + Mockito.verify(mockedExpensiveFunction, Mockito.never()).get(); + testee.getData(); + testee.getData(); + testee.getData(); + testee.getData(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(1)).get(); + } + +} From 2ed78462c830a7560d8c748d661a3586178a5fb0 Mon Sep 17 00:00:00 2001 From: maenolis Date: Wed, 15 Nov 2023 08:36:28 +0200 Subject: [PATCH 2/4] Code formatting --- .../baeldung/lazylambda/LambdaSupplierUnitTest.java | 12 +++++++----- .../lazylambda/LazyLambdaSupplierUnitTest.java | 9 ++++++--- .../LazyLambdaThreadSafeSupplierUnitTest.java | 9 ++++++--- 3 files changed, 19 insertions(+), 11 deletions(-) diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java index b2d8b91043..8b705286c2 100644 --- a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java +++ b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java @@ -9,16 +9,18 @@ public class LambdaSupplierUnitTest { @Test public void whenCalledMultipleTimes_thenShouldBeCalledMultipleTimes() { - @SuppressWarnings("unchecked") - Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); - Mockito.when(mockedExpensiveFunction.get()).thenReturn("expensive call"); + @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()) + .thenReturn("expensive call"); LambdaSupplier testee = new LambdaSupplier<>(mockedExpensiveFunction); - Mockito.verify(mockedExpensiveFunction, Mockito.never()).get(); + Mockito.verify(mockedExpensiveFunction, Mockito.never()) + .get(); testee.getData(); testee.getData(); testee.getData(); testee.getData(); - Mockito.verify(mockedExpensiveFunction, Mockito.times(4)).get(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(4)) + .get(); } } diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java index 37464afe2e..4f110dfba7 100644 --- a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java +++ b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java @@ -10,14 +10,17 @@ public class LazyLambdaSupplierUnitTest { @Test public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); - Mockito.when(mockedExpensiveFunction.get()).thenReturn("expensive call"); + Mockito.when(mockedExpensiveFunction.get()) + .thenReturn("expensive call"); LazyLambdaSupplier testee = new LazyLambdaSupplier<>(mockedExpensiveFunction); - Mockito.verify(mockedExpensiveFunction, Mockito.never()).get(); + Mockito.verify(mockedExpensiveFunction, Mockito.never()) + .get(); testee.getData(); testee.getData(); testee.getData(); testee.getData(); - Mockito.verify(mockedExpensiveFunction, Mockito.times(1)).get(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(1)) + .get(); } } diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java index a67600c974..7870b5a111 100644 --- a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java +++ b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java @@ -10,14 +10,17 @@ public class LazyLambdaThreadSafeSupplierUnitTest { @Test public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); - Mockito.when(mockedExpensiveFunction.get()).thenReturn("expensive call"); + Mockito.when(mockedExpensiveFunction.get()) + .thenReturn("expensive call"); LazyLambdaThreadSafeSupplier testee = new LazyLambdaThreadSafeSupplier<>(mockedExpensiveFunction); - Mockito.verify(mockedExpensiveFunction, Mockito.never()).get(); + Mockito.verify(mockedExpensiveFunction, Mockito.never()) + .get(); testee.getData(); testee.getData(); testee.getData(); testee.getData(); - Mockito.verify(mockedExpensiveFunction, Mockito.times(1)).get(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(1)) + .get(); } } From 62c3d6bf328220c3bf66828cd71eeb3f9e71d845 Mon Sep 17 00:00:00 2001 From: maenolis Date: Fri, 17 Nov 2023 22:44:42 +0200 Subject: [PATCH 3/4] Moved to core-java-function module Added concurrent tests --- .../LazyLambdaSupplierUnitTest.java | 26 ---------- .../LazyLambdaThreadSafeSupplierUnitTest.java | 26 ---------- .../baeldung/lazylambda/LambdaSupplier.java | 2 +- .../lazylambda/LazyLambdaSupplier.java | 7 ++- .../LazyLambdaThreadSafeSupplier.java | 7 +-- .../lazylambda/LambdaSupplierUnitTest.java | 4 +- .../LazyLambdaSupplierUnitTest.java | 51 ++++++++++++++++++ .../LazyLambdaThreadSafeSupplierUnitTest.java | 52 +++++++++++++++++++ 8 files changed, 110 insertions(+), 65 deletions(-) delete mode 100644 core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java delete mode 100644 core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java rename core-java-modules/{core-java-21 => core-java-function}/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java (85%) rename core-java-modules/{core-java-21 => core-java-function}/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java (70%) rename core-java-modules/{core-java-21 => core-java-function}/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java (79%) rename core-java-modules/{core-java-21 => core-java-function}/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java (85%) create mode 100644 core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java create mode 100644 core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java deleted file mode 100644 index 4f110dfba7..0000000000 --- a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.baeldung.lazylambda; - -import java.util.function.Supplier; - -import org.junit.Test; -import org.mockito.Mockito; - -public class LazyLambdaSupplierUnitTest { - - @Test - public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { - @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); - Mockito.when(mockedExpensiveFunction.get()) - .thenReturn("expensive call"); - LazyLambdaSupplier testee = new LazyLambdaSupplier<>(mockedExpensiveFunction); - Mockito.verify(mockedExpensiveFunction, Mockito.never()) - .get(); - testee.getData(); - testee.getData(); - testee.getData(); - testee.getData(); - Mockito.verify(mockedExpensiveFunction, Mockito.times(1)) - .get(); - } - -} diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java b/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java deleted file mode 100644 index 7870b5a111..0000000000 --- a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.baeldung.lazylambda; - -import java.util.function.Supplier; - -import org.junit.Test; -import org.mockito.Mockito; - -public class LazyLambdaThreadSafeSupplierUnitTest { - - @Test - public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { - @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); - Mockito.when(mockedExpensiveFunction.get()) - .thenReturn("expensive call"); - LazyLambdaThreadSafeSupplier testee = new LazyLambdaThreadSafeSupplier<>(mockedExpensiveFunction); - Mockito.verify(mockedExpensiveFunction, Mockito.never()) - .get(); - testee.getData(); - testee.getData(); - testee.getData(); - testee.getData(); - Mockito.verify(mockedExpensiveFunction, Mockito.times(1)) - .get(); - } - -} diff --git a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java b/core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java similarity index 85% rename from core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java rename to core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java index a9c4c78edd..36cd1b31ae 100644 --- a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java +++ b/core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LambdaSupplier.java @@ -4,7 +4,7 @@ import java.util.function.Supplier; public class LambdaSupplier { - private final Supplier expensiveData; + protected final Supplier expensiveData; public LambdaSupplier(Supplier expensiveData) { this.expensiveData = expensiveData; diff --git a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java b/core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java similarity index 70% rename from core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java rename to core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java index 484fadbe90..dce3cc4997 100644 --- a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java +++ b/core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaSupplier.java @@ -2,16 +2,15 @@ package com.baeldung.lazylambda; import java.util.function.Supplier; -public class LazyLambdaSupplier { - - private final Supplier expensiveData; +public class LazyLambdaSupplier extends LambdaSupplier { private T data; public LazyLambdaSupplier(Supplier expensiveData) { - this.expensiveData = expensiveData; + super(expensiveData); } + @Override public T getData() { if (data != null) { return data; diff --git a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java b/core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java similarity index 79% rename from core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java rename to core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java index 27180ced7d..32eec0a5d8 100644 --- a/core-java-modules/core-java-21/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java +++ b/core-java-modules/core-java-function/src/main/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplier.java @@ -3,14 +3,12 @@ package com.baeldung.lazylambda; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Supplier; -public class LazyLambdaThreadSafeSupplier { - - private final Supplier expensiveData; +public class LazyLambdaThreadSafeSupplier extends LambdaSupplier { private final AtomicReference data; public LazyLambdaThreadSafeSupplier(Supplier expensiveData) { - this.expensiveData = expensiveData; + super(expensiveData); data = new AtomicReference<>(); } @@ -22,7 +20,6 @@ public class LazyLambdaThreadSafeSupplier { } } } - return data.get(); } diff --git a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java b/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java similarity index 85% rename from core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java rename to core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java index 8b705286c2..f0a500e084 100644 --- a/core-java-modules/core-java-21/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java +++ b/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LambdaSupplierUnitTest.java @@ -17,9 +17,7 @@ public class LambdaSupplierUnitTest { .get(); testee.getData(); testee.getData(); - testee.getData(); - testee.getData(); - Mockito.verify(mockedExpensiveFunction, Mockito.times(4)) + Mockito.verify(mockedExpensiveFunction, Mockito.times(2)) .get(); } diff --git a/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java b/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java new file mode 100644 index 0000000000..1371983a3d --- /dev/null +++ b/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaSupplierUnitTest.java @@ -0,0 +1,51 @@ +package com.baeldung.lazylambda; + +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.function.Supplier; + +import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.stubbing.Answer; + +public class LazyLambdaSupplierUnitTest { + + @Test + public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { + @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()) + .thenReturn("expensive call"); + LazyLambdaSupplier testee = new LazyLambdaSupplier<>(mockedExpensiveFunction); + Mockito.verify(mockedExpensiveFunction, Mockito.never()) + .get(); + testee.getData(); + testee.getData(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(1)) + .get(); + } + + @Test + public void whenCalledMultipleTimesConcurrently_thenShouldBeCalledMultipleTimes() throws InterruptedException { + @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()) + .thenAnswer((Answer) invocation -> { + Thread.sleep(1000L); + return "Late response!"; + }); + LazyLambdaSupplier testee = new LazyLambdaSupplier<>(mockedExpensiveFunction); + Mockito.verify(mockedExpensiveFunction, Mockito.never()) + .get(); + + ExecutorService executorService = Executors.newFixedThreadPool(4); + executorService.invokeAll(List.of(testee::getData, testee::getData)); + executorService.shutdown(); + if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) { + executorService.shutdownNow(); + } + + Mockito.verify(mockedExpensiveFunction, Mockito.times(2)) + .get(); + } +} diff --git a/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java b/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java new file mode 100644 index 0000000000..83bd49aa7e --- /dev/null +++ b/core-java-modules/core-java-function/src/test/java/com/baeldung/lazylambda/LazyLambdaThreadSafeSupplierUnitTest.java @@ -0,0 +1,52 @@ +package com.baeldung.lazylambda; + +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.function.Supplier; + +import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.stubbing.Answer; + +public class LazyLambdaThreadSafeSupplierUnitTest { + + @Test + public void whenCalledMultipleTimes_thenShouldBeCalledOnlyOnce() { + @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()) + .thenReturn("expensive call"); + LazyLambdaThreadSafeSupplier testee = new LazyLambdaThreadSafeSupplier<>(mockedExpensiveFunction); + Mockito.verify(mockedExpensiveFunction, Mockito.never()) + .get(); + testee.getData(); + testee.getData(); + Mockito.verify(mockedExpensiveFunction, Mockito.times(1)) + .get(); + } + + @Test + public void whenCalledMultipleTimesConcurrently_thenShouldBeCalledOnlyOnce() throws InterruptedException { + @SuppressWarnings("unchecked") Supplier mockedExpensiveFunction = Mockito.mock(Supplier.class); + Mockito.when(mockedExpensiveFunction.get()) + .thenAnswer((Answer) invocation -> { + Thread.sleep(1000L); + return "Late response!"; + }); + LazyLambdaThreadSafeSupplier testee = new LazyLambdaThreadSafeSupplier<>(mockedExpensiveFunction); + Mockito.verify(mockedExpensiveFunction, Mockito.never()) + .get(); + + ExecutorService executorService = Executors.newFixedThreadPool(4); + executorService.invokeAll(List.of(testee::getData, testee::getData)); + executorService.shutdown(); + if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) { + executorService.shutdownNow(); + } + + Mockito.verify(mockedExpensiveFunction, Mockito.times(1)) + .get(); + } + +} From 9a003c4bf4c2aa9e074e016b7681b879aa2be3a2 Mon Sep 17 00:00:00 2001 From: maenolis Date: Tue, 5 Dec 2023 17:21:04 +0200 Subject: [PATCH 4/4] Unnecessary change revert. --- core-java-modules/core-java-21/pom.xml | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/core-java-modules/core-java-21/pom.xml b/core-java-modules/core-java-21/pom.xml index 98e73c89c0..bfe1cd2c78 100644 --- a/core-java-modules/core-java-21/pom.xml +++ b/core-java-modules/core-java-21/pom.xml @@ -22,7 +22,9 @@ 21 false - --enable-preview + + --enable-preview + @@ -36,15 +38,6 @@ - - - org.mockito - mockito-core - 5.7.0 - test - - - 21 21