}

    @ParameterizedTest
    @DisplayName("Test with various timeout values")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 1000L, -1000L })
    void testWithVariousTimeoutValues(long timeout) {
        // Setup
        String pipeName = "TestPipe";
        FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName, timeout);

                                        <input type="number" name="depth" id="depth"
                                               value="${f:h(depth)}" class="form-control"
                                               min="0" max="10000">
                                    </div>
                                </div>
                                <div class="form-group row">

        }

        @Test
        void shouldReturnInetAddressFromWrappedAddressWhenWrappedIsAddress() throws UnknownHostException {
            InetAddress expectedInetAddress = InetAddress.getByName("10.0.0.1");
            when(mockAddress.toInetAddress()).thenReturn(expectedInetAddress);
            UniAddress uniAddress = new UniAddress(mockAddress);
            assertEquals(expectedInetAddress, uniAddress.toInetAddress());

		}
		srvRecord.Key = strings.TrimPrefix(string(n.Key), key)
		srvRecord.Key = strings.TrimSuffix(srvRecord.Key, srvRecord.Host)

		// Skip non-bucket entry like for a key
		// /skydns/net/miniocloud/10.0.0.1 that may exist as
		// dns entry for the server (rather than the bucket
		// itself).
		if srvRecord.Key == "" {
			continue
		}

		srvRecord.Key = msgUnPath(srvRecord.Key)

    assertThat(min(NUMBERS)).isEqualTo(LEAST);
    assertThat(Double.isNaN(min(VALUES))).isTrue();
  }

  public void testConstrainToRange() {
    assertThat(Doubles.constrainToRange(1.0, 0.0, 5.0)).isEqualTo(1.0);
    assertThat(Doubles.constrainToRange(1.0, 1.0, 5.0)).isEqualTo(1.0);
    assertThat(Doubles.constrainToRange(1.0, 3.0, 5.0)).isEqualTo(3.0);

            assertEquals(2000L * 4 * 1024, fileFsSizeInfo.getCapacity());
            assertEquals(2000L * 4 * 1024, fileFsSizeInfo.getCapacity());
            assertEquals(1000L * 4 * 1024, fileFsSizeInfo.getFree());
            assertEquals(1000L * 4 * 1024, fileFsSizeInfo.getFree());
        }

        @Test
        @DisplayName("Should update state on subsequent decode calls")

        assertEquals(2, conservativePolicy.getMaxAttempts());
        assertEquals(2000, conservativePolicy.getInitialDelayMs());
        assertEquals(10000, conservativePolicy.getMaxDelayMs());
        assertEquals(3.0, conservativePolicy.getBackoffMultiplier());
        assertTrue(conservativePolicy.isExponentialBackoff());

        // NO_RETRY policy

    private final Queue<WitnessNotification> pendingNotifications;
    private final ScheduledExecutorService scheduler;
    private final int batchSize = 10;
    private final long batchTimeout = 100;  // 100ms
    
    public void addNotification(WitnessNotification notification) {
        synchronized (pendingNotifications) {
            pendingNotifications.offer(notification);
            

    // Defer correctness tests to Long.isPrime

    // Check the first 100,000 integers
    for (int i = 0; i < 100000; i++) {
      assertEquals(LongMath.isPrime(i), IntMath.isPrime(i));
    }

    // Then check 1000 deterministic pseudo-random int values.
    Random rand = new Random(1);
    for (int i = 0; i < 1000; i++) {
      int n = rand.nextInt(Integer.MAX_VALUE);
      assertEquals(LongMath.isPrime(n), IntMath.isPrime(n));

        }

        @Test
        @DisplayName("Should decode efficiently for large buffers")
        void testLargeBufferDecoding() throws SMBProtocolDecodingException {
            byte[] largeBuffer = new byte[10000];
            FileFsSizeInformation info = new FileFsSizeInformation();

            long startTime = System.nanoTime();
            info.decode(largeBuffer, 0, 24);
            long endTime = System.nanoTime();