From 17b31b39dddac1b9593ecb9c26af3772d0ed5ab6 Mon Sep 17 00:00:00 2001 From: jimcao Date: Thu, 6 Jan 2022 13:13:09 +0800 Subject: [PATCH] refine code --- .../com/alibaba/demo/lambda/BaseDemo.java | 42 +++++++ .../java/com/alibaba/demo/lambda/Fzo.java | 34 ------ .../demo/lambda/InvokeInterfaceDemo.java | 84 +++++++++++++ ...LambdaDemo.java => InvokeVirtualDemo.java} | 6 +- .../demo/lambda/StaticInstanceReference.java | 110 +----------------- .../java/com/alibaba/demo/lambda/FzoTest.java | 46 -------- .../demo/lambda/InvokeInterfaceDemoTest.java | 72 ++++++++++++ ...moTest.java => InvokeVirtualDemoTest.java} | 6 +- .../lambda/StaticInstanceReferenceTest.java | 44 ------- 9 files changed, 205 insertions(+), 239 deletions(-) create mode 100644 demo/java-demo/src/main/java/com/alibaba/demo/lambda/BaseDemo.java delete mode 100644 demo/java-demo/src/main/java/com/alibaba/demo/lambda/Fzo.java create mode 100644 demo/java-demo/src/main/java/com/alibaba/demo/lambda/InvokeInterfaceDemo.java rename demo/java-demo/src/main/java/com/alibaba/demo/lambda/{ExternalLambdaDemo.java => InvokeVirtualDemo.java} (96%) delete mode 100644 demo/java-demo/src/test/java/com/alibaba/demo/lambda/FzoTest.java create mode 100644 demo/java-demo/src/test/java/com/alibaba/demo/lambda/InvokeInterfaceDemoTest.java rename demo/java-demo/src/test/java/com/alibaba/demo/lambda/{ExternalLambdaDemoTest.java => InvokeVirtualDemoTest.java} (90%) diff --git a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/BaseDemo.java b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/BaseDemo.java new file mode 100644 index 0000000..e92d917 --- /dev/null +++ b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/BaseDemo.java @@ -0,0 +1,42 @@ +package com.alibaba.demo.lambda; + +import java.util.function.BiFunction; +import java.util.function.Consumer; +import java.util.function.Function; +import java.util.function.Supplier; + +/** + * @author jim + */ +public interface BaseDemo { + default void blackHole(Object... ignore) {} + + default void consumesRun(Runnable r) { + r.run(); + } + + default void consumesFunction0(Runnable f) { + f.run(); + } + + default void consumesFunction1(Consumer f) { + f.accept(null); + } + + default void consumesFunction2(Function f) { + f.apply(null); + } + + default void consumesFunction3(BiFunction f) { + f.apply(null, null); + } + + default void consumesSupplier(Supplier supplier) { + supplier.get(); + } + + default void consumesTwoFunction2(Function f1, Function f2) { + f1.apply(null); + f2.apply(null); + } +} diff --git a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/Fzo.java b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/Fzo.java deleted file mode 100644 index 399a957..0000000 --- a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/Fzo.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.alibaba.demo.lambda; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; -import java.util.Optional; -import java.util.function.BiFunction; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Stream; - -/** - * @author jim - */ -public class Fzo { - - public void objectStaticMethodReference() { - Boolean aBoolean = zz().get(); - System.out.println(aBoolean); - } - - public Optional zz() { - List> zz = new ArrayList<>(); - List f = new ArrayList<>(); - f.add(false); - f.add(false); - f.add(false); - zz.add(f); - return zz.stream() - .flatMap(Collection::stream) - .reduce(Boolean::logicalAnd); - } - -} diff --git a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/InvokeInterfaceDemo.java b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/InvokeInterfaceDemo.java new file mode 100644 index 0000000..0ea3e09 --- /dev/null +++ b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/InvokeInterfaceDemo.java @@ -0,0 +1,84 @@ +package com.alibaba.demo.lambda; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; + +/** + * @author jim + */ +public class InvokeInterfaceDemo implements BaseDemo { + + public void collectionInterfaceDefaultOrStatic() { + blackHole(collectionStreamTest()); + blackHole(arraysStreamTest()); + } + + public void interfaceDefault() { + ILambda l = new LambdaFoo(); + consumesRun(l::run); + consumesFunction1(l::function1); + } + + public void interfaceStatic() { + consumesRun(ILambda::staticRun); + consumesFunction1(ILambda::staticFunction1); + } + + public Object collectionStreamTest() { + List> testList = new ArrayList<>(); + List fooList = new ArrayList<>(); + testList.add(fooList); + return testList.stream() + //.flatMap(v -> v.stream()) + .flatMap(Collection::stream) + .map(Double::valueOf) + .map(BigDecimal::new) + .reduce(BigDecimal::add); + } + + public Object arraysStreamTest() { + List zz = new ArrayList<>(); + zz.add(new String[]{"1", "2", "3"}); + return zz.stream() + .flatMap(Arrays::stream) + .map(Double::valueOf) + .map(BigDecimal::new) + .reduce(BigDecimal::add); + } + + public void objectStaticMethodReference() { + List f = new ArrayList<>(); + f.add(false); + f.add(false); + f.add(false); + blackHole(f.stream() + .reduce(Boolean::logicalAnd) + .get() + ); + } + + public interface ILambda { + default void run() { + + } + + default void function1(String s) { + + } + + static void staticRun() { + + } + + static void staticFunction1(String s) { + + } + } + + public static class LambdaFoo implements ILambda { + + } +} diff --git a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/ExternalLambdaDemo.java b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/InvokeVirtualDemo.java similarity index 96% rename from demo/java-demo/src/main/java/com/alibaba/demo/lambda/ExternalLambdaDemo.java rename to demo/java-demo/src/main/java/com/alibaba/demo/lambda/InvokeVirtualDemo.java index b9fa289..5883af5 100644 --- a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/ExternalLambdaDemo.java +++ b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/InvokeVirtualDemo.java @@ -9,7 +9,7 @@ import java.util.function.Supplier; * @author jimca */ @SuppressWarnings({"WrapperTypeMayBePrimitive", "ResultOfMethodCallIgnored", "MismatchedReadAndWriteOfArray", "unused"}) -public class ExternalLambdaDemo { +public class InvokeVirtualDemo { public void string1() { String s = ""; @@ -197,8 +197,8 @@ public class ExternalLambdaDemo { } public void function3() { - ExternalLambdaDemo externalLambdaDemo = new ExternalLambdaDemo(); - consumesFunction3(externalLambdaDemo::f3); + InvokeVirtualDemo invokeVirtualDemo = new InvokeVirtualDemo(); + consumesFunction3(invokeVirtualDemo::f3); } public Boolean f3(String s1, Long l) { diff --git a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/StaticInstanceReference.java b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/StaticInstanceReference.java index 5657a2c..b85f056 100644 --- a/demo/java-demo/src/main/java/com/alibaba/demo/lambda/StaticInstanceReference.java +++ b/demo/java-demo/src/main/java/com/alibaba/demo/lambda/StaticInstanceReference.java @@ -10,50 +10,15 @@ import java.util.stream.Collectors; /** * @author jim */ -public class StaticInstanceReference { +public class StaticInstanceReference implements BaseDemo { private static final StaticClassA STATIC_CLASS_A = new StaticClassA(); public void staticMethodReference() { - //StaticClassA a = new StaticClassA(); - //consumesRun(a::doIt); consumesRun(STATIC_CLASS_A::doIt); consumesFunction1(STATIC_CLASS_A::function1); consumesFunction2(STATIC_CLASS_A::function2); consumesFunction3(STATIC_CLASS_A::function3); - - } - - public void collectionInterfaceDefaultOrStatic() { - blackHole(invokeInterfaceTest()); - blackHole(interfaceStaticMethodTest()); - } - - public void interfaceDefault() { - ILambda l = new LambdaFoo(); - consumesRun(l::run); - consumesFunction1(l::function1); - } - - public void interfaceStatic() { - consumesRun(ILambda::staticRun); - consumesFunction1(ILambda::staticFunction1); - } - - private void consumesRun(Runnable r) { - r.run(); - } - - private void consumesFunction1(Consumer r) { - r.accept(null); - } - - private void consumesFunction2(Function r) { - r.apply(null); - } - - private void consumesFunction3(BiFunction r) { - r.apply(null, null); } public static class StaticClassA { @@ -72,77 +37,4 @@ public class StaticInstanceReference { return 1; } } - - public static class XBean { - private Long id; - - public Long getId() { - return id; - } - - public void setId(Long id) { - this.id = id; - } - } - - public void foo() { - List testList = Collections.emptyList(); - //noinspection RedundantOperationOnEmptyContainer - List response = testList.stream().map(XBean::getId).distinct().collect(Collectors.toList()); - } - - public Object invokeInterfaceTest() { - List> zz = new ArrayList<>(); - zz.add(new ArrayList<>()); - return zz.stream() - //.flatMap(v -> v.stream()) - .flatMap(Collection::stream) - .map(Double::valueOf) - .map(BigDecimal::new) - .reduce(BigDecimal::add); - } - public Object interfaceStaticMethodTest() { - List zz = new ArrayList<>(); - zz.add(new String[]{"1"}); - return zz.stream() - .flatMap(Arrays::stream) - .map(Double::valueOf) - .map(BigDecimal::new) - .reduce(BigDecimal::add); - } - - public void objectStaticMethodReference() { - List f = new ArrayList<>(); - f.add(false); - f.add(false); - f.add(false); - blackHole(f.stream() - .reduce(Boolean::logicalAnd) - .get() - ); - } - - private void blackHole(Object... ignore) {} - - public interface ILambda { - default void run() { - - } - - default void function1(String s) { - - } - - static void staticRun() { - - } - - static void staticFunction1(String s) { - - } - } - - public static class LambdaFoo implements ILambda { - - } } diff --git a/demo/java-demo/src/test/java/com/alibaba/demo/lambda/FzoTest.java b/demo/java-demo/src/test/java/com/alibaba/demo/lambda/FzoTest.java deleted file mode 100644 index da5bf14..0000000 --- a/demo/java-demo/src/test/java/com/alibaba/demo/lambda/FzoTest.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.alibaba.demo.lambda; - -import com.alibaba.testable.core.annotation.MockDiagnose; -import com.alibaba.testable.core.annotation.MockInvoke; -import com.alibaba.testable.core.model.LogLevel; -import org.junit.jupiter.api.Test; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; -import java.util.stream.Stream; - -/** - * @author jim - */ -public class FzoTest { - Fzo f = new Fzo(); - @MockDiagnose(LogLevel.VERBOSE) - public static class Mock { - @MockInvoke(targetClass = Double.class, targetMethod = "hashCode") - private int cc() { - return 1; - } - - @MockInvoke(targetClass = Collection.class, targetMethod = "stream") - Stream mockStream() { - List l = new ArrayList<>(); - l.add((E)Boolean.TRUE); - l.add((E)Boolean.TRUE); - l.add((E)Boolean.TRUE); - System.out.println("mockStreammockStreammockStreammockStreammockStreammockStreammockStream"); - return l.stream(); - } - - @MockInvoke(targetClass = Boolean.class, targetMethod = "logicalAnd") - public static boolean mockLogicalAnd(boolean a, boolean b) { - System.out.println("ZPPPPPPPPPPPPPPPPPPPPPP"); - return false; - } - } - - @Test - public void shouldMockInterfaceStatic() { - f.objectStaticMethodReference(); - } -} diff --git a/demo/java-demo/src/test/java/com/alibaba/demo/lambda/InvokeInterfaceDemoTest.java b/demo/java-demo/src/test/java/com/alibaba/demo/lambda/InvokeInterfaceDemoTest.java new file mode 100644 index 0000000..c80ca76 --- /dev/null +++ b/demo/java-demo/src/test/java/com/alibaba/demo/lambda/InvokeInterfaceDemoTest.java @@ -0,0 +1,72 @@ +package com.alibaba.demo.lambda; + +import com.alibaba.testable.core.annotation.MockDiagnose; +import com.alibaba.testable.core.annotation.MockInvoke; +import com.alibaba.testable.core.model.LogLevel; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.stream.Stream; + +import static com.alibaba.testable.core.matcher.InvocationVerifier.verifyInvoked; + + +/** + * @author jim + */ +public class InvokeInterfaceDemoTest { + + private final InvokeInterfaceDemo instance = new InvokeInterfaceDemo(); + + @MockDiagnose(LogLevel.VERBOSE) + public static class Mock { + + @MockInvoke(targetClass = InvokeInterfaceDemo.ILambda.class, targetMethod = "run") + private void mockILambdaRun() { + } + + @MockInvoke(targetClass = InvokeInterfaceDemo.ILambda.class, targetMethod = "function1") + private void mockILambdaFunction1(String s) { + } + + @SuppressWarnings("unchecked") + @MockInvoke(targetClass = Collection.class, targetMethod = "stream") + Stream mockStream() { + List fooList = new ArrayList<>(); + fooList.add((E) "123"); + fooList.add((E) "456"); + return fooList.stream(); + } + + @MockInvoke(targetClass = Boolean.class, targetMethod = "logicalAnd") + public static boolean mockLogicalAnd(boolean a, boolean b) { + return false; + } + } + + @Test + public void shouldMockCollectionStream() { + instance.collectionInterfaceDefaultOrStatic(); + verifyInvoked("mockStream").withTimes(1); + } + + @Test + public void shouldMockInterfaceDefault() { + instance.interfaceDefault(); + verifyInvoked("mockILambdaRun").withTimes(1); + verifyInvoked("mockILambdaFunction1").withTimes(1); + } + + @Test + public void shouldMockObjectStaticMethodReference() { + instance.objectStaticMethodReference(); + verifyInvoked("mockLogicalAnd").withTimes(2); + } + + @Test + public void shouldMockInterfaceStatic() { + instance.interfaceStatic(); + } +} diff --git a/demo/java-demo/src/test/java/com/alibaba/demo/lambda/ExternalLambdaDemoTest.java b/demo/java-demo/src/test/java/com/alibaba/demo/lambda/InvokeVirtualDemoTest.java similarity index 90% rename from demo/java-demo/src/test/java/com/alibaba/demo/lambda/ExternalLambdaDemoTest.java rename to demo/java-demo/src/test/java/com/alibaba/demo/lambda/InvokeVirtualDemoTest.java index 9c84911..32a03a2 100644 --- a/demo/java-demo/src/test/java/com/alibaba/demo/lambda/ExternalLambdaDemoTest.java +++ b/demo/java-demo/src/test/java/com/alibaba/demo/lambda/InvokeVirtualDemoTest.java @@ -8,8 +8,8 @@ import static com.alibaba.testable.core.matcher.InvocationVerifier.verifyInvoked /** * @author zcbbpo */ -public class ExternalLambdaDemoTest { - private final ExternalLambdaDemo lambdaDemo = new ExternalLambdaDemo(); +public class InvokeVirtualDemoTest { + private final InvokeVirtualDemo lambdaDemo = new InvokeVirtualDemo(); @SuppressWarnings("unused") public static class Mock { @@ -34,7 +34,7 @@ public class ExternalLambdaDemoTest { return ""; } - @MockInvoke(targetClass = ExternalLambdaDemo.class, targetMethod = "f3") + @MockInvoke(targetClass = InvokeVirtualDemo.class, targetMethod = "f3") public Boolean mockF3(String s1, Long l) { return true; } diff --git a/demo/java-demo/src/test/java/com/alibaba/demo/lambda/StaticInstanceReferenceTest.java b/demo/java-demo/src/test/java/com/alibaba/demo/lambda/StaticInstanceReferenceTest.java index 27aaf81..9e760e5 100644 --- a/demo/java-demo/src/test/java/com/alibaba/demo/lambda/StaticInstanceReferenceTest.java +++ b/demo/java-demo/src/test/java/com/alibaba/demo/lambda/StaticInstanceReferenceTest.java @@ -5,9 +5,6 @@ import com.alibaba.testable.core.annotation.MockInvoke; import com.alibaba.testable.core.model.LogLevel; import org.junit.jupiter.api.Test; -import java.util.Collection; -import java.util.stream.Stream; - import static com.alibaba.testable.core.matcher.InvocationVerifier.verifyInvoked; @@ -23,23 +20,6 @@ public class StaticInstanceReferenceTest { @MockInvoke(targetClass = StaticInstanceReference.StaticClassA.class, targetMethod = "doIt") private void mockDoIt() { } - - @MockInvoke(targetClass = StaticInstanceReference.ILambda.class, targetMethod = "run") - private void mockILambdaRun() { - } - - @MockInvoke(targetClass = StaticInstanceReference.ILambda.class, targetMethod = "function1") - private void mockILambdaFunction1(String s) { - } - @MockInvoke(targetClass = Collection.class, targetMethod = "stream") - Stream mockStream() { - return null; - } - - @MockInvoke(targetClass = Boolean.class, targetMethod = "logicalAnd") - public static boolean mockLogicalAnd(boolean a, boolean b) { - return false; - } } @Test @@ -47,28 +27,4 @@ public class StaticInstanceReferenceTest { instance.staticMethodReference(); verifyInvoked("mockDoIt").withTimes(1); } - - @Test - public void shouldMockCollectionStream() { - instance.collectionInterfaceDefaultOrStatic(); - verifyInvoked("mockStream").withTimes(1); - } - - @Test - public void shouldMockInterfaceDefault() { - instance.interfaceDefault(); - verifyInvoked("mockILambdaRun").withTimes(1); - verifyInvoked("mockILambdaFunction1").withTimes(1); - } - - @Test - public void shouldMockObjectStaticMethodReference() { - instance.objectStaticMethodReference(); - verifyInvoked("mockLogicalAnd").withTimes(2); - } - - @Test - public void shouldMockInterfaceStatic() { - instance.interfaceStatic(); - } }