fix copyrights, remove typos, change sleep to a custom shorthand backportable shorthand without nanoseconds

Author: stefanomondino

Sources/AsyncAlgorithms/AsyncShareSequence.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift Async Algorithms open source project
 //
-// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -130,7 +130,7 @@ where Base.Element: Sendable, Base: _SendableMetatype, Base.AsyncIterator: _Send
   //   **Cleanup**: Automatically unregisters and cancels pending operations on deinit
   final class Side {
     // Due to a runtime crash in 1.0 compatible versions, it's not possible to handle
-    // a generic failure constrained to Base.Failure. We handle inner failure with a `any Error`
+    // a generic failure constrained to Base.Failure. We handle inner failure with a `any Error`
     // and force unwrap it to the generic 1.2 generic type on the outside Iterator.
     typealias Failure = any Error
     // Tracks the state of a single consumer's iteration.

Sources/AsyncAlgorithms/Shims.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift Async Algorithms open source project
 //
-// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information

Tests/AsyncAlgorithmsTests/Support/FailingSequence.swift

@@ -1,9 +1,13 @@
+//===----------------------------------------------------------------------===//
 //
-//  FailingSequence.swift
-//  swift-async-algorithms
+// This source file is part of the Swift Async Algorithms open source project
 //
-//  Created by Stefano Mondino on 15/10/25.
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
 //
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
 
 @available(AsyncAlgorithms 1.2, *)
 struct FailingSequence<Failure: Error>: AsyncSequence, Sendable {

Tests/AsyncAlgorithmsTests/Support/Task+Extensions.swift

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Async Algorithms open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+/// Backportable versions of `sleep(for:)` for legacy platforms where this kind of method is not available
+extension Task where Success == Never, Failure == Never {
+  
+  static func sleep(milliseconds duration: UInt64) async throws {
+    try await sleep(duration, multiplier: 1_000_000)
+  }
+  static func sleep(microseconds duration: UInt64) async throws {
+    try await sleep(duration, multiplier: 1_000)
+  }
+  static func sleep(seconds duration: UInt64) async throws {
+    try await sleep(duration, multiplier: 1_000_000_000)
+  }
+  
+  private static func sleep(_ value: UInt64, multiplier: UInt64) async throws {
+    guard UInt64.max / multiplier > value else {
+      throw SleepError.durationOutOfBounds
+    }
+    try await sleep(nanoseconds: value * multiplier)
+  }
+}
+
+fileprivate enum SleepError: Error {
+  case durationOutOfBounds
+}

Tests/AsyncAlgorithmsTests/TestShare.swift

@@ -98,7 +98,7 @@ final class TestShare: XCTestCase {
         results1.withLock { $0.append(value) }
       }
       // Delay to allow consumer 2 to get ahead
-      try? await Task.sleep(nanoseconds: 10_000_000)
+      try? await Task.sleep(milliseconds: 10)
       // Continue reading
       while let value = await iterator.next() {
         results1.withLock { $0.append(value) }
@@ -146,7 +146,7 @@ final class TestShare: XCTestCase {
       while let value = await iterator.next() {
         results1.withLock { $0.append(value) }
         // Add some delay to consumer 1
-        try? await Task.sleep(nanoseconds: 1_000_000)
+        try? await Task.sleep(milliseconds: 1)
       }
     }
 
@@ -193,7 +193,7 @@ final class TestShare: XCTestCase {
         slowResults.withLock { $0.append(value) }
       }
       // Add significant delay to let buffer fill up and potentially overflow
-      try? await Task.sleep(nanoseconds: 50_000_000)
+      try? await Task.sleep(milliseconds: 50)
       // Continue reading remaining elements
       while let value = await iterator.next() {
         slowResults.withLock { $0.append(value) }
@@ -202,13 +202,13 @@ final class TestShare: XCTestCase {
 
     // Release all elements quickly to test buffer overflow behavior
     gated.advance()  // 1
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 2
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 3
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 4
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 5
 
     await fastConsumer.value
@@ -265,7 +265,7 @@ final class TestShare: XCTestCase {
         slowResults.withLock { $0.append(value) }
       }
       // Add significant delay to let buffer fill up and potentially overflow
-      try? await Task.sleep(nanoseconds: 50_000_000)
+      try? await Task.sleep(milliseconds: 50)
       // Continue reading remaining elements
       while let value = await iterator.next() {
         slowResults.withLock { $0.append(value) }
@@ -274,13 +274,13 @@ final class TestShare: XCTestCase {
 
     // Release all elements quickly to test buffer overflow behavior
     gated.advance()  // 1
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 2
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 3
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 4
-    try? await Task.sleep(nanoseconds: 5_000_000)
+    try? await Task.sleep(milliseconds: 5)
     gated.advance()  // 5
 
     await fastConsumer.value
@@ -490,7 +490,7 @@ final class TestShare: XCTestCase {
     gated.advance()  // 2
 
     // Give early consumer time to consume
-    try? await Task.sleep(nanoseconds: 10_000_000)
+    try? await Task.sleep(milliseconds: 10)
 
     // Start late consumer
     let lateConsumer = Task {
@@ -587,18 +587,18 @@ final class TestShare: XCTestCase {
   }
 
   func test_share_rethrows_failure_type_without_falling_back_to_any_error() async {
-    if #available(AsyncAlgorithms 1.2, *) {
-      // Ensure - at compile time - that error is effectively a TestError
-      let shared: some AsyncSequence<Void, TestError> = FailingSequence(TestError.failure).share()
-      do {
-        for try await _ in shared {
-          XCTFail("Expected to not get here")
-        }
-      } catch {
-        XCTAssertEqual(error, TestError.failure)
+    guard #available(AsyncAlgorithms 1.2, *) else {
+      _ = XCTSkip("This test is not available before 1.2")
+      return
+    }
+    // Ensure - at compile time - that error is effectively a TestError
+    let shared: some AsyncSequence<Void, TestError> = FailingSequence(TestError.failure).share()
+    do {
+      for try await _ in shared {
+        XCTFail("Expected to not get here")
       }
-    } else {
-      throw XCTSkip("This test is not available before 1.2")
+    } catch {
+      XCTAssertEqual(error, TestError.failure)
     }
   }
 }