feat: Update package.json to 2.2.5

This reverts commit 4fc9ca315e.

.github/workflows/build-release.yml

@@ -26,40 +26,51 @@ jobs:
       sha: ${{ steps.commit.outputs.sha }}
     steps:
       - uses: actions/checkout@v2
-      - name: before
+      - name: Output package.json (Before)
         run: cat ${{ env.TARGET_FILE}}
-      - name: update package.json to version ${{ env.GIT_TAG }}
+
+      - name: Update package.json to version ${{ env.GIT_TAG }}
         run: sed -i -e "s/\(\"version\":\) \"\(.*\)\",/\1 \"${{ env.GIT_TAG }}\",/" ${{ env.TARGET_FILE }}
-      - name: after
-        run: cat ${{ env.TARGET_FILE}}
+
+      - name: Check update
+        id: check_update
+        run: |
+          cat ${{ env.TARGET_FILE}}
+          git diff --exit-code || echo "::set-output name=changed::1"
+
       - name: Commit files
         id: commit
+        if: steps.check_update.outputs.changed == '1'
         run: |
           git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
           git config --local user.name "github-actions[bot]"
           git commit -m "feat: Update package.json to ${{ env.GIT_TAG }}" -a
           echo "::set-output name=sha::$(git rev-parse HEAD)"
-      - name: check sha
+
+      - name: Check sha
         run: echo "SHA ${SHA}"
         env:
           SHA: ${{ steps.commit.outputs.sha }}
-      - name: tag
+
+      - name: Create Tag
+        if: steps.check_update.outputs.changed == '1'
         run: git tag ${{ env.GIT_TAG }}
-        if: env.DRY_RUN == 'false'
+
       - name: Push changes
+        if: env.DRY_RUN == 'false' && steps.check_update.outputs.changed == '1'
         uses: ad-m/github-push-action@master
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           branch: ${{ github.ref }}
           tags: true
-        if: env.DRY_RUN == 'false'
+
       - name: Push changes (dry_run)
+        if: env.DRY_RUN == 'true' && steps.check_update.outputs.changed == '1'
         uses: ad-m/github-push-action@master
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           branch: ${{ env.DRY_RUN_BRANCH_PREFIX }}-${{ env.GIT_TAG }}
           tags: false
-        if: env.DRY_RUN == 'true'
 
   build-dotnet:
     needs: [update-packagejson]

README.md

@@ -669,7 +669,7 @@ Async LINQ is enabled when `using Cysharp.Threading.Tasks.Linq;`, and `UniTaskAs
 
 It's closer to UniRx (Reactive Extensions), but UniTaskAsyncEnumerable is a pull-based asynchronous stream, whereas Rx was a push-based asynchronous stream. Note that although similar, the characteristics are different and the details behave differently along with them.
 
-`UniTaskAsyncEnumerable` is the entry point like `Enumerbale`. In addition to the standard query operators, there are other generators for Unity such as `EveryUpdate`, `Timer`, `TimerFrame`, `Interval`, `IntervalFrame`, and `EveryValueChanged`. And also added additional UniTask original query operators like `Append`, `Prepend`, `DistinctUntilChanged`, `ToHashSet`, `Buffer`, `CombineLatest`, `Do`, `Never`, `ForEachAsync`, `Pairwise`, `Publish`, `Queue`, `Return`, `SkipUntil`, `TakeUntil`, `SkipUntilCanceled`, `TakeUntilCanceled`, `TakeLast`, `Subscribe`.
+`UniTaskAsyncEnumerable` is the entry point like `Enumerable`. In addition to the standard query operators, there are other generators for Unity such as `EveryUpdate`, `Timer`, `TimerFrame`, `Interval`, `IntervalFrame`, and `EveryValueChanged`. And also added additional UniTask original query operators like `Append`, `Prepend`, `DistinctUntilChanged`, `ToHashSet`, `Buffer`, `CombineLatest`, `Do`, `Never`, `ForEachAsync`, `Pairwise`, `Publish`, `Queue`, `Return`, `SkipUntil`, `TakeUntil`, `SkipUntilCanceled`, `TakeUntilCanceled`, `TakeLast`, `Subscribe`.
 
 The method with Func as an argument has three additional overloads, `***Await`, `***AwaitWithCancellation`.
 
@@ -848,7 +848,7 @@ button.OnClickAsAsyncEnumerable().Subscribe(async x =>
 
 Channel
 ---
-`Channel` is the same as [System.Threading.Tasks.Channels](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.channels?view=netcore-3.1) which is similar to a GoLang Channel.
+`Channel` is the same as [System.Threading.Tasks.Channels](https://docs.microsoft.com/en-us/dotnet/api/system.threading.channels?view=netcore-3.1) which is similar to a GoLang Channel.
 
 Currently it only supports multiple-producer, single-consumer unbounded channels. It can create by `Channel.CreateSingleConsumerUnbounded<T>()`.
 

src/UniTask.NetCore/UniTask.NetCore.csproj

@@ -19,6 +19,8 @@
         <RepositoryType>git</RepositoryType>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <PackageIcon>Icon.png</PackageIcon>
+        <SignAssembly>true</SignAssembly>
+        <AssemblyOriginatorKeyFile>opensource.snk</AssemblyOriginatorKeyFile>
     </PropertyGroup>
 
     <ItemGroup>
@@ -26,30 +28,8 @@
     </ItemGroup>
 
     <ItemGroup>
-        <Compile Include="..\UniTask\Assets\Plugins\UniTask\Runtime\**\*.cs"
-                 Exclude="
-..\UniTask\Assets\Plugins\UniTask\Editor\*.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\Triggers\*.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\Linq\UnityExtensions\*.cs;
-  
-..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\UnityEqualityComparer.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\DiagnosticsExtensions.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\PlayerLoopRunner.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\ContinuationQueue.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\UnityWebRequestExtensions.cs;
-  
-..\UniTask\Assets\Plugins\UniTask\Runtime\UniTaskSynchronizationContext.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\CancellationTokenSourceExtensions.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\EnumeratorAsyncExtensions.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\TimeoutController.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\PlayerLoopHelper.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Delay.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Run.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Bridge.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.WaitUntil.cs;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.*;
-..\UniTask\Assets\Plugins\UniTask\Runtime\UnityBindingExtensions.cs;
-" />
+        <Compile Include="..\UniTask\Assets\Plugins\UniTask\Runtime\**\*.cs" Exclude="&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Editor\*.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\Triggers\*.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\Linq\UnityExtensions\*.cs;&#xD;&#xA;  &#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\UnityEqualityComparer.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\DiagnosticsExtensions.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\PlayerLoopRunner.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\ContinuationQueue.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\Internal\UnityWebRequestExtensions.cs;&#xD;&#xA;  &#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\UniTaskSynchronizationContext.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\CancellationTokenSourceExtensions.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\EnumeratorAsyncExtensions.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\TimeoutController.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\PlayerLoopHelper.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\PlayerLoopTimer.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Delay.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Run.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.Bridge.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\UniTask.WaitUntil.cs;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\UnityAsyncExtensions.*;&#xD;&#xA;..\UniTask\Assets\Plugins\UniTask\Runtime\UnityBindingExtensions.cs;&#xD;&#xA;" />
+        <Compile Remove="..\UniTask\Assets\Plugins\UniTask\Runtime\_InternalVisibleTo.cs" />
     </ItemGroup>
 
     <ItemGroup>

src/UniTask.NetCoreTests/AsyncReactivePropertyTest.cs

@@ -31,7 +31,7 @@ namespace NetCoreTests
 
             var ar = await array;
 
-            ar.Should().BeEquivalentTo(new[] { 99, 100, 100, 100, 131 });
+            ar.Should().Equal(new[] { 99, 100, 100, 100, 131 });
         }
 
         [Fact]
@@ -49,7 +49,7 @@ namespace NetCoreTests
 
             var ar = await array;
 
-            ar.Should().BeEquivalentTo(new[] { 100, 100, 100, 131, 191 });
+            ar.Should().Equal(new[] { 100, 100, 100, 131, 191 });
         }
 
         //[Fact]
@@ -70,7 +70,7 @@ namespace NetCoreTests
 
         //    var ar = await array;
 
-        //    ar.Should().BeEquivalentTo(new[] { 99, 100, 100, 100, 131 });
+        //    ar.Should().Equal(new[] { 99, 100, 100, 100, 131 });
         //}
 
         //[Fact]
@@ -88,7 +88,7 @@ namespace NetCoreTests
 
         //    var ar = await array;
 
-        //    ar.Should().BeEquivalentTo(new[] { 100, 100, 100, 131, 191 });
+        //    ar.Should().Equal(new[] { 100, 100, 100, 131, 191 });
         //}
 
 

src/UniTask.NetCoreTests/ChannelTest.cs

@@ -276,8 +276,8 @@ namespace NetCoreTests
             reference.Writer.TryComplete();
             channel.Writer.TryComplete();
 
-            (await ta1).Should().BeEquivalentTo(new[] { 10, 20, 30 });
-            (await ta2).Should().BeEquivalentTo(new[] { 10, 20, 30 });
+            (await ta1).Should().Equal(new[] { 10, 20, 30 });
+            (await ta2).Should().Equal(new[] { 10, 20, 30 });
         }
 
         [Fact]

src/UniTask.NetCoreTests/Linq/Aggregate.cs

@@ -481,7 +481,7 @@ namespace NetCoreTests.Linq
                 list.Add(x);
             });
 
-            list.Should().BeEquivalentTo(Enumerable.Range(1, 10));
+            list.Should().Equal(Enumerable.Range(1, 10));
 
             var list2 = new List<(int, int)>();
             await Enumerable.Range(5, 10).ToUniTaskAsyncEnumerable().ForEachAsync((index, x) =>
@@ -490,7 +490,7 @@ namespace NetCoreTests.Linq
             });
 
             var list3 = Enumerable.Range(5, 10).Select((index, x) => (index, x)).ToArray();
-            list2.Should().BeEquivalentTo(list3);
+            list2.Should().Equal(list3);
         }
     }
 }

src/UniTask.NetCoreTests/Linq/Concat.cs

@@ -24,7 +24,7 @@ namespace NetCoreTests.Linq
             var xs = await Enumerable.Range(start, count).ToUniTaskAsyncEnumerable().Append(99).ToArrayAsync();
             var ys = Enumerable.Range(start, count).Append(99).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -50,7 +50,7 @@ namespace NetCoreTests.Linq
             var xs = await Enumerable.Range(start, count).ToUniTaskAsyncEnumerable().Prepend(99).ToArrayAsync();
             var ys = Enumerable.Range(start, count).Prepend(99).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -85,7 +85,7 @@ namespace NetCoreTests.Linq
 
             var xs = await l.ToUniTaskAsyncEnumerable().Concat(r.ToUniTaskAsyncEnumerable()).ToArrayAsync();
             var ys = l.Concat(r).ToArray();
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -119,17 +119,17 @@ namespace NetCoreTests.Linq
             {
                 var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync();
                 var ys = Enumerable.Range(1, 0).DefaultIfEmpty(99).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await Enumerable.Range(1, 1).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync();
                 var ys = Enumerable.Range(1, 1).DefaultIfEmpty(99).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await Enumerable.Range(1, 10).ToUniTaskAsyncEnumerable().DefaultIfEmpty(99).ToArrayAsync();
                 var ys = Enumerable.Range(1, 10).DefaultIfEmpty(99).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             // Throw
             {

src/UniTask.NetCoreTests/Linq/Convert.cs

@@ -34,11 +34,11 @@ namespace NetCoreTests.Linq
         {
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, 10).ToObservable().ToArray();
-                xs.Should().BeEquivalentTo(Enumerable.Range(1, 10));
+                xs.Should().Equal(Enumerable.Range(1, 10));
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, 0).ToObservable().ToArray();
-                xs.Should().BeEquivalentTo(Enumerable.Range(1, 0));
+                xs.Should().Equal(Enumerable.Range(1, 0));
             }
         }
 
@@ -70,21 +70,21 @@ namespace NetCoreTests.Linq
                 var xs = await Observable.Range(1, 100).ToUniTaskAsyncEnumerable().ToArrayAsync();
                 var ys = await Observable.Range(1, 100).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
 
             {
                 var xs = await Observable.Range(1, 100, ThreadPoolScheduler.Instance).ToUniTaskAsyncEnumerable().ToArrayAsync();
                 var ys = await Observable.Range(1, 100, ThreadPoolScheduler.Instance).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
 
             {
                 var xs = await Observable.Empty<int>(ThreadPoolScheduler.Instance).ToUniTaskAsyncEnumerable().ToArrayAsync();
                 var ys = await Observable.Empty<int>(ThreadPoolScheduler.Instance).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
 
@@ -95,25 +95,25 @@ namespace NetCoreTests.Linq
                 var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x);
                 var ys = Enumerable.Range(1, 100).ToDictionary(x => x);
 
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.OrderBy(x => x.Key).Should().Equal(ys.OrderBy(x => x.Key));
             }
             {
                 var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x);
                 var ys = Enumerable.Range(1, 0).ToDictionary(x => x);
 
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.OrderBy(x => x.Key).Should().Equal(ys.OrderBy(x => x.Key));
             }
             {
                 var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x, x => x * 2);
                 var ys = Enumerable.Range(1, 100).ToDictionary(x => x, x => x * 2);
 
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.OrderBy(x => x.Key).Should().Equal(ys.OrderBy(x => x.Key));
             }
             {
                 var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToDictionaryAsync(x => x, x => x * 2);
                 var ys = Enumerable.Range(1, 0).ToDictionary(x => x, x => x * 2);
 
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.OrderBy(x => x.Key).Should().Equal(ys.OrderBy(x => x.Key));
             }
         }
 
@@ -126,34 +126,34 @@ namespace NetCoreTests.Linq
                 var ys = arr.ToLookup(x => x);
 
                 xs.Count.Should().Be(ys.Count);
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.Should().BeEquivalentTo(ys);
                 foreach (var key in xs.Select(x => x.Key))
                 {
-                    xs[key].Should().BeEquivalentTo(ys[key]);
+                    xs[key].Should().Equal(ys[key]);
                 }
             }
             {
                 var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToLookupAsync(x => x);
                 var ys = Enumerable.Range(1, 0).ToLookup(x => x);
 
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.Should().BeEquivalentTo(ys);
             }
             {
                 var xs = await arr.ToUniTaskAsyncEnumerable().ToLookupAsync(x => x, x => x * 2);
                 var ys = arr.ToLookup(x => x, x => x * 2);
 
                 xs.Count.Should().Be(ys.Count);
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.Should().BeEquivalentTo(ys);
                 foreach (var key in xs.Select(x => x.Key))
                 {
-                    xs[key].Should().BeEquivalentTo(ys[key]);
+                    xs[key].Should().Equal(ys[key]);
                 }
             }
             {
                 var xs = await Enumerable.Range(1, 0).ToUniTaskAsyncEnumerable().ToLookupAsync(x => x, x => x * 2);
                 var ys = Enumerable.Range(1, 0).ToLookup(x => x, x => x * 2);
 
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.Should().BeEquivalentTo(ys);
             }
         }
 
@@ -164,13 +164,13 @@ namespace NetCoreTests.Linq
                 var xs = await Enumerable.Range(1, 100).ToUniTaskAsyncEnumerable().ToListAsync();
                 var ys = Enumerable.Range(1, 100).ToList();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().ToListAsync();
                 var ys = Enumerable.Empty<int>().ToList();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
 
@@ -181,13 +181,13 @@ namespace NetCoreTests.Linq
                 var xs = await new[] { 1, 20, 4, 5, 20, 4, 6 }.ToUniTaskAsyncEnumerable().ToHashSetAsync();
                 var ys = new[] { 1, 20, 4, 5, 20, 4, 6 }.ToHashSet();
 
-                xs.OrderBy(x => x).Should().BeEquivalentTo(ys.OrderBy(x => x));
+                xs.OrderBy(x => x).Should().Equal(ys.OrderBy(x => x));
             }
             {
                 var xs = await Enumerable.Empty<int>().ToUniTaskAsyncEnumerable().ToHashSetAsync();
                 var ys = Enumerable.Empty<int>().ToHashSet();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
     }

src/UniTask.NetCoreTests/Linq/CreateTest.cs

@@ -30,7 +30,7 @@ namespace NetCoreTests.Linq
 
             var ys = await Range(from, count).AsUniTaskAsyncEnumerable().ToArrayAsync();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -57,19 +57,19 @@ namespace NetCoreTests.Linq
             list.Should().BeEmpty();
 
             await e.MoveNextAsync();
-            list.Should().BeEquivalentTo(100);
+            list.Should().Equal(100);
             e.Current.Should().Be(10);
 
             await e.MoveNextAsync();
-            list.Should().BeEquivalentTo(100, 200);
+            list.Should().Equal(100, 200);
             e.Current.Should().Be(20);
 
             await e.MoveNextAsync();
-            list.Should().BeEquivalentTo(100, 200, 300);
+            list.Should().Equal(100, 200, 300);
             e.Current.Should().Be(30);
 
             (await e.MoveNextAsync()).Should().BeFalse();
-            list.Should().BeEquivalentTo(100, 200, 300, 400);
+            list.Should().Equal(100, 200, 300, 400);
         }
 
         [Fact]
@@ -144,19 +144,19 @@ namespace NetCoreTests.Linq
             list.Should().BeEmpty();
 
             await e.MoveNextAsync();
-            list.Should().BeEquivalentTo(100);
+            list.Should().Equal(100);
             e.Current.Should().Be(10);
 
             await e.MoveNextAsync();
-            list.Should().BeEquivalentTo(100, 200);
+            list.Should().Equal(100, 200);
             e.Current.Should().Be(20);
 
             await e.MoveNextAsync();
-            list.Should().BeEquivalentTo(100, 200, 300);
+            list.Should().Equal(100, 200, 300);
             e.Current.Should().Be(30);
 
             (await e.MoveNextAsync()).Should().BeFalse();
-            list.Should().BeEquivalentTo(100, 200, 300, 400);
+            list.Should().Equal(100, 200, 300, 400);
         }
 
         async IAsyncEnumerable<int> Range(int from, int count)

src/UniTask.NetCoreTests/Linq/Factory.cs

@@ -22,7 +22,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Range(start, count).ToArrayAsync();
             var ys = Enumerable.Range(start, count).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Theory]
@@ -36,7 +36,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Repeat(value, count).ToArrayAsync();
             var ys = Enumerable.Repeat(value, count).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -45,7 +45,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Empty<int>().ToArrayAsync();
             var ys = Enumerable.Empty<int>().ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Theory]

src/UniTask.NetCoreTests/Linq/Filtering.cs

@@ -23,26 +23,26 @@ namespace NetCoreTests.Linq
             {
                 var a = await src.Where(x => x % 2 == 0).ToArrayAsync();
                 var expected = range.Where(x => x % 2 == 0).ToArray();
-                a.Should().BeEquivalentTo(expected);
+                a.Should().Equal(expected);
             }
             {
                 var a = await src.Where((x, i) => (x + i) % 2 == 0).ToArrayAsync();
                 var expected = range.Where((x, i) => (x + i) % 2 == 0).ToArray();
-                a.Should().BeEquivalentTo(expected);
+                a.Should().Equal(expected);
             }
             {
                 var a = await src.WhereAwait(x => UniTask.Run(() => x % 2 == 0)).ToArrayAsync();
                 var b = await src.WhereAwait(x => UniTask.FromResult(x % 2 == 0)).ToArrayAsync();
                 var expected = range.Where(x => x % 2 == 0).ToArray();
-                a.Should().BeEquivalentTo(expected);
-                b.Should().BeEquivalentTo(expected);
+                a.Should().Equal(expected);
+                b.Should().Equal(expected);
             }
             {
                 var a = await src.WhereAwait((x, i) => UniTask.Run(() => (x + i) % 2 == 0)).ToArrayAsync();
                 var b = await src.WhereAwait((x, i) => UniTask.FromResult((x + i) % 2 == 0)).ToArrayAsync();
                 var expected = range.Where((x, i) => (x + i) % 2 == 0).ToArray();
-                a.Should().BeEquivalentTo(expected);
-                b.Should().BeEquivalentTo(expected);
+                a.Should().Equal(expected);
+                b.Should().Equal(expected);
             }
         }
 
@@ -79,7 +79,7 @@ namespace NetCoreTests.Linq
             var a = await data.ToUniTaskAsyncEnumerable().OfType<int>().ToArrayAsync();
             var b = data.OfType<int>().ToArray();
 
-            a.Should().BeEquivalentTo(b);
+            a.Should().Equal(b);
         }
 
 
@@ -101,7 +101,7 @@ namespace NetCoreTests.Linq
             var a = await data.ToUniTaskAsyncEnumerable().Cast<int>().ToArrayAsync();
             var b = data.Cast<int>().ToArray();
 
-            a.Should().BeEquivalentTo(b);
+            a.Should().Equal(b);
         }
 
 

src/UniTask.NetCoreTests/Linq/Joins.cs

@@ -38,7 +38,7 @@ namespace NetCoreTests.Linq
             var xs = await outer.ToUniTaskAsyncEnumerable().Join(inner.ToUniTaskAsyncEnumerable(), x => x, x => x, (x, y) => (x, y)).ToArrayAsync();
             var ys = outer.Join(inner, x => x, x => x, (x, y) => (x, y)).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
 
@@ -66,7 +66,7 @@ namespace NetCoreTests.Linq
             var xs = await outer.ToUniTaskAsyncEnumerable().JoinAwait(inner.ToUniTaskAsyncEnumerable(), x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun((x, y))).ToArrayAsync();
             var ys = outer.Join(inner, x => x, x => x, (x, y) => (x, y)).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
 
@@ -94,7 +94,7 @@ namespace NetCoreTests.Linq
             var xs = await outer.ToUniTaskAsyncEnumerable().JoinAwaitWithCancellation(inner.ToUniTaskAsyncEnumerable(), (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun((x, y))).ToArrayAsync();
             var ys = outer.Join(inner, x => x, x => x, (x, y) => (x, y)).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
 
@@ -123,7 +123,7 @@ namespace NetCoreTests.Linq
                 var ys = arr.GroupBy(x => x).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.Should().BeEquivalentTo(ys);
             }
 
             {
@@ -131,7 +131,7 @@ namespace NetCoreTests.Linq
                 var ys = arr.GroupBy(x => x, (key, xs) => (key, xs.ToArray())).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().BeEquivalentTo(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
+                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().Equal(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
             }
 
             {
@@ -139,7 +139,7 @@ namespace NetCoreTests.Linq
                 var ys = arr.GroupBy(x => x).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.Should().BeEquivalentTo(ys);
             }
 
             {
@@ -147,7 +147,7 @@ namespace NetCoreTests.Linq
                 var ys = arr.GroupBy(x => x, (key, xs) => (key, xs.ToArray())).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().BeEquivalentTo(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
+                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().Equal(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
             }
 
             {
@@ -155,7 +155,7 @@ namespace NetCoreTests.Linq
                 var ys = arr.GroupBy(x => x).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.OrderBy(x => x.Key).Should().BeEquivalentTo(ys.OrderBy(x => x.Key));
+                xs.Should().BeEquivalentTo(ys);
             }
 
             {
@@ -163,7 +163,7 @@ namespace NetCoreTests.Linq
                 var ys = arr.GroupBy(x => x, (key, xs) => (key, xs.ToArray())).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().BeEquivalentTo(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
+                xs.OrderBy(x => x.key).SelectMany(x => x.Item2).Should().Equal(ys.OrderBy(x => x.key).SelectMany(x => x.Item2));
             }
         }
 
@@ -199,21 +199,21 @@ namespace NetCoreTests.Linq
                 var ys = outer.GroupJoin(inner, x => x, x => x, (x, y) => (x, string.Join(", ", y))).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await outer.ToUniTaskAsyncEnumerable().GroupJoinAwait(inner.ToUniTaskAsyncEnumerable(), x => RandomRun(x), x => RandomRun(x), (x, y) => RandomRun((x, string.Join(", ", y)))).ToArrayAsync();
                 var ys = outer.GroupJoin(inner, x => x, x => x, (x, y) => (x, string.Join(", ", y))).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await outer.ToUniTaskAsyncEnumerable().GroupJoinAwaitWithCancellation(inner.ToUniTaskAsyncEnumerable(), (x, _) => RandomRun(x), (x, _) => RandomRun(x), (x, y, _) => RandomRun((x, string.Join(", ", y)))).ToArrayAsync();
                 var ys = outer.GroupJoin(inner, x => x, x => x, (x, y) => (x, string.Join(", ", y))).ToArray();
 
                 xs.Length.Should().Be(ys.Length);
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
 

src/UniTask.NetCoreTests/Linq/Paging.cs

@@ -27,7 +27,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Range(1, collection).Skip(skipCount).ToArrayAsync();
             var ys = Enumerable.Range(1, collection).Skip(skipCount).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -52,7 +52,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipLast(skipCount).ToArrayAsync();
             var ys = Enumerable.Range(1, collection).SkipLast(skipCount).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -77,7 +77,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeLast(takeCount).ToArrayAsync();
             var ys = Enumerable.Range(1, collection).TakeLast(takeCount).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -103,7 +103,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Range(1, collection).Take(takeCount).ToArrayAsync();
             var ys = Enumerable.Range(1, collection).Take(takeCount).ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -130,37 +130,37 @@ namespace NetCoreTests.Linq
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwait(x => UniTask.Run(() => x < skipCount)).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwait((x, i) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < skipCount)).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).SkipWhile(x => x < skipCount).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).SkipWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).SkipWhile((x, i) => x < (skipCount - i)).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
 
@@ -213,37 +213,37 @@ namespace NetCoreTests.Linq
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwait(x => UniTask.Run(() => x < skipCount)).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwait((x, i) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwaitWithCancellation((x, _) => UniTask.Run(() => x < skipCount)).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).TakeWhile(x => x < skipCount).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, collection).TakeWhileAwaitWithCancellation((x, i, _) => UniTask.Run(() => x < (skipCount - i))).ToArrayAsync();
                 var ys = Enumerable.Range(1, collection).TakeWhile((x, i) => x < (skipCount - i)).ToArray();
 
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
 

src/UniTask.NetCoreTests/Linq/Projection.cs

@@ -24,7 +24,7 @@ namespace NetCoreTests.Linq
             var xs = await Enumerable.Range(start, count).ToUniTaskAsyncEnumerable().Reverse().ToArrayAsync();
             var ys = Enumerable.Range(start, count).Reverse().ToArray();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -46,18 +46,18 @@ namespace NetCoreTests.Linq
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, count).Select(x => x * x).ToArrayAsync();
                 var ys = Enumerable.Range(1, count).Select(x => x * x).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
 
                 var zs = await UniTaskAsyncEnumerable.Range(1, count).SelectAwait((x) => UniTask.Run(() => x * x)).ToArrayAsync();
-                zs.Should().BeEquivalentTo(ys);
+                zs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, count).Select((x, i) => x * x * i).ToArrayAsync();
                 var ys = Enumerable.Range(1, count).Select((x, i) => x * x * i).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
 
                 var zs = await UniTaskAsyncEnumerable.Range(1, count).SelectAwait((x, i) => UniTask.Run(() => x * x * i)).ToArrayAsync();
-                zs.Should().BeEquivalentTo(ys);
+                zs.Should().Equal(ys);
             }
         }
 
@@ -98,22 +98,22 @@ namespace NetCoreTests.Linq
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany(x => UniTaskAsyncEnumerable.Range(99, rightCount * x)).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany((i, x) => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x)).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany(x => UniTaskAsyncEnumerable.Range(99, rightCount * x), (x, y) => x * y).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x), (x, y) => x * y).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectMany((i, x) => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
 
             // await
@@ -121,22 +121,22 @@ namespace NetCoreTests.Linq
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x))).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait((i, x) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x))).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait(x => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x)), (x, y) => UniTask.Run(() => x * y)).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x), (x, y) => x * y).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwait((i, x) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x)), (x, y) => UniTask.Run(() => x * y)).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
 
             // with cancel
@@ -144,22 +144,22 @@ namespace NetCoreTests.Linq
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x))).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((i, x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x))).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99, rightCount * x)), (x, y, _) => UniTask.Run(() => x * y)).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany(x => Enumerable.Range(99, rightCount * x), (x, y) => x * y).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).SelectManyAwaitWithCancellation((i, x, _) => UniTask.Run(() => UniTaskAsyncEnumerable.Range(99 * i, rightCount * x)), (x, y, _) => UniTask.Run(() => x * y)).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).SelectMany((i, x) => Enumerable.Range(99 * i, rightCount * x), (x, y) => x * y).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
 
@@ -219,17 +219,17 @@ namespace NetCoreTests.Linq
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).Zip(UniTaskAsyncEnumerable.Range(99, rightCount)).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).Zip(Enumerable.Range(99, rightCount)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).ZipAwait(UniTaskAsyncEnumerable.Range(99, rightCount), (x, y) => UniTask.Run(() => (x, y))).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).Zip(Enumerable.Range(99, rightCount)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await UniTaskAsyncEnumerable.Range(1, leftCount).ZipAwaitWithCancellation(UniTaskAsyncEnumerable.Range(99, rightCount), (x, y, _) => UniTask.Run(() => (x, y))).ToArrayAsync();
                 var ys = Enumerable.Range(1, leftCount).Zip(Enumerable.Range(99, rightCount)).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
         [Fact]
@@ -288,7 +288,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount).Select(x => string.Join(",", x)).ToArrayAsync();
             var ys = await AsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount).Select(x => string.Join(",", x)).ToArrayAsync();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Theory]
@@ -305,7 +305,7 @@ namespace NetCoreTests.Linq
             var xs = await UniTaskAsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount, skipCount).Select(x => string.Join(",", x)).ToArrayAsync();
             var ys = await AsyncEnumerable.Range(0, rangeCount).Buffer(bufferCount, skipCount).Select(x => string.Join(",", x)).ToArrayAsync();
 
-            xs.Should().BeEquivalentTo(ys);
+            xs.Should().Equal(ys);
         }
 
         [Fact]
@@ -402,7 +402,7 @@ namespace NetCoreTests.Linq
         public async Task PariwiseImmediate()
         {
             var xs = await UniTaskAsyncEnumerable.Range(1, 5).Pairwise().ToArrayAsync();
-            xs.Should().BeEquivalentTo((1, 2), (2, 3), (3, 4), (4, 5));
+            xs.Should().Equal((1, 2), (2, 3), (3, 4), (4, 5));
         }
 
         [Fact]
@@ -426,7 +426,7 @@ namespace NetCoreTests.Linq
 
             await complete;
 
-            list.Should().BeEquivalentTo((10, 20), (20, 30), (30, 40), (40, 50));
+            list.Should().Equal((10, 20), (20, 30), (30, 40), (40, 50));
         }
 
         class MyException : Exception

src/UniTask.NetCoreTests/Linq/PulbishTest.cs

@@ -26,7 +26,7 @@ namespace NetCoreTests.Linq
 
             rp.Value = 2;
 
-            (await b).Should().BeEquivalentTo(1, 2);
+            (await b).Should().Equal(1, 2);
 
             var c = multicast.ToArrayAsync();
 
@@ -36,8 +36,8 @@ namespace NetCoreTests.Linq
 
             rp.Dispose();
 
-            (await a).Should().BeEquivalentTo(1, 2, 3, 4, 5);
-            (await c).Should().BeEquivalentTo(3, 4, 5);
+            (await a).Should().Equal(1, 2, 3, 4, 5);
+            (await c).Should().Equal(3, 4, 5);
 
             disp.Dispose();
         }
@@ -56,7 +56,7 @@ namespace NetCoreTests.Linq
 
             rp.Value = 2;
 
-            (await b).Should().BeEquivalentTo(1, 2);
+            (await b).Should().Equal(1, 2);
 
             var c = multicast.ToArrayAsync();
 

src/UniTask.NetCoreTests/Linq/QueueTest.cs

@@ -23,7 +23,7 @@ namespace NetCoreTests.Linq
                 l.Add(x);
             });
 
-            l.Should().BeEquivalentTo(100, 110, 120, 130, 140, 150, 160, 170, 180, 190);
+            l.Should().Equal(100, 110, 120, 130, 140, 150, 160, 170, 180, 190);
         }
     }
 }

src/UniTask.NetCoreTests/Linq/Sets.cs

@@ -34,10 +34,10 @@ namespace NetCoreTests.Linq
         {
             var ys = array.Distinct().ToArray();
             {
-                (await array.ToUniTaskAsyncEnumerable().Distinct().ToArrayAsync()).Should().BeEquivalentTo(ys);
-                (await array.ToUniTaskAsyncEnumerable().Distinct(x => x).ToArrayAsync()).Should().BeEquivalentTo(ys);
-                (await array.ToUniTaskAsyncEnumerable().DistinctAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
-                (await array.ToUniTaskAsyncEnumerable().DistinctAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().Distinct().ToArrayAsync()).Should().Equal(ys);
+                (await array.ToUniTaskAsyncEnumerable().Distinct(x => x).ToArrayAsync()).Should().Equal(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys);
             }
         }
 
@@ -71,10 +71,10 @@ namespace NetCoreTests.Linq
         {
             var ys = await array.ToAsyncEnumerable().DistinctUntilChanged().ToArrayAsync();
             {
-                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChanged().ToArrayAsync()).Should().BeEquivalentTo(ys);
-                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChanged(x => x).ToArrayAsync()).Should().BeEquivalentTo(ys);
-                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
-                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().BeEquivalentTo(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChanged().ToArrayAsync()).Should().Equal(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChanged(x => x).ToArrayAsync()).Should().Equal(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwait(x => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys);
+                (await array.ToUniTaskAsyncEnumerable().DistinctUntilChangedAwaitWithCancellation((x, _) => UniTask.Run(() => x)).ToArrayAsync()).Should().Equal(ys);
             }
         }
 
@@ -112,7 +112,7 @@ namespace NetCoreTests.Linq
                 {
                     var xs = await a1.ToUniTaskAsyncEnumerable().Except(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync();
                     var ys = a1.Except(a2).ToArray();
-                    xs.Should().BeEquivalentTo(ys);
+                    xs.Should().Equal(ys);
                 }
             }
         }
@@ -141,7 +141,7 @@ namespace NetCoreTests.Linq
                 {
                     var xs = await a1.ToUniTaskAsyncEnumerable().Intersect(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync();
                     var ys = a1.Intersect(a2).ToArray();
-                    xs.Should().BeEquivalentTo(ys);
+                    xs.Should().Equal(ys);
                 }
             }
         }
@@ -170,7 +170,7 @@ namespace NetCoreTests.Linq
                 {
                     var xs = await a1.ToUniTaskAsyncEnumerable().Union(a2.ToUniTaskAsyncEnumerable()).ToArrayAsync();
                     var ys = a1.Union(a2).ToArray();
-                    xs.Should().BeEquivalentTo(ys);
+                    xs.Should().Equal(ys);
                 }
             }
         }

src/UniTask.NetCoreTests/Linq/Sort.cs

@@ -59,32 +59,32 @@ namespace NetCoreTests.Linq
             {
                 var xs = await array.ToUniTaskAsyncEnumerable().OrderBy(x => x).ToArrayAsync();
                 var ys = array.OrderBy(x => x).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x).ToArrayAsync();
                 var ys = array.OrderByDescending(x => x).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await array.ToUniTaskAsyncEnumerable().OrderByAwait(RandomRun).ToArrayAsync();
                 var ys = array.OrderBy(x => x).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(RandomRun).ToArrayAsync();
                 var ys = array.OrderByDescending(x => x).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation(RandomRun).ToArrayAsync();
                 var ys = array.OrderBy(x => x).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
             {
                 var xs = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation(RandomRun).ToArrayAsync();
                 var ys = array.OrderByDescending(x => x).ToArray();
-                xs.Should().BeEquivalentTo(ys);
+                xs.Should().Equal(ys);
             }
         }
 
@@ -125,14 +125,14 @@ namespace NetCoreTests.Linq
                     var g2 = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x.Age).ThenByDescending(x => x.FirstName).ThenBy(x => x.LastName).ToArrayAsync();
                     var h2 = await array.ToUniTaskAsyncEnumerable().OrderByDescending(x => x.Age).ThenByDescending(x => x.FirstName).ThenByDescending(x => x.LastName).ToArrayAsync();
 
-                    a.Should().BeEquivalentTo(a2);
-                    b.Should().BeEquivalentTo(b2);
-                    c.Should().BeEquivalentTo(c2);
-                    d.Should().BeEquivalentTo(d2);
-                    e.Should().BeEquivalentTo(e2);
-                    f.Should().BeEquivalentTo(f2);
-                    g.Should().BeEquivalentTo(g2);
-                    h.Should().BeEquivalentTo(h2);
+                    a.Should().Equal(a2);
+                    b.Should().Equal(b2);
+                    c.Should().Equal(c2);
+                    d.Should().Equal(d2);
+                    e.Should().Equal(e2);
+                    f.Should().Equal(f2);
+                    g.Should().Equal(g2);
+                    h.Should().Equal(h2);
                 }
                 {
                     var a2 = await array.ToUniTaskAsyncEnumerable().OrderByAwait(x => RandomRun(x.Age)).ThenByAwait(x => RandomRun(x.FirstName)).ThenByAwait(x => RandomRun(x.LastName)).ToArrayAsync();
@@ -144,14 +144,14 @@ namespace NetCoreTests.Linq
                     var g2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(x => RandomRun(x.Age)).ThenByDescendingAwait(x => RandomRun(x.FirstName)).ThenByAwait(x => RandomRun(x.LastName)).ToArrayAsync();
                     var h2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwait(x => RandomRun(x.Age)).ThenByDescendingAwait(x => RandomRun(x.FirstName)).ThenByDescendingAwait(x => RandomRun(x.LastName)).ToArrayAsync();
 
-                    a.Should().BeEquivalentTo(a2);
-                    b.Should().BeEquivalentTo(b2);
-                    c.Should().BeEquivalentTo(c2);
-                    d.Should().BeEquivalentTo(d2);
-                    e.Should().BeEquivalentTo(e2);
-                    f.Should().BeEquivalentTo(f2);
-                    g.Should().BeEquivalentTo(g2);
-                    h.Should().BeEquivalentTo(h2);
+                    a.Should().Equal(a2);
+                    b.Should().Equal(b2);
+                    c.Should().Equal(c2);
+                    d.Should().Equal(d2);
+                    e.Should().Equal(e2);
+                    f.Should().Equal(f2);
+                    g.Should().Equal(g2);
+                    h.Should().Equal(h2);
                 }
                 {
                     var a2 = await array.ToUniTaskAsyncEnumerable().OrderByAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
@@ -163,14 +163,14 @@ namespace NetCoreTests.Linq
                     var g2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
                     var h2 = await array.ToUniTaskAsyncEnumerable().OrderByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.Age)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.FirstName)).ThenByDescendingAwaitWithCancellation((x, ct) => RandomRun(x.LastName)).ToArrayAsync();
 
-                    a.Should().BeEquivalentTo(a2);
-                    b.Should().BeEquivalentTo(b2);
-                    c.Should().BeEquivalentTo(c2);
-                    d.Should().BeEquivalentTo(d2);
-                    e.Should().BeEquivalentTo(e2);
-                    f.Should().BeEquivalentTo(f2);
-                    g.Should().BeEquivalentTo(g2);
-                    h.Should().BeEquivalentTo(h2);
+                    a.Should().Equal(a2);
+                    b.Should().Equal(b2);
+                    c.Should().Equal(c2);
+                    d.Should().Equal(d2);
+                    e.Should().Equal(e2);
+                    f.Should().Equal(f2);
+                    g.Should().Equal(g2);
+                    h.Should().Equal(h2);
                 }
             }
         }

src/UniTask.NetCoreTests/Linq/TakeInfinityTest.cs

@@ -24,7 +24,7 @@ namespace NetCoreTests.Linq
             rp.Value = 4;
             rp.Value = 5;
 
-            (await xs).Should().BeEquivalentTo(1, 2, 3, 4, 5);
+            (await xs).Should().Equal(1, 2, 3, 4, 5);
         }
 
         [Fact]
@@ -39,7 +39,7 @@ namespace NetCoreTests.Linq
             rp.Value = 4;
             rp.Value = 5;
 
-            (await xs).Should().BeEquivalentTo(1, 2, 3, 4);
+            (await xs).Should().Equal(1, 2, 3, 4);
         }
 
         [Fact]
@@ -56,7 +56,7 @@ namespace NetCoreTests.Linq
             await c;
             var foo = await xs;
 
-            foo.Should().BeEquivalentTo(new[] { 1, 10, 20 });
+            foo.Should().Equal(new[] { 1, 10, 20 });
 
             async Task CancelAsync()
             {
@@ -85,7 +85,7 @@ namespace NetCoreTests.Linq
             await c;
             var foo = await xs;
 
-            foo.Should().BeEquivalentTo(new[] { 20, 30, 40 });
+            foo.Should().Equal(new[] { 20, 30, 40 });
 
             async Task CancelAsync()
             {
@@ -116,7 +116,7 @@ namespace NetCoreTests.Linq
             await c;
             var foo = await xs;
 
-            foo.Should().BeEquivalentTo(new[] { 1, 10, 20 });
+            foo.Should().Equal(new[] { 1, 10, 20 });
 
             async Task CancelAsync()
             {
@@ -145,7 +145,7 @@ namespace NetCoreTests.Linq
             await c;
             var foo = await xs;
 
-            foo.Should().BeEquivalentTo(new[] { 20, 30, 40 });
+            foo.Should().Equal(new[] { 20, 30, 40 });
 
             async Task CancelAsync()
             {

src/UniTask.NetCoreTests/TriggerEventTest.cs

@@ -34,7 +34,7 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
 
                 ev.SetCompleted();
 
@@ -46,7 +46,7 @@ namespace NetCoreTests
                 ev.SetCompleted();
                 ev.SetCanceled(default);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
                 one.CompletedCalled.Count.Should().Be(1);
             }
             // after removed, onemore
@@ -59,7 +59,7 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
 
                 ev.SetCompleted();
 
@@ -71,7 +71,7 @@ namespace NetCoreTests
                 ev.SetCompleted();
                 ev.SetCanceled(default);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
                 one.CompletedCalled.Count.Should().Be(1);
             }
         }
@@ -102,10 +102,10 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
+                four.NextCalled.Should().Equal(10, 20, 30);
 
                 ev.SetCompleted();
 
@@ -120,11 +120,11 @@ namespace NetCoreTests
                 ev.SetCompleted();
                 ev.SetCanceled(default);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
                 one.CompletedCalled.Count.Should().Be(1);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
                 three.CompletedCalled.Count.Should().Be(1);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
                 three.CompletedCalled.Count.Should().Be(1);
             }
 
@@ -145,10 +145,10 @@ namespace NetCoreTests
                 ev.SetResult(30);
                 ev.Add(four);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
+                four.NextCalled.Should().Equal(10, 20, 30);
 
                 ev.SetCompleted();
 
@@ -163,11 +163,11 @@ namespace NetCoreTests
                 ev.SetCompleted();
                 ev.SetCanceled(default);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
                 one.CompletedCalled.Count.Should().Be(1);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
                 three.CompletedCalled.Count.Should().Be(1);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
                 three.CompletedCalled.Count.Should().Be(1);
             }
         }
@@ -190,9 +190,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
 
                 ev.Remove(one);
 
@@ -200,9 +200,9 @@ namespace NetCoreTests
                 ev.SetResult(50);
                 ev.SetResult(60);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60);
+                three.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60);
             }
         }
         [Fact]
@@ -222,9 +222,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
 
                 ev.Remove(two);
 
@@ -232,9 +232,9 @@ namespace NetCoreTests
                 ev.SetResult(50);
                 ev.SetResult(60);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
+                one.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60);
             }
         }
         [Fact]
@@ -254,9 +254,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
 
                 ev.Remove(three);
 
@@ -264,9 +264,9 @@ namespace NetCoreTests
                 ev.SetResult(50);
                 ev.SetResult(60);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40, 50, 60);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60);
+                two.NextCalled.Should().Equal(10, 20, 30, 40, 50, 60);
+                three.NextCalled.Should().Equal(10, 20, 30);
             }
         }
 
@@ -321,9 +321,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
             }
 
             public void Run2()
@@ -342,9 +342,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
             }
 
             public void Run3()
@@ -363,9 +363,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10);
-                two.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10);
+                two.NextCalled.Should().Equal(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
             }
         }
 
@@ -390,9 +390,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
                 two.NextCalled.Count.Should().Be(0);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                three.NextCalled.Should().Equal(10, 20, 30);
             }
 
             public void Run2()
@@ -412,9 +412,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10);
+                three.NextCalled.Should().Equal(10, 20, 30);
             }
 
             public void Run3()
@@ -434,9 +434,9 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
-                two.NextCalled.Should().BeEquivalentTo(10);
-                three.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
+                two.NextCalled.Should().Equal(10);
+                three.NextCalled.Should().Equal(10, 20, 30);
             }
         }
 
@@ -464,10 +464,10 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                one.NextCalled.Should().Equal(10, 20, 30);
                 two.NextCalled.Count.Should().Be(0);
                 three.NextCalled.Count.Should().Be(0);
-                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                four.NextCalled.Should().Equal(10, 20, 30);
             }
 
             public void Run2()
@@ -490,10 +490,10 @@ namespace NetCoreTests
                 ev.SetResult(20);
                 ev.SetResult(30);
 
-                one.NextCalled.Should().BeEquivalentTo(10);
+                one.NextCalled.Should().Equal(10);
                 two.NextCalled.Count.Should().Be(0);
                 three.NextCalled.Count.Should().Be(0);
-                four.NextCalled.Should().BeEquivalentTo(10, 20, 30);
+                four.NextCalled.Should().Equal(10, 20, 30);
             }
 
 
@@ -533,10 +533,10 @@ namespace NetCoreTests
                 ev.SetResult(30);
                 ev.SetResult(40);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40);
-                two.NextCalled.Should().BeEquivalentTo(20, 30, 40);
-                three.NextCalled.Should().BeEquivalentTo(30, 40);
-                four.NextCalled.Should().BeEquivalentTo(40);
+                one.NextCalled.Should().Equal(10, 20, 30, 40);
+                two.NextCalled.Should().Equal(20, 30, 40);
+                three.NextCalled.Should().Equal(30, 40);
+                four.NextCalled.Should().Equal(40);
             }
 
             public void Run2()
@@ -573,10 +573,10 @@ namespace NetCoreTests
                 ev.SetResult(30);
                 ev.SetResult(40);
 
-                one.NextCalled.Should().BeEquivalentTo(10, 20, 30, 40);
-                two.NextCalled.Should().BeEquivalentTo(20, 30, 40);
-                three.NextCalled.Should().BeEquivalentTo(30, 40);
-                four.NextCalled.Should().BeEquivalentTo(40);
+                one.NextCalled.Should().Equal(10, 20, 30, 40);
+                two.NextCalled.Should().Equal(20, 30, 40);
+                three.NextCalled.Should().Equal(30, 40);
+                four.NextCalled.Should().Equal(40);
             }
         }
     }

src/UniTask/Assets/Plugins/UniTask/Runtime/CancellationTokenSourceExtensions.cs

@@ -4,32 +4,29 @@ using System.Threading;
 using UnityEngine;
 using Cysharp.Threading.Tasks.Triggers;
 using System;
+using Cysharp.Threading.Tasks.Internal;
 
 namespace Cysharp.Threading.Tasks
 {
 
-    public static class CancellationTokenSourceExtensions
+    public static partial class CancellationTokenSourceExtensions
     {
-        public static void CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        readonly static Action<object> CancelCancellationTokenSourceStateDelegate = new Action<object>(CancelCancellationTokenSourceState);
+
+        static void CancelCancellationTokenSourceState(object state)
         {
-            var delay = UniTask.Delay(millisecondsDelay, delayType, delayTiming, cts.Token);
-            CancelAfterCore(cts, delay).Forget();
+            var cts = (CancellationTokenSource)state;
+            cts.Cancel();
         }
 
-        public static void CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        public static IDisposable CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
         {
-            var delay = UniTask.Delay(delayTimeSpan, delayType, delayTiming, cts.Token);
-            CancelAfterCore(cts, delay).Forget();
+            return CancelAfterSlim(cts, TimeSpan.FromMilliseconds(millisecondsDelay), delayType, delayTiming);
         }
 
-        static async UniTaskVoid CancelAfterCore(CancellationTokenSource cts, UniTask delayTask)
+        public static IDisposable CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
         {
-            var alreadyCanceled = await delayTask.SuppressCancellationThrow();
-            if (!alreadyCanceled)
-            {
-                cts.Cancel();
-                cts.Dispose();
-            }
+            return PlayerLoopTimer.StartNew(delayTimeSpan, false, delayType, delayTiming, cts.Token, CancelCancellationTokenSourceStateDelegate, cts);
         }
 
         public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, Component component)
@@ -40,11 +37,7 @@ namespace Cysharp.Threading.Tasks
         public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, GameObject gameObject)
         {
             var trigger = gameObject.GetAsyncDestroyTrigger();
-            trigger.CancellationToken.RegisterWithoutCaptureExecutionContext(state =>
-            {
-                var cts2 = (CancellationTokenSource)state;
-                cts2.Cancel();
-            }, cts);
+            trigger.CancellationToken.RegisterWithoutCaptureExecutionContext(CancelCancellationTokenSourceStateDelegate, cts);
         }
     }
 }

src/UniTask/Assets/Plugins/UniTask/Runtime/Linq/AppendPrepend.cs

@@ -17,7 +17,7 @@ namespace Cysharp.Threading.Tasks.Linq
         {
             Error.ThrowArgumentNullException(source, nameof(source));
 
-            return new AppendPrepend<TSource>(source, element, true);
+            return new AppendPrepend<TSource>(source, element, false);
         }
     }
 
@@ -79,7 +79,7 @@ namespace Cysharp.Threading.Tasks.Linq
 
                 if (enumerator == null)
                 {
-                    if (state == State.RequireAppend)
+                    if (state == State.RequirePrepend)
                     {
                         Current = element;
                         state = State.None;

src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs

@@ -181,7 +181,7 @@ namespace Cysharp.Threading.Tasks
         static readonly ContinuationQueue ThrowMarkerContinuationQueue = new ContinuationQueue(PlayerLoopTiming.Initialization);
         static readonly PlayerLoopRunner ThrowMarkerPlayerLoopRunner = new PlayerLoopRunner(PlayerLoopTiming.Initialization);
 
-        public static SynchronizationContext UnitySynchronizationContext => unitySynchronizationContetext;
+        public static SynchronizationContext UnitySynchronizationContext => unitySynchronizationContext;
         public static int MainThreadId => mainThreadId;
         internal static string ApplicationDataPath => applicationDataPath;
 
@@ -189,7 +189,7 @@ namespace Cysharp.Threading.Tasks
 
         static int mainThreadId;
         static string applicationDataPath;
-        static SynchronizationContext unitySynchronizationContetext;
+        static SynchronizationContext unitySynchronizationContext;
         static ContinuationQueue[] yielders;
         static PlayerLoopRunner[] runners;
         internal static bool IsEditorApplicationQuitting { get; private set; }
@@ -289,7 +289,7 @@ namespace Cysharp.Threading.Tasks
         static void Init()
         {
             // capture default(unity) sync-context.
-            unitySynchronizationContetext = SynchronizationContext.Current;
+            unitySynchronizationContext = SynchronizationContext.Current;
             mainThreadId = Thread.CurrentThread.ManagedThreadId;
             try
             {

src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopTimer.cs

@@ -0,0 +1,262 @@
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using System;
+using Cysharp.Threading.Tasks.Internal;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks
+{
+    public abstract class PlayerLoopTimer : IDisposable, IPlayerLoopItem
+    {
+        readonly CancellationToken cancellationToken;
+        readonly Action<object> timerCallback;
+        readonly object state;
+        readonly PlayerLoopTiming playerLoopTiming;
+        readonly bool periodic;
+
+        bool isRunning;
+        bool tryStop;
+        bool isDisposed;
+
+        protected PlayerLoopTimer(bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
+        {
+            this.periodic = periodic;
+            this.playerLoopTiming = playerLoopTiming;
+            this.cancellationToken = cancellationToken;
+            this.timerCallback = timerCallback;
+            this.state = state;
+        }
+
+        public static PlayerLoopTimer Create(TimeSpan interval, bool periodic, DelayType delayType, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
+        {
+#if UNITY_EDITOR
+            // force use Realtime.
+            if (PlayerLoopHelper.IsMainThread && !UnityEditor.EditorApplication.isPlaying)
+            {
+                delayType = DelayType.Realtime;
+            }
+#endif
+
+            switch (delayType)
+            {
+                case DelayType.UnscaledDeltaTime:
+                    return new IgnoreTimeScalePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state);
+                case DelayType.Realtime:
+                    return new RealtimePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state);
+                case DelayType.DeltaTime:
+                default:
+                    return new DeltaTimePlayerLoopTimer(interval, periodic, playerLoopTiming, cancellationToken, timerCallback, state);
+            }
+        }
+
+        public static PlayerLoopTimer StartNew(TimeSpan interval, bool periodic, DelayType delayType, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
+        {
+            var timer = Create(interval, periodic, delayType, playerLoopTiming, cancellationToken, timerCallback, state);
+            timer.Restart();
+            return timer;
+        }
+
+        /// <summary>
+        /// Restart(Reset and Start) timer.
+        /// </summary>
+        public void Restart()
+        {
+            if (isDisposed) throw new ObjectDisposedException(null);
+
+            ResetCore(null); // init state
+            if (!isRunning)
+            {
+                isRunning = true;
+                PlayerLoopHelper.AddAction(playerLoopTiming, this);
+            }
+            tryStop = false;
+        }
+
+        /// <summary>
+        /// Restart(Reset and Start) and change interval.
+        /// </summary>
+        public void Restart(TimeSpan interval)
+        {
+            if (isDisposed) throw new ObjectDisposedException(null);
+
+            ResetCore(interval); // init state
+            if (!isRunning)
+            {
+                isRunning = true;
+                PlayerLoopHelper.AddAction(playerLoopTiming, this);
+            }
+            tryStop = false;
+        }
+
+        /// <summary>
+        /// Stop timer.
+        /// </summary>
+        public void Stop()
+        {
+            tryStop = true;
+        }
+
+        protected abstract void ResetCore(TimeSpan? newInterval);
+
+        public void Dispose()
+        {
+            isDisposed = true;
+        }
+
+        bool IPlayerLoopItem.MoveNext()
+        {
+            if (isDisposed)
+            {
+                isRunning = false;
+                return false;
+            }
+            if (tryStop)
+            {
+                isRunning = false;
+                return false;
+            }
+            if (cancellationToken.IsCancellationRequested)
+            {
+                isRunning = false;
+                return false;
+            }
+
+            if (!MoveNextCore())
+            {
+                timerCallback(state);
+
+                if (periodic)
+                {
+                    ResetCore(null);
+                    return true;
+                }
+                else
+                {
+                    isRunning = false;
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        protected abstract bool MoveNextCore();
+    }
+
+    sealed class DeltaTimePlayerLoopTimer : PlayerLoopTimer
+    {
+        int initialFrame;
+        float elapsed;
+        float interval;
+
+        public DeltaTimePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
+            : base(periodic, playerLoopTiming, cancellationToken, timerCallback, state)
+        {
+            ResetCore(interval);
+        }
+
+        protected override bool MoveNextCore()
+        {
+            if (elapsed == 0.0f)
+            {
+                if (initialFrame == Time.frameCount)
+                {
+                    return true;
+                }
+            }
+
+            elapsed += Time.deltaTime;
+            if (elapsed >= interval)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        protected override void ResetCore(TimeSpan? interval)
+        {
+            this.elapsed = 0.0f;
+            this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1;
+            if (interval != null)
+            {
+                this.interval = (float)interval.Value.TotalSeconds;
+            }
+        }
+    }
+
+    sealed class IgnoreTimeScalePlayerLoopTimer : PlayerLoopTimer
+    {
+        int initialFrame;
+        float elapsed;
+        float interval;
+
+        public IgnoreTimeScalePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
+            : base(periodic, playerLoopTiming, cancellationToken, timerCallback, state)
+        {
+            ResetCore(interval);
+        }
+
+        protected override bool MoveNextCore()
+        {
+            if (elapsed == 0.0f)
+            {
+                if (initialFrame == Time.frameCount)
+                {
+                    return true;
+                }
+            }
+
+            elapsed += Time.unscaledDeltaTime;
+            if (elapsed >= interval)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        protected override void ResetCore(TimeSpan? interval)
+        {
+            this.elapsed = 0.0f;
+            this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1;
+            if (interval != null)
+            {
+                this.interval = (float)interval.Value.TotalSeconds;
+            }
+        }
+    }
+
+    sealed class RealtimePlayerLoopTimer : PlayerLoopTimer
+    {
+        ValueStopwatch stopwatch;
+        long intervalTicks;
+
+        public RealtimePlayerLoopTimer(TimeSpan interval, bool periodic, PlayerLoopTiming playerLoopTiming, CancellationToken cancellationToken, Action<object> timerCallback, object state)
+            : base(periodic, playerLoopTiming, cancellationToken, timerCallback, state)
+        {
+            ResetCore(interval);
+        }
+
+        protected override bool MoveNextCore()
+        {
+            if (stopwatch.ElapsedTicks >= intervalTicks)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        protected override void ResetCore(TimeSpan? interval)
+        {
+            this.stopwatch = ValueStopwatch.StartNew();
+            if (interval != null)
+            {
+                this.intervalTicks = interval.Value.Ticks;
+            }
+        }
+    }
+}
+

src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopTimer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57095a17fdca7ee4380450910afc7f26
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/TimeoutController.cs

@@ -1,8 +1,7 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
-using System.Threading;
 using System;
-using Cysharp.Threading.Tasks.Internal;
+using System.Threading;
 
 namespace Cysharp.Threading.Tasks
 {
@@ -14,26 +13,44 @@ namespace Cysharp.Threading.Tasks
 
     public sealed class TimeoutController : IDisposable
     {
+        readonly static Action<object> CancelCancellationTokenSourceStateDelegate = new Action<object>(CancelCancellationTokenSourceState);
+
+        static void CancelCancellationTokenSourceState(object state)
+        {
+            var cts = (CancellationTokenSource)state;
+            cts.Cancel();
+        }
+
         CancellationTokenSource timeoutSource;
         CancellationTokenSource linkedSource;
-        StoppableDelayRealtimePromise timeoutDelay;
+        PlayerLoopTimer timer;
+        bool isDisposed;
 
+        readonly DelayType delayType;
+        readonly PlayerLoopTiming delayTiming;
         readonly CancellationTokenSource originalLinkCancellationTokenSource;
 
-        public TimeoutController()
+        public TimeoutController(DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
         {
             this.timeoutSource = new CancellationTokenSource();
             this.originalLinkCancellationTokenSource = null;
             this.linkedSource = null;
-            this.timeoutDelay = null;
+            this.delayType = delayType;
+            this.delayTiming = delayTiming;
         }
 
-        public TimeoutController(CancellationTokenSource linkCancellationTokenSource)
+        public TimeoutController(CancellationTokenSource linkCancellationTokenSource, DelayType delayType = DelayType.DeltaTime, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
         {
             this.timeoutSource = new CancellationTokenSource();
             this.originalLinkCancellationTokenSource = linkCancellationTokenSource;
             this.linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, linkCancellationTokenSource.Token);
-            this.timeoutDelay = null;
+            this.delayType = delayType;
+            this.delayTiming = delayTiming;
+        }
+
+        public CancellationToken Timeout(int millisecondsTimeout)
+        {
+            return Timeout(TimeSpan.FromMilliseconds(millisecondsTimeout));
         }
 
         public CancellationToken Timeout(TimeSpan timeout)
@@ -43,6 +60,7 @@ namespace Cysharp.Threading.Tasks
                 return originalLinkCancellationTokenSource.Token;
             }
 
+            // Timeouted, create new source and timer.
             if (timeoutSource.IsCancellationRequested)
             {
                 timeoutSource.Dispose();
@@ -53,18 +71,25 @@ namespace Cysharp.Threading.Tasks
                     this.linkedSource.Dispose();
                     this.linkedSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, originalLinkCancellationTokenSource.Token);
                 }
+
+                timer?.Dispose();
+                timer = null;
             }
 
-            if (timeoutDelay == null)
+            var useSource = (linkedSource != null) ? linkedSource : timeoutSource;
+            var token = useSource.Token;
+            if (timer == null)
             {
-                RunDelayAsync(timeout).Forget(); // timeoutDelay = ... in RunDelayAsync(immediately, before await)
+                // Timer complete => timeoutSource.Cancel() -> linkedSource will be canceled.
+                // (linked)token is canceled => stop timer
+                timer = PlayerLoopTimer.StartNew(timeout, false, delayType, delayTiming, token, CancelCancellationTokenSourceStateDelegate, timeoutSource);
             }
             else
             {
-                timeoutDelay.RestartStopwatch(); // already running RunDelayAsync
+                timer.Restart(timeout);
             }
 
-            return (linkedSource != null) ? linkedSource.Token : timeoutSource.Token;
+            return token;
         }
 
         public bool IsTimeout()
@@ -74,184 +99,30 @@ namespace Cysharp.Threading.Tasks
 
         public void Reset()
         {
-            if (timeoutDelay != null)
-            {
-                timeoutDelay.Stop(); // stop delay, will finish RunDelayAsync
-                timeoutDelay = null;
-            }
-        }
-
-        async UniTaskVoid RunDelayAsync(TimeSpan timeout)
-        {
-            timeoutDelay = StoppableDelayRealtimePromise.Create(timeout, PlayerLoopTiming.Update, (linkedSource == null) ? CancellationToken.None : linkedSource.Token, out var version);
-            try
-            {
-                var reason = await new UniTask<DelayResult>(timeoutDelay, version);
-                if (reason == DelayResult.DelayCompleted)
-                {
-                    // UnityEngine.Debug.Log("DEBUG:Timeout Complete, try to call timeoutSource.Cancel");
-                    timeoutSource.Cancel();
-                }
-                else if (reason == DelayResult.LinkedTokenCanceled)
-                {
-                    // UnityEngine.Debug.Log("DEBUG:LinkedSource IsCancellationRequested");
-                }
-                else if (reason == DelayResult.ExternalStopped)
-                {
-                    // Reset(Promise.Stop) called, do nothing.
-                    // UnityEngine.Debug.Log("DEBUG:Reset called");
-                }
-            }
-            finally
-            {
-                timeoutDelay = null;
-            }
+            timer.Stop();
         }
 
         public void Dispose()
         {
-            if (timeoutDelay != null)
+            if (isDisposed) return;
+
+            try
             {
-                timeoutDelay.Stop();
-            }
-            timeoutSource.Dispose();
-            if (linkedSource != null)
-            {
-                linkedSource.Dispose();
-            }
-        }
+                // stop timer.
+                timer.Dispose();
 
-        enum DelayResult
-        {
-            LinkedTokenCanceled,
-            ExternalStopped,
-            DelayCompleted, // as Timeout.
-        }
-
-        // Stop + SuppressCancellationThrow.
-        sealed class StoppableDelayRealtimePromise : IUniTaskSource<DelayResult>, IPlayerLoopItem, ITaskPoolNode<StoppableDelayRealtimePromise>
-        {
-            static OperationCanceledException ExterenalStopException = new OperationCanceledException();
-
-            static TaskPool<StoppableDelayRealtimePromise> pool;
-            StoppableDelayRealtimePromise nextNode;
-            public ref StoppableDelayRealtimePromise NextNode => ref nextNode;
-
-            static StoppableDelayRealtimePromise()
-            {
-                TaskPool.RegisterSizeGetter(typeof(StoppableDelayRealtimePromise), () => pool.Size);
-            }
-
-            long delayTimeSpanTicks;
-            ValueStopwatch stopwatch;
-            CancellationToken cancellationToken;
-            bool externalStop;
-
-            UniTaskCompletionSourceCore<DelayResult> core;
-
-            StoppableDelayRealtimePromise()
-            {
-            }
-
-            public static StoppableDelayRealtimePromise Create(TimeSpan delayTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
-            {
-                if (!pool.TryPop(out var result))
+                // cancel and dispose.
+                timeoutSource.Cancel();
+                timeoutSource.Dispose();
+                if (linkedSource != null)
                 {
-                    result = new StoppableDelayRealtimePromise();
-                }
-
-                result.stopwatch = ValueStopwatch.StartNew();
-                result.delayTimeSpanTicks = delayTimeSpan.Ticks;
-                result.cancellationToken = cancellationToken;
-                result.externalStop = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(timing, result);
-
-                token = result.core.Version;
-                return result;
-            }
-
-            public void Stop()
-            {
-                externalStop = true;
-            }
-
-            public void RestartStopwatch()
-            {
-                stopwatch = ValueStopwatch.StartNew();
-            }
-
-            public DelayResult GetResult(short token)
-            {
-                try
-                {
-                    return core.GetResult(token);
-                }
-                finally
-                {
-                    TryReturn();
+                    linkedSource.Cancel();
+                    linkedSource.Dispose();
                 }
             }
-
-            void IUniTaskSource.GetResult(short token)
+            finally
             {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    core.TrySetResult(DelayResult.LinkedTokenCanceled);
-                    return false;
-                }
-
-                if (externalStop)
-                {
-                    core.TrySetResult(DelayResult.ExternalStopped);
-                    return false;
-                }
-
-                if (stopwatch.IsInvalid)
-                {
-                    core.TrySetResult(DelayResult.DelayCompleted);
-                    return false;
-                }
-
-                if (stopwatch.ElapsedTicks >= delayTimeSpanTicks)
-                {
-                    core.TrySetResult(DelayResult.DelayCompleted);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                stopwatch = default;
-                cancellationToken = default;
-                externalStop = false;
-                return pool.TryPush(this);
+                isDisposed = true;
             }
         }
     }

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs

@@ -20,12 +20,23 @@ namespace Cysharp.Threading.Tasks
 
     public partial struct UniTask
     {
-        public static YieldAwaitable Yield(PlayerLoopTiming timing = PlayerLoopTiming.Update)
+        public static YieldAwaitable Yield()
+        {
+            // optimized for single continuation
+            return new YieldAwaitable(PlayerLoopTiming.Update);
+        }
+
+        public static YieldAwaitable Yield(PlayerLoopTiming timing)
         {
             // optimized for single continuation
             return new YieldAwaitable(timing);
         }
 
+        public static UniTask Yield(CancellationToken cancellationToken)
+        {
+            return new UniTask(YieldPromise.Create(PlayerLoopTiming.Update, cancellationToken, out var token), token);
+        }
+
         public static UniTask Yield(PlayerLoopTiming timing, CancellationToken cancellationToken)
         {
             return new UniTask(YieldPromise.Create(timing, cancellationToken, out var token), token);
@@ -34,11 +45,36 @@ namespace Cysharp.Threading.Tasks
         /// <summary>
         /// Similar as UniTask.Yield but guaranteed run on next frame.
         /// </summary>
-        public static UniTask NextFrame(PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default)
+        public static UniTask NextFrame()
+        {
+            return new UniTask(NextFramePromise.Create(PlayerLoopTiming.Update, CancellationToken.None, out var token), token);
+        }
+
+        /// <summary>
+        /// Similar as UniTask.Yield but guaranteed run on next frame.
+        /// </summary>
+        public static UniTask NextFrame(PlayerLoopTiming timing)
+        {
+            return new UniTask(NextFramePromise.Create(timing, CancellationToken.None, out var token), token);
+        }
+
+        /// <summary>
+        /// Similar as UniTask.Yield but guaranteed run on next frame.
+        /// </summary>
+        public static UniTask NextFrame(CancellationToken cancellationToken)
+        {
+            return new UniTask(NextFramePromise.Create(PlayerLoopTiming.Update, cancellationToken, out var token), token);
+        }
+
+        /// <summary>
+        /// Similar as UniTask.Yield but guaranteed run on next frame.
+        /// </summary>
+        public static UniTask NextFrame(PlayerLoopTiming timing, CancellationToken cancellationToken)
         {
             return new UniTask(NextFramePromise.Create(timing, cancellationToken, out var token), token);
         }
 
+
         /// <summary>
         /// Same as UniTask.Yield(PlayerLoopTiming.LastPostLateUpdate).
         /// </summary>

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskObservableExtensions.cs

@@ -58,6 +58,7 @@ namespace Cysharp.Threading.Tasks
             {
                 try
                 {
+                    task.GetAwaiter().GetResult();
                     return new ReturnObservable<AsyncUnit>(AsyncUnit.Default);
                 }
                 catch (Exception ex)

src/UniTask/Assets/Plugins/UniTask/package.json

@@ -1,7 +1,7 @@
 {
     "name": "com.cysharp.unitask",
     "displayName": "UniTask",
-    "version": "2.2.1",
+    "version": "2.2.5",
     "unity": "2018.4",
     "description": "Provides an efficient async/await integration to Unity.",
     "keywords": [ "async/await", "async", "Task", "UniTask" ],

src/UniTask/Assets/Tests/PlayerLoopTimerTest.cs

@@ -0,0 +1,179 @@
+using Cysharp.Threading.Tasks;
+using FluentAssertions;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using UnityEngine.TestTools;
+
+namespace Cysharp.Threading.TasksTests
+{
+    public class PlayerLoopTimerTest
+    {
+        void Between(TimeSpan l, TimeSpan data, TimeSpan r)
+        {
+            NUnit.Framework.Assert.AreEqual(l < data, true, "{0} < {1} failed.", l, data);
+            NUnit.Framework.Assert.AreEqual(data < r, true, "{0} < {1} failed.", data, r);
+        }
+
+        [UnityTest]
+        public IEnumerator StandardTicks() => UniTask.ToCoroutine(async () =>
+        {
+            foreach (var delay in new[] { DelayType.DeltaTime, DelayType.Realtime, DelayType.UnscaledDeltaTime })
+            {
+                var raisedTimeout = new UniTaskCompletionSource();
+                PlayerLoopTimer.StartNew(TimeSpan.FromSeconds(1), false, delay, PlayerLoopTiming.Update, CancellationToken.None, _ =>
+                {
+                    raisedTimeout.TrySetResult();
+                }, null);
+
+
+                var sw = Stopwatch.StartNew();
+                await raisedTimeout.Task;
+                sw.Stop();
+
+                Between(TimeSpan.FromSeconds(0.9), sw.Elapsed, TimeSpan.FromSeconds(1.1));
+            }
+        });
+
+
+        [UnityTest]
+        public IEnumerator Periodic() => UniTask.ToCoroutine(async () =>
+        {
+            var raisedTime = new List<DateTime>();
+            var count = 0;
+            var complete = new UniTaskCompletionSource();
+
+            PlayerLoopTimer timer = null;
+            timer = PlayerLoopTimer.StartNew(TimeSpan.FromSeconds(1), true, DelayType.DeltaTime, PlayerLoopTiming.Update, CancellationToken.None, _ =>
+            {
+                raisedTime.Add(DateTime.UtcNow);
+                count++;
+                if (count == 3)
+                {
+                    complete.TrySetResult();
+                    timer.Dispose();
+                }
+            }, null);
+
+            var start = DateTime.UtcNow;
+            await complete.Task;
+
+            Between(TimeSpan.FromSeconds(0.9), raisedTime[0] - start, TimeSpan.FromSeconds(1.1));
+            Between(TimeSpan.FromSeconds(1.9), raisedTime[1] - start, TimeSpan.FromSeconds(2.1));
+            Between(TimeSpan.FromSeconds(2.9), raisedTime[2] - start, TimeSpan.FromSeconds(3.1));
+        });
+
+        [UnityTest]
+        public IEnumerator CancelAfterSlimTest() => UniTask.ToCoroutine(async () =>
+        {
+            var cts = new CancellationTokenSource();
+            var complete = new UniTaskCompletionSource();
+            cts.Token.RegisterWithoutCaptureExecutionContext(() =>
+            {
+                complete.TrySetResult();
+            });
+
+            cts.CancelAfterSlim(TimeSpan.FromSeconds(1));
+
+            var sw = Stopwatch.StartNew();
+            await complete.Task;
+
+            Between(TimeSpan.FromSeconds(0.9), sw.Elapsed, TimeSpan.FromSeconds(1.1));
+        });
+
+        [UnityTest]
+        public IEnumerator CancelAfterSlimCancelTest() => UniTask.ToCoroutine(async () =>
+        {
+            var cts = new CancellationTokenSource();
+            var complete = new UniTaskCompletionSource();
+            cts.Token.RegisterWithoutCaptureExecutionContext(() =>
+            {
+                complete.TrySetResult();
+            });
+
+            var d = cts.CancelAfterSlim(TimeSpan.FromSeconds(1));
+
+            var sw = Stopwatch.StartNew();
+
+            await UniTask.Delay(TimeSpan.FromMilliseconds(100));
+            d.Dispose();
+
+            await UniTask.Delay(TimeSpan.FromSeconds(2));
+
+            complete.Task.Status.Should().Be(UniTaskStatus.Pending);
+        });
+
+        [UnityTest]
+        public IEnumerator TimeoutController() => UniTask.ToCoroutine(async () =>
+        {
+            var controller = new TimeoutController();
+
+            var token = controller.Timeout(TimeSpan.FromSeconds(1));
+
+            var complete = new UniTaskCompletionSource();
+            token.RegisterWithoutCaptureExecutionContext(() =>
+            {
+                complete.TrySetResult();
+            });
+
+            var sw = Stopwatch.StartNew();
+            await complete.Task;
+            Between(TimeSpan.FromSeconds(0.9), sw.Elapsed, TimeSpan.FromSeconds(1.1));
+
+            controller.IsTimeout().Should().BeTrue();
+        });
+
+
+        [UnityTest]
+        public IEnumerator TimeoutReuse() => UniTask.ToCoroutine(async () =>
+        {
+            var controller = new TimeoutController(DelayType.DeltaTime);
+
+            var token = controller.Timeout(TimeSpan.FromSeconds(2));
+
+            var complete = new UniTaskCompletionSource();
+            token.RegisterWithoutCaptureExecutionContext(() =>
+            {
+                complete.TrySetResult(); // reuse, used same token?
+            });
+
+            await UniTask.Delay(TimeSpan.FromMilliseconds(100));
+            controller.Reset();
+
+            controller.IsTimeout().Should().BeFalse();
+
+            var sw = Stopwatch.StartNew();
+
+            controller.Timeout(TimeSpan.FromSeconds(5));
+
+            await complete.Task;
+
+            UnityEngine.Debug.Log(UnityEngine.Time.timeScale);
+            Between(TimeSpan.FromSeconds(4.9), sw.Elapsed, TimeSpan.FromSeconds(5.1));
+
+            controller.IsTimeout().Should().BeTrue();
+        });
+
+        [UnityTest]
+        public IEnumerator LinkedTokenTest() => UniTask.ToCoroutine(async () =>
+        {
+            var cts = new CancellationTokenSource();
+
+            var controller = new TimeoutController(cts);
+            var token = controller.Timeout(TimeSpan.FromSeconds(2));
+
+            await UniTask.DelayFrame(3);
+
+            cts.Cancel();
+
+            token.IsCancellationRequested.Should().BeTrue();
+
+            controller.Dispose();
+        });
+    }
+}

src/UniTask/Assets/Tests/PlayerLoopTimerTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c0c49de697f829f44aa8709b4d1eff3e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: