if (array[i] > max) {
        max = array[i];
      }
    }
    return max;
  }

  /**
   * Returns the value nearest to {@code value} which is within the closed range {@code [min..max]}.
   *
   * <p>If {@code value} is within the range {@code [min..max]}, {@code value} is returned
   * unchanged. If {@code value} is less than {@code min}, {@code min} is returned, and if {@code

      if (array[i] > max) {
        max = array[i];
      }
    }
    return max;
  }

  /**
   * Returns the value nearest to {@code value} which is within the closed range {@code [min..max]}.
   *
   * <p>If {@code value} is within the range {@code [min..max]}, {@code value} is returned
   * unchanged. If {@code value} is less than {@code min}, {@code min} is returned, and if {@code

     * and cleaning up quoted strings.
     *
     * @param list the list to retrieve the value from
     * @param index the index of the value to retrieve
     * @return the cleaned value at the specified index, or empty string if index is out of bounds
     */
    static String getValue(final List<String> list, final int index) {
        if (index >= list.size()) {
            return StringUtil.EMPTY;

        }

        /** The return value of the operation */
        public int retval;
        /** The handle to be closed */
        public rpc.policy_handle handle;

        /**
         * Constructs a SamrCloseHandle request.
         *
         * @param handle The policy handle to close
         */
        public SamrCloseHandle(final rpc.policy_handle handle) {
            this.handle = handle;
        }

        }

        /** The return value of the operation */
        public int retval;
        /** The handle to be closed */
        public rpc.policy_handle handle;

        /**
         * Constructs a SamrCloseHandle request.
         *
         * @param handle The policy handle to close
         */
        public SamrCloseHandle(final rpc.policy_handle handle) {
            this.handle = handle;
        }

   * @since 3.0
   */
  public static <E> ImmutableList<E> copyOf(E[] elements) {
    return (elements.length == 0)
        ? ImmutableList.<E>of()
        : ImmutableList.<E>construct(elements.clone());
  }

  /**
   * Returns an immutable list containing the given elements, sorted according to their natural
   * order. The sorting algorithm used is stable, so elements that compare as equal will stay in the

        void testWriteBytesWireFormatDoesNotModifyBuffer() {
            // Given
            byte[] dst = new byte[100];
            Arrays.fill(dst, (byte) 0xFF);
            byte[] originalDst = dst.clone();

            // When
            response.writeBytesWireFormat(dst, 0);

            // Then
            assertArrayEquals(originalDst, dst);
        }
    }

    @Nested

        response = spy(response);
        when(response.getHeaderStart()).thenReturn(0);

        // Make a copy of the buffer
        byte[] bufferCopy = buffer.clone();

        // Call readBytesWireFormat
        response.readBytesWireFormat(buffer, bufferIndex);

        // Verify buffer wasn't modified except for the decode operations

        throw new IOException("Failed to reconnect durable handle");
    }
}

@Override
public void close() throws IOException {
    try {
        // Normal close operations
        super.close();
    } finally {
        // Don't release durable handle on close if it's persistent
        if (handleManager != null && handleType != HandleType.PERSISTENT) {

				Key:       entry.Name,
				Size:      entry.Size,
				ModTime:   entry.ModTime,
				VersionID: entry.VersionID,
				Content:   gr,
				Headers:   make(http.Header),
				Close: func() {
					gr.Close()
				},
			}

			opts, _, err := batchReplicationOpts(ctx, "", gr.ObjInfo)
			if err != nil {
				batchLogIf(ctx, err)
				continue
			}