From 40c46880d9dbf25628eeb288f8619453c63cdd44 Mon Sep 17 00:00:00 2001
From: Andrei Tcibin <tsibin.andr@gmail.com>
Date: Fri, 23 Jun 2017 17:30:13 +0300
Subject: [PATCH 1/2] add OptionalExample tests and 2 methods for zipMap

---
 src/test/java/option/OptionalExample.java | 133 +++++++++++++++++++++-
 1 file changed, 132 insertions(+), 1 deletion(-)

diff --git a/src/test/java/option/OptionalExample.java b/src/test/java/option/OptionalExample.java
index db18993..a7f6a62 100644
--- a/src/test/java/option/OptionalExample.java
+++ b/src/test/java/option/OptionalExample.java
@@ -4,13 +4,30 @@
 
 import java.util.Optional;
 import java.util.concurrent.ThreadLocalRandom;
+import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
 
 import static org.junit.Assert.assertEquals;
 
 public class OptionalExample {
 
-    @Test
+    //length is min of two collections
+    //R only when T1 and T2 exists
+    //without isPresent && get
+    //without mutable var (only final vars)
+    //hint: 2 methods to use: only map and flatMap
+    public static <T1, T2, R> Optional<R> zipMap(Optional<T1> o1, Optional<T2> o2, BiFunction<T1, T2, R> bf) {
+        return o1.flatMap(t1 -> o2.map(t2 -> bf.apply(t1, t2)));
+    }
+
+    public static <T1, T2, R> Optional<R> zipMap1(Optional<T1> o1, Optional<T2> o2, BiFunction<T1, T2, R> bf) {
+        Optional<Optional<R>> optionalOptional = o1.map(t1 -> o2.map(t2 -> bf.apply(t1, t2)));
+        return optionalOptional.orElse(Optional.empty());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
     public void get() {
         final Optional<String> o1 = Optional.empty();
 
@@ -50,6 +67,120 @@ public void map() {
         assertEquals(expected, actual);
     }
 
+    //ifPresent && get -> realise all methods from Optional
+    /*
+    1. option.filter();      +
+    2. option.flatMap();     +
+    3. option.orElse();      +
+    4. option.orElseGet();   +
+    5. option.orElseThrow(); +
+    */
+
+    @Test
+    public void filter() throws Exception {
+        Optional<String> o1 = getOptional();
+
+        Predicate<String> p = s -> s.equals("abc");
+
+        Optional<String> expected = o1.filter(p);
+        Optional<String> actual;
+
+        if (o1.isPresent()) {
+            if (p.test(o1.get())) {
+                actual = o1;
+            } else {
+                actual = Optional.empty();
+            }
+        } else {
+            actual = Optional.empty();
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void flatMap() throws Exception {
+        Optional<String> o1 = getOptional();
+
+        Function<String, Optional<String>> f = s -> Optional.of("test");
+
+        Optional<String> expected = o1.flatMap(f);
+        Optional<String> actual;
+
+        if (o1.isPresent()) {
+            actual =  f.apply(o1.get());
+        } else {
+            actual = Optional.empty();
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElse() throws Exception {
+        Optional<String> o1 = getOptional();
+
+        String str = "test";
+
+        String expected = o1.orElse(str);
+        String actual;
+
+        if (o1.isPresent()) {
+            actual = o1.get();
+        } else {
+            actual = str;
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElseGet() throws Exception {
+        Optional<String> o1 = getOptional();
+
+        Supplier<String> supplier = () -> "test";
+
+        String expected = o1.orElseGet(supplier);
+        String actual;
+
+        if (o1.isPresent()) {
+            actual = o1.get();
+        } else {
+            actual = supplier.get();
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElseThrow() throws Exception {
+        Optional<String> o1 = getOptional();
+        Supplier<NullPointerException> thrower = NullPointerException::new;
+
+        boolean thrownedExpected = false;
+        String expected = null;
+        try {
+            expected = o1.orElseThrow(thrower);
+        } catch (NullPointerException e) {
+            thrownedExpected = true;
+        }
+
+        boolean thrownedActual = false;
+        String actual = null;
+        try {
+            if (o1.isPresent()) {
+                actual = o1.get();
+            } else {
+                thrower.get();
+            }
+        } catch (NullPointerException e) {
+            thrownedActual = true;
+        }
+
+        assertEquals(thrownedExpected, thrownedActual);
+        assertEquals(expected, actual);
+    }
+
     private Optional<String> getOptional() {
         return ThreadLocalRandom.current().nextBoolean()
             ? Optional.empty()

From 122faab2eff87e2f2619d5a96a36ca942fafa770 Mon Sep 17 00:00:00 2001
From: Andrei Tcibin <tsibin.andr@gmail.com>
Date: Fri, 23 Jun 2017 17:31:20 +0300
Subject: [PATCH 2/2] remove comments from OptionalExample

---
 src/test/java/option/OptionalExample.java | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/src/test/java/option/OptionalExample.java b/src/test/java/option/OptionalExample.java
index a7f6a62..e21432a 100644
--- a/src/test/java/option/OptionalExample.java
+++ b/src/test/java/option/OptionalExample.java
@@ -13,11 +13,6 @@
 
 public class OptionalExample {
 
-    //length is min of two collections
-    //R only when T1 and T2 exists
-    //without isPresent && get
-    //without mutable var (only final vars)
-    //hint: 2 methods to use: only map and flatMap
     public static <T1, T2, R> Optional<R> zipMap(Optional<T1> o1, Optional<T2> o2, BiFunction<T1, T2, R> bf) {
         return o1.flatMap(t1 -> o2.map(t2 -> bf.apply(t1, t2)));
     }
@@ -67,15 +62,6 @@ public void map() {
         assertEquals(expected, actual);
     }
 
-    //ifPresent && get -> realise all methods from Optional
-    /*
-    1. option.filter();      +
-    2. option.flatMap();     +
-    3. option.orElse();      +
-    4. option.orElseGet();   +
-    5. option.orElseThrow(); +
-    */
-
     @Test
     public void filter() throws Exception {
         Optional<String> o1 = getOptional();