Arguments.of((LongGetter) FileEntry::length, -100L, "negative length"),
                Arguments.of((LongGetter) FileEntry::length, 0L, "zero length"),
                Arguments.of((LongGetter) FileEntry::length, 1L, "small length"));
    }

    @ParameterizedTest(name = "Long getter {2} returns {1}")
    @MethodSource("longGetterProvider")
    void longGetters_edgeCases(LongGetter getter, long value, String label) {
        // Arrange

## Server Machine and Server Program { #server-machine-and-server-program }

There's a small detail about names to keep in mind. 💡

The word "**server**" is commonly used to refer to both the remote/cloud computer (the physical or virtual machine) and also the program that is running on that machine (e.g. Uvicorn).

    }

    @Test
    @DisplayName("Test buffer overflow protection")
    void testBufferOverflowProtection() {
        byte[] smallBuffer = new byte[23]; // One byte too small

        // Should throw ArrayIndexOutOfBoundsException
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            request.writeBytesWireFormat(smallBuffer, 0);
        });
    }

        System.arraycopy(body, 0, packet, header.length, body.length);

        BaseConfiguration config = new BaseConfiguration(true);
        byte[] outBuf = new byte[4]; // too small
        Smb2IoctlResponse resp = new Smb2IoctlResponse(config, outBuf);
        assertThrows(SMBProtocolDecodingException.class, () -> resp.decode(packet, 0));
    }

    @Test

        assertTrue(response.hasMoreElements());
    }

    @Test
    @DisplayName("Test data handling with various sizes")
    void testDataHandlingWithVariousSizes() {
        // Test with small data count
        response.setDataCount(10);
        assertEquals(10, response.getDataCount());

        // Test with large data count
        response.setDataCount(65535);

    ImmutableSet.Builder<Double> fractionalBuilder = ImmutableSet.builder();
    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL
    for (int scale = 1; scale <= 4; scale++) {
      for (double d : Doubles.asList(Double.MIN_VALUE, Double.MIN_NORMAL)) {
        fractionalBuilder.add(d * scale).add(-d * scale);

    this.safeOctets = createSafeOctets(safeChars);
  }

  /**
   * Creates a boolean array with entries corresponding to the character values specified in
   * safeChars set to true. The array is as small as is required to hold the given character
   * information.
   */
  private static boolean[] createSafeOctets(String safeChars) {
    int maxChar = -1;
    char[] safeCharArray = safeChars.toCharArray();

  // Timed Get
  // There are a few design constraints to consider
  // * We want to be responsive to small timeouts, unpark() has non trivial latency overheads (I
  //   have observed 12 micros on 64-bit linux systems to wake up a parked thread). So if the
  //   timeout is small we shouldn't park(). This needs to be traded off with the cpu overhead of

    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    // ===================================================================================

                    out.print("\"><b>");
                    out.print(name);
                    out.print("</b><br><small>");
                    out.print(f.length() / 1024 + "KB <br>");
                    out.print(sdf.format(new Date(f.lastModified())));
                    out.print("</small>");
                    out.println("</a>");
                }
            }
        }