27 | * Note: We create a Clock instance in setup() used for some of the tests. 28 | * 29 | * @see Clock 30 | * @see Month 31 | * @see MonthDay 32 | * @see Year 33 | * @see YearMonth 34 | * @see DayOfWeek 35 | */ 36 | @DisplayNameGeneration(DateTimeKataDisplayNames.class) 37 | @DisplayName("Date and Time partials such as credit card expiration") 38 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 39 | public class TestKata5DateTimePartials { 40 | 41 | private Clock terminatorOriginalJudgementDay = null; 42 | 43 | @BeforeEach 44 | public void setup() { 45 | 46 | Instant instant = Instant.parse("1997-08-29T06:14:30Z"); 47 | // We make an assumption for GMT -4 as the timezone for users of this test. 48 | terminatorOriginalJudgementDay = Clock.fixed(instant, ZoneId.of("GMT-4")); 49 | } 50 | 51 | @Test 52 | @Tag("TODO") 53 | @Order(1) 54 | public void verifyMonth() { 55 | 56 | LocalDateTime tOJDateTime = LocalDateTime.now(terminatorOriginalJudgementDay); 57 | 58 | // TODO: Replace the "Month.JANUARY" below get a Month instance. 59 | // Check: java.time.LocalDateTime.getMonth() 60 | Month tOJMonth = Month.JANUARY; 61 | 62 | assertEquals(Month.AUGUST, 63 | tOJMonth, 64 | "The Month enumeration should match August."); 65 | } 66 | 67 | @Test 68 | @Tag("TODO") 69 | @Order(2) 70 | public void verifyMonthDay() { 71 | 72 | // Real world: Birthday or anniversary 73 | 74 | // TODO: Replace the MonthDay.now() below get a MonthDay anniversary for the Judgement Day. 75 | // Check: java.time.MonthDay.now(java.time.Clock) 76 | MonthDay anniversaryofJudgementDay = MonthDay.now(); 77 | 78 | assertEquals(Month.AUGUST, 79 | anniversaryofJudgementDay.getMonth(), 80 | "The month enumeration should match August."); 81 | 82 | assertEquals(8, 83 | anniversaryofJudgementDay.getMonthValue(), 84 | "The month value should match 8."); 85 | 86 | assertEquals(29, 87 | anniversaryofJudgementDay.getDayOfMonth(), 88 | "The date value should match 29."); 89 | } 90 | 91 | @Test 92 | @Tag("TODO") 93 | @Order(3) 94 | public void verifyYear() { 95 | 96 | // Real world: Age or Year of occurrence. 97 | 98 | // TODO: Replace the Year.now() below get a Year for the Judgement Day. 99 | // Check: java.time.Year.now(java.time.Clock) 100 | Year yearOfJudgementDay = Year.now(); 101 | 102 | assertEquals(1997, 103 | yearOfJudgementDay.getValue(), 104 | "The year value should match 1997."); 105 | } 106 | 107 | @Test 108 | @Tag("TODO") 109 | @Order(4) 110 | public void verifyYearMonth() { 111 | 112 | // Real world: CreditCard or Medicine expiration. 113 | 114 | // TODO: Replace the YearMonth.now() below get a YearMonth for the Judgement Day. 115 | // Check: java.time.YearMonth.now(java.time.Clock) 116 | YearMonth yearMonthOfJudgementDay = YearMonth.now(); 117 | 118 | assertEquals(Month.AUGUST, 119 | yearMonthOfJudgementDay.getMonth(), 120 | "The month enumeration should match August."); 121 | 122 | assertEquals(8, 123 | yearMonthOfJudgementDay.getMonthValue(), 124 | "The month value should match 8."); 125 | 126 | assertEquals(1997, 127 | yearMonthOfJudgementDay.getYear(), 128 | "The year value should match 1997."); 129 | } 130 | 131 | @Test 132 | @Tag("TODO") 133 | @Order(5) 134 | public void verifyDayOfWeek() { 135 | 136 | LocalDateTime tOJDateTime = LocalDateTime.now(terminatorOriginalJudgementDay); 137 | 138 | // TODO: Replace the null below to get the Day Of Week from the tOJDateTime. 139 | // Check: java.time.LocalDateTime.getDayOfWeek() 140 | DayOfWeek dayOfWeek = null; 141 | 142 | assertEquals(DayOfWeek.FRIDAY, 143 | dayOfWeek, 144 | "The day of the week enumeration should match Friday."); 145 | } 146 | 147 | } 148 | -------------------------------------------------------------------------------- /java-handles/src/test/java/none/cvg/methods/TestKataPublicStaticMethodInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.methods; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.invoke.MethodType; 6 | import java.lang.reflect.InvocationTargetException; 7 | import java.lang.reflect.Method; 8 | 9 | import none.cvg.handles.DemoClass; 10 | import none.cvg.handles.HandlesKataDisplayNames; 11 | import org.junit.jupiter.api.DisplayName; 12 | import org.junit.jupiter.api.DisplayNameGeneration; 13 | import org.junit.jupiter.api.MethodOrderer; 14 | import org.junit.jupiter.api.Order; 15 | import org.junit.jupiter.api.Tag; 16 | import org.junit.jupiter.api.Test; 17 | import org.junit.jupiter.api.TestMethodOrder; 18 | 19 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 20 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 21 | import static org.junit.jupiter.api.Assertions.assertEquals; 22 | import static org.junit.jupiter.api.Assertions.fail; 23 | 24 | /* 25 | * TODO: 26 | * This test aims at using MethodHandles to invoke a public static method on a class. 27 | * Each solved test shows how this can be achieved with the traditional reflection calls. 28 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 29 | * the exercise to achieve the same goal with MethodHandles. 30 | */ 31 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 32 | @DisplayName("Invoke DemoClass.publicStaticMethod(String)") 33 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 34 | public class TestKataPublicStaticMethodInvocation { 35 | 36 | @Test 37 | @Tag("PASSING") 38 | @Order(1) 39 | public void reflectionPublicStaticMethod() { 40 | 41 | String expectedOutput = "DemoClass.class - Public static method via reflection"; 42 | 43 | try { 44 | 45 | // Find the method on the class via a getMethod. 46 | Method publicStaticMethod = 47 | DemoClass.class.getMethod("publicStaticMethod", 48 | String.class); 49 | 50 | assertEquals(expectedOutput, 51 | publicStaticMethod.invoke(DemoClass.class, "via reflection"), 52 | "Reflection invocation failed"); 53 | 54 | } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 55 | 56 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 57 | } 58 | } 59 | 60 | @Test 61 | @Tag("TODO") 62 | @Order(2) 63 | public void methodHandlePublicStaticMethod() { 64 | 65 | String expectedOutput = "DemoClass.class - Public static method via Method Handles"; 66 | 67 | /* 68 | * TODO: 69 | * Get a public lookup from java.lang.invoke.MethodHandles 70 | * Public parts of a class are looked up via "public lookups" 71 | * Check API: java.lang.invoke.MethodHandles.publicLookup() 72 | */ 73 | MethodHandles.Lookup publicStaticMethodHandlesLookup = null; 74 | 75 | /* 76 | * TODO: 77 | * Replace the "null"s with valid values to get a signature for a publicStaticMethod. 78 | * Create a methodType instance that matches the signature of what we wish to invoke 79 | * The publicMethod() returns a String and accepts a String parameter 80 | * Check API: java.lang.invoke.MethodType.methodType(?, ?) 81 | */ 82 | MethodType methodType = null; // HINT: MethodType.methodType(null, null); 83 | 84 | try { 85 | 86 | /* 87 | * TODO: 88 | * Replace the "null"s with valid values to get a handle to publicStaticMethod. 89 | * "Find" a method of the class via the Lookup instance, 90 | * based on the methodType described above and the method name. 91 | * Public static methods can be searched via the findStatic() method. 92 | * Check API: java.lang.invoke.MethodHandles.Lookup.findStatic(?, ?, ?) 93 | */ 94 | MethodHandle publicStaticMethodHandle = 95 | publicStaticMethodHandlesLookup.findStatic(null, 96 | null, null); // Class, Method name, Method type 97 | 98 | /* 99 | * ATTENTION: The invoke() method does not take an instance of demoClass as its 100 | * first parameter for static method invocation. 101 | */ 102 | assertEquals(expectedOutput, 103 | publicStaticMethodHandle.invoke( 104 | "via Method Handles"), 105 | "Method handles invocation failed"); 106 | 107 | } catch (NoSuchMethodException | IllegalAccessException e) { 108 | 109 | fail("Failed to execute a public static method invocation via Method Handles: " 110 | + e.getMessage()); 111 | } catch (Throwable t) { 112 | 113 | // invoke throws a Throwable (hence catching Throwable separately). 114 | fail(TEST_FAILURE.getValue() + t.getMessage()); 115 | } 116 | } 117 | } -------------------------------------------------------------------------------- /java-handles/src/solutions/java/none/cvg/methods/TestSolutionPublicStaticMethodInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.methods; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.invoke.MethodType; 6 | import java.lang.reflect.InvocationTargetException; 7 | import java.lang.reflect.Method; 8 | 9 | import none.cvg.handles.DemoClass; 10 | import none.cvg.handles.HandlesKataDisplayNames; 11 | import org.junit.jupiter.api.DisplayName; 12 | import org.junit.jupiter.api.DisplayNameGeneration; 13 | import org.junit.jupiter.api.MethodOrderer; 14 | import org.junit.jupiter.api.Order; 15 | import org.junit.jupiter.api.Tag; 16 | import org.junit.jupiter.api.Test; 17 | import org.junit.jupiter.api.TestMethodOrder; 18 | 19 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 20 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 21 | import static org.junit.jupiter.api.Assertions.assertEquals; 22 | import static org.junit.jupiter.api.Assertions.fail; 23 | 24 | /* 25 | * DONE: 26 | * This test aims at using MethodHandles to invoke a public static method on a class. 27 | * Each solved test shows how this can be achieved with the traditional reflection calls. 28 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 29 | * the exercise to achieve the same goal with MethodHandles. 30 | */ 31 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 32 | @DisplayName("Invoke DemoClass.publicStaticMethod(String)") 33 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 34 | public class TestSolutionPublicStaticMethodInvocation { 35 | 36 | @Test 37 | @Tag("PASSING") 38 | @Order(1) 39 | public void reflectionPublicStaticMethod() { 40 | 41 | String expectedOutput = "DemoClass.class - Public static method via reflection"; 42 | 43 | try { 44 | 45 | // Find the method on the class via a getMethod. 46 | Method publicStaticMethod = 47 | DemoClass.class.getMethod("publicStaticMethod", 48 | String.class); 49 | 50 | assertEquals(expectedOutput, 51 | publicStaticMethod.invoke(DemoClass.class, "via reflection"), 52 | "Reflection invocation failed"); 53 | 54 | } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 55 | 56 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 57 | } 58 | } 59 | 60 | @Test 61 | @Tag("PASSING") 62 | @Order(2) 63 | public void methodHandlePublicStaticMethod() { 64 | 65 | String expectedOutput = "DemoClass.class - Public static method via Method Handles"; 66 | 67 | /* 68 | * DONE: 69 | * Get a public lookup from java.lang.invoke.MethodHandles 70 | * Public parts of a class are looked up via "public lookups" 71 | * Check API: java.lang.invoke.MethodHandles.publicLookup() 72 | */ 73 | MethodHandles.Lookup publicStaticMethodHandlesLookup = MethodHandles.publicLookup(); 74 | 75 | /* 76 | * DONE 77 | * Replace the "null"s with valid values to get a signature for a publicStaticMethod. 78 | * Create a methodType instance that matches the signature of what we wish to invoke 79 | * The publicMethod() returns a String and accepts a String parameter 80 | * Check API: java.lang.invoke.MethodType.methodType(?, ?) 81 | */ 82 | MethodType methodType = MethodType.methodType(String.class, String.class); 83 | 84 | try { 85 | 86 | /* 87 | * DONE 88 | * Replace the "null"s with valid values to get a handle to publicStaticMethod. 89 | * "Find" a method of the class via the Lookup instance, 90 | * based on the methodType described above and the method name. 91 | * Public static methods can be searched via the findStatic() method. 92 | * Check API: java.lang.invoke.MethodHandles.Lookup.findStatic(?, ?, ?) 93 | */ 94 | MethodHandle publicStaticMethodHandle = 95 | publicStaticMethodHandlesLookup.findStatic(DemoClass.class, 96 | "publicStaticMethod", methodType); // Class, Method name, Method type 97 | 98 | /* 99 | * ATTENTION: The invoke() method does not take an instance of demoClass as its 100 | * first parameter for static method invocation. 101 | */ 102 | assertEquals(expectedOutput, 103 | publicStaticMethodHandle.invoke( 104 | "via Method Handles"), 105 | "Method handles invocation failed"); 106 | 107 | } catch (NoSuchMethodException | IllegalAccessException e) { 108 | 109 | fail("Failed to execute a public static method invocation via Method Handles: " 110 | + e.getMessage()); 111 | } catch (Throwable t) { 112 | 113 | // invoke throws a Throwable (hence catching Throwable separately). 114 | fail(TEST_FAILURE.getValue() + t.getMessage()); 115 | } 116 | } 117 | } -------------------------------------------------------------------------------- /java-datetime/src/solutions/java/none/cvg/datetime/TestSolution5DateTimePartials.java: -------------------------------------------------------------------------------- 1 | package none.cvg.datetime; 2 | 3 | import java.time.Clock; 4 | import java.time.DayOfWeek; 5 | import java.time.Instant; 6 | import java.time.LocalDateTime; 7 | import java.time.Month; 8 | import java.time.MonthDay; 9 | import java.time.Year; 10 | import java.time.YearMonth; 11 | import java.time.ZoneId; 12 | 13 | import org.junit.jupiter.api.BeforeEach; 14 | import org.junit.jupiter.api.DisplayName; 15 | import org.junit.jupiter.api.DisplayNameGeneration; 16 | import org.junit.jupiter.api.MethodOrderer; 17 | import org.junit.jupiter.api.Order; 18 | import org.junit.jupiter.api.Tag; 19 | import org.junit.jupiter.api.Test; 20 | import org.junit.jupiter.api.TestMethodOrder; 21 | 22 | import static org.junit.jupiter.api.Assertions.assertEquals; 23 | 24 | /** 25 | * DateTime partials: Month, MonthDay, Year, YearMonth and DayOfWeek tests. 26 | *
27 | * Note: We create a Clock instance in setup() used for some of the tests. 28 | * 29 | * @see Clock 30 | * @see Month 31 | * @see MonthDay 32 | * @see Year 33 | * @see YearMonth 34 | * @see DayOfWeek 35 | */ 36 | @DisplayNameGeneration(DateTimeKataDisplayNames.class) 37 | @DisplayName("Date and Time partials such as credit card expiration") 38 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 39 | public class TestSolution5DateTimePartials { 40 | 41 | private Clock terminatorOriginalJudgementDay = null; 42 | 43 | @BeforeEach 44 | public void setup() { 45 | 46 | Instant instant = Instant.parse("1997-08-29T06:14:30Z"); 47 | // We make an assumption for GMT -4 as the timezone for users of this test. 48 | terminatorOriginalJudgementDay = Clock.fixed(instant, ZoneId.of("GMT-4")); 49 | } 50 | 51 | @Test 52 | @Tag("PASSING") 53 | @Order(1) 54 | public void verifyMonth() { 55 | 56 | LocalDateTime tOJDateTime = LocalDateTime.now(terminatorOriginalJudgementDay); 57 | 58 | // DONE: Replace the "null" below get a Month instance. 59 | // Check: java.time.LocalDateTime.getMonth() 60 | Month tOJMonth = tOJDateTime.getMonth(); 61 | 62 | assertEquals(Month.AUGUST, 63 | tOJMonth, 64 | "The Month enumeration should match August."); 65 | } 66 | 67 | @Test 68 | @Tag("PASSING") 69 | @Order(2) 70 | public void verifyMonthDay() { 71 | 72 | // Real world: Birthday or anniversary 73 | 74 | // DONE: Replace the MonthDay.now() below get a MonthDay anniversary for the Judgement Day. 75 | // Check: java.time.MonthDay.now(java.time.Clock) 76 | MonthDay anniversaryofJudgementDay = MonthDay.now(terminatorOriginalJudgementDay); 77 | 78 | assertEquals(Month.AUGUST, 79 | anniversaryofJudgementDay.getMonth(), 80 | "The month enumeration should match August."); 81 | 82 | assertEquals(8, 83 | anniversaryofJudgementDay.getMonthValue(), 84 | "The month value should match 8."); 85 | 86 | assertEquals(29, 87 | anniversaryofJudgementDay.getDayOfMonth(), 88 | "The date value should match 29."); 89 | } 90 | 91 | @Test 92 | @Tag("PASSING") 93 | @Order(3) 94 | public void verifyYear() { 95 | 96 | // Real world: Age or Year of occurrence. 97 | 98 | // DONE: Replace the Year.now() below get a Year for the Judgement Day. 99 | // Check: java.time.Year.now(java.time.Clock) 100 | Year yearOfJudgementDay = Year.now(terminatorOriginalJudgementDay); 101 | 102 | assertEquals(1997, 103 | yearOfJudgementDay.getValue(), 104 | "The year value should match 1997."); 105 | } 106 | 107 | @Test 108 | @Tag("PASSING") 109 | @Order(4) 110 | public void verifyYearMonth() { 111 | 112 | // Real world: CreditCard or Medicine expiration. 113 | 114 | // DONE: Replace the YearMonth.now() below get a YearMonth for the Judgement Day. 115 | // Check: java.time.YearMonth.now(java.time.Clock) 116 | YearMonth yearMonthOfJudgementDay = YearMonth.now(terminatorOriginalJudgementDay); 117 | 118 | assertEquals(Month.AUGUST, 119 | yearMonthOfJudgementDay.getMonth(), 120 | "The month enumeration should match August."); 121 | 122 | assertEquals(8, 123 | yearMonthOfJudgementDay.getMonthValue(), 124 | "The month value should match 8."); 125 | 126 | assertEquals(1997, 127 | yearMonthOfJudgementDay.getYear(), 128 | "The year value should match 1997."); 129 | } 130 | 131 | @Test 132 | @Tag("PASSING") 133 | @Order(5) 134 | public void verifyDayOfWeek() { 135 | 136 | LocalDateTime tOJDateTime = LocalDateTime.now(terminatorOriginalJudgementDay); 137 | 138 | // DONE: Replace the null below to get the Day Of Week from the tOJDateTime. 139 | // Check: java.time.LocalDateTime.getDayOfWeek() 140 | DayOfWeek dayOfWeek = tOJDateTime.getDayOfWeek(); 141 | 142 | assertEquals(DayOfWeek.FRIDAY, 143 | dayOfWeek, 144 | "The day of the week enumeration should match Friday."); 145 | } 146 | 147 | } 148 | -------------------------------------------------------------------------------- /java-optional/README.adoc: -------------------------------------------------------------------------------- 1 | = java-optional 2 | :toc: 3 | :toclevels: 4 4 | 5 | image:assets/images/DukeOptional.png[Java Duke Optional Logo, 233, 420] 6 | 7 | Quite often, we have to test if a field or variable is `null` or has a value. 8 | Conditional checks in traditional java relied on an if condition. 9 | Failure to check and assumption of existence of a value can lead to the 10 | ever-so-popular `NullPointerException`. 11 | 12 | Sir Charles Anthony Richard Hoare (Tony Hoare), creator of the *null reference* 13 | rued the creation of null in 2009: 14 | 15 | >I call it my billion-dollar mistake. It was the invention of the null reference in 1965. 16 | At that time, I was designing the first comprehensive type system for references in an 17 | object-oriented language (ALGOL W). My goal was to ensure that all use of references 18 | should be absolutely safe, with checking performed automatically by the compiler. 19 | But, I couldn't resist the temptation to put in a null reference, simply because it was 20 | so easy to implement. This has led to innumerable errors, vulnerabilities, and 21 | system crashes, which have probably caused a billion dollars of pain and damage in 22 | the last forty years. 23 | 24 | Optional was added in Java 8 as a possible solution to errant null issues. An Optional wrapper 25 | over a field or variable ensures there is a check - or - a deliberate attempt to get a value from 26 | the wrapper. The kata will help us better understand the features of `java.util.Optional` 27 | 28 | == What is a Code-Kata 29 | 30 | A code-kata is a coding exercise that builds muscle memory by a practice of programming to arrive 31 | at a known solution. 32 | 33 | === How does one go about with this code kata? 34 | 35 | The essence of the exercise (presentation material and code kata) is to demonstrate the 36 | usage patterns for the java API or functionality. 37 | 38 | This set of code katas rely on fixing broken tests. The tests may have multiple solutions, the 39 | intent is to learn and experiment. 40 | 41 | The project contains several JUnit tests that fail. 42 | 43 | ==== Simple steps to use this kata 44 | 45 | . Run the test class(es). 46 | . One or more tests will fail with the test failure message. 47 | . Fix the failing tests by using `HINT` and `TODO` comments. 48 | . Repeat above steps until all tests pass. 49 | . Check the solutions to see if there are other ways to solve. 50 | (Remember, the solution may be less performant/optimal than yours) 51 | . Rinse and repeat (delete and checkout again, then back to Step 1) to build muscle memory. 52 | 53 | === Mission 54 | > Your mission, should you choose to accept it, will be to fix the JUnit tests. This 55 | message will self-destruct in `**NaN**` minutes. 56 | 57 | == Requirements 58 | How to prepare for coding along 59 | 60 | This kata is developed as a Java maven project.Ensure that you have: 61 | 62 | . Apache Maven 3.6.x or above. _Tested with Apache Maven 3.6.0_. 63 | Link: https://maven.apache.org/download.cgi 64 | 65 | . JDK 11 or above. _Tested with OpenJDK 11_ 66 | Link: http://jdk.java.net/11/ 67 | 68 | . Your favorite Java IDE. _IntelliJ IDEA Ultimate was used to develop this kata_. 69 | 70 | == Project Structure 71 | 72 | The structure of the project: 73 | 74 | [source] 75 | ---- 76 | |____pom.xml 77 | |____README.md 78 | | 79 | |____src 80 | | | 81 | | |____test <------------------- Kata Tests 82 | | | |____java 83 | | | |____none 84 | | | |____cvg 85 | | | |____optional 86 | | | 87 | | |____solutions <------------------- Solutions 88 | | | |____java 89 | | | |____none 90 | | | |____cvg 91 | | | |____optional 92 | ---- 93 | 94 | == Tests Included 95 | 96 | === Java Optional API 97 | The JUnit tests listed below are set to utilize the Java Optional API features. 98 | 99 | link:src/test/java/none/cvg/optional/TestKata1OptionalCreationAndFetchingValues.java[TestKata1OptionalCreationAndFetchingValues.java]:: show creation of and fetching value from an Optional. 100 | 101 | link:src/test/java/none/cvg/optional/TestKata2OptionalConditionalFetching.java[TestKata2OptionalConditionalFetching.java]:: show conditional checks and alternate actions when fetching values from an Optional. 102 | 103 | link:src/test/java/none/cvg/optional/TestKata3StreamsAndOptionals.java[TestKata3StreamsAndOptionals.java]:: show the usage of Optional in Java Stream API. 104 | 105 | == Solutions 106 | 107 | .Solutions for each test 108 | |=== 109 | | Kata Test | Solution 110 | 111 | |link:src/test/java/none/cvg/optional/TestKata1OptionalCreationAndFetchingValues.java[TestKata1OptionalCreationAndFetchingValues.java] 112 | |link:src/solutions/java/none/cvg/optional/TestSolution1OptionalCreationAndFetchingValues.java[TestSolution1OptionalCreationAndFetchingValues.java] 113 | 114 | |link:src/test/java/none/cvg/optional/TestKata2OptionalConditionalFetching.java[TestKata2OptionalConditionalFetching.java] 115 | |link:src/solutions/java/none/cvg/optional/TestSolution2OptionalConditionalFetching.java[TestSolution2OptionalConditionalFetching.java] 116 | 117 | |link:src/test/java/none/cvg/optional/TestKata3StreamsAndOptionals.java[TestKata3StreamsAndOptionals.java] 118 | |link:src/solutions/java/none/cvg/optional/TestSolution3StreamsAndOptionals.java[TestSolution3StreamsAndOptionals.java] 119 | |=== 120 | 121 | == Take Away 122 | 123 | The key take-away from this kata is a solid understanding of the Java Optional API. 124 | -------------------------------------------------------------------------------- /java-datetime/src/test/java/none/cvg/datetime/TestKata1InstantAndDateInterop.java: -------------------------------------------------------------------------------- 1 | package none.cvg.datetime; 2 | 3 | import java.text.SimpleDateFormat; 4 | import java.time.Instant; 5 | import java.util.Date; 6 | import java.util.TimeZone; 7 | 8 | import org.junit.jupiter.api.BeforeEach; 9 | import org.junit.jupiter.api.DisplayName; 10 | import org.junit.jupiter.api.DisplayNameGeneration; 11 | import org.junit.jupiter.api.MethodOrderer; 12 | import org.junit.jupiter.api.Order; 13 | import org.junit.jupiter.api.Tag; 14 | import org.junit.jupiter.api.Test; 15 | import org.junit.jupiter.api.TestMethodOrder; 16 | 17 | import static none.cvg.datetime.LenientAssert.assertAlmostEquals; 18 | import static org.junit.jupiter.api.Assertions.assertEquals; 19 | import static org.junit.jupiter.api.Assertions.assertTrue; 20 | 21 | /** 22 | * The tests in this class aim to show interoperability between 23 | * `java.util.Date` and the newer `java.time.Instant`. 24 | * 25 | * @see Instant 26 | * @see Date 27 | * @see LenientAssert 28 | */ 29 | @DisplayNameGeneration(DateTimeKataDisplayNames.class) 30 | @DisplayName("Instant And Date Interoperability") 31 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 32 | public class TestKata1InstantAndDateInterop { 33 | 34 | private Date classicDate; 35 | 36 | private SimpleDateFormat classicDateFormatter = new SimpleDateFormat("YYYY-MM-dd'T'HH:mm:ss.SSS'Z'"); 37 | 38 | @BeforeEach 39 | public void setup() { 40 | classicDate = new Date(); 41 | } 42 | 43 | @Test 44 | @Tag("TODO") 45 | @Order(1) 46 | public void verifyInstantAndDateHaveSameEpochMilliseconds() { 47 | 48 | // TODO: Replace the Instant.now() with an instant from classicDate. 49 | // Use a Date API that converts Date instances into Instant instances. 50 | // Check: java.util.Date.toInstant() 51 | Instant instant = Instant.now(); 52 | 53 | // TODO: Replace the "null" below to get milliseconds from epoch from the Instant 54 | // Use an Instant API which converts it into milliseconds 55 | // Check: java.time.Instant.toEpochMilli() 56 | assertEquals(Long.valueOf(classicDate.getTime()), 57 | null, 58 | "Date and Instant milliseconds should be equal"); 59 | } 60 | 61 | @Test 62 | @Tag("TODO") 63 | @Order(2) 64 | public void verifyInstantAndDateHaveAlmostSameEpochSeconds() { 65 | 66 | Instant instant = classicDate.toInstant(); 67 | 68 | // NOTE: There is no simpler API method to get epoch seconds. 69 | long classicDateInSeconds = classicDate.getTime() / 1000; 70 | 71 | // TODO: Replace the "null" below to get seconds from epoch from the Instant 72 | // Assert that the seconds from epoch from both Date and Instant are equal. 73 | // Check: java.time.Instant.getEpochSecond() 74 | // NOTE: We use a custom assertion here since the millis to second arithmetic may cause 75 | // rounding issues. We add a tolerance of 1 second. 76 | assertAlmostEquals(classicDateInSeconds, 77 | null, 78 | 1L, 79 | "Date and Instant seconds should almost match"); 80 | } 81 | 82 | @Test 83 | @Tag("TODO") 84 | @Order(3) 85 | public void verifyInstantHasNanoseconds() { 86 | 87 | Instant instant = Instant.now(); 88 | 89 | // TODO: Replace the string "-2" below to get nanos from the Instant 90 | // Assert that instant has nano seconds. 91 | // Check: java.time.Instant.getNano() 92 | assertTrue(Integer.valueOf("-2") > -1, 93 | "Instant should have nanoseconds"); 94 | } 95 | 96 | @Test 97 | @Tag("TODO") 98 | @Order(4) 99 | public void verifyInstantDefaultFormatting() { 100 | 101 | classicDateFormatter.setTimeZone(TimeZone.getTimeZone("UTC")); 102 | 103 | Instant instant = classicDate.toInstant(); 104 | 105 | // TODO: Replace the "null" below to retrieve an instant as a string 106 | // Assert that instant default toString matches the ISO8601 full date format. 107 | assertEquals(classicDateFormatter.format(classicDate), 108 | null, 109 | "Instant toString() should match ISO8601 format"); 110 | } 111 | 112 | @Test 113 | @Tag("TODO") 114 | @Order(5) 115 | public void verifyInstantDateInteroperability() { 116 | 117 | // ***************************************************** 118 | // Converting Date to an Instant. 119 | // ***************************************************** 120 | Instant instant = classicDate.toInstant(); 121 | assertEquals(classicDate.getTime(), instant.toEpochMilli()); 122 | 123 | 124 | // ***************************************************** 125 | // Converting an Instant to a Date. 126 | // ***************************************************** 127 | // TODO: Replace the "null" below to convert an Instant into a Date 128 | // Check: java.util.Date.from() 129 | Date anotherDate = null; 130 | assertEquals(classicDate, anotherDate); 131 | 132 | // ***************************************************** 133 | // Think about why all conversions and inter-ops are 134 | // built into Date and not the newer java.time API. 135 | // ***************************************************** 136 | } 137 | 138 | } 139 | -------------------------------------------------------------------------------- /java-datetime/README.adoc: -------------------------------------------------------------------------------- 1 | = Java Time API - A Code kata 2 | :toc: 3 | :toclevels: 4 4 | 5 | image:assets/images/DukeTime.png[Java Duke Date Time Logo, 233, 420] 6 | 7 | Most, if not all Java developers need to rely on Java date and time libraries. 8 | 9 | == What is a Code-Kata 10 | 11 | A code-kata is a coding exercise that builds muscle memory by a practice of programming to arrive 12 | at a known solution. 13 | 14 | === How does one go about with this code kata? 15 | 16 | The essence of the exercise (presentation material and code kata) is to demonstrate the 17 | usage patterns for the java API or functionality. 18 | 19 | This set of code katas rely on fixing broken tests. The tests may have multiple solutions, the 20 | intent is to learn and experiment. 21 | 22 | The project contains several JUnit tests that fail. 23 | 24 | ==== Simple steps to use this kata 25 | 26 | . Run the test class(es). 27 | . One or more tests will fail with the test failure message. 28 | . Fix the failing tests by using `HINT` and `TODO` comments. 29 | . Repeat above steps until all tests pass. 30 | . Check the solutions to see if there are other ways to solve. 31 | (Remember, the solution may be less performant/optimal than yours) 32 | . Rinse and repeat (delete and checkout again, then back to Step 1) to build muscle memory. 33 | 34 | === Mission 35 | > Your mission, should you choose to accept it, will be to fix the JUnit tests. This 36 | message will self-destruct in `**NaN**` minutes. 37 | 38 | == Requirements 39 | How to prepare for coding along 40 | 41 | This kata is developed as a Java maven project.Ensure that you have: 42 | 43 | . Apache Maven 3.6.x or above. _Tested with Apache Maven 3.6.3_. 44 | Link: https://maven.apache.org/download.cgi 45 | 46 | . JDK 11 or above. _Tested with OpenJDK 11_ 47 | Link: http://jdk.java.net/11/ 48 | 49 | . Your favorite Java IDE. _IntelliJ IDEA Ultimate was used to develop this kata_. 50 | 51 | == Project Structure 52 | 53 | The structure of the project: 54 | 55 | [source] 56 | ---- 57 | |____pom.xml 58 | |____README.md 59 | | 60 | |____src 61 | | | 62 | | |____test <------------------- Kata Tests 63 | | | |____java 64 | | | |____none 65 | | | |____cvg 66 | | | |____datetime 67 | | | 68 | | |____main <------------------- Shared ErrorMessages & DemoClass 69 | | | |____java 70 | | | |____none 71 | | | |____cvg 72 | | | |____datetime 73 | | | 74 | | |____solutions <------------------- Solutions 75 | | | |____java 76 | | | |____none 77 | | | |____cvg 78 | | | |____datetime 79 | ---- 80 | 81 | 82 | == Tests Included 83 | 84 | === Java Date Time API 85 | 86 | The JUnit tests listed below are setup to utilize the Java Time API features. 87 | 88 | link:src/test/java/none/cvg/datetime/TestKata1InstantAndDateInterop.java[TestKata1InstantAndDateInterop.java]:: show interoperability between `java.util.Date`, and the newer `java.time.Instant`. 89 | 90 | link:src/test/java/none/cvg/datetime/TestKata2Clocks.java[TestKata2Clocks.java]:: show the usage of `java.time.Clock`. 91 | 92 | link:src/test/java/none/cvg/datetime/TestKata3LocalAndZonedDateTimes.java[TestKata3LocalAndZonedDateTimes.java]:: show the usage of `java.time.LocalDate`, `java.time.LocalTime`, `java.time.LocalDateTime` and `java.time.ZonedDateTime`. 93 | 94 | link:src/test/java/none/cvg/datetime/TestKata4PeriodsAndDurations.java[TestKata4PeriodsAndDurations.java]:: show the usage of DateTime ranges: Period, Duration tests. 95 | 96 | link:src/test/java/none/cvg/datetime/TestKata5DateTimePartials.java[TestKata5DateTimePartials.java]:: show the usage of DateTime partials: Month, MonthDay, Year, YearMonth and DayOfWeek tests. 97 | 98 | link:src/test/java/none/cvg/datetime/TestKata6StreamsInDateTime.java[TestKata6StreamsInDateTime.java]:: show the usage of DateTime in Java `stream()` lazy iterations. 99 | 100 | == Solutions 101 | 102 | .Solutions for each test: 103 | |=== 104 | | Kata Test | Solution 105 | 106 | |link:src/test/java/none/cvg/datetime/TestKata1InstantAndDateInterop.java[TestKata1InstantAndDateInterop.java] 107 | |link:src/solutions/java/none/cvg/datetime/TestSolution1InstantAndDateInterop.java[TestSolution1InstantAndDateInterop.java] 108 | 109 | |link:src/test/java/none/cvg/datetime/TestKata2Clocks.java[TestKata2Clocks.java] 110 | |link:src/solutions/java/none/cvg/datetime/TestSolution2Clocks.java[TestSolution2Clocks.java] 111 | 112 | |link:src/test/java/none/cvg/datetime/TestKata3LocalAndZonedDateTimes.java[TestKata3LocalAndZonedDateTimes.java] 113 | |link:src/solutions/java/none/cvg/datetime/TestSolution3LocalAndZonedDateTimes.java[TestSolution3LocalAndZonedDateTimes.java] 114 | 115 | |link:src/test/java/none/cvg/datetime/TestKata4PeriodsAndDurations.java[TestKata4PeriodsAndDurations.java] 116 | |link:src/solutions/java/none/cvg/datetime/TestSolution4PeriodsAndDurations.java[TestSolution4PeriodsAndDurations.java] 117 | 118 | |link:src/test/java/none/cvg/datetime/TestKata5DateTimePartials.java[TestKata5DateTimePartials.java] 119 | |link:src/solutions/java/none/cvg/datetime/TestSolution5DateTimePartials.java[TestSolution5DateTimePartials.java] 120 | 121 | |link:src/test/java/none/cvg/datetime/TestKata6StreamsInDateTime.java[TestKata6StreamsInDateTime.java] 122 | |link:src/solutions/java/none/cvg/datetime/TestSolution6StreamsInDateTime.java[TestSolution6StreamsInDateTime.java] 123 | |=== 124 | 125 | == Take Away 126 | 127 | The key take-away from this kata is a solid understanding of the Java Time API. 128 | -------------------------------------------------------------------------------- /java-datetime/src/solutions/java/none/cvg/datetime/TestSolution1InstantAndDateInterop.java: -------------------------------------------------------------------------------- 1 | package none.cvg.datetime; 2 | 3 | import java.text.SimpleDateFormat; 4 | import java.time.Instant; 5 | import java.util.Date; 6 | import java.util.TimeZone; 7 | 8 | import org.junit.jupiter.api.BeforeEach; 9 | import org.junit.jupiter.api.DisplayName; 10 | import org.junit.jupiter.api.DisplayNameGeneration; 11 | import org.junit.jupiter.api.MethodOrderer; 12 | import org.junit.jupiter.api.Order; 13 | import org.junit.jupiter.api.Tag; 14 | import org.junit.jupiter.api.Test; 15 | import org.junit.jupiter.api.TestMethodOrder; 16 | 17 | import static none.cvg.datetime.LenientAssert.assertAlmostEquals; 18 | import static org.junit.jupiter.api.Assertions.assertEquals; 19 | import static org.junit.jupiter.api.Assertions.assertTrue; 20 | 21 | /** 22 | * The tests in this class aim to show interoperability between 23 | * `java.util.Date` and the newer `java.time.Instant`. 24 | * 25 | * @see Instant 26 | * @see Date 27 | * @see LenientAssert 28 | */ 29 | @DisplayNameGeneration(DateTimeKataDisplayNames.class) 30 | @DisplayName("Instant And Date Interoperability") 31 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 32 | public class TestSolution1InstantAndDateInterop { 33 | 34 | private Date classicDate; 35 | 36 | private SimpleDateFormat classicDateFormatter = new SimpleDateFormat("YYYY-MM-dd'T'HH:mm:ss.SSS'Z'"); 37 | 38 | @BeforeEach 39 | public void setup() { 40 | classicDate = new Date(); 41 | } 42 | 43 | @Test 44 | @Tag("PASSING") 45 | @Order(1) 46 | public void verifyInstantAndDateHaveSameEpochMilliseconds() { 47 | 48 | // DONE: Replace the Instant.now() with an instant from classicDate. 49 | // Use a Date API that converts Date instances into Instant instances. 50 | // Check: java.util.Date.toInstant() 51 | Instant instant = classicDate.toInstant(); 52 | 53 | // DONE: Replace the "null" below to get milliseconds from epoch from the Instant 54 | // Use an Instant API which converts it into milliseconds 55 | // Check: java.time.Instant.toEpochMilli() 56 | assertEquals(Long.valueOf(classicDate.getTime()), 57 | instant.toEpochMilli(), 58 | "Date and Instant milliseconds should be equal"); 59 | } 60 | 61 | @Test 62 | @Tag("PASSING") 63 | @Order(2) 64 | public void verifyInstantAndDateHaveAlmostSameEpochSeconds() { 65 | 66 | Instant instant = classicDate.toInstant(); 67 | 68 | // NOTE: There is no simpler API method to get epoch seconds. 69 | long classicDateInSeconds = classicDate.getTime() / 1000; 70 | 71 | // DONE: Replace the "null" below to get seconds from epoch from the Instant 72 | // Assert that the seconds from epoch from both Date and Instant are equal. 73 | // Check: java.time.Instant.getEpochSecond() 74 | // NOTE: We use a custom assertion here since the millis to second arithmetic may cause 75 | // rounding issues. We add a tolerance of 1 second. 76 | assertAlmostEquals(classicDateInSeconds, 77 | instant.getEpochSecond(), 78 | 1L, 79 | "Date and Instant seconds should almost match"); 80 | } 81 | 82 | @Test 83 | @Tag("PASSING") 84 | @Order(3) 85 | public void verifyInstantHasNanoseconds() { 86 | 87 | Instant instant = Instant.now(); 88 | 89 | // DONE: Replace the "null" below to get nanos from the Instant 90 | // Assert that instant has nano seconds. 91 | // Check: java.time.Instant.getNano() 92 | assertTrue(Integer.valueOf(instant.getNano()) > -1, 93 | "Instant should have nanoseconds"); 94 | } 95 | 96 | @Test 97 | @Tag("PASSING") 98 | @Order(4) 99 | public void verifyInstantDefaultFormatting() { 100 | 101 | classicDateFormatter.setTimeZone(TimeZone.getTimeZone("UTC")); 102 | 103 | Instant instant = classicDate.toInstant(); 104 | 105 | // DONE: Replace the "null" below to retrieve an instant as a string 106 | // Assert that instant default toString matches the ISO8601 full date format. 107 | assertEquals(classicDateFormatter.format(classicDate), 108 | instant.toString(), 109 | "Instant toString() should match ISO8601 format"); 110 | } 111 | 112 | @Test 113 | @Tag("PASSING") 114 | @Order(5) 115 | public void verifyInstantDateInteroperability() { 116 | 117 | // ***************************************************** 118 | // Converting Date to an Instant. 119 | // ***************************************************** 120 | Instant instant = classicDate.toInstant(); 121 | assertEquals(classicDate.getTime(), instant.toEpochMilli()); 122 | 123 | 124 | // ***************************************************** 125 | // Converting an Instant to a Date. 126 | // ***************************************************** 127 | // DONE: Replace the "null" below to convert an Instant into a Date 128 | // Check: java.util.Date.from() 129 | Date anotherDate = Date.from(instant); 130 | assertEquals(classicDate, anotherDate); 131 | 132 | // ***************************************************** 133 | // Think about why all conversions and inter-ops are 134 | // built into Date and not the newer java.time API. 135 | // ***************************************************** 136 | } 137 | 138 | } 139 | -------------------------------------------------------------------------------- /CONTRIBUTING.adoc: -------------------------------------------------------------------------------- 1 | = Contributing 2 | 3 | Thank you for your interest in contributing to this set of Code Katas ! 4 | 5 | == Contribution Guide 6 | 7 | === Build policy 8 | 9 | The Code Katas in this repository are arranged as independent maven projects that can be orchestrated or built together using the aggregator and **parent pom** pom.xml at the root of the project. The parent pom (located at the root of the project) defines a few properties used throughout (such as the *JUnit version*, and the *Java compiler's source and target* version). In addition, some common build plugins are configured under the `pluginManagement` section of the parent pom. 10 | 11 | ==== REQUIREMENT 12 | The individual Kata projects should remain independent build targets and should not depend on any other module or kata for a successful build. 13 | 14 | === Kata structure 15 | 16 | Irrespective of the contribution style (a full module or enhancement/bug fix to existing module), here are some requirements: 17 | 18 | ==== General Project Structure 19 | 20 | The project layout in the every Code Kata is similar.Here is a tree structure to explain: 21 | 22 | [source] 23 | ---- 24 | |____pom.xml <------------------- Project pom, using the java-katas/pom.xml as parent 25 | |____README.md <------------------- Well documented README, with links to tests & solutions 26 | | 27 | |____src 28 | | | 29 | | |____test <------------------- Kata Tests 30 | | | |____java 31 | | | |____none 32 | | | |____cvg 33 | | | |____ <------------------- Name the package that corresponds to the kata. 34 | | | |____ <------------------- Optional multiple packages if the kata covers more sections 35 | | | 36 | | |____main <------------------- Shared content (re-used in both tests and solutions) 37 | | | |____java 38 | | | |____none 39 | | | |____cvg 40 | | | 41 | | |____solutions <------------------- Solutions 42 | | | |____java 43 | | | |____none 44 | | | |____cvg 45 | | | |____ <------------------- Name the package that corresponds to the kata. 46 | | | |____ <------------------- Optional multiple packages if the kata covers more sections 47 | 48 | ---- 49 | ==== REQUIREMENT 50 | The Code Kata project structure should comply with the setup of a `test` folder with failing tests, and a `solution` folder with solved working tests. 51 | 52 | When contributing to this repository, please first discuss the change you wish to make via issue, 53 | email, or any other method with the owners of this repository before making a change. 54 | 55 | == Code of Conduct 56 | 57 | In the interest of fostering an open and welcoming environment, we as 58 | contributors and maintainers pledge to making participation in our project, and 59 | our community a harassment-free experience for everyone, regardless of age, body 60 | size, disability, ethnicity, gender identity and expression, level of experience, 61 | nationality, personal appearance, race, religion, or sexual identity and 62 | orientation. 63 | 64 | === Our Standards 65 | 66 | Examples of behavior that contributes to creating a positive environment 67 | include: 68 | 69 | * Using welcoming and inclusive language 70 | * Being respectful of differing viewpoints and experiences 71 | * Gracefully accepting constructive criticism 72 | * Focusing on what is best for the community 73 | * Showing empathy towards other community members 74 | 75 | Examples of unacceptable behavior by participants include: 76 | 77 | * The use of sexualized language or imagery and unwelcome sexual attention or 78 | advances 79 | * Trolling, insulting/derogatory comments, and personal or political attacks 80 | * Public or private harassment 81 | * Publishing others' private information, such as a physical or electronic 82 | address, without explicit permission 83 | * Other conduct which could reasonably be considered inappropriate in a 84 | professional setting 85 | 86 | === Our Responsibilities 87 | 88 | Project maintainers are responsible for clarifying the standards of acceptable 89 | behavior and are expected to take appropriate and fair corrective action in 90 | response to any instances of unacceptable behavior. 91 | 92 | Project maintainers have the right and responsibility to remove, edit, or 93 | reject comments, commits, code, wiki edits, issues, and other contributions 94 | that are not aligned to this Code of Conduct, or to ban temporarily or 95 | permanently any contributor for other behaviors that they deem inappropriate, 96 | threatening, offensive, or harmful. 97 | 98 | === Scope 99 | 100 | This Code of Conduct applies both within project spaces and in public spaces 101 | when an individual is representing the project or its community.Examples of 102 | representing a project or community include using an official project e-mail 103 | address, posting via an official social media account, or acting as an appointed 104 | representative at an online or offline event.Representation of a project may be 105 | further defined and clarified by project maintainers. 106 | 107 | === Enforcement 108 | 109 | Project maintainers who do not follow or enforce the Code of Conduct in good 110 | faith may face temporary or permanent repercussions as determined by other 111 | members of the project's leadership. 112 | 113 | === Attribution 114 | 115 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, 116 | available at [http://contributor-covenant.org/version/1/4][version] 117 | 118 | [homepage]: http://contributor-covenant.org 119 | [version]: http://contributor-covenant.org/version/1/4/ 120 | -------------------------------------------------------------------------------- /java-lambdas/src/solutions/java/none/cvg/lambdas/TestSolution2LambdasDeeperDive.java: -------------------------------------------------------------------------------- 1 | package none.cvg.lambdas; 2 | 3 | import org.junit.jupiter.api.DisplayName; 4 | import org.junit.jupiter.api.DisplayNameGeneration; 5 | import org.junit.jupiter.api.MethodOrderer; 6 | import org.junit.jupiter.api.Order; 7 | import org.junit.jupiter.api.Tag; 8 | import org.junit.jupiter.api.Test; 9 | import org.junit.jupiter.api.TestMethodOrder; 10 | 11 | import java.util.ArrayList; 12 | import java.util.Arrays; 13 | import java.util.Collections; 14 | import java.util.Comparator; 15 | import java.util.List; 16 | import java.util.function.BiFunction; 17 | import java.util.function.Function; 18 | 19 | import static org.junit.jupiter.api.Assertions.assertEquals; 20 | import static org.junit.jupiter.api.Assertions.assertTrue; 21 | 22 | @DisplayNameGeneration(LambdasKataDisplayNames.class) 23 | @DisplayName("Lambdas - A deeper dive") 24 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 25 | public class TestSolution2LambdasDeeperDive { 26 | 27 | @Test 28 | @Tag("PASSING") 29 | @Order(1) 30 | @DisplayName("use a BiFunction") 31 | public void useBiFunction() { 32 | 33 | final int integer1 = 3; 34 | final int integer2 = 4; 35 | 36 | // DONE: 37 | // Replace the MyBiFuncton class with a BiFunction named add. 38 | // Replace the max with a sum() function. 39 | // ------------------- 40 | // Hint: BiFunction adder = (x, y) -> //do something 41 | // Check API: java.util.function.BiFunction 42 | // Check API: java.util.function.BiFunction.apply 43 | BiFunction adder = (x, y) -> Integer.sum(x, y); 44 | // ------------------- 45 | 46 | assertEquals(7, adder.apply(integer1, integer2), 47 | "The function should produce a result of 7"); 48 | } 49 | 50 | @Test 51 | @Tag("PASSING") 52 | @Order(2) 53 | public void partialFunctions() { 54 | // Partial application describes the conversion of a multi-argument function 55 | // into one that accepts fewer arguments, with values for the elided arguments 56 | // supplied in advance. It partially applies some arguments to a function, 57 | // returning a function with a signature that consists of the remaining arguments. 58 | BiFunction add = (x, y) -> x + y; 59 | 60 | // TODO: 61 | // Replace the below Function to create a partial function from the above BiFunction 62 | // Create an addOne, which passes in a 1 and a int n to the add function and 63 | // returns a partial application of 1, n. 64 | // HINT: use the add.apply(?, ?) 65 | Function addOne = n -> add.apply(1, n); 66 | 67 | // TODO: 68 | // Replace the 6 with a call to addOne 69 | // HINT: use the addOne.apply() to return a value of 7 70 | assertEquals(7, addOne.apply(6), 71 | "The function should return 7"); 72 | } 73 | 74 | /** 75 | * @see Calculator - An interface with a single calculate() abstract method. 76 | */ 77 | @Test 78 | @Tag("PASSING") 79 | @Order(3) 80 | public void customSingleAbstractFunctions() { 81 | // DONE: 82 | // Replace the below Function to a lambda 83 | // Replace the zero with a valid function call 84 | Calculator addition = (x, y) -> x + y; 85 | 86 | // DONE: 87 | // Replace the below Function to a lambda 88 | // Replace the zero with a valid function call 89 | Calculator subtraction = (x, y) -> x - y; 90 | 91 | // DONE: 92 | // Replace the below Function to a lambda 93 | // Replace the zero with a valid function call 94 | Calculator multiplication = (x, y) -> x * y; 95 | 96 | assertTrue(7 == addition.calculate(6, 1), 97 | "The addition should return a value of 7"); 98 | 99 | assertTrue(7 == subtraction.calculate(10, 3), 100 | "The subtraction should return a value of 7"); 101 | 102 | assertTrue(49 == multiplication.calculate(7, 7), 103 | "The multiplication should return a value of 49"); 104 | } 105 | 106 | @Test 107 | @Tag("PASSING") 108 | @Order(4) 109 | public void sortNames() { 110 | List persons = 111 | Arrays.asList(Person.ALICE, Person.BOB, Person.CATHY, Person.DHRUV, Person.EMILY); 112 | List expectedList = 113 | Arrays.asList(Person.EMILY, Person.BOB, Person.DHRUV, Person.ALICE, Person.CATHY); 114 | 115 | // TODO: 116 | // Replace the anonymous class with a lambda. 117 | // Replace the postions of o2 and o1 to pass the test as well 118 | 119 | // ----------------- Solution 1 ----------------- 120 | Comparator nameSorter = (Comparator) (o1, o2) -> o1.getLastName().compareTo(o2.getLastName()); 121 | List actualList = new ArrayList<>(); 122 | actualList.addAll(persons); 123 | Collections.sort(actualList, nameSorter); 124 | // ----------------------------------------------- 125 | 126 | // ----------------- Solution 2 ----------------- 127 | // Comparator nameSorter = Comparator.comparing(Person::getLastName); 128 | // List actualList = persons.stream().sorted(nameSorter).collect(Collectors.toList()); 129 | // ----------------------------------------------- 130 | 131 | assertEquals(expectedList, actualList, "The sorted lists should match"); 132 | } 133 | } 134 | -------------------------------------------------------------------------------- /java-lambdas/src/test/java/none/cvg/lambdas/TestKata2LambdasDeeperDive.java: -------------------------------------------------------------------------------- 1 | package none.cvg.lambdas; 2 | 3 | import org.junit.jupiter.api.DisplayName; 4 | import org.junit.jupiter.api.DisplayNameGeneration; 5 | import org.junit.jupiter.api.MethodOrderer; 6 | import org.junit.jupiter.api.Order; 7 | import org.junit.jupiter.api.Tag; 8 | import org.junit.jupiter.api.Test; 9 | import org.junit.jupiter.api.TestMethodOrder; 10 | 11 | import java.util.ArrayList; 12 | import java.util.Arrays; 13 | import java.util.Collections; 14 | import java.util.Comparator; 15 | import java.util.List; 16 | import java.util.function.BiFunction; 17 | import java.util.function.Function; 18 | 19 | import static org.junit.jupiter.api.Assertions.assertEquals; 20 | import static org.junit.jupiter.api.Assertions.assertTrue; 21 | 22 | @DisplayNameGeneration(LambdasKataDisplayNames.class) 23 | @DisplayName("Lambdas - A deeper dive") 24 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 25 | public class TestKata2LambdasDeeperDive { 26 | 27 | @Test 28 | @Tag("TODO") 29 | @Order(1) 30 | @DisplayName("use a BiFunction") 31 | public void useBiFunction() { 32 | 33 | final int integer1 = 3; 34 | final int integer2 = 4; 35 | 36 | // TODO: 37 | // Replace the MyBiFuncton class with a BiFunction named add. 38 | // Replace the max with a sum() function. 39 | // ------------------- 40 | // Hint: BiFunction adder = (x, y) -> //do something 41 | // Check API: java.util.function.BiFunction 42 | // Check API: java.util.function.BiFunction.apply 43 | class MyBiFunction { 44 | int apply(int x, int y) { 45 | return Integer.max(x, y); 46 | } 47 | } 48 | MyBiFunction adder = new MyBiFunction(); 49 | // ------------------- 50 | 51 | assertEquals(7, adder.apply(integer1, integer2), 52 | "The function should produce a result of 7"); 53 | } 54 | 55 | @Test 56 | @Tag("TODO") 57 | @Order(2) 58 | public void partialFunctions() { 59 | // Partial application describes the conversion of a multi-argument function 60 | // into one that accepts fewer arguments, with values for the elided arguments 61 | // supplied in advance. It partially applies some arguments to a function, 62 | // returning a function with a signature that consists of the remaining arguments. 63 | BiFunction add = (x, y) -> x + y; 64 | 65 | // TODO: 66 | // Replace the below Function to create a partial function from the above BiFunction 67 | // Create an addOne, which passes in a 1 and a int n to the add function and 68 | // returns a partial application of 1, n. 69 | // HINT: use the add.apply(?, ?) 70 | Function addOne = n -> 0; 71 | 72 | // TODO: 73 | // Replace the 6 with a call to addOne 74 | // HINT: use the addOne.apply() to return a value of 7 75 | assertEquals(7, addOne.apply(6), 76 | "The function should return 7"); 77 | } 78 | 79 | /** 80 | * @see Calculator - An interface with a single calculate() abstract method. 81 | */ 82 | @Test 83 | @Tag("TODO") 84 | @Order(3) 85 | public void customSingleAbstractFunctions() { 86 | // TODO: 87 | // Replace the below Function to a lambda 88 | // Replace the zero with a valid function call 89 | Calculator addition = new Calculator() { 90 | @Override 91 | public int calculate(int x, int y) { 92 | return 0; 93 | } 94 | }; 95 | 96 | // TODO: 97 | // Replace the below Function to a lambda 98 | // Replace the zero with a valid function call 99 | Calculator subtraction = new Calculator() { 100 | @Override 101 | public int calculate(int x, int y) { 102 | return 0; 103 | } 104 | }; 105 | 106 | // TODO: 107 | // Replace the below Function to a lambda 108 | // Replace the zero with a valid function call 109 | Calculator multiplication = new Calculator() { 110 | @Override 111 | public int calculate(int x, int y) { 112 | return 0; 113 | } 114 | }; 115 | 116 | assertTrue(7 == addition.calculate(6, 1), 117 | "The addition should return a value of 7"); 118 | 119 | assertTrue(7 == subtraction.calculate(10, 3), 120 | "The subtraction should return a value of 7"); 121 | 122 | assertTrue(49 == multiplication.calculate(7, 7), 123 | "The multiplication should return a value of 49"); 124 | } 125 | 126 | @Test 127 | @Tag("TODO") 128 | @Order(4) 129 | public void sortNames() { 130 | List persons = 131 | Arrays.asList(Person.ALICE, Person.BOB, Person.CATHY, Person.DHRUV, Person.EMILY); 132 | List expectedList = 133 | Arrays.asList(Person.EMILY, Person.BOB, Person.DHRUV, Person.ALICE, Person.CATHY); 134 | 135 | // TODO: 136 | // Replace the anonymous class with a lambda. 137 | // Replace the postions of o2 and o1 to pass the test as well 138 | Comparator nameSorter = new Comparator<>() { 139 | @Override 140 | public int compare(Person o1, Person o2) { 141 | return o2.getLastName().compareTo(o1.getLastName()); 142 | } 143 | }; 144 | List actualList = new ArrayList<>(); 145 | actualList.addAll(persons); 146 | Collections.sort(actualList, nameSorter); 147 | 148 | assertEquals(expectedList, actualList, "The sorted lists should match"); 149 | } 150 | } 151 | -------------------------------------------------------------------------------- /java-optional/src/test/java/none/cvg/optional/TestKata1OptionalCreationAndFetchingValues.java: -------------------------------------------------------------------------------- 1 | package none.cvg.optional; 2 | 3 | import org.junit.jupiter.api.BeforeEach; 4 | import org.junit.jupiter.api.DisplayName; 5 | import org.junit.jupiter.api.MethodOrderer; 6 | import org.junit.jupiter.api.Order; 7 | import org.junit.jupiter.api.Tag; 8 | import org.junit.jupiter.api.Test; 9 | import org.junit.jupiter.api.TestMethodOrder; 10 | 11 | import java.util.NoSuchElementException; 12 | import java.util.Optional; 13 | 14 | import static org.junit.jupiter.api.Assertions.assertEquals; 15 | import static org.junit.jupiter.api.Assertions.assertFalse; 16 | import static org.junit.jupiter.api.Assertions.assertNotEquals; 17 | import static org.junit.jupiter.api.Assertions.assertThrows; 18 | import static org.junit.jupiter.api.Assertions.assertTrue; 19 | 20 | /* 21 | * TODO: 22 | * This test aims at understanding the basic features of Optional 23 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 24 | * the exercise. 25 | * 26 | * empty(), of(?), ofNullable(?), isPresent(), get() 27 | */ 28 | @DisplayName("java.util.Optional Creation And Getting value") 29 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 30 | public class TestKata1OptionalCreationAndFetchingValues { 31 | 32 | @BeforeEach 33 | public void setUp() { 34 | } 35 | 36 | @Test 37 | @DisplayName("create an empty Optional") 38 | @Tag("TODO") 39 | @Order(1) 40 | public void emptyOptional() { 41 | 42 | /* 43 | * TODO: 44 | * Replace the "null" to create an empty Optional. 45 | * Check API: java.util.Optional.empty() 46 | */ 47 | Optional optionalEmptyString = null; 48 | 49 | assertTrue(optionalEmptyString instanceof Optional, 50 | "The optionalEmptyString should be an instance of Optional"); 51 | 52 | assertTrue(optionalEmptyString.isEmpty(), 53 | "The optionalEmptyString should be empty"); 54 | } 55 | 56 | @Test 57 | @DisplayName("create an Optional from a variable") 58 | @Tag("TODO") 59 | @Order(2) 60 | public void createOptionalFromValue() { 61 | 62 | Integer anInteger = 10; 63 | 64 | /* 65 | * TODO: 66 | * Replace the "null" to create an Optional for anInteger. 67 | * Check API: java.util.Optional.of(?) 68 | */ 69 | Optional optionalForInteger = null; 70 | 71 | assertTrue(optionalForInteger instanceof Optional, 72 | "The optionalEmptyString should be an instance of Optional"); 73 | 74 | assertFalse(optionalForInteger.isEmpty(), 75 | "The optionalForInteger should not be empty"); 76 | } 77 | 78 | @Test 79 | @DisplayName("create a nullable Optional from a variable") 80 | @Tag("TODO") 81 | @Order(3) 82 | public void createNullableOptionalFromValue() { 83 | 84 | Integer anInteger = null; 85 | 86 | /* 87 | * TODO: 88 | * Replace the "null" to create a nullable Optional for anInteger. 89 | * Check API: java.util.Optional.ofNullable(?) 90 | */ 91 | Optional optionalNullableInteger = Optional.of(10); 92 | 93 | assertTrue(optionalNullableInteger instanceof Optional, 94 | "The optionalNullableInteger should be an instance of Optional"); 95 | 96 | assertTrue(optionalNullableInteger.isEmpty(), 97 | "The optionalNullableInteger should be empty"); 98 | } 99 | 100 | @Test 101 | @DisplayName("check a non-null Optional has a value") 102 | @Tag("TODO") 103 | @Order(4) 104 | public void checkOptionalForNonNullValueIsPresent() { 105 | 106 | Integer anInteger = 10; 107 | 108 | Optional optionalInteger = Optional.ofNullable(anInteger); 109 | 110 | /* 111 | * TODO: 112 | * Replace the "false" to check that the Optional has a non-null value. 113 | * Check API: java.util.Optional.isPresent() 114 | */ 115 | assertTrue(false, 116 | "The optionalNullableInteger should be present"); 117 | 118 | 119 | anInteger = null; 120 | 121 | optionalInteger = Optional.ofNullable(anInteger); 122 | 123 | /* 124 | * TODO: 125 | * Replace the "true" to check that the Optional has a non-null value. 126 | * Check API: java.util.Optional.isPresent() 127 | */ 128 | assertFalse(true, 129 | "The optionalNullableInteger should not be present"); 130 | 131 | } 132 | 133 | @Test 134 | @DisplayName("fetch from a non-null and from a null holding Optional") 135 | @Tag("TODO") 136 | @Order(5) 137 | public void getValueFromOptionalForNonNullValue() { 138 | 139 | Integer anInteger = 10; 140 | 141 | Optional optionalInteger = Optional.ofNullable(anInteger); 142 | 143 | /* 144 | * TODO: 145 | * Replace the "11" to check that the Optional has a non-null value. 146 | * Check API: java.util.Optional.get() 147 | */ 148 | assertEquals(10, 149 | 11, 150 | "The optionalNullableInteger should be present"); 151 | 152 | 153 | anInteger = null; 154 | 155 | Optional anotherOptionalInteger = Optional.ofNullable(anInteger); 156 | 157 | /* 158 | * TODO: 159 | * Replace the "10" to get the Optional has a null value. 160 | * Verify that the call throws a NoSuchElementException 161 | * Check API: java.util.Optional.get() 162 | */ 163 | assertThrows(NoSuchElementException.class, () -> { 164 | 165 | assertNotEquals(10, 166 | 10, 167 | "This call should throw a NoSuchElementException"); 168 | }); 169 | 170 | } 171 | 172 | } 173 | -------------------------------------------------------------------------------- /java-handles/src/test/java/none/cvg/constructors/TestKataParameteredConstructorInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.constructors; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.invoke.MethodType; 6 | import java.lang.reflect.Constructor; 7 | import java.lang.reflect.InvocationTargetException; 8 | 9 | import none.cvg.handles.DemoClass; 10 | import none.cvg.handles.HandlesKataDisplayNames; 11 | import org.junit.jupiter.api.DisplayName; 12 | import org.junit.jupiter.api.DisplayNameGeneration; 13 | import org.junit.jupiter.api.MethodOrderer; 14 | import org.junit.jupiter.api.Order; 15 | import org.junit.jupiter.api.Tag; 16 | import org.junit.jupiter.api.Test; 17 | import org.junit.jupiter.api.TestMethodOrder; 18 | 19 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 20 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 21 | import static org.junit.jupiter.api.Assertions.assertEquals; 22 | import static org.junit.jupiter.api.Assertions.fail; 23 | 24 | /* 25 | * TODO: 26 | * This test aims at using MethodHandles to invoke a constructor with a parameter on a class in 27 | * order to create a new instance. 28 | * Each solved test shows how this can be achieved with the traditional reflection calls. 29 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 30 | * the exercise to achieve the same goal with MethodHandles. 31 | */ 32 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 33 | @DisplayName("Invoke DemoClass(String)") 34 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 35 | public class TestKataParameteredConstructorInvocation { 36 | 37 | @Test 38 | @Tag("PASSING") 39 | @Order(1) 40 | public void reflectionParamConstructor() { 41 | 42 | String expectedOutput = "[Constructor Demo]" + 43 | " - Constructor via reflection"; 44 | 45 | try { 46 | 47 | Class demoClassClass = 48 | (Class) Class.forName("none.cvg.handles.DemoClass"); 49 | 50 | Constructor demoClassConstructor = 51 | demoClassClass.getConstructor(String.class); 52 | 53 | DemoClass demoClass = 54 | demoClassConstructor.newInstance("Constructor Demo"); 55 | 56 | assertEquals(expectedOutput, 57 | demoClass.printStuff("Constructor via reflection"), 58 | "Reflection invocation failed"); 59 | 60 | } catch (ClassNotFoundException | NoSuchMethodException | 61 | InstantiationException | IllegalAccessException | InvocationTargetException e) { 62 | 63 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 64 | } 65 | } 66 | 67 | 68 | @Test 69 | @Tag("TODO") 70 | @Order(2) 71 | public void methodHandleParamConstructor() { 72 | 73 | String expectedOutput = "[Constructor Demo] - Constructor via Method Handles"; 74 | 75 | /* 76 | * TODO: 77 | * The API provides a few lookup mechanisms. For a public constructor, on a 78 | * public class, we can use the lookup with minimal checks and trust. 79 | * Public members of public classes are looked up via "public lookups" 80 | * Check API: java.lang.invoke.MethodHandles.publicLookup() 81 | */ 82 | MethodHandles.Lookup publicMethodHandlesLookup = null; 83 | 84 | /* 85 | * TODO: 86 | * Create a methodType instance that matches the constructor that takes a string param 87 | * Constructors should have a void return type 88 | * This constructor has a string parameter 89 | * Search for method that: has a return type of void (Constructor) 90 | * and accepts a String parameter. 91 | * Check API: java.lang.invoke.MethodType.methodType(?, ?) 92 | */ 93 | MethodType methodType = null; // HINT: MethodType.methodType(?, ?); 94 | 95 | try { 96 | 97 | /* 98 | * TODO: 99 | * Replace the "nulls" to find a constructor handle for DemoClass using methodType 100 | * "Find" a constructor of the class via the Lookup instance, 101 | * based on the methodType described above 102 | * Check API: java.lang.invoke.MethodHandles.Lookup.findConstructor(?, ?) 103 | */ 104 | MethodHandle demoClassConstructor = 105 | publicMethodHandlesLookup.findConstructor(null, null); 106 | // Hint: Class and MethodType 107 | 108 | /* 109 | * TODO: 110 | * Invoke the constructor and pass in "Constructor Demo" as the parameter. 111 | * Create an instance of the DemoClass by invoking the method handle 112 | * The MethodHandle has two methods invoke() and invokeExact() 113 | * The invoke() is good for conversion/substitution of param types 114 | * The invokeExact() is great if there is no ambiguity 115 | * Check API: java.lang.invoke.MethodHandle.invokeExact(?) 116 | */ 117 | DemoClass demoClass = 118 | null; //HINT: invokeExact( 119 | //constructor argument(s)); Requires casting. 120 | 121 | assertEquals(expectedOutput, 122 | demoClass.printStuff( 123 | "Constructor via Method Handles"), 124 | "Method handles invocation failed"); 125 | 126 | } catch (NoSuchMethodException | IllegalAccessException e) { 127 | 128 | fail("Failed to execute a constructor invocation via Method Handles: " 129 | + e.getMessage()); 130 | } catch (Throwable t) { 131 | 132 | // invokeExact() throws a Throwable (hence catching Throwable separately). 133 | fail(TEST_FAILURE.getValue() + t.getMessage()); 134 | } 135 | } 136 | } -------------------------------------------------------------------------------- /java-optional/src/test/java/none/cvg/optional/TestKata3StreamsAndOptionals.java: -------------------------------------------------------------------------------- 1 | package none.cvg.optional; 2 | 3 | import org.junit.jupiter.api.BeforeEach; 4 | import org.junit.jupiter.api.DisplayName; 5 | import org.junit.jupiter.api.MethodOrderer; 6 | import org.junit.jupiter.api.Order; 7 | import org.junit.jupiter.api.Tag; 8 | import org.junit.jupiter.api.Test; 9 | import org.junit.jupiter.api.TestMethodOrder; 10 | 11 | import java.util.HashMap; 12 | import java.util.HashSet; 13 | import java.util.Map; 14 | import java.util.Optional; 15 | import java.util.Set; 16 | import java.util.TreeSet; 17 | 18 | import static org.junit.jupiter.api.Assertions.assertEquals; 19 | 20 | /* 21 | * TODO: 22 | * These tests show how Optionals can be used in stream APIs 23 | * The first test demonstrates a simple usage of Optional using isPresent() and get() 24 | * while the second test shows the newer API flatMap() that returns Optionals if they exist 25 | * and discards empty values. 26 | * 27 | * stream(), isPresent(), get() 28 | */ 29 | @DisplayName("Optional - using Optionals in collections with Stream API") 30 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 31 | public class TestKata3StreamsAndOptionals { 32 | 33 | private Set expectedSetOfNameValuePairs; 34 | private Set namesSet = new HashSet<>(); 35 | private Map nameNameValuePairMap = new HashMap<>(); 36 | 37 | private static class NameValuePair implements Comparable { 38 | private String name; 39 | 40 | private String value; 41 | 42 | public NameValuePair() { 43 | } 44 | 45 | public NameValuePair(String name, String value) { 46 | this.name = name; 47 | this.value = value; 48 | } 49 | 50 | public NameValuePair name(final String name) { 51 | this.name = name; 52 | return this; 53 | } 54 | 55 | public NameValuePair value(final String value) { 56 | this.value = value; 57 | return this; 58 | } 59 | 60 | public String getName() { 61 | return name; 62 | } 63 | 64 | public void setName(String name) { 65 | this.name = name; 66 | } 67 | 68 | public String getValue() { 69 | return value; 70 | } 71 | 72 | public void setValue(String value) { 73 | this.value = value; 74 | } 75 | 76 | @Override 77 | public int compareTo(Object o) { 78 | NameValuePair that = (NameValuePair) o; 79 | return this.getName().compareTo(that.getName()); 80 | } 81 | 82 | } 83 | 84 | @BeforeEach 85 | public void setUp() { 86 | expectedSetOfNameValuePairs = new TreeSet<>(); 87 | expectedSetOfNameValuePairs.add(new NameValuePair("ABC", "01_02_03")); 88 | expectedSetOfNameValuePairs.add(new NameValuePair("DEF", "04_05_06")); 89 | expectedSetOfNameValuePairs.add(new NameValuePair("XYZ", "24_25_26")); 90 | 91 | namesSet = new HashSet<>(); 92 | namesSet.add("ABC"); 93 | namesSet.add("DEF"); 94 | namesSet.add("XYZ"); 95 | namesSet.add("ZZZ"); 96 | 97 | nameNameValuePairMap.put("ABC", new NameValuePair("ABC", "01_02_03")); 98 | nameNameValuePairMap.put("DEF", new NameValuePair("DEF", "04_05_06")); 99 | nameNameValuePairMap.put("XYZ", new NameValuePair("XYZ", "24_25_26")); 100 | } 101 | 102 | public Optional findOptionalNameValuePair(String name) { 103 | return Optional.ofNullable(nameNameValuePairMap.get(name)); 104 | } 105 | 106 | @Test 107 | @DisplayName("Java 8 Streaming with Optional") 108 | @Tag("TODO") 109 | @Order(1) 110 | public void java8Example() { 111 | 112 | /* 113 | * TODO: 114 | * Replace the code below to use stream() API: 115 | * 1. stream() the namesSet 116 | * 2. map() to get an Optional using this::findOptionalNameValuePair(?) 117 | * 3. filter() to include non empty Optionals, use Optional::isPresent as predicate 118 | * 4. map() to get the actual NameValuePair object, use Optional::get 119 | * 5. collect() to a Set, use Collectors.toSet() 120 | */ 121 | Set actualNameValuePairs = new TreeSet<>(); 122 | for (String name : namesSet) { 123 | NameValuePair nameValuePair = nameNameValuePairMap.get(name); 124 | if (nameValuePair != null) { 125 | actualNameValuePairs.add(nameValuePair); 126 | } 127 | } 128 | 129 | assertEquals( 130 | expectedSetOfNameValuePairs, 131 | actualNameValuePairs, 132 | "The two collections should be the same"); 133 | } 134 | 135 | @Test 136 | @DisplayName("Java 9 and above Streaming with Optional") 137 | @Tag("TODO") 138 | @Order(2) 139 | public void java9Example() { 140 | /* 141 | * TODO: 142 | * Replace the code below to use stream() API: 143 | * 1. stream() the namesSet 144 | * 2. map() to get an Optional using this::findOptionalNameValuePair(?) 145 | * 3. flatMap() to include non empty Optionals, use Optional::stream flattener 146 | * 4. collect() to a Set, use Collectors.toSet() 147 | */ 148 | Set actualNameValuePairs = new TreeSet<>(); 149 | for (String name : namesSet) { 150 | NameValuePair nameValuePair = nameNameValuePairMap.get(name); 151 | if (nameValuePair != null) { 152 | actualNameValuePairs.add(nameValuePair); 153 | } 154 | } 155 | 156 | assertEquals( 157 | expectedSetOfNameValuePairs, 158 | actualNameValuePairs, 159 | "The two collections should be the same"); 160 | } 161 | 162 | } 163 | -------------------------------------------------------------------------------- /java-handles/src/solutions/java/none/cvg/constructors/TestSolutionParameteredConstructorInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.constructors; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.invoke.MethodType; 6 | import java.lang.reflect.Constructor; 7 | import java.lang.reflect.InvocationTargetException; 8 | 9 | import none.cvg.handles.DemoClass; 10 | import none.cvg.handles.HandlesKataDisplayNames; 11 | import org.junit.jupiter.api.DisplayName; 12 | import org.junit.jupiter.api.DisplayNameGeneration; 13 | import org.junit.jupiter.api.MethodOrderer; 14 | import org.junit.jupiter.api.Order; 15 | import org.junit.jupiter.api.Tag; 16 | import org.junit.jupiter.api.Test; 17 | import org.junit.jupiter.api.TestMethodOrder; 18 | 19 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 20 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 21 | import static org.junit.jupiter.api.Assertions.assertEquals; 22 | import static org.junit.jupiter.api.Assertions.fail; 23 | 24 | /* 25 | * DONE: 26 | * This test aims at using MethodHandles to invoke a constructor with a parameter on a class in 27 | * order to create a new instance. 28 | * Each solved test shows how this can be achieved with the traditional reflection calls. 29 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 30 | * the exercise to achieve the same goal with MethodHandles. 31 | */ 32 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 33 | @DisplayName("Invoke DemoClass(String)") 34 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 35 | public class TestSolutionParameteredConstructorInvocation { 36 | 37 | @Test 38 | @Tag("PASSING") 39 | @Order(1) 40 | public void reflectionParamConstructor() { 41 | 42 | String expectedOutput = "[Constructor Demo]" + 43 | " - Constructor via reflection"; 44 | 45 | try { 46 | 47 | Class demoClassClass = 48 | (Class) Class.forName("none.cvg.handles.DemoClass"); 49 | 50 | Constructor demoClassConstructor = 51 | demoClassClass.getConstructor(String.class); 52 | 53 | DemoClass demoClass = 54 | demoClassConstructor.newInstance("Constructor Demo"); 55 | 56 | assertEquals(expectedOutput, 57 | demoClass.printStuff("Constructor via reflection"), 58 | "Reflection invocation failed"); 59 | 60 | } catch (ClassNotFoundException | NoSuchMethodException | 61 | InstantiationException | IllegalAccessException | InvocationTargetException e) { 62 | 63 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 64 | } 65 | } 66 | 67 | 68 | @Test 69 | @Tag("PASSING") 70 | @Order(2) 71 | public void methodHandleParamConstructor() { 72 | 73 | String expectedOutput = "[Constructor Demo] - Constructor via Method Handles"; 74 | 75 | /* 76 | * DONE: 77 | * The API provides a few lookup mechanisms. For a public constructor, on a 78 | * public class, we can use the lookup with minimal checks and trust. 79 | * Public members of public classes are looked up via "public lookups" 80 | * Check API: java.lang.invoke.MethodHandles.publicLookup() 81 | */ 82 | MethodHandles.Lookup publicMethodHandlesLookup = MethodHandles.publicLookup(); 83 | 84 | /* 85 | * DONE: 86 | * Create a methodType instance that matches the constructor that takes a string param 87 | * Constructors should have a void return type 88 | * This constructor has a string parameter 89 | * Search for method that: has a return type of void (Constructor) 90 | * and accepts a String parameter. 91 | * Check API: java.lang.invoke.MethodType.methodType(?, ?) 92 | */ 93 | MethodType methodType = MethodType.methodType(void.class, String.class); 94 | 95 | try { 96 | 97 | /* 98 | * DONE: 99 | * Replace the "nulls" to find a constructor handle for DemoClass using methodType 100 | * "Find" a constructor of the class via the Lookup instance, 101 | * based on the methodType described above 102 | * Check API: java.lang.invoke.MethodHandles.Lookup.findConstructor(?, ?) 103 | */ 104 | MethodHandle demoClassConstructor = 105 | publicMethodHandlesLookup.findConstructor(DemoClass.class, methodType); 106 | // Hint: Class and MethodType 107 | 108 | /* 109 | * DONE: 110 | * Invoke the constructor and pass in "Constructor Demo" as the parameter. 111 | * Create an instance of the DemoClass by invoking the method handle 112 | * The MethodHandle has two methods invoke() and invokeExact() 113 | * The invoke() is good for conversion/substitution of param types 114 | * The invokeExact() is great if there is no ambiguity 115 | * Check API: java.lang.invoke.MethodHandle.invokeExact(?) 116 | */ 117 | DemoClass demoClass = 118 | (DemoClass) demoClassConstructor.invokeExact( 119 | "Constructor Demo"); 120 | 121 | assertEquals(expectedOutput, 122 | demoClass.printStuff( 123 | "Constructor via Method Handles"), 124 | "Method handles invocation failed"); 125 | 126 | } catch (NoSuchMethodException | IllegalAccessException e) { 127 | 128 | fail("Failed to execute a constructor invocation via Method Handles: " 129 | + e.getMessage()); 130 | } catch (Throwable t) { 131 | 132 | // invokeExact() throws a Throwable (hence catching Throwable separately). 133 | fail(TEST_FAILURE.getValue() + t.getMessage()); 134 | } 135 | } 136 | } -------------------------------------------------------------------------------- /java-futures/README.adoc: -------------------------------------------------------------------------------- 1 | = java-futures 2 | :toc: 3 | :toclevels: 4 4 | 5 | image:assets/images/DukeCompletableFuture.png[Duke with Back to the Future Car, 480, 321] 6 | 7 | `java.util.concurrent.CompletableFuture` is a versatile utility in Java (since Java 8).It provides a means of task execution, both synchronous and asynchronous. 8 | 9 | A CompletableFuture implements `java.util.concurrent.Future` (available since Java 5) and `java.util.concurrent.CompletionStage` (available since Java 8) and adds additional methods for operating on tasks. 10 | 11 | Some additional documentation about the three in this kata: 12 | 13 | * link:assets/docs/Future.adoc[Future] 14 | * link:assets/docs/CompletionStage.adoc[CompletionStage] 15 | * link:assets/docs/CompletableFuture.adoc[CompletableFuture] 16 | 17 | A special lookup for exception handling: 18 | 19 | * link:assets/docs/Exceptions.adoc[Exception Handling in CompletableFuture] 20 | 21 | == What is a Code-Kata 22 | 23 | A code-kata is a coding exercise that builds muscle memory by a practice of programming to arrive 24 | at a known solution. 25 | 26 | === How does one go about with this code kata? 27 | 28 | The essence of the exercise (presentation material and code kata) is to demonstrate the 29 | usage patterns for the java API or functionality. 30 | 31 | This set of code katas rely on fixing broken tests. The tests may have multiple solutions, the 32 | intent is to learn and experiment. 33 | 34 | The project contains several JUnit tests that fail. 35 | 36 | ==== Simple steps to use this kata 37 | 38 | . Run the test class(es). 39 | . One or more tests will fail with the test failure message. 40 | . Fix the failing tests by using `HINT` and `TODO` comments. 41 | . Repeat above steps until all tests pass. 42 | . Check the solutions to see if there are other ways to solve. 43 | (Remember, the solution may be less performant/optimal than yours) 44 | . Rinse and repeat (delete and checkout again, then back to Step 1) to build muscle memory. 45 | 46 | === Mission 47 | > Your mission, should you choose to accept it, will be to fix the JUnit tests. This 48 | message will self-destruct in `**NaN**` minutes. 49 | 50 | == Requirements 51 | How to prepare for coding along 52 | 53 | This kata is developed as a Java maven project. Ensure that you have: 54 | 55 | . Apache Maven 3.6.x or above. _Tested with Apache Maven 3.6.3_. 56 | Link: https://maven.apache.org/download.cgi 57 | 58 | . JDK 11 or above. _Tested with OpenJDK 16_ 59 | Link: http://jdk.java.net/11/ 60 | 61 | . Your favorite Java IDE. _IntelliJ IDEA Ultimate was used to develop this kata_. 62 | 63 | == Project Structure 64 | 65 | The structure of the project: 66 | 67 | [source] 68 | ---- 69 | |____pom.xml 70 | |____README.adoc <------------------- This file 71 | |____assets 72 | | |____docs <------------------- Documentation 73 | | |____images 74 | |____src 75 | | |____test <------------------- Kata Tests 76 | | | |____java 77 | | | |____none 78 | | | |____cvg 79 | | | |____futures 80 | | |____solutions <------------------- Solutions 81 | | | |____java 82 | | | |____none 83 | | | |____cvg 84 | | | |____futures 85 | ---- 86 | 87 | == Tests Included 88 | 89 | === Java CompletableFuture 90 | 91 | The JUnit tests listed below are set up to utilize the Java CompletableFuture API features. 92 | 93 | 94 | link:src/test/java/none/cvg/futures/TestKata1SimpleCompletableFutureOperations.java[TestKata1SimpleCompletableFutureOperations.java]:: covers the basic features of creating CompletableFuture instances and fetching results. 95 | 96 | link:src/test/java/none/cvg/futures/TestKata2HandleExceptionsInCompletableFuture.java[TestKata2HandleExceptionsInCompletableFuture.java]:: covers how CompletableFuture exceptions are handled. + 97 | Also check: link:assets/docs/Exceptions.adoc[Tabulated Exception Handling in CompletableFuture] 98 | 99 | link:src/test/java/none/cvg/futures/TestKata3CompletableFutureExecutions.java[TestKata3CompletableFutureExecutions.java]:: covers some common executions in CompletableFuture. 100 | 101 | link:src/test/java/none/cvg/futures/TestKata4CompletableFutureChaining.java[TestKata4CompletableFutureChaining.java]:: covers CompletableFuture chaining. 102 | 103 | link:src/test/java/none/cvg/futures/TestKata5CompletableFutureCombinations.java[TestKata5CompletableFutureCombinations.java]:: Tcovers a few common combinations in CompletableFuture. 104 | 105 | 106 | == Solutions 107 | 108 | .Solutions for each test 109 | |=== 110 | | Kata Test | Solution 111 | 112 | |link:src/test/java/none/cvg/futures/TestKata1SimpleCompletableFutureOperations.java[TestKata1SimpleCompletableFutureOperations.java] 113 | |link:src/solutions/java/none/cvg/futures/TestSolution1SimpleCompletableFutureOperations.java[TestSolution1SimpleCompletableFutureOperations.java] 114 | 115 | |link:src/test/java/none/cvg/futures/TestKata2HandleExceptionsInCompletableFuture.java[TestKata2HandleExceptionsInCompletableFuture.java] 116 | |link:src/solutions/java/none/cvg/futures/TestSolution2HandleExceptionsInCompletableFuture.java[TestSolution2HandleExceptionsInCompletableFuture.java]. 117 | 118 | |link:src/test/java/none/cvg/futures/TestKata3CompletableFutureExecutions.java[TestKata3CompletableFutureExecutions.java] 119 | |link:src/solutions/java/none/cvg/futures/TestSolution3CompletableFutureExecutions.java[TestSolution3CompletableFutureExecutions.java] 120 | 121 | |link:src/test/java/none/cvg/futures/TestKata4CompletableFutureChaining.java[TestKata4CompletableFutureChaining.java] 122 | |link:src/solutions/java/none/cvg/futures/TestSolution4CompletableFutureChaining.java[TestSolution4CompletableFutureChaining.java] 123 | 124 | |link:src/test/java/none/cvg/futures/TestKata5CompletableFutureCombinations.java[TestKata5CompletableFutureCombinations.java] 125 | |link:src/solutions/java/none/cvg/futures/TestSolution5CompletableFutureCombinations.java[TestSolution5CompletableFutureCombinations.java] 126 | 127 | |=== 128 | 129 | 130 | == Take Away 131 | 132 | The key take-away from this kata is a solid understanding of the Java CompletableFuture API. 133 | -------------------------------------------------------------------------------- /java-futures/src/test/java/none/cvg/futures/TestKata1SimpleCompletableFutureOperations.java: -------------------------------------------------------------------------------- 1 | package none.cvg.futures; 2 | 3 | import org.junit.jupiter.api.BeforeEach; 4 | import org.junit.jupiter.api.DisplayName; 5 | import org.junit.jupiter.api.MethodOrderer; 6 | import org.junit.jupiter.api.Order; 7 | import org.junit.jupiter.api.Tag; 8 | import org.junit.jupiter.api.Test; 9 | import org.junit.jupiter.api.TestMethodOrder; 10 | 11 | import java.util.concurrent.CompletableFuture; 12 | 13 | import static org.junit.jupiter.api.Assertions.assertEquals; 14 | import static org.junit.jupiter.api.Assertions.assertNotNull; 15 | import static org.junit.jupiter.api.Assertions.assertTrue; 16 | import static org.junit.jupiter.api.Assertions.fail; 17 | 18 | /* 19 | * This test covers the basic features of creating CompletableFuture instances and fetching 20 | * results. 21 | */ 22 | @DisplayName("Simple CompletableFuture operations to: ") 23 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 24 | public class TestKata1SimpleCompletableFutureOperations { 25 | 26 | private static final String REPLACE_THIS = ""; 27 | 28 | @BeforeEach 29 | public void setUp() { 30 | } 31 | 32 | @DisplayName("create a completed CompletableFuture") 33 | @Test 34 | @Tag("TODO") 35 | @Order(1) 36 | public void createCompletedCompletableFuture() { 37 | 38 | String successMessage = "This is a completed future"; 39 | 40 | // completedFuture() returns a new CompletableFuture that is already completed with the 41 | // given value. 42 | // TODO: 43 | // Create a completedFuture. Replace the null with a completedFuture. 44 | // HINT: 45 | // • Use the static CompletableFuture.completedFuture() method with 46 | // the successMessage. 47 | CompletableFuture completedFuture = 48 | null; 49 | 50 | assertNotNull(completedFuture, 51 | "The completedFuture should be null"); 52 | 53 | assertTrue(completedFuture instanceof CompletableFuture, 54 | "The completedFuture should be an instance of CompletableFuture"); 55 | } 56 | 57 | @DisplayName("create a failed CompletableFuture") 58 | @Test 59 | @Tag("TODO") 60 | @Order(2) 61 | public void failedCompletableFuture() { 62 | 63 | String exceptionMessage = "This CompletableFuture has failed"; 64 | 65 | // failedFuture() returns a new CompletableFuture that is already completed 66 | // exceptionally with the given exception. 67 | // TODO: 68 | // Create a failedFuture. Replace the null with a failedFuture. 69 | // HINT: 70 | // • Use the static CompletableFuture.failedFuture() method with 71 | // a new RuntimeException(exceptionMessage). 72 | CompletableFuture failedFuture = 73 | null; 74 | 75 | assertNotNull(failedFuture, 76 | "The completedFuture should be null"); 77 | 78 | assertTrue(failedFuture instanceof CompletableFuture, 79 | "The completedFuture should be an instance of CompletableFuture"); 80 | } 81 | 82 | @DisplayName("check if a future is completed") 83 | @Test 84 | @Tag("TODO") 85 | @Order(3) 86 | public void checkCompletableFuture() { 87 | 88 | String successMessage = "This is a completed future"; 89 | 90 | CompletableFuture completedFuture = CompletableFuture 91 | .completedFuture(successMessage); 92 | 93 | // TODO: 94 | // Check if the completedFuture is done. Replace the 'false' with a check. 95 | // HINT: 96 | // • Use the instance method isDone() on CompletableFuture. 97 | assertTrue(false, 98 | "The completedFuture should be done"); 99 | } 100 | 101 | @DisplayName("get the value of a CompletableFuture using get()") 102 | @Test 103 | @Tag("TODO") 104 | @Order(4) 105 | public void valueOfCompletableFutureUsingGet() { 106 | 107 | String successMessage = "This is a completed future"; 108 | 109 | CompletableFuture completedFuture = CompletableFuture 110 | .completedFuture(successMessage); 111 | 112 | try { 113 | // TODO: 114 | // Get the value of the completedFuture. Replace the REPLACE_THIS_STRING with a 115 | // valid call. 116 | // HINT: 117 | // • Use the instance method get() on CompletableFuture. 118 | // • The get() method throws checked exceptions, which need to be caught and handled. 119 | assertEquals(successMessage, 120 | REPLACE_THIS, 121 | "The completedFuture value should return the content of successMessage"); 122 | // TODO: 123 | // Replace the catch-block with right Exceptions thrown by the get(). 124 | } catch (Exception e) { 125 | fail("Failed to get the value of the CompletedFuture"); 126 | } 127 | } 128 | 129 | @DisplayName("get the value of a CompletableFuture using join()") 130 | @Test 131 | @Tag("TODO") 132 | @Order(5) 133 | public void valueOfCompletableFutureUsingJoin() { 134 | 135 | String successMessage = "This is a completed future"; 136 | 137 | CompletableFuture completedFuture = CompletableFuture 138 | .completedFuture(successMessage); 139 | 140 | // TODO: 141 | // Get the value of the completedFuture. Replace the REPLACE_THIS_STRING with a 142 | // valid call. 143 | // HINT: 144 | // • Use the instance method join() on CompletableFuture. 145 | // • The join() method throws unchecked exceptions, which need not be caught. 146 | // The join method throws the following RuntimeExceptions: 147 | // • java.util.concurrent.CancellationException 148 | // • java.util.concurrent.CompletionException 149 | assertEquals(successMessage, 150 | REPLACE_THIS, 151 | "The completedFuture value should return the content of successMessage"); 152 | } 153 | } -------------------------------------------------------------------------------- /java-optional/src/solutions/java/none/cvg/optional/TestSolution1OptionalCreationAndFetchingValues.java: -------------------------------------------------------------------------------- 1 | package none.cvg.optional; 2 | 3 | import java.util.NoSuchElementException; 4 | import java.util.Optional; 5 | 6 | import org.junit.jupiter.api.BeforeEach; 7 | import org.junit.jupiter.api.DisplayName; 8 | import org.junit.jupiter.api.DisplayNameGeneration; 9 | import org.junit.jupiter.api.MethodOrderer; 10 | import org.junit.jupiter.api.Order; 11 | import org.junit.jupiter.api.Tag; 12 | import org.junit.jupiter.api.Test; 13 | import org.junit.jupiter.api.TestMethodOrder; 14 | 15 | import static org.junit.jupiter.api.Assertions.assertEquals; 16 | import static org.junit.jupiter.api.Assertions.assertFalse; 17 | import static org.junit.jupiter.api.Assertions.assertNotEquals; 18 | import static org.junit.jupiter.api.Assertions.assertThrows; 19 | import static org.junit.jupiter.api.Assertions.assertTrue; 20 | 21 | /* 22 | * DONE: 23 | * This test aims at understanding the basic features of Optional 24 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 25 | * the exercise. 26 | * 27 | * empty(), of(?), ofNullable(?), isPresent(), get() 28 | */ 29 | @DisplayName("java.util.Optional Creation And Getting value") 30 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 31 | public class TestSolution1OptionalCreationAndFetchingValues { 32 | 33 | @BeforeEach 34 | public void setUp() { 35 | } 36 | 37 | @Test 38 | @DisplayName("create an empty Optional") 39 | @Tag("PASSING") 40 | @Order(1) 41 | public void emptyOptional() { 42 | 43 | /* 44 | * DONE: 45 | * Replace the "null" to create an empty Optional. 46 | * Check API: java.util.Optional.empty() 47 | */ 48 | Optional optionalEmptyString = Optional.empty(); 49 | 50 | assertTrue(optionalEmptyString instanceof Optional, 51 | "The optionalEmptyString should be an instance of Optional"); 52 | 53 | assertTrue(optionalEmptyString.isEmpty(), 54 | "The optionalEmptyString should be empty"); 55 | } 56 | 57 | @Test 58 | @DisplayName("create an Optional from a variable") 59 | @Tag("PASSING") 60 | @Order(2) 61 | public void createOptionalFromValue() { 62 | 63 | Integer anInteger = 10; 64 | 65 | /* 66 | * DONE: 67 | * Replace the "null" to create an Optional for anInteger. 68 | * Check API: java.util.Optional.of(?) 69 | */ 70 | Optional optionalForInteger = Optional.of(anInteger); 71 | 72 | assertTrue(optionalForInteger instanceof Optional, 73 | "The optionalEmptyString should be an instance of Optional"); 74 | 75 | assertFalse(optionalForInteger.isEmpty(), 76 | "The optionalForInteger should not be empty"); 77 | } 78 | 79 | @Test 80 | @DisplayName("create a nullable Optional from a variable") 81 | @Tag("PASSING") 82 | @Order(3) 83 | public void createNullableOptionalFromValue() { 84 | 85 | Integer anInteger = null; 86 | 87 | /* 88 | * DONE: 89 | * Replace the "null" to create a nullable Optional for anInteger. 90 | * Check API: java.util.Optional.ofNullable(?) 91 | */ 92 | Optional optionalNullableInteger = Optional.ofNullable(anInteger); 93 | 94 | assertTrue(optionalNullableInteger instanceof Optional, 95 | "The optionalNullableInteger should be an instance of Optional"); 96 | 97 | assertTrue(optionalNullableInteger.isEmpty(), 98 | "The optionalNullableInteger should be empty"); 99 | } 100 | 101 | @Test 102 | @DisplayName("check a non-null Optional has a value") 103 | @Tag("PASSING") 104 | @Order(4) 105 | public void checkOptionalForNonNullValueIsPresent() { 106 | 107 | Integer anInteger = 10; 108 | 109 | Optional optionalInteger = Optional.ofNullable(anInteger); 110 | 111 | /* 112 | * DONE: 113 | * Replace the "false" to check that the Optional has a non-null value. 114 | * Check API: java.util.Optional.isPresent() 115 | */ 116 | assertTrue(optionalInteger.isPresent(), 117 | "The optionalNullableInteger should be present"); 118 | 119 | 120 | anInteger = null; 121 | 122 | optionalInteger = Optional.ofNullable(anInteger); 123 | 124 | /* 125 | * DONE: 126 | * Replace the "false" to check that the Optional has a non-null value. 127 | * Check API: java.util.Optional.isPresent() 128 | */ 129 | assertFalse(optionalInteger.isPresent(), 130 | "The optionalNullableInteger should not be present"); 131 | 132 | } 133 | 134 | @Test 135 | @DisplayName("fetch from a non-null and from a null holding Optional") 136 | @Tag("PASSING") 137 | @Order(5) 138 | public void getValueFromOptionalForNonNullValue() { 139 | 140 | Integer anInteger = 10; 141 | 142 | Optional optionalInteger = Optional.ofNullable(anInteger); 143 | 144 | /* 145 | * DONE: 146 | * Replace the "null" to check that the Optional has a non-null value. 147 | * Check API: java.util.Optional.get() 148 | */ 149 | assertEquals(10, 150 | optionalInteger.get(), 151 | "The optionalNullableInteger should be present"); 152 | 153 | 154 | anInteger = null; 155 | 156 | Optional anotherOptionalInteger = Optional.ofNullable(anInteger); 157 | 158 | /* 159 | * DONE: 160 | * Replace the "null" to get the Optional has a null value. 161 | * Verify that the call throws a NoSuchElementException 162 | * Check API: java.util.Optional.get() 163 | */ 164 | assertThrows(NoSuchElementException.class, () -> { 165 | 166 | assertNotEquals(10, 167 | anotherOptionalInteger.get(), 168 | "This call should throw a NoSuchElementException"); 169 | }); 170 | 171 | } 172 | 173 | } 174 | -------------------------------------------------------------------------------- /java-lambdas/src/solutions/java/none/cvg/lambdas/TestSolution1LambdaBasics.java: -------------------------------------------------------------------------------- 1 | package none.cvg.lambdas; 2 | 3 | import org.junit.jupiter.api.DisplayName; 4 | import org.junit.jupiter.api.DisplayNameGeneration; 5 | import org.junit.jupiter.api.MethodOrderer; 6 | import org.junit.jupiter.api.Order; 7 | import org.junit.jupiter.api.Tag; 8 | import org.junit.jupiter.api.Test; 9 | import org.junit.jupiter.api.TestMethodOrder; 10 | 11 | import java.util.concurrent.atomic.AtomicInteger; 12 | import java.util.function.Function; 13 | 14 | import static org.junit.jupiter.api.Assertions.assertEquals; 15 | 16 | /** 17 | * The tests in this class aim to show how functions can be invoked as lambdas 18 | * and method references 19 | * 20 | * @see Function 21 | */ 22 | @DisplayNameGeneration(LambdasKataDisplayNames.class) 23 | @DisplayName("Lambdas and Method Reference Basics") 24 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 25 | public class TestSolution1LambdaBasics { 26 | 27 | /** 28 | * @see IntegerPairFactory 29 | * @see IntegerPair 30 | */ 31 | @Test 32 | @Tag("PASSING") 33 | @Order(1) 34 | public void newObjectUsingLambdas() { 35 | IntegerPair classic = new IntegerPair(); 36 | 37 | // DONE: 38 | // Replace the anonymous class with a lambda. 39 | // Hint: () -> new object() 40 | IntegerPairFactory integerPairFactory = () -> new IntegerPair(); 41 | 42 | assertEquals(classic, integerPairFactory.get(), 43 | "Both objects should be equal"); 44 | } 45 | 46 | /** 47 | * @see IntegerPairFactory 48 | * @see IntegerPair 49 | */ 50 | @Test 51 | @Tag("PASSING") 52 | @Order(2) 53 | public void newObjectUsingMethodReferences() { 54 | IntegerPair classic = new IntegerPair(); 55 | 56 | // TODO: 57 | // Replace the anonymous class with a method reference. 58 | // Hint: () -> Object::new 59 | IntegerPairFactory integerPairFactory = IntegerPair::new; 60 | 61 | assertEquals(classic, integerPairFactory.get(), 62 | "Both objects should be equal"); 63 | } 64 | 65 | /** 66 | * @see IntegerPair 67 | * @see Function 68 | */ 69 | @Test 70 | @Tag("PASSING") 71 | @Order(3) 72 | public void methodCallAsLambda() { 73 | IntegerPair integerPair = new IntegerPair(); 74 | 75 | // DONE: 76 | // Replace the below anonymous class with a lambda call 77 | // Most IDEs allow for an automatic conversion 78 | // Hint: object -> object.method() 79 | Function getSecond = integerPair1 -> integerPair1.getSecond(); 80 | 81 | // DONE: 82 | // Fix the assertion to return the correct expectation (6) 83 | // Check API: java.util.function.Function.apply(?) 84 | assertEquals(6, getSecond.apply(integerPair), 85 | "The key should have a value of \'defaultKey\'"); 86 | } 87 | 88 | /** 89 | * @see IntegerPair 90 | * @see Function 91 | */ 92 | @Test 93 | @Tag("PASSING") 94 | @Order(4) 95 | public void methodCallAsMethodReference() { 96 | IntegerPair integerPair = new IntegerPair(); 97 | 98 | // DONE: 99 | // Replace the below anonymous class with a method reference 100 | // Most IDEs allow for an automatic conversion (no parenthesis for method) 101 | // Hint: object -> Object::method 102 | Function getSecond = IntegerPair::getSecond; 103 | 104 | // DONE: 105 | // Fix the assertion to return the correct expectation (6) 106 | // Check API: java.util.function.Function.apply(?) 107 | assertEquals(6, getSecond.apply(integerPair), 108 | "The key should have a value of \'defaultKey\'"); 109 | } 110 | 111 | @Test 112 | @Tag("PASSING") 113 | @Order(5) 114 | public void convertAnonymousClassToLambda() { 115 | 116 | final AtomicInteger counter = new AtomicInteger(); 117 | 118 | // DONE: 119 | // Replace the anonymous class with a lambda. Hint: () -> 120 | // The addAndGet() needs to be updated to add 1 instead of 0. 121 | Runnable runnable = () -> counter.addAndGet(1); 122 | 123 | runnable.run(); 124 | 125 | assertEquals(1, counter.get() ); 126 | } 127 | 128 | @Test 129 | @Tag("PASSING") 130 | @Order(6) 131 | public void customFunctionWithLambda() { 132 | 133 | int integer = 10; 134 | 135 | String s = Integer.toBinaryString(integer); 136 | 137 | // DONE: 138 | // Create a Function that maps any integer into a String using a lambda syntax 139 | // Do not create a new method. Replace the empty String below to invoke a toBinaryString 140 | // Check API: java.util.function.Function 141 | // Check API: java.util.function.Function.apply(?) 142 | Function toBinaryStringFunction = i -> Integer.toBinaryString(i); 143 | 144 | assertEquals("1010", 145 | toBinaryStringFunction.apply(10), 146 | ""); 147 | 148 | assertEquals("11110", 149 | toBinaryStringFunction.apply(30), 150 | ""); 151 | 152 | } 153 | 154 | @Test 155 | @Tag("PASSING") 156 | @Order(7) 157 | public void customFunctionWithMethodReference() { 158 | 159 | // DONE: 160 | // Create a Function that maps any integer into a String using a method reference 161 | // Do not create a new method. Replace the lambda below to invoke a toBinaryString 162 | // as a method reference 163 | // Check API: java.util.function.Function 164 | // Check API: java.util.function.Function.apply(?) 165 | // Check API: java.lang.Integer.toBinaryString(?) 166 | Function toBinaryStringFunction = Integer::toBinaryString; 167 | 168 | assertEquals("1010", 169 | toBinaryStringFunction.apply(10), 170 | ""); 171 | 172 | assertEquals("11110", 173 | toBinaryStringFunction.apply(30), 174 | ""); 175 | 176 | } 177 | } 178 | -------------------------------------------------------------------------------- /java-handles/src/test/java/none/cvg/methods/TestKataPrivateMethodInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.methods; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.reflect.InvocationTargetException; 6 | import java.lang.reflect.Method; 7 | 8 | import none.cvg.handles.DemoClass; 9 | import none.cvg.handles.HandlesKataDisplayNames; 10 | import org.junit.jupiter.api.DisplayName; 11 | import org.junit.jupiter.api.DisplayNameGeneration; 12 | import org.junit.jupiter.api.MethodOrderer; 13 | import org.junit.jupiter.api.Order; 14 | import org.junit.jupiter.api.Tag; 15 | import org.junit.jupiter.api.Test; 16 | import org.junit.jupiter.api.TestMethodOrder; 17 | 18 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 19 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 20 | import static org.junit.jupiter.api.Assertions.assertEquals; 21 | import static org.junit.jupiter.api.Assertions.fail; 22 | 23 | /* 24 | * TODO: 25 | * This test aims at using MethodHandles to invoke a private method on a class. 26 | * Each solved test shows how this can be achieved with the traditional reflection calls. 27 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 28 | * the exercise to achieve the same goal with MethodHandles. 29 | */ 30 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 31 | @DisplayName("Invoke DemoClass.privateMethod(String)") 32 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 33 | public class TestKataPrivateMethodInvocation { 34 | 35 | @Test 36 | @Tag("PASSING") 37 | @Order(1) 38 | public void reflectionPrivateMethod() { 39 | 40 | String expectedOutput = "[DemoClass] - Private method via reflection"; 41 | 42 | try { 43 | 44 | // Cannot call getMethod(), use getDeclaredMethod() to get private and protected methods 45 | Method privateMethod = 46 | DemoClass.class.getDeclaredMethod("privateMethod", 47 | String.class); 48 | 49 | /* 50 | * Method has to be made accessible. 51 | * Not setting this will cause IllegalAccessException 52 | * Setting accessible to true causes the JVM to skip access control checks 53 | * 54 | * This is needed to access non-public content 55 | */ 56 | privateMethod.setAccessible(true); 57 | 58 | DemoClass demoClass = new DemoClass(); 59 | 60 | assertEquals(expectedOutput, 61 | privateMethod.invoke(demoClass, "via reflection"), 62 | "Reflection invocation failed"); 63 | 64 | } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 65 | 66 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 67 | } 68 | } 69 | 70 | @Test 71 | @Tag("TODO") 72 | @Order(2) 73 | public void methodHandlePrivateMethod() { 74 | 75 | String expectedOutput = "[DemoClass] - Private method via Method Handles"; 76 | 77 | /* 78 | * TODO: 79 | * Get a non-public lookup from java.lang.invoke.MethodHandles 80 | * Non-public methods are looked up via "lookup" 81 | * Find the differences between lookup() and publicLookup() on MethodHandles. 82 | * Check API: java.lang.invoke.MethodHandles.lookup() 83 | */ 84 | MethodHandles.Lookup privateMethodHandlesLookup = null; 85 | 86 | try { 87 | 88 | /* 89 | * TODO: 90 | * Replace the "null"s with valid values to produce a privateMethod instance. 91 | * Create a method instance that matches the name "privateMethod()" 92 | * See java.lang.class for a getDeclaredMethod() 93 | * Look for the declared method on the DemoClass.class 94 | * The privateMethod() needs a String input parameter. 95 | * Same call as is used in vanilla reflection. 96 | * Check API: java.lang.Class.getDeclaredMethod(?, ?) 97 | */ 98 | Method privateMethod = 99 | DemoClass.class.getDeclaredMethod(null, 100 | null); // Method name, Class ... = Parameter types 101 | 102 | /* 103 | * Method has to be made accessible. 104 | * Not setting this will cause IllegalAccessException 105 | * Setting accessible to true causes the JVM to skip access control checks 106 | * 107 | * This is needed to access non-public content 108 | */ 109 | privateMethod.setAccessible(true); 110 | 111 | /* 112 | * TODO: 113 | * Replace the "null" with a valid value to get an unreflected private method handle. 114 | * Unreflect to create a method handle from a method instance 115 | * Generate a MethodHandle from the method instance created earlier. 116 | * See unreflect method in the innerclass Lookup of MethodHandles. 117 | * java.lang.invoke.MethodHandles.Lookup.unreflect() 118 | * We can unreflect the method since we bypassed the access control checks above. 119 | * Check API: java.lang.invoke.MethodHandles.Lookup.unreflect(?) 120 | */ 121 | MethodHandle privateMethodHandle = 122 | privateMethodHandlesLookup.unreflect(null); 123 | 124 | DemoClass demoClass = new DemoClass(); 125 | 126 | assertEquals(expectedOutput, 127 | privateMethodHandle.invoke(demoClass, 128 | "via Method Handles"), 129 | "Method handles invocation failed"); 130 | 131 | } catch (NoSuchMethodException | IllegalAccessException e) { 132 | 133 | fail("Failed to execute a private method invocation via Method Handles: " 134 | + e.getMessage()); 135 | } catch (Throwable t) { 136 | 137 | // invoke throws a Throwable (hence catching Throwable separately). 138 | fail(TEST_FAILURE.getValue() + t.getMessage()); 139 | } 140 | } 141 | } -------------------------------------------------------------------------------- /java-handles/src/test/java/none/cvg/methods/TestKataProtectedMethodInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.methods; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.reflect.InvocationTargetException; 6 | import java.lang.reflect.Method; 7 | 8 | import none.cvg.handles.DemoClass; 9 | import none.cvg.handles.HandlesKataDisplayNames; 10 | import org.junit.jupiter.api.DisplayName; 11 | import org.junit.jupiter.api.DisplayNameGeneration; 12 | import org.junit.jupiter.api.MethodOrderer; 13 | import org.junit.jupiter.api.Order; 14 | import org.junit.jupiter.api.Tag; 15 | import org.junit.jupiter.api.Test; 16 | import org.junit.jupiter.api.TestMethodOrder; 17 | 18 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 19 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 20 | import static org.junit.jupiter.api.Assertions.assertEquals; 21 | import static org.junit.jupiter.api.Assertions.fail; 22 | 23 | /* 24 | * TODO: 25 | * This test aims at using MethodHandles to invoke a protected method on a class. 26 | * Each solved test shows how this can be achieved with the traditional reflection calls. 27 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 28 | * the exercise to achieve the same goal with MethodHandles. 29 | */ 30 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 31 | @DisplayName("Invoke DemoClass.protectedMethod(String)") 32 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 33 | public class TestKataProtectedMethodInvocation { 34 | 35 | @Test 36 | @Tag("PASSING") 37 | @Order(1) 38 | public void reflectionProtectedMethod() { 39 | 40 | String expectedOutput = "[DemoClass] - Protected method via reflection"; 41 | 42 | try { 43 | 44 | // Cannot call getMethod(), use getDeclaredMethod() to get private and protected methods 45 | Method protectedMethod = 46 | DemoClass.class.getDeclaredMethod("protectedMethod", 47 | String.class); 48 | 49 | /* 50 | * Method has to be made accessible. 51 | * Not setting this will cause IllegalAccessException 52 | * Setting accessible to true causes the JVM to skip access control checks 53 | * 54 | * This is needed to access non-public content 55 | */ 56 | protectedMethod.setAccessible(true); 57 | 58 | DemoClass demoClass = new DemoClass(); 59 | 60 | assertEquals(expectedOutput, 61 | protectedMethod.invoke(demoClass, "via reflection"), 62 | "Reflection invocation failed"); 63 | 64 | } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 65 | 66 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 67 | } 68 | } 69 | 70 | @Test 71 | @Order(2) 72 | @Tag("TODO") 73 | public void methodHandleProtectedMethod() { 74 | 75 | String expectedOutput = "[DemoClass] - Protected method via Method Handles"; 76 | 77 | /* 78 | * TODO: 79 | * Get a non-public lookup from java.lang.invoke.MethodHandles 80 | * Non-public methods are looked up via "lookup" 81 | * Find the differences between lookup() and publicLookup() on MethodHandles. 82 | * Check API: java.lang.invoke.MethodHandles.lookup() 83 | */ 84 | MethodHandles.Lookup protectedMethodHandlesLookup = null; 85 | 86 | try { 87 | 88 | /* 89 | * TODO: 90 | * Replace the "null"s valid values to create a protectedMethod instance. 91 | * Create a method instance that matches the name "protectedMethod()" 92 | * See java.lang.class for a getDeclaredMethod() 93 | * Look for the declared method on the DemoClass.class 94 | * The protectedMethod() accepts a String input parameter. 95 | * Same call as is used in vanilla reflection. 96 | * Check API: java.lang.Class.getDeclaredMethod(?, ?) 97 | */ 98 | Method protectedMethod = 99 | DemoClass.class.getDeclaredMethod(null, 100 | null); // Method name, Class ... = Parameter types 101 | 102 | /* 103 | * Method has to be made accessible. 104 | * Not setting this will cause IllegalAccessException 105 | * Setting accessible to true causes the JVM to skip access control checks 106 | * 107 | * This is needed to access non-public content 108 | */ 109 | protectedMethod.setAccessible(true); 110 | 111 | /* 112 | * TODO: 113 | * Replace the null with the method instance to produce a protectedMethod handle. 114 | * Unreflect to create a method handle from a method instance 115 | * Generate a MethodHandle from the method instance created earlier. 116 | * See unreflect method in the innerclass Lookup of MethodHandles. 117 | * java.lang.invoke.MethodHandles.Lookup.unreflect() 118 | * We can unreflect the method since we bypassed the access control checks above. 119 | * Check API: java.lang.invoke.MethodHandles.Lookup.unreflect(?) 120 | */ 121 | MethodHandle protectedMethodHandle = 122 | protectedMethodHandlesLookup.unreflect(null); 123 | 124 | DemoClass demoClass = new DemoClass(); 125 | 126 | assertEquals(expectedOutput, 127 | protectedMethodHandle.invoke(demoClass, 128 | "via Method Handles"), 129 | "Method handles invocation failed"); 130 | 131 | } catch (NoSuchMethodException | IllegalAccessException e) { 132 | 133 | fail("Failed to execute a protected method invocation via Method Handles: " 134 | + e.getMessage()); 135 | } catch (Throwable t) { 136 | 137 | // invoke throws a Throwable (hence catching Throwable separately). 138 | fail(TEST_FAILURE.getValue() + t.getMessage()); 139 | } 140 | } 141 | } -------------------------------------------------------------------------------- /java-handles/src/solutions/java/none/cvg/methods/TestSolutionPrivateMethodInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.methods; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.reflect.InvocationTargetException; 6 | import java.lang.reflect.Method; 7 | 8 | import none.cvg.handles.DemoClass; 9 | import none.cvg.handles.HandlesKataDisplayNames; 10 | import org.junit.jupiter.api.DisplayName; 11 | import org.junit.jupiter.api.DisplayNameGeneration; 12 | import org.junit.jupiter.api.MethodOrderer; 13 | import org.junit.jupiter.api.Order; 14 | import org.junit.jupiter.api.Tag; 15 | import org.junit.jupiter.api.Test; 16 | import org.junit.jupiter.api.TestMethodOrder; 17 | 18 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 19 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 20 | import static org.junit.jupiter.api.Assertions.assertEquals; 21 | import static org.junit.jupiter.api.Assertions.fail; 22 | 23 | /* 24 | * DONE: 25 | * This test aims at using MethodHandles to invoke a private method on a class. 26 | * Each solved test shows how this can be achieved with the traditional reflection calls. 27 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 28 | * the exercise to achieve the same goal with MethodHandles. 29 | */ 30 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 31 | @DisplayName("Invoke DemoClass.privateMethod(String)") 32 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 33 | public class TestSolutionPrivateMethodInvocation { 34 | 35 | @Test 36 | @Tag("PASSING") 37 | @Order(1) 38 | public void reflectionPrivateMethod() { 39 | 40 | String expectedOutput = "[DemoClass] - Private method via reflection"; 41 | 42 | try { 43 | 44 | // Cannot call getMethod(), use getDeclaredMethod() to get private and protected methods 45 | Method privateMethod = 46 | DemoClass.class.getDeclaredMethod("privateMethod", 47 | String.class); 48 | 49 | /* 50 | * Method has to be made accessible. 51 | * Not setting this will cause IllegalAccessException 52 | * Setting accessible to true causes the JVM to skip access control checks 53 | * 54 | * This is needed to access non-public content 55 | */ 56 | privateMethod.setAccessible(true); 57 | 58 | DemoClass demoClass = new DemoClass(); 59 | 60 | assertEquals(expectedOutput, 61 | privateMethod.invoke(demoClass, "via reflection"), 62 | "Reflection invocation failed"); 63 | 64 | } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 65 | 66 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 67 | } 68 | } 69 | 70 | @Test 71 | @Tag("PASSING") 72 | @Order(2) 73 | public void methodHandlePrivateMethod() { 74 | 75 | String expectedOutput = "[DemoClass] - Private method via Method Handles"; 76 | 77 | /* 78 | * DONE: 79 | * Get a non-public lookup from java.lang.invoke.MethodHandles 80 | * Non-public methods are looked up via "lookup" 81 | * Find the differences between lookup() and publicLookup() on MethodHandles. 82 | * Check API: java.lang.invoke.MethodHandles.lookup() 83 | */ 84 | MethodHandles.Lookup privateMethodHandlesLookup = MethodHandles.lookup(); 85 | 86 | try { 87 | 88 | /* 89 | * DONE: 90 | * Replace the "null"s with valid values to produce a privateMethod instance. 91 | * Create a method instance that matches the name "privateMethod()" 92 | * See java.lang.class for a getDeclaredMethod() 93 | * Look for the declared method on the DemoClass.class 94 | * The privateMethod() needs a String input parameter. 95 | * Same call as is used in vanilla reflection. 96 | * Check API: java.lang.Class.getDeclaredMethod(?, ?) 97 | */ 98 | Method privateMethod = 99 | DemoClass.class.getDeclaredMethod("privateMethod", 100 | String.class); // Method name, Class ... = Parameter types 101 | 102 | /* 103 | * Method has to be made accessible. 104 | * Not setting this will cause IllegalAccessException 105 | * Setting accessible to true causes the JVM to skip access control checks 106 | * 107 | * This is needed to access non-public content 108 | */ 109 | privateMethod.setAccessible(true); 110 | 111 | /* 112 | * DONE: 113 | * Replace the "null" with a valid value to get an unreflected private method handle. 114 | * Unreflect to create a method handle from a method instance 115 | * Generate a MethodHandle from the method instance created earlier. 116 | * See unreflect method in the innerclass Lookup of MethodHandles. 117 | * java.lang.invoke.MethodHandles.Lookup.unreflect() 118 | * We can unreflect the method since we bypassed the access control checks above. 119 | * Check API: java.lang.invoke.MethodHandles.Lookup.unreflect(?) 120 | */ 121 | MethodHandle privateMethodHandle = 122 | privateMethodHandlesLookup.unreflect(privateMethod); 123 | 124 | DemoClass demoClass = new DemoClass(); 125 | 126 | assertEquals(expectedOutput, 127 | privateMethodHandle.invoke(demoClass, 128 | "via Method Handles"), 129 | "Method handles invocation failed"); 130 | 131 | } catch (NoSuchMethodException | IllegalAccessException e) { 132 | 133 | fail("Failed to execute a private method invocation via Method Handles: " 134 | + e.getMessage()); 135 | } catch (Throwable t) { 136 | 137 | // invoke throws a Throwable (hence catching Throwable separately). 138 | fail(TEST_FAILURE.getValue() + t.getMessage()); 139 | } 140 | } 141 | } -------------------------------------------------------------------------------- /java-handles/src/solutions/java/none/cvg/methods/TestSolutionProtectedMethodInvocation.java: -------------------------------------------------------------------------------- 1 | package none.cvg.methods; 2 | 3 | import java.lang.invoke.MethodHandle; 4 | import java.lang.invoke.MethodHandles; 5 | import java.lang.reflect.InvocationTargetException; 6 | import java.lang.reflect.Method; 7 | 8 | import none.cvg.handles.DemoClass; 9 | import none.cvg.handles.HandlesKataDisplayNames; 10 | import org.junit.jupiter.api.DisplayName; 11 | import org.junit.jupiter.api.DisplayNameGeneration; 12 | import org.junit.jupiter.api.MethodOrderer; 13 | import org.junit.jupiter.api.Order; 14 | import org.junit.jupiter.api.Tag; 15 | import org.junit.jupiter.api.Test; 16 | import org.junit.jupiter.api.TestMethodOrder; 17 | 18 | import static none.cvg.handles.ErrorMessages.REFLECTION_FAILURE; 19 | import static none.cvg.handles.ErrorMessages.TEST_FAILURE; 20 | import static org.junit.jupiter.api.Assertions.assertEquals; 21 | import static org.junit.jupiter.api.Assertions.fail; 22 | 23 | /* 24 | * DONE: 25 | * This test aims at using MethodHandles to invoke a protected method on a class. 26 | * Each solved test shows how this can be achieved with the traditional reflection calls. 27 | * Each unsolved test provides a few hints that will allow the kata-taker to manually solve 28 | * the exercise to achieve the same goal with MethodHandles. 29 | */ 30 | @DisplayNameGeneration(HandlesKataDisplayNames.class) 31 | @DisplayName("Invoke DemoClass.protectedMethod(String)") 32 | @TestMethodOrder(MethodOrderer.OrderAnnotation.class) 33 | public class TestSolutionProtectedMethodInvocation { 34 | 35 | @Test 36 | @Tag("PASSING") 37 | @Order(1) 38 | public void reflectionProtectedMethod() { 39 | 40 | String expectedOutput = "[DemoClass] - Protected method via reflection"; 41 | 42 | try { 43 | 44 | // Cannot call getMethod(), use getDeclaredMethod() to get private and protected methods 45 | Method protectedMethod = 46 | DemoClass.class.getDeclaredMethod("protectedMethod", 47 | String.class); 48 | 49 | /* 50 | * Method has to be made accessible. 51 | * Not setting this will cause IllegalAccessException 52 | * Setting accessible to true causes the JVM to skip access control checks 53 | * 54 | * This is needed to access non-public content 55 | */ 56 | protectedMethod.setAccessible(true); 57 | 58 | DemoClass demoClass = new DemoClass(); 59 | 60 | assertEquals(expectedOutput, 61 | protectedMethod.invoke(demoClass, "via reflection"), 62 | "Reflection invocation failed"); 63 | 64 | } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) { 65 | 66 | fail(REFLECTION_FAILURE.getValue() + e.getMessage()); 67 | } 68 | } 69 | 70 | @Test 71 | @Order(2) 72 | @Tag("PASSING") 73 | public void methodHandleProtectedMethod() { 74 | 75 | String expectedOutput = "[DemoClass] - Protected method via Method Handles"; 76 | 77 | /* 78 | * DONE: 79 | * Get a non-public lookup from java.lang.invoke.MethodHandles 80 | * Non-public methods are looked up via "lookup" 81 | * Find the differences between lookup() and publicLookup() on MethodHandles. 82 | * Check API: java.lang.invoke.MethodHandles.lookup() 83 | */ 84 | MethodHandles.Lookup protectedMethodHandlesLookup = MethodHandles.lookup(); 85 | 86 | try { 87 | 88 | /* 89 | * DONE: 90 | * Replace the "null"s valid values to create a protectedMethod instance. 91 | * Create a method instance that matches the name "protectedMethod()" 92 | * See java.lang.class for a getDeclaredMethod() 93 | * Look for the declared method on the DemoClass.class 94 | * The protectedMethod() accepts a String input parameter. 95 | * Same call as is used in vanilla reflection. 96 | * Check API: java.lang.Class.getDeclaredMethod(?, ?) 97 | */ 98 | Method protectedMethod = 99 | DemoClass.class.getDeclaredMethod("protectedMethod", 100 | String.class); // Method name, Class ... = Parameter types 101 | 102 | /* 103 | * Method has to be made accessible. 104 | * Not setting this will cause IllegalAccessException 105 | * Setting accessible to true causes the JVM to skip access control checks 106 | * 107 | * This is needed to access non-public content 108 | */ 109 | protectedMethod.setAccessible(true); 110 | 111 | /* 112 | * DONE: 113 | * Replace the null with the method instance to produce a protectedMethod handle. 114 | * Unreflect to create a method handle from a method instance 115 | * Generate a MethodHandle from the method instance created earlier. 116 | * See unreflect method in the innerclass Lookup of MethodHandles. 117 | * java.lang.invoke.MethodHandles.Lookup.unreflect() 118 | * We can unreflect the method since we bypassed the access control checks above. 119 | * Check API: java.lang.invoke.MethodHandles.Lookup.unreflect(?) 120 | */ 121 | MethodHandle protectedMethodHandle = 122 | protectedMethodHandlesLookup.unreflect(protectedMethod); 123 | 124 | DemoClass demoClass = new DemoClass(); 125 | 126 | assertEquals(expectedOutput, 127 | protectedMethodHandle.invoke(demoClass, 128 | "via Method Handles"), 129 | "Method handles invocation failed"); 130 | 131 | } catch (NoSuchMethodException | IllegalAccessException e) { 132 | 133 | fail("Failed to execute a protected method invocation via Method Handles: " 134 | + e.getMessage()); 135 | } catch (Throwable t) { 136 | 137 | // invoke throws a Throwable (hence catching Throwable separately). 138 | fail(TEST_FAILURE.getValue() + t.getMessage()); 139 | } 140 | } 141 | } --------------------------------------------------------------------------------
2 |
3 |
4 | [<< Prev](page03.md)
5 |
6 |
7 |
8 |
9 |
10 | [Next >>](page05.md)
11 |
12 |
--------------------------------------------------------------------------------
/java-handles/docs/page00.md:
--------------------------------------------------------------------------------
1 | # Alternates to
2 | # Java Reflection
3 | # and
4 | # Unsafe usage
5 |
6 | ## Chandra Guntur
7 |
8 |
9 |
10 |
11 |
12 | ##### Twitter: @CGuntur
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 | [Next >>](page01.md)
--------------------------------------------------------------------------------
/java-handles/docs/page02.md:
--------------------------------------------------------------------------------
1 | # Agenda
2 |
3 | ## EXPLANATION and CODE SAMPLES FOR:
4 |
5 | ### Java Reflection
6 | * Usage until now
7 | * New alternates - A Code Kata
8 |
9 | ### `sun.misc.Unsafe`
10 | * Usage until now
11 | * New alternates - A Code Kata
12 |
13 | [<< Prev](page01.md)
14 |
15 |
16 |
17 |
18 |
19 | [Next >>](page03.md)
20 |
21 |
--------------------------------------------------------------------------------
/java-handles/docs/page14.md:
--------------------------------------------------------------------------------
1 | # Usage of Unsafe
2 |
3 | `sun.misc.Unsafe` has quite a few usages:
4 |
5 | * Low level memory information
6 | * Object & field manipulation
7 | * Classes and static field manipulation
8 | * Array manipulations
9 | * Low-level primitive for synchronization
10 | * Direct memory access
11 | * Avoiding initialization/constructor calls
12 | * Faster serialization/deserialization
13 |
14 | [<< Prev](page13.md)
15 |
16 |
17 |
18 |
19 |
20 | [Next >>](page15.md)
--------------------------------------------------------------------------------
/java-handles/docs/page08.md:
--------------------------------------------------------------------------------
1 | * JSR-292 led to lightweight references to methods
2 | * The references are called Method Handles
3 | * A call via a handle is as fast as a statically linked Java call
4 | * A bit more verbose than reflection code
5 | * APIs to investigate :
6 | * **`java.lang.invoke.MethodHandles.Lookup`**
7 | * **`java.lang.invoke.MethodHandle`**
8 | * **`java.lang.invoke.MethodType`**
9 |
10 |
11 | [<< Prev](page07.md)
12 |
13 |
14 |
15 |
16 |
17 | [Next >>](page09.md)
18 |
19 |
--------------------------------------------------------------------------------
/java-handles/docs/page19.md:
--------------------------------------------------------------------------------
1 | # Unsafe -to - VarHandle Recap
2 |
3 | * Get a MethodHandles.Lookup via :
4 | * **`lookup().in(`** requestedLookupClass **`)`**
5 | * **`privateLookupIn(`** targetClass, lookup **`)`**
6 | * Find a VarHandle :
7 | * For fields :
8 | * **`findVarHandle(`** receiverClass, attributeName, attributeType **`)`**
9 | * For array elements :
10 | * **`arrayElementVarHandle(`** arrayClass **`)`**
11 |
12 |
13 | [<< Prev](page18.md)
14 |
15 |
16 |
17 |
18 |
19 | [Next >>](page20.md)
--------------------------------------------------------------------------------
/java-handles/docs/page13.md:
--------------------------------------------------------------------------------
1 | # Reflection - To - MethodHandles Recap
2 |
3 | * MethodHandles.Lookup the methods on the class.
4 | * Acquire a MethodHandle to invoke:
5 | * by **Method type** approach ::
6 | * Describe the method to create a MethodType
7 | * `find*()` method to extract a MethodHandle
8 | * by **Method signature** approach ::
9 | * Get a Method instance by name and arity
10 | * `unreflect()` the Method instance to extract a MethodHandle.
11 |
12 | [<< Prev](page12.md)
13 |
14 |
15 |
16 |
17 |
18 | [Next >>](page14.md)
--------------------------------------------------------------------------------
/java-handles/docs/page16.md:
--------------------------------------------------------------------------------
1 | # Unsafe Replacement: VarHandle (Java 9)
2 |
3 | * JSR-292 led to lightweight references to attributes
4 | * The references are called VarHandles
5 | * Standard replacements for features in :
6 | * **`java.util.concurrent.atomic.*`**
7 | * **`sun.misc.Unsafe`**
8 | * The VarHandle API provides :
9 | * **Field and array index element access**
10 | * **Memory fences** for fine-grained control of memory ordering
11 | * A strong **reachability-fence** operation for an object
12 |
13 | [<< Prev](page15.md)
14 |
15 |
16 |
17 |
18 |
19 | [Next >>](page17.md)
--------------------------------------------------------------------------------
/java-handles/docs/page06.md:
--------------------------------------------------------------------------------
1 | ## Reflection introduced in Java 1.1 circa 1997
2 | * Used to examine/alter behavior and structure
3 | * Bypasses accessibility and instantiation rules
4 | * Reflection drawbacks * :
5 | * **performance overhead** - dynamic resolution, no optimization
6 | * **security restrictions** - runtime permission, SecurityManager override
7 | * **exposure of internals** - breaks abstractions and encapsulation
8 |
9 | * Read more at: https://docs.oracle.com/javase/tutorial/reflect/
10 |
11 | [<< Prev](page05.md)
12 |
13 |
14 |
15 |
16 |
17 | [Next >>](page07.md)
18 |
19 |
--------------------------------------------------------------------------------
/java-futures/assets/docs/Future.adoc:
--------------------------------------------------------------------------------
1 | = Future
2 | :toc:
3 |
4 | == What is a Future
5 |
6 | Introduced in Java 5 (2004).
7 |
8 | A link:https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/concurrent/Future.html[`java.util.concurrent.Future`] is a placeholder for a result of a computation task that hasn't finished yet.
9 |
10 | Once the task completes, the Future holds the result.
11 |
12 | == Operations on a Future
13 |
14 | The following operations can be performed on a Future:
15 |
16 | .Future operations
17 | [width="99%", options="header"]
18 | |===
19 | |Method name |Description
20 |
21 | |`*cancel*` |Attempts to cancel execution of this task.
22 | |`*get*`|Waits if necessary for the computation to complete, and then retrieves its result, with or without a timeout parameter.
23 | |`*isCancelled*`|Check if the Future has been canceled, prior to normal completion.
24 | |`*isDone*`|Check if the Future completed normally.
25 | |===
--------------------------------------------------------------------------------
/java-handles/docs/page10.md:
--------------------------------------------------------------------------------
1 | # MethodHandle - "The Executor"
2 |
3 | 
4 |
5 |
6 | * Direct executable reference to an underlying method
7 | * Not distinguished by name of method or class
8 | * Special invoker methods :
9 | * **`invoke()`**
10 | * **`invokeExact()`**
11 | * Immutable and stateless
12 |
13 |
14 | https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/invoke/MethodHandle.html
15 |
16 |
17 | [<< Prev](page09.md)
18 |
19 |
20 |
21 |
22 |
23 | [Next >>](page11.md)
24 |
--------------------------------------------------------------------------------
/java-handles/docs/page17.md:
--------------------------------------------------------------------------------
1 | # Unsafe Replacement: VarHandles - Purpose
2 |
3 | * **Safety** - JVM cannot be placed in a corrupt memory state :
4 | * Content data types must match or be ‘castable’ to field type
5 | * Array indexes must exist in order to be accessed/written to
6 | * **Integrity** - Field access rules cannot be violated :
7 | * Same rules as for **`getfield`** and **`putfield`** byte codes
8 | * A final field cannot be updated
9 | * **Performance** - Must be similar to **`Unsafe`** operations
10 | * **Usability** - Friendlier, consistent API compared to **`Unsafe`**
11 |
12 | [<< Prev](page16.md)
13 |
14 |
15 |
16 |
17 |
18 | [Next >>](page18.md)
--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
1 | name: CI
2 |
3 | on:
4 | push:
5 | pull_request:
6 | workflow_dispatch:
7 |
8 | jobs:
9 | ci:
10 | name: "JDK ${{ matrix.java }} on ${{ matrix.os }}"
11 | strategy:
12 | fail-fast: false
13 | matrix:
14 | os: [ ubuntu-latest ] # [ ubuntu-latest, macos-latest, windows-latest ]
15 | java: [ 16 ] # [ 17-ea, 16, 15 ]
16 | runs-on: ${{ matrix.os }}
17 | steps:
18 | - name: 'Check out repository'
19 | uses: actions/checkout@v2
20 | - name: 'Download JDK'
21 | id: download-jdk
22 | uses: sormuras/download-jdk@v1
23 | with:
24 | feature: ${{ matrix.java }}
25 | - name: 'Set up JDK, Project ${{ matrix.project }}'
26 | uses: actions/setup-java@v1
27 | with:
28 | java-version: ${{ steps.download-jdk.outputs.version }}
29 | jdkFile: "${{ steps.download-jdk.outputs.file }}"
30 | - name: 'Print Java version'
31 | run: java -version
32 | - name: 'Build with Maven'
33 | run: mvn --batch-mode --no-transfer-progress verify
34 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2019 Chandra Guntur
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/java-handles/docs/page11.md:
--------------------------------------------------------------------------------
1 | # MethodType - "The Discriminator"
2 |
3 | 
4 |
5 |
6 | * Represents return type and input parameters of a method :
7 | * First parameter of a method type is return type
8 | * Other parameters are input parameter types
9 | * Immutable
10 | * Primitives, arrays and void (return) values are types :
11 | * **`int.class`**
12 | * **`double.class`**
13 | * **`void.class`**
14 | * **`int[].class`**
15 | * **`...`**
16 |
17 | https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/invoke/MethodType.html
18 |
19 | [<< Prev](page10.md)
20 |
21 |
22 |
23 |
24 |
25 | [Next >>](page12.md)
26 |
--------------------------------------------------------------------------------
/java-handles/docs/page05.md:
--------------------------------------------------------------------------------
1 | # Future-Oriented changes in Java - Circa 2006
2 |
3 | * JSR-292 * - Multi-Language Virtual Machine proposed in 2006
4 | * Code-named **Da Vinci Machine Project**
5 | * Formulated to ease implementation of dynamic languages (JRuby **)
6 | * Core features introduced in Java 7:
7 | * *addition of an invokedynamic instruction at the JVM level*
8 | * gave us **lambdas** and **method references** in Java
9 | * **ability to change classes & methods at runtime, dynamically**
10 | * ***session focuses on this second core feature***
11 |
12 | * https://www.jcp.org/en/jsr/detail?id=292
13 |
14 | ** Read more at: https://groups.google.com/forum/#!topic/jvm-languages/28Oko4KGiQQ
15 |
16 | [<< Prev](page04.md)
17 |
18 |
19 |
20 |
21 |
22 | [Next >>](page06.md)
23 |
24 |
--------------------------------------------------------------------------------
/java-handles/docs/page01.md:
--------------------------------------------------------------------------------
1 |
2 | # CHANDRA GUNTUR - #Saganist
3 |
4 | 
5 |
6 | ## Active in Java Community
7 | * **JUG Leader**: Organizer, Presenter at NYJavaSIG and NYJavaSIG Hands-On Workshops
8 |
9 | * **Speaker**: Oracle Code One, Devnexus, QCon New York, Oracle Code New York and at several Java User Groups
10 |
11 | * **Advocacy**: Active on *blogging* and *tweeting* on all things Java
12 |
13 | ## Work Portfolio
14 |
15 | * Director, Resilient Systems Engineering
16 | * Java, Eclipse Collections, Spring Boot/Cloud & Microprofile Advocate & Evangelist
17 | * Typical-day tools: Java, Groovy, Spring Boot, Vert.x, Drools, Spock
18 |
19 | #### Twitter: @CGuntur
20 |
21 |
22 | [<< Prev](page00.md)
23 |
24 |
25 |
26 |
27 |
28 | [Next >>](page02.md)
29 |
30 |
--------------------------------------------------------------------------------
/CodeKataMission.adoc:
--------------------------------------------------------------------------------
1 | == What is a Code-Kata
2 |
3 | A code-kata is a coding exercise that builds muscle memory by a practice of programming to arrive
4 | at a known solution.
5 |
6 | === How does one go about with this code kata?
7 |
8 | The essence of the exercise (presentation material and code kata) is to demonstrate the
9 | usage patterns for the java API or functionality.
10 |
11 | This set of code katas rely on fixing broken tests. The tests may have multiple solutions, the
12 | intent is to learn and experiment.
13 |
14 | The project contains several JUnit tests that fail.
15 |
16 | ==== Simple steps to use this kata
17 |
18 | . Run the test class(es).
19 | . One or more tests will fail with the test failure message.
20 | . Fix the failing tests by using `HINT` and `TODO` comments.
21 | . Repeat above steps until all tests pass.
22 | . Check the solutions to see if there are other ways to solve.
23 | (Remember, the solution may be less performant/optimal than yours)
24 | . Rinse and repeat (delete and checkout again, then back to Step 1) to build muscle memory.
25 |
26 | === Mission
27 | > ***Your mission**, should you choose to accept it, will be to fix the JUnit tests. This
28 | message will self-destruct in* **NaN** *minutes*
29 |
30 |
--------------------------------------------------------------------------------
/java-handles/docs/page09.md:
--------------------------------------------------------------------------------
1 | # MethodHandles.Lookup - "The Searcher"
2 |
3 | 
4 |
5 | * Enclosed in a MethodHandles factory class
6 | * _MethodHandles is itself a sledgehammer of various Java operations_
7 | * _Iteration, While, Do While Loops_
8 | * _Try Finally, Throw Exception, Consume Exception_
9 | * ...
10 | * Performs access checks and security manager interactions
11 | * If allowed creates a method handle reference
12 | * Has several lookup methods such as :
13 | * **`findGetter`**
14 | * **`findStaticSetter`**
15 | * **`findVirtual`**
16 | * **`findConstructor`**
17 | * **`...`**
18 |
19 | https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/invoke/MethodHandles.Lookup.html
20 |
21 | [<< Prev](page08.md)
22 |
23 |
24 |
25 |
26 |
27 | [Next >>](page10.md)
28 |
29 |
--------------------------------------------------------------------------------
/java-handles/_layouts/default.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | {% seo %}
8 |
10 |
13 |
14 |
17 |
20 |
21 |
22 |
23 |
24 |
25 |