input    []int
		trimLen  int
		expected []int
	}{
		{
			name:     "Trim two elements from end",
			input:    []int{1, 2, 3, 4, 5},
			trimLen:  2,
			expected: []int{1, 2, 3},
		},
		{
			name:     "Trim entire slice",
			input:    []int{1, 2, 3},
			trimLen:  3,
			expected: []int{},
		},
		{
			name:     "Trim length greater than slice length",
			input:    []int{1, 2, 3},
			trimLen:  5,

    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)

internal fun Map<String, String>.commonToHeaders(): Headers {
  // Make a defensive copy and clean it up.
  val namesAndValues = arrayOfNulls<String>(size * 2)
  var i = 0
  for ((k, v) in this) {
    val name = k.trim()
    val value = v.trim()
    headersCheckName(name)
    headersCheckValue(value, name)
    namesAndValues[i] = name
    namesAndValues[i + 1] = value
    i += 2
  }

                    "includesDependencies",
                    ""
                };

                int i = 0;
                for (String col : cols) {
                    assertEquals(expected[i++], col.trim(), "Wrong column header");
                }
            } else if (line.startsWith("|")) {
                String[] cols = line.split("\\|");

                String type = trimApt(cols[1]);

            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

            File file = new File(artifactBasedir, "artifact-1.0.jar");
            assertEquals("dummy", new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8).trim());

            artifactDeployer.deploy(file, artifact, remoteRepository(), localRepository());

            ArtifactRepository remoteRepository = remoteRepository();

		}
		for _, arg := range e.SFunc.ArgsList {
			result.combine(arg.analyze(s))
		}
		return result

	case sqlFnTrim:
		if e.Trim.TrimChars != nil {
			result.combine(e.Trim.TrimChars.analyze(s))
		}
		if e.Trim.TrimFrom != nil {
			result.combine(e.Trim.TrimFrom.analyze(s))
		}
		return result

	case sqlFnSubstring:
		errVal := fmt.Errorf("Invalid argument(s) to %s", string(funcName))

			AccessKeyID: cred.AccessKey,
		},
	}
	return eventData, nil
}

func fwdHeadersToS3(h http.Header, w http.ResponseWriter) {
	const trim = "x-amz-fwd-header-"
	for k, v := range h {
		if stringsHasPrefixFold(k, trim) {
			w.Header()[k[len(trim):]] = v
		}
	}
}

func fwdStatusToAPIError(statusCode int, resp *http.Response) *APIError {
	if statusCode < http.StatusBadRequest {
		return nil

while IFS="=" read -r key value; do
  case "${key-}" in
  distributionUrl) distributionUrl=$(trim "${value-}") ;;
  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
  esac
done <"${0%/*}/.mvn/wrapper/maven-wrapper.properties"

    new EqualsTester()
        .addEqualityGroup(trimEqualsFoo, Predicates.compose(equalsFoo, trim))
        .addEqualityGroup(equalsFoo)
        .addEqualityGroup(trim)
        .addEqualityGroup(Predicates.compose(equalsFoo, identity))
        .addEqualityGroup(Predicates.compose(equalsBar, trim))
        .testEquals();
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester