# Install the certs.
COPY certs/                           /var/lib/istio/
COPY certs/default/                   /var/run/secrets/istio/

# Install the sidecar components
COPY istio-sidecar.rpm  /tmp/istio-sidecar.rpm
RUN rpm -vi /tmp/istio-sidecar.rpm && rm /tmp/istio-sidecar.rpm

# Sudoers used to allow tcpdump and other debug utilities.
COPY sudoers /etc/sudoers

# Install the Echo application

    TreeMultimap<String, Integer> copy = TreeMultimap.create(tree);
    assertEquals(tree, copy);
    assertThat(copy.keySet()).containsExactly("google", "tree").inOrder();
    assertThat(copy.get("google")).containsExactly(2, 6).inOrder();
    assertEquals(Ordering.natural(), copy.keyComparator());
    assertEquals(Ordering.natural(), copy.valueComparator());
    assertEquals(Ordering.natural(), copy.get("google").comparator());
  }

import org.gradle.api.Action;

/**
 * Specifies sources for a file copy.
 */
public interface CopySourceSpec {
    /**
     * Specifies source files or directories for a copy. The given paths are evaluated as per {@link
     * org.gradle.api.Project#files(Object...)}.
     *
     * @param sourcePaths Paths to source files for the copy
     */
    CopySourceSpec from(Object... sourcePaths);

    /**

class DefaultLockOptionsTest extends Specification {
    def "can make copy of options"() {
        def builder = DefaultLockOptions.mode(Exclusive).useCrossVersionImplementation()

        when:
        def copy = builder.copyWithMode(Shared)

        then:
        !copy.is(builder)
        copy.mode == Shared
        copy.useCrossVersionImplementation
    }

        file("in-dir").createDir()
        def inFile = file("in.txt").createFile()
        def copy = file("other")

        given:
        run("work")
        run("work")
        result.assertTasksSkipped(":work")

        when:
        inFile.copyTo(copy)
        inFile.delete()
        inFile.createLink(copy)
        run("work")

        /*

	shouldPanic("cap out of range", func() { x := make(T, 0, uint(n)); copy(x, c) })
	shouldPanic("len out of range", func() { x := make(T, int64(n)); copy(x, c) })
	shouldPanic("cap out of range", func() { x := make(T, 0, int64(n)); copy(x, c) })
	shouldPanic("len out of range", func() { x := make(T, uint64(n)); copy(x, c) })
	shouldPanic("cap out of range", func() { x := make(T, 0, uint64(n)); copy(x, c) })
}

func testMakeCopyBytes(n uint64) {

# prepare a distroless source context to copy files from
FROM cgr.dev/chainguard/static@sha256:873e9709e2a83acc995ff24e71c100480f9c0368e0d86eaee9c3c7cb8fb5f0e0 as distroless_source

# prepare a base dev to modify file contents
FROM ubuntu:noble as ubuntu_source

# Modify contents of container
COPY --from=distroless_source /etc/ /home/etc
COPY --from=distroless_source /home/nonroot /home/nonroot
RUN echo istio-proxy:x:1337: >> /home/etc/group

        if (getIncludeSpecs() != null) {
            copy.setIncludeSpecs(Sets.newHashSet(getIncludeSpecs()));
        }
        if (getExcludeSpecs() != null) {
            copy.setExcludeSpecs(Sets.newHashSet(getExcludeSpecs()));
        }
        if (getRequiredAttributes() != null) {
            copy.setRequiredAttributes(Maps.newHashMap(getRequiredAttributes()));
        }
        return copy;
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "changing child specs of the copy task while executing is disallowed"() {
        given:
        file("some-dir/input.txt") << "Data"
        buildScript """
            task copy(type: Copy) {
                outputs.cacheIf { true }
                from ("some-dir")
                into ("build/output")

	if endPos > len(dd.hist) {
		endPos = len(dd.hist)
	}

	// Copy non-overlapping section after destination position.
	//
	// This section is non-overlapping in that the copy length for this section
	// is always less than or equal to the backwards distance. This can occur
	// if a distance refers to data that wraps-around in the buffer.
	// Thus, a backwards copy is performed here; that is, the exact bytes in