fix for unit test (+2 squashed commits)

Squashed commits:
[6d854db8] TimeoutExecutor
[09d316e] added comment

Author: abelonogov-ld

LaunchDarkly/LaunchDarkly/LDClient.swift

@@ -384,22 +384,18 @@ public class LDClient {
         if timeout > LDClient.longTimeoutInterval {
             os_log("%s LDClient.identify was called with a timeout greater than %f seconds. We recommend a timeout of less than %f seconds.", log: config.logger, type: .info, self.typeName(and: #function), LDClient.longTimeoutInterval, LDClient.longTimeoutInterval)
         }
-
-        var cancel = false
-
-        DispatchQueue.global().asyncAfter(deadline: .now() + timeout) {
-            guard !cancel else { return }
-
-            cancel = true
-            completion(.timeout)
-        }
-
-        identify(context: context, useCache: useCache) { result in
-            guard !cancel else { return }
-
-            cancel = true
-            completion(result)
-        }
+        
+        TimeoutExecutor.run(
+            timeout: timeout,
+            queue: .global(),
+            operation: { done in
+                self.identify(context: context, useCache: useCache) { result in
+                    done(result)
+                }
+            },
+            timeoutValue: .timeout,
+            completion: completion
+        )
     }
 
     func internalIdentify(newContext: LDContext, useCache: IdentifyCacheUsage, completion: (() -> Void)? = nil) {
@@ -854,27 +850,25 @@ public class LDClient {
     }
 
     static func start(serviceFactory: ClientServiceCreating?, config: LDConfig, context: LDContext? = nil, startWaitSeconds: TimeInterval, completion: ((_ timedOut: Bool) -> Void)? = nil) {
-        var completed = false
         let internalCompletedQueue: DispatchQueue = DispatchQueue(label: "TimeOutQueue")
         if !config.startOnline {
             start(serviceFactory: serviceFactory, config: config, context: context)
             completion?(true) // offline is considered a short circuited timed out case
         } else {
             let startTime = Date().timeIntervalSince1970
-            start(serviceFactory: serviceFactory, config: config, context: context) {
-                internalCompletedQueue.async {
-                    if startTime + startWaitSeconds > Date().timeIntervalSince1970 && !completed {
-                        completed = true
-                        completion?(false) // false for not timedOut
+        
+            TimeoutExecutor.run(
+                timeout: startWaitSeconds,
+                queue: internalCompletedQueue,
+                operation: { done in
+                    Self.start(serviceFactory: serviceFactory, config: config, context: context) {
+                        let onTime = startWaitSeconds > Date().timeIntervalSince1970 - startTime
+                        done(!onTime)
                     }
-                }
-            }
-            internalCompletedQueue.asyncAfter(deadline: .now() + startWaitSeconds) {
-                if !completed {
-                    completed = true
-                    completion?(true) // true for timedOut
-                }
-            }
+                },
+                timeoutValue: true,
+                completion: completion
+            )
         }
     }
 

LaunchDarkly/LaunchDarkly/ServiceObjects/TimeoutExecutor.swift

@@ -0,0 +1,68 @@
+import Foundation
+
+/// A lightweight utility for executing asynchronous operations with a timeout fallback.
+///
+/// `TimeoutExecutor` guarantees that the provided `completion` closure is called **exactly once**,
+/// either with the result of the asynchronous operation or with a timeout value if the operation
+/// does not complete in time.
+///
+/// ### Typical Usage
+/// ```swift
+/// TimeoutExecutor.run(
+///     timeout: 2.0,
+///     queue: .main,
+///     operation: { done in
+///          service.action() {
+///                     done("Success")
+///          }
+///     },
+///     timeoutValue: "Timeout",
+///     completion: { result in
+///         print("Result:", result)
+///     }
+/// )
+/// ```
+///
+final class TimeoutExecutor {
+    private init() {}
+
+    static func run<T>(
+        timeout: TimeInterval,
+        queue: DispatchQueue = .global(),
+        operation: (@escaping (T) -> Void) -> Void,
+        timeoutValue: @autoclosure @escaping () -> T,
+        completion: ((T) -> Void)?
+    ) {
+        guard let completion = completion else {
+            operation { _ in
+                /* ignore result */
+            }
+            return
+        }
+        
+        let lockQueue = DispatchQueue(label: "launchdarkly.timeout.executor.lock")
+        var finished = false
+
+        func finish(_ value: @autoclosure () -> T) {
+            var shouldCall = false
+            lockQueue.sync {
+                if !finished {
+                    finished = true
+                    shouldCall = true
+                }
+            }
+            guard shouldCall else { return }
+            queue.async { completion(timeoutValue()) }
+        }
+
+        // Start the user operation (they can call `done` from any queue)
+        operation { value in
+            finish(value)
+        }
+
+        // Timeout fallback scheduled
+        queue.asyncAfter(deadline: .now() + timeout) {
+            finish(timeoutValue())
+        }
+    }
+}