}
    }

    /**
     * Static factory for file handle exhaustion
     */
    public static SmbResourceException fileHandleExhausted(int errorCode) {
        return new SmbResourceException("File handle limit exceeded", errorCode, ResourceType.FILE_HANDLE);
    }

    /**
     * Static factory for connection pool exhaustion
     */

        assertEquals("b", it.next().getName(), "Next element should skip '.' and '..'");
        assertFalse(it.hasNext(), "Iterator exhausted after valid entries");
        verify(tree, times(1)).release(); // closed after exhaustion
    }

    @ParameterizedTest
    @ValueSource(strings = { "", "file.txt", "subdir" })
    @DisplayName("Name filter interaction: accept calls and rejections")

 * {@link PriorityQueue} and supplies blocking retrieval operations. While this queue is logically
 * unbounded, attempted additions may fail due to resource exhaustion (causing {@code
 * OutOfMemoryError}). This class does not permit {@code null} elements. A priority queue relying on
 * {@linkplain Comparable natural ordering} also does not permit insertion of non-comparable objects

        });

        assertTrue(exception.getMessage().contains("Invalid negotiate context count: 65535"));
    }

    /**
     * Test validation of excessive buffer sizes to prevent resource exhaustion.
     */
    @Test
    public void testExcessiveBufferSizes() {
        byte[] buffer = createBasicNegotiateResponseBuffer();

        // Test excessive maxTransactSize (> 16MB)

        this.maxReadSize = SMBUtil.readInt4(buffer, bufferIndex + 4);
        this.maxWriteSize = SMBUtil.readInt4(buffer, bufferIndex + 8);

        // Validate reasonable buffer sizes to prevent resource exhaustion
        if (this.maxTransactSize < 0 || this.maxTransactSize > 16777216) { // 16MB max
            throw new SMBProtocolDecodingException("Invalid maxTransactSize: " + this.maxTransactSize + " (must be 0-16777216)");
        }

                    val source = responseBody.source()
                    if (source.isOpen) {
                      source.skipAll()
                    }
                    return peek() ?: error("null trailers after exhausting response body?!")
                  }
                },
              ).build()
          }
        }
      if ("close".equals(response.request.header("Connection"), ignoreCase = true) ||

- Fixed an ephemeral port exhaustion bug caused by improper connection management that occurred when a large number of objects were handled by `kubectl` while exec auth was in use. ([#112017](https://github.com/kubernetes/kubernetes/pull/112017), [@enj](https://github.com/enj))

import com.google.common.collect.Iterables;
import com.google.common.primitives.Doubles;
import java.math.BigInteger;
import java.math.RoundingMode;
import org.jspecify.annotations.NullUnmarked;

/**
 * Exhaustive input sets for every integral type.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullUnmarked
public final class MathTesting {
  static final ImmutableSet<RoundingMode> ALL_ROUNDING_MODES =

   * response body. Call `body.source().request(1024 * 1024)` to block until either that's done, or
   * 1 MiB of response data is loaded into memory. (You could use any size here, though large values
   * risk exhausting memory.)
   *
   * This returns an empty value if the trailers are available, but have no data.
   *
   * It is not safe to call this concurrently with code that is processing the response body.
   *

              }
            });

    List<String> actual = newArrayList(result);
    List<String> expected = asList("1", "2", "null", "3");
    assertEquals(expected, actual);
  }

  // Far less exhaustive than the tests in IteratorsTest
  public void testCycle() {
    Iterable<String> cycle = Iterables.cycle("a", "b");

    int howManyChecked = 0;
    for (String string : cycle) {