public static Element findChildElement(Element parent, String name) {
        return parent.child(name).orElse(null);
    }

    /**
     * Serializes a domtrip Document to XML string with preserved formatting.
     *
     * @param document the domtrip Document
     * @return the XML string with preserved formatting
     *
     */
    public static String toXml(Document document) {

}

type eventArgs struct {
	EventName    event.Name
	BucketName   string
	Object       ObjectInfo
	ReqParams    map[string]string
	RespElements map[string]string
	Host         string
	UserAgent    string
}

// ToEvent - converts to notification event.
func (args eventArgs) ToEvent(escape bool) event.Event {
	eventTime := UTCNow()

import okio.Buffer
import okio.BufferedSink

class FormBody internal constructor(
  encodedNames: List<String>,
  encodedValues: List<String>,
) : RequestBody() {
  private val encodedNames: List<String> = encodedNames.toImmutableList()
  private val encodedValues: List<String> = encodedValues.toImmutableList()

  /** The number of key-value pairs in this form-encoded body. */
  @get:JvmName("size")

     */
    void interpolate(
            @Nonnull Map<String, String> map,
            @Nullable UnaryOperator<String> callback,
            @Nullable BinaryOperator<String> postprocessor,
            boolean defaultsToEmpty);

    /**
     * Interpolates a single string value using the provided callback function.

        // Test that getMessage returns the same value consistently
        String message = "Consistent message";
        UnsupportedSearchException exception = new UnsupportedSearchException(message);

        String firstCall = exception.getMessage();
        String secondCall = exception.getMessage();
        String thirdCall = exception.getMessage();

        assertEquals(firstCall, secondCall);

@GwtIncompatible
public final class HostSpecifier {

  private final String canonicalForm;

  private HostSpecifier(String canonicalForm) {
    this.canonicalForm = canonicalForm;
  }

  /**
   * Returns a {@code HostSpecifier} built from the provided {@code specifier}, which is already
   * known to be valid. If the {@code specifier} might be invalid, use {@link #from(String)}
   * instead.
   *

                    public Source(@Nullable String some) {}
                    @Nullable public String nonFinalField = null;
                    public String foo(@Nullable String bar) { return "some"; }
                }
            """,
            v2 = """
                public class Source {
                    public Source(String some) {}
                    public String nonFinalField = "some";

    public static final String DEFAULT_FESS_URL = "http://localhost:8080";
    public static final String DEFAULT_SEARCH_ENGINE_URL = "http://localhost:9200";
    public static final String DEFAULT_TEST_TOKEN = "E44TjYrJQadtGBFFuECA0SBqqVtqj7lRGmhYep53ixNdvlRxnkhwqCVCpRoO";
    public static final String DEFAULT_TEST_TOKEN_ID = "testToken";
    private static final String TEST_TOKEN = "test.token";

// metadata map if metadata is nil.
func (ssec) CreateMetadata(metadata map[string]string, sealedKey SealedKey) map[string]string {
	if sealedKey.Algorithm != SealAlgorithm {
		logger.CriticalIf(context.Background(), Errorf("The seal algorithm '%s' is invalid for SSE-C", sealedKey.Algorithm))
	}

	if metadata == nil {
		metadata = make(map[string]string, 3)
	}
	metadata[MetaAlgorithm] = SealAlgorithm

			"X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id": []string{""},
			"X-Amz-Server-Side-Encryption-Context":        []string{""},
		},
		Expected: true,
	}, // 4
	{
		Header: http.Header{
			"X-Amz-Server-Side-Encryption":                []string{"AES256"},
			"X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id": []string{""},
		},
		Expected: true,
	}, // 5