set("b", "bb", "bbb")

    // Cause the cache trim job to fail.
    filesystem.setFaultyDelete(cacheDir / "a.0", true)
    taskFaker.runNextTask()

    // An edit should now add a job to clean up if the most recent trim failed.
    assertThat(cache.edit("b")).isNull()
    taskFaker.runNextTask()

    // Confirm a successful cache trim now allows edits.
    filesystem.setFaultyDelete(cacheDir / "a.0", false)

            boolean inlineContent = trimmedContent.find { it instanceof Text && it.textContent.trim() }

            if (prettyPrint && !inlineContent) {
                trimmedContent = element.childNodes.inject([]) { list, child ->
                    if (!(child instanceof Text) || child.textContent.trim().length() != 0) {
                        list << child
                    }
                    return list

                    form.virtualHosts = stream(entity.getVirtualHosts())
                            .get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.joining("\n")));
                    form.name = null;
                });
                form.crudMode = CrudMode.CREATE;
            });
        }).renderWith(data -> {

                    form.virtualHosts = stream(entity.getVirtualHosts())
                            .get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.joining("\n")));
                    form.name = null;
                });
                form.crudMode = CrudMode.CREATE;
            });
        });
    }

    @Execute

    val out = ByteArrayOutputStream()
    exec {
        isIgnoreExitValue = ignoreExitValue
        commandLine(*args)
        standardOutput = out
        this.workingDir = workingDir
    }
    return out.toString().trim()
}


fun ExecOperations.execAndGetStdoutIgnoringError(vararg args: String) = execAndGetStdout(File("."), true, *args)

                        if (contentMetaBuf.length() > 0) {
                            contentMetaBuf.append(' ');
                        }
                        contentMetaBuf.append(joinedValue.trim());
                    }
                }

                final Tuple3<String, String, String> mapping = fessConfig.getCrawlerMetadataNameMapping(key);
                if (mapping != null) {

                        updater.write("# " + line);
                    }
                    continue;
                }

                final String input = m.group(1).trim();
                final String output = m.group(2).trim();

                if (input == null || output == null) {
                    logger.warn("Failed to parse {} to {}", line, path);
                    if (updater != null) {

                String line;
                StringBuilder contentBuilder = new StringBuilder();
                while ((line = reader.readLine()) != null) {
                    if (!line.trim().startsWith("#")) {
                        existingClasses.add(line.trim());
                    }
                    contentBuilder.append(line).append("\n");
                }
                existingContent = contentBuilder.toString();
            }

    @Internal
    protected
    fun getContributorsInReleaseNotes(): Set<GitHubUser> {
        val (_, contributorLines, _) = parseReleaseNotes()
        return contributorLines
            .map { it.trim() }
            .filter { it.isNotEmpty() }
            .onEach { check(contributorLineRegex.containsMatchIn(it)) { "Invalid contributor line: $it" } }

	From     *PrimaryTerm `parser:" \"FROM\" @@ \")\" "`
}

// TrimFunc represents TRIM sql function
type TrimFunc struct {
	TrimWhere *string      `parser:" \"TRIM\" \"(\" ( @( \"LEADING\" | \"TRAILING\" | \"BOTH\" ) "`
	TrimChars *PrimaryTerm `parser:"             @@?  "`
	TrimFrom  *PrimaryTerm `parser:"             \"FROM\" )? @@ \")\" "`
}