Add new tasks to CrazyLambdas.java

Author: tboychuk

crazy-lambdas/src/main/java/com/bobocode/CrazyLambdas.java

@@ -1,6 +1,7 @@
 package com.bobocode;
 
 import java.math.BigDecimal;
+import java.util.TreeMap;
 import java.util.function.*;
 
 public class CrazyLambdas {
@@ -102,6 +103,51 @@ public static Supplier<IntUnaryOperator> nMultiplyFunctionSupplier(int n) {
         throw new UnsupportedOperationException("It's your job to implement this method"); // todo
     }
 
+    /**
+     * Receives a {@link Runnable} parameter, and returns a {@link Supplier<Thread>}. The thread will be started only
+     * when you call supplier method {@link Supplier#get()}
+     *
+     * @param runnable the code you want to tun in new thread
+     * @return a thread supplier
+     */
+    public static Supplier<Thread> runningThreadSupplier(Runnable runnable) {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
+
+    /**
+     * Returns a {@link Consumer} that accepts {@link Runnable} as a parameter and runs in in a new thread.
+     *
+     * @return a runnable consumer
+     */
+    public static Consumer<Runnable> newThreadRunnableConsumer() {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
+
+
+    public static Function<Runnable, Supplier<Thread>> runnableToThreadSupplierFunction() {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
 
+    /**
+     * Returns a {@link BiFunction} that has two parameters. First is {@link IntUnaryOperator} which is some integer function.
+     * Second is {@link IntPredicate} which is some integer condition. And the third is {@link IntUnaryOperator} which is
+     * a new composed function that uses provided predicate (second parameter of binary function) to verify its input
+     * parameter. If predicate returns {@code true} it applies a provided integer function
+     * (first parameter of binary function) and returns a result value, otherwise it returns an element itself.
+     *
+     * @return a binary function that receiver predicate and function and compose them to create a new function
+     */
+    public static BiFunction<IntUnaryOperator, IntPredicate, IntUnaryOperator> functionToConditionalFunction() {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
+
+    /**
+     * Returns {@link Supplier} of {@link Supplier} of {@link Supplier} of {@link String} "WELL DONE".
+     *
+     * @return a supplier instance
+     */
+    public static Supplier<Supplier<Supplier<String>>> trickyWellDoneSupplier() {
+        throw new UnsupportedOperationException("It's your job to implement this method"); // todo
+    }
 }
 

crazy-lambdas/src/test/java/com/bobocode/CrazyLambdasTest.java

@@ -5,6 +5,10 @@
 import org.junit.runners.JUnit4;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.function.*;
 
 import static org.junit.Assert.*;
@@ -126,4 +130,69 @@ public void testNMultiplyFunctionSupplier() {
 
         assertEquals(55, result);
     }
+
+    @Test
+    public void testRunningThreadSupplier() throws InterruptedException {
+        Queue<Integer> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
+        Supplier<Thread> runningThreadSupplier = CrazyLambdas.runningThreadSupplier(() -> concurrentLinkedQueue.add(25));
+
+        // supplier does not create and start a thread before you call get()
+        assertEquals(0, concurrentLinkedQueue.size());
+
+        Thread runningThread = runningThreadSupplier.get(); // new thread has been started
+        runningThread.join();
+
+        assertEquals(1, concurrentLinkedQueue.size());
+        assertEquals(25, concurrentLinkedQueue.element().intValue());
+    }
+
+    @Test
+    public void testNewThreadRunnableConsumer() throws InterruptedException {
+        Consumer<Runnable> newThreadRunnableConsumer = CrazyLambdas.newThreadRunnableConsumer();
+
+        Queue<Integer> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
+        newThreadRunnableConsumer.accept(() -> concurrentLinkedQueue.add(50));
+
+        Thread.sleep(500); // don't do that in real code
+
+        assertEquals(1, concurrentLinkedQueue.size());
+        assertEquals(50, concurrentLinkedQueue.element().intValue());
+    }
+
+    @Test
+    public void testRunnableToThreadSupplierFunction() throws InterruptedException {
+        Function<Runnable, Supplier<Thread>> runnableSupplierFunction = CrazyLambdas.runnableToThreadSupplierFunction();
+        Queue<Integer> concurrentLinkedQueue = new ConcurrentLinkedQueue<>();
+
+        Supplier<Thread> threadSupplier = runnableSupplierFunction.apply(() -> concurrentLinkedQueue.add(200));
+
+        assertEquals(0, concurrentLinkedQueue.size()); // supplier does not create and start a thread before you call get()
+
+        Thread thread = threadSupplier.get();// new thread has been started
+        thread.join();
+
+        assertEquals(1, concurrentLinkedQueue.size());
+        assertEquals(200, concurrentLinkedQueue.element().intValue());
+    }
+
+    @Test
+    public void testFunctionToConditionalFunction() {
+        BiFunction<IntUnaryOperator, IntPredicate, IntUnaryOperator> intFunctionToConditionalIntFunction
+                = CrazyLambdas.functionToConditionalFunction();
+
+        IntUnaryOperator abs = intFunctionToConditionalIntFunction.apply(a -> -a, a -> a < 0);
+
+        assertEquals(5, abs.applyAsInt(-5));
+        assertEquals(0, abs.applyAsInt(0));
+        assertEquals(5, abs.applyAsInt(5));
+    }
+
+    @Test
+    public void testTrickyWellDoneSupplier() {
+        Supplier<Supplier<Supplier<String>>> wellDoneSupplier = CrazyLambdas.trickyWellDoneSupplier();
+
+        String wellDoneStr = wellDoneSupplier.get().get().get();
+
+        assertEquals("WELL DONE!", wellDoneStr);
+    }
 }