* MoreExecutors#newDirectExecutorService} and subject to the same constraints.
   *
   * <p>Although all tasks are immediately executed in the thread that submitted the task, this
   * {@code ExecutorService} imposes a small locking overhead on each task submission in order to
   * implement shutdown and termination behavior.
   *
   * <p>Because of the nature of single-thread execution, the methods {@code scheduleAtFixedRate}

  // 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

                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).

    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verify the CRUD mode.
     * @param crudMode The CRUD mode.
     * @param expectedMode The expected mode.

            return entity;
        });
    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verify that the CRUD mode matches the expected mode.
     *
     * @param crudMode the actual CRUD mode

    class EdgeCasesTests {

        @Test
        @DisplayName("Should handle malformed buffer gracefully")
        void testReadDataWireFormatMalformedBuffer() {
            byte[] buffer = new byte[3]; // Too small for valid DFS referral

            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                response.readDataWireFormat(buffer, 0, buffer.length);
            });
        }

        @Test

 * encode/decode operation.
 */
public class DcerpcMessageTest {

    /**
     * A trivial concrete subclass used for testing. It simply writes a
     * single small value in {@code encode_in} and reads it in
     * {@code decode_out}.
     */
    private static class TestMessage extends DcerpcMessage {
        int decodedValue = 0;

        TestMessage() {

    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();