diff --git a/enzevalos_iphone.xcodeproj/project.pbxproj b/enzevalos_iphone.xcodeproj/project.pbxproj
index fdd80f437b051fdf13d25afa465cdcd703c504b0..c0e8dd4a6209a67b7b917ced0f567ea16d4f8152 100644
--- a/enzevalos_iphone.xcodeproj/project.pbxproj
+++ b/enzevalos_iphone.xcodeproj/project.pbxproj
@@ -143,6 +143,8 @@
 		47EABF0A241A9C8700774A93 /* AuthenticationViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 47EABF07241A9C8700774A93 /* AuthenticationViewModel.swift */; };
 		47EABF0B241A9C8700774A93 /* AuthenticationScreen.swift in Sources */ = {isa = PBXBuildFile; fileRef = 47EABF08241A9C8700774A93 /* AuthenticationScreen.swift */; };
 		47EABF0D241A9CA800774A93 /* MailAccount.swift in Sources */ = {isa = PBXBuildFile; fileRef = 47EABF0C241A9CA800774A93 /* MailAccount.swift */; };
+		47EABF0E2420C63600774A93 /* GeneratedMocks.swift in Sources */ = {isa = PBXBuildFile; fileRef = 97C527A0241AA4090030BBC9 /* GeneratedMocks.swift */; };
+		47EABF0F2420C63600774A93 /* AuthenticationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 97C5279E241A9F7B0030BBC9 /* AuthenticationTests.swift */; };
 		47F0376E22A7278A0005C9DE /* accounts.json in Resources */ = {isa = PBXBuildFile; fileRef = 47F0376D22A7278A0005C9DE /* accounts.json */; };
 		47F79240203492E3005E7DB6 /* KeyRecord+CoreDataClass.swift in Sources */ = {isa = PBXBuildFile; fileRef = 47F7923E203492E3005E7DB6 /* KeyRecord+CoreDataClass.swift */; };
 		47F79241203492E3005E7DB6 /* KeyRecord+CoreDataProperties.swift in Sources */ = {isa = PBXBuildFile; fileRef = 47F7923F203492E3005E7DB6 /* KeyRecord+CoreDataProperties.swift */; };
@@ -576,6 +578,8 @@
 		94EE54279AB591E0CAB8EFD8 /* Pods_enzevalos_iphone.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_enzevalos_iphone.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		9771AA8B241161190023A096 /* MailAccount.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MailAccount.swift; sourceTree = "<group>"; };
 		97AACD2324178C230078A68E /* AuthenticationModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AuthenticationModel.swift; sourceTree = "<group>"; };
+		97C5279E241A9F7B0030BBC9 /* AuthenticationTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AuthenticationTests.swift; sourceTree = "<group>"; };
+		97C527A0241AA4090030BBC9 /* GeneratedMocks.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; name = GeneratedMocks.swift; path = enzevalos_iphoneTests/GeneratedMocks.swift; sourceTree = SOURCE_ROOT; };
 		988C9C5C240D507A006213F0 /* PhishingTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PhishingTests.swift; sourceTree = "<group>"; };
 		9A132EDE8BCA06ACDB505C22 /* Pods-enzevalos_iphoneUITests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-enzevalos_iphoneUITests.debug.xcconfig"; path = "../enzevalos_iphone_workspace/Pods/Target Support Files/Pods-enzevalos_iphoneUITests/Pods-enzevalos_iphoneUITests.debug.xcconfig"; sourceTree = "<group>"; };
 		9B3D62838C729BAC6832270A /* Pods-enzevalos_iphone-AdHoc.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-enzevalos_iphone-AdHoc.debug.xcconfig"; path = "../enzevalos_iphone_workspace/Pods/Target Support Files/Pods-enzevalos_iphone-AdHoc/Pods-enzevalos_iphone-AdHoc.debug.xcconfig"; sourceTree = "<group>"; };
@@ -1237,6 +1241,15 @@
 			name = Data;
 			sourceTree = "<group>";
 		};
+		97C5279D241A9F690030BBC9 /* authentication */ = {
+			isa = PBXGroup;
+			children = (
+				97C527A0241AA4090030BBC9 /* GeneratedMocks.swift */,
+				97C5279E241A9F7B0030BBC9 /* AuthenticationTests.swift */,
+			);
+			path = authentication;
+			sourceTree = "<group>";
+		};
 		A10DE41E1EFAA140005E8189 /* folders */ = {
 			isa = PBXGroup;
 			children = (
@@ -1350,6 +1363,8 @@
 			isa = PBXGroup;
 			children = (
 				71497EC1240FF7FC00B6210F /* phishing */,
+				97C5279D241A9F690030BBC9 /* authentication */,
+				988C9C5C240D507A006213F0 /* PhishingTests.swift */,
 				47F0376C22A7278A0005C9DE /* private */,
 				470709202189C24800DF71A3 /* testKeys */,
 				470709112189BB4A00DF71A3 /* testMails */,
@@ -1626,9 +1641,11 @@
 			buildConfigurationList = A13526A31D955BE000D3BFE1 /* Build configuration list for PBXNativeTarget "enzevalos_iphoneTests" */;
 			buildPhases = (
 				D6F0EB205D61EA8C8A045390 /* [CP] Check Pods Manifest.lock */,
+				47EABF01241A99DA00774A93 /* Cockoo run script */,
 				A13526881D955BE000D3BFE1 /* Sources */,
 				A13526891D955BE000D3BFE1 /* Frameworks */,
 				A135268A1D955BE000D3BFE1 /* Resources */,
+				0811D368D52F1D9B243500D4 /* [CP] Embed Pods Frameworks */,
 			);
 			buildRules = (
 			);
@@ -1800,6 +1817,24 @@
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXShellScriptBuildPhase section */
+		0811D368D52F1D9B243500D4 /* [CP] Embed Pods Frameworks */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-enzevalos_iphoneTests/Pods-enzevalos_iphoneTests-frameworks.sh",
+				"${BUILT_PRODUCTS_DIR}/Cuckoo/Cuckoo.framework",
+			);
+			name = "[CP] Embed Pods Frameworks";
+			outputPaths = (
+				"${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/Cuckoo.framework",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-enzevalos_iphoneTests/Pods-enzevalos_iphoneTests-frameworks.sh\"\n";
+			showEnvVarsInLog = 0;
+		};
 		3992B0CB6412E8526773B814 /* [CP] Embed Pods Frameworks */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
@@ -1836,6 +1871,24 @@
 			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-enzevalos_iphone/Pods-enzevalos_iphone-frameworks.sh\"\n";
 			showEnvVarsInLog = 0;
 		};
+		47EABF01241A99DA00774A93 /* Cockoo run script */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+			);
+			name = "Cockoo run script";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "# Define output file. Change \"${PROJECT_DIR}/${PROJECT_NAME}Tests\" to your test's root source folder, if it's not the default name.\nOUTPUT_FILE=\"${PROJECT_DIR}/${PROJECT_NAME}Tests/GeneratedMocks.swift\"\necho \"Generated Mocks File = ${OUTPUT_FILE}\"\n\n# Define input directory. Change \"${PROJECT_DIR}/${PROJECT_NAME}\" to your project's root source folder, if it's not the default name.\nINPUT_DIR=\"${PROJECT_DIR}/${PROJECT_NAME}\"\necho \"Mocks Input Directory = ${INPUT_DIR}\"\n\n# Generate mock files, include as many input files as you'd like to create mocks for.\n\"${PODS_ROOT}/Cuckoo/run\" generate --testable \"${PROJECT_NAME}\" \\\n--output \"${OUTPUT_FILE}\" \\\n\"${INPUT_DIR}/AuthenticationModel.swift\" \\\n\"${INPUT_DIR}/AuthenticationViewModel.swift\" \n# ... and so forth, the last line should never end with a backslash\n\n# After running once, locate `GeneratedMocks.swift` and drag it into your Xcode test target group.\n";
+		};
 		47F867E52052B4B500AA832F /* ShellScript */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 8;
