fix

Author: Semen Popugaev

src/main/java/part2/cache/CachingDataStorageImpl.java

@@ -38,23 +38,6 @@ public OutdatableResult<T> getOutdatable(String key) {
         // TODO don't use obtrudeException on result - just don't
         // TODO use remove(Object key, Object value) to remove target value
         // TODO Start timeout after receiving result in CompletableFuture, not after receiving CompletableFuture itself
-        if (!cache.containsKey(key)) {
-            final CompletableFuture<Void> outdated = new CompletableFuture<>();
-            final CompletableFuture<T> value = db.get(key);
-            final OutdatableResult<T> result = new OutdatableResult<>(value, outdated);
-            cache.put(key, result);
-            value.thenApply((x) ->
-            scheduledExecutorService.schedule(
-                    () -> {
-                        cache.remove(key, result);
-                        outdated.complete(null);
-                    },
-                    timeout,
-                    timeoutUnits));
-
-            return result;
-        }
-
-        return cache.get(key);
+        throw new UnsupportedOperationException();
     }
 }

src/test/java/part1/exercise/Methods.java

@@ -2,10 +2,11 @@
 
 import org.junit.Test;
 
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ForkJoinPool;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.TimeUnit;
+import java.util.Optional;
+import java.util.concurrent.*;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class Methods {
 
@@ -22,6 +23,14 @@ private Integer slowTask() {
 
     @Test
     public void create() {
+        final CompletableFuture<Integer> future = new CompletableFuture<>();
+        final CompletableFuture<Integer> completedFuture = CompletableFuture.completedFuture(1);
+
+        final CompletableFuture<Integer> supplied = CompletableFuture.supplyAsync(this::slowTask);
+        final CompletableFuture<Integer> supplied2 = CompletableFuture.supplyAsync(this::slowTask, customExecutor);
+
+        final CompletableFuture<Void> runAsync = CompletableFuture.runAsync(this::slowTask);
+        final CompletableFuture<Void> runAsync2 = CompletableFuture.runAsync(this::slowTask, customExecutor);
         // new
         // supplyAsync
         // runAsync
@@ -31,21 +40,64 @@ public void create() {
     @Test
     public void write() {
         // complete (completed)
+        final CompletableFuture<Integer> future = new CompletableFuture<>();
+        future.complete(1);
+
+        final CompletableFuture<Integer> future2 = new CompletableFuture<>();
+        //new Thread(() -> future2.complete(slowTask())).start();
+        ForkJoinPool.commonPool().submit(() -> {
+            try {
+                final Integer result = slowTask();
+                future2.complete(result);
+            } catch (Exception e) {
+                future2.completeExceptionally(e);
+            }
+        });
+
+        final CompletableFuture<Void> voidFuture = new CompletableFuture<>();
+        ForkJoinPool.commonPool().submit(() -> {
+            try {
+                slowTask();
+                voidFuture.complete(null);
+            } catch (Exception e) {
+                voidFuture.completeExceptionally(e);
+            }
+        });
+
         // completeExceptionally
     }
 
     @Test
-    public void rewrite() {
+    public void rewrite() throws ExecutionException, InterruptedException {
         // obtrudeValue
         // obtrudeException
+        final CompletableFuture<Integer> future = CompletableFuture.completedFuture(1);
+        assertEquals(Integer.valueOf(1), future.get());
+
+        future.obtrudeValue(2);
+        assertEquals(Integer.valueOf(2), future.get());
     }
 
     @Test
     public void read() {
+        final CompletableFuture<Integer> future = CompletableFuture.completedFuture(1);
+        final CompletableFuture<Integer> future2 = new CompletableFuture<>();
+        future2.completeExceptionally(new UnsupportedOperationException());
         // isDone
+        assertTrue(future.isDone());
+        assertTrue(future2.isDone());
         // get
+        try {
+            assertEquals(Integer.valueOf(1), future.get());
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+        }
         // join
+        assertEquals(Integer.valueOf(1), future.join());
         // getNow
+        future.getNow(0);
         // getNumberOfDependents
     }
 
@@ -56,9 +108,19 @@ public void foreachMapFlatMap() {
         final CompletableFuture<String> future2 = null;
 
         // forEach
+        final CompletableFuture<Void> thenAccept = future.thenAccept(System.out::println);
+        final CompletableFuture<Void> thenAcceptAsync = future.thenAcceptAsync(System.out::println);
+        final CompletableFuture<Void> thenAcceptAsync2 = future.thenAcceptAsync(System.out::println, customExecutor);
+        final CompletableFuture<Void> thenRun = future.thenRun(() -> System.out.println("Done"));
         // map
+        final CompletableFuture<String> thenApply = future.thenApply(Object::toString);
         // flatMap
+        final CompletableFuture<Integer> thenCompose = future.thenCompose(i -> CompletableFuture.completedFuture(i + 1));
+        final CompletableFuture<Integer> thenComposeAsync = future.thenComposeAsync(i -> CompletableFuture.completedFuture(i + 1));
         // *3
+        // *Async
+
+        final CompletableFuture<Integer> sum = future.thenCompose(i -> future1.thenApply(i1 -> i + i1));
     }
 
     @Test
@@ -68,12 +130,31 @@ public void allAnyOf() {
         final CompletableFuture<String> future2 = null;
 
         // All of
+        final CompletableFuture<Void> allOf = CompletableFuture.allOf(future, future1, future2);
+        allOf.thenRun(() -> {
+            final Integer i = future.join();
+            final String s = future2.join();
+        });
+
+
         // Any of
+        final CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future, future1);
+        anyOf.thenRun(() -> {
+            if (future.isDone()) {
+                future.join();
+            } else {
+                future1.join();
+            }
+        });
+
 
         // any of
-        // acceptEither
         // applyToEither
+        final CompletableFuture<Integer> applyToEither = future.applyToEither(future1, i -> i + 1);
+        // acceptEither
+        final CompletableFuture<Void> acceptEither = future.acceptEither(future1, System.out::println);
         // runAfterEither
+        final CompletableFuture<Void> runAfterEither = future.runAfterEither(future1, () -> System.out.println("Done!"));
 
         // all of
         // thenCombine
@@ -82,4 +163,27 @@ public void allAnyOf() {
 
     }
 
+    @Test
+    public void recover() {
+        final CompletableFuture<String> future = new CompletableFuture<>();
+        // exceptionally
+        final CompletableFuture<Optional<String>> exceptionally =
+                future.thenApply(Optional::of).exceptionally(e -> {
+                    e.printStackTrace();
+                    return Optional.empty();
+                });
+
+        // handle
+        final CompletableFuture<Optional<?>> handle =
+                future.handle((s, e) -> {
+                    if (e != null) {
+                        e.printStackTrace();
+                        return Optional.empty();
+                    } else {
+                        return Optional.of(s);
+                    }
+                });
+
+    }
+
 }