if err != nil {
		return encryptedETag
	}
	return hex.EncodeToString(etagBytes)
}

// GetDecryptedRange - To decrypt the range (off, length) of the
// decrypted object stream, we need to read the range (encOff,
// encLength) of the encrypted object stream to decrypt it, and
// compute skipLen, the number of bytes to skip in the beginning of
// the encrypted range.
//
// In addition we also compute the object part number for where the

        } else if (input instanceof List) {
            values = ((List<?>) input).stream().filter(Objects::nonNull).map(Object::toString).toArray(n -> new String[n]);
        } else if (input instanceof String) {
            return input.toString();
        }
        if (values != null) {
            return stream(values).get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.joining(" ")));
        }

        private void writeObject(ObjectOutputStream stream) throws IOException {
      stream.defaultWriteObject();
      stream.writeObject(factory);
      stream.writeObject(backingMap());
    }

    @GwtIncompatible
    @J2ktIncompatible
        @SuppressWarnings("unchecked") // reading data stored by writeObject
    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {

        private void writeObject(ObjectOutputStream stream) throws IOException {
      stream.defaultWriteObject();
      stream.writeObject(factory);
      stream.writeObject(backingMap());
    }

    @GwtIncompatible
    @J2ktIncompatible
        @SuppressWarnings("unchecked") // reading data stored by writeObject
    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {

                }
                stream(accessToken.getPermissions()).of(stream -> stream.forEach(permissionSet::add));
                final String name = accessToken.getParameterName();
                stream(request.getParameterValues(name)).of(stream -> stream.filter(StringUtil::isNotBlank).forEach(permissionSet::add));
                return OptionalEntity.of(permissionSet);

                    }
                }
                stream(groups).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByGroup(s))));
                stream(roles).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByRole(s))));
                permissions = permissionSet.stream().filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]);
            }

     * @return true if the OpenSearch file exists
     */
    public boolean hasOpenSearchFile() {
        return osddFile != null;
    }

    /**
     * Returns the OSDD as a stream response.
     *
     * @return the stream response
     */
    public StreamResponse asStream() {
        if (osddFile == null) {

    sink.writeLines(ImmutableList.of("foo", "bar", "baz").stream());
    String separator = LINE_SEPARATOR.value();
    assertEquals("foo" + separator + "bar" + separator + "baz" + separator, sink.getString());
  }

  public void testWriteLines_stream_separator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz").stream(), "!");
    assertEquals("foo!bar!baz!", sink.getString());
  }

    /**
     * Reads the next ASN.1 object from a stream and casts it to the specified type
     * @param <T> the target ASN.1 primitive type
     * @param type the target class type
     * @param stream the ASN.1 input stream
     * @return next object from stream cast to type
     * @throws PACDecodingException if types are incompatible
     * @throws IOException if reading from stream fails
     */

type SpeedTestResult struct {
	Endpoint      string
	Uploads       uint64
	Downloads     uint64
	UploadTimes   madmin.TimeDurations
	DownloadTimes madmin.TimeDurations
	DownloadTTFB  madmin.TimeDurations
	Error         string
}

func newRandomReader(size int) io.Reader {
	return io.LimitReader(randreader.New(), int64(size))
}

type firstByteRecorder struct {
	t *time.Time
	r io.Reader
}