From b61b64073a01edd5fd1154a5993ea028732d4229 Mon Sep 17 00:00:00 2001 From: tigraboris Date: Mon, 8 Jan 2018 14:00:12 +0300 Subject: [PATCH 1/5] #677 init folder for pattern trampoline --- trampoline/.gitignore | 2 + trampoline/README.md | 38 +++++++++++ trampoline/pom.xml | 67 +++++++++++++++++++ .../java/com/iluwatar/trampoline/App.java | 4 ++ 4 files changed, 111 insertions(+) create mode 100644 trampoline/.gitignore create mode 100644 trampoline/README.md create mode 100644 trampoline/pom.xml create mode 100644 trampoline/src/main/java/com/iluwatar/trampoline/App.java diff --git a/trampoline/.gitignore b/trampoline/.gitignore new file mode 100644 index 000000000..431845ed0 --- /dev/null +++ b/trampoline/.gitignore @@ -0,0 +1,2 @@ +/target/ +.idea/ diff --git a/trampoline/README.md b/trampoline/README.md new file mode 100644 index 000000000..849cc663e --- /dev/null +++ b/trampoline/README.md @@ -0,0 +1,38 @@ +--- +layout: pattern +title: Trampoline +folder: trampoline +permalink: /patterns/trampoline/ +categories: Behavior +tags: + - Java + - Difficulty-Intermediate + - Performance + - Recursion +--- + +## Intent +By representing a computation in one of 2 states +(completed with result, or a reference to the reminder of the computation, +something like the way a java.util.Supplier does) +it is possible to implement algorithms recursively in Java without blowing the stack +and to interleave the execution of functions without hard coding them together or even using threads. + + + +## Applicability +Use the Trampoline pattern when + +* For implementing tail recursive function. This pattern allows to switch on a stackless operation. +* For to interleaving the execution of two or more functions on the same thread. + +## Known uses(real world examples) +* Trampoline refers to using reflection to avoid using inner classes, for example in event listeners. +The time overhead of a reflection call is traded for the space overhead of an inner class. +Trampolines in Java usually involve the creation of a GenericListener to pass events to an outer class. + +## Credits + +* [Trampolining: a practical guide for awesome Java Developers](https://medium.com/@johnmcclean/trampolining-a-practical-guide-for-awesome-java-developers-4b657d9c3076) +* [Trampoline in java ](http://mindprod.com/jgloss/trampoline.html) + diff --git a/trampoline/pom.xml b/trampoline/pom.xml new file mode 100644 index 000000000..c4cef6860 --- /dev/null +++ b/trampoline/pom.xml @@ -0,0 +1,67 @@ + + + + 4.0.0 + + com.iluwatar + java-design-patterns + 1.19.0-SNAPSHOT + + trampoline + + + + junit + junit + 4.12 + test + + + + org.projectlombok + lombok + 1.16.18 + provided + + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.19 + + false + + + + + diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/App.java b/trampoline/src/main/java/com/iluwatar/trampoline/App.java new file mode 100644 index 000000000..8afda31a7 --- /dev/null +++ b/trampoline/src/main/java/com/iluwatar/trampoline/App.java @@ -0,0 +1,4 @@ +package com.iluwatar.trampoline; + +public class App { +} From 94fdefee3a65f8a67335c919440c1a8962681c51 Mon Sep 17 00:00:00 2001 From: tigraboris Date: Mon, 8 Jan 2018 14:45:38 +0300 Subject: [PATCH 2/5] add code --- trampoline/README.md | 4 +- .../java/com/iluwatar/trampoline/App.java | 4 - .../com/iluwatar/trampoline/Trampoline.java | 84 +++++++++++++++++++ .../iluwatar/trampoline/TrampolineApp.java | 67 +++++++++++++++ .../trampoline/TrampolineAppTest.java | 17 ++++ 5 files changed, 171 insertions(+), 5 deletions(-) delete mode 100644 trampoline/src/main/java/com/iluwatar/trampoline/App.java create mode 100644 trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java create mode 100644 trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java create mode 100644 trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java diff --git a/trampoline/README.md b/trampoline/README.md index 849cc663e..4a4030f39 100644 --- a/trampoline/README.md +++ b/trampoline/README.md @@ -24,15 +24,17 @@ and to interleave the execution of functions without hard coding them together o Use the Trampoline pattern when * For implementing tail recursive function. This pattern allows to switch on a stackless operation. -* For to interleaving the execution of two or more functions on the same thread. +* For interleaving the execution of two or more functions on the same thread. ## Known uses(real world examples) * Trampoline refers to using reflection to avoid using inner classes, for example in event listeners. The time overhead of a reflection call is traded for the space overhead of an inner class. Trampolines in Java usually involve the creation of a GenericListener to pass events to an outer class. + ## Credits * [Trampolining: a practical guide for awesome Java Developers](https://medium.com/@johnmcclean/trampolining-a-practical-guide-for-awesome-java-developers-4b657d9c3076) * [Trampoline in java ](http://mindprod.com/jgloss/trampoline.html) +* [cyclops-react](https://github.com/aol/cyclops-react) diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/App.java b/trampoline/src/main/java/com/iluwatar/trampoline/App.java deleted file mode 100644 index 8afda31a7..000000000 --- a/trampoline/src/main/java/com/iluwatar/trampoline/App.java +++ /dev/null @@ -1,4 +0,0 @@ -package com.iluwatar.trampoline; - -public class App { -} diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java b/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java new file mode 100644 index 000000000..3be44ebba --- /dev/null +++ b/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java @@ -0,0 +1,84 @@ +package com.iluwatar.trampoline; + +import java.util.stream.Stream; + +/**When get is called on the returned Trampoline, internally it will iterate calling ‘jump’ + on the returned Trampoline as long as the concrete instance returned is More, + stopping once the returned instance is Done. Essential we convert looping via recursion into iteration, + the key enabling mechanism is the fact that Trampoline.more is a lazy operation. + Trampoline in cyclops-react extends java.util.Supplier. Calling Trampoline.more we are basically creating + a Supplier that defers the actual recursive call, and having defered the call we can move it outside of the recursive loop. + This means we can define algorithms recursively in Java but execute them iteratively.*/ + +public interface Trampoline { + T get(); + + + /** + * @return next stage + */ + default Trampoline jump() { + return this; + } + + + default T result() { + return get(); + } + + /** + * @return true if complete + * + */ + default boolean complete() { + return true; + } + + /** + * Created a completed Trampoline + * + * @param result Completed result + * @return Completed Trampoline + */ + static Trampoline done(final T result) { + return () -> result; + } + + + /** + * Create a Trampoline that has more work to do + * + * @param trampoline Next stage in Trampoline + * @return Trampoline with more work + */ + static Trampoline more(final Trampoline> trampoline) { + return new Trampoline() { + @Override + public boolean complete() { + return false; + } + + @Override + public Trampoline jump() { + return trampoline.result(); + } + + @Override + public T get() { + return trampoline(this); + } + + T trampoline(final Trampoline trampoline) { + + return Stream.iterate(trampoline, Trampoline::jump) + .filter(Trampoline::complete) + .findFirst() + .get() + .result(); + + } + }; + } + + +} diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java b/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java new file mode 100644 index 000000000..d629f7a84 --- /dev/null +++ b/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java @@ -0,0 +1,67 @@ +/** + * The MIT License + * Copyright (c) 2014-2016 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +package com.iluwatar.trampoline; + + +import lombok.extern.slf4j.Slf4j; + +/** + *
+ * By representing a computation in one of 2 states + (completed with result, or a reference to the reminder of the computation, + something like the way a java.util.Supplier does) + it is possible to implement algorithms recursively in Java without blowing the stack + and to interleave the execution of functions without hard coding them together or even using threads. +
+
+ Trampoline has 2 state : [done], [ more] +
+ When get is called on the returned Trampoline, internally it will iterate calling ‘jump’ + on the returned Trampoline as long as the concrete instance returned is More, + stopping once the returned instance is Done. Essential we convert looping via recursion into iteration, + the key enabling mechanism is the fact that Trampoline.more is a lazy operation. + Trampoline in cyclops-react extends java.util.Supplier. Calling Trampoline.more we are basically creating + a Supplier that defers the actual recursive call, and having defered the call we can move it outside of the recursive loop. + This means we can define algorithms recursively in Java but execute them iteratively. + */ + +@Slf4j +public class TrampolineApp { + public static void main(String[] args) { + log.info("start pattern"); + Integer result = loop(10, 1).result(); + log.info("result {}" ,result); + + } + /** + * Manager for pattern. + * */ + public static Trampoline loop(int times,int prod){ + if(times==0) + return Trampoline.done(prod); + else + return Trampoline.more(()->loop(times-1,prod*times)); + } + +} diff --git a/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java b/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java new file mode 100644 index 000000000..fb7fc09ee --- /dev/null +++ b/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java @@ -0,0 +1,17 @@ +package com.iluwatar.trampoline; + +import org.junit.Test; + +import java.io.IOException; + +import static org.junit.Assert.*; + +public class TrampolineAppTest { + + @Test + public void test()throws IOException{ + int result = TrampolineApp.loop(10, 1).result(); + assertEquals("Be equal",3628800,result); + } + +} \ No newline at end of file From f7825f6c9942b0d7e07f500bc8f5b4ebf227a8af Mon Sep 17 00:00:00 2001 From: tigraboris Date: Sat, 20 Jan 2018 13:36:43 +0300 Subject: [PATCH 3/5] changes fixing mistakes --- pom.xml | 2 +- trampoline/README.md | 19 ++++++---- trampoline/pom.xml | 3 -- .../com/iluwatar/trampoline/Trampoline.java | 14 +++---- .../iluwatar/trampoline/TrampolineApp.java | 37 ++++++------------- .../trampoline/TrampolineAppTest.java | 3 +- 6 files changed, 34 insertions(+), 44 deletions(-) diff --git a/pom.xml b/pom.xml index 66c5fa850..7e669d396 100644 --- a/pom.xml +++ b/pom.xml @@ -147,13 +147,13 @@ event-sourcing data-transfer-object throttling - unit-of-work partial-response eip-wire-tap eip-splitter eip-aggregator retry + trampoline diff --git a/trampoline/README.md b/trampoline/README.md index 4a4030f39..cae343a61 100644 --- a/trampoline/README.md +++ b/trampoline/README.md @@ -12,13 +12,16 @@ tags: --- ## Intent -By representing a computation in one of 2 states +Trampoline pattern is used for implementing algorithms recursively in Java without blowing the stack +and to interleave the execution of functions without hard coding them together +It is possible by representing a computation in one of 2 states : done | more (completed with result, or a reference to the reminder of the computation, -something like the way a java.util.Supplier does) -it is possible to implement algorithms recursively in Java without blowing the stack -and to interleave the execution of functions without hard coding them together or even using threads. +something like the way a java.util.Supplier does). +## Explanation +Trampoline pattern allows to define recursive algorithms by iterative loop. + ## Applicability Use the Trampoline pattern when @@ -32,9 +35,11 @@ The time overhead of a reflection call is traded for the space overhead of an in Trampolines in Java usually involve the creation of a GenericListener to pass events to an outer class. -## Credits - +## Tutorials * [Trampolining: a practical guide for awesome Java Developers](https://medium.com/@johnmcclean/trampolining-a-practical-guide-for-awesome-java-developers-4b657d9c3076) * [Trampoline in java ](http://mindprod.com/jgloss/trampoline.html) -* [cyclops-react](https://github.com/aol/cyclops-react) + +## Credits +* [library 'cyclops-react' uses the pattern](https://github.com/aol/cyclops-react) + diff --git a/trampoline/pom.xml b/trampoline/pom.xml index c4cef6860..cea93969c 100644 --- a/trampoline/pom.xml +++ b/trampoline/pom.xml @@ -34,19 +34,16 @@ trampoline - junit junit 4.12 test - org.projectlombok lombok 1.16.18 - provided diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java b/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java index 3be44ebba..8a02e246b 100644 --- a/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java +++ b/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java @@ -2,13 +2,13 @@ package com.iluwatar.trampoline; import java.util.stream.Stream; -/**When get is called on the returned Trampoline, internally it will iterate calling ‘jump’ - on the returned Trampoline as long as the concrete instance returned is More, - stopping once the returned instance is Done. Essential we convert looping via recursion into iteration, - the key enabling mechanism is the fact that Trampoline.more is a lazy operation. - Trampoline in cyclops-react extends java.util.Supplier. Calling Trampoline.more we are basically creating - a Supplier that defers the actual recursive call, and having defered the call we can move it outside of the recursive loop. - This means we can define algorithms recursively in Java but execute them iteratively.*/ +/**

