Fix AttemptAcquire(0) when token isn't available

src/libraries/System.Threading.RateLimiting/src/System/Threading/RateLimiting/TokenBucketRateLimiter.cs

@@ -112,7 +112,7 @@ protected override RateLimitLease AttemptAcquireCore(int tokenCount)
             // Return SuccessfulLease or FailedLease depending to indicate limiter state
             if (tokenCount == 0 && !_disposed)
             {
-                if (_tokenCount > 0)
+                if (_tokenCount >= 1)
                 {
                     Interlocked.Increment(ref _successfulLeasesCount);
                     return SuccessfulLease;
@@ -146,7 +146,7 @@ protected override ValueTask<RateLimitLease> AcquireAsyncCore(int tokenCount, Ca
             ThrowIfDisposed();
 
             // Return SuccessfulAcquisition if requestedCount is 0 and resources are available
-            if (tokenCount == 0 && _tokenCount > 0)
+            if (tokenCount == 0 && _tokenCount >= 1)
             {
                 Interlocked.Increment(ref _successfulLeasesCount);
                 return new ValueTask<RateLimitLease>(SuccessfulLease);
@@ -227,7 +227,7 @@ private bool TryLeaseUnsynchronized(int tokenCount, [NotNullWhen(true)] out Rate
             ThrowIfDisposed();
 
             // if permitCount is 0 we want to queue it if there are no available permits
-            if (_tokenCount >= tokenCount && _tokenCount != 0)
+            if (_tokenCount >= tokenCount && _tokenCount >= 1)
             {
                 if (tokenCount == 0)
                 {
@@ -336,7 +336,7 @@ private void ReplenishInternal(long nowTicks)
                             : queue.DequeueTail();
                         disposer.Add(nextPendingRequest);
                     }
-                    else if (_tokenCount >= nextPendingRequest.Count)
+                    else if (_tokenCount >= nextPendingRequest.Count && (nextPendingRequest.Count > 0 || _tokenCount >= 1))
                     {
                         // Request can be fulfilled
                         nextPendingRequest =

src/libraries/System.Threading.RateLimiting/tests/TokenBucketRateLimiterTests.cs

@@ -464,6 +464,96 @@ public override void AcquireZero_WithoutAvailability()
             lease2.Dispose();
         }
 
+        [Fact]
+        public void AcquireZero_WithFractionalTokens_Fails()
+        {
+            var limiter = new TokenBucketRateLimiter(new TokenBucketRateLimiterOptions
+            {
+                TokenLimit = 3,
+                QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
+                QueueLimit = 1,
+                ReplenishmentPeriod = TimeSpan.FromMilliseconds(2),
+                TokensPerPeriod = 1,
+                AutoReplenishment = false
+            });
+
+            using var lease1 = limiter.AttemptAcquire(3);
+            Assert.True(lease1.IsAcquired);
+            Assert.Equal(0, limiter.GetStatistics()!.CurrentAvailablePermits);
+
+            // Replenish a fractional amount (less than 1 token)
+            // With ReplenishmentPeriod=2ms and TokensPerPeriod=1, replenishing 1ms adds 0.5 tokens
+            Replenish(limiter, 1);
+
+            // Statistics should still report 0 available permits (fractional tokens truncated)
+            Assert.Equal(0, limiter.GetStatistics()!.CurrentAvailablePermits);
+
+            // AttemptAcquire(0) should fail when there are only fractional tokens
+            var lease2 = limiter.AttemptAcquire(0);
+            Assert.False(lease2.IsAcquired);
+            lease2.Dispose();
+        }
+
+        [Fact]
+        public async Task AcquireAsyncZero_WithFractionalTokens_Queues()
+        {
+            var limiter = new TokenBucketRateLimiter(new TokenBucketRateLimiterOptions
+            {
+                TokenLimit = 3,
+                QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
+                QueueLimit = 1,
+                ReplenishmentPeriod = TimeSpan.FromMilliseconds(2),
+                TokensPerPeriod = 1,
+                AutoReplenishment = false
+            });
+
+            using var lease1 = limiter.AttemptAcquire(3);
+            Assert.True(lease1.IsAcquired);
+
+            Replenish(limiter, 1);
+            Assert.Equal(0, limiter.GetStatistics()!.CurrentAvailablePermits);
+
+            var acquireTask = limiter.AcquireAsync(0);
+            Assert.False(acquireTask.IsCompleted);
+
+            Replenish(limiter, 1);
+            using var lease2 = await acquireTask;
+            Assert.True(lease2.IsAcquired);
+        }
+
+        [Fact]
+        public async Task AcquireAsyncZero_QueuedRequest_NotFulfilledWithFractionalTokens()
+        {
+            var limiter = new TokenBucketRateLimiter(new TokenBucketRateLimiterOptions
+            {
+                TokenLimit = 3,
+                QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
+                QueueLimit = 1,
+                ReplenishmentPeriod = TimeSpan.FromMilliseconds(4),
+                TokensPerPeriod = 1,
+                AutoReplenishment = false
+            });
+
+            using var lease1 = limiter.AttemptAcquire(3);
+            Assert.True(lease1.IsAcquired);
+            Assert.Equal(0, limiter.GetStatistics()!.CurrentAvailablePermits);
+
+            Replenish(limiter, 2);
+            Assert.Equal(0, limiter.GetStatistics()!.CurrentAvailablePermits);
+
+            var acquireTask = limiter.AcquireAsync(0);
+            Assert.False(acquireTask.IsCompleted);
+
+            Replenish(limiter, 1);
+            Assert.Equal(0, limiter.GetStatistics()!.CurrentAvailablePermits);
+            Assert.False(acquireTask.IsCompleted);
+
+            Replenish(limiter, 1);
+            Assert.Equal(1, limiter.GetStatistics()!.CurrentAvailablePermits);
+            using var lease2 = await acquireTask;
+            Assert.True(lease2.IsAcquired);
+        }
+
         [Fact]
         public override async Task AcquireAsyncZero_WithAvailability()
         {