diff --git a/src/test/java/part1/exercise/CompletableFutureBasics.java b/src/test/java/part1/exercise/CompletableFutureBasics.java
index cfd0861..9ce881b 100755
--- a/src/test/java/part1/exercise/CompletableFutureBasics.java
+++ b/src/test/java/part1/exercise/CompletableFutureBasics.java
@@ -60,21 +60,19 @@ public static void after() {
     public void createNonEmpty() throws ExecutionException, InterruptedException {
         final Person person = new Person("John", "Galt", 33);
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
         assertTrue(optPerson.isPresent());
         assertEquals(person, optPerson.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
         final List<Person> persons = streamPerson.collect(toList());
         assertThat(persons.size(), is(1));
         assertEquals(person, persons.get(0));
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
         assertTrue(futurePerson.isDone());
         assertEquals(person, futurePerson.get());
@@ -82,20 +80,18 @@ public void createNonEmpty() throws ExecutionException, InterruptedException {
 
     @Test
     public void createEmpty() throws ExecutionException, InterruptedException {
-        // TODO Create empty Optional
-        final Optional<Person> optPerson = null;
+
+        final Optional<Person> optPerson = Optional.empty();
 
         assertFalse(optPerson.isPresent());
 
-        // TODO Create empty stream
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.empty();
 
         final List<Person> persons = streamPerson.collect(toList());
         assertThat(persons.size(), is(0));
 
-        // TODO Complete CompletableFuture with NoSuchElementException
-        final CompletableFuture<Person> futurePerson = null;
-        // futurePerson.???
+        final CompletableFuture<Person> futurePerson = new CompletableFuture<>();
+        futurePerson.completeExceptionally(new NoSuchElementException());
 
         assertTrue(futurePerson.isCompletedExceptionally());
         assertTrue(futurePerson
@@ -107,28 +103,27 @@ public void createEmpty() throws ExecutionException, InterruptedException {
     public void forEach() throws ExecutionException, InterruptedException {
         final Person person = new Person("John", "Galt", 33);
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
         final CompletableFuture<Person> result1 = new CompletableFuture<>();
 
-        // TODO using optPerson.ifPresent complete result1
+        result1.complete(optPerson.get());
+
+        optPerson.ifPresent(result1::complete);
         assertEquals(person, result1.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
         final CompletableFuture<Person> result2 = new CompletableFuture<>();
 
-        // TODO Using streamPerson.forEach complete result2
+        streamPerson.forEach(result2::complete);
         assertEquals(person, result2.get());
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
         final CompletableFuture<Person> result3 = new CompletableFuture<>();
 
-        // TODO Using futurePerson.thenAccept complete result3
+        futurePerson.thenAccept(result3::complete);
         assertEquals(person, result3.get());
     }
 
@@ -136,27 +131,21 @@ public void forEach() throws ExecutionException, InterruptedException {
     public void map() throws ExecutionException, InterruptedException {
         final Person person = new Person("John", "Galt", 33);
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
-        // TODO get Optional<first name> from optPerson
-        final Optional<String> optFirstName = null;
+        final Optional<String> optFirstName = optPerson.map(Person::getFirstName);
 
         assertEquals(person.getFirstName(), optFirstName.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
-        // TODO Get Stream<first name> from streamPerson
-        final Stream<String> streamFirstName = null;
+        final Stream<String> streamFirstName = streamPerson.map(Person::getFirstName);
 
         assertEquals(person.getFirstName(), streamFirstName.collect(toList()).get(0));
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
-        // TODO Get CompletableFuture<first name> from futurePerson
-        final CompletableFuture<String> futureFirstName = null;
+        final CompletableFuture<String> futureFirstName = futurePerson.thenApply(Person::getFirstName);
 
         assertEquals(person.getFirstName(), futureFirstName.get());
     }
@@ -165,30 +154,24 @@ public void map() throws ExecutionException, InterruptedException {
     public void flatMap() throws ExecutionException, InterruptedException {
         final Person person = employeeDb.get(keys.get(0)).thenApply(Employee::getPerson).get();
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
-        // TODO Using flatMap and .getFirstName().codePoints().mapToObj(p -> p).findFirst()
-        // TODO get the first letter of first name if any
         final Optional<Integer> optFirstCodePointOfFirstName =
-                null;
+                optPerson.flatMap(p -> p.getFirstName().codePoints().mapToObj(l -> l).findFirst());
+
 
         assertEquals(Integer.valueOf(65), optFirstCodePointOfFirstName.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
-        // TODO Using flatMapToInt and .getFirstName().codePoints() get codepoints stream from streamPerson
-        final IntStream codePoints = null;
+        final IntStream codePoints = streamPerson.flatMapToInt(p -> p.getFirstName().codePoints());
 
         final int[] codePointsArray = codePoints.toArray();
         assertEquals(person.getFirstName(), new String(codePointsArray, 0, codePointsArray.length));
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
-        // TODO Get CompletableFuture<Employee> from futurePerson using getKeyByPerson and employeeDb
-        final CompletableFuture<Employee> futureEmployee = null;
+        final CompletableFuture<Employee> futureEmployee = futurePerson.thenCompose(p -> employeeDb.get(getKeyByPerson(p)));
 
         assertEquals(person, futureEmployee.thenApply(Employee::getPerson).get());
     }