* SmbFile.resolveDfs can re-insert the dr list with
                                 * the dr that was successful so that subsequent
                                 * attempts to resolve DFS use the last successful
                                 * referral first.
                                 */
                                tmp.map = links.map;

        // Setup mock SearchLogHelper that succeeds
        SearchLogHelper mockSearchLogHelper = new SearchLogHelper() {
            @Override
            public void storeSearchLog() {
                // Successful execution - no exception thrown
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // Execute the job
        String result = aggregateLogJob.execute();

        // Test getting the generator name
        assertEquals("TestGenerator", thumbnailGenerator.getName());
    }

    public void test_generate_withValidThumbnailId() {
        // Test successful thumbnail generation
        String thumbnailId = "test-thumbnail-001";
        assertTrue(thumbnailGenerator.generate(thumbnailId, tempOutputFile));
        assertTrue(tempOutputFile.exists());
    }

import jcifs.internal.util.SMBUtil;
import jcifs.smb.NtStatus;

/**
 * SMB2 Session Setup response message. This response contains the server's authentication
 * challenge or confirms successful session establishment.
 *
 * @author mbechler
 *
 */
public class Smb2SessionSetupResponse extends ServerMessageBlock2Response {

    /**
     * Session flag indicating this is a guest session
     */

      for (Present<V> element : values) {
        result.add(element != null ? element.value : null);
      }
      return unmodifiableList(result);
    }
  }

  /** The result of a successful {@code Future}. */
  private static final class Present<V extends @Nullable Object> {
    @ParametricNullness final V value;

    Present(@ParametricNullness V value) {
      this.value = value;
    }
  }

  }

  private fun showUrl(url: String) {
    val request = Builder().url(url).build()
    client
      .newCall(request)
      .execute()
      .use { response ->
        if (!response.isSuccessful) {
          val responseHeaders = response.headers
          for (i in 0 until responseHeaders.size) {
            println(responseHeaders.name(i) + ": " + responseHeaders.value(i))
          }

    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.handshake().cipherSuite());
      System.out.println(response.body().string());
    }
  }

    Request request = new Request.Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) {
        Headers responseHeaders = response.headers();
        for (int i = 0; i < responseHeaders.size(); i++) {
          System.out.println(responseHeaders.name(i) + ": " + responseHeaders.value(i));
        }

   * completed, has already been cancelled, or could not be cancelled for some other reason. If
   * successful, and this step has not started when {@code cancel} is called, this step should never
   * run.
   *
   * <p>If successful, causes the objects captured by this step (if already started) and its input

     * This method should be overridden by subclasses to provide the actual
     * SMB reconnection implementation.
     *
     * @param info the handle information
     * @return true if reconnection was successful
     * @throws Exception if reconnection fails
     */
    protected boolean performReconnection(HandleInfo info) throws Exception {
        // This is a template method that should be implemented by the actual