diff --git a/src/test/java/option/Option.java b/src/test/java/option/Option.java
index cb2da39..bfbdf9e 100644
--- a/src/test/java/option/Option.java
+++ b/src/test/java/option/Option.java
@@ -4,6 +4,7 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.function.Supplier;
 
 // https://github.com/java8-course/option
 public abstract class Option<T> {
@@ -54,6 +55,11 @@ public boolean isEmpty() {
         public T orElse(T t) {
             return t;
         }
+
+        @Override
+        public T orElseGet(Supplier<T> s) {
+            return s.get();
+        }
     }
 
     private static class Some<T> extends Option<T> {
@@ -93,6 +99,11 @@ public boolean isEmpty() {
         public T orElse(T t) {
             return value;
         }
+
+        @Override
+        public T orElseGet(Supplier<T> s) {
+            return value;
+        }
     }
 
 
@@ -108,6 +119,8 @@ public T orElse(T t) {
     public abstract boolean isEmpty();
 //    orElse
     public abstract T orElse(T t);
+//    orElseGet
+    public abstract T orElseGet(Supplier<T> s);
 }
 
 
diff --git a/src/test/java/option/OptionalExample.java b/src/test/java/option/OptionalExample.java
index db18993..f68ae29 100644
--- a/src/test/java/option/OptionalExample.java
+++ b/src/test/java/option/OptionalExample.java
@@ -2,14 +2,34 @@
 
 import org.junit.Test;
 
+import java.util.Objects;
 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> zipMap(Optional<T1> t1, Optional<T2> t2, BiFunction<T1, T2, R> f) {
+        return t1.flatMap(opt1 -> t2.map(opt2 -> f.apply(opt1, opt2)));
+//        //no mutable
+//        //no is present and get
+//        //map and flatmap
+    }
+
+    @Test
+    public void zipMap() {
+        Optional<Integer> first = Optional.of(1);
+        Optional<String> second = Optional.of("a");
+
+        Optional<String> result = zipMap(first, second, (i, s) -> i + s);
+        assertEquals(result.get(), "1a");
+    }
+
     @Test
     public void get() {
         final Optional<String> o1 = Optional.empty();
@@ -50,9 +70,102 @@ public void map() {
         assertEquals(expected, actual);
     }
 
+    @Test
+    public void orElse() {
+        final Optional<String> o1 = getOptional();
+
+        final String orElse = "t";
+
+        final String expected = o1.orElse("t");
+
+        final String actual;
+        if (o1.isPresent()) {
+            actual = o1.get();
+        } else {
+            actual = orElse;
+        }
+    }
+
+    @Test
+    public void orElseGet() {
+        final Optional<String> o1 = getOptional();
+
+        final Supplier<String> getChar = () -> "t";
+
+        final String expected = o1.orElseGet(getChar);
+
+        final String actual;
+        if (o1.isPresent()) {
+            actual = o1.get();
+        } else {
+            actual = "t";
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void filter() {
+        final Optional<String> o1 = getOptional();
+
+        final Predicate<String> isNull = Objects::isNull;
+
+        final Optional<String> expected = o1.filter(isNull);
+
+        final Optional<String> actual;
+        if (o1.isPresent() && isNull.test(o1.get())) {
+            actual = Optional.of(o1.get());
+        } else {
+            actual = Optional.empty();
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void flatMap() {
+        final Optional<String> o1 = getOptional();
+
+        final Function<String, Optional<String>> big = s -> Optional.of(s.toUpperCase());
+
+        final Optional<String> expected = o1.flatMap(big);
+
+        final Optional<String> actual;
+        if (o1.isPresent()) {
+            actual = big.apply(o1.get());
+        } else {
+            actual = Optional.empty();
+        }
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void orElseThrow() {
+        final Optional<String> o1 = getOptional();
+
+        final Supplier<Exception> exception = Exception::new;
+
+        try {
+            System.out.println(o1.orElseThrow(exception));
+        } catch (Exception e) {
+            System.out.println("no value");
+        }
+
+        try {
+            if (o1.isPresent()) {
+                System.out.println(o1.get());
+            } else {
+                throw exception.get();
+            }
+        } catch (Exception e) {
+            System.out.println("no value");
+        }
+    }
+
     private Optional<String> getOptional() {
         return ThreadLocalRandom.current().nextBoolean()
-            ? Optional.empty()
-            : Optional.of("abc");
+                ? Optional.empty()
+                : Optional.of("abc");
     }
 }