From 3c45106d7e77b3f374cad96bddfb4e3222e2b6a9 Mon Sep 17 00:00:00 2001
From: Mikhail <figurin_mih@mail.ru>
Date: Fri, 23 Jun 2017 18:28:10 +0300
Subject: [PATCH] + zipMap (1,2) + some Optional methods with only get and
 isPresent usage

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

diff --git a/src/test/java/option/OptionalExample.java b/src/test/java/option/OptionalExample.java
index db18993..a3e479a 100644
--- a/src/test/java/option/OptionalExample.java
+++ b/src/test/java/option/OptionalExample.java
@@ -4,12 +4,42 @@
 
 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 {
 
+    public static <T1, T2, R> Optional<R> zipMap1(Optional<T1> o1, Optional<T2> o2, BiFunction<T1, T2, R> f) {
+        if (o1.isPresent() && o2.isPresent()) {
+            return Optional.ofNullable(f.apply(o1.get(), o2.get()));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    public static <T1, T2, R> Optional<R> zipMap2(Optional<T1> o1, Optional<T2> o2, BiFunction<T1, T2, R> f) {
+        return o1.flatMap(
+                t1 -> o2.flatMap(
+                        t2 -> Optional.ofNullable(f.apply(t1, t2))));
+    }
+
+    @Test
+    public void zipTest() {
+        Optional<String> o1 = Optional.of("hello");
+        Optional<Integer> o2 = Optional.of(404);
+
+        BiFunction<String, Integer, String> f = (s, i) -> "" + s + i;
+        Optional<String> rOption1 = zipMap1(o1, o2, f);
+        Optional<String> rOption2 = zipMap2(o1, o2, f);
+
+        assertEquals(rOption1.get(), "hello404");
+        assertEquals(rOption2.get(), "hello404");
+    }
+
     @Test
     public void get() {
         final Optional<String> o1 = Optional.empty();
@@ -50,6 +80,83 @@ public void map() {
         assertEquals(expected, actual);
     }
 
+    @Test
+    public void filter() {
+        Optional<String> o = getOptional();
+        Predicate<String> p = String::isEmpty;
+        Optional<String> expected = o.filter(p);
+
+        Optional<String> actual = (o.isPresent() && p.test(o.get()))
+                ? o : Optional.empty();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void flatMap() {
+        Optional<String> o = getOptional();
+        Function<String, Optional<String>> f = (s) -> Optional.of(s + "hello");
+        Optional<String> expected = o.flatMap(f);
+
+        Optional<String> actual = (o.isPresent())
+                ? f.apply(o.get()) : Optional.empty();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElse() {
+        Optional<String> o = getOptional();
+        String str = "hello";
+        String expected = o.orElse(str);
+
+        String actual = (o.isPresent())
+                ? o.get() : str;
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElseGet() {
+        Optional<String> o = getOptional();
+        Supplier<String> s = () -> "hello";
+        String expected = o.orElseGet(s);
+
+        String actual = (o.isPresent())
+                ? o.get() : s.get();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElseThrow() {
+        Optional<String> o = getOptional();
+        Supplier<RuntimeException> s = RuntimeException::new;
+
+        String expected = null;
+        Exception e1 = new Exception();
+
+        try {
+            expected = o.orElseThrow(s);
+        } catch (RuntimeException e) {
+            e1 = e;
+        }
+
+        String actual = null;
+        try {
+            if (o.isPresent()) {
+                actual = o.get();
+            } else {
+                throw s.get();
+            }
+        } catch (RuntimeException e) {
+            assertEquals(e1.getClass(), e.getClass());
+        }
+
+        assertEquals(expected, actual);
+
+    }
+
     private Optional<String> getOptional() {
         return ThreadLocalRandom.current().nextBoolean()
             ? Optional.empty()