Add some first drafts at unit tests for verifying share behaviors

Author: phausler

Evolution/NNNN-share.md

@@ -98,7 +98,7 @@ The order of the interleaving of the prints are not guaranteed; however the orde
 If the creation were instead altered to the following:
 
 ```swift
-let exampleSource = [0, 1, 2, 3, 4].async.share(bufferingPolicy: .bufferingNewest(2))
+let exampleSource = [0, 1, 2, 3, 4].async.share(bufferingPolicy: .bufferingLatest(2))
 ```
 
 The output would print the possible ordering of:

Sources/AsyncAlgorithms/AsyncShareSequence.swift

@@ -227,9 +227,9 @@ struct AsyncShareSequence<Base: AsyncSequence>: Sendable where Base.Element: Sen
       var generation = 0
       var sides = [Int: Side.State]()
       var iteratingTask: IteratingTask
-      var buffer = [Element]()
-      var finished = false
-      var failure: Failure?
+      private(set) var buffer = [Element]()
+      private(set) var finished = false
+      private(set) var failure: Failure?
       var cancelled = false
       var limit: UnsafeContinuation<Bool, Never>?
       var demand: UnsafeContinuation<Void, Never>?
@@ -485,11 +485,10 @@ struct AsyncShareSequence<Base: AsyncSequence>: Sendable where Base.Element: Sen
           if let element {
             state.enqueue(element)
           } else {
-            state.finished = true
+            state.finish()
           }
         case .failure(let failure):
-          state.finished = true
-          state.failure = failure
+          state.fail(failure)
         }
         for (id, side) in state.sides {
           if let continuation = side.continuaton {

Tests/AsyncAlgorithmsTests/Support/GatedSequence.swift

@@ -10,6 +10,7 @@
 //===----------------------------------------------------------------------===//
 
 public struct GatedSequence<Element> {
+  public typealias Failure = Never
   let elements: [Element]
   let gates: [Gate]
   var index = 0
@@ -44,6 +45,15 @@ extension GatedSequence: AsyncSequence {
       await gate.enter()
       return element
     }
+    
+    public mutating func next(isolation actor: isolated (any Actor)?) async throws(Never) -> Element? {
+      guard gatedElements.count > 0 else {
+        return nil
+      }
+      let (element, gate) = gatedElements.removeFirst()
+      await gate.enter()
+      return element
+    }
   }
 
   public func makeAsyncIterator() -> Iterator {