diff --git a/src/main/java/assertions/Person.java b/src/main/java/assertions/Person.java
index ac7666b..87ba6e5 100644
--- a/src/main/java/assertions/Person.java
+++ b/src/main/java/assertions/Person.java
@@ -22,4 +22,15 @@ public String getFullName(){
     public Period getAge(){
         return Period.between(birthDate, LocalDate.now());
     }
+
+    public Boolean isTeen(int years){
+        // Is teen if Age 12 <= && >=18
+        Period age = getAge();
+        years =  age.getYears();
+        if (years >= 12 && years <= 18){
+            return true;
+        }
+        return false;
+
+    }
 }
diff --git a/src/main/java/fakes/UserController.java b/src/main/java/fakes/UserController.java
index d61b7e8..c800498 100644
--- a/src/main/java/fakes/UserController.java
+++ b/src/main/java/fakes/UserController.java
@@ -2,16 +2,28 @@
 
 public class UserController {
 
-    private static Database db = FileDatabase.getInstance();
+    private Database database;
+    private UserValidator userValidator;
+
+    public UserController(UserValidator userValidator) {
+
+        this.userValidator = userValidator;
+    }
+    public UserController(UserValidator userValidator, Database database) {
+
+        this.userValidator = userValidator;
+        this.database = database;
+    }
+
 
     public Message create(User user){
         if(user == null){
             throw new IllegalArgumentException("user required");
         }
-        Boolean canCreate = UserValidator.isValidUsername(user.getUsername())
-                            && !UserValidator.doesUsernameExist(user.getUsername());
+        Boolean canCreate = this.userValidator.isValidUsername(user.getUsername())
+                            && !this.userValidator.doesUsernameExist(user.getUsername());
         if(canCreate){
-            db.addUser(user);
+            database.addUser(user);
             return Message.createOK();
         }else{
             return Message.createNotOK();
diff --git a/src/main/java/fakes/UserValidator.java b/src/main/java/fakes/UserValidator.java
index 0bd28b2..3e09606 100644
--- a/src/main/java/fakes/UserValidator.java
+++ b/src/main/java/fakes/UserValidator.java
@@ -4,22 +4,36 @@ public class UserValidator {
 
     private static Database db = FileDatabase.getInstance();
 
-    public static boolean doesUsernameExist(String username){
-        try {
+    public boolean doesUsernameExist(String username) {
+        /*try {
             Thread.sleep(5000);
         } catch (InterruptedException e) {
             e.printStackTrace();
-        }
+        }*/
 
-        for(User user : db.getUsers()){
-            if (user.getUsername().equals(username)){
+        for (User user : db.getUsers()) {
+            if (user.getUsername().equals(username)) {
                 return true;
             }
         }
         return false;
     }
 
-    public static boolean isValidUsername(String username){
+    public boolean isValidUsername(String username) {
+
+        char[] letters = username.toCharArray();
+        int position = 0;
+
+        for (char letter: letters){
+            if (!Character.isLetter(letter)|| !Character.isAlphabetic(letter)){
+                if (Character.isDigit(letter) && position > 0){
+                    continue;
+                }
+                return false;
+            }
+              position+=1;
+
+        }
         return true;
     }
 }
diff --git a/src/test/java/assertions/PersonTest.java b/src/test/java/assertions/PersonTest.java
index ddfacc8..1ecc385 100644
--- a/src/test/java/assertions/PersonTest.java
+++ b/src/test/java/assertions/PersonTest.java
@@ -1,8 +1,10 @@
 package assertions;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.time.LocalDate;
+import java.time.Period;
 
 class PersonTest {
 
@@ -11,20 +13,63 @@ class PersonTest {
     @Test
     void getFullNameReturnsFirstnameSpaceLastname(){
         // TODO implement
-        throw new IllegalArgumentException("you should implement code here");
+       // throw new IllegalArgumentException("you should implement code here");
+        Person pers1 = new Person("Tobias", "Meier", null);
+        Assertions.assertEquals("Tobias Meier",pers1.getFullName());
+
     }
 
     // TODO some more useful tests
+    @Test
+    void getFullNameCheckSpaceBetween(){
+        Person pers1 = new Person("Tobias", "Meier", null);
+        String fullName = pers1.getFullName();
+        Assertions.assertTrue(fullName.contains(" "), "True if space between firstname and lastname");
+    }
+
+    @Test
+    void isTeenAge18_12ReturnTrue(){
+        Person pers1 = new Person("", "", LocalDate.of(2003, 3,11));
+        Person pers2 = new Person("", "", LocalDate.of(2009, 3, 11));
+        Period age1 = pers1.getAge();
+        Period age2 = pers2.getAge();
+        int years1 = age1.getYears();
+        int years2 = age2.getYears();
+
+        Assertions.assertEquals(18, age1.getYears());
+        Assertions.assertEquals(12, age2.getYears());
+        Assertions.assertTrue(pers1.isTeen(years1),"Is teen = true");
+        Assertions.assertTrue(pers2.isTeen(years2),"Is teen = true");
+
+    }
+    @Test
+    void isNotTeenAge11_19ReturnFalse(){
+        Person pers1 = new Person("", "", LocalDate.of(2010, 3,11));
+        Person pers2 = new Person("", "", LocalDate.of(2002, 3, 11));
+        Period age1 = pers1.getAge();
+        Period age2 = pers2.getAge();
+        int years1 = age1.getYears();
+        int years2 = age2.getYears();
+
+        Assertions.assertEquals(11, age1.getYears());
+        Assertions.assertEquals(19, age2.getYears());
+        Assertions.assertFalse(pers1.isTeen(years1), "Not teen = false");
+        Assertions.assertFalse(pers2.isTeen(years2), "Not teen = false");
+    }
 
 
     // --- getAge
 
     @Test
-    void getAgeReturns10YearsIfBornIn2009() throws Exception {
+    void getAgeReturns10YearsIfBorn10YearsFromToday() throws Exception {
         // TODO verbessern. Hinweis: Repeatable (wiederholbar) zu jeder Zeit.
-        Person p = new Person("", "", LocalDate.of(2009, 1, 1));
+        Person p = new Person("", "", LocalDate.now().minusYears(10));
 
-        throw new IllegalArgumentException("you should implement code here");
+        //throw new IllegalArgumentException("you should implement code here");
+        Period age = p.getAge();
+        Assertions.assertEquals(10,age.getYears());
+        Assertions.assertEquals(0, age.getMonths());
+        Assertions.assertEquals(0, age.getDays());
     }
 
     @Test
@@ -32,7 +77,11 @@ void getAgeReturns1DayIfYesterday() throws Exception {
         Person p = new Person("", "", LocalDate.now().minusDays(1));
 
         // TODO implement
-        throw new IllegalArgumentException("you should implement code here");
+        //throw new IllegalArgumentException("you should implement code here");
+        Period age = p.getAge();
+        Assertions.assertEquals(1,age.getDays());
+        Assertions.assertEquals(0, age.getMonths());
+        Assertions.assertEquals(0, age.getYears());
     }
 
     // TODO some more useful tests
diff --git a/src/test/java/fakes/FakeUserValidator.java b/src/test/java/fakes/FakeUserValidator.java
new file mode 100644
index 0000000..f045457
--- /dev/null
+++ b/src/test/java/fakes/FakeUserValidator.java
@@ -0,0 +1,34 @@
+package fakes;
+// Stupp
+public class FakeUserValidator extends UserValidator{
+
+
+    private  boolean doesUsernameExist;
+    private boolean isValidUsername;
+
+    public FakeUserValidator(){
+
+    }
+
+    public FakeUserValidator(boolean doesUserNameExist, boolean isValidUsername ) {
+        this.doesUsernameExist = doesUserNameExist;
+        this.isValidUsername = isValidUsername;
+    }
+
+    /*@Override
+   public boolean doesUsernameExist(String username) {
+        if(username.equals("kalua")){
+            return true;
+        }
+        return false;
+    }*/
+    public boolean DoesUsernameExist(String username){
+        return doesUsernameExist;
+    }
+
+    public boolean isValidUsername(String username){
+        return isValidUsername;
+    }
+
+
+}
diff --git a/src/test/java/fakes/MockDatabase.java b/src/test/java/fakes/MockDatabase.java
new file mode 100644
index 0000000..b9034f7
--- /dev/null
+++ b/src/test/java/fakes/MockDatabase.java
@@ -0,0 +1,19 @@
+package fakes;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MockDatabase extends Database{
+    List<User> users = new ArrayList<>();
+
+    @Override
+    public void addUser(User user) {
+        users.add(user);
+
+    }
+
+    @Override
+    public List<User> getUsers() {
+        return users;
+    }
+}
diff --git a/src/test/java/fakes/UserControllerTest.java b/src/test/java/fakes/UserControllerTest.java
index cc4b61b..351722e 100644
--- a/src/test/java/fakes/UserControllerTest.java
+++ b/src/test/java/fakes/UserControllerTest.java
@@ -4,6 +4,8 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import static org.mockito.Mockito.*;
+
 class UserControllerTest {
 
   // Pro getestete Methode gibt es eine inner class (Hier für UserController.create)
@@ -14,25 +16,64 @@ class create {
     @Test
     @org.junit.jupiter.api.Disabled
     void withValidInexistingUsername_returnsOK__NO_FAKE_DEMO() {
-      UserController ctrl = new UserController();
+      UserController ctrl = new UserController(new FakeUserValidator(true, true));
       User user = new User("kalua");
 
       Message result = ctrl.create(user);
 
-      Assertions.assertEquals(result.status, Message.Status.OK);
+      Assertions.assertEquals(result.status, Message.Status.NOT_OK);
     }
 
+
     @Test
     void withValidInexistingUsername_returnsOK__FAKE() {
       // TODO
       // 1. Test schneller machen
       // 2. UserController.create so beinflussen,
       //    dass einmal der "if"- und einmal der "else"-Fall durchlaufen wird
+      //Warum NullPointerException? Musste Mockdatabase erzeugen..
+
+      MockDatabase db = new MockDatabase();
+      UserController ctrl = new UserController(new FakeUserValidator(false, true), db );
+      User user = new User("peter");
+
+      Message result = ctrl.create(user);
+
+      Assertions.assertEquals(result.status, Message.Status.OK);
+
+    }
+
+    @Test
+    void withValidInexistingUsername_returnsNOT_OK__FAKE() {
+      // TODO
+      // 1. Test schneller machen
+      // 2. UserController.create so beinflussen,
+      //    dass einmal der "if"- und einmal der "else"-Fall durchlaufen wird
+      UserController ctrl = new UserController(new FakeUserValidator(true, true));
+      User user = new User("kalua");
+
+      Message result = ctrl.create(user);
+
+      Assertions.assertEquals(result.status, Message.Status.NOT_OK);
+
     }
 
     @Test
     void withValidInexistingUsername_returnsOK__MOCKITO() {
       // TODO
+      //uv = Meine FakeUservalidation
+      //db = Meine FakeDataBase
+      //UserController Konstruktor mit parameter UserValidation, Database aufrufen
+      UserValidator uv = mock(UserValidator.class);
+      Database db = mock(Database.class);
+      UserController ctrl = new UserController(uv, db);
+
+      doReturn(true).when(uv).isValidUsername(anyString());
+      doReturn(false).when(uv).doesUsernameExist(anyString());
+
+      User user = new User("kalua");
+      Message result = ctrl.create(user);
+      Assertions.assertEquals(result.status, Message.Status.OK);
     }
 
     @Test
@@ -40,19 +81,100 @@ void withValidInexitingUsername_addUserToDB__FAKE() {
       // TODO
       // Der Test soll prüfen, ob der Benutzer tatsächlich der DB hinzugefügt wurde.
       // Dazu soll ein Database Mock Objekt verwendet werden.
+      MockDatabase database =new MockDatabase();
+      UserController ctrl = new UserController(new FakeUserValidator(false, true), database);
+      User user = new User("peter");
+
+      Message result = ctrl.create(user);
+
+      Assertions.assertEquals(result.status, Message.Status.OK);
+
+
+      boolean doesUserExists = false;
+      for (User u : database.getUsers()){
+        if (u.getUsername().equals("peter")){
+          doesUserExists = true;
+        }
+      }
+      Assertions.assertTrue(doesUserExists);
+
     }
 
     @Test
     void withValidInexitingUsername_addUserToDB__MOCKITO() {
       // TODO
+      UserValidator uv = mock(UserValidator.class);
+      Database db = mock(Database.class);
+      UserController ctrl = new UserController(uv, db);
+      User user = new User("kalua");
+      User user2 = new User("peter");
+
+      doReturn(true).when(uv).isValidUsername(anyString());
+      doReturn(false).when(uv).doesUsernameExist(anyString());
+      db.addUser(user);
+
+
+//überpüft wieviel mal der User auf der Datenbank registriert wurde
+      verify(db, times(1)).addUser(any(User.class));
+
+      }
+
+      @Test
+      void withValidInexistingUsername_addUser2xToDB__MOCKITO(){
+        UserValidator uv = mock(UserValidator.class);
+        Database db = mock(Database.class);
+        UserController ctrl = new UserController(uv, db);
+        User user = new User("kalua");
+        User user2 = new User("peter");
+
+        doReturn(true).when(uv).isValidUsername(anyString());
+        doReturn(false).when(uv).doesUsernameExist(anyString());
+        db.addUser(user);
+        db.addUser(user2);
+
+
+        verify(db, times(2)).addUser(any(User.class));
+
+
+      }
+      @Test
+       void withValidInexistingUsername_addUser2xToDBSameUser__MOCKITO() {
+      UserValidator uv = mock(UserValidator.class);
+      UserValidator uv2 = mock(UserValidator.class);
+      Database db = mock(Database.class);
+      UserController ctrl = new UserController(uv, db);
+      UserController ctrl2 = new UserController(uv2, db);
+      User user = new User("kalua");
+
+        doReturn(true).when(uv).isValidUsername(anyString());
+        doReturn(false).when(uv).doesUsernameExist(anyString());
+
+        Message result = ctrl.create(user);
+
+       Assertions.assertEquals(result.status, Message.Status.OK);
+
+
+      doReturn(true).when(uv2).isValidUsername(anyString());
+      doReturn(true).when(uv2).doesUsernameExist(anyString());
+
+      Message result2 = ctrl2.create(user);
+      Assertions.assertEquals(result2.status, Message.Status.NOT_OK);
+
+
+      verify(db, times(1)).addUser(any(User.class));
+
     }
 
+
+
+
+
     // --- Testing Exceptions ---
 
     @Test
     void TRY_CATCH_withNullUser_throwsIllegalArgumentExc() {
       try {
-        UserController ctrl = new UserController();
+        UserController ctrl = new UserController(new FakeUserValidator());
         ctrl.create(null);
         Assertions.fail("No IllegalArgumentException was thrown");
       } catch (IllegalArgumentException ex) {
@@ -64,7 +186,7 @@ void TRY_CATCH_withNullUser_throwsIllegalArgumentExc() {
     @Test
     void THROWN_withNullUser_throwsIllegalArgumentException() {
       Assertions.assertThrows(IllegalArgumentException.class, () -> {
-        UserController ctrl = new UserController();
+        UserController ctrl = new UserController(new FakeUserValidator());
         ctrl.create(null);
       });
     }
@@ -72,7 +194,7 @@ void THROWN_withNullUser_throwsIllegalArgumentException() {
     @Test
     void THROWN_MESSAGE_withNullUser_throwsIllegalArgumentExceptionWithMessage() {
       Exception thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> {
-        UserController ctrl = new UserController();
+        UserController ctrl = new UserController(new FakeUserValidator());
         ctrl.create(null);
       });
       Assertions.assertTrue(thrown.getMessage().contains("required"));
diff --git a/src/test/java/fakes/UserValidatorTest.java b/src/test/java/fakes/UserValidatorTest.java
index 4cffc57..c1b7aaa 100644
--- a/src/test/java/fakes/UserValidatorTest.java
+++ b/src/test/java/fakes/UserValidatorTest.java
@@ -1,49 +1,91 @@
 package fakes;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+import java.util.Locale;
+
+import static org.mockito.Mockito.mock;
+
 class UserValidatorTest {
 
     @Nested
-    class isValidUsername{
+    class isValidUsername {
 
         @Test
-        void returnsTrueIfOnlyLetters(){
-            throw new IllegalArgumentException("you should implement code here");
+        void returnsTrueIfOnlyLetters() {
+            UserValidator validator = new UserValidator();
+            boolean validName = validator.isValidUsername("Claudia");
+            Assertions.assertTrue(validName);
         }
 
         @Test
-        void returnsFalseIfStartsWithNumber(){
-            throw new IllegalArgumentException("you should implement code here");
+        void returnsFalseIfStartsWithNumber() {
+            UserValidator validator = new UserValidator();
+            boolean validName = validator.isValidUsername("1Claudia");
+            Assertions.assertFalse(validName);
         }
 
         @Test
-        void returnsTrueIfContainsNumberButNotAsFirstChar(){
-            throw new IllegalArgumentException("you should implement code here");
+        void returnsTrueIfContainsNumberButNotAsFirstChar() {
+            UserValidator validator = new UserValidator();
+            boolean validName = validator.isValidUsername("c2a3dia");
+            Assertions.assertTrue(validName);
         }
 
         @Test
-        void returnsFalseIfContainsAnyNonAlphanumericChar(){
-            throw new IllegalArgumentException("you should implement code here");
+        void returnsFalseIfContainsAnyNonAlphanumericChar() {
+            UserValidator validator = new UserValidator();
+            boolean validName = validator.isValidUsername("%inprozent");
+            Assertions.assertFalse(validName);
         }
     }
 
-    static class doesUsernameExist{
+    static class doesUsernameExist {
 
         @Test
-        void returnsFalseIfUsernameNotInDBYet(){
-            throw new IllegalArgumentException("you should implement code here");
+        void returnsFalseIfUsernameNotInDBYet() {
+            Database mockDatabase = mock(Database.class);
+
+            final UserValidator uv = new UserValidator();
+            final boolean usernameExist = uv.doesUsernameExist("peter");
+            Assertions.assertFalse(usernameExist);
         }
 
+
         @Test
-        void returnsTrueIfUsernameInDB(){
-            throw new IllegalArgumentException("you should implement code here");
+        void returnsTrueIfUsernameInDB() {
+            Database db = new MockDatabase();
+            User user = new User("hans");
+            db.addUser(user);
+            boolean result = false;
+
+            for (User u : db.getUsers()){
+                if (u.getUsername().equals(user.getUsername())){
+                     result = true;
+                }
+            }
+
+            Assertions.assertTrue(result);
+
+
         }
 
         @Test
-        void returnsTrueIfSameNameInDBButWithDifferentLetterCasing(){
-            throw new IllegalArgumentException("you should implement code here");
+        void returnsTrueIfSameNameInDBButWithDifferentLetterCasing() {
+            User user = new User("PETER");
+
+            boolean result = false;
+            Database db = FileDatabase.getInstance();
+            for(User u : db.getUsers()){
+                if (u.getUsername().toLowerCase(Locale.ROOT).equals(user.getUsername().toLowerCase(Locale.ROOT))){
+                    result = true;
+                }
+            }
+            Assertions.assertTrue(result);
+
         }
     }
 }