diff --git a/src/main/java/data/Generator.java b/src/main/java/data/Generator.java
index cbd46ea..f5e76d1 100644
--- a/src/main/java/data/Generator.java
+++ b/src/main/java/data/Generator.java
@@ -60,7 +60,11 @@ public static Employee generateEmployee() {
     }
 
     public static List<Employee> generateEmployeeList() {
-        // TODO
-        throw new UnsupportedOperationException();
+        int maxLength = 10;
+        final int length = ThreadLocalRandom.current().nextInt(maxLength) + 1;
+
+        return Stream.generate(Generator::generateEmployee)
+                .limit(length)
+                .collect(toList());
     }
 }
diff --git a/src/test/java/part1/exercise/StreamsExercise1.java b/src/test/java/part1/exercise/StreamsExercise1.java
index 02dd2da..e17884a 100755
--- a/src/test/java/part1/exercise/StreamsExercise1.java
+++ b/src/test/java/part1/exercise/StreamsExercise1.java
@@ -2,19 +2,14 @@
 
 import data.Employee;
 import data.JobHistoryEntry;
-import data.Person;
 import org.junit.Test;
 
-import java.util.*;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import java.util.stream.Stream;
+import java.util.Collection;
+import java.util.List;
 
 import static data.Generator.generateEmployeeList;
-import static java.util.stream.Collectors.groupingBy;
-import static java.util.stream.Collectors.mapping;
 import static java.util.stream.Collectors.toList;
+import static org.junit.Assert.assertEquals;
 
 public class StreamsExercise1 {
     // https://youtu.be/kxgo7Y4cdA8 Сергей Куксенко и Алексей Шипилёв — Через тернии к лямбдам, часть 1
@@ -25,14 +20,33 @@ public class StreamsExercise1 {
 
     @Test
     public void getAllEpamEmployees() {
-        List<Person> epamEmployees = null;// TODO all persons with experience in epam
-        throw new UnsupportedOperationException();
+        List<Employee> employees = generateEmployeeList(); // all persons with experience in epam
+
+        List<Employee> epamEmployees = employees.stream()
+                .filter(this::workedInEpam)
+                .collect(toList());
+    }
+
+    private boolean workedInEpam(Employee employee) {
+        return employee.getJobHistory().stream()
+                .map(JobHistoryEntry::getEmployer)
+                .anyMatch("epam"::equals);
     }
 
     @Test
     public void getEmployeesStartedFromEpam() {
-        List<Person> epamEmployees = null;// TODO all persons with first experience in epam
-        throw new UnsupportedOperationException();
+        List<Employee> employees = generateEmployeeList();// all persons with first experience in epam
+
+        List<Employee> epamEmployees = employees.stream()
+                .filter(this::workedFirstlyInEpam)
+                .collect(toList());
+    }
+
+    private boolean workedFirstlyInEpam(Employee employee) {
+        return employee.getJobHistory().stream()
+                .findFirst()
+                .filter("epam"::equals)
+                .isPresent();
     }
 
     @Test
@@ -49,11 +63,18 @@ public void sumEpamDurations() {
             }
         }
 
-        // TODO
-        throw new UnsupportedOperationException();
+         int result = employees.stream()
+                 .map(Employee::getJobHistory)
+                 .flatMap(Collection::stream)
+                 .filter(this::epamJobHistoryEntry)
+                 .mapToInt(JobHistoryEntry::getDuration)
+                 .sum();
+
+         assertEquals(expected, result);
+    }
 
-        // int result = ???
-        // assertEquals(expected, result);
+    private boolean epamJobHistoryEntry(JobHistoryEntry jobHistoryEntry) {
+        return jobHistoryEntry.getEmployer().equals("epam");
     }
 
 }
diff --git a/src/test/java/part1/exercise/StreamsExercise2.java b/src/test/java/part1/exercise/StreamsExercise2.java
index 5be9d38..5873b41 100755
--- a/src/test/java/part1/exercise/StreamsExercise2.java
+++ b/src/test/java/part1/exercise/StreamsExercise2.java
@@ -5,13 +5,11 @@
 import data.Person;
 import org.junit.Test;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static data.Generator.generateEmployeeList;
