class NameServiceClient implements Runnable {

    static final int DEFAULT_SO_TIMEOUT = 5000;
    static final int DEFAULT_RCV_BUF_SIZE = 576;
    static final int DEFAULT_SND_BUF_SIZE = 576;
    static final int NAME_SERVICE_UDP_PORT = 137;
    static final int DEFAULT_RETRY_COUNT = 2;
    static final int DEFAULT_RETRY_TIMEOUT = 3000;

    static final int RESOLVER_LMHOSTS = 1;
    static final int RESOLVER_BCAST = 2;

    @Test
    public void test_doFilter_differentOrigins() throws Exception {
        String[] origins = { "http://localhost:8080", "https://example.com", "http://subdomain.example.com", "https://example.com:3000" };

        for (String origin : origins) {
            resetMocks(); // Reset for each test
            mockRequest.setHeader("Origin", origin);
            mockRequest.setMethod("GET");

        SMBUtil.writeInt4(-1000, buffer, bufferIndex + 11);
        SMBUtil.writeInt4(0, buffer, bufferIndex + 15);
        SMBUtil.writeInt4(0, buffer, bufferIndex + 19);
        SMBUtil.writeInt4(-5000, buffer, bufferIndex + 23);
        SMBUtil.writeInt4(0, buffer, bufferIndex + 27);
        SMBUtil.writeInt4(0, buffer, bufferIndex + 31);
        buffer[bufferIndex + 35] = (byte) 0x80; // 128 as unsigned

@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public final class TestThread<L> extends Thread implements TearDown {

  private static final long DUE_DILIGENCE_MILLIS = 100;
  private static final long TIMEOUT_MILLIS = 5000;

  private final L lockLikeObject;

  private final SynchronousQueue<Request> requestQueue = new SynchronousQueue<>();
  private final SynchronousQueue<Response> responseQueue = new SynchronousQueue<>();

MINIMIZED_COMMENTS_REASONS_TO_EXCLUDE = {"abuse", "off-topic", "duplicate", "spam"}


class RateLimiter:
    def __init__(self) -> None:
        self.last_query_cost: int = 1
        self.remaining_points: int = 5000
        self.reset_at: datetime = datetime.fromtimestamp(0, timezone.utc)
        self.last_request_start_time: datetime = datetime.fromtimestamp(0, timezone.utc)
        self.speed_multiplier: float = 1.0

## ref: http://kubernetes.io/docs/user-guide/services/
##
service:
  type: ClusterIP
  clusterIP: ~
  port: "9000"
  nodePort: 32000
  loadBalancerIP: ~
  externalIPs: []
  annotations: {}

  ## service.loadBalancerSourceRanges Addresses that are allowed when service is LoadBalancer

        format.formatRate(builder, 5.0);
        assertEquals("5.0 B/s", builder.build());

        // Test kilobytes per second
        builder = new DefaultMessageBuilder();
        format.formatRate(builder, 5500.0);
        assertEquals("5.5 kB/s", builder.build());

        // Test megabytes per second
        builder = new DefaultMessageBuilder();
        format.formatRate(builder, 5500000.0);

        System.out.printf("  Avg atomic operation time: %.2f ns%n", avgOpTimeNs);

        // Verify lock-free performance (allowing for JVM overhead)
        assertTrue(avgOpTimeNs < 5000, "Atomic operations should be reasonably fast (no lock contention)");
        assertEquals(threadCount * operationsPerThread, operations.get());

        assertEquals((byte) 0x00, getFieldValue(netServerEnum2, "maxSetupCount"));
        assertEquals(0, getFieldValue(netServerEnum2, "setupCount"));
        assertEquals(5000, getFieldValue(netServerEnum2, "timeout"));
    }

    @Test
    @DisplayName("Test constructor with empty domain")
    void testConstructorEmptyDomain() {
        String domain = "";

        }
        assertEqualsUsingSeed(seed, expected, elements);
      }
    }
  }

  public void testCorrectOrdering_mediumHeapsPollFirst() {
    for (int attempts = 0; attempts < reduceIterationsIfGwt(5000); attempts++) {
      int size = new Random().nextInt(256) + 16;
      ArrayList<Integer> elements = createOrderedList(size);
      List<Integer> expected = ImmutableList.copyOf(elements);