assertNull(echoResponse.getExpiration());
        }
    }

    @Nested
    @DisplayName("Signature Verification Tests")
    class SignatureVerificationTests {

        @Test
        @DisplayName("Should verify signature when digest is present and successful")
        void testVerifySignatureSuccess() throws Exception {
            byte[] buffer = new byte[1024];

 * versions of the {@link FluentFuture#catching(Class, com.google.common.base.Function)
 * FluentFuture.catching} family of methods. Those versions have slightly different signatures.
 */
abstract class GwtFluentFutureCatchingSpecialization<V extends @Nullable Object>
    extends AbstractFuture<V> {
  /*
   * In the GWT versions of the methods (below), every exceptionType parameter is required to be

        for (Class<?> parameterType : parameterTypes) {
            // If the argument type is primitive then we want
            // to convert our primitive type signature to the
            // corresponding Object type so introspection for
            // methods with primitive types will work correctly.
            if (parameterType.isPrimitive()) {

 * the {@link Futures#catching(ListenableFuture, Class, com.google.common.base.Function)
 * Futures.catching} family of methods. Those versions have slightly different signatures.
 */
abstract class GwtFuturesCatchingSpecialization {
  /*
   * In the GWT versions of the methods (below), every exceptionType parameter is required to be

  static double getMinValue(double[] array, int from) {
    // This is basically a copy of com.google.math.Rank#getMinValue, with a small change in the
    // method signature: we always search to the end of the array.
    int min = from;
    for (int i = from + 1; i < array.length; i++) {
      if (array[min] > array[i]) {
        min = i;
      }
    }
    return array[min];

	}

	if lc != "" {
		args["LocationConstraint"] = []string{lc}
	}

	cloneHeader := r.Header.Clone()
	if v := cloneHeader.Get("x-amz-signature-age"); v != "" {
		args["signatureAge"] = []string{v}
		cloneHeader.Del("x-amz-signature-age")
	}

	if userTags := cloneHeader.Get(xhttp.AmzObjectTagging); userTags != "" {
		tag, _ := tags.ParseObjectTags(userTags)
		if tag != nil {

 * {@code GwtIncompatible}. This is more accurate for {@link Futures#catching}, which is available
 * under GWT but with a slightly different signature.
 *
 * <p>We can't use {@code PartiallyGwtIncompatible} because then the GWT compiler wouldn't recognize
 * it as a {@code GwtIncompatible} annotation. And for {@code Futures.catching}, we need the GWT

class AddressTest extends BaseTest {

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Address mockAddress;

    @Test
    @DisplayName("Address interface should define correct method signatures")
    void testInterfaceContract() {
        // Given
        Address address = mockAddress;

        // When & Then - verify interface methods exist and can be called
        assertDoesNotThrow(() -> {

   *
   * TODO(cpovirk): Could this be simplified if we modified implementations of LegacyConverter to
   * override methods (probably called "unsafeDoForward" and "unsafeDoBackward") with the same
   * signatures as the methods below, rather than overriding the same doForward and doBackward
   * methods as implementations of normal converters do?
   *

// errMethodNotAllowed means that method is not allowed.
var errMethodNotAllowed = errors.New("Method not allowed")

// errSignatureMismatch means signature did not match.
var errSignatureMismatch = errors.New("Signature does not match")

// When upload object size is greater than 5G in a single PUT/POST operation.
var errDataTooLarge = errors.New("Object size larger than allowed limit")