return true
		}
	}
	return false
}

// isStandardHeader returns true if header is a supported header and not a custom header
func isStandardHeader(matchHeaderKey string) bool {
	return equals(matchHeaderKey, standardHeaders...)
}

// returns whether object version is a deletemarker and if object qualifies for replication

    return refreshNanos > 0;
  }

  boolean usesAccessQueue() {
    return expiresAfterAccess() || evictsBySize();
  }

  boolean usesWriteQueue() {
    return expiresAfterWrite();
  }

  boolean recordsWrite() {
    return expiresAfterWrite() || refreshes();
  }

  boolean recordsAccess() {
    return expiresAfterAccess();
  }

  boolean recordsTime() {

     * @return the length of this file or 0 if it refers to a directory
     */

    @Override
    public int getContentLength() {
        try {
            return (int) (length() & 0xFFFFFFFFL);
        } catch (final SmbException se) {}
        return 0;
    }

    /**
     * This URLConnection method just returns the result of {@code lastModified}.
     *

				err = msgp.WrapError(err, "FilePath")
				return
			}
		case "fi":
			bts, err = z.FI.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "FI")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

				return nil
			}
		}
		configData, err := base64.StdEncoding.DecodeString(*versioning)
		if err != nil {
			return wrapSRErr(err)
		}
		_, err = globalBucketMetadataSys.Update(ctx, bucket, bucketVersioningConfig, configData)
		if err != nil {
			return wrapSRErr(err)
		}
		return nil
	}

	return nil
}

		if globalTierConfigMgr.Empty() {
			return metrics
		}

		dui, err := loadDataUsageFromBackend(ctx, objLayer)
		if err != nil {
			metricsLogIf(ctx, err)
			return metrics
		}
		// data usage has not captured any tier stats yet.
		if dui.TierStats == nil {
			return metrics
		}

		return dui.tierMetrics()
	})
	return mg
}

	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	opts, err := getOpts(ctx, r, bucket, object)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	getObjectInfo := objectAPI.GetObjectInfo

	// Check for auth type to return S3 compatible error.
	// type to return the correct error (NoSuchKey vs AccessDenied)

    assertThat(range.body.string()).isEqualTo("AA")
    assertThat(get(url).body.string()).isEqualTo("BB")
  }

  /**
   * When the server returns a full response body we will store it and return it regardless of what
   * its Last-Modified date is. This behavior was different prior to OkHttp 3.5 when we would prefer
   * the response with the later Last-Modified date.
   *

    * Security Action Required:
      * This only applies to you if you use the PodSecurityPolicy feature.  You are using that feature if `kubectl get podsecuritypolicy` returns one or more objects.  If it returns an error, you are not using it.

        return toString;
      }
    };
  }

  private static <V> AsyncCallable<V> tagged(String toString, AsyncCallable<V> callable) {
    return new AsyncCallable<V>() {
      @Override
      public ListenableFuture<V> call() throws Exception {
        return callable.call();
      }

      @Override
      public String toString() {
        return toString;
      }
    };