func TestRecordAuthorizationConfigAutomaticReloadFailure(t *testing.T) {
	expectedValue := `
	# HELP apiserver_authorization_config_controller_automatic_reloads_total [ALPHA] Total number of automatic reloads of authorization configuration split by status and apiserver identity.
    # TYPE apiserver_authorization_config_controller_automatic_reloads_total counter

            Collections.addAll(emptyLockIds, lockIds);
        }
    }

    private Path getUniqueLockfilePath() {
        return lockFile.get().getAsFile().toPath();
    }

    private void parseLine(String line, Map<String, List<String>> result) {
        String[] split = line.split("=");
        if (split.length != 2) {

}}
{{- end }}

{{/* SD has metrics and logging split. Default metrics are enabled if SD is enabled */}}
{{ define "default-sd-metrics" }}
{{- and
  (not .Values.meshConfig.defaultProviders)
  .Values.telemetry.enabled .Values.telemetry.v2.enabled .Values.telemetry.v2.stackdriver.enabled
}}
{{- end }}

{{/* SD has metrics and logging split. */}}
{{ define "default-sd-logs" }}
{{- and

}}
{{- end }}

{{/* SD has metrics and logging split. Default metrics are enabled if SD is enabled */}}
{{ define "default-sd-metrics" }}
{{- and
  (not .Values.meshConfig.defaultProviders)
  .Values.telemetry.enabled .Values.telemetry.v2.enabled .Values.telemetry.v2.stackdriver.enabled
}}
{{- end }}

{{/* SD has metrics and logging split. */}}
{{ define "default-sd-logs" }}
{{- and

internal
fun javaFunctionOf(functionSignature: String): JavaFunction<String> =
    JavaFunction(
        typeName = functionSignature.split('(')[0].dropLastWhile { it != '.' }.dropLast(1),
        name = functionSignature.split('(')[0].takeLastWhile { it != '.' },
        parameterTypes = functionSignature.split('(')[1].dropLast(1).split(",").map { it.trim() }.let { paramStrings ->
            paramStrings.mapIndexed { idx: Int, paramString: String ->

import static ${basePackagePrefix.raw}utilities.StringUtils.split;
import static ${basePackagePrefix.raw}app.MessageUtils.getMessage;

import org.apache.commons.text.WordUtils;

public class App {
    public static void main(String[] args) {
        LinkedList tokens;
        tokens = split(getMessage());
        String result = join(tokens);
        System.out.println(WordUtils.capitalize(result));

import static ${basePackagePrefix.raw}utilities.StringUtils.join
import static ${basePackagePrefix.raw}utilities.StringUtils.split
import static ${basePackagePrefix.raw}app.MessageUtils.getMessage

import org.apache.commons.text.WordUtils

class App {
    static void main(String[] args) {
        LinkedList tokens
        tokens = split(getMessage())
        String result = join(tokens)
        println(WordUtils.capitalize(result))
    }

        String mi = expectString(alias, librariesTable, "module");
        if (mi != null) {
            List<String> split = SPLITTER.splitToList(mi);
            if (split.size() == 2) {
                group = notEmpty(split.get(0), "group", alias);
                name = notEmpty(split.get(1), "name", alias);
            } else {
                throw throwVersionCatalogProblemException(builder ->

	HasLoopBackIP bool
}

func split(s string) []string {
	return config.Split(s)
}

func (cfg *IptablesConfigurator) separateV4V6(cidrList string) (NetworkRange, NetworkRange, error) {
	if cidrList == "*" {
		return NetworkRange{IsWildcard: true}, NetworkRange{IsWildcard: true}, nil
	}
	ipv6Ranges := NetworkRange{}
	ipv4Ranges := NetworkRange{}
	for _, ipRange := range split(cidrList) {

        fun String.runIfNotEmpty(action: String.() -> String): String =
            if (this.isEmpty()) this else action()

        return pathWithWildcards.split("**").joinToString(separator = ".*", prefix = "^", postfix = "$") { outerPart ->
            outerPart.runIfNotEmpty {
                split("*").joinToString("[^/]*") { innerPart ->
                    innerPart.runIfNotEmpty(Regex::escape)
                }
            }
        }
    }