diff --git a/src/test/java/lambda/part3/exercise/FilterMap.java b/src/test/java/lambda/part3/exercise/FilterMap.java
index 178190e..a39af6c 100644
--- a/src/test/java/lambda/part3/exercise/FilterMap.java
+++ b/src/test/java/lambda/part3/exercise/FilterMap.java
@@ -1,10 +1,21 @@
 package lambda.part3.exercise;
 
+import data.Employee;
+import data.JobHistoryEntry;
+import data.Person;
+import org.junit.Test;
+
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import static lambda.part3.exercise.Mapping.addOneYear;
+import static lambda.part3.exercise.Mapping.changeToQa;
+import static org.junit.Assert.assertEquals;
+
 public class FilterMap {
 
     public static class Container<T, R> {
@@ -32,31 +43,95 @@ public Function<T, R> getFunction() {
 
     public static class LazyCollectionHelper<T> {
         private final List<Container<Object, Object>> actions;
-        private final List<T> list;
+        private final List list;
 
-        public LazyCollectionHelper(List<T> list, List<Container<Object, Object>> actions) {
+        private LazyCollectionHelper(List list, List<Container<Object, Object>> actions) {
             this.actions = actions;
             this.list = list;
         }
 
         public LazyCollectionHelper(List<T> list) {
-            this(list, new ArrayList<>());
+            this( list, new ArrayList<>());
         }
 
         public LazyCollectionHelper<T> filter(Predicate<T> condition) {
-            List<Container<Object, Object>> newActions = new ArrayList<>(actions);
-            newActions.add(new Container<>((Predicate<Object>) condition));
-            return new LazyCollectionHelper<>(list, newActions);
+            actions.add(new Container<>((Predicate<Object>) condition));
+            return this;
         }
 
         public <R> LazyCollectionHelper<R> map(Function<T, R> function) {
-            // TODO
-            throw new UnsupportedOperationException();
+            actions.add(new Container<>((Function<Object, Object>) function));
+            return new LazyCollectionHelper<R>(list, actions);
         }
 
         public List<T> force() {
-            // TODO
-            throw new UnsupportedOperationException();
+            List<Object> result = new ArrayList<>(list);
+            for (Container<Object, Object> action : actions) {
+                List<Object> tmp = new ArrayList<>();
+                if (action.getFunction() != null)
+                    result.forEach(element ->
+                        tmp.add(action.getFunction().apply(element)));
+                else result.forEach(element -> {
+                            if (action.getPredicate().test(element))
+                                tmp.add(element);
+                        });
+                result = tmp;
+            }
+            final ArrayList<T> ret = new ArrayList<>();
+            result.forEach(e -> ret.add((T) e));
+            return ret;
         }
     }
+
+    @Test
+    public void createEmployeesAndGetEpamEmployeesHistory() {
+        final List<Employee> employees =
+                Arrays.asList(
+                        new Employee(
+                                new Person("a", "Galt", 30),
+                                Arrays.asList(
+                                        new JobHistoryEntry(2, "dev", "epam"),
+                                        new JobHistoryEntry(1, "dev", "google")
+                                )),
+                        new Employee(
+                                new Person("b", "Doe", 40),
+                                Arrays.asList(
+                                        new JobHistoryEntry(3, "qa", "yandex"),
+                                        new JobHistoryEntry(1, "qa", "epam"),
+                                        new JobHistoryEntry(1, "dev", "abc")
+                                )),
+                        new Employee(
+                                new Person("c", "White", 50),
+                                Collections.singletonList(
+                                        new JobHistoryEntry(5, "qa", "JoshkinaLolo")
+                                ))
+                );
+
+        final List<Employee> mappedEmployees =
+                new LazyCollectionHelper(employees)
+                        .map(e -> ((Employee)e).withPerson(((Employee)e).getPerson().withFirstName("John")))
+                        .map(e -> ((Employee)e).withJobHistory(addOneYear(((Employee)e).getJobHistory())))
+                        .map(e -> ((Employee)e).withJobHistory(changeToQa(((Employee)e).getJobHistory())))
+                        .filter(e -> ((Employee)e).getJobHistory().stream().anyMatch(j -> j.getEmployer().equals("epam")))
+                        .force();
+
+        final List<Employee> expectedResult =
+                Arrays.asList(
+                        new Employee(
+                                new Person("John", "Galt", 30),
+                                Arrays.asList(
+                                        new JobHistoryEntry(3, "dev", "epam"),
+                                        new JobHistoryEntry(2, "dev", "google")
+                                )),
+                        new Employee(
+                                new Person("John", "Doe", 40),
+                                Arrays.asList(
+                                        new JobHistoryEntry(4, "QA", "yandex"),
+                                        new JobHistoryEntry(2, "QA", "epam"),
+                                        new JobHistoryEntry(2, "dev", "abc")
+                                ))
+                );
+
+        assertEquals(mappedEmployees, expectedResult);
+    }
 }
diff --git a/src/test/java/lambda/part3/exercise/Mapping.java b/src/test/java/lambda/part3/exercise/Mapping.java
index c0a814a..1dd337d 100644
--- a/src/test/java/lambda/part3/exercise/Mapping.java
+++ b/src/test/java/lambda/part3/exercise/Mapping.java
@@ -9,10 +9,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.Predicate;
 
 import static org.junit.Assert.assertEquals;
 
@@ -33,7 +30,9 @@ public List<T> getList() {
         // [T1, T2, T3] -> (T -> R) -> [R1, R2, R3]
         public <R> MapHelper<R> map(Function<T, R> f) {
             // TODO
-            throw new UnsupportedOperationException();
+            final ArrayList<R> result = new ArrayList<>();
+            this.list.forEach(e -> result.add(f.apply(e)));
+            return new MapHelper<>(result);
         }
 
         // [T] -> (T -> [R]) -> [R]
@@ -46,10 +45,22 @@ public <R> MapHelper<R> flatMap(Function<T, List<R>> f) {
                     f.apply(t).forEach(result::add)
             );
 
-            return new MapHelper<R>(result);
+            return new MapHelper<>(result);
         }
     }
 
+    public static List<JobHistoryEntry> addOneYear(List<JobHistoryEntry> list){
+        return new MapHelper<>(list)
+                .map(e -> e.withDuration(e.getDuration() + 1) ).getList();
+    }
+
+    public static List<JobHistoryEntry> changeToQa(List<JobHistoryEntry> list) {
+        return new MapHelper<>(list)
+                .map(e -> e.getPosition().equals("qa") ?
+                        e.withPosition("QA") : e)
+                .getList();
+    }
+
     @Test
     public void mapping() {
         final List<Employee> employees =
@@ -76,12 +87,15 @@ public void mapping() {
 
         final List<Employee> mappedEmployees =
                 new MapHelper<>(employees)
-                /*
-                .map(TODO) // change name to John .map(e -> e.withPerson(e.getPerson().withFirstName("John")))
-                .map(TODO) // add 1 year to experience duration .map(e -> e.withJobHistory(addOneYear(e.getJobHistory())))
-                .map(TODO) // replace qa with QA
-                * */
-                .getList();
+                        /*
+                        .map(TODO) // change name to John .map(e -> e.withPerson(e.getPerson().withFirstName("John")))
+                        .map(TODO) // add 1 year to experience duration .map(e -> e.withJobHistory(addOneYear(e.getJobHistory())))
+                        .map(TODO) // replace qa with QA
+                        * */
+                        .map(e -> e.withPerson(e.getPerson().withFirstName("John")))
+                        .map(e -> e.withJobHistory(addOneYear(e.getJobHistory())))
+                        .map(e -> e.withJobHistory(changeToQa(e.getJobHistory())))
+                        .getList();
 
         final List<Employee> expectedResult =
                 Arrays.asList(
@@ -105,13 +119,16 @@ public void mapping() {
                                 ))
                 );
 
-        assertEquals(mappedEmployees, expectedResult);
+        assertEquals(expectedResult, mappedEmployees);
     }
 
-
     private static class LazyMapHelper<T, R> {
+        private List<T> list;
+        private Function<T, R> function;
 
         public LazyMapHelper(List<T> list, Function<T, R> function) {
+            this.list = list;
+            this.function = function;
         }
 
         public static <T> LazyMapHelper<T, T> from(List<T> list) {
@@ -119,54 +136,18 @@ public static <T> LazyMapHelper<T, T> from(List<T> list) {
         }
 
         public List<R> force() {
-            // TODO
-            throw new UnsupportedOperationException();
+            if (function == null) throw new NullPointerException("Function is NULL");
+            return new MapHelper<>(list)
+                    .map(function)
+                    .getList();
         }
 
         public <R2> LazyMapHelper<T, R2> map(Function<R, R2> f) {
-            // TODO
-            throw new UnsupportedOperationException();
-        }
-
-    }
-
-    private static class LazyFlatMapHelper<T, R> {
-
-        public LazyFlatMapHelper(List<T> list, Function<T, List<R>> function) {
+            return new LazyMapHelper<>(list, f.compose(function));
         }
 
-        public static <T> LazyFlatMapHelper<T, T> from(List<T> list) {
-            throw new UnsupportedOperationException();
-        }
-
-        public List<R> force() {
-            // TODO
-            throw new UnsupportedOperationException();
-        }
-
-        // TODO filter
-        // (T -> boolean) -> (T -> [T])
-        // filter: [T1, T2] -> (T -> boolean) -> [T2]
-        // flatMap": [T1, T2] -> (T -> [T]) -> [T2]
-
-        public <R2> LazyFlatMapHelper<T, R2> map(Function<R, R2> f) {
-            final Function<R, List<R2>> listFunction = rR2TorListR2(f);
-            return flatMap(listFunction);
-        }
-
-        // (R -> R2) -> (R -> [R2])
-        private <R2> Function<R, List<R2>> rR2TorListR2(Function<R, R2> f) {
-            throw new UnsupportedOperationException();
-        }
-
-        // TODO *
-        public <R2> LazyFlatMapHelper<T, R2> flatMap(Function<R, List<R2>> f) {
-            throw new UnsupportedOperationException();
-        }
     }
 
-
-
     @Test
     public void lazy_mapping() {
         final List<Employee> employees =
@@ -193,12 +174,15 @@ public void lazy_mapping() {
 
         final List<Employee> mappedEmployees =
                 LazyMapHelper.from(employees)
-                /*
-                .map(TODO) // change name to John
-                .map(TODO) // add 1 year to experience duration
-                .map(TODO) // replace qa with QA
-                * */
-                .force();
+                        /*
+                        .map(TODO) // change name to John
+                        .map(TODO) // add 1 year to experience duration
+                        .map(TODO) // replace qa with QA
+                        * */
+                        .map(e -> e.withPerson(e.getPerson().withFirstName("John")))
+                        .map(e -> e.withJobHistory(addOneYear(e.getJobHistory())))
+                        .map(e -> e.withJobHistory(changeToQa(e.getJobHistory())))
+                        .force();
 
         final List<Employee> expectedResult =
                 Arrays.asList(
@@ -224,4 +208,6 @@ public void lazy_mapping() {
 
         assertEquals(mappedEmployees, expectedResult);
     }
+
+
 }
diff --git a/src/test/java/lambda/part3/exercise/ReachIterableTest.java b/src/test/java/lambda/part3/exercise/ReachIterableTest.java
new file mode 100644
index 0000000..51793fa
--- /dev/null
+++ b/src/test/java/lambda/part3/exercise/ReachIterableTest.java
@@ -0,0 +1,227 @@
+package lambda.part3.exercise;
+
+import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader;
+import data.Employee;
+import data.JobHistoryEntry;
+import data.Person;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import static lambda.part3.exercise.Mapping.addOneYear;
+import static lambda.part3.exercise.Mapping.changeToQa;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * Created by whobscr on 06.07.17.
+ */
+public class ReachIterableTest {
+    private interface ReachIterable<T> {
+
+        boolean tryGet(Consumer<T> c);
+
+        default <R> ReachIterable<R> map(Function<T, R> f) {
+            return new ReachIterable<R>() {
+                @Override
+                public boolean tryGet(Consumer<R> c) {
+                    return ReachIterable.this.tryGet(t -> c.accept(f.apply(t)));
+                }
+            };
+        }
+
+        default <R> ReachIterable<R> flatMap(Function<T, ReachIterable<R>> mapper) {
+            return new ReachIterable<R>() {
+                @Override
+                public boolean tryGet(Consumer<R> c) {
+                    return ReachIterable.this.tryGet(e -> mapper.apply(e).tryGet(c));
+                }
+            };
+        }
+
+        default ReachIterable<T> filter(Predicate<T> p) {
+            return new ReachIterable<T>() {
+                @Override
+                public boolean tryGet(Consumer<T> c) {
+                    return ReachIterable.this.tryGet(e -> {
+                        if (p.test(e)) c.accept(e);
+                    });
+                }
+            };
+        }
+
+        default List<T> toList() {
+            final ArrayList<T> ts = new ArrayList<>();
+            while (tryGet(ts::add));
+            return ts;
+        }
+
+        default boolean allMatch(Predicate<T> p) {
+            return !anyMatch(p.negate());
+        }
+
+        default boolean noneMatch(Predicate<T> p) {
+            return anyMatch(p.negate());
+        }
+
+        default boolean anyMatch(Predicate<T> p) {
+            return firstMatch(p).isPresent();
+        }
+
+        default Optional<T> firstMatch(Predicate<T> p) {
+            Map.Entry<Integer, Optional<T>> curElem =
+                    new AbstractMap.SimpleEntry<>(0, Optional.empty());
+            while (tryGet(c -> curElem.setValue(Optional.of(c)))) {
+                if (curElem.getValue().isPresent()
+                        && p.test(curElem.getValue().get()))
+                    return Optional.of(curElem.getValue().get());
+            }
+            return Optional.empty();
+        }
+    }
+
+    static <T> ReachIterable<T> from(Iterable<T> iterable) {
+        return new ReachIterable<T>() {
+            private Iterator<T> iterator = iterable.iterator();
+
+            @Override
+            public boolean tryGet(Consumer<T> action) {
+                if (iterator.hasNext()) {
+                    action.accept(iterator.next());
+                    return true;
+                } else return false;
+            }
+        };
+    }
+
+    @Test
+    public void emptyArray() {
+        assertFalse(from(new ArrayList<Integer>())
+                            .tryGet(c -> {}));
+    }
+
+    @Test
+    public void fiveElementsArrayMapEven() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(1); integers.add(2); integers.add(3);
+        integers.add(4); integers.add(5); integers.add(6);
+
+        final ReachIterable<Integer> reachIterable = from(integers);
+        integers = reachIterable.map(c -> c % 2).toList();
+        final ArrayList<Integer> expected = new ArrayList<>();
+
+        expected.add(1); expected.add(0); expected.add(1);
+        expected.add(0); expected.add(1); expected.add(0);
+        assertThat(integers, is(expected));
+    }
+
+    @Test
+    public void fiveElementsArrayFilterEven() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(1); integers.add(2); integers.add(3);
+        integers.add(4); integers.add(5); integers.add(6);
+
+        final ReachIterable<Integer> reachIterable = from(integers);
+        integers = reachIterable.filter(c -> c % 2 == 0).toList();
+        final ArrayList<Integer> expected = new ArrayList<>();
+
+        expected.add(2); expected.add(4); expected.add(6);
+        assertThat(integers, is(expected));
+    }
+
+    @Test
+    public void trueNoneMatchGreaterThanFive() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(4); integers.add(2); integers.add(3);
+        integers.add(1); integers.add(5);
+
+        assertTrue(from(integers)
+                        .noneMatch(c -> c > 5));
+    }
+
+    @Test
+    public void trueAllMatchLessThanFive() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(4); integers.add(2); integers.add(5);
+        integers.add(1); integers.add(6); integers.add(3);
+
+        assertTrue(from(integers)
+                        .allMatch(c -> c < 7 && c > 0));
+    }
+
+    @Test
+    public void falseAllMatchLessThanFive() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(1); integers.add(2); integers.add(3);
+        integers.add(4); integers.add(5); integers.add(6);
+
+        assertFalse(from(integers)
+                        .allMatch(c -> c < 5));
+    }
+
+    @Test
+    public void mapping() {
+        final List<Employee> employees =
+                Arrays.asList(
+                        new Employee(
+                                new Person("a", "Galt", 30),
+                                Arrays.asList(
+                                        new JobHistoryEntry(2, "dev", "epam"),
+                                        new JobHistoryEntry(1, "dev", "google")
+                                )),
+                        new Employee(
+                                new Person("b", "Doe", 40),
+                                Arrays.asList(
+                                        new JobHistoryEntry(3, "qa", "yandex"),
+                                        new JobHistoryEntry(1, "qa", "epam"),
+                                        new JobHistoryEntry(1, "dev", "abc")
+                                )),
+                        new Employee(
+                                new Person("c", "White", 50),
+                                Collections.singletonList(
+                                        new JobHistoryEntry(5, "qa", "forForeach")
+                                ))
+                );
+
+        final List<Employee> result =
+                from(employees)
+                        .map(e -> e.withPerson(e.getPerson().withFirstName("John")))
+                        .map(e -> e.withJobHistory(addOneYear(e.getJobHistory())))
+                        .map(e -> e.withJobHistory(changeToQa(e.getJobHistory())))
+                        .filter(e -> from(e.getJobHistory()).anyMatch(j -> j.getEmployer().equals("epam")))
+                        .toList();
+
+        final List<Employee> expectedResult =
+                Arrays.asList(
+                        new Employee(
+                                new Person("John", "Galt", 30),
+                                Arrays.asList(
+                                        new JobHistoryEntry(3, "dev", "epam"),
+                                        new JobHistoryEntry(2, "dev", "google")
+                                )),
+                        new Employee(
+                                new Person("John", "Doe", 40),
+                                Arrays.asList(
+                                        new JobHistoryEntry(4, "QA", "yandex"),
+                                        new JobHistoryEntry(2, "QA", "epam"),
+                                        new JobHistoryEntry(2, "dev", "abc")
+                                ))
+                );
+        assertThat(result, is(expectedResult));
+        assertTrue(from(result)
+                    .allMatch(e -> from(e.getJobHistory())
+                            .anyMatch(entry -> entry.getEmployer().equals("epam"))));
+        assertTrue(from(result)
+                .allMatch(e -> from(e.getJobHistory())
+                        .noneMatch(entry -> entry.getPosition().equals("qa"))));
+        assertFalse(from(result)
+                .anyMatch(e -> from(e.getJobHistory())
+                        .anyMatch(entry -> entry.getEmployer().equals("forForeach"))));
+    }
+}
diff --git a/src/test/java/lambda/part3/exercise/Traverser.java b/src/test/java/lambda/part3/exercise/Traverser.java
new file mode 100644
index 0000000..ea6d944
--- /dev/null
+++ b/src/test/java/lambda/part3/exercise/Traverser.java
@@ -0,0 +1,161 @@
+package lambda.part3.exercise;
+
+import data.Employee;
+import data.JobHistoryEntry;
+import data.Person;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import static lambda.part3.exercise.Mapping.addOneYear;
+import static lambda.part3.exercise.Mapping.changeToQa;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by whobscr on 06.07.17.
+ */
+public class Traverser {
+    private interface Traversable<T> {
+        void forEach(Consumer<T> c);
+
+        default <R> Traversable<R> map(Function<T, R> f) {
+            return new Traversable<R>() {
+                @Override
+                public void forEach(Consumer<R> c) {
+                    Traversable.this.forEach(t -> c.accept(f.apply(t)));
+                }
+            };
+        }
+
+        default <R> Traversable<R> flatMap(Function<T, Traversable<R>> mapper) {
+            return new Traversable<R>() {
+                @Override
+                public void forEach(Consumer<R> c) {
+                    Traversable.this.forEach(e -> mapper.apply(e).forEach(c));
+                }
+            };
+
+        }
+
+        default Traversable<T> filter(Predicate<T> p) {
+            return new Traversable<T>() {
+                @Override
+                public void forEach(Consumer<T> c) {
+                    Traversable.this.forEach(e -> {
+                        if (p.test(e)) c.accept(e);
+                    });
+                }
+            };
+        }
+
+        default List<T> toList() {
+            final ArrayList<T> ts = new ArrayList<>();
+            forEach(ts::add);
+            return ts;
+        }
+    }
+
+    static <T> Traversable<T> from(List<T> list) {
+        return new Traversable<T>() {
+            @Override
+            public void forEach(Consumer<T> action) {
+                list.forEach(action);
+            }
+        };
+    }
+
+    @Test
+    public void emptyArray() {
+        from(new ArrayList<Integer>()).forEach(c -> {});
+    }
+
+    @Test
+    public void fiveElementsArrayMapEven() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(1); integers.add(2); integers.add(3);
+        integers.add(4); integers.add(5); integers.add(6);
+
+        final Traversable<Integer> reachIterable = from(integers);
+        integers = reachIterable.map(c -> c % 2).toList();
+        final ArrayList<Integer> expected = new ArrayList<>();
+
+        expected.add(1); expected.add(0); expected.add(1);
+        expected.add(0); expected.add(1); expected.add(0);
+        assertThat(integers, is(expected));
+    }
+
+    @Test
+    public void fiveElementsArrayFilterEven() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(1); integers.add(2); integers.add(3);
+        integers.add(4); integers.add(5); integers.add(6);
+
+        final Traversable<Integer> reachIterable = from(integers);
+        integers = reachIterable.filter(c -> c % 2 == 0).toList();
+        final ArrayList<Integer> expected = new ArrayList<>();
+
+        expected.add(2); expected.add(4); expected.add(6);
+        assertThat(integers, is(expected));
+    }
+
+    @Test
+    public void createEmployeesAndGetEpamEmployeesHistory() {
+        final List<Employee> employees =
+                Arrays.asList(
+                        new Employee(
+                                new Person("a", "Galt", 30),
+                                Arrays.asList(
+                                        new JobHistoryEntry(2, "dev", "epam"),
+                                        new JobHistoryEntry(1, "dev", "google")
+                                )),
+                        new Employee(
+                                new Person("b", "Doe", 40),
+                                Arrays.asList(
+                                        new JobHistoryEntry(3, "qa", "yandex"),
+                                        new JobHistoryEntry(1, "qa", "epam"),
+                                        new JobHistoryEntry(1, "dev", "abc")
+                                )),
+                        new Employee(
+                                new Person("c", "White", 50),
+                                Collections.singletonList(
+                                        new JobHistoryEntry(5, "qa", "JoshkinaLolo")
+                                ))
+                );
+
+        final List<Employee> mappedEmployees =
+                    from(employees)
+                        .map(e -> e.withPerson(e.getPerson().withFirstName("John")))
+                        .map(e -> e.withJobHistory(addOneYear(e.getJobHistory())))
+                        .map(e -> e.withJobHistory(changeToQa(e.getJobHistory())))
+                        .filter(e -> e.getJobHistory().stream().anyMatch(j -> j.getEmployer().equals("epam")))
+                        .toList();
+
+        final List<Employee> expectedResult =
+                Arrays.asList(
+                        new Employee(
+                                new Person("John", "Galt", 30),
+                                Arrays.asList(
+                                        new JobHistoryEntry(3, "dev", "epam"),
+                                        new JobHistoryEntry(2, "dev", "google")
+                                )),
+                        new Employee(
+                                new Person("John", "Doe", 40),
+                                Arrays.asList(
+                                        new JobHistoryEntry(4, "QA", "yandex"),
+                                        new JobHistoryEntry(2, "QA", "epam"),
+                                        new JobHistoryEntry(2, "dev", "abc")
+                                ))
+                );
+
+        assertEquals(mappedEmployees, expectedResult);
+    }
+}