 
     func testLazyRegister_UsingTypeInference_ShouldFailWithDuplicateLazyService() {
 
-        let testLazyServiceString: () -> (String) = {
+        let testLazyServiceString: () -> String = {
             return "Test Register Service"
         }
 

    
    func testGetLazyInitRegistered_UsingName_ShouldReturnService() {
        
        let testLazyServiceString: () -> (String) = {
            return "Test Register Service"
        }
        let serviceName = "String"

            XCTFail("💥: Unregister failed with error: \(error)")
        }
    }

    func testUnregister_UsingName_ShouldFailWithLazyServiceTypeMismatch() {

        let serviceName = "LazyInt"
        let testLazyServiceInt: () -> Int = {
            return 1
        }

        do {
            try serviceLocator.register(name: serviceName, testLazyServiceInt)

            try serviceLocator.unregister(Double.self, name: serviceName)

        } catch let ServiceLocatorError.lazyServiceTypeMismatch(expected: expectedType, found: foundType) {
            assertMismatchTypes(expected: expectedType,
                                found: foundType,
                                registeredService: type(of: testLazyServiceInt),
                                getService: type(of: { return 1.0 } as () -> Double))
        } catch {
            XCTFail("💥: Unregister failed with error: \(error)")
        }
    }
    
    func testUnregisterAll_ShouldRemoveAllServices() {

        let testServiceString = "Test Register Service"
        let testServiceDouble = 1.0
        let testLazyServiceInt: () -> Int = {
            return 1
        }