Trampoline pattern allows to define recursive algorithms by iterative loop

+ *

When get is called on the returned Trampoline, internally it will iterate calling ‘jump’ + on the returned Trampoline as long as the concrete instance returned is {@link #more(Trampoline)}, + stopping once the returned instance is {@link #done(Object)}.

+

Essential we convert looping via recursion into iteration, + the key enabling mechanism is the fact that {@link #more(Trampoline)} is a lazy operation.

+*/ public interface Trampoline { T get(); diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java b/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java index d629f7a84..73222ddf5 100644 --- a/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java +++ b/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java @@ -1,17 +1,17 @@ /** * The MIT License * Copyright (c) 2014-2016 Ilkka Seppälä - * + *

* Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + *

* The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * + *

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE @@ -27,23 +27,9 @@ package com.iluwatar.trampoline; import lombok.extern.slf4j.Slf4j; /** - *

- * By representing a computation in one of 2 states - (completed with result, or a reference to the reminder of the computation, - something like the way a java.util.Supplier does) - it is possible to implement algorithms recursively in Java without blowing the stack - and to interleave the execution of functions without hard coding them together or even using threads. -
-
- Trampoline has 2 state : [done], [ more] -
- When get is called on the returned Trampoline, internally it will iterate calling ‘jump’ - on the returned Trampoline as long as the concrete instance returned is More, - stopping once the returned instance is Done. Essential we convert looping via recursion into iteration, - the key enabling mechanism is the fact that Trampoline.more is a lazy operation. - Trampoline in cyclops-react extends java.util.Supplier. Calling Trampoline.more we are basically creating - a Supplier that defers the actual recursive call, and having defered the call we can move it outside of the recursive loop. - This means we can define algorithms recursively in Java but execute them iteratively. + *

Trampoline pattern allows to define recursive algorithms by iterative loop

+ *

it is possible to implement algorithms recursively in Java without blowing the stack + * and to interleave the execution of functions without hard coding them together or even using threads.

*/ @Slf4j @@ -51,17 +37,18 @@ public class TrampolineApp { public static void main(String[] args) { log.info("start pattern"); Integer result = loop(10, 1).result(); - log.info("result {}" ,result); + log.info("result {}", result); } + /** - * Manager for pattern. + * Manager for pattern. Define it with a factorial function. * */ - public static Trampoline loop(int times,int prod){ - if(times==0) + public static Trampoline loop(int times, int prod) { + if (times == 0) return Trampoline.done(prod); else - return Trampoline.more(()->loop(times-1,prod*times)); + return Trampoline.more(() -> loop(times - 1, prod * times)); } } diff --git a/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java b/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java index fb7fc09ee..9765131d5 100644 --- a/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java +++ b/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java @@ -8,8 +8,9 @@ import static org.junit.Assert.*; public class TrampolineAppTest { + @Test - public void test()throws IOException{ + public void testTrampolineWithFactorialFunction()throws IOException{ int result = TrampolineApp.loop(10, 1).result(); assertEquals("Be equal",3628800,result); } From 4c4cbd41cf8a1310304bd16a2b40acb18ee7a05d Mon Sep 17 00:00:00 2001 From: tigraboris Date: Sat, 20 Jan 2018 21:42:14 +0300 Subject: [PATCH 4/5] fix checkstyle errors --- .../com/iluwatar/trampoline/Trampoline.java | 127 +++++++++--------- .../iluwatar/trampoline/TrampolineApp.java | 32 +++-- .../trampoline/TrampolineAppTest.java | 14 +- 3 files changed, 91 insertions(+), 82 deletions(-) diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java b/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java index 8a02e246b..277ae9ffb 100644 --- a/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java +++ b/trampoline/src/main/java/com/iluwatar/trampoline/Trampoline.java @@ -2,83 +2,84 @@ package com.iluwatar.trampoline; import java.util.stream.Stream; -/**

Trampoline pattern allows to define recursive algorithms by iterative loop

+/** + *

Trampoline pattern allows to define recursive algorithms by iterative loop

*

When get is called on the returned Trampoline, internally it will iterate calling ‘jump’ - on the returned Trampoline as long as the concrete instance returned is {@link #more(Trampoline)}, - stopping once the returned instance is {@link #done(Object)}.

-

Essential we convert looping via recursion into iteration, - the key enabling mechanism is the fact that {@link #more(Trampoline)} is a lazy operation.

-*/ - -public interface Trampoline { - T get(); + * on the returned Trampoline as long as the concrete instance returned is {@link #more(Trampoline)}, + * stopping once the returned instance is {@link #done(Object)}.

+ *

Essential we convert looping via recursion into iteration, + * the key enabling mechanism is the fact that {@link #more(Trampoline)} is a lazy operation.

+ * + * @param is type for returning result. + */ +public interface Trampoline { + T get(); - /** - * @return next stage - */ - default Trampoline jump() { - return this; - } + /** + * @return next stage + */ + default Trampoline jump() { + return this; + } - default T result() { - return get(); - } + default T result() { + return get(); + } - /** - * @return true if complete - * - */ - default boolean complete() { - return true; - } + /** + * @return true if complete + */ + default boolean complete() { + return true; + } - /** - * Created a completed Trampoline - * - * @param result Completed result - * @return Completed Trampoline - */ - static Trampoline done(final T result) { - return () -> result; - } + /** + * Created a completed Trampoline + * + * @param result Completed result + * @return Completed Trampoline + */ + static Trampoline done(final T result) { + return () -> result; + } - /** - * Create a Trampoline that has more work to do - * - * @param trampoline Next stage in Trampoline - * @return Trampoline with more work - */ - static Trampoline more(final Trampoline> trampoline) { - return new Trampoline() { - @Override - public boolean complete() { - return false; - } + /** + * Create a Trampoline that has more work to do + * + * @param trampoline Next stage in Trampoline + * @return Trampoline with more work + */ + static Trampoline more(final Trampoline> trampoline) { + return new Trampoline() { + @Override + public boolean complete() { + return false; + } - @Override - public Trampoline jump() { - return trampoline.result(); - } + @Override + public Trampoline jump() { + return trampoline.result(); + } - @Override - public T get() { - return trampoline(this); - } + @Override + public T get() { + return trampoline(this); + } - T trampoline(final Trampoline trampoline) { + T trampoline(final Trampoline trampoline) { - return Stream.iterate(trampoline, Trampoline::jump) - .filter(Trampoline::complete) - .findFirst() - .get() - .result(); + return Stream.iterate(trampoline, Trampoline::jump) + .filter(Trampoline::complete) + .findFirst() + .get() + .result(); - } - }; - } + } + }; + } } diff --git a/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java b/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java index 73222ddf5..76e3ed3da 100644 --- a/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java +++ b/trampoline/src/main/java/com/iluwatar/trampoline/TrampolineApp.java @@ -31,24 +31,28 @@ import lombok.extern.slf4j.Slf4j; *

it is possible to implement algorithms recursively in Java without blowing the stack * and to interleave the execution of functions without hard coding them together or even using threads.

*/ - @Slf4j public class TrampolineApp { - public static void main(String[] args) { - log.info("start pattern"); - Integer result = loop(10, 1).result(); - log.info("result {}", result); - } + /** + * Main program for showing pattern. It does loop with factorial function. + * */ + public static void main(String[] args) { + log.info("start pattern"); + Integer result = loop(10, 1).result(); + log.info("result {}", result); - /** - * Manager for pattern. Define it with a factorial function. - * */ - public static Trampoline loop(int times, int prod) { - if (times == 0) - return Trampoline.done(prod); - else - return Trampoline.more(() -> loop(times - 1, prod * times)); + } + + /** + * Manager for pattern. Define it with a factorial function. + */ + public static Trampoline loop(int times, int prod) { + if (times == 0) { + return Trampoline.done(prod); + } else { + return Trampoline.more(() -> loop(times - 1, prod * times)); } + } } diff --git a/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java b/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java index 9765131d5..553e583e1 100644 --- a/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java +++ b/trampoline/src/test/java/com/iluwatar/trampoline/TrampolineAppTest.java @@ -6,13 +6,17 @@ import java.io.IOException; import static org.junit.Assert.*; + +/** + * Test for trampoline pattern. + * */ public class TrampolineAppTest { - @Test - public void testTrampolineWithFactorialFunction()throws IOException{ - int result = TrampolineApp.loop(10, 1).result(); - assertEquals("Be equal",3628800,result); - } + @Test + public void testTrampolineWithFactorialFunction() throws IOException { + int result = TrampolineApp.loop(10, 1).result(); + assertEquals("Be equal", 3628800, result); + } } \ No newline at end of file From 9667878b5f3dacb8a9bd1a7c7d95fa13a153b2d5 Mon Sep 17 00:00:00 2001 From: tigraboris Date: Sat, 20 Jan 2018 22:09:42 +0300 Subject: [PATCH 5/5] add junit - jupiter -engine --- trampoline/pom.xml | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/trampoline/pom.xml b/trampoline/pom.xml index cea93969c..71de3f8f2 100644 --- a/trampoline/pom.xml +++ b/trampoline/pom.xml @@ -31,6 +31,7 @@ com.iluwatar java-design-patterns 1.19.0-SNAPSHOT + trampoline @@ -40,6 +41,18 @@ 4.12 test + + + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine + test + + org.projectlombok lombok