} catch (final ConnectException | NoRouteToHostException nr) {
            // Try an alternate port if there was an issue communicating to the server
            // Only set the alternate port to the port property if it was successful
            final int altPort = port == 0 || port == DEFAULT_PORT ? 139 : DEFAULT_PORT;
            negotiate(altPort, resp);
            port = altPort;
        }

        if (resp.dialectIndex > 10) {

  /**
   * Adds a single occurrence of the specified element to this multiset.
   *
   * <p>This method refines {@link Collection#add}, which only <i>ensures</i> the presence of the
   * element, to further specify that a successful call must always increment the count of the
   * element, and the overall size of the collection, by one.
   *
   * <p>To both add the element and obtain the previous count of that element, use {@link

 * previous callable has returned -- and, if the previous callable was an {@link AsyncCallable}, not
 * until the {@code Future} it returned is {@linkplain Future#isDone done} (successful, failed, or
 * cancelled).
 *
 * <p>This class serializes execution of <i>submitted</i> tasks but not any <i>listeners</i> of
 * those tasks.
 *

  fun response() {
    val response: Response = Response.Builder().build()
    val request: Request = response.request
    val protocol: Protocol = response.protocol
    val code: Int = response.code
    val successful: Boolean = response.isSuccessful
    val message: String = response.message
    val handshake: Handshake? = response.handshake
    val headersForName: List<String> = response.headers("")

			t.Fatalf("Put Object %s:  Error uploading object: <ERROR> %v", name, err)
		}
	}

	// The following block will create a bucket policy with delete object to 'public/*'. This is
	// to test a mixed response of a successful & failure while deleting objects in a single request

			[]CompletePart{
				{ETag: fmt.Sprintf("\"\"\"\"\"%s\"\"\"", validPartMD5), PartNumber: 5},
			},
		},
		// inputParts - 4.
		// Used to verify that the other remaining parts are deleted after
		// a successful call to CompleteMultipartUpload.
		{
			[]CompletePart{
				{ETag: validPartMD5, PartNumber: 6},
			},
		},
	}
	s3MD5 := getCompleteMultipartMD5(inputParts[3].parts)

              lock.unlock();
            }
          });
    }

    @Override
    protected final void doStop() {
      // Both requireNonNull calls are safe because doStop can run only after a successful doStart.
      requireNonNull(runningTask);
      requireNonNull(executorService);
      runningTask.cancel(false);
      executorService.execute(
          () -> {
            try {

  /**
   * Adds a single occurrence of the specified element to this multiset.
   *
   * <p>This method refines {@link Collection#add}, which only <i>ensures</i> the presence of the
   * element, to further specify that a successful call must always increment the count of the
   * element, and the overall size of the collection, by one.
   *
   * <p>To both add the element and obtain the previous count of that element, use {@link

				return errInvalidStorageClass
			}
		}
	}
	return nil
}

// enqueueTransitionImmediate enqueues obj for transition if eligible.
// This is to be called after a successful upload of an object (version).
func enqueueTransitionImmediate(obj ObjectInfo, src lcEventSrc) {
	if lc, err := globalLifecycleSys.Get(obj.Bucket); err == nil {
		switch event := lc.Eval(obj.ToLifecycleOpts()); event.Action {

   * conversion is done lazily.
   *
   * <p>The returned iterable's iterator supports {@code remove()} if the input iterator does. After
   * a successful {@code remove()} call, {@code fromIterable} no longer contains the corresponding
   * element.
   */
  /*
   * Just as Converter could implement `Function<@Nullable A, @Nullable B>` instead of `Function<A,