// `value` does not need to be volatile; visibility piggy-backs on volatile read of `delegate`.
    private @Nullable T value;

    NonSerializableMemoizingSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    @ParametricNullness
    public T get() {
      // Because Supplier is read-heavy, we use the "double-checked locking" pattern.
      if (delegate != null) {

    checkNotNull(reason);
    /*
     * All elements of `futures` are completed, or this future has already completed and read
     * `futures` into a local variable (in preparation for propagating cancellation to them). In
     * either case, no one needs to read `futures` for cancellation purposes later. (And
     * cancellation purposes are the main reason to access `futures`, as discussed in its docs.)
     */

  /*
   * The mainline copy of ImmutableMapValues doesn't produce this serialized form anymore, though
   * the backport does. For now, we're keeping the class declaration in *both* flavors so that both
   * flavors can read old data or data from the other flavor. However, we strongly discourage
   * relying on this, as we have made incompatible changes to serialized forms in the past and

 *
 * This class implements the TRANS_PEEK_NAMED_PIPE transaction which allows
 * reading data from a pipe without removing it, useful for checking if data
 * is available before performing a blocking read.
 */
public class TransPeekNamedPipe extends SmbComTransaction {

    private final int fid;

    /**
     * Constructs a TransPeekNamedPipe request to check the status of a named pipe.
     *

     * @return the namedPipeState
     */
    public int getNamedPipeState() {
        return this.namedPipeState;
    }

    /**
     * Gets the amount of data available to read from the pipe
     * @return the readDataAvailable
     */
    public int getReadDataAvailable() {
        return this.readDataAvailable;
    }

    /**
     * Gets the number of messages available in the pipe

        }
    }

    /**
     * Test concurrent reads from deleteUrlList while synchronized.
     * Verifies that ArrayList can be safely read when properly synchronized.
     */
    @Test
    public void test_deleteUrlList_concurrentReads() throws Exception {
        IndexUpdateCallback mockCallback = new IndexUpdateCallback() {
            @Override

    apply {
      var found = false
      for (expectedClass in allowedExceptionTypes) {
        if (expectedClass.isInstance(failure)) {
          found = true
          break
        }
      }
      assertThat(
        found,
        "Expected exception type among ${allowedExceptionTypes.contentToString()}, got $failure",
      ).isTrue()
    }

        testReadJobLog();
        testDeleteJobLog();
    }

    @Test
    void searchParametersTest() {
        testSearchByJobName();
        testPagination();
    }

    /**
     * Test: Read job logs list
     */
    private void testReadJobLogs() {
        logger.info("[BEGIN] testReadJobLogs");
        final Map<String, Object> searchBody = new HashMap<>();
        searchBody.put("size", 100);

        BaseConfiguration config = new BaseConfiguration(true);
        Smb2IoctlResponse resp = new Smb2IoctlResponse(config);

        int read = resp.decode(packet, 0);
        assertTrue(read >= packet.length, "Decoded length should cover entire packet");
        assertNotNull(resp.getErrorData(), "Error data should be decoded");
        assertEquals(3, resp.getErrorData().length);

                    .append(" - ")
                    .append(message)
                    .append('\n');
            if (sb.length() > maxDetailsLength) {
                sb.setLength(maxDetailsLength);
                break;
            }
        }

        if (totalCount > displayCount) {
            sb.append("... and ").append(totalCount - displayCount).append(" more\n");
        }

        return sb.toString();
    }