@@ -2090,10 +2143,12 @@
 				71497EC3240FF82700B6210F /* MailComparisonTests.swift in Sources */,
 				479B5977206914BE00B3944D /* CryptoTests.swift in Sources */,
 				A15D215F223BE6E4003E0CE0 /* MailTest.swift in Sources */,
+				47EABF0F2420C63600774A93 /* AuthenticationTests.swift in Sources */,
 				988C9C5D240D507A006213F0 /* PhishingTests.swift in Sources */,
 				4715F637202A0248001BFFD0 /* CoreDataTests.swift in Sources */,
 				47C22281218AFD6300BD2C2B /* AutocryptTest.swift in Sources */,
 				478154AE2200641900A931EC /* StudyTest.swift in Sources */,
+				47EABF0E2420C63600774A93 /* GeneratedMocks.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
diff --git a/enzevalos_iphoneTests/GeneratedMocks.swift b/enzevalos_iphoneTests/GeneratedMocks.swift
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..db5f7320ce0fa90b95bef8aa82efccd6b6b5fa41 100644
--- a/enzevalos_iphoneTests/GeneratedMocks.swift
+++ b/enzevalos_iphoneTests/GeneratedMocks.swift
@@ -0,0 +1,1086 @@
+// MARK: - Mocks generated from file: enzevalos_iphone/AuthenticationModel.swift at 2020-03-18 10:30:41 +0000
+
+//
+//  AuthenticationModel.swift
+//  enzevalos_iphone
+//
+//  Created by SWP Usable Security für Smartphones on 10.03.20.
+//  Copyright © 2020 fu-berlin. All rights reserved.
+//
+import Cuckoo
+@testable import enzevalos_iphone
+
+import Combine
+import Foundation
+
+
+ class MockAuthenticationModel: AuthenticationModel, Cuckoo.ClassMock {
+    
+     typealias MocksType = AuthenticationModel
+    
+     typealias Stubbing = __StubbingProxy_AuthenticationModel
+     typealias Verification = __VerificationProxy_AuthenticationModel
+
+     let cuckoo_manager = Cuckoo.MockManager.preconfiguredManager ?? Cuckoo.MockManager(hasParent: true)
+
+    
+    private var __defaultImplStub: AuthenticationModel?
+
+     func enableDefaultImplementation(_ stub: AuthenticationModel) {
+        __defaultImplStub = stub
+        cuckoo_manager.enableDefaultStubImplementation()
+    }
+    
+
+    
+    
+    
+     override var extendedValidation: Bool {
+        get {
+            return cuckoo_manager.getter("extendedValidation",
+                superclassCall:
+                    
+                    super.extendedValidation
+                    ,
+                defaultCall: __defaultImplStub!.extendedValidation)
+        }
+        
+        set {
+            cuckoo_manager.setter("extendedValidation",
+                value: newValue,
+                superclassCall:
+                    
+                    super.extendedValidation = newValue
+                    ,
+                defaultCall: __defaultImplStub!.extendedValidation = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var imapCallback: AuthenticationCallback? {
+        get {
+            return cuckoo_manager.getter("imapCallback",
+                superclassCall:
+                    
+                    super.imapCallback
+                    ,
+                defaultCall: __defaultImplStub!.imapCallback)
+        }
+        
+        set {
+            cuckoo_manager.setter("imapCallback",
+                value: newValue,
+                superclassCall:
+                    
+                    super.imapCallback = newValue
+                    ,
+                defaultCall: __defaultImplStub!.imapCallback = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var smtpCallback: AuthenticationCallback? {
+        get {
+            return cuckoo_manager.getter("smtpCallback",
+                superclassCall:
+                    
+                    super.smtpCallback
+                    ,
+                defaultCall: __defaultImplStub!.smtpCallback)
+        }
+        
+        set {
+            cuckoo_manager.setter("smtpCallback",
+                value: newValue,
+                superclassCall:
+                    
+                    super.smtpCallback = newValue
+                    ,
+                defaultCall: __defaultImplStub!.smtpCallback = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var imapConfigurationSuccessful: Bool {
+        get {
+            return cuckoo_manager.getter("imapConfigurationSuccessful",
+                superclassCall:
+                    
+                    super.imapConfigurationSuccessful
+                    ,
+                defaultCall: __defaultImplStub!.imapConfigurationSuccessful)
+        }
+        
+        set {
+            cuckoo_manager.setter("imapConfigurationSuccessful",
+                value: newValue,
+                superclassCall:
+                    
+                    super.imapConfigurationSuccessful = newValue
+                    ,
+                defaultCall: __defaultImplStub!.imapConfigurationSuccessful = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var smtpConfigurationSuccessful: Bool {
+        get {
+            return cuckoo_manager.getter("smtpConfigurationSuccessful",
+                superclassCall:
+                    
+                    super.smtpConfigurationSuccessful
+                    ,
+                defaultCall: __defaultImplStub!.smtpConfigurationSuccessful)
+        }
+        
+        set {
+            cuckoo_manager.setter("smtpConfigurationSuccessful",
+                value: newValue,
+                superclassCall:
+                    
+                    super.smtpConfigurationSuccessful = newValue
+                    ,
+                defaultCall: __defaultImplStub!.smtpConfigurationSuccessful = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var dispatchGroup: DispatchGroup {
+        get {
+            return cuckoo_manager.getter("dispatchGroup",
+                superclassCall:
+                    
+                    super.dispatchGroup
+                    ,
+                defaultCall: __defaultImplStub!.dispatchGroup)
+        }
+        
+        set {
+            cuckoo_manager.setter("dispatchGroup",
+                value: newValue,
+                superclassCall:
+                    
+                    super.dispatchGroup = newValue
+                    ,
+                defaultCall: __defaultImplStub!.dispatchGroup = newValue)
+        }
+        
+    }
+    
+
+    
+
+    
+    
+    
+     override func checkConfig(mailAccount: MailAccount, extendedValidation: Bool) -> Future<AuthenticationResult, Never> {
+        
+    return cuckoo_manager.call("checkConfig(mailAccount: MailAccount, extendedValidation: Bool) -> Future<AuthenticationResult, Never>",
+            parameters: (mailAccount, extendedValidation),
+            escapingParameters: (mailAccount, extendedValidation),
+            superclassCall:
+                
+                super.checkConfig(mailAccount: mailAccount, extendedValidation: extendedValidation)
+                ,
+            defaultCall: __defaultImplStub!.checkConfig(mailAccount: mailAccount, extendedValidation: extendedValidation))
+        
+    }
+    
+    
+    
+     override func checkIMAPConfig(mailAccount: MailAccount, _ callback: AuthenticationCallback)  {
+        
+    return cuckoo_manager.call("checkIMAPConfig(mailAccount: MailAccount, _: AuthenticationCallback)",
+            parameters: (mailAccount, callback),
+            escapingParameters: (mailAccount, callback),
+            superclassCall:
+                
+                super.checkIMAPConfig(mailAccount: mailAccount, callback)
+                ,
+            defaultCall: __defaultImplStub!.checkIMAPConfig(mailAccount: mailAccount, callback))
+        
+    }
+    
+    
+    
+     override func checkSMTPConfig(mailAccount: MailAccount, _ callback: AuthenticationCallback)  {
+        
+    return cuckoo_manager.call("checkSMTPConfig(mailAccount: MailAccount, _: AuthenticationCallback)",
+            parameters: (mailAccount, callback),
+            escapingParameters: (mailAccount, callback),
+            superclassCall:
+                
+                super.checkSMTPConfig(mailAccount: mailAccount, callback)
+                ,
+            defaultCall: __defaultImplStub!.checkSMTPConfig(mailAccount: mailAccount, callback))
+        
+    }
+    
+    
+    
+     override func onTimeout(timeoutResult: DispatchTimeoutResult) -> AuthenticationResult {
+        
+    return cuckoo_manager.call("onTimeout(timeoutResult: DispatchTimeoutResult) -> AuthenticationResult",
+            parameters: (timeoutResult),
+            escapingParameters: (timeoutResult),
+            superclassCall:
+                
+                super.onTimeout(timeoutResult: timeoutResult)
+                ,
+            defaultCall: __defaultImplStub!.onTimeout(timeoutResult: timeoutResult))
+        
+    }
+    
+    
+    
+     override func onImapCompleted(imapWorks: Bool, _ login: String, _ password: String)  {
+        
+    return cuckoo_manager.call("onImapCompleted(imapWorks: Bool, _: String, _: String)",
+            parameters: (imapWorks, login, password),
+            escapingParameters: (imapWorks, login, password),
+            superclassCall:
+                
+                super.onImapCompleted(imapWorks: imapWorks, login, password)
+                ,
+            defaultCall: __defaultImplStub!.onImapCompleted(imapWorks: imapWorks, login, password))
+        
+    }
+    
+    
+    
+     override func onSmtpCompleted(smtpWorks: Bool, _ login: String, _ password: String)  {
+        
+    return cuckoo_manager.call("onSmtpCompleted(smtpWorks: Bool, _: String, _: String)",
+            parameters: (smtpWorks, login, password),
+            escapingParameters: (smtpWorks, login, password),
+            superclassCall:
+                
+                super.onSmtpCompleted(smtpWorks: smtpWorks, login, password)
+                ,
+            defaultCall: __defaultImplStub!.onSmtpCompleted(smtpWorks: smtpWorks, login, password))
+        
+    }
+    
+
+	 struct __StubbingProxy_AuthenticationModel: Cuckoo.StubbingProxy {
+	    private let cuckoo_manager: Cuckoo.MockManager
+	
+	     init(manager: Cuckoo.MockManager) {
+	        self.cuckoo_manager = manager
+	    }
+	    
+	    
+	    var extendedValidation: Cuckoo.ClassToBeStubbedProperty<MockAuthenticationModel, Bool> {
+	        return .init(manager: cuckoo_manager, name: "extendedValidation")
+	    }
+	    
+	    
+	    var imapCallback: Cuckoo.ClassToBeStubbedOptionalProperty<MockAuthenticationModel, AuthenticationCallback> {
+	        return .init(manager: cuckoo_manager, name: "imapCallback")
+	    }
+	    
+	    
+	    var smtpCallback: Cuckoo.ClassToBeStubbedOptionalProperty<MockAuthenticationModel, AuthenticationCallback> {
+	        return .init(manager: cuckoo_manager, name: "smtpCallback")
+	    }
+	    
+	    
+	    var imapConfigurationSuccessful: Cuckoo.ClassToBeStubbedProperty<MockAuthenticationModel, Bool> {
+	        return .init(manager: cuckoo_manager, name: "imapConfigurationSuccessful")
+	    }
+	    
+	    
+	    var smtpConfigurationSuccessful: Cuckoo.ClassToBeStubbedProperty<MockAuthenticationModel, Bool> {
+	        return .init(manager: cuckoo_manager, name: "smtpConfigurationSuccessful")
+	    }
+	    
+	    
+	    var dispatchGroup: Cuckoo.ClassToBeStubbedProperty<MockAuthenticationModel, DispatchGroup> {
+	        return .init(manager: cuckoo_manager, name: "dispatchGroup")
+	    }
+	    
+	    
+	    func checkConfig<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(mailAccount: M1, extendedValidation: M2) -> Cuckoo.ClassStubFunction<(MailAccount, Bool), Future<AuthenticationResult, Never>> where M1.MatchedType == MailAccount, M2.MatchedType == Bool {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailAccount, Bool)>] = [wrap(matchable: mailAccount) { $0.0 }, wrap(matchable: extendedValidation) { $0.1 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationModel.self, method: "checkConfig(mailAccount: MailAccount, extendedValidation: Bool) -> Future<AuthenticationResult, Never>", parameterMatchers: matchers))
+	    }
+	    
+	    func checkIMAPConfig<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(mailAccount: M1, _ callback: M2) -> Cuckoo.ClassStubNoReturnFunction<(MailAccount, AuthenticationCallback)> where M1.MatchedType == MailAccount, M2.MatchedType == AuthenticationCallback {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailAccount, AuthenticationCallback)>] = [wrap(matchable: mailAccount) { $0.0 }, wrap(matchable: callback) { $0.1 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationModel.self, method: "checkIMAPConfig(mailAccount: MailAccount, _: AuthenticationCallback)", parameterMatchers: matchers))
+	    }
+	    
+	    func checkSMTPConfig<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(mailAccount: M1, _ callback: M2) -> Cuckoo.ClassStubNoReturnFunction<(MailAccount, AuthenticationCallback)> where M1.MatchedType == MailAccount, M2.MatchedType == AuthenticationCallback {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailAccount, AuthenticationCallback)>] = [wrap(matchable: mailAccount) { $0.0 }, wrap(matchable: callback) { $0.1 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationModel.self, method: "checkSMTPConfig(mailAccount: MailAccount, _: AuthenticationCallback)", parameterMatchers: matchers))
+	    }
+	    
+	    func onTimeout<M1: Cuckoo.Matchable>(timeoutResult: M1) -> Cuckoo.ClassStubFunction<(DispatchTimeoutResult), AuthenticationResult> where M1.MatchedType == DispatchTimeoutResult {
+	        let matchers: [Cuckoo.ParameterMatcher<(DispatchTimeoutResult)>] = [wrap(matchable: timeoutResult) { $0 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationModel.self, method: "onTimeout(timeoutResult: DispatchTimeoutResult) -> AuthenticationResult", parameterMatchers: matchers))
+	    }
+	    
+	    func onImapCompleted<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable>(imapWorks: M1, _ login: M2, _ password: M3) -> Cuckoo.ClassStubNoReturnFunction<(Bool, String, String)> where M1.MatchedType == Bool, M2.MatchedType == String, M3.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(Bool, String, String)>] = [wrap(matchable: imapWorks) { $0.0 }, wrap(matchable: login) { $0.1 }, wrap(matchable: password) { $0.2 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationModel.self, method: "onImapCompleted(imapWorks: Bool, _: String, _: String)", parameterMatchers: matchers))
+	    }
+	    
+	    func onSmtpCompleted<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable>(smtpWorks: M1, _ login: M2, _ password: M3) -> Cuckoo.ClassStubNoReturnFunction<(Bool, String, String)> where M1.MatchedType == Bool, M2.MatchedType == String, M3.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(Bool, String, String)>] = [wrap(matchable: smtpWorks) { $0.0 }, wrap(matchable: login) { $0.1 }, wrap(matchable: password) { $0.2 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationModel.self, method: "onSmtpCompleted(smtpWorks: Bool, _: String, _: String)", parameterMatchers: matchers))
+	    }
+	    
+	}
+
+	 struct __VerificationProxy_AuthenticationModel: Cuckoo.VerificationProxy {
+	    private let cuckoo_manager: Cuckoo.MockManager
+	    private let callMatcher: Cuckoo.CallMatcher
+	    private let sourceLocation: Cuckoo.SourceLocation
+	
+	     init(manager: Cuckoo.MockManager, callMatcher: Cuckoo.CallMatcher, sourceLocation: Cuckoo.SourceLocation) {
+	        self.cuckoo_manager = manager
+	        self.callMatcher = callMatcher
+	        self.sourceLocation = sourceLocation
+	    }
+	
+	    
+	    
+	    var extendedValidation: Cuckoo.VerifyProperty<Bool> {
+	        return .init(manager: cuckoo_manager, name: "extendedValidation", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var imapCallback: Cuckoo.VerifyOptionalProperty<AuthenticationCallback> {
+	        return .init(manager: cuckoo_manager, name: "imapCallback", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var smtpCallback: Cuckoo.VerifyOptionalProperty<AuthenticationCallback> {
+	        return .init(manager: cuckoo_manager, name: "smtpCallback", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var imapConfigurationSuccessful: Cuckoo.VerifyProperty<Bool> {
+	        return .init(manager: cuckoo_manager, name: "imapConfigurationSuccessful", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var smtpConfigurationSuccessful: Cuckoo.VerifyProperty<Bool> {
+	        return .init(manager: cuckoo_manager, name: "smtpConfigurationSuccessful", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var dispatchGroup: Cuckoo.VerifyProperty<DispatchGroup> {
+	        return .init(manager: cuckoo_manager, name: "dispatchGroup", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	
+	    
+	    @discardableResult
+	    func checkConfig<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(mailAccount: M1, extendedValidation: M2) -> Cuckoo.__DoNotUse<(MailAccount, Bool), Future<AuthenticationResult, Never>> where M1.MatchedType == MailAccount, M2.MatchedType == Bool {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailAccount, Bool)>] = [wrap(matchable: mailAccount) { $0.0 }, wrap(matchable: extendedValidation) { $0.1 }]
+	        return cuckoo_manager.verify("checkConfig(mailAccount: MailAccount, extendedValidation: Bool) -> Future<AuthenticationResult, Never>", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func checkIMAPConfig<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(mailAccount: M1, _ callback: M2) -> Cuckoo.__DoNotUse<(MailAccount, AuthenticationCallback), Void> where M1.MatchedType == MailAccount, M2.MatchedType == AuthenticationCallback {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailAccount, AuthenticationCallback)>] = [wrap(matchable: mailAccount) { $0.0 }, wrap(matchable: callback) { $0.1 }]
+	        return cuckoo_manager.verify("checkIMAPConfig(mailAccount: MailAccount, _: AuthenticationCallback)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func checkSMTPConfig<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(mailAccount: M1, _ callback: M2) -> Cuckoo.__DoNotUse<(MailAccount, AuthenticationCallback), Void> where M1.MatchedType == MailAccount, M2.MatchedType == AuthenticationCallback {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailAccount, AuthenticationCallback)>] = [wrap(matchable: mailAccount) { $0.0 }, wrap(matchable: callback) { $0.1 }]
+	        return cuckoo_manager.verify("checkSMTPConfig(mailAccount: MailAccount, _: AuthenticationCallback)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func onTimeout<M1: Cuckoo.Matchable>(timeoutResult: M1) -> Cuckoo.__DoNotUse<(DispatchTimeoutResult), AuthenticationResult> where M1.MatchedType == DispatchTimeoutResult {
+	        let matchers: [Cuckoo.ParameterMatcher<(DispatchTimeoutResult)>] = [wrap(matchable: timeoutResult) { $0 }]
+	        return cuckoo_manager.verify("onTimeout(timeoutResult: DispatchTimeoutResult) -> AuthenticationResult", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func onImapCompleted<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable>(imapWorks: M1, _ login: M2, _ password: M3) -> Cuckoo.__DoNotUse<(Bool, String, String), Void> where M1.MatchedType == Bool, M2.MatchedType == String, M3.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(Bool, String, String)>] = [wrap(matchable: imapWorks) { $0.0 }, wrap(matchable: login) { $0.1 }, wrap(matchable: password) { $0.2 }]
+	        return cuckoo_manager.verify("onImapCompleted(imapWorks: Bool, _: String, _: String)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func onSmtpCompleted<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable>(smtpWorks: M1, _ login: M2, _ password: M3) -> Cuckoo.__DoNotUse<(Bool, String, String), Void> where M1.MatchedType == Bool, M2.MatchedType == String, M3.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(Bool, String, String)>] = [wrap(matchable: smtpWorks) { $0.0 }, wrap(matchable: login) { $0.1 }, wrap(matchable: password) { $0.2 }]
+	        return cuckoo_manager.verify("onSmtpCompleted(smtpWorks: Bool, _: String, _: String)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	}
+}
+
+ class AuthenticationModelStub: AuthenticationModel {
+    
+    
+     override var extendedValidation: Bool {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (Bool).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var imapCallback: AuthenticationCallback? {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (AuthenticationCallback?).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var smtpCallback: AuthenticationCallback? {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (AuthenticationCallback?).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var imapConfigurationSuccessful: Bool {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (Bool).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var smtpConfigurationSuccessful: Bool {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (Bool).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var dispatchGroup: DispatchGroup {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (DispatchGroup).self)
+        }
+        
+        set { }
+        
+    }
+    
+
+    
+
+    
+     override func checkConfig(mailAccount: MailAccount, extendedValidation: Bool) -> Future<AuthenticationResult, Never>  {
+        return DefaultValueRegistry.defaultValue(for: (Future<AuthenticationResult, Never>).self)
+    }
+    
+     override func checkIMAPConfig(mailAccount: MailAccount, _ callback: AuthenticationCallback)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func checkSMTPConfig(mailAccount: MailAccount, _ callback: AuthenticationCallback)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func onTimeout(timeoutResult: DispatchTimeoutResult) -> AuthenticationResult  {
+        return DefaultValueRegistry.defaultValue(for: (AuthenticationResult).self)
+    }
+    
+     override func onImapCompleted(imapWorks: Bool, _ login: String, _ password: String)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func onSmtpCompleted(smtpWorks: Bool, _ login: String, _ password: String)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+}
+
+
+
+ class MockAuthenticationCallback: AuthenticationCallback, Cuckoo.ClassMock {
+    
+     typealias MocksType = AuthenticationCallback
+    
+     typealias Stubbing = __StubbingProxy_AuthenticationCallback
+     typealias Verification = __VerificationProxy_AuthenticationCallback
+
+     let cuckoo_manager = Cuckoo.MockManager.preconfiguredManager ?? Cuckoo.MockManager(hasParent: true)
+
+    
+    private var __defaultImplStub: AuthenticationCallback?
+
+     func enableDefaultImplementation(_ stub: AuthenticationCallback) {
+        __defaultImplStub = stub
+        cuckoo_manager.enableDefaultStubImplementation()
+    }
+    
+
+    
+    
+    
+     override var callback: ((Bool, String, String) -> Void)? {
+        get {
+            return cuckoo_manager.getter("callback",
+                superclassCall:
+                    
+                    super.callback
+                    ,
+                defaultCall: __defaultImplStub!.callback)
+        }
+        
+        set {
+            cuckoo_manager.setter("callback",
+                value: newValue,
+                superclassCall:
+                    
+                    super.callback = newValue
+                    ,
+                defaultCall: __defaultImplStub!.callback = newValue)
+        }
+        
+    }
+    
+
+    
+
+    
+    
+    
+     override func onResult(worked: Bool, login: String, password: String)  {
+        
+    return cuckoo_manager.call("onResult(worked: Bool, login: String, password: String)",
+            parameters: (worked, login, password),
+            escapingParameters: (worked, login, password),
+            superclassCall:
+                
+                super.onResult(worked: worked, login: login, password: password)
+                ,
+            defaultCall: __defaultImplStub!.onResult(worked: worked, login: login, password: password))
+        
+    }
+    
+
+	 struct __StubbingProxy_AuthenticationCallback: Cuckoo.StubbingProxy {
+	    private let cuckoo_manager: Cuckoo.MockManager
+	
+	     init(manager: Cuckoo.MockManager) {
+	        self.cuckoo_manager = manager
+	    }
+	    
+	    
+	    var callback: Cuckoo.ClassToBeStubbedOptionalProperty<MockAuthenticationCallback, ((Bool, String, String) -> Void)> {
+	        return .init(manager: cuckoo_manager, name: "callback")
+	    }
+	    
+	    
+	    func onResult<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable>(worked: M1, login: M2, password: M3) -> Cuckoo.ClassStubNoReturnFunction<(Bool, String, String)> where M1.MatchedType == Bool, M2.MatchedType == String, M3.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(Bool, String, String)>] = [wrap(matchable: worked) { $0.0 }, wrap(matchable: login) { $0.1 }, wrap(matchable: password) { $0.2 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationCallback.self, method: "onResult(worked: Bool, login: String, password: String)", parameterMatchers: matchers))
+	    }
+	    
+	}
+
+	 struct __VerificationProxy_AuthenticationCallback: Cuckoo.VerificationProxy {
+	    private let cuckoo_manager: Cuckoo.MockManager
+	    private let callMatcher: Cuckoo.CallMatcher
+	    private let sourceLocation: Cuckoo.SourceLocation
+	
+	     init(manager: Cuckoo.MockManager, callMatcher: Cuckoo.CallMatcher, sourceLocation: Cuckoo.SourceLocation) {
+	        self.cuckoo_manager = manager
+	        self.callMatcher = callMatcher
+	        self.sourceLocation = sourceLocation
+	    }
+	
+	    
+	    
+	    var callback: Cuckoo.VerifyOptionalProperty<((Bool, String, String) -> Void)> {
+	        return .init(manager: cuckoo_manager, name: "callback", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	
+	    
+	    @discardableResult
+	    func onResult<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable>(worked: M1, login: M2, password: M3) -> Cuckoo.__DoNotUse<(Bool, String, String), Void> where M1.MatchedType == Bool, M2.MatchedType == String, M3.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(Bool, String, String)>] = [wrap(matchable: worked) { $0.0 }, wrap(matchable: login) { $0.1 }, wrap(matchable: password) { $0.2 }]
+	        return cuckoo_manager.verify("onResult(worked: Bool, login: String, password: String)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	}
+}
+
+ class AuthenticationCallbackStub: AuthenticationCallback {
+    
+    
+     override var callback: ((Bool, String, String) -> Void)? {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (((Bool, String, String) -> Void)?).self)
+        }
+        
+        set { }
+        
+    }
+    
+
+    
+
+    
+     override func onResult(worked: Bool, login: String, password: String)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+}
+
+
+// MARK: - Mocks generated from file: enzevalos_iphone/AuthenticationViewModel.swift at 2020-03-18 10:30:41 +0000
+
+//
+//  AuthenticationViewModel.swift
+//  enzevalos_iphone
+//
+//  Created by SWP Usable Security für Smartphones on 02.03.20.
+//  Copyright © 2020 fu-berlin. All rights reserved.
+//
+import Cuckoo
+@testable import enzevalos_iphone
+
+import Combine
+import Foundation
+
+
+ class MockAuthenticationViewModel: AuthenticationViewModel, Cuckoo.ClassMock {
+    
+     typealias MocksType = AuthenticationViewModel
+    
+     typealias Stubbing = __StubbingProxy_AuthenticationViewModel
+     typealias Verification = __VerificationProxy_AuthenticationViewModel
+
+     let cuckoo_manager = Cuckoo.MockManager.preconfiguredManager ?? Cuckoo.MockManager(hasParent: true)
+
+    
+    private var __defaultImplStub: AuthenticationViewModel?
+
+     func enableDefaultImplementation(_ stub: AuthenticationViewModel) {
+        __defaultImplStub = stub
+        cuckoo_manager.enableDefaultStubImplementation()
+    }
+    
+
+    
+    
+    
+     override var errorMessage: String? {
+        get {
+            return cuckoo_manager.getter("errorMessage",
+                superclassCall:
+                    
+                    super.errorMessage
+                    ,
+                defaultCall: __defaultImplStub!.errorMessage)
+        }
+        
+        set {
+            cuckoo_manager.setter("errorMessage",
+                value: newValue,
+                superclassCall:
+                    
+                    super.errorMessage = newValue
+                    ,
+                defaultCall: __defaultImplStub!.errorMessage = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var isDetailedAuthentication: Bool {
+        get {
+            return cuckoo_manager.getter("isDetailedAuthentication",
+                superclassCall:
+                    
+                    super.isDetailedAuthentication
+                    ,
+                defaultCall: __defaultImplStub!.isDetailedAuthentication)
+        }
+        
+        set {
+            cuckoo_manager.setter("isDetailedAuthentication",
+                value: newValue,
+                superclassCall:
+                    
+                    super.isDetailedAuthentication = newValue
+                    ,
+                defaultCall: __defaultImplStub!.isDetailedAuthentication = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var showProgressSpinner: Bool {
+        get {
+            return cuckoo_manager.getter("showProgressSpinner",
+                superclassCall:
+                    
+                    super.showProgressSpinner
+                    ,
+                defaultCall: __defaultImplStub!.showProgressSpinner)
+        }
+        
+        set {
+            cuckoo_manager.setter("showProgressSpinner",
+                value: newValue,
+                superclassCall:
+                    
+                    super.showProgressSpinner = newValue
+                    ,
+                defaultCall: __defaultImplStub!.showProgressSpinner = newValue)
+        }
+        
+    }
+    
+    
+    
+     override var cancellable: AnyCancellable? {
+        get {
+            return cuckoo_manager.getter("cancellable",
+                superclassCall:
+                    
+                    super.cancellable
+                    ,
+                defaultCall: __defaultImplStub!.cancellable)
+        }
+        
+        set {
+            cuckoo_manager.setter("cancellable",
+                value: newValue,
+                superclassCall:
+                    
+                    super.cancellable = newValue
+                    ,
+                defaultCall: __defaultImplStub!.cancellable = newValue)
+        }
+        
+    }
+    
+
+    
+
+    
+    
+    
+     override func validate(_ login: String, _ password: String)  {
+        
+    return cuckoo_manager.call("validate(_: String, _: String)",
+            parameters: (login, password),
+            escapingParameters: (login, password),
+            superclassCall:
+                
+                super.validate(login, password)
+                ,
+            defaultCall: __defaultImplStub!.validate(login, password))
+        
+    }
+    
+    
+    
+     override func detailValidation(_ login: String, _ password: String, _ username: String, _ imapServer: String, _ imapPort: String, _ imapEncryption: Int, _ smtpServer: String, _ smtpPort: String, _ smtpEncryption: Int)  {
+        
+    return cuckoo_manager.call("detailValidation(_: String, _: String, _: String, _: String, _: String, _: Int, _: String, _: String, _: Int)",
+            parameters: (login, password, username, imapServer, imapPort, imapEncryption, smtpServer, smtpPort, smtpEncryption),
+            escapingParameters: (login, password, username, imapServer, imapPort, imapEncryption, smtpServer, smtpPort, smtpEncryption),
+            superclassCall:
+                
+                super.detailValidation(login, password, username, imapServer, imapPort, imapEncryption, smtpServer, smtpPort, smtpEncryption)
+                ,
+            defaultCall: __defaultImplStub!.detailValidation(login, password, username, imapServer, imapPort, imapEncryption, smtpServer, smtpPort, smtpEncryption))
+        
+    }
+    
+    
+    
+     override func startGoogleOauth()  {
+        
+    return cuckoo_manager.call("startGoogleOauth()",
+            parameters: (),
+            escapingParameters: (),
+            superclassCall:
+                
+                super.startGoogleOauth()
+                ,
+            defaultCall: __defaultImplStub!.startGoogleOauth())
+        
+    }
+    
+    
+    
+     override func authenticationSucceed()  {
+        
+    return cuckoo_manager.call("authenticationSucceed()",
+            parameters: (),
+            escapingParameters: (),
+            superclassCall:
+                
+                super.authenticationSucceed()
+                ,
+            defaultCall: __defaultImplStub!.authenticationSucceed())
+        
+    }
+    
+    
+    
+     override func authenticationFailed(error: MailServerConnectionError)  {
+        
+    return cuckoo_manager.call("authenticationFailed(error: MailServerConnectionError)",
+            parameters: (error),
+            escapingParameters: (error),
+            superclassCall:
+                
+                super.authenticationFailed(error: error)
+                ,
+            defaultCall: __defaultImplStub!.authenticationFailed(error: error))
+        
+    }
+    
+    
+    
+     override func timeoutNotification()  {
+        
+    return cuckoo_manager.call("timeoutNotification()",
+            parameters: (),
+            escapingParameters: (),
+            superclassCall:
+                
+                super.timeoutNotification()
+                ,
+            defaultCall: __defaultImplStub!.timeoutNotification())
+        
+    }
+    
+
+	 struct __StubbingProxy_AuthenticationViewModel: Cuckoo.StubbingProxy {
+	    private let cuckoo_manager: Cuckoo.MockManager
+	
+	     init(manager: Cuckoo.MockManager) {
+	        self.cuckoo_manager = manager
+	    }
+	    
+	    
+	    var errorMessage: Cuckoo.ClassToBeStubbedOptionalProperty<MockAuthenticationViewModel, String> {
+	        return .init(manager: cuckoo_manager, name: "errorMessage")
+	    }
+	    
+	    
+	    var isDetailedAuthentication: Cuckoo.ClassToBeStubbedProperty<MockAuthenticationViewModel, Bool> {
+	        return .init(manager: cuckoo_manager, name: "isDetailedAuthentication")
+	    }
+	    
+	    
+	    var showProgressSpinner: Cuckoo.ClassToBeStubbedProperty<MockAuthenticationViewModel, Bool> {
+	        return .init(manager: cuckoo_manager, name: "showProgressSpinner")
+	    }
+	    
+	    
+	    var cancellable: Cuckoo.ClassToBeStubbedOptionalProperty<MockAuthenticationViewModel, AnyCancellable> {
+	        return .init(manager: cuckoo_manager, name: "cancellable")
+	    }
+	    
+	    
+	    func validate<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(_ login: M1, _ password: M2) -> Cuckoo.ClassStubNoReturnFunction<(String, String)> where M1.MatchedType == String, M2.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(String, String)>] = [wrap(matchable: login) { $0.0 }, wrap(matchable: password) { $0.1 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationViewModel.self, method: "validate(_: String, _: String)", parameterMatchers: matchers))
+	    }
+	    
+	    func detailValidation<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable, M4: Cuckoo.Matchable, M5: Cuckoo.Matchable, M6: Cuckoo.Matchable, M7: Cuckoo.Matchable, M8: Cuckoo.Matchable, M9: Cuckoo.Matchable>(_ login: M1, _ password: M2, _ username: M3, _ imapServer: M4, _ imapPort: M5, _ imapEncryption: M6, _ smtpServer: M7, _ smtpPort: M8, _ smtpEncryption: M9) -> Cuckoo.ClassStubNoReturnFunction<(String, String, String, String, String, Int, String, String, Int)> where M1.MatchedType == String, M2.MatchedType == String, M3.MatchedType == String, M4.MatchedType == String, M5.MatchedType == String, M6.MatchedType == Int, M7.MatchedType == String, M8.MatchedType == String, M9.MatchedType == Int {
+	        let matchers: [Cuckoo.ParameterMatcher<(String, String, String, String, String, Int, String, String, Int)>] = [wrap(matchable: login) { $0.0 }, wrap(matchable: password) { $0.1 }, wrap(matchable: username) { $0.2 }, wrap(matchable: imapServer) { $0.3 }, wrap(matchable: imapPort) { $0.4 }, wrap(matchable: imapEncryption) { $0.5 }, wrap(matchable: smtpServer) { $0.6 }, wrap(matchable: smtpPort) { $0.7 }, wrap(matchable: smtpEncryption) { $0.8 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationViewModel.self, method: "detailValidation(_: String, _: String, _: String, _: String, _: String, _: Int, _: String, _: String, _: Int)", parameterMatchers: matchers))
+	    }
+	    
+	    func startGoogleOauth() -> Cuckoo.ClassStubNoReturnFunction<()> {
+	        let matchers: [Cuckoo.ParameterMatcher<Void>] = []
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationViewModel.self, method: "startGoogleOauth()", parameterMatchers: matchers))
+	    }
+	    
+	    func authenticationSucceed() -> Cuckoo.ClassStubNoReturnFunction<()> {
+	        let matchers: [Cuckoo.ParameterMatcher<Void>] = []
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationViewModel.self, method: "authenticationSucceed()", parameterMatchers: matchers))
+	    }
+	    
+	    func authenticationFailed<M1: Cuckoo.Matchable>(error: M1) -> Cuckoo.ClassStubNoReturnFunction<(MailServerConnectionError)> where M1.MatchedType == MailServerConnectionError {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailServerConnectionError)>] = [wrap(matchable: error) { $0 }]
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationViewModel.self, method: "authenticationFailed(error: MailServerConnectionError)", parameterMatchers: matchers))
+	    }
+	    
+	    func timeoutNotification() -> Cuckoo.ClassStubNoReturnFunction<()> {
+	        let matchers: [Cuckoo.ParameterMatcher<Void>] = []
+	        return .init(stub: cuckoo_manager.createStub(for: MockAuthenticationViewModel.self, method: "timeoutNotification()", parameterMatchers: matchers))
+	    }
+	    
+	}
+
+	 struct __VerificationProxy_AuthenticationViewModel: Cuckoo.VerificationProxy {
+	    private let cuckoo_manager: Cuckoo.MockManager
+	    private let callMatcher: Cuckoo.CallMatcher
+	    private let sourceLocation: Cuckoo.SourceLocation
+	
+	     init(manager: Cuckoo.MockManager, callMatcher: Cuckoo.CallMatcher, sourceLocation: Cuckoo.SourceLocation) {
+	        self.cuckoo_manager = manager
+	        self.callMatcher = callMatcher
+	        self.sourceLocation = sourceLocation
+	    }
+	
+	    
+	    
+	    var errorMessage: Cuckoo.VerifyOptionalProperty<String> {
+	        return .init(manager: cuckoo_manager, name: "errorMessage", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var isDetailedAuthentication: Cuckoo.VerifyProperty<Bool> {
+	        return .init(manager: cuckoo_manager, name: "isDetailedAuthentication", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var showProgressSpinner: Cuckoo.VerifyProperty<Bool> {
+	        return .init(manager: cuckoo_manager, name: "showProgressSpinner", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	    
+	    var cancellable: Cuckoo.VerifyOptionalProperty<AnyCancellable> {
+	        return .init(manager: cuckoo_manager, name: "cancellable", callMatcher: callMatcher, sourceLocation: sourceLocation)
+	    }
+	    
+	
+	    
+	    @discardableResult
+	    func validate<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable>(_ login: M1, _ password: M2) -> Cuckoo.__DoNotUse<(String, String), Void> where M1.MatchedType == String, M2.MatchedType == String {
+	        let matchers: [Cuckoo.ParameterMatcher<(String, String)>] = [wrap(matchable: login) { $0.0 }, wrap(matchable: password) { $0.1 }]
+	        return cuckoo_manager.verify("validate(_: String, _: String)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func detailValidation<M1: Cuckoo.Matchable, M2: Cuckoo.Matchable, M3: Cuckoo.Matchable, M4: Cuckoo.Matchable, M5: Cuckoo.Matchable, M6: Cuckoo.Matchable, M7: Cuckoo.Matchable, M8: Cuckoo.Matchable, M9: Cuckoo.Matchable>(_ login: M1, _ password: M2, _ username: M3, _ imapServer: M4, _ imapPort: M5, _ imapEncryption: M6, _ smtpServer: M7, _ smtpPort: M8, _ smtpEncryption: M9) -> Cuckoo.__DoNotUse<(String, String, String, String, String, Int, String, String, Int), Void> where M1.MatchedType == String, M2.MatchedType == String, M3.MatchedType == String, M4.MatchedType == String, M5.MatchedType == String, M6.MatchedType == Int, M7.MatchedType == String, M8.MatchedType == String, M9.MatchedType == Int {
+	        let matchers: [Cuckoo.ParameterMatcher<(String, String, String, String, String, Int, String, String, Int)>] = [wrap(matchable: login) { $0.0 }, wrap(matchable: password) { $0.1 }, wrap(matchable: username) { $0.2 }, wrap(matchable: imapServer) { $0.3 }, wrap(matchable: imapPort) { $0.4 }, wrap(matchable: imapEncryption) { $0.5 }, wrap(matchable: smtpServer) { $0.6 }, wrap(matchable: smtpPort) { $0.7 }, wrap(matchable: smtpEncryption) { $0.8 }]
+	        return cuckoo_manager.verify("detailValidation(_: String, _: String, _: String, _: String, _: String, _: Int, _: String, _: String, _: Int)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func startGoogleOauth() -> Cuckoo.__DoNotUse<(), Void> {
+	        let matchers: [Cuckoo.ParameterMatcher<Void>] = []
+	        return cuckoo_manager.verify("startGoogleOauth()", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func authenticationSucceed() -> Cuckoo.__DoNotUse<(), Void> {
+	        let matchers: [Cuckoo.ParameterMatcher<Void>] = []
+	        return cuckoo_manager.verify("authenticationSucceed()", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func authenticationFailed<M1: Cuckoo.Matchable>(error: M1) -> Cuckoo.__DoNotUse<(MailServerConnectionError), Void> where M1.MatchedType == MailServerConnectionError {
+	        let matchers: [Cuckoo.ParameterMatcher<(MailServerConnectionError)>] = [wrap(matchable: error) { $0 }]
+	        return cuckoo_manager.verify("authenticationFailed(error: MailServerConnectionError)", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	    @discardableResult
+	    func timeoutNotification() -> Cuckoo.__DoNotUse<(), Void> {
+	        let matchers: [Cuckoo.ParameterMatcher<Void>] = []
+	        return cuckoo_manager.verify("timeoutNotification()", callMatcher: callMatcher, parameterMatchers: matchers, sourceLocation: sourceLocation)
+	    }
+	    
+	}
+}
+
+ class AuthenticationViewModelStub: AuthenticationViewModel {
+    
+    
+     override var errorMessage: String? {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (String?).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var isDetailedAuthentication: Bool {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (Bool).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var showProgressSpinner: Bool {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (Bool).self)
+        }
+        
+        set { }
+        
+    }
+    
+    
+     override var cancellable: AnyCancellable? {
+        get {
+            return DefaultValueRegistry.defaultValue(for: (AnyCancellable?).self)
+        }
+        
+        set { }
+        
+    }
+    
+
+    
+
+    
+     override func validate(_ login: String, _ password: String)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func detailValidation(_ login: String, _ password: String, _ username: String, _ imapServer: String, _ imapPort: String, _ imapEncryption: Int, _ smtpServer: String, _ smtpPort: String, _ smtpEncryption: Int)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func startGoogleOauth()   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func authenticationSucceed()   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func authenticationFailed(error: MailServerConnectionError)   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+     override func timeoutNotification()   {
+        return DefaultValueRegistry.defaultValue(for: (Void).self)
+    }
+    
+}
+
diff --git a/enzevalos_iphoneTests/authentication/AuthenticationTests.swift b/enzevalos_iphoneTests/authentication/AuthenticationTests.swift
new file mode 100644
index 0000000000000000000000000000000000000000..46ec9c172820eb352888e6d9e3d4c017ad595b6a
--- /dev/null
+++ b/enzevalos_iphoneTests/authentication/AuthenticationTests.swift
@@ -0,0 +1,109 @@
+//
+//  AuthenticationTests.swift
+//  enzevalos_iphoneTests
+//
+//  Created by Cezary Pilaszewicz on 12.03.20.
+//  Copyright © 2020 fu-berlin. All rights reserved.
+//
+
+import Cuckoo
+import XCTest
+import Combine
+
+@testable import enzevalos_iphone
+class AuthenticationTests: XCTestCase {
+    let login = "test_login"
+    let password = "test_password"
+    let username = "test_uesrname"
+    let imapServer = "test.imap.server.de"
+    let imapPort = 997
+    let imapEncryption = MCOConnectionType.startTLS.rawValue
+    let smtpServer = "test.smtp.server.com"
+    let smtpPort = 1234
+    let smtpEncryption = MCOConnectionType.startTLS.rawValue
+
+    
+    //Test whether correct arguments are passed to the model
+    func testValidate() {
+        let model = MockAuthenticationModel().withEnabledSuperclassSpy()
+        let viewModel = MockAuthenticationViewModel(authenticationModel: model).withEnabledSuperclassSpy()
+        let future: Future<AuthenticationModel.AuthenticationResult, Never> = Future {
+            promise  in promise(.success(AuthenticationModel.AuthenticationResult.Success))
+        }
+        stub(model) { stub in
+            when(stub.checkConfig(mailAccount: any(), extendedValidation: false)).thenReturn(future)
+        }
+        viewModel.validate(self.login, self.password)
+        let argumentCaptor = ArgumentCaptor<MailAccount>()
+        verify(model).checkConfig(mailAccount: argumentCaptor.capture(), extendedValidation: false)
+        let passedMailAccount =  argumentCaptor.value
+        XCTAssertEqual(passedMailAccount?.emailAddress, self.login)
+        XCTAssertEqual(passedMailAccount?.password, self.password)
+    }
+    
+    func testDetailValidate() {
+        let model = MockAuthenticationModel().withEnabledSuperclassSpy()
+        let viewModel = MockAuthenticationViewModel(authenticationModel: model).withEnabledSuperclassSpy()
+        let future: Future<AuthenticationModel.AuthenticationResult, Never> = Future {
+            promise  in promise(.success(AuthenticationModel.AuthenticationResult.Success))
+        }
+        stub(model) { stub in
+            when(stub.checkConfig(mailAccount: any(), extendedValidation: true)).thenReturn(future)
+        }
+        viewModel.detailValidation(login, password, username, imapServer, String(imapPort), imapEncryption, smtpServer, String(smtpPort), smtpEncryption)
+        let argumentCaptor = ArgumentCaptor<MailAccount>()
+        verify(model).checkConfig(mailAccount: argumentCaptor.capture(), extendedValidation: true)
+        let passedMailAccount =  argumentCaptor.value
+        XCTAssertEqual(passedMailAccount?.emailAddress, self.login)
+        XCTAssertEqual(passedMailAccount?.password, self.password)
+        XCTAssertEqual(passedMailAccount?.username, self.username)
+        XCTAssertEqual(passedMailAccount?.imapServer, self.imapServer)
+        XCTAssertEqual(passedMailAccount?.imapPort, self.imapPort)
+        XCTAssertEqual(passedMailAccount?.imapEncryption, self.imapEncryption)
+        XCTAssertEqual(passedMailAccount?.smtpServer, self.smtpServer)
+        XCTAssertEqual(passedMailAccount?.smtpPort, self.smtpPort)
+        XCTAssertEqual(passedMailAccount?.smtpEncryption, self.smtpEncryption)
+    }
+    
+    //Test authentification results
+    func testAuthenticationSuccessful() {
+        let model = MockAuthenticationModel().withEnabledSuperclassSpy()
+        let viewModel = MockAuthenticationViewModel(authenticationModel: model).withEnabledSuperclassSpy()
+        let future: Future<AuthenticationModel.AuthenticationResult, Never> = Future {
+            promise  in promise(.success(AuthenticationModel.AuthenticationResult.Success))
+        }
+        stub(model) { stub in
+            when(stub.checkConfig(mailAccount: any(), extendedValidation: false)).thenReturn(future)
+        }
+        viewModel.validate(self.login, self.password)
+        verify(viewModel).authenticationSucceed()
+    }
+    
+    func testAuthenticationFailed() {
+        let model = MockAuthenticationModel().withEnabledSuperclassSpy()
+        let viewModel = MockAuthenticationViewModel(authenticationModel: model).withEnabledSuperclassSpy()
+        let future: Future<AuthenticationModel.AuthenticationResult, Never> = Future {
+            promise  in promise(.success(AuthenticationModel.AuthenticationResult.Error(value: MailServerConnectionError.AuthenticationError)))
+        }
+        stub(model) { stub in
+            when(stub.checkConfig(mailAccount: any(), extendedValidation: false)).thenReturn(future)
+        }
+        viewModel.validate(self.login, self.password)
+        let argumentCaptor = ArgumentCaptor<MailServerConnectionError>()
+        verify(viewModel).authenticationFailed(error: argumentCaptor.capture())
+        XCTAssertEqual(argumentCaptor.value, MailServerConnectionError.AuthenticationError)
+    }
+    
+    func testAuthenticationTimeout() {
+        let model = MockAuthenticationModel().withEnabledSuperclassSpy()
+        let viewModel = MockAuthenticationViewModel(authenticationModel: model).withEnabledSuperclassSpy()
+        let future: Future<AuthenticationModel.AuthenticationResult, Never> = Future {
+            promise  in promise(.success(AuthenticationModel.AuthenticationResult.Timeout))
+        }
+        stub(model) { stub in
+            when(stub.checkConfig(mailAccount: any(), extendedValidation: false)).thenReturn(future)
+        }
+        viewModel.validate(self.login, self.password)
+        verify(viewModel).timeoutNotification()
+    }
+}