+import static java.util.Comparator.comparingInt;
 import static java.util.stream.Collectors.*;
 import static org.junit.Assert.assertEquals;
 
@@ -23,27 +21,100 @@ public class StreamsExercise2 {
     // https://youtu.be/i0Jr2l3jrDA Сергей Куксенко — Stream API, часть 2
 
     // TODO class PersonEmployerPair
+    private static class PersonEmployerPair {
+        private Person person;
+        private String employer;
+
+        public PersonEmployerPair(Person person, String employer) {
+            this.person = person;
+            this.employer = employer;
+        }
+
+        public Person getPerson() {
+            return person;
+        }
+
+        public String getEmployer() {
+            return employer;
+        }
+    }
 
     @Test
     public void employersStuffLists() {
-        Map<String, List<Person>> employersStuffLists = null;// TODO
-        throw new UnsupportedOperationException();
+        Stream<PersonEmployerPair> personEmployerPairStream = getEmployees().stream()
+                .flatMap(this::toPersonEmployerPair);
+
+        Map<String, Set<Person>> employersStuffLists = personEmployerPairStream
+                .collect(groupingBy(
+                                PersonEmployerPair::getEmployer,
+                                Collectors.mapping(PersonEmployerPair::getPerson, Collectors.toSet())));
     }
 
+    private Stream<PersonEmployerPair> toPersonEmployerPair(Employee employee) {
+        return employee.getJobHistory().stream()
+                .map(jhe -> new PersonEmployerPair(employee.getPerson(), jhe.getEmployer()));
+    }
     @Test
     public void indexByFirstEmployer() {
-        Map<String, List<Person>> employeesIndex = null;// TODO
-        throw new UnsupportedOperationException();
+        Stream<PersonEmployerPair> personFirstEmployerPairStream = getEmployees().stream()
+                .flatMap(this::toPersonAndFirstEmployerPair);
+
+        Map<String, Set<Person>> employeesIndex = personFirstEmployerPairStream
+                .collect(groupingBy(
+                        PersonEmployerPair::getEmployer,
+                        Collectors.mapping(PersonEmployerPair::getPerson, Collectors.toSet())));
+    }
+
+    private Stream<PersonEmployerPair> toPersonAndFirstEmployerPair(Employee employee) {
+        return employee.getJobHistory().stream()
+                .limit(1)
+                .map(jhe -> new PersonEmployerPair(employee.getPerson(), jhe.getEmployer()));
+    }
+
+    private static class PersonEmployerDuration {
+
+        private final Person person;
+        private final String employer;
+        private final int duration;
+        public PersonEmployerDuration(Person person, String employer, int duration) {
+            this.person = person;
+            this.employer = employer;
+            this.duration = duration;
+        }
+
+        public Person getPerson() {
+            return person;
+        }
+
+        public String getEmployer() {
+            return employer;
+        }
+
+        public int getDuration() {
+            return duration;
+        }
+
+    }
+
+    private Stream<PersonEmployerDuration> toPersonEmployerDuration(Employee employee) {
+        return employee.getJobHistory().stream()
+                .map(jhe -> new PersonEmployerDuration(employee.getPerson(), jhe.getEmployer(), jhe.getDuration()));
     }
 
     @Test
     public void greatestExperiencePerEmployer() {
-        Map<String, Person> employeesIndex = null;// TODO
+        Stream<PersonEmployerDuration> personEmployerDurationStream = getEmployees().stream()
+                .flatMap(this::toPersonEmployerDuration);
+
+        Map<String, Person> employeesIndex = personEmployerDurationStream
+                .collect(groupingBy(PersonEmployerDuration::getEmployer,
+                                collectingAndThen(
+                                        maxBy(comparingInt(PersonEmployerDuration::getDuration)),
+                                        o -> o.get().getPerson())));
 
         assertEquals(new Person("John", "White", 28), employeesIndex.get("epam"));
     }
 
-
     private List<Employee> getEmployees() {
         return Arrays.asList(
                 new Employee(