diff --git a/src/libraries/System.Linq.AsyncEnumerable/tests/SequenceTests.cs b/src/libraries/System.Linq.AsyncEnumerable/tests/SequenceTests.cs
index 00ef5f25452ca8..7f7c1dcd05e82a 100644
--- a/src/libraries/System.Linq.AsyncEnumerable/tests/SequenceTests.cs
+++ b/src/libraries/System.Linq.AsyncEnumerable/tests/SequenceTests.cs
@@ -51,25 +51,28 @@ static void ValidateSigned<T>() where T : INumber<T>
             {
                 ValidateUnsigned<T>();
 
-                for (int i = 1; i < 3; i++)
-                {
-                    Assert.NotNull(AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(-i)));
-                }
+                // Test negative steps from 123 to 122
+                // step=-1: should give [123, 122] (2 elements)
+                // step=-2: should give [123] (1 element, step too large)
+                Assert.Equal(2, AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(-1)).CountAsync().Result);
+                Assert.Single(AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(-2)));
 
                 ValidateThrows(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(-2));
             }
 
             static void ValidateUnsigned<T>() where T : INumber<T>
             {
+                // When start == end, all steps should return single element [123]
                 for (int i = 0; i < 3; i++)
                 {
-                    Assert.NotNull(AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(123), T.CreateTruncating(i)));
+                    Assert.Single(AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(123), T.CreateTruncating(i)));
                 }
 
-                for (int i = 1; i < 3; i++)
-                {
-                    Assert.NotNull(AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(i)));
-                }
+                // Test positive steps from 123 to 124
+                // step=1: should give [123, 124] (2 elements)
+                // step=2: should give [123] (1 element, step too large)
+                Assert.Equal(2, AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(1)).CountAsync().Result);
+                Assert.Single(AsyncEnumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(2)));
 
                 ValidateThrows(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(2));
             }
diff --git a/src/libraries/System.Linq/tests/SequenceTests.cs b/src/libraries/System.Linq/tests/SequenceTests.cs
index 18a8fbd880749e..7c39f7437bd69c 100644
--- a/src/libraries/System.Linq/tests/SequenceTests.cs
+++ b/src/libraries/System.Linq/tests/SequenceTests.cs
@@ -50,25 +50,28 @@ static void ValidateSigned<T>() where T : INumber<T>
             {
                 ValidateUnsigned<T>();
 
-                for (int i = 1; i < 3; i++)
-                {
-                    Assert.NotNull(Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(-i)));
-                }
+                // Test negative steps from 123 to 122
+                // step=-1: should give [123, 122] (2 elements)
+                // step=-2: should give [123] (1 element, step too large)
+                Assert.Equal(2, Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(-1)).Count());
+                Assert.Single(Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(-2)));
 
                 ValidateThrows(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(-2));
             }
 
             static void ValidateUnsigned<T>() where T : INumber<T>
             {
+                // When start == end, all steps should return single element [123]
                 for (int i = 0; i < 3; i++)
                 {
-                    Assert.NotNull(Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(123), T.CreateTruncating(i)));
+                    Assert.Single(Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(123), T.CreateTruncating(i)));
                 }
 
-                for (int i = 1; i < 3; i++)
-                {
-                    Assert.NotNull(Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(i)));
-                }
+                // Test positive steps from 123 to 124
+                // step=1: should give [123, 124] (2 elements)
+                // step=2: should give [123] (1 element, step too large)
+                Assert.Equal(2, Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(1)).Count());
+                Assert.Single(Enumerable.Sequence(T.CreateTruncating(123), T.CreateTruncating(124), T.CreateTruncating(2)));
 
                 ValidateThrows(T.CreateTruncating(123), T.CreateTruncating(122), T.CreateTruncating(2));
             }