[repo-assist] Tests: add coverage for distinctUntilChanged, takeWhile, skipWhile

RELEASE_NOTES.md

@@ -1,6 +1,7 @@
 ### Unreleased
 
 * Test coverage: Added tests for previously-untested public API functions `AsyncSeq.tryFirst`, `AsyncSeq.firstOrDefault`, `AsyncSeq.zipWithParallel`, `AsyncSeq.combineLatestWithAsync`, and `AsyncSeq.toObservable`. No functional changes.
+* Test coverage: Added tests for `AsyncSeq.distinctUntilChanged` (default-equality variant), `AsyncSeq.takeWhile`, and `AsyncSeq.skipWhile` (sync-predicate variants), which previously had no direct tests. No functional changes.
 * Fixed Fable CI build: `Microsoft.Bcl.AsyncInterfaces` was pinned to a specific version (`10.0.7`) that was older than the version resolved transitively via `System.Threading.Channels`, causing a `NU1605` package downgrade error that made Fable's project cracker fail during `dotnet fable`. The reference now uses `Version="*"` (matching `System.Threading.Channels`) so both resolve consistently. (#334)
 * Tests: Added comprehensive tests for `AsyncSeq.zapp`, `AsyncSeq.zappAsync`, and `AsyncSeq.compareWithAsync`, which previously had no dedicated test coverage.
 

tests/FSharp.Control.AsyncSeq.Tests/AsyncSeqTests.fs

@@ -2094,7 +2094,7 @@
       let actual =
         ls
         |> AsyncSeq.ofSeq
         |> AsyncSeq.groupBy p
         |> AsyncSeq.mapAsyncParallel (snd >> AsyncSeq.toListAsync)
       Assert.AreEqual(expected, actual)
 
@@ -2103,7 +2103,7 @@
   let expected = asyncSeq { raise (exn("test")) }
   let actual =
     asyncSeq { raise (exn("test")) }
     |> AsyncSeq.groupBy (fun i -> i % 3)
     |> AsyncSeq.mapAsyncParallel (snd >> AsyncSeq.toListAsync)
   Assert.AreEqual(expected, actual)
 
@@ -2876,6 +2876,39 @@
   let result = AsyncSeq.distinctUntilChangedWith (=) source |> AsyncSeq.toListSynchronously
   Assert.AreEqual([1], result)
 
+[<Test>]
+let ``AsyncSeq.distinctUntilChanged collapses consecutive duplicates using default equality`` () =
+  let source = asyncSeq { yield 1; yield 1; yield 2; yield 2; yield 2; yield 1; yield 3 }
+  let result = AsyncSeq.distinctUntilChanged source |> AsyncSeq.toListSynchronously
+  Assert.AreEqual([1; 2; 1; 3], result)
+
+[<Test>]
+let ``AsyncSeq.distinctUntilChanged on empty sequence returns empty`` () =
+  let result = AsyncSeq.distinctUntilChanged AsyncSeq.empty<int> |> AsyncSeq.toListSynchronously
+  Assert.AreEqual([], result)
+
+[<Test>]
+let ``AsyncSeq.distinctUntilChanged on all-unique sequence returns all elements`` () =
+  let source = asyncSeq { yield 1; yield 2; yield 3 }
+  let result = AsyncSeq.distinctUntilChanged source |> AsyncSeq.toListSynchronously
+  Assert.AreEqual([1; 2; 3], result)
+
+[<Test>]
+let ``AsyncSeq.takeWhile takes elements while predicate holds`` () =
+  for ls in [ []; [1]; [1;2;3;4;5] ] do
+      let p i = i < 4
+      let actual = ls |> AsyncSeq.ofSeq |> AsyncSeq.takeWhile p
+      let expected = ls |> Seq.takeWhile p |> AsyncSeq.ofSeq
+      Assert.True(EQ expected actual)
+
+[<Test>]
+let ``AsyncSeq.skipWhile skips elements while predicate holds`` () =
+  for ls in [ []; [1]; [3]; [1;2;3;4;5] ] do
+      let p i = i <= 2
+      let actual = ls |> AsyncSeq.ofSeq |> AsyncSeq.skipWhile p
+      let expected = ls |> Seq.skipWhile p |> AsyncSeq.ofSeq
+      Assert.True(EQ expected actual)
+
 [<Test>]
 let ``AsyncSeq.append with both sequences having exceptions should propagate first`` () =
   async {
@@ -4851,7 +4884,7 @@
 let ``AsyncSeq.groupByAsync groups elements by async projection`` () =
   let result =
     AsyncSeq.ofSeq [1..6]
     |> AsyncSeq.groupByAsync (fun x -> async { return x % 2 })
     |> AsyncSeq.mapAsyncParallel (fun (key, grp) -> async {
         let! items = AsyncSeq.toArrayAsync grp
         return key, Array.sort items })
@@ -4864,7 +4897,7 @@
 let ``AsyncSeq.groupByAsync on empty sequence returns empty`` () =
   let result =
     AsyncSeq.empty<int>
     |> AsyncSeq.groupByAsync (fun x -> async { return x % 2 })
     |> AsyncSeq.toArrayAsync
     |> Async.RunSynchronously
   Assert.AreEqual([||], result)
@@ -4873,7 +4906,7 @@
 let ``AsyncSeq.groupByAsync with all-same key produces single group`` () =
   let result =
     AsyncSeq.ofSeq [1; 2; 3]
     |> AsyncSeq.groupByAsync (fun _ -> async { return "same" })
     |> AsyncSeq.mapAsyncParallel (fun (key, grp) -> async {
         let! items = AsyncSeq.toArrayAsync grp
         return key, Array.sort